Embedded Networking and Communications

#define TX_PIN 5  // GPIO5 for TX
#define RX_PIN 4  // GPIO4 for RX

void setup() {
    Serial.begin(115200);       // USB Serial for debugging
    Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);  // UART communication
}

void loop() {
    Serial1.println("Hello from Master!"); // Send test message
    Serial.println("Sent: Hello from Master!");

    delay(2000);
}
  

#define TX_PIN 5  // GPIO5 for TX
#define RX_PIN 4  // GPIO4 for RX

void setup() {
    Serial.begin(115200);       // USB Serial for debugging
    Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);  // UART communication
}

void loop() {
    if (Serial1.available()) {
        String received = Serial1.readStringUntil('\n');
        Serial.print("Received: ");
        Serial.println(received);
    }
}
  

#define SENSOR_PIN 4   // Define the ADC pin (use a safe GPIO)
#define REF_VOLTAGE 3.3 // ESP32-C3 operates on 3.3V
#define ADC_RESOLUTION 4095 // 12-bit ADC resolution (0-4095)

float voltageDividerFactor = 4.3;  // Adjust based on the sensor calibration

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

void loop() {
    int adcValue = analogRead(SENSOR_PIN);  // Read ADC value
    float voltage = (adcValue * REF_VOLTAGE) / ADC_RESOLUTION;  // Convert ADC to voltage
    float measuredVoltage = voltage * voltageDividerFactor; // Adjust based on sensor ratio


    Serial.print("Voltage: ");
    Serial.print(measuredVoltage);
    Serial.println("V");

    delay(500);  // Read every second
}

  
#define TX_PIN 21
#define RX_PIN 20
#define SENSOR_PIN 4   // Define the ADC pin (use a safe GPIO)
#define REF_VOLTAGE 3.3 // ESP32-C3 operates on 3.3V
#define ADC_RESOLUTION 4095 // 12-bit ADC resolution (0-4095)

float voltageDividerFactor = 4.3;  // Adjust based on the sensor calibration

void setup() {
    Serial.begin(115200);     
    Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN); 


}

void loop() {
  int adcValue = analogRead(SENSOR_PIN);  // Read ADC value
  float voltage = (adcValue * REF_VOLTAGE) / ADC_RESOLUTION;  // Convert ADC to voltage
  float measuredVoltage = voltage * voltageDividerFactor; // Adjust based on sensor ratio

    Serial1.println(measuredVoltage); 
    Serial.print("Sent:measuredVoltage=");
    Serial.print(measuredVoltage);
   Serial.println("V");
    delay(1000);
}

#include Wire.h
#include LiquidCrystal_I2C.h
#define TX_PIN 21  
#define RX_PIN 20  
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
    Serial.begin(115200);       
    Serial1.begin(9600, SERIAL_8N1, RX_PIN, TX_PIN);  
   lcd.begin();
    lcd.backlight();
}

void loop() {
    if (Serial1.available()) {
        String receivedData = Serial1.readStringUntil('\n'); 
        receivedData.trim();  
        Serial.print("Received: ");
        Serial.println(receivedData);
         lcd.setCursor(0, 0);
        lcd.print("measuredVoltage"); // Add spaces to clear previous text
        lcd.setCursor(0, 1);
        lcd.print(receivedData);
   }
    }

  
#include WiFi.h

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

    WiFi.mode(WIFI_STA); // Set ESP32 to Station mode
    delay(100); // Small delay to ensure mode is set

    // Get MAC address
    Serial.print("ESP32-C3 MAC Address: ");
    Serial.println(WiFi.macAddress());
}

void loop() {
    // Do nothing
}
  
  

	
	
#include WiFi.h
#include esp_now.h


uint8_t receiverMAC[] = {0xD4, 0xF9, 0x8D, 0x04, 0x42, 0x64}; // Change to actual receiver MAC

// Data structure to send
typedef struct struct_message {
    int value;
} struct_message;

struct_message myData;

// Callback when data is sent
void onDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
    Serial.print("Send Status: ");
    Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Success" : "Fail");
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA); // Set ESP32 to Station mode

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

    esp_now_register_send_cb(onDataSent);

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

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

void loop() {
    myData.value = random(1, 100);;

    // Send data
    esp_err_t result = esp_now_send(receiverMAC, (uint8_t *)&myData, sizeof(myData));

    if (result == ESP_OK) {
        Serial.println("Sent successfully");
    } else {
        Serial.println("Error sending data");
    }

    delay(2000); // Send every 2 seconds
}
	
	
	
	

	
	
#include WiFi.h
#include esp_now.h


uint8_t receiverMAC[] = {0xD4, 0xF9, 0x8D, 0x04, 0x42, 0x64}; // Change to actual receiver MAC

// Data structure to send
typedef struct struct_message {
    int value;
} struct_message;

struct_message myData;

// Callback when data is sent
void onDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
    Serial.print("Send Status: ");
    Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Success" : "Fail");
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA); // Set ESP32 to Station mode

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

    esp_now_register_send_cb(onDataSent);

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

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

void loop() {
    myData.value = random(1, 100);;

    // Send data
    esp_err_t result = esp_now_send(receiverMAC, (uint8_t *)&myData, sizeof(myData));

    if (result == ESP_OK) {
        Serial.println("Sent successfully");
    } else {
        Serial.println("Error sending data");
    }

    delay(2000); // Send every 2 seconds
}
	
	
	

#define SENSOR_PIN 4   // ADC GPIO4
#define SENSITIVITY 185  // 185mV/A for 5A module (Change for your module)
#define ADC_RESOLUTION 4096  // 12-bit ADC (ESP32)
#define V_REF 3300  // ESP32 ADC Reference Voltage (mV)

const int numSamples = 100;  
float zeroPoint;  

void setup() {
    Serial.begin(115200);
    pinMode(SENSOR_PIN, INPUT);
    delay(2000);

    // Measure idle voltage (zero current)
    long sum = 0;
    for (int i = 0; i < numSamples; i++) {
        sum += analogReadMilliVolts(SENSOR_PIN);
        delay(10);
    }
    zeroPoint = sum / numSamples;
    Serial.print("Zero Point (No Current): ");
    Serial.print(zeroPoint);
    Serial.println(" mV");
}

float readACCurrent() {
    float sumSquared = 0;

    for (int i = 0; i < numSamples; i++) {
        float voltage = analogReadMilliVolts(SENSOR_PIN);  
        float current = (voltage - zeroPoint) / SENSITIVITY;  
        sumSquared += current * current;
        delay(1);
    }

    return sqrt(sumSquared / numSamples);  
}

void loop() {
    float acCurrent = readACCurrent();
    Serial.print("AC Current RMS: ");
    Serial.print(acCurrent, 3);
    Serial.println(" A");
    delay(1000);
}
	
	

  
#include WiFi.h
#include esp_now.h


#define SENSOR_PIN 4   // ADC GPIO4
#define SENSITIVITY 185  // 185mV/A for 5A module (Change for your module)
#define ADC_RESOLUTION 4096  // 12-bit ADC (ESP32)
#define V_REF 3300  // ESP32 ADC Reference Voltage (mV)

const int numSamples = 100;  
float zeroPoint;  

uint8_t receiverMAC[] = {0xD4, 0xF9, 0x8D, 0x04, 0x42, 0x64}; // Change to actual receiver MAC

// Data structure to send
typedef struct struct_message {
     float value;
} struct_message;

struct_message myData;

// Callback when data is sent
void onDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
    Serial.print("Send Status: ");
    Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Success" : "Fail");
}

void setup() {
    Serial.begin(115200);
  pinMode(SENSOR_PIN, INPUT);
    delay(500);

    // Measure idle voltage (zero current)
    long sum = 0;
    for (int i = 0; i < numSamples; i++) {
        sum += analogReadMilliVolts(SENSOR_PIN);
        delay(10);
    }
    zeroPoint = sum / numSamples;
    Serial.print("Zero Point (No Current): ");
    Serial.print(zeroPoint);
    Serial.println(" mV");    
    WiFi.mode(WIFI_STA); // Set ESP32 to Station mode

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

    esp_now_register_send_cb(onDataSent);

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

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

float readACCurrent() {
    float sumSquared = 0;

    for (int i = 0; i < numSamples; i++) {
        float voltage = analogReadMilliVolts(SENSOR_PIN);  
        float current = (voltage - zeroPoint) / SENSITIVITY;  
        sumSquared += current * current;
        delay(1);
    }

    return sqrt(sumSquared / numSamples);  
}

void loop() {
    float acCurrent = readACCurrent();
    Serial.print("Current R
    MS: ");
    Serial.print(acCurrent, 3);
    Serial.println(" A");
    myData.value =acCurrent;

    // Send data
    esp_err_t result = esp_now_send(receiverMAC, (uint8_t *)&myData, sizeof(myData));

    if (result == ESP_OK) {
        Serial.println("Sent successfully");
    } else {
        Serial.println("Error sending data");
    }

    delay(200); // Send every 2 seconds
}

  
  

  
#include WiFi.h
#include esp_now.h
#include Wire.h
#include Adafruit_GFX.h
#include Adafruit_SSD1306.h

// OLED display width and height
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

// Create display object
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Structure to receive data
typedef struct struct_message {
     float value;
} struct_message;

struct_message myData;

// New ESP-IDF v5.x compatible callback
void onDataRecv(const esp_now_recv_info_t *info, const uint8_t *incomingData, int len) {
    memcpy(&myData, incomingData, sizeof(myData));
    Serial.print("Received Value: ");
    Serial.print(myData.value);
    Serial.println(" A");
   
}

void setup() {
    Serial.begin(115200);
 // Initialize OLED display
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // 0x3C is the I2C address
    Serial.println(F("SSD1306 allocation failed"));
    while (1); // Halt execution
  }

  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
    WiFi.mode(WIFI_STA); // Set ESP32 to Station mode

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

    esp_now_register_recv_cb(onDataRecv); // Register new ESP-NOW receive callback
}

void loop() {
display.clearDisplay();
  display.setCursor(0, 0);
  display.print("Pradeep");
    display.setCursor(0, 18);
  display.print("CurrentRMS");
      display.setCursor(10, 40);
  display.print(myData.value);
        display.setCursor(60, 40);
  display.print("A");
  display.display();
    // Do nothing, waiting for ESP-NOW messages
}

  
  

  #include WiFi.h
#include HTTPClient.h

// Replace with your WiFi credentials
const char* ssid = "FABLAB";
const char* password = "12345678";

// Replace with your ThingSpeak Write API Key
const char* apiKey = "15DBNHTNHL25YMYN";

// ThingSpeak API URL
const char* server = "http://api.thingspeak.com/update";

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    
    Serial.print("Connecting to WiFi...");
    while (WiFi.status() != WL_CONNECTED) {
        Serial.print(".");
        delay(1000);
    }
    Serial.println("\nConnected to WiFi!");
}

void loop() {
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        
        // Generate random values
        int value1 = random(20, 40);  // Example: Temperature
        int value2 = random(30, 60);  // Example: Humidity
        int value3 = random(100, 500); // Example: Light Intensity

        // Construct the request URL
        String url = String(server) + "?api_key=" + apiKey + 
                     "&field1=" + String(value1) + 
                     "&field2=" + String(value2) + 
                     "&field3=" + String(value3);

        Serial.println("Sending data to ThingSpeak...");
        Serial.println(url);

        // Send data to ThingSpeak
        http.begin(url);
        int httpCode = http.GET();
        
        if (httpCode > 0) {
            Serial.println("Data sent successfully!");
        } else {
            Serial.println("Failed to send data.");
        }
        
        http.end();
    } else {
        Serial.println("WiFi Disconnected!");
    }

    delay(15000); // ThingSpeak allows updates every 15 seconds
}

  
#include WiFi.h
#include HTTPClient.h
#include Wire.h
#include Adafruit_GFX.h
#include Adafruit_SSD1306.h

// OLED display width and height
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

// Create display object
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
#define VOLTAGE_SENSOR_PIN A2   // ADC pin for voltage sensor
#define CURRENT_SENSOR_PIN A0  // ADC pin for ACS712 current sensor

#define REF_VOLTAGE 3.3  // ESP32-C3 operates on 3.3V
#define ADC_RESOLUTION 4095  // 12-bit ADC (0-4095)

#define SENSITIVITY 185  // Set this based on your ACS712 module: (5A = 185mV/A, 20A = 100mV/A, 30A = 66mV/A)
#define VOLTAGE_DIVIDER_FACTOR 4.3  // Adjust based on calibration

const int numSamples = 200;  
float zeroPoint = 0;  

// Replace with your WiFi credentials
const char* ssid = "FABLAB";
const char* password = "12345678";

// Replace with your ThingSpeak Write API Key
const char* apiKey = "9HO2SSQ4PUUDVWAY";

// ThingSpeak API URL
const char* server = "http://api.thingspeak.com/update";

void setup() {
Serial.begin(115200);
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // 0x3C is the I2C address
Serial.println(F("SSD1306 allocation failed"));
while (1); // Halt execution
}

display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
pinMode(VOLTAGE_SENSOR_PIN, INPUT);
pinMode(CURRENT_SENSOR_PIN, INPUT);
delay(500);

// Calibrate Zero Point (Idle Voltage when NO Load)
long sum = 0;
for (int i = 0; i < numSamples; i++) {
sum += analogReadMilliVolts(CURRENT_SENSOR_PIN);
delay(5);
}
zeroPoint = sum / numSamples;
Serial.print("Zero Point (No Load): ");
Serial.print(zeroPoint);
Serial.println(" mV");


WiFi.begin(ssid, password);

Serial.print("Connecting to WiFi...");
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(100);
}
Serial.println("\nConnected to WiFi!");
}
// Function to measure AC Current RMS correctly
float readACCurrent() {
float sumSquared = 0;
for (int i = 0; i < numSamples; i++) {
float voltage = analogReadMilliVolts(CURRENT_SENSOR_PIN);  
float current = (voltage - zeroPoint) / SENSITIVITY;  
sumSquared += current * current;
delayMicroseconds(50);  // Sampling rate improvement
}
return sqrt(sumSquared / numSamples);  // RMS Current Calculation
}

// Function to measure Voltage
float readVoltage() {
int adcValue = analogRead(VOLTAGE_SENSOR_PIN);
float voltage = (adcValue * REF_VOLTAGE) / ADC_RESOLUTION;  
return voltage * VOLTAGE_DIVIDER_FACTOR;  // Adjust with divider factor
}
void loop() {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
float voltage = readVoltage();  
float current = readACCurrent();  
float power = voltage * current;  // Power Calculation: P = V * I
display.clearDisplay();
display.setCursor(0, 0);
display.print("volt=");
display.setCursor(70, 0);
display.print(voltage);
display.setCursor(0, 18);
display.print("Amp=");
display.setCursor(60, 18);
display.print(current);
display.setCursor(0, 40);
display.print("power=");
display.setCursor(80, 40);
display.print(power);
display.display();
Serial.print("Voltage: ");
Serial.print(voltage);
Serial.print(" V  |  AC Current: ");
Serial.print(current, 3);
Serial.print(" A  |  Power: ");
Serial.print(power, 3);
Serial.println(" W");
// Generate random values
float value1 = voltage;  // Example: Temperature
float value2 = current;  // Example: Humidity
float value3 =power; // Example: Light Intensity

// Construct the request URL
String url = String(server) + "?api_key=" + apiKey + 
            "&field1=" + String(value1) + 
            "&field2=" + String(value2) + 
            "&field3=" + String(value3);

Serial.println("Sending data to ThingSpeak...");
Serial.println(url);

// Send data to ThingSpeak
http.begin(url);
int httpCode = http.GET();

if (httpCode > 0) {
  Serial.println("Data sent successfully!");
} else {
  Serial.println("Failed to send data.");
}

http.end();
} else {
Serial.println("WiFi Disconnected!");
}

delay(500); // ThingSpeak allows updates every 15 seconds
}