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.

Le principe est assez simple finalement, quand on envoie un message à la machine, et transmet sa réponse qui contient ce qu’on lui a demandé. Une chaîne standard de modbus contient diverses infos, la trame « question » a généralement une longueur fixe, alors que la réponse dépend de la question.

Question : {adresse machine} {fonction lecture/ecriture} {adresse départ lecture} {nombre de registre} {CRC}

L’adresse machine, c’est son identifiant dans le cas où il y a plusieurs appareils ModBus sur le même réseau, la fonction permet de lire ou d’écrire des registres. L’adresse départ est la case par laquelle on commence et on prend autant de case que demandé après. Le CRC est particulier, c’est une valeur calculer en fonction des valeurs précités pour confirmer à la machine qu’on envoie des données viables.

Dans beaucoup de cas, le CRC est calculé par un logiciel en dur, donc pas besoin de la calculer.

Voici un exemple de trame : 01 04 00 00 00 14 F0 H5

Là je lis sur la machine « 01 », avec la fonction « 04 », 20 cases (le « 00 14 » est en hexadécimal) à partir de 00. « F0 H5 » correspond au CRC.

La principale difficulté est de comprendre le codage de la trame à envoyer et de savoir comment recevoir les données. Vous avez sans doute remarquer que certaines valeurs sont codées sur 2 bits « 00 00 » et « 00 14 », alors que la fonction et l’esclave sont codés sur 1 bit.

Mais je ne vais pas faire durer le suspens plus longtemps, voici le code de réception des données.

Private Sub SerialPort1_DataReceived(ByVal sender As Object, ByVal e As System.IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived
 Dim ByteArr(SerialPort1.ReadBufferSize) As Byte
 Dim NbBytesRecu As Integer
 Dim i As Integer
 Dim BytesEnString As String = ""

'Tempo pour laisser le temps à la trame d'arriver
 Threading.Thread.Sleep(200)

'Nombre de bytes reçus
 NbBytesRecu = SerialPort1.Read(ByteArr, 0, SerialPort1.ReadBufferSize)

'Chainage des bytes reçus
 For i = 0 To NbBytesRecu - 1
 BytesEnString = BytesEnString & ByteArr(i) & "/"
 Next

'A ce niveau la chaine BytesEnString contient toutes les valeurs retour de trame séparées d'un "/"

End Sub

C’est un système événement qui se déclenche automatiquement à chaque arrivé d’information. J’ai épuré la véritable fonction que j’utilise car elle contient des données sensibles, mais également un système d’espion et un système de cycle.

Le cycle me permet en cas de case « cycle » coché, de renvoyer une trame quand le traitement de la trame reçue est terminé. Du coup a chaque fois que j’ai fini de traiter la réponse, je repose la question pour revérifier les données.

L’espion quant à lui me permet juste d’afficher dans une fenêtre les trames que je reçois pour les décoder manuellement au besoin.

La trame de retour se compose ainsi :

Réponse : {adresse machine} {fonction lecture/ecriture} {nombre de registre} {registre 0} {registre 1} … {registre X} {CRC}

Si j’ai demandé trois registres dans ma question à la machine 1, le retour sera : 01 04 03 00 45 06 F4 00 0A CRC

Le CRC renvoyé sera différent que celui que vous avez transmis puisqu’il est recalculé à chaque question et à chaque réponse. Les trois registres demandés, à partir de l’adresse X sont donc « 00 45 », « 06 F4 » et « 00 0A ». A vous de retravailler les valeurs pour obtenir des données concrètes.

Dans le prochain chapitre, je vous donnerais quelques fonctions et astuce pour traiter vos données.

Cet article Recevoir une trame en ModBus est apparu en premier sur Garikover.com.

Il vous faudra un bouton (btnSend) pour envoyer la trame.

    Private Sub btnSend_Click_1(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSend.Click
        Dim ByteArr As Byte()

        ByteArr = New Byte() {Convert.ToByte(NumEsclave), _ 'numéro de l'esclave
Convert.ToByte(FonctionModbus), _ 'fonction de lecture modbus
0, Convert.ToByte(0), _ 'Adresse de démarreg
0, Convert.ToByte(20), _ 'nombre de mots a partir de l'adresse
Convert.ToByte(&HF0), Convert.ToByte(&H5)} 'CRC
        SerialPort1.Write(ByteArr, 0, ByteArr.Length)
        Threading.Thread.Sleep(200)
    End Sub

Le CRC se calcule, mais pour commencer, je conseille de créer une trame en dur avec des valeurs prédéfinies.

N’hésitez pas a poser des questions, ou à demander des détails. Dans le prochain exemple, on verra la réception des données.

Cet article Envoyer une trame en ModBus est apparu en premier sur Garikover.com.

Ce premier code concerne le chargement de la Form1. Il vous faudra trois Combobox (cmbPort, cmbParity et cmbBaud), un bouton de connection (btnConnect) et un bouton de deconnection (btnDisconnect).

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        btnConnect.Enabled = True
        btnDisconnect.Enabled = False
        btnSend.Enabled = False

        Dim myPort As Array = IO.Ports.SerialPort.GetPortNames() 'Récupère tous les ports COM disponibles

        'Inclusion des Baud standard
        cmbBaud.Items.Add(9600)
        cmbBaud.Items.Add(19200)
        cmbBaud.Items.Add(38400)
        cmbBaud.Items.Add(57600)
        cmbBaud.Items.Add(115200

        'Inclusion des parités standard
        cmbParity.Items.Add("Even")
        cmbParity.Items.Add("Odd")
        cmbParity.Items.Add("None")

End Sub

Private Sub btnConnect_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnConnect.Click

        'Sécurité si le port est déjà ouvert
        If SerialPort1.IsOpen = True Then
            MsgBox("Port " & SerialPort1.PortName & " déjà ouvert. Communication en court.", vbCritical)
            Exit Sub
        End If

        SerialPort1.PortName = cmbPort.Text
        SerialPort1.BaudRate = cmbBaud.Text 

        'Selection de parité
        If cmbParity.Text = "Even" Then
            SerialPort1.Parity = IO.Ports.Parity.Even
        ElseIf cmbParity.Text = "Odd" Then
            SerialPort1.Parity = IO.Ports.Parity.Odd
        ElseIf cmbParity.Text = "None" Then
            SerialPort1.Parity = IO.Ports.Parity.None
        Else
            MsgBox("Parité non définie.")
            Exit Sub
        End If

        SerialPort1.StopBits = IO.Ports.StopBits.One
        SerialPort1.DataBits = 8

        Try
            SerialPort1.Open()
        Catch ex As Exception
            MsgBox("Vérifiez les paramètres de connection ou qu'un autre logiciel ne soit pas déjà en communication avec l'appareil")
            Exit Sub
        End Try

        If SerialPort1.IsOpen = True Then
            btnConnect.Enabled = False
            btnDisconnect.Enabled = True
            btnSend.Enabled = True
        Else
            MsgBox("Le Port " & SerialPort1.PortName & " n'a pas pu être ouvert. Vérifiez les paramètres de connection.", vbCritical)
        End If
    End Sub

Dans une autre partie, je publierai un code pour envoyer une trame Modbus RS232 à un automate.

Cet article Ouvrir un port série en VB est apparu en premier sur Garikover.com.