LOCODUINO

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

lundi 29 mai 2023

73 visiteurs en ce moment

Passage à niveau géré par Arduino (5)

Amélioration et résolution des problèmes

. Par : Christian

DIFFICULTÉ :

Les quatre précédents articles nous ont permis de construire un passage à niveau automatique de type SAL 2 et de l’intégrer à un réseau de trains miniatures comme le réseau Train’ In Box. Cet article, le dernier de la série, va vous donner des pistes pour améliorer le montage et surtout vous montrer comment le dépanner si certains éléments devaient tomber en panne.

Article mis à jour le 17 octobre 2021 pour préciser que l’emploi de détecteurs d’occupation par consommation de courant simplifie grandement le programme pour déterminer l’état d’occupation de la zone du PN.

Il aura fallu quatre articles qui s’enchaînent pour arriver à bout de notre projet de passage à niveau reproduisant la réalité le plus fidèlement possible. Chaque article complétait le précédent afin de rajouter une fonctionnalité. On ne développe pas une application complète en une seule fois ; il faut opérer par petits bouts et toujours partir d’un montage qui fonctionne pour l’améliorer en lui ajoutant une nouvelle option.

Bien évidemment, au cours de notre développement, nous avons dû faire des choix qui n’étaient sans doute pas les meilleurs mais qui s’imposaient pour d’autres raisons :
• Facilité d’intégration sur un réseau déjà monté
• Facilité d’approvisionnement en matériaux ou composants
• Facilité d’usinage des pièces mécaniques sans nécessiter de machines spécialisées
• Possibilités d’évolution

Nous allons voir ici comment remettre en cause certains des choix qui ont été faits et comment améliorer notre passage à niveau.

Les améliorations possibles

La détection des trains
La première chose que nous pouvons améliorer est la détection des trains. Nous avons fait le choix de positionner des capteurs ponctuels à la périphérie de la zone de voies à surveillée, solution qui a le mérite de ne nécessiter aucun travaux sur les voies en elles-mêmes. Nous avons fait le choix d’utiliser des ILS mais ceux-ci ont des contacts mécaniques qui peuvent parfois se rompre ou rester collés (sans parler des problèmes de rebonds mais nous en avions tenu compte par une temporisation de 2 s). Il peut être intéressant de remplacer ces ILS par des capteurs à effet Hall qui réagissent également à la présence d’un champ magnétique ; ces capteurs sont faciles à trouver et bon marché. Le signal transmis à la carte Arduino doit rester compris entre 0 et 5 V. Pour plus d’informations sur la mise en oeuvre de capteurs à effet Hall, vous pouvez consulter l’article Capteurs à effet Hall.

Que ce soit des ILS ou bien des capteurs à effet Hall, il faut que les locomotives soient équipées d’un aimant, ce qui peut constituer une contrainte si vous voulez que vos amis viennent sur votre réseau avec leurs locomotives personnelles qui ne sont peut-être pas équipées d’aimant. On peut alors faire appel à des capteurs infra-rouge par réflexion qui vont également se fixer sous la voie entre deux traverses et qui restent relativement discrets. Encore une fois, le signal délivré à la carte Arduino doit rester compris entre 0 et 5 V et il faudra faire un traitement informatique car le capteur verra passer chaque wagon qu’il faudra ensuite reconstituer comme un seul et unique train. Ceci n’est pas très compliqué ; il suffit de mettre une temporisation pour filtrer le temps relativement court de non détection entre wagons.

Comme on l’a dit au début, le nec plus ultra est de faire de la détection d’occupation de voies par consommation de courant. On peut utiliser des détecteurs d’occupation du commerce ou bien monter ses propres détecteurs en s’inspirant de schémas trouvés sur internet ou sur notre forum. Le signal délivré doit être compris entre 0 et 5 V pour être envoyé à la carte Arduino ; si ce n’est pas le cas, on peut utiliser un coupleur optique comme on l’a fait pour le module son. Néanmoins, l’utilisation de détecteur d’occupation par consommation de courant nécessite de créer physiquement des zones de détection en coupant une file de rail aux endroits stratégiques. Les voitures et wagons doivent consommer du courant pour être détectés. Pour des voitures, c’est assez simple si elles sont éclairées et pour les wagons, il suffit de graphiter les essieux ou de mettre des feux de fin de convois.

La figure 1 montre en bleu la forme des zones de protection du PN pour chaque voie ainsi que le positionnement de certains accessoires (cliquez sur l’image pour l’agrandir). La distance "L" est la longueur du plus long train circulant sur le réseau. L’utilisation de ce genre de détecteurs est d’autant plus facile que le réseau a été conçu en ce sens, en créant par exemple des cantons pour que plusieurs trains puissent se suivre. Une fois le réseau monté, c’est plus compliqué d’intervenir dessus sans être pour autant impossible ; il suffit de couper les rails et de souder sur les flancs un fil électrique pour réalimenter la portion. Avec le décor en place, cela peut devenir assez sportif…

Figure 1
Figure 1
Zones de protection des voies avec des détecteurs d’occupation

Le gros avantage des détecteurs d’occupation par rapport aux capteurs ponctuels en périphérie de zone à protéger est qu’on n’a plus à tenir compte de conditions à respecter lors de l’initialisation. Si un détecteur envoie un signal, c’est que la zone est occupée et qu’un train approche du PN et il n’y a plus à se poser la question de l’état antérieur de la zone. Mais il faut aussi un minimum de tension sur la voie pour détecter un train arrêté en gare ; ceci ne concerne pas un réseau en DCC puisque la voie est toujours sous tension, même avec des trains à l’arrêt.

Il faut aussi se rappeler que la mise en parallèle de plusieurs capteurs sur une même entrée n’est possible que pour des contacts (ILS tels qu’ils ont été montés dans ce projet) ou bien des sorties à collecteur ouvert (capteurs à effet Hall ou détecteurs d’occupation par consommation de courant). Un peu d’électronique peut se révéler nécessaire pour traiter plusieurs capteurs. Dans le cas de la figure 1, il ne faut que deux détecteurs d’occupation (un sur chaque voie) qui peuvent alors être reliés aux entrées 2 et 3 de la carte Uno ; dans ce cas, l’entrée 3 travaille de la même façon que l’entrée 2 pour déterminer l’occupation globale du PN comme nous l’avons expliqué dans le premier article et le traitement de l’information n’est plus qu’un simple exercice de programmation.

Les programmes donnés dans cette série d’articles ont été conçus pour traiter des événements de courte durée (fermeture d’ILS) et ils surveillent la périphérie de la zone PN en faisant appel aux interruptions pour ne pas louper des événements. Les détecteurs d’occupation fournissent des signaux de longue durée (tant que la zone à surveiller est occupée) ; le programme est considérablement simplifié puisqu’il suffit de lire l’état des entrées reliées aux détecteurs en début de boucle loop pour déterminer l’état d’occupation de la zone du PN. Toutes les entrées sont utilisables à la condition que le signal fourni par le détecteur soit ramené dans l’intervalle 0-5 V.

Quatre feux de PN au lieu de deux
Il suffit de rajouter deux LED et une résistance de 470 Ω sur la sortie 5 (PWM) comme le montre la figure 2, et bien évidemment modifier le programme. Chaque ensemble de deux LED sera positionné d’un côté ou l’autre des voies et bien évidemment les LED d’un même ensemble seront positionnées de chaque côté de la route pour être vues par les automobilistes devant s’arrêter avant la barrière.

Figure 2
Figure 2
Montage pour quatre feux de passage à niveau

Concernant le programme, il suffit d’instancier un deuxième objet (feu2PN) avec LightDimmer. Chaque opération sur le premier objet est répétée sur le deuxième.

  1. /*******************************************************************************
  2.  * PN_TIB_4Feux_Barrieres_SortieSon_InitFerme.ino
  3.  * *****************************************************************************
  4.  * Programme developpe pour le projet de PN pour Train In Box.
  5.  * Il prend en compte l arrivee du train, le clignotement des feux en simulant 
  6.  * une ampoule a filaments, un delai avant mouvement des barrieres,
  7.  * le mouvements des deux barrieres sur 90° d amplitude (depend de 
  8.  * la transmission adoptee).
  9.  * Le programme s'initialise barrieres fermees, donc AVEC TRAIN EN GARE SUR TIB.
  10.  * La LED_SON est allumee tant que sonnerie doit jouer ; cette sortie commande
  11.  * le module sonore.
  12.  * *****************************************************************************
  13.  * Christian BEZANGER - 13 Novembre 2018 - 2 Juin 2019 - 29 mai 2020
  14.  ******************************************************************************/
  15.  
  16. #include <LightDimmer.h>  // Bibliotheque pour gerer les feux du PN
  17. #include <Servo.h>        // Bibliotheque pour gerer les barrieres du PN
  18.  
  19. const byte ILS=2; // entree des capteurs 
  20. const byte LED=6; // sortie PWM pour deux feux du PN
  21. const byte LED2=5; // sortie PWM pour deux autres feux du PN
  22. const byte LED_SON=7; // sortie pour indiquer sonnerie
  23. const byte S1=4; // sortie pour le servomoteur 1
  24. const byte S2=8; // sortie pour le servomoteur 2
  25. unsigned int compteur = 1;  // compteur d evenements (survol ILS)
  26.  
  27. // Variables utilisateur pour reglage du mouvement des barrieres
  28. // -------------------------------------------------------------
  29. unsigned long delaiFermeture = 0; // Regle le delai entre clignotement LED 
  30. // et fermeture barrieres - entre 2000 et 8000 mais 0 sur TIB (pas de delai)
  31. int speedServo = 30;  // Regle la vitesse de mouvement des barrieres
  32.  
  33. // Variables non utilisateur
  34. // -------------------------
  35. volatile static boolean etatZonePN = true; // true si la zone du PN est occupee
  36. volatile static boolean old_etatZonePN = false; // etat anterieur de la zone
  37. volatile static unsigned long old_top_debutISR;  // Date anterieure d appel ISR
  38. unsigned long old_top = 0;  // variable pour afficher donnees utiles
  39. int posServo = 90; // position courante a initialiser imperativement FERMEE
  40. int posOuvert = 0;  // barriere a la verticale
  41. int posFerme = 90; // barriere a l'horizontale (90° de la verticale)
  42. unsigned long topAttente = 0; // top pris au début franchissement de la zone PN
  43. boolean etatSon = false; // true si sonnerie doit retentir
  44.  
  45. // Instanciations
  46. LightDimmer feuPN;
  47. LightDimmer feu2PN;
  48. Servo servo1;
  49. Servo servo2;
  50.  
  51. void changeEtat() { // routine d'interruption (ISR)
  52.   unsigned long top_debutISR = millis();  // date appel ISR
  53.   if((top_debutISR - old_top_debutISR) > 2000) {
  54.     // 2 secondes au moins entre execution ISR
  55.     etatZonePN = !etatZonePN; // etat passe a etat oppose
  56.     old_top_debutISR = top_debutISR;  // initialisation date anterieure d appel ISR
  57.   }
  58. } // fin de ISR
  59.  
  60. void setup() {
  61.   // put your setup code here, to run once:
  62.   Serial.begin(115200); // communication avec le moniteur
  63.   pinMode (ILS, INPUT_PULLUP);  // entree capteur
  64.   pinMode (LED_BUILTIN, OUTPUT);  // LED du module allumee si Zone PN occupee
  65.   pinMode (LED, OUTPUT);  // sortie pour feux du PN
  66.   pinMode (LED2, OUTPUT); // sortie pour autres feux du PN
  67.   pinMode (LED_SON, OUTPUT);
  68.   attachInterrupt (digitalPinToInterrupt(ILS), changeEtat, FALLING);
  69.   digitalWrite (LED_BUILTIN, LOW);
  70.   feuPN.begin(LED, HIGH); // LED s'allume avec etat haut
  71.   feu2PN.begin(LED2, HIGH); // LED2 s'allume avec etat haut
  72.   servo1.attach(S1);
  73.   servo2.attach(S2);
  74.   // initialisation des barrieres en position fermee
  75.   servo1.write(posFerme); // barriere 1 FERMEE apres initialisation
  76.   servo2.write(posFerme); // barriere 2 FERMEE apres initialisation
  77.   delay(2000);
  78.   digitalWrite (LED_BUILTIN, HIGH); // Indique fin de setup
  79. }  // fin de setup
  80.  
  81. void loop() {
  82.   // put your main code here, to run repeatedly:
  83.   if(etatSon == false) {digitalWrite (LED_SON, LOW);}
  84.   if(etatSon == true) {digitalWrite (LED_SON, HIGH);}
  85.   if(etatZonePN == false) {
  86.     old_etatZonePN = etatZonePN;
  87.     digitalWrite (LED_BUILTIN, LOW); // eteint LED de controle de la zone PN
  88.     etatSon = false;  // pas de sonnerie
  89.     feuPN.stopBlink();  // arrete le clignotement
  90.     feu2PN.stopBlink(); // arrete le clignotement
  91.     feuPN.off();  // eteint les feux
  92.     feu2PN.off(); // eteint les feux
  93.     // ouverture barriere
  94.     if(posServo > posOuvert) {
  95.       posServo = posServo - 1;
  96.       servo1.write(posServo);
  97.       servo2.write(posServo);
  98.       delay(speedServo);
  99.     }  // fin du test sur position des servos
  100.   }  // fin du test sur etat de la Zone du PN -> false
  101.   if(etatZonePN == true) {
  102.     if(etatZonePN != old_etatZonePN) {
  103.       topAttente = millis();  // prend un top d'entree dans zone PN
  104.       old_etatZonePN = etatZonePN;
  105.       etatSon = true; // sonnerie
  106.     }  // fin du deuxieme if
  107.   digitalWrite (LED_BUILTIN, HIGH); // allume LED de controle de la zone PN
  108.   feuPN.startBlink(); // commence le clignotement
  109.   feu2PN.startBlink();  // commence le clignotement
  110.   // fermeture barriere après attente
  111.   if(millis() - topAttente > delaiFermeture) {
  112.       if(posServo <= posFerme) {
  113.         posServo = posServo + 1;
  114.         servo1.write(posServo);
  115.         servo2.write(posServo);
  116.         if(posServo >= 89) {etatSon = false;}
  117.         delay(speedServo);
  118.       }  // fin du test sur position des servos 
  119.     }  // fin du test sur delai avant ouverture
  120.   }  // fin du test sur etat de la Zone du PN -> true
  121.   LightDimmer::update();
  122.   if(old_top_debutISR != old_top) { // Affichage pour chaque nouveau survol ILS
  123.     Serial.print(compteur);
  124.     Serial.print("     ");
  125.     Serial.print(old_top_debutISR);
  126.     Serial.print("     ");
  127.     Serial.println(old_top_debutISR - old_top);
  128.     old_top = old_top_debutISR; 
  129.     compteur = compteur + 1;   
  130.   }
  131. }  // fin de loop

Télécharger

La bibliothèque LightDimmer permet de régler la fréquence de clignotement, les temps de montée et descente de la luminosité des ampoules pour reproduire l’inertie thermique des filaments. Les choix faits par défaut dans la bibliothèque reproduisent très bien un PN français de la SNCF, si bien qu’il n’est pas forcément nécessaire de les changer. Reportez-vous au fichier « readme » fourni avec la bibliothèque.

Mouvement des barrières
Comme on l’a dit, les barrières en plastique du PN Auhagen sont très fragiles et ce PN ne ressemble pas vraiment à ce qu’on trouve en France. On peut donc envisager d’autres marques mais si on veut appliquer la transmission du mouvement décrite dans cette série d’articles, la commande de la barrière doit se faire en tirant ou poussant une tige ou une corde à piano. Peu importe la valeur du déplacement, il suffit de modifier la forme de la came. Par contre, une corde à piano devra être rigidifiée comme on l’a fait pour le PN Auhagen. Parmi les candidats possibles, nous conseillons les barrières réalisées en impression 3D par NTrail45 ; l’avantage est que vous n’avez pas à monter la barrière car elle est livrée fonctionnelle, l’inconvénient est que le mouvement est limité à l’ouverture par le socle sur lequel vient buter le contrepoids. Il convient de limer un peu ce socle sur un côté. Il existe aussi des feux équipés d’une LED donc fonctionnels ; un ensemble de deux barrières et de deux feux vous coûtera un peu plus de 50 € (prix 2020) mais ceci vous évite quelques heures de travail.

Il existe aussi de très beaux kits en laiton de barrières oscillantes manœuvrées par un ou une garde-barrières. Il fallait tourner une manivelle pour faire descendre ces barrières qui rebondissaient un peu en arrivant en bout de course. Ceux qui voudront reproduire ce mouvement de façon très réaliste auront intérêt à utiliser la bibliothèque SlowMotionServo de LOCODUINO qu’on trouve dans le gestionnaire de bibliothèques de l’IDE. Pour plus d’informations sur la bibliothèque SlowMotionServo, consultez l’article La bibliothèque SlowMotionServo.

Une autre amélioration possible est de construire un passage à niveau automatique SAL 4, c’est-à-dire avec quatre barrières. Il suffit de rajouter deux autres servomoteurs, d’alimenter tous les servos à part (parce que cela ferait trop pour votre carte Uno) et bien évidemment, modifier le programme. C’est un peu plus compliqué de fermer quatre barrières, car elles se ferment deux par deux, les unes après les autres. Par contre, elles s’ouvrent en même temps. La sonnerie s’arrête juste après la fermeture des deux premières barrières. Voilà donc un bel exercice de programmation !

La vidéo ci-dessous vous donne un exemple de PN SAL 4 :

PN à SAL 4
par Sylvain cheminot
https://www.youtube.com/watch?v=-hZ-K13oVk4

Recherche de pannes

Vous avez installé le PN sur votre réseau, conformément à cette série d’articles et lors de la mise en route de la carte Arduino, ça ne fonctionne pas comme cela devrait. Voici quelques éléments de réponses aux questions que vous vous posez.

Lorsque la carte est branchée, rien ne se passe

Vérifiez que la carte Arduino est bien alimentée (sa LED ON doit être allumée).

Si elle l’est, vérifiez que la LED reliée à la sortie 13 est allumée après l’initialisation (la zone est supposée être occupée à l’initialisation).

Si oui, les LED du PN clignotent-elles ? Non, alors vérifiez qu’elles ne sont pas montées à l’envers et vérifiez aussi les connexions avec la carte Arduino. Cette partie du montage doit fonctionner sans problème.

Le train tourne mais rien ne se passe

Avez-vous pensé à mettre un aimant sous la locomotive ? Car sans aimant, pas de déclenchement des ILS !

Vérifiez que la carte Arduino est bien alimentée (sa LED ON doit être allumée).

Essayez de surpasser un ILS en pontant les fils qui en sortent au niveau du domino de connexion. Cette action équivaut à la fermeture des contacts de l’ILS et doit donc déclencher des actions au niveau de la LED de la carte Arduino, des LED de feux de PN, des mouvements de barrières.

Les barrières s’ouvrent quand elles devraient se fermer et se ferment quand elles devraient être ouvertes.

Cela peut être dû à une mauvaise initialisation de la carte Arduino. Amenez un train dans la gare du réseau TIB puis appuyez sur le bouton RESET de la carte Arduino. Attendez que l’initialisation se fasse ; les barrières doivent être fermées et les feux doivent clignoter. Faites démarrer le train et laissez-le tourner ; le comportement du passage à niveau doit être correct. Sinon, c’est qu’un ILS ne joue pas son rôle et ne détecte pas quand un train passe. La solution est de le changer. Pour tester tous les ILS, laisser le train tourner sur toutes les voies possibles.

La barrière n’est pas horizontale quand elle est fermée

Essayez de régler la rallonge de la tige de commande sans forcer.

La barrière est à moitié ouverte au lieu de complètement ouverte

La tige de commande ne redescend pas assez et ceci doit se voir car elle ne frotte plus sur la came. Changez l’élastique de rappel pour un plus petit qui exercera une force de rappel un peu plus grande.

Le fonctionnement des feux est correct mais les barrières ne bougent pas

Vérifiez la connexion des servomoteurs à la carte Arduino. Vérifiez aussi que la transmission mécanique ne soit pas coincée par un objet ou un élastique tirant trop fort sur la tige de commande. Au besoin, retirez les deux cames et regardez si les servomoteurs tournent correctement.

Vérifiez que les servomoteurs que vous avez utilisés ne consomment pas trop de courant par rapport à ce que peut délivrer la sortie 5 V de la carte Arduino ; au besoin, alimentez les servomoteurs avec une alimentation à part.

Une des deux barrières ne bouge pas

Vérifiez le fonctionnement de son servomoteur et que rien ne bloque la transmission mécanique.

Tout fonctionne sauf le son

Vérifiez que la carte Arduino du module sonore est bien alimentée (sa LED ON doit être allumée) et vérifiez les connexions avec la carte Uno de commande du PN.

Lors de l’initialisation de la carte Arduino du module sonore, vous devez entendre la sonnerie durant trois secondes ; est-ce le cas ?

Vérifiez les connexions du DFPlayer avec la carte Arduino du module sonore.

Vérifiez que vous avez bien inséré la carte SD et que celle-ci contient bien un fichier audio au format MP3.

Si cela ne fonctionne toujours pas, branchez la carte Arduino du module sonore à votre ordinateur, ouvrez le moniteur et regardez les messages envoyés par DFPlayer ; ils vous permettront de comprendre d’où peut venir le problème.

J’entends la sonnerie durant trois secondes, puis plus rien

Vérifiez la sortie son de la carte Arduino de commande du PN en branchant une LED entre cette sortie et la masse (GND) ; cette LED doit être allumée lorsque la sonnerie doit jouer.

Vérifiez alors la connexion de cette sortie son avec le module sonore.

Si vous entendez la sonnerie en reliant l’entrée 2 de la carte Arduino du module sonore à la masse (GND) de cette carte, alors le problème vient sans doute du coupleur optique ; remplacez-le.

Le fonctionnement de mon PN est erratique : un coup ça marche, puis ça ne marche plus

C’est certainement dû à des mauvais contacts dans le câblage. Vérifiez le câblage, les connecteurs Dupont utilisés. Remplacer les dominos d’électricien par de vraies soudures bien plus fiables.

Le programme ne veut pas se téléverser sur ma carte Arduino

Vérifiez que vous avez sélectionné le bon type de carte dans le menu Outils et que le port série utilisé est le bon ; au besoin, réglez ces paramètres.

Vérifiez que vous avez pensé à inclure la bibliothèque « LightDimmer » dans votre IDE ; sans cette bibliothèque, la compilation génère un message d’erreur (puisqu’il manque une « partie » du programme), ce qui empêche le téléversement.

Le programme a été modifié et depuis, plus rien ne marche

Visiblement, cette modification est la cause du dysfonctionnement. Il faut trouver pourquoi en demandant de l’aide sur notre forum.

Il est toujours possible de revenir en arrière, il suffit de téléverser à nouveau dans votre carte Arduino le programme publié dans cette série d’articles (ou l’avant dernière version que vous avez modifiée et qui fonctionnait).

Conclusion

Faire une recherche de panne n’a rien de compliqué, il suffit d’être méthodique. Souvent, on oublie de brancher quelque chose, parfois c’est un composant qui claque. Mais la plupart du temps, ce sont des mauvais contacts dus à des liaisons mal serrées ou à de mauvaises soudures. Le problème peut aussi se cacher derrière quelque chose qu’on ne remet pas en cause parce qu’on est persuadé d’avoir bien fait ; par exemple, vous êtes certain que votre carte SD contient bien un fichier MP3 car vous avez vous-même fait la copie de ce fichier mais êtes vous certain que cette copie n’a pas corrompu votre fichier ? Le diable se cache parfois dans les détails !

Ce montage n’est pas seulement un montage électronique ; il y a aussi une partie de pure mécanique qui peut gripper ou casser, mais ce genre de panne n’arrive qu’au bout d’un certain temps de fonctionnement. Par exemple, un élastique peut devenir cassant avec le temps. Il est donc important de bien surveiller les organes mécaniques de ce passage à niveau.

Enfin rassurez-vous : les montages bien construits peuvent aussi fonctionner parfaitement et ne jamais connaître de panne !

35 Messages

Réagissez à « Passage à niveau géré par Arduino (5) »

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

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment concevoir rationnellement votre système

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

La compilation d’un projet Arduino

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Ces tableaux qui peuvent nous simplifier le développement Arduino

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Processing pour nos trains

Arduino : toute première fois !

Démarrer en Processing (1)

TCOs en Processing (1)

TCOs en Processing (2)

Comment réussir son projet Arduino

Comment utiliser Arduino sans apprendre à programmer ?

Du sketch à l’exécutable

Programmer vos Arduino avec un fichier hexadécimal

L’assembleur (1)

L’assembleur (2)

L’assembleur (3)

L’assembleur (4)

L’assembleur (5)

L’assembleur (6)

L’assembleur (7)

L’assembleur (8)

L’assembleur (9)

Le monde des objets (1)

Le monde des objets (2)

Le monde des objets (3)

Le monde des objets (4)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Piloter son Arduino avec son navigateur web et Node.js (1)

Piloter son Arduino avec son navigateur web et Node.js (2)

Piloter son Arduino avec son navigateur web et Node.js (3)

Piloter son Arduino avec son navigateur web et Node.js (4)

Les derniers articles

L’assembleur (9)


Christian

Comment utiliser Arduino sans apprendre à programmer ?


Christian

L’assembleur (8)


Christian

L’assembleur (7)


Christian

L’assembleur (6)


Christian

L’assembleur (5)


Christian

L’assembleur (4)


Christian

L’assembleur (3)


Christian

L’assembleur (2)


Christian

L’assembleur (1)


Christian

Les articles les plus lus

Les interruptions (1)

Les Timers (I)

Instructions conditionnelles : le if … else

Calculer avec l’Arduino (1)

Ces tableaux qui peuvent nous simplifier le développement Arduino

Comment gérer le temps dans un programme ?

Les Timers (II)

Les Timers (III)

Installation de l’IDE Arduino

Instructions conditionnelles : le switch … case