//Master
/*
  ESP-NOW Remote Sensor - Receiver (Multiple Version)
  esp-now-rcv.ino
  Receives Temperature & Humidity data from other ESP32 via ESP-NOW
  
  DroneBot Workshop 2022
  https://dronebotworkshop.com
  https://www.youtube.com/watch?v=bEKjCDDUPaU
  https://dronebotworkshop.com/esp-now/
*/

// Include required libraries
#include <WiFi.h>
#include <esp_now.h>

// Define data structure
typedef struct struct_message {
    String a;
    String b;
    String c;
    int d;
} struct_message;

// Create structured data object
struct_message myData;

// Callback function
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) 
{
  // Get incoming data
  memcpy(&myData, incomingData, sizeof(myData));
  
  // Print to Serial Monitor
  Serial.print("Temp Sensor ");
  Serial.print(myData.d);
  Serial.print(": ");
  Serial.println(myData.a);
    
  Serial.print("Heat Sensor ");
  Serial.print(myData.d);
  Serial.print(": ");
  Serial.println(myData.b);

  Serial.print("Smoke Sensor ");
  Serial.print(myData.d);
  Serial.print(": ");
  Serial.println(myData.c);

  Serial.println("");
}

const int relayPins[] = {4, 5, 18, 19};
int relayPin = 0;
const int numPins = sizeof(relayPins) / sizeof(relayPins[0]);
bool relayState = false;

const unsigned long offInterval2 = 1000;
const unsigned long onInterval2 = 1000;
const unsigned long offInterval3 = 1000;
const unsigned long onInterval3 = 1000;
unsigned long previousMillis2 = 0;
unsigned long previousMillis3 = 0;
 
void setup() {
  // Set up Serial Monitor
  Serial.begin(115200);

  // Start ESP32 in Station mode
  WiFi.mode(WIFI_STA);

  // Initalize ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
   
  // Register callback function
  esp_now_register_recv_cb(OnDataRecv);

  for (int i = 0; i < numPins; i++) {
    pinMode(relayPins[i], OUTPUT);
    digitalWrite(relayPins[i], HIGH);
  }
}

void loop() {
  unsigned long currentMillis = millis();

  if (myData.d == 2 && relayState == false && currentMillis - previousMillis2 >= offInterval2 && myData.a == "Y" && myData.b == "N" && myData.c == "N") {
    relayPin = myData.d;
    Serial.print("Pin in is ");Serial.println(myData.d);
    digitalWrite(relayPins[relayPin-2], LOW);
    
    Serial.println("In here 2");
    relayState = true;
    previousMillis2 = currentMillis;
  }
  if (myData.d == 2 && relayState == true && currentMillis - previousMillis2 >= onInterval2 && myData.a == "Y" && myData.b == "N" && myData.c == "N") {
    relayPin = myData.d;
    Serial.print("Pin out is ");Serial.println(myData.d);
    digitalWrite(relayPins[relayPin-2], HIGH);
    
    Serial.println("Out here 2");
    relayState = false;
    previousMillis2 = currentMillis;
  }
  if (myData.d == 3 && relayState == false && currentMillis - previousMillis3 >= offInterval3 && myData.a == "Y" && myData.b == "N" && myData.c == "N") {
    relayPin = myData.d;
    Serial.print("Pin in is ");Serial.println(myData.d);
    digitalWrite(relayPins[relayPin-2], LOW);
    
    Serial.println("In here 3");
    relayState = true;
    previousMillis3 = currentMillis;
  }
  if (myData.d == 3 && relayState == true && currentMillis - previousMillis3 >= onInterval3 && myData.a == "Y" && myData.b == "N" && myData.c == "N") {
    relayPin = myData.d;
    Serial.print("Pin out is ");Serial.println(myData.d);
    digitalWrite(relayPins[relayPin-2], HIGH);
    
    Serial.println("Out here 3");
    relayState = false;
    previousMillis3 = currentMillis;
  }
}

//Slave
/*
  ESP-NOW Remote Sensor - Transmitter (Multiple Version)
  esp-now-xmit-multiple.ino
  Sends Temperature & Humidity data to other ESP32 via ESP-NOW
  Uses DHT22
  Multiple Transmitter modification
  
  DroneBot Workshop 2022
  https://dronebotworkshop.com
  https://www.youtube.com/watch?v=bEKjCDDUPaU
  https://dronebotworkshop.com/esp-now/
*/

// Include required libraries
#include <WiFi.h>
#include <esp_now.h>
#include <DHT.h>

// Define DHT22 parameters
#define DHTPin 5
#define DHTType DHT22

// Create DHT Object
DHT dht(DHTPin, DHTType);

// Variables for temperature and humidity
float temp;
float humid;

// Integer for identification (make unique for each transmitter)
int ident = 3;

// Responder MAC Address (Replace with your responders MAC Address)
uint8_t broadcastAddress[] = {0xD0, 0xEF, 0x76, 0x46, 0xCB, 0x24};

// Define data structure
typedef struct struct_message {
  // float a;
  // float b;
  // int c;
  String a;
  String b;
  String c;
  int d;
} struct_message;

// Create structured data object
struct_message myData;

// Register peer
esp_now_peer_info_t peerInfo;

// Sent data callback function
void OnDataSent(const uint8_t *macAddr, esp_now_send_status_t status)
{
  Serial.print("Last Packet Send Status: ");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void setup() {

  // Setup Serial monitor
  Serial.begin(115200);
  delay(100);

  // Initiate DHT22
  dht.begin();

  // Set ESP32 WiFi mode to Station temporarly
  WiFi.mode(WIFI_STA);

  // Initialize ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Define callback
  esp_now_register_send_cb(OnDataSent);


  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer");
    return;
  }

}

void loop() {

  // Read DHT22 module values
  // temp = dht.readTemperature();
  // delay(10);
  // humid = dht.readHumidity();
  // delay(10);

  // Serial.print("Temp: ");
  // Serial.println(temp);
  // Serial.print("Humid: ");
  // Serial.println(humid);

  // Add to structured data object
  // myData.a = temp;
  // myData.b = humid;
  // myData.c = ident;
  
  myData.a = "Y";
  myData.b = "N";
  myData.c = "N";
  myData.d = ident;

  // Send data
  esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));

  // Delay for DHT22 sensor
  delay(2000);
}

//Relays
const int buttonPins[] = {33, 32, 35, 34}; // {33, 32, 35, 34}
const int ledPins[] = {13, 12, 14, 27}; // {13, 12, 14, 27}
const int numButtons = 4; // calculate the number of buttons
const int numLeds = 4; // calculate the number of LEDs

int ledStates[] = {LOW, LOW, HIGH, HIGH}; // an array to store the state of each LED

unsigned long lastPressTime[numButtons] = {0}; // array to store the last press time for each button
unsigned long lastDebounceTime[numButtons] = {0}; // array to store the last debounce time for each button
int lastButtonState[numButtons] = {LOW}; // array to store the last button state for each button
int buttonState[numButtons] = {LOW}; // array to store the last button state for each button

const unsigned long pressInterval = 100; // Interval for button press in milliseconds
const unsigned long debounceDelay = 50;  // Debounce time in milliseconds

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < numButtons; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP); // Using internal pull-up resistor for each button
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], ledStates[i]); // Initialize LED states
  }
}

void loop() {
  for (int i = 0; i < numButtons; i++) {
    int reading = digitalRead(buttonPins[i]);
    if (reading != lastButtonState[i]) {
      lastDebounceTime[i] = millis(); // Reset the debounce timer
    }
    if ((millis() - lastDebounceTime[i]) > debounceDelay) {
      // If the button state has been stable for the debounce delay
      if (reading != buttonState[i]) {
        buttonState[i] = reading; // Update the button state
        Serial.print(i);Serial.print(" ");Serial.println(buttonState[i]);

        // If the button is pressed
        if (buttonState[i] == HIGH) {
          // Check if press interval has passed since last press
          if (millis() - lastPressTime[i] >= pressInterval) {
            ledStates[i] = !ledStates[i]; // Toggle LED state
            digitalWrite(ledPins[i], ledStates[i]); // Update LED state
            lastPressTime[i] = millis();// Update last press time
          }
        }
      }
    }
    lastButtonState[i] = reading;
  }
}