ModelleisenbahN

Accueil > La technologie > Arduino > Manœuvre des aiguilles avec des servo-moteurs > Clavier de réglage des butées

Manœuvre des aiguilles en analogique avec des servo-moteurs

Clavier de réglage des butées

publié par Jean-Luc, le samedi 30 novembre 2013

Tags aiguille - arduino - servo

Essayant de ne pas faire de trop gros articles indigestes, je saucissonne un peu plus les sujets. Voici le 2e 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.

  1. byte etatAutomate = NON_PRESSE;
  2. int etatPoussoir = -1;

Télécharger

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.

  1. class DescripteurClavierAnalogique {
  2. byte etatAutomate;
  3. int etatPoussoir;
  4. int taillePlage;
  5. int nbPoussoirs;
  6. int pin;
  7. };

Télécharger

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.

  1. public:
  2.  
  3. DescripteurClavierAnalogique()
  4. {
  5. etatAutomate = NON_PRESSE;
  6. etatPoussoir = -1;
  7. }
  8.  
  9. void connecte(int pinDeConnexion, int nombreDePoussoirs)
  10. {
  11. pin = pinDeConnexion;
  12. nbPoussoirs = nombreDePoussoirs;
  13. /*
  14.   * calcule la taille d'une plage
  15.   * le convertisseur a 1024 valeurs, Le taille de plage
  16.   * est égal à 1024/nombreDePoussoirs.
  17.   */
  18. taillePlage = 1024 / nombreDePoussoirs;
  19. }

Télécharger

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()

  1. int lirePoussoirs()
  2. {
  3. int resultat;
  4. int numPoussoir = (analogRead(pin) + taillePlage / 2) /taillePlage;
  5.  
  6. int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */
  7.  
  8. switch (etatAutomate) {
  9. case NON_PRESSE:
  10. if (numPoussoir < nbPoussoirs)
  11. etatAutomate = ENFONCE;
  12. break;
  13. case ENFONCE:
  14. if (numPoussoir < nbPoussoirs) {
  15. etatAutomate = PRESSE;
  16. nouvelEtatPoussoir = numPoussoir;
  17. }
  18. else {
  19. etatAutomate = NON_PRESSE;
  20. }
  21. break;
  22. case PRESSE:
  23. if (numPoussoir == nbPoussoirs) {
  24. etatAutomate = NON_PRESSE;
  25. nouvelEtatPoussoir = -1;
  26. }
  27. break;
  28. }
  29.  
  30. return nouvelEtatPoussoir;
  31. }

Télécharger

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

  1. DescripteurClavierAnalogique clavierOrdreServo;
  2. DescripteurClavierAnalogique clavierReglage;

Télécharger

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

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

Télécharger

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.

  1. class DescripteurClavierAnalogique {
  2. byte etatAutomate;
  3. int etatPoussoir;
  4. int taillePlage;
  5. int nbPoussoirs;
  6. int pin;
  7.  
  8. int lirePoussoirs()
  9. {
  10. int resultat;
  11. int numPoussoir = (analogRead(pin) + taillePlage / 2) /taillePlage;
  12.  
  13. int nouvelEtatPoussoir = etatPoussoir; /* à priori rien ne change */
  14.  
  15. switch (etatAutomate) {
  16. case NON_PRESSE:
  17. if (numPoussoir < nbPoussoirs)
  18. etatAutomate = ENFONCE;
  19. break;
  20. case ENFONCE:
  21. if (numPoussoir < nbPoussoirs) {
  22. etatAutomate = PRESSE;
  23. nouvelEtatPoussoir = numPoussoir;
  24. }
  25. else {
  26. etatAutomate = NON_PRESSE;
  27. }
  28. break;
  29. case PRESSE:
  30. if (numPoussoir == nbPoussoirs) {
  31. etatAutomate = NON_PRESSE;
  32. nouvelEtatPoussoir = -1;
  33. }
  34. break;
  35. }
  36.  
  37. return nouvelEtatPoussoir;
  38. }
  39.  
  40. public:
  41.  
  42. DescripteurClavierAnalogique()
  43. {
  44. etatAutomate = NON_PRESSE;
  45. etatPoussoir = -1;
  46. }
  47.  
  48. void connecte(int pinDeConnexion, int nombreDePoussoirs)
  49. {
  50. pin = pinDeConnexion;
  51. nbPoussoirs = nombreDePoussoirs;
  52. /*
  53.   * calcule la taille d'une plage
  54.   * le convertisseur a 1024 valeurs, Le taille de plage
  55.   * est égal à 1024/nombreDePoussoirs. Le décalage est
  56.   * la taille de la plage sur 2
  57.   */
  58. taillePlage = 1024 / nombreDePoussoirs;
  59. }
  60.  
  61. /*
  62.   * construction d'un événement en comparant
  63.   * le nouvel état des poussoirs avec l'état précédent.
  64.   */
  65. byte lireEvenement(int *numPoussoir)
  66. {
  67. byte evenement;
  68. int nouvelEtatPoussoir = lirePoussoirs();
  69.  
  70. if (nouvelEtatPoussoir == etatPoussoir)
  71. evenement = AUCUN_EVENEMENT;
  72. if (nouvelEtatPoussoir >= 0 && etatPoussoir == -1)
  73. evenement = EVENEMENT_PRESSE;
  74. if (nouvelEtatPoussoir == -1 && etatPoussoir >= 0)
  75. evenement = EVENEMENT_RELACHE;
  76.  
  77. etatPoussoir = nouvelEtatPoussoir;
  78. *numPoussoir = etatPoussoir;
  79.  
  80. return evenement;
  81. }
  82. };

Télécharger

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.

Répondre à cet article

Les thèmes

Archives

Informations

ModelleisenbahN | publié sous licence Creative Commons by-nc-nd 2.0 fr | généré dynamiquement par SPIP & Blog'n Glop