garage status about esp8266-esp32-sdk HOT 40 CLOSED

  if (doorState) {
    // Si la puerta está cerrada, enviar evento de puerta abierta
    SinricPro[GARAGEDOOR_ID_1].sendDoorStateEvent(true);
    SinricPro[GARAGEDOOR_ID_2].sendDoorStateEvent(true);
  } else {
    // Si la puerta está abierta, enviar evento de puerta cerrada
    SinricPro[GARAGEDOOR_ID_1].sendDoorStateEvent(false);
    SinricPro[GARAGEDOOR_ID_2].sendDoorStateEvent(false);
  }

// Uncomment the following line to enable serial debug output
//#define ENABLE_DEBUG

#ifdef ENABLE_DEBUG
  #define DEBUG_ESP_PORT Serial
  #define NODEBUG_WEBSOCKETS
  #define NDEBUG
#endif 

#include <Arduino.h>
#if defined(ESP8266)
  #include <ESP8266WiFi.h>
#elif defined(ESP32) || defined(ARDUINO_ARCH_RP2040)
  #include <WiFi.h>
#endif

#include <WiFiManager.h>            // Include the library
#include "SinricPro.h"
#include "SinricProGarageDoor.h"
#include <SimpleTimer.h>

#define APP_KEY           "d0465cxxxxxxxxxxxxxxxx"      // Should look like "de0bxxxx-1x3x-4x3x-ax2x-5dabxxxxxxxx"
#define APP_SECRET        "xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   // Should look like 
"5f36xxxxxxxxxxxxxxxxxx-333d65xxxxxx"
#define BAUD_RATE         115200                     // Change baudrate to your need

SimpleTimer timer;
WiFiManager wifiManager;



bool paso1 = true;
bool paso2 = true;
const int GARAGE_DOOR_PIN_1 = 22;
const int GARAGE_DOOR_PIN_2 = 23;
const int RESET = 21;
const char* GARAGEDOOR_ID_1 = "6xxxxxxxxxxxxxxxxxxxxxxxx";  // Should look like "5dc1564130xxxxxxxxxxxxxx"
const char* GARAGEDOOR_ID_2 = "6xxxxxxxxxxxxxxxxxxxxxxx";  // Should look like "5dc1564130xxxxxxxxxxxxxx"
int Segundos;
int Segundos2;


bool onDoorState(const String& deviceId, bool &doorState) {
  Serial.printf("Garagedoor %s is %s now.\r\n", deviceId.c_str(), doorState?"closed":"open");

  if (deviceId == GARAGEDOOR_ID_1) {
    digitalWrite(GARAGE_DOOR_PIN_1, LOW); // Activa el relé
    paso1 = false;
    Segundos = 0;
    delay(500); // Espera 0.5 segundos
    digitalWrite(GARAGE_DOOR_PIN_1, HIGH); // Desactiva el relé
  } else if (deviceId == GARAGEDOOR_ID_2) {
    digitalWrite(GARAGE_DOOR_PIN_2, LOW); // Activa el relé
    paso2 = false;
    Segundos2 = 0;
    delay(500); // Espera 0.5 segundos
    digitalWrite(GARAGE_DOOR_PIN_2, HIGH); // Desactiva el relé
  }

  return true;
}

void setupSinricPro() {
 

  // setup SinricPro
  SinricPro.onConnected([](){ Serial.printf("Connected to SinricPro\r\n"); }); 
  SinricPro.onDisconnected([](){ Serial.printf("Disconnected from SinricPro\r\n"); });
  SinricPro.begin(APP_KEY, APP_SECRET);
  
 
}
 void SetInterval()
 {
  SinricProGarageDoor &myGarageDoor1 = SinricPro[GARAGEDOOR_ID_1];
  myGarageDoor1.onDoorState(onDoorState);

  SinricProGarageDoor &myGarageDoor2 = SinricPro[GARAGEDOOR_ID_2];
  myGarageDoor2.onDoorState(onDoorState);
  
  Segundos ++;
  Segundos2 ++;
  
  if(Segundos >= 20 && paso1 == false)
  {
   Serial.println("envio estado P11111111111111111");
   myGarageDoor1.sendDoorStateEvent(true);   
   paso1 = true;
  }
   if(Segundos2 >= 20 && paso2 == false)
  {
  Serial.println("envio estado P222222222222222222");
   myGarageDoor2.sendDoorStateEvent(true);    
   paso2 = true;
  }
  if(Segundos >=25)
  {
    Segundos = 0;
  }
  if(Segundos2 >=25)
  {
    Segundos2 = 0;  
  }
 }
void setup() {
  Serial.begin(BAUD_RATE); Serial.printf("\r\n\r\n");

//  WiFiManager wifiManager;        // Create an instance of WiFiManager
  wifiManager.autoConnect("GarageDoorAP"); // Start WiFiManager

  pinMode(GARAGE_DOOR_PIN_1, OUTPUT);
  pinMode(GARAGE_DOOR_PIN_2, OUTPUT);  
  pinMode(RESET, INPUT_PULLUP);
  
  // Invert logic for relay control
  digitalWrite(GARAGE_DOOR_PIN_1, HIGH); // Set initial state to off
  digitalWrite(GARAGE_DOOR_PIN_2, HIGH); // Set initial state to off

  setupSinricPro ();
  timer.setInterval(1000, SetInterval);
  
}

void loop() {
  SinricPro.handle();
   timer.run();
  if(digitalRead(RESET) == LOW) 
  {
    wifiManager.resetSettings();
  }
}
```
is ok??

#include <Arduino.h>
#include <WiFiManager.h>
#include <SinricPro.h>
#include <SinricProGarageDoor.h>

const char* APP_KEY = "xxxxxxxxxxxxxxxxxxxxxxxxx";
const char* APP_SECRET = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdf34825a937";
const char* GARAGEDOOR_ID_1 = "xxxxxxxxxxxxxxxxxxxxxxxxxx";
const char* GARAGEDOOR_ID_2 = "xxxxxxxxxxxxxxxxxxxxxxxxxxxx";

const int doorPin1 = 22;
const int doorPin2 = 23;

unsigned long timerDoor1 = 0;
unsigned long timerDoor2 = 0;
const int RESET = 21;

const int DELAY_TIME = 2000;

WiFiManager wifiManager;

void startDoorTimer(unsigned long& timerReference) {
    timerReference = millis();
}

void triggerDoor(const int doorPin) {
    digitalWrite(doorPin, LOW);
    delay(500);
    digitalWrite(doorPin, HIGH);
}

bool onDoorState(const String& deviceId, bool& state) {
    if (state) {
        if (deviceId == GARAGEDOOR_ID_1) {
            triggerDoor(doorPin1);
            startDoorTimer(timerDoor1);
        }

        if (deviceId == GARAGEDOOR_ID_2) {
            triggerDoor(doorPin2);
            startDoorTimer(timerDoor2);
        }
    }

    return true;
}



void handleDoorTimer(unsigned long& timer, const String& deviceId) {
    if (timer && millis() - timer >= DELAY_TIME) {
        SinricProGarageDoor& myGarageDoor = SinricPro[deviceId];
        myGarageDoor.sendDoorStateEvent(false);
        timer = 0;
    }
}

void handleDoorTimers() {
    handleDoorTimer(timerDoor1, GARAGEDOOR_ID_1);
    handleDoorTimer(timerDoor2, GARAGEDOOR_ID_2);
}

void setupGarageDoors() {
    pinMode(doorPin1, OUTPUT);
    digitalWrite(doorPin1, HIGH);

    pinMode(doorPin2, OUTPUT);
    digitalWrite(doorPin2, HIGH);
}

void setupWiFi() {
    wifiManager.autoConnect("GarageDoorAP");
}

void setupSinricPro() {
    SinricProGarageDoor& myGarageDoor1 = SinricPro[GARAGEDOOR_ID_1];
    SinricProGarageDoor& myGarageDoor2 = SinricPro[GARAGEDOOR_ID_2];
    myGarageDoor1.onDoorState(onDoorState);
    myGarageDoor2.onDoorState(onDoorState);
    SinricPro.onConnected([](){ Serial.println("SinricPro connected");});
    SinricPro.onDisconnected([](){ Serial.println("SinricPro disconnected");});
    Serial.println("Connecting SinricPro...");
    SinricPro.begin(APP_KEY, APP_SECRET);
    //  WiFiManager wifiManager;        // Create an instance of WiFiManager
    wifiManager.autoConnect("GarageDoorAP"); // Start WiFiManager

}

void setup() {
    Serial.begin(115200);
    pinMode(RESET, INPUT_PULLUP);   

    setupGarageDoors();
    setupWiFi();
    setupSinricPro();
}

void loop() {
    SinricPro.handle();
    handleDoorTimers();
     if(digitalRead(RESET) == LOW) 
  {
    wifiManager.resetSettings();
  }
}

#include <Arduino.h>
#include <WiFiManager.h> // Incluimos la biblioteca WiFiManager
#include "GarageDoor.h"
#include <SinricPro.h>
#include <SinricProGarageDoor.h>

const char* APP_KEY    = "d0465c32-b7e1-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const char* APP_SECRET = "c9bb2cab-5213-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const int RESET = 21;
WiFiManager wifiManager;

GarageDoor garageDoors[]{
    //   name           deviceId               pin  delay time (ms)
    {"GarageDoor1", "66354xxxxxxxxxxx", 22, 20000},
    {"GarageDoor2", "66354xxxxxxxxxxx", 23, 20000}
};

void triggerGarageDoor(GarageDoor& garageDoor) {
    digitalWrite(garageDoor.pin, LOW);
    delay(500);
    digitalWrite(garageDoor.pin, HIGH);
    Serial.printf("[%s]: triggered\r\n", garageDoor.name.c_str());
}

void startGarageDoorTimer(GarageDoor& garageDoor) {
    Serial.printf("[%s]: timer started\r\n", garageDoor.name.c_str());
    garageDoor.timer = millis();
}

void stopGarageDoorTimer(GarageDoor& garageDoor) {
    Serial.printf("[%s]: timer stopped\r\n", garageDoor.name.c_str());
    garageDoor.timer = 0;
}

void openGarageDoor(GarageDoor& garageDoor) {
    Serial.printf("[%s]: opening door\r\n", garageDoor.name.c_str());
    triggerGarageDoor(garageDoor);
    startGarageDoorTimer(garageDoor);
}

void closeGarageDoor(GarageDoor& garageDoor) {
    Serial.printf("[%s]: closing door\r\n", garageDoor.name.c_str());
    triggerGarageDoor(garageDoor);
    stopGarageDoorTimer(garageDoor);
}

bool garageDoorTimerIsExpired(GarageDoor& garageDoor) {
    if (garageDoor.timer && millis() - garageDoor.timer >= garageDoor.delayTime) {
        Serial.printf("[%s]: timer expired\r\n", garageDoor.name.c_str());
        return true;
    }
    return false;
}

void sendGarageDoorCloseEvent(GarageDoor& garageDoor) {
    SinricProGarageDoor& myGarageDoor = SinricPro[garageDoor.deviceId];
    myGarageDoor.sendDoorStateEvent(true);
    Serial.printf("[%s]: close event sent\r\n", garageDoor.name.c_str());
}

void handleGarageDoorTimer(GarageDoor& garageDoor) {
    if (garageDoorTimerIsExpired(garageDoor)) {
        stopGarageDoorTimer(garageDoor);
        sendGarageDoorCloseEvent(garageDoor);
    }
}

void handleGarageDoorTimers() {
    for (auto& garageDoor : garageDoors) handleGarageDoorTimer(garageDoor);
}

bool onDoorState(const String& deviceId, bool& state) {
    for (auto& garageDoor : garageDoors) {
        if (deviceId == garageDoor.deviceId) {
            if (state) {
                closeGarageDoor(garageDoor);
            } else {
                openGarageDoor(garageDoor);
            }
            return true;
        }
    }

    return false;
}

void setupGarageDoor(GarageDoor& garageDoor) {
    int pin = garageDoor.pin;
    pinMode(pin, OUTPUT);
    digitalWrite(pin, HIGH);

    SinricProGarageDoor& door = SinricPro[garageDoor.deviceId];
    door.onDoorState(onDoorState);
}

void setupGarageDoors() {
    for (auto& garageDoor : garageDoors) setupGarageDoor(garageDoor);
}

void setupWiFi() {
    // Creamos un objeto WiFiManager
//    WiFiManager wifiManager;
    
    // Conectamos al WiFi, si no se puede conectar, se abrirá un portal de configuración de WiFi
    if (!wifiManager.autoConnect("GarageDoorAP")) {
        Serial.println("failed to connect and hit timeout");
        // Reiniciar y volver a intentar la conexión si no se puede conectar
        ESP.restart();
        delay(1000);
    }
    Serial.println("connected... :)");
}

void setupSinricPro() {
    SinricPro.onConnected([]() { Serial.println("[SinricPro]: connected"); });
    SinricPro.onDisconnected([]() { Serial.println("[SinricPro]: disconnected"); });
    Serial.println("[SinricPro]: connecting...");
    SinricPro.begin(APP_KEY, APP_SECRET);
}

void setup() {
    Serial.begin(115200);
    setupGarageDoors();
    setupWiFi();
    setupSinricPro();
    pinMode(RESET, INPUT_PULLUP);
    
}

void loop() {
    SinricPro.handle();
    handleGarageDoorTimers();
     if(digitalRead(RESET) == LOW) 
  {
    wifiManager.resetSettings();
  }
}