Le broker qu’est-ce que c’est ?

Pour faire interagir la platine arduino et le web nous utilisons un broker. Son rôle est de distribuer les messages aux ensembles des objets IOT connectés. 

Lorsque l’objet IOT a souscrit à un topic, il va recevoir tous les messages de celui - ci. Quand il publie un message tous les objets abonnés à son topic le reçoivent.

Exemple:  

Pour interagir avec les différents objets, le broker utilise le protocole MQTT. Vous n’avez pas besoin de rentrer dans la technique pour utiliser celui-ci. 

Il existe plusieurs brokers, en principe nous pouvons avoir besoin d’un broker local ou accessible par internet. 

J’ai testé le broker Mosquitto en local sur une platine rasberryPi qui remplie efficacement son rôle.

Pour ne pas vous faire acheter du matériel supplémentaire, j’ai choisi le brocker shiftr.io sur internet car il est facile à installer et la documentation remplie les exigences du projet que je souhaite réaliser. 

Etape 1: Mise en place du Broker

• Créer un compte sur shiftr.io 
• Créer le broker 
• Modifier le token avec pour paramètre l’identifiant et le mot de passe.

Ces démarches sont rapides, pour ceux qui auraient des difficultés, je vous renvoie sur la vidéo Web et arduino ci-dessus.

Etape 2: Test avec la platine Arduino

Dans un premier temps, je vous invite à installer la librairie MQTT de Joel Gaehwiller

Ensuite lancer l’exemple 

- Fichier/EXEMPLE / MQTT / ArduinoEthernetShield

- Modifier les paramètres de connexion au broker dans la fonction Connect ligne 23 avec votre identifiant et votre mot de passe du token

- Téléverser le programme et vérifier que le broker reçoit l’information

« World »  sous le topic « Hello ».

A partir de là, la platine arduino et le broker sont opérationnels.

Etape 3: Le Web 

Dans la documentation de shiftr.io vous y touverez le code source de base pour interagir avec le broker et le navigateur. 

•  Créer un dossier dans lequel vous allez y mettre trois fichiers: index.html, script.js et style.css
• Prenez le code de la documentation sous exemple browser et faites un copier/coller dans les différents fichiers.
• Tester l’envoi du message lorsque vous appuyez sur le bouton

ARDUINO ET WEB

Présentation 

Il s'agit d’allumer des diodes aux travers du navigateur, recevoir le retour d’un potentiomètre et d’agir avec un bouton poussoir sur la platine arduino.

Le broker étant opérationnel, nous n’agirons plus sur celui-ci.

Index.html

L’objectif est d’afficher deux boutons pour commander des diodes et un retour potentiomètre.

Style.css

Le fichier style.css permet de donner des paramètres d’affichage de la page index.html

Script.js

Script permet de modifier et d'actualiser la page index.html, son langage est le javascript.  

Le javascript a la particularité de modifier la page Web, même après son téléchargement celui-ci est interprété par le navigateur.  

Le premier élément, c’est la connexion au broker ligne 4, il faut renseigner ses identifiants de token

Le second élément: lignes 10 et 11 permettent de souscrire aux différents Topic. 

Le troisième élément: lignes 15 à 69 modifient le contenu des balises ou leurs styles en fonction des  messages reçus .

Exemple 

document.getElementById('led7').innerHTML = ‘ON';

Modifie le contenue de la balise qui porte l’identifiant « led7 » dans la page index.html par « ON ».

 document.getElementById("led7").style.backgroundColor="green";

Modifie le style backgroundColor de la balise qui porte l’identifiant « led7 » dans la page index.html.

Le dernier élément: ligne 71 à ligne 76 permettent de publier des messages au broker au click de bouton. 

Lorsque le bouton est appuyé le message est traité par la fonction de traitement des messages : lignes 15 à 69.

Code source arduino

Le programme est fourni gratuitement en téléchargement https://plaisirarduino.fr/telechargement  

Déclaration des variables pour les entrées / sorties de la commande des diodes et des différentes temporisations.

• Connexion avec les identifiants et mot de passe du token
• Souscription aux Topic

La fonction messageReceived traite toutes les interactions des messages reçus par le broker, elle a pour rôle de commander l’état des différentes diodes.

Dans cet exemple, lorsque la platine reçoit le message 9$Led7, elle met la diode 7 à HIGH

Le setup initialise les entrées / sorties et les différents paramètres nécessaires

La première partie de la fonction Loop renvoie toutes les 5 secondes les paramètres des diodes et ceux du potentiomètre en publiant leurs valeurs.

La seconde partie de loop renvoie les valeurs du potentiomètre, seulement quand celui-ci change de valeur.

Et enfin le traitement du bouton poussoir publie la commande de la diode 7 lorsque celui-ci est appuyé. 

Cet article WEB ET ARDUINO est apparu en premier sur PlaisirArduino.

Il est vrai que l'exploitation d'un afficheur LCD 8bit est gourmand en brochages.
Ainsi le but de ce projet est de récupérer deux entrées supplémentaires, en supprimant les boutons PLUS (+) et MOINS (-), en les remplaçant par un POTENTIOMÈTRE.

Le matériel

• Carte Arduino UNO.
• Un afficheur LCD. 16X2.
• Deux (2) LED -Rouge -Vert.
• Trois (3) résistances de charge de 220 ohm.(pour les boutons hors pull_up).
• 1 bouton poussoir.
• Un potentiomètre de 10k ohm pour l'écran LCD.
• Un potentiomètre de 10k ohm pour l'évolution dans le MENU.

LE SCHÉMA DES BRANCHEMENTS.

Étude de projet.

Toutefois grâce aux précédents projets Menu_Thermostat et  Menu_LCD_commande_LED nous avons vu comment piloter un projet à l'aide d'un MENU et d'un clavier à boutons.

En effet,  vous avez sûrement constaté que l'exploitation d'un afficheur LCD (8 ou 4 bits) utilise déjà 6 entrées au minimum.
De surcroît pour naviguer dans le menu il nous faut trois (3) boutons minimum pour l'exploitation du menu PLUS, MOINS et ENTRÉE.
En somme cela nous fait un total de neuf (9) entrées exploitées rien que pour notre interface.
Ce qui par conséquent mise à part les broches zéro (0) et un (1) ne laisse plus qu'une broche d' entrée/sortie exploitable.
Suivant le schéma des projets précédents; la broche treize (13).

Évolution du menu par potentiomètre.

Il faut donc repenser la sélection des fenêtres et la saisie des paramètres dans le menu. Nous utiliserons donc la valeur de retour d'un potentiomètre  pour incrémenter les fenêtres et la valeur de saisie.

Pour commencer  nous faisons l'acquisition du potentiomètre en divisant par cent sa valeur pour obtenir stabilité en butée du potentiomètre et une valeur de 0 à 10.

Ensuite pour la sélection des fenêtres, nous ajustons la mesure traité avec le nombre des repères de fenêtres par une mise en butée de un (1) à six(6).
Enfin pour la saisie nous ajustons la mesure traité par une mise en butée de un (1) à neuf(9) pour la valeur de chaque chiffre de saisie.

Étant donné que la sélection et la saisie n'utilisent pas les mêmes valeurs, il va donc falloir deux variables distinctes pour chacune de ces deux étapes.

La sélection des fenêtres.

Tout d'abord, la sélection des fenêtres s’effectuera suivant le principe du projet Menu_LCD_commande_LED et sur l'incrémentation de la variable de "selection".

La saisie des données de paramètres.

La saisie des valeurs de paramètres s’effectue comme pour le projet cité ci-dessus avec l'incrémentation de la variable "incremente".

Toutefois par la suppression du bouton MOINS "-" il n'est plus possible de sortir du mode de saisi sans avoir validé une valeur.
Afin de ne pas valider une saisi erroné ou non souhaité nous créons une fenêtre pour confirmer la saisi.

Ce qui change dans la structure.

l’aspect le plus important de cet exemple est que la structure du menu restent sensiblement les mêmes que les projets précédents.
Néanmoins nous avons ajouté une fenêtre de retour sur laquelle un appui sur le bouton ENTRÉE permet un retour à la fenêtre de lecture.

Finalement la principale chose qui change est dans le fait que le menu conserve l'état de sélection actuel en fonction de la position du potentiomètre.
Malgré cela, au bout du compte, nous y gagnons deux entrées supplémentaires !

FIN.

En définitif,  vous avez là un outil d’exploitation compatible avec des projets exploitant un écran LCD.
Vous pouvez à présent créer votre propre menu et opérer une saisie de données à transmettre à votre système. Explorez et amusez-vous à l’adapter à vos projets.

En téléchargeant le sketch « MENU_LCD_SAISI_POTAR » vous découvrirez sans difficultés sa construction ainsi que ses différentes fonctions. Ces fonctions ne contiennent aucune particularité que nous n’ayons pas abordé jusque là, voici donc pourquoi nous ne les détaillerons pas.

MERCI.

Plaisir Arduino.fr

Cet article MENU LCD PAR POTENTIOMÈTRE est apparu en premier sur PlaisirArduino.

• De piloter et faire varier l'intensité lumineuse de trois LED en envoyant des données depuis le moniteur série.
• Connaître d'autres méthodes d'exploitation du moniteur série.
• Avoir la possibilité d'ajuster des variables en temps réel dans son projet sans téléverser.

Avant tout, nous allons avoir besoin de:

• Trois diodes électroluminescentes (rouge)
• Trois résistances de 220 ohms.

Nous brancherons nos diodes aux broches PWM repérées  "~" et prévues pour l’exploitation du signal en MLI.

Notre schéma de branchements.

Comment piloter nos équipements ?

En premier lieu, il nous faut sélectionner la LED que l'on souhaite piloter. Dans notre cas la led1, led2 ou led3.
Puis, il lui appliquer une valeur de pilotage allant de 0 à 255.

Par conséquent, cela nous fait deux étapes. C'est-à-dire la sélection et le pilotage.

Afin de réaliser ces deux étapes, plus précisément, nous utilisons des méthodes de la classe Serial. 

De sorte que la sélection des LED soit claire et simple, nous utiliserons des mots clés propre à chacune d'elles. Soit led1, led2 et led3.
Le pilotage étant, lui, sur une base numérique.

De toute évidence, nous avons deux types de données à traiter.
Une première de type alphabétiques String et la suivante de type numériques int "Integer" ou byte "byte".
Par conséquent, cela nous fait deux étapes d'acquisition. La première pour le mot clé et la seconde pour la valeur de pilotage.

Le programme.

Tout d’abord, le moniteur affiche un message d'ouverture et d'informations puis les diodes s'allument en test.  Les déclarations et configurations sont donc faites.

Tout est prêt pour commencer la programmation.

Premièrement:  L'acquisition des données séries.

Commençons par la première donnée utile qui est un mot clé envoyé depuis le moniteur.

Tout d'abord, avec la méthode Serial.available(); nous savons recevoir des données  pour les lire.-
Mais contrairement au tutoriel "Moniteur série", pour les mots clés, nous utilisons la méthode Serial.readString(); afin de lire le buffer sans avoir à recomposer les données de type String.

Deuxièmement:  Le traitement des données séries reçu.

le mot clé.
Ensuite il va falloir reconnaître le mot clé envoyé depuis le moniteur série par rapport aux mots clés prédéfinis dans un tableau de type String.

De la même manière que pour deux variables, il vous suffira, dans une condition d'exécution if(), de réaliser une comparaison de la donnée série par rapport aux mots clés du tableau.

En outre, de la condition exécution l'utilisation d'une boucle for() est utile pour scruter le tableau et comparer la donnée reçue.

Puis une  fois la condition d'exécution vrai, on valide la donnée  et on stoppe la boucle de scan par un break.

Les données de pilotage.

Finalement, nous utilisons la donnée de pilotage  afin de sécuriser les systèmes.
Dans une condition d'exécution, nous contrôlons la donnée reçue pour interdire l'envoi d'une valeur de pilotage, aberrante.

Aussi pour les données de pilotages de type int, nous utilisons la méthode Serial.parseInt(); qui permet de réaliser la lecture des données séries numériques et de les convertir en type int.

Troisièmement: L'exécution du programme.

En ce qui concerne l'exécution programme. Comme nous l'avons vu plus haut -Comment piloter nos équipements ?- il y a deux étapes à réaliser. Afin d'exécuter nos deux modes d'acquisition, nous utilisons switch() et une variable de transition "etape" permettant le passage d'une étape à l'autre.

Quatrièmement: Le paramétrage du moniteur.

Comme vu lors du tutoriel "Moniteur série", il ne faut pas oublier que, les données sont traitées sur la présence ou l'absence de saut de ligne et des retours chariot.
N'oublions donc pas de paramétrer le moniteur en mode « Pas de fin de ligne » .
Nous pouvons à présent tester le programme et envoyer des valeurs.

Grâce à ce programme en exemple, il vous est possible de modifier est de piloter en temps réel sans avoir à continuellement téléverser.
Ainsi, vous interagissez directement avec le système de votre projet. Cela est très utile pour des phases de tests et d'ajustements de projet. Amusez vous à l'intégrer à vos projets.

Vous découvrirez au fur et à mesure de votre progression qu'il existe d'autres méthodes pratiques pour exploiter le moniteur série.

Pour conclure, téléchargez le programme "Moniteur_serie_pilote" amusez vous à l'intégrer à vos projets. Encore une fois, merci de votre lecture.

Plaisir Arduino.

Cet article Comment piloter depuis le moniteur Aduino ? est apparu en premier sur PlaisirArduino.

Principe de fonctionnement

Ce cours a pour objectif d'appréhender le module RFID. Le téléchargement du code source vous permettra de mettre en application la modification de chaque block.

Le module RFID détecte des badges ou des cartes magnétiques à moins de 10 cm. Le passage d’un composant magnétique permet de lire l’identifiant de l'UID de la carte, ainsi que les données enregistrées.

Par principe, chaque carte RFID dispose de son propre UID.

De plus, les cartes ou tags répondent à une fréquence. Les tags, les plus répandus, sont à une fréquence de 13,56Mhz.

Le contenu est divisé en plusieurs secteurs, subdivisé en block et encore en données.

Certaines cartes disposent du block 0 verrouillé, c’est-à-dire non modifiable. Celui-ci contient essentiellement l’identifiant unique "UID". 

Sur le marché, vous pouvez avoir des cartes dont le cluster UID est modifiable. Dans le cadre de ce tutoriel, j’utilise des cartes dont l’UID est modifiable à 13,56Mhz et d’une capacité mémoire de 1 Ko.

Schéma du module RFID RC522

Le montage du module RFID se compose de 7 fils :

• RST/Reset   RST       —>   Pin 9 Arduino
• SPI SS      SDA(SS)  —>    Pin 10 Arduino
• SPI MOSI    MOSI      —>  Pin 11 Arduino
• SPI MISO    MISO     —>    Pin 12 Arduino
• SPI SCK     SCK      —>    Pin 13 Arduino
• GND 
• VCC 3,3V !Attention pas 5V

Lire le contenu d’un module RFID

Maintenant que nous avons vu à quoi ressemble le contenu d’un tag RFID,  passons à la pratique.

Premièrement, ajoutons la librairie MFRC522 

A ce stade, les exemples de la librairie MFRC52  permettent de lire et d’écrire (attention !!! le fait d’approcher votre carte du module en écriture modifie les informations contenues dans le tag et la rend inutilisable) . 

Voyons le résultat de l’exemple « dump info » qui est sans danger.

Exemple dump info:

Cet exemple nous donne toutes les informations de notre carte RFID . On y trouve la capacité mémoire, l’UID, les secteurs, les adresses et les données.

Vous constaterez que les données sont sous formes hexadécimales, c’est un langage  machine qui nous est incompréhensible au premier abord.

Ecrire du contenu dans le module RFID

Pour écrire une information dans le tag, il est nécessaire de définir trois choses : le secteur , l’adresse , et les données.  La modification des données se font par ligne de 16 octets.  

Nous pourrions mettre n’importe quelles données hexadécimales. En ce qui me concerne, j’ai fait le choix de faire correspondre les données, au traditionnel tableau ascii. En effet , ce langage se montre  particulièrement utile pour l’exploitation des informations par la suite.

Lançons l’exemple ReadAndWrite (Attention!! Modification du tag).

L’exécution de ce sketch a pour effet de modifier le secteur 1, le block 4 et les 16 octets hexadécimales. 

En relisant le contenu, les données à cet emplacement, vous avez 0x01, 0x02, 0x03, 0x04,0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0xff, 0x0b,0x0c, 0x0d, 0x0e, 0x0f

Retour d'expérience

Suite aux deux "programmes exemples" que je vous ai présenté, vous êtes capable de lire et d'écrire sur une carte RFID.

Dans mon expérience de l'utilisation de la carte RFID, j'ai rendu inutilisable une paire de cartes en voulant tester les différents exemples de la librairie.

Ce que j'ai constaté:

• Ne pas modifier le dernier block d'un secteur. Exemple: secteur 1 block 7, secteur 2 block 11 etc...
• Ne pas tester n'importe quel code sans le comprendre .

Cet article RFID avec Arduino est apparu en premier sur PlaisirArduino.

Le but de ce projet est de réaliser un thermostat et de donner quelques notions de gestion de ce type de projet.

LE THERMOSTAT.

Un thermostat est principalement utilisé pour surveiller un environnement thermique ambiant et pour piloter un système de chauffe.

Il se compose principalement d'une sonde de température, d'une sortie de pilotage,d'un clavier de boutons et d'un afficheur.

LE MATÉRIEL.

Un potentiomètre qui simulera la variation de température.
Une LED de couleur verte branchée en sortie qui simulera l'activation de notre système.
Une autre LED de couleur rouge branchée en sortie qui simulera l'activation d'un défaut système.

Ci-dessous la liste du matériel utilisé:

• Une carte Arduino.
• Un afficheur LCD . 16X2.
• Deux (2) LED Rouge et Vert.
• Trois (3) résistances de charge de 220 ohm.
• Trois (3) boutons poussoirs.
• Deux (2) potentiomètres de 10k ohm.

LE SCHÉMA.

NOTRE CAHIER DES CHARGES.

Avoir un menu capable de :

1. Afficher la température actuelle.
2. Indiquer la tendance de la température sur un temps défini.
3. Enregistrer les températures minimum et maximum.
4. Signaler les alarmes de dépassement seuil MINI et MAXI et les remettre à zéro.
5. Modifier les valeurs de paramètres de seuils.
6. Piloter des sorties en fonction du traitement signal.
7. Retourner l'état du système.

ÉTUDE DU PROJET THERMOSTAT.

1 -La température.

Dans un premier temps pour connaître la température ambiante d'un milieu, il nous faut faire l’acquisition d'un signal analogique de la sonde de température.

2 - La tendance.

L'indication de tendance d’évènements fonctionne suivant le principe d'enregistrement cadencé sur un temps défini. Une comparaison dans le temps de la valeur N-1 est faite avec la valeur actuelle. En fonction de l'écart négatif, positif ou nul, on affichera un symbole à  l'écran LCD à l’occurrence une flèche allant vers le bas , le haut ou double pour une valeur stable.

L'affichage de la tendance de la température ambiante permet une surveillance active de notre application. C'est un petit plus à notre thermostat.

3 - Le MINI/MAXI enregistré.

Nous souhaitons également avoir une surveillance des évènements du système. Pour cela, nous intégrons l'enregistrement des mesures de températures maximum et minimum.
L'initialisation des ces valeurs doit également être possible par une commande à l'afficheur LCD.

4 - Les alarmes et leurs signalements.

Les alarmes seront activées lors du franchissement des seuils MINI et MAXI définis en fonction de l'application par l'utilisateur.

Un thermostat dédié à la surveillance d'une application a pour but de signaler et ou de piloter un système pour réaliser une action palliative lors de dysfonctionnements.
Dans notre cas, les alarmes seront signalées par l'allumage de la LED rouge mais également par l'activation d'un pointeur à la fenêtre des mesures MINI et MAXI des températures.

De toute évidence, une alarme qui signale un dysfonctionnement doit par conséquent être maintenue.
L'alarme sera donc acquittée seulement par l'action de l'utilisateur.

5 - La modification des seuils de températures.

Comme cités ci-dessus, nous avons déjà deux seuils connus: le MAXI et le MINI.

En plus des seuils MINI et MAXI, notre système doit être activé et désactivé à des températures définies en fonction de l'application et par l'utilisateur.
D’ailleurs, la température définie pour la mise à l’arrêt d'un système de chauffage est ce que l'on appelle la consigne.

Tout d'abord,  le point de consigne:
C'est un seuil auquel un système doit maintenir une application à un état ou une grandeur physique de fonctionnement. Dans notre cas, c'est une température mais cela peut être un débit, une pression, une position ou une vitesse.

Pour notre projet, nous l’appellerons seuil d' "ARRÊT".

En suite, le seuil de "MARCHE":
A l'inverse du point de consigne, nous avons le seuil MARCHE qui va définir la mise en service du système.

Ils doivent être ajustés et adaptés à volonté suivant la configuration et la demande d'exploitation des projets.
Par conséquent, il va nous falloir la possibilité de modifier ces seuils via l'afficheur L.C.D.

Attention! Les seuils de températures ne doivent pas être croisés.

C'est-à-dire que le seuil d ’ARRÊT doit toujours être supérieur au seuil de MARCHE.

Ce qui implique également que le seuil MAXI doit toujours être supérieur au point de consigne. Mais aussi que le seuil MINI doit toujours être inférieur au seuil de MARCHE et inversement.

Donc, il va nous falloir contrôler les valeurs lors de la saisie pour que ces conditions soient respectées.

6 - Les sorties.

L' activation des sorties est le résultat  du traitement du signal en fonction des seuils définis par le projet.
Dans notre cas, nous avons deux sorties. L'une pour le pilotage du système matérialisé par une LED verte et l'autre pour le signalement d'alarmes par une LED rouge.

Conformément à notre projet, le pilotage de la sortie se fera en mode tout ou rien.

7 - Le retour d'état.

Étant donné que  l'activation des sorties définit l'état de fonctionnement du système, nous en profitons donc pour retourner cet état MARCHE ou ARRÊT par l'affichage d'un message STOP ou RUN à l'afficheur L.C.D. Sont également affichés les états d'alarmes.

Nous avons à présent réuni  toutes les particularités de notre projet pour passer à l'étape de programmation du menu.

Le menu du thermostat.

Plus concrètement, nous allons maintenant étudier le menu qui nous permettra de visualiser la température ambiante ainsi que sa tendance et qui nous permettra de saisir les valeurs de seuils.

Suivant le cahier des charges, notre menu est composé d'une fenêtre de LECTURE pour la visualisation de la température , l'état du système et sa tendance.

Somme toute, le projet est simple. Mais la complexité réside dans la conception du MENU.

Premièrement, il faut penser la structure de notre menu. (Sur une feuille de papier !!)
Voyez ci-dessous la structure qui va nous servir à la construction du programme MENU.

Ci-dessous la structure du menu.

PARAMÉTRAGE ET VISUALISATION DE DONNÉES.

Un appui sur ENTRÉE affiche les fenêtres de SÉLECTIONS de PARAMÈTRES à faire défiler par un appui sur le bouton PLUS(+).
Un second appui sur ENTRÉE permet la SAISIE d'une valeur au paramètre sélectionné.
Ensuite, à la fin du processus de saisie,  un appui sur ENTRÉE valide la saisie et retourne le menu à la fenêtre de LECTURE.

De plus, s'ajoutent deux fenêtres supplémentaires aux paramètres .
Une fenêtre pour la visualisation des températures MINI et MAXI mesurées et la suivante de de remise à zéro des alarmes et des mesures MINI / MAXI.

En outre, un appui sur le bouton MOINS (-) permet un retour à la fenêtre de LECTURE depuis les positions de SÉLECTION.

D'autre part, un retour systématique à la fenêtre de lecture sera effectué si aucune action au clavier n'est détectée pendant un certain temps.

SIGNALISATIONS LCD.

Lors d'une alarme, celle-ci sera signalée par l'allumage de la LED rouge mais également via l'affichage LCD.
Un pointeur d'alarme sous forme d'une flèche sera visible à la fenêtre des enregistrements de températures mini et maxi.

La fenêtre RAZ est prévue pour l’acquittement des alarmes mais aussi pour initialiser les valeurs mini/maxi enregistrées. Ce qui notamment effacera aussi le pointeur d'alarme.

LE PROGRAMME.

Dans le cas d'un MENU L.C.D., chaque action sur un bouton sélectionne un CAS particulier d'affichage.
Notre programme se basera donc essentiellement sur l'application de switch().

LE CLAVIER.

Tout d'abord, le clavier sera géré par une fonction nommée "boutons()" qui retournera les états d'activation de chaque bouton.

L'AFFICHAGE DES FENÊTRES.

Pour commencer, il est  à noter qu'un affichage à répétition de boucle sur un afficheur LCD n'est pas conseillé, surtout si l'on effectue un rafraîchissement d'écran. ("clear()")
Par conséquent, nous avons fait en sorte que l'affichage ne s'active qu'une seule fois.
Pour cela, nous "verrouillons" les fenêtres en effectuant un conditionnement d’exécution des cas par les appuis de boutons.
Une variable nommée "fenêtre" servira de "verrou" mais également de repère pour la sélection de chaque CAS de FENÊTRES.

Aussi, nous faisons le choix d'utiliser une table de données, de type "String", contenant les noms de paramètres afin d'activer un affichage  standard via une fonction. Ce qui permet d'éviter la répétition des lignes de codes similaires.

LA SAISIE DE VALEUR AUX PARAMÈTRES.

Comme nous l'avons évoqué dans l'étude de projet, nous effectuons la mise en butée de la saisie (+/-1) en fonction des valeurs voisines respectives à chaque paramètre.

En revanche, lors d'une saisie, contrairement à l'affichage standard qui n'est activé qu'une seule fois;  une actualisation constante de la valeur est nécessaire.

LES DONNÉES PROGRAMMES.

Afin de manipuler plus facilement les données et leurs affichages respectifs,  nous utilisons deux tableaux.
Ces tableaux contiennent  les valeurs de paramètres de chaque seuil et leurs noms respectifs. Ces données sont organisées en fonction de leur position d'affichage.
C'est-à-dire que la donnée du tableau des valeurs de seuils correspond à la donnée du tableau du nom du seuil.

Par exemple l'index 2 du tableau "nom_parametres[2]" qui contient "MARCHE" correspond à la valeur d'index 2 au tableau "parametres[2]" qui contient 25.(par défaut ).

L'index 0 du tableau "parametres[0]" est utilisé pour le chargement de la valeur signal.

PRÉSENTATION DU MENU THERMOSTAT.

En définitif,  vous avez là un outil d’exploitation compatible avec des projets exploitant un signal analogique avec un écran LCD.
Vous pouvez à présent créer votre propre menu et opérer une saisie de données à transmettre à votre système. Explorez et amusez-vous à l’adapter à vos projets.

En téléchargeant le sketch « MENU_THERMOSTAT_LCD » vous découvrirez sans difficultés sa construction ainsi que ses différentes fonctions. Ces fonctions ne contiennent aucune particularité que nous n’ayons pas abordé jusque là, voici donc pourquoi nous ne les détaillerons pas.

MERCI.

Plaisir Arduino.fr

Cet article Thermostat créé avec un LCD et Arduino. est apparu en premier sur PlaisirArduino.

L'objectif de ce cours va être de présenter la commande de diode rouge, verte et bleu grâce à un navigateur Internet.

Présentation du shield ethernet.

Le Shield Ethernet utilise la broche 4 pour faire appel à la carte SD et les broches 10/11/12/13 pour l’usage du shield.

La Carte SD

La carte SD contient la page HTML que nous avons nommé "pagehtml.txt".  Vous avez le code complet en téléchargement.

Partie 1

Le programme se compose de deux parties, la phase d'initialisation qui comprend les librairies, les variables, l’instanciation ethernet et le setup.

Partie 2

La deuxième partie comprend la fonction loop qui englobe les quatre fonctions suivantes: MonURL, traitementurl,  ecritureSD et MonHTML.

MonURL

Le rôle de "monURL", est de créer une chaîne de caractères avec la variable "Mydata".  Afin qu'à chaque connexion d'un client, nous captions ses informations URL.

TraitementURL

Maintenant  que avons l'url de l'utilisateur, nous vérifions que celle-ci contient B2=1, B3=1 etc... . Dans la mesure où il y a une correspondance, on agit sur la broche en question.

EcritureSD

La fonction ecritureSD, voit son utilité dans le fait de mémoriser l’état des valeurs pour les boutons radio.

A chaque fois où un utilisateur renvoie l’information d'allumer des diodes, cette information doit être mémorisée au niveau de la page html. Le but est donc de définir si la LED rouge est égale à 1, on inscrit  la valeur checked. Car comme vous le savez, les deux boutons radio ne peuvent être actifs en même temps.

MonHTML

Restitue le contenu du fichier "pagehtml.txt".

Cet article Shield ethernet est apparu en premier sur PlaisirArduino.

La principale fonction d'un afficheur LCD est de renvoyer des informations à l'utilisateur d'un système. Mais il peut également donner la possibilité de saisir des données pour piloter ce système. Prenons l'exemple d'un thermostat d'ambiance. A l'aide d'une commande de boutons, on peut saisir, la consigne de température voulue dans une pièce.

L’intérêt de ce projet réside dans le fait qu'il n'est plus utile d'accéder au programme source pour modifier une valeur et de téléverser pour agir sur le système. Ainsi le pilotage du système est rendu, de toute évidence,  accessible à des utilisateurs lambdas.

Le but de notre projet va être, donc au travers d'un programme exemple que nous vous proposons, de faire varier l'intensité lumineuse de plusieurs LED (2) via un afficheur LCD  et un clavier de boutons PLUS (+), MOINS (-), ENTRÉE.

1 - Le matériel.

• Une carte Arduino.
• Un afficheur LCD . 16X2.
• deux (2) LED Rouge et Vert.
• Trois résistances de charge de 220 ohm.
• Trois Boutons poussoirs.
• Deux potentiomètres de 10k ohm.

 2 - Les branchements.

Étude du projet.

D'abord nous avons trois boutons poussoirs. PLUS (+), MOINS (-) et ENTRÉE.
Évidemment, les boutons poussoirs serviront à naviguer dans un menu et c'est aussi  grâce à eux que nous pourrons saisir une donnée puis l'affecter à l'une des LED.
La fonction clavier() contrôle l'état des boutons. et renvoie les actions de chaque bouton à sa variable de retour nommé "action".

Pour affecter une donnée à l'une des LED, il faut avoir la possibilité de les sélectionner. Alors il va de ce fait falloir créer un menu de sélection.
La fonction menu() activera l’affichage de chaque fenêtre en fonction des actions sur les boutons et par conséquent elle aura en paramètre la variable de retour de la fonction clavier().

En clair, le plus gros du travail réside dans la conception du menu. Car gérer un afficheur LCD et deux LED nous savons le faire.
Consultez au besoin le tuto l'afficheur LCD, comment l'exploiter ?.

Mais avant de passer au menu, il faut tout d'abord s'intéresser à deux points essentiels concernant la donnée. L'unité et sa grandeur d'exploitation.

1 L'unité de la donnée.

Effectivement il y a plusieurs façons de piloter un système.
Prenons pour exemple des systèmes qui nécessitent l'utilisation de données en degrés Celsius, en degrés angulaire, en mètres, ou autres.

En partant de notre exemple, le pourcentage % est l'unité la plus parlante et la plus simple à exploiter pour un utilisateur aux commandes d'un système de variations de puissances. Cette unité est donc préférable si plusieurs utilisateurs ont accès au système.

2 Grandeur de la donnée.

En fonction du système, d'autre projets peuvent utiliser des valeurs angulaires allant jusqu’à 180° ou 360°  (servomoteur) , une température ou une distance précise etc... .
Certains projets, en fonction de leurs équipements et de leurs précisions auront besoin d'une valeur de données bien plus grande comme 450mm ou plus.

Il faut souligner qu’une valeur plus grande que la grandeur de la donnée peut compromettre le bon fonctionnement de vos projets.
A l'inverse, une valeur négative ou trop petite peut également être source de problèmes.
En effet, pour assurer un bon pilotage et sécuriser votre système  il ne faut pas dépasser la grandeur et la valeur minimale imposées par le système.

Par conséquent, il faut limiter la valeur de saisie entre ces deux bornes mini et maxi.
Ainsi une personne non averti ne pourra pas saisir une donnée aberrante pour le système.

Dans notre cas, pour piloter les LED nous utilisons une modulation de puissance allant de 0 à 255 points. La grandeur maximale pour notre donnée est donc de 255 et la valeur minimale de 0. Au delà de ces valeurs le système réagira de façon non désiré ou aléatoire.

3.La limitation de donnée.

Nous avons différencié deux types de données:

  "Numérique" pour des nombres et  "Pourcentage" pour une valeur en pourcentage.

Numérique.

Pour limiter la saisie d'une valeur numérique chaque chiffre est limité en fonction de la valeur maximum de la donnée  exploitable.
Pour notre exemple, nous limiterons la saisie à 255 (PWM). Ce qui revient à contrôler, si le chiffre de la centaine est égale à 2, dans ce cas la dizaine aura pour valeur maximum 5 et de même pour la dizaine, si elle est égale à 5, l'unité aura pour valeur maximum 5.

La donnée en pourcentage.

Étant donné que la valeur de saisie sera préalablement conditionnée, dans le programme source, entre 0% et 100% l'utilisation d'une valeur erronée n'est plus possible.

Il est à noter  cependant, que deux données différentes seront utiles.
En effet dans notre cas, le pilotage à besoin d'une donnée différente de celle de l'affichage.
Il faudra donc opérer une mise à l’échelle vers une valeur adéquate de pilotage.
Soit de 0 à 255 PWM.
Cela implique deux variables différentes. L'une pour l'activation de l'affichage et l'autre pour le pilotage.

La saisie de la donnée.

En bref, si on laisse la possibilité d'une saisie non limitée, nous avons trois modes de saisie.

• Non limité. (Paramètre 0).
• Valeur maximum. (Paramètre 1).
  
• Pourcentage. (Paramètre 2).

Incrémenter une donnée pour des projets nécessitant jusqu'à 360° ou 800 mm serait évidemment un peu long. Par conséquent, il est judicieux d'agir sur chaque chiffre du nombre  composant la donnée.

De toute évidence, en saisissant chaque chiffre, la donnée ne pourra pas être supérieure à neuf (9) ou inférieure à zéro (0). Elle évoluera donc entre ces deux bornes, ce qui nous permet néanmoins, de saisir des valeurs allant de 0 à 9999 au besoin.

La  fonction saisie (mode,X,Y,Z) est là pour contrôler la saisie de la donnée.
Elle a comme paramètre la variable "mode" pour la sélection du mode de saisie et pour chaque chiffre X, Y et Z,  la valeur maximum de la donnée.
En fonction du mode de saisie choisie, elle adapte la grandeur de saisie pour chaque chiffre de la donnée. Elle met à l’échelle ou recompose la donnée saisie puis la charge pour l'affichage et renvoie la valeur de pilotage.

• En mode pourcentage:
  La saisie est immédiate. Pour apporter plus de souplesse à la saisie,  la correction de donnée est réalisée depuis la valeur actuelle.
• En mode numérique:
  Par contre, la saisie se fait au troisième et dernier chiffre saisi. La donnée est ensuite chargée dans une variable prévue pour le pilotage et l'affichage de la sélection. Dans notre cas, c'est l'unité du nombre 255. La correction de données reprendra depuis zéro.

Le programme sera donc exploitable en fonction du mode de saisie choisi et de la grandeur de la donnée.

Note : libre à vous de modifier la valeur maxi de la donnée et l'affichage de l'unité dans le menu.

3.4 Le nombre d'organes à piloter.

Le nombre d'organes à piloter définira le nombre de fenêtre de sélection à créer dans votre menu.

Ici,  nous avons seulement deux LED à piloter.
Vous pouvez bien-sûr en fonction des capacités de votre carte et des besoins de votre projet,  ajouter autant de fenêtre de sélection que vous le souhaitez. Afin de compléter l'exemple nous en avons crée trois de plus.

Nous pouvons, à présent, passer au montage de notre menu.

4 Le menu.

Avant de se lancer dans la programmation d'un menu, il faut avant tout avoir un repère de travail. Ce qui veut dire, penser à la structure et établir un schéma représentatif du menu.

Voici un schéma représentatif de la structure du menu avec les actions utiles pour passer d'une fenêtre à l'autre.

A première vue, une action sur les boutons implique une sélection de fenêtres. A chaque fenêtre est attribuée un numéro. Ces numéros permettent d'activer l'affichage et de  verrouiller une position dans le menu.
Il y a deux "sous fenêtres". La onze (11) permet de verrouiller l'étape de la sélection des LED et la douze (12) permet de verrouiller l'étape de paramétrage.

La fenêtre de sélection "RAZ" est en fait, l’accès à un sous-menu dans lequel, il nous est possible de mettre à zéro toutes les données par la sélection du choix OUI (O) ou NON (N). Voici donc la structure de ce sous-menu "RAZ".

3.2 Les fenêtres.

Pour créer le menu, il faut utiliser la  fonction menu().
Elle permet de générer l'affichage des fenêtres.
L'activation des affichages des fenêtres se fait en fonction des actions sur les boutons et la position actuelle verrouillée dans le menu.
Pour cette raison, la fonction à pour paramètre la variable de retour "action" de la fonction clavier().

Ci-dessous, l'illustration du menu.

Voyons maintenant comment va se dérouler la validation de la donnée.

4 Validation de données.

Durant la saisie en cours, l'actualisation de la valeur se fait dans la boucle principale (loop).

Une fois la sélection validée, la fenêtre de paramétrage est active, on peut alors saisir une valeur, puis la valider. Cette valeur est ensuite affectée à une variable prévue au pilotage de la sélection et à l'affichage.

Pour finir, l'affichage retourne à la fenêtre de lecture. Dans notre exemple, celle de la LED une (1) et  deux (2).

C'est ainsi que le programme LCD MENU se termine !

Partant de cet exemple, vous pouvez piloter d'autres systèmes que des LED. Comme des systèmes  équipés de sondes de température, de servomoteurs ou bien de moteurs à courant continu et bien d'autres.

FIN.

Vous avez là un premier outil d'exploitation d'écran LCD. Vous pouvez à présent créer votre propre menu et opérer une saisie de données à transmettre à votre système. Explorez et amusez vous à l'adapter à vos projets.

En téléchargeant le sketch "LCD_MENU ARDUINO" vous découvrirez sans difficulté la construction des différentes fonctions. Ces fonctions ne contiennent aucune particularité que nous n'ayons pas abordé jusque là, voici donc pourquoi nous ne les détaillerons pas.

Remarque: Il est possible d'utiliser des bibliothèques que vous trouverez sur le net . Mais, ce projet a pour but de faire comprendre et maîtriser les différentes méthodes de base de la bibliothèque <<LiquidCrystal.h>> et l'exploitation d'un écran LCD.
Un tableau string aurait également pu être utilisé pour générer les affichages. Mais pour plus de lisibilité, nous n'avons pas utilisé cette méthode.

Nous vous invitons à nous faire part de vos commentaires et propositions.

MERCI.

Plaisir Arduino.fr

Cet article Créer un MENU – LCD avec Arduino. est apparu en premier sur PlaisirArduino.

Communiquer avec le port série

Pour permettre l'interaction entre processing et arduino, il est nécessaire de connaître le port de communication.

Pour l'arduino, il faut brancher la platine et repérer le port actif pour le téléversement.

Pour processing, il faut afficher la liste des ports actifs sur l'ordinateur et affecter celui qui correspond à l'arduino.

Dans ce cas, c'est le port "COM 6" qui prend pour valeur 0.

Envoyer une donnée par l'arduino 

Deux instructions sont indispensables:

Avec cette base le programme arduino est opérationnel, toutefois la donnée envoyée est toujours la même.

Envoyer une donnée par Processing

Voilà, la donnée 1 est envoyée par le port série à condition de bien mettre une valeur adaptée pour soi dans l'instruction "Serial.list[ ]". Dans mon cas,  c'est "Serial.list[0]".

Traiter la donnée avec Arduino

Les données séries sont stockées dans la variable "val". Il suffit de réceptionner la donnée val et de la traiter.

Traiter la donnée avec Processing

La variable "sb" contient la chaîne de caractère à exploiter dans le programme. Dans ce cas précis, j'ai choisi de l'afficher dans un fond blanc.

FIN

Si vous n'avez pas encore vu la vidéo de processing, je vous invite à la visionner. De plus, le code complet se trouve en téléchargement avec d'autres exemples .

Cet article Processing et port série est apparu en premier sur PlaisirArduino.

Le MAX 7219 est un circuit intégré permettant le contrôle d'afficheur sept segments jusqu'à huit digits et de matrices à leds.

L’aspect le plus important du MAX 7219 est de pouvoir être contrôlé par un bus compatible SPI, QSPI et MICROWIRE. N'utilisant que trois fils pour la communication, il permet ainsi de libérer des sorties de la carte Arduino pour d'autres usages.

Tout d’abord, je commencerai par détailler le fonctionnement  du MAX 7219  à l’aide du "datasheet". Ensuite, je vous proposerai la librairie « SPI .h » et « LedControl.h »  pour l'exploiter dans vos programmes.

Exploiter le DATASHEET.

Le "datasheet" est un document (pdf) fourni par le fabriquant du composant dans lequel nous y trouverons toutes les explications nous permettant son exploitation. Nous nous appuierons donc sur ce document et les tableaux qui y sont représentés. Vous verrez par conséquent, comment lire un "datasheet".

Le format de transmission des données série du MAX 7219

En premier lieu le MAX 7219 utilise un format de transmission sur 16Bits  de D0 à D15 représenté par le tableau ci-dessous.

• Les huit premiers bit de D0 à D7 pour des données (data). D0 étant le bit, dit de poids faible (LSB) et D7 le bit de poids fort (MSB).
• Les quatre prochains bits de D8 à D11 sont utilisés pour les adresses (registre).
• Les quatre bits de D12 à D15 restent par contre inexploités.

Ainsi, le MAX 7219 utilise 14 registres de 0xX0 à 0xXF représentés dans le tableau (N°) ci- dessous. Le registre OxXD n’étant pas exploité.

Tableau des adresses de registre

Commençons par examiner les registres « «DIGIT0 » à « DIGIT7 » représentés en hexadécimale de 0xX1 à 0xX8. En fait, ces huit registres permettent d’affecter une donnée à chaque Digit. Vous observerez qu'il y a aussi des fonctions spécifiques.

Les fonctions du MAX 7219.

1) La fonction "decode mode" - "0xx9".

Commençons par  le registre "decode Mode" "0xX9", il permet d'activer le code "B font". Le code B s'active sur les digits de votre choix en y inscrivant un bit à 1. Le tableau 4 ci-dessous, nous donne quelques exemples d'activation du  "decode mode". 

Il suffit de prendre pour exemple la deuxième ligne du tableau pour comprendre comment activer le code B. L'activation à 1 du digit 0 de l'afficheur par la donnée 0x01(héxa.) implique que seul le digit 0 sera en code B. Les sept autres digits à 0 de l'affichage ne seront pas gérés par le code B.

Par exemple, si l'on souhaite activer le code B seulement au digit quatre (4), cela nous donnera en binaire et respectivement au tableau ceci: 0001 0000 soit en hexadécimale 0x10. Nous avons donc la donnée utile à renseigner au registre "decode mode" "0xX9" pour activer le code B au digit 4 "D4". Bien-sûr, vous remarquerez que cette donnée est la suivante après 0x0f.

Qu'est-ce que le "code B" ?

Pour comprendre le code B, il faut tout d’abord savoir que c'est une fonction interne au MAX 7219 qui décode les données d'affichage selon un tableau prédéfini et représenté ci-dessous.

Plus précisément ce tableau nous montre comment, en fonction du registre appelé correspondant à un caractère , le MAX 7219 va activer les segments pour afficher les chiffres et caractères inscrits dans le tableau du code B .

Ainsi, chaque donnée d'affichage d'un caractère présent dans ce tableau sera systématiquement décodé, si le mode code B est activé au digit piloté pour l'affichage de la donnée qu'il reçoit .

Prenons le cas de l'envoi de la  donnée du chiffre quatre (4) "0x04" à afficher au digit 0 et activé en "decode Mode", tous les segments correspondant au registre du chiffre 4 seront activés pour afficher 4. Soit les segments B,C,F et G sur l'afficheur sept segments. Comme indiqué par le tableau 5.

A l'inverse, si "décode mode" n'est pas activé, seul le segment E de l'afficheur va s'allumer. Pourquoi ? Car la valeur "0x04" vaut en binaire 0000 0100 et que dans ce cas le MAX 7219 décode l'affichage suivant un mode binaire. On trouve ici un exemple important, à savoir que sans "decode mode" chaque segment est piloté individuellement en fonction du bit à 1. Le tableau 6 ci dessous représente la correspondance des huit segments via les huit bits.

En fait "decode mode" nous simplifie la tâche de façon à ne pas traiter en binaire l'affichage d'un chiffre. Ce qui impliquerait l'envoi de huit données de huit bits les unes après les autres pour piloter chaque segment. Il faut reconnaître que cela serait fastidieux.

En conclusion,  il est possible d'afficher des symboles ou caractères comme le moins "- "ou un "C" en désactivant "decode mode" au digit de notre choix.

2) LA FONCTION "intensity" - "0xXA"

Abordons à présent le registre "intensity" "0xXA". Il permet de définir l'intensité lumineuse de l'afficheur. En fonction du tableau  7, ci-dessous, il peut avoir seize (16) données, sur quatre (4) bits, possible de "0xX0" à "0xXF" (hexa.) allant du plus faible éclairage au plus fort.

LA FONCTION "scan limit" - "OxXB"

Passons ensuite au registre "scan limit" "OxXB" Il a pour rôle de définir le nombre de digits que l'on souhaite exploiter de digit0 à digit8. En fonction du tableau 8 ci-dessous, il peut prendre huit (8) données sur trois (3) bits allant de 0xX0 à 0xX7 sélectionnant ainsi les digits de droite à gauche.

Il faut souligner que le digit 0 sera toujours le minimum configurable et à juste titre, car il ne serait pas logique d'utiliser cette fonction pour une extinction générale alors qu'une fonction de ce type existe.

3) LA FONCTION "shutdown" - "OxXC".

Le registre "shutdown" "OxXC".  Il permet d'allumer ou d’éteindre l'afficheur. Suivant le tableau trois (3) ci-dessous? il ne prend que deux (2) données sur un (1) bit soit "0xX0" ou "0xX1". A zéro (0) "0xX0" l'afficheur est éteint.

4) LA FONCTION "Display test" - "0xXF"

Et enfin, le registre "Display test" "0xXF", il permet de tester l'afficheur en activant toutes les leds de l'afficheur. En fonction du tableau dix (10)  comme "shutdown", il ne prend que deux (2) données sur un (1) bit soit "0xX0" ou "0xX1". A un (1) le mode test de l'afficheur est activé.

Cependant, il est à noter que le mode test reste activé tant qu'une donnée de désactivation "0xX0" n'est pas renvoyé au registre "0xXF".

Concrètement, nous venons de passer en revue les fonctions de registre ainsi que leurs données d'exploitation.

Mais nous ne savons toujours pas comment les transmettre au MAX.

L'ENVOI DES DONNÉES.

Avant propos: Les données transmises.

Dans nos programmes, il va falloir remplacer le "X" majuscule, dans les données des tableaux, par le chiffre ou la lettre correspondant à la bonne donnée hexadécimale.

Prenons le cas de la donnée "0xX6". En premier lieu, regardons les deux premiers "caractères" "0x", ils indiquent que la donnée et de type HEXADÉCIMALE. Voyons ensuite les deux prochain caractères "X6". Ces derniers sont la transcription hexadécimale d'une donnée en bits. Hors le format Hexadécimale n'accepte pas le terme "X" il va donc falloir le remplacer. Mais par quoi ?

Pour le savoir, il suffit d'utiliser la calculette du "PC" en mode programmeur sur "hexa" et "octet" et de reprendre les bits du tableau, en l’occurrence le sept (7), en cliquant sur les bits affichés en calculette. Avec 0000 0110 on trouve 6, ce qui nous fait "06" car ce format s'écrit sur deux caractères et le premier a par défaut 0, si il n'est pas affiché.

A partir de là "0xX6" devient "0x06".

Toutefois, il sera possible de l'écrire simplement par zéro "0 ou un "1" lorsque la donnée n'est que sur un (1) bit.

Le format d'envoi.

Avant tout chose, elles doivent respecter ce que l'on appelle un format d'envoi. Et c'est donc dans vos programmes que ce format devra être respecté.

Nous venons de voir précédemment qu'il fallait renseigner une adresse et sa donnée pour activer la fonction d'un registre. Il nous faudra donc les envoyer toutes les deux.

Considérons une fonction de transfert de données constituée des deux paramètres utiles "adresse" et "data". (data = données en anglais).

• void transfert(adresse, data);

Pour une compréhension aisée, prenons par exemple, la fonction "Display test" qui a pour adresse "0xXF",  si l'on souhaite l'activer, il faut donc  inscrire "0xX1" comme donnée.

En conclusion, cela nous donne en paramètre de fonction.

• void transfert(0x0F, 0x01); //Transfert des données.

La fonction transférera de notre carte Arduino vers le MAX7219,  les données selon le protocole choisi via le port série. Dans notre cas, c'est le SPI que nous utiliserons.

LA COMMUNICATION

LE S.P.I.

Le Max 7219 peut fonctionner avec plusieurs protocoles de communication bus. Mais dans ce tutoriel, nous utiliserons et ne parlerons que du protocole de bus SPI qui transmet les données de la platine Arduino vers le MAX 7219.

Qu'est ce que le SPI "Serial Peripheral Interface" ? C'est une communication sur le principe du maître-esclave. Ce qui veut dire que la transmission des données ne se fait que dans un seul sens du maître vers l'esclave, donc la platine Arduino représente le maître et le MAX 7219 l'esclave. Plusieurs esclaves peuvent être reliés à ce bus série et seront sélectionnés pour réception de données via une ligne prévue à cet effet.

LA LIAISON SPI

Ci-dessous,nous avons le schéma de câblage de la liaison série entre la platine Arduino et le MAX 7219.

On observe trois liaisons:

1. 1. MOSI qui signifie "Master Output Slave INput" est une broche de sortie vers DIN qui est l'entrée de traitement des données série.
   2. I/O est une sortie vers LOAD (CS) qui est l'entrée d'activation de chargement de données.

1. SCK est une sortie vers CLK qui est l'entrée d' horloge série.

Le choix des différentes broches pour la liaison SPI ne s'est pas fait au hasard. Elles ont été définies par la configuration matérielle de la carte Arduino en fonction du mode SPI. Pour le savoir, il faut consulter la documentation de la carte Arduino pour le mode SPI.

Il existe d'autres broches, de type mâle, facilement reconnaissable pour installé cette liaison.

Premièrement la broche onze (11) MOSI configurée en mode sortie va envoyer les données sous forme de suite de bit zéro(0)-un(1).

Deuxièmement la broche dix (10) I/O configurée en mode sortie, activera le chargement des données dans le MAX.

Et troisièmement la broche treize (13) SCK configurée également en mode sortie, elle synchronisera et cadencera la transmission des données.

Voici la représentation schématique de la transmission au niveau du MAX7219..

C'est ainsi que se passe la transmission en fonction de l'état de chaque entrée du MAX. Vous constaterez qu'il y a aussi DOUT qui est une entrée utilisée pour connecter en série plusieurs MAX7219 ou MAX7221 mais nous ne l'utiliserons pas.

En résumé, la condition de fonctionnement de ce circuit dépend de l'état bas LOAD (CS), de l'envoi des données par MOSI et de leur synchronisation par SCK. Ce schéma illustre bien la transmission des données du  bit de poids fort D15 vers le bit de poids faible D0.

L'exploitation du bus SPI

Tout d’abord pour exploiter le MAX, il va nous falloir configurer notre port série SPI à l'aide de paramètres. Tout comme nous le faisons pour exploiter le port série du moniteur avec la fonction Serial.begin();.

Sauf qu'à la différence du port série moniteur, cela va se faire au travers d'une librairie incluse dans l'IDE de Arduino. Cette librairie s'appelle <SPI.h>

Dans le programme, interviennent plusieurs instructions qu'il va être nécessaire de comprendre.

Les instructions à connaître

Cette instruction indique que nous incluons la librairie SPI.

SPISettings est utilisée pour configurer le port SPI, il prend successivement trois paramètres:

• • La vitesse de transmission des données.

• • L'ordre d'envoi des données.

• Le mode d'envoi.

Initialise le bus SPI en utilisant les données  de SPISettings dans notre cas TransferMax7219 .

Transfert des données sous un format  de un (1) octet soit huit (8) bit.

La fonction de transfert de données

Cette tâche étant répétitive, nous avons du créer une fonction de transfert pour dialoguer aisément avec le MAX 7219 dont on fait abondamment usage dans le programme.

La fonction prend deux paramètres en considération: le registre auquel on souhaite s'adresser et  la valeur de la donnée.

Exemple:

Prenons le cas de l'exemple illustré ci-dessus. On fait appel à la fonction Trsf7219 pour transmettre au registre 0x0A « intensity » la donnée 0x06, soit la valeur 13/32. Ce qui a pour effet de modifier la luminosité de l’afficheur.

Vous savez à présent exploiter l'utilisation des données et leur transmission vers le MAX via la communication SPI. Néanmoins, il existe un moyen plus simple de transférer des données vers le MAX. Ce moyen est une librairie que l'on appelle <LedControl.h>

Utilisation de LedControl

LedControl  est une librairie simple qui offre des fonctions simplifiées de transfert de données vers le MAX7219 rendant ainsi la programmation d'un afficheur sept segments ou d'une matrice plus souple et conviviale. Elle utilise des fonctions sous forme de  texte bien documenté et qui  permettent de réaliser de nombreuses choses.

Les fonctions de bases

Après avoir téléchargé la librairie <ledcontrol.h>, il est nécessaire de l'inclure au programme.

Ci-dessous LedControl est déclaré par une instance d'un objet et appelé "septSegMax" dans notre programme. Cette fonction prend trois (3) paramètres, définis par le câblage de la platine Arduino et un (1), la dernière valeur correspond  au nombre de contrôleur présent sur le bus.

L'objet "septSegMax" servira donc à faire appel aux fonctions fournies par <LedControl.h>.

• Le premier paramètre définit la broche 10 de l'Arduino comme étant LOAD CS
• Le deuxième paramètre définit la broche 13 de l'Arduino comme étant CLK
• Le troisième paramètre définit la broche 11 de l'Arduino comme étant le MOSI
• Le dernier paramètre correspond au nombre de MAX7219 utilisé. Ici un (1).

Voyons enfin les fonctions de <LedControl.h>

La fonction shutdown();

Cette fonction permet d'allumer ou d’éteindre le MAX 7219. Si la valeur est false, le circuit fonctionne normalement et à l'inverse, true le circuit est éteint. Vous constatez de toute évidence que les registres précédemment utilisés ont été remplacés par des fonctions de sorte que leurs noms soient évocateurs à rôle. Dans notre cas, shutdown(paramètre1, paramètre2 ); il faut reconnaître que cela est bien plus simple.

La fonction setIntensity();

Vous l'aurez deviné cette fonction permet de définir l'intensité lumineuse de l'afficheur en 16 valeurs différentes; 15 étant notamment  le maximum représentant le nombre de données possible que l'on a vu dans le tableau sept (7).

La fonction clearDisplay();

Cette fonction éteint l'afficheur et supprime toutes les données précédentes.

Schéma de montage

Schéma Afficheur Sept Segments

Maintenant pour utiliser le Max 7219, nous allons faire un montage type avec deux afficheurs 4 digits,  dont il est possible de câbler qu'un seul afficheur.

Vous trouverez un sketch pour 8 et 4 digits en téléchargement. .

Schéma Matrice 1588BS

Constater que les digits de la matrice correspondent à la cathode commune et que les segments à l'anode commune, ceci inverse l'utilisation de la librairie LedControle où les colonnes correspondent aux segments et les digits aux lignes.  Après avoir tester plusieurs montages celui-ci a été le plus fonctionnel.

Cet article MAX 7219 est apparu en premier sur PlaisirArduino.

Introduction.

Le but de ce projet  et d'envoyer et recevoir des données au moniteur série. Pour cela, seule une carte arduino nous est utile avec un cordon USB.

Lançons le moniteur série et configurons le.

Puis dans le compilateur, configurons le débit de transmission de la carte Arduino.

Nous avons utilisé la classe Serial. avec la fonction begin(); que nous avons renseigné avec la valeur 9600 baud de transmission. Les deux périphériques fonctionnent à la même vitesse.

Recevoir des données.

Voilà, tout est prêt pour la communication. Commençons par recevoir au moniteur des données envoyées par la carte Arduino.Pour cela, nous utilisons la fonction println();

println();

println(); envoie les données vers le moniteur série avec un saut à la ligne . Ici notre donnée est une phrase placée entre les guillemets ces derniers sont utiles pour ce type de données qui sont des caractères alphabétiques. Ci-dessus, nous testons notre communication.

Téléversons notre programme et voyons le résultat.Le moniteur affiche la phrase ! Notre communication est bonne.

Le code A.S.C.I.

Vous constaterez ci dessus que nous avons volontairement négligé les accents sur les «e» . Cela est dû au fait que les caractères alphabétiques sont organisés par un code conventionné, appelé ASCII = American Standard Code for Information Interchange*. Mais les accents sont « exclus » de ce code.

* Il est possible de trouver des extensions de code ASCII qui incluent les caractères spéciaux.

ASTUCE: Pour connaître le code ASCII des lettres majuscules ou minuscules: il faut retenir que "A" majuscule vaut 65 points et que l'écart avec la lettre "a" minuscule est de 32 points, soit "a" minuscule correspond à 65+32 = 97 en code ASCII. Les caractères se suivent dans le tableau.

Afficher le résultat d'un petit calcul.

Nous allons maintenant demander d'afficher le résultat d'un petit calcul avec une phrase complémentaire. Il n'est pas permis de mélanger les types de données dans la fonction print(); il nous faudra donc faire plusieurs appels de cette fonction pour chacun d'eux.
Nous déclarons trois variables. Deux pour le calcul et une pour le résultat. Puis nous réalisons le produit de nos deux variables, pour stocker le résultat dans la variable prévue à cet effet. Nous affichons ensuite une phrase complémentaire suivie de la valeur du résultat et d'un saut à la ligne suivante sous une autre méthode avec l'intégration de \n en fin de phrase.

NOTE:
Dans nos phrases chaque mot est espacé, il est donc possible de mettre des espaces en fin de phrase pour créer un espace avec la donnée suivante.

Téléversons les ajouts et voyons le résultat.L'affichage défile et est illisible a cette vitesse !!! Nous pourrions temporiser cela mais cela ne serais pas une solution confortable.

Exploitation du moniteur pou la mise en forme visuelle de l'affichage.

Il y a deux raisons à cela. La manière dont on a envoyé les données et le fait que ces dernières sont envoyées à chaque cycle d’exécution de la fonction loop(). Si l'on souhaite stopper le défilement, il faut décocher la case en-bas à gauche.

Note: Le défilement représente chaque cycle de passage dans la boucle loop().

Une fois l'affichage stoppé, on constate qu'il nous manque des sauts de lignes pour que cela soit correctement lisible.  Installons des sauts de lignes vierges avec println(); entre chaque exécutions et ajoutons une temporisation avec la fonction delay(); qui aidera à la lecture des données transmises.

NOTE: Il vous sera utile de ralentir le défilement du moniteur série par la mise en place de delay(); qui arrêtera temporairement le cycle du programme et vous permettra de comprendre son évolution ou de cibler ces dysfonctionnement (Débogage).

Nous avons en fin de programme nos deux instructions. Téléversons les ajouts et voyons le résultat.

Stoppons le défilement et revenons au début. On retrouve nos espaces et l'inter-ligne. C'est déjà plus lisible !!

Astuce: Pour un programme qui n'effectue qu'une seule et unique action. Il est possible de forcer son arrêt dans une boucle while(); en y inscrivant 1. while(1);*. Cela permet d'avoir une page dégagée et plus de confort visuel. C'est également utile pour rechercher des dysfonctionnement dans des séquences d'un programme. (débogage) Mais le mieux pour des tests ou des exemples est de l’inscrire dans le setup().

Installons cette instruction à la fin du programme suivant. Téléversons et voyons le résultat.Nous y voyons déjà plus clair !!

Manipuler les format de données

A présent que l'affichage est ordonné, nous allons manipuler notre résultat. Il serait utile de pouvoir convertir l'affichage de cette donnée et de voir quelle est sa valeur.

Il y a trois types de format de données que l'on peut exploiter.

• Le décimale DEC. Le système décimale est un système en base 10 (avec les chiffres de 0 à 9). 
• L’hexadécimale HEX. L'hexadécimale en base 16 avec les chiffres de 0 à 9 en plus des lettres de A à F qui représentent les valeurs de 10 à 15.
• Le binaire BIN. Le système binaire en base 2 avec les chiffres 0 et 1 seulement. (mais à lui seul a permis le montage de système complexe que l'on connaît)

Nous ne rentrerons pas dans le détail de chaque format. Il est nécessaire ici de connaître l'exploitation possible de ce type de format.

Pour afficher une donnée dans un format voulu, il suffit de l'indiquer avec une virgule "," dit opérateur séquentiel dans la fonction print();

Ça se présente sous cette forme (Exemple).

Serial.print(variable opérateur séquentiel format);Voici le résultat au moniteur.

L'utilisation de l'affichage sous un format différent est parfois utiles pour un traitement plus lisible de données binaires vers l'hexadécimale.

Envoyer des données.

Nous avons vu comment envoyer des données vers le moniteur. Maintenant nous allons envoyer des données vers la carte Arduino.

Pour envoyer des données vers la carte nous avons une zone de saisie de données et un bouton.

Fonctions  available() et read().

Pour cela, nous allons utiliser deux autres fonctions de Serial. Tout d'abord comme dans toute communication, il va falloir dire à la carte que l'on s'adresse à elle.

available() va contrôler si des données sont présentent dans le buffer*. Dans ce cas, on les lira avec la fonction read() qui va récupérer les données dans le buffer. C'est l'acquisition de la donnée qui vient d'être faite.

*Buffer: Mémoire tampon de stockage de données pour le transfert.

read() récupère les données une à une dans le buffer. Il faudra répéter son action de lecture tant qu'il y a des données dans le buffer. L'utilisation de while() nous permettra de réaliser cette opération. Il faut savoir également que read() efface du buffer la donnée qu'il vient de lire.

Créons une variable qui va récupérer les données et mettons en place
les fonctions dans notre programme.La présence de données est contrôlée par Serial.available(). La fonction retourne « true » (1) si des données sont présentent dans le buffer. Ensuite la fonction read() s'occupe de lire dans le buffer et de charger les données dans la variable « acquis_donnees » .

NOTE: Ici delay() apporte une stabilité de traitement des données. Sans cela, il y a un risque d'un affichage erroné.

Téléversons les modifications et voyons le résultat avec l'envoi du mot Arduino.Que s'est-il passé ? Il nous retourne que des chiffres !

Le type char

Se sont les valeurs de code ASCII qui correspondent à chaque lettre du mot Arduino. Ces chiffres correspondent à ce qui a été envoyé par le moniteur pour transférer les données vers la carte. Cette dernière nous les a simplement retourné sous le format entier int de la variable dans laquelle elles ont été stockées.

Si l'on souhaite avoir un retour de notre envoi par des lettres, il faut faire la conversion inverse. Sauf qu'une conversion n'est pas intéressante car nous avons le type char qui prend en charge les caractères alphabétiques. Il nous faut donc changer le type de déclaration de la variable acquis_donnees.

Renvoyons le mot arduino.

Afficher ce mot sur une ligne, c'est possible. Comme on le voit sur le moniteur chaque lettre du mot est une donnée lue à chaque lecture de read().

La première solution est de retirer les sauts de lignes après l'affichage de la donnée et supprimer la phrase complémentaire à l'aide des barres obliques //.Cela nous donne.

Envoyer une chaine de caractères.

Vous constaterez que les lettres s'affichent une à une comme précédemment. C'est dû  au traitement de notre acquisition qui s'effectue via notre variable de type char. Il nous faudrait stocker une à une les lettres de notre mot dans une variable; mais le type char n'a de place mémoire que pour des caractères alphabétiques seuls. Il ne permet pas de stocker un mot ou une phrase qui sont trop volumineux pour l'espace mémoire alloué. Une suite de lettres alphabétiques dans un mot ou une phrase est appelée chaîne de caractères.

String

Il existe une classe String qui contient suffisamment de place mémoire pour des chaînes de caractères.

Comment utiliser String ?
String est une classe qui regroupe plusieurs fonctions utiles à l'exploitation des chaînes de caractères. A la différence de Serial, pour faire appel à l'une de ses fonctions, il faut lui attribuer un  objet  . Un  objet : c'est comme une variable mais pas vraiment. Il nous faut la nommer judicieusement en fonction de son utilisation.

Voici comment attribuer un objet, qui ne sera utile uniquement pour la classe String
à laquelle il est rattaché. Dans le jargon, on dit faire une instanciation*.

*Instanciation :  L'instance d'une classe est faite par l'affectation d'un objet qui lui est propre à son exploitation.

chaineCaractere; est notre objet, une instance de String.

Comme nous l'avons vu plutôt on récupère les données une à une. Donc par le biais d'une addition nous stockerons une à une les données reçues dans l'objet.

N'oublions pas de réinstaller notre phrase complémentaire et le saut de ligne en fin d'affichage de données. Il nous faut à présent afficher notre objet chaineCaractere à la place de acquis_donnees

Téléversons nos modifications et envoyons le mot Arduino.Le résultat est volontaire, c'est pour vous montrer comment se déroule l'acquisition et ce qu'il se passe à chaque cycle de while().

Mise en forme de l'affichage des données.

Pour un affichage complet de notre envoi, il nous faut sortir de la boucle while() l'affichage de notre objet . Par conséquent, il se retrouve dans le programme principal loop() et notre phrase complémentaire risque d’être afficher en continu. Donc pour éviter cela nous allons conditionner l'affichage sur la présence de données contenues dans notre objet.NOTE rappel: delay() dans la boucle sera à présent seulement utile pour apporter une stabilité de traitement des données. Sans ça, il y a un risque d'un affichage erroné.

Téléversons les modifications et voyons le résultat avec l'envoi du mot Arduino.Voici un résultat plus satisfaisant ! Nous avons un bel outil qui nous permet de retourner une phrase au moniteur. Amusez-vous avec d'autres mots et phrases.

Petit plus: Pour l'affichage des données avec String, il est possible de le faire avec une seule ligne d'instruction à l'aide d'un "+" en fin de phrase. Vous comprendrez que cela est faisable par le traitement de type de données identiques. Voyez ci-dessous.

Les fins de lignes de données ?

Nous allons voir à présent l'importance que le moniteur porte au saut de ligne et fin de ligne. Nous avons vu précédemment que le code ASCII régie la transmission des données. Pour traiter les données en fonction des sauts ou fins de lignes, il nous faut connaître le code ASCII des sauts de lignes et fins de lignes. Celui de fin de ligne "LF - Line feed" vaut 10 en code ASCII.
Nous allons donc contrôler la présence du code 10 dans la réception des données transmises pour afficher un message.

Assurez-vous que le paramètre de ligne du moniteur soit sur "Pas de fin de ligne" (nous verons pourquoi plus tard).

Téléversons les modifications et envoyons le mot Arduino.

Rien ne se passe ! C'est normal . Cela pour comprendre que les fins de lignes sont générées par le moniteur lui-même lors d'une transmission de données. Pour Activer les fins de lignes, il faut changer le paramètre d'envoi de données sur "nouvelle ligne"

Essayez avec le mot Arduino.

Cela fonctionne. Et l'on comprend maintenant que le moniteur peut être configuré pour traiter des envois de données sur des fins de lignes ou pas. Si vous appuyez simplement sur "entrée" ou le bouton "envoyé" vous envoyez des données vierges.

Je vous propose un petit jeu !!

Amusons-nous à distinguer chaque mot d'une phrase !!!!
Pour cela nous allons faire la même chose que pour les sauts de lignes, sauf que cette fois, se sont les espaces entre chaque mot que nous chercherons.

Dans le tableau ASCII l'espace "space" vaut 32.
Nous avons également besoin de savoir quand vient le saut de ligne 10 pour le dernier mot de la phrase qui ne dispose pas forcément d'un espace. Intégrons cette dernière valeur dans notre condition de  contrôle.

Nous aurons aussi besoin d'un objet "chaineCaractere2" supplémentaire pour décomposer notre phrase. Il va nous falloir réinitialiser à zéro (vider) notre nouvel objet à chaque détection d'espace pour afficher seulement le mot suivant entre espace. En utilisant la boucle while() tant que des données sont présentes.

Téléversons nos modifications et voyons le résultat avec une phrase de plusieurs mots.Cela fonctionne mais prenez garde au paramétrage du moniteur car en mode "pas de fin de ligne" le dernier mot ne sera pas affiché, si vous n'y ajoutez pas d'espace. Le mode "nouvelle ligne" est approprié à l'utilisation de ce sketch.

Il existe de multiples fonctions de String utiles pour le traitement des chaînes de caractères.

Vous avez exploré les bases pour traiter l'envoi et la réception de données au moniteur série. Nous avons atteint le but de ce projet. Il y a beaucoup de manière d'utiliser le moniteur série. Vous le découvrirez au fur et à mesure de votre progression.

FIN.

Téléchargez les codes sources référent à ce sujet. Merci.

Cet article Envoyer et recevoir des données au moniteur série. est apparu en premier sur PlaisirArduino.