En premier lieu et c’est sans doute l’étape la plus importante dont on ne peut pas se passer, il faut ouvrir le port série qui permettra la communication. Pour le moment je ne passe que par un port COM, je travaille sur une mise à joueur pour passer en ethernet.

1. Ouvrir un port série en VB

Ensuite, maintenant que le port est ouvert… et avec les bons paramètres, on peut envoyer une trame de lecture pour recevoir une réponse.

2. Envoyer une trame en ModBus

Pour cette étape, on peut utiliser les constructeurs de trame pour ressortir ce qu’on veut envoyer, le tout combiné avec les fonctions CRC indispensable si vous utilisez les constructeurs.

2.1. Constructeurs de trame ModBus

2.2. Le CRC16 en ModBus

Maintenant qu’on sait se connecter et envoyer des infos, il faut pouvoir les recevoir.

3. Recevoir une trame en ModBus

Arrivé à ce point là, le plus dur est fait, déjà on peut savoir si on communique ou non avec l’appareil et si les trames reçues sont correctes. L’étape suivante consiste à décoder la trame en fonction de l’envoie et d’établir une correspondance entre les données reçues et celles demandées. Pour cela on va utiliser une fonction de décodage.

4. Décodage de trame ModBus reçue

A partir de là vous êtes tout seul et votre principale problématique sera de trouver une solution pour stocker les correspondances en fonction des machines. Personnellement, j’ai opté pour un stockage en base de données, ce qui a le gros avantage de n’avoir qu’à mettre la base à jour pour rajouter des infos. Le soucis c’est que ça demande pas mal de code pour intégrer la base de données, donc si on n’a qu’une ou deux machines à gérer ce n’est pas spécialement conseillé, l’utilisation d’un tableau serait plus adapté.

Au besoin je posterais une solution simple.

Cet article Résumé ModBus RTU en VB est apparu en premier sur Garikover.com.

    Public Function ReadDecoder(ByVal ligne As String)
        'Passage de la trame en Array
        Dim MyBytes As Array = Split(ligne, "/")
        Dim i, partie1, partie2 As Integer
        Dim grille As ListView
        Dim ReponseValeur As String
        Dim MyValue As Array

        'Remplissage table
        Dim _AliasDBData As New GTCDataSet.AliasDBDataTable
        Dim _AliasDBAdapter As New GTCDataSetTableAdapters.AliasDBTableAdapter
        _AliasDBAdapter.Fill(_AliasDBData)

        If MyBytes(1) = "" Then 'Erreur de retour Trame
            Return 0
        Else 'Pas d'erreur
            For i = 4 To UBound(MyBytes) - 1
                If i / 2 = Int(i / 2) Then 'nombre pair

                    partie1 = MyBytes(i - 1)
                    partie2 = MyBytes(i)

                End If
            Next i
        End If
        Return 0
    End Function

La trame ModBus de retour est composé de plusieurs données :

{num esclave} {fonction} {nbr de valeurs} {valeur 1, partie 1} {valeur 1, partie 2}…{CRC1}{CRC2}

Pour avoir valeur 1 en entier, il faut combiner les deux parties en hexadécimale, puis reconvertir en décimal. C’est pour cette raison qu’on récupère les nombres paires et que pour chaque « i » pair, on récupère deux valeurs.

La traitement des données est à votre charge. Mais par exemple, quand vous demandez en trame X mots à partir de l’adresse Y, vous savez que pour i = 4, adresse = Y.

Si vous avez besoin d’infos supplémentaires, n’hésitez pas à demander.

Cet article Décodage de trame ModBus reçue est apparu en premier sur Garikover.com.

On commence avec les trames de lecture :

    Function ConstructTrameLecture(ByVal func As Integer, ByVal startaddress As Integer, ByVal nbregisters As Integer) As Byte()
        Dim ByteArr As Byte()
        Dim s1, s2 As String
        Dim ss1, ss2, sa1, sa2 As Integer

        'Decoupage adresse
        s1 = Microsoft.VisualBasic.Right(Hex(startaddress), 2)
        s2 = Replace(Hex(startaddress), s1, "")
        If s2 = "" Then
            sa2 = 0
        Else
            sa2 = "&h" & s2
        End If
        sa1 = "&h" & s1

        'Decoupage nombre registres
        s1 = Microsoft.VisualBasic.Right(Hex(nbregisters), 2)
        s2 = Replace(Hex(nbregisters), s1, "")
        If s2 = "" Then
            ss2 = 0
        Else
            ss2 = "&h" & s2
        End If
        ss1 = "&h" & s1

        'Construction
        ByteArr = New Byte() {Convert.ToByte(Val(Form1.SlaveId.Value)), Convert.ToByte(func), Convert.ToByte(sa2), Convert.ToByte(sa1), Convert.ToByte(ss2), Convert.ToByte(ss1)}
        ByteArr = AddCRC16(ByteArr)

        Return ByteArr
    End Function

Pour cette fonction, vous l’aurez remarqué, on a besoin de 3 paramètres :

1. La fonction « func » qui peut prendre comme valeur 3 ou 4 (ou autre mais plus rare)
2. L’adresse de départ « startaddress » qui indique par quel registre on commence (fonction de la machine)
3. Le nombre de registres « nbregisters » (c’est explicite)

La fonction AddCRC16 est aussi nécessaire pour le fonctionnement du constructeur, ainsi que de la Form1 qui contient le numéro d’esclave de la machine.

Le constructeur suivant est plus simple d’utilisation :

    Function ConstructTrameEcriture(ByVal address As Integer, ByVal valeur As Integer) As Byte()
        Dim ByteArr As Byte()
        Dim s1, s2 As String
        Dim ss1, ss2, sa1, sa2 As Integer

        'Decoupage de Value
        s1 = Microsoft.VisualBasic.Right(Hex(valeur), 2)
        s2 = Replace(Hex(valeur), s1, "")
        If s2 = "" Then
            ss2 = 0
        Else
            ss2 = "&h" & s2
        End If
        ss1 = "&h" & s1

        'Decoupage adresse
        s1 = Microsoft.VisualBasic.Right(Hex(address), 2)
        s2 = Replace(Hex(address), s1, "")
        If s2 = "" Then
            sa2 = 0
        Else
            sa2 = "&h" & s2
        End If
        sa1 = "&h" & s1

        'Construction
        ByteArr = New Byte() {Convert.ToByte(Form1.SlaveId.Value), Convert.ToByte(16), Convert.ToByte(sa2), Convert.ToByte(sa1), 0, Convert.ToByte(1), Convert.ToByte(2), Convert.ToByte(ss2), Convert.ToByte(ss1)}
        ByteArr = AddCRC16(ByteArr)

        Return ByteArr
    End Function

Les deux paramètres sont très simples :

1. « address » indique le registre à modifier
2. « valeur » la valeur à appliquer à ce registre

Les pré-requis sont les mêmes que pour l’autre constructeurs.

C’est tout pour aujourd’hui, dans le prochain épisode, vous verrez…. d’autres choses, mais je ne sais pas encore quoi.

Cet article Constructeurs de trame ModBus est apparu en premier sur Garikover.com.

Le plus souvent, on utilise un CRC16, c’est le système le plus courant, l’autre étant le 32 bits (CRC32).

Le calcul du CRC fait appel à des notions de programmation logique avec des OR, XOR, AND et XAND… autant dire que si on ne connait pas c’est le bordel, et même moi qui connait le principe je n’arrive pas à le traduire en code. Ci dessous vous trouverez deux fonctions, CRC16 et AddCRC16 :

• CRC16 : renvoie un tableau contenant le bit de poids fort et le bit de poids faible en fonction d’une trame sans CRC en Byte().
• AddCRC16 : corrige la trame envoyé sans CRC en Byte() en rajoutant le CRC à la fin.

Quand on souhaite envoyer une trame, on a souvent besoin d’ajouter le CRC après calcul quand le trame est variable, d’où la modification de la fonction CRC16 (qui n’est pas de moi) en AddCRC16 (que j’ai adapté) qui permet de restituer une trame exploitable immédiatement.

Function CRC16(ByVal data() As Byte) As Array
        Dim CRC16Lo As Byte, CRC16Hi As Byte 'CRC register
        Dim CL As Byte, CH As Byte 'Polynomial codes & HA001
        Dim SaveHi As Byte, SaveLo As Byte
        Dim i As Integer
        Dim Flag As Integer
        Dim ReturnData(2) As Byte

        CRC16Lo = &HFF
        CRC16Hi = &HFF
        CL = &H1
        CH = &HA0

        For i = 0 To UBound(data)
            CRC16Lo = CRC16Lo Xor data(i) 'for each data and CRC register XOR

            For Flag = 0 To 7
                SaveHi = CRC16Hi
                SaveLo = CRC16Lo
                CRC16Hi = CRC16Hi  2 'peak shift to the right one
                CRC16Lo = CRC16Lo  2 'shift to the right a low

                If ((SaveHi And &H1) = &H1) Then 'If the high byte last one for a
                    CRC16Lo = CRC16Lo Or &H80 'then the low byte shifted to the right after the meeting in front of a
                End If 'Otherwise, auto-fill 0

                If ((SaveLo And &H1) = &H1) Then 'If the LSB is 1, then XOR with the polynomial codes
                    CRC16Hi = CRC16Hi Xor CH
                    CRC16Lo = CRC16Lo Xor CL
                End If
            Next Flag
        Next i

        ReturnData(0) = CRC16Hi 'CRC high
        ReturnData(1) = CRC16Lo 'CRC low
        Return ReturnData
    End Function

Fonction suivante…

Function AddCRC16(ByVal data() As Byte) As Byte()
        Dim CRC16Lo As Byte, CRC16Hi As Byte 'CRC register
        Dim CL As Byte, CH As Byte 'Polynomial codes & HA001
        Dim SaveHi As Byte, SaveLo As Byte
        Dim i As Integer
        Dim Flag As Integer
        'Dim ReturnData(2) As Byte

        CRC16Lo = &HFF
        CRC16Hi = &HFF
        CL = &H1
        CH = &HA0

        For i = 0 To UBound(data)
            CRC16Lo = CRC16Lo Xor data(i) 'for each data and CRC register XOR

            For Flag = 0 To 7
                SaveHi = CRC16Hi
                SaveLo = CRC16Lo
                CRC16Hi = CRC16Hi  2 'peak shift to the right one
                CRC16Lo = CRC16Lo  2 'shift to the right a low

                If ((SaveHi And &H1) = &H1) Then 'If the high byte last one for a
                    CRC16Lo = CRC16Lo Or &H80 'then the low byte shifted to the right after the meeting in front of a
                End If 'Otherwise, auto-fill 0

                If ((SaveLo And &H1) = &H1) Then 'If the LSB is 1, then XOR with the polynomial codes
                    CRC16Hi = CRC16Hi Xor CH
                    CRC16Lo = CRC16Lo Xor CL
                End If
            Next Flag
        Next i

        'Agrandissement du data pour mettre 2 paramètres supplémentaires
        ReDim Preserve data(UBound(data) + 2)

        'Stock le CRC
        data(UBound(data) - 1) = Convert.ToByte(CRC16Lo)
        data(UBound(data)) = Convert.ToByte(CRC16Hi)

        Return data
    End Function

Bien sur il faut quand même créer la trame pour lui ajouter le CRC. Dans le prochain chapitre, je donnerais deux fonctions pour créer des trames de lecture et d’écriture qui font justement appellent à la fonction AddCRC16.

Cet article Le CRC16 en ModBus est apparu en premier sur Garikover.com.