LOCODUINO

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

vendredi 23 juin 2017

32 visiteurs en ce moment

Multi-animations lumineuses

. Par : Christian Bézanger, Dominique, Guillaume

Ce programme regroupe sur un même arduino plusieurs programmes d’animations lumineuses dont chacun a fait l’objet d’un article : feu tricolore, chenillard et enseigne de magasin. Vous trouverez dans ces articles quelques bases de la programmation ainsi que l’utilisation des DEL  , mais aussi les exemples en vidéo.

Pour quel arduino ?

Le code est écrit pour un arduino uno, il sera toutefois plus difficile de le transcrire pour un autre type d’arduino, vu que les branchements de chaque DEL   influent sur le code. La déclaration des broches de sortie n’a pas été faite au tout début du programme. Nous utilisons des boucles pour simplifier la programmation.

Précaution

Comme vous le savez, un Arduino tant Uno que Mega accepte un maximum de 200 mA en consommation sur toutes les broches ensemble. Etudions donc la consommation de courant de ce montage qui est limitée à 200 mA pour la carte Uno. Le feu tricolore allume deux DEL en même temps (il consomme donc 40 mA), le chenillard n’allume qu’une seule DEL à la fois (il consomme 20 mA), l’enseigne lumineuse peut allumer toutes les DEL en même temps ; elle consomme donc 120 mA et la consommation totale des trois montages peut être de 180 mA, ce qui est très proche des possibilités du module !

Cela passe, mais si vous voulez garder une petite marge de sécurité, la solution la plus simple consiste à limiter le courant à 15 mA par DEL pour l’enseigne de commerçant qui consomme le plus. C’est la solution que j’ai adoptée ; les résistances sont égales à 150 ohms pour les DEL des feux et du chenillard, et à 220 ohms pour les DEL de l’enseigne.

Cette résistance dépend bien sûr de la DEL utilisée. Il faudra donc se reporter à la Datasheet   de celle-ci pour calculer la valeur de la résistance associée. Une autre manière consiste à employer une résistance avec une valeur supérieure. Se reporter à l’article : Fonctionnement et pilotage d’une DEL

Comment les assembler ?

En général, les programmes commandant des DEL utilisent la fonction delay() qui est une fonction bloquante. En effet, le microcontrôleur ne peut rien faire d’autre pendant que delay() s’exécute.

2 manières de faire s’offrent donc à nous :

  • nous pouvons soit utiliser la fonction millis() afin de remplacer delay(). Pour cela, un réarrangement du code est nécessaire
  • soit nous gardons la fonction delay(). En effet, L’allumage ou l’extinction d’une DEL est quasiment instantané. Il suffira donc de régler correctement l’enchaînement pour obtenir le même effet désiré. Nous verrons plus en détail dans le paragraphe concerné.

Programme regroupant les animations avec la fonction millis()

Branchements

Code

Le code ci-après est à recopier dans l’interface de l’IDE d’arduino. Il y a même un bouton télécharger à la fin.

  1. /*
  2. Programme pour arduino uno
  3. par G. Marty Novembre 2013
  4. Licence GNU GPLv3
  5.  
  6.  
  7. Multi-programme pour feu tricolore, enseigne et chenillard avec fonction millis
  8. Schéma de branchement :
  9. => feu vert 1 et 2 sur broche 0 et 1, orange 1 et 2 sur 2 et 3
  10. et rouge 1 et 2 sur 4 et 5
  11. => Chenillard sur les broches de 6 à 11 : 6 LED
  12. => Enseigne sur les broches analogiques de 14 à 19 soit de A0 à A5
  13. */
  14.  
  15. // Déclaration des broches de feu
  16. const int feu_vert = 0;
  17. const int feu_orange = 2;
  18. const int feu_rouge = 4;
  19. // Il n'y a pas besoin de déclarer les variables des autres broches.
  20.  
  21. // Déclaration des différentes variables utilisées pour flécher les différentes étapes
  22. byte i; // Variable utilisée pour les boucles.
  23. // Cela évite de déclarer cette variable à chaque fois dans la boucle for.
  24.  
  25. // Pour le feu tricolore
  26. byte etat_temps_feu = 0; // pour comptabiliser le nombre de fois où la valeur de temps
  27. // choisie s'écoule.
  28. boolean feu = 0; // pour gérer la route où le feu doit fonctionner : 0 ou 1 dans le cas
  29. // 'un croisement où 2 ou 4 feux (fonctionnant 2 par 2) sont présents
  30.  
  31. // Pour le chenillard
  32. byte broche_chenillard = 6; // gérer l'état des broches du chenillard en fonction
  33. // d'une incrémentation
  34. byte etat_temps_chenillard = 0; // compter le nombre du temps de 50ms passées
  35.  
  36. // Pour les animations de l'enseigne
  37. byte etat_temps_enseigne= 0; // compter le nombre du temps de 50ms passées
  38. byte compteur_tour_enseigne = 0; // compter le nombre de boucles passées
  39. byte broche_enseigne = 14; // gérer la broche de sorties lors des répétitions
  40. long aleatoire; // gérer l'aléatoire dans le choix des animations
  41. byte compte_LED_restantes = 5; // pour l'animation 3
  42.  
  43. // Déclaration des différents variables pour stocker le temps de l'arduino
  44. unsigned long temps_feu = 0; // pour le feu tricolore
  45. unsigned long temps_chenillard = 0; // pour le chenillard i.e. feux dans les virages
  46. unsigned long temps_enseigne = 0; // pour l'enseigne
  47.  
  48. void setup()
  49. // Déclaration des broches du feu, du chenillard et de l'enseigne en boucle
  50. {
  51. for (i=0 ; i<12 ; i++)
  52. {
  53. pinMode(i, OUTPUT);
  54. }
  55.  
  56. for(i=14 ; i < 20 ; i++)
  57. {
  58. pinMode(i, OUTPUT);
  59. }
  60.  
  61. // Mise des valeurs de base sur les broches : LOW à part les feux rouges
  62. for (i=0 ; i<4 ; i++)
  63. {
  64. digitalWrite(i, 0);
  65. }
  66.  
  67. digitalWrite(4, 1);
  68. digitalWrite(5, 1);
  69.  
  70. for (i=6 ; i<12 ; i++)
  71. {
  72. digitalWrite(i, 0);
  73. }
  74.  
  75. eteindre_enseigne();
  76. aleatoire=random(1, 4); // attribution à la variable d'un nombre
  77. // entre 1 et 4 non inclus
  78. }
  79.  
  80. // Boucle du programme
  81. void loop()
  82. {
  83. // Etape de condition pour le feu. Si le temps passé est supérieur à 2s,
  84. // on exécute le code après sinon on continue le loop.
  85. if (millis() - temps_feu > 2000) // Utilisation d'un temps de 2s multiple de 2 et 10
  86. {
  87. etat_temps_feu++; // On incrémente le compteur pour les 2s
  88. fonction_feu(etat_temps_feu); // On exécute la fonction du feu en fonction
  89. // du compteur
  90. temps_feu = millis(); // On stocke la nouvelle valeur du temps pour en quelque sorte
  91. // remettre à zéro la condition du if précédent
  92. }
  93.  
  94. // Etape de condition pour le chenillard. Si le temps passé est supérieur à 50ms,
  95. // on exécute le code après sinon on continue le loop.
  96. if (millis()-temps_chenillard > 50) // Utilisation d'un temps de 50ms multiple
  97. // de 50 et 500ms
  98. {
  99. etat_temps_chenillard++; // On incrémente le compteur pour les 50ms
  100. fonction_chenillard(etat_temps_chenillard); // On exécute la fonction du chenillard
  101. // en fonction du compteur
  102. temps_chenillard = millis(); // On stocke la nouvelle valeur du temps pour en quelque
  103. // sorte remettre à zéro la condition du if précédent
  104. }
  105.  
  106. // Etape de condition pour l'enseigne Si le temps passé est supérieur à 50ms,
  107. // on exécute le code ci-après
  108. if ((millis() - temps_enseigne) > 50 )
  109. {
  110. etat_temps_enseigne++; // On incrémente pour les 50ms passées
  111. switch(aleatoire) // on sélectionne l'animation que le random a défini.
  112. { // chaque animation est stockée dans une fonction
  113. case 1:
  114. enseigne1(etat_temps_enseigne);
  115. break;
  116.  
  117. case 2:
  118. enseigne2(etat_temps_enseigne);
  119. break;
  120.  
  121. case 3:
  122. enseigne3(etat_temps_enseigne);
  123. break;
  124. }
  125. temps_enseigne = millis();
  126. }
  127. }
  128.  
  129. // Définition des différentes fonctions
  130.  
  131. /* Définition de la fonction du feu. L'allumage des LED se fait en fonction
  132.   du temps passé 2s pour feu rouge et orange et 10s pour le feu vert soit 5 tours.

  133.   Pour changer de feu qui doit faire le cycle, on échange la valeur booléane feu.
  134. */
  135.  
  136. void fonction_feu(byte x)
  137. {
  138. switch(x)
  139. {
  140. case 1:
  141. digitalWrite(feu_rouge + feu, 0); // On éteint le feu rouge
  142. digitalWrite(feu_vert + feu, 1); // On allume le feu vert
  143. break;
  144.  
  145. case 6:
  146. digitalWrite(feu_vert + feu, 0); // On éteint le feu vert
  147. digitalWrite(feu_orange + feu, 1); // On allume le feu orange
  148. break;
  149.  
  150. case 7:
  151. digitalWrite(feu_orange + feu, 0); // On éteint le feu orange
  152. digitalWrite(feu_rouge + feu, 1); // On allume le feu rouge
  153. etat_temps_feu = 0; // On remet à zéro pour refaire le cycle de la fonction
  154. feu = !feu; // on échange de croisement
  155. break;
  156. }
  157. }
  158.  
  159.  
  160. /*
  161.   Définition de la fonction du chenillard en fonction du compteur commençant par 5,
  162.   le compteur définissant aussi la broche de sortie pour l'allumage
  163.   des différentes LED toutes les 50ms puis un retour au début du cycle après 500ms
  164.   soit 10 cycles
  165. */
  166. void fonction_chenillard(byte t)
  167. {
  168. switch(t)
  169. {
  170. case 1:
  171. digitalWrite(broche_chenillard, 1);
  172. break;
  173.  
  174. case 4:
  175. digitalWrite(broche_chenillard, 0);
  176. break;
  177.  
  178. case 5:
  179. broche_chenillard++;
  180. if (broche_chenillard == 12) // arrivée au bout du chenillard
  181. {
  182. etat_temps_chenillard = 6; // pour établir un délai entre chaque chenillard
  183. broche_chenillard = 6; // on remet à zéro pour une nouvelle boucle de
  184. // chenillard après attente
  185. }
  186. else
  187. {
  188. etat_temps_chenillard = 0; // on remet à zéro pour un changement
  189. // d'allumage/extinction de LED
  190. }
  191. break;
  192.  
  193. case 20: // pour patienter un peu 750ms
  194. etat_temps_chenillard = 0;
  195. break;
  196. }
  197. }
  198.  
  199. /* Définition des fonctions des animations de l'enseigne
  200.   3 fonctions au total
  201. */
  202.  
  203. // 1ère animation : clignotement de l'ensemble des LED 3 fois
  204. void enseigne1(byte z)
  205. {
  206. switch(z)
  207. {
  208. case 1: // allumage des LED
  209. for (i=14 ; i < 20 ; i++)
  210. {
  211. digitalWrite(i, 1);
  212. }
  213. break;
  214.  
  215. case 11: // extinction des LED
  216. eteindre_enseigne();
  217. break;
  218.  
  219. case 20: // pour patienter un peu 500ms
  220. compteur_tour_enseigne++; // on incrémente le compteur de tours
  221. etat_temps_enseigne =0; // on remet à zéro pour une nouvelle boucle
  222. if (compteur_tour_enseigne==3) // si 3 tours exécutés
  223. {
  224. compteur_tour_enseigne = 0; // on remet à zéro le compteur
  225. aleatoire = random(1, 4); // on change d'animation si aleatoire
  226. // ne reste pas 1
  227. }
  228. break;
  229. }
  230. }
  231.  
  232. // 2ème animation : chenillard exécuté 2 fois
  233. void enseigne2(byte t)
  234. {
  235. switch(t)
  236. {
  237. case 1:
  238. digitalWrite(broche_enseigne, 1); // Allumage de la LED
  239. break;
  240.  
  241. case 4:
  242. digitalWrite(broche_enseigne, 0); // Extinction de la LED
  243. break;
  244.  
  245. case 5:
  246. broche_enseigne++; // incrémentation de la broche pour changer de LED
  247. etat_temps_enseigne = 0; // RAZ pour revenir au début de la boucle
  248. if (broche_enseigne == 20) // quand le chenillard est fini
  249. {
  250. broche_enseigne = 14; // RAZ des broches pour revenir au début du chenillard
  251. compteur_tour_enseigne++;// Incrémentation du compteur
  252. }
  253. if (compteur_tour_enseigne == 2) // si 2 chenillards faits
  254. {
  255. compteur_tour_enseigne = 0; // RAZ du compteur
  256. etat_temps_enseigne = 6; // pour faire patienter
  257. }
  258. break;
  259.  
  260. case 25:
  261. etat_temps_enseigne = 0;
  262. aleatoire = random(1, 4);
  263. break;
  264. }
  265. }
  266.  
  267. // 3ème animation : chenillard de gauche à droite avec cumul des LED sur la droite
  268. // et extinction de gauche à droite
  269. void enseigne3(byte u)
  270. {
  271. switch(u)
  272. {
  273. case 1:
  274. digitalWrite(broche_enseigne, 1);
  275. break;
  276.  
  277. case 4:
  278. // Ensemble de conditions si fausses la boucle continue
  279. if (compteur_tour_enseigne == compte_LED_restantes) // tour complet
  280. {
  281. compte_LED_restantes--; // décrémentation des LED restantes à allumer pour
  282. // faire un tour moins complet
  283. etat_temps_enseigne = 0; // RAZ pour refaire la boucle
  284. broche_enseigne = 14; // RAZ de la broche de sortie
  285. compteur_tour_enseigne = 0; // RAZ des tours
  286. if (compte_LED_restantes == 0) // les 5 dernières LED sont allumées
  287. {
  288. digitalWrite(14, 1); // On allume la dernière LED
  289. broche_enseigne = 19; // On met à 19 pour l'extinction
  290. etat_temps_enseigne = 97; // On sort de la boucle
  291. }
  292. }
  293. else // On recommence le tour pour faire une boucle complete
  294. {
  295. digitalWrite(broche_enseigne, 0); // On éteint la LED
  296. broche_enseigne++; // On change de broche
  297. etat_temps_enseigne = 0; // On remet à 0 le temps
  298. compteur_tour_enseigne++; // On comptabilise le tour
  299. }
  300. break;
  301.  
  302. case 100:
  303. digitalWrite(broche_enseigne, 0); // On éteint la LED
  304. break;
  305.  
  306. case 103:
  307. broche_enseigne--; // on décrémente pour éteindre les LED
  308. if (broche_enseigne == 13) // Extinction de toutes les LED faites
  309. {
  310. etat_temps_enseigne = 104; // on fait sortir de cette boucle
  311. }
  312. else
  313. {
  314. etat_temps_enseigne = 97; // on continue l'extinction
  315. }
  316. break;
  317.  
  318. case 114: // pour faire patienter
  319. // RAZ de toutes les valeurs utilisées
  320. aleatoire = random(1, 4); // choix d'une animation au hasard
  321. etat_temps_enseigne = 0;
  322. compteur_tour_enseigne = 0;
  323. broche_enseigne = 14;
  324. compte_LED_restantes = 5;
  325. break;
  326. }
  327. }
  328.  
  329. // Extinction des LED de l'enseigne
  330. void eteindre_enseigne()
  331. {
  332. for(i=14 ; i < 20 ; i++)
  333. {
  334. digitalWrite(i, 0);
  335. }
  336. }

Télécharger

Programme regroupant les animations avec la fonction delay()

Explications
La fonction delay() est bloquante, ce qui signifie que le microcontrôleur ne peut rien faire d’autre pendant l’exécution de delay(), Or, l’allumage ou l’extinction d’une DEL est quasiment instantané (quelques microsecondes) ; ces actions très rapides sont à intercaler entre d’autres actions. On peut régler les feux lorsque c’est nécessaire et pour cela, il faut se fixer une unité de base de temps. Le plus simple est de prendre une seconde et de choisir que le chenillard soit lancé toutes les secondes. Avant chaque lancement du chenillard, on manipule une DEL de l’enseigne, selon la séquence choisie (cette fois on ne fait plus appel aux fonctions). La première séquence de l’enseigne est le cumul sur la gauche ; lorsqu’elle est terminée, le temps écoulé est de 22 secondes. Il est alors temps de faire passer à l’orange le feu qui était vert. La durée du feu orange, dure le temps de la séquence 2 (clignotement de l’ensemble des DEL de l’enseigne deux fois). Lorsque la séquence 2 est terminée, le feu doit passer au rouge. On lance alors la dernière séquence de l’enseigne (l’extinction de la gauche vers la droite), ce qui permet la temporisation du chauffard ; puis l’autre feu passe au vert, et un deuxième cycle recommence à l’identique pour le feu B1.

Bien sûr, il ne faut pas oublier de lancer le chenillard toutes les secondes. La fonction « chenillard » a été créée pour cela. Chaque DEL s’allumant 50 ms (T2), la durée totale du chenillard est de 300 ms (6 fois T2). Pour le déclencher toutes les secondes, on introduit un délai égal à 700 ms (T1).

En choisissant T1 = 700 ms et T2 = 50 ms, le chenillard est lancé toutes les secondes, la durée du vert est de 22 s, celle de l’orange de 4 s et celle du rouge 27 s (22 + 4 + 1 qui est la temporisation du chauffard).

Maintenant que vous connaissez les astuces pour commander les trois animations, vous pouvez remarquer, sur la vidéo, qu’on voit bien que c’est le rythme de l’enseigne qui fixe le rythme des feux. Ceci est dû au fait que les trois animations sont proches l’une de l’autre sur la breadboard. Une fois que les animations seront en place sur votre réseau, cela ne se remarquera plus, car l’observateur fixera une animation à la fois, en fonction des saynètes que vous développerez.

Branchements

Code

  1. /*-------------------------------------------------------
  2. Programme pour arduino uno
  3. par C. Bézanger Novembre 2013
  4. Licence GNU GPLv3
  5.  
  6. Ce programme fait fonctionner une enseigne lumineuse,
  7. un chenillard et des feux tricolores, en même temps.
  8. Six LED rouges sont reliées aux sorties 2 à 7 et
  9. forment l'enseigne.
  10. Six LED jaunes sont reliées aux sorties 8 à 13 et
  11. forment le chenillard.
  12. Les sorties analogiques sont utilisées comme sorties
  13. numériques et sont numérotées 14 à 19.
  14. Les sorties 14 à 16 forment le feu A1.
  15. Les sorties 17 à 19 forment le feu B1.
  16. T2 est la durée d'un flash du chenillard en ms.
  17. La durée du chenillard est 6 fois T2 en ms.
  18. Pour que le chenillard soit déclenché toutes les secondes,
  19. il faut que (T1 + 6 fois T2) soit égal à 1000 ms
  20. En jouant sur T1 et/ou T2, on dynamise le rythme
  21. Par exemple, pour T1 = 700 et T2 = 50, on a :
  22. Vert : 22 secondes
  23. Orange : 4 secondes
  24. Rouge : 27 secondes (car temporisation du chauffard 1 sec)
  25. --------------------------------------------------------*/
  26.  
  27. // Initialisation des variables
  28.  
  29. const byte A1V = 14 ;
  30. const byte A1O = 15 ;
  31. const byte A1R = 16 ;
  32. const byte B1V = 17 ;
  33. const byte B1O = 18 ;
  34. const byte B1R = 19 ;
  35. const int T1 = 700 ; // Fixe le rythme de déclenchement du chenillard
  36. const int T2 = 50 ; // Durée du flash du chenillard
  37. // T1 + 6 fois T2 doit être égal à 1000 !
  38.  
  39.  
  40. void setup ()
  41. {
  42. // Initialisation de toutes les lignes en sortie
  43. for (byte i = 2 ; i <= 19 ; i++)
  44. {
  45. pinMode (i, OUTPUT) ;
  46. }
  47.  
  48. // Extinction de toutes les LED au départ
  49. for (byte j = 2 ; j <= 19 ; j++)
  50. {
  51. digitalWrite (j, LOW) ;
  52. }
  53.  
  54. // Allumage de A1V et B1R
  55. digitalWrite (A1V, HIGH) ;
  56. digitalWrite (B1R, HIGH) ;
  57.  
  58. }
  59.  
  60. // Fonction loop
  61. void loop ()
  62. {
  63. // Début de cycle ; le feu A1 est vert et le feu B1 est rouge
  64. // L'enseigne cumule vers la gauche
  65. for (byte n = 0 ; n <= 5 ; n++)
  66. {
  67. for (byte m = 2 ; m <= (7 - n) ; m++)
  68. {
  69. digitalWrite (m, HIGH) ;
  70. delay (T1) ;
  71. chenillard () ;
  72. digitalWrite (m, LOW) ;
  73. }
  74. digitalWrite ((7 - n), HIGH) ;
  75. }
  76. delay (T1) ;
  77. chenillard () ;
  78. // On est à 22 secondes
  79. // Feu A1 passe à orange
  80. digitalWrite (A1V, LOW) ;
  81. digitalWrite (A1O, HIGH) ;
  82. // Enseigne clignote dans sa totalité deux fois
  83. for (byte j = 1 ; j <= 2 ; j++)
  84. {
  85. for (byte k = 2 ; k <= 7 ; k++)
  86. {
  87. digitalWrite (k, LOW) ;
  88. }
  89. delay (T1) ;
  90. chenillard () ;
  91. for (byte l = 2 ; l <= 7 ; l++)
  92. {
  93. digitalWrite (l, HIGH) ;
  94. }
  95. delay (T1) ;
  96. chenillard () ;
  97. }
  98. // On est à quatre secondes
  99. // Feu A1 passe au rouge
  100. digitalWrite (A1O, LOW) ;
  101. digitalWrite (A1R, HIGH) ;
  102. // Enseigne s'éteint de la gauche vers la droite
  103. // Le temps nécessaire pour cela constitue la temporisation du chauffard
  104. for (byte i = 7 ; i >= 2 ; i--)
  105. {
  106. digitalWrite (i, LOW) ;
  107. delay (T1/6) ;
  108. }
  109. chenillard () ;
  110. // On est à une seconde, le rouge a donc duré 22 + 4 + 1 = 25 sec
  111. // Feu B1 passe au vert
  112. digitalWrite (B1R, LOW) ;
  113. digitalWrite (B1V, HIGH) ;
  114. // Le feu A1 est rouge et le feu B1 est vert
  115. // L'enseigne cumule vers la gauche
  116. for (byte n = 0 ; n <= 5 ; n++)
  117. {
  118. for (byte m = 2 ; m <= (7 - n) ; m++)
  119. {
  120. digitalWrite (m, HIGH) ;
  121. delay (T1) ;
  122. chenillard (

    n style="color: #009900;">) ;
  123. digitalWrite (m, LOW) ;
  124. }
  125. digitalWrite ((7 - n), HIGH) ;
  126. }
  127. delay (T1) ;
  128. chenillard () ;
  129. // Feu B1 passe à l'orange
  130. digitalWrite (B1V, LOW) ;
  131. digitalWrite (B1O, HIGH) ;
  132. // Enseigne clignote dans sa totalité deux fois
  133. for (byte j = 1 ; j <= 2 ; j++)
  134. {
  135. for (byte k = 2 ; k <= 7 ; k++)
  136. {
  137. digitalWrite (k, LOW) ;
  138. }
  139. delay (T1) ;
  140. chenillard () ;
  141. for (byte l = 2 ; l <= 7 ; l++)
  142. {
  143. digitalWrite (l, HIGH) ;
  144. }
  145. delay (T1) ;
  146. chenillard () ;
  147. }
  148. // Feu B1 passe au rouge
  149. digitalWrite (B1O, LOW) ;
  150. digitalWrite (B1R, HIGH) ;
  151. // Enseigne s'éteint de la gauche vers la droite
  152. // Le temps nécessaire pour cela constitue la temporisation du chauffard
  153. for (byte i = 7 ; i >= 2 ; i--)
  154. {
  155. digitalWrite (i, LOW) ;
  156. delay (T1/6) ;
  157. }
  158. chenillard () ;
  159. // Feu A1 passe au vert
  160. digitalWrite (A1R, LOW) ;
  161. digitalWrite (A1V, HIGH) ;
  162. // Le feu A1 est vert, le feu B1 est rouge, le cycle peut recommencer
  163. }
  164.  
  165. void chenillard ()
  166. {
  167. // Boucle pour faire flasher les LED du chenillard, durée 300 ms
  168. for (byte i = 8 ; i <= 13 ; i++)
  169. {
  170. digitalWrite (i, HIGH) ; // allume la LED sur broche i
  171. delay (T2) ; // durée du flash 50 millisecondes
  172. digitalWrite (i, LOW) ; // éteint la LED
  173. }
  174. return ;
  175. }

Télécharger

3 Messages

Réagissez à « Multi-animations lumineuses »

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 « Projets »

Un chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

La rétro-signalisation sur Arduino

Décodeur pour aiguillage à solénoïdes sur Arduino

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est ce que c’est ? (3)

La PWM : Qu’est ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Gestion d’une gare cachée (1)

Gestion d’une gare cachée (2)

Gestion d’une gare cachée (3)

Les derniers articles

La PWM : Qu’est ce que c’est ? (4)


Jean-Luc

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"


Christian Bézanger

Réalisation d’un affichage de gare ARRIVEE DEPART


Gilbert

Contrôleur à télécommande infrarouge pour centrale DCC++


Daniel

La PWM : Qu’est ce que c’est ? (3)


Jean-Luc

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)


bobyAndCo

Un gestionnaire en C++ pour votre réseau (4)


Pierre59

Un décodeur DCC pour 16 feux tricolores


Dominique, JPClaude, Thierry

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)


bobyAndCo

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)


Dominique

Les articles les plus lus

La PWM : Qu’est-ce que c’est ? (1)

Comment piloter trains et accessoires en DCC avec un Arduino (1)

L’Arduino et le système de commande numérique DCC

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

La rétro-signalisation sur Arduino

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Un chenillard de DEL

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)