Commande d`Arduino Uno

TP PCSI – CI6
Commander des systèmes et acquérir des
données avec une carte Arduino Uno
CI6 :
Proposer et valider une solution de
l’organisation de la commande d’un
système logique ou numérique.
À l’issue de ce TP, les compétences acquises doivent vous permettre plus particulièrement de :
–
–
–
–
–
–
–
Exprimer le fonctionnement par un ensemble d’équations logiques
Identifier les entrées et sorties d’un système logique
Analyser et décrire le comportement attendu
Exprimer le comportement attendu (représentation technique imposée)
Réaliser les fonctions logiques (représentation technique imposée)
Tester la réalisation de fonctions logiques et valider par rapport au CdC
Valider le fonctionnement d’une fonction logique par câblage ou simulation
page 1
TP PCSI – CI6
Table des matières
1
Problématique
1.1 Commande de systèmes par micro-contrôleurs . . . . . . . . . . . . . . . . . .
1.2 Présentation de la carte Arduino Uno . . . . . . . . . . . . . . . . . . . . . . .
1.3 Toolbox Arduino sous Scilab – Xcos . . . . . . . . . . . . . . . . . . . . . . . .
3
3
3
4
2
Commande de l’allumage d’une LED
2.1 Par interface Arduino (langage C) . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Par interface graphique Scilab – Xcos . . . . . . . . . . . . . . . . . . . . . . . .
4
4
4
3
Programmation de la lecture d’un port analogique (potentiomètre)
3.1 Par interface Arduino (langage C) . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Par interface graphique Scilab – Xcos . . . . . . . . . . . . . . . . . . . . . . . .
6
6
6
4
Programmation du pilotage de la puissance de la LED avec le potentiomètre
4.1 Par interface Arduino (langage C) . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Par interface graphique Scilab – Xcos . . . . . . . . . . . . . . . . . . . . . . . .
6
6
7
5
Commande d’un moteur à courant continu en boucle ouverte
5.1 Par interface Arduino (langage C) . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Par interface graphique Scilab – Xcos . . . . . . . . . . . . . . . . . . . . . . . .
8
8
9
6
Lecture du codeur incrémental
6.1 Par interface Arduino (langage C) . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Par interface graphique Scilab – Xcos . . . . . . . . . . . . . . . . . . . . . . . .
9
9
10
7
Commande du moteur en boucle fermée
11
page 2
TP PCSI – CI6
1
Problématique
1.1
Commande de systèmes par micro-contrôleurs
Les parties commandes des système actuels sont réalisées avec des cartes micro-controleurs
permettant de piloter des sorties en fonction de l’état des entrées. Nous allons utiliser la platine Arduino afin de programmer un micro-controleur dans des situations simples (acquisition de la valeur d’un potentiomètre, allumer une led, piloter un moteur...).
1.2
Présentation de la carte Arduino Uno
Une carte Arduino Uno comporte les ports (pins en anglais) suivants :
– 14 (+6) Entrées – Sorties logiques (port ou « pin Digital » de 0 à 13) :
– série asynchrone (avec 0 sur Rx et 1 sur Tx) : les
pins 0 et 1 ne seront donc pas utilisables
– 2 Interruptions externes sur 2 et 3 (utilisées pour
le codeur en quadrature)
– Sortie 13 couplée à une LED sur la carte
– 6 Entrées analogiques (A0 à A5) :
– la tension d’entrée doit nécessairement être inférieure à la tension de référence (5 V ou 1,1 V ou
AREF : référence externe)
– 6 CAN 10 bits (plage de 1024) à 10kHz maximum
– ces entrées peuvent aussi fonctionner comme des
E/S numériques
– 6 Sorties « Analogiques » : 6 PWM sur les ports 3,
5, 6, 9, 10 et 11, construites sur les pins d’entréessorties logiques
Q 1 : Identifer les ports détaillés ci-dessus sur la carte réelle.
La programmation de toutes les cartes de la famille Arduino, dont le modèle Uno utilisé dans le cadre de cette séance, se fait dans un langage simplifié adapté du C/C++, basé
sur l’utilisation de « classes » (ou macro-commandes) faciles à comprendre et à modifier, y
compris par des personnes non spécialistes de la programmation.
Le projet « Open Source » Arduino a en effet initialement été créé pour la mise en œuvre
d’environnements sonores ou visuels à destination de créations artistiques, il était indispensable que l’interface soit réduite à la mise en œuvre séquentielle d’ordres simples et
l’acquisition de données analogiques ou numériques.
Le logiciel de programmation, gratuit et utilisable sans installation sur l’ordinateur sur
les environnements Windows, MacOS ou Linux, est téléchargeable en ligne à l’adresse http ://Arduino.cc/en/Main/Software. Sur ce même site, le guide d’installation est aussi disponible
(http ://Arduino.cc/en/Guide/HomePage). Par ailleurs, sur Internet, la littérature est fournie.
Comme les mémoires sont de type Flash, le programme reste « indéfiniment » en mémoire, même sans alimentation, après son implantation dans le micro-contrôleur : pour
charger le programme, la liaison USB permet de communiquer avec le micro-contrôleur
à travers une liaison série.
page 3
TP PCSI – CI6
1.3
Toolbox Arduino sous Scilab – Xcos
Une toolbox Arduino a été développée dans Scilab – Xcos. La gestion de la liaison série
est intégrée à la toolbox. Pour faire fonctionner la toolbox, il faut aussi préalablement charger le programme toolbox_Arduino.ino dans l’Arduino. L’Arduino est alors prêt pour être
interfacé avec Scilab et Xcos.
2
Commande de l’allumage d’une LED
2.1
Par interface Arduino (langage C)
Brancher la carte Arduino Uno grâce au câble USB. Retenir le port COM utilisé. Le numéro port COM doit être inférieur à 9 (si ce n’est pas le cas, il faut le changer dans les
paramètres avancés).
Lancer le logiciel Arduino puis vérifier dans le menu déroulant « outils » que le type de
carte et le port COM sont correctement sélectionnés.
Ouvrir l’exemple blink dans fichierexemples01.basics puis téléverser (charger) le programme dans l’Arduino : le téléversement consiste à compiler le programme puis le transmettre à l’Arduino.
Q 2 : Vérifier que cet exemple permet de faire clignoter la diode associé au pin 13 à une
fréquence de 0,5 Hz.
Un programme Arduino comporte au moins 2 fonctions principales :
– setup() : la fonction qui est exécutée dès la connexion sur le port série a été réalisée
– loop() : la fonction qui tourne en boucle dès la fonction setup terminé
Matériel à disposition : une platine Labdec, une LED et une résistance et des petits câbles.
Q 3 : Modifier le programme pour allumer la diode fournie (diode associée à une résistance, voir figure 1) à brancher sur un des ports numériques (ou « pin digital ») en mettant
le fil noir sur la masse GND et le fil rouge sur la sortie logique choisie. Téléverser et vérifier
le fonctionnement.
Remarque : il est possible de tester le sens passant de la diode en la reliant directement au 5 V.
F IGURE 1 – Schéma électrique du montage de la LED.
2.2
Par interface graphique Scilab – Xcos
Sous Scilab, à partir du module Arduino, glisser dans la fenêtre Xcos :
– Un bloc de configuration du port : double-cliquer dessus pour définir le port COM
auquel est relié l’Arduino.
– Un bloc d’échantillonnage : il permet de spécifier le temps de simulation ainsi que la
fréquence d’échantillonnage .
page 4
TP PCSI – CI6
– Un bloc commandant une sortie logique (digitale) de l’Arduino.
– Une entrée PULSE : à partir du module CPGE et à configurer pour avoir un clignotement de 1 seconde.
Bloc de configuration du port :
Bloc d'échantillonage :
Bloc de commande sortie logique
digitale :
Entrée pulse (module CPGE) :
F IGURE 2 – Blocs Xcos à utiliser.
On pourra dans un premier temps utiliser la diode de la carte Arduino associée au port 13.
Q 4 : Paramétrer les blocs introduits (on gardera la fréquence d’échantillonnage par
défaut) et relier l’entrée Pulse et la sortie logique.
Lancer la simulation et vérifier le bon fonctionnement : les deux diodes Rx et Tx sur la
carte doivent indiquer la communication série entre Xcos et l’Arduino tandis qu’une troisième diode reliée au pin paramétré doit clignoter.
On propose maintenant de commander le clignotement de la LED par appui sur un bouton poussoir, qui sera câblé en utilisant une résistance de tirage (pull up) (voir figure 3).
F IGURE 3 – Schéma électrique du montage du bouton poussoir.
Q 5 : Remplacer l’entrée Pulse par un bouton poussoir en utilisant le bloc "digital read".
Brancher le bouton poussoir en reliant la masse (le fil noir) à GND (niveau logique bas),
le fil rouge au +5V (niveau logique haut) et le fil bleu sur la pin digitale de votre choix, en
concordance avec votre déclaration dans le bloc digital read.
Relier l’entrée et la sortie logique, correspondant au bouton poussoir et à la diode, de
façon à l’allumer à chaque appui.
Vérifier le bon fonctionnement.
page 5
TP PCSI – CI6
3
3.1
Programmation de la lecture d’un port analogique (potentiomètre)
Par interface Arduino (langage C)
Brancher le potentiomètre sur la platine Labdec. Relier : la patte extérieure à 0 V (masse),
la patte intérieure à 5 V et patte du milieu à relier à une entrée analogique.
F IGURE 4 – Photo du potentiomètre.
Q 6 : Modifier le programme dans la fonction loop() :
– Ajouter la lecture du port analogique : val = analogRead(pin), où pin est le numéro de
l’entrée analogique (il faut tout d’abord déclarer la variable val de type entier : int val).
– Ajouter l’écriture sur le port série de la valeur lue : Serial.println(val) pour écrire la
valeur val et ajouter un retour à la ligne automatiquement.
– Modifier la pause et mettre 100 ms.
– Modifier la fonction setup () en ajoutant l’initialisation du port série : Serial.begin(115200).
Q 7 : Compiler et téléverser le programme. Quelles sont les valeurs prises par la sortie
du potentiomètre ? Justifier.
3.2
Par interface graphique Scilab – Xcos
Q 8 : Ouvrir le fichier potentiomètre et double-cliquer sur l’entrée analogique pour spécifier le numéro de pin.
Lancer la simulation et faire tourner le potentiomètre.
Quelles sont les valeurs prises par la sortie du potentiomètre ? Justifier.
4
4.1
Programmation du pilotage de la puissance de la LED avec
le potentiomètre
Par interface Arduino (langage C)
Avant de continuer, s’assurer que la LED est relié à une sortie analogique PWM (3, 5, 6,
9, 10, 11).
Les sorties PWM (ou MLI pour modulation de la largeur d’impulsion, voir figure 5) codées sur 8 bits permettent de créer un signal de commande périodique qui sera à 5V pendant
x% de la période et à 0V le reste du temps. La période étant très courte, cela donnera l’impression de de faire varier la tension de 0 à 5V de manière continue.
page 6
TP PCSI – CI6
F IGURE 5 – Principe du signal de commande PWM.
On trouvera une application flash présentant le fonctionnement d’un hacheur série sur
la page ??http ://fisik.free.fr/ressources/hacheurserie.swf.
Q 9 : Modifier le programme de façon à allumer la LED avec une tension proportionnelle
à la valeur lue sur le potentiomètre : pour cela, utiliser la fonction analogWrite(pin, val_out).
Il faut faire attention : la valeur val_out est forcément comprise entre 0 et 255 alors que la
valeur val lue sur le port analogique est comprise entre 0 et 1024.
Remarque : Attention, si les variables sont des entiers (int) la division entre deux entiers
sera une division entière : 45/255 = 0 ! Il peut donc être nécessaire de faire de la conversion
de type en faisant : float(val)/4.0.
Q 10 : Compiler et téléverser le programme. Valider que le comportement réalisé est
conforme à celui attendu.
4.2
Par interface graphique Scilab – Xcos
Q 11 : Modifier le fichier Xcos précédent de façon à allumer la LED avec une tension proportionnelle à la valeur lue sur le potentiomètre. On pensera à adapter la plage de variation
de la sortie du potentiomètre à celle de commande de la LED.
Lancer la simulation et vérifier le bon fonctionnement.
page 7
TP PCSI – CI6
5
5.1
Commande d’un moteur à courant continu en boucle ouverte
Par interface Arduino (langage C)
Pour réaliser la commande d’un moteur, nous allons utiliser un hacheur externe. Cela est
nécessaire car la carte Arduino Uno utilisée ne peut pas délivrer suffisamment de puissance
pour alimenter un moteur.
Le hacheur fonctionne selon le même principe que le signal PWM précédent : il hache la
tension issue de l’alimentation externe grâce à des transistors et la tension moyenne dépend
alors du rapport cyclique. C’est justement le signal PWM de l’Arduino qui est utilisé pour
commander ces transistors.
Il est possible d’utiliser des cartes toutes prêtes qui permettent de relier simplement l’Arduino, le hacheur externe et le moteur. Il n’est cependant pas beaucoup plus compliqué
de créer son propre hacheur à partir de circuits imprimés (comme les références L293D ou
SN754410).
Nous allons utiliser dans un premier temps le moteur-réducteur 6V ainsi que la carte
pmodhb5 disponibles sur le poste de travail.
Il y a 6 broches à connecter via la rallonge sur la carte Labdec, il s’agit du connecteur
J1 du schéma suivant. La rallonge possède un détrompeur pour bien repérer les différentes
connectiques du port J1.
En cas de doute, ne pas hésiter à demander, une inversion des bornes pourraient endommager le circuit.
Le signal PWM pour la commutation du pont en H
sera envoyé sur l’entrée EN.
Il faut aussi spécifier le sens de rotation avec l’entrée
DIR.
SA et SB correspondent aux signaux des deux capteurs en quadrature de phase.
GND et VCC : alimentation des capteurs.
Vm et GND correspondent à l’alimentation externe
(chaîne d’énergie). Une fiche femelle a été placée pour
plus de commodité.
Q 12 : Relier l’alimentation 5V à la borne VCC, ainsi que la masse à la borne GND avec
des straps.
Connecter la borne DIR sur une sortie digital de l’Arduino.
Connecter la borne EN sur une sortie analogique/PWM de l’Arduino.
On va maintenant créer un nouveau programme permettant de faire bouger le moteur
en boucle ouverte.
Q 13 : À partir du programme précédent sur la LED, faire tourner le moteur tout d’abord
à une vitesse fixée dans le programme.
Modifier le programme pour faire tourner le moteur dans un sens en fonction du potentiomètre.
Modifier à nouveau le programme pour faire tourner le moteur dans un sens ou dans
l’autre de manière symétrique en fonction de la valeur du potentiomètre.
page 8
TP PCSI – CI6
Q 14 : Mettre en évidence l’existence d’une tension seuil en deçà de laquelle le moteur
ne tourne pas. Quel est le phénomène à l’origine de ce seuil ?
5.2
Par interface graphique Scilab – Xcos
Q 15 : Ouvrir un nouveau fichier Xcos et insérer le bloc de configuration du port et le
bloc échantillonnage.
Ajouter un bloc entrée analogique et la régler pour qu’elle donne l’information issue du
potentiomètre.
Ajouter un bloc moteur continu et régler sur la carte pmodhb5 (option 3) puis sur le
moteur 1.
Ajouter un gain d’adaptation du CAN vers PWM de 255/1023 (la sortie PWM de l’Arduino est sur 8 bits).
Lancer la simulation et valider le bon fonctionnement.
Bloc de configuration du port :
Bloc d'échantillonage :
Bloc d'entrée analogique :
Bloc moteur continu :
F IGURE 6 – Blocs Xcos à utiliser pour la commande en boucle ouverte du moteur.
Q 16 : Mettre en évidence l’existence d’une tension seuil en deçà de laquelle le moteur
ne tourne pas. Quel est le phénomène à l’origine de ce seuil ?
6
6.1
Lecture du codeur incrémental
Par interface Arduino (langage C)
Pour récupérer les informations du codeur incrémental, il faut être capable de détecter
des fronts montants et/ou front descendants des voies du codeur.
Les micro-contrôleurs sont dotés d’entrée de type interruption, qui détectent justement
les changements d’état d’une entrée et lancent une fonction.
Pour cela, il faudra écrire les lignes suivantes dans la fonction setup() :
page 9
TP PCSI – CI6
encoder_1_pin1=3;
//SA sur PIN3
encoder_1_pin2=2;
//SB sur PIN4
pinMode(encoder_1_pin1,INPUT);
//déclaration des PIN comme étant des entrées.
pinMode(encoder_1_pin2,INPUT);
attachInterrupt(1, encoder_change_m4_A1, CHANGE);
// Attach interrupt on channel A change pin3
attachInterrupt(0, encoder_change_m4_B1, CHANGE);
// Attach interrupt on channel B change pin2
Q 17 : Définir les fonctions encoder_change_m4_A1 et encoder_change_m4_B1 afin de compter les changements d’état. Il faudra déclarer une variable globale de type entier et l’affecter
des bonnes valeurs à chaque changement.
6.2
Par interface graphique Scilab – Xcos
Grâce à la quadrature des deux signaux SA et SB issus des capteurs en quadrature de
phase (voir schéma du pont en H en partie précédente), il est possible de déterminer le sens
de rotation.
Nous allons étudier différentes options pour compter les impulsions :
– x1 : incrémente/décrémente (selon le sens de rotation) le compteur à tous les fronts
montants de la voie A.
– x2 : incrémente/décrémente (selon le sens de rotation) le compteur à tous les fronts
montants et descendants de la voie A.
– x4 : incrémente/décrémente (selon le sens de rotation) le compteur à tous les fronts
montants et descendants de la voie A et de la voie B
Sur nos moteur, nous avons trois périodes pour chaque cellule par tour d’arbre moteur
(voir figure 7). Nous pouvons donc en mode x4 obtenir 12 incréments par tour de l’arbre
moteur.
F IGURE 7 – Signaux issus des 2 codeurs.
Comme le motoréducteur comporte un réducteur de rapport 1/53, cela doit nous donner
636 incréments par tour en sortie du réducteur.
Pour faciliter le câblage, nous utiliserons une shield de prototypage associée à une plaquette d’essai sans soudure.
– Brancher la carte shield précablée sur l’Arduino, puis ouvrir le fichier encodeur.zcos.
On constate que la direction (DIR) est reliée à la pin 12, que la vitesse (EN = signal PWM) est
reliée à la pin PWM compatible 9.
– En double-cliquant sur le bloc moteur DC , changer le type de carte de commande
pour PmodHB5 (option 3), puis choisir le pin de PWM (EN) et le pin de direction
(DIR). Rappel : le pin de PWM doit forcément être 3,5,6,9,10,11.
Pour faire fonctionner un codeur, nous avons besoin d’entrées en interruption. Ce sont
des entrées capables d’arrêter le programme principal lors d’un changement d’état afin
d’exécuter un sous-programme (dans notre cas incrémenter un compteur).
page 10
TP PCSI – CI6
Les pins 2 et 3 sont les seuls pins de l’Arduino Uno supportant les interruptions. Pour
faire fonctionner un codeur en mode x4, il faut que les deux voies soient câblées sur les
pins d’interruption. Par contre en modes x1 ou x2, seule une voie doit être branchée en
interruption, l’autre peut être reliée à une entrée logique classique.
On remarquere que les voies SA et SB ont été ici câblées sur les pins 2 et 3 (compatibles
interruptions) et que l’alimentation des codeurs a bien été reliée aussi.
– En double-cliquant sur le bloc encoder, choisir le numéro du codeur (1) et le mode de
fonctionnement (x1, x2, x4). Spécifier ensuite les bons pins pour la voie A (forcément 2
ou 3) et la voie B, qui permet de trouver la direction.
– Le potentiomètre est branché sur la pin analogique 2 : vérifier qu’il est bien déclaré
dans le programme.
– Pour l’alimentation du pont en H, brancher la fiche d’alimentation et vérifiez que le
chargeur 12v est branché dans la prise.
– Un gain de 127/1023 a été ajouté entre la consigne issue du potentiomètre et le moteur.
En effet, les moteurs admettent une tension nominale maximum de 6V, or l’alimentation du chargeur est en 12V. Il faut donc envoyer uniquement 50 % de la tension max
12V, ce qui correspond à un rapport cyclique max de 127 (255*0,5) pour une valeur de
consigne max de 1023.
Q 18 : Lancer la simulation et tester la commande avec le potentiomètre.
Choisir une valeur fixe de commande avec le potentiomètre et vérifier les rapports de
multiplication x1, x2, x4 en regardant la courbe obtenue.
7
Commande du moteur en boucle fermée
Q 19 : Programmer la commande d’un moteur en boucle fermée de position avec un
correcteur proportionnel (dans un premier temps...).
page 11