Auteur Sujet: Boite de mesure de vitesse Arduino  (Lu 3040 fois)

Escargot

  • Newbie
  • *
  • Messages: 14
    • Voir le profil
    • Le Train d'Enfer
Re : Boite de mesure de vitesse Arduino
« Réponse #15 le: novembre 25, 2020, 09:34:12 am »
Bonjour,

Nous n'avons pas réussi à trouver la liste et la description des fonctions disponibles dans une librairie  ::) C'est où ?
Président du Train d'Enfer de Franconville
Président d'Union Rail 95

msport

  • Hero Member
  • *****
  • Messages: 1295
  • HO avec DCC++ en DIY Réseaux très éphémères
    • Voir le profil
Re : Boite de mesure de vitesse Arduino
« Réponse #16 le: novembre 25, 2020, 10:03:54 am »
LiquidCrystal_I2C.cpp

https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library/blob/master/LiquidCrystal_I2C.cpp

C:\Users\Michel\Documents\Arduino\libraries\LiquidCrystal_I2C
Cordialement

Thierry

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 648
    • Voir le profil
Re : Boite de mesure de vitesse Arduino
« Réponse #17 le: novembre 25, 2020, 10:04:33 am »
Il n'y a pas de liste des fonctions disponibles. Soit le créateur de la librairie met une doc à disposition comme je le fais (comme dans DCCpp, Commanders, Accessories, etc...), soit il faut regarder dans le fichier .h principal pour savoir de quoi il retourne.

Escargot

  • Newbie
  • *
  • Messages: 14
    • Voir le profil
    • Le Train d'Enfer
Re : Boite de mesure de vitesse Arduino
« Réponse #18 le: décembre 10, 2020, 12:19:58 pm »
Bonjour,

J'ai du mieux, j'en suis là  :D

Président du Train d'Enfer de Franconville
Président d'Union Rail 95

Thierry

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 648
    • Voir le profil
Re : Boite de mesure de vitesse Arduino
« Réponse #19 le: décembre 10, 2020, 01:39:10 pm »
Bravo, c'est sympa.

Escargot

  • Newbie
  • *
  • Messages: 14
    • Voir le profil
    • Le Train d'Enfer
Re : Boite de mesure de vitesse Arduino
« Réponse #20 le: janvier 04, 2021, 01:13:42 pm »
Bonjour,

Bonne année, je vous souhaite de pouvoir retourner dans vos clubs dès que possible, ça devient long  :'(

Petit message pour vous dire que le projet est presque prêt :D Nous sommes maintenant en mesure de faire tous les réglages de base des CV 5-6, 3 et 4 mais en plus, de communiquer avec TrainController ce qui permet de faire la calibration des crans de vitesse des motrices dans TC en moins de 5 mn ;D Les test sont très concluants, précis au 100è de km/h à l'échelle, que du bonheur pour le pilotage automatique ou semi automatique d'un réseau.

Je vais bientôt mettre en ligne les pages dédiées sur notre site web, encore quelques détails à régler  ;)
Président du Train d'Enfer de Franconville
Président d'Union Rail 95

Escargot

  • Newbie
  • *
  • Messages: 14
    • Voir le profil
    • Le Train d'Enfer
Re : Boite de mesure de vitesse Arduino
« Réponse #21 le: janvier 25, 2021, 07:21:11 pm »
Bonjour,

Je vous présente mon concept de mesure de vitesses  ;D . Hyper précis, permettant les réglages des CV 2, 5 et 6 par lecture directe de la vitesse ainsi que les 3 et 4 par mesure de la distance parcourue en réel et au 87è.
Compatible avec TrainController V9 pour le calibrage des crans de vitesse :D.

https://traindenfer95.wixsite.com/accueil/conceptdemesure

Concept déposé auprès de FIDEALIS, reproduction pour commercialisation non autorisé  ;)
« Modifié: janvier 25, 2021, 10:36:18 pm par Escargot »
Président du Train d'Enfer de Franconville
Président d'Union Rail 95

Escargot

  • Newbie
  • *
  • Messages: 14
    • Voir le profil
    • Le Train d'Enfer
Re : Boite de mesure de vitesse Arduino
« Réponse #22 le: mars 23, 2021, 12:02:23 pm »
Bonjour,

Visiblement ce sujet ne fait pas recette :( mais bon, pas grave ;)

Juste pour info à ceux qui ont suivi, nous avons ajouté une nouvelle fonction : Le temps de passage sur une distance de 98cm
Cela permet de mesurer les temps de passage aux différents crans de vitesse pour le paramétrage des UM et autres triplettes dans l'application Z21 de ROCO entre autre.

 ;D
Président du Train d'Enfer de Franconville
Président d'Union Rail 95

msport

  • Hero Member
  • *****
  • Messages: 1295
  • HO avec DCC++ en DIY Réseaux très éphémères
    • Voir le profil
Re : Boite de mesure de vitesse Arduino
« Réponse #23 le: mars 23, 2021, 05:12:10 pm »
Bonjour,
il est possible que parmi les lecteurs de Locoduino, il n'y ait pas beaucoup d'utilisateurs de Train Controller, qui semble la première cible de ce projet, certes intéressant en soi.
Par ailleurs, il y a une partie mécanique incontournable qui rend la réalisation délicate.
Cordialement
Cordialement

Dominique

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 2287
  • 100% Arduino et N
    • Voir le profil
Re : Boite de mesure de vitesse Arduino
« Réponse #24 le: mars 24, 2021, 10:50:09 am »
J'ai intégré une mesure de vitesse dans ma centrale DCC afin de déterminer les valeurs des crans correspondant aux vitesses 30, 60 et 90 km/h gérés par mon gestionnaire qui n'est pas RRTC, mais un Arduino !

J'en parle peut-être ici : https://forum.locoduino.org/index.php?topic=290.msg4005#msg4005
Cordialement.

La qualité des réponses est liée à la qualité des questions. Les Winners, c'est juste des Losers qui s'acharnent..

Jean-Luc

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1609
    • Voir le profil
Re : Re : Boite de mesure de vitesse Arduino
« Réponse #25 le: mars 24, 2021, 01:34:07 pm »
Visiblement ce sujet ne fait pas recette :( mais bon, pas grave ;)

Bonjour,

Par ici nous somme plutôt dans l'OpenHardware et l'OpenSource. Votre projet n'est ni l'un ni l'autre. Donc bon.

Après je comprends tout à fait que vous soyez dans une démarche commerciale mais à vrai dire j'ai du mal à trouver de l'intérêt pour votre projet n'ayant ni schéma ni code à me mettre sous la dent.

Cordialement
Cordialement

Marc-Henri

  • Full Member
  • ***
  • Messages: 148
    • Voir le profil
    • Modélisme ferroviaire & électronique
Re : Re : Re : Boite de mesure de vitesse Arduino
« Réponse #26 le: avril 01, 2021, 06:56:22 pm »
...Par ici nous somme plutôt dans l'OpenHardware et l'OpenSource....

Bonjour,

Je suis tout à fait d'accord avec ce point de vue. J'ajouterais que l'esprit de Locoduino inclut certainement aussi le partage de connaissances.

La démarche autour de ce projet me surprend. L'auteur commence par poser beaucoup de questions, jusqu'à demander si quelqu'un pourrait écrire le programme.
Ensuite il protège le concept élaboré avec l'aide des membres du forum. Par ailleurs, les conditions auxquelles on peut obtenir le système ne sont pas claires.

Bon week-end de Pâques.
« Modifié: avril 02, 2021, 09:01:13 am par Marc-Henri »

Escargot

  • Newbie
  • *
  • Messages: 14
    • Voir le profil
    • Le Train d'Enfer
Re : Boite de mesure de vitesse Arduino
« Réponse #27 le: avril 25, 2021, 12:51:32 pm »
Bonjour à tous,

Bon, il semble que je me sois mal expliqué sur mes intentions et que j'ai mis beaucoup trop de temps à venir partager les infos que j'avais, j'en suis navré  :-\

Sachez que ma démarche n'est pas commerciale, j'autorise les particuliers à s'inspirer et même à reproduire, mais j'ai pris le parti de protéger contre la commercialisation, ce n'est pas la même chose. A date, je n'en ai vendu que deux et n'espère pas en vendre beaucoup plus, je ne le fait que pour satisfaire les personnes qui en veulent une mais n'ont pas les connaissance pour le faire eux même. Pour la fabrication, c'est très artisanal, les composants se trouvent sur Ebay très facilement, la quincaillerie vient de Leroy-Merlin et certains éléments sont imprimés en PLA.
Il est tout à fait possible que ça fonctionne avec d'autre TCO que TCV9, mais je ne suis pas en mesure de tester.

N'étant pas moi même programmeur Arduino, je n'ai visiblement pas eu la bonne démarche de partage, j'espère que ce post rétablira un peu les choses.

Pour ceux que ça intéresse encore un peu, voici le code, qui a été écrit par un membre de mon club et pas du tout avec les informations glanées ici. Je partage d'ailleurs les petits bénéfices avec lui ;)
Le seul truc que nous ne sommes pas arrivé à faire, c'est de faire clignoter la LED verte lorsque la vitesse est stabilisée et ce, jusqu'à ce quel se fige allumée. Dans le meilleur des cas elle clignote une fois au début...

//Type de Carte: Adafruit ItsyBitsy 5V
//Port Com:
//Programmer: ArduinoISP

//  NOTE:  OK le 04/11/2020  sur impulsion Arduino 25ms/10ms/75ms --> 120km/h, 300km/h, 40km/h

// NOTE: v10 OK le 28/12/2020, sauf l'envoi vers TC:
//          - ne pas envoyer de 0
//          - envoyer la vitesse une seule fois qaund elle est stabilisée

/****************************************************************************************************************
https://learn.adafruit.com/introducting-itsy-bitsy-32u4/pinouts
https://letmeknow.fr/shop/fr/ecrans/185-afficheur-lcd-4-lignes-20-caracteres-bleu-i2c-4894479443361.html
https://www.arduino.cc/reference/en/language/functions/interrupts/interrupts/

https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/

 
Blink
D7: capteur input d

Pour les calculs, diamètre des rondelles => 5.88 cm
5.88 x 3.1416 = 18.472608 cm de circonférence
18.47 x 87 = 1606.89 cm => 16,0689 m réels

100km/h / HO <==> 1.15km/h
1.15km/h x 1000m/km / 3600s/h <=> 0.319m/s = 32cm/s

1 tour = 18.47cm
==> 100km/h <--> 1.7tr/s ???????
==> 1.7tr/s / 20 aimants => 1/(1,7 x20)= 29ms entre 2 aimants ??????

pulse 100ms = 2tr = 200km/h

120km/h / HO <==> 1.38km/h
1.38km/h x 1000m/km / 3600s/h <=> 0.38m/s = 38cm/s

==> 120km/h = 2tr/sec
2tr/sec / 20 aimant = 1sec/(2tr x 20 aimants) = 25ms

******************************************************************************************************************/
//======================================================================
// V1.5
// Add 2 LEDs:
// GREEN: flash when speed is stable
// YELLOW: ON when in Freeze
// Ajout du temps pour parcourir 1m a vitesse stabilisée.
//======================================================================

#define FALSE   false
#define TRUE    true
#define LED_BUILTIN 13
#define LED_VERT    8
#define LED_JAUNE   4

#define LED_OFF     0
#define LED_ON      1

#define CAPTEUR_IN_D7 7    // D7 also interrupt pin
#define CAPTEUR_IN_A0 A0

#define SW 11

#define SCL 3
#define SDA 2

#define SENSOR_ON   1
#define SENSOR_OFF  0
bool sensor_state = 0;

unsigned char sw_status, sw_state;
#define COUNT   0
#define FREEZ   1
#define CLEAR   2
#define END_FREEZ   3

//--- v12 ----
#define MIN_SERIAL_TEMPO    10000       // 5 sec = 5000 millisecond
#define MAX_SPEED_ERR       0.10        // 10%

volatile byte sense;
unsigned long ref_time, new_time, delta_t;
unsigned long lcd_time, lcd_new_time, ref_time_avg;
unsigned long serial_time, serial_new_time;           // PA v11

volatile unsigned long pulse_cnt = 0;
volatile unsigned long pulse_cnt_tot = 0;
float speed_i, speed_avg, speed_avg_lcd;               // vitesse instantannée entre 2 aimants, vitesse moyenne par tour, vitesse moyenne pour affichage
float serial_speed_avg, speed_avg_delta, speed_avg_delta_pos, speed_avg_delta_neg;                  // PA v11

//-------------------------------------------------------------------------------------
// Les 3 constantes suivantes sont à ajuster avec le systeme de mesure
//-------------------------------------------------------------------------------------
const float circonf_cm = 18.47;                 // Circonference de la roue de mesure en cm
const int nb_aimants = 20;                      // Nb d'aimants par circonference
const int scale = 87;                               // echelle HO

//------------------- NE pas modifier --------------------------------------------------
float circonf = (circonf_cm * scale) / 100;            // Circonférence réelle en m
float interval = circonf / nb_aimants;                 // Intervale entre 2 aimants en m.
float intervalHO = circonf_cm / nb_aimants;            // Intervale entre 2 aimants en cm.

//-------------------------------------------------------------------------------------
// La constante suivante est à ajuster en fonction de la distance voulue pour le calcul du temps (UM)
//-------------------------------------------------------------------------------------
const int UM_DIST = 98;                 // distance de mesure en cm


volatile float distance = 0;                    // distance parcourue
volatile float dist_avg = 0;
volatile float dist_tot = 0;
volatile float dist_totHO = 0;
float conv_kmh = 3.6;                           // 3600 sec / 1000m

int afield;

unsigned long debounce_time, new_debounce_time;
unsigned long sensor_time_rise, sensor_time_fall;
unsigned long time_UM, time_UM_new;
volatile float dist_UM;
bool fg_speed_stable, fg_UM_cnt, fg_UM_cnt_end;

unsigned long LED_VERT_Blink = 0;

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);               // set the LCD address to 0x27 for a 16 chars and 2 line display



// the setup function runs once when you press reset or power the board
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(LED_VERT, OUTPUT);
  pinMode(LED_JAUNE, OUTPUT);

  digitalWrite(LED_BUILTIN, HIGH);

  delay(100);
  int tempo = 20;
 
  Serial.begin(115200);
  while (tempo > 0) {
      delay(100);
      tempo--;
      if(Serial) tempo = 0;
    ; // wait for serial port to connect. Needed for native USB
  }
  digitalWrite(LED_BUILTIN, LOW);
  digitalWrite(LED_JAUNE, LED_OFF);
  digitalWrite(LED_VERT, LED_OFF);
 
   // initialize digital pin SWitch as an input.
  pinMode(SW, INPUT_PULLUP);
 
  // initialize digital pin CAPTEUR_D7 as an output.
  pinMode(CAPTEUR_IN_D7, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(CAPTEUR_IN_D7), sens_change, CHANGE); 
   
   
//  pinMode(CAPTEUR_IN_A0, AnalogInput);    // NO need to define analog pins


  afield = analogRead(CAPTEUR_IN_A0);

  lcd.init();                      // initialize the lcd
  lcd.init();
  // Print a message to the LCD.
  lcd.backlight();
  lcd.setCursor(0, 0);                       // (x, y)
  lcd.print(" La Box a Laurent J ");
  lcd.setCursor(0, 2);                       // (x, y)
  lcd.print("Vers 1.5  18-02-2021");
  lcd.setCursor(0, 3);                       // (x, y)
  lcd.print("  Circonf. 18.47cm  ");

  Serial.println(" La Box a Laurent J ");
  Serial.println("Vers 1.5  18-02-2021");

  delay(5000);

  ref_time = 0;
  distance = 0;
  dist_avg = 0;
  pulse_cnt = 0;
  ref_time_avg = 0;

  sw_status = COUNT;
  sw_state = 1;

  serial_speed_avg = 0;
  speed_avg_delta_pos = 1;
  speed_avg_delta_neg = 1;

  time_UM = 0;
  dist_UM = 0;
  fg_speed_stable = FALSE;
  fg_UM_cnt = FALSE;
  fg_UM_cnt_end = FALSE;
}

// the loop function runs over and over again forever
void loop() {
   if(sense > 0)
    {
    //digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)

    //new_time = millis();

    if(ref_time != 0)
      {
      delta_t = new_time - ref_time;
      speed_i = (3600 * sense * interval) / delta_t;       // vitesse instantanée en m/s
      }
   
    ref_time = new_time;

    sense = 0;

    if(ref_time_avg != 0)
        {
        speed_avg = (3600 * dist_avg)/(new_time - ref_time_avg);           // 3.6 = (3600 sec/h * 1000 ms/sec) / 1000m/km
        dist_avg = 0;                       // PA v10
        ref_time_avg = new_time;            // PA v10

        if (speed_avg != 0)
            {
            serial_speed_avg = (serial_speed_avg * 7) + speed_avg;        // PA V11: moyenne sur 8 echantillons
            serial_speed_avg = serial_speed_avg / 8;

            speed_avg_delta = speed_avg - serial_speed_avg;               // v11: calculate positiv and negativ delta
            if (speed_avg_delta < 0)
                {
                speed_avg_delta_neg = -speed_avg_delta;
                speed_avg_delta_neg = speed_avg_delta_neg / serial_speed_avg;     
                }
            else
                {
                speed_avg_delta_pos = speed_avg_delta;
                speed_avg_delta_pos = speed_avg_delta_pos / serial_speed_avg;
                }

            }
        else
            {
            serial_speed_avg = 0;

            speed_avg_delta_pos = 1;
            speed_avg_delta_neg = 1;
            }
        }
    else
        {
        ref_time_avg = new_time;
        }
    }

  lcd_new_time = millis();
  serial_new_time = lcd_new_time;        // v12

  if((lcd_new_time - lcd_time) > 1000)
    {

// PA 
    lcd.setCursor(0, 0);
    if(fg_UM_cnt_end == TRUE)
        lcd.print("Pls:      Temp:     ");
    else
        lcd.print("Pls:                ");
       
    lcd.setCursor(0, 1);
    lcd.print("Dist.en  m:         ");
    lcd.setCursor(0, 2);
    lcd.print("Dist.en km:         ");
    lcd.setCursor(0, 3);
    lcd.print("Vit.moy.:       km/h");

           
    lcd.setCursor(5, 0);
    lcd.print(pulse_cnt_tot);
     
    lcd.setCursor(15, 0);
    lcd.print((float)time_UM/1000);
     
    lcd.setCursor(13, 1);
    lcd.print(dist_totHO/100);
     
    lcd.setCursor(13, 2);
    lcd.print(dist_tot/1000);
     
    lcd.setCursor(10, 3);
    lcd.print(speed_avg);
     
 #ifdef DEBUG   
     Serial.print("pulse_cnt: ");
     Serial.print(pulse_cnt_tot);
     Serial.print("   - distance_avg (m): ");
     Serial.print(dist_avg);
     Serial.print("   - speed_avg (km/h): ");
#endif

// ------------- v11 --------------------------------
     if(serial_speed_avg != 0)
        {
        if((serial_new_time - serial_time) > MIN_SERIAL_TEMPO)
            {
/*            speed_avg_delta = speed_avg - serial_speed_avg;
            if (speed_avg_delta < 0)
                {
                speed_avg_delta_neg = -speed_avg_delta;
                speed_avg_delta_neg = speed_avg_delta_neg / serial_speed_avg;     
                }
            else
                {
                speed_avg_delta_pos = speed_avg_delta;
                speed_avg_delta_pos = speed_avg_delta_pos / serial_speed_avg;
                }
*/
            if((speed_avg_delta_pos < MAX_SPEED_ERR)  && (speed_avg_delta_neg < MAX_SPEED_ERR))
                {
                digitalWrite(LED_VERT, LED_ON);
                LED_VERT_Blink = 10;
                Serial.println(serial_speed_avg);                     // envoi serie pour TC
               
                serial_time = serial_new_time;
                   
                speed_avg_delta_pos = 1;
                speed_avg_delta_neg = 1;

                fg_speed_stable = TRUE;
                }
            else if ( LED_VERT_Blink > 0)
                {
                LED_VERT_Blink--;
                if (LED_VERT_Blink == 0)
                    {
                    digitalWrite(LED_VERT, LED_ON);
                    }
                else if (LED_VERT_Blink == 7)
                    {
                    digitalWrite(LED_VERT, LED_OFF);
                    }
                }
            else
                {
                digitalWrite(LED_VERT, LED_OFF);
                fg_speed_stable = FALSE;   
                }
            }
        }
     else
        {
        serial_time = serial_new_time;
        }
//------------------ v11 end -----------------------
     
     if (sw_status == COUNT)
        {
        speed_avg = 0;                                 // PA v10 à VERIFIER !!!! le 25-12-2020 
        }
     
     lcd_time = lcd_new_time;
     //ref_time_avg = 0;
     //dist_avg = 0;        // PA v10
     pulse_cnt = 0;
    }

if((digitalRead(SW) == 0) && (sw_state == 0))
    {
     sw_state = 1000;                // debounce
     if(sw_status == END_FREEZ)         // FREEZ --> CLEAR
        {
        sw_status = CLEAR;
        digitalWrite(LED_VERT, LED_ON);   
        digitalWrite(LED_JAUNE, LED_OFF);     
       
        dist_tot = 0; 
        dist_totHO = 0;
        pulse_cnt_tot = 0;
        speed_avg = 0;

        fg_speed_stable = FALSE;
        time_UM = 0;
        fg_UM_cnt = FALSE;
        fg_UM_cnt = FALSE;
        fg_UM_cnt_end = FALSE;
        }
     else if (sw_status == COUNT)
        {
        sw_status = FREEZ;   
        digitalWrite(LED_JAUNE, LED_ON);
        }
     }

else if(digitalRead(SW) == 1)
    {
    if (sw_state > 0)sw_state--;      // debounce
   
    else if(sw_status == CLEAR)         // CLEAR --> COUNT
        {
        sw_status = COUNT;
        digitalWrite(LED_VERT, LED_OFF);
        }
     else if (sw_status == FREEZ)
        {
        sw_status = END_FREEZ;
        //digitalWrite(LED_JAUNE, LED_OFF); 
        }
    }
}


void sens_change() {
  delayMicroseconds(100);      // debounce delay 10µs
  if(digitalRead(CAPTEUR_IN_D7) == 1)
    {
    sensor_time_rise = micros();
    if((sensor_time_rise - sensor_time_fall) > 2000) {        // if delay > 10ms
        if((sensor_state == SENSOR_OFF) && (sw_status == COUNT))
            {
            new_time = millis();
           
            sense++;
            pulse_cnt++;
            pulse_cnt_tot++;
            distance += interval;
            dist_avg += interval;
            dist_tot += interval;
            dist_totHO += intervalHO;
            sensor_state = SENSOR_ON;
            digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)

            if(fg_speed_stable == TRUE)
                {
                if(fg_UM_cnt == FALSE)
                    {
                    time_UM_new = new_time;
                    fg_UM_cnt = TRUE;
                    fg_UM_cnt_end = FALSE;
                    dist_UM = 0;
                    digitalWrite(LED_VERT, LOW);
                    }
                else if (dist_UM < UM_DIST)               // en cm
                    {
                    time_UM = new_time - time_UM_new;   
                    dist_UM += intervalHO;
                    }
                else
                    {
                    digitalWrite(LED_VERT, HIGH); 
                    fg_UM_cnt_end = TRUE; 
                    }
                }
            else
                {
                dist_UM = 0;
                //time_UM = 0;
                fg_UM_cnt = FALSE;
                if(fg_UM_cnt_end != TRUE)
                    {
                    dist_UM = 0;
                    time_UM = 0;
                    }
               
                //digitalWrite(LED_VERT, LOW);
                }
            }
        }
    }

  else                                        //    if(digitalRead(CAPTEUR_IN_D7) == 0)
    {
    if(sensor_state == SENSOR_ON)
        {
        sensor_time_fall = micros();
        if((sensor_time_fall - sensor_time_rise) > 2000) {        // if delay > 10ms
            sensor_state = SENSOR_OFF;
             digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
            }
        }
    }

}

Bonne journée ;)
Président du Train d'Enfer de Franconville
Président d'Union Rail 95