ModelleisenbahN

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.

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

Mise en œuvre d'un servo-moteur

Jean-Luc — 2013-11-10T16:29:55Z

L'Arduino c'est à la fois une carte équipée d'un microcontrôleur et un environnement logiciel qui fournit à l'utilisateur des fonctions pour manipuler le matériel de manière plus simple que s'il devait mettre en œuvre le micro-contrôleur à partir de rien.

L'Arduino se programme en langage C et quelques fois en C++. Le C est un langage de programmation très populaire, notamment sur les systèmes embarqués, c'est à dire les systèmes informatiques intégrés dans un procédé dans le but de le piloter.

Un programme minimum pour Arduino

Le programme minimum pour l'Arduino est constitué de deux fonctions. Une fonction regroupe une série d'instructions et remplit un rôle. Voici ces deux fonctions, setup() et loop(). La fonction setup() est exécutée 1 seule fois au début de programme. La fonction loop() est exécutée répétitivement.

/* * La fonction setup() est exécutée 1 fois * au démarrage du programme */ void setup() { } /* * La fonction loop() est exécutée * répétitivement */ void loop() { }

en langage C, une fonction retourne une valeur dont le type est indiqué juste à gauche du nom de la fonction. Il existe plusieurs types de données en C, les nombres entiers positifs et négatif (int), ceux qui sont seulement positif (unsigned int) etc. Nous verrons les types au fur et à mesure des besoins. Ici le type est void, il s'agit d'un type spécial qui signifie « rien » ou « vide » et qui indique que les fonctions setup() et loop() ne retournent aucune valeur.

Une fonction peut prendre des arguments. Les arguments sont donnés entre les parenthèses juste après le nom de la fonction. Ici les deux fonctions n'ont aucun argument.

Les instructions qui constituent la fonction sont données entre les accolades. Ici les deux fonctions sont vides et par conséquent elle ne font strictement rien.

Au dessus des fonctions il y a du texte. Il s'agit de commentaires. Un commentaire commence par /* et termine par */. C'est une bonne habitude de commenter abondamment ses programmes. En effet, quelques semaines plus tard, il est difficile de se rappeler de ce que l'on a voulu faire dans un programme et les commentaires explicatifs sont bienvenus.

Mise en œuvre d'un servo-moteur

La mise en œuvre d'un servo-moteur avec l'Arduino est aisée. Il y a une bibliothèque pour ça !

Une bibliothèque est un jeu de fonctions optionnelles que l'on peut ou non employer dans le programme. Pour utiliser la bibliothèque permettant de piloter des servo-moteurs, il suffit d'inclure, au début du programme la directive suivante

#include

Il faut ensuite pouvoir manipuler le servo-moteur. Il faut pour cela créer une variable de type Servo. On dit aussi instancier une variable. Le type Servo est un peu spécial, on entre là sur le terrain du C++. Servo est une classe et créer une variable de ce type donne un objet. En plus de contenir une valeur comme une variable de type nombre entier, un objet possède des fonctions qui agissent sur lui. Dans le monde de l'objet on appelle communément ces fonctions des méthodes. Nous n'avons pas besoin d'en connaître plus pour utiliser un objet de type Servo. Voici comment on crée une variable, que nous appelons monServo de type Servo.

Servo monServo;

Notez le « ; » qui termine la ligne, il est nécessaire et termine la directive. Notez aussi que le respect des majuscules et des minuscules est important car le langage C fait la différence entre s et S par exemple. Par conséquent appeler la variable monServo n'est pas la même chose que de l'appeler monservo.

La variable monServo est instanciée, il faut maintenant l'accrocher à une des sorties numériques de l'Arduino. Nous allons choisir la sortie 2 car les sorties 0 et 1 ont un rôle particulier : elles permettent d'envoyer des messages qui seront affichés sur votre ordinateur hôte. Il s'agit d'une aide irremplaçable qui se révèle nécessaire pour comprendre ce qui se passe quand le programme ne fait pas ce que l'on attend.
Accrocher la variable à une sortie se fait avec la méthode attach et, évidemment, dans la fonction setup() car il est inutile de le faire plus d'une fois.

void setup() { monServo.attach(2); /* accroche monServo à la pin 2 de l'Arduino */ }

Aller-retours

La première application est très simple, il s'agit de faire faire au servo des aller-retours de part et d'autre de la position médiane. La méthode write(...) permet de donner l'angle auquel le servo doit se positionner. L'argument est une valeur comprise entre 0 et 180°. L'angle minimum choisi est donc de 70° et l'angle maximum de 110°. On fixe la pause entre 2 changements de position à 1s. La fonction loop() est donc la suivante.

void loop() { /* positionne le servo à 70° */ monServo.write(70); /* attend 1000 ms */ delay(1000); /* positionne le servo à 110° */ monServo.write(110); /* attend 1000 ms */ delay(1000); }

Cette première application ne remplit pas le cahier des charges. À savoir un mouvement lent. Le mouvement a bien lieu toutes les secondes mais il est très rapide, quasi instantané.

Aller-retours lents

Pour obtenir un mouvement lent, il faut faire varier l'angle du servo progressivement. Pour cela, il faut changer l'angle très très peu et le faire plus souvent. Fixons par exemple un changement d'angle de 1°. Si l'on veut que le mouvement, passer de 70° à 110° soit accompli en 1s, il faut augmenter l'angle de 1° toutes les 1000ms / (110 - 70). soit une pause de 25ms. Quand l'angle atteint 110°, il faut inverser le mouvement. Quand l'angle atteint 70°, il faut de nouveau inverser le mouvement. Nous avons donc besoin de deux variables, angle qui contient l'angle courant du servo et vitesse qui contient 1 si on augmente l'angle et -1 si on le diminue. Pour faciliter la programmation, on va placer 70 et 110 dans deux constantes. Le programme est le suivant.

Programme 2

#include  Servo monServo; int vitesse; int angle; const int angleMin = 70; const int angleMax = 110; /* * La fonction setup() est exécutée 1 fois * au démarrage du programme */ void setup() { monServo.attach(2); angle = angleMin; vitesse = 1; } /* * La fonction loop() est exécutée * répétitivement */ void loop() { monServo.write(angle); /* calcule le nouvel angle */ angle = angle + vitesse; if (angle > angleMax) { /* * le nouvel angle dépasse le maximum * on le recale au maximum et on inverse la vitesse */ angle = angleMax; vitesse = -1; } else if (angle < angleMin) { /* * le nouvel angle dépasse le minimum * on le recale au minimum et on inverse la vitesse */ angle = angleMin; vitesse = 1; } delay(25); }

Le mouvement est bien lent comme on le désire mais avec une variation de l'angle par degré, le mouvement est un peu saccadé. Une autre méthode permet un positionnement plus précis. Il s'agit de la méthode writeMicroseconds(...). L'argument de cette méthode n'est plus un angle mais la durée de l'impulsion de commande du servo-moteur en micro-secondes. En effet, le signal de commande du servo-moteur est une impulsion dont la largeur détermine la position du servo (plus d'informations sont données dans l'article « La carte de commande 6 servo-moteurs, le matériel », une autre mise en œuvre utilisant une conception matérielle personnelle). Cette impulsion a donc la forme suivante.

La PWM de commande d'un servo

Seuls les durées extrêmes de l'impulsion et la durée médiane sont montrées mais toutes les valeurs entre 0,5 ms et 2,5 ms sont possibles.

La valeur médiane est donc de 1500µs et les valeurs minimum et maximum pour les angles que nous avions fixés deviennent respectivement et approximativement 1250 et 1750. On va conserver une vitesse de 1 ou -1 et pour avoir un mouvement d'1s alors que l'on franchi 500 pas d'angle on va désormais faire une pause de 2ms. Le programme est donc le suivant.

Programme 3

#include  Servo monServo; int vitesse; int angle; const int angleMin = 1250; const int angleMax = 1750; /* * La fonction setup() est exécutée 1 fois * au démarrage du programme */ void setup() { monServo.attach(2); angle = angleMin; vitesse = 1; } /* * La fonction loop() est exécutée * répétitivement */ void loop() { monServo.writeMicroseconds(angle); /* calcule le nouvel angle */ angle = angle + vitesse; if (angle > angleMax) { /* * le nouvel angle dépasse le maximum * on le recale au maximum et on inverse la vitesse */ angle = angleMax; vitesse = -1; } else if (angle < angleMin) { /* * le nouvel angle dépasse le minimum * on le recale au minimum et on inverse la vitesse */ angle = angleMin; vitesse = 1; } delay(2); }

Le résultat est meilleur avec un mouvement plus fluide.

Voici qui conclut cette prise en main des servo-moteurs. Le prochain article portera sur l'ajout d'un bouton permettant de commander le mouvement du servo-moteur.

Mise en œuvre des 3 programmes présentés

Description du système

Jean-Luc — 2013-11-10T11:35:53Z

Une petite récréation par rapport à la construction de mon réseau. Je bricole un peu d'Arduino avec ma fille pour animer des petits robots. Et qui dit robots dit servo-moteurs. Il se trouve que c'est aussi lié au modélisme ferroviaire, d'où la présence de cet article sur mon blog.

En effet, l'Arduino me semble être une excellente solution pour mettre en œuvre des systèmes électroniques et électro-mécaniques sophistiqués sur un réseau. La manœuvre des aiguilles via des servo-moteurs en est un exemple qui reste d'une complexité raisonnable tout en répondant à un besoin exprimé par ceux qui exploitent leur réseau en analogique.

Tam Valley Depot commercialise une carte de ce type, l'Octopus III. Nous allons reproduire le fonctionnement de cette carte en utilisant un Arduino Uno quelques LED et quelques poussoirs. Je dis nous car ces articles sont conçus comme un tutoriel pour expliquer le fonctionnement du système Arduino et son application en modélisme ferroviaire. En parallèle un forum spécifique a été mis en place sur le forum Loco-Revue sous la houlette de Christian Bézanger, auteur de la série d'articles sur l'Arduino dans la revue éponyme et les idées bouillonnent.

Que veut-on comme fonction ?

Fonctionnellement, l'utilisateur veut le système classique. Il dispose d'une batterie de boutons, un par aiguille. Une pression sur un bouton change la position de l'aiguille. Nous allons prévoir ici 8 aiguilles et donc 8 servo-moteurs et 8 boutons. Son objectif est bien sûr d'avoir un mouvement lent et réaliste.

Il veut aussi un retour sur la position, par exemple une LED verte signifie que l'aiguille est droite et une jaune que l'aiguille est déviée.

Enfin, chaque moteur d'aiguille pouvant être différent, il veut régler les deux positions extrêmes servo par servo. Il faut donc qu'il puisse indiquer qu'il veut régler les servos puis préciser le servo qu'il souhaite régler puis disposer d'un dispositif de réglage.

De quel matériel a-t-on besoin ?

Du point de vue physique, le système que nous allons concevoir est constitué de :

Un Arduino Uno. Il s'agit d'une petite carte embarquant un micro-contrôleur ATMega328, un régulateur de tension 5V pour l'Arduino et ce qu'on peut y brancher et une électronique de programmation qui permet d'envoyer un programme sur l'Arduino via la liaison USB de l'ordinateur ;
8 servos-moteur ;
8 boutons poussoir, 1 pour chaque servo-moteur, permettant de changer la position du servo-moteur correspondant ;
Un bouton rotatif à 8 positions pour sélectionner un servo-moteur afin de régler ses butées (mode réglage). Un commutateur ou un poussoir permettant de passer du mode réglage au mode exploitation. Le mode exploitation est le fonctionnement normal du dispositif ;
Une paire de poussoirs pour le réglage des butées des servo-moteurs ;
Des résistances de tirage ;
16 LED, 8 vertes et 8 jaunes, pour les temoins ;

Courte présentation de l'Arduino Uno et des servo-moteurs que nous allons utiliser

Certains points peuvent sembler obscurs pour l'instant mais nous allons revenir dessus et les choses s'éclairciront.

L'électronique est réduite à sa plus simple expression et elle sera expliquée au fur et à mesure.

Enfin la plus grosse partie du travail est évidemment le logiciel. Plutôt que d'aborder cette partie de manière académique nous allons la voir au travers de la mise en œuvre de notre application, en amenant les explications sur la programmation au fur et à mesure que le besoin s'en fait sentir. Nous n'allons donc pas faire de conception globale de notre application comme cela se fait dans l'industrie [1] mais présenter des sous-ensembles restreints permettant de saisir les concepts pour ensuite, une brique après l'autre, construire l'application.

[1] Bon, en fait j'ai déjà fait cette conception, rassurez-vous.

Conception et mise en œuvre

Jean-Luc — 2013-07-01T16:56:34Z

Comme présenté dans « État de l'art », il existe de nombreuses façons de monter un servo-moteur en modélisme ferroviaire. Voici la solution choisie sur mon réseau. Il s'agit d'une solution similaire à celle de Pierre mais adaptée à des micro-servos.

Cahier des charges

L'actionneur doit répondre à des exigences de mise en œuvre :

Un encombrement raisonnable. Notamment, il doit être possible de mettre deux actionneurs côte à côte sur deux voies parallèles avec un entraxe de 26,5mm (entraxe PECO). La hauteur sous la plateforme est moins cruciale dans la mesure où je me suis débrouillé pour ne pas avoir d'aiguille au dessus d'une voie.
Un démontage facile. Notamment le démontage partiel : dépose du palonnier, dépose des contacts de fin de course, dépose du servo lui-même. La dépose du palonnier est essentielle car glisser la tige dans le trou de la traverse n'est pas des plus commodes.
Un coût raisonnable, c'est à dire comparable à un actionneur à fil à mémoire.
Les deux orientations doivent être possibles. C'est à dire que l'actionneur doit pourvoir se monter dans une position et également tourné de 180°.

Il doit aussi satisfaire des exigences fonctionnelles :

La commutation de l'alimentation du cœur de l'aiguille. Cette commutation doit être faite de manière à ce qu'elle ne provoque pas de court-circuit : la commutation doit être cohérente avec les contacts des lames de l'aiguille sur les rails.
Le retour de la position de l'actionneur. Le calculateur qui s'occupe de la commande de l'actionneur pourra ainsi confronter la consigne que l'actionneur doit suivre et sa position effective. Plus de détails seront donnés dans l'article sur les cartes de commande des actionneurs à servo-moteur.

Satisfaire les exigences de mise en œuvre

Le démontage facile implique une liaison simple entre le servo et la tringle qui passe dans la traverse de l'aiguille. Cela disqualifie les actionneurs où le mouvement en renvoyé par une tringle intermédiaire.

La faible largeur ne peut être obtenue qu'en positionnant le servo avec sa plus grande dimension dans la direction de la voie.

La liaison simple concoure aussi à un prix de reviens raisonnable et à un temps de montage court.

Le coût et l'encombrement peuvent rester très faible. En effet, les micro-servos sont disponibles à faible coût, on peut presque parler de consommables. Voir par exemple les servos distribués par Hobby King. Le servo lui même revient donc à moins de 2€ pièce. À cela il faut ajouter des interrupteurs de fin de course donc le coût unitaire peut descendre à moins de 50 centimes pièce et de la quincaillerie.

La possibilité de monter l'actionneur dans un sens ou un autre s'obtient en rendant son empreinte (fixation, sortie de la tringle de commande de l'aiguille) symétrique.

Satisfaire les exigences fonctionnelles

Tout d'abord un mot sur les systèmes existants en modélisme ferroviaire. Ces systèmes peuvent être autonome, à charge pour l'utilisateur d'ajouter une interface permettant d'envoyer des ordres aux servos ou peuvent intégrer une interface numérique comme le DCC [1]. On peut citer :

Les systèmes Tam Valley. Tam Valley propose des décodeurs monoservo, des décodeurs 4 servos. Ces deux systèmes intègrent un décodeur DCC et ne fonctionnent donc qu'en DCC. En revanche l'Octupus III assure seulement le fonction de pilotage des servos. Il peut être connecté à un décodeur DCC ou bien commandé directement par des boutons pour une exploitation dite analogique.
Chez Viessmann, on trouve un boîtier de commande monoservo utilisable en DCC en ajoutant un décodeur ou en analogique.

À ma connaissance, aucun produit commercial pour la commande de servos en modélisme ferroviaire n'inclut d'entrées pour les interrupteurs de fin de course.

Par conséquent, la rétrosignalisation de la position des aiguilles est basée sur la consigne et non sur l'état réel de la mécanique. Il en découle qu'en cas de panne du servo-moteur, l'état réel diffère de l'état connu par l'informatique ou par l'opérateur avec pour conséquence des court-circuits sur la commutation du cœur de l'aiguille [2] et des erreurs d'exploitation pouvant conduire à des collisions ou à des déraillements.

Il est donc nécessaire de baser la rétrosignalisation sur la position mécanique des aiguilles. Idéalement le capteur devrait rendre compte de la position des lames ou à défaut de la traverse. C'est assez difficile à mettre en place, surtout de manière invisible. On se contentera donc de la position effective du palonnier du servo au moyen d'interrupteurs de fin de course.

La conception

Le servo est donc positionné de manière à ce que le plan du palonnier soit perpendiculaire à la plateforme de voie et parallèle aux traverses.

Montage de l'actionneur

Cette vue en coupe montre l'actionneur fixé sous la plateforme. En haut la platforme avec le trou de passage, le track-bed et la traverse où passe la tringle de commande.

Une petite platine découpée dans de la carte plastique de 2 mm supporte le servo. Elle est fixée sur une cornière en aluminium de 20 mm x 10 mm. Cette cornière possède un perçage pour laisser passer la tringle et deux trous de fixation. La platine supporte aussi les 4 interrupteurs de fin de course : 2 servent à commuter l'alimentation du cœur de l'aiguille, les deux autres servent à renvoyer la position à la carte de commande. Les interrupteurs de fin de course sont soudés sur un petit circuit imprimé qui comporte aussi un bornier pour l'alimentation du cœur.

Le schéma de ce CI est le suivant :

Schéma de la platine

La platine supporte les 4 interrupteurs de fin de course et un bornier pour le raccordement des rails et du cœur de l'aiguille.

La prise d'origine du servo est coupée et les fils sont directement soudés sur le CI. Une nappe De 5 fils (5,3V, PWM, Fin de Course Horaire, GND, Fin de Course Trigo) raccorde la platine à la carte de commande.

Typon du circuit imprimé

Le CI est fixé sur la platine au moyen de 2 vis de M2x20mm qui passent par les trous de fixation des interrupteurs de fin de course. La platine est percée à 4mm de manière à pouvoir ajuster les fins de course par rapport au palonnier.

L'actionneur d'aiguille

Pour appuyer sur deux fins de course simultanément, il est nécessaire de munir le palonnier de deux tiges aux extrémités. Ces tiges sont réalisées avec des vis et des écrous.

L'actionneur est assemblé exclusivement avec des vis, rondelles et écrous. Tout ou presque est démontable.

Fixation sous la plateforme

L'actionneur est fixé au moyen de 2 vis de 3mm à tête fraisée. On perce la plateforme à égale distance de part et d'autre de la voie (écartement de 30mm). À cet effet, un gabarit a été fabriqué. Deux écrous tiennent les vis par dessous. L'actionneur est ensuite boulonné en place.

Coût d'un actionneur

Les 42 actionneurs prévus pour le réseau nécessitent les composants suivants :

Quincaillerie

Cornière aluminium brut 20 mm x 10 mm en 2 m : 8,65€ (Castorama) ;
Plaques de styrène blanche opaque Evergreen au format 200x530 mm épaisseur 2,00 mm / 2 plaques : 15,50€ (Micro-modèles), il restera du rab pour les bâtiments ;
Corde à piano de 0,5mm, 3m : 0,90 (Micro-modèles) ;

Visserie
Fixation des actionneurs sous la plateforme :

200 vis à tête fraisée de M3x16mm : 2,15€ (TME)
200 écrous M3 : 1,14€ (TME)

Fixation du servo sur la platine et de la platine sur la cornière :

100 vis M2x6 : 0,8€ (TME)
100 vis M2x8 : 0,85€ (TME
200 écrous M2 : 1,5€ (TME)

Système d'appui sur les fins de course et de fixation de la tringle de commande

100 vis M2x12 : 0,7€ (TME)
100 vis M2x10 : 0,6€ (TME)
450 écrous M2 : 3€ (TME)

Composants

168 interrupteurs de fin de course miniatures (1A) : 40€10 (TME)
42 borniers 3 points, pas 3,5mm : 11€10 (TME)
42 servo-moteurs HK15178 : 77€70 (HobbyKing)
30m de câble en nappe 10 conducteurs : 11€ (TME)
42 connecteurs pour cosses à sertir : 3€90 (TME)
500 cosses pour les connecteur : 7€33 (TME)
Circuit imprimé à graver : 5€50 (TME)

Soit une somme totale d'environ 190€ et 4€50 par actionneur. Qui dit mieux ?

Réalisation

Le prototype a été testé avec succès. Ces tests ont permis de déterminer la diamètre de la tringle (corde à piano de 0,5mm de Ø), l'écartement entre la cornière et la plateforme (l'épaisseur des écrous est suffisantes) et le réglage des fins de course. Les 42 cornières nécessaires ont été découpées et percées. 6 des 9 exemplaires destinés à équiper la gare ont été assemblés. Les efforts portent maintenant sur la carte de commande qui fera l'objet d'un prochain billet.

La fabrication en série a commencé

[1] Bus portant à la fois l'alimentation et les données et utilisé en exploitation numérique

[2] Quand les aiguilles ne prennent pas en charge cette commutation par elles-même

ModelleisenbahN

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

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

Mise en œuvre d'un servo-moteur

Un programme minimum pour Arduino

Mise en œuvre d'un servo-moteur

Description du système

Que veut-on comme fonction ?

De quel matériel a-t-on besoin ?

Conception et mise en œuvre

Cahier des charges

Satisfaire les exigences de mise en œuvre

Satisfaire les exigences fonctionnelles

La conception

Fixation sous la plateforme

Coût d'un actionneur

Réalisation

Modification de la classe `DescripteurServo`