int ledPin = 2;        // chọn chân 13 báo hiệu LED
int inputPin = 4;       // chọn ngõ tín hiệu vào cho PIR
int pirState = LOW;     // Bắt đầu với không có báo động
int val = 0;
int cambien = 5;// khai báo chân digital 10 cho cảm biến


void setup()
{
	pinMode(ledPin, OUTPUT);
	pinMode(inputPin, INPUT);
	Serial.begin(9600);

  pinMode(LedPin,OUTPUT);//pinMode xuất tín hiệu đầu ra cho led

  pinMode(cambien,INPUT);//pinMode nhận tín hiệu đầu vào cho cảm biê

}
 
void loop()
{
	val = digitalRead(inputPin);    // đọc giá trị đầu vào.
	if (val == HIGH)                // nếu giá trị ở mức cao.(1)
	{
    int value = digitalRead(cambien);//lưu giá trị cảm biến vào biến value

    digitalWrite(LedPin,value);//xuất giá trị ra đèn LED
		digitalWrite(ledPin, HIGH); // LED On
		delay(150);
 
		if (pirState == LOW)
		{
			Serial.println("Motion detected!");
			pirState = HIGH;
		}
	}
	else
	{
		digitalWrite(ledPin, LOW);
		delay(300);
		if (pirState == HIGH)
		{
			Serial.println("Motion ended!");
			pirState = LOW;
		}
	}
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

WiFi
HttpClient
Arduino_JSON
EncButton
FastLED


libraries.txt

#ifndef SerialParser_h
#define SerialParser_h
// простой и быстрый парсер строк в отдельные строки и числа

class SerialParser {
  public:
  
	SerialParser (char newDiv = ',') {
		div = newDiv;
	}
  
    SerialParser (char* data, char newDiv = ',') {
      buf = data;
      div = newDiv;
    }
    ~SerialParser() {
      clear();
    }
    void clear() {
      if (str) free(str);
    }
    int amount() {
      int i = 0, count = 0;
      while (buf[i++]) if (buf[i] == div) count++;  // подсчёт разделителей
      return ++count;
    }
	
	int splitBuff(char* data) {
		buf = data;
		return split();
	}
	
    int split() {
      int am = amount();            // количество данных
      clear();                      // освобождаем буфер
      str = (char**)malloc(am * sizeof(char*)); // создаём буфер
      str[0] = buf;                 // строка 0
      int i = 0, j = 0;             // счётчики
      while (buf[i]) {              // пока не NULL
        if (buf[i] == div) {        // если разделитель
          buf[i] = '\0';            // меняем на NULL
          str[++j] = buf + i + 1;   // запоминаем начало строки
        }
        i++;
      }
      return am;
    }
    int16_t getInt(int num) {
      return atol(str[num]);
    }
    float getFloat(int num) {
      return atof(str[num]);
    }
    bool equals(int num, const char* comp) {
      return !strcmp(str[num], comp);
    }
    int parseInts(int* data) {
      int count = 0;
      char* offset = buf;
      while (true) {
        data[count++] = atoi(offset);
        offset = strchr(offset, div);
        if (offset) offset++;
        else break;
      }
      return count;
    }
    int parseBytes(byte* data) {
      int count = 0;
      char* offset = buf;
      while (true) {
        data[count++] = atoi(offset);
        offset = strchr(offset, div);
        if (offset) offset++;
        else break;
      }
      return count;
    }

    char* buf = NULL;
    char** str = NULL;

    char* operator [] (uint16_t idx) {
      return str[idx];
    }
    char div;
  private:
};

#endif


SerialParser.h

/*
    Библиотека для асинхронного чтения объектов Stream (Serial итд)
    Документация: 
    GitHub: https://github.com/GyverLibs/AsyncStream
    Возможности:
    - Неблокирующее чтение в свой буфер
    - Указание символа терминатора
    
    AlexGyver, alex@alexgyver.ru
    https://alexgyver.ru/
    MIT License

    Версии:
    v1.0 - релиз
    v1.1 - исправлен баг
*/

#ifndef _AsyncStream_h
#define _AsyncStream_h
#include <Arduino.h>

template < uint16_t SIZE >
class AsyncStream {
public:
    AsyncStream(Stream* port, char ter = ';', uint16_t tout = 50) {
        _port = port;
        _tout = tout;
        _ter = ter;
    }
    
    // установить таймаут
    void setTimeout(uint16_t tout) {
        _tout = tout;
    }
    
    // установить символ конца
    void setEOL(char ter) {
        _ter = ter;
    }
    
    // данные приняты
    bool available() {
        if (_port -> available()) {
            if (!_parseF) {
                _parseF = true;
                _count = 0;
                _tmr = millis();
            }
            char ch = _port -> read();
            if (ch == _ter) {
                buf[_count] = '\0';
                _parseF = false;
                return true;
            } else if (_count < SIZE - 1) buf[_count++] = ch;
            _tmr = millis();
        }
        if (_parseF && millis() - _tmr >= _tout) {
            _parseF = false;
            buf[_count] = '\0';
            return true;
        }
        return false;
    }
    
    // доступ к буферу
    char buf[SIZE];

private:
    Stream* _port;
    char _ter;
    uint16_t _tout, _count = 0;
    uint32_t _tmr = 0;
    bool _parseF = false;
};

#endif

AsyncStream.h

#include <EEPROM.h>

int eep[20] = {
  111,73,200,2,6,16,10,3,13,3,
  8,1,0,22,1,0,0,0,0,0
};


int eepromData[256];
int unitCount = 0;
int hadSize = 0; 
int memSize = 0;


int getRoomKey() { return EEPROM.read(0); };
String getIpAdresL1() { return String(EEPROM.read(0)); };
String getIpAdresL2() { return String(EEPROM.read(1)); };
String getIpAdresM() { return String(EEPROM.read(2)); };
String getIpMasck() { return getIpAdresL1() + "." + getIpAdresL2() + ":" + getIpAdresM(); };
int getUnitCount() { unitCount =  unitCount > 0 ? unitCount : EEPROM.read(3); return unitCount; };
int getHadSize() { hadSize = hadSize > 0 ? hadSize : EEPROM.read(4); return hadSize; };
int getMemSize() { memSize = memSize > 0 ? memSize : EEPROM.read(5); return memSize; };


void eeprom_setup() {
  EEPROM.begin(256);

  for(int i = 0; i < 20; i++){
    EEPROM.put(i, eep[i]);  
  }

  read(false, 256);
};


void eeprom_tick(int am) {
 switch (serialData.getInt(0)) {
    case 99 : write(am); break;  
    case -99 : read(true, serialData.getInt(1)); break;  
  };
};

void write(int am) {
  for (int p = 0; p < am - 1; p++) {
    EEPROM.put(p, serialData.getInt(p+1));
  }
  EEPROM.commit();

  resetFunc();
};

void read(bool show, int size) {
  for (int p = 0; p < size; p++) {
    eepromData[p] = EEPROM.read(p);
    if (show) {
      if (p > 0) Serial.print(",");
      Serial.print(eepromData[p]);
    }
  }
  if (show) { Serial.println(""); }
};





eeprom.ino

#include <WiFi.h>
#include <HTTPClient.h>

#define STASSID "Wokwi-GUEST"
#define STAPSK ""

//#define STASSID "CLOUD24"
//#define STAPSK "wifip@sswordcloud4p1ple24"

String serverName = "http://193.16.";
unsigned long lastTime = 0;
unsigned int timerDelay = 1000;

void http_setup() {
  WiFi.begin(STASSID, STAPSK);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  serverName += getIpMasck();

  Serial.println("");
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());
  
  unitDetailParser();
}

void http_tick() {
  if ((WiFi.status() == WL_CONNECTED)) {
    if ((millis() - lastTime) > timerDelay) unitDetailParser(); 
  }
}

void responsParser(String url, int code){
 Serial.print(url);
 Serial.print(" -> ");
 Serial.println(code);
}

//unsigned int unitDetailParser() {
void unitDetailParser() {
  JSONVar obj = JSON.parse(getUnitDetail(getUnitsKey()));
  lastTime = millis();

  if (JSON.typeof(obj) == "undefined") Serial.println("Parsing input failed!");
  else {
    timerDelay = obj[0]["refresh_delay"];
    for (int res = 0; res < obj.length(); res++) {
      unitParse(obj[res]);
    }
  }
}

String getUnitDetail(String units) {
  WiFiClient client;
  HTTPClient http;

  String serverPath = serverName + "/unit/esp/detail?units=" + units;
  http.begin(client, serverPath.c_str());
  int httpResponseCode = http.GET();

  String payload = "[]"; 
  if (httpResponseCode>0) payload = http.getString();
  responsParser(serverPath, httpResponseCode);

  http.end();
  //Serial.println(payload);
  return payload;
}

String savedEeprom() {
  WiFiClient client;
  HTTPClient http;

  String serverPath = serverName + "/room/saved_eeprom?room_key=" + getRoomKey();
  http.begin(client, serverPath.c_str());
  int httpResponseCode = http.GET();

  String payload = "[]"; 
  if (httpResponseCode>0) payload = http.getString();
  responsParser(serverPath, httpResponseCode);

  http.end();
  return payload;
}

void exportEeprom(String payload) {
  WiFiClient client;
  HTTPClient http;

  String serverPath = serverName + "/room/export_eeprom";
  http.begin(client, serverPath.c_str());
  http.addHeader("Content-Type", "application/json");

  JSONVar obj;

  obj["room_key"] = getRoomKey();
  obj["data"] = payload;

  int httpResponseCode = http.PUT(JSON.stringify(obj));

  responsParser(serverPath, httpResponseCode);

  http.end();
}

String switchUnitTriger(int pos) {
  
  WiFiClient client;
  HTTPClient http;

  String serverPath = serverName + "/unit/esp/triger";
  http.begin(client, serverPath.c_str());
  http.addHeader("Content-Type", "application/json");

  int httpResponseCode = http.POST(JSON.stringify(getUnit(pos)));
  String payload = "{}"; 
  responsParser(serverPath, httpResponseCode);

  if (httpResponseCode>0) payload = http.getString();

  http.end();
  return payload;
}

http.ino

#include <EncButton.h>
#include "FastLED.h"

#define LED_PIN 27      // пин ленты 1
#define NUMLEDS 4

Button btn0, btn1, btn2, btn3;

CRGB leds[NUMLEDS];

int btn_pin[] = {16, 17, 18, 19};

void switch_setup() {
  FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUMLEDS);
  FastLED.setBrightness(80);
}

void switch_setup_position(int pos) {
  getUnit(pos)["fl_trigger"] = false;

  switch(pos) {
    case 0: btn0.init(btn_pin[0]); break;
    case 1: btn1.init(btn_pin[1]); break;
    case 2: btn2.init(btn_pin[2]); break;
    case 3: btn3.init(btn_pin[3]); break;
  }
}

void switch_tick(int pos) {
  switch(pos) {
    case 0:  btn0.tick(); if(btn0.click()) unitTriger(pos); break;
    case 1:  btn1.tick(); if(btn1.click()) unitTriger(pos); break;
    case 2:  btn2.tick(); if(btn2.click()) unitTriger(pos); break;
    case 3:  btn3.tick(); if(btn3.click()) unitTriger(pos); break;
  }
}

void unitTriger(int pos) {
  getUnit(pos)["fl_trigger"] = !getUnit(pos)["fl_trigger"];
  JSONVar obj = JSON.parse(switchUnitTriger(pos));
  if (JSON.typeof(obj) != "undefined") switchParse(getUnit(pos), obj);  
}

void switchParse(JSONVar to, JSONVar from) {
  //if (to["unit_key"] != from["unit_key"]) return;
  to["fl_trigger"] = (int)from["fl_trigger"] == 1;
  to["red"] = from["red"];
  to["green"] = from["green"];
  to["blue"] = from["blue"];

  if (to["fl_trigger"]) setBackground(to["pos"], 0, 255, 0); 
  else setBackground(to); 
}

void setBackground(JSONVar data) {
  Serial.println(data["pos"]);
  Serial.println(data["red"]);
  Serial.println(data["green"]);
  Serial.println(data["blue"]);
  setBackground(data["pos"], data["red"], data["green"], data["blue"]);
}

void setBackground(int pos, int r, int g, int b) {
  leds[pos].setRGB(r, g, b);
  FastLED.show();
}

/*
  if (data[2] > 0) {
    if (data[0] == 8) setBackground(224, 187, 255);
    else setBackground(0, 255, 0);
  } else {
    if (data[0] == 8) setBackground(255, 215, 0);
    else setBackground(0, 255, 0);
  }
*/

switch.ino

JSONVar units;

String units_string = "";

void unit_setup() {
  for (int u = 0; u < getUnitCount(); u++) {
    const int adres = eepromData[getHadSize() + (2 * u)];
    const int type = eepromData[adres + 1];
    units[u]["pos"] = u;
    units[u]["unit_adres"] = adres;
    units[u]["unit_type"] = type;
    units[u]["unit_size"] = eepromData[(getHadSize() + (2 * u)) + 1];  
    units[u]["unit_key"] = eepromData[adres + 0];
    units[u]["unit_man"] = eepromData[adres + 2];

    switch (type) {                        // check unit Type
      case 1: switch_setup_position(u); break;
    }
  }
}

JSONVar getUnit(int pos) {
  return units[pos];
}

String getUnitsKey() {
  if (units_string.length() == 0) units_string = JSON.stringify(units);
  return units_string;
}

void unit_tick() {
  for (int u = 0; u < getUnitCount(); u++) {
    switch((int)units[u]["unit_type"]) {
      case 1: switch_tick(u); break;
    }
  }
}

void unitParse(JSONVar data) {

   Serial.println(JSON.stringify(data));

  for (int u = 0; u < getUnitCount(); u++) {
    if (units[u]["unit_key"] == data["unit_key"]) {
      switch((int)data["id_unit_type"]) {
        case 1: switchParse(units[u], data);
      }
      return;
    }
  }
}
