Depuis le premier article, notre passage à niveau a bien évolué et il joue pleinement son rôle en retenant la circulation routière lorsqu’un train passe. Il lui manque pourtant un élément que nous allons rajouter aujourd’hui : la sonnerie. Nous utiliserons un lecteur DFPlayer Mini pour reproduire le son comme nous l’avions fait dans l’article Annonces en gare avec la RFID.
Passage à niveau géré par Arduino
Passage à niveau géré par Arduino (4)
La sonnerie
.
Par :
DIFFICULTÉ :★★☆
Nous vous renvoyons donc vers cet article pour plus de détails sur le lecteur et la façon de le mettre en œuvre puisque nous nous sommes inspirés du montage de cet article pour réaliser la partie son de notre PN.
La figure 1 montre comment relier le DFPlayer à la carte Arduino ; il est alimenté en 5 V et deux fils seulement sont utilisés pour faire la liaison avec la carte Arduino (les sorties 10 et 11) grâce à la bibliothèque SoftwareSerial qui fait partie de l’IDE d’Arduino. Le son est produit par un petit haut-parleur de 3 W maximum mais il est possible d’utiliser une paire d’enceintes pour ceux qui veulent la stéréo. Pour reproduire la sonnerie du PN, il suffit de lire un fichier son au format MP3 stocké sur une carte micro-SD.
- Figure 1
- Raccordement du Player à une carte Uno (extraite du site de DFRobot)
Ce lecteur a besoin de la bibliothèque DFRobotDFPlayerMini qui devra donc être installée dans l’IDE : on la trouve grâce au gestionnaire de bibliothèque.
L’idée première était donc de rajouter ce montage sur le montage de notre PN puisque les sorties 10 et 11 ne sont pas utilisées, mais ceci perturbait la fréquence de clignotement des feux de PN. Un remplacement des sorties 10 et 11 par les sorties 7 et 12, non utilisées et ne donnant pas de PWM n’y fit rien ; visiblement nous étions face à une incompatibilité entre les bibliothèques utilisées. Vu que le prix d’une carte Uno est aujourd’hui dérisoire, nous avons adopté comme solution de déporter la fonction son sur une deuxième carte Uno, commandée par la première. Cette solution a aussi l’avantage d’une maintenance plus facile : on peut perdre la fonction son sans pour autant perdre tout le PN. De plus, ce module son, constitué d’une carte Uno (ou Nano) et d’un DFPlayer Mini, peut être utilisé pour jouer d’autres ambiances sonores (un train qui siffle à l’entrée d’un tunnel pour prévenir d’éventuels ouvriers, des annonces en gare, etc.), mais il faut se rappeler qu’il est impossible de jouer plusieurs fichiers son en même temps ! Enfin, un autre avantage est que ce module son peut être remplacé par un module déjà en votre possession comme le module sonore Séries 100 ou 200 d’AVT Products (en vente chez LR-Modélisme).
Modification du programme de PN
Nous allons donc utiliser la sortie 7 pour créer une sortie son qui commande la carte son par son état haut. Pour la mise au point du programme, une simple LED permet de contrôler à quel moment cette sortie est active à l’état haut. En fait, la sonnerie doit retentir depuis le début du clignotement des feux de PN jusqu’à la fin du mouvement fermant les barrières. En dehors de cette phase, la sonnerie ne doit jamais être active.
On introduit une variable booléenne appelée etatSon qui vaut false si le son n’est pas commandé (sortie 7 à l’état bas) et qui vaut true si le son est commandé (sortie 7 à l’état haut). La sortie 7 commandera ultérieurement la carte son par l’intermédiaire d’un coupleur optique. C’est assez facile de mettre etatSon à false lorsqu’ etatZone est également false (zone non occupée). Par contre, lorsque la zone est occupée (etatZone = true), etatSon devient égale à true puis redevient égale à false dès que le mouvement des barrières est terminé. L’état de la sortie 7 est mis à jour à chaque itération de la fonction loop() en fonction de la valeur etatSon.
Voici donc le nouveau programme :
/*******************************************************************************
* PN_TIB_FeuBarrieresAttente_InitFerme_SortieSon.ino
* *****************************************************************************
* Programme developpe pour le projet de PN pour Train In Box.
* Il prend en compte l arrivee du train, le clignotement des feux en simulant
* une ampoule a filaments, un delai de 0 a 8 secondes avant mouvement des
* barrieres, le mouvements des deux barrieres sur 90° d amplitude (depend de
* la transmission adoptee).
* Le programme s'initialise barrieres fermees, donc AVEC TRAIN EN GARE SUR TIB.
* La LED_SON est allumee tant que sonnerie doit jouer ; cette sortie commande
* le module sonore.
* *****************************************************************************
* Christian BEZANGER - 13 Novembre 2018 - 2 Juin 2019 - 29 mai 2020
******************************************************************************/
#include <LightDimmer.h> // Bibliotheque pour gerer les feux du PN
#include <Servo.h> // Bibliotheque pour gerer les barrieres du PN
const byte ILS=2; // entree des capteurs
const byte LED=6; // sortie PWM des feux du PN
const byte LED_SON=7; // sortie pour indiquer sonnerie
const byte S1=4; // sortie pour le servomoteur 1
const byte S2=8; // sortie pour le servomoteur 2
unsigned int compteur = 1; // compteur d evenements (survol ILS)
// Variables utilisateur pour reglage du mouvement des barrieres
// -------------------------------------------------------------
unsigned long delaiFermeture = 0; // Regle le delai entre clignotement LED
// et fermeture barrieres - entre 2000 et 8000 mais 0 sur TIB (pas de delai)
int speedServo = 30; // Regle la vitesse de mouvement des barrieres
// Variables non utilisateur
// -------------------------
volatile static boolean etatZonePN = true; // true si la zone du PN est occupee
volatile static boolean old_etatZonePN = false; // etat anterieur de la zone
volatile static unsigned long old_top_debutISR; // Date anterieure d appel ISR
unsigned long old_top = 0; // variable pour afficher donnees utiles
int posServo = 90; // position courante a initialiser imperativement FERMEE
int posOuvert = 0; // barriere a la verticale
int posFerme = 90; // barriere a l'horizontale (90° de la verticale)
unsigned long topAttente = 0; // top pris au début franchissement de la zone PN
boolean etatSon = false; // true si sonnerie doit retentir
// Instanciations
LightDimmer feuPN;
Servo servo1;
Servo servo2;
void changeEtat() { // routine d'interruption (ISR)
unsigned long top_debutISR = millis(); // date appel ISR
if((top_debutISR - old_top_debutISR) > 2000) {
// 2 secondes au moins entre execution ISR
etatZonePN = !etatZonePN; // etat passe a etat oppose
old_top_debutISR = top_debutISR; // initialisation date anterieure d appel ISR
}
} // fin de ISR
void setup() {
// put your setup code here, to run once:
Serial.begin(115200); // communication avec le moniteur
pinMode (ILS, INPUT_PULLUP); // entree capteur
pinMode (LED_BUILTIN, OUTPUT); // LED du module allumee si Zone PN occupee
pinMode (LED, OUTPUT); // sortie pour feux du PN
pinMode (LED_SON, OUTPUT);
attachInterrupt (digitalPinToInterrupt(ILS), changeEtat, FALLING);
digitalWrite (LED_BUILTIN, LOW);
feuPN.begin(LED, HIGH); // LED s'allume avec etat haut
servo1.attach(S1);
servo2.attach(S2);
// initialisation des barrieres en position fermee
servo1.write(posFerme); // barriere 1 FERMEE apres initialisation
servo2.write(posFerme); // barriere 2 FERMEE apres initialisation
delay(2000);
digitalWrite (LED_BUILTIN, HIGH); // Indique fin de setup
} // fin de setup
void loop() {
// put your main code here, to run repeatedly:
if(etatSon == false) {digitalWrite (LED_SON, LOW);}
if(etatSon == true) {digitalWrite (LED_SON, HIGH);}
if(etatZonePN == false) {
old_etatZonePN = etatZonePN;
digitalWrite (LED_BUILTIN, LOW); // eteint LED de controle de la zone PN
etatSon = false; // pas de sonnerie
feuPN.stopBlink(); // arrete le clignotement
feuPN.off(); // eteint les feux
// ouverture barriere
if(posServo > posOuvert) {
posServo = posServo - 1;
servo1.write(posServo);
servo2.write(posServo);
delay(speedServo);
} // fin du test sur position des servos
} // fin du test sur etat de la Zone du PN -> false
if(etatZonePN == true) {
if(etatZonePN != old_etatZonePN) {
topAttente = millis(); // prend un top d'entree dans zone PN
old_etatZonePN = etatZonePN;
etatSon = true; // sonnerie
} // fin du deuxieme if
digitalWrite (LED_BUILTIN, HIGH); // allume LED de controle de la zone PN
feuPN.startBlink(); // commence le clignotement
// fermeture barriere après attente
if(millis() - topAttente > delaiFermeture) {
if(posServo <= posFerme) {
posServo = posServo + 1;
servo1.write(posServo);
servo2.write(posServo);
if(posServo >= 89) {etatSon = false;}
delay(speedServo);
} // fin du test sur position des servos
} // fin du test sur delai avant ouverture
} // fin du test sur etat de la Zone du PN -> true
LightDimmer::update();
if(old_top_debutISR != old_top) { // Affichage pour chaque nouveau survol ILS
Serial.print(compteur);
Serial.print(" ");
Serial.print(old_top_debutISR);
Serial.print(" ");
Serial.println(old_top_debutISR - old_top);
old_top = old_top_debutISR;
compteur = compteur + 1;
}
} // fin de loopDans ce nouveau programme, à la ligne 28, la variabledelaiFermeturequi règle le délai entre le début de clignotement des feux et le début de mouvement de fermeture des barrières, est initialisée à 0 car ce programme est livré pour le réseau TIB qui est un petit réseau. Pour un réseau avec de grands cantons, ce délai peut être réglé entre 2 et 8 secondes, ce dernier chiffre correspondant à la réalité. N’oubliez pas de régler cette variable en fonction des caractéristiques de votre réseau.
Montage avec le module son
La figure 2 montre comment raccorder notre module son à la carte de commande du passage à niveau.
- Figure 2
- Raccordement du module son à la carte de commande du PN via un coupleur optique 4N35
On utilise un coupleur optique 4N35 (ou équivalent) dont la LED est alimentée par la sortie 7 de la carte de commande du PN à travers une résistance de limitation de courant de 1 kΩ. Lorsque cette LED est allumée, le transistor est passant et l’entrée 2 de la carte Uno du module son est reliée à la masse. Ce coupleur optique permet une isolation galvanique des deux cartes Arduino.
Programme du module son
Le programme est inspiré d’un programme de démonstration donné sur le site du constructeur DFRobot, modifié selon nos besoins. Le principe consiste à surveiller les changements d’état de l’entrée 2 sur laquelle est installé le coupleur optique. Tant que le transistor du coupleur optique n’est pas passant, cette entrée est à l’état haut car elle a été initialisée en INPUT_PULLUP. Lorsque la sortie son (sortie 7) de la carte de commande du PN est à l’état haut, la LED du coupleur optique est allumée et le transistor devient passant : l’entrée est alors à l’état LOW. Un changement d’état de cette entrée de HIGH vers LOW commande la lecture du fichier son et un changement d’état de cette entrée de LOW vers HIGH arrête cette lecture. La carte PN provoque un événement (faut-il ou non du son ?) et l’information est envoyée à la carte son, ce qui provoque un changement d’état de l’entrée. On surveille donc les changements d’état de l’entrée et lorsqu’ils ont lieu, on regarde l’état de l’entrée qui indique l’opération à réaliser (produire du son ou l’arrêter).
Le programme commence par instancier un objet appelé myDFPlayer à partir de la bibliothèque DFRobotDFPlayerMini. Pour commander la lecture du fichier son, nous utilisons la fonction myDFPlayer.play(1) qui lit le premier fichier son de la carte micro-SD (cette carte n’a d’ailleurs pas besoin d’avoir plusieurs fichiers pour notre application). Pour arrêter la lecture du fichier son, on utilise la fonction myDFPlayer.stop() (ici pas besoin de préciser le numéro du fichier audio, c’est celui en cours de lecture qui est arrêté).
/*********************************************************
PNA_CommandeSonnerie
---------------------------------------------------------
Ce programme commande la sonnerie du PN selon les
changements d'etat de l'entree entreeCommande
De HIGH -> LOW : joue sonnerie
De LOW -> HIGH : arrete sonnerie
---------------------------------------------------------
Christian BEZANGER - mai 2020
Programme dans le domaine public
********************************************************/
#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
SoftwareSerial mySoftwareSerial(10, 11); // RX, TX
DFRobotDFPlayerMini myDFPlayer;
void printDetail(uint8_t type, int value);
const byte entreeCommande = 2; // entree commandee par carte PN
const int volumeSon = 25; // volume du son entre 0 et 30 (a regler)
int etatEntree = HIGH; // etat courant de l entree de commande
int old_etatEntree = HIGH; // etat précedent de l entree de commande
void setup()
{
pinMode (entreeCommande, INPUT_PULLUP); // inactive a etat HIGH
mySoftwareSerial.begin(9600);
Serial.begin(115200);
Serial.println();
Serial.println(F("DFRobot DFPlayer Mini Demo"));
Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));
if (!myDFPlayer.begin(mySoftwareSerial)) { //Use softwareSerial to communicate with mp3.
Serial.println(F("Unable to begin:"));
Serial.println(F("1.Please recheck the connection!"));
Serial.println(F("2.Please insert the SD card!"));
while(true);
}
Serial.println(F("DFPlayer Mini online."));
myDFPlayer.volume(volumeSon); // Regle le volume entre 0 et 30
myDFPlayer.play(1); // Joue 3 secondes de sonnerie pour controle
delay(3000);
myDFPlayer.stop(); // fin initialisation
}
void loop()
{
etatEntree = digitalRead(entreeCommande); // lecteure de l entree
if(etatEntree != old_etatEntree) {
// il y a eu changement d etat
if(etatEntree == LOW) {
myDFPlayer.play(1); // on joue la sonnerie
} // fin etatEntree LOW
if(etatEntree == HIGH) {
myDFPlayer.stop(); // on arrete la sonnerie
} // fin etatEntree HIGH
} // fin de comparaison
old_etatEntree = etatEntree;
// fin de traitement
// Imprime eventuellement des messages d erreur ou d etats du DFPlayer
if (myDFPlayer.available()) {
printDetail(myDFPlayer.readType(), myDFPlayer.read());
}
}
void printDetail(uint8_t type, int value){
switch (type) {
case TimeOut:
Serial.println(F("Time Out!"));
break;
case WrongStack:
Serial.println(F("Stack Wrong!"));
break;
case DFPlayerCardInserted:
Serial.println(F("Card Inserted!"));
break;
case DFPlayerCardRemoved:
Serial.println(F("Card Removed!"));
break;
case DFPlayerCardOnline:
Serial.println(F("Card Online!"));
break;
case DFPlayerPlayFinished:
Serial.print(F("Number:"));
Serial.print(value);
Serial.println(F(" Play Finished!"));
break;
case DFPlayerError:
Serial.print(F("DFPlayerError:"));
switch (value) {
case Busy:
Serial.println(F("Card not found"));
break;
case Sleeping:
Serial.println(F("Sleeping"));
break;
case SerialWrongStack:
Serial.println(F("Get Wrong Stack"));
break;
case CheckSumNotMatch:
Serial.println(F("Check Sum Not Match"));
break;
case FileIndexOut:
Serial.println(F("File Index Out of Bound"));
break;
case FileMismatch:
Serial.println(F("Cannot Find File"));
break;
case Advertise:
Serial.println(F("In Advertise"));
break;
default:
break;
}
break;
default:
break;
}
}Ce programme est à téléverser dans la carte Arduino du module son ; au préalable, pensez à modifier la valeur de volumeSon pour augmenter ou baisser le volume sonore.
L’alimentation du module son se fait par le câble USB et une prise de smartphone, comme préconisé pour la carte de commande du PN. Bien évidemment d’autres solutions d’alimentation sont possibles et ont été décrites sur ce site.
Vous trouverez ci-dessous un fichier son au format MP3 d’une durée de 15 secondes, ce qui est bien suffisant pour nos réseaux.
Sonnerie du PN
Sonnerie_PN
Cette série d’articles pourrait se terminer ici puisque nous avons reproduit le fonctionnement complet d’un passage à niveau automatique SAL 2. Néanmoins, je vous donne rendez-vous pour un cinquième et dernier article où nous verrons quelques améliorations possibles et comment dépanner ce montage s’il ne fonctionne pas du premier coup.
14 Messages
-
Passage à niveau géré par Arduino (4) 23 novembre 2020 12:06, par Frédéric
Bonjour,
Un grand merci pour ces 4 articles très didactiques qui montrent bien l’évolution d’un projet par ajout de fonctions successives
Pour ma part j’avais posté un message il y a quelques semaines ( Un automatisme de Passage à Niveau 29 octobre 19:48, par Frédéric ) pour vous rapporter mon expérience personnelle d’un PN avec le problème du rajout du son sur lequel j’ai buté un bon moment. J’ai finalement réglé le problème en utilisant une carte MEGA à la place d’une carte UNO, en affectant une sortie native dédiée Serial2 (4 sorties séries disponibles sur la MEGA au lieu d’une) pour le pilotage du module DFPlayer mini avec la même bibliothèque que celle que vous utilisez (DFRobotDFPlayerMini en version 1.05). Ceci afin d’éviter les fluctuations que j’avais sur la commande des 2 servos avec une UNO et la librairie SoftwareSerial
(je n’avais pas d’effet de bord sur le pilotage des LED mais je n’avais pas programmé l’allumage progressif, juste un clignotement)
Je suis d’ailleurs un peu frustré de n’avoir pas identifié d’où venait vraiment le problème
Merci également pour l’idée de l’usage d’un optocoupleur 4N35 pour l’interconnexion avec isolation galvanique des 2 UNOFrédéric
-
Bonjour Frédéric,
Merci pour vos appréciations.
Si je n’ai pas utilisé une carte Mega, c’est justement parce que je voulais que ce kit de passage à niveau puisse être réalisé au moindre coût et essentiellement par des gens qui débutent. Finalement, comme je rajoute une deuxième carte Uno pour la partie son, l’argument prix n’est peut-être pas aussi justifié que je le croyais. D’après mes calculs, ce module son reviendrait à un peu moins de quinze euros (prix 2020).
La bibliothèque DFPlayer perturbe les bibliothèques déjà employées dans le projet, d’où l’idée d’un module indépendant qui peut d’ailleurs être ajouté ultérieurement.
Pour ma part, je réponds toujours aux questions posées (sauf si un autre membre du staff l’a fait avant moi). Je viens de vérifier votre question qui s’adresse à Dominique, un des co-auteurs de l’article en question ; il a dû louper cela et je vais lui faire suivre car je suis certain qu’il vous répondra.
-
-
Passage à niveau géré par Arduino (4) 24 novembre 2020 17:44, par Frédéric
Bonjour Christian,
Merci pour votre retour. Pour le premier post, l’idée c’était juste de vous faire partager ma démarche, il est en effet très difficile à distance de faire une quelconque investigation sans avoir tout le détail de ce qui a été implémenté. Il est d’ailleurs intéressant de voir que pour un même objectif, les solutions peuvent être assez différentes. Pour le réseau G de ma fille j’ai un peu de place pour intégrer l’électronique dans une maison de type garde barrière attenante au PN qu’il me faut encore finaliser pour cacher l’électronique
La carte Mega (clone d’origine chinoise) est peu couteuse (j’ai choisi une elegoo 14€ sur amazon et encore moins cher 5€ sur ali express ...)
Pour le défaut constaté, je pense que le problème vient de la gestion virtuelle du port série avec la librairie softwareserial ; ce qui explique que sur la mega je n’ai pas d’effet de bord sur les mouvements des servos en affectant une sortie série hardware pour piloter le Dfplayer Mini(la serial 2/4) ; je pense que c’est purement un problème logicielPar contre, et je ne sais pas si c’est lié à l’origine de la carte (clone), le programme ne se lance pas seul, il faut l’activer avec le bouton reset pour qu’il s’exécute dans la boucle loop(en mode alim autonome, carte non connectée au port USB du PC). Ce n’est pas un problème puisqu’il existe plusieurs solutions pour contourner ce problème mais c’est un peu ch... Sur la DUE le problème est clairement référencée sur certains forum avec certains clones chinois (modif de la carte à réaliser), sur la mega je n’ai rien trouvé de tangible. Pendant la mise au point je ne m’en étais pas aperçu puisque fonctionnant normalement après chaque téléversement à partir de l’IDE Arduino. Si vous avez une idée je suis preneur
Comme quoi plus on creuse plus on trouve, et plus on trouve plus on creuse ...
Bonne soirée
Frédéric
-
L’inconvénient des cartes clones, c’est qu’elles ont parfois de petites différences dans le fonctionnement, dues à des composants qui ne sont pas les mêmes que sur les cartes de marque Arduino. Un avantage, elles sont moins chères. Parfois, pour s’en sortir, il faut arpenter les forums pour glaner des informations, comme vous l’avez fait.
Difficile pour moi de donner une idée sans expérimenter. mais à défaut d’idée, j’ai une proposition à vous faire : vous semblez avoir déjà un bon niveau et une certaine indépendance pour la résolution de problèmes, donc pourquoi ne pas rejoindre l’équipe d’Arduino pour éventuellement écrire des articles sur les projets que vous avez développés ? Ca ne rapporte rien, mais ça ne coûte rien non plus sauf un peu de votre temps. Et c’est utile pour tous les lecteurs. A vous de voir, c’est sans obligation.
Cordialement.
Christian -
-
Bonjour,
Merci pour cette information, je vais étudier cette solution pour l’adapter sur ma carte MEGAFrédéric
-
-
-
Passage à niveau géré par Arduino (4) 14 décembre 2021 11:49, par meunier
bonjour
je me retrouve devant un problème : à la fin de la lecture d’un fichier (envoyé par poussoir), le dfplayer n’envoie pas le message "finished" dans le moniteur série.
par contre si je lance le fichier deux fois (deuxième appui poussoir avant la fin de lecture), alors là il envoie le message "finished".
le détail du problème sur le forum arduino. merci de votre aide. je galère pas mal. (suis débutant)Voir en ligne : Régis Meunier
-
Pour faire le montage du PN, je ne me suis pas penché en détail sur la bibliothèque du DFPlayer. Sans en être certain, le comportement que vous avez décrit est peut-être le comportement normal, à savoir le message ne s’affiche que si le morceau est interrompu et non lorsqu’il est joué jusqu’au bout. Ceci expliquerait ce qui se passe quand vous appuyez deux fois sur le bouton "Play".
Pour ce qui concerne la sonorisation du PN, deux choses sont importantes :- que la sonnerie s’exécute dès détection d’un train
- qu’elle s’arrête dès que les barrières sont fermées
Et justement, cela marche, alors j’avoue que je n’ai pas regardé en détail ce qui est affiché comme message dans le moniteur. Si j’ai laissé ces lignes dans mon programme, c’est pour comprendre en cas de dysfonctionnement, mais comme le PN réagit bien, pas besoin. Il faut remarquer que les messages qui peuvent s’afficher sont des messages d’erreur. Interrompre un morceau est considéré comme une erreur mais le jouer jusqu’au bout non. Mais ce n’est qu’une hypothèse.
Vous pouvez essayer de contacter l’équipe qui maintient la bibliothèque pour en savoir plus sur le fonctionnement de celle-ci. Mais est-ce si important d’avoir le message ? Ce qui compte est le comportement du lecteur, non ? A moins que vous n’ayez des besoins très particuliers dans votre projet.
-
-
Passage à niveau géré par Arduino (4) 13 mai 2022 09:06, par pedro88
bonjour
comment puis-je retarder la descente des barrières (1sec), car ce circuit fonctionne à merveille et je vous remercie pour ce programme.
merci de me répondreVoir en ligne : jean pierre deveau
-
merci pour votre réponse
-
-
Passage à niveau géré par Arduino (4) 13 mai 2022 17:48, par msport
Bonjour, avez vous vu dans l’article l’avertissement concernant à la ligne 28, la variable delaiFermeture ?
Cordialement -
Passage à niveau géré par Arduino (4) 6 décembre 21:21, par Taupier
quand je vérifie le programme sonnerie celui bloque à le ligne 3
-
Je viens de vérifier ce programme avec l’IDE 2.3.4 (le plus récent) et il compile parfaitement pour une carte Uno R3.
Si le vôtre bloque, c’est certainement que vous avez changé quelque chose ou bien que vous n’avez pas copié correctement ce programme (il peut manquer un caractère par exemple).
Par curiosité, je l’ai aussi vérifié avec l’IDE 1.8.19 et il compile parfaitement.
Dans les deux cas, même résultat : 5278 octets pour le programme et 288 octets pour les variables.
Refaites un copier-coller du programme en utilisant la touche spéciale qui apparait dans la fenêtre programme, coller le programme dans votre IDE et vérifiez à nouveau : cela devrait marcher. -
Ce que j’ai dit au-dessus est valable pour le premier programme de l’article.
Si vous parliez du deuxième, celui-ci compile aussi parfaitement et on obtient 5434 octets de programme et 357 octets de données.
-