Découverte Arduino : Platine de test - programmation pour pilotage moteurs

Tout ce qu'il faut savoir pour radio-commander vos modèles de voitures, robots, tractopelle, etc..
Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : Platine de test - programmation pour pilotage moteurs

Message par marc80 »

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.

IMG_20160927_094044.resized.jpg

 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.

platines.jpg

Votre avis est le bienvenu.

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

 
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Désactivé

Re: Découverte Arduino : Une platine de test

Message par Désactivé »

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é ... )

Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : La carte Roméo

Message par marc80 »

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

Arduino V2.jpg

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 :
Grue tour.jpg



 
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Avatar du membre
Reno
Modérateur
Modérateur
Messages : 620
Enregistré le : 03 août 2020, 10:33
Localisation : Cesson-Sévigné / antérieurement CAMBRIDGE
Contact :

Re: Découverte Arduino : Une platine de test

Message par Reno »

Bravo Marc !

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

A+
Cordialement,
Reno. 
RENO vous présente son nouveau site ; 9 chapitres d'électronique appliquée, Théorie et Pratique
et un Forum interactif. Accés gratuit.  
https://www.john-velly-thekit.eu

Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : Un premier programme - BLINK

Message par marc80 »

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 :
 
ex1_Blink.jpg
 
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 :
boutons.png

Pour télécharger le programme : [/size]
Blink1.zip
 
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Mordu
Membre Habitué
Membre Habitué
Messages : 45
Enregistré le : 03 août 2020, 16:00

Re: Découverte Arduino : Une platine de test

Message par Mordu »

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

Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : petite révision - programme blink2

Message par marc80 »

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

ex2_Blink2.jpg

 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 :
Blink2.zip
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : Utiliser des boutons poussoirs

Message par marc80 »

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).
  
ex3_BPLeds.png
  
 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 :  
BPsLeds.zip
 
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : Un gradateur

Message par marc80 »

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.

ex4_gradateur_simple.png
[/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 :   
gradateur_simple.zip
 
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Avatar du membre
marc80
Modérateur
Modérateur
Messages : 424
Enregistré le : 27 juil. 2020, 14:22
Localisation : 80500 Montdidier

Découverte Arduino : Menu IDE Arduino

Message par marc80 »

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 :
menu_fichiers.png
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 :
 
menu_type_carte.png
 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 :
 
menu_port.png
 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 :
 
menu_moniteur.png
 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.
moniteur.png
 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.




 
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Bon Meccano à tous ! :020:  Marc
 

Répondre