Montre numérique sur Arduino à l'aide d'une machine à états finis

Applications et services en ligne

À propos de ce projet

Salut,

Je vais vous montrer comment créer une montre numérique avec YAKINDU Statechart Tools et fonctionner sur un Arduino, qui utilise un écran de clavier LCD.

Le modèle original de la montre numérique a été repris de David Harel. Il a publié un article sur la "large extension du formalisme conventionnel des machines à états et des diagrammes d'états."

Dans cet article, il a utilisé l'exemple de la montre numérique pour ses recherches. Je l'ai utilisé comme source d'inspiration et reconstruit la montre avec YAKINDU Statechart Tools (un outil pour créer des modèles graphiques de machines à états et générer du code C/C++ avec) et lui redonner vie sur un Arduino.

Comment fonctionne la montre numérique

Commençons par définir comment doit fonctionner la montre numérique. Vous souvenez-vous de ces… disons… des montres numériques « ultra cool » que tout le monde avait dans les années 90 ? Un chronomètre intégré, différentes alarmes et son bip agaçant toutes les heures. Si ce n'est pas le cas, jetez un œil à la montre numérique des années 90.

Donc, en gros, c'est une montre configurable avec différents modes. L'heure actuelle sera principalement affichée, mais il existe d'autres fonctionnalités. En entrée, vous avez un on/off , un mode et un ensemble bouton. De plus, vous pouvez allumer et éteindre la lumière.

Avec le mode bouton vous pouvez distinguer les modes et activer/désactiver les fonctions de l'horloge :

• Afficher l'heure (Horloge)
• Afficher la date (Date)
• Régler l'alarme (Alarme 1, Alarme 2)
• Activer/désactiver le carillon (Définir le carillon)
• Utilisez le chronomètre (Stop Watch)

Dans les menus, vous pouvez utiliser le on/off bouton pour configurer le mode. L'ensemble Le bouton vous permet de régler l'heure - par ex. pour l'horloge ou les alarmes. Le chronomètre peut être contrôlé - démarré et arrêté - en utilisant le bouton d'allumage et d'extinction de l'éclairage. Vous pouvez également utiliser un compteur de tours intégré.

De plus, il y a un carillon, qui sonne à chaque fois, et un rétro-éclairage contrôlable intégré. À la première étape, je ne les ai pas câblés à l'Arduino.

La machine d'état

Je ne veux pas entrer trop dans les détails pour l'explication de cet exemple. Ce n'est pas parce que c'est trop complexe, c'est juste un peu trop gros. Je vais essayer d'expliquer l'idée de base de son fonctionnement. L'exécution doit s'expliquer d'elle-même, en regardant le modèle ou en le téléchargeant et en le simulant. Certaines parties de la machine d'état sont résumées en sous-régions, comme l'temps défini Région. Avec cela, la lisibilité de la machine d'état doit être assurée.

Le modèle est divisé en deux parties - une graphique et une textuelle. Dans la partie textuelle les événements, variables, etc. seront définis. Dans la partie graphique - le diagramme d'état - l'exécution logique du modèle est spécifiée. Pour créer une machine d'état, qui remplit le comportement spécifié, certains événements d'entrée sont nécessaires, qui peuvent être utilisés dans le modèle :onoff , définir , mode , lumière , et light_r. Dans la section de définition, un événement interne est utilisé, qui incrémente la valeur temporelle toutes les 100 ms :

toutes les 100 ms / temps +=1 

Sur la base des pas de 100 ms, l'heure actuelle sera calculée dans le HH:MM:SS format :

display.first =(heure / 36000) % 24 ;
 display.second =(heure / 600) % 60 ;
display.third =(heure / 10) % 60 ;  

Les valeurs seront câblées à l'écran LCD en utilisant l'opération updateLCD à chaque fois que la machine d'état sera appelée :

display.updateLCD(display.first, display.second, display.third, display.text) 

L'exécution de base de la machine d'état est déjà définie dans la section Comment fonctionne la Digital Watch . Dans l'outil, j'ai utilisé des éléments de modélisation "spéciaux" comme CompositeState , Historique , Sous-Diagrammes , ExitNodes, etc. Une description détaillée peut être trouvée dans le Guide de l'utilisateur.

Écran de clavier LCD

Le LCD Keypad Shield est assez cool pour les projets simples, qui nécessitent un écran pour la visualisation et quelques boutons comme entrée - une HMI (interface homme-machine) simple et typique. L'écran LCD Keypad Shield contient cinq boutons utilisateur et un autre pour la réinitialisation. Les cinq boutons ensemble sont connectés à la broche A0 de l'Arduino. Chacun d'eux est connecté à un diviseur de tension, ce qui permet de distinguer les boutons.

Vous pouvez utiliser analogRead(0) pour trouver les valeurs spécifiques, qui peuvent bien sûr différer selon le fabricant. Ce projet simple affiche la valeur actuelle sur l'écran LCD :

#include 
#include 

LiquidCrystal lcd (8, 9, 4, 5, 6, 7);

configuration vide() {
 lcd.begin(16, 2);
 lcd.setCursor(0,0);
 lcd.write("Valeur mesurée");
}

boucle vide() {
 lcd.setCursor(0,1);
 lcd.print(" ");
 lcd. setCursor(0,1) ;
 lcd.print(analogRead(0));
 delay(200);
} 

Voici mes résultats mesurés :

• Aucun :1023
• Sélectionnez :640
• À gauche : 411
• En baisse : 257
• Jusqu'à : 100
• À droite : 0

Avec ces seuils il est possible de lire les boutons :

#define NONE 0
#define SELECT 1
#define LEFT 2
#define DOWN 3
#define UP 4
#define RIGHT 5 

static int readButton() {
 int result =0;
 result =analogRead(0);
 if (result <50) {
 return DROITE ;
 }
 si (résultat <150) {
 retourne HAUT ;
 }
 si (résultat <300) {
 retourne BAS ;
 }
 if (résultat <550) {
 return LEFT;
 }
 if (résultat <850) {
 return SELECT;
 }
 renvoie NONE ;
} 

Interfacer la machine d'état

Le code C++ généré de la machine d'état fournit des interfaces, qui doivent être implémentées pour contrôler la machine d'état. La première étape consiste à connecter les événements in avec les touches du Keypad Shield. J'ai déjà montré comment lire les boutons, mais pour les interfacer avec la machine d'état, il est nécessaire de neutraliser les boutons - sinon les événements seraient déclenchés plusieurs fois, ce qui entraînerait un comportement imprévisible. Le concept de logiciel anti-rebond n'est pas nouveau. Vous pouvez consulter la documentation Arduino.

Dans mon implémentation, je détecte un front descendant (relâchement du bouton). J'ai lu la valeur du bouton, j'ai attendu 80 ms (obtenu de meilleurs résultats avec 80 au lieu de 50), j'ai enregistré le résultat et lu la nouvelle valeur. Si l'ancienRésultat n'était pas AUCUN (non enfoncé) et le nouveau résultat est AUCUN , je sais que le bouton a été enfoncé auparavant et qu'il a maintenant été relâché. Ensuite, je déclenche l'événement d'entrée correspondant de la machine d'état.

int oldState =NONE;
static void raiseEvents() {
 int buttonPressed =readButton();
 delay(80);
 oldState =buttonPressed;
 if (oldState !=NONE &&readButton() ==NONE) {
 switch (oldState) {
 case SELECT:{
 stateMachine->getSCI_Button()->raise_mode();
 break;
 }
 case GAUCHE :{
 stateMachine->getSCI_Button()->raise_set();
 break ;
 }
 case DOWN :{
 stateMachine->getSCI_Button()->raise_light();
 break ;
 }
 case UP :{
 stateMachine->getSCI_Button() ->raise_light_r();
 break;
 }
 case DROITE :{
 stateMachine->getSCI_Button()->raise_onoff();
 break ;
 }
 par défaut :{
 break ;
 }
 }
 }
} 

Câblage des choses ensemble

Le programme principal utilise trois parties :

• La machine d'état
• Un minuteur
• Un gestionnaire d'affichage (typiquement lcd.print(...))

DigitalWatch* stateMachine =new DigitalWatch();
CPPTimerInterface* timer_sct =new CPPTimerInterface();
DisplayHandler* displayHandler =new DisplayHandler(); 

La machine d'état utilise un gestionnaire d'affichage et dispose d'un temporisateur, qui sera mis à jour pour contrôler les événements temporisés. Ensuite, la machine d'état est initialisée et entrée.

void setup() {
 stateMachine->setSCI_Display_OCB(displayHandler);
 stateMachine->setTimer(timer_sct);
 stateMachine->init();
 stateMachine->enter();
} 

La boucle fait trois choses :

• Soulever des événements d'entrée
• Calculez le temps écoulé et mettez à jour le chronomètre
• Appeler la machine d'état

long current_time =0;
long last_cycle_time =0;
void loop() {
 raiseEvents();
 last_cycle_time =current_time;
 current_time =millis();
 timer_sct->updateActiveTimer(stateMachine, 
 current_time - last_cycle_time);
 stateMachine->runCycle();
} 

Obtenez l'exemple

C'est ça. Probablement, je n'ai pas mentionné tous les détails de l'implémentation, mais vous pouvez jeter un œil à l'exemple ou laisser un commentaire.

Ajoutez l'exemple à un IDE en cours d'exécution avec :

Fichier -> Nouveau -> Exemple -> Exemples de diagrammes d'états YAKINDU -> Suivant -> Arduino - Montre numérique (C++)

>> Vous pouvez télécharger l'IDE ici <<

Vous pouvez commencer par un essai de 30 jours. Ensuite, vous devez obtenir une licence, qui est gratuite pour une utilisation non commerciale !