Sylvain Mahé Artisan mécatronique Retour à l'accueil Profil Âge : 36 ans
Situation familiale : Union libre
Nationalité : Française
Permis : B
"Autodidacte & créatif, autonomie & travail en équipe, savoir-faire & savoir-être" Contact ✕ Ville : Nantes
✆ Téléphone : 06.45.49.96.98
✉ E-mail : contact@sylvainmahe.site
✎ Site web : sylvainmahe.site
Centres d'intérêts ✓ Philosophie des sciences.
✓ Écologie & biodiversité.
✓ Artisanat & partage d'inventions.
✓ Lecture & écriture d'ouvrages.
✓ Sport : cyclisme & natation.
Écriture de la page : Sylvain Mahé
Un réseau d'automates programmables avec la classe UsartNetwork Avec la classe UsartNetwork vous pouvez relier plusieurs automates programmes en un réseau filaire pour permettre l'échange de données numériques. C'est le protocole USART (pour "Universal Synchronous Asynchronous Receiver Transmitter" ou émetteur récepteur synchrone asynchrone universel) qui est utilisé afin d'effectuer les communications bidirectionnelles à la vitesse de 2M bauds / seconde sur une largeur de 32 bits utiles (c'est-à-dire en faisant abstraction du marqueur de début de trame, de l'identifiant réseau, de l'adresse de destination, et du code de correction d'erreurs). Ports des automates programmables concernés par l'USART : Automate programmable MODULABLE 20 :
- Port GPIO 1 (PD0) = RXD (receive data)
- Port GPIO 2 (PD1) = TXD (transmit data)

Automate programmable MODULABLE 32 :
- Port GPIO 9 (PD0) = RXD (receive data)
- Port GPIO 10 (PD1) = TXD (transmit data)
L'exemple ci-dessous est minimaliste afin de bien comprendre comment envoyer une donnée sur le réseau (constitué d'un ou de plusieurs automates programmables). Exemple pour émettre des données avec la classe UsartNetwork : #include <UsartNetwork.h> int main() { UsartNetwork myVariable = UsartNetwork (1); UsartNetwork::start (void, 1524003746); while (true) { myVariable.transmit (123); } return 0; } Dans cet exemple, un objet myVariable de type UsartNetwork est déclaré, en paramètre est indiqué l'adresse 1 sur lequel communiquer les données (il y a 64 adresses en tout). Puis, l'USART est démarré en appelant la fonction statique start prenant plusieurs paramètres :
- Le 1er paramètre sert à indiquer une fonction à appeler lorsque des données sont reçues. Ici ce paramètre est indiqué void (vide) ce qui signifie qu'aucune fonction ne sera appelée lors de la réception de données (une interruption interviendra mais n'appellera pas de fonction).
- Le 2ème paramètre 1524003746 correspond au code d'identification (ou ID unique par définition) qui permet de sécuriser la communication entre plusieurs (deux ou plus) automates programmables sur le réseau.
C'est à vous de choisir ce code ID, plus le nombre est complexe et plus la communication sera protégée. Puis dans la boucle while, la fonction transmit de l'objet myVariable est utilisée pour transmettre le nombre 123 sur le réseau. Du fait de la boucle, le nombre 123 sera transmit continuellement à la vitesse du réseau. Exemple pour recevoir des données avec la classe UsartNetwork : #include <UsartNetwork.h> int main() { UsartNetwork myVariable = UsartNetwork (1); UsartNetwork::start (void, 1524003746); while (true) { myVariable.receive(); //myVariable.data est la donnée reçue } return 0; } L'exemple ci-dessus reprend le principe avec comme seul changement l'utilisation de la fonction receive en lieu et place de la fonction transmit de l'exemple précédent, afin cette fois de recevoir des données au lieu d'en émettre. Dans ce cas les données à leur arrivée sont stockées dans la variable data associée à l'objet myVariable. Note : si les deux exemples fonctionneraient sur deux automates programmables distincts reliés ensembles, la communication aboutirait, et la variable data de l'objet myVariable du deuxième montage prendrait alors la valeur 123 envoyée par le premier montage. Ce deuxième exemple est améliorable via l'utilisation d'une fonction qui est appelée uniquement lorsqu'une donnée valide est reçue du réseau. Exemple d'utilisation d'une fonction qui est appelée lors de la réception de données : #include <UsartNetwork.h> UsartNetwork _myVariable = UsartNetwork (1); void myReceiving() { _myVariable.receive(); //_myVariable.data est la donnée reçue } int main() { UsartNetwork::start (myReceiving, 1524003746); while (true) { } return 0; } Dans cet exemple, l'objet _myVariable de type UsartNetwork est déclaré cette fois à l'extérieur de la fonction principale main afin d'y avoir accès dans une fonction myReceiving qui sera exécutée uniquement lors de la réception de données. Dans la fonction principale main, la communication est démarrée en appelant la fonction statique start. Le 1er paramètre est renseigné avec la fonction myReceiving qui sera appelée lorsque des données seront reçues. Le 2ème paramètre 1524003746 reste inchangé par rapport aux exemples précédents (c'est le code d'identification unique). Autre fonctionnalité disponible : Si besoin la classe UsartNetwork dispose d'une fonction statique stop ce qui permet d'arrêter les communications, un nouvel appel à la fonction statique start permet de redémarrer les communications. Communication ping pong : Les deux exemples suivants montrent comment envoyer la donnée 1 depuis un montage vers un autre, ce dernier se contentant simplement de retourner cette donnée (aussitôt reçue) vers le premier montage. Montage ping : #include <UsartNetwork.h> int main() { UsartNetwork myVariablePing = UsartNetwork (1); UsartNetwork myVariablePong = UsartNetwork (2); UsartNetwork::start (void, 1524003746); while (true) { myVariablePing.transmit (1); myVariablePong.receive(); } return 0; } Dans l'exemple ci-dessus, tant que le montage "pong" n'existe pas, la variable data de l'objet myVariablePong sera toujours égale à 0. Quand le montage "pong" existera et aura reçu la donnée du montage "ping", soit 1, alors la donnée reçue stockée dans la variable data de l'objet myVariablePong sera égale à 1, preuve qu'un aller/retour aura été effectué. Montage pong : #include <UsartNetwork.h> int main() { UsartNetwork myVariablePing = UsartNetwork (1); UsartNetwork myVariablePong = UsartNetwork (2); UsartNetwork::start (void, 1524003746); while (true) { myVariablePing.receive(); myVariablePong.transmit (myVariablePing.data); } return 0; } Ce deuxième montage retourne simplement la donnée reçue à son propriétaire. La réception s'effectue sur l'adresse 1 via l'objet myVariablePing, et l'émission s'effectue sur l'adresse 2 via l'objet myVariablePong. Câblages et priorités : Il convient dans l'utilisation de la classe UsartNetwork de prendre note de quelques considérations techniques importantes pour le bon fonctionnement : Si vous n'utilisez pas la partie réception du montage et que vous n'appelez pas la fonction receive, il est important de quand même connecter un câble sur le port RXD de l'automate programmable allant vers un port TXD du périphérique, car dans le cas contraire les fonctions matérielles USART capteraient tous les bruits électromagnétiques environnants sur la broche laissée en l'air du microcontrôleur, et générerait des interruptions intempestives, ce qui n'est pas souhaité. La classe UsartNetwork utilise le protocole USART tout comme les classes UsartRs232 et UsartMidi, mais les vitesses de communication et les algorithmes mis en œuvre ne sont pas compatibles les uns avec les autres. Pour éviter tout problème de compatibilité, la classe utilisant l'USART déclarée en premier dans votre projet sera la seule activée et fonctionnelle. Références : Récapitulatif des fonctions et variables de cette classe : signed long data = 0; UsartNetwork (const unsigned char ADDRESS); static void start (void functionJump(), const unsigned long ID); void receive(); void transmit (const signed long DATA); static void stop();