Class Imbriquées

Pour commencer, on va reprendre l’exemple de notre classe société. J’enlève volontairement le contenu de New() car il ne sera pas nécessaire d’y revenir et je considère que vous savez initialiser une class.

Public Class Societe
    'Déclaration des variables
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Adresse As String = ""
    Public CP As String = ""
    Public Ville As String = ""

    Sub New(ByVal id_societe As String)
        'Initialisation de la class
    End Sub

End Class

On admettra qu’au delà de la fiche d’identité d’une société qui peut être intéressante, il nous faut également une classe Interlocuteur qui pourra contenir les informations de la personne concerné. Pour commencer une rajoute une class, rien de particulier là dedans.

Public Class Societe
    'Déclaration des variables
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Adresse As String = ""
    Public CP As String = ""
    Public Ville As String = ""

    Sub New(ByVal id_societe As Integer)
        'Initialisation de la class
    End Sub

End Class

Public Class Interlocuteur
    'Déclaration des variables
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Prenom As String = ""
    Public Telephone As String = ""

    Sub New(ByVal id_interlocuteur As integer)
        'Initialisation de la class
    End Sub

End Class

Alors comment faire pour compléter la class Interlocuteur quand on appelle la class Société et les relier ? On va partir du principe qu’on veut avoir les données du directeur pour chaque instance de Société qu’on créé, et que dans la base de données des Sociétés il existe un champs id_directeur qui contient le numéro de l’interlocuteur.

Public Class Societe
    'Déclaration des variables
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Adresse As String = ""
    Public CP As String = ""
    Public Ville As String = ""
    Public Directeur As Interlocteur

    Sub New(ByVal id_societe As Integer)
        'Initialisation de la class
        Directeur = New Interlocuteur(id_directeur)
    End Sub

End Class

Public Class Interlocuteur
    'Déclaration des variables
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Prenom As String = ""
    Public Telephone As String = ""

    Sub New(ByVal id_interlocuteur As integer)
        'Initialisation de la class
    End Sub

End Class

Donc on a déclaré la class Interlocuteur comme variable de la class Société. Mais maintenant, comment on utilise les valeurs ?

Dim Client As New Societe()

Client.Nom 'Renvoie le nom de la société
Client.Directeur.Nom 'Renvoie le nom du Directeur

Simple non ?

Méthodes et attributs

Derrière ces deux appellations se cachent une seule est unique chose, les fonctions. Dans une class, on peut déclarer une fonction (ou sub) qui sera appelée pour une action particulière. Alors pourquoi deux noms ? Simplement car : méthodes = private, attributs = public. Au final ça ne change pas grand chose sur leur utilisation si ce n’est qu’en « private », la fonctione ne sera pas accessible en dehors de la class.

Voici un exemple de fonction.

Public Class Societe
    'Déclaration des variables
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Adresse As String = ""
    Public CP As String = ""
    Public Ville As String = ""
    Public Directeur As Interlocteur

    Sub New(ByVal id_societe As Integer)
        'Initialisation de la class
        Directeur = New Interlocuteur(id_directeur)
    End Sub

    Sub Sauvegarde(ByVal id_societe As Integer)
        'Cette fonction sauvegarde les modifications dans la base de données
    End Sub

End Class

Pour appeler ma sauvegarde c’est très simple.

Client.Sauvegarde()

Rien n’empêche de passer des paramètres bien sur donc la seule différence c’est la manière dont on va appeler cette fonction.

Conclusion

C’est la fin de ce tuto sur la POO en VB.Net. J’espère que j’ai été assez clair, n’hésitez pas à poser des questions s’il vous manque des éléments.

Cet article Tuto POO en Vb.NET : La suite est apparu en premier sur Garikover.com.

Problématique

Alors pourquoi ne pas se satisfaire des tutos déjà présent sur internet ?

Pour le simple et bonne raison que je les trouve surchargés, sans réel intérêt dans le sens ou il explique des principes de base sans exemple très parlant. J’ai été amené à faire pas mal de recherche post-tuto pour savoir comment on faisait ceci ou cela, qui sont des principes de base, mais rien de simple à trouver. Donc je réalise ce tuto avec un exemple qui marche (puisque je l’utilise réellement en programmation).

La POO ?

La Programmation Orientée Objet est présente dans plusieurs langages de programmation et a pour objectif de faciliter le traitement des données. Elle présente pas mal d’avantages et peu d’inconvénient.

Actuellement en programmation, quand on veut obtenir une valeur à partir d’une base de données, on fait une requête est on traite les informations au cas par cas. Or un des principes de base est de ne jamais répéter plusieurs fois un code identique. Si on a besoin d’un même bout de code plusieurs fois, on créé une fonction pour le remplacer, ce qui facilite la maintenance du code.

L’idée de la POO est de centraliser la gestion des données et de faciliter leur exploitation grâce à une formulation plus explicite.

Si on compare l’avant et l’après POO :

• Avant : Une multitude de boite qu’on doit ouvrir au pied de biche pour en modifier le contenu
• Après : une commode avec une infinité de tiroir et une jolie clé toute simple pour modifier le contenu

Vocabulaire

Oui j’ai dit qu’on n’allait pas aborder de vocabulaire très poussé, mais il en faut un minimum.

• La POO s’articule autour des Class. Pour faire simple, il s’agit d’une fonction en plus poussée (c’est notre commode).
• Ensuite, chaque Class possède ses attributs qui ne sont que des variables avec une syntaxe particulière (ce sont nos tiroirs).
• Les propriétés qui sont là pour accéder aux tiroirs attributs et les modifier (la clé du tiroir).
• Et pour finir, les méthodes qui sont des sous-fonctions (c’est l’équivalent de la personne qui change le contenu des tiroirs).

Code

Déclaration de la Class

Avant toute chose, histoire d’avoir un code clair, on ouvre un nouveau module de Class et on la déclare. Cette syntaxe ne doit pas vous être étrangère car c’est de cette manière qu’est déclaré une UserForm.

Public Class MaClasse

End Class

Alors ça peut paraître très simple, mais c’est parce que ça l’est. Mais on va entrer tout de suite dans le vif du sujet avec une classe assez simple à propos qui contient les informations d’une société.

Ajout des attribus (propriétés)

Là on rajoute les attributs de la classe. Jusque là rien de bien compliqué puisqu’on utilise la même méthode pour déclarer une variable Public.

Public Class Societe
    Public Nom As String
    Public Adresse As String
    Public CP As String
    Public Ville As String

End Class

Jusque là ce ne sont que des choses déjà vu et connu mais qu’on ne remarque pas forcément (voir ci-dessous).

Le constructeur

Tout comme une fonction, une classe s’initialise quand on l’appelle. Alors tout l’intérêt de cet appel est qu’il peut intégrer des paramètres pour adapter les variables.

Public Class Societe
    Public Nom As String
    Public Adresse As String
    Public CP As String
    Public Ville As String

    Sub New(<paramètres comme="" n'importe="" quelle="" fonction="">)

    End Sub

End Class

Vous avez déjà vu ce genre de structure avant, quand vous utilisez une Form dans un projet et des variables Public.

Public Class Form1

    Public Stockage As String

    Private Sub MaSub()

    End Sub

End Class

Histoire de faire avancer le schmilblick, on va voir immédiatement comment utiliser le Constructeur en lui passant un paramètre. Ici, on va passer un identifiant unique de la société. On va également prévoir le cas où la base de donnée ne contient pas de société avec cet identifiant et utiliser des valeurs par défaut. Ça évite une erreur en cas d’utilisation d’une variable sans valeur.

Public Class Societe
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Adresse As String = ""
    Public CP As String = ""
    Public Ville As String = ""

    Sub New(ByVal id_societe As String)
        'On transforme id_client en membre de la classe
        Id = id_client
        Dim Dr As OleDbDataReader
        Dim Command As OleDbCommand
        Connection.Open()
        Command = New OleDbCommand("SELECT * FROM SOCIETE WHERE id_societe = " & id_societe & ";", Connection)
        Dr = Command.ExecuteReader
        While Dr.Read()
            Nom = Dr("nom").ToString
            Adresse = Dr("adresse").ToString
            CP = Dr("code_postal").ToString
            Ville = Dr("ville").ToString
        End While
        Connection.Close()
    End Sub

End Class

 L’utilisation dans le code

Maintenant qu’on a vu comment ça fonctionne, on va voir comment exploiter ces résultats.

'Création d'une instance "client"
Dim client As New Societe(id_client)

Cette simple ligne permet d’instancié le client. Donc pour reprendre l’exemple de la commode à tiroir, client est notre commode. Donc comment utiliser ses tiroirs ? En fait c’est très simple.

'Création d'une instance "client"
Dim client As New Societe(id_client)

'On place le nom du client dans une TextBox
TextBox1.Text = client.Nom

'On change le contenu d'une valeur
client.Ville = TextBox2.Text

Vous comprenez maintenant ? C’est simple, propre, presque beau. Mais on peut encore allé bien plus loin en multipliant les instances. Si je souhaite avoir deux commodes, l’une étant un client l’autre un fournisseur…

'Création d'une instance "client"
Dim client As New Societe(id_client)

'Création d'une instance "fournisseur"
Dim fournisseur As New Societe(id_fournisseur)

Le client et le fournisseur étant deux sociétés, ils contiennent les mêmes informations : Nom de société, adresse, ville, code postal… Donc ma class société est en fait un archétype que je peux remplir.

Shared !

Le dernier point de ce tuto est l’utilisation de l’option Shared. Cette option permet d’utiliser la variable à laquelle elle a été rattachée sans avoir à instancié la class.

L’exemple ci-dessous devrait vous éclairer.

Public Class Societe
    Public Shared Nom As String
    Public Ville As String

    Sub New()
    End Sub

End Class

Sub Instance()
    'Initialise la class sans nom
    TextBox1.Text = Societe.Nom 'Fonctionne
    TextBox2.Text = Societe.Ville 'Ne Fonctionne Pas

    'Fonctionne
    Dim client As New Societe(id)
    TextBox2.Text = client.Ville
End Sub

Conclusion

C’est la fin de la première partie du tuto POO. Pour le moment vous savez déclarer une Class, l’initialiser via un constructeur et exploiter ses données.

Dans la prochaine partie, on verra les class imbriquées et les méthodes (si j’en ai parlé au début).

Cet article Tuto POO en Vb.NET : La base est apparu en premier sur Garikover.com.

L’idée

Lassé de la fonction upload de WordPress qui est assez lourde et surtout très pénible avec la multiplication des pains miniatures et des différents formats quand j’upload une affiche de film ou une pochette de Cd ou de jeu vidéo, j’ai créé Auto Pictures afin de répondre à une problématique simple : ajouter automatiquement une image en début d’article si le titre correspond.

Le gros plus de ce plugin, c’est qu’il gère tous les articles, donc pas besoin de rééditer à la main chaque article, il suffit de rajouter les images avec le bon nom sur le serveur.

Première version

Même si le développement ne m’a pris que quelques heures sur quelques jours, je suis passé par plusieurs étapes de réflexions. Au départ, le plugin ne devait avoir aucune interface administration et simplement récupérer le nom de l’article et de chercher l’image correspondante.

Par exemple, l’article « The Hobbit : un voyage inattendu » cherchait l’image « the-hobbit-un-voyage-inattendu », avec plusieurs extensions possibles (jpg, jpeg, png, gif).

Vous avez compris que l’idée est de charger via FTP l’image déjà dimensionnée dans un dossier spécifique afin que l’article se charge de lui même de l’afficher. Si une image était déjà présente dans l’article, aucune recherche n’était faite.

Seconde version

Là, le plugin est fonctionnel, mais il manque quelque chose. Comment savoir si une image est belle et surtout si le nom correspond ?

J’ai donc rajouté un bout de code qui indique juste après le titre d’un article le nom de doit avoir l’image histoire de faire un copier/coller. Mais comme c’est très moche vis-à-vis du visiteur d’avoir « image manquante », cette ligne ne s’affiche que si on est connecté en tant qu’administrateur.

Troisième version

Quand on rédige l’article, on ne sait pas si l’image est déjà présente. Du coup j’ai simplement rajouté une petite fenêtre qui affiche l’image si elle est trouvée ou qui affiche le nom qu’elle devrait avoir. Aucune option sur cette meta box (c’est le nom d’une case administration sur wordpress), elle n’a que vocation à affichage (pour le moment…).

Quatrième version

LA question ultime… Comment retrouver les articles qui n’ont pas d’image ?

LA réponse ultmie…. En faisant une vérification article par articles filtrés par catégorie.

Du coup, j’ai créé une interface administrateur qui permet de consulter les images manquantes pour tous les articles. On peut bien sur filtrer sur une catégorie particulière et masquer les articles sont les images sont présentes sur le serveur. Petit plus, en cas d’image manquante, un lien vers google avec recherche selon le titre de l’article pour trouver notre image en un clique, et lien vers l’image quand elle est présente.

Cinquième version (avenir ?)

L’idéal serait que l’interface d’édition de l’article (la meta box du début) permette de charger une image depuis le disque dur en la redimensionnant et en la renommant avec le bon nom. Mais ce n’est pas pour tout de suite.

Conclusion

Au final, j’ai l’impression d’avoir créé toute une interface de gestion qui me correspond mieux.

Au passage, je ferais un article sur le logiciel XnView qui permet de redimensionner des images à la volée (ce qui est très pratique avec ce plugin).

Cet article Auto Pictures est apparu en premier sur Garikover.com.

La problématique que j’ai est de récupérer le nom du control sur lequel je fais un clique droit. Après plusieurs heures de recherche, j’ai trouvé un truc tout bête :

1. Créer le ContextMenuStrip (CMS)
2. Assigner le CMS à tous les controls que vous souhaitez utiliser
3. Utiliser le code suivant

Private Sub ContextMenuStrip1_Opening(ByVal sender As Object, ByVal e As System.ComponentModel.CancelEventArgs) Handles ContextMenuStrip1.Opening

        'Acquisition des références
        Dim c As Control = ContextMenuStrip1.SourceControl
        Dim tsi As ToolStripDropDownItem = ContextMenuStrip1.OwnerItem
        Dim nomControl As String = c.Name
        ContextMenuStrip1.Items.Clear()

        If nomControl = "xxx" Then

        ElseIf nomControl = "yyy" Then

        End If
        e.Cancel = False
    End Sub

Cet article [VB.NET] Le ContextMenuStrip est apparu en premier sur Garikover.com.

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.