Week 11 - Alejandro Reyes - Fab Academy documentation

Main Protocol

I2C communication

Main Hardware

ESP32-C6 and MAX30102

Main Goal

Establish communication between embedded devices and sensors.

Assignments

Group Assignment

Send a message between two projects.
Document your work to the group work page and reflect on your individual page what you learned.

Individual Assignment

Design, build and connect wired or wireless node(s) with network or bus addresses and a local input and/or output device(s).

Group Assignment

Group Assignment – Networking and Communications

During the group assignment we explored different communication protocols commonly used in embedded systems and IoT projects.

We analyzed how each protocol works, its advantages, limitations and possible applications depending on the project requirements.

Understanding these protocols helped me decide which communication method was the most suitable for my wearable biometric project.

Communication Protocols

Different communication protocols offer different advantages depending on speed, distance, power consumption and system complexity.

During this week I researched and tested several common protocols used in embedded systems and IoT applications.

Different standard communication protocols

Wiring

Connect the two boards like this:

Controller (SDA) to Target (SDA)
Controller (SCL) to Target (SCL)
Controller GND to Target GND
4.7 kOhm pull-up from SDA to 3.3 V
4.7 kOhm pull-up from SCL to 3.3 V

Main code steps

Controller

Include Wire.h.
Start I2C with Wire.begin(SDA_PIN, SCL_PIN, frequency).
Send data using Wire.beginTransmission(address) and Wire.write(...).
Finish transmission with Wire.endTransmission().
Request data from the Target using Wire.requestFrom(...).
Read the response using Wire.read().

Target

Include Wire.h.
Create a receive callback using Wire.onReceive(...).
Create a request callback using Wire.onRequest(...).
Start slave mode with Wire.begin(address, SDA_PIN, SCL_PIN, frequency).
Store received data in a variable.
Return data when the Controller requests it.

When to Use I2C

I2C is recommended in situations where you need to connect multiple low-speed devices using only two wires (SDA and SCL). It is especially useful in embedded systems where pin availability is limited.

When connecting multiple sensors or modules to a single microcontroller.
When you need a simple communication bus between a controller and several target devices.
When wiring simplicity is important, since I2C only uses two communication lines.
For short-distance communication on the same PCB or within the same device enclosure.
When devices support addressing, allowing many components to share the same bus.

I2C is not ideal for high-speed or long-distance communication. In those cases, protocols like SPI or UART may be more suitable.

Main Code Steps (Wi-Fi Web Server)

Include WiFi.h and WebServer.h.
Set your Wi-Fi SSID and password.
Connect to the network using WiFi.begin(...).
Create a WebServer object.
Define functions for each route (endpoints).
Register routes using server.on(...).
Start the server with server.begin().
Call server.handleClient() inside the main loop.

HTTP Communication Between Two Boards on the Same Network

Two boards can communicate through HTTP when both are connected to the same Wi-Fi network and one board knows the IP address of the other.

In this setup:

Board A works as the HTTP server.
Board B works as the HTTP client.
Board B sends requests such as GET /sensor or GET /led/on to Board A.
Board A responds with data in formats such as plain text, JSON, or other structured responses.

Steps to Run the System

Upload the server sketch to Board A.
Open the Serial Monitor and note the IP address printed by Board A.
Insert that IP address into the client sketch on Board B.
Upload the client sketch to Board B.
Board B sends HTTP requests to Board A at regular intervals.
Board A responds with a text message.
Board B prints the received response in the Serial Monitor.

When to Use Wi-Fi (HTTP Communication)

Wi-Fi with HTTP is recommended when you need wireless communication between devices that are already connected to the same network or have access to a router or hotspot.

When communicating between two or more microcontrollers over a local network.
When sending sensor data to a web browser, dashboard, or local server.
When remote control of devices is needed using simple HTTP requests (GET/POST).
When integrating embedded systems with web services or APIs.
When longer range communication is required compared to I2C or SPI.

Wi-Fi HTTP is not ideal for low-power applications or real-time critical systems, since it has higher latency and power consumption compared to simpler communication protocols.

Main Code Steps (MQTT Communication)

Include WiFi.h and PubSubClient.h.
Connect to a Wi-Fi network.
Create a Wi-Fi client and an MQTT client.
Set the MQTT broker address and port.
Define a callback function to handle incoming messages.
Reconnect automatically if the connection is lost.
Publish sensor data or messages periodically.
Subscribe to a command topic to receive instructions.

When to Use Wi-Fi (MQTT Communication)

MQTT over Wi-Fi is recommended for lightweight, efficient, and scalable communication between embedded devices and servers, especially in IoT systems.

When multiple devices need to publish and receive data through a central broker.
When working with IoT applications that require real-time sensor monitoring.
When low bandwidth and low power consumption are important.
When devices need to communicate over unreliable or intermittent networks.
When building scalable systems with many nodes (smart home, industrial monitoring, etc.).

MQTT is not ideal for direct device-to-device communication without a broker, or for applications that require complex request-response logic like HTTP.

Important Note (MAC Address)

Each receiver has a unique MAC address. The sender must know the receiver’s MAC address in order to communicate with it.

A simple way to find it is to upload the following temporary sketch to the receiver board once:

#include <WiFi.h>

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

            void loop() {
            }

After uploading, open the Serial Monitor to read and copy the MAC address. Then, place that MAC address in the sender code.

Main Code Steps (ESP-NOW Communication)

Sender

Include WiFi.h and esp_now.h.
Set Wi-Fi mode to WIFI_STA.
Initialize ESP-NOW.
Register the peer using its MAC address.
Build a data packet (struct or array).
Send the packet using esp_now_send(...).

Receiver

Include WiFi.h and esp_now.h.
Set Wi-Fi mode to WIFI_STA.
Initialize ESP-NOW.
Register a receive callback function.
Read and process the incoming struct data.

When to Use ESP-NOW

ESP-NOW is recommended for fast, low-power, and direct communication between ESP devices without the need for a Wi-Fi router or internet connection.

When devices need to communicate directly without a network infrastructure (router or access point).
When low latency and fast response time are required.
When working with battery-powered or low-power embedded systems.
When sending small data packets between multiple ESP boards.
When building simple sensor networks, remote controls, or wireless triggers.

ESP-NOW is not suitable for large data transfers, internet-based communication, or systems that require standard IP networking and web integration.

Workflow Overview

1. Protocol Research

Study different communication protocols and compare their characteristics.

2. Hardware Integration

Connect the MAX30102 sensor to the ESP32-C6 using I2C communication.

3. Programming and Testing

Validate stable communication and biometric data acquisition.

Why I Chose I2C

Since the MAX30102 sensor communicates using SDA and SCL pins and the ESP32-C6 board is physically close to the sensor, I2C communication was the best option for this project.

I2C simplifies wiring, reduces the number of required pins and provides stable communication between embedded devices.

These are the pinouts used for the connection:

Programming

The code initializes the MAX30102 sensor using I2C communication and continuously processes biometric heart rate data.

The program also filters noise, calculates BPM averages and activates physical outputs depending on heart rate variations.


#include <Wire.h>
#include "MAX30105.h"
#include "heartRate.h"

MAX30105 particleSensor;

const int LED_PIN = D1;
const int MOTOR_PIN = D2;

const byte RATE_SIZE = 12;

byte rates[RATE_SIZE];

byte rateSpot = 0;

long lastBeat = 0;

float beatsPerMinute;

int beatAvg;

bool baseEstablecida = false;

int muestrasCalibracion = 0;

const int TOTAL_MUESTRAS_CAL = 20;

float sumaCalibracion = 0;

float pulsoBase = 0;

int altosConsecutivos = 0;

const int MINIMO_PULSOS_ALTO = 3;

bool alertaActiva = false;

void setup() {

  Serial.begin(115200);

  delay(1000);

  pinMode(LED_PIN, OUTPUT);

  pinMode(MOTOR_PIN, OUTPUT);

  digitalWrite(LED_PIN, LOW);

  digitalWrite(MOTOR_PIN, LOW);

  Wire.begin(22, 23);

  if (!particleSensor.begin(Wire, I2C_SPEED_FAST)) {

    Serial.println("MAX30102 no encontrado");

    while (1);

  }

  byte ledBrightness = 60;

  byte sampleAverage = 1;

  byte ledMode = 2;

  int sampleRate = 200;

  int pulseWidth = 411;

  int adcRange = 4096;

  particleSensor.setup(
    ledBrightness,
    sampleAverage,
    ledMode,
    sampleRate,
    pulseWidth,
    adcRange
  );

}

void loop() {

  long irValue = particleSensor.getIR();

  if (irValue < 50000) {

    digitalWrite(LED_PIN, LOW);

    digitalWrite(MOTOR_PIN, LOW);

    delay(500);

    return;

  }

  if (checkForBeat(irValue) == true) {

    long delta = millis() - lastBeat;

    lastBeat = millis();

    beatsPerMinute = 60 / (delta / 1000.0);

    if (beatsPerMinute < 140 &&
        beatsPerMinute > 40) {

      rates[rateSpot++] =
      (byte)beatsPerMinute;

      rateSpot %= RATE_SIZE;

      int sum = 0;

      for (byte x = 0; x < RATE_SIZE; x++) {

        sum += rates[x];

      }

      beatAvg = sum / RATE_SIZE;

      if (!baseEstablecida) {

        sumaCalibracion += beatsPerMinute;

        muestrasCalibracion++;

        if (muestrasCalibracion >=
            TOTAL_MUESTRAS_CAL) {

          pulsoBase =
          sumaCalibracion /
          TOTAL_MUESTRAS_CAL;

          baseEstablecida = true;

        }

      }

      else {

        float dif =
        beatAvg - pulsoBase;

        if (dif >= 4.0) {

          altosConsecutivos++;

          if (altosConsecutivos >=
              MINIMO_PULSOS_ALTO)

            alertaActiva = true;

        }

        else {

          altosConsecutivos = 0;

          alertaActiva = false;

        }

        if (alertaActiva) {

          digitalWrite(LED_PIN, HIGH);

          digitalWrite(MOTOR_PIN, HIGH);

        }

        else {

          digitalWrite(LED_PIN, LOW);

          digitalWrite(MOTOR_PIN, LOW);

        }

      }

    }

  }

}

Code Explanation

Sensor Initialization

Initializes I2C communication and prepares the MAX30102 sensor for biometric readings.

BPM Filtering

Uses averaging and filtering methods to reduce noise and stabilize BPM measurements.

Calibration

Establishes a baseline heart rate before entering monitoring mode.

Alert System

Activates the LED and vibration motor when BPM exceeds the baseline threshold.

Testing the Code

During testing I monitored the BPM values through the Serial Monitor to validate stable communication and heart rate detection.

Debugging and Problems

Motion Artifacts

Wrist movement still generates false BPM peaks during measurements.

Unstable Calibration

Noisy readings can still affect the baseline BPM calculation.

IR Signal Sensitivity

The infrared readings are highly sensitive to pressure and movement.

Communication Stability

Incorrect wiring or unstable connections can interrupt I2C communication.

Connection to My Final Project

This week is directly related to my wearable biometric project because communication between the sensor and the microcontroller is essential for real-time monitoring.

I2C communication allows stable biometric data transfer while keeping the wearable system compact and efficient.

In future iterations I may integrate BLE or ESP-NOW to send biometric information wirelessly to external devices.

Real-Time Monitoring

Stable communication is critical for reliable biometric sensing.

Wearable Integration

I2C simplifies the internal wiring of the wearable system.

Future Wireless Features

Wireless communication protocols could expand the project capabilities.

Downloadable Files

Download Project Files

To download the zipe click here to go to week 10 page and download the files from there, as they are the same.

Week 11: Networking and Communications

Main Protocol

Main Hardware

Main Goal

Assignments

Group Assignment

Individual Assignment

Group Assignment

Communication Protocols

Different standard communication protocols

Wiring

Main code steps

Controller

Target

When to Use I2C

Main Code Steps (Wi-Fi Web Server)

HTTP Communication Between Two Boards on the Same Network

Steps to Run the System

When to Use Wi-Fi (HTTP Communication)

Main Code Steps (MQTT Communication)

When to Use Wi-Fi (MQTT Communication)

Important Note (MAC Address)

Main Code Steps (ESP-NOW Communication)

Sender

Receiver

When to Use ESP-NOW

Main Code Steps (BLE Communication)

When to Use BLE (Bluetooth Low Energy)

Workflow Overview

1. Protocol Research

2. Hardware Integration

3. Programming and Testing

Why I Chose I2C

Programming

Code Explanation

Sensor Initialization

BPM Filtering

Calibration

Alert System

Testing the Code

Debugging and Problems

Motion Artifacts

Unstable Calibration

IR Signal Sensitivity

Communication Stability

Connection to My Final Project

Real-Time Monitoring

Wearable Integration

Future Wireless Features

Downloadable Files

Download Project Files