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.

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.

This is a fun, real-world IoT project that combines a handful of technologies — GPS, Wi-Fi, APIs, JSON parsing, and good old Arduino code.

What You’ll Need

Hardware:

• ESP32 Dev Board (I used a generic one)
• NEO-6M GPS Module
• ST7735 1.8" SPI TFT LCD
• Breadboard and jumper wires
• Power source (USB cable or battery)

Software:

• Arduino IDE
• Required libraries (we’ll get to that in a sec)

Wiring It Up

Let’s hook up everything. Here’s the connection table:

Note: The GPS module works best outdoors or near a window. It needs a GPS fix before it can provide coordinates.

The Code

Here's the full code for this project:

<wifi.h><httpclient.h><tinygpsplus.h><hardwareserial.h><adafruit_gfx.h><adafruit_st7735.h><spi.h>#include <WiFi.h>
#include <HTTPClient.h>
#include <TinyGPSPlus.h>
#include <HardwareSerial.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <SPI.h>
#include <ArduinoJson.h> <arduinojson.h>

// ========== WiFi Credentials ==========
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

// ========== GPS Setup ==========
HardwareSerial GPSserial(2); // UART2
TinyGPSPlus gps;

// ========== LCD Setup ==========
#define TFT_CS     5
#define TFT_RST    4
#define TFT_DC     2
#define TFT_SCLK  18
#define TFT_MOSI  23

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

// ========== Timing ==========
unsigned long lastUpdate = 0;
const unsigned long updateInterval = 60000; // 60 sec

void setup() {
  Serial.begin(115200);
  GPSserial.begin(9600, SERIAL_8N1, 16, 17); // RX=16, TX=17

  tft.initR(INITR_BLACKTAB);
  tft.fillScreen(ST77XX_BLACK);
  tft.setRotation(1);
  tft.setTextWrap(false);
  tft.setTextColor(ST77XX_WHITE);
  tft.setTextSize(1);
  tft.setCursor(0, 0);
  tft.println("Connecting to WiFi...");

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

  tft.println("\nWiFi connected!");
}

void loop() {
  // Continuously read GPS data
  while (GPSserial.available() > 0) {
    gps.encode(GPSserial.read());
  }

  // Check if valid GPS data is available
  if (gps.location.isValid() && millis() - lastUpdate > updateInterval) {
    lastUpdate = millis();
    float latitude = gps.location.lat();
    float longitude = gps.location.lng();

    Serial.printf("GPS: %.6f, %.6f\n", latitude, longitude);
    fetchAndDisplayWeather(latitude, longitude);
  }
}

void fetchAndDisplayWeather(float lat, float lon) {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    String url = "https://api.open-meteo.com/v1/forecast?latitude=" + 
                 String(lat, 6) + "&longitude=" + String(lon, 6) +
                 "&current_weather=true";

    http.begin(url);
    int httpCode = http.GET();

    if (httpCode > 0) {
      String payload = http.getString();
      Serial.println(payload);

      DynamicJsonDocument doc(1024);
      DeserializationError error = deserializeJson(doc, payload);

      if (!error) {
        float temperature = doc["current_weather"]["temperature"];
        float windspeed = doc["current_weather"]["windspeed"];
        int weathercode = doc["current_weather"]["weathercode"];

        tft.fillScreen(ST77XX_BLACK);
        tft.setCursor(0, 0);
        tft.setTextColor(ST77XX_WHITE);
        tft.setTextSize(1);

        tft.printf("Lat: %.2f\n", lat);
        tft.printf("Lon: %.2f\n", lon);
        tft.printf("Temp: %.1f C\n", temperature);
        tft.printf("Wind: %.1f km/h\n", windspeed);
        tft.printf("Code: %d\n", weathercode);

        displayWeatherIcon(weathercode);
      } else {
        Serial.println("JSON parse failed!");
      }
    } else {
      Serial.println("HTTP request failed.");
    }

    http.end();
  }
}

void displayWeatherIcon(int code) {
  tft.setTextSize(1);
  tft.setTextColor(ST77XX_CYAN);
  tft.setCursor(0, 70);

  // Simplified icon logic
  if (code == 0) {
    tft.println("Clear");
  } else if (code <= 3) {
    tft.println("Partly Cloudy");
  } else if (code <= 45) {
    tft.println("Cloudy");
  } else if (code <= 67) {
    tft.println("Rain");
  } else if (code <= 86) {
    tft.println("Snow");
  } else {
    tft.println("Fog");
  }
}
</arduinojson.h></spi.h></adafruit_st7735.h></adafruit_gfx.h></hardwareserial.h></tinygpsplus.h></httpclient.h></wifi.h>

1. Install Required Libraries

In Arduino IDE, go to Library Manager and install the following:

• TinyGPSPlus by Mikal Hart
• Adafruit GFX and Adafruit ST7735
• ArduinoJson by Benoit Blanchon
• HTTPClient (included with ESP32)

2. Setup Wi-Fi

Replace this with your actual credentials:

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

3. Upload and Run!

Upload the sketch to your ESP32. Open the Serial Monitor at 115200 baud, and give it a minute or two to get GPS data.

What You’ll See on the LCD

• Your real-time GPS coordinates
• Current temperature
• Wind speed
• A simple weather message (Clear, Rainy, etc.)

All this on a colorful, 1.8" TFT screen! Perfect for a portable gadget or even mounting to a bike or backpack.

How It Works

1. GPS Module gives real-time latitude and longitude.
2. ESP32 connects to Wi-Fi.
3. It builds a request to the Open-Meteo API using your location.
4. Parses the JSON response using

   ArduinoJson

   .
5. Displays the info on the ST7735 LCD.

Why Use GPS?

Because it makes this project location-agnostic — you can carry the device anywhere, and it'll always show the weather for your exact location.

No need to enter a city, zip code, or country. Let the satellites handle it

Possible Upgrades

• Add a battery and enclosure to make it portable.
• Add alerts or buzzers for extreme weather.
• Store weather logs on an SD card.
• Switch to ePaper if you want ultra-low power.

Final Thoughts

This project is a great intro to integrating hardware with cloud APIs. I loved seeing live GPS data triggering real-time weather updates. It’s magical how much you can do with just a few modules!

If you build this, I’d love to hear about it. Got stuck somewhere? Just ask!

The post Building a GPS-Based Weather Station with ESP32, NEO-6M & ST7735 LCD appeared first on Microcontroller Tutorials.

Ever wanted to measure temperature without actually touching anything? Meet the MLX90614, a cool little infrared sensor that lets you do just that! Whether you're building a DIY thermometer, automating your home, or monitoring industrial equipment, this sensor has got you covered. We have already covered how to use the MLX90614 with an Arduino. In this guide, we’ll hook up the MLX90614 to an ESP32, walk through the wiring, dive into the code, and throw in some handy troubleshooting tips along the way.

MLX90614 Specifications

• Wide Temperature Range: -70°C to 380°C
• Super Accurate: ±0.5°C (in the 0°C to 50°C range)
• Tiny Details Matter: 0.02°C resolution
• Uses I2C for Easy Communication
• Plays Well with 3.3V and 5V Devices
• Decent Field of View (FoV): Around 35°

Materials

• An ESP32 board
• An MLX90614 infrared temperature sensor
• A bunch of jumper wires
• A breadboard (optional but makes life easier)

Wiring Diagram

Connecting the MLX90614 to the ESP32 is a breeze. Just match up these pins:

Required Libraries

Before jumping into the code, let's grab some libraries in the Arduino IDE:

1. Open Arduino IDE.
2. Go to Sketch > Include Library > Manage Libraries.
3. Search for Adafruit MLX90614 and hit install.
4. If needed, install Adafruit BusIO as well.

Reading Temperature

#include <Wire.h>
#include <Adafruit_MLX90614.h>


Adafruit_MLX90614 mlx = Adafruit_MLX90614();

void setup() {
    Serial.begin(115200);
    Serial.println("MLX90614 Sensor Check...");
    if (!mlx.begin()) {
        Serial.println("Uh-oh! Can't find the MLX90614. Check your wiring!");
        while (1);
    }
}


void loop() {
    Serial.print("Ambient Temp: ");
    Serial.print(mlx.readAmbientTempC());
    Serial.println(" °C");
    Serial.print("Object Temp: ");
    Serial.print(mlx.readObjectTempC());
    Serial.println(" °C"); 

    delay(1000);
}

Code Explanation:

1. Library Setup: We include Wire.h for I2C and Adafruit_MLX90614.h for sensor functions.
2. Sensor Check: mlx.begin() ensures we can communicate with the MLX90614.
3. Reading Temperatures:
   • mlx.readAmbientTempC() gives the surrounding temperature.
   • mlx.readObjectTempC() gets the temperature of whatever it’s pointed at.
4. Serial Monitor Fun: Readings are printed every second for easy debugging.

Creating a Web Server to Display Temperature Readings

If you want to view the temperature readings from any device on your network, let's create a simple web server on the ESP32.

#include <WiFi.h>
#include <Wire.h>
#include <Adafruit_MLX90614.h>
#include <ESPAsyncWebServer.h>

const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";

Adafruit_MLX90614 mlx = Adafruit_MLX90614();
AsyncWebServer server(80);

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

    Serial.println("Connected to WiFi");


    if (!mlx.begin()) {
        Serial.println("Failed to find MLX90614 sensor!");
        while (1);
    }


    server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request) {
        String response = "Ambient Temp: " + String(mlx.readAmbientTempC()) + " °C\n";
        response += "Object Temp: " + String(mlx.readObjectTempC()) + " °C";
        request->send(200, "text/plain", response);
    });

    server.begin();
}


void loop() {
    // Nothing needed here, the server handles everything!
}

Code Explanation:

1. WiFi Setup: Connects the ESP32 to your WiFi network.
2. Web Server Setup: Creates a simple web server that responds to requests.
3. Temperature Data on Request: Visiting http://your-esp32-ip/temperature will display the temperature readings.
4. No Looping Needed: Since the web server runs in the background, there's no need for code in loop().

Tips for More Accurate Readings

• Know Your Emissivity: Most organic materials work well with the default 0.95 setting, but metals or shiny surfaces may need adjustments.
• Keep the Right Distance: Too close or too far can affect accuracy.
• Avoid Direct Heat Sources: Bright lights or strong infrared sources can throw off readings.

What If Things Go Wrong?

• No readings? Double-check your wiring, especially SDA/SCL connections.
• Weird errors? Use an I2C scanner script to verify the sensor’s address.
• Inconsistent numbers? Let the sensor stabilize before trusting the values.

Project Ideas for the MLX90614

• DIY Contactless Thermometer: Perfect for checking object or body temperatures.
• Smart Home Integration: Use temperature readings to trigger fans, AC, or heating.
• Machine Health Monitoring: Detect overheating components in real-time.
• Greenhouse or Animal Monitoring: Keep track of temperature conditions easily.

Handy Resources

• MLX90614 Datasheet
• Adafruit MLX90614 Library
• I2C Scanner Code

Wrapping It Up

And there you have it! The MLX90614 + ESP32 combo is a powerful tool for measuring temperatures without contact. Whether you’re making a thermometer or automating home gadgets, this sensor is a great addition to your projects. Now, with the added web server, you can monitor temperatures remotely! So go ahead, start experimenting, and have fun coding!

The post Interfacing MLX90614 Non-Contact Infrared Temperature Sensor with ESP32 appeared first on Microcontroller Tutorials.