Avant propos - Clavier d'écran tactile.

L’intérêt principale d'un écran tactile est de retourner, par un visuel graphique, des données système sur son état actuel de marche, arrêt, température, vitesse, niveau, débit et bien d'autres.
Mais également, d'offrir aussi la possibilité à l'utilisateur lambda d'agir sur le système en appuyant sur un bouton, en faisan un slide curseur ou bien de saisir puis charger des valeurs de données.

Sur un écran tactile il existe, à première vue, plusieurs façons d'agir ou transmettre des données à un système.
Mais ce qui nous intéresse ici c'est la saisie puis le chargement de données.
Nous allons donc concevoir un petit formulaire doté d'un clavier d'écran tactile alphanumérique capable de saisir des données pour ensuite les charger à l'endroit de notre choix.

Nous ne nous attarderons pas sur comment crée un projet, le mettre en forme et les divers manipulations des composants , variables et événement tactiles au cours du tutoriel étant donné que nous l'avons fait au tutoriel "NEXTION editor ".
Par ailleurs pour ceux qui n’aurait pas chargé l'éditeur vous le trouverez via le lien ci-dessous.
https://nextion.itead.cc/resources/download/nextion-editor/https:

Le projet du clavier d'écran tactile.

Dans un premier temps nous affichons une page d'accueil nommée "Données" qui présente deux données. L'une de type "numérique" et l'autre de type "texte".
Puis dans le second temps nous affichons une seconde page nommée "Clavier" qui permettra la saisie et le chargement des données.

Pour commencer créons la première page avec les deux composants utiles à nos données avec un bouton nommée "SAISI" permettant de passer au formulaire de saisi.

Ensuite créons la seconde page qui vas contenir notre formulaire de saisi avec le clavier d'écran tactile NEXTION.
Mais tout d'abord attardons nous aux fonctionnalités attendus lors d'une saisi de données.

Les fonctionnalités souhaité d'une saisi.

Premièrement, la possibilité de visionner la valeur en cours de saisi.
Deuxièmement, de saisir une donnée ce qui implique l'emploie d'un Clavier alphanumérique.
Troisièmement, la possibilité d'effacer tour à tour la dernière saisi ou les saisis complète.
Quatrièmement, avoir la possibilité de sélectionner la saisi souhaité à charger.

Les composants utiles à la saisi tactile.

Pour visualiser les données à saisir plaçons deux composants d'affichages. L'un de texte et l'autre numérique.
Ajoutons également deux boutons nommée "<= Eff" pour effacer la saisi en cours.
En plus de cela ajoutons aussi deux boutons radio pour valider au choix le chargement des données renseignées.
Et pour finir un bouton "OK" qui charge le ou les données et passe à l'action suivante de retour à la page d'accueil.

Pour saisir des données il nous faut donc un clavier alphanumérique. Ce dernier on vas le créer à l'aide de composants boutons.

Les composants utiles au clavier d'écran tactile.

La mise en forme du clavier d'écran tactile.

Premièrement dimensionnons à notre convenance un boutons standard puis ensuite par un copié collé dupliquons le.

Deuxièmement, grâce aux paramètres de positionnements "X" et "Y" du volet "Attribute" alignons les boutons entres eux.

Pour cela, en fonction la largeur "A" du bouton standard et de l'écart "B" souhaité nous obtenons le pas "C" de positions sur l'axe "X".
Donc en ajoutant l'écart total mesuré nous obtenons le positionnement de chaque bouton sur l'axe "X".
Suivant l'exemple ci dessous le prochain bouton (1) se positionnera à 78. Et ainsi de suite pour les autres. (0+78 = 78 +78 = 156 + 78 =234 + ...)

Nous obtenons ainsi une ligne de boutons parfaitement aligné que nous pouvons a son tour copier et coller plus bas pour la réalisation de chaque ligne de notre clavier alphabétique.

Pour l'alignement en hauteur de nos ligne de boutons répétons l'opération précédente mais sur l'axe "Y" avec une ligne de boutons.
Nous faisons ensuite l'identification des boutons suivant leurs fonctions.
Pour finir plaçons les boutons "Espace" et "clear".

Notre clavier d'écran tactile de saisis est graphiquement prête et nous pouvons à présent passer à la programmation de la saisi.

Gestion de la saisi.

Avant toute choses il faut penser à la grandeur numérique ou alphabétique des données utiles à saisir dans notre systèmes.
"t0" est configuré pour n'accepter que 10 caractères. "n0" ne peut pas dépasser -2147483648 à 2147483647 bits par conséquent de ne pas dépasser la valeur de 999 999 999.
Il faut donc conditionner le composant de lettres sur dix (10) lettres et le composant de nombre sur neuf (9) chiffres.

Saisis des caractères alphabétiques.

En toute logique les chaines de caractères saisis se succèdent ce qui reviens donc à faire de la concaténation.
Pour la programmation nous utilisons la Variables système numériques "sys1", de nature globale, temporaires et fourni par l'éditeur. Elles n’ont pas besoin d’être déclaré et peuvent être lus ou écrits de n’importe quelle page. Entiers signés 32 bits.

Nous conditionnons donc l'exécutions de la saisi alphabétique avec cette variable "sys1".
voyez l'exemple ci dessous avec la lettre "a".

Finalement il ne reste plus qu'a copier puis ajuster ce programme pour les autres boutons alphabétiques.
Une fois cela fait passons à la saisi des chiffres avec le clavier d'écran tactile

Saisi des caractères numériques.

Pour la saisi des caractères numériques ou chiffres c'est différent.
Effectivement si on exécute le même principe de programmation que pour les lettres.
Le compilateur vas plutôt additionner les chiffres et notre saisi ne sera pas fidèle.

Nous partons donc du principe que chaque saisi de chiffres correspond tour à tour à une unité, dizaine, centaine, millier et ainsi de suite. Ce qui reviens à multiplier par dix la valeur de saisis actuelle pour l'additionner la prochaine saisi.

Pour la programmation nous utilisons la Variables système numériques "sys0".
Voyez cela dans l'exemple ci dessous avec le chiffre un (1).

Bravos, à ce stade vous êtes en mesure de saisir des valeurs de données numériques et alphabétiques.
Mais qu'en est il en cas d'erreur ?

Effacement d'une saisi alphabétique.

Tout comme pour ajouter une lettre, pour en effacer une, il suffis de la retirer en faisant une soustraction par "-1" à la valeur actuel.

Effacement d'une saisi numérique.

Ensuite pour les chiffres nous exploitons le fait que la zone de saisi numérique n'admet pas les nombre décimale. Par conséquent en faisant une division par 10 de la valeur actuelle elle vas retirer la dernier saisi .

Effacer toutes les saisis.

Maintenant pour effacer toutes les saisis nous utilisons bien-sur le boutons "Clear".
Sa programmation consiste donc à initialiser à zéro (0) toutes les donnée des variables utiles aux traitement de la saisi.

A cette étape de notre projet, nous pouvons corriger nos saisis à volonté. Voyons donc la possibilité de les sélectionner pour valider leurs chargement vers le système.

Sélection d'une zone de saisis.

Pour sélectionner la donnée que l'on souhaite charger nous avons intégrons deux boutons radio. Paramétrés à zéro (0) depuis le volet "Attribue" sur en "val" = 0 .

Ils nous permettent de sélection la ou les données souhaitées dans notre système.
Chaque bouton radio est affecté à une zone de saisi. La validation de nos saisis est donc conditionné par l'état zéro, faux ou un, vrais du bouton radio.

La saisis de nos données faites, nous pouvons finalement les valider. C'est la fin de notre saisis.

Fin de saisi.

Comme vous le comprenez déjà c'est Lors d'un appuie sur le boutons "OK" que l'on charge la ou les valeurs saisi vers les composants de la page d'accueil pour ensuite l'afficher.
Mais n’oublions pas aussi d'initialiser les variables, systèmes "sys0" et "sys1", de traitement de la saisi.
Voyez l'exemple ci dessous.

Nous y voila la saisis est terminé. Nous sommes capable de saisir des données grâce à un clavier d'écran tactile NEXTION alphanumérique.

Mais nous souhaitons aller plus loin.
Maintenant que l'aspect fonctionnel du clavier d'écran tactile NEXTION est en place. Nous lui avons apporté une mise en style plus agréable au visuel.

Mise en style de écran tactile NEXTION.

En vous aidant du tutoriel "Écran tactile NEXTION" et d'un logiciel de dessin, voyez l'aperçus de ce qu'il vous est possible de réaliser.

Votre imagination est sans limites ! Avec des images graphiques ou photos vous pouvez réaliser bien plus que cela !
Pour notre projet exemple nous utilisons des composants NEXTION en exploitation de saisi. Mais finalement, comme par exemple, le but est d'envoyer la donnée saisi vers une carte ARDUINO qui pilote une système.

BRAVOS!

Vous connaissez les bases pour réaliser une interface de saisi de données.
Téléchargez le programme et amusez vous à l'intégrer à vos projets et à en améliorer ces fonctionnalités.

Merci de votre lecture et à bientôt !

PLAISIR ARDUINO.fr

Cet article Clavier d’écran tactile NEXTION. est apparu en premier sur PlaisirArduino.

Le but de ce tutoriel est de vous aiguiller étape après étapes dans l'utilisation de l'éditeur NEXTION et de ses composants pour la mise en forme de pages d'écran tactile.

Le matériel.

Écran tactile NEXTION et son alimentation 5V.
Avoir une carte micro SD formaté en FAT32.
Télécharger et installer l'éditeur logiciel NEXION sur votre PC.

L'éditeur NEXTION.

Ouvrons l'éditeur NEXTION. ( En anglais)
Au centre de l'éditeur se trouve deux volets. "Recent projects" pour les récent projets et "About" qui nous informe sur la version utilisé et donne la possibilité de faire une mise à jour (latest version).
Commençons par observer son aspect. En plus de la barres de menus et de la barre d'outils fonctionnels l'éditeur est composé de sept (7) volets de travail détaillés dans le tableau qui suit.
A ce stade les volets de travail ne sont pas actifs car il nous faut crée un projet.

Créer un projet avec l'éditeur NEXTION.

Pour commencer créons un nouveau projet.
Dans la barres des menu "file" (= Fichier) puis "new" (= Nouveau).
L'utilitaire d'enregistrement s'ouvre puis à l'emplacement de notre choix créons un fichier repérable "NEXTION projet".
Nommons le "Tuto NEXTION Éditeur" -ou différemment si vous le souhaitez-, enregistrons et l'éditeur nous aiguille ensuite vers l'étape de configurations en ouvrant la fenêtre "Setting".

Configurations de l'éditeur NEXTION.

L'éditeur à besoins de connaitre le profil de votre écran tactile pour s'y adapter. Nous comprendrons cela plus tard lors de la mise en forme de nos pages.

Recherchons et sélectionnons notre modèle d'écran suivant sa catégorie "BASIC", "ENHANCED" ou "INTELLIGENT" .
Dans notre cas pour le modèle NX8048K070 la catégorie est "ENHANCED".
N'appuyons pas encore sur OK!.

Sélectionnons d'abord l'orientation de l'écran souhaité en fonction de l'exploitation de notre projet. Dans "Display" (= Affichage) à gauche de la fenêtre de configuration.

Divers choix d'orientations sont proposés Horizontale à 0° ou 180° ou verticale à 0° ou 180°. Pour notre exemple nous faisons le choix
Horizontale à 0° puis validons sur "OK".
Note : l'orientation à 180° est équivalent à un retournement de l'écran.

Nous retournons systématiquement vers l'éditeur, les volets de travail sont à présent actifs et l'on a au centre l'onglet d'aperçu de notre écran.

Nous sommes prêt à la réalisation de notre écran tactile NEXTION.

La police d'affichage.

Premièrement choisissons et configurons une police d'affichage utilisé à l'écran.

Dans "Tools" (= Outils) puis "Font generator" (=générateur de police) la fenêtre "Font generator" s'ouvre.
Puis choisissons une taille et un style de police via la liste "Height" et celle qui se situe dans la zone d'aperçu "Preview Aréa".
Le caractère "X" donne un aperçu de sa taille et sa forme par rapport à l'écran.
Pour démarrer notre exemple nous choisirons "56" et "Source code pro"

Finalement, saisissons le nom de notre police personnel "Source code pro_56" et validons sur "Generate font" générer une police.
Enfin enregistrons celle ci dans le même fichier que notre projet "NEXTION projets" dans un fichier nommé "NEXTION polices".
Puis comme demandé par la pop-up qui suit ajoutons la police générée à notre projet en cliquant sur "OK".
Nous retrouvons nos polices personnalisé dans le volet "Font" situé sous le volet "Picture".

Avant de passer à la réalisation de notre page d'accueil nous devons avant tout nous intéresser à la résolution de nos écrans et des images qui vont alimenter notre projet d'interface graphique.

Images et résolutions.

Un projet d'affichage graphique sur un écran tactile implique un travail d'apparence sur images.
l’aspect le plus important du traitement des images est basé sur la résolutions.

Pour ces raisons il nous faut souligner l'importance de leurs dimensionnement car elles risqueraient de ne pas être afficher de manière optimale donc prenons garde à faire une adéquation entre la résolution écran et celle de l'image.
Étant donnée que les caractéristiques des écrans tactiles ne sont pas modifiables nous dimensionnons les images en fonction de la résolution indiqué par la référence de notre écran.

Prenons le cas de notre écran NX8048 K070. Le chiffre 8048 indique une résolution de 800 pixels de largeur par 480 pixels de hauteur. (80/48)
Les images ne doivent donc pas dépasser les dimensions de résolution de l'écran que nous exploitons.
Mais pour faire plus simple il suffis de regarder dans la barres d'informations système (écran) au bas de l'éditeur .

Mais en réalité nos images n'aurons jamais une résolution identique aux écrans tactiles. Par conséquent à chaque fois que l'on souhaite ajouter une image il nous faudra la dimensionner.

Dimensionner l'image de votre choix.

Pour la suite du projet nous vous proposons et invitons à suivre cette méthode -Parmi d'autre- pour dimensionner l'image de votre choix.
Ouvrez là sous "PAINT".
Passez en mode "sélection".
Faites un clic droit sur celle ci.
Sélectionnez "Redimensionner".

Choisissez le mode "Pixel".
Décochez "conserver les proportions".
Entrez vos valeurs de résolutions horizontale et verticale.
Validez par "OK".
Si besoins ajustez la planche "paint" (blanc) à votre image.
L'image et à présent dimensionné pour un affichage en fond d'écran.
Pour d'autres dimensionnements plus petit qui vous seront utiles faite la même.
Faites tout de même attention à la qualité de l'image.

Afin de ne pas perdre l'image originale faite "enregistrer sous" puis renommez la nouvelle image avec un nom qui lui est propre et pour une exploitation via l'éditeur créez un fichier repérable "image NEXTION" dans le ficher "NEXTION projet" .

Après cela, l'image sélectionné est prête à être ajouter au projet.

Cela vu, nous pouvons passer à la création de notre projet.

Débuter un projet NEXTION.

Lors de la création du projet "Etape NEXTION" l'éditeur à d'office inséré une page vierge, nommé "page0", que l'on trouve dans le volet "Page".
De toute évidence ce volet représente la structure de classement des pages de notre projet.

Par simplicité de repérages à notre projet, renommons la page "accueil" en faisant un double clic dessus. Attention toutefois à ne pas dépasser les quatorze (14) caractères maximum.

Nous sommes prêt pour la mise en forme d'une page d'accueil.

Crée une page d’accueil à l'écran tactile.

En premier lieu, Plaçons y un fond d'écran.
Cliquons sur notre page d'aperçu qui s'encadre en bleu et complète alors les volets "Event" et "Attribute".
Concentrons nous plus précisément sur le volet "Attribute".
Observons le tableau qui s'y trouve car en fonction des objets sélectionnés il contient les paramètres et données utiles à modifier pour l'aspect et les caractéristiques des composants que nous verrons plus tard.
Comme illustré ci dessous, notre page "accueil" fait partie de ces composants.

Trouvez en fin de tutoriel un tableau qui décrit les différentes fonctions de chaque paramètres que l'on peut y trouver en fonction des composants.

Suivant les paramètres choisis nous pouvons crée un fond d'écran de couleur uni ou insérer une image.

Pour donner plus d’intérêt à notre exemple nous choisissons d'insérer une image en modifiant le paramètre "sta" en mode "image".

Cette action active le paramètre "pic" qui doit obligatoirement être complété par un double clic à son emplacement.

La fenêtre de sélection d'images s'ouvre mais à ce stade du projet elle est vide.
Il faut donc préalablement ajouter une image.

Ajouter une image

Utilisons le volet "Picture" (= Image).
La zone blanche sous la barre d'outils affichera de toute évidence les images contenus dans nôtre projets.

Cliquons sur plus "+" (Add) qui aura pour effet d'ouvrir l'utilitaire d’accès aux fichiers image de notre bibliothèque PC.
Allons dans notre fichier repéré "image NEXTION", puis sélectionnons l'image notre choix et validons.

Après cela une pop-up nous indique que l'ajout au projet est un succès et nous invite à valider par "OK".
Notre image fait donc partie du projet et apparait dans le volet "Picture".
A noter que chaque images aura un indice de 0 à X pour l'identifier en paramètre de composants.

La zone blanche sous la barre d'outils affichera de toute évidence les images contenus dans nôtre projets.
Cliquons sur plus "+" (Add) qui aura pour effet d'ouvrir l'utilitaire d’accès aux fichiers image de notre bibliothèque PC.
Allons dans notre fichier repéré "image NEXTION", puis sélectionnons l'image notre choix et validons.
Après cela une pop-up nous indique que l'ajout au projet est un succès et nous invite à valider par "OK".

Notre image fait donc partie du projet et apparait dans le volet "Picture".

A noter que chaque images aura un indice de 0 à X pour l'identifier en paramètre de composants.

Le fond d'écran.

Revenons au volet "Attribute" et faisons un double clic au paramètre "pic". La fenêtre de sélection est à présent fourni de notre image.
Sélectionnons là et validons sur "OK".

Bravo !! L'image s'affiche à l'aperçu !!
A ce stade nous sauvegardons notre travail en cliquant sur "Save" dans la barres d'outils.
Nous avons ainsi une page d’accueil stylisé et prête à recevoir nos textes d'informations ou d'instructions utilisateurs.

L'exercice suivant consiste à afficher des textes d'instructions ou des informations utiles aux utilisateurs.

Affichage de textes.

L'ajout d'un texte ce fait via le volet "Toolbox".
Nous y trouverons tout les composants utiles à la réalisation de nos commandes, retours d'actions systèmes et autres que nous verrons plus tard.

Cliquons donc sur le composant "Text".
Le texte s'installe sous forme d'un rectangle bleu, en haut à gauche, dans l'aperçu d'écran.
Remarquons l'indication "t0" qui est en faite sa variable d'exploitation programme.

Il faut retenir que chaque composants installés à l'écran sera affecté d'une variable que nous pouvons renommer dans le volet "Attribute".

Déplaçons le rectangle en le faisant glisser à l'endroit de notre choix puis redimensionnons le en tirant sur ses bords pour y voir l'affichage "Newtxt" inscrit par défaut.

Les paramètres de mise en formes et de propriétés sont accessibles dans le volet "Attribute".

Modifions le texte "newtxt" par "Bienvenu" au paramètre "txt".

En ce qui concerne la longueur du texte prenons garde à adapter le paramètre "txt_maxl" au nombre de caractères maximum à afficher.
On peut aussi modifier le nom de variable du composant texte au paramètre "objname" mais comme nous n'avons pas de raison de le modifier nous en resterons là.

Rappelons que vous trouvez en fin de tutoriel un tableau qui décrit les différentes fonctions de chaque paramètres que l'on peut y trouver en fonction des composants.

Nous avons à présent une page d'accueil digne de ce nom qui porte une instruction de "Bienvenu".

Il faut reconnaitre que cela est un peu léger comme instruction utilisateur.

Donc pour la suite de notre projet nous affichons une instruction utilisateur sous forme de texte défilant de droite à gauche.

Texte défilant.

Prenons le composant "Scrolling text" dans la "toolbox.

Modifions le contenu et la forme de notre nouveau composants. Centrons le sur l'image.

Par contre comment modifier la police du texte si elle est trop grande ?
Ce n'est pas possible car nous ne disposons que d'un seul type de police dans le volet "Fonts". Il faut crée une police de plus.

Comme déjà vu précédemment créons puis ajoutons une nouvelle police.
Il faudra en crée autant que nécessaire dans l'évolution du projet.
Par conséquent ajoutons une police de taille "24" et renseignons le paramètre "font" du texte défilant avec la valeur d'index de la nouvelle police dans le volet "Fonts".

Il est possible de modifier la vitesse, le pas et le sens de défilement par "tim" "dis" et "dir".

Affichons le texte "Touchez l'écran". Comme ont pouvait s'y attendre il ne défile pas. 

De plus il faut reconnaitre que le fond blanc de la zone de texte par dessus notre belle image n'est pas très esthétique.

Alors dans le but de rendre le fond de la zone de texte transparent nous changeons le paramètre "sta" en mode "crop image" ce qui implique de renseigner le paramètre "picc" par l'indice de l'image de fond d'écran dans notre cas zéro "0".

En fonction de l'image de fond nous aurons besoins d'adapter la couleur de police au paramètre "pco".

Nous avons là une page d'accueil qui a plus de classe !!!

Toujours définir une zone tactile d'activation car un appuie sur un composants non programmée n'aura aucun effet à moins de les programmées aussi pour cela. Constatons cela sur les composants texte "Bienvenu" et "Touchez l’écran".

Mais pour un premier aperçu dynamique du rendu graphique sans charger le programme dans l'écran tactile, l'éditeur est équipé d'un débogueur qui fait office de simulateur.

Le débogage. (Debug)

Utilisons "Debug" dans la barre d'outil, afin de tester nos configurations de mise en page et le rendu graphique de façon dynamique.

Cette outils est dédié au débogage qui entrainera donc une compilation et un enregistrement du projet avec un retour d'informations au volet "Output". Le débogueur ne s'ouvre pas si une erreur est présente et un message rouge apparait alors dans le volet "Output".

Dans le cas contraire le simulateur d'affichage s'ouvre et nous pouvons alors tester et constater les résultats.

Bravos !! A ce stade, vous franchissez, à présent, l'étape de mise en forme des afficheur NEXTION.

Alors maintenant que l'on maitrise la mise en forme des pages et des textes fermons le simulateur pour revenir à l'éditeur NEXTION et passons à présent à une chose essentiel à l'exploitation d'un écran tactile. Les événements tactiles.

Crée un événement tactile en page.

Premièrement l'événement tactile que l'on vas créer consiste à passer à une page suivante en touchant l'écran. Ce qui, par conséquent, demande d'ajouter une page via le volet "page".
La mise en forme de cette dernière se ferra donc en répétant les actions précédentes.

Nommons la "SecondeEtape", ajoutons une image en fond d'écran et revenons ensuite à la page précédente.
Les événements sont générés dans le volet "Event" via les principaux onglets qui sont:

• "Touch Press Event". Événement lors d'un appui sur un composant.
• "Touch Release Event(0)" Événement lors d'un appui puis relâchement sur un composant ou l'écran.
• "Preinitialize Event(0)" Événement avant l'affichage d'une page. Utile pour initialiser des composants ou variables.
• "Postinitialize Event(0)" Événement après l'affichage d'une page.
• "Page Exite Event(0" Événement à la fermeture de la page.

Pour plus de détaille référez vous à ce lien Le guide de l’éditeur Nextion

Dans la zone de saisi de l'onglet "Touch Press Event(0)" écrivons l'instruction ci dessous.

Testons premièrement l'exactitude de notre programmation d'événements en utilisant "Compile" sous la barre des menus.
Une compilation exécute l'enregistrement fichier de votre projet et de ce fait, renvoie ses résultats de compilations dans le volet "Output" et en cas d'erreurs le message s'affiche en rouge.
Deuxièmement, si tout est "ok" faisons un test par le "Débug".

Ça fonctionne bravo! Encore une étape de passé! Ainsi, vous touchez du doigt la programmation de votre projet. -Si l'on peux dire !!-

Mais retenons que chaque composants d'une page peut générer des événements en programmant dans leurs volet "EVENT".

Restons sur la seconde page !
La prochaine étape consistera donc à revenir à la page précédente en appuyant sur un bouton.

Le bouton.

Une fois de plus servons nous dans la "Tollbox" pour le composant bouton.

De la même façon que les objets déjà utilisés il est paramétrable en formes et styles.
Affichons "RETOUR" dessus (txt).

Rappelons une dernière fois que vous trouvez en fin de tutoriel un tableau qui décrit les différentes fonctions de chaque paramètres que l'on peut y trouver, en fonction des composants.

Ensuite dans l'onglet "Touch Press Event" du bouton écrivons l'instruction

En outre lors de la saisi une aide contextuelle nous assiste en proposant des raccourcis par mots clés.

Puis clôturons par une compilation et si tout est "Ok" faisons un essais "Debug".

Encore bravos, une seconde étape est une fois de plus de franchis !!
Ensuite abordons les bases des événements tactiles par bouton il est temps pour la prochaine étape d'utiliser la programmation des commandes à boutons pour renseigner une valeur en affichage.

Afficher des données.

La prochaine étape consistera, lors de l'appuie sur un bouton, à afficher deux type de données, l'une texte et l'autre numérique.

En bref, pour cela, ajoutons les composant "text" (=Nombre) et "Number" (=Nombre) qui permet d'afficher des valeurs numérique et entière.

Nommons le boutons "Charge ".

Une fois les composants en forme et placés, sélectionnons le bouton "charge" puis programmons le.

Écrivons les instructions ci-dessous.

Rappelons une dernière fois de prendre garde à la grandeur maximales que peut accepter chaque composants. Voire le paramètre "txt_maxl".

Finalement compilons et testons notre programme.
Un appuie sur le boutons "Charge" et s'affichent les données "12" et "Nombre" dans les composants.

Encore bravos !!!
Mais avant l'étape suivante revenons sur les instructions précédentes.

Déclarations des variables sous l'éditeur NEXTION.

N'oublions pas que dans tout programmes informatiques les déclaration sont primordiale.
Donc voici dessous le format de déclaration de variable.
Variable.type.
Cependant, dans la programmation NEXTION, il faut réitérer cette façon de faire appel à une variable.
Comme le montre l'exemple ci dessous.

Prenons le cas de notre exemple, "n0" et "t1" correspondent respectivement aux variables des composants numérique et texte.
Puis suivis du point "." dit, par traduction, séparateur de période.
Pour conclure "val" et txt" correspondent respectivement aux type des variables numérique et texte.
Il faut savoir que la programmation ne supporte pas les espaces.
t0. val = "texte" ne fonctionne pas.(t0.val="texte" correcte)

Nous sommes donc capable de charger des données vers un composant texte ou numérique.
Mais nous pouvons tout aussi bien le faire vers une variable.

Les variables NEXTION.

Considérons les composants à l'écran comme des entrées ou des sorties mais de type tactiles et graphiques.
Par conséquent pour traiter des données internes à l'affichage il faut utiliser des variables.

Pour crée une variable une fois de plus nous devons faire appel à un composant qui porte le juste nom de "Variable".
En revanche contrairement aux autres composant il n'est pas installé dans l'aperçu mais dans le bandeau qui s'ouvre juste en dessous.

Par défaut elle aura le nom de "va0" mais comme tout les autres composants sont nom peut être modifié dans le volet ATTRIBUTE.

Pour affecter une valeur à une variable respectons le format vu précédemment, en se rappelant de ne pas mettre d'espace.
va0.val=154

Faisons l'exercice de charger une valeur dans la variable "va0" lors d'un appuie sur le bouton "charge". Ensuite additionnons à la variable "va0" la valeur du composant "n0". Et finalement affichons le résultat sur un autre composant numérique "n1".
Écrivons les instructions suivantes à la suite du programme.

Une fois cela fait, faisons une compilation et un test.

Bravos, c'est finalement la dernière étape de l'exploration des divers fonctionnalités de l'éditeur NEXTION. En définitive nous sommes capable de manipuler des pages, leurs composants, leurs variables internes et générer des événements tactiles.

Mais vous trépignez surement d'impatience à l'idée de voire le résultat de notre travail à l'écran tactile NEXTION et de tester votre programme !!

Or patience, car avant cela il nous faut charger le programme dans l'écran tactile.

Chargement du projet de l'éditeur NEXTION vers l'écran tactile.

Néanmoins, au préalable, préparons les branchements d'alimentation de l'écran, mais sans le connecter à l'Arduino.

Pour ce faire, il vas donc nous falloir une carte micro "SD" formaté en "FAT32".

Puis ouvrir le dossier de construction "Open build folder" dans le menu "file" et rechercher le fichier projet "Etape NEXTION.tft".
Ensuite faire copie et le coller à l'emplacement de la carte "SD".

Par contre prenons garde à ce que le fichier soit le seul de type "tft". Par conséquent, dédions Idéalement, une carte vierge juste pour cela.
Ensuite une fois le projet dans la carte SD insérons là à l'écran tactile.

A présent alimentons l'écran.

En premier lieu, à l'allumage, il entre en phase d'initialisation et détecte la présence d'une carte "SD" puis charge les données contenus dans la carte vers sa mémoire interne. Par la suite affiche le message "Check Data 100% / Update Successed" qui indique sont initialisation complète et terminé avec succès.
Maintenant désactivons puis réactivons l'alimentation de l'écran Afin qu'il se configure suivant les nouvelles données et exécute notre projet.
L'écran est ainsi prêt à être exploiter et n'attends plus que vos actions tactiles pour exécuter vos instructions.

En fin de compte, c'est une belle avancé dans l'exploration des écrans tactiles NEXTION qui vous permettra la constructions de vos projets sur ce type de supports HMI.

Tableau des 42 attribues de composants.

Mnémoniques	Fonctions.
id	Identifiant de l'objet.
objname	Nom de l'objet. (à saisir)
type	Numéros du type d'objet.
vscope	Local / global. Portée de la variable.Visible localement dans la page en cours ou visible globalement dans toutes les pages.
sta	crop image / solid color / image. Remplissage du fond: image sans recadrage, couleur unie ou image.
dez	Horizontal / Vertical Direction de la barre de progression. Horizontal / vertical.
style	flat / border / 3D_down / 3D_up / 3D_Auto. Style d'affichage du bouton. Plat, bordure, 3D_Bas, 3D_haut ou 3D_Auto.
key	full qwerty-kebod\ - numeric keboard\ - speed dial-keybdC / None. Configuration du type de clavier utilisé en addition avec l'écran.
pic	Permet d'affecter une image au composant. Double clic pour activer la sélection d'images..
picc	Permet d'affecter une image en coupe superposé. Double clic pour activer la sélection d'images..
bco	Couleur de fond par défaut. Choix de personnalisation en palette de couleur.
bc02	Couleur de fond par défaut lors d'une pression sur le bouton. Choix de personnalisation en palette de couleur.
pco	Couleur de police par défaut. Choix de personnalisation en palette de couleur.
pc02	Couleur de police par défaut lors d'une pression sur le composant. Choix de personnalisation en palette de couleur.
hig	Hauteur du curseur. En fonction de la taille.
hiw	Largeur du curseur. En fonction de la taille.
val	État initiale ou valeur attribué à un composant. Logique, analogique ou donnée numériques.
maxval	Valeur maximale de donnée de composant.
minval	Valeur minimale de donnée de composant.
font	Numéros de police par défaut.
xcen	Left / Center / Right. Positionnement horizontale de l'affichage. Gauche, centré ou à droite.
ycen	Left / Center / Right. Positionnement verticale de l'affichage. Gauche, centré ou à droite.
pw	Character / Password Type d'entrée. Caractère /mot de passe
dir	Left to Right / Right to Left / Up to Down / Down to Up. Sens de défilement. De gauche à droite, de droite à gauche, de haut en bas ou de bas en haut.
tim	Temps d'intervalle en ms (à saisir de 80 à 65535) Vitesse de défilement.
dis	Distance de défilement en pixels (à saisir de 2 à 50). Définis le pas d'avance plus ou moins grand.
txt	Contenu du message ou données à afficher au composant. (à saisir). Texte ou hyperliens QRcode
txt_maxl	Taille maximum du nombre de caractères contenu dans l'affichage. (à saisir).
isbr	True / False Envoloppe. Vrais ou faux.
lenth	Montre le nombre de chiffres maxi à afficher. 0-auto, Max-10
format	Decimal /Currency / Hex Type de format. Décimal / segmenté / Hexadécimale.
spax	Espacement horizontal entre les caractères des mots contenu dans l'affichage depuis le point de positionnement "xcen/ycen" (à saisir de 0 à 255).
spay	Espacement verticale entre les caractères des mots contenu dans l'affichage depuis le point de positionnement "xcen/ycen" (à saisir de 0 à 255).
x	Coordonnées en abscisse de positionnement du bouton. Utile pour l'alignement de plusieurs objets. (à saisir suivant résolution écran)
y	Coordonnées en ordonnées de positionnement du bouton. Utile pour l'alignement de plusieurs objets. (à saisir suivant résolution écran)
w	Largeur du bouton. (à saisir).
h	Hauteur du bouton. (à saisir).
tim	Défini le temps d'activation en ms. 50 à 65535.
en	Activation du "timer" 0 = Désactivé, 1 = Activé
gdw	Largeur de la grille. 0 = Aucune.
gdh	Hauteur de la grille. 0 = Aucune.
ch	Nombre de canaux d'affichages. Mini 1, maxi 4.

Quant à vous, Téléchargez l'exemple "Tuto NEXTION Éditeur" dans la rubrique "Download" et amusez vous avec les bases de ce tutoriel pour créer vos projet et découvrir les autres composants !!
Rejoignez nous aussi sur le projet "Clavier NEXTION" et élargissez vos compétences pour optimiser vos projets.

Encore une fois, merci de votre lecture.

PlaisirArduino.fr

FIN

Cet article NEXTION EDITOR l’éditeur pour écran tactile. 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.

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.

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.

La bibliothèque est incontournable dans l'univers Arduino pour l'exploitation de multiple composants ou la gestion de communication entre composants et l'Arduino. Vous avez sûrement déjà utilisé <<LiquidCrystal.h>> pour un afficheur LCD ou <<Servo.h>> pour des servomoteurs et <<SPI.h>> pour le traitement de la communication SPI. Mais, il y en a bien d'autres.

Avant toute chose , il faut préalablement installer puis inclure la bibliothèque dans notre programme.

Tout comme vous, à mes débuts, je me suis fié aux divers exemples trouvés dans l'IDE ou sur le net sans me demander pourquoi et comment on utilisait les bibliothèques. Puis avec l'expérience, je me suis documenté et me suis aperçu que je n'exploitais qu'à moitié certaines bibliothèques alors qu'elles me proposaient d'autres possibilités intéressantes.

C'est pour cela donc, que dans ce tutoriel, nous allons apprendre à "lire" une bibliothèque et identifier ce dont il nous faut pour son exploitation optimale.

Nous explorerons la bibliothèque <<Servo.h>> pour nos exemples.

De quoi est composé une bibliothèque ?

En fait, c'est un dossier. Il contient des dossiers et fichiers de code programme. Il y a principalement trois fichiers et un dossier à explorer.

• Le fichier d'entête. Repérable par ".h"
• Le fichier sources. Repérable par ".cpp"
• Le dossier "exemple". Qui contient des codes sources en exemple d'utilisation.
• Le fichier de syntaxe des couleurs. Qui contient les consignes de couleurs à appliquer pour chaque type de mots-clés.

Ici, nous nous concentrerons particulièrement sur le fichier d'entête, Puis nous verrons le fichier "exemple" et "syntaxe".

Comment explorer une bibliothèque ?

Tout d'abord, commencez par rechercher et trouver le fichier d'entête de la bibliothèque qui est en l’occurrence pour nos exemples "Servo.h".

Deux solutions pour trouver ce fichier.

Première solution.

Exécutez une recherche de fichiers depuis le menu "DÉMARRER" en tapant "Servo.h".  Ensuite, ouvrez-le et suivez les étapes 5 et 6 de la solution suivante.

Deuxième solution.

1. Premièrement, si vous n'avez pas modifié son emplacement par défaut à l'installation, allez sur vôtre disque local "C:" dans le dossier "programme files".
2. Ensuite, ouvrez le dossier "Arduino"
3. Puis, le dossier "libraries".
4. Après, le dossier "Servo".
5. Ouvrir le dossier "src".
6. Finalement, le fichier "Servo.h" apparaît.

Explorons le fichier.

Une fois que vous avez trouvé l'emplacement du fichier "Servo.h", ouvrez-le.

A première vue, on a pas l'impression que ce fichier est un code programme car il est présenté sous format" texte". De ce fait, il est exploitable par un éditeur de texte comme "NotePad", "WordPad" ou le "Bloc-notes".

De toute évidence, vous constaterez qu'il est en anglais. Donc pour cette étape, un travail de traduction des commentaires sera très utile à la compréhension du programme. Je vous invite donc à le faire avec un traducteur de votre choix.

Ne surtout pas apporter de modifications à ce document! Surtout si vous n'avez pas d'idée précise de ce que vous faite. Alors dans ce cas, ne JAMAIS accepter d'enregistrer des modifications car cela entraînerait le dysfonctionnement de la bibliothèque et provoquerait des erreurs lors du téléversement.

Mais quel est son rôle ?

le rôle du fichier d'entête.

Le rôle du fichier d'en-tête est de mettre en place la structure principale de la bibliothèque. Il informe le compilateur de tout ce qu'il lui faut pour exécuter la bibliothèque et va en quelque sorte s'occuper de "déclarer". Il n'y a pas d'exécution de fonctions, ces dernières se font dans le fichier source ".cpp".

On dit qu'il contient le prototype de la bibliothèque.

 Clairement,  nous avons découpé le fichier en plusieurs parties.

• La présentation.
• L'inclusion.
• La déclaration.
• La classe.

Les grandes parties du fichier d'entête ".h"

1) La présentation.

En somme, après traduction, elle vous indique la version, le ou les auteurs, ainsi que les conditions générales d'utilisation (GNU). C'est obligatoire et recommandé pour la distribution.

Il faut aussi souligner que ce texte est un commentaire balisé par ceci  "/* */" ce qui vous permet d'identifier la première partie de la présentation générale.

Ensuite, vous avez une seconde partie. L’aspect le plus important de cette partie, c'est qu'elle décrit le fonctionnement globale de la bibliothèque.

Cependant, toutes les bibliothèques ne le font pas. Dans celle-ci sont citées et mentionnées avec un descriptif, toutes les méthodes, dont vous avez besoin pour exploiter vos programmes. Nous y viendrons en détail par la suite.

Après la présentation, poursuivons à présent, vers le code programme qui s'en suit.

2) L'inclusion.

Voyons tout d'abord, les lignes du code ci-dessous.

Les deux premières lignes permettent au compilateur l'inclusion de la bibliothèque dans votre projet. La troisième ligne quand à elle inclue au sein même de la bibliothèque une autre bibliothèque.

Par contre, "ifndef" signifie en anglais "if not defined" soit en français "si n'est pas défini". Nous avons donc là une condition "if". Cette condition permet lors de la compilation d'un programme de ne pas systématiquement la compiler. On trouve ici un exemple important, à savoir, que l'on a une compilation conditionnelle des bibliothèques.

Par conséquent, suite à notre condition d’exécution, il faut bien-sûr indiquer au compilateur quoi exécuter !!

Cela ce fait avec l'instruction #endif. "endif" qui signifie en français "fin de si". On comprend que la condition d'exécution s’arrête là. On trouve cette instruction à la fin du fichier d'entête.

J'attire votre attention sur le fait que tout le programme du fichier d'entête est contenu dans ces instructions. Vous le constaterez en explorant le fichier.

Poursuivons vers la partie suivante.

Celle-ci fait appel aux versions d'Arduino utilisées AVR SAM ou SAMD. Effectivement, il existe plusieurs versions possibles de compilations. De ce fait, le compilateur doit donc être capable de s'adapter aux divers environnements d'exploitation proposés. Mais là aussi, nous n’approfondirons pas. Sachez juste que cette partie définie votre environnement de travail pour adapter le travail du compilateur.

Vous avez sans doute remarqué les instructions suivantes. #if defined pour si définis, #elif defined pour si non définis, #else pour sinon et finalement #endif pour fin de if. Vous l'avez compris, c'est un ensemble d’instructions conditionnelles en fonction des versions possibles.

3) Les déclarations.

A ce niveau du programme, nous avons deux parties distinctes. Les variables et la classe. Nous décomposerons donc cette partie en deux et nous ignorerons celle encadrée en noir qui nous est étrangère.  Les commentaires ont été traduit pour une approche plus compréhensible.

3.1) Les variables.

En premier lieu, nous avons les déclarations de variables utiles au traitement de tout programme. A cette étape de notre exemple, on intègre une donnée à chaque variable.

3.2) La classe.

Finalement, nous voici dans la "déclaration" de ce que l'on appelle une classe.

L'instruction "class" et son bloc d'instructions "{ }" permet de nommer et de créer une classe. Dans notre exemple ci-dessous elle est nommée Servo.

class Servo { Bloc d'instructions à exécuter }; // Déclaration d'une classe.

Une fois nommée, la classe permettra d'initialiser un objet auquel elle sera rattachée pour que ce dernier puisse faire appel au constructeur et aux méthodes qu'elle contient.
Cela étant dit une classe peut être aussi utilisée sans objet.

Examinez l'illustration ci-dessous.

Notamment, il y a deux parties très importantes de la "classe". La partie "public:" et "private:". En français public et privé. Mais en fait leur véritable nom est modificateurs d'accès. Comme le nom l'indique, ils conditionnent l'accès ou non à certaines instructions utilisées à l’intérieur de la classe.

Public permet aux utilisateurs au travers de l'IDE d’accéder aux instructions qui lui sont confiées. Par contre private interdit l'accès aux instructions qui lui sont confiées.

Observons ensuite la partie public. Nous avons, le constructeur.

3.2.1) Le Constructeur.

Vous le reconnaîtrez par le fait qu'il porte le nom de la classe suivi de parenthèses (comme pour un appel de fonction) et qu'il est placé juste après l'instruction "public:". Notez que, dans notre exemple ci-dessus, il ne possède aucun paramètre.

Contrairement à notre exemple "servo", il est possible que dans d'autres librairies, vous trouviez plusieurs constructeurs qui portent le même nom. Si vous observez (entre parenthèses) vous constaterez que ces librairies n'ont pas toutes les mêmes types ou nombres de paramètres. Néanmoins, le compilateur est capable de faire la différence et de ce fait, il laisse aux utilisateurs la possibilité de configurer le projet de différentes manières en fonction du type ou du nombre de données renseigné.

Prenons pour exemple la bibliothèque <<LiquidCrystal.h>> et observez ci-dessous les différences.

Nous avons quatre méthodes paramétrables toutes différentes l'une de l'autre. Ces dernières nous indiquent le type et le nombre de données à utiliser pour chaque paramètre. Les paramètres ont également été nommés? ce qui n'est pas toujours le cas.

Mais à quoi sert le constructeur ?

Le constructeur permet aux utilisateurs de renseigner et configurer un objet qui lui est rattaché avec des données externes. Voyez l'exemple ci-dessous.

Ci-dessus LiquidCrystal est notre classe puis nous avons créé un objet "lcd" et indiqué en paramètre le numéro des broches utilisées pour exploiter note afficheur LCD.

Voici ce que cela donne à l'IDE avec la bibliothèque Servo.

On retrouve notre classe "Servo" et notre objet "mon_servo". Notamment, il n'y a pas de paramètres à renseigner car il n'a pas été déclaré pour cela.

En déclarant notre objet, nous pouvons à présent depuis l'IDE faire appel à ce qui suit, c'est-à-dire les méthodes.

3.2.2) Les méthodes.

Les méthodes sont en réalité des fonctions nommées méthodes pour les identifier comme appartenant à une bibliothèque et les différencier des fonctions classiques que l'on peut créer dans nos programmes. Elles aussi peuvent être paramétrées ou non. A cette étape du programme, nous avons la déclaration des méthodes. Un type et un nom symbolique sont attribués à la méthode et à ses paramètres. Exactement comme on le ferait pour une fonction.

type nomSymbolique (type nomSymbolique ) ;

uint8_t attach (int pin); // attache la broche donnée au canal libre suivant, définit pinMode, renvoie le numéro de canal ou 0 si défaut.

Notez l'absence des accolades et des instructions aux méthodes. En effet, comme nous l'avons dit plus haut le fichier ".h" s'occupe principalement de la déclaration. La partie "exécutive" étant exécutée dans le fichier source ".cpp". Dans notre exemple (ci-dessus encadré en bleu), nous avons là toutes les méthodes utiles pour exploiter un servomoteur.

Finalement, pour toutes bibliothèques si vous cherchez les méthodes, dont vous avez besoin, c'est à cet endroit que vous les trouverez. Certes, il ne vous est pas nécessaire de connaître leur programmation mais seulement leur utilité.

Les exemples.

Dans la plupart des bibliothèques les méthodes sont expliquées avec des commentaires. Mais dans certain cas, cela n'est pas fait. Heureusement dans ces cas là, les éditeurs intègrent toujours des exemples d'exploitation à leurs bibliothèques. A travers les exemples, vous trouverez les commentaires sur l'utilisation de chaque méthode.

C'est pourquoi vous trouverez dans le dossier de chaque bibliothèque, un dossier nommé "examples". Toutefois, il n'est pas utile de passer par le dossier mais de simplement lancer l'exemple depuis l'IDE en cliquant sur "Fichier" ensuite sélectionnez "Exemple" puis le nom de la bibliothèque que l'on souhaite exploiter.

Les mises en forme

Cela à titre d'information. Quand vous utilisez une bibliothèque, la classe et les méthodes s'affichent à l'IDE en orange. C'est fait pour signaler leur utilisation dans un fichier de bibliothèque et vous assurer que vous l'avez bien orthographié. Aussi de cette façon, si vous déclarez, par hasard, une variable qui porte le même nom qu'une méthode utilisée dans l'une des bibliothèque incluse à votre programme; cette variable changera de couleur vous indiquant par conséquent qu'elle ne peut pas être utilisée comme telle.

Ce jeu de couleur est appliqué dans un fichier nommé "Keywords.txt".

Voici ce qu'il contient:

En fait, ici sont regroupés des mots-clés en deux catégories de format de couleurs. Le premier "KEYWORD1" et le second "KEYWORD2". Évidemment, les mots-clés choisis sont ceux utilisés pour les méthodes de la classe Servo.

• KEYWORD1 applique un caractère gras et la couleur orange  aux mots-clés.
• KEYWORD2 applique seulement la couleur orange aux mots-clés.

Il vous sera utile de connaître ce fichier le jour où vous créerez vous-même vos bibliothèques. Ce qui sera un sujet bientôt abordé.

Vous savez à présent comment explorer le fichier "H" et comment identifier les méthodes utiles pour l'exploitation d'une bibliothèque. Amusez-vous à explorer les autres bibliothèques pour en comprendre le fonctionnement.

MERCI.

PlaisirArduino/tutoriel.

FIN.

Cet article Bibliothèque, comment l’explorer ? est apparu en premier sur PlaisirArduino.

Tout d’abord que veut dire LCD ? LCD est l'abréviation du terme anglais "Liquid Crystal Display" qui signifie en français  "Écran à cristaux liquides". D’où afficheur LCD.

L'afficheur LCD est en particulier une interface visuelle entre un système (projet) et l'homme (utilisateur). Son rôle est de transmettre les informations utiles d'un système à un utilisateur. Il affichera donc des données susceptibles d'être exploiter par l'utilisateur d'un système.

Nous utiliserons le modèle 1602A (V2.0) que l'on trouve dans le kit Arduino (2012).

Comprendre l'afficheur

Pour commencer nous détaillerons le datasheet  de l 'afficheur 1602A (V2.0). C' est un document fourni par le constructeur dans lequel est détaillé ses caractéristiques, son fonctionnement et ses différentes utilisations possibles. Il est une source de renseignements très utile pour la maîtrise de son exploitation. Les datasheet sont, pour la plupart, en anglais. Aidez vous de Google traduction pour les traduire.

1 - Les caractéristiques.

La première information à connaître est le nombre de caractère affichable par ligne. Pour ce modèle, c'est 16 caractères sur deux lignes soit au total 32 caractères. De toute évidence, on retrouve cette information dans le datasheet sous la forme 16 X 02. Mais aussi dans la référence 1602 A.

On recueille également l'information du mode de  transmission de données sur quatre (4) ou huit (8) bits.

En outre, les informations suivantes à connaître sont les tensions d'exploitations, caractéristiques électriques et mécaniques de l'afficheur LCD.

2 - Le brochage.

Le tableau ci-dessous représente bien le rôle de chaque broche et définit le brochage de l'afficheur LCD .

• Premièrement, les broches 1, 2 et 3 sont dédiées à l'alimentation. La broche 1 et 2 pour l'alimentation générale. La broche 3 pour le branchement d'un potentiomètre qui contrôle le contraste de l'afficheur.
• Deuxièmement, les broches 4, 5 et 6 pour le pilotage de la transmission des données. Elles pilotent l'écriture ou la lecture de données.
• Troisièmement, les broches de 7 à 14  pour le transfert des données elles-mêmes.
• Et pour finir, les broches 15 et 16 pour l'alimentation du rétro-éclairage.

Grâce à ces informations nous connaissons le brochage de l'afficheur. De plus nous avons en appui un schéma de raccordement.

Ce schéma illustre bien les branchements de l'alimentation principale et de ces auxiliaires. Nous avons ajouté le repérage des broches. Il y a une erreur signalée en rouge. Ne pas câbler ce fil.

Nous avons donc maintenant suffisamment d'informations pour brancher l'afficheur LCD en toute confiance.

3 - Les branchements de l'afficheur LCD.

A présent que tout est en place. Comment l'activer et le piloter? De toute évidence? il nous faudra lui envoyer des données . Mais quelles données envoyer et comment ?

4 - La transmissions de données.

Observez le schéma ci-dessous. Nous avons ajouté le brochage suivant les repères du tableau. De plus, vous constaterez bien-sûr, la représentation de deux "modules". Le ST7066U et le ST7065C.

Le ST7066U et le ST7065C sont des puces électronique utilisées en particulier pour piloter des matrices d'afficheurs LCD et capables de piloter 40 segments respectivement. Comme, par exemple, un MAX7219 avec une matrice à LED 8X8.

En effet l'afficheur est composé de plusieurs matrices chacune d'elle indépendante. Ci-contre la représentation d'une matrice affichant le caractère "A".

En définitive, il y a 32 matrices de cinq points sur huit (5X8) disposés sur deux lignes qui composent l'afficheur représenté ci-dessous.

En fait, les pilotes reçoivent les données, les interprètent et affichent les caractères voulus aux positions souhaitées. Mais pour cela, il faut leur transmettre des données.

D'ailleurs, les deux logigrammes de transmission de données ci-dessous. L'un Writing data pour la réception de données  et l'autre Reading data pour la transmission de données. Cependant, la seule chose qui diffère entre ces deux diagrammes, c'est l'état à la broche "RW" en rouge.

Ainsi, on comprend qu'en fonction de l'état "Haut" ou "Bas" à la broche "RW", le pilote de la matrice ST7066U est en mode de réception ou émission de données.

Il n'y aura pas d'émission de données, la broche R/W sera donc par défaut à l'état bas "LOW" et par conséquent branché au 0V.

5-Les instructions de données.

Comment transmettre des données à l'afficheur LCD?

Le tableau ci-dessous regroupe les diverses instructions de pilotage de l'afficheur.

D'autan plus qu'à la suite du tableau, il y a un descriptif de ces instructions.

Donc pour ceux qui veulent plus de détails, à titre d'information téléchargez la traduction, en français, du datasheet. Il faut reconnaître que malgré les termes non définis, cela vous sera plus facile de comprendre toutes les données utiles pour piloter l'afficheur LCD.

Pour transmettre ces données, il faut maîtriser le protocole de transmission de données entre l'Arduino et l'afficheur LCD. Créer une fonction de transfert de données et pour le moment, c'est hors de notre portée. Pour ces raisons, et heureusement pour nous, des programmeurs ont conçu ces fonctions. Nous n'avons donc plus qu'à les exploiter pour mettre en service l'afficheur.

Note: dans le jargon de programmeur les fonctions dont on parle sont normalement appelées des méthodes .

6-Les fonctions de la bibliothèque.

Des programmeurs ont créé des méthodes qui nous permettent d'exploiter l'afficheur. D'ailleurs, par simplicité et plus de flexibilité, ils les ont installé dans une bibliothèque appelée <LiquidCristal.h>.

Ces méthodes, nous les avons bien évidemment  extraites en explorant le fichier d'en-tête de la bibliothèque <LiquidCristal.h>. Vous trouverez comment le faire au travers du tutoriel intitulé  <<Explorer une bibliothèque et découvrir ses méthodes>>.

Ci-dessous un tableau des méthodes de <LiquidCristal.h>

Nom de fonction.	Rôles.
void clear();	Efface l'afficheur.
void home();	Retourne le curseur au point d'origine (0,0).
void noDisplay();	Désactive l'affichage.
void display();	Active l'affichage.
void noBlink();	Désactive le clignotement du curseur.
void blink();	Active le clignotement du curseur.
void noCursor();	Désactive le curseur.
void cursor();	Active le curseur.
void scrollDisplayLeft	Décale l'affichage vers la gauche.
void scrollDisplayRight();	Décale l'affichage vers la droite.
void leftToRight();	Déplace le curseur vers la droite à l'affichage d'une donnée.
void rightToLeft();	Déplace le curseur vers la gauche à l'affichage d'une donnée.
void autoscroll();	Active le défilement automatique de l'affichage vers la gauche.
void noAutoscroll();	Désactive le défilement automatique de l'affichage vers la gauche.
void createChar(uint8_t, uint8_t[]);	Permet l'appel de caractères ou symboles pré- construit dans un tableau.
void setCursor(uint8_t, uint8_t);	Place le curseur à la position souhaitée.
void setRowOffsets(int row1, int row2, int row3, int row4)	?
virtual size_t write(uint8_t);	?
void command(uint8_t);	?

Pour utiliser les méthodes d'une bibliothèque, il faut avant toute chose l'inclure dans le programme  par l'instruction #include <bibliothèque.h> .

Une fois incluses, nous pouvons commencer la programmation.

Mais avant de commencer,  il va falloir initialiser et configurer l'afficheur. Sans cela impossible d'utiliser les méthodes .

7-Initialisation, configuration et test de l'afficheur LCD.

L'initialisation.

Premièrement, il faut donc initialiser l'Arduino en fonction des besoins de l'afficheur. Cela consiste à attribuer aux broches de l’Arduino des tâches de travail en fonction des broches de l'afficheur.

Étant donné que c'est une initialisation, elle s'effectue en tête de programme par l'appel de la classe LiquidCrystal et en lui attribuant un OBJET. On dit ici faire une instanciation. Comme illustré ci-dessous "lcd" est l'objet. (Vous pouvez lui donner le nom de votre choix.)

Néanmoins, vous constaterez que l'attribution d'un objet ne suffit pas. Il faut également attribuer des données préalablement déclarées. Ces données consistent à initialiser les broches. (Vous pouvez aussi bien ne pas les déclarer et utiliser le numéro de broche).

Il faut souligner que l'ordre de chaque donnée a son utilité et son importance. Elles correspondent particulièrement à un traitement bien défini car elles seront traitées pour exécuter une tâche bien précise.

• RS : Donnée de broches qui synchronise les données.
• E : Donnée de broches qui active la réception des données.
• D4, D5, D6, Et D7 ; Données de broches qui transmettent les données.

Ci-dessous un exemple de déclaration des broches en fonction de notre exemple.

Nous sommes en mode transmission de données quatre bits, délivrée en quartet, soit quatre bits via les broches 2,3,4 et 5. Les broches 12 et 11 pilotent le transfert des données. Nous pourrions utiliser huit bits (plus rapide) mais quatre bits (plus simple) suffiront largement.

La configuration.

Une fois initialisée,  il faut configurer le LCD dans le setup() grâce à la méthode begin() en rattachant son objet "lcd" et en la paramétrant.

Ci-dessus la première donnée (16) est le nombre de colonne et la seconde (2) le nombre de ligne. Nous pouvons à présent mettre en service l'afficheur pour le tester.

Le test.

Pour tester l'afficheur nous utiliserons donc la méthode print(); que nous connaissons déjà. Comme illustré ci-dessous ne pas oublier de placer le message entre guillemets.

L'affichage du message confirmera alors le bon branchement et le fonctionnement de l'afficheur. Passons donc à l'étape de l'exploitation.

8-L'exploitation de l'afficheur.

Ensuite pour exploiter l'afficheur LCD,  il suffit de faire appel aux autres méthode de la bibliothèque. Vous trouverez aussi des exemples de programmes fournis avec la bibliothèque.

En effet, dans le menu de l'IDE. Via FICHIER => EXEMPLE => LiquidCrystal => tous les exemples d'exploitation possibles.

L'ensemble des méthodes est utilisé dans les exemples. Pour cette raison, nous ne détaillerons pas l'exploitation des méthodes car les exemples sont simples à comprendre.  Reportez-vous au tableau des méthodes plus haut dans  le chapitre six " Les fonctions de la bibliothèque".

Vous savez à présent de quoi se compose un afficheur LCD et comment le mettre en service. Apprenez et amusez-vous à manipuler et modifier les exemples selon vos besoins de programmation de vos projets. Aidez-vous des traducteurs pour les traduire.

MERCI.

PlaisirArduino/tutoriel.

FIN.

Cet article L’afficheur LCD. Qu’est ce que c’est ? est apparu en premier sur PlaisirArduino.

Introduction

Au travers de ce tutoriel, nous allons exploiter un signal analogique en entrée pour piloter en sortie PMW dit MLI en français Modulation de Largeur d'Impulsion.

Le but est de faire varier la luminosité d'une LED en agissant sur un potentiomètre. Pour cela nous allons utiliser:

• Une carte Adruino UNO.
• Un potentiomètre de 10Kohm.
• Une résistance de charge de 220ohm.
• Une LED de couleur rouge.

Pour comprendre la gestion PWM, il faut tout d’abord faire un petit rappel. Vous découvrirez plus de détail, en cliquant ici.

Les branchements.

Commençons par examiner la platine Arduino UNO :

• Nous avons 12 broches configurables en entrées ou sorties repérées de 2 à 13. Seules les broches PMW repérées avec ce symbole "~" configurées en sorties modulerons une longueur d'impulsion numérique MLI calculée sur une résolution numérique de 8bits qui représente une plage de 0 à 255 points de mesure. Ce procédé simule un signal de sortie analogique mais qui en fait n'en n'est pas un. Donc nous utiliserons la broche 3, repéré par le sigle "~" (PMW).
• Il y a également 6 broches d'entrées, repérées de A0 à A5, spécifiquement conçues pour le traitement des signaux de tensions analogiques allant jusqu'à 5V max. Elles exploitent un convertisseur analogique/numérique d'une résolution numérique de 10 BITS qui représentent une plage de 0 à 1023 points de mesure. C'est pour cela que nous utiliserons l'une de ces broches pour raccorder notre potentiomètre, à l'occurrence A0.

Ne surtout pas dépasser la tension de 5V max si celle-ci est externe à la carte Arduino.

Le programme.

Déclarations.

En premier lieu, nous déclarons nos variables.

Configurations.

Nous établissons ensuite nos configurations.

• Pour un retour visuel des valeurs exploitées au moniteur série, nous paramétrons la Vitesse du port série.
• Nous configurons en mode sortie la broche utile au pilotage de la LED.

NOTE: il faut souligner qu'il n'est pas nécessaire de configurer une broche d'entrée analogique quant elle est utilisée pour ce type de signal.

Test.

Pour s'assurer que tout fonctionne correctement, il faut tester nos configurations et nos équipements Cela évite de chercher un bogue dans le  programme alors que c'est l'équipement qui est en cause.

Premièrement nous testons la LED. Nous l'activons trois fois pour la contrôler visuellement.

Deuxièmement, pour contrôler le potentiomètre nous utilisons la fonctions analogRead (); qui lit la valeur de tension à la broche sélectionnée et la convertit en chiffre entier de 0 à 1023, puis nous positionnons le potentiomètre en butée mini (gauche) ou maxi (droite)  et effectuons une lecture de notre signal à l'un de ces deux points.  On teste ensuite que la valeur lue correspond bien à 0 (mini) ou à 1023 (maxi) à l'un de ces deux points. Si ce n'est pas le cas, il y a un problème de branchements.

analogRead(Broche à lire);  //Ou variable affectée à la broche.

Vous constaterez l'utilisation de while(1) dans le test qui stoppera l'évolution du programme. En effet dans le cas ou un défaut de lecture est vrais lors du test il faudra donc relancer le programme par un re-set sur la platine ou un téléversement.

Note: Dans ce programme, nous n'avons pas d'initialisation à effectuer.

Programme principal.

Nous décomposons le programme principal en quatre parties.

1. La déclaration des variables locales.
2. L'acquisition du signal.
3. Le traitement du signal.
4. L'exploitation du signal.

Déclarations.

Acquisitions.

Ensuite, nous réalisons la lecture de la valeur du potentiomètre par la fonction analogRead(); et chargeons la valeur acquise dans la variable de traitement  (V.T.)  "val_potar" .

Traitement des signaux.

Une fois la valeur chargée, nous pouvons la manipuler. A cette étape nous allons convertir, mettre à l'échelle et limiter les signaux.

Conversion

Tout d'abord, pour une exploitation plus parlante de notre projet au travers du moniteur série, il est utile de connaître la valeur de tension équivalente de la donnée brute. En d'autres termes, convertir la donnée brute en volt.

• Donc nous allons diviser la tension de service aux bornes du potentiomètre par le nombre de points de lecture. Soit 5Volts divisés 1024 points. Ce qui nous donne un coefficient "K" de conversion que l'on applique par multiples à notre donnée brute. (48.82*10e-3). Après cela nous connaissons théoriquement la valeur de tension appliquée à l'entrée analogique.

Note: Par ailleurs, vous pouvez vous brancher en parallèle au signal de sortie du potentiomètre un appareil de mesure. Néanmoins, des écarts sont à noter et à corriger si nécessaire.

La tension de service est la tension maximum qui sera appliquée à l'entrée analogique.

Ne surtout pas dépasser la tension de 5V maxi si celle-ci est externe à la carte Arduino.

Mise à l'échelle.

Ensuite, il va nous falloir réaliser une concordance entre le signal d'entrée et de sortie. Malgré cela, elles n’ont pas la même échelle de mesure car un signal PWM en sortie est de 255 points et que le signal analogique d'entrée est de 1024 points.

• La fonction map(); nous aide à réaliser une mise à l'échelle du signal d'entrée avec le signal de sortie. De sorte que nous obtenons une corrélation entre le signal d'entrée et de sortie.

map (VT* , mini VT, maxi VT, mini VS*, maxi VS); //Format de la fonction.

*VT = Variable de traitement *VS = Variable de Sortie.

Nous obtiendrons donc 255 points en sortie pour 1023 point en lecture d'entrée.

Limitation.

Certains projets ont des butées mécaniques de fonctionnement qu'il ne faut surtout pas atteindre par risque de casse ou blocage.  Par conséquent, il ne faut pas dépasser certaines valeurs de pilotage en sortie. C'est pour cela que nous utilisons la fonction  constrain(); qui nous aide à effectuer cette opération.

Toutefois, constrain de l'anglais veux dire LIMITER. Nous réalisons donc par cette fonction une mise en butée du pilotage électrique.

constrain(*VT, mini , maxi ); // *VT Variable de traitement.

CONSEIL: Nous pouvons appliquer cette limitation à deux endroits du programme. Soit au signal d'entrée ou au signal de sortie. Il est sécurisant de le faire en sortie car une erreur de traitement (calcul) de la valeur du signal dans le programme  peut avoir des valeurs non acceptables pour vos projets.

Les valeurs de limitations du signal de sortie se détermine par des relevés ou des calculs effectués par vos soins et en connaissance du projet.

La mise en butée du signal d'entrée peut aussi être directement réalisé dans la fonction  map(); avec les paramètres de sorties mini et maxi.

Conversion

Pour les même raison que le signal analogique d'entrée, il nous est utile de connaître la valeur en tension équivalente à la donnée brute d'exploitation en sortie. Nous opérons une conversion comme décrit plus haut mais avec une résolution de 255 points.

• Il faut également diviser la tension de service aux bornes du potentiomètre par le nombre de points de résolution de lecture. Soit 5 Volts divisés par 255 points. Cela nous donne un coefficient "K" de conversion que l'on applique par multiples à notre donnée brute de sortie. (195.3*10e-3).
  Grâce à cela nous connaissons théoriquement la valeur de tension appliquée à la sortie pour le  pilotage.

L'exploitation

Finalement, une fois le signal traité, nous l’intégrons à la fonction  analogWrite(); pour appliquer la consigne de pilotage.

La LED s'allume en fonction de la valeur traitée.

En conclusion, nous constatons que la valeur de tension appliquée à la LED ne dépassera pas les 4,10V. Le signal de sortie étant mis en butée mini et maxi, la valeur de sortie n'atteindra jamais 0V et 5V. Nous voyons ci-dessous le résultat du traitement signal par le moniteur série.

Si l'on voulait, nous pourrions même limiter la tension de pilotage à 2V pour se passer de la résistance de charge de la LED.

Vous connaissez à présent les bases et quelques outils utiles pour l'exploitation d'un signal analogique en entrée et modulé en sortie.

Découvrez et exploitez le signal analogique en téléchargeant les sketchs référents de ce sujet.

++ Petit plus ce programme exemple n'est pas visuellement confortable pour une exploitation via le moniteur série. C'est pour cela que nous vous proposons aussi un programme évolué "Signale_analogique_EVO" de cet exemple qui n'affiche que la valeur actualisée lors d'un changement de valeur au potentiomètre. Vous le trouverez dans la rubrique téléchargement.++.

MERCI.

PlaisirArduino/tutoriel.

FIN.

Cet article Analogique et MLI. Gestion de ces signaux est apparu en premier sur PlaisirArduino.

Description.

Dans l'univers Arduino, vous rencontrerez les LIBRARIES , que l'on appelle bibliothèques . Certaines sont intégrées d'origine au sein du compilateur mais il est aussi possible d'en ajouter en les téléchargeant sur Internet.

Mais en réalité, c'est un sous-programme qui forme un groupement de fonctions utiles à l'exploitation d'équipements comme les servomoteurs, les afficheurs LCD ou gérer des communications SPI et autres composants électroniques.

Charger une bibliothèque.

Il vous sera parfois nécessaire d'installer une librairie qui ne fait pas partie de la liste. Tout d'abord, il vous faudra la télécharger sous format ZIP sur Internet.

Prenons l'exemple de <RTClib.h> utile à la gestion des temps horaires coordonnés pour avoir l'heure exacte. Après avoir recherché et trouvé un site ou télécharger la bibliothèque.

1. D’abord, téléchargez la en format ZIP dans un ficher de destination de votre choix. Nous prendrons "Téléchargement" par défaut.
2. Vous lancez ensuite votre compilateur et ouvrez le menu "croquis", sélectionner "inclure une bibliothèque". Puis la fenêtre déroulante s'ouvre. Cliquez sur " Ajoutez une bibliothèque ZIP".
3. L'explorateur de fichiers s'ouvre. Sélectionnez et ouvrez votre dossier de destination en l’occurrence pour nous "Téléchargement". Recherché le fichier ZIP appelé RTClib et cliquez dessus.
4. Vous retournerez systématiquement au compilateur et constaterez la confirmation du chargement.

Finalement, vous avez installé RTClib.h dans la librairie du compilateur.

Il ne vous reste plus qu'a l'installer dans vos programmes. A l'opposé des originales, celle-ci se trouve dans une seconde liste appelé "Contributed bibliothèque". Il y a aussi une autre liste "Recommended bibliothèque".

Note: Vous retrouverez aussi les fichiers source (.h) des bibliothèques dans le fichier d'installation "Arduino" dans programme files dans le fichier "libraries". Prenez garde à ne pas les modifier si vous ne maîtrisez pas la programmation car il serait endommagé et plus du tout utilisable.

Faire appel à une bibliothèque.

Pour  faire appel à une bibliothèque, il faut aller la chercher dans le menu du compilateur   "croquis" =>>"inclure une bibliothèque" comme illustré ci-dessous.

Vous y retrouverez toutes les bibliothèques incluses dans le compilateur Arduino. Il suffit de cliquer sur l'une d'elle pour installer la directive d'inclusion dans notre programme.

Exemple:

#include de l'anglais veut dire inclure en français c'est la directive d'inclusion . Ce terme ordonne au compilateur de traiter le contenu d'un fichier de la bibliothèque spécifié à son nom, comme s'il faisait partie du programme principal.

La directive d'inclusion se présente sous cette forme  #include <nomDeLaBibliothèque.h>.

Il ne faut pas oublier que pour que le compilateur trouve la bibliothèque à inclure, il faut lui spécifier un chemin d'accès nommé entre  < > guillemets. Le compilateur recherchera les termes du fichier entre guillemets.

Le .h spécifie le type de fichier. H vient du terme anglais Header qui veut dire entête. C'est donc pour spécifier un fichier dit d'entête.

Le but étant ici de savoir comment les mettre en place, nous ne rentrerons pas dans les détails sur leurs constructions car cela sera abordé dans un autre tutoriel.

Vous connaissez à présent la marche à suivre pour installer les bibliothèques de votre choix dans vos projets.

Merci.

Plaisir.Arduino.fr

FIN.

Cet article Bibliothèque, comment l’installer ? est apparu en premier sur PlaisirArduino.