LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

mercredi 18 octobre 2017

50 visiteurs en ce moment

Bibliothèque Accessories (2)

Que mettre dans son croquis ?

. Par : Thierry

Accessories n’est pas qu’un assemblage de classes et de lignes de code. Le but est quand même de faire bouger des moteurs ou d’allumer des DELs ! Alors après un premier article plutôt théorique, voyons maintenant le côté pratique.

Cas d’école

Prenons un cas simple, la gestion d’une simple DEL   via un bouton poussoir et comparons diverses possibilités de codage.

D’abord la version classique sans bibliothèques :

  1. // Programme 1
  2.  
  3. const int buttonPin = 2; // broche du poussoir
  4.  
  5. void setup()
  6. {
  7. // initialise la DEL interne de l'Arduino comme sortie
  8. pinMode(LED_BUILTIN, OUTPUT);
  9. // initialise le poussoir comme entrée
  10. pinMode(buttonPin, INPUT);
  11. }
  12.  
  13. void loop()
  14. {
  15. // Selon l'état du bouton, on allume ou éteint la DEL
  16. if (digitalRead(buttonPin)== HIGH) {
  17. digitalWrite(LED_BUILTIN, HIGH); // Allume la DEL
  18. } else {
  19. digitalWrite(LED_BUILTIN, LOW); // Eteint la DEL
  20. }
  21. }

C’est la version minimaliste : pas de gestion des rebonds sur le poussoir, la DEL   directement reliée à l’état de sa broche… La constante LED_BUILTIN qui définit la broche de la DEL interne utilisée est à 13 pour la plupart des Arduino, mais par exemple elle est à 6 pour un MKR1000 !

Ajoutons maintenant la bibliothèque Accessories :

  1. // Programme 2
  2.  
  3. #include <Accessories.h>
  4.  
  5. const int buttonPin = 2; // broche du poussoir
  6.  
  7. AccessoryLight light; // La DEL
  8. PortOnePin port; // La connexion entre l'Arduino et la DEL.
  9.  
  10. void setup()
  11. {
  12. Accessories::begin();
  13.  
  14. port.begin(LED_BUILTIN, DIGITAL); // broche 13 sur un Uno, broche digitale.
  15.  
  16. light.begin(&port, 100); // On branche la DEL sur le port, et on lui assigne le No 100
  17.  
  18. // initialise le poussoir comme entrée
  19. pinMode(buttonPin, INPUT);
  20. }
  21.  
  22. void loop()
  23. {
  24. // Selon l'état du bouton, on allume ou éteint la DEL
  25. if (digitalRead(buttonPin)== HIGH) {
  26. light.LightOn(); // Allume la DEL
  27. } else {
  28. light.LightOff(); // Eteint la DEL
  29. }
  30. }

Accessories va permettre d’utiliser un objet light identifié par un entier (100 ici). L’exemple est très simple, il n’y a toujours pas de gestion des rebonds du bouton, mais ajouter un allumage ou une extinction progressive façon vieille ampoule en passant par une broche PWM   ne coûterais qu’une légère modification : signaler le port comme analogique, puis spécifier les paramètres pour la vitesse de passage d’un état à l’autre :

  1. void setup()
  2. {
  3. ...
  4.  
  5. // déclaration de la broche 3 en PWM (analogique)
  6. port.begin(3, ANALOG);
  7.  
  8. ...
  9. // déclaration des vitesses (pas, durée sur ce pas...)
  10. light.SetFading(5, 10);
  11. ...
  12. }

Par exemple pour allumer une DEL raccordée à une broche PWM   et passer d’une valeur analogique de 0 (éteint) à 255 (allumé pleine puissance) par pas de 5 pendant 10ms chacun et inversement pour l’extinction…

Troisième option, ajoutons Commanders pour gérer le bouton et la communication avec les accessoires :

  1. // Programme 3
  2.  
  3. #include <Accessories.h>
  4. #include <Commanders.h>
  5.  
  6. const int buttonPin = 2; // broche du poussoir
  7.  
  8. ButtonsCommanderPush push; // Le bouton
  9. AccessoryLight light; // La DEL
  10. PortOnePin port; // La connexion entre l'Arduino et la DEL.
  11.  
  12. void setup()
  13. {
  14. Commanders::begin();
  15. Accessories::begin();
  16.  
  17. port.begin(LED_BUILTIN, DIGITAL); // broche 13 sur un Uno, broche digitale.
  18.  
  19. light.begin(&port, 100); // On branche la DEL sur le port, et on lui assigne le No 100
  20.  
  21. // initialise le poussoir comme entrée
  22. // l'identifiant du bouton à 100 indique que c'est l'accessoire '100' qui sera affecté si le bouton est pressé.
  23. push.begin(100, buttonPin);
  24. }
  25.  
  26. void loop()
  27. {
  28. unsigned long id = Commanders::loop();
  29.  
  30. if (id != UNDEFINED_ID)
  31. {
  32. // Renvoie l'événement reçu de Commanders, vers les accessoires...
  33. Accessories::RaiseEvent(id, (ACCESSORIES_EVENT_TYPE) Commanders::GetLastEventType(), Commanders::GetLastEventData());
  34. }
  35.  
  36. Accessories::loop();
  37. }

La version Commanders+Accessories peut sembler plus complexe que la toute première, mais elle assure en interne la prise en compte des événements via le RaiseEvent(), plus la gestion des rebonds pour le poussoir.
Et ajouter le traitement via un bus DCC   par exemple, ne réclame qu’une seule ligne supplémentaire :

  1. void setup()
  2. {
  3. ...
  4.  
  5. // identifiants fabricant et produit, puis le numéro d'interruption, ici sur la broche 3.
  6. DccCommander.begin(0x00, 0x00, digitalPinToInterrupt(3));
  7.  
  8. ...
  9. }

Si un message DCC   arrive, il sera décodé et s’il désigne l’identifiant 100, la DEL va réagir aussi ! Et le bouton est toujours actif… Qui a dit que c’était compliqué ?

Sur un exemple très simple, il est difficile de voir le gain apporté par l’utilisation de ces bibliothèques, alors parlons de vrais cas…

Des cas concrets

Prenons quelques cas courants et codons les.

Deux aiguillages simples, et un rail de découplage

Imaginons une partie de réseau avec une voie d’évitement équipée à une extrémité d’un rail électrique de découplage. Les aiguillages sont de modèles courants, à deux solénoïdes et donc trois fils.

Nous allons le coder à la fois pour un TCO analogique, et une entrée DCC. Les deux ne sont pas incompatibles et peuvent cohabiter. A l’inverse, même si le codage des deux versions (TCO+DCC) est inclus, l’absence de l’un ou l’autre ne posera pas de problème…
Il est bien évident que dans le cas d’un contrôle extérieur (gestionnaire de trajets, logiciel de pilotage…) la présence d’une possibilité manuelle de basculement d’aiguille peut être perturbatrice. Dans ce cas le mieux est de retirer la partie TCO.

Le programme :

  1. // Programme 4
  2.  
  3. #include <Accessories.h>
  4. #include <Commanders.h>
  5.  
  6. // Les boutons du TCO...
  7. ButtonsCommanderPush boutonDecoupleur;
  8. ButtonsCommanderSwitch boutonAiguillageGauche;
  9. ButtonsCommanderSwitch boutonAiguillageDroite;
  10.  
  11. // Les trois moteurs
  12. AccessoryMotorTwoWays aiguillageGauche;
  13. AccessoryMotorTwoWays aiguillageDroite;
  14. AccessoryMotorOneWay decouplage;
  15.  
  16. // Les ports pour connecter les moteurs.
  17. PortTwoPins portAiguillageGauche;
  18. PortTwoPins portAiguillageDroite;
  19. PortOnePin portDecoupleur;
  20.  
  21. void setup()
  22. {
  23. Commanders::begin(LED_BUILTIN);
  24. // Memoriser les positions des moteurs dans l'EEPROM.
  25. Accessories::begin(0, 500);
  26.  
  27. // Activation de la reception de messages DCC
  28. // Ne fera rien en analogique... Mais on peut carrement enlever la ligne si besoin de mémoire.
  29. // Le dernier argument à true, c'est pour voir la DEL LED_BUILTIN déclarée plus haut clignoter si un signal DCC est présent.
  30. // Mieux vaut remettre à false une fois le programme mis au point.
  31. DccCommander.begin(0x00, 0x00, digitalPinToInterrupt(3), true);
  32.  
  33. // Gestion des boutons pour le TCO.
  34. // Ne fera rien si aucun bouton n'est branché, mais on peut enlever si besoin de mémoire.
  35.  
  36. // Le switch d'aiguillage a deux positions, chacune associée à un Id DCC.
  37. boutonAiguillageGauche.begin();
  38. // DCC 15 /0 et broche 2
  39. boutonAiguillageGauche.AddEvent(DCCINT(15, 0), 2);
  40. // DCC 15 / 1 et broche 7
  41. boutonAiguillageGauche.AddEvent(DCCINT(15, 1), 7);
  42.  
  43. boutonAiguillageDroite.begin();
  44. boutonAiguillageDroite.AddEvent(DCCINT(16, 0), 4);
  45. boutonAiguillageDroite.AddEvent(DCCINT(16, 1), 5);
  46.  
  47. // Un seul evenement pour le découpleur
  48. boutonDecoupleur.begin(DCCINT(17, 0), 6);
  49.  
  50. // Les ports avec leurs broches en digital (pas PWM)
  51. portAiguillageGauche.begin(8, 9, DIGITAL);
  52. portAiguillageDroite.begin(10, 11, DIGITAL);
  53. portDecoupleur.begin(12, DIGITAL);
  54.  
  55. // Les accessoires avec pour chacun le port utilisé et le ou les identifiants associés à chaque position.
  56. // 255 est la vitesse, ici au maxi, et 400 est la durée d'activation du moteur en millisecondes.
  57. // C'est encore un peu long pour des solénoïdes. Il faudra adapter selon le modèle de moteur...
  58. aiguillageGauche.beginTwoWays(&portAiguillageGauche, DCCINT(15, 0), DCCINT(15, 1), 255, 400);
  59. aiguillageDroite.beginTwoWays(&portAiguillageDroite, DCCINT(16, 0), DCCINT(16, 1), 255, 400);
  60. decouplage.begin(&portDecoupleur, DCCINT(17, 0), 255, 400);
  61. }
  62.  
  63. void loop()
  64. {
  65. unsigned long id = Commanders::loop();
  66.  
  67. if (id != UNDEFINED_ID)
  68. {
  69. // Renvoie l'événement reçu de Commanders, vers les accessoires...
  70. Accessories::RaiseEvent(id, (ACCESSORIES_EVENT_TYPE) Commanders::GetLastEventType(), Commanders::GetLastEventData());
  71. }
  72.  
  73. Accessories::loop();
  74. }

Le schéma est toujours le même : dans l’entête les déclarations pour les boutons, les accessoires, et les ports pour les piloter.
Dans le setup(), des begin() sur les bibliothèques, puis les begin() sur les boutons, les accessoires et les ports. C’est à ce moment que l’on va fixer les broches utilisées, dire qui est connecté à quoi, adapter les comportements des boutons, des accessoires et des ports, comme le clignotement d’une DEL ou une durée d’activation. Les boutons vont recevoir des identifiants, et les accessoires associés à ces boutons vont recevoir les mêmes identifiants.
Enfin le loop() qui ne fait que prendre les événements reçus par Commanders et les renvoyer à Accessories avec RaiseEvent(). A la fin du loop général, c’est le loop() de Accessories qui va véritablement traiter ces événements et faire bouger ou changer l’état des accessoires concernés.

Ainsi quand le bouton du découpleur sera pressé, qu’il y ait ou pas une centrale DCC branchée, l’événement généré aura l’identifiant DCCINT(17, 0). Et lorsque Accessories recevra l’événement (renvoyé par RaiseEvent(), rappelons-le), il ira activer l’accessoire dont l’identifiant est DCCINT(17, 0), et c’est bien du découpleur qu’il s’agit ! Bien sûr, si un centrale est présente et que c’est elle qui envoie une demande de mouvement de l’accessoire 17, Accessories recevra le même identifiant DCC(17, 0), et le découpleur réagira de la même manière.

Un croisement de quatre aiguillages plus un servo

Imaginons un croisement de quatre aiguillages animés ensembles, avec deux positions seulement : droit ou dévié, activés par un interrupteur.

On va bien déclarer les quatre moteurs à deux solénoïdes, puis un groupe qui les réunit pour créer deux états, un droit avec un identifiant DCC, et un dévié avec un autre identifiant. Enfin, comme ces moteurs ont tendance à beaucoup consommer d’énergie pendant leurs mouvements, on va s’assurer qu’ils fonctionnent en séquence, et pas simultanément. Ainsi la consommation sera d’un seul moteur à la fois, mais il faudra un peu plus de temps pour changer d’état.

  1. // Programme 5
  2.  
  3. #include <Accessories.h>
  4. #include <Commanders.h>
  5.  
  6. // Les boutons du TCO...
  7. ButtonsCommanderSwitch boutonCroisement;
  8.  
  9. // Les moteurs
  10. AccessoryMotorTwoWays aiguillageHautGauche;
  11. AccessoryMotorTwoWays aiguillageHautDroite;
  12. AccessoryMotorTwoWays aiguillageBasGauche;
  13. AccessoryMotorTwoWays aiguillageBasDroite;
  14.  
  15. // Le groupe pour les moteurs
  16. AccessoryGroup groupeCroisement;
  17.  
  18. // Les ports pour connecter les moteurs.
  19. PortTwoPins portAiguillageHautGauche;
  20. PortTwoPins portAiguillageHautDroite;
  21. PortTwoPins portAiguillageBasGauche;
  22. PortTwoPins portAiguillageBasDroite;
  23.  
  24. void setup()
  25. {
  26. Commanders::begin(LED_BUILTIN);
  27. // Memoriser les positions des moteurs dans l'EEPROM.
  28. Accessories::begin(0, 500);
  29.  
  30. // Activation de la reception de messages DCC
  31. // Ne fera rien en analogique... Mais on peut carrement enlever la ligne si besoin de mémoire.
  32. // Le dernier argument à true, c'est pour voir la DEL LED_BUILTIN clignoter si un signal DCC est présent.
  33. // Mieux vaut remettre à false une fois le programme mis au point.
  34. DccCommander.begin(0x00, 0x00, digitalPinToInterrupt(3), true);
  35.  
  36. // Gestion des boutons pour le TCO.
  37. // Ne fera rien si aucun bouton n'est branché, mais on peut enlever si besoin de mémoire.
  38.  
  39. // Le switch de croisement a deux positions, chacune associée à un Id DCC.
  40. boutonCroisement.begin();
  41. // DCC 15 /0 et broche 4 pour l'interrupteur
  42. boutonCroisement.AddEvent(DCCINT(15, 0), 4);
  43. // dcc 15 / 1 et broche 5 pour l'interrupteur
  44. boutonCroisement.AddEvent(DCCINT(15, 1), 5);
  45.  
  46. // Les ports avec leurs broches en digital (pas PWM)
  47. portAiguillageHautGauche.begin(7, 8, DIGITAL);
  48. portAiguillageHautDroite.begin(9, 10, DIGITAL);
  49. portAiguillageBasGauche.begin(11, 12, DIGITAL);
  50. portAiguillageBasDroite.begin(14, 15, DIGITAL);
  51.  
  52. // Les accessoires avec pour chaque, le port utilisé et le ou les identifiants associés à chaque position.
  53. // 255 est la vitesse, ici au maxi, et 400 est la durée d'activation du moteur en millisecondes.
  54. // C'est encore un peu long pour des solénoïdes. Il faudra adapter selon le modèle de moteur...
  55. // Les identifiants sont volontairement non significatifs (1000 et plus...)
  56. // puisqu'aucun événement ne doit faire bouger ces moteurs individuellement.
  57. aiguillageHautGauche.beginTwoWays(&portAiguillageHautGauche, 1000, 1001, 255, 400);
  58. aiguillageHautDroite.beginTwoWays(&portAiguillageHautDroite, 1002, 1003, 255, 400);
  59. aiguillageBasGauche.beginTwoWays(&portAiguillageBasGauche, 1004, 1005, 255, 400);
  60. aiguillageBasDroite.beginTwoWays(&portAiguillageBasDroite, 1006, 1007, 255, 400);
  61.  
  62. // Fabriquons le groupe de quatre moteurs à deux états
  63. groupeCroisement.begin();
  64.  
  65. // Premier état, tous les moteurs droits.
  66. // L'argument 'false' signifie pas d'exécution simultanée. Les moteurs bougeront les uns après les autres.
  67. groupeCroisement.AddState(DCCINT(15, 0), false);
  68. // Arbitrairement, LEFT signifie droit (première broche activée)
  69. groupeCroisement.AddStateItem(DCCINT(15, 0), aiguillageHautGauche, LEFT);
  70. groupeCroisement.AddStateItem(DCCINT(15, 0), aiguillageHautDroite, LEFT);
  71. groupeCroisement.AddStateItem(DCCINT(15, 0), aiguillageBasGauche, LEFT);
  72. groupeCroisement.AddStateItem(DCCINT(15, 0), aiguillageBasDroite, LEFT);
  73.  
  74. // Second état, tous les moteurs déviés.
  75. // Arbitrairement, RIGHT signifie dévié (seconde broche activée)
  76. groupeCroisement.AddState(DCCINT(15, 1), false);
  77. groupeCroisement.AddStateItem(DCCINT(15, 1), aiguillageHautGauche, RIGHT);
  78. groupeCroisement.AddStateItem(DCCINT(15, 1), aiguillageHautDroite, RIGHT);
  79. groupeCroisement.AddStateItem(DCCINT(15, 1), aiguillageBasGauche, RIGHT);
  80. groupeCroisement.AddStateItem(DCCINT(15, 1), aiguillageBasDroite, RIGHT);
  81. }
  82.  
  83. void loop()
  84. {
  85. unsigned long id = Commanders::loop();
  86.  
  87. if (id != UNDEFINED_ID)
  88. {
  89. // Renvoie l'événement reçu de Commanders, vers les accessoires...
  90. Accessories::RaiseEvent(id, (ACCESSORIES_EVENT_TYPE) Commanders::GetLastEventType(), Commanders::GetLastEventData());
  91. }
  92.  
  93. Accessories::loop();
  94. }

Le code est assez direct, surtout que pour le laisser compréhensible, je n’ai pas utilisé de boucles qui auraient sans doute un peu réduit la taille du programme.
Comme d’habitude, on déclare les boutons, les moteurs, le groupe et les ports. Puis dans le setup() on va initialiser les boutons, les moteurs et les ports. Une fois la partie matérielle fixée, reste à déclarer le groupe et ses différents états. Le premier, activé par un code DCC 15/0 activera la première broche de tous les aiguillages, tour à tour grâce au dernier argument du AddState() à false. Le second, activé par 15/1, fera de même avec la seconde broche. Bien sûr, cela suppose que les aiguillages soient branchés dans le bon sens ! Sinon il suffit d’inverser deux fils, ou encore plus simple, d’inverser les deux broches dans le begin() du port correspondant. Rien à changer dans la loop()…

Un passage à niveau avec feu clignotant

Prenons maintenant un passage à niveau sur une voie unique et mono directionnelle (on fait simple…), activé par un ils posé sur la voie un peu avant le passage, et qui active un moteur pour faire descendre les deux barrières tout en faisant clignoter deux feux sur la route, un de chaque côté. Au bout d’une tempo, le tout revient en position de repos : barrières ouvertes et feux éteints.
Le montage est autonome et n’est piloté par personne : pas de bouton, pas de DCC !

Nous allons déclarer un bouton poussoir. En effet, un ILS est un assimilable à un poussoir activé par le passage d’un aimant. On y ajoute un servo et deux DELs.

  1. // Programme 6
  2.  
  3. #include <Accessories.h>
  4. #include <Commanders.h>
  5.  
  6. #define TEMPO 20000
  7.  
  8. // L'ILS ...
  9. ButtonsCommanderPush boutonILS;
  10.  
  11. // Le moteur
  12. AccessoryServo PN;
  13.  
  14. // Les DELS
  15. AccessoryLightMulti Dels;
  16.  
  17. // Les ports pour connecter le moteur et les DELs.
  18. PortServo portPN;
  19. PortOnePin portLight1;
  20. PortOnePin portLight2;
  21.  
  22. void setup()
  23. {
  24. Commanders::begin(LED_BUILTIN);
  25.  
  26. Accessories::begin();
  27.  
  28. // Un seul bouton, mais deux événements pour le PN
  29. boutonILS.begin(1234, 6); // premier événement pour le déclanchement
  30.  
  31. // Les ports avec leurs broches en digital (pas PWM)
  32. portPN.begin(14);
  33. portLight1.begin(7, DIGITAL_INVERTED);
  34. portLight2.begin(8, DIGITAL_INVERTED);
  35.  
  36. // begin de l'accessoire de 2 Dels qui doivent clignoter à 500ms d'intervalle.
  37. Dels.begin(0, 2, 500);
  38.  
  39. // Les DELs avec pour chaque, le port utilisé.
  40. Dels.beginLight(0, &portLight1);
  41. Dels.beginLight(1, &portLight2);
  42.  
  43. // On fait clignoter les leds...
  44. Dels.SetBlinking(0, 500);
  45. Dels.SetBlinking(1, 500);
  46.  
  47. // Le servo : pas de durée de mouvement, un débattement entre 95 et 135 degres
  48. // et deux positions stables annoncées avec des identifiants inutiles (mais obligatoires)
  49. PN.begin(&portPN, 50, 95, 135, 1);
  50. // Les deux positions sont au mini et au maxi :
  51. PN.AddMinMaxMovingPositions(456, 789);
  52. }
  53.  
  54. unsigned long dateFermeture = 0;
  55.  
  56. void loop()
  57. {
  58. Accessories::loop();
  59.  
  60. unsigned long id = Commanders::loop();
  61.  
  62. // si l'ils est activé !
  63. if (id == 1234)
  64. {
  65. if (dateFermeture== 0)
  66. {
  67. dateFermeture = millis();
  68.  
  69. // mise en route clignotement
  70. Dels.Blink();
  71.  
  72. // mouvement servo : fermeture
  73. PN.MoveMinimum();
  74.  
  75. // Plus rien à faire, attendons l'étape suivante.
  76. return;
  77. }
  78. else
  79. {
  80. dateFermeture = millis();
  81. }
  82. }
  83.  
  84. if (dateFermeture > 0)
  85. {
  86. if (millis() - dateFermeture > TEMPO)
  87. {
  88. // Fin de l'animation. On ouvre les barrières et on éteint les Dels...
  89. dateFermeture = 0;
  90. PN.MoveMaximum();
  91. Dels.LightOff();
  92. }
  93. }
  94. }

Les déclarations sont assez simples, avec juste l’apparition du AccessoryLightMulti qui permet de piloter plusieurs DELs à la fois. L’ordre Blink() permet de les faire toutes clignoter à la fréquence fixée par le délai du lights.begin() .
Le loop() utilise une date de mise en route du cycle. A début du cycle on lance l’ouverture des barrières. J’ai supposé que la position minimum du servo correspond à la position haute des barrières. On lance en même temps le clignotement des Dels. Une TEMPO plus tard, on lance l’ouverture avec le MoveMaximum(), et on arrête le clignotement avec le LightOff. Petite astuce : si l’ILS est à nouveau activé alors que le cycle est en cours (delaiFermeture != 0), la date de départ est rafraîchie pour laisser le temps au nouveau train de passer !

Pour rappel, le bibliothèque est disponible ici : Forge Locoduino

A noter que tous les programmes de cet article sont présents dans les exemples livrés avec la bibliothèque sous le nom de locoduino.org .

14 Messages

Réagissez à « Bibliothèque Accessories (2) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Bibliothèques »

Bibliothèque Servo

Bibliothèque SoftWare Serial

Bibliothèque Serial

Bibliothèque EEPROM

Bibliothèque Wire : I2C

Bibliothèque LCD

Bibliothèque ScheduleTable

Bibliothèque MemoryUsage

Bibliothèque EEPROMextent

Bibliothèque Commanders

Bibliothèque DcDccNanoController

Un décodeur d’accessoires universel (1)

Un décodeur d’accessoires universel (2)

Un décodeur d’accessoires universel (3)

Bibliothèque LcdUi (1)

Bibliothèque LcdUi (2)

Les derniers articles

Bibliothèque DcDccNanoController


Thierry

Bibliothèque LcdUi (2)


Thierry

Bibliothèque LcdUi (1)


Thierry

Bibliothèque Accessories (2)


Thierry

Bibliothèque Accessories (1)


Thierry

Bibliothèque Commanders


Thierry

Bibliothèque MemoryUsage


Thierry

Bibliothèque Wire : I2C


Dominique, Guillaume

Bibliothèque Serial


Dominique, Guillaume, Jean-Luc

Bibliothèque SoftWare Serial


Dominique, Guillaume

Les articles les plus lus

Bibliothèque Wire : I2C

Bibliothèque DcDccNanoController

Bibliothèque Serial

Un décodeur d’accessoires universel (1)

Bibliothèque Servo

Bibliothèque SoftWare Serial

Bibliothèque Commanders

Bibliothèque LCD

Bibliothèque EEPROM

Bibliothèque Accessories (1)