Meccano Créations

Je crée un nouveau sujet, pour plus de lisibilité.

Dans le cadre d’une association de promotion du logiciel libre à la quelle j’appartiens, nous organisons régulièrement des ateliers de présentation de logiciels (Libreoffice, Gimp, Linux …). Parmi ces ateliers, j’anime régulièrement un atelier de découverte Arduino pour le quel j’utilise des platines de test intégrant :

• une carte DFRDuino Roméo qui a l’avantage d’intégrer 2 contrôleurs moteur et quelques boutons poussoirs en complément des fonctions de base de la carte Arduino UNO de base
  
• un moteur Meccano
  
• Une alimentation (Boitier Piles Meccano) qui alimente les 2 controleurs moteurs
  
• une platine de câblage (breadbord) qui permet de poser et d'interconnecter les composants
  
• un potentiomètre
  
• 2 boutons poussoirs. Ces boutons poussoirs sont connectés par une résistance de 10 Kohms à la masse, pour forcer un état "0" quand le bouton est relaché.
  
• 2 Leds, connectées à 2 sorties arduino avec une résistance de 220 ohms
  
• une photorésistance + Résistance
  
• un servomoteur (non présent sur la ploto)
  

Cette platine se connecte par un câble USB à un ordinateur. La carte est alimentée par la prise USB.


 En une vingtaine de programmes, allant du classique Blink qui permet de faire clignoter une led à un programme de contrôle moteur avec accélération / décélération, elle permet de découvrir progressivement la programmation Arduino.
Ci dessous, un schéma de la platine (sans la photo-resistance). Ce schéma est volontairement non conventionnel, en privilégiant l'aspect visuel des composants utilisés et les liaisons.


Votre avis est le bienvenu.

Dans les messages suivants, je vais mettre plusieurs petits programmes commentés, fonctionnant avec cette platine.

 

HOUA , c'est beau ! , mais j'ai un peu peur ... pour mon petit cerveau 

ça a l'air très sympa comme même Marc80 ... :  essayons !  ( sympa =  sans doute bien expliqué ... )

Tout d’abord, un commentaire sur la carte que j’utilise.
 Il s’agit d’une carte fabriquée par DFRDuino type ROMEO Version 1.1.
 Cette carte est basée sur la carte Arduino UNO déjà décrite par Reno dans son pas à pas. Avec Arduino, on est dans le domaine de ce qu'on appelle de l’« électronique libre », c’est à dire que toute société peut copier les plans sans avoir à payer la moindre redevance. La seule obligation est de garder la notion de paternité. Elle fonctionne avec des logiciels libres qui répondent aux mêmes règles
 La compatibilité est totale. Avec une carte ROMEO , on peut faire tout ce que l’on fait avec une UNO.
 Les plus de la carte :

• Une connectique étendue, facilitant la connexion directe de modules capteurs et de servomoteurs, sans passer par une Breadboard
  
• un double contrôleur Moteurs intégré, desservant 2 Ampères par Moteur
  
• 6 boutons poussoirs précablés (nécessite un petit programme spécifie pour les utiliser)
  
• la possibilité de câbler directement un module Bluetooth ou des modules à la norme I2C
  

Lien vers la notice :
https://docplayer.fr/22075390-Manuel-de ... -2012.html

 La carte est désormais disponible en Version 2. Par exemple :
https://www.gotronic.fr/art-carte-dfrdu ... -19244.htm


Il y a quelques différences que j’indiquerai dans les exemples à venir.

C'est la carte que j'utilise en priorité pour mes modèles Meccano. Par exemple pour une grue tour avec 3 moteurs et une télécommande infrarouge :



 

Bravo Marc !

On attend la suite, ... à votre cadence bien sûr.

A+
Cordialement,
Reno. 

Le programme Blink est préchargé sur toutes les cartes Arduino (J’utilise le terme Arduino en terme générique – toute carte compatible quelle que soit la marque). Je vais essayer de l’expliquer le plus simplement possible pour les néophytes, quitte à paraître un peu ridicule.
Voici le programme :
   
Comme tout programme informatique où tout document, il y a une syntaxe et un vocabulaire à utiliser. Il y a aussi une structure (comme dans un courrier, il y a l’entête, l’objet, le corps, la formule de politesse et la signature).

Coté structure : Dans un programme Arduino, il y a 3 parties au minimum :

• une partie définition, déclaration des « objets  » (composants, constantes ou variables) que l’on va utiliser
  
• une partie initialisation : la fonction « Setup » qui sera exécutée une seule fois par la carte au lancement du programme
  
• une partie corps du programme : la fonction « Loop » qui bouclera indéfiniment tant que le programme est actif.
  

Ces 3 parties peuvent complétées par des fonctions complémentaires pour les programmes plus complexes.

Coté syntaxe :

• /* signifie début de zone commentaire. Un commentaire est juste un texte d’information qui ne sera pas utilisé par le programme
  
• */ signifie fin de zone commentaire
  
• // signifie que le texte qui se trouve entre ces 2 symboles et la fin de la ligne est un commentaire
  
• ; est utilisé pour indiquer qu’il s’agit de la fin d’une ligne de programme qui sera interprétée par le « compilateur » (le traducteur qui permet de traduire le texte du programme en code compréhensible par la carte.
  
• { et } sont assimilables à un début et une fin de paragraphe. Dans cet exemple, 2 paragraphes – 1 pour la fonction Setup, un pour la fonction loop
  
• ( et ) liées aux fonctions, permettent de définir des lien avec d’autres fonctions. Ici, aucun lien, chaque fonction est autonome.
  
• ( et ) liées au « mots du vocabulaire » indique les variables ou les valeurs associées
  

 Coté Vocabulaire (le vocabulaire de base est en rouge orangé dans le programme - on parle de coloration syntaxique) :

• int permet de définit un « variable entière », qui peut avoir une valeur entre -32768 et +32767.
  
• void indique le début d’une fonction
  
• pinmode permet de définir une entrée ou une sortie de la carte Arduino
  
  • OUTPUT indique une sortie
    
  • INPUT indique une entrée
    
• digitalWrite indique que l’on « écrit » une valeur sur une sortie
  
  • HIGH Etat haut : Valeur + 5V en sortie
    
  • LOW Etat bas : Valeur 0V en sortie
    
• delay indique un temps (en millisecondes) pendant lequel la carte va attendre, se tourner les pouces en attendant que ça se passe
  

pinmode, digitalWrite et delay sont en réalité des fonctions internes prédéfinies dans le compilateur.
 
Donc, pour le programme :

• int led = 13 ; définit le mot « led » comme une variable à laquelle on donne la valeur 13
  
• pinmode( led ,OUTPUT) ; indique que la broche dont la valeur est « led », soit 13 est une sortie
  
• digitalWrite (led, HIGH) ; positionne la sortie 13 à l’état Haut, soit +5V pour allumer la led
  
• digitalWrite (led, LOW) ; positionne la sortie 13 à l’état bas, soit 0V pour éteindre la led
  
• delay(1000) ; attendre 1 s
  

 
Pour vérifier le programme ou le téléverser (l’envoyer sur la carte) voici les boutons :

Pour télécharger le programme : [/size]  

Bonjour marc80
Vos informations très complètes et didactiques seront très utiles à bon nombre d'entre nous
La démonstration est orienté pour notre application. Que demander de plus
Cordialement
Gilbert

Juste pour réviser un peu.
Comme sur la platine, il y a 2 leds , autant les faire clignoter toutes les deux alternativement :


 On retrouve les mêmes éléments que précédemment.
  
 Seule différence, coté Vocabulaire :

• #define permet de définir une valeur constante, ce qui est le cas des sorties sur les quelles sont connectées les Leds. #define n’étant pas une fonction n’a pas besoin d’avoir un « ; » à la fin de la ligne.
  

  led1 correspond à la valeur 13, led2 correspond à la valeur 12.
  
 Question que pourront se poser certains : Pourquoi définir des valeurs led1 et led2 alors qu’il suffirait de mettre les valeurs 12 et 13 directement dans les fonctions pinmode et digitalWrite - par exemple : pinmode(13, OUTPUT) ?
Réponse :  Le fait de les définir en tant que constante ou variable (comme dans le programme Blink) m’évite de changer mon programme si je suis obligé, pour une raison ou une autre, de modifier mon câblage. Si je déplace led1 sur la broche 5, je n’ai qu’à changer la ligne de définition par " #define led1 5 " sans avoir à reparcourir tout mon programme pour corriger le reste.

Pour télécharger le programme :

Regarder clignoter des leds, c’est bien, mais un peu lassant. Maintenant on va faire un peu de gymnastique avec les doigts. Comme on a 2 boutons poussoirs sur la platine, on va les utiliser pour allumer et éteindre les leds.
Les boutons poussoirs sont ici câblés avec une résistance dite de « pull down » qui force le voltage en entrée à 0V si le bouton n’est pas appuyé. Si le bouton est appuyé, le voltage en entrée passe à 5V (voir le schéma plus haut).
  
  
 Nouveauté en structure :

• on voit apparaître des « sous paragraphes » inclus dans le « paragraphe loop ». les symboles { et } encadre un groupe d’instructions conditionnées par le mot clé « if »
  

 
 En vocabulaire :

• digitalRead(entrée) permet de lire l’état d’un signal digital en entrée
  
  • HIGH ou « 1 » voltage en entrée proche de 5V
    
  • LOW ou « 0 » voltage en entrée proche de 0V
    
• if (condition) { ensemble de fonctions } : le mot clef if permet ici de tester l’état d’une valeur (la condition) et de n’exécuter le code que si la condition est vérifiée.
  
  • A noter : dans le cas d’un test d’égalité, le signe = doit etre doublé : « == »
    

 
 Donc, pour le programme :

• dans la partie déclaration :
  

• • Déclaration de 4 constantes(broches d’E/S : bouton1 ; bouton2, led1, led2)
    
  • Déclaration de 2 variables (marche, arrêt)
    
• dans la fonction setup() :
  
  • initialisation des broches led1 et led2 (broches 12 et 13 de la carte) en sortie
    
  • initialisation des broches bouton1 et bouton2 (broches 8 et 9) en entrée
    
• dans la fonction loop()
  
  • lecture de l’état du bouton n° 1 (variable marche)
    
  • Si le bouton 1 est appuyé (marche = HIGH)
    
    • allumer les Leds (sous paragraphe avec 2 digitalWrite)
      
  • Si le bouton 2 est appuyé (arret = HIGH)
    
    • éteindre les Leds
      
  • Ce qui veut dire aussi que si aucun des boutons n’est appuyé, il ne se passe rien, c’est à dire que les Leds restent dans l’état ou elles étaient précédemment (allumées ou éteintes)
    

Pour télécharger le programme :    

Avec ce qu’on a déjà vu, on pourrait déjà réaliser la commande d’un moteur en tout ou rien. Il suffit de remplacer une des leds par un relais 5V, comme expliqué par Reno dans son pas à pas.
Commander un moteur à vitesse variable est plus intéressant et ouvre plus de possibilités. Pour cela, on peut utiliser le potentiomètre de la platine de test. Ce potentiomètre est connecté sur une des entrées analogiques de la carte, ici, l’entrée A1.
Pour commencer simplement, je propose de réaliser un gradateur en faisant varier la tension de commande d’une LED.
 
Attention :
Pour cela, on doit d’abord faire une modification de câblage. On va déplacer la LED branchée sur la broche 12 vers la broche 10. Pourquoi ?
Seules quelques broches de la carte Arduino UNO (et donc la ROMEO compatible UNO) peuvent fournir une tension variable de 0 à 5V. Les autres ne peuvent donner que 0V (LOW) ou 5V (HIGH). Ces broches, dites PWM sont les 3, 5, 6, 9, 10, 11.
D’où la nécessité de déplacer la Led sur la broche 10 si on veut faire varier son intensité (le programme marcherait aussi sur la broche 1é, mais on ne verrait pas la variation).
D’où l’intérêt aussi d’utiliser des constantes : Seule la ligne #define led est à corriger.

[/size]

Coté structure, rien de neuf.
Coté syntaxe, on découvre comment faire des calculs arithmétiques simples :

• le résultat attendu (par exemple sortie ou tension) est situé en début de ligne suivi du signe « = »
  
• la formule utilise les symboles classiques :
  
  • + Addition
    
  • - soustraction
    
  • * multiplication
    
  • / division
    
• il est possible d’utiliser des parenthèses pour des sous calculs
  

Cette syntaxe était déjà utilisée pour lire l’état des boutons poussoirs dans le message précédant, avec la fonction digitalRead(bouton)
 
Coté Vocabulaire :

• float permet de déclarer un nombre réel / nombre flottant / valeur décimale comprise de 3.4*10-38 à 3.4*1038 .
  
• analogRead permet de lire une valeur analogique (ici la tension transmise par le potentiomètre de 0 à 5 Volt. Cette tension est convertie en une valeur de 0 à 1024
  
• analogWrite permet d’envoyer sur une broche une tension variable. Cette tension est codée par une valeur de 0 à 255. d’où la nécessité de diviser par 4 la valeur lue en entrée pour obtenir la bonne valeur de sortie.
  

 
Donc, pour le programme :

• Déclaration :
  
  • définition des constantes potar et led
    
  • définition des variables entières valeurlue et sortie
    
  • définition d’une valeur décimale tension
    
• setup()
  
  • initialisation de la broche 10 comme sortie
    
  • Nota : les entrées analogiques n’ont pas besoin d’etre initialisées
    
• loop()
  
  • lecture de la valeur du potentiometre
    
  • calcul de la valeur de sortie (division par 4)
    
  • écriture de la valeur en sortie
    
  • calcul de la tension (une règle de 3 classique)
    

 
Question : Pourquoi calculer une tension alors qu’on ne peut pas en afficher le résultat ?
 
On verra comment faire dans les prochains messages.

Pour télécharger le progrmme :     

L'IDE Arduino est le programme (logiciel libre et gratuit) qui permet le programmation des cartes Arduino. Ce programme fonctionne sur Windows, Mac et Linux. J'utilise les versions Linux et Windows (Machine virtuelle Virtualbox sous Linux). En fonction des besoins, je fais des copies d'écran à partir de l'une ou l'autre des versions.Avant de continuer sur d’autres exemples, quelques fonctions du menu indispensables à connaître
Menu Fichier / Carnet de croquis :
Le menu Fichiers est assez classique.
Particularité : le menu arborescent  "Carnet de croquis" donne accès à tous vos programmes. Ici, j’accède aux programmes de bases de la platine de test que je présente ici.

 Menu Outils / Type de carte :
   Ce menu va permettre de définir le type de carte sur le quel nous travaillons. Ici une carte UNO, puisque la ROMEO V1.1 est totalement compatible UNO, car basée sur le même processeur. 
 Pour information, la carte ROMEO V2 est compatible LEONARDO (processeur différent). 
 J’utilise aussi la carte mega 2560 qui est plus puissante et permet d’avoir plus d’entrées / sorties.

 Menu Outils / port :
   Ce menu permet de vérifier et de définir le port USB auquel est connectée la carte sur laquelle on travaille.

 Menu Outils / moniteur série :
   Ce menu permet d’afficher un écran virtuel (moniteur série) connecté à la carte arduino sur laquelle vous travaillez. Ce moniteur permet au programme d’afficher des informations, mais aussi éventuellement de recevoir des commandes à partir du clavier de l’ordinateur.
 La vitesse de communication est définie en "baud" (Bits/seconde) . La vitesse sélectionnée dans l’écran moniteur (en bas à droite) doit être la même que celle du programme.

Nous allons utiliser ce moniteur dans les prochains exemples. Il est indispensable lors de la mise au point de programmes un peu complexes.




 

Quelques liens utiles :

Téléchargement et installation de l'IDE :
https://www.arduino.cc/en/main/software

https://www.arduino-france.com/tutoriel ... ilisation/

Site Arduino France :
https://www.arduino-france.com/

Des tutoriels :
https://www.arduino-france.com/category/tutoriels/

http://www.mon-club-elec.fr/pmwiki_mon_ ... N.ATELIERS

On a vu précédemment qu’on pouvait utiliser un moniteur pour afficher des informations. En voici un premier exemple.
 On commence par reconnecter la Led sur la broche 12.
On va compléter le programme BpsLeds qui permettait d’allumer et d’éteindre des leds à l’aide de 2 boutons poussoir.
 On va utiliser pour cela une « librairie », c’est à dire un module annexe dédié. Il s’agit ici de la librairie « Serial », dédiée à la gestion du moniteur. Cette librairie est présente par défaut dans l’IDE Arduino.
D’autres librairies nécessitent d’être déclarées. Ce sera, par exemple, le cas de la librairie permettant de commander des servomoteurs.
 Ici, On va juste rajouter 3 lignes d’instructions.

Aucun changement au niveau structure.
 Coté syntaxe :

• une commande liée à une librairie prend la forme : Librairie.commande(données de la commande)
  
• «texte » : un texte placé entre cotes est considéré comme texte et n’est pas décodé
  

Coté vocabulaire :

• Serial.begin(9600) ; initialise la communication avec le moniteur série avec une vitesse de 9600 bauds.
  
• Serial.println(« texte ») affiche le texte entre cotes sur le moniteur série et passe à la ligne suivante.
  

 Donc, pour le Programme :

• dans la fonction setup(), on initialise la communication
  
• dans chacun des « sous paragraphes », on intègre la commande Seriel.println avec le texte à afficher
  

Une fois le programme chargé sur la carte, on affiche le moniteur (par le menu ou le raccourci clavier correspondant).
Voilà le résultat :

Hourra : ça s’affiche !
    Mais, pourquoi l’affichage défile si vite quand j’appuie sur un bouton ?
 
C’est normal. La fonction loop() du programme boucle rapidement et s’exécute plusieurs fois pendant l’appui du bouton. A chaque boucle, il affiche le message demandé.
 La solution : On crée une variable mémoire qui changera d’état à l’affichage du message :

• si mémoire = 0 et message « marche » à afficher, afficher message et mettre la mémoire à 1
  
• si mémoire = 1 et message « arret » à afficher, afficher message et mettre la mémoire à 0
  

 
 Et Voilà le résultat :

Pour télécharger le programme :    

 

On a vu qu’on pouvait afficher du texte, on va maintenant afficher du texte et la valeur de variables.
Pour cela, on va à nouveau déplacer le branchement de la Led de la broche 12 vers la broche 10 et on reprend le programme de gradateur vu précédemment. On va le compléter pour afficher la valeur lue en entrée et la tension résultante.


 Coté structure, rien de nouveau.
Coté syntaxe :
A l’intérieur d’une condition, avec la fonction if(condition), il est possible d’utiliser, en complément des opérateurs de comparaison, des opérateurs logiques et des calculs. Précédemment, nous avons vu l’opérateur de comparaison « == » qui permet de tester une égalité. Il y en a d'autres.
Les opérateurs de comparaison utilisables sont :

• ==  test d’égalité
  
• >    supérieur
  
• <    inférieur
  
• <=  inférieur ou égal
  
• >=  supérieur ou égal
  
• !=   différent de
  

 Les termes d’un comparaison peuvent être des calculs (par exemple : valeurlue – memoire).
 Les opérateurs logiques sont :

• &&        ET logique
  
• ||        OU logique
  
• !          NON
  

Dans notre exercice : Si la valeur lue – la mémoire est supérieure à 2 OU si la valeur lue – la mémoire est inférieure à -2 (en clair ; s’il y a une variation d’au moins 2 de la valeur lue en entrée), on affichage les informations. Sinon, on ne fait rien.
  
 Autre point de syntaxe :
 dans les fonction » avec des variables :

• une valeur entre cotes (exemple : « valeurLue = ») est considérée comme du texte
  
• une valeur sans cotes (exemple : valeurLue) est considérée comme une variable
  

Coté Vocabulaire :

• Serial.print affiche une information sans passage à la ligne suivantes
  
• Serial.println affiche une information et passe à la ligne suivante
  
• Si une valeur est imprimée, on peut préciser le nombre de décimales  - exemple : Seriel.print(tension,2)
  

Donc, les compléments intégrés dans le programme :

• Déclaration :
  
  • déclaration de la variable mémoire
    
• Setup()
  
  • initialisation de la communication avec le moniteur
    
• loop()
  
  • test de variation de la valeur lue : if(condition1 OU condition2). Si variation :
    
    • impression du texte « valeurLue = », puis impression de la variable valeurLue – aller à la ligne suivante
      
    • impression du texte « Tension = », puis impression de la variable tension avec 2 décimales, puis impression de «  V » - aller à la ligne suivante
      
    • sauter une ligne
      
    • mémoriser la valeur lue
      
  • attendre 0,5 seconde avant le prochain test (ici, evite d'avoir un affichage trop rapide)
    

Le résultat :


Pour télécharger le programme : 
 On dispose maintenant de presque toutes les notions qui vont nous permettre de commander des moteurs et donc de piloter nos modèles Meccano avec une carte Arduino.
 On pourra aussi contrôler ce qu’on fait avec le moniteur, ce qui facilitera la mise eu point.
Nota : même si le moniteur n'est pas activé, le programme fonctionne très bien.

Pour des programmes de démonstration simples ;, la fonction Delay() est interessante car elle permet de temporiser facilement. Le gros problème de cette fonction, et que le programme s’arrête durant le temps demandé et ne contrôle donc plus rien, mais ce qui est en marche continue de marcher..
Par exemple, si vous avez un capteur de fin de course sur un chariot de grue qui s’active alors que le moteur tourne, le fin de course ne pourra être vu qu’à la fin de la fonction Delay(). Il faut donc la bannir de nos programmes.
 Pour cela, Les nouveautés en Vocabulaire :

• L’utilisation d’une fonction baptisée millis(), qui comptabilise le temps en millisecondes depuis le lancement du programme.
  
• 2 nouveaux type de variables :
  
  • unsigned long : entier non signé long (valeur entre 0 et 4 294 967 295)
    
  • long : entier signé long (Valeur entre -2 147 483 647 et +2 147 483 647) . const indique une constante
    

Programme :

 3 nouvelles variables :

• temps = valeur instantanée de millis()
  
• mémoire_temps = mémorise la valeur du temps lors de l’affichage des messages
  
• intervalle : temps entre 2 affichage de messages
  

 
 dans loop() :

• si -temps – mémoire du temps) supérieur à l’intervalle (500 ms) , alors
  
  • mémoriser le temps
    
  • réaliser l’affichage comme dans le programme précédent
    

L’affichage se faii tous les 500 ms, s'il y a chagement de tension, comme précédemment, mais le programme tourne en permanence et peut contrôler d'autres choses.

Pour télécharger le programme :    

On avait aussi utilisé la fonction delay() dans le premier programme : Blink.
On va ici voir une autre solution permettant de supprimer cette fonction, et en profiter pour completer notre clignotant.
 2 nouveautés :

• l'opérateur « Modulo » symbolisé par le signe « % ». Le modulo donne le reste d’une division (Exemple : Modulo 5000 divisé par 4000 = 1000)
  
• on va aussi compléter la fonction if { } par « else if » (sinon si) et par « else » (sinon), ce qui permet d’avoir un traitement conditionnel complet.
  

Le programme :

• Setup()
  
  • Extinction des leds
    
• loop() : traitement sur modulo 4000
  
  • si modulo 4000 inférieur à 1000, allumer Led2
    
  • sinon si modulo 4000 inférieur à 2000, allumer Led1
    
  • sinon si modulo 4000 inférieur à 3000, éteindre Led2
    
  • sinon 3000, éteindre Led1
    

 Nota : Une fois une led allumée ou éteinte, elle reste dans le même état, tant qu’il n’y a pas d’autre commande.

Pour télécharger le programme : 
Maintenant, on va pouvoir piloter le moteur.
 

Un programme très simple : Un bouton poussoir, une voyant de contrôle, un potentiomètre, un moteur.

Pour commencer, une présentation plus détaillée de la carte Romeo qui équipe la platine de test.

1. Alimentation de puissance optionnelle pour servomoteurs
   
2. connecteurs 3 broches (Masse 0V, 5V, signal), permettant entre autre le branchement direct de servomoteurs
   
3. cavaliers permettant de valider les contrôleurs moteurs
   
4. Branchement Moteur 2 (bornier)
   
5. Branchement Moteur 1 (bornier)
   
6. Cavalier permettant d’alimenter la carte à partir de l’alimentation Moteurs
   
7. Alimentation Moteurs (bornier) 6 à 14Volts
   
8. connecteur permettant de commecter un module radio ou un module bluetooth
   
9. connecteurs 3 broches permettant de connecter directement certains capteurs
   
10. cavalier pour la connection des 5 boutons poussoirs sur l’en trée analogique 7 (nécessite une fonction de décodage dans le programme)
    
11. Boutons poussoirs
    
12. Alimentation normale de la carte (connecteur rond)
    
13. Connecteur 6 broches ICSP (je n’ai jamais utilisé)
    
14. Connecteur spécifique (je n’ai jamais utilisé)
    
15. Connecteur USB permettant la programmation de la carte et l’alimentation à partir de l’ordinateur.
    

L’utilisation des contrôleurs moteurs bloque l’utilisation de 4 broches dédiées à ces contrôleurs - par les cavaliers (3) :

• Broche 4 Sens Moteur 1
  
• Broche 5 Vitesse Moteur 1
  
• Broche 6 Vitesse Moteur 2
  
• Broche 7 Sens Moteur 2
  

Chaque moteur peut utiliser 2A.
 
Pour le programme, rien de compliqué. Aucune nouveauté :

  Déclaration :

• définition des broches (ici les broches 6 et 7 pour le moteur)
  

 setup() :

• Initialisation du bouton poussoir en entrée
  
• Initialisation de la leds et des broches moteurs en sortie
  

 loop() :

• lecture du bouton
  
• lecture du potentiomètre
  
• Si le bouton est appuyé (marche = HIGH)
  
  • Allumer la Led
    
  • Calculer la vitesse
    
• Si le bouton n’est pas appuyé
  
  • Éteindre la Led
    
  • Mettre la vitesse à 0 : Arret du moteur
    
• « écrire » la vitesse sur la broche « vitesse Moteur »
  
• Mettre la broche Sens à HIGH (sens avant)
  

 Voilà, ça n’est pas plus compliqué. Le moteur tourne et la LED s’allume sur appui du bouton. La vitesse varie en fonction du potentiomètre.

Pour télécharger le programme : 
  

Un programme plus complet. J’utilise ce programme systématiquement, adapté à chaque couple moteur / contrôleur, pour faire le réglage de chaque mouvement piloté d’un modèle.
Il commande le moteur (2 sens de rotation, vitesse variable) et affiche des informations de contrôle sur le moniteur, pour faciliter les réglages.

Nouveauté de Vocabulaire :
La fonction map( ) permet de lier une variable de sortie et une variable d’entrée par les valeurs hautes et basses :résultat = map(entrée, E1, E2, S1, S2)
exemples :

• vitesse = map(consigne, 0, 1023, 0, 255); revient à diviser par 4 « consigne » pour obtenir « vitesse »
  
  • quand le potentiomètre est à 0 la sortie est à 0
    
  • quand le potentiomètre est à 1023 la sortie est à 255
    
• vitesse = map(consigne, 0, 1023, 50, 255) ; permet de définir une valeur mini en sortie
  
  • quand le potentiomètre est à 0 la sortie est à 50 – le moteur tourne même si le potentiomètre est à 0
    
  • quand le potentiomètre est à 1023 la sortie est à 255
    
• vitesse = map(consigne, 0, 1023, 0, 150) ; permet de définir une valeur mini en sortie, et limiter la valeur en sortie
  
  • quand le potentiomètre est à 0 la sortie est à 0
    
  • quand le potentiomètre est à 1023 la sortie est à 150
    

Dans le dernier cas, cela permet d’utiliser un moteur Meccano 6V avec une batterie 12V. Le moteur sera piloté en 0 Volts et 7 Volts. Cette fonction permet de personnaliser le réglage de chaque moteur pour chaque sens et d’utiliser simplement des moteurs d’origines différentes pour un même modèle.
 
Le programme :

Déclarations :

• interH , interB broches pour interrupteur 3 positions ou boutons poussoirs
  
• M2, E2 broches dédiées au pilotage moteur
  
• marcheH, marcheB, Consigne valeur boutons et potentiomètre
  
• moteur2, vitesse2 valeurs de pilotage moteur
  
• mem_moteur2, mem_vitesse2 mémoires pour gérer l’affichage
  

setup() : initialisation des entrées/sortie et du moniteur série

 loop() :
3 "paragraphes" :
 Pilotage Moteur :

• lecture des entrées
  
• si bouton avant appuyé
  
  • le moteur est dans le sens 1
    
  • calculer la vitesse
    
  • positionner la broche de contrôle dans le sens avant
    
• si bouton arrière appuyé
  
  • le moteur est dans le sens -1
    
  • calculer la vitesse
    
  • positionner la broche de contrôle dans le sens arrière
    
• sinon
  
  • le moteur est dans le sens 0 - arrêt
    
  • vitesse = 0
    
  • positionner la broche de contrôle dans le sens arrière
    
• « impression » consigne vitesse moteur
  

 
Affichage sur moniteur :

• si le moteur est en marche et la mémoire à 0, imprimer un message en fonction du sens et la valeur de vitesse
  
• si le moteur et à l’arret et la mémoire différente de 0, imprimer le message arrêt
  

Affichage sur variation de vitesse

• si la vitesse à varié depuis 500 ms, forcer la mémoire moteur à 0 pour déclencher l’impression (par le bloc affichage).
  

 Une fois la mise au pont terminée, on peut mettre la partie affichage en commentaire.

Pour télécharger le programme :     

Avec la carte Roméo, il est très facile de brancher et de piloter un servomoteur.
 Pour une faible charge, l’alimentation par la carte est suffisante (ce qui est le cas sur la photo). Si on veut plus de puissance, on peut brancher une alimentation externe 6V prévue à cet effet (bornier à l’avant sur cette photo.

  
 Pour piloter le servo simplement, on va utiliser une librairie qui sera utilisée par le programme Arduino en complément de notre programme. Pas besoin de se casser la tête.
  
 Un peu de [/size]vocabulaire :

• #include <librairie.h> utiliser la librairie « librairie » dans notre exemple : servo.h
  
• Servo « nom du servo » définit un servo par son nom. Ce nom sera utilisé avec les fonctions de la librairie
  
• « nom de servo ».attach (broche) indique à la carte qu’un servo est connecté sur cette broche. Le servo se fige
  
• « nom du servo ».write(angle) définit l’angle dans le quel on veut positionner le servo
  
• « nom du servo ».detach (broche) libérer le servo . Le servo n’est plus commandé.
  

 
 Pour le programme :

 déclaration :

• utiliser la librairie servo
  
• Broche du servo = 10
  
• déclaration du servo1
  

 setup() :

• définir la broche du servo en sortie
  
• initialiser le servo connecté à cette broche
  
• initialiser le moniteur série
  
• envoyer un message
  

 
loop() :

• lire le potentiomètre
  
• calculer la valeur de sortie du servo de 0 à 180 (fonction map)
  
• envoyer le signal au servo
  
• imprimer un message de contrôle (texte + variable)
  
• delay(50) : ne sert juste qu’à ralentir le programme, donc l’affichage
  

 L’affichage permet de repérer les positions extrêmes que l’on veut utiliser, en ensuite de les intégrer dans la fonction map.
Exemple : sortie = map ( valeurlue , 0 , 1023, 15 , 150) fera tourner le servo de 15 à 150 degrés en fonction du potentiomètre.

Pour télécharger le programme :   

Pour répondre entre autre au besoin de pilotage de moteurs avec des Joysticks (émis par Yves) et montrer d'autres possibilités, j'ai ressorti une platine de test un peu plus complète (ma platine Instructeur lors des ateliers Arduino que j'animais).

Avant de parler  programmes, la platine :


un des joysticks que j'ai commandé récemment chez Gotronic (j'y trouve un grand choix de modules) :
5 broches (de bas en haut) :

• la Masse (0V)
  
• L’alimentation + 5V
  
• le potentiomètre 1
  
• Le potentiomètre 2
  
• le poussoir commandé par appui sur le Joystick
  

un rotacteur - un commutateur 12 positions qui se câble comme un potentiomètre avec 12 positions). je l'utilise dans ma grue ferroviaire comme sélecteur de modes de fonctionnement :

2 moteurs meccano, dont un est équipé d'une fourche optique en face des trous de la roue barillet (ce qui permet entre autre de réaliser un compte tours) :

Je vais essayer de présenter divers programmes. un des objectifs à terme :

• Utiliser au choix plusieurs types de commandes différents (Interrupteurs et potentiomètres, joysticks, télécommande infrarouge, radiocommande)
  
• Utiliser 2 types d'actionneurs différents  : moteur pour commande directe de mouvements, servomoteur pour commande des leviers d'un système mécanique de commande, comme il y aura sûrement sur la grue hachette
  
• Proposer une structure modulaire permettant d'associer ces différents équipements au choix.
  
• Pouvoir utiliser plusieurs modes de commandes sur un même modèles
  

Ça ne se fera pas en un jour.

Autre objectif : comme j'utilise le moins possible le fer à souder : Piloter une maquette essentiellement par assemblage de modules reliés entre eux par des fils, comme en Meccano, on assemble des pièces avec des boulons.
 

Bonsoir Marc
Diable! quelle complexité! J'attends la suite.
Bonne fin de soirée
Yves

Ce programme a pour but de lire les valeurs en provenance du joystick et de créer les valeurs qui vont permettre de commander un moteur et/ou un servomoteur.
Pour contrôler le fonctionnement, l’affichage est fait sur le moniteur série de l’IDE Arduino.
 Le Joystick est constitué de 2 potentiomètres raccordés aux broches d’entrées analogiques A4 et A5 et d’un bouton poussoir raccordéé sur la broche 11 de la carte Roméo.
Chaque potentiomètre donne une tension comprise entre 0 et 5 Volts. Au repos, les potentiomètres sont en position médiane et la tension de sortie est d’environ 2,5 Volts. L’entrée analogique transforme cette tension en une valeur de 0 à 1023. La valeur au repos est donc d’environ 512 pour chaque entrée.Ces valeurs ne sont pas très précises. Il faut en tenir compte, en créant une « plage morte de -25 à +25 autour du 512 théorique.
 Un appui sur le bouton donne une valeur 0V. Au repos, l’entrée correspondante est forcée à +5 Volts. Dans ce programme, un appui sur le bouton allume la LED câblée en sortie 13.
Le programme :
 
Partie Déclaration :
Définition des broches entrées/ sorties utilisées (il suffit de changer les valeurs #define en fonction du cablge réalisé
Définition des variables ( x = N° de potentiomètre) :

• marche (valeur 1 si bouton relaché, valeur 0 si Appui sur le bouton)
  
• ValeurPx      valeur lue en entrée de la carte sur le potentiomètre x ( 0 à 1023 )
  
• joystickx     valeur ( -512 à + 511), 0 correspondant à la position centrale théorique du joystick
  
• vitessex       vitesse du moteur commandé (0 à 255)
  
• sensx           Sens de rotation du moteur commandé valeurs -1, 0, 1
  
• positionx      angle demandé au servomoteur (0 à 180)
  
• posx             Valeur de commande du servomoteur (0 à 255)
  
• mémoirex     mémoire de la valeur précédente pour n’afficher que s’il y a un changement de valeur
  

Setup() :

• déclarer le bouton en entrée et définir sa résistance de pull-up
  
• déclarer la led en sortie
  
• déclarer la liaison vers le moniteur série
  

 
Loop() :

• Lire les entrées analogiques
  

Pour commander des moteurs :

• Calculer les variables Joystick (-512 à +511)
  
• Calculer la vitesse moteur : 3 fonctions imbriquées :
  
  • abs : prendre la valeur absolue de la variable Joystick
    
  • constrain : borner cette valeur entre 25 et 450 (si joystick < 25, alors forcer à 25 – Si joystick > 450 alors forcer à 450)
    
  • map convertir l’intervalle 25 – 450 en intervalle 0 -254 (voir un des messages précédents qui pr)
    
• Calculer le sens
  
  • si la valeur joystick est entre -25 et + 25 : Arret moteur
    
  • SI > 25 : sens Avant
    
  • si < 25 : sens arrière
    

Pour commander des servomoteurs :

• utiliser la fonction map() pour transformer les valeurs (0 à 1023) aux angles souhaités (ici 0 à 180 °, mais on peut choisir l’angle mini et l’angle maxi en modifiant les 2 derniers paramètres de la fonction MAP (Exemple: si je veux que mon servo évolue entre 15° et 135° : map (valeurPx,0,1023,15,135). pour les valeurs posx – faire une petite règle de 3 pour la valeur de sortie).
  

Contrôler la Led avec le bouton poussoir
 
afficher es valeurs à l’écran (fonctions déjà étudiées dans les messages précédents).
 
La fonction Delay() permet de ralentir l’affichage. Exemple d’affichage :

Le programme et téléchargeable ici :    

Je viens de modifier tous les messages de ce sujet contenant un programme. Chaque programme de test est maintenant téléchargeable.

Décompresser le dossier, double cliquer sur le fichier avec l'extension .ino.
Si l'IDE Arduino est sur votre poste, il devrait s'ouvrir automatiquement.

 

Vraiment passionnant ! Merci beaucoup pour ce travail et pour votre talent !  

Pas de notion nouvelle.Ce programme reprend le programme précédant au quel on a ajouter les  2 commandes de moteurs (proches de celui déjà présenté et d’un affichage de contrôle (déjà présentés en détail plus haut.
Déclaration :
ajout de  :

• 4 #define pour définir les sorties moteurs utilisées sur la carte Romeo
  
• 2 mémoires Vitesse utilisées pour l’affichage
  

Setup() :ajout : initialisation des 2 sorties de contrôle du sens Moteur (les sorties analogiques n »ont pas besoin de l’être)  loop() :
La première partie reprend le programme précédant et permet de calculer les variables qui vont piloter les moteurs.  
La deuxième partie contrôle les moteurs :

• en fonction du sens moteur positionner la sortie correspondante du moteur (1 : avant – 0 : arrêt ou arrière)
  
• forcer la consigne à 0 si sens = 0
  

 La troisième partie permet un affichage de contrôle que l’on peut mettre en commentaire quand tout fonctionne correctement. Ci dessous l’affichage pour le premier moteur (son fonctionnement a déjà été expliqué plus haut.
 
Voilà le résultat de l’affichage :
 Si le câblage est conforme, les 2 moteurs tournent en fonction de la position des joysticks

Pour télécharger le programme :  

Merci Marc, je regarde tout ça ce soir-
Yves

Bonsoir Marc,
Pas de miracle un beau message d'erreur en rouge qui ne se copie pas. Mais j'ai sans doute deux erreurs:
1) port série mal formaté
2) branchement mal faits.
Pour l'instant juste le fichier  "ino" modifié car je n'ai si servo moteur, ni led.
Merci d'avance pour ton aide.
Yves

Copie de Erreur Arduino:

Le script

//#define bouton 2     // Bouton Joystick sur broche 11   
//#define led 2
int marche;

#define potar1 0     // 2 potentiomètres, branchés sur broches analogiques 4 et 5
#define potar2 1
int valeurP1;        // valeur lue (0 à 1023)
int valeurP2;
int joystick1;       // ValeurJoystick (-512 à +511)
int joystick2;
int vitesse1;            //vitesse calculée pour moteur (0 à 255)
int vitesse2;
int sens1;                //sens de marche calculé pour moteur (-1, 0, 1)
int sens2;

int position1;           //positionnement d'un servo moteur 0 à 180°
int pos1;                //Valeur de sortie correspondante
int position2;
int pos2;

#define E1 5             //Moteur1 Controle de vitesse PWM
#define M1 4             //Moteur1 Controle du sens de rotation
#define E2 6             //Moteur2 Controle de vitesse PWM
#define M2 7             //Moteur2 Controle du sens de rotation

int memoire1 = 0;        //mémoires pour affichage
int memoire2 = 0;
int mem_vitesse1 =0;
int mem_vitesse2 =0;

void setup()
{
//  pinMode(bouton, INPUT);
//  digitalWrite(bouton, HIGH);  //bouton avec resistance de pull-up
//  pinMode(led, OUTPUT);
  Serial.begin(9600);
  pinMode(M1, OUTPUT);        //sorties tout ou rien
  pinMode(M2, OUTPUT);
 
}

void loop()
{
//chaque axe du joystick est un potentionmetre.
//Le point milieu au repos donne donc environ 2,5 V, soit la valeur 512

valeurP1 = analogRead(potar1);    //Lecture potentiometres Joystick (0 à 1023)
valeurP2 = analogRead(potar2);
joystick1 = valeurP1 - 512;       //convertir en valeur Joystick (-512 à + 511)
joystick2 = valeurP2 - 512;

//Calcul vitesse et sens moteur
//le point 0 est situé entre -25 et + 25. la valeur maxi est de 450.
//constrain() permet de neutraliser le point 0 non stable
//map permet de normaliser la valeur entre 0 et 255 pour piloter un moteur CC

vitesse1 = map(constrain(abs(joystick1),25,450),25,450,0,254);
if (joystick1 >= 25) {sens1 = 1;}
else if (joystick1 <= -25) {sens1 = -1;}
else {sens1 = 0;}

vitesse2 = map(constrain(abs(joystick2),25,450),25,450,0,254);
if (joystick2 >= 0) {sens2 = 1;}
else if (joystick2 <= -25) {sens2 = -1;}
else {sens2 = 0;}

//commande pour un servomoteur

pos1 = map(valeurP1,0,1023,0,255);        //valeur pour servo
position1 = map(valeurP1,0,1023,0,180);   //angle Servo

pos2 = map(valeurP2,0,1023,0,255);
position2 = map(valeurP2,0,1023,0,180);

//marche =  digitalRead(bouton);       // allumage de la led avec le BP du joystick
if (marche == HIGH)
  //{digitalWrite(led, LOW);}
//else
//  {digitalWrite(led, HIGH);}
 
//Moteur 1  
  if (sens1 == 1)      
  {     
   digitalWrite(M1,HIGH);
  }
else if (sens1 == -1)
  {
  digitalWrite(M1,LOW);
  }
else  
  {     
  vitesse1 = 0;
  digitalWrite(M1,LOW);
  }
analogWrite (E1,vitesse1);                    //envoi consigne

//Moteur 2  
  if (sens2 == 1)           
  {     
   digitalWrite(M2,HIGH);
  }
else if (sens2 == -1)
  {
  digitalWrite(M2,LOW);
  }
else  
  {     
  vitesse2 = 0;             //si arret, forcer la vitesse à 0
  digitalWrite(M2,LOW);
  }
analogWrite (E2,vitesse2);                    //envoi consigne

//Affichage pour controle
if (sens1 != 0)
  {
  if (memoire1 == 0)                      //si le moteur vient de démarrer
    {
    if (sens1 == 1)
      {
      Serial.print("M1 avant      ");        // afficher l'état marche
      Serial.println(vitesse1);
      }
    else
      {
      Serial.print("M1 arriere      ");    
      Serial.println(vitesse1);
      }
    memoire1 = 1;
    }
  }
else
  {
  if (memoire1 == 1)
    {
    Serial.println("M1 arret");                // afficher l'état arret
    memoire1 = 0;
    }
  }
 
//si la vitesse varie, mettre la mémoire à 0 pour forcer l'affichage
//affichage possible toutes les 500 ms

if ((memoire1 == 1) && (vitesse1 != mem_vitesse1) && (millis() % 500 < 1))  
  {
  mem_vitesse1 = vitesse1;
  memoire1 = 0;
  }

if (sens2 != 0)
  {
  if (memoire2 == 0)                      //si le moteur vient de démarrer
    {
    if (sens2 == 1)
      {
      Serial.print("M2 avant      ");        // afficher l'état marche
      Serial.println(vitesse2);
      }
    else
      {
      Serial.print("M2 arriere      ");    
      Serial.println(vitesse2);
      }
    memoire2 = 1;
    }
  }
else
  {
  if (memoire2 == 1)
    {
    Serial.println("M2 arret");                // afficher l'état arret juste après l'arret
    memoire2 = 0;
    }
  }
 
if ((memoire2 == 1) && (vitesse2 != mem_vitesse2) && (millis() % 500 < 1))
  {
  mem_vitesse2 = vitesse2;
  memoire2 = 0;
  }

}

Le message
Arduino : 1.8.6 (Windows 7), Carte : "Arduino Leonardo"


Le croquis utilise 5830 octets (20%) de l'espace de stockage de programmes. Le maximum est de 28672 octets.
Les variables globales utilisent 257 octets (10%) de mémoire dynamique, ce qui laisse 2303 octets pour les variables locales. Le maximum est de 2560 octets.
Found programmer: Id = ""; type = à
    Software Version =
Found programmer: Id = ""; type = à
    Software Version =

Software Version = .à; Hardware Version = à.à

Il n'y a pas d'autre message d'erreur ?
Déjà 2 anomalies :
"
//marche =  digitalRead(bouton);       // allumage de la led avec le BP du joystick
if (marche == HIGH)
  //{digitalWrite(led, LOW);}
//else
//  {digitalWrite(led, HIGH);}
"
if (marche == HIGH)   n'est pas mis en commentaire.

Sur la Leonardo V2, il vaut mieux ne pas utiliser l'entrée A0, qui est par défaut utilisée pour les boutons poussoirs intégrés à la carte. Si c'est une V1 il faut la définir en tant que UNO.

Idéalement, il faudrait utiliser le script en ne changeant que les valeurs de #define en fonction du câblage.
 

Merci- Je regarde tout ça demain.
Bonne fin de soirée
Yves

Bonjour Marc,

ça marche; pour moi, c'est toujours un petit miracle, car je ne comprends pas tout!!!
Merci et bonne journée.
Yves

Cet exemple est dans la lignée des précédents. on reprend le programme lecture Joystick et commande de 2 moteurs. On enlève le moteur 2 et on le remplace par une commande de servomoteur.
L’affichage est adapté pour indiquer la position du servomoteur.
Déclaration / Initialisation :
Lecture Joystick - Commande moteur et servo
Affichage de controle :
Résultat sur moniteur de contrôle :

Pour télécharger le programme :

 

Au niveau d ‘un modèle, il peut être intéressant de gérer plusieurs modes de fonctionnement. Par exemple sur ma grue de dépannage ferroviaire, j’utilise 6 modes de fonctionnement :

• Mode 1 : Marche manuelle Crochet lourd
  
• Mode 2 : Marche manuelle Crochet Léger
  
• Mode 3 : Marche manuelle Flèche
  
• Mode 4 : Marche manuelle Rotation
  
• Mode 5 : Arrêt complet
  
• Mode 6 : Marche grue avec la radiocommande
  

Pour la marche manuelle, j’utilise un interrupteur 3 positions et un potentiomètre.
 Pour sélectionner le mode de fonctionnement, j’utilise un « rotacteur », c’est à dire un commutateur 12 positions basé sur un potentiomètre. Celui ci est branché sur une entrée analogique de la carte Arduino. Comme d’un rotacteur à l’autre, les tensions en entrée ne sont pas exactement les mêmes, il faut d’abord le calibrer, repérer les valeurs d’entrée (de 0 à 1023) associées à chaque position.

 Programme de calibrage du rotacteur :
Ce programme est très simple : S’il y a variation de la tension (changement de position), j’affiche le voltage et la valeur d’entrée.
Cet affichage va me permettre de calculer les seuils que je vais utiliser pour calculer la position :

 Le programme suivant calcule la position du rotateur et l’affiche sur le moniteur série.
Notion nouvelle : Pour cela, j’utilise une « fonction ». cette fonction constitue une quatrième partie de mon programme. Elle est utilisée dans loop(), comme une variable particulière.Elle est définie et calculée après la partie loop() :

• int position_rotacteur() : definition de le variable « position-rotacteur » calculée par la fonction
  
• Ensuite, définition des variables « positionC » et « valeurlue » internes à la fonction.
  
• Lecture de l’entrée rotacteur (broche A3 définie plus haut).
  
• Une suite de test de seuils permettant de calculer « positionC
  
• return positionC : renvoie le résultat dans la variable « position_rotacteur()
  

l'affichage résultant :

Le programme de calibrage : Le programme de calcul :  

Le programme suivant reprend intégralement le programme précédant. J’y ai ajouté le nouvelle commande qui permet de sélectionner quelle partie de programme sera exécutée en fonction d’une variable.

La variable testée est « posit ».
switch (posit) tester la variable posit
 case(1) : lance l’exécution des lignes de programme qui suivent, jusque la commande break
 default : lance l’exécution des lignes si la valeur ne correspond à aucun des cas prévus.
 Break : fin de traitement de la fonction switch


le programme :