NETWORKING & COMMUNICATIONS

📂 OPEN GROUP ASSIGNMENT

1. Packets & Overhead

HTTP is a "heavy" protocol. Every time my ESP32 requests or sends data via HTTP, it must send massive textual headers (Cookies, User-Agent, Accept, etc.), often exceeding 500 bytes just to send a 2-byte sensor reading. MQTT, on the other hand, has a fixed, ultra-lightweight header of only 2 Bytes.

2. Speed & Latency

Because MQTT packets are tiny, the transmission speed is significantly faster, and it requires far less bandwidth. For a project where I need real-time target detection, the latency of opening and closing TCP connections for every HTTP request is unacceptable. MQTT keeps a persistent connection open to a Broker.

3. Publish / Subscribe Architecture

HTTP uses a strict Request/Response model (the client must ask for data). MQTT uses a Pub/Sub model. My ESP32 simply "Publishes" data to a topic, and any node "Subscribed" to that topic receives the data instantly.

The HTML interface rendered directly from the ESP32 memory.

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

// MAC Address of the Master Board (Receiver)
uint8_t masterAddress[] = {0x48, 0x27, 0xE2, 0x11, 0x22, 0x33};

// Structure to package the data
typedef struct struct_message {
  float impact_speed;
  int zone;
} struct_message;

struct_message myData;
esp_now_peer_info_t peerInfo;

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

// Callback: When data is received (On Master)
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.print("Bytes received: ");
  Serial.println(len);
  Serial.print("Speed: "); Serial.println(myData.impact_speed);
}

void setup() {
  Serial.begin(115200);
  
  // Set ESP32 as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

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

  // Register the peer
  memcpy(peerInfo.peer_addr, masterAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
  // Add peer        
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
}

void loop() {
  // Send data from Slave to Master
  myData.impact_speed = 85.5;
  myData.zone = 2;
  
  esp_err_t result = esp_now_send(masterAddress, (uint8_t *) &myData, sizeof(myData));
  delay(2000);
}

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH110X.h>

#define i2c_Address 0x3C
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1

#define SHT31_ADDR 0x44   

Adafruit_SH1106G display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

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

  Wire.begin();

  if (!display.begin(i2c_Address, true)) {
    Serial.println("Fail to initialize OLED SH110X");
    while (1);
  }

  display.clearDisplay();
  display.setTextColor(SH110X_WHITE);
  display.setTextSize(1);
  display.setCursor(10, 20);
  display.println("Starting...");
  display.display();
  delay(1000);
}

void loop() {
  // SEND COMMAND TO SHT3X
  Wire.beginTransmission(SHT31_ADDR);
  Wire.write(0x24); // Measurement High Repeatability
  Wire.write(0x00);

  if (Wire.endTransmission() != 0) {
    Serial.println("Error sending command");
    return;
  }
  delay(20);

  // READ DATA (6 Bytes)
  Wire.requestFrom(SHT31_ADDR, 6);

  if (Wire.available() == 6) {
    uint8_t data[6];
    for (int i = 0; i < 6; i++) {
      data[i] = Wire.read();
    }

    uint16_t rawTemp = (data[0] << 8) | data[1];
    uint16_t rawHum  = (data[3] << 8) | data[4];

    float temperature = -45.0 + (175.0 * rawTemp / 65535.0);
    float humidity    = 100.0 * rawHum / 65535.0;

    // Show on OLED
    display.clearDisplay();
    display.setTextSize(1);
    display.setCursor(10, 10);
    display.println("SHT3X Sensor Node");

    display.setTextSize(2);
    display.setCursor(10, 25);
    display.print(temperature, 1);
    display.print(" C");

    display.setCursor(10, 45);
    display.print(humidity, 1);
    display.print(" %");

    display.display();
  }
  delay(2000);
}

#include <Arduino.h>
#include <Wire.h>
#include <WiFi.h>
#include <WebServer.h>

#define SHT31_ADDR 0x44

const char* ssid = "RoyZ";
const char* password = "Zarate28";

WebServer server(80); // Port 80 is standard for HTTP

float temperature = 0.0;
float humidity = 0.0;

// Function to read sensor via I2C
void readSHT3X() {
  Wire.beginTransmission(SHT31_ADDR);
  Wire.write(0x24);
  Wire.write(0x00);
  if (Wire.endTransmission() != 0) return;
  delay(20);

  Wire.requestFrom(SHT31_ADDR, 6);
  if (Wire.available() == 6) {
    uint8_t data[6];
    for (int i = 0; i < 6; i++) { data[i] = Wire.read(); }
    uint16_t rawTemp = (data[0] << 8) | data[1];
    uint16_t rawHum  = (data[3] << 8) | data[4];

    temperature = -45.0 + (175.0 * rawTemp / 65535.0);
    humidity    = 100.0 * rawHum / 65535.0;
  }
}

// Function to serve the Web Page
void handleRoot() {
  readSHT3X(); // Get fresh data

  // Construct HTML with CSS and Auto-Refresh tag
  String html = R"rawliteral(
  <!DOCTYPE html>
  <html>
  <head>
    <meta charset="UTF-8">
    <meta http-equiv="refresh" content="2"> 
    <title>SHT3X Monitor</title>
    <style>
      body { font-family: Arial; text-align: center; background-color: #111; color: white; margin-top: 50px;}
      .card { background: #222; display: inline-block; padding: 30px; border-radius: 20px; box-shadow: 0 0 20px rgba(255,255,255,0.1); }
      h1 { font-size: 32px; }
      p { font-size: 28px; margin: 20px 0; }
    </style>
  </head>
  <body>
    <div class="card">
      <h1>SHT3X Sensor</h1>
      <p>🌡 Temperature: )rawliteral";

  html += String(temperature, 1);
  html += R"rawliteral( °C</p>
      <p>💧 Humidity: )rawliteral";

  html += String(humidity, 1);
  html += R"rawliteral( %</p>
    </div>
  </body>
  </html>
  )rawliteral";

  server.send(200, "text/html", html); // Push to client
}

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

  Wire.begin();
  WiFi.begin(ssid, password);

  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("IP: ");
  Serial.println(WiFi.localIP()); // Print IP so user can connect

  // Start Server Routing
  server.on("/", handleRoot);
  server.begin();
  Serial.println("HTTP Server started");
}

void loop() {
  // Constantly listen for incoming clients (Laptops, Phones)
  server.handleClient();
}