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

[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

  

[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

 

[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.
 

[yvespetit86]

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

[marc80]

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
  

ex1-debut.png

 
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

ex1-calculs.png

 
afficher es valeurs à l’écran (fonctions déjà étudiées dans les messages précédents).

ex1-affichage.png

 
La fonction Delay() permet de ralentir l’affichage. Exemple d’affichage :

ex1-moniteur.png

Le programme et téléchargeable ici :  

Lecture_JoyStick.zip

 

[marc80]

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.

 

[Suzimentvotre]

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

[marc80]

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)

ex2-debut.png

 loop() :
La première partie reprend le programme précédant et permet de calculer les variables qui vont piloter les moteurs.

ex2-lecture.png

 
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
  

ex2-moteurs.png

 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.

ex2-affichage.png

 
Voilà le résultat de l’affichage :

ex2-moniteur.png

 Si le câblage est conforme, les 2 moteurs tournent en fonction de la position des joysticks

Pour télécharger le programme :

Commande_2_moteurs_Joystick.zip

 

[yvespetit86]

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

[yvespetit86]

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

erreur Arduino.docx