I. Préface:

 

Les écrans intelligents ont été largement utilisés dans divers domaines tels que le médical, le contrôle industriel et l'automobile après le lancement des produits. En termes simples, il s'agit d'un écran combiné à un micro contrôleur qui peut gérer le chargement, le réglage, l'affichage et même l’entrée des graphiques complexes, et le dispositif extérieur (un hôte, par exemple) peut effectuer des opérations interactives avec des commandes simples, de sorte qu'il est très adapté à divers besoins. Différents types d'applications affichées ou contrôlées.

Les écrans intelligents supportent une variété d'interfaces de communication. Actuellement, les plus utilisées sont CAN/CANopen, RS485/Modbus ; d'autres choix seront proposés à l'avenir. Parmi elles, RS485/Modbus est une interface de communication très populaire dans l'industrie, et divers dispositifs RS485 à des prix raisonnables sont disponibles sur le marché. La structure des lignes est simple, tant que deux fils (RS485_A/RS485_B) peuvent communiquer, et l'interface de communication est généralement présentée sous la forme d'un « port série » sur un système d'exploitation. Chaque plate-forme a une bibliothèque de fonctions développées pour correspondre. De plus, le protocole Modbus est assez facile à comprendre, c'est pourquoi nous l'avons pris comme exemple pour les expériences et les explications suivantes.

Cet article décrit la manière de contrôler l’écran intelligent, de la simplicité à en grand détails, y compris son principe de contrôle, et enfin présente la manière de créer des applications multiplateformes. Que vous soyez un expert en équipement industriel ou un bricoleur, bienvenue dans le monde des écrans intelligents avec nous !

II. Conditions requises:

 

■Écran intelligent_RS485

Un écran intelligent qui supporte l'interface RS485 est nécessaire pour tester la connexion.

■Dongle RS485

Puisqu'un hôte comme un PC/Raspberry Pi n'a normalement pas de port RS485, nous pouvons utiliser divers dongles, de USB à RS485 si nécessaire.

 

■Dispositif HÔTE

Lorsque les conditions ci-dessus sont remplies, nous pouvons choisir un environnement d'exécution de banc d'essai comme Hôte. La seule condition pour un dispositif hôte est d'être capable de lire et d'écrire avec le port série de l'hôte, peu importe le système d'exploitation Windows, MacOS, même divers Linux (y compris Raspbian pour Raspberry Pi), ou la plate-forme doit être un ordinateur monocarte, Arduino, etc.

Nous créons des ordinateurs à carte unique avec RS485 intégré de Demo.set pour la commodité, qui peut être utilisé comme un dispositif hôte comme indiqué dans l’image ci-dessous.

 

III. Test simple pour l'interface de contrôle:

 

■Obtenir le code de contrôle

Afin de comprendre comment faire pour collaborer Smart avec un hôte. La première chose à faire est d'obtenir le code de contrôle. Le moyen le plus simple est de l'obtenir à partir du logiciel GUI Builder sur l’écran intelligent. GUI Builder est un excellent logiciel de support pour les écrans intelligents. Il peut nous aider à apprendre, à utiliser, à concevoir et à afficher l'interface utilisateur sans dispositif physique matériel, et à concevoir l'interface utilisateur sans écrire une seule ligne de code. Avec la fonction WYSIWYG, la conception de l'interface utilisateur peut être faite en faisant glisser ou en cliquant sur des boutons ou des objets uniquement. En outre, il y a un simulateur intégré qui partage le code source avec l’écran intelligent, garantissant ainsi la même apparence et le même comportement que le dispositif physique. Encore mieux, c’est gratuit !

► Contact for Smart Display GUI Builder

 

Double-cliquez sur GUI Builder pour exécuter l'application sous Windows OS, et ouvrez un nouveau projet. Ici, nous choisissons l’écran intelligent de 5" RS485 WL0F00050000FGDAASA00, et le scénario par défaut ci-dessous est Véhicule. Entrez le nom du projet, appuyez sur le bouton Créer pour créer le nouveau projet. S'il a déjà été créé auparavant, vous pouvez sélectionner le projet directement dans le menu à droite.

 

Lorsque le projet est ouvert, sélectionnez d'abord l'interface.

 

 

Sélectionnez RS485 pour l'interface, et le port RS485 de l'hôte doit être défini comme le port réel du port connecté pour le dongle RS485. En cas de doute, vous pouvez vérifier le nom du port dans l'administrateur des périphériques (débranchez-le à plusieurs reprises et vérifiez s'il disparaît ou s'il affiche celui qui est affiché). Le débit en bauds peut utiliser la valeur par défaut de 115 200.

 

Cependant, s'il n'y a pas encore un dispositif d’écran intelligent RS485, cela n'est pas important tant que l'interface sélectionnée est RS485, le port RS485 peut être ignoré pour l'instant parce que maintenant nous allons juste utiliser le simulateur, et nous n’allons pas nous connecter au dispositif d’écran intelligent.

Cliquez sur Simulateur/Simulateur avec GUI exécuter:

 

Après l'exécution, vous pouvez voir l'écran de simulation, les éléments de contrôle de chaque objet ; et l'enregistrement des données de communication sur le côté droit de l'écran. Changez la valeur de n'importe quel objet pour voir le contenu de la commande en conséquence :

 

Chaque action aura deux commandes TX/RX, parce que le dispositif d'affichage (même s'il s'agit simplement d'un émulateur comme maintenant) renverra la même commande comme accusé de réception après avoir reçu la commande pour indiquer qu'elle a été reçue.

Nous enregistrons plusieurs valeurs différentes pour différents objets, et l'étape suivante peut être utilisée pour contrôler le dispositif physique.

■Connexion câblée

RS485 utilise la paire différentielle pour transmettre et recevoir les signaux, donc tant que ces deux fils peuvent être connectés, même le fil de terre n'est pas nécessaire. Le nom de la ligne de signal de RS485 est A/B, suivez-la simplement (A connecté avec A, B connecté avec B).

 

Comment un hôte peut-il transmettre des codes de contrôle depuis lui-même ? Tant qu'il peut écrire sur un port série. Cependant, il y a deux choses à garder à l'esprit avant de commencer les tests.

1. Les noms des ports de communication étant différents d'un système d'exploitation à l'autre, veuillez vérifier et confirmer avant de procéder aux tests. Par exemple, le tableau suivant :

 

2. La permission du port de communication de certains systèmes d'exploitation n'est pas ouverte par défaut. Elle doit être définie avant de pouvoir l'utiliser. En prenant Linux/Ubuntu comme exemple, si le nom du port de communication est ttyUSB0, veuillez l'exécuter dans le terminal:

sudo chmod 666 /dev/ttyUSB0

 

Deux méthodes de test sont fournies ci-dessous:

■Contrôle du terminal du port série

Utilisez le logiciel de terminal du port série qui prend en charge l'entrée hexadécimale, et entrez directement le code de contrôle hexadécimal après la connexion:

 

S'il est normal, vous devriez voir que les objets sur le dispositif agissent différemment avec différents codes de contrôle.

Mais cette méthode n'est utilisée que pour tester si la connexion est réussie, et elle n'est pas très pratique en pratique. Pour obtenir les meilleurs résultats, veuillez le faire avec le programme. Quel langue ? En fait, nous pouvons essayer d'abord avec le populaire langage de programmation multiplateforme Python.

■Utiliser Python

Les programmes suivants sont exécutés avec Python3. La structure du programme est assez simple, il suffit d'écrire directement trois ensembles de codes de contrôle dans le port série toutes les secondes, pour que l'instrument sur le dispositif continue à tourner.
 

import serial from time import sleep """ The name of Com Port varies according to the operating system, For example: Raspberry Pi: /dev/ttyUSBn (e.g. /dev/ttyUSB0) Windows: COMn (e.g. COM22) """ # Raspberry Pi / Rasbian # COM_PORT = '/dev/ttyUSB0' COM_PORT = 'COM22' v000 = bytes.fromhex('7B06000600006251') v050 = bytes.fromhex('7B0600060032E384') v100 = bytes.fromhex('7B060006006463BA') ser = serial.Serial(COM_PORT, 115200) while True: ser.write(v000) sleep(1.0) ser.write(v050) sleep(1.0) ser.write(v100) sleep(1.0) ser.write(v050) sleep(1.0)

Le code source Python peut être exécuté sur une variété de plateformes, donc tant que le port série est nommé correctement, il devrait fonctionner correctement avec le banc d'essai de connexion approprié.

Cependant, ces codes de contrôle fixes à titre d'exemple ne doivent pas correspondre aux applications pratiques, nous devons donc comprendre le contenu de ces instructions avant de pouvoir les utiliser pleinement.

IV. Analyse du code de contrôle

 

■Analyse comparative

Comparez des commandes avec des valeurs différentes pour le même objet:

Il n'est pas difficile de constater que la partie bleue correspond à la valeur de l'objet que nous avons défini.

Comparer des objets différents avec la même commande de valeur :

La partie bleue fait évidemment référence à une sorte d'index ou d'adresse de l'objet.

Quant aux données des deux derniers octets, il semble qu'il n'y ait pas de règles. Mais que signifient ces messages ? Nous allons l'expliquer ci-dessous.

■Analyse du code de contrôle

En fait, le contenu de ces 8 octets est ce qu'on appelle le message Modbus. Utilisons une image pour illustrer la signification de chaque champ :

 

ID
Chaque dispositif Modbus doit avoir un code d'identification. Le code d'identification de l’écran intelligent est 0x7B = 123

Fun (Code de fonction)
Un code de fonction, indiquant le but de ce message, par exemple, 06 ici est « Write Single Register », qui écrit également une valeur à l'endroit spécifié.

Adresse du registre
L'adresse du registre est la destination de l'écriture (c'est-à-dire l'adresse de l'objet).

Données
Ce qu'il faut écrire (c'est-à-dire la valeur de l'objet).

CRC
Le résultat de CRC (Cyclic Redundancy Check) sur les 6 premiers octets est utilisé pour vérifier s'il y a une erreur dans les données pendant le processus de transmission.

Vous avez compris certains concepts ? Si vous voulez en savoir plus, vous devez comprendre ce qu'est Modbus.

V. Introduction à Modbus

 

■Protocole Modbus

Le protocole Modbus est en fait un format de données. Il définit essentiellement le contenu de la communication d'une architecture maître-esclave. Puisqu'il ne s'agit que de la définition de la structure des données, il peut communiquer à travers diverses interfaces physiques, telles que RS232, RS422, RS485, et même un réseau.

Comme il existe déjà de nombreux documents de formation et d'explication sur l’Internet, Modbus ne sera pas décrit en détail ici. En fait, tant que vous connaissez quelques concepts, vous pouvez utiliser Modbus immédiatement.

■Modèle conceptuel

Modbus considère la transmission de données comme un accès « registre ». Chaque appareil doit définir son propre type et son adresse de registre pour une référence externe. Ce que l'on appelle la transmission des données sur un dispositif consiste à écrire dans le registre spécifié, et la lecture des données consiste à lire le registre spécifié, cela est simple et clair. En outre, la valeur stockée dans chaque registre d'adresse est de 16 bits.

■Code de fonction

Selon les caractéristiques des données, Modbus définit plusieurs méthodes de lecture et d'écriture, qui sont spécifiées par le code de fonction dans le message.

 

Pour les programmes de contrôle d’écran intelligent, les plus couramment utilisées sont 06 : « Write single register » (écrire une valeur de 16 bits) et « Read holding registers » (lire une valeur de plusieurs registres).

■CRC

Les deux derniers octets semblent être la partie la plus compliquées, mais ils ne sont pas difficiles. Il s'agit simplement d'un CRC (Cyclic Redundancy Check - Contrôle de redondance cyclique) pour assurer la communication des données. Il n'est pas forcément nécessaire d'étudier son principe en profondeur (en fait, il s'agit juste d'une table de consultation et d'opération sur les bits, et à la fin un code de contrôle de 16 bits est obtenu), tant que vous comprenez comment l'utiliser.

VI. Contrôler les objets d’un écran intelligent

 

Comme mentionné précédemment, chaque Modbus doit définir le type et l'adresse du registre, et nous allons maintenant aborder ce sujet.

■Classification du registre

Les registres des écrans intelligents peuvent être grossièrement divisés en trois catégories :

1.)Informations sur le dispositif (par exemple, la version, le nom du dispositif, etc.)
Utiliser 04 : Lire les registres d'entrée pour lire. Ces données ne seront modifiées que lors de la mise à jour du firmware, généralement lorsqu'il vient d'être connecté, pour obtenir les paramètres caractéristiques du dispositif.

2.)Propriétés de l'objet (par exemple, type, emplacement, etc.)
Utiliser 03 : Lire les registres d’entretien/16 : Écrire plusieurs registres pour lire et écrire. Ces données affectent l'apparence des objets et ne changent généralement pas après la phase de conception. Pour modifier le contenu, l'écran intelligent doit être temporairement éteint avant de pouvoir être mis à jour.

3.)Valeurs de l’objet (les valeurs que l'objet représente, telles que RPM, activé ou désactivé, pourcentage, etc. varient d'un objet à l'autre)
Il s'agit du principal élément de modification de l'opération. Chaque élément utilise une valeur de 16 bits, il est donc réglé avec 06 : Écrire un seul registre

Ce qui suit est une liste organisée de ces registres:

■Input Registers

 

■Holding Registers

 

Les premiers écrans intelligents ne prenaient en charge que 10 objets, la plage de widgetID était donc de 0 ~ 9 (inclus). La nouvelle version du firmware a été étendue à 64, mais la méthode d'adressage a été modifiée, celle-ci ne sera pas abordé ici.

Avec ces données (bien qu'elles ne soient pas complètes, mais suffisantes pour le moment), nous pouvons emballer les instructions de contrôle et les envoyer à l’écran intelligent pour le contrôle. La façon d'emballer et d'ajouter le code CRC sera expliquée dans les chapitres suivants.

VII. Interface utilisateur

 

Afin de mettre en pratique l'écran intelligent, une interface homme-machine appropriée (en particulier une interface utilisateur graphique, ou GUI) est toujours nécessaire pour maximiser son efficacité. À l'heure actuelle, il y a de nombreux choix de plateforme de développement d'interface graphique multiplateforme, et nous utilisons Qt pour cet exemple.

Beaucoup de gens pensent que Qt n'est qu'une bibliothèque d'interface graphique, mais c’est en fait un cadre de développement assez complet. Si l'application est entièrement mise en œuvre par sa bibliothèque de classes, le projet peut être facilement transférés sur d'autres plates-formes (PC/Windows, Mac/MacOS, Raspberry Pi/Raspbian, Android, iOS, Embedded, etc.) avec peu de modifications. Le programme est un outil de développement logiciel qui vaut la peine d'investir du temps dans son apprentissage.

La version la plus récente de Qt supporte en fait déjà la bibliothèque de classe Modbus. Mais ici pour l'illustration, et pour faciliter à chacun de réécrire dans d'autres langues, nous implémentons encore ce programme de test à partir de la lecture et l'écriture la plus basique du port série.

En plus de fournir la fonction de sélection du port série et de transmission du code de contrôle utilisé dans l'exemple précédent, cet exemple fournit également un levier horizontal dans l'interface utilisateur de la fenêtre d'application, qui peut définir la valeur de l'objet spécifié. Si vous choisissez COM pour le port série, n'oubliez pas d'indiquer le numéro réel.

L'image suivante montre l'écran d'exécution de ce programme sur Raspberry Pi et Ubuntu. Le programme n'a pas besoin d'être modifié du tout.

 

 

■Opération CRC

L'opération CRC n'est en fait pas compliquée. C'est probablement comme les codes ci-dessous avec Qt :

QByteArray SetWidgetValue::calculateCRC(QByteArray data) { uint16_t crc = 0xFFFF; for(int idx = 0; idx < data.length(); idx++) { uint8_t i = (uint8_t)crc ^ data[idx]; crc >>= 8; crc ^= crcTable[i]; } QByteArray ba; ba.append(char(crc & 0xFF)); ba.append(char(crc >> 8)); return ba; }

The contents of crcTable[] are:

const uint16_t crcTable[] = { 0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241, 0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440, 0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40, 0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841, . . . 0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40, 0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41, 0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641, 0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040 };

Tous les codes ne sont pas listés ici. Il y a des informations complètes sur github que les utilisateurs peuvent télécharger eux-mêmes s'ils sont intéressés par la programmation, dans cet article nous voulons seulement utiliser le format de données.

■Conditionnement des données

La fonction suivante est la fonction clé qui calcule le code de contrôle en fonction de l'UI et l'envoie à l’écran intelligent :

void SetWidgetValue::on_sbValue_valueChanged(int value) { int id = ui->edWidgetID->text().toInt(); sendWidgetValue(id, value); ui->lbValue->setText(QString::number(value)); } void SetWidgetValue::sendWidgetValue(int id, int value) { QByteArray msg; uint16_t addr = (uint16_t)(id * 100 + 6); msg.append(deviceID); msg.append(writeSingleRegister); msg.append((uint8_t)addr >> 8); msg.append((uint8_t)addr & 0xFF); msg.append((uint8_t)value >> 8); msg.append((uint8_t)value & 0xFF); QByteArray msgToSend = msg.append(calculateCRC(msg)); writeSerialPortData(msgToSend); }

Si vous êtes déjà familier avec Qt, le code ci-dessus ne devrait pas être difficile à comprendre. Si vous ne le connaissez pas, prenez un moment pour l'étudier, certains de ses concepts sont en fait assez utiles et méritent d'être étudiés en profondeur. Après vous être familiarisé avec cela, il est un bon choix pour le développement d'applications multiplateformes ou le prototypage rapide d'un système.

VIII. Exemple avancé

 

L'exemple précédent ne concerne que le réglage de la valeur de l'objet. Il y a un exemple plus complet de programmes d'application SmartDisplayConsole que les lecteurs intéressés pourront découvrir. L'image suivante est l'écran d'exécution sur un Raspberry Pi:

 

Il y a une URL de github à la fin de l'article, et tout le monde est invité à s'y référer et à apprendre ensemble.

IX. Conclusion

 

Nous avons expliqué chaque étape du contrôle de l'écran intelligent, et nous avons également fourni une variété de méthodes de contrôle. En utilisant ces connaissances et votre riche imagination, je crois que diverses étincelles peuvent être remuées et que des produits plus diversifiés pourront être créés. Créons ensemble un meilleur avenir avec les écrans intelligents !

X. Références

 

Serial Terminal Basics
https://learn.sparkfun.com/tutorials/terminal-basics/command-line-windows-mac-linux

Modbus
https://www.modbustools.com/modbus.html
https://www.modbusdriver.com/doc/mbusmaster.net/modbus.htm

XI. Sample source code

 

GettingStartedWithSmartDisplay
https://github.com/Smart-Display-Series/GettingStartedWithSmartDisplay.git

SmartDisplayConsole
https://github.com/Smart-Display-Series/SmartDisplayConsole.git