bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)
node-red-start

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <BH1750.h>

// --- WiFi credentials ---
const char* WIFI_SSID = "YOUR_WIFI_NAME";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

// --- MQTT broker (your UNO Q's IP) ---
const char* MQTT_BROKER = "192.168.1.42";
const int MQTT_PORT = 1883;

const int PIR_PIN = 2;

WiFiClient espClient;
PubSubClient client(espClient);
BH1750 lightMeter;

void setup_wifi() {
  delay(10);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected");
}

void reconnect_mqtt() {
  while (!client.connected()) {
    Serial.print("Connecting to MQTT...");
    if (client.connect("XIAO_Sensor_Node_1")) {
      Serial.println("connected");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);

  Wire.begin();
  lightMeter.begin();

  setup_wifi();
  client.setServer(MQTT_BROKER, MQTT_PORT);
}

void loop() {
  if (!client.connected()) {
    reconnect_mqtt();
  }
  client.loop();

  bool motion = digitalRead(PIR_PIN) == HIGH;
  float lux = lightMeter.readLightLevel();

  client.publish("home/room/motion", motion ? "1" : "0");
  client.publish("home/room/light", String(lux).c_str());

  Serial.print("Motion: ");
  Serial.print(motion);
  Serial.print(" | Light: ");
  Serial.print(lux);
  Serial.println(" lux");

  delay(1000);
}

#include <WiFi.h>
#include <PubSubClient.h>

// ==== EDIT THESE ====
const char* WIFI_SSID     = "YOUR_WIFI_NAME";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char* MQTT_BROKER   = "192.168.1.42";
const int   MQTT_PORT     = 1883;
const char* MQTT_TOPIC    = "home/room/sound";
const char* CLIENT_ID     = "XIAO_Sensor_Node_2";
const int   SOUND_PIN     = 2;
const bool  ACTIVE_HIGH   = true;   // flip to false if your module is active-low
const int   PUBLISH_DELAY_MS = 200; // how often to check
// =====================

WiFiClient espClient;
PubSubClient client(espClient);

bool wasDetected = false;  // tracks previous reading, so we only fire on a NEW clap

void setup_wifi() {
  Serial.print("Connecting to WiFi");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected, IP: " + WiFi.localIP().toString());
}

void reconnect_mqtt() {
  while (!client.connected()) {
    Serial.print("Connecting to MQTT...");
    if (client.connect(CLIENT_ID)) {
      Serial.println("connected");
    } else {
      Serial.print("failed, rc=");
      Serial.println(client.state());
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(SOUND_PIN, INPUT);
  setup_wifi();
  client.setServer(MQTT_BROKER, MQTT_PORT);
}

void loop() {
  if (!client.connected()) reconnect_mqtt();
  client.loop();

  bool raw = digitalRead(SOUND_PIN) == HIGH;
  bool soundDetected = ACTIVE_HIGH ? raw : !raw;

  // Only publish when sound just started (wasn't detected last check, is detected now)
  if (soundDetected && !wasDetected) {
    client.publish(MQTT_TOPIC, "1");
    Serial.println("Clap detected! Published.");
  }

  wasDetected = soundDetected;
  delay(PUBLISH_DELAY_MS);
}

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <U8g2lib.h>

// ==== EDIT THESE ====
const char* WIFI_SSID     = "YOUR_WIFI_NAME";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char* MQTT_BROKER   = "192.168.1.42";
const int   MQTT_PORT     = 1883;
const char* SUB_TOPIC     = "home/room/light/set";
const char* CLIENT_ID     = "ESP32_Actuator_Node";
const int   RELAY_PIN     = 26;
const bool  RELAY_ACTIVE_HIGH = true;  // flip if your relay module is active-low
const int   OLED_SDA      = 21;
const int   OLED_SCL      = 22;
// =====================

WiFiClient espClient;
PubSubClient client(espClient);
U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

String lastState = "0";
String connStatus = "Connecting...";

void updateOLED() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "MQTT Automation Node");
  u8g2.drawStr(0, 28, ("Status: " + connStatus).c_str());
  u8g2.drawStr(0, 44, ("LED: " + String(lastState == "1" ? "ON" : "OFF")).c_str());
  u8g2.sendBuffer();
}

void setRelay(String state) {
  bool on = (state == "1");
  digitalWrite(RELAY_PIN, (on == RELAY_ACTIVE_HIGH) ? HIGH : LOW);
  lastState = state;
  updateOLED();
}

void callback(char* topic, byte* payload, unsigned int length) {
  String msg;
  for (unsigned int i = 0; i < length; i++) msg += (char)payload[i];
  Serial.println("Received: " + msg);
  setRelay(msg);
}

void setup_wifi() {
  connStatus = "WiFi connecting";
  updateOLED();
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  connStatus = "WiFi OK";
  updateOLED();
}

void reconnect_mqtt() {
  while (!client.connected()) {
    connStatus = "MQTT connecting";
    updateOLED();
    if (client.connect(CLIENT_ID)) {
      client.subscribe(SUB_TOPIC);
      connStatus = "Connected";
      updateOLED();
    } else {
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_ACTIVE_HIGH ? LOW : HIGH);  // start OFF

  Wire.begin(OLED_SDA, OLED_SCL);
  u8g2.begin();
  updateOLED();

  setup_wifi();
  client.setServer(MQTT_BROKER, MQTT_PORT);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) reconnect_mqtt();
  client.loop();
}

flow.set(msg.topic, msg.payload);

let lux = parseFloat(flow.get("home/room/light")) || 0;
let sound = String(flow.get("home/room/sound"));
let LUX_THRESHOLD = 50;

let current = flow.get("led_state") || "0";
let controlMode = flow.get("control_mode") || "light"; // "light" or "clap"
let lastLuxState = flow.get("last_lux_state") || "bright";
let turnOn = (current === "1");

let luxState = (lux < LUX_THRESHOLD) ? "dark" : "bright";

// Rule 1: Light only works while in "light" control mode
if (msg.topic === "home/room/light" && controlMode === "light" && luxState !== lastLuxState) {
    turnOn = (luxState === "dark");
    flow.set("last_lux_state", luxState);
}

// Rule 2: Sound always wins, toggles regardless of current mode
if (msg.topic === "home/room/sound" && sound === "1") {
    turnOn = (current === "0");

    // Clap turned LED ON -> lock out light control
    // Clap turned LED OFF -> hand control back to light
    controlMode = turnOn ? "clap" : "light";
    flow.set("control_mode", controlMode);

    // Reset lux tracking so light doesn't immediately re-trigger once unlocked
    flow.set("last_lux_state", luxState);
}

flow.set("led_state", turnOn ? "1" : "0");

msg.payload = turnOn ? "1" : "0";
msg.topic = "home/room/light/set";
return msg;