Notre monde connecté ; expliquer les machines à états finis

L'homme/la femme aurait été créé à l'image de Dieu. De la même manière, Hommes/Femmes créent désormais des machines à notre image. Un tel exemple est la programmation , ou FSM en abrégé. Les ingénieurs et les développeurs utilisent désormais des ordinateurs pour effectuer des tâches qui étaient auparavant exécutées manuellement. Par exemple : vous avez du linge sale qui traîne ? – Je le sais. Auparavant, nous devions rincer les vêtements dans une baignoire ou un évier, ajouter du savon, frotter, rincer à nouveau et ainsi de suite pour obtenir un t-shirt propre pour aller travailler ou sortir le soir. Nous disposons désormais de machines à laver pour effectuer ce travail à notre place. Nous sommes arrivés à ce point avec des ingénieurs ayant conçu des milliers de produits et d’appareils qui exécutent des programmes basés sur la pensée ou l’action humaine. Cela ne fait pas exception à l’apprentissage automatique actuel ou à d’autres mots à la mode en matière d’IA. Des millions d'appareils et d'applications sont en cours de développement pour accroître l'efficacité et la commodité des hommes et des femmes et bon nombre de ces processus d'assistance existent grâce aux FSM.

Les machines à états finis sont simplement un calcul mathématique d'une série de causes et d'événements. Par rapport à notre exemple de machine à laver, le FSM détermine quand démarrer le cycle de rinçage, quand essorer et quand arrêter complètement. Pour mieux comprendre une machine à états finis (FSM), nous devons d'abord définir le concept d'« état ». Un état est une information unique au sein d’un programme informatique plus vaste. Le calcul FSM change ou passe d'un état à un autre état en réponse à des entrées externes. Un FSM est défini par une liste ou un ordre logique de ses états ; son état initial et les conditions de chaque transition, se terminant par un état final ou final. Le FSM est une série de pensées programmées par l’ordinateur pour exécuter des opérations basées sur des entrées – de la même manière que l’homme pense et agit, nos machines et les ordinateurs qui les contrôlent aussi.

Les états sont l'ADN du FSM qui dicte le comportement interne ou les interactions avec un environnement, comme l'acceptation d'entrées ou la production de sorties qui peuvent ou non entraîner un changement ou une transition d'état du système. L'état est à exécuter spécifiquement en fonction des différentes conditions définies dans votre FSM. Ce concept est très important pour les ingénieurs en matériel informatique et en électricité, car de nombreux problèmes pratiques tels que la programmation des machines à laver (quand ajouter de l'eau ou du savon, quand essorer ou se reposer) sont facilement résolus en utilisant FSM au lieu des paradigmes de programmation séquentielle classiques. En d'autres termes, un FSM est une solution plus « électrique et électronique » pour résoudre un problème matériel par rapport à la programmation séquentielle.

Vous trouverez ci-dessous deux exemples de FSM qui produisent une prise de décision logique avec moins de temps et d'énergie nécessaires pour déployer un programme logique testé. Le FSM est votre première étape vers l’Edge Computing au niveau d’un seul appareil dans les applications IoT industrielles.

Machine Mealy : Dans le calcul de la machine Mealy, les sorties de chaque état dépendent de l'état réel et de ses valeurs d'entrée actuelles. Généralement, avec chaque calcul Mealy, l'entrée d'un état aboutit à une seule sortie vers une transition ou vers un état final. Le lave-linge se remplit d'eau – lorsque le niveau X est atteint – arrêtez l'eau.

Machine Moore : Dans la machine Moore, les sorties de chaque état dépendent de l'état réel et sont normalement basées sur des systèmes séquentiels cadencés. La machine à laver essore après 4 minutes d'arrêt de la machine.

DIAGRAMME D'ÉTAT

Tout FSM doit être décrit avant d'être codé par un diagramme d'état – de la même manière que nous pouvons schématiser les pensées de la machine. L'exemple ci-dessous montre le comportement du FSM et ses transitions qui sont (généralement) dessinées à l'aide de bulles pour décrire les états et de flèches pour les transitions. En outre, une remarque courante lors de l'exécution correcte d'un FSM est d'avoir un état présent unique dans lequel le prochain (futur) état qui sera exécuté peut être facilement identifié par les informations d'identification de programmation de l'état.

Dans le diagramme ci-dessus, nous illustrons un processus Mealy Finite State Machine terminé. Supposons que l'opération commence dans l'État 1 puis passe à l'État 2 une fois que les informations d'identification de programmation ont été remplies. Après la transition vers l'étape 2, le FSM calcule l'état actuel jusqu'à ce qu'un déclencheur soit satisfait pour passer à l'état 3 ou à l'état 4. Notez que dans ce diagramme, l'état 3 et l'étape 4 sont des états finaux ou finaux qui aboutissent à des données calculées pour votre le résultat final du projet.

Ubidots FSM

Commençons maintenant à coder un FSM pour envoyer des données à Ubidots et vous offrir une expérience réelle de travail avec cette méthode de programmation. Pour notre FSM, nous cherchons à identifier et à réagir à l’exigence initiale. Nous allons construire une machine Moore rapide : envoyer les données des capteurs de notre microcontrôleur (Espressif ESP8266) toutes les minutes à Ubidots

Sur la base de cette exigence initiale, nous avons choisi d'implémenter deux états en utilisant un modèle de calcul Moore Machine FSM :

• ATTENDRE : ne faites rien avant qu'une minute ne se soit écoulée (restez en veille pendant environ 59 secondes).
• READ_SEND : lisez l'entrée analogique du microcontrôleur sur lequel le capteur est connecté et envoyez le résultat à Ubidots à l'aide de MQTT au bout de 60 secondes.

Le diagramme d'état ci-dessous illustre la logique de programmation de notre FSM :

Ce diagramme montre clairement que la transition de WAIT à READ_SEND dépend exclusivement du fait que la valeur de temps indépendante est supérieure ou inférieure à 60 secondes. À partir du prochain état WAIT, le programme s'exécutera continuellement en WAIT jusqu'à ce que le temps indépendant atteigne ou dépasse 60 secondes. Une fois la barre des 60 secondes atteinte, le FSM passera de WAIT à READ_SEND. Une fois la valeur envoyée, le FSM reviendra à WAIT pour un comptage supplémentaire d'environ 59 secondes avant de calculer à nouveau la transition.

Codage

Pour rendre cet exemple un peu plus simple à comprendre, examinons un code FSM pratique qui a été divisé en quatre parties distinctes pour détailler chacun des états et conditions de transition. Le code complet peut être trouvé dans son intégralité ici.

Partie 1 – Définir les contraintes

// Inclure les bibliothèques #include " Ubidots ESPMQTT.h" // Définir des constantes #define TOKEN "...." // Votre Ubidots TOKEN #define WIFINAME "...." // Votre SSID #define WIFIPASS "... ." // Votre Pass Wifi #define WAIT 0 #define READ_SEND 1 uint8_t fsm_state = WAIT; // État initial int msCount = 0; // valeur flottante du compteur de temps ; // espace mémoire pour la valeur à lire Client Ubidots (TOKEN);

Cette première partie du code n'est pas très intéressante car on importe simplement la bibliothèque MQTT d'envoi de données vers Ubidots et on complète quelques définitions requises. Il est important de noter qu'ici nous définissons les deux états, WAIT et READ_SEND comme constantes à l'intérieur de tout le code et que nous définissons l'état actuel en utilisant la variable fsm_state. La partie suivante du code réserve de l'espace mémoire pour le minuteur indépendant et la valeur à lire et le client MQTT à initialiser.

Il est important de ne pas oublier de définir les valeurs appropriées pour votre TOKEN ainsi que le nom et le mot de passe de votre réseau WiFi. Si vous ne savez pas où trouver votre token, veuillez vous référer au centre d'aide Ubidots pour plus de trucs et astuces.

Partie 2 – Rappel

// Fonctions auxiliaires void callback (sujet char*, charge utile octet*, longueur int non signée) { Serial.print("Message arrivé ["); Serial.print (sujet); Série.print("] "); for (int i=0;i < length;i++) { Serial.print((char)payload[i]); } Serial.println(); }

Dans cette partie du code, nous fournissons un rappel qui gère les données du serveur lorsque/si nécessaire. Pour notre FSM, cette étape est nécessaire pour compiler correctement votre code. Comme décrit dans notre article MQTT , la fonction de rappel gère les modifications de vos variables dans Ubidots et il est nécessaire de compiler le code et de le définir.

Partie 3 – Fonctions principales – Configuration()

// Fonctions principales void setup() { // initialise la broche numérique LED_BUILTIN comme sortie. pinMode(A0, ENTRÉE); client.wifiConnection(WIFINAME, WIFIPASS); client.begin(rappel); }

Commençons maintenant par les fonctions principales. Dans notre configuration (), nous définirons la broche analogique zéro comme entrée (vous devez modifier le numéro du code PIN en fonction de la connexion physique de votre capteur) pour pouvoir utiliser l'ADC qui permet au capteur de lire les données de l'environnement et représente un nombre flottant comme valeur. De plus, nous initialisons le client WiFi et transmettons la fonction de rappel en fonction des paramètres de programmation précédemment définis.

Partie 4 – Fonctions principales – Boucle()

void loop() { switch(fsm_state) { case WAIT : if (msCount >= 60000){ msCount = 0 ; fsm_state = READ_SEND ; } casser; cas READ_SEND : valeur = analogRead(A0 ); if(!client.connected()){ client.reconnect(); } /* Routine d'envoi de données */ client.add("stuff", value); client. ubidots Publier("source1"); client.loop(); fsm_state = ATTENDRE ; casser; par défaut : pause ; } // Incrémente le compteur msCount += 1; retard(1); }

Un moyen populaire d'implémenter FSM dans les microcontrôleurs consiste à utiliser la à boîtier de commutation . Pour notre exemple, les cas seront nos états et les commutateurs seront la fsm_state . Voyons plus en détail comment chaque état est conçu :

Un moyen populaire d'implémenter FSM dans les microcontrôleurs consiste à utiliser la à boîtier de commutation . Pour notre exemple, les cas de commutation seront nos états et la programmation qui provoque une transition représentée par la variable fsm_state. Ici, nous déterminerons READ_SEND vs WAIT où les valeurs de 1 ou 0 seront envoyées respectueusement pour identifier chaque étape du FSM et la transition entre les opérations en fonction de la minuterie indépendante de 60 secondes.

Voyons plus en détail comment chaque état est conçu :

• WAIT : à partir du code de cet état, nous pouvons déduire qu'il ne fera rien si le résultat du minuteur indépendant stocké dans msCount est inférieur à 60 000 millisecondes ; une fois cette condition atteinte, la valeur de fsm_state change et nous passons à l'état suivant, l'état READ_SEND.
• READ_SEND : Ici, nous lisons la valeur de notre capteur, puis l'ajoutons simplement à une variable appelée « stuff » et publions ses données sur un appareil appelé « source1 ». Lors de l'exécution de ce programme, nous reviendrons toujours à l'état WAIT avant d'émettre une deuxième sortie.

Enfin, à partir de notre structure de commutation, nous incrémentons la valeur de notre minuterie et disposons d'un très petit délai de 1 milliseconde pour rendre le temps cohérent avec notre compteur.

À ce stade, vous vous demandez peut-être pourquoi programmer tout cela si nous pouvons utiliser la programmation séquentielle habituelle ? Imaginez que vous ayez trois tâches supplémentaires à effectuer dans votre routine :

1. Contrôler un servomoteur à l'aide de PWM
2. Afficher les valeurs sur un écran LCD
3. Pour fermer ou ouvrir un portail

Lors de l'exécution de plusieurs tâches, le FSM permet un stockage minimal de données dans la mémoire locale d'un appareil et les fonctions d'état peuvent effectuer des tâches immédiates basées sur les valeurs d'entrée et pas seulement sur une seule sortie. En utilisant FSM, vous pouvez prendre des décisions plus logiques avec moins de temps et d'énergie nécessaires au déploiement d'un programme logique testé. La valeur du FSM réside dans sa capacité à calculer des processus au niveau d’un seul appareil – la première étape de l’Edge Computing.

Essai

Nos scripts fonctionnent comme prévu, un nouveau périphérique appelé « source1 » est créé avec une variable appelée « stuff » qui reçoit et enregistre la valeur du capteur toutes les 60 secondes dans Ubidots .

Améliorations et idées

Un FSM peut être implémenté de plusieurs manières, et parfois l' instruction switch-case peut être fastidieuse à maintenir si vous devez gérer un très grand nombre d'états. Une amélioration supplémentaire du code expliqué ici dans la première partie serait d'éviter l'attente d'une milliseconde entre chaque cas analysé. Cela peut être effectué en utilisant millis().

Conclusion

L'homme et la femme ont conçu nos ordinateurs pour qu'ils fonctionnent à notre propre image et les machines à états finis sont la programmation qui permet aux machines d'exécuter des tâches et de fournir aux humains une aide et une assurance précieuses dans notre vie quotidienne. À mesure que la technologie et les connaissances nécessaires à la mise en œuvre des FSM deviennent de plus en plus abordables et accessibles, nous continuerons de voir les ordinateurs monocarte (SBC) imprégner les usines industrielles et les ateliers. Le contrôle de processus simples avec la programmation FSM sur les SBC continue de générer des solutions connectées qui complètent gateway et les API de base comme Dell, Siemens, etc., tout en fournissant des solutions locales qui permettent d'économiser $ en matériel et en coûts opérationnels.