[RESOLU] ESP8266-ESP01S Alexa Probleme de tempo

Bonjour
j'ai réussi en glanant à droite à gauche, à réalisé un code a televerser dans un esp01 qui permet a Alexa de le reconnaître et d'enclenché un relais sur le gpio 0. Jusque la je suis content, mon problème et je pense tout bête mais je sèche.
je recherche juste a enclenché un relais que un certain temps quand je demande a Alexa d'allumer le salon (télérupteur) pour que le relais ne face qu'une impulsion de 1 ou 2 seconde)
voici mon code total (cela pourra aidé certain dans leur réalisation)`

Je sais que ce code et mal écrit, j'ai pris des bout a droite a gauche réécrit certain, je seche au niveau des state ==1 et state ==0
physiquement le relais avec ce code ne fait que on off et j'aimerais si possible qu'il face on 4s off a l’état 1 et la même chose a l’état 0
merci à vous et bon dimanche

   if (state==1) {
               
                    for (int t=0;t<4;t++){
                                 digitalWrite (0, LOW);
                                  delay (1000);
                                  
                                 }
                     digitalWrite (0, LOW);

              }


else if (state==0) {

               
                  for (int ta=0;ta<4;ta++){
                                  digitalWrite(0, LOW);
                                 delay(1000);
                                   
                                  }

                  digitalWrite (0,HIGH);

la totalité du code

[code]
#include <Arduino.h>
#if defined(ESP8266)
#include <ESP8266WiFi.h>
#elif defined(ESP32)
#include <WiFi.h>
#endif
#include <ESPAsyncWebServer.h>

#include "fauxmoESP.h"

// Rename the credentials.sample.h file to credentials.h and
// edit it according to your router configuration
#define WIFI_SSID "***********"
#define WIFI_PASS "**********"
fauxmoESP fauxmo;
AsyncWebServer server(80);

// -----------------------------------------------------------------------------

#define SERIAL_BAUDRATE 115200
//#define LED_BUILTIN 2

// -----------------------------------------------------------------------------
// Wifi
// -----------------------------------------------------------------------------

void wifiSetup() {

// Set WIFI module to STA mode
WiFi.mode(WIFI_STA);

// Connect
Serial.printf("[WIFI] Connecting to %s ", WIFI_SSID);
WiFi.begin(WIFI_SSID, WIFI_PASS);

// Wait
while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(100);
}
Serial.println();

// Connected!
Serial.printf("[WIFI] STATION Mode, SSID: %s, IP address: %s\n", WiFi.SSID().c_str(), WiFi.localIP().toString().c_str());

}

void serverSetup() {

// Custom entry point (not required by the library, here just as an example)
server.on("/index.html", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send(200, "text/plain", "Hello, world");
});

// These two callbacks are required for gen1 and gen3 compatibility
server.onRequestBody([](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) {
    if (fauxmo.process(request->client(), request->method() == HTTP_GET, request->url(), String((char *)data))) return;
    // Handle any other body request here...
});
server.onNotFound([](AsyncWebServerRequest *request) {
    String body = (request->hasParam("body", true)) ? request->getParam("body", true)->value() : String();
    if (fauxmo.process(request->client(), request->method() == HTTP_GET, request->url(), body)) return;
    // Handle not found request here...
});

// Start the server
server.begin();

}

void setup() {

// Init serial port and clean garbage
Serial.begin(SERIAL_BAUDRATE);
Serial.println();
Serial.println();

// LED_BUILTIN
pinMode(0, OUTPUT);
digitalWrite(0, HIGH); // Our LED_BUILTIN has inverse logic (high for OFF, low for ON)
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
digitalWrite(2, HIGH);
pinMode(3, OUTPUT);



// Wifi
wifiSetup();

// Web server
serverSetup();

// Set fauxmoESP to not create an internal TCP server and redirect requests to the server on the defined port
// The TCP port must be 80 for gen3 devices (default is 1901)
// This has to be done before the call to enable()
fauxmo.createServer(false);
fauxmo.setPort(80); // This is required for gen3 devices

// Vous devez appeler enable (true) une fois que vous avez une connexion WiFi
// Vous pouvez activer ou désactiver la bibliothèque à tout moment
// La désactiver empêchera les appareils d'être découverts et commutés
fauxmo.enable(true);

// Vous pouvez utiliser différentes manières d'appeler alexa pour modifier l'état des appareils:
// «Alexa, allume la cuisine» («cuisine» est le nom du premier appareil ci-dessous)
// "Alexa, allume la cuisine"
// "Alexa, règle la cuisine sur cinquante" (50 signifie 50% de luminosité)

// Ajouter des appareils virtuels
// fauxmo.addDevice ("cuisine");
fauxmo.addDevice("salon");

// Vous pouvez ajouter d'autres appareils

//fauxmo.addDevice("light 3 ");
//fauxmo.addDevice("light 4 ");
//fauxmo.addDevice("light 5 ");
//fauxmo.addDevice("light 6 ");
//fauxmo.addDevice("light 7 ");
//fauxmo.addDevice("light 8 ");

fauxmo.onSetState([](unsigned char device_id, const char * device_name, bool state, unsigned char value) {
    
    // Rappel quand une commande d'Alexa est reçue.
    // Vous pouvez utiliser device_id ou device_name pour choisir l'élément sur lequel effectuer une action (relay, LED_BUILTIN, ...)
    // L'état est un booléen (ON / OFF) et la valeur d'un nombre de 0 à 255 (si vous dites "régler la lumière de la cuisine à 50%", vous recevrez un 128 ici).
    // N'oubliez pas de ne pas trop tarder ici, c'est un rappel, quittez dès que possible.
    // Si vous devez faire quelque chose de plus compliqué ici, définissez un indicateur et traitez-le dans votre boucle principale.
    
    // if (0 == device_id) digitalWrite(RELAY1_PIN, state);
    // if (1 == device_id) digitalWrite(RELAY2_PIN, state);
    // if (2 == device_id) analogWrite(LED_BUILTIN1_PIN, value);
    
    Serial.printf("[MAIN] Device #%d (%s) state: %s value: %d\n", device_id, device_name, state ? "ON" : "OFF", value);

    // Pour l'exemple, nous allumons et éteignons le même LED_BUILTIN quel que soit l'appareil déclenché ou la valeur
  // digitalWrite (LED_BUILTIN,! état); // nous ne sommes pas en train de nier l'état car notre LED_BUILTIN a une logique inverse.
  
   if (state==1) {
               
                    for (int t=0;t<4;t++){
                                 digitalWrite (0, LOW);
                                  delay (1000);
                                  
                                 }
                     digitalWrite (0, LOW);

              }


else if (state==0) {

               
                  for (int ta=0;ta<4;ta++){
                                  digitalWrite(0, LOW);
                                 delay(1000);
                                   
                                  }

                  digitalWrite (0,HIGH);
         
    
                 } 

});

}

void loop() {

// fauxmoESP uses an async TCP server but a sync UDP server
// Therefore, we have to manually poll for UDP packets
fauxmo.handle();

// This is a sample code to output free heap every 5 seconds
// This is a cheap way to detect memory leaks
static unsigned long last = millis();
if (millis() - last > 6000) {
    last = millis();
    //Serial.printf("[MAIN] Free heap: %d bytes\n", ESP.getFreeHeap());
}

}

`[/code]

j'ai continué a chercher et j'ai modifier mon code j'ai donc reussi à obtenir avec la fonction millis:() uune marche de mon relais avec extinction au bout d'un certain temps
par contre ce que je ne comprend pas c'est que ce temps et aléatoire
<del>[code]
void loop() {

// fauxmoESP uses an async TCP server but a sync UDP server
// Therefore, we have to manually poll for UDP packets
fauxmo.handle();



if (millis() - last > 10000) {
    last = millis();
    i=3;
    
    //Serial.printf("[MAIN] Free heap: %d bytes\n", ESP.getFreeHeap());
}

startShow(i);
}

void startShow(int i) {
switch (i) {
case 0: digitalWrite(0,LOW);
break;
case 1: digitalWrite(0, LOW);
break;
case 3: digitalWrite(0, HIGH);
break;
}
`[/code]

last est toujours déclaré en unsigned long ?
Quel genre d'aléatoire observes-tu ?