ModelleisenbahN

L'algorithme de rotation du pont tournant

Jean-Luc — 2014-01-01T12:12:33Z

Après avoir présenté le matériel nécessaire au pilotage du moteur pas-à-pas par µPas et le choix de la DRV8824 de Pololu pour sa meilleure résolution et la fluidité de mouvement qui en résulte, il est temps de se pencher sur l'algorithme qui permet de décider du sens de rotation et de la décomposition du mouvement en phase d'accélération, en régime permanent et en phase de décélération.

Calcul du sens de rotation pour le plus court chemin

Le pont est bien évidemment orienté. C'est à dire que les positions p et p+180° sont différentes. Avec la DRV8824, nous avons 12800 positions possibles que nous allons numéroter de 0 à 12799. Partant de la position courante, le pont devant aller dans une nouvelle position, il faut décider dans quel sens tourner pour minimiser la distance parcourue. C'est à dire que partant de la position courante 12799 et allant à la position 0, il n'y a qu'un µPas à effectuer et non 12799.

On va distinguer deux cas :

La position à atteindre à un numéro > à la position courante ;
La position à atteindre à un numéro < à la position courante.

Par convention, on va également décider qu'un déplacement positif se fait dans le sens horaire et un déplacement négatif dans le sens trigonométrique.

La position à atteindre à un numéro supérieur à la position courante

Ce cas correspond à la figure ci-dessous :

chemin 1 se calcule en soustrayant la position courante à la position destination : chemin 1 = position destination — positition courante.
Il est bien positif, la rotation pour parcourir chemin 1 se fait dans le sens horaire.

chemin 2 doit être négatif puisque la rotation de fait dans le sens trigonométrique et il se décompose en deux : d'une part la portion entre la position courante et 0 et d'autre part la portion entre 12800 et la position destination.
On a donc chemin 2 = — (positition courante + 12800 — position destination)

La position à atteindre à un numéro inférieur à la position courante

Ce cas correspond à la figure ci-dessous :

chemin 1 se calcule également en soustrayant la position courante à la position destination : chemin 1 = position destination — positition courante.
Comme la position courante est plus grande que la position destination, il est bien négatif, la rotation pour parcourir chemin 1 se fait dans le sens trigonométrique.

chemin 2 doit être positif et se décompose en deux : d'une part la portion entre la position courante et 12800 et d'autre part la portion entre 0 et la position destination.
On a donc chemin 2 = 12800 — positition courante + position destination.

Pour choisir le chemin, il suffit de comparer les valeurs absolues de chemin 1 et chemin 2 et de choisir le chemin ayant la plus petite. Le signe du chemin donne le sens de rotation.

Le code correspondant est le suivant :

int chemin1 = positionDestination - positionCourante; int chemin2; if (positionDestination > positionCourante) chemin2 = - (positionCourante + 12800 - positionDestination); else chemin2 = 12800 - positionCourante + positionDestination; int chemin; int dir; if (abs(chemin1) > abs(chemin2)) chemin = chemin2; else chemin = chemin1; /* Si chemin < 0, la direction est mise à 1 */ if (chemin < 0) dir = HIGH; else dir = LOW;

Le nombre de µPas à parcourir sera mis dans une variable distance calculée comme suit : distance = abs(chemin);.

Vitesse de rotation, accélération et décélération

La vitesse de rotation d'un pont tournant est assez faible. On peut par exemple voir dans cette vidéo qu'il faut environ 2 minutes (entre 45" et 2'45") pour que la 141TD 740 fasse son demi-tour, ce qui donne 4 minutes pour un tour.

La 141TD 740 s'engage sur le pont tournant et fait un demi-tour

Dans notre cas, il faut donc passer 12800 µPas en 4 minutes soit 240s, ce qui donne un délai de 18 à 19ms entre deux µPas. Pour clarifier le code, ce délai va être mis dans une variable delaiInterMicropas, ce qui permettra aussi de changer la vitesse de rotation sans avoir à modifier le code.

Si on ne se soucie pas d'avoir des phases d'accélération et de décélération, le code est très simple :

for (microPas = 0; microPas < distance; microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delaiInterMicroPas - 1); }

Mais le mouvement a une allure artificielle. Il est donc préférable de simuler une petite phase d'accélération et de décélération.

Les phases d'accélération vont être réglées en nombre de µPas passés à accélérer et à décélérer. On va donc avoir 2 variables microPasAcceleration et microPasDeceleration pour régler ces phases.

Un mouvement d'une position courante à une position de destination consiste donc à parcourir microPasAcceleration µPas avec un délai variable et décroissant puis à parcourir distance - microPasAcceleration - microPasDeceleration µPas avec un délai delaiInterMicropas et enfin parcourir microPasDeceleration µPas avec un délai variable croissant.

Bien entendu, il ne faut pas que microPasAcceleration + microPasDeceleration soit supérieur à distance. En pratique les phases d'accélération et de décélération seront courte et la distance est supérieur à l'écartement de la voie utilisée. Par exemple pour un pont en N de 150mm de diamètre, les 9mm d'écartement correspondent à 245 µPas.

Le délai initial de la phase d'accélération est calculé est ajoutant microPasAcceleration à delaiInterMicropas. On va ensuite boucler microPasAcceleration fois en diminuant le délai de 1 à chaque tour pour donc terminer sur un délai égal à delaiInterMicropas. Comme ceci :

int delai = delaiInterMicroPas - 1 + microPasAcceleration; for (microPas = 0; microPas < microPasAcceleration; microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delai); delai-- ; }

Le mouvement a vitesse maximum est accompli par la boucle suivante :

for (microPas = 0; microPas < (distance - microPasAcceleration - microPasDeceleration); microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delaiInterMicroPas - 1); }

Enfin, la phase de décélération consiste à boucler microPasDeceleration fois en augmentant le délai de 1 à chaque tour, delai est initialisé à la valeur delaiInterMicropas. Comme ceci :

for (microPas = 0; microPas < microPasDeceleration; microPas++) { digitalWrite(stepPin, LOW); delay(1); digitalWrite(stepPin, HIGH); delay(delai); delai ++; }

Tout cela est mis dans une fonction allerAPosition(...).

Sketch de démonstration

Voici le câblage :

Et le sketch de l'application de démonstration. Il contient la fonction allerAPosition(...) et l'exécution d'un scénario de mouvement.

Sketch de démonstration du pont tournant

Mise en œuvre de l'EasyDriver v4.4 pour un pont tournant

Jean-Luc — 2013-12-09T12:33:38Z

Voici le compte rendu de quelques essais de mise en œuvre avec l'objectif de motoriser un pont tournant.

Le matériel

Afin d'avoir la meilleure résolution possible, le moteur pas-à-pas bipolaire choisi est un moteur 400 pas par tour vendu par Selectronic. Il s'agit de ce modèle.

Ce moteur est prévu pour être alimenté en 12V. Les bobines ont une résistance de 40Ω et par conséquent chaque bobine consomme 300mA. Le couple de maintien est de 3,5 kg/cm.

J'ai fixé sur l'arbre une latte en bois de 40 cm de longueur et donc un rayon de 20cm. Cette longueur est de 30% supérieure à la longueur d'un pont tournant en H0 et plus de 2 fois plus long qu'un pont tournant en N. Cela permet de visualiser la rotation et plus particulièrement les défauts.

Montage d'essai du moteur pas-à-pas

En combinant les 400 pas par tour du moteur et les 8 µpas de l'EasyDriver, on arrive à 3200 positions sur le cercle. Avec un diamètre de 30cm, typiquement un pont tournant en H0, cela nous donne un pas d'environ 0,3mm en bout de pont. Avec un diamètre de 15cm qui correspond au pont tournant PECO en N, cela nous donne un pas de 0,15mm en bout de pont.

La connexion de l'Arduino à l'EasyDriver est particulièrement simple. Comme on la vu dans « L'Easydriver v4.4 », la plupart des broches de l'EasyDriver ont la configuration adéquate quand on les laisse tout simplement non connectées.

Les sorties numériques 2 et 3 de l'Arduino sont employées pour piloter le moteur. On garde les alimentations séparées. L'EasyDriver est alimenté en 12V continu et, pour les essais, l'Arduino reste alimenté via l'USB.

Connexion de l'Arduino à l'EasyDriver

Influence de la limitation de courant

Plus le courant maximum I_max, c'est à dire le courant correspondant à 100% d'alimentation d'une bobine, est élevé et plus le passage d'un µPas au suivant est rapide et franc. Comme on veut le passage le plus doux possible, il faut régler le courant maximum à la valeur la plus basse possible.

Les indications de sens de rotation du potentiomètre sur l'EasyDriver 4.4 sont fausses. La valeur minimum correspond en fait à une rotation dans le sens trigonométrique (à gauche) et la valeur maximum à une rotation dans le sens horaire (à droite).

D'après la schématique, le I_max minimum possible est de 166mA pour V_ref = 1V, ce qui correspond à la valeur minimum que l'on trouve dans la documentation de l'Allegro A3967. En réalité, le V_ref minimum mesuré est de 1,59V au lieu des 1V annoncés. Par ailleurs, j'ai mesuré une valeur de 1,2Ω pour les résistances de capture de courant au lieu des 0,75Ω annoncés dans la schématique. Le rapport V_ref / R_s est quasiment le même et le I_max pour V_ref = 1,59V est donc bien de 166mA.

Voici une vidéo montrant l'influence de la limitation de courant sur la fluidité de la rotation pour les valeurs suivantes de I_max : 280mA (V_ref = 2,69V), 224mA (V_ref = 2,15V) et 166mA (V_ref = 1,59V). La vitesse de rotation est de 1 tour en 2 minutes.

On voit effectivement que le réglage I_max au minimum donne le meilleur résultat en terme de fluidité de mouvement même si la vidéo gomme les petites vibrations qui sont observables à des I_max plus élevés. Le couple reste largement suffisant.

Le logiciel

La pilotage du moteur pas-à-pas est très facile. La broche 2 de l'Arduino connectée à l'entrée DIR de l'EasyDriver permet de fixer le sens de rotation et la broche 3 connectée à l'entrée STEP de l'EasyDriver permet d'avancer d'un µPas. Ces deux broches sont donc mises en sortie dans setup() comme ceci.

const int pinSens = 2; const int pinMicroPas = 3; void setup() { pinMode(pinSens, OUTPUT); pinMode(pinMicroPas, OUTPUT); }

Le jeu consiste ensuite à choisir un sens de rotation en mettant pinSens à HIGH ou LOW puis à enchaîner à une certaine cadence des HIGH et des LOW sur pinMicroPas.

La cadence est déterminée par le délai d'attente entre deux bagottages sur pinMicroPas. Par exemple, si l'on veut que le pont accomplisse un tour complet en 2 minutes, soit 120 s, on calcule ce temps d'attente de la manière suivante : 3200 µPas en 120 s donne un délai de 120/3200 = 37,5 ms ≃ 37 ms.

Ainsi le programme le plus simple possible consiste à faire tourner le moteur en permanence dans loop().

void loop() { digitalWrite(pinMicroPas, LOW); digitalWrite(pinMicroPas, HIGH); delay(37); }

Voici une vidéo qui montre l'exécution d'une séquence de déplacement : positionnement en 100, puis 300, puis 200, puis 800, puis 1600, puis 1000 et enfin 2400. Dans la première partie, un délai de 36ms entre deux µPas est utilisé. Les µPas ne sont pas visibles. Dans la seconde on passe à un délai de 99ms, les µPas deviennent visibles. Enfin dans la 3e partie, le mouvement d'une position à l'autre a une phase d'accélération pendant 0,5s en passant d'un délai de 78ms à 36ms par décrément de 3ms et une phase de décélération pendant 0,75s en passant d'un délai de 36ms à 99ms par incrément de 3. Les phases d'accélération et de décélération sont légèrement hachées.

L'EasyDriver remplit son office mais montre quelques limites pour les très faibles vitesses qui sont utilisées dans les phases d'accélération et de décélération. D'autres breakout boards existent et la prochaine fois, nous verrons celle développée par Pololu qui utilise un Texas Instruments DRV8824 permettant 32 µPas.

Témoins de positions : la mise en œuvre

Jean-Luc — 2013-12-03T19:28:33Z

Nous avons vu la technique du Charlieplexing dans « Témoins de positions : le Charlieplexing », nous allons maintenant l'appliquer à un système à 5 broches de pilotage et 16 LED puis l'intégrer dans notre application.

Charlieplexing des 16 LED témoins [1]

Le schéma pour allumer 16 LED est le suivant.

Charlieplexing avec 5 broches et 16 LED

On peut noter que le schéma est incomplet. En effet, avec 5 broches, il est possible de piloter 20 LED. Ici les couples de broches 0-3 et 1-4 sont manquants et nous n'allons donc pas les placer dans notre table d'état des broches.

Voici donc la table d'état des broches pour chaque LED

	broche 0	broche 1	broche 2	broche 3	broche 4
D0	0	1	Z	Z	Z
D1	1	0	Z	Z	Z
D2	Z	0	1	Z	Z
D3	Z	1	0	Z	Z
D4	Z	Z	0	1	Z
D5	Z	Z	1	0	Z
D6	Z	Z	Z	0	1
D7	Z	Z	Z	1	0
D8	0	Z	1	Z	Z
D9	1	Z	0	Z	Z
D10	Z	Z	0	Z	1
D11	Z	Z	1	Z	0
D12	Z	0	Z	1	Z
D13	Z	1	Z	0	Z
D14	0	Z	Z	Z	1
D15	1	Z	Z	Z	0

Nous allons donc construire cette table en C comme nous l'avons fait pour la Charlieplexing avec 3 broches de commande.

const byte etatSortiePourLED[16][5] = { { OUT0, OUT1, INZ, INZ, INZ }, /* D0 */ { OUT1, OUT0, INZ, INZ, INZ }, /* D1 */ { INZ, OUT0, OUT1, INZ, INZ }, /* D2 */ { INZ, OUT1, OUT0, INZ, INZ }, /* D3 */ { INZ, INZ, OUT0, OUT1, INZ }, /* D4 */ { INZ, INZ, OUT1, OUT0, INZ }, /* D5 */ { INZ, INZ, INZ, OUT0, OUT1 }, /* D6 */ { INZ, INZ, INZ, OUT1, OUT0 }, /* D7 */ { OUT0, INZ, OUT1, INZ, INZ }, /* D8 */ { OUT1, INZ, OUT0, INZ, INZ }, /* D9 */ { INZ, INZ, OUT0, INZ, OUT1 }, /* D10 */ { INZ, INZ, OUT1, INZ, OUT0 }, /* D11 */ { INZ, OUT0, INZ, OUT1, INZ }, /* D12 */ { INZ, OUT1, INZ, OUT0, INZ }, /* D13 */ { OUT0, INZ, INZ, INZ, OUT1 }, /* D14 */ { OUT1, INZ, INZ, INZ, OUT0 } /* D15 */ };

La fonction programmeBroche(...) reste la même par contre la fonction gereLED(...) doit être modifiée puisque l'on passe de 3 à 5 broches de commande.

void gereLED(int num) { if (etatLED[num] == ALLUME) { programmeBroche(8,etatSortiePourLED[num][0]); programmeBroche(9,etatSortiePourLED[num][1]); programmeBroche(10,etatSortiePourLED[num][2]); programmeBroche(11,etatSortiePourLED[num][3]); programmeBroche(12,etatSortiePourLED[num][4]); } else { programmeBroche(8,INZ); programmeBroche(9,INZ); programmeBroche(10,INZ); programmeBroche(11,INZ); programmeBroche(12,INZ); } }

Et le tableau etatLED doit être agrandi pour contenir 16 éléments.

Intégration dans l'application

Pour intégrer l'allumage des témoins dans l'application il faut tout d'abord insérer l'appel à gereLED() dans loop(). Nous faisons face à un premier problème. Pour que les servomoteurs pivotent suffisamment lentement, l'attente est de 5ms. Cela conduit à un balayage des 16 LED en 80ms ce qui est trop lent pour que la persistance rétinienne opère. Il faudrait balayer au moins 4 fois plus souvent. Par conséquent, le délai dans loop() va être réduit à 1ms et la gestion des poussoirs et des servomoteurs sera appelée toutes les 5 fois alors que la gestion des LED sera appelée toutes les fois. Nous allons donc ajouter un compteur compteurGestionServos initialisé à 0. Comme ceci.

void loop() { compteurGestionServos++; if (compteurGestionServos == 5) { compteurGestionServos = 0; ... /* code de gestion des servos et des poussoir à l'identique */ ... } gereLED(numLED); numLED++; if (numLED == 16) numLED = 0; delay(1); }

Il suffit ensuite de changer l'état des LED en ALLUME ou ETEINT dans le tableau etatLED en fonction des événements. Deux fonctions membre de la classe DescripteurServo sont concernées : evenementServo(...) où on va éteindre la LED de la position que l'on quitte et gereServo() où on va allumer la LED de la position que l'on atteint. Dans le tableau etatLED, les LED sont alternativement rouges et vertes et par conséquent la paire de LED correspondant à un servomoteur est à la position numéro de servo × 2 (angle minimum) et numéro de servo × 2 + 1 (angle maximum).

void evenementServo() { cptArret = -1; switch (etatServo) { case SERVO_A_ANGLE_MIN: etatLED[numServo * 2] = ETEINT; objetServo.attach(pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: vitesse = 1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: etatLED[numServo * 2 + 1] = ETEINT; objetServo.attach(pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: vitesse = -1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } }

Dans la fonction membre gereServo(), la partie qui s'occupe du passage de la vitesse à 0 quand les angles minimum ou maximum sont atteint est modifiée comme suit :

if (! reglageEnCours || etatServo == SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN || etatServo == SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX) { if (angle > angleMax) { angle = angleMax; arreteServo(); etatServo = SERVO_A_ANGLE_MAX; etatLED[numServo * 2 + 1] = ALLUME; } else if (angle < angleMin) { angle = angleMin; arreteServo(); etatServo = SERVO_A_ANGLE_MIN; etatLED[numServo * 2] = ALLUME; } }

Il ne faut pas oublier d'allumer la LED correspondant à l'angle minimum dans la fonction membre connecte(...)

/* allume la LED correspondante */ etatLED[numServo * 2] = ALLUME;

Nous sommes parvenus au bout de ce développement. Voici le sketch de l'application complète à télécharger.

Sketch de l'application complète

mis à jour en version 1.1. La position des servos est désormais mémorisée dans l'EEPROM.

Dessin du montage complet

Attention : le montage montre les 8 servomoteurs alimentés par l'Arduino. Ce n'est pas possible en pratique et il est nécessaire d'avoir une alimentation 5V séparée pour les servomoteurs

Dessin du montage complet à télécharger en PDF

Attention : le montage montre les 8 servomoteurs alimentés par l'Arduino. Ce n'est pas possible en pratique et il est nécessaire d'avoir une alimentation 5V séparée pour les servomoteurs

Ainsi qu'une vidéo de démonstration.

Démonstration de l'application complète et terminée

[1] On peut noter que plus le nombre de LED est important, plus le temps d'allumage sur un cycle de balayage devient faible. En pratique, la luminosité n'est pas beaucoup plus faible avec 16 LED. Pour un plus grand nombre de LED, il peut être nécessaire de diminuer la valeur des résistances sans toutefois dépasser les capacités des entrées/sorties du micro-contrôleur

Témoins de positions : le Charlieplexing

Jean-Luc — 2013-12-02T21:08:29Z

La dernière fonction à mettre en œuvre est la gestion des témoins de position. 16 LED sont nécessaires et il nous reste 6 broches. La broche numérique 13 ayant déjà une LED soudée sur la carte de l'Arduino n'est pas très commode à utiliser. Il nous reste donc en réalité 5 broches.

Comment faire ?

Il existe une technique connue sous le nom de Charliplexing [1] qui permet de multiplexer des LED sur des entrées/sorties numériques. Examinons tout d'abord le cas de deux LED connectées à 2 broches avec 2 résistances de 150Ω.

Charlieplexing avec 2 broches

dont l'intérêt est plus que discutable.

Si la broche 0 est en sortie à 5V et la broche 1 en sortie à 0V, la LED rouge est allumée. Si la broche 0 est en sortie à 0V et la broche 1 en sortie à 5V, la LED verte est allumée. Toute autre configuration, une des broches ou les deux en entrée ou les deux en sortie au même potentiel, éteint les deux LED.

Ça ne nous avance pas beaucoup me direz vous.

Rajoutons donc une broche 2 et une résistance et ajoutons une paire de LED entre la broche 2 et la broche 1 mais aussi entre la broche 2 et la broche 0, soit 6 LED au total.

Charlieplexing avec 3 broches

Pour allumer la LED D5 par exemple, il faut mettre la broche 0 en sortie à 5V, la broche 2 en sortie à 0V et pour que ni D1, ni D3 ne s'allument, mettre la broche 1 en entrée (donc en haute impédance). On peut remarquer que D1 et D3 sont également alimentées mais comme elle sont en série, elles présentent une tension de seuil 2 fois supérieure [2] et le courant empruntera le chemin de plus faible tension de seuil.

Pour la suite on va noter le fait de mettre une sortie à 5V : 1, à 0V, 0 et en entrée : Z.

La table correspondant à l'allumage de chaque LED est la suivante.

	broche 0	broche 1	broche 2
D0	0	1	Z
D1	1	0	Z
D2	Z	0	1
D3	Z	1	0
D4	0	Z	1
D5	1	Z	0

De manière générale, avec N broches, on peut piloter N × N-1 LED. Avec nos 5 broches disponible, on pourra donc piloter 5 × 4 = 20 LED.

Programme de démonstration

Évidemment, seule une LED peut être allumée à un instant. C'est donc l'Arduino qui va s'occuper de balayer les LED et, pour chacune les allumer ou non à une vitesse suffisamment grande pour que l'œil ait l'impression que l'allumage de chaque LED est permanent grâce à la persistance rétinienne. Avant de nous lancer dans l'allumage de 16 LED, voyons comment fonctionne le programme pour 3 broches et 6 LED. Dans un premier temps, nous allons balayer et allumer les 6 LED pour juger de l'effet rendu.

Il faut tout d'abord transposer le table d'états en C dont les lignes correspondront aux LED et les colonnes aux sortie. Les états eux même sont définis par un enum, une manière de donner un nom symbolique à une constante numérique :

enum { OUT0, OUT1, INZ }; const byte etatSortiePourLED[6][3] = { { OUT0, OUT1, INZ }, /* D0 */ { OUT1, OUT0, INZ }, /* D1 */ { INZ, OUT0, OUT1 }, /* D2 */ { INZ, OUT1, OUT0 }, /* D3 */ { OUT0, INZ, OUT1 }, /* D4 */ { OUT1, INZ, OUT0 } /* D5 */ };

OUT0 signifie que le broche est en sortie et à 0, OUT1 qu'elle est en sortie et à 1 et INZ en entrée et à haute impédance, c'est à dire sans résistance de pull-up.

Ajoutons une fonction pour programmer une broche en fonction de ce code :

void programmeBroche(int numBroche, byte etat) { switch (etat) { case OUT0: digitalWrite(numBroche,LOW); pinMode(numBroche,OUTPUT); break; case OUT1: digitalWrite(numBroche,HIGH); pinMode(numBroche,OUTPUT); break; case INZ: pinMode(numBroche,INPUT); digitalWrite(numBroche,LOW); /* pas de pullup */ break; } }

Pour que l'on puisse tour à tour allumer une LED ou non, il nous faut un tableau qui, pour chaque LED, va indiquer son état, ALLUME ou ETEINT. De nouveau nous allons utiliser un enum.

enum { ALLUME, ETEINT }; byte etatLED[6] = { ETEINT, ETEINT, ETEINT, ETEINT, ETEINT, ETEINT };

Enfin, il nous faut une fonction qui, pour un numéro de LED, va chercher son état et, si elle elle allumée, appelle, pour chaque broche, programmeBroche avec les états de broche correspondant à l'allumage de cet LED. Si elle est éteinte, toutes les sorties sont mises dans l'état INZ.

void gereLED(int num) { if (etatLED[num] == ALLUME) { programmeBroche(10,etatSortiePourLED[num][0]); programmeBroche(11,etatSortiePourLED[num][1]); programmeBroche(12,etatSortiePourLED[num][2]); } else { programmeBroche(10,INZ); programmeBroche(11,INZ); programmeBroche(12,INZ); } }

Il suffit ensuite dans loop() de balayer les LED, de 0 à 5, en donnant leur état avec une période de 2ms.

int numLED = 0; void loop() { gereLED(numLed); numLED++; if (numLED > 5) numLED = 0; delay(2); }

Par dessus on superpose une séquence d'allumage comme, par exemple, un chenillard.

int numLED = 0; int LEDAllumee = 0; int compteur1s = 0; void setup() { /* Au début la LED 0 est allumée */ etatLED[LEDAllumee] = ALLUME; } void loop() { compteur1s++; if (compteur1s == 500) { /* Au bout de 1s, on allume la LED suivante */ compteur1s = 0; /* Éteint la LED qui était allumée */ etatLED[LEDAllumee] = ETEINT; /* Passe à la LED suivante */ LEDAllumee++; if (LEDAllumee > 5) LEDAllumee = 0; /* Allume la nouvelle LED */ etatLED[LEDAllumee] = ALLUME; } gereLED(numLed); numLED++; if (numLED > 5) numLED = 0; delay(2); }

Voici le programme de chenillard en Charlieplexing sur 3 broches et 6 LED.

Sketch du chenillard en Charlieplexing

Ainsi que la vidéo de démonstration

Démonstration du sketch de chenillard

[1] Le Charlieplexing est une technique proposée en 1995 par Charlie Allen, voir l'article sur Wikipedia

[2] La tension de seuil dépend de la couleur de la LED mais même en mettant en série 2 LED rouge dont la tension de seuil est la plus faible, 1,6V, 2 × 1,6V = 3,2 V reste supérieure à la tension de seuil des LED violettes, 3,1V

Amélioration et mémorisation des réglages

Jean-Luc — 2013-12-02T07:45:39Z

Comme indiqué dans la vidéo au bas de l'article « Réglage des butées des servomoteurs », un problème lié à l'inertie mécanique subsiste. Nous avons aussi le problème de la non mémorisation des réglages. Nous allons voir comment régler ces deux problèmes.

Prise en compte de l'inertie mécanique

Quand la consigne de position, via la durée de l'état haut de la PWM, est envoyé au servomoteur, celui-ci met quelques instants à appliquer cette consigne. Or, le programme actuel coupe la PWM est appelant la fonction detach() dès que la consigne atteint l'angle maximum ou l'angle minimum. Le servo n'a donc pas le temps de répondre à cette consigne et pour régler le problème il faut différer le détachement du servo.

Au lieu de détacher immédiatement le servo, il faut initialiser un compteur, que nous appelleront cptArret, qui quand il atteint 0 provoque le détachement du servo. Une fois le servo détaché, le compteur est mis à -1 pour éviter de détacher le servo de manière répétitive. Actuellement dans gereServo() en plusieurs endroits, la vitesse est mise à 0 et le servo est détaché.

Il faut remplacer les objetServo.detach() par l'initialisation du compteur. Pour rationaliser nous allons mettre le vitesse = 0; et l'initialisation du compteur dans une fonction membre séparée :

void arreteServo() { vitesse = 0; cptArret = 30; }

Avec le délai de 5ms dans loop(), une valeur de 30 engendre un délai de 150ms ce qui est suffisant pour que la mécanique rattrape l'électronique.

Il faut maintenant, dans la fonction gereServo(), décrémenter ce compteur tant qu'il est ≥ à 0 et détacher le servo quand ce compteur est égal à 0. De plus, à chaque fois que nous avons la mise de la vitesse à 0 et le détachement du servo, nous le remplaçons par l'appel à la fonction arreteServo(). gereServo() devient :

void gereServo() { objetServo.writeMicroseconds(angle); if (vitesse == 0) { if (cptArret == 0) objetServo.detach(); if (cptArret >= 0) cptArret--; } else angle += vitesse; if (! reglageEnCours || etatServo == SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN || etatServo == SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX) { if (angle > angleMax) { angle = angleMax; arreteServo(); etatServo = SERVO_A_ANGLE_MAX; } else if (angle < angleMin) { angle = angleMin; arreteServo(); etatServo = SERVO_A_ANGLE_MIN; } } else { if (etatServo == SERVO_A_ANGLE_MIN) { if (vitesse > 0 && angle >= angleMin) { angle = angleMin; arreteServo(); } else if (vitesse < 0 && angle <= angleMin) { angle = angleMin; arreteServo(); } } else if (etatServo == SERVO_A_ANGLE_MAX) { if (vitesse > 0 && angle >= angleMax) { angle = angleMax; arreteServo(); } else if (vitesse < 0 && angle <= angleMax) { angle = angleMax; arreteServo(); } } } }

Il faut également garantir que le servo ne sera pas détaché intempestivement. En effet, si l'utilisateur demande un mouvement du servo dans l'intervalle de temps entre le passage de la vitesse à 0 et le passage du compteur à 0, il faut passer directement le compteur à -1 dans evenementServo() car sinon le détachement du servo interviendra pendant le mouvement, ce qui est un dysfonctionnement.

Mémorisation des butées

La plupart des microcontrôleurs dispose d'une mémoire permanente, c'est à dire qui ne s'efface pas à la mise hors tension, sous forme d'EEPROM (Electrically Erasable Programmable Read-Only Memory). La bibliothèque de l'Arduino permet de lire et d'écrire l'EEPROM de manière très simple via deux fonctions : EEPROM.read(...) et EEPROM.write(..., ...). EEPROM.read(...) prend comme argument une adresse d'octet (byte) et retourne l'octet qui se trouve à cet adresse et EEPROM.write(..., ...) prend deux arguments. Le premier est l'adresse de l'octet que l'on souhaite écrire et le second est la valeur que l'on souhaite y écrire. L'EEPROM de l'ATMega328 qui équipe l'Arduino Uno a une taille de 1ko.

Pour chaque servomoteur, il faut stocker les deux butées. Chaque butée est stockée dans un int. Sur l'Arduino Uno, un int prend 2 octets. Par conséquent il faut 4 octets pour chaque servos et donc 32 octets au total. En démarrant à l'adresse 0 de l'EEPROM, l'adresse de stockage des butée d'une servo sera donc égale au numéro du servo × 4. Nous allons donc stocker le premier octet de angleMin à numéro du servo × 4, le second à numéro du servo × 4 + 1, le premier octet de angleMax à numéro du servo × 4 + 2 et le 2e octet à numéro du servo × 4 + 3. Nous allons donc ajouter une donnée membre à la classe DescripteurServo pour y mémoriser cette adresse. Cette donnée est initialisée dans le constructeur.

Il est nécessaire d'être prudent avec les EEPROM. En effet, elle supporte un nombre de cycle d'effacement/écriture réduit. Par exemple, celle de l'ATMega328 qui équipe l'Arduino Uno supporte 100 000 cycles d'effacement/écriture. Cela peut sembler une valeur importante mais si nous écrivons imprudemment les butées des servos en EEPROM à chaque passage dans loop(), l'EEPROM sera fichue en 5ms × 100 000 = 500s = 8 minutes et 20 secondes.

Il faut donc n'écrire les butées que si un réglage a été effectué et si la valeur a changé. Nous allons donc ajouter un booléen membre de la classe DescripteurServo, aSauver, qui sera mis à vrai dans regleServo() si l'une des butées a été changée.

Enfin, deux fonctions membres, ecrireEEPROMSiDifferent(...) et enregistre() sont ajoutées pour mémoriser les butées dans l'EEPROM. Le travail n'est effectué que si aSauver est vrai et si les valeurs ont changé.

void ecrireEEPROMSiDifferent(int adresseEcriture, byte valeur) { if (EEPROM.read(adresseEcriture) != valeur) EEPROM.write(adresseEcriture, valeur); } void enregistre() { if (aSauver) { ecrireEEPROMSiDifferent(adresse, angleMin & 0xFF); ecrireEEPROMSiDifferent(adresse + 1, angleMin >> 8); ecrireEEPROMSiDifferent(adresse + 2, angleMax & 0xFF); ecrireEEPROMSiDifferent(adresse + 3, angleMax >> 8); aSauver = false; } }

Enfin, au démarrage du système dans connecte(), il faut initialiser la position des servos aux valeurs enregistrées. La valeur lue est recadrée entre ANGLE_MIN et ANGLE_MAX car l'EEPROM peut contenir des valeurs écrites par une autre application ou bien être vierge [1].

angleMin = EEPROM.read(adresse) | ((int)EEPROM.read(adresse + 1)) << 8; angleMax = EEPROM.read(adresse + 2) | ((int)EEPROM.read(adresse + 3)) << 8; if (angleMin < ANGLE_MIN || angleMin > ANGLE_MAX) angleMin = ANGLE_MIN; if (angleMax < ANGLE_MIN || angleMax > ANGLE_MAX) angleMax = ANGLE_MAX;

Le sketch de l'application améliorée

Sketch Arduino de l'application avec réglage des butées amélioré

Et enfin une petite vidéo qui montre l'effet de ces deux améliorations.

Démonstration de l'amélioration et de la mémorisation des butées

[1] Un octet d'EEPROM qui n'a jamais été écrit est à la valeur 255 en décimal ou 0xFF en hexadécimal (tous les bits de l'octet sont à 1).

Réglage des butées des servomoteurs

Jean-Luc — 2013-12-01T17:09:10Z

Nous voici enfin à l'avant dernière étape de développement de notre système. Dans « Sélection d'un servomoteur pour le réglage des butées », nous avons vu la mise en œuvre d'un codeur pour désigner le servomoteur à régler, dans « Clavier de réglage des butées », nous avons vu l'ajout d'un second clavier analogique destiné à permettre le réglage des butées et, comme nous avions déjà un clavier analogique, la généralisation de la gestion de ce type de clavier par le biais d'une classe C++.

Nous allons maintenant voir comment intégrer cette fonction de réglage au programme de pilotage des 8 servos. Mais tout d'abord quelques éclaircissement sur la fonction désirée.

Le fonctionnement du réglage

Lorsqu'un des servo est désigné au moyen du codeur, le mouvement des servos restent actif. En effet, le réglage ne porte que sur la butée actuelle du servo désigné.

Si le servo est en butée dans le sens horaire, une pression sur le poussoir de droite doit déplacer la butée horaire un peu plus dans le sens horaire. Une pression sur le poussoir de gauche déplace la butée un peu moins. De même, si le servo est en butée dans le sens trigonométrique, une pression sur le poussoir de gauche déplace un peu plus la butée dans le sens trigonométrique et une pression sur le poussoir de droite un peu moins.

Pour passer du réglage d'une butée au réglage de l'autre butée, il suffit de presser le poussoir commandant le mouvement du servomoteur.

Une tentative de réglage alors que le servo est en mouvement est ignorée.

Le réglage en lui même va donc augmenter ou diminuer les angles minimum et maximum. Si on veut un réglage précis, il faut régler de pas en pas [1]. Mais régler de pas en pas risque d'être long. On veut donc pouvoir décider de combien de pas la butée est augmentée ou diminuée lors d'une pression sur un des poussoirs de réglage. Voici donc le rôle des 2 boutons supplémentaires du clavier de réglage, ils servent à augmenter et diminuer le nombre de pas de réglage.

Par défaut, lorsqu'on désigne un servo à régler, le nombre de pas sera de 8. Une pression sur le poussoir d'augmentation du pas le multipliera par 2 avec un maximum de 32. Une pression sur le poussoir de diminution du pas le divisera par 2 avec un minimum de 1. Le fait de désigner un nouveau servo réinitialisera le pas de réglage à 8.

Modification de la classe `DescripteurServo`

La première modification est évidente. Auparavant, les butées étaient déterminées globalement pour les 8 servomoteurs. Maintenant que l'on veut régler les butées de chaque servomoteur individuellement, il faut que le DescripteurServo comporte deux données membres angleMin et angleMax comme ceci :

class DescripteurServo { Servo objetServo; /* Objet issu de la bibliothèque Servo de l'Arduino */ int vitesse; /* La vitesse de déplacement du servomoteur */ int angle; /* L'angle du servo-moteur */ int angleMin; /* Angle minimum du servo */ int angleMax; /* Angle maximum du servo */ int pin; /* La broche sur laquelle il est connecté */ byte etatServo; /* son état : SERVO_A_ANGLE_MIN, SERVO_A_ANGLE_MAX SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX ou SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN */ ...

On va bien entendu conserver des constantes minimum et maximum absolues afin de limiter le réglage :

const int ANGLE_MIN = 1000; const int ANGLE_MAX = 2000;

Ces constantes vont être employées dans le constructeur de DescripteurServo pour initialiser les données membres angleMin et angleMax.

La fonction de réglage

Ensuite, il faut écrire une fonction membre de réglage. Cette fonction est appelée de loop() lorsque le codeur désigne le servo concerné. Cette fonction doit

lire un événement sur le clavier de réglage ;
si l'événement est un changement de pas de réglage, la variable de pas est multipliée par 2 ou divisée par 2 ;
si l'événement est un réglage :
- si l'état du servo est SERVO_A_ANGLE_MIN, l'angle minimum est ajusté, la vitesse du servo est mise à 1 ou -1 selon le changement pour que le servo vienne de recaler sur l'angle minimum ;
- si l'état du servo est SERVO_A_ANGLE_MAX, l'angle maximum est ajusté, la vitesse du servo est mise à 1 ou -1 selon le changement pour que le servo vienne de recaler sur l'angle maximum.

Afin de séparer clairement les différents cas, nous allons utiliser des switch ... case.

void regleServo() { int numPoussoir; if (clavierReglage.lireEvenement(&numPoussoir) == EVENEMENT_PRESSE) { switch(numPoussoir) { case 0: /* déplacement de la butée dans le sens trigo */ switch(etatServo) { case SERVO_A_ANGLE_MIN: if (angleMin < angleMax) angleMin += min(pasDeReglage, angleMax - angleMin); objetServo.attach(pin); vitesse = 1; break; case SERVO_A_ANGLE_MAX: if (angleMax < ANGLE_MAX) angleMax += min(pasDeReglage, ANGLE_MAX - angleMax); objetServo.attach(pin); vitesse = 1; break; } break; case 1: /* déplacement de la butée dans le sens horaire */ switch(etatServo) { case SERVO_A_ANGLE_MIN: if (angleMin > ANGLE_MIN) angleMin -= min(pasDeReglage, angleMin - ANGLE_MIN); objetServo.attach(pin); vitesse = -1; break; case SERVO_A_ANGLE_MAX: if (angleMax > angleMin) angleMax -= min(pasDeReglage, angleMax - angleMin); objetServo.attach(pin); vitesse = -1; break; } break; case 2: /* diminution du pas de réglage */ if (pasDeReglage > 1) pasDeReglage /= 2; break; case 3: /* augmentation du pas de réglage */ if (pasDeReglage < 32) pasDeReglage *= 2; break; } } }

La gestion du mouvement

Le réglage est un cas particulier, l'angle du servo peut être en dehors de la fourchette angleMin et angleMax. Or la fonction gereServo() suppose que l'angle est dans la fourchette. Il ne va donc pas fonctionner correctement pour le réglage. Il faut donc l'adapter.

Tout d'abord, il nous faut une variable booléenne qui va indiquer si un réglage est en cours ou non. Cette variable sera modifiée dans loop en fonction de la valeur renvoyée par lireReglage(), la fonction qui renvoie l'état du codeur.

Si il n'y a aucun réglage en cours ou si le servo est dans l'une des états SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX ou SERVO_EN_MOUVEMENT_ VERS_ANGLE_MIN, il s'agit d'un mouvement normal du servo et le code existant fonctionne. Dans l'autre cas, il faut un code spécifique pour gérer le mouvement vers la nouvelle butée. Selon la butée où le servo est et selon le signe de la vitesse, on détermine quand le mouvement doit être arrêté :

if (etatServo == SERVO_A_ANGLE_MIN) { if (vitesse > 0 && angle >= angleMin) { angle = angleMin; vitesse = 0; objetServo.detach(); } else if (vitesse < 0 && angle <= angleMin) { angle = angleMin; vitesse = 0; objetServo.detach(); } } else if (etatServo == SERVO_A_ANGLE_MAX) { if (vitesse > 0 && angle >= angleMax) { angle = angleMax; vitesse = 0; objetServo.detach(); } else if (vitesse < 0 && angle <= angleMax) { angle = angleMax; vitesse = 0; objetServo.detach(); } }

Le fait de tester l'angle par rapport aux angles minimum et maximum avec des >= et <= est une sécurité. En effet, en testant avec une égalité == et si pour une raison indéterminée l'angle dépassait l'angle min ou max, le servo continuerait sont mouvement et irait en butée mécanique, ce qui pourrait l'endommager.

Modification de loop()

loop() est modifié pour prendre en compte la fonction de réglage.

void loop() { int numServo; /* gestion du mouvement des servos */ for (numServo = 0; numServo < 8; numServo++) servoMoteur[numServo].gereServo(); /* lecture d'un ordre de mouvement */ byte evenement = clavierOrdreServo.lireEvenement(&numServo); /* exécution de l'ordre de mouvement */ if (evenement == EVENEMENT_PRESSE) servoMoteur[numServo].evenementServo(); /* lecture du codeur qui désigne le servo à régler */ int servoARegler = lireReglage(); /* si positif ou nul, il y a un servo à régler */ reglageEnCours = (servoARegler >= 0); /* si on a changé de servo à régler, le pas est remis à 8 */ if (servoARegler != ancienServoARegler) { ancienServoARegler = servoARegler; pasDeReglage = 8; } /* exécution de réglage */ if (reglageEnCours) servoMoteur[servoARegler].regleServo(); delay(5); }

Voici le code complet du sketch à télécharger.

Sketch Arduino de l'application avec réglage des butées

Et une vidéo de la mise en œuvre.

Test de l'application avec le réglage des butées

Comme expliqué dans la vidéo, il reste une paire de détails à régler. Nous verrons cela dans le prochain article mais on commence à voir le bout du tunnel !

[1] Un pas vaut 1µs puisqu'on utilise la fonction writeMicroseconds(...) pour piloter les servos

Clavier de réglage des butées

Jean-Luc — 2013-11-30T12:49:01Z

Essayant de ne pas faire de trop gros articles indigestes, je saucissonne un peu plus les sujets. Voici le 2^e sur le réglage des butées. Il porte sur la transformation du programme que nous avions écrit pour le clavier analogique afin que le même programme puisse servir pour le clavier de réglage et en fait pour n'importe quel clavier analogique. En informatique on appelle ça la généricité.

Poussoirs de réglage de la position

Les poussoirs de réglage de la position sont mis en œuvre avec un clavier analogique de la même manière que les poussoirs de commande mais nous allons employer 4 poussoirs au lieu de 8 et les connecter sur l'entrée analogique A1. Nous allons voir plus tard pourquoi 4 et pas 2.

Pour avoir les valeurs des résistances, il suffit de faire sauter un poussoir sur deux dans le tableau de « Plusieurs boutons poussoir sur une entrée analogique » et d'additionner les deux résistances de part et d'autre des poussoirs supprimés. Les valeurs des résistances peuvent être moins précises car les plages de valeurs sont deux fois plus larges. Nous avons donc :

	Tension	Résistance	Résistance approchée	Tension approchée	Erreur
R1	1,25V	110Ω	120Ω	1,33V	6,4%
R2	2,5V	212Ω	220Ω	2,61V	4,4%
R3	3,75V	650Ω	560Ω	3,65V	1,78%

Le logiciel

Nous avons maintenant deux clavier analogiques, l'un pour les 8 poussoirs de changement de positions des servomoteurs et l'autre avec 4 pour le réglage. Nous allons bien entendu utiliser les mêmes fonctions pour les deux claviers et en profiter pour les passer en C++ comme nous l'avons fait pour les servomoteurs car maintenant que nous avons 2 claviers, il est logique d'avoir des objets. Un clavier analogique est jusqu'à présent représenté par 2 variables.

byte etatAutomate = NON_PRESSE; int etatPoussoir = -1;

Mais les fonctions lirePoussoirs() et lireEvenement() que nous avons écrites ont en dur dans le code le fait qu'il y ait 8 poussoirs. Il en est de même pour la broche de connexion. Par conséquent, pour que les fonctions puissent être génériques, nous allons en plus avoir besoin de la broche de connexion, du nombre de poussoirs et de ce nombre de poussoirs, nous allons déduire la taille d'une plage de valeurs. Voici le début de notre classe DescripteurClavierAnalogique.

class DescripteurClavierAnalogique { byte etatAutomate; int etatPoussoir; int taillePlage; int nbPoussoirs; int pin; };

Nous allons ajouter le constructeur qui contient les initialisations indépendantes du nombre de poussoirs et de la broche et une fonction de connexion qui va contenir les initialisations qui en sont dépendantes.

 public: DescripteurClavierAnalogique() { etatAutomate = NON_PRESSE; etatPoussoir = -1; } void connecte(int pinDeConnexion, int nombreDePoussoirs) { pin = pinDeConnexion; nbPoussoirs = nombreDePoussoirs; /* * calcule la taille d'une plage * le convertisseur a 1024 valeurs, Le taille de plage * est égal à 1024/nombreDePoussoirs. */ taillePlage = 1024 / nombreDePoussoirs; }

Enfin, nous allons modifier lirePoussoirs() afin de remplacer les valeur en dur par la plage de valeurs ou le nombre de poussoirs. lirePoussoirs() est placé dans la partie privée de la classe car il n'est appelé que part la fonction lireEvenement()

 int lirePoussoirs() { int resultat; int numPoussoir = (analogRead(pin) + taillePlage / 2) /taillePlage; int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */ switch (etatAutomate) { case NON_PRESSE: if (numPoussoir < nbPoussoirs) etatAutomate = ENFONCE; break; case ENFONCE: if (numPoussoir < nbPoussoirs) { etatAutomate = PRESSE; nouvelEtatPoussoir = numPoussoir; } else { etatAutomate = NON_PRESSE; } break; case PRESSE: if (numPoussoir == nbPoussoirs) { etatAutomate = NON_PRESSE; nouvelEtatPoussoir = -1; } break; } return nouvelEtatPoussoir; }

Nous pouvons maintenant créer nos deux objets clavierOrdreServo et clavierReglage.

DescripteurClavierAnalogique clavierOrdreServo; DescripteurClavierAnalogique clavierReglage;

et à appeler la fonction connect(...) dans setup()

 clavierOrdreServo.connecte(0,8); /* pin A0, 8 poussoirs */ clavierReglage.connecte(1,4); /* pin A1, 4 poussoirs */

Pour finir, la classe complète de gestion de clavier analogique avec l'ajout de lireEvenement(...). Cette classe est réutilisable sans modification dans n'importe quel montage comportant un clavier analogique.

class DescripteurClavierAnalogique { byte etatAutomate; int etatPoussoir; int taillePlage; int nbPoussoirs; int pin; int lirePoussoirs() { int resultat; int numPoussoir = (analogRead(pin) + taillePlage / 2) /taillePlage; int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */ switch (etatAutomate) { case NON_PRESSE: if (numPoussoir < nbPoussoirs) etatAutomate = ENFONCE; break; case ENFONCE: if (numPoussoir < nbPoussoirs) { etatAutomate = PRESSE; nouvelEtatPoussoir = numPoussoir; } else { etatAutomate = NON_PRESSE; } break; case PRESSE: if (numPoussoir == nbPoussoirs) { etatAutomate = NON_PRESSE; nouvelEtatPoussoir = -1; } break; } return nouvelEtatPoussoir; } public: DescripteurClavierAnalogique() { etatAutomate = NON_PRESSE; etatPoussoir = -1; } void connecte(int pinDeConnexion, int nombreDePoussoirs) { pin = pinDeConnexion; nbPoussoirs = nombreDePoussoirs; /* * calcule la taille d'une plage * le convertisseur a 1024 valeurs, Le taille de plage * est égal à 1024/nombreDePoussoirs. Le décalage est * la taille de la plage sur 2 */ taillePlage = 1024 / nombreDePoussoirs; } /* * construction d'un événement en comparant * le nouvel état des poussoirs avec l'état précédent. */ byte lireEvenement(int *numPoussoir) { byte evenement; int nouvelEtatPoussoir = lirePoussoirs(); if (nouvelEtatPoussoir == etatPoussoir) evenement = AUCUN_EVENEMENT; if (nouvelEtatPoussoir >= 0 && etatPoussoir == -1) evenement = EVENEMENT_PRESSE; if (nouvelEtatPoussoir == -1 && etatPoussoir >= 0) evenement = EVENEMENT_RELACHE; etatPoussoir = nouvelEtatPoussoir; *numPoussoir = etatPoussoir; return evenement; } };

Maintenant que les deux commandes nécessaires au réglage sont mises en place, nous allons pouvoir nous concentrer sur le réglage en lui-même.

Sélection d'un servomoteur pour le réglage des butées

Jean-Luc — 2013-11-23T16:06:22Z

Le réglage des butées est un point important. En effet, chaque servo moteur va avoir un neutre un peu différent de ses congénères. Il en va de même pour les positions extrêmes. De plus, chaque installation d'aiguille est un peu différente des autres.

Il est donc essentiel de pouvoir, servomoteur par servomoteur, régler les deux positions extrêmes.

Le matériel

Afin de sélectionner l'un des servomoteurs pour régler, au moyen de deux poussoirs, sa position extrême actuelle nous avons besoin d'un dispositif permettant de donner un numéro de servomoteur. Le dispositif le plus adapté est un codeur rotatif à 10 positions comme celui-ci.

http://akizukidenshi.com/img/goods/...

Ces codeurs rotatifs ont 6 broches. 2 d'entre-elles sont reliées entre elles et communes, les 4 autres codent en binaire la position du bouton (4 bits).

Comme 5 entrées analogiques sont disponibles et qu'il est aussi possible de les utiliser comme entrée numérique, on ne va pas finasser et simplement utiliser une entrée par bit [1]. 1 entrée analogique, A1, restera disponible pour les poussoirs de réglage.

Je n'ai pas de codeur rotatif en stock, à la place je vais utiliser un DIP-switch à 4 interrupteurs sur lequel le numéro du servo sera codé en binaire et qui sera raccordé exactement de la même façon que le codeur. Par convention, on décide que la valeur 0 (position 0 du codeur) est le mode d'exploitation. Aucun servo n'est sélectionné par le codeur. Les valeurs de 1 à 8 permettent de sélectionner le servo à régler. La valeur 9 correspond aussi au mode exploitation où aucun servo n'est sélectionné.

Le codeur est donc raccordé de la manière suivante aux entrées A2 à A5.

Câblage du codeur

Les interrupteurs c3, c2, c1 et c0 représentent chacun un chiffre binaire. Par convention, un 0 correspond à l'interrupteur ouvert et un 1 à l'interrupteur fermé. Si tous les interrupteurs sont ouverts, la valeur 0 est codée, si c0 est fermé et les autres ouverts la valeur 1 est codée. Si c2 et c1 sont fermés, les autres ouverts la valeur 6 est codée.

Les entrées dispose de résistances de tirage à 5V (on dit pull-up) interne que l'on peut activer par programme. Quand les interrupteurs sont ouverts, c'est à dire à 0 par convention, la valeur présente sur les entrées est 5V et non 0V ; Il faut en tenir compte pour construire le logiciel.

Le logiciel

Pour lire la valeur numérique codée et la stocker dans une variable entière servoARegler, il faut donc lire les entrées A2, A3, A4 et A5 en numérique, en déduire une valeur de bit et positionner le bit correspondant dans servoARegler. C'est l'occasion de voir une nouvelle spécificité du langage C, la manipulation des bits dans une variable.

Le langage C permet de faire des opérations logiques bit à bit. Les opérateurs permettant de telles opérations sont : le et bit à bit, noté &, le ou bit à bit, noté |, le ou exclusif bit à bit, noté ^ et le non (inversion de bit) bit à bit noté ~. Il existe aussi deux opérateurs de décalage : décalage logique vers la gauche d'un certain nombre de bits, noté << et le décalage vers la droite d'un certain nombre de bits, noté >>. Dans les deux cas, les bits laissés libres par le décalage sont à 0 [2], les bits qui sont expulsés sont perdus.

Ainsi, si l'on veut construire un byte dont tous les bits sont à 0 sauf les bits 0, 2 et 4 qui sont à 1 :

On peut écrire : 1 << 4 | 1 << 2 | 1

C'est à dire :

Ce qui est bien le résultat escompté.

On peut se poser la question de savoir que renvoit la lecture d'une entrée en numérique par un digitalRead(...). Eh bien elle vaut soit HIGH, soit LOW. Ces deux constantes sont en fait des entiers qui valent 1 pour HIGH et 0 pour LOW. On peut donc utiliser la valeur renvoyée par un digitalRead(...) dans un calcul. C'est ce que nous allons faire pour calculer la valeur du codeur.

En examinant le schéma de connexion, on voit que la condition permettant de construire le bit correspondant à une des entrées est l'inverse de la valeur renvoyée par digitalRead(...) parce que la position ouverte de l'interrupteur correspond à +5V. Il faut donc inverser cette valeur en utilisant le non logique : !. Cet opérateur retourne un 1 si son opérande est un 0 et un 0 si son opérande est différent de 0.

Donc la valeur du codeur peut être construite par l'expression suivante :

servoARegler = (! digitalRead(A2)) << 3 | (! digitalRead(A3)) << 2 | (! digitalRead(A4)) << 1 | (! digitalRead(A5));

Pour programmer proprement, on va loger ceci dans une fonction, lireReglage() et en profiter pour recadrer la valeur brute. Si la valeur brute est plus grande que 8, elle est remise à 0 et la valeur brute - 1 est retournée. De cette manière -1 signifie « rien à régler » et une valeur positive désigne le numéro du servo à régler.

/* * Lecture du codeur de réglage. * Retourne -1 si aucun servo n'est sélectionné et * le numéro du servo de 0 à 7 si un servo est sélectionné */ int lireReglage() { int servoARegler = (! digitalRead(A2)) << 3 | (! digitalRead(A3)) << 2 | (! digitalRead(A4)) << 1 | (! digitalRead(A5)); if (servoARegler > 8) servoARegler = 0; return servoARegler - 1; }

Comme c'est l'état du codeur qui nous intéresse et non les événements de changement d'état, il n'est pas nécessaire de se préoccuper des transitoires et autres rebonds.

Il va aussi falloir activer les résistances interne de pull-up. Faisons ceci dans une fonction qui sera appelée à partir de setup().

void initialiseCodeur() { /* Active le pullup des entrées A2, A3, A4 et A5 */ digitalWrite(A2,HIGH); digitalWrite(A3,HIGH); digitalWrite(A4,HIGH); digitalWrite(A5,HIGH); }

[1] On rappelle que les entrées/sorties logiques, en haut de l'Arduino, encore disponibles sont réservées pour les LED témoin.

[2] Seulement si la variable est non signée. Si la variable est signée, le décalage à droite remplit les bits laissés libres avec le bit de signe.

Un zeste de C++

Jean-Luc — 2013-11-23T10:19:00Z

Comme nous l'avons détaillé dans l'article précédent « 8 poussoirs et 8 servos, enfin ! », le passage d'un servomoteur à 8 servomoteurs, nous à contraint à rassembler les variables permettant de décrire l'état d'un servomoteur dans une struct afin de créer un tableau de 8 éléments de ce type.

struct DescripteurServo { Servo objetServo; int vitesse; int angle; int pin; byte etatServo; }; struct DescripteurServo servoMoteur[8];

Malheureusement, le programme manipulant un servomoteur s'en est trouvé alourdi car dorénavant, il faut préciser de quel élément du tableau il s'agit quand on veut modifier l'un des membre du descripteur de servomoteur. On se retrouve partout avec des servoMoteur[numServo]., Ce qui n'est ni joli, ni agréable.

De plus, si on examine le programme tel qu'il est actuellement, on s'aperçoit que seules deux fonctions s'occupent du descripteur de servomoteur : gereServo() pour accomplir le mouvement lent et evenementServo() pour donner l'ordre de mouvement. Il y a aussi setup() qui initialise les descripteurs mais on pourrait très bien le faire dans une fonction appelée par setup(). Il est donc tentant de mettre tout cela ensemble, le descripteur de servomoteur et les fonctions qui le manipule, et c'est exactement ce que permet le C++.

Le C++ va donc venir à notre secours pour simplifier et aérer considérablement notre programme.

Le C++ pris dans sa globalité est un langage complexe et nous n'avons pas besoin de tout. Nous n'allons prendre que ce dont nous avons besoin et qui va nous faciliter la tâche.

Le C++ est très utilisé dans l'Arduino. Par exemple, la bibliothèque Servo que nous utilisons est écrite en C++. C++ est une extension du C qui ajoute principalement une chose : les objets. Un objet contient une ou plusieurs données et une ou plusieurs fonctions (on dit méthode dans le jargon) pour lire/écrire cette valeur mais pas seulement. Pour créer un objet, on a besoin d'un type, comme pour créer une variable entière, on a besoin du type int. Pour créer un type d'objet, on déclare une classe. Faisons ça directement avec notre DescripteurServo :

class DescripteurServo { Servo objetServo; int vitesse; int angle; int pin; byte etatServo; };

Rien de renversant jusqu'à là. C'est exactement comme une struct. La particularité est de pouvoir y mettre aussi des fonctions qui deviennent donc membres de la classe. Mettons y gereServo() et evenementServo().

class DescripteurServo { Servo objetServo; int vitesse; int angle; int pin; byte etatServo; public: void gereServo() { objetServo.writeMicroseconds(angle); angle += vitesse; if (angle > angleMax) { angle = angleMax; vitesse = 0; objetServo.detach(); etatServo = SERVO_A_ANGLE_MAX; } else if (angle < angleMin) { angle = angleMin; vitesse = 0; objetServo.detach(); etatServo = SERVO_A_ANGLE_MIN; } } void evenementServo() { switch (etatServo) { case SERVO_A_ANGLE_MIN: objetServo.attach(pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: vitesse = 1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: objetServo.attach(pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: vitesse = -1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } } };

Comme vous pouvez le constater, tous les servoMoteur[numServo]. ont disparu. En effet, les fonctions membre accèdent directement aux données membres de la classe. Par ailleurs, l'argument numServo des fonctions a disparu pour la même raison.
Enfin, le public: permet de rendre les deux fonctions membres appelables depuis l'extérieur de l'objet. Notez aussi que les données membres ne sont pas publiques, on ne peut donc y accéder depuis l'extérieur de l'objet.

Il reste une dernier point à régler. Dans setup(), une boucle initialise chaque descripteur de servo. Certaines initialisations sont dépendantes du numéro de servo (en fait du numéro de broche à laquelle le servo est connecté), d'autre ne le sont pas. En C++, un objet peut avoir un constructeur. Il s'agit d'une fonction membre qui porte le même nom que la classe et qui est exécutée lors de la création de l'objet. Nous allons ajouter ce constructeur pour y mettre les initialisations indépendantes du numéro de broche. Enfin nous allons ajouter une fonction membre pour les initialisations qui sont dépendantes du numéro de broche.

 DescripteurServo() { angle = angleMin; vitesse = 0; etatServo = SERVO_A_ANGLE_MIN; } void connecte(int pinDeConnection) { pin = pinDeConnection; objetServo.attach(pinDeConnection); }

Il reste à modifier le reste du programme pour l'adapter. Tout d'abord, dans setup() les initialisations consistent maintenant à appeler la fonction membre connecte(...). Les intialisation indépendantes du numéro de broche sont déjà faites.

void setup() { /* Initialisation des servos */ int numServo; for (numServo = 0; numServo < 8; numServo++) servoMoteur[numServo].connecte(numServo + 2); }

Notez la syntaxe pour appeler une fonction membre. servoMoteur[numServo] est un objet du tableau, le . permet d'accéder à un de ses membres et connecte(numServo +2) permet d'appeler la fonction membre connecte en lui passant numServo + 2 comme argument.

De la même manière, la boucle qui appelait gereServo() pour chacun des servomoteurs est modifiée.

 for (numServo = 0; numServo < 8; numServo++) servoMoteur[numServo].gereServo();

Enfin, la notification d'un événement sur le poussoir est aussi modifié.

 byte evenement = lireEvenement(&numServo); if (evenement == EVENEMENT_PRESSE) { servoMoteur[numServo].evenementServo(); }

Rien de bien sorcier finalement. Le programme est beaucoup plus clair écrit de cette manière et cerise sur le gâteau, il prend 274 octets de moins une fois compilé !

Voici le sketch Arduino correspondant :

Logiciel de pilotage de 8 servos avec 8 boutons réécrit en C++

8 poussoirs et 8 servos, enfin !

Jean-Luc — 2013-11-17T13:12:48Z

Dans « Commande du servo-moteur par bouton poussoir », nous avons vu comment commander un servo-moteur avec un poussoir. Dans « Plusieurs boutons poussoir sur une entrée analogique », nous avons vu comment connecter 8 poussoirs sur une entrée analogique et détecter lequel est pressé. Il reste maintenant à mettre en œuvre les 8 servos.

Les variables pour manipuler les 8 servos

Si vous vous rappelez, plusieurs variables étaient employées pour notre servo : l'objet de type Servo permettant de le piloter, son angle, sa vitesse, son état. Comme ceci.

Servo monServo; int vitesse = 0; int angle = angleMin; byte etatServo = SERVO_A_ANGLE_MIN;

Si nous avons 8 servos, il va falloir 8 exemplaires de chacune de ces variables. Plutôt que de répliquer 8 fois ces définitions, ce qui serait fastidieux, nous allons créer un tableau avec autant d'éléments que de servos. Mais avant de créer ce tableau, nous devons mettre ces variables ensemble. Pour les mettre ensemble, il existe en C les struct pour structure. Comme ceci.

struct DescripteurServo { Servo objetServo; int vitesse; int angle; byte etatServo; };

Une struct a un nom, ici DescripteurServo, et des membres, objetServo, vitesse, angle et etatServo. struct DescripteurServo est en quelques sortes un nouveau type de donnée, comme int ou byte, et on peut l'utiliser pour créer un tableau de 8 éléments que nous appelons servoMoteur comme ceci.

struct DescripteurServo servoMoteur[8];

servoMoteur est le nom de notre tableau, le [8] indique qu'il contient 8 éléments et struct DescripteurServo est le type d'un élément.

Pour accéder à un élément du tableau servoMoteur, il faut indiquer son numéro, entre 0 et 7 compris. Ainsi, servoMoteur[4] est le 5e élément [1] du tableau.

Enfin, pour accéder à un membre d'un élément, il faut ajouter un . et le nom de l'élément. Ainsi, servoMoteur[4].angle permet d'accéder à l'angle du 5e servo.

La mise à jour de l'angle des 8 servos

Pour un seul servo, le morceau de programme de mise à jour de l'angle était le suivant.

 /* actualisation de l'angle du servo */ monServo.writeMicroseconds(angle); angle = angle + vitesse; if (angle > angleMax) { angle = angleMax; vitesse = 0; etatServo = SERVO_A_ANGLE_MAX; } else if (angle < angleMin) { angle = angleMin; vitesse = 0; etatServo = SERVO_A_ANGLE_MIN; }

Comme nous avons maintenant un tableau de variables, il faut le réécrire. Pour bien séparer les différentes parties du programme qui commence à grossir, nous allons déplacer ce morceau de programme dans une fonction, appelons la gereServo. Cette fonction prendra un argument, le numéro de servo à gérer. Ce numéro de servo va servir à accéder au tableau.

void gereServo(int numServo) { servoMoteur[numServo].objetServo.writeMicroseconds( servoMoteur[numServo].angle); servoMoteur[numServo].angle += servoMoteur[numServo].vitesse; if (servoMoteur[numServo].angle > angleMax) { servoMoteur[numServo].angle = angleMax; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MAX; } else if (servoMoteur[numServo].angle < angleMin) { servoMoteur[numServo].angle = angleMin; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MIN; } }

Dans loop(), nous allons appeler cette fonction gereServo pour chacun des servos. Pour cela nous allons faire une boucle for( ... ; ... ; ... ). Pour parcourir tous les servos, nous allons écrire for( numServo = 0; numServo < 8; numServo++). Le numServo = 0; est exécuté une fois au début de la boucle. il s'agit de l'initialisation. Le numServo < 8 est une condition qui est testée au début de chaque itération. Si la condition est vraie, la boucle continue, sinon elle s'arrête. Enfin le numServo++ est exécuté à la fin de chaque itération de la boucle, numServo est augmenté de 1. Par conséquent, cette boucle va produire 8 itérations et numServo vaudra successivement 0, 1, 2, 3, 4, 5, 6 et 7, ce qui correspond bien au parcours des éléments de notre tableau servoMoteur.

Gérer les 8 servos est donc pris en charge par cette ligne dans loop()

for (numServo = 0; numServo < 8; numServo++) gereServo(numServo);

Intégration de la commande par poussoir

Dans « Commande du servo-moteur par bouton poussoir », L'unique poussoir était lu et la vitesse du servo était changée. Comme ceci.

 byte evenement = lireEvenement(); if (evenement == EVENEMENT_PRESSE) { switch (etatServo) { case SERVO_A_ANGLE_MIN: case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: vitesse = 1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: vitesse = -1; etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } }

Nous allons isoler le switch ... case dans une fonction que nous appelons evenementServo(...) et dont l'argument est le numéro de servo. Ce numéro de servo est le numéro de bouton pressé. Il suffit alors de modifier la vitesse du servo correspondant. Comme ceci.

void evenementServo(int numServo) { switch (servoMoteur[numServo].etatServo) { case SERVO_A_ANGLE_MIN: case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: servoMoteur[numServo].vitesse = 1; servoMoteur[numServo].etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: servoMoteur[numServo].vitesse = -1; servoMoteur[numServo].etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } }

Il ne reste plus qu'à lire l'événement du bouton comme dans « Plusieurs boutons poussoir sur une entrée analogique » et à appeler la fonction evenementServo(...) avec le numéro de bouton recueilli.

 byte evenement = lireEvenement(&numServo); if (evenement == EVENEMENT_PRESSE) evenementServo(numServo);

Le programme complet est le suivant.

#include  const byte SERVO_A_ANGLE_MIN = 0; const byte SERVO_A_ANGLE_MAX = 1; const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX = 2; const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN = 3; const int angleMin = 1250; const int angleMax = 1750; struct DescripteurServo { Servo objetServo; int vitesse; int angle; byte etatServo; }; struct DescripteurServo servoMoteur[8]; const byte NON_PRESSE = 0; const byte ENFONCE = 1; const byte PRESSE = 2; byte etatAutomate = NON_PRESSE; int etatPoussoir = -1; const byte AUCUN_EVENEMENT = 0; const byte EVENEMENT_PRESSE = 1; const byte EVENEMENT_RELACHE = 2; const int pinPoussoirs = 0; /* * Lecture des poussoirs. À l'aide d'un automate, on assure que les valeurs * transitoires sont filtrées. */ int lirePoussoirs() { int resultat; int numPoussoir = (analogRead(pinPoussoirs) + 64) / 128; int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */ switch (etatAutomate) { case NON_PRESSE: if (numPoussoir < 8) etatAutomate = ENFONCE; break; case ENFONCE: if (numPoussoir < 8) { etatAutomate = PRESSE; nouvelEtatPoussoir = numPoussoir; } else { etatAutomate = NON_PRESSE; } break; case PRESSE: if (numPoussoir == 8) { etatAutomate = NON_PRESSE; nouvelEtatPoussoir = -1; } break; } return nouvelEtatPoussoir; } /* * construction d'un événement en comparant * le nouvel état des poussoirs avec l'état précédent. */ byte lireEvenement(int *numPoussoir) { byte evenement; int nouvelEtatPoussoir = lirePoussoirs(); if (nouvelEtatPoussoir == etatPoussoir) evenement = AUCUN_EVENEMENT; if (nouvelEtatPoussoir >= 0 && etatPoussoir == -1) evenement = EVENEMENT_PRESSE; if (nouvelEtatPoussoir == -1 && etatPoussoir >= 0) evenement = EVENEMENT_RELACHE; etatPoussoir = nouvelEtatPoussoir; *numPoussoir = etatPoussoir; return evenement; } /* * Initialisations. Chaque servomoteur est initialisé à l'angle minimum * sa vitesse est mise à 0 */ void setup() { /* Initialisation des servos */ int numServo; for (numServo = 0; numServo < 8; numServo++) { servoMoteur[numServo].angle = angleMin; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MIN; servoMoteur[numServo].objetServo.attach(numServo+2); } } /* * Actualisation de l'angle du servo */ void gereServo(int numServo) { servoMoteur[numServo].objetServo.writeMicroseconds( servoMoteur[numServo].angle); servoMoteur[numServo].angle += servoMoteur[numServo].vitesse; if (servoMoteur[numServo].angle > angleMax) { servoMoteur[numServo].angle = angleMax; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MAX; } else if (servoMoteur[numServo].angle < angleMin) { servoMoteur[numServo].angle = angleMin; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MIN; } } /* * changement de consigne d'un servomoteur. */ void evenementServo(int numServo) { switch (servoMoteur[numServo].etatServo) { case SERVO_A_ANGLE_MIN: case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: servoMoteur[numServo].vitesse = 1; servoMoteur[numServo].etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: servoMoteur[numServo].vitesse = -1; servoMoteur[numServo].etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } } void loop() { int numServo; for (numServo = 0; numServo < 8; numServo++) gereServo(numServo); byte evenement = lireEvenement(&numServo); if (evenement == EVENEMENT_PRESSE) evenementServo(numServo); delay(3); }

Coupure de la commande dans les positions extrêmes

Jusqu'à maintenant, une fois qu'un servomoteur a gagné une de ses deux positions extrêmes, la commande PWM de position reste active. Par conséquent l'électronique du servomoteur continue d'asservir la position. Or, en présence d'une résistance mécanique comme par exemple l'effet ressort de la tige de commande de l'aiguille, l'asservissement de position fait que le servomoteur grogne. C'est un inconvénient, à la fois pour les oreilles et pour la consommation électrique.

Pour supprimer cet asservissement une fois que le servomoteur a accompli son mouvement, il suffit de couper la commande PWM. Ce n'est pas explicitement prévu dans la bibliothèque Servo de l'Arduino mais il suffit de détacher le servo de la broche de sortie par la méthode detach() pour couper la commande PWM.

Pour simplifier le programme, on va ajouter dans DescripteurServo un membre pour stocker le numéro de broche. Appelons le pin.

struct DescripteurServo { Servo objetServo; int vitesse; int angle; int pin; byte etatServo; };

Il faut évidemment ne pas oublier d'initialiser pin dans setup()

 for (numServo = 0; numServo < 8; numServo++) { servoMoteur[numServo].angle = angleMin; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MIN; servoMoteur[numServo].pin = numServo + 2; servoMoteur[numServo].objetServo.attach(servoMoteur[numServo].pin); }

Dans la fonction gereServo(...) on va détacher le servo quand une des positions extrêmes est atteinte.

 if (servoMoteur[numServo].angle > angleMax) { servoMoteur[numServo].angle = angleMax; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].objetServo.detach(); servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MAX; } else if (servoMoteur[numServo].angle < angleMin) { servoMoteur[numServo].angle = angleMin; servoMoteur[numServo].vitesse = 0; servoMoteur[numServo].objetServo.detach(); servoMoteur[numServo].etatServo = SERVO_A_ANGLE_MIN; }

Enfin, dans la fonction evenementServo, on va attacher de nouveau le servo à la broche quand si le servo est dans une des positions extrêmes. On voit ici l'intérêt d'avoir séparer les cas SERVO_A_ANGLE_x et SERVO_EN_MOUVEMENT_VERS_ANGLE_x car pour le second il ne faut pas attacher le servo à la broche.

void evenementServo(int numServo) { switch (servoMoteur[numServo].etatServo) { case SERVO_A_ANGLE_MIN: servoMoteur[numServo].objetServo.attach(servoMoteur[numServo].pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN: servoMoteur[numServo].vitesse = 1; servoMoteur[numServo].etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX; break; case SERVO_A_ANGLE_MAX: servoMoteur[numServo].objetServo.attach(servoMoteur[numServo].pin); case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX: servoMoteur[numServo].vitesse = -1; servoMoteur[numServo].etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN; break; } }

Le programme devenant plus gros, je vais cesser de donner son code in-extenso sur les pages du blog. Le voici donc à télécharger

Programme Arduino avec coupure de la commande PWM

Les essais

Attention, avec 8 servomoteurs tirant sur l'alimentation de l'Arduino, il faut prendre certaines précautions. Il faut tout d'abord s'assurer que la consommation totale n'excède pas ce que l'Arduino peut fournir. Son régulateur de tension est donné pour 1A mais la carte elle-même consomme.

Pour mes expérimentations j'ai mesuré la consommation des servos HK15178. Au repos, il consomment 7mA. En mouvement à la vitesse imposée, ils montent à un peu moins de 60mA. Si il n'y qu'un seul servo en mouvement à un instant, l'ensemble va donc consommer 7 × 7mA + 60mA = 110mA ce qui reste raisonnable. Bloqué, il consomme 150mA. Dans les faits la connexion du 6e servo a provoqué la coupure de l'alimentation car le régulateur a détecté une consommation excessive. Comme déjà indiqué dans « La carte de commande 6 servo-moteurs, le matériel », l'appel de courant lors de la mise sous tension d'un servomoteur peut être important.

Pour une installation sur le réseau, il est donc préférable de prévoir une alimentation séparée pour les servomoteurs.

Voici la vidéo des essais.

La prochain article sera consacré à l'ajout de la fonction de réglage des butées.

[1] Oui le 5e puisque le premier à le numéro 0

ModelleisenbahN

L'algorithme de rotation du pont tournant

Calcul du sens de rotation pour le plus court chemin

Vitesse de rotation, accélération et décélération

Sketch de démonstration

Mise en œuvre de l'EasyDriver v4.4 pour un pont tournant

Le matériel

Le logiciel

Témoins de positions : la mise en œuvre

Charlieplexing des 16 LED témoins [1]

Intégration dans l'application

Témoins de positions : le Charlieplexing

Comment faire ?

Programme de démonstration

Amélioration et mémorisation des réglages

Prise en compte de l'inertie mécanique

Mémorisation des butées

Réglage des butées des servomoteurs

Le fonctionnement du réglage

Modification de la classe DescripteurServo

Clavier de réglage des butées

Poussoirs de réglage de la position

Le logiciel

Sélection d'un servomoteur pour le réglage des butées

Le matériel

Le logiciel

Un zeste de C++

8 poussoirs et 8 servos, enfin !

Les variables pour manipuler les 8 servos

La mise à jour de l'angle des 8 servos

Intégration de la commande par poussoir

Coupure de la commande dans les positions extrêmes

Les essais

Modification de la classe `DescripteurServo`