WEEK 11

Networking and Communications

Week 11’s Assignment

Refernce

Communication is the key... well, to everything I guess!? So under everything comes Printed Circuit Boards too.! Now, how do I make communication happen between these? This communication between the board , other components or devices is called a PCB interface. It is based on how they connect and communicate with other boards or devices and exchange information with each other. It could be via wires or wireless connections.

TO CREATE COMMUNICATION BETWEEN PCB BOARDS THERE ARE DIFFERENT WAYS.

These methods can be broadly divided into wired and wireless modes of communication.

Wired interface : Uses physical connections like cables, connectors, or traces on a PCB to transfer data, control signals, or power between devices. Protocols like UART, I2C, and SPI use wired communication. These methods are generally reliable and fast, but the communication distance is limited by the physical connection.
Wireless interfaces : These do not need physical connections to work. Data is transferred through radio waves, allowing devices to communicate without being directly connected. Common wireless communication methods include Bluetooth, Wi-Fi, and LoRa. The choice depends on factors such as range, speed, and power consumption.

UART - Universal Asynchronous Receiver/Transmitter

image source

UART is one of the simplest communication protocols and is commonly used for communication between microcontrollers, sensors, computers, and other electronic devices. It transmits data bit by bit using an asynchronous serial communication protocol. Since it is asynchronous, there is no separate clock line shared between devices. For communication to work properly, both devices must be configured with the same baud rate (communication speed). Common baud rates include 9600, 115200, and others.

It uses a TX (Transmit) and RX (Receive) wire interface to transfer data. The data is usually sent as 7 or 8 data bits wrapped between a start bit (0) and a stop bit (1) for synchronization. RX of one board must be connected to TX of the other board, and vice versa.

Because only two signal wires are needed, UART is easy to set up and is often used for debugging, serial monitoring, and communication between two devices.The decent distance commnunciation can happen is under 2 meters, maximum distance is 15 meters with low baud rate. This is important when building products.

Serial Peripheral Interface (SPI)

This is used for high speed communication between microcontrollers and sensors. They need multiple wires. Good for short distance communications inside the boards.

Inter-Integrated Circuit (I2C)

In this communication, 2 wires allow multiple devices communication using the same wires. Each device has its own unique address. Data is transferred in byte size.

Universal Serial Bus (USB)

The wired mouse or the wired keyboard (peripherals) we connect to our computer, the phones we can plug and play with, while it transfers data and power.

Pulse Width Modulation (PWM)

In simple terms, it is a technique to control the amount of power delivered to a device by turning the power on and off very quickly. Used in fading LEDs, speed control of motors, and heating elements.

---

Wireless Communications

Bluetooth

This is a short range network called a piconet. It includes the primary device and secondary devices that could directly speak to the primary device. Can cover up to 10 meters. This is why our Bluetooth earphones also say 10 meters connection. Low power consumption.

Wireless Fidelity (Wi-Fi)

Enables devices to connect to local area networks and the internet using radio waves. This moves data fast over a medium distance. Consumes more power than Bluetooth.

Radio Frequency Identification (RFID)

This uses electromagnetic fields to read and write data from the devices. Used in tracking and access control. Access cards use them.

ESP-NOW protocol

REFERNCES : espressif.com and seeedstudio.com

ESP-NOW is a wireless communication protocol developed by Espressif. It allows ESP devices to communicate directly with each other without the need for a Wi Fi router. It is fast, uses very little power, and devices can connect instantly using their MAC addresses. ESP-NOW can also work alongside Wi Fi and Bluetooth LE on supported ESP devices. It is a good choice for simple applications that need quick communication, such as smart home sensors, remote controls, and battery powered devices.

---

Breakout Board - KiCad

1 / 4

2 / 4

3 / 4

4 / 4

❮ ❯

Gerber Files

The gerber files are downloaded and used to mill the PCB

Milling PCB

1 / 4

2 / 4

3 / 4

4 / 4

❮ ❯

Soldered PCB

---

Previous week's boards

I had created two boards during the Input and Output Week. I wanted them to communicate with each other. The Input Week board has an ATtiny on it, and the Output Week board has a plug and play XIAO. To make it a system of three nodes, I am milling a breakout board with a plug and play XIAO on it.

SCHEMATIC DIAGRAM - Input Week board with ATtiny 1614 Week-9

Input Week board with ATtiny 1614 Week-9

SCHEMATIC DIAGRAM - Output Week board with a plug and play XIAO RP2040 Week-10

Output Week board with a plug and play XIAO RP2040 Week-10

---

System Overview

I created a breakout board to connect with my Week 9 input board. The Week 9 board uses an ATtiny1614 and includes an RTC, touch pad, and phototransistor. To add wireless communication, I connected a XIAO ESP32C6 to the ATtiny1614 through UART. The XIAO ESP32C6 is used to send data wirelessly using the ESP NOW protocol. This allows the Week 9 input board to communicate with my Week 10 output board.

Week 9 Input Board
ATtiny1614 + RTC + Touch Pad + Phototransistor

Breakout Board
XIAO ESP32C6 connected to the ATtiny1614 through UART

Week 10 Output Board
XIAO RP2040 + Servo Motor + Stepper Motor

ATtiny1614

Why the RP2040 Would Not Have Worked for This Project

For this project, I needed two boards to exchange data wirelessly using ESP-NOW. The RP2040 cannot support ESP-NOW because it does not have built in Wi Fi or Bluetooth hardware. Adding wireless communication would require additional modules, which would increase both the circuit complexity and the board space required.
Since I used a plug and play approach by adding a developer board through headers, I had the flexibility to switch between different XIAO developer boards whenever needed. The Seeed Studio XIAO RP2040, ESP32-C6, and ESP32-S3 all share the same form factor, pin count, and pin pitch, making them interchangeable without redesigning the board.
The ESP32-C6 already includes Wi Fi, Bluetooth, and ESP-NOW support, allowing direct wireless communication between the boards without any additional hardware. This made it a much more suitable choice for the networking and communication requirements of the project.

Developer boards - Seeed Studio XIAO ESP32

Seeed Studio XIAO ESP32-C6

The XIAO ESP32-C6 is a next generation wireless microcontroller built for modern IoT and smart home applications. It supports Wi Fi 6, Bluetooth 5.3, Thread, Zigbee, and Matter, making it ideal for devices that need to communicate across multiple wireless ecosystems while maintaining low power consumption. An IoT (Internet of Things) ecosystem is an interconnected network of physical devices embedded with sensors, software, and connectivity. It collects, shares, and acts on data automatically.

Seeed Studio XIAO ESP32-S3

The XIAO ESP32-S3 is a powerful microcontroller designed for projects that need higher processing performance. It is well suited for AI, machine learning, image processing, multimedia applications, and complex interactive projects. Its mature ecosystem and strong community support can also help reduce development time.

REFERENCES: SeeedStudio - Mozelectronics - Flywing-tech

---

Lets follow some traditions

The blink test

Open:

File → Examples → 01.Basics → Blink

Code explained

• LED_BUILTIN – The LED on the board. LED_BUILTIN is used in the code for Arduino to understand which onboard LED should be controlled. The developer board connected is selected from the board list. The board definition files specify which GPIO pin the onboard LED is connected to. During compilation, LED_BUILTIN is replaced with the GPIO number defined for that board. For the Seeed XIAO RP2040, this is GPIO 25. This GPIO number is what the microcontroller understands. Therefore, when the code writes to GPIO 25, the onboard LED connected to GPIO 25 blinks.
• pinMode(LED_BUILTIN, OUTPUT); – Sets the LED's pin as OUTPUT
• digitalWrite() – Inside this we define what action it has to do
• digitalWrite(LED_BUILTIN, HIGH); – This defines that the LED is HIGH or ON
• delay(1000) – 1000 milliseconds, that is a 1 second delay in performing the next action

---

How much can a person forget in 1 week?

I heard about UART, and I plugged the breakout board into the ATtiny1614 board using the UART pins. I was trying to program the Microchip ATtiny1614 through the Seeed Studio XIAO ESP32C6. I thought that since these pins were connected, the XIAO ESP32C6 would be able to tell the ATtiny1614 what to do. It turns out that it does not work that way. It still needs the programmer I used in Week 9. So there I was, spending time on something that did not work. I had to be reminded by my instructor to use the programmer.
After that, every time I used the programmer to program the Microchip ATtiny1614. Then I connected the ATtiny1614 board to the breakout board with the Seeed Studio XIAO ESP32C6. Then I uploaded the program to the XIAO ESP32C6, followed by the code for the Seeed Studio XIAO ESP32S3 on the output week board, and communicated between these boards using ESP-NOW.

ESP-NOW : TOUCH + LED (half connection)

NOTE: Node 2 communicates to node 1 through node 3. This only completes a partial requirement for the assignment.

  #include <WiFi.h>

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  Serial.println(WiFi.macAddress());
}

void loop() {}

#include <esp_now.h>
#include <WiFi.h>

#define LED_PIN D9

typedef struct struct_message {
  bool touched;
} struct_message;

struct_message data;

void onReceive(const esp_now_recv_info *info, const uint8_t *incomingData, int len) {
  memcpy(&data, incomingData, sizeof(data));

  Serial.print("Received: ");
  Serial.println(data.touched ? "TOUCHED" : "NOT TOUCHED");

  if (data.touched) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }
}

void setup() {
  Serial.begin(115200);

  pinMode(LED_PIN, OUTPUT);

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP NOW Init Failed");
    return;
  }

  esp_now_register_recv_cb(onReceive);
}

void loop() {
}

#include <esp_now.h>
#include <WiFi.h>

#define TOUCH_PIN D6

int threshold = 500;

// Receiver MAC (S3)
uint8_t receiverMAC[] = {0x30, 0x30, 0xF9, 0x34, 0x60, 0x2C};

typedef struct struct_message {
  bool touched;
} struct_message;

struct_message data;

void setup() {
  Serial.begin(115200);

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP NOW Init Failed");
    return;
  }

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, receiverMAC, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  esp_now_add_peer(&peerInfo);
}

void loop() {
  // Touch sensing (your logic)
  pinMode(TOUCH_PIN, OUTPUT);
  digitalWrite(TOUCH_PIN, LOW);
  delayMicroseconds(10);

  pinMode(TOUCH_PIN, INPUT);

  int count = 0;
  while (digitalRead(TOUCH_PIN) == LOW) {
    count++;
  }

  Serial.print("Value: ");
  Serial.println(count);

  if (count < threshold) {
    Serial.println("TOUCHED");
    data.touched = true;
  } else {
    Serial.println("NOT TOUCHED");
    data.touched = false;
  }

  esp_now_send(receiverMAC, (uint8_t *)&data, sizeof(data));

  Serial.println("------------------");

  delay(500);
}

    Arduino IDE with ESP32 board package version 3.3.7. 
ESP-NOW communication 
MASTER: XIAO ESP32C6 , NODE 1: ATTINY1614 , NODE2: XIAO ESP32S3 
NODE 1: ATTINY1614
PA1 : LED-A
* LED_PIN, HIGH);  // LED ON
* LED_PIN, LOW);   // LED OFF
PA2 : PHOTOTRANSISTOR
* lightValue 0 = dark, 1023 = bright
 *(lightValue < 200 ) DARK
 *(lightValue < 600) DIM
send to MASTER (ESP32C6)  via UART
PB2 : TX , PB3 : RX

NODE2: XIAO ESP32S3
D0 : microServo MG90S
*Standard servos move 0-180. 
D6 : TOUCHPAD-N
* Receive ESP-NOW data
* const int TOUCH_THRESHOLD = 20000;  
 if (touchValue < TOUCH_THRESHOLD) {
    Serial.print("Touch Detected! Value: ");

MASTER (ESP32C6):
UART connection to NODE1
D6 : TX
D7 : RX
D9 : LED-N
* TRUE turns LED ON 
* FALSE turns LED OFF 

CONDITIONS 
Master connected to node 1 via UART. MATER to NODE 2 via ESP-NOW
action 1 - WHEN “Touch Detected “ IN TOUCHPAD-N  on NODE 2  , LED-A becomes LED_PIN, HIGH on NODE-1.
action 2 - When  PA2 : PHOTOTRANSISTOR light value is “DARK” , D0 : microServo MG90S on NODE 2 does 180degree sweep once.
When either one of these actions are complete on “D9 : LED-N” BLINKS TWICE with delay500 miliseconds on MASTER

Important: 
* Code must compile without errors 
* Use correct ESP-NOW callback signatures for version 3.3.7 
* Do not include unnecessary code 
* Keep CODES separate 
* Keep the code simple and beginner friendly 

GENERATE CODES IN THIS ORDER
code 1 : mac address
code 2: NODE-1 ATTINY1615
code 3: MASTER ESP32-C6
code 4: NODE-2 ESP32-S3
 GENERATE 1 CODE THEN TROUBLESHOOT ADN THEN WILL ASK FOR THE ENXT CODE

  

#include <WiFi.h>

void setup() {
  Serial.begin(115200); //baud rate
  delay(2000); 

  WiFi.mode(WIFI_STA); //to turn on the WIFI hardware
  delay(100);

  Serial.print("MAC Address: "); //the serial output
  Serial.println(WiFi.macAddress()); // this is the MAC ADDRESS
}

void loop() {
}

/*
  NODE 1 - ATTINY1614

  PA1 -> LED-A
  PA2 -> Phototransistor

  PB2 -> TX
  PB3 -> RX
*/

const byte LED_PIN = PIN_PA1; //LED-A
const byte LIGHT_PIN = PIN_PA2; // Phototransistor

String rxBuffer = "";  //string is a variable that can store data received from UART or any
bool darkSent = false; //this is a check box, if something is sent-true, not done-false

void setup() {

  pinMode(LED_PIN, OUTPUT); // led would be turnd on if pressed
  digitalWrite(LED_PIN, LOW); 

  Serial0.begin(9600); //baud rate 

  Serial0.println("NODE1 READY"); // after upload - seral print
}

void loop() {

  int lightValue = analogRead(LIGHT_PIN); // setting Phototransistor pin value conditons

  if (lightValue < 200) { //condition if Phototransistor read value lower then 200 then

    if (!darkSent) { 

      Serial0.print("DARK "); //print value dark if vlaue less than 200
      Serial0.println(lightValue); //serial monitor pritns ligth avlue

      darkSent = true; // if value lower than 200 check the check box
    }

  } else {

    darkSent = false; //if not dont check the box
  }

  while (Serial0.available()) {

    char c = Serial0.read();

    if (c == '\n' || c == '\r') {

      if (rxBuffer == "LED_ON") { // if the rxbuffer gets "touch detected" input from node2

        digitalWrite(LED_PIN, HIGH); //turn led on

        Serial0.println("LED ON"); //serial monitor led on
      }

      else if (rxBuffer == "LED_OFF") { // if the condition not satisfied, led off
 
        digitalWrite(LED_PIN, LOW); //LED off

        Serial0.println("LED OFF"); //serial monitor reads led off
      }

      rxBuffer = ""; //if the node 2 input is received

    } else {

      rxBuffer += c; //if the node 2 input is not received
    }
  }

  delay(100);
}
  

#include  //wifi

void setup() {
  Serial.begin(115200); //baud rate

  WiFi.mode(WIFI_STA); //turn wifi harware on

  Serial.println(WiFi.macAddress()); //pritn MAC address
}

void loop() {
}

#include  //wifi 
#include  //esp now library

// UART to ATTINY1614
#define RX_PIN D7
#define TX_PIN D6 // pins UART

// Status LED
#define LED_N D9 //led on master

HardwareSerial Node1Serial(1); //uart conenction

// NODE2 MAC
uint8_t node2MAC[] = {0xE0, 0x72, 0xA1, 0xD7, 0x7D, 0x64}; //enter the MAC address

String rxBuffer = ""; //an empty text box that keeps incoming data from node 2 

// ESP-NOW message
typedef struct {
  char text[16]; //this is the  text message sthat the string rx buffer box can hold
} Message;

Message msg; //Creates a message object named msg.It is the actual container used to send or receive text.

// --------------------
// Blink Master LED
// --------------------
void blinkTwice() {

  for (int i = 0; i < 2; i++) {

    digitalWrite(LED_N, HIGH); //led on
    delay(500); //delay of .5seconds

    digitalWrite(LED_N, LOW); //led off
    delay(500); //delay of .5seconds
  }
}

// --------------------
// ESP-NOW Receive
// ESP32 package 3.3.7
// --------------------
void onReceive(const esp_now_recv_info_t *info, //the input received from node 1 or node 2
               const uint8_t *data,
               int len) {

  Message incoming;

  memcpy(&incoming, data, sizeof(incoming));

  if (strcmp(incoming.text, "TOUCH") == 0) {

    Node1Serial.println("LED_ON");

    blinkTwice();
  }
}

void setup() {

  Serial.begin(115200);  //baud rate

  pinMode(LED_N, OUTPUT); //led is output
  digitalWrite(LED_N, LOW); //led is off

  Node1Serial.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);

  WiFi.mode(WIFI_STA); //wifi hardware is on

  if (esp_now_init() != ESP_OK) {  //id esp conenction is fine 
    Serial.println("ESP-NOW Init Failed");
    return;
  }

  esp_now_register_recv_cb(onReceive); //run onReceive function when message arrives in ESP-NOW

  esp_now_peer_info_t peerInfo = {}; //stores info of the other board

  memcpy(peerInfo.peer_addr, node2MAC, 6); //Stores NODE 2's address so it knows where to send messages

  peerInfo.channel = 0; //if this is the condition 
  peerInfo.encrypt = false; //no encryption 

  esp_now_add_peer(&peerInfo);

  Serial.println("MASTER READY"); //serial print 
}

void loop() {

  while (Node1Serial.available()) {

    char c = Node1Serial.read();

    if (c == '\n' || c == '\r') {

      if (rxBuffer == "DARK") { //if phototranssitor is dark

        strcpy(msg.text, "SWEEP"); // if "DARK" then 180 degree sweep

        esp_now_send(node2MAC,
                     (uint8_t *)&msg,
                     sizeof(msg));

        blinkTwice(); //to do blink function 
      }

      rxBuffer = "";

    } else {

      rxBuffer += c;
    }
  }
}

Arduino IDE with ESP32 board package 
ESP-NOW communication 
MASTER: XIAO ESP32S3 , NODE 1: ATTINY1614 , NODE2: XIAO ESP32C6 
NODE 1: ATTINY1614
PA1 : LED-A
* LED_PIN, HIGH);  // LED ON
* LED_PIN, LOW);   // LED OFF
PA2 : PHOTOTRANSISTOR
* lightValue 0 = dark, 1023 = bright
 *(lightValue < 200 ) DARK
 *(lightValue < 600) DIM
send to MASTER (ESP32S3)  via UART
PB2 : TX , PB3 : RX

NODE2: XIAO ESP32C6
D0 : microServo MG90S
*Standard servos move 0-180. 
D6 : TOUCHPAD-N
* Receive ESP-NOW data
* const int TOUCH_THRESHOLD = 20000;  
 if (touchValue < TOUCH_THRESHOLD) {
    Serial.print("Touch Detected! Value: ");

MASTER (ESP32S3):
UART connection to NODE1
D6 : TX
D7 : RX
D9 : LED-N
* TRUE turns LED ON 
* FALSE turns LED OFF 

CONDITIONS 
Master connected to node 1 via UART. MATER to NODE 2 via ESP-NOW
action 1 - WHEN “Touch Detected “ IN TOUCHPAD-N  on NODE 2  , LED-A becomes LED_PIN, HIGH on NODE-1.
action 2 - When  PA2 : PHOTOTRANSISTOR light value is “DARK” , D0 : microServo MG90S on NODE 2 does 180degree sweep once.
When either one of these actions are complete on “D9 : LED-N” BLINKS TWICE with delay500 miliseconds on MASTER

Important: 
* Code must compile without errors 
* Use correct ESP-NOW callback signatures 
* Do not include unnecessary code 
* Keep CODES separate 
* Keep the code simple and beginner friendly 
* WiFi.mode(WIFI_STA); INCLUDE THIS ISN MAC ADDRESS CODE

GENERATE CODES IN THIS ORDER
code 1 : mac address : NODE-2 ESP32-C6
code 2: NODE-1 ATTINY1615
code 3: mac address : MASTER ESP32-S3
code 4: MASTER ESP32-S3
code 5: NODE-2 ESP32-C6
 GENERATE 1 CODE THEN TROUBLESHOOT AND THEN WILL ASK FOR THE NEXT CODE

  

#include 

void setup() {
  Serial.begin(115200); //baud rate
  delay(1000); //delay 1 second 

  WiFi.mode(WIFI_STA); //turn on wifi hardware

  Serial.println();
  Serial.print("ESP32-C6 MAC Address: "); //print ESP32-C6 MAC Address:
  Serial.println(WiFi.macAddress());  //the mac address
}

void loop() { //no loop added
}
  

const int PHOTO_PIN = PIN_PA2; //phototransistor conencted to PA2

void setup() {
  Serial.begin(9600); //baud rate
}

void loop() {

  int lightValue = analogRead(PHOTO_PIN); //read the ligthvalue in loop

  Serial.print("Value: "); // print in loop "Value:"
  Serial.print(lightValue); // print the light value 100 or 956

  if (lightValue > 1000) { //if ligth value is more the 1000 print as DARK
    Serial.println("  DARK");
  }
  else if (lightValue > 600) { //if light value more tha 600 print DIM
    Serial.println("  DIM");
  }
  else {
    Serial.println("  BRIGHT"); //orelse  print BRIGHT
  }

  delay(500); //the delay in printing is .5seconds
}
  

#include <WiFi.h> //library 
#include <esp_wifi.h>  //library

void setup() {
  Serial.begin(115200); //baud rate is 115200
  delay(2000);

  WiFi.mode(WIFI_STA); //turn on wifi hardware
  delay(1000);

  uint8_t mac[6]; //mac address
  esp_wifi_get_mac(WIFI_IF_STA, mac);

  Serial.printf(
    "ESP32-S3 MAC Address: %02X:%02X:%02X:%02X:%02X:%02X\n", //the MAC address format
    mac[0], mac[1], mac[2],
    mac[3], mac[4], mac[5]
  );
}

void loop() { //no loop
}
  

#include <WiFi.h>
#include <esp_now.h>

// NODE 2 ESP32-C6 MAC
uint8_t node2MAC[] = {0x7C, 0x2C, 0x67, 0x64, 0xBA, 0xF8}; //mac address of NODE 2 ESP32-C6 

#define MASTER_TX D6 //tx pin
#define MASTER_RX D7 //rx pin
#define LED_N     D9 //led on master

HardwareSerial Node1Serial(1); 

struct Message { //the message send or received 16 characters
  char text[16];
};

Message incomingMsg; //the incoming message

unsigned long ledOnTime = 0; //
bool ledTimerRunning = false;

// --------------------------------------------------
// Blink MASTER LED twice
// --------------------------------------------------
void blinkMasterLED() { //it pauses all actions and blinks LED twice fro confirmation
  for (int i = 0; i < 2; i++) {
    digitalWrite(LED_N, HIGH);
    delay(500);

    digitalWrite(LED_N, LOW);
    delay(500);
  }
}

// --------------------------------------------------
// Send ESP NOW message to NODE 2
// --------------------------------------------------
void sendToNode2(const char* text) { //add text into "struct Message" and transmits to NODE2
  Message msg;
  strcpy(msg.text, text);

  esp_now_send(node2MAC, (uint8_t*)&msg, sizeof(msg)); //sends the message to NODE 2
}

// --------------------------------------------------
// ESP NOW receive callback
// --------------------------------------------------
void onReceive(const esp_now_recv_info_t *info, //this an intruper trigger when node 2 send a message
               const uint8_t *data,
               int len) {

  memcpy(&incomingMsg, data, sizeof(incomingMsg));

  if (strcmp(incomingMsg.text, "TOUCH") == 0) { //if the incoming message is touch

    Node1Serial.println("LED_ON"); // the led turns high or on

    ledOnTime = millis(); //captures timestamp
    ledTimerRunning = true; //turns on for 

    blinkMasterLED(); // after action confirmation blink
  }
}

void setup() {

  Serial.begin(115200); //baud

  pinMode(LED_N, OUTPUT); //led is output
  digitalWrite(LED_N, LOW); //led is off

  // UART to NODE 1
  Node1Serial.begin(9600, SERIAL_8N1, MASTER_RX, MASTER_TX);

  // ESP NOW
  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) { //Initializes the ESP-NOW wireless protocol,
    Serial.println("ESP NOW Init Failed");
    return;
  }

  esp_now_register_recv_cb(onReceive); //function to listen for incoming data

  esp_now_peer_info_t peerInfo = {};

  memcpy(peerInfo.peer_addr, node2MAC, 6); //pairs the Master explicitly with NODE 2's MAC address
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  esp_now_add_peer(&peerInfo);

  Serial.println("MASTER READY"); //outputs "MASTER READY"
}

void loop() { //main loop

  // Read UART from NODE 1
  if (Node1Serial.available()) {  //Continuously listens for data coming from NODE 1

    String msg = Node1Serial.readStringUntil('\n');
    msg.trim();

Serial.print("UART Received: "); // to print the message from attiny
Serial.println(msg);

if (msg == "DARK") { //if teh message is dark then follow the below steps

  Serial.println("DARK detected"); //if DARK detected

  sendToNode2("SWEEP"); //do the sweep action

  blinkMasterLED(); //then blik the master led
}
  }

  // Turn LED-A OFF after 1 second
  if (ledTimerRunning) {

    if (millis() - ledOnTime >= 1000) { //if touch was send

      Node1Serial.println("LED_OFF"); //led turns off after 1 second

      ledTimerRunning = false;
    }
  }
}
  

#include <WiFi.h>
#include <esp_now.h> //esp-now
#include <ESP32Servo.h> // ESP32Servo library

const int SERVO_PIN = D0; //the pins 
const int TOUCH_PIN = D6;
const int TOUCH_THRESHOLD = 2000; // touch threshold adjusted to 2000

Servo myServo;

// MASTER ESP32-S3 MAC
uint8_t masterMAC[] = { // MAC ADRESS MASTER ESP32-S3
  0xE0, 0x72, 0xA1,
  0xD7, 0x7D, 0x64
};

struct Message { //the text box
  char text[16];
};

Message incomingMsg;

bool touchSent = false;

// --------------------------------------------------
// Servo Sweep
// --------------------------------------------------
void servoSweep() { //if touch is detected 

  myServo.write(0); //with delay of .3seconds at 0
  delay(300);

  myServo.write(180); //with delay of 1 second at 180degree sweep
  delay(1000);

  myServo.write(0);
  delay(1000);
}

// --------------------------------------------------
// Send ESP-NOW Message
// --------------------------------------------------
void sendToMaster(const char* text) { //to send text

  Message msg;
  strcpy(msg.text, text);

  esp_now_send(masterMAC, (uint8_t*)&msg, sizeof(msg));
}

// --------------------------------------------------
// Receive Callback
// --------------------------------------------------
void onReceive(const esp_now_recv_info_t *info,
               const uint8_t *data,
               int len) {

  memcpy(&incomingMsg, data, sizeof(incomingMsg)); //the incoming data

  if (strcmp(incomingMsg.text, "SWEEP") == 0) {

    Serial.println("SWEEP RECEIVED"); //when sweep i noted

    servoSweep();
  }
}

void setup() {

  Serial.begin(115200);

  myServo.attach(SERVO_PIN); // the servo pin has to move
  myServo.write(0);

  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW Init Failed");
    return;
  }

  esp_now_register_recv_cb(onReceive);

  esp_now_peer_info_t peerInfo = {};

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

  esp_now_add_peer(&peerInfo);

  Serial.println("NODE2 READY"); //prints node 2 readyw ehn uploaded
}

void loop() {

pinMode(TOUCH_PIN, OUTPUT);
digitalWrite(TOUCH_PIN, LOW);
delayMicroseconds(10);

pinMode(TOUCH_PIN, INPUT);

int count = 0;

while (digitalRead(TOUCH_PIN) == LOW) {
  count++;
}

Serial.print("Touch Value: ");
Serial.println(count);

if (count < TOUCH_THRESHOLD) {

  if (!touchSent) {

    Serial.println("TOUCH DETECTED"); //when count cycle is less than threshold value

    sendToMaster("TOUCH");

    touchSent = true;
  }
}
else {

  touchSent = false;
}
  delay(50);
}
  

 
i need two xiao boardS to communincate with eachother by ESP-NOW. CREATE SIMPLE ARDUINO CODES. XIAO ESP32C6 IS THE SENDER, HEREAFTER BE CALLED C6 XIAO ESP32S3 IS THE RECEIVER, HEREAFTER BE CALLED S3 RECEIVER MAC ID IS 30:30:f9:34:60:2c USE 115200 BAUD WHEN I PRESS THE TOUCH PAD (PIN D6) ON C6 BOARD . IN S3 BOARD I NEED THE LED CONNECTED TO PIN D9 TO TURN ON. Touched ≈ 70 Not touched ≈ 1000 TOUCH ARDUINO CODE: #define TOUCH_PIN D6 int threshold = 500; // adjust based on your readings void setup() { Serial.begin(115200); } void loop() { // Discharge pin pinMode(TOUCH_PIN, OUTPUT); digitalWrite(TOUCH_PIN, LOW); delayMicroseconds(10); // Switch to input and measure charge time pinMode(TOUCH_PIN, INPUT); int count = 0; while (digitalRead(TOUCH_PIN) == LOW) { count++; } Serial.print("Value: "); Serial.println(count); // Your case: touched = LOWER value if (count < threshold) { Serial.println("TOUCHED"); } else { Serial.println("NOT TOUCHED"); } Serial.println("------------------"); delay(1500); // slower (1.5 seconds) } LED BLINK TEST CODE: #define LED_PIN D9 // Define pin D9 void setup() { pinMode(LED_PIN, OUTPUT); // Set D9 as output } void loop() { digitalWrite(LED_PIN, HIGH); // Turn LED ON delay(1000); // Wait 1 second digitalWrite(LED_PIN, LOW); // Turn LED OFF delay(1000); // Wait 1 second } WRITE CODES REFERING THE ABOVE TO AVOID ERRORS. GIVE SIMPLE , CLEAN SENDER AND RECEIVER CODES, WITHOUT ERROR
 

        #include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

void setup() {
  // ATtiny1614 Serial (TX:PB2, RX:PB3)
  Serial.begin(9600); 
  Wire.begin(); // SCL:PB0, SDA:PB1

  if (!rtc.begin()) {
    while (1); // Stop if RTC not found
  }
}

void loop() {
  DateTime now = rtc.now();
  
  // We send just the "Seconds" as a string to simplify the trigger
  Serial.println(now.second()); 
  
  delay(1000); 
}
    

    #include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

BLECharacteristic *pCharacteristic;
bool deviceConnected = false;

// We need a class to handle connection status
class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) { deviceConnected = true; };
    void onDisconnect(BLEServer* pServer) { 
      deviceConnected = false; 
      BLEDevice::startAdvertising(); // Restart advertising when disconnected
      Serial.println("Device disconnected, restarting advertising...");
    }
};

void setup() {
  Serial.begin(115200);
  // On S3, Serial1 pins are 44 (RX) and 43 (TX)
  Serial1.begin(9600, SERIAL_8N1, 44, 43); 

  Serial.println("Initializing S3 BLE...");

  BLEDevice::init("XIAO_S3_SENDER");
  BLEServer *pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  BLEService *pService = pServer->createService(SERVICE_UUID);

  pCharacteristic = pService->createCharacteristic(
                      CHARACTERISTIC_UUID,
                      BLECharacteristic::PROPERTY_READ   |
                      BLECharacteristic::PROPERTY_WRITE  |
                      BLECharacteristic::PROPERTY_NOTIFY |
                      BLECharacteristic::PROPERTY_INDICATE
                    );

  pService->start();

  // Explicitly setup advertising
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);  
  pAdvertising->setMinPreferred(0x12);
  
  BLEDevice::startAdvertising();
  Serial.println("S3 is now advertising! Check your phone now.");
}

void loop() {
  // Check if ATtiny sent data
  if (Serial1.available()) {
    String tinyData = Serial1.readStringUntil('\n');
    tinyData.trim(); // Remove any hidden spaces/newlines
    
    if (tinyData.length() > 0) {
      pCharacteristic->setValue(tinyData.c_str());
      pCharacteristic->notify(); 
      Serial.print("Data from ATtiny sent to BLE: ");
      Serial.println(tinyData);
    }
  }
  
  // Heartbeat to Serial Monitor so you know the S3 hasn't crashed
  static unsigned long lastTime = 0;
  if (millis() - lastTime > 5000) {
    Serial.println("S3 is alive and waiting for ATtiny data...");
    lastTime = millis();
  }
}

#include <BLEDevice.h>
#include <ESP32Servo.h>


#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8" //The sender and receiver must use the same UUIDs to communicate.

Servo myServo; //UUID (Universally Unique Identifier) is a unique ID used in BLE to identify services and characteristics.
int servoPin = 0; // D0 on C6
static BLEUUID binServiceUUID(SERVICE_UUID);
static BLEUUID binCharUUID(CHARACTERISTIC_UUID);
bool doConnect = false;
BLERemoteCharacteristic* pRemoteChar;
BLEAdvertisedDevice* myDevice;

// --- UPDATED SERVO FUNCTION WITH REAL-TIME MONITORING ---
void sweepServo() {
  Serial.println(">>> 5 SECOND MARK DETECTED!");
  
  Serial.print("Moving to 180°... "); //moves 180 degree
  myServo.write(180); 
  Serial.println("[DONE]");
  
  delay(500); // Wait for the motor to physically reach the spot waits 0.5seconds
  
  Serial.print("Returning to 0°... "); //returns to 0 degree
  myServo.write(0);
  Serial.println("[DONE]");
  
  Serial.println("Sweep Cycle Complete. Waiting for next 5s mark...\n"); 
}

static void notifyCallback(BLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
  String val = "";
  for (int i = 0; i < length; i++) val += (char)pData[i];
  
  int seconds = val.toInt();
  Serial.print("RTC Time Received: "); 
  Serial.print(seconds);
  Serial.println("s");

  // Trigger sweep every 5 seconds
  if (seconds % 5 == 0 && seconds != 0) {
    sweepServo();
  }
}

class MyCallbacks: public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice advertisedDevice) {
    if (advertisedDevice.isAdvertisingService(binServiceUUID)) {
      BLEDevice::getScan()->stop();
      myDevice = new BLEAdvertisedDevice(advertisedDevice);
      doConnect = true;
    }
  }
};

void setup() {
  Serial.begin(115200);
  myServo.attach(servoPin);
  myServo.write(0); // Initialize at zero
  
  BLEDevice::init("XIAO_C6_RECEIVER");
  BLEScan* pScan = BLEDevice::getScan();
  pScan->setAdvertisedDeviceCallbacks(new MyCallbacks());
  pScan->setActiveScan(true);
  pScan->start(30);
  
  Serial.println("C6 Receiver Started. Scanning for S3 Sender...");
}

void loop() {
  if (doConnect) {
    BLEClient* pClient = BLEDevice::createClient();
    if(pClient->connect(myDevice)) {
      Serial.println("--- CONNECTED TO S3 SENDER ---");
      BLERemoteService* pService = pClient->getService(binServiceUUID);
      if (pService != nullptr) {
        pRemoteChar = pService->getCharacteristic(binCharUUID);
        if (pRemoteChar != nullptr) {
           pRemoteChar->registerForNotify(notifyCallback);
           Serial.println("Monitoring RTC data...");
        }
      }
    } else {
      Serial.println("Connection failed. Retrying scan...");
      BLEDevice::getScan()->start(30);
    }
    doConnect = false;
  }
}