In this tutorial, I will build a small access control system using a Raspberry Pi Pico and several modules from the Elecrow Raspberry Pi Pico Advanced Kit. The system can read an RFID card, accept a PIN from a keypad, show messages on an LCD, control a solenoid lock through a relay, and respond to fire and tamper alarm inputs.

This is not meant to replace a real commercial access control panel, but it is a very good learning project if you want to understand how access control logic works at the microcontroller level.

Project Overview

The Raspberry Pi Pico will act as the main controller. It will accept access requests from two sources:

1. An RFID card scanned through the RC522 RFID module
2. A PIN entered through a membrane keypad

If the card UID or PIN is valid, the Pico activates a relay driver. The relay then powers a solenoid lock for a few seconds to simulate unlocking a door.

The system also monitors two alarm inputs:

1. Fire alarm input
2. Tamper alarm input

When the fire alarm is triggered, the door is released and the buzzer sounds. This simulates a real access control system where doors may be released during emergency conditions.

When the tamper alarm is triggered, the system keeps the door locked and sounds the buzzer. This simulates someone trying to force open or tamper with the door or panel.

About the Elecrow Raspberry Pi Pico Advanced Kit

For this project, I used modules from the Elecrow Raspberry Pi Pico Advanced Kit. The kit includes a Raspberry Pi Pico, breadboards, LEDs, an RGB module, sound sensor, PIR motion sensor, photoresistor module, passive buzzer, vibration sensor, magnetic spring module, soil moisture sensor, potentiometer, servo, joystick, RC522 RFID module, 4-digit display, traffic light module, rotary encoder, 1602 LCD, temperature and humidity sensor, raindrops module, flame sensor, OLED module, membrane keypad, smart car parts, ultrasonic sensor, infrared remote, and several other accessories.

For this access control project, I will use the parts that make sense for a small door controller:

• Raspberry Pi Pico
• RC522 RFID module
• Membrane keypad
• 1602 LCD module
•  Passive buzzer
• LEDs (traffic light module)
• Flame sensor or button for fire alarm simulation
• Vibration sensor for tamper detection

I will also use an external solenoid lock and relay driver. These are not driven directly by the Pico because a solenoid needs more current than a GPIO pin can provide.

How the System Works

Here is the basic block diagram of the project:

The Pico continuously checks the system inputs. In normal standby mode, the LCD asks the user to scan a card or enter a PIN.

If access is granted, the relay turns on and the solenoid unlocks for a short time. If access is denied, the buzzer gives an error sound and the red LED turns on.

The fire alarm and tamper alarm have higher priority than normal card or PIN access.

Features of This Project

This project includes the following features:

• RFID card access using the RC522 module
• PIN access using a membrane keypad
• LCD status messages
• Solenoid lock control using a relay driver
• Buzzer feedback
• LED status indicators
• Fire alarm input
• Tamper alarm input
• Optional door contact monitoring
• MicroPython code for beginners

Required Components

Most of the components used in this project are included in the Elecrow Raspberry Pi Pico Advanced Kit. I also added a solenoid lock and relay driver to make the project closer to a real access control setup.

You can also use a servo motor instead of a solenoid lock if you want a safer beginner version of the project. However, using a relay and solenoid makes the project feel closer to a real access control system.

Important Safety Note About Solenoid Locks

The Raspberry Pi Pico cannot directly drive a solenoid lock. A solenoid usually requires more voltage and current than a Pico GPIO pin can provide.

The correct setup is:

Pico GPIO → Relay Driver Input → Relay Contact → Solenoid Power

The Pico only controls the relay input. The solenoid must have its own power supply.

Also, make sure the Pico ground and relay module ground are connected together, unless you are using a fully isolated relay module.

If your relay board or solenoid driver does not already include flyback protection, you should add a diode across the solenoid coil to protect the circuit from voltage spikes.

For a real door access system, use proper certified hardware. This tutorial is only for learning and prototyping.

Pin Connections

The exact pins can be changed in the code, but I will use this pin assignment for the tutorial.

RC522 RFID Module to Raspberry Pi Pico

The RC522 uses SPI communication.

Do not connect the RC522 to 5V. The RC522 module works with 3.3V logic.

I2C LCD to Raspberry Pi Pico

This tutorial assumes that the 1602 LCD has an I2C backpack.

Most I2C LCD backpacks work at 5V, but the I2C pull-ups may also pull SDA and SCL to 5V. Many hobby modules work in practice, but the safer method is to use a level shifter or power the backpack in a way that keeps the I2C lines at 3.3V.

If your LCD has 16 pins instead of 4 pins, then it is probably a parallel LCD and will need different wiring and a different library.

Keypad to Raspberry Pi Pico

For a 4x4 membrane keypad:

If you are using a 4x3 keypad, you can modify the keypad map and remove one column.

Relay Driver and Solenoid Lock

The solenoid is connected through the relay contacts, not directly to the Pico.

A simple wiring idea is:

Solenoid Power +  → Relay COM
Relay NO          → Solenoid +
Solenoid -        → Solenoid Power -

When the relay turns on, the solenoid receives power and unlocks.

Some relay modules are active-low. This means the relay turns on when the Pico output is LOW instead of HIGH. I will make this configurable in the code.

Buzzer and LEDs

Use current-limiting resistors for the LEDs.

Alarm Inputs

For beginner testing, I recommend using push buttons first. Once the logic works, you can replace the buttons with the flame sensor and tamper sensor.

This is my setup on a breadboard. I didn't use the relay + solenoid lock yet; the red LED on the middle of the breadboard will serve as the indicator that the lock released or not.

Installing MicroPython on the Raspberry Pi Pico

Before uploading the code, install MicroPython on the Raspberry Pi Pico. You can download the latest UF2 file in the official MicroPython website.

1. Hold the BOOTSEL button on the Pico.
2. Connect the Pico to your computer using a USB cable.
3. Release the BOOTSEL button.
4. The Pico should appear as a USB drive.
5. Copy the MicroPython UF2 file to the Pico.
6. Open Thonny.
7. Select the MicroPython interpreter for Raspberry Pi Pico.

Once this is done, you can run MicroPython code on the Pico using Thonny.

Required MicroPython Libraries

This project needs libraries for:

• RC522 RFID module
• I2C LCD

For the RC522, you need a file named:

mfrc522.py

For the I2C LCD, you need files such as:

lcd_api.py
pico_i2c_lcd.py

You can find the mfrc522.py in this library, while the I2C LCD files are in this library.

Upload these files to the Raspberry Pi Pico using Thonny. You can place them directly on the Pico or inside a /lib folder.

Testing the RFID Reader First

Before combining all parts, it is better to test the RFID reader alone. This helps you get the UID of your RFID card.

A card UID may look something like this:

12 AB 34 CD

You will later place this UID inside the list of authorized cards.

In the final code, the authorized cards are stored here:

AUTHORIZED_CARDS = [
    z">"12 AB 34 CD",
    z">"A1 B2 C3 D4"
]

Replace these values with your actual card UID.

System Behavior

The system has several operating conditions.

Idle Mode

In idle mode, the LCD shows:

PICO ACCESS
SCAN CARD/PIN

The system waits for an RFID card or keypad input.

Access Granted

If the card or PIN is valid:

ACCESS GRANTED
DOOR UNLOCKED

The green LED turns on, the buzzer gives a short beep, and the relay unlocks the solenoid for a few seconds.

Access Denied

If the card or PIN is invalid:

ACCESS DENIED
TRY AGAIN

The red LED turns on and the buzzer gives an error sound.

Fire Alarm

If the fire alarm input is triggered:

FIRE ALARM!
DOOR RELEASED

The door unlocks and the buzzer sounds repeatedly.

This is done because many access control systems release doors during emergency conditions. Again, this project is only a simulation.

Tamper Alarm

If the tamper input is triggered:

TAMPER ALARM!
SYSTEM LOCKED

The system sounds the buzzer and flashes the red LED. The door remains locked.

Event Priority

The Pico should not treat all events equally. Alarm inputs should have higher priority than normal access requests.

For this project, I use this priority:

Fire alarm has the highest priority because it is a safety-related condition.

Final MicroPython Code

Upload the required libraries first, then save the following code as

main.py

on the Raspberry Pi Pico.

This code assumes:

• RC522 uses SPI0
• LCD uses I2C0
• Keypad is 4x4
• Relay output is active-high by default
• Fire and tamper inputs are active-low using pull-up resistors

If your relay module is active-low, change:

RELAY_ACTIVE_HIGH = True

to:

RELAY_ACTIVE_HIGH = False

Here is the complete code:

from machine import Pin, PWM, I2C, SPI
from time import sleep, ticks_ms, ticks_diff

# ------------------------------------------------------------
# Optional libraries
# ------------------------------------------------------------
# These imports depend on the library files you uploaded.
# If your library uses different class names, adjust these lines.

try:
    from mfrc522 import MFRC522
except ImportError:
    MFRC522 = None

try:
    from pico_i2c_lcd import I2cLcd
except ImportError:
    I2cLcd = None


# ------------------------------------------------------------
# User settings
# ------------------------------------------------------------

AUTHORIZED_CARDS = [
    "C3 A4 13 29",
    "12 AB 34 CD",
    "A1 B2 C3 D4"
]

AUTHORIZED_PIN = "1234"

ALARM_CHECK_INTERVAL_SECONDS = 5
UNLOCK_TIME_SECONDS = 3

RELAY_ACTIVE_HIGH = True

LCD_I2C_ADDR = 0x27
LCD_ROWS = 2
LCD_COLS = 16


# ------------------------------------------------------------
# Pin assignments
# ------------------------------------------------------------

# RFID RC522 SPI pins
RFID_SCK_PIN = 18
RFID_MOSI_PIN = 19
RFID_MISO_PIN = 16
RFID_CS_PIN = 17
RFID_RST_PIN = 20

# LCD I2C pins
LCD_SDA_PIN = 4
LCD_SCL_PIN = 5

# Keypad pins
ROW_PINS = [6, 7, 8, 9]
COL_PINS = [10, 11, 12, 13]

# Outputs
RELAY_PIN = 14
BUZZER_PIN = 15
GREEN_LED_PIN = 21
RED_LED_PIN = 22
YELLOW_LED_PIN = 26

# Inputs
FIRE_INPUT_PIN = 27
TAMPER_INPUT_PIN = 28
DOOR_CONTACT_PIN = 2


# ------------------------------------------------------------
# Hardware setup
# ------------------------------------------------------------

green_led = Pin(GREEN_LED_PIN, Pin.OUT)
red_led = Pin(RED_LED_PIN, Pin.OUT)
yellow_led = Pin(YELLOW_LED_PIN, Pin.OUT)

relay = Pin(RELAY_PIN, Pin.OUT)

buzzer = PWM(Pin(BUZZER_PIN))
buzzer.duty_u16(0)

fire_input = Pin(FIRE_INPUT_PIN, Pin.IN, Pin.PULL_UP)
tamper_input = Pin(TAMPER_INPUT_PIN, Pin.IN, Pin.PULL_UP)
door_contact = Pin(DOOR_CONTACT_PIN, Pin.IN, Pin.PULL_UP)

row_pins = [Pin(pin, Pin.OUT) for pin in ROW_PINS]
col_pins = [Pin(pin, Pin.IN, Pin.PULL_UP) for pin in COL_PINS]

key_map = [
    ["1", "2", "3", "A"],
    ["4", "5", "6", "B"],
    ["7", "8", "9", "C"],
    ["*", "0", "#", "D"]
]

# LCD setup
lcd = None

if I2cLcd is not None:
    try:
        i2c = I2C(0, sda=Pin(LCD_SDA_PIN), scl=Pin(LCD_SCL_PIN), freq=400000)
        lcd = I2cLcd(i2c, LCD_I2C_ADDR, LCD_ROWS, LCD_COLS)
    except Exception as e:
        print("LCD init failed:", e)
        lcd = None
else:
    print("LCD library not found. LCD output disabled.")

# RFID setup
rfid = None

if MFRC522 is not None:
    try:
        # This constructor may be different depending on your mfrc522.py library.
        # Some libraries use:
        # rfid = MFRC522(spi_id=0, sck=18, miso=16, mosi=19, cs=17, rst=20)
        #
        # If this line fails, check the documentation of your RC522 library.
        rfid = MFRC522(
            spi_id=0,
            sck=RFID_SCK_PIN,
            miso=RFID_MISO_PIN,
            mosi=RFID_MOSI_PIN,
            cs=RFID_CS_PIN,
            rst=RFID_RST_PIN
        )
    except Exception as e:
        print("RFID init failed:", e)
        rfid = None
else:
    print("MFRC522 library not found. RFID disabled.")


# ------------------------------------------------------------
# Helper functions
# ------------------------------------------------------------

def set_relay(active):
    if RELAY_ACTIVE_HIGH:
        relay.value(1 if active else 0)
    else:
        relay.value(0 if active else 1)


def lock_door():
    set_relay(False)


def unlock_door():
    set_relay(True)


def all_leds_off():
    green_led.off()
    red_led.off()
    yellow_led.off()

def pad_lcd_text(text, width=16):
    text = str(text)[:width]

    while len(text) < width:
        text += " "

    return text

last_lcd_line1 = None
last_lcd_line2 = None

def lcd_message(line1, line2=""):
    global last_lcd_line1, last_lcd_line2

    line1 = str(line1)[:16]
    line2 = str(line2)[:16]

    # Do not refresh the LCD if the message did not change
    if line1 == last_lcd_line1 and line2 == last_lcd_line2:
        return

    print(line1, line2)

    last_lcd_line1 = line1
    last_lcd_line2 = line2

    if lcd is None:
        return

    lcd.move_to(0, 0)
    lcd.putstr(pad_lcd_text(line1, 16))

    lcd.move_to(0, 1)
    lcd.putstr(pad_lcd_text(line2, 16))


def beep(freq=2000, duration=0.1):
    buzzer.freq(freq)
    buzzer.duty_u16(30000)
    sleep(duration)
    buzzer.duty_u16(0)


def beep_success():
    beep(1800, 0.08)
    sleep(0.05)
    beep(2200, 0.08)


def beep_error():
    for _ in range(3):
        beep(600, 0.12)
        sleep(0.08)


def beep_alarm():
    beep(1200, 0.15)
    sleep(0.08)


def is_fire_alarm_active():
    # Active-low input
    return fire_input.value() == 0


def is_tamper_active():
    # Active-low input
    return tamper_input.value() == 0


def is_door_open():
    # This depends on your magnetic switch module.
    # For this example, LOW means door open.
    return door_contact.value() == 0


# ------------------------------------------------------------
# Keypad functions
# ------------------------------------------------------------

def scan_keypad():
    for row_index, row in enumerate(row_pins):
        for r in row_pins:
            r.value(1)

        row.value(0)

        for col_index, col in enumerate(col_pins):
            if col.value() == 0:
                sleep(0.05)  # debounce

                if col.value() == 0:
                    key = key_map[row_index][col_index]

                    while col.value() == 0:
                        sleep(0.01)

                    return key

    return None


# ------------------------------------------------------------
# RFID functions
# ------------------------------------------------------------

def uid_to_string(uid):
    return " ".join("{:02X}".format(byte) for byte in uid)


def read_rfid_card():
    if rfid is None:
        return None

    try:
        (stat, tag_type) = rfid.request(rfid.REQIDL)

        if stat == rfid.OK:
            (stat, uid) = rfid.SelectTagSN()

            if stat == rfid.OK:
                return uid_to_string(uid)

    except Exception as e:
        print("RFID read error:", e)

    return None


# ------------------------------------------------------------
# Access control actions
# ------------------------------------------------------------

def grant_access(source):
    all_leds_off()
    green_led.on()

    lcd_message("ACCESS GRANTED", source)
    beep_success()

    unlock_door()
    sleep(UNLOCK_TIME_SECONDS)
    lock_door()

    green_led.off()
    lcd_message("DOOR LOCKED", "SCAN CARD/PIN")
    sleep(1)


def deny_access(reason):
    all_leds_off()
    red_led.on()

    lcd_message("ACCESS DENIED", reason)
    beep_error()

    red_led.off()
    sleep(1)

def sound_alarm_cycle(duration_seconds, fire_mode=False):
    start_time = ticks_ms()

    while ticks_diff(ticks_ms(), start_time) < duration_seconds * 1000:
        if fire_mode:
            red_led.toggle()
            yellow_led.toggle()
        else:
            red_led.toggle()
            yellow_led.off()

        beep_alarm()
        sleep(0.2)

    buzzer.duty_u16(0)

def handle_fire_alarm():
    all_leds_off()

    lcd_message("FIRE ALARM!", "DOOR RELEASED")
    unlock_door()

    while True:
        sound_alarm_cycle(ALARM_CHECK_INTERVAL_SECONDS, fire_mode=True)

        if not is_fire_alarm_active():
            break

        lcd_message("FIRE ALARM!", "STILL ACTIVE")

    all_leds_off()
    lock_door()
    lcd_message("FIRE CLEARED", "DOOR LOCKED")
    sleep(1)


def handle_tamper_alarm():
    all_leds_off()

    lcd_message("TAMPER ALARM!", "SYSTEM LOCKED")
    lock_door()

    while True:
        sound_alarm_cycle(ALARM_CHECK_INTERVAL_SECONDS, fire_mode=False)

        if not is_tamper_active():
            break

        lcd_message("TAMPER ALARM!", "STILL ACTIVE")

    all_leds_off()
    lcd_message("TAMPER CLEARED", "SCAN CARD/PIN")
    sleep(1)


def handle_forced_door():
    all_leds_off()
    red_led.on()

    lcd_message("DOOR FORCED!", "ALARM ACTIVE")
    lock_door()

    # Sound alarm for a few seconds
    start_time = ticks_ms()

    while ticks_diff(ticks_ms(), start_time) < 5000:
        red_led.toggle()
        beep_alarm()
        sleep(0.2)

    all_leds_off()
    lcd_message("SCAN CARD/PIN", "")
    sleep(1)


# ------------------------------------------------------------
# Main program
# ------------------------------------------------------------

def main():
    entered_pin = ""
    last_idle_update = 0

    lock_door()
    all_leds_off()

    lcd_message("PICO ACCESS", "SCAN CARD/PIN")
    yellow_led.on()

    door_was_unlocked_by_system = False

    while True:
        # Highest priority: fire alarm
        if is_fire_alarm_active():
            handle_fire_alarm()
            entered_pin = ""
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            continue

        # Second priority: tamper alarm
        if is_tamper_active():
            handle_tamper_alarm()
            entered_pin = ""
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            continue

        # Optional forced door detection
        # This is basic logic only. A real system needs better door timing rules.
        if is_door_open() and not door_was_unlocked_by_system:
            handle_forced_door()
            entered_pin = ""
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            continue

        # RFID access
        uid = read_rfid_card()

        if uid is not None:
            print("Card UID:", uid)

            if uid in AUTHORIZED_CARDS:
                yellow_led.off()
                door_was_unlocked_by_system = True
                grant_access("RFID CARD")
                door_was_unlocked_by_system = False
            else:
                yellow_led.off()
                deny_access("INVALID CARD")

            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            entered_pin = ""
            sleep(0.5)
            continue

        # Keypad access
        key = scan_keypad()

        if key is not None:
            print("Key:", key)

            if key == "*":
                entered_pin = ""
                lcd_message("ENTER PIN:", "")
                beep(1200, 0.05)

            elif key == "#":
                if entered_pin == AUTHORIZED_PIN:
                    yellow_led.off()
                    door_was_unlocked_by_system = True
                    grant_access("PIN ENTRY")
                    door_was_unlocked_by_system = False
                else:
                    yellow_led.off()
                    deny_access("WRONG PIN")

                entered_pin = ""
                lcd_message("PICO ACCESS", "SCAN CARD/PIN")
                yellow_led.on()

            elif key in "0123456789":
                if len(entered_pin) < 8: entered_pin += key lcd_message("ENTER PIN:", "*" * len(entered_pin)) beep(1500, 0.04) # Refresh idle display occasionally if ticks_diff(ticks_ms(), last_idle_update) > 3000 and entered_pin == "":
            lcd_message("PICO ACCESS", "SCAN CARD/PIN")
            yellow_led.on()
            last_idle_update = ticks_ms()

        sleep(0.05)


main()

How the Code Works

The code starts by defining the authorized cards and PIN:

AUTHORIZED_CARDS = [
    "12 AB 34 CD",
    "A1 B2 C3 D4"
]

AUTHORIZED_PIN = "1234"

You need to replace the sample RFID UIDs with the actual UIDs of your cards.

The system also defines how long the door will unlock:

UNLOCK_TIME_SECONDS = 3

This means that when access is granted, the solenoid is released for 3 seconds.

There is also another delay for when the fire alarm or tamper alarm is triggered:

ALARM_CHECK_INTERVAL_SECONDS = 5

This means that the buzzer will stay in alarm mode for 5 seconds before checking the states of the sensor again.

Relay Control

The relay is controlled by this function:

def set_relay(active):
    if RELAY_ACTIVE_HIGH:
        relay.value(1 if active else 0)
    else:
        relay.value(0 if active else 1)

This is useful because some relay modules turn on when the input pin is HIGH, while others turn on when the input pin is LOW.

If your relay works backward, simply change this line:

RELAY_ACTIVE_HIGH = True

to:

RELAY_ACTIVE_HIGH = False

LCD Messages

The function below prints messages to both the LCD and the Thonny shell:

def lcd_message(line1, line2=z">""):
    print(line1, line2)

    if lcd is None:
        return

    lcd.clear()
    lcd.move_to(0, 0)
    lcd.putstr(line1[:16])

    lcd.move_to(0, 1)
    lcd.putstr(line2[:16])

The

[:16]

part makes sure that the message fits on a 16-column LCD.

Reading the Keypad

The keypad is scanned row by row. Each row is pulled LOW one at a time, and the Pico checks which column also becomes LOW.

def scan_keypad():
    for row_index, row in enumerate(row_pins):
        for r in row_pins:
            r.value(1)

        row.value(0)

        for col_index, col in enumerate(col_pins):
            if col.value() == 0:
                sleep(0.05)

                if col.value() == 0:
                    key = key_map[row_index][col_index]

                    while col.value() == 0:
                        sleep(0.01)

                    return key

    return None

The small delay is used for basic button debounce.

RFID Access Logic

The RFID function returns the UID of a scanned card:

uid = read_rfid_card()

Then the main loop checks whether the UID is in the list of authorized cards:

if uid in AUTHORIZED_CARDS:
    grant_access("RFID CARD")
else:
    deny_access("INVALID CARD")

This is the simplest way to handle RFID authorization in a beginner project.

PIN Access Logic

The keypad allows the user to enter a PIN. The

*

key clears the input, while the

#

key submits it.

if key == "*":
    entered_pin = ""

elif key == "#":
    if entered_pin == AUTHORIZED_PIN:
        grant_access("PIN ENTRY")
    else:
        deny_access("WRONG PIN")

This is similar to how many keypad-based access systems work.

Fire Alarm Logic

The fire alarm input has the highest priority. If it is active, the system immediately runs this function:

handle_fire_alarm()

Inside that function, the door is unlocked:

unlock_door()

Then the buzzer and LEDs continue until the fire alarm input clears.

This behavior simulates an emergency door release.

Tamper Alarm Logic

The tamper alarm works differently from the fire alarm. When tamper is detected, the system keeps the door locked:

lock_door()

Then it sounds the buzzer and flashes the red LED.

This simulates a forced access or panel tamper condition.

Door Contact Logic

The optional door contact can detect if the door was opened without a valid unlock command.

In this tutorial, the logic is simplified:

if is_door_open() and not door_was_unlocked_by_system:
    handle_forced_door()

In a real access control system, this part would usually include a delay timer. For example, after access is granted, the door is allowed to open for a few seconds. If it stays open too long, the controller may trigger a “door held open” alarm.

You can add this as an advanced improvement.

Video

Here's the project in action:

Again, I didn't include the relay and solenoid lock for this video. The red LED lighting up means the door is unlocked. Replacing the red LED with the relay module and solenoid lock combination opens the lock when the LED is on.

Testing the Project

Test the project in stages. Do not connect everything at once.

Step 1: Test the LCD

Upload a simple LCD test first and confirm that the LCD can display text.

Step 2: Test the Keypad

Print each key to the Thonny shell. Make sure every key is detected correctly.

Step 3: Test the RFID Reader

Scan your card and copy the UID from the shell.

Then place the UID inside:

AUTHORIZED_CARDS = [
    "YOUR CARD UID HERE"
]

Step 4: Test the Relay Without the Solenoid

Before connecting the solenoid, test the relay with only the relay module connected. You should hear the relay click when access is granted.

Step 5: Test the Solenoid Lock

Once the relay works, connect the solenoid to its external power supply through the relay contacts.

Do not power the solenoid from the Pico.

Step 6: Test Fire and Tamper Inputs

Use push buttons first. Once the logic works, replace the buttons with the flame sensor, magnetic sensor, or vibration sensor.

RFID Reader Not Detected

Check the SPI wiring carefully. The most common mistake is swapping MOSI and MISO.

Also make sure the RC522 is powered from 3.3V, not 5V.

LCD Shows Nothing

Try adjusting the contrast potentiometer on the I2C backpack.

If the LCD still does not work, scan for the I2C address. Some LCD backpacks use 0x27, while others use 0x3F.

Change this line if needed:

LCD_I2C_ADDR = 0x27

Relay Works Backward

Change:

RELAY_ACTIVE_HIGH = True

to:

RELAY_ACTIVE_HIGH = False

Buzzer Is Too Weak

The passive buzzer may need a transistor driver if you want it to be louder. For simple breadboard testing, direct GPIO control is usually enough.

Solenoid Resets the Pico

This usually means the solenoid is causing voltage drops or electrical noise.

Use a separate power supply for the solenoid, connect grounds properly, and add flyback protection if needed.

Improving the Project

There are many ways to improve this project.

You can add an enrollment mode where an admin card allows new cards to be registered. You can also save authorized cards in the Pico’s flash memory so they are not hardcoded in the program.

Another useful improvement is event logging. The Pico can record events such as:

ACCESS GRANTED - RFID
ACCESS DENIED - INVALID CARD
ACCESS GRANTED - PIN
FIRE ALARM
TAMPER ALARM
DOOR FORCED

If you use a Raspberry Pi Pico W instead of a regular Pico, you can add a simple web dashboard. This dashboard can show the latest access events and alarm status.

You can also add a real-time clock module to timestamp each event.

Final Thoughts

This Raspberry Pi Pico access control project combines several important embedded system concepts into one practical build. It uses SPI for RFID, GPIO scanning for the keypad, I2C for the LCD, PWM for the buzzer, and digital outputs for the relay and LEDs.

The best part is that the project behaves like a small version of a real access control controller. It accepts credentials, controls a lock, displays status messages, and responds to alarm inputs.

For beginners, MicroPython makes the project easier to understand because the code is readable and the system logic is clear. For a production access control device, I would normally use C or C++ for better structure, timing, and reliability. But for learning how the system works, MicroPython is a very good starting point.

The nice thing about using a kit like the Elecrow Raspberry Pi Pico Advanced Kit is that the project can be expanded easily. After getting the RFID and keypad access working, you can add more modules from the same kit, such as the OLED display, PIR motion sensor, vibration sensor, magnetic spring module, infrared receiver, or ultrasonic sensor.

This makes the project more than just a one-time RFID door lock demo. It becomes a small platform for learning how real embedded control systems handle inputs, outputs, alarms, and user feedback.

The post Raspberry Pi Pico Access Control System Using the Elecrow Pico Advanced Kit appeared first on Microcontroller Tutorials.

What is a Time-of-Flight Sensor?

A Time-of-Flight sensor measures distance using light instead of sound. It emits an infrared laser and calculates how long it takes for the reflection to return.

Because it uses light, it avoids common ultrasonic issues like:

• Poor readings on soft surfaces
• Wide beam angles
• Slow response time

With ToF sensors, I consistently get millimeter-level precision, especially indoors.

Why Use ESP32 with ToF Sensors?

The ESP32 is perfect for this because:

• Built-in I2C makes wiring simple
• Plenty of processing power for filtering
• Easy to expand into WiFi dashboards later

This combo is something I often use for smart sensing projects.

Materials

For this setup, I used:

• ESP32 development board
• VL53L0X (or VL53L1X) ToF sensor
• Breadboard
• Jumper wires

Wiring the ToF Sensor to ESP32

The ToF sensor uses I2C, so wiring is straightforward.

I always stick to 3.3V with ESP32 to avoid voltage compatibility issues.

Installing the Library

In Arduino IDE, install:

• Adafruit VL53L0X

This library is reliable and easy to use, especially if you’re just starting.

Basic ESP32 ToF Example Code

Here’s the exact code I use for quick testing:

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

Adafruit_VL53L0X lox = Adafruit_VL53L0X();

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

 if (!lox.begin()) {
   Serial.println("Failed to initialize VL53L0X");
   while (1);
 }
 Serial.println("ToF Sensor Ready!");
}

void loop() {

 VL53L0X_RangingMeasurementData_t measure;
 lox.rangingTest(&measure, false);

 if (measure.RangeStatus != 4) {
   Serial.print("Distance: ");
   Serial.print(measure.RangeMilliMeter);
   Serial.println(" mm");
 } else {
   Serial.println("Out of range");
 }

 delay(500);
}

What the Output Means

The sensor returns distance in millimeters.

Typical ranges:

• VL53L0X → up to ~2 meters
• VL53L1X → up to ~4 meters

If you see “Out of range”, it usually means:

• Object is too far
• Surface is not reflective enough

Improving Accuracy 

Raw readings can still fluctuate slightly. In real projects, I always apply simple filtering.

Here’s a quick averaging function:

int get_average_distance(int samples) {
 int sum = 0;
 int valid = 0;

 for (int i = 0; i < samples; i++) {
   VL53L0X_RangingMeasurementData_t measure;
   lox.rangingTest(&measure, false);

   if (measure.RangeStatus != 4) {
     sum += measure.RangeMilliMeter;
     valid++;
   }

   delay(50);
 }

 if (valid == 0) return -1;
 return sum / valid;
}

This alone dramatically improves stability.

Common Problems and Fixes

Sensor Not Detected

I usually check:

• SDA/SCL swapped
• Loose wiring
• I2C address (normally 0x29)

Constant Invalid Readings

This often comes from:

• Weak power supply
• Too fast reading loop

Adding delay usually fixes it.

Noisy Measurements

If readings jump around:

• Use averaging
• Avoid direct sunlight
• Keep sensor steady

Real-World Applications

Once this is working, you can easily expand it into:

• Touchless switches
• Distance-triggered automation
• Liquid level sensing
• Robot obstacle detection
• Smart parking systems

This sensor is one of those components that scales really well from beginner to advanced projects.

Example Project: Touchless Switch (ToF + Relay)

One of my favorite practical uses of a ToF sensor is creating a touchless switch. Instead of physically pressing a button, you simply place your hand in front of the sensor to toggle a device—like a light or fan.

This is especially useful for:

• Hygiene (no physical contact)
• Smart home projects
• Modern UI interactions

How It Works

The idea is simple:

• The ToF sensor continuously measures distance
• When your hand comes within a threshold (e.g., < 100 mm), it triggers an action
• The ESP32 toggles a relay module
• The relay acts like a physical switch (ON/OFF)

I usually add a small delay or state logic to prevent repeated triggering.

Additional Components

For this project, I added:

• 1-channel relay module (3.3V or 5V compatible)
• External load (e.g., lamp, fan, or test LED)

Relay Wiring

Note: Some relay modules are active LOW, meaning:

• LOW → ON
• HIGH → OFF

Concept Logic

Instead of constantly switching while your hand is present, I use a toggle mechanism:

1. Detect hand within threshold
2. Toggle relay state
3. Wait until hand is removed before detecting again

This prevents flickering or rapid switching.

Example Code: Touchless Toggle Switch

#include <Wire.h>
#include "Adafruit_VL53L0X.h"
#define RELAY_PIN 26
#define DIST_THRESHOLD 100  // mm

Adafruit_VL53L0X lox = Adafruit_VL53L0X();
bool relay_state = false;
bool hand_detected = false;

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

 pinMode(RELAY_PIN, OUTPUT);
 digitalWrite(RELAY_PIN, HIGH); // OFF (for active LOW relay)

 if (!lox.begin()) {
   Serial.println("Failed to initialize VL53L0X");
   while (1);
 }

 Serial.println("Touchless Switch Ready");

}


void loop() {

 VL53L0X_RangingMeasurementData_t measure;
 lox.rangingTest(&measure, false);

 if (measure.RangeStatus != 4) {
   int distance = measure.RangeMilliMeter;
   Serial.print("Distance: ");
   Serial.println(distance);

   // Hand detected

   if (distance < DIST_THRESHOLD && !hand_detected) {
     relay_state = !relay_state;
     digitalWrite(RELAY_PIN, relay_state ? LOW : HIGH);
     Serial.println(relay_state ? "Relay ON" : "Relay OFF");
     hand_detected = true;
     delay(300); // debounce
   }

   // Hand removed
   if (distance >= DIST_THRESHOLD) {
     hand_detected = false;
   }
 }
 delay(50);
}

Behavior Explanation

Here’s what actually happens when I use it:

• I move my hand close to the sensor
• The ESP32 detects distance < 100 mm
• The relay toggles ON
• I remove my hand → system resets
• Next gesture toggles it OFF

It feels very natural—almost like a “gesture button”.

Safety Notes (Important)

If you’re controlling AC devices:

• Use proper relay modules with isolation
• Never touch exposed wiring
• Consider using a relay module with optocoupler

For testing, I recommend starting with:

• LED + resistor instead of mains devices

Improvements I Usually Add

In real builds, I often extend this by:

• Adding LED indicator for ON/OFF state
• Using moving average filtering for stable detection
• Adding sound or buzzer feedback
• Integrating with WiFi control (web dashboard or MQTT)

Conclusion

Using a Time-of-Flight sensor with ESP32 is one of the easiest ways to build accurate distance-based projects. Once I started using these sensors, I stopped relying on ultrasonic modules for most indoor applications.

They’re precise, fast, and incredibly easy to integrate.

The post ESP32 Time-of-Flight Sensor Tutorial (VL53L0X / VL53L1X Distance Measurement) appeared first on Microcontroller Tutorials.

An NPK sensor measures the levels of Nitrogen (N), Phosphorus (P), and Potassium (K) in soil. These three nutrients are the primary macronutrients needed by plants. In this tutorial, I will show you how to connect an RS485 NPK sensor to an ESP32, read the values using Modbus RTU, and then create a simple web dashboard so you can monitor the readings from your browser without needing to keep the Serial Monitor open.

What is an NPK sensor?

An NPK sensor is a soil probe designed to estimate the levels of nitrogen, phosphorus, and potassium present in the soil. These values are commonly reported in mg/kg or in similar concentration-based units depending on the sensor model.

Most low-cost NPK sensors used in hobby and prototype projects do not output simple analog voltages. Instead, they usually communicate using RS485 and Modbus RTU. Because of this, you cannot connect the sensor directly to a normal ESP32 GPIO pin and expect useful readings. The ESP32 needs help from an RS485-to-TTL converter, usually a MAX485 module or something similar.

This sounds more complicated at first, but once the wiring and Modbus request frames are set up correctly, reading the sensor becomes straightforward.

How the sensor communicates

The type of NPK sensor used in this tutorial communicates over RS485, which is commonly used in industrial devices because it works well over longer cable distances and in electrically noisy environments.

The protocol on top of RS485 is usually Modbus RTU. In simple terms, the ESP32 sends a request asking for a specific register, and the sensor replies with the data stored in that register.

For many common NPK sensors, the nutrient registers are as follows:

Nitrogen at register 0x001E

Phosphorus at register 0x001F

Potassium at register 0x0020

The ESP32 must send a proper Modbus frame including the CRC bytes at the end. The sensor then replies with the value.

Materials needed

You will need the following parts for this project:

• ESP32 development board
• RS485 NPK soil sensor
• MAX485 or equivalent RS485-to-TTL converter
• Jumper wires
• External power supply for the NPK sensor
• Breadboard or terminal connections as needed

The external power supply is important because many NPK sensors require 9V to 24V, and they will not work correctly from the ESP32’s 3.3V pin.

Wiring the NPK sensor to the ESP32

The RS485 lines from the sensor connect to the A and B terminals of the MAX485 module. The MAX485 then converts the differential RS485 signals into TTL serial that the ESP32 can understand.

The typical connections are as follows.

NPK sensor to MAX485

• Sensor A to MAX485 A
• Sensor B to MAX485 B
• Sensor VCC to external sensor supply positive
• Sensor GND to external sensor supply ground

MAX485 to ESP32

• RO to ESP32 RX pin
• DI to ESP32 TX pin
• RE and DE tied together, then connected to one ESP32 GPIO
• VCC to ESP32 3.3V or module-rated logic supply
• GND to ESP32 GND

For this tutorial, I will use these ESP32 pins:

• MAX485 RO to GPIO16
• MAX485 DI to GPIO17
• MAX485 RE+DE to GPIO4

The ESP32 and the sensor power supply must share a common ground. Without a common ground, communication may fail or become unstable.

Why the RE/DE pin matters

RS485 communication is usually half-duplex. This means the same pair of wires is used for both sending and receiving data, but not at the same time.

The MAX485 module uses the RE and DE pins to control whether it is transmitting or receiving. In many hobby circuits, these two pins are tied together and driven by one ESP32 GPIO.

When the control pin is HIGH, the module transmits. When it is LOW, the module listens for incoming data. So every time the ESP32 sends a Modbus request, it must briefly switch the MAX485 into transmit mode, then immediately switch back to receive mode so it can catch the sensor’s reply.

Basic ESP32 code to read NPK values

Before jumping into a web dashboard, I always prefer starting with the simplest working version. That means reading the values first and printing them to the Serial Monitor. Once that works, it becomes much easier to build additional features on top.

Here is the basic code:

#include <HardwareSerial.h>

#define RXD2 16
#define TXD2 17
#define RS485_DIR 4

HardwareSerial npk_serial(2);

byte nitrogen_cmd[]   = {0x01, 0x03, 0x00, 0x1E, 0x00, 0x01, 0xE4, 0x0C};
byte phosphorus_cmd[] = {0x01, 0x03, 0x00, 0x1F, 0x00, 0x01, 0xB5, 0xCC};
byte potassium_cmd[]  = {0x01, 0x03, 0x00, 0x20, 0x00, 0x01, 0x85, 0xC0};


void setup() {
  Serial.begin(115200);
  npk_serial.begin(9600, SERIAL_8N1, RXD2, TXD2);
  pinMode(RS485_DIR, OUTPUT);
  digitalWrite(RS485_DIR, LOW);
}

int read_npk_value(byte *command) {
  while (npk_serial.available()) {
    npk_serial.read();
  }

  digitalWrite(RS485_DIR, HIGH);
  delay(10);

  npk_serial.write(command, 8);
  npk_serial.flush();

  digitalWrite(RS485_DIR, LOW);
  delay(20);

 

  byte response[7];
  int index = 0;
  unsigned long start_time = millis();

 

  while ((millis() - start_time) < 1000 && index < 7) {
    if (npk_serial.available()) {
      response[index++] = npk_serial.read();
    }
  }

 
  if (index == 7) {
    return response[4];
  }

   return -1;

}

 

void loop() {
  int nitrogen = read_npk_value(nitrogen_cmd);
  int phosphorus = read_npk_value(phosphorus_cmd);
  int potassium = read_npk_value(potassium_cmd);

 

  Serial.print("Nitrogen: ");
  Serial.print(nitrogen);
  Serial.print(" mg/kg, Phosphorus: ");
  Serial.print(phosphorus);
  Serial.print(" mg/kg, Potassium: ");
  Serial.print(potassium);
  Serial.println(" mg/kg");

  delay(2000);
}

Understanding the code

The ESP32 is using HardwareSerial(2) so that we can use a second UART for the sensor. That keeps the main Serial Monitor free for debugging.

Each nutrient has its own Modbus command frame. These command frames already include the sensor address, function code, register address, number of registers to read, and CRC bytes.

The read_npk_value() function performs four important steps:

First, it clears any old bytes from the UART buffer. This prevents leftover data from earlier reads from corrupting the next reading.

Second, it sets the RS485 direction pin HIGH so the MAX485 goes into transmit mode.

Third, it writes the Modbus command to the sensor.

Fourth, it switches the RS485 module back to receive mode and waits for the reply.

If the sensor responds correctly, the function returns the value byte. If not, it returns -1, which is useful for indicating a failed read.

Expected Serial Monitor output

If everything is wired correctly, you should see values similar to this:

Nitrogen: 32 mg/kg, Phosphorus: 14 mg/kg, Potassium: 56 mg/kg

Nitrogen: 31 mg/kg, Phosphorus: 14 mg/kg, Potassium: 57 mg/kg

Nitrogen: 32 mg/kg, Phosphorus: 15 mg/kg, Potassium: 56 mg/kg

The numbers will vary depending on your soil and sensor model. Some cheaper sensors may not be highly accurate, but they are still useful for monitoring trends and comparing one soil condition against another.

Looking at the Modbus response

A typical sensor reply might look something like this:

01 03 02 00 20 B8 44

This can be interpreted as follows:

• 01 is the sensor address
• 03 is the Modbus function code for reading holding registers
• 02 means two data bytes follow
• 00 20 is the returned value in hexadecimal
• B8 44 is the CRC

Hex 0x0020 is decimal 32, so that would mean the nutrient value is 32.

In the basic example above, I kept things simple and returned response[4], since many sensors return small values that fit in one byte. However, if your sensor returns larger values, you may need to combine both data bytes like this:

int value = (response[3] << 8) | response[4];

That is the safer approach if you expect readings greater than 255.

Adding a web dashboard

Once I can see valid readings in the Serial Monitor, the next step is making the ESP32 serve those values on a web page. This way, I can open the ESP32 IP address in a browser on my phone or laptop and watch the nutrient values update automatically.

To keep things simple, I will use the built-in WiFi.h and WebServer.h libraries. The browser will periodically request the latest readings from a /data endpoint, and JavaScript on the page will update the displayed values automatically.

This approach is simple, reliable, and easy to understand.

How the web dashboard works

The idea is straightforward:

The ESP32 connects to Wi-Fi and starts a web server. The main page contains some HTML and JavaScript. Every two seconds, the JavaScript sends a request to /data. The ESP32 responds with the latest NPK values in JSON format. The browser then updates the page without needing a manual refresh.

So while the sensor continues to be read by the ESP32, the browser becomes a live dashboard.

ESP32 NPK web dashboard code

#include <WiFi.h>
#include <WebServer.h>
#include <HardwareSerial.h>

#define RXD2 16
#define TXD2 17
#define RS485_DIR 4

const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

HardwareSerial npk_serial(2);
WebServer server(80);

byte nitrogen_cmd[]   = {0x01, 0x03, 0x00, 0x1E, 0x00, 0x01, 0xE4, 0x0C};
byte phosphorus_cmd[] = {0x01, 0x03, 0x00, 0x1F, 0x00, 0x01, 0xB5, 0xCC};
byte potassium_cmd[]  = {0x01, 0x03, 0x00, 0x20, 0x00, 0x01, 0x85, 0xC0};

int nitrogen_value = -1;
int phosphorus_value = -1;
int potassium_value = -1;

unsigned long last_read_time = 0;
const unsigned long read_interval = 2000;

const char dashboard_html[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>NPK Sensor Dashboard</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      text-align: center;
      margin: 0;
      padding: 20px;
      background: #f4f4f4;
    }
    .container {
      max-width: 500px;
      margin: auto;
    }
    .card {
      background: white;
      margin: 15px 0;
      padding: 20px;
      border-radius: 12px;
      box-shadow: 0 2px 8px rgba(0,0,0,0.1);
    }
    .label {
      font-size: 18px;
      color: #555;
    }
    .value {
      font-size: 36px;
      font-weight: bold;
      margin-top: 10px;
    }
    .unit {
      font-size: 16px;
      color: #777;
    }
    .status {
      margin-top: 20px;
      color: #666;
      font-size: 14px;
    }
  </style>
</head>
<body>
  <div class="container">
    <h2>NPK Soil Sensor Dashboard</h2>
    <div class="card">
      <div class="label">Nitrogen</div>
      <div class="value" id="nitrogen">--</div>
      <div class="unit">mg/kg</div>
    </div>
    <div class="card">
      <div class="label">Phosphorus</div>
      <div class="value" id="phosphorus">--</div>
      <div class="unit">mg/kg</div>
    </div>
    <div class="card">
      <div class="label">Potassium</div>
      <div class="value" id="potassium">--</div>
      <div class="unit">mg/kg</div>
    </div>
    <div class="status" id="status">Waiting for data...</div>
  </div>
  <script>
    function updateData() {
      fetch('/data')
        .then(response => response.json())
        .then(data => {
          document.getElementById('nitrogen').innerText = data.nitrogen;
          document.getElementById('phosphorus').innerText = data.phosphorus;
          document.getElementById('potassium').innerText = data.potassium;
          document.getElementById('status').innerText =
            'Last updated: ' + new Date().toLocaleTimeString();
        })
        .catch(error => {
          document.getElementById('status').innerText = 'Connection error';
        });
    }
    updateData();
    setInterval(updateData, 2000);
  </script>
</body>
</html>
)rawliteral";
 

int read_npk_value(byte *command) {
  while (npk_serial.available()) {
    npk_serial.read();
  }

  digitalWrite(RS485_DIR, HIGH);
  delay(10);

  npk_serial.write(command, 8);
  npk_serial.flush();

  digitalWrite(RS485_DIR, LOW);
  delay(20);

  byte response[7];
  int index = 0;
  unsigned long start_time = millis();

  while ((millis() - start_time) < 1000 && index < 7) {
    if (npk_serial.available()) {
      response[index++] = npk_serial.read();
    }
  }
 
  if (index == 7) {
    return (response[3] << 8) | response[4];
  }
 
  return -1;
}

void update_sensor_values() {
  nitrogen_value = read_npk_value(nitrogen_cmd);
  delay(100);

  phosphorus_value = read_npk_value(phosphorus_cmd);
  delay(100);

  potassium_value = read_npk_value(potassium_cmd);
}

void handle_root() {
  server.send(200, "text/html", dashboard_html);
}

void handle_data() {
  String json = "{";
  json += "\"nitrogen\":" + String(nitrogen_value) + ",";
  json += "\"phosphorus\":" + String(phosphorus_value) + ",";
  json += "\"potassium\":" + String(potassium_value);
  json += "}";
  server.send(200, "application/json", json);
}

void setup() {
  Serial.begin(115200);
  npk_serial.begin(9600, SERIAL_8N1, RXD2, TXD2);
  pinMode(RS485_DIR, OUTPUT);
  digitalWrite(RS485_DIR, LOW);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");

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

  Serial.println();
  Serial.print("Connected. ESP32 IP address: ");
  Serial.println(WiFi.localIP());

  update_sensor_values();

  server.on("/", handle_root);
  server.on("/data", handle_data);
  server.begin();

  Serial.println("Web server started");
}

void loop() {
  server.handleClient();

  if (millis() - last_read_time >= read_interval) {
    last_read_time = millis();
    update_sensor_values();
 
    Serial.print("N: ");
    Serial.print(nitrogen_value);
    Serial.print("  P: ");
    Serial.print(phosphorus_value);
    Serial.print("  K: ");
    Serial.println(potassium_value);
  }
}

What this code adds

This version builds on the earlier example. It still reads the sensor the same way, but now it also does three additional things.

First, it connects the ESP32 to your Wi-Fi network.

Second, it starts a web server and serves a dashboard page when you visit the ESP32 IP address.

Third, it creates a /data endpoint that sends the current nitrogen, phosphorus, and potassium readings in JSON format.

The JavaScript in the browser requests this JSON every two seconds, so the dashboard updates automatically.

Viewing the dashboard

After uploading the code, open the Serial Monitor. Once the ESP32 connects to Wi-Fi, it will print something like this:

Connected. ESP32 IP address: 192.168.1.25

Web server started

Open that IP address in your browser. You should see a simple dashboard showing the current nitrogen, phosphorus, and potassium values.

As the ESP32 reads new values, the page updates automatically every two seconds. There is no need to refresh the browser manually.

Why this approach is useful

A web dashboard makes the project much more practical. Instead of connecting the ESP32 to a computer and opening the Serial Monitor every time, you can simply use your phone or laptop on the same Wi-Fi network.

This is useful for greenhouse monitoring, classroom demonstrations, farm prototypes, and remote sensor nodes where you want a quick way to view live data.

Once this basic dashboard is working, you can later expand it into something more advanced such as charts, historical logging, cloud upload, or mobile notifications.

Common problems and fixes

One of the most common issues is getting -1 values from the sensor. This usually means the ESP32 did not receive a valid response. If this happens, I would first check the A and B lines on the RS485 connection. Some sensors label these differently, so swapping them is often worth trying.

Another common issue is power. Many NPK sensors draw more power than expected and require a stable external supply. If the supply is weak or noisy, the readings may fail or jump around.

If the web page loads but the values do not update, check whether the ESP32 is still reading the sensor properly in the Serial Monitor. If the Serial Monitor values are wrong, the browser will simply display those same wrong values.

If the browser cannot load the dashboard at all, verify that your phone or laptop is on the same Wi-Fi network as the ESP32.

Possible improvements

This version is intentionally simple so it is easy to follow. But once you understand the flow, there are several ways to improve it.

You could add color indicators so the dashboard visually shows low, medium, or high nutrient levels. You could also add a chart so you can see how values change over time. Another useful upgrade would be to save the readings into EEPROM, SPIFFS, an SD card, or a cloud database.

If you want smoother real-time updates, you can also replace periodic fetch() requests with WebSockets, but for many projects the current method is already enough.

Final thoughts

Using an NPK sensor with an ESP32 is a very good beginner-to-intermediate project because it introduces several useful topics at once. You learn how to work with RS485, how Modbus RTU communication works, how to read industrial-style sensors, and how to turn the ESP32 into a live monitoring device with a browser-based dashboard.

I like this kind of project because it moves beyond simple LEDs and basic analog sensors. It feels much closer to how real agricultural and industrial monitoring systems are built.

The most important thing is to get the basic serial-reading version working first. Once you can reliably read nitrogen, phosphorus, and potassium values, adding the web dashboard becomes much easier.

The post How to Use an NPK Soil Sensor with ESP32 appeared first on Microcontroller Tutorials.

When I first worked with microphones on microcontrollers, I used analog modules. They worked, but noise and signal stability were always a concern. The INMP441 solves that by outputting digital audio through I2S. Once I got it working with the ESP32, the readings became much more consistent and reliable.

To make this project more practical, I won’t stop at just reading audio values. I’ll also show how to turn the ESP32 into a web server that displays a live graph of the captured sound—no page refresh needed.

Materials

• ESP32 development board
• INMP441 I2S microphone module
• Jumper wires
• Breadboard
• Wi-Fi network

Understanding the INMP441 and I2S

The INMP441 is a MEMS microphone with a built-in ADC, which means it outputs digital audio instead of an analog voltage. Because of this, the ESP32 uses its I2S peripheral instead of the ADC.

In this setup, the ESP32 acts as the master and generates the clock signals, while the microphone sends audio data back in sync. The key signals involved are the serial clock, word select, and serial data lines.

Although I2S supports stereo, the INMP441 outputs only one channel. The channel depends on the L/R pin connection.

Wiring the ESP32 to INMP441

The connections are simple once you understand the signals. I typically use GPIO26 for the clock, GPIO25 for the word select line, and GPIO33 for the data input.

The L/R pin is connected to ground so the microphone outputs on the left channel. The ESP32 is then configured to read only that channel.

Make sure to power the module using 3.3V. Using 5V can damage it.

Basic Example: Reading Audio Data

Before building anything more advanced, I always start by verifying that the microphone is working correctly. The simplest way to do that is to read the audio samples and print them to the Serial Monitor.

At first glance, the values may look random, but they actually represent the sound waveform.

Example Code

#include "driver/i2s.h"

#define I2S_WS 25
#define I2S_SD 33
#define I2S_SCK 26

#define I2S_PORT I2S_NUM_0
#define BUFFER_LEN 64

int32_t sBuffer[BUFFER_LEN];

void setup() {

 Serial.begin(115200);

 i2s_config_t i2s_config = {
   .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
   .sample_rate = 16000,
   .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
   .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
   .communication_format = I2S_COMM_FORMAT_I2S,
   .intr_alloc_flags = 0,
   .dma_buf_count = 4,
   .dma_buf_len = BUFFER_LEN
 };

 i2s_pin_config_t pin_config = {
   .bck_io_num = I2S_SCK,
   .ws_io_num = I2S_WS,
   .data_out_num = -1,
   .data_in_num = I2S_SD
 };

 i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
 i2s_set_pin(I2S_PORT, &pin_config);

}

void loop() {

 size_t bytes_read;

 i2s_read(I2S_PORT, &sBuffer, sizeof(sBuffer), &bytes_read, portMAX_DELAY);

 for (int i = 0; i < BUFFER_LEN; i++) {
   Serial.println(sBuffer[i]);
 }

}

Visualizing the Data (Serial Plotter)

After uploading the code, I usually switch to the Serial Plotter instead of the Serial Monitor. This makes it much easier to understand what’s going on.

When there is silence, the signal appears relatively flat. As soon as I speak or make noise, the waveform starts to move. Louder sounds produce larger peaks.

This step is important because it confirms that both the wiring and I2S configuration are correct before moving on.

From Raw Audio to Usable Data

At this point, we are reading raw audio samples, but sending all of these directly to a web page would not be practical. The ESP32 would have to transmit thousands of samples per second, which is unnecessary for simple visualization.

Instead, I process a block of samples and compute a single value that represents the sound level. This makes the system more efficient while still capturing how loud the environment is.

Turning the ESP32 into a Web Server

Once I confirmed that the microphone works, I moved on to building a web interface.

The ESP32 connects to Wi-Fi and hosts a web page. When I open that page in a browser, it displays a graph that updates continuously based on the microphone input.

To achieve real-time updates, I use Server-Sent Events (SSE). This allows the browser to stay connected to the ESP32 and receive new data automatically, without refreshing the page.

How the Live Graph Works

The ESP32 reads a buffer of samples and computes an average magnitude value. This value represents the sound intensity at that moment.

That value is then streamed to the browser. JavaScript on the page receives the data and draws it on a canvas. As new values arrive, the graph shifts and updates continuously.

The result is a smooth, real-time visualization of sound activity.

Full Example: ESP32 Web Server with Live Sound Graph

#include <WiFi.h>
#include <WebServer.h>
#include "driver/i2s.h"

#define I2S_WS   25
#define I2S_SD   33
#define I2S_SCK  26

#define I2S_PORT       I2S_NUM_0
#define SAMPLE_BUFFER  128

const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

WebServer server(80);

int32_t sample_buffer[SAMPLE_BUFFER];

const char webpage[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>ESP32 Sound Graph</title>
  <style>
    body { font-family: Arial; text-align: center; }
    canvas { border: 1px solid black; }
  </style>
</head>
<body>

  <h3>Live Sound Graph</h3>
  <canvas id="graph" width="600" height="250"></canvas>
  <script>

    const canvas = document.getElementById("graph");
    const ctx = canvas.getContext("2d");

    const maxPoints = 120;
    let dataPoints = new Array(maxPoints).fill(0);

    function drawGraph() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);
      ctx.beginPath();

      for (let i = 0; i < dataPoints.length; i++) {
        let x = i * (canvas.width / maxPoints);
        let y = canvas.height - dataPoints[i];
        if (i === 0) ctx.moveTo(x, y);
        else ctx.lineTo(x, y);
      }

      ctx.stroke();
    }

    const source = new EventSource('/events');

    source.onmessage = function(event) {
      let val = parseInt(event.data);
      if (isNaN(val)) return;

      if (val > 250) val = 250;
      if (val < 0) val = 0;

      dataPoints.push(val);
      dataPoints.shift();
      drawGraph();
    };

  </script>

</body>

</html>

)rawliteral";

void setup_i2s() {

  i2s_config_t config = {
    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = 16000,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = I2S_COMM_FORMAT_I2S,
    .intr_alloc_flags = 0,
    .dma_buf_count = 4,
    .dma_buf_len = SAMPLE_BUFFER

  };

  i2s_pin_config_t pins = {
    .bck_io_num = I2S_SCK,
    .ws_io_num = I2S_WS,
    .data_out_num = -1,
    .data_in_num = I2S_SD
  };

  i2s_driver_install(I2S_PORT, &config, 0, NULL);
  i2s_set_pin(I2S_PORT, &pins);
}

int get_sound_level() {
  size_t bytes_read;
  i2s_read(I2S_PORT, sample_buffer, sizeof(sample_buffer), &bytes_read, portMAX_DELAY);

  int samples = bytes_read / sizeof(int32_t);
  uint64_t total = 0;

  for (int i = 0; i < samples; i++) {
    int32_t s = sample_buffer[i] >> 14;
    if (s < 0) s = -s;
    total += s;
  }

  int avg = total / samples;
  return map(avg, 0, 3000, 0, 250);

}

void handle_root() {
  server.send_P(200, "text/html", webpage);
}


void handle_events() {

  WiFiClient client = server.client();

  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/event-stream");
  client.println("Cache-Control: no-cache");
  client.println("Connection: keep-alive");
  client.println();


  while (client.connected()) {

    int level = get_sound_level();

    client.print("data: ");

    client.print(level);

    client.print("\n\n");

    delay(50);

  }

}

void setup() {

  Serial.begin(115200);

  setup_i2s();

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  Serial.println(WiFi.localIP());

  server.on("/", handle_root);
  server.on("/events", handle_events);
  server.begin();
}

void loop() {
  server.handleClient();
}

Testing the Web Graph

After uploading the code, I check the Serial Monitor for the ESP32’s IP address. Then I open that address in a browser on the same network.

The graph starts updating immediately. When I speak or clap, the graph responds in real time. If needed, I adjust the scaling in the map() function to better match the environment.

Final Thoughts

I always like starting simple—just reading raw data—before moving into more advanced features. It makes debugging much easier and helps build confidence that each part of the system is working correctly.

Once everything is combined, the ESP32 and INMP441 become a powerful platform for audio-based projects. Adding a live web interface makes it even more practical and interactive.

The post ESP32 + INMP441 I2S Microphone with Live Web Graph appeared first on Microcontroller Tutorials.

Interestingly, many modern signal-processing systems — from Wi-Fi sensing to broadcast monitoring infrastructures like this Thor Broadcast deployment — rely on analyzing how signals propagate through networks.

In this tutorial, I’ll walk through what ESPectre is, how it works, and how to set it up using an ESP32 and Home Assistant. No cameras, no audio recording, and no machine learning — just physics and signal processing.

What Is ESPectre?

ESPectre is an open-source motion detection system that runs on an ESP32 and uses Wi-Fi Channel State Information (CSI) to detect movement.

When a person moves through a room, their body changes the way Wi-Fi signals bounce and propagate between a router and the ESP32. ESPectre measures these changes and converts them into a motion signal that can be used for automation or security.

Key characteristics:

• No cameras
• No microphones
• Works in total darkness
• Preserves privacy
• Integrates with Home Assistant via MQTT

How Wi-Fi Motion Detection Works

Wi-Fi signals do not travel in a straight line. They reflect off walls, furniture, and people. Modern Wi-Fi chips expose detailed radio measurements known as Channel State Information (CSI).

ESPectre:

1. Captures CSI data from Wi-Fi packets
2. Stabilizes and filters the signal
3. Measures variance caused by movement
4. Produces a real-time motion score
5. Publishes motion events via MQTT

Instead of learning patterns through AI, ESPectre relies on signal statistics such as variance and segmentation. This makes it lightweight and fast enough to run entirely on the ESP32.

Hardware Requirements

You will need the following:

• ESP32 board with CSI support
  • ESP32-S3 is recommended
  • ESP32-C6 also works
• A 2.4 GHz Wi-Fi network
• USB cable for flashing
• Optional external antenna for better range

No special router configuration is required.

Software Requirements

• ESP-IDF version 6.1
• Git
• MQTT broker
  • Home Assistant’s built-in broker, or
  • Mosquitto on a PC, Raspberry Pi, or NAS
• Home Assistant (optional but recommended)

Cloning the ESPectre Repository

Open a terminal and clone the project:

git clone https://github.com/francescopace/espectre.git
cd espectre

This repository contains the firmware, configuration options, and tuning documentation.

Setting Up ESP-IDF

ESPectre is built using Espressif’s official framework.

Make sure:

• ESP-IDF v6.1 is installed
• idf.py is available in your terminal
• Your ESP32 drivers are correctly installed

Once ESP-IDF is ready, connect your ESP32 via USB.

Configuring the Firmware

Set the target chip (example for ESP32-S3):

idf.py set-target esp32s3

Open the configuration menu:

idf.py menuconfig

Inside menuconfig, configure:

• Wi-Fi SSID and password
• MQTT broker address
• MQTT credentials (if required)
• CSI capture settings (leave defaults initially)

Save and exit.

Building and Flashing

Compile the firmware:

idf.py build

Flash it to the ESP32:

idf.py flash

After flashing, monitor the output:

idf.py monitor

If everything is correct, the ESP32 will connect to Wi-Fi and start publishing motion data.

MQTT Integration

ESPectre communicates using MQTT.

Using Home Assistant

If you are running Home Assistant with MQTT enabled:

• ESPectre uses Home Assistant MQTT auto-discovery
• Motion sensors will appear automatically

You will typically see:

• A binary motion sensor
• A numeric movement or activity score

No YAML configuration is required for basic usage.

Using a Standalone MQTT Broker

If you are not using Home Assistant, you can subscribe manually:

mosquitto_sub -t "espectre/#"

This allows you to inspect raw motion data and debug signal behavior.

Sensor Placement Guidelines

Placement has a major effect on detection quality.

Recommended setup:

• ESP32 placed 3 to 8 meters from the Wi-Fi router
• Height of approximately 1 to 1.5 meters
• Avoid metal surfaces and dense electronics
• Clear line-of-sight is helpful but not required

The router and ESP32 create a radio “field.” Motion is detected when someone crosses or disturbs that field.

Tuning Motion Sensitivity

ESPectre includes tuning parameters that affect sensitivity and noise rejection.

Common parameters include:

• Segmentation threshold
• Filtering strength
• Subcarrier selection

Start with default values. Once motion detection is working, adjust thresholds to:

• Reduce false positives
• Ignore pets or fans
• Improve responsiveness

Tuning is environment-specific and may take some experimentation.

Example Use Cases

ESPectre can be used for:

• Turning lights on when someone enters a room
• Detecting occupancy without cameras
• Privacy-friendly home security
• Energy saving automation
• Presence detection in offices or bedrooms

Because it does not rely on infrared or optics, it works through furniture and in complete darkness.

Troubleshooting Tips

If no motion is detected:

• Confirm Wi-Fi connection
• Check MQTT broker address
• Verify CSI is enabled in firmware

If motion is always detected:

• Increase segmentation threshold
• Move ESP32 farther from the router
• Reduce environmental noise sources

If Home Assistant sensors do not appear:

• Ensure MQTT discovery is enabled
• Restart Home Assistant
• Check MQTT logs

Final Thoughts

ESPectre demonstrates that motion detection does not require cameras or microphones. By using Wi-Fi CSI and an ESP32, it offers a low-cost, privacy-respecting alternative that integrates cleanly with Home Assistant.

If you are interested in experimental sensing, smart homes, or signal processing, ESPectre is a project worth exploring.

The post ESPectre Tutorial: Motion Detection Using Wi-Fi Signals (ESP32 + Home Assistant) appeared first on Microcontroller Tutorials.

The LM35 is a precision temperature sensor that provides an analog voltage output proportional to the measured temperature. It's popular among electronics enthusiasts for its simplicity, accuracy, and ease of use with microcontrollers like Arduino and ESP32.

In this tutorial, you’ll learn how LM35 works, how to interface it with Arduino and ESP32, and how to build two practical projects — a basic temperature reader and an IoT-based web server display.

What Is an LM35 Sensor?

The LM35 is an analog temperature sensor that outputs voltage linearly related to the Celsius temperature. It doesn’t require calibration and provides a direct temperature-to-voltage conversion, making it extremely beginner-friendly.

Manufacturer: Texas Instruments
Output Type: Analog (10mV/°C)
Operating Range: -55°C to +150°C
Accuracy: ±0.5°C (at room temperature)

Key Features and Specifications of LM35

How the LM35 Sensor Works: Principle of Operation

The LM35 works on the principle that the output voltage changes linearly with temperature.
For every 1°C rise, the output increases by 10 mV.

So if the LM35 outputs 250 mV, the temperature is 25°C.
Formula:

This linear relationship makes the LM35 simple to use — no complex calibration or signal conditioning is required.

That means:

• 0°C → 0V
• 25°C → 250mV
• 100°C → 1.0V

Since the ESP32 ADC reads voltage in a range (0–3.3V), we can compute the temperature as:

$T(^{0}C)=(\frac{ADC_{value}}{4095})\cdot3.3\cdot100$

Understanding the LM35 Pin Configuration and Circuit Diagram

LM35 Pinout Explained

LM35 Wiring and Power Requirements

• For Arduino, power it with 5V.
• For ESP32, use 3.3V.
• Always use a common ground between LM35 and the microcontroller.
• Optionally, add a 0.1 µF capacitor between VOUT and GND to stabilize readings.

Using LM35 with Arduino: Step-by-Step Guide

Components Required for Arduino + LM35 Project

• Arduino Uno (or Nano)
• LM35 temperature sensor
• Jumper wires
• Breadboard
• (Optional) 16x2 LCD display

Circuit Diagram for LM35 with Arduino

Connections:

• LM35 VCC → 5V
• LM35 GND → GND
• LM35 VOUT → A0 (analog pin)

Arduino Code to Read Temperature from LM35

const int sensorPin = A0;
float temperature;

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

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = (sensorValue / 1023.0) * 5.0;
  temperature = voltage * 100; // 10mV per degree Celsius
  Serial.print("Temperature: ");
  Serial.print(temperature);
  Serial.println(" °C");
  delay(1000);
}

Displaying Temperature on Serial Monitor or LCD

• Open Serial Monitor (Ctrl + Shift + M).
• You’ll see continuous readings like:
  Temperature: 27.35 °C
  Temperature: 27.42 °C
• To display it on an LCD, use the LiquidCrystal library and connect pins RS, E, D4–D7 accordingly.

Using LM35 with ESP32: IoT-Based Temperature Monitoring

Components Required for ESP32 + LM35 Project

• ESP32 board
• LM35 temperature sensor
• Breadboard and jumper wires
• (Optional) Wi-Fi network for IoT display

Circuit Diagram for LM35 with ESP32

Connections:

• LM35 VCC → 3.3V
• LM35 GND → GND
• LM35 VOUT → GPIO34 (analog input)

ESP32 Code to Read Temperature from LM35

const int sensorPin = 34;
float temperature;

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

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = (sensorValue / 4095.0) * 3.3;
  temperature = voltage * 100;
  Serial.print("Temperature: ");
  Serial.print(temperature);
  Serial.println(" °C");
  delay(2000);
}

Displaying Temperature on a Web Server (IoT Project)

Below is a full example code that:

1. Reads temperature from LM35.
2. Connects to Wi-Fi.
3. Hosts a simple webpage showing live temperature readings.

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

// Replace with your Wi-Fi credentials
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

const int lm35_pin = 34; // Analog pin for LM35
WebServer server(80);    // Web server on port 80

float read_temperature() {
  int adc_value = analogRead(lm35_pin);
  float voltage = (adc_value / 4095.0) * 3.3;  // Convert ADC reading to voltage
  float temperature_c = voltage * 100;         // 10mV per °C
  return temperature_c;
}


String html_page(float temp_c) {
  String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width, initial-scale=1.0'>";
  html += "<title>ESP32 LM35 Temperature</title>";
  html += "<style>body{font-family:Arial;text-align:center;background:#111;color:#0ff;}h1{color:#00ffff;}</style>";
  html += "</head><body>";
  html += "<h1>ESP32 LM35 Temperature Monitor</h1>";
  html += "<h2>Current Temperature: " + String(temp_c, 2) + " °C</h2>";
  html += "<meta http-equiv='refresh' content='2'>"; // auto-refresh every 2 seconds
  html += "</body></html>";
  return html;
}


void handle_root() {
  float temp = read_temperature();
  server.send(200, "text/html", html_page(temp));
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected!");
  Serial.print("ESP32 IP address: ");
  Serial.println(WiFi.localIP());

  server.on("/", handle_root);
  server.begin();
  Serial.println("Web server started!");
}

void loop() {
  server.handleClient();
}

Accessing the Web Page

1. Upload the sketch to your ESP32.
2. Open the Serial Monitor at 115200 baud.
3. Wait until you see:
   Connected!
   ESP32 IP address: 192.168.1.xxx
4. Open that IP in your browser (e.g., http://192.168.1.45)
5. You’ll see a temperature dashboard refreshing every 2 seconds!

Troubleshooting Common Issues

Incorrect Temperature Readings

• Check voltage reference (5V or 3.3V).
• Ensure correct analog pin.
• Add a capacitor between VOUT and GND to reduce noise.

Sensor Noise and Calibration Tips

• Use shielded cables for long distances.
• Calibrate by comparing with a digital thermometer.

Applications of LM35 in Real-Life Projects

Home Automation Systems

• Temperature-controlled fans or air conditioners.

Environmental Monitoring and IoT Systems

• Smart agriculture
• Weather monitoring stations
• IoT dashboards (via Blynk, ThingSpeak, etc.)

Advantages and Limitations of LM35 Sensor

Benefits of Using LM35

• Linear and accurate output
• Low cost and easy to interface
• No external calibration needed

Limitations and Alternatives

• Analog-only output (needs ADC)
• Not waterproof
• Alternatives: DHT11, DS18B20, TMP36

FAQs: How to Use LM35 Temperature Sensor with Arduino and ESP32

1. What voltage does LM35 require?
It operates between 4V and 30V, commonly powered by 5V (Arduino) or 3.3V (ESP32).

2. Can I use LM35 with ESP8266 or Raspberry Pi?
Yes, but ensure you use analog-to-digital conversion, as some boards (like ESP8266) have limited ADC support.

3. Why are my readings unstable?
Add a capacitor (0.1 µF) across output and ground to filter noise.

4. How accurate is the LM35 sensor?
±0.5°C at room temperature and ±1°C across a wide range.

5. Can LM35 measure below 0°C?
Yes, but output voltage may go negative, requiring offset circuitry.

6. Which IoT platforms support LM35 + ESP32 projects?
Popular ones include Blynk, ThingSpeak, and Google Firebase.

Conclusion

The LM35 temperature sensor is a simple, reliable, and precise device for temperature measurement and monitoring. Whether you’re using Arduino for basic sensor readings or ESP32 for IoT web dashboards, the LM35 offers versatility and accuracy.

Experimenting with LM35 is an excellent way to start learning about analog sensors, ADC conversion, and IoT data visualization.

For more information, visit the Texas Instruments LM35 Datasheet.

The post How to Use LM35 Temperature Sensor with Arduino and ESP32: Complete Guide with Example Projects appeared first on Microcontroller Tutorials.

We’re building an ESP32 Earthquake Monitor that fetches live data from the USGS Earthquake API, locates your position via NEO-6M GPS, and alerts you through an LCD, buzzer, and RGB LED. It even logs quake data to an SD card and hosts a mini web dashboard for quake history — because if you’re going to feel the earth move, you might as well have the data to prove it.

Project Overview

This project combines IoT, geolocation, and real-time data processing in one neat ESP32 package.

Here’s what happens behind the scenes:

1. The ESP32 connects to Wi-Fi and syncs its clock with an NTP (Network Time Protocol) server.
2. Using the current date, it requests the day’s earthquakes in a given location via the USGS Earthquake API.
3. The NEO-6M GPS module provides your current coordinates.
4. The ESP32 computes which earthquakes are closest to you.
5. If a quake is detected within ~200 km:
   • The LCD shows the event.
   • The buzzer sounds an alarm.
   • The RGB LED turns red (otherwise it stays green).
6. All quake data is logged to the SD card, and you can view it later through the ESP32’s built-in web page.

Components Needed

Fetching Data from the USGS Earthquake API

We’ll use this endpoint to get the latest quakes in the Philippines (my country):

https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson
&starttime=2025-10-17
&endtime=2025-10-18
&minmagnitude=4.5
&minlatitude=5.0
&maxlatitude=20.0
&minlongitude=115.0
&maxlongitude=130.0
&orderby=time

But instead of fixed dates, we’ll dynamically replace starttime and endtime each day using the ESP32’s NTP-synced clock.

That means the device automatically fetches today’s earthquakes every 24 hours — no manual editing required.

GPS and Connections

Code Overview

Here’s the project flow summarized:

1. Connect to Wi-Fi and get time from NTP.
2. Format today’s date into YYYY-MM-DD.
3. Construct the API URL dynamically.
4. Fetch and parse the GeoJSON data.
5. Get your GPS location (latitude & longitude).
6. Compute the distance between your location and each quake’s epicenter using the Haversine formula.
7. Update the LCD, RGB LED, and buzzer accordingly.
8. Log quake data to the SD card.
9. Host a simple web page displaying recent logs.

Example Code Snippet (Simplified)

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TinyGPSPlus.h>
#include <HardwareSerial.h>
#include <SD.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

#define BUZZER_PIN 25
#define LED_R 26
#define LED_G 27
#define SD_CS 5

LiquidCrystal_I2C lcd(0x27, 16, 2);
HardwareSerial gpsSerial(2);
TinyGPSPlus gps;
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", 28800); // +8 GMT (Philippines)

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

void setup() {
  Serial.begin(115200);
  lcd.init(); lcd.backlight();
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(LED_R, OUTPUT);
  pinMode(LED_G, OUTPUT);

  gpsSerial.begin(9600, SERIAL_8N1, 16, 17);

  WiFi.begin(ssid, password);
  lcd.print("Connecting WiFi...");
  while (WiFi.status() != WL_CONNECTED) delay(500);

  timeClient.begin();
  while(!timeClient.update()) timeClient.forceUpdate();

  if(!SD.begin(SD_CS)) lcd.print("SD Fail!"); else lcd.print("SD Ready");
  delay(2000);
  lcd.clear();

  fetchEarthquakes();
}

void fetchEarthquakes() {
  // Get today's date
  time_t epoch = timeClient.getEpochTime();
  struct tm *tm_info = localtime(&epoch);
  char date_str[11];
  strftime(date_str, 11, "%Y-%m-%d", tm_info);

  String url = "https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson";
  url += "&starttime=" + String(date_str);
  url += "&endtime=" + String(date_str);
  url += "&minmagnitude=4.5&minlatitude=5.0&maxlatitude=20.0&minlongitude=115.0&maxlongitude=130.0&orderby=time";

  HTTPClient http;
  http.begin(url);
  int code = http.GET();
  if(code == 200) {
    DynamicJsonDocument doc(16384);
    deserializeJson(doc, http.getString());

    for(JsonObject f : doc["features"].as<JsonArray>()) {
      double lon = f["geometry"]["coordinates"][0];
      double lat = f["geometry"]["coordinates"][1];
      double mag = f["properties"]["mag"];
      const char* place = f["properties"]["place"];

      double myLat = gps.location.lat();
      double myLon = gps.location.lng();

      double dist = TinyGPSPlus::distanceBetween(myLat, myLon, lat, lon) / 1000.0;
      logToSD(place, mag, dist);

      if(dist < 200) alertUser(place, mag);
    }
  }
  http.end();
}

void alertUser(const char* place, double mag) {
  lcd.clear();
  lcd.print("ALERT!");
  lcd.setCursor(0,1);
  lcd.print(place);
  digitalWrite(LED_R, HIGH);
  digitalWrite(LED_G, LOW);
  tone(BUZZER_PIN, 1000, 2000);
  delay(5000);
  noTone(BUZZER_PIN);
  digitalWrite(LED_R, LOW);
  digitalWrite(LED_G, HIGH);
}

void logToSD(const char* place, double mag, double dist) {
  File f = SD.open("/quakes.csv", FILE_APPEND);
  if(f) {
    f.printf("%s,%.1f,%.1f km\n", place, mag, dist);
    f.close();
  }
}

Adding a Web Dashboard

With the ESP32’s Wi-Fi capability, it’s easy to serve quake logs over a local webpage.

The idea:

• The ESP32 starts a web server.
• When a user visits the ESP32’s IP address (e.g., http://192.168.1.25), the page displays the contents of quakes.csv from the SD card.
• The page auto-refreshes every 60 seconds, so you always see the latest events.

#include <WebServer.h>

WebServer server(80);

void handleRoot() {
  if (!SD.exists("/quakes.csv")) {
    server.send(200, "text/html", "<h3>No quake data logged yet.</h3>");
    return;
  }

  File file = SD.open("/quakes.csv");
  if (!file) {
    server.send(500, "text/html", "Error opening quake log.");
    return;
  }

  String html = "<!DOCTYPE html><html><head><meta charset='UTF-8'>";
	html += "<meta http-equiv='refresh' content='60'>";
	html += "<title>ESP32 Earthquake Monitor</title>";
	html += "<style>body{font-family:Arial;background:#f8f9fa;color:#333;text-align:center;}";
	html += "table{margin:auto;border-collapse:collapse;width:80%;}";
	html += "th,td{border:1px solid #aaa;padding:8px;}th{background:#004b87;color:white;}</style></head><body>";
	html += "<h1>ESP32 Earthquake Log</h1><table><tr><th>Location</th><th>Magnitude</th><th>Distance (km)</th></tr>";


  while (file.available()) {
    String line = file.readStringUntil('\n');
    int firstComma = line.indexOf(',');
    int secondComma = line.indexOf(',', firstComma + 1);
    if (firstComma > 0 && secondComma > 0) {
      String place = line.substring(0, firstComma);
      String mag = line.substring(firstComma + 1, secondComma);
      String dist = line.substring(secondComma + 1);
      html += "<tr><td>" + place + "<td><td>" + mag + "</td><td>" + dist + "</td></tr>";
    }
  }
  file.close();

  html += "</table><p><em>Auto-refreshes every 60 seconds</em></p><body></html>";
  server.send(200, "text/html", html);
}

void startWebServer() {
  server.on("/", handleRoot);
  server.begin();
  Serial.println("Web server started. Access via http://" + WiFi.localIP().toString());
}

void loop() {
  gpsSerial.listen();
  while (gpsSerial.available()) gps.encode(gpsSerial.read());

  server.handleClient();
}

How it works

1. WebServer server(80); creates a basic web server on port 80.
2. The handleRoot() function reads quakes.csv and formats it into an HTML table.
3. The meta refresh tag reloads the page every minute automatically.
4. The startWebServer() function launches the web interface after Wi-Fi connects and SD initializes.

To start the dashboard, just call this inside setup() after SD initialization:

startWebServer();

When you connect to your ESP32’s IP (check Serial Monitor), you’ll see a simple HTML table listing quake records stored on the SD card:

The full code can be downloaded here: github repo

Notes

• You can open the page from any device on the same Wi-Fi network (phone, laptop, tablet).
• To clear old logs, simply remove or format the SD card.
• You can expand this with JavaScript charting (like Chart.js) for visual magnitude trends later.

Visual Indicators

• RGB LED Green — No nearby quakes.
• RGB LED Red + Buzzer — Earthquake within ~200 km radius.

You can tweak the threshold or add yellow for “moderate distance.”

Bonus Improvements

• Add a real-time clock (RTC) backup if NTP isn’t reachable.
• Include magnitude filtering (e.g., only warn for M≥5.0).
• Replace the buzzer with a relay and a siren for stronger sound alerts
• Create a map visualization using Google Maps API for stored quakes.

Final Thoughts

With the NTP-based auto date update, GPS-based distance calculation, SD card logging, RGB alert LED, and now this web dashboard, your ESP32 Earthquake Monitor is a full-fledged, connected device worthy of a spot on your desk.

It not only helps answer “Was that an earthquake?” —it lets you prove it with data, logs, and a neat little web interface.

The post ESP32 Earthquake Monitor with USGS API, GPS, LCD, and Web Dashboard appeared first on Microcontroller Tutorials.

A 16x2 monochrome LCD module is a widely used display in microcontroller projects. It can show two lines of text, each up to 16 characters long, making it ideal for simple user interfaces. These LCDs are based on the HD44780 controller (or compatible), which accepts commands and data via an 8-bit or 4-bit parallel interface.

The LCD works by receiving control signals (RS, R/W, E) and data signals (D0–D7 or D4–D7 for 4-bit mode). In this tutorial, we’ll use 8-bit mode for simplicity. The PIC16F84A will send initialization commands to the LCD, followed by ASCII characters to be displayed.

Understanding the control lines:

• RS (Register Select):
  • 0 = Instruction/command (e.g., clear display).
  • 1 = Data (character to display).
• R/W (Read/Write):
  • 0 = Write to LCD.
  • 1 = Read from LCD (rarely needed, we’ll keep it  0.
• E (Enable):
  • A high-to-low pulse latches the data/command into the LCD.

Once initialized, the LCD can display text by sending ASCII codes as data.

Materials

• PIC16F84A microcontroller
• 16x2 HD44780-based monochrome LCD module
• 4 MHz crystal oscillator + 2 × 22pF capacitors
• 10kΩ potentiometer (for LCD contrast adjustment)
• Breadboard and jumper wires
• 5V regulated power supply

Code (Assembly for PIC16F84A)

We’ll walk through the full code, then explain each part.

Full Program

;===========================================================
; Program: LCD 16x2 Display with PIC16F84A
;===========================================================

    list p=16F84A
    include <p16f84a.inc>

    __CONFIG _FOSC_HS & _WDTE_OFF & _PWRTE_ON & _CP_OFF

;-------------------------------
; Pin connections
; LCD Data -> PORTB
; RS -> RA0
; RW -> RA1 (tied low, write only)
; EN -> RA2
;-------------------------------

    cblock 0x20
        temp
    endc

;-------------------------------
; Reset vector
;-------------------------------
    org 0x00
    goto main

;-------------------------------
; Subroutines
;-------------------------------
delay_ms
    movlw   d'250'
    movwf   temp
d1  nop
    nop
    decfsz  temp, f
    goto d1
    return

lcd_pulse
    bsf     PORTA,2      ; E=1
    call    delay_ms
    bcf     PORTA,2      ; E=0
    call    delay_ms
    return

lcd_cmd
    bcf     PORTA,0      ; RS=0
    movwf   PORTB        ; Send command
    call    lcd_pulse
    return

lcd_data
    bsf     PORTA,0      ; RS=1
    movwf   PORTB        ; Send data
    call    lcd_pulse
    return

lcd_init
    ; Function Set: 8-bit, 2 line, 5x8 font
    movlw   0x38
    call    lcd_cmd

    ; Display ON, Cursor OFF
    movlw   0x0C
    call    lcd_cmd

    ; Clear display
    movlw   0x01
    call    lcd_cmd

    ; Entry mode: auto-increment
    movlw   0x06
    call    lcd_cmd
    return

;-------------------------------
; Main Program
;-------------------------------
main
    bsf     STATUS, RP0
    movlw   0x00
    movwf   TRISB       ; PORTB = output
    movlw   0xF8
    movwf   TRISA       ; RA0-RA2 output, RA3-RA4 input
    bcf     STATUS, RP0

    call    lcd_init

    ; Write "HELLO"
    movlw   'H'
    call    lcd_data
    movlw   'E'
    call    lcd_data
    movlw   'L'
    call    lcd_data
    movlw   'L'
    call    lcd_data
    movlw   'O'
    call    lcd_data

endless
    goto endless

    end

Simulate this code in PICSimulator

Code Explanation

1. Configuration and Setup

list p=16F84A
    include <P16F84A.inc>
    __CONFIG _FOSC_HS & _WDTE_OFF & _PWRTE_ON & _CP_OFF

• Sets processor type and includes the register definitions.
• Configures the microcontroller for High-Speed crystal oscillator, watchdog timer off, power-up timer on, and code protection off.

2. LCD Pin Mapping

• PORTB is used for LCD data (D0–D7).
• RA0 = RS, RA1 = R/W (grounded), RA2 = E.
• Only writing to the LCD is needed, so R/W is tied to ground.

3. Delay Routine

delay_ms
    movlw d'250'
    movwf temp
d1: decfsz temp, f
    goto d1
    return

A simple software delay loop to let the LCD process commands.

4. LCD Enable Pulse

lcd_pulse
    bsf PORTA,2   ; E=1
    call delay_ms
    bcf PORTA,2   ; E=0
    call delay_ms
    return

The LCD latches commands/data on the falling edge of E.

5. Sending Commands and Data

lcd_cmd
    bcf PORTA,0   ; RS=0 (command)
    movwf PORTB
    call lcd_pulse
    return

lcd_data
    bsf PORTA,0   ; RS=1 (data)
    movwf PORTB
    call lcd_pulse
    return

These subroutines separate instructions (clear, cursor) from characters (ASCII).

6. LCD Initialization

movlw 0x38   ; Function set: 8-bit, 2-line, 5x8 font
movlw 0x0C   ; Display ON, cursor OFF
movlw 0x01   ; Clear display
movlw 0x06   ; Entry mode: auto-increment

These commands are required at startup to prepare the LCD.

7. Writing Text

movlw 'H'
call lcd_data

Each ASCII character is written sequentially to the LCD.

Conclusion

In this tutorial, we connected a 16x2 monochrome LCD to a PIC16F84A microcontroller using an 8-bit parallel interface. We wrote initialization and display routines in assembly, giving full control of the LCD at a low level.

This project demonstrates how to:

• Initialize the LCD in 8-bit mode.
• Send commands and data separately.
• Display custom strings of text.

With this foundation, you can extend the program to display sensor data, menu options, or real-time feedback for embedded projects.

The post Using a 16x2 Monochrome LCD with the PIC16F84A (Assembly Tutorial) appeared first on Microcontroller Tutorials.

1. Direct: ESP32 → OpenRouter API
2. With Proxy: ESP32 → Python Flask Server → OpenRouter API

By the end, you’ll have an ESP32 that can “talk” to AI — and you’ll understand which setup is best for demos vs real projects.

What is OpenRouter?

OpenRouter is a service that lets you use many different AI models (OpenAI, Anthropic, Mistral, LLaMA, etc.) with just one API. Instead of juggling keys and endpoints, you use a single chat completions endpoint:

POST https://openrouter.ai/api/v1/chat/completions

• Authorization: Bearer <API_KEY>
• Optional: HTTP-Referer and X-Title headers (to identify your app)
• JSON body with model, messages, etc.

The response looks like OpenAI’s API: a JSON with choices[0].message.content.

Approach A: ESP32 Directly to OpenRouter

This is the “bare minimum” setup: the ESP32 connects to Wi-Fi and makes an HTTPS POST request.

Hardware Needed

• Any ESP32 development board
• Wi-Fi connection
• Arduino IDE

Sketch

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>

// ====== EDIT THESE ======
const char* WIFI_SSID = "YOUR_WIFI";
const char* WIFI_PASS = "YOUR_PASS";
const char* OPENROUTER_API_KEY = "YOUR_API_KEY";
const char* OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
const char* MODEL = "openai/gpt-4o-mini";
// ========================

void setup() {
  Serial.begin(115200);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
  Serial.println("\nWiFi connected.");

  WiFiClientSecure client;
  client.setInsecure(); // For demo only! Use setCACert() in production.

  HTTPClient https;
  if (!https.begin(client, OPENROUTER_URL)) {
    Serial.println("HTTPS begin failed");
    return;
  }

  https.addHeader("Content-Type", "application/json");
  https.addHeader("Authorization", String("Bearer ") + OPENROUTER_API_KEY);
  https.addHeader("HTTP-Referer", "https://teachmemicro.com");
  https.addHeader("X-Title", "ESP32 LLM Demo");

  String body = String("{\"model\":\"") + MODEL + "\","
                "\"messages\":["
                  "{\"role\":\"system\",\"content\":\"Answer in <=25 words.\"}," "{\"role\":\"user\",\"content\":\"Say hi from an ESP32.\"}" "]," "\"max_tokens\": 50," "\"temperature\": 0.7" "}"; int code = https.POST(body); if (code > 0) {
    Serial.printf("HTTP %d\n", code);
    String resp = https.getString();
    Serial.println(resp);
  } else {
    Serial.printf("HTTP error: %d\n", code);
  }
  https.end();
}

void loop() {}

Things to Note

• API key is on the device. Anyone who gets your ESP32 could extract it.
• TLS certificates. I used setInsecure() for demo. Properly, you should embed OpenRouter’s root CA.
• Memory. ESP32 RAM is small. Don’t ask for long essays; keep max_tokens low.
• Parsing JSON. The full response is big. Use ArduinoJson filters if you only need choices[0].message.content.

This works fine for demos and lab projects. But for real-world apps, we need more control.

Approach B: ESP32 → Python Proxy → OpenRouter

Here, the ESP32 doesn’t talk to OpenRouter directly. Instead, it calls a tiny Python Flask server you run on your PC, Raspberry Pi, or VPS. The proxy calls OpenRouter, trims the answer, and returns a small JSON.

Why bother?

• No API key on the ESP32.
• Responses are small and easy to parse.
• You can switch models or preprocess answers without touching the ESP32.

Setting Up the Python Flask Proxy on Windows

We’ll create a tiny Flask server that your ESP32 can call on your home network. These steps use Windows 10/11, PowerShell, and Python 3.10+.

1) Install Python (and add to PATH)

1. Download Python from python.org → Downloads → Windows.
2. Run the installer and tick “Add python.exe to PATH.”
3. Verify in PowerShell:

   python --version
   pip --version

   If either command is not found, sign out/in or reboot.

2) Make a project folder

Open PowerShell and create a folder anywhere (e.g., Documents):

cd $HOME\Documents
mkdir esp32-llm-proxy
cd esp32-llm-proxy

3) Create and activate a virtual environment

A venv keeps your dependencies clean and local to the project.

python -m venv .venv
.\.venv\Scripts\Activate.ps1   # You should see (.venv) prefix in the prompt

If you get an execution policy error, run PowerShell as Administrator once:

Set-ExecutionPolicy RemoteSigned

Then retry Activate.ps1.

4) Add the three files

Create requirements.txt, .env, and server.py in the folder.

esp32-llm-proxy/
├─ server.py
├─ requirements.txt
├─ .env

requirements.txt

flask
requests
python-dotenv

OPENROUTER_API_KEY=your_key_here
MODEL=openai/gpt-4o-mini
APP_URL=https://teachmemicro.com
APP_TITLE=ESP32 LLM Proxy

server.py

import os, json, requests
from flask import Flask, request, jsonify
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("OPENROUTER_API_KEY")
MODEL = os.getenv("MODEL", "openai/gpt-4o-mini")
APP_URL = os.getenv("APP_URL")
APP_TITLE = os.getenv("APP_TITLE")

OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
app = Flask(__name__)

@app.post("/ask")
def ask():
    q = str((request.json or {}).get("q", ""))[:200]
    payload = {
        "model": MODEL,
        "messages": [
            {"role": "system", "content": "Answer concisely (<=25 words)."},
            {"role": "user", "content": q}
        ],
        "max_tokens": 60
    }
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
        "HTTP-Referer": APP_URL,
        "X-Title": APP_TITLE,
    }
    r = requests.post(OPENROUTER_URL, headers=headers, data=json.dumps(payload))
    data = r.json()
    text = data.get("choices", [{}])[0].get("message", {}).get("content", "")
    return jsonify({"text": text[:512]})

pip install -r requirements.txt
python server.py

Test from your PC:

curl -X POST http://localhost:3000/ask -H "Content-Type: application/json" -d '{"q":"Say hi!"}'

Invoke-RestMethod -Method Post -Uri http://localhost:3000/ask -Body (@{q="Say hi!"} | ConvertTo-Json) -ContentType "application/json"

{"text":"Hi from the LLM!"}

#include <WiFi.h>
#include <HTTPClient.h> 

const char* WIFI_SSID = "YOUR_WIFI";
const char* WIFI_PASS = "YOUR_PASS";
const char* PROXY_URL = "http://192.168.1.100:3000/ask";

void setup() {
  Serial.begin(115200);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }
  Serial.println("\nWiFi connected.");

  HTTPClient http;
  http.begin(PROXY_URL);
  http.addHeader("Content-Type", "application/json");

  String body = R"({"q":"ESP32 says hello! Keep it short."})";
  int code = http.POST(body);

  if (code > 0) {
    String resp = http.getString(); // Example: {"text":"Hi from the LLM!"}
    Serial.println(resp);
  } else {
    Serial.printf("HTTP error: %d\n", code);
  }
  http.end();
}

void loop() {}

Open Serial Monitor @ 115200. You should see the tiny JSON:

{"text":"Hi from the LLM!"}

Pros and Cons

Direct (ESP32 → OpenRouter)
Simple, no server
One less hop
✘ API key in firmware
✘ Large JSON responses
✘ Hard to change models without reflashing

Proxy (ESP32 → Flask → OpenRouter)
API key stays safe
Tiny, clean responses
Easy to swap models or add features (caching, logging, RAG)
✘ Requires hosting a server
✘ One extra hop

When to Use Which

• For a classroom demo or quick experiment: Direct is fine.
• For anything serious (multiple devices, production, or publishing a project): Use a proxy.

Final Thoughts

This project shows how the ESP32 — a microcontroller with just a few hundred KB of RAM — can still talk to cutting-edge AI models. Thanks to OpenRouter, you can choose models freely without rewriting code.

Start with the direct approach if you just want to see “Hello from ESP32” echoed back by an AI. But if you plan to make an AI gadget (like a smart display or voice assistant), invest the extra step: build a proxy. It makes your setup more secure, scalable, and flexible.

The post ESP32 Meets AI: Talking to Large Language Models via OpenRouter appeared first on Microcontroller Tutorials.

What is TensorFlow Lite for Microcontrollers?

TensorFlow Lite for Microcontrollers is a lightweight version of TensorFlow designed specifically to run machine learning models on devices with limited memory and processing power, such as the ESP32.

Key features include:

• • Lightweight and optimized for microcontrollers
  • Can run with less than 100 KB RAM
  • Supports common ML operations like fully connected layers and convolution

Requirements

Hardware

• • ESP32 Development Board
  • Microphone Module (e.g., INMP441, MAX9814)
  • Micro USB Cable
  • (Optional) LED

Software

• • Arduino IDE
  • ESP32 Board Package
  • TensorFlow Lite Micro Arduino Library
  • Python (optional, for custom model preparation)

Setting Up the Environment

1. Install Arduino IDE

Download from Arduino.cc

2. Install ESP32 Board Support

• • Go to File → Preferences, and add the URL: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  • Install via Tools → Board → Board Manager → ESP32.

3. Install TensorFlow Lite Library

• • Navigate to Sketch → Include Library → Manage Libraries.
  • Search and install the Arduino_TensorFlowLite library.

Practical Example: Voice Activity Detection (VAD)

This project demonstrates detecting voice activity using TensorFlow Lite on ESP32.

Step 1: Download and Prepare the Model

Download the pre-trained model: Download Model (audio_preprocessor.tflite)

Convert the downloaded model into a C source file (speech_model_data.cc) using the following command:

xxd -i audio_prepocessor.tflite > speech_model_data.cc

wsl --install

with open("audio_preprocessor.tflite", "rb") as f:
    data = f.read()

with open("speech_model_data.cc", "w") as f:
    f.write("const unsigned char micro_speech_model_data[] = {")
    for i, byte in enumerate(data):
        if i % 12 == 0:
            f.write("\n  ")
        f.write(f"0x{byte:02x}, ")
    f.write("\n};\nconst int micro_speech_model_data_len = ")
    f.write(f"{len(data)};\n")

Step 2: Arduino Sketch (Main Code)

Open Arduino IDE and create a new sketch. Copy this code into your Arduino sketch file.

#include "TensorFlowLite.h"
#include "speech_model_data.cc"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
constexpr int kTensorArenaSize = 10 * 1024;
uint8_t tensor_arena[kTensorArenaSize];

void setup() {  
    Serial.begin(115200);  
    model = tflite::GetModel(speech_model_data);  
    if (model->version() != TFLITE_SCHEMA_VERSION) {    
        Serial.println("Model schema mismatch!");    
        return;  
    }  

    static tflite::MicroMutableOpResolver<5> resolver;  
    resolver.AddFullyConnected();  
    resolver.AddSoftmax();  
    resolver.AddReshape();  
    resolver.AddConv2D();  
    resolver.AddMaxPool2D();  
    static tflite::MicroInterpreter static_interpreter(    
        model, resolver, tensor_arena, kTensorArenaSize);  
    interpreter = &static_interpreter;  

    interpreter->AllocateTensors();  
    Serial.println("Model ready.");
}

void loop() {  
    float dummy_input[49 * 10] = {0};  
    // Simulated data (replace with real audio input)  
    memcpy(interpreter->input(0)->data.f, dummy_input, sizeof(dummy_input));  
    TfLiteStatus invoke_status = interpreter->Invoke();  
    if (invoke_status != kTfLiteOk) {    
        Serial.println("Invoke failed!");    
        return;  
    }  

    float* output = interpreter->output(0)->data.f;  
    Serial.print("Speech confidence: ");  
    Serial.println(output[1]);  

    delay(500);
}

Step 3: Real Audio Input (Optional)

To incorporate a microphone:

• • Use I2S to read microphone data (e.g., INMP441).
  • Convert audio data into a log Mel spectrogram.
  • Feed real audio input instead of the dummy data.

You can use libraries such as ArduinoFFT for FFT computation.

Application Possibilities

• • Smart Speakers
  • Voice-controlled Devices
  • Noise-level Monitoring Systems

Next Steps and Further Exploration

• • Train custom models easily with Edge Impulse.
  • Implement network capabilities with ESP32 Wi-Fi.

Helpful Resources

• • TensorFlow Lite for Microcontrollers
  • ESP32 Arduino Library Documentation
  • Edge Impulse (Free ML training platform)

The post Getting Started with TensorFlow Lite on ESP32 (With Voice Activity Detection Project) appeared first on Microcontroller Tutorials.