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 : telecharger et installer l'IDE

Message par marc80 »

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 le moniteur série

Message par marc80 »

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.

ex5_BPLeds_ecran1.png
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 :
moniteur_MA.png

Hourra : ça s’affiche ! :R_CHAM~1: :R_CHAM~1:
  :010105angry_hair: :010105angry_hair:  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
 
ex5_BPleds_écran2.png

 Et Voilà le résultat :
moniteur_MA_mem.png

Pour télécharger le programme :  
BPsLeds_avec_ecran.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 : afficher des valeurs sur le moniteur

Message par marc80 »

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.

ex6_gradateur.png

 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 :

moniteur_gradateur.png

Pour télécharger le programme : 
BPsLeds_avec_ecran_et_memoire.zip

 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.
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 : Corriger une hérésie - Delay()

Message par marc80 »

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 :
ex7_gradateur sans delay.png

 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 : 
gradateur_sans_delay.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 : Clignotement revisité sans delay()

Message par marc80 »

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 :
ex7_blink_sans_delay.png
  • 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 : 
blink_sans_delay.zip

Maintenant, on va pouvoir piloter le moteur.
 
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 : Pliloter un moteur - 1 seul sens

Message par marc80 »

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.
RomeoV1_photo.jpg

RomeoV1_schema.png
  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é :

 
ex8_moteur_simple.png
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 : 
controle_moteur_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

Arduino : Programme complet pilotage Moteur

Message par marc80 »

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

ex9_1.png
 loop() :
3 "paragraphes" :
 Pilotage Moteur :
ex9_2.png
  • 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
 
ex9_3.png

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).
ex9_4.png
 Une fois la mise au pont terminée, on peut mettre la partie affichage en commentaire.

Pour télécharger le programme :  
controle_moteur_2.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

Arduino : Pilotage d'un servomoteur

Message par marc80 »

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.

  
servo_branché.jpg

 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 :

ex10.png
 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 : 
Servo_pilote_par_potar.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 : Platine de test completée - 2 moteurs

Message par marc80 »

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 :
IMG_20210208_115553.jpg
IMG_20210208_115623.jpg


un des joysticks que j'ai commandé récemment chez Gotronic (j'y trouve un grand choix de modules) :
IMG_20210208_115617.jpg
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 :
IMG_20210208_115631.jpg

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) :
IMG_20210208_115722.jpg

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

yvespetit86
Membre Expérimenté
Membre Expérimenté
Messages : 389
Enregistré le : 30 août 2020, 17:37
Localisation : Migné-Auxances

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

Message par yvespetit86 »

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

Répondre