ModelleisenbahN

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

Plusieurs boutons poussoir sur une entrée analogique

Jean-Luc — 2013-11-16T22:11:12Z

Dans « Commande du servo-moteur par bouton poussoir », nous avons vu comment connecter un bouton poussoir à une entrée analogique. Dans celui-ci nous allons voir comment en connecter plusieurs et lire lequel est enfoncé.

Cette idée de connecter plusieurs poussoirs sur une entrée analogique n'est pas nouvelle. Une Application Note de Freescale existe et l'idée m'a été soufflée par Marc-Henri que je remercie au passage.

Marc-Henri vient de publier un article sur son blog qui décrit précisément le calcul des résistances ainsi qu'une feuille de calcul (format Excel) le mettant en œuvre pour un nombre quelconque de poussoirs

Principe de fonctionnement

Avec un seul poussoir, nous avons vu que l'entrée analogique de l'Arduino était tirée à la masse via une résistance de 10kΩ. L'appui sur le poussoir amenait cette entrée à 5V. Pour la suite, on va inverser la connexion. L'entrée analogique esr tirée à +5V et l'appui sur le poussoir amène cette entrée à la masse. En effet, avec plusieurs poussoirs, cette façon de faire est plus commode car, sur le réseau, la masse est distribuée partout alors que ce n'est pas le cas pour le +5V.

Connexion d'un poussoir à l'entrée analogique de l'Arduino Uno, état de repos à +5V

Imaginons maintenant que nous ajoutions un second poussoir en parallèle du premier et qu'il soit connecté entre l'entrée analogique de l'Arduino et la masse via une résistance, également de 10kΩ, comme ceci.

Connexion de deux poussoirs à une entrée analogique

Lorsque B0 est pressé, nous avons le même comportement, l'entrée analogique est à 0V. Lorsque B1 est pressé, les deux résistances sont en série entre 5V et 0V et l'entrée analogique est à la tension qui existe entre les deux résistances. On voit qu'il s'agit d'un diviseur de tension, et donc l'entrée analogique est à 2,5V. Evidemment, on ne peut pas presser 2 poussoirs en même temps, l'Arduino ne verra que le poussoir de rang le plus bas.

On peut continuer à ajouter des poussoirs en parallèle avec la résistance adéquate pour que le diviseur de tension donne une tension précise pour chaque poussoir. Pour nos 8 boutons-poussoir, nous allons procéder de cette manière.

Connexion de 8 poussoirs à une entrée analogique

Avec 8 poussoirs, il faut diviser les 1024 valeurs possibles en 8 intervalles de 1024 ÷ 8 = 128 valeurs. Plus on ajoute des poussoirs et plus cet intervalle devient petit. Plus cet intervalle devient petit et plus il est nécessaire d'avoir des résistances précises. Or, les résistances standards ont des valeurs déterminées et sont précises à 5%. Si les intervalles sont trop petits, il devient impossible de distinguer deux valeurs voisines de façon fiable. Cela limite le nombre de poussoirs que l'on peut connecter mais 8 poussoirs ne devraient pas poser de problème.

Sur la figure précédente, la plage de valeurs analogiques a été découpée en 8 intervalles. En (a) le poussoir pressé, en (b) la tension correspondante, en (c) la valeur numérique, en (d) cette même valeur numérique en binaire. Il faut donc déterminer les résistances R1 à R7 de manière à obtenir plus ou moins la tension voulue. On va voir que ça se fait assez bien.

Une fois une valeur analogique numérisée, il faut déterminer par programme de quel poussoir il s'agit. On peut le faire par une succession de if ... else ... en testant la valeur lue par rapport au milieu des intervalles : entre 0 et 63, aucun poussoir n'est pressé, entre 63 et 191, B0 est pressé, entre 192 et 319, B1 est pressé, etc. Mais c'est un peu long. On peut écrire cela de manière plus concise, un programmeur est un fainéant, moins il écrit de code, mieux il se porte.

Pour cela, nous allons diviser la valeur lue par la taille de l'intervalle (128).
Il s'agit évidemment d'une division entière, le résultat donnerait le numéro du poussoir pressé, il s'agit des 3 bits de poids fort dans la colonne (d), ceux qui sont séparés des autres. Malheureusement, on peut voir que ce résultat change au voisinage de la valeur lue. Par exemple au voisinage de 127, le résultat peut être 0 ou 1 et au voisinage de 255, le résultat peut être 1 ou 2. Par conséquent on peut confondre les deux poussoirs !

Pour malgré tout procéder de cette manière, il suffit de décaler l'intervalle. En ajoutant la moitié de la taille de l'intervalle à la valeur lue, 64 donc, le résultat donné pas la division entière est directement le numéro du poussoir (de 0 à 7), ou bien 8 si aucun poussoir n'est pressé, et ce numéro est stable et centré au voisinage des valeurs lues, comme montré à la colonne (d). La détermination du poussoir pressé se fait alors en une ligne de code.

int numPoussoir = (analogRead(pinPoussoirs) + 64) / 128;

Cette concision ne peut que réjouir le programmeur ^_^

Immunité au bruit et détermination des résistances

Les essais avec un seul poussoir ont employé une résistance de 10kΩ traversée par une courant de 0,5mA quand le poussoir est pressé. Avec de longs fils entre les poussoirs et l'Arduino, le bruit électrique dû aux ondes électromagnétiques qui nous environnent peut être important. Il est préférable d'utiliser des résistances de plus faible valeur afin que le courant circulant dans le circuit quand un poussoir est pressé soit plus élevé et que le bruit puisse être absorbé par l'alimentation. Nous allons donc choisir un courant maximum d'environ 15mA, soit une résistance de 330Ω à la place de la résistance de 10kΩ utilisée jusqu'à présent.

Il faut maintenant déterminer les valeurs des résistances R1 à R7 pour obtenir les tensions que nous avons déterminées. Les diviseurs de tension pour chacun des poussoirs sont les suivants.

Les diviseurs de tension pour chacun des poussoirs.

Par calcul on détermine les valeurs des résistances pour chaque poussoir. La colonne Résistance donne la résistance qui serait nécessaire, la colonne Résistance approchée donne la valeur standard employée et la colonne Tension approchée donne la tension effectivement obtenue en supposant évidemment que la résistance est juste.

	Tension	Résistance	Résistance approchée	Tension approchée	Erreur
R1	0,625V	47,14Ω	47Ω	0,634V	0,04%
R2	1,25V	62,85Ω	62Ω	1,27V	0,23%
R3	1,875V	88Ω	82Ω	1,89V	1,34%
R4	2,5V	132Ω	130Ω	2,53V	1,38%
R5	3,125V	220Ω	220Ω	3,17V	1,03%
R6	3,75V	440Ω	430Ω	3,76V	1,46%
R7	4,375V	1320Ω	1300Ω	4,377V	1,50%

Le retour du rebond

Il ne s'agit pas tout à fait d'un rebond mais il va falloir prendre en compte ce que l'on appelle une transitoire.

Quand l'un des poussoirs est pressé, l'entrée analogique passe de 5V à la tension correspondante telle qu'elle a été réglée par les résistances. Mais elle ne le fait pas instantanément. Cela prend un certain temps.

Imaginons maintenant que le convertisseur analogique-numérique de l'Arduino capture la tension alors que celle-ci est en train de descendre. Le résultat va être que le logiciel croit voir une pression sur un poussoir de rang supérieur à celui véritablement pressé. De même quand le poussoir va être relâché, la capture de la tension peut avoir lieu alors qu'elle est en train de monter et retourner également un numéro de poussoir de rang supérieur. Il faut donc filtrer ces transitoires et n'accepter la valeur brute calculée dans numPoussoir que sous certaines conditions.

Avec un seul poussoir ce phénomène n'existait pas car il n'y avait pas d'autre poussoir.

Pour filtrer les valeurs non voulues, nous allons mettre en œuvre ce que l'on appelle un système séquentiel. On représente ce genre de système par un graphe, appelé automate. Un ovale est un état, une flèche est une transition qui permet de passer d'un état à l'autre. Les textes en vert sont des conditions qui permettent ou empêchent une transition et les textes en rouge des actions qui sont effectuées lors d'une transition. L'ovale à double bordure est l'état initial. La flèche qui vient de nulle part et qui pointe sur l'état initial correspond aux actions d'initialisation.

Voici l'automate de notre système.

Automate de lecture de l'état des poussoirs

Entre chaque transition, le temps nécessaire à l'exécution de loop(), s'écoule.
Le passage par l'état ENFONCE permet de laisser passer du temps entre la détection de la pression sur un poussoir et la lecture du numéro correspondant. Ce numéro n'est pas réactualisé dans l'état PRESSE, ce qui permet de filtrer les valeurs non désirées lors du relâchement du poussoir.

À partir de l'état initial, NON_PRESSE, qui correspond à aucun poussoir enfoncé, on peut :

rester dans cet état (aucun poussoir enfoncé correspond à un numéro de poussoir égal à 8) ;
passer dans l'état ENFONCE (l'un des poussoir enfoncé correspond à un numéro de poussoir inférieur à 8).

Une fois dans l'état ENFONCE :

soit le poussoir est relâché immédiatement (c'est à dire en quelques millisecondes, il s'agissait d'un rebond ou d'un parasite), le numéro de poussoir est égal à 8 ;
soit il est toujours enfoncé, numéro de poussoir inférieur à 8 et on confirme en passant dans l'état PRESSE et en mémorisant dans etatBouton le numéro du poussoir enfoncé.

Dans l'état PRESSE :

soit le poussoir est maintenu enfoncé (numPoussoir < 8) et on attend en restant dans l'état PRESSE ;
soit le poussoir est relâché (numPoussoir == 8) et on repasse dans l'état NON_PRESSE en remettant etatBouton à -1.

Le passage de l'automate à un programme C est direct. On va avoir besoin d'une variable pour stocker l'état dans lequel se trouve l'automate ainsi que des variables employées par l'automate. Comme il est impossible de détecter plusieurs poussoirs enfoncés, il est inutile d'avoir une variable d'état par poussoir. Une seule variable suffit mais elle a autant d'états que de poussoirs plus une pour représenter le fait qu'aucun poussoir n'est enfoncé.

const byte NON_PRESSE = 0; const byte ENFONCE = 1; const byte PRESSE = 2; byte etatAutomate = NON_PRESSE; int etatPoussoir = -1; /* aucun poussoir n'est pressé au début */ const int pinPoussoirs = 0; 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; }

Il reste à modifier lireEvenement(...) pour l'adapter à lirePoussoirs(). En effet, en plus de l'information de présence d'événement, il est nécessaire d'obtenir le numéro du poussoir qui a déclenché l'événement. Or une fonction C ne retourne qu'une seule valeur. Il faut donc trouver un moyen pour obtenir la seconde valeur, le numéro du poussoir.

Nous allons employer un argument. En C les arguments sont passés aux fonctions par valeur. C'est à dire que la valeur contenue dans la variable que l'on passe à la fonction est recopiée dans une variable locale de la fonction. Si la fonction change le contenu de cette variable, seule sa copie est changée. Il faut donc employer un autre moyen pour que la fonction puisse modifier la variable qui lui est passée. Ce moyen, ce sont les pointeurs.

Une variable est placée dans la mémoire RAM du micro-contrôleur. On peut voir la RAM comme un tableau de cases. Chaque case a un numéro, on dit une adresse. Il est possible d'obtenir l'adresse d'une variable via l'opérateur &, de définir une variable qui soit un pointeur vers un type, via la notation * et il est possible d'écrire ou de lire dans une variable par l'intermédiaire de son adresse via l'opérateur *. Ainsi :

int *p;

définit un pointeur vers une variable de type int. Ce pointeur est pour l'instant non initialisé, il ne pointe sur rien. Essayer d'accéder à ce qu'il pointe est une erreur.

int a; int *p = &a;

définit un pointeur p vers une variable de type int qui pointe sur a. &a retourne l'adresse de a.

*p = 3;

met la valeur 3 dans la variable a.

Pour définir la fonction lireEvenement(...) qui retourne un byte et prend pour argument un pointeur vers un int, et qui modifie la variable pointée, on écrira.

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; }

L'argument int *numPoussoir définit numPoussoir qui est un pointeur sur un int. À l'avant dernière ligne de la fonction, l'état du poussoir est écrit dans la variable pointée par numPoussoir, il s'agit de la ligne *numPoussoir = etatPoussoir;

Il faut donc que numPoussoir pointe sur la variable dans laquelle on désire récupérer le numéro de poussoir. Donc, pour appeler cette fonction, on écrira.

 int numeroPoussoir; byte evenement = lireEvenement(&numeroPoussoir);

ce qui a pour effet de passer à la fonction l'adresse, opérateur &, de numeroPoussoir afin d'obtenir la valeur désirée dans cette variable.

Essai du système

La première étape consiste à câbler sur la breadboard les poussoirs est les résistances comme ceci.

Placement des composants sur le breadboard

Voici le programme complet de test du système. Les messages d'appui ou de relâchement des poussoirs sont affichés sur le moniteur série avec le numéro de poussoir enfoncé.

 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; 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; if (evenement == EVENEMENT_PRESSE) { *numPoussoir = nouvelEtatPoussoir; } else if (evenement == EVENEMENT_RELACHE) { *numPoussoir = etatPoussoir; } etatPoussoir = nouvelEtatPoussoir; return evenement; } void setup() { Serial.begin(9600); } void loop() { int numPoussoir; byte evenement = lireEvenement(&numPoussoir); switch (evenement) { case EVENEMENT_PRESSE: Serial.print("Presse : "); Serial.println(numPoussoir); break; case EVENEMENT_RELACHE: Serial.print("Relache : "); Serial.println(numPoussoir); break; } delay(3); }

Une petite vidéo montrant la mise en œuvre du programme.

Le système de commande à 8 boutons sur une entrée analogique est opérationnel.

Nous avons vu quelques éléments supplémentaires de langage C comme les pointeurs et leur emploi pour retourner plusieurs valeurs à partir d'une fonction. Nous avons vu rapidement les automates et comment les mettre en œuvre avec un switch ... case. La prochaine fois nous ajouterons nos 8 servo-moteurs.

Commande du servo-moteur par bouton poussoir

Jean-Luc — 2013-11-11T17:57:57Z

Nous allons maintenant ajouter un bouton poussoir pour commander le mouvement du servo-moteur. Cet article fait suite à « Mise en œuvre d'un servo-moteur ».

Le système fonctionnera de la manière suivante : Lorsque le servo-moteur est dans une des positions extrêmes, une pression sur le poussoir donnera au servo-moteur une vitesse lui permettant de gagner l'autre position extrême. Lorsque le servo-moteur est en mouvement, une pression sur le bouton inversera la vitesse.

Mise en œuvre du bouton poussoir

Comme déjà expliqué, nous allons réserver les entrées/sorties numériques, les broches 0 à 13 de l'Arduino, au pilotage des servo-moteurs et à l'allumage des LED témoin.

Pour l'instant, l'unique bouton poussoir est connecté sur une entrée analogique, A0 par exemple. Une entrée analogique permet à l'Arduino de lire une grandeur analogique, entre 0V et 5V, et de la convertir en un nombre que l'on pourra manipuler dans le programme. Le nombre obtenu peut prendre des valeurs comprises entre 0 (pour 0V) et 1023 (pour 5V) avec donc 1024 valeurs possibles.

Pour notre bouton, il n'y aura que deux valeurs, celle qui correspond au bouton relâché et celle qui correspond au bouton enfoncé. Le bouton est connecté à l'Arduino comme ceci.

Connexion du bouton poussoir à l'Arduino Uno

Lorsque le bouton est relâché, l'entrée analogique A0 est tirée à 0V via la résistance de 10kΩ. Lorsque le bouton est pressé, l'entrée est mise à 5V.

Du côté du programme, nous allons séparer l'espace de valeurs (0 à 1023) en deux parties égales : les valeurs inférieures ou égales à 511 et celles supérieures à 511 et nous allons définir une fonction qui lit la valeur analogique, la compare à la valeur milieu et retourne soit RELACHE, soit PRESSE. Ces deux constantes sont des booléens, c'est à dire des valeurs logiques. Elle sont définies pour faciliter la lecture du programme. Jusqu'alors nous n'avons vu que des fonctions qui ne retournaient rien, c'est à dire void. Ici la fonction lireBouton retourne un booléen, qui sera l'état du bouton. Nous avons donc le morceau de programme suivant avec la définition des constantes nécessaires et la fonction de lecture de l'état du bouton poussoir.

/* le bouton est connecté à la broche A0 */ const int pinBouton = 0; /* valeur logique pour indiquer que le bouton est pressé */ const boolean PRESSE = true; /* valeur logique pour indiquer que le bouton est relâché */ const boolean RELACHE = false; /* * lecture du bouton poussoir. Le bouton poussoir est connecté * sur une entrée analogique. Quand il est pressé, l'entrée est * connectée au +5V. Quand il est relaché, l'entrée est connectée * à la masse. On va discriminer les deux états en comparant la * valeur analogique lue à 511 qui est la valeur milieu. */ boolean lirePoussoir() { boolean resultat = RELACHE; if (analogRead(pinBouton) > 511) { resultat = PRESSE; } /* retourne l'état */ return resultat; }

Mais l'état du bouton ne nous intéresse pas directement. En effet, ne mettre le servo-moteur en mouvement que lorsque le bouton est pressé forcerait l'utilisateur à maintenir le bouton pressé pendant le mouvement. Ce sont donc les changements d'état du bouton qui nous intéressent : le fait de passer de l'état RELACHE à l'état PRESSE ou le fait de passer de l'état PRESSE à l'état RELACHE. Pour détecter ces changements d'état, il faut mémoriser l'état précédent du bouton et, quand on lit son état actuel, le comparé à l'état précédent pour déterminer si l'un des changements a eu lieu. On a donc besoin d'une variable pour y mémoriser l'état précédent. Pour clarifier les choses et rendre le programme lisible, nous allons aussi définir 3 constantes : AUCUN_EVENEMENT, l'état précédent du bouton est identique à l'état courant, EVENEMENT_PRESSE, l'état précédent du bouton était RELACHE, l'état courant est PRESSE et EVENEMENT_RELACHE, l'état précédent du bouton était PRESSE, l'état courant est RELACHE. Ces constantes sont des byte, c'est à dire un type de donnée pouvant prendre 256 valeurs différentes, ce qui suffit amplement.

const byte AUCUN_EVENEMENT = 0; const byte EVENEMENT_PRESSE = 1; const byte EVENEMENT_RELACHE = 2;

Enfin nous allons définir la fonction lireEvenement() qui va lire l'état courant du bouton et calculer l'événement. Le code vient assez naturellement.

/* * construction d'un événement. * - Si l'état du bouton n'a pas changé entre l'état précédent du bouton * et le nouvelle état, l'événement est AUCUN_EVENEMENT. * - Si le pouton était précédemment RELACHE et qu'il est maintenant PRESSE, * l'événement est EVENEMENT_PRESSE. * - Si le pouton était précédemment PRESSE et qu'il est maintenant RELACHE, * l'événement est EVENEMENT_RELACHE. */ byte lireEvenement() { byte evenement; /* lit l'état courant du bouton */ boolean nouvelEtat = lirePoussoir(); /* calcule l'événement */ if (nouvelEtat == etatBouton) evenement = AUCUN_EVENEMENT; if (nouvelEtat == PRESSE && etatBouton == RELACHE) evenement = EVENEMENT_PRESSE; if (nouvelEtat == RELACHE && etatBouton == PRESSE) evenement = EVENEMENT_RELACHE; /* L'état courant devient l'état précédent */ etatBouton = nouvelEtat; /* retourne l'événement */ return evenement; }

Afin de tester la lecture du poussoir indépendamment, nous allons mettre en œuvre l'envoi de message sur la ligne série qui, via l'USB, s'affiche dans le Moniteur Série de l'environnement de programmation Arduino. Il faut tout d'abord ouvrir la connexion dans la fonction setup() en utilisant la méthode begin(...) de Serial. Nous allons ensuite utiliser la méthode println pour afficher un message sur le moniteur série. Voici le programme complet pour cette première application mettant en œuvre un bouton.

const int pinBouton = 0; /* le bouton est connecté à la broche A0 */ const boolean PRESSE = true; const boolean RELACHE = false; boolean etatBouton = RELACHE; const byte AUCUN_EVENEMENT = 0; const byte EVENEMENT_PRESSE = 1; const byte EVENEMENT_RELACHE = 2; boolean lirePoussoir() { boolean resultat = RELACHE; if (analogRead(pinBouton) > 512) { resultat = PRESSE; } return resultat; } byte lireEvenement() { byte evenement; boolean nouvelEtat = lirePoussoir(); if (nouvelEtat == etatBouton) evenement = AUCUN_EVENEMENT; if (nouvelEtat == PRESSE && etatBouton == RELACHE) evenement = EVENEMENT_PRESSE; if (nouvelEtat == RELACHE && etatBouton == PRESSE) evenement = EVENEMENT_RELACHE; etatBouton = nouvelEtat; return evenement; } void setup() { Serial.begin(9600); } void loop() { byte evenement = lireEvenement(); if (evenement == EVENEMENT_PRESSE) Serial.println("presse !"); if (evenement == EVENEMENT_RELACHE) Serial.println("relache !"); }

À ma grande surprise ce programme fonctionne sans effort supplémentaire ! À ma grande surprise car lorsque l'on presse ou que l'on relâche un bouton, le contact ou la coupure ne s'effectue pas d'un coup et une succession rapide de contact-coupure a lieu. On appelle cela un rebond. Mon poussoir n'a pas de caractéristique particulière et j'ai par ailleurs eu des rebonds en le connectant à une entrée numérique. La réponse à ce mystère est donc ailleurs.

Deux techniques sont possibles pour filtrer les rebonds des poussoirs :

par matériel : un condensateur de filtrage ;
par logiciel : laisser passer du temps entre deux lectures.

Or, la conversion analogique numérique n'est pas instantanée. Entre deux conversions successives et donc deux acquisitions successive de la valeur analogique, il s'écoule 100µs. Ce qui équivaut à la solution logicielle de « laisser passer du temps entre 2 lectures ». Cette durée semble être suffisante pour filtrer les rebonds de notre bouton.

Intégration avec le programme de pilotage du servo-moteur

Nous allons maintenant intégrer notre fonction de lecture d'événement au programme de pilotage du servo-moteur tel que nous l'avons présenté dans l'article précédent.

Il faut procéder à quelques modification. Tout d'abord, il faut supprimer l'aller-retour qu'effectue le servo-moteur. Ensuite, il faut ajouter une variable qui va permettre de savoir dans quel état se trouve le servo-moteur afin de prendre la décision adéquate quand le bouton est pressé. On va distinguer 4 états :

SERVO_A_ANGLE_MIN : le servo-moteur est arrêté dans la position correspondant à l'angle minimum. Sa vitesse est égale à 0.
SERVO_A_ANGLE_MAX : le servo-moteur est arrêté dans la position correspondant à l'angle maximum. Sa vitesse est égale à 0.
SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX : le servo est en mouvement vers la position d'angle maximum. Sa vitesse est égale à 1.
SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN : le servo est en mouvement vers la position d'angle minimum. Sa vitesse est égale à -1.

Comme tout est nombre, nous allons définir chacune de ces constantes comme étant un byte et définir une variable etatServo de type byte comme ceci.

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; Servo monServo; int vitesse = 0; int angle = angleMin; byte etatServo = SERVO_A_ANGLE_MIN;

Dans setup(), nous retrouvons l'accrochage de monServo à la broche 2. La gestion du mouvement du servo est modifiée. Quand l'angle dépasse l'angle maximum, il est recalé comme auparavant. Mais dorénavant la vitesse est mise à 0 et l'état du servo est changé en SERVO_A_ANGLE_MAX. Quand l'angle dépasse l'angle minimum, il est recalé à l'angle minimum, la vitesse est mise à 0 et l'état du servo est changé en SERVO_A_ANGLE_MIN. De cette manière, le servo arrête son mouvement quand il atteint l'une des positions extrêmes.

On va ensuite lire l'événement. Si l'événement est EVENEMENT_PRESSE, on va effectuer les actions suivantes :

Si le servo est dans l'état SERVO_A_ANGLE_MIN ou
SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN, la vitesse est mise à 1 et l'état du servo est changé en SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX.
Si le servo est dans l'état SERVO_A_ANGLE_MAX ou
SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX, la vitesse est mise à -1 et et l'état du servo est changé en SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN

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; Servo monServo; int vitesse = 0; int angle = angleMin; byte etatServo = SERVO_A_ANGLE_MIN; const int pinBouton = 0; /* le bouton est connecté à la broche A0 */ const boolean PRESSE = true; const boolean RELACHE = false; boolean etatBouton = RELACHE; const byte AUCUN_EVENEMENT = 0; const byte EVENEMENT_PRESSE = 1; const byte EVENEMENT_RELACHE = 2; /* * fonctions de gestion du poussoir */ boolean lirePoussoir() { boolean resultat = RELACHE; if (analogRead(pinBouton) > 512) { resultat = PRESSE; } return resultat; } byte lireEvenement() { byte evenement; boolean nouvelEtat = lirePoussoir(); if (nouvelEtat == etatBouton) evenement = AUCUN_EVENEMENT; if (nouvelEtat == PRESSE && etatBouton == RELACHE) evenement = EVENEMENT_PRESSE; if (nouvelEtat == RELACHE && etatBouton == PRESSE) evenement = EVENEMENT_RELACHE; etatBouton = nouvelEtat; return evenement; } /* * La fonction setup() est exécutée 1 fois * au démarrage du programme */ void setup() { monServo.attach(2); } /* * La fonction loop() est exécutée * répétitivement */ void loop() { /* 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; } /* lecture de la commande de l'utilisateur */ 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; } } delay(3); }

Ce programme est l'occasion d'introduire une nouvelle construction du C, le switch ... case. Il s'agit d'un choix multiple. On a vu avec le if ... else ... un choix double. Ici la valeur de la variable etatServo indique à quel case le programme continue son exécution. L'exécution se poursuit jusqu'à rencontrer un break qui fait que le programme continue sont exécution après le switch.

Distinguer les états SERVO_A_ANGLE_MIN et SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN n'est pas nécessaire, idem pour SERVO_A_ANGLE_MAX et SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX. On le conserve tout de même car le programme est plus lisible ainsi et la distinction qui est faite va nous servir plus tard.

Une petite vidéo du montage volant et de l'exécution de ce dernier programme.

Démonstration du programme

ModelleisenbahN

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

Plusieurs boutons poussoir sur une entrée analogique

Principe de fonctionnement

Immunité au bruit et détermination des résistances

Le retour du rebond

Essai du système

Commande du servo-moteur par bouton poussoir

Mise en œuvre du bouton poussoir

Intégration avec le programme de pilotage du servo-moteur

Modification de la classe `DescripteurServo`