ESP32 Web Server guide

The ESP32 is a powerful, low-cost microcontroller with built-in Wi-Fi and Bluetooth, making it ideal for hosting lightweight web servers directly on embedded devices. An ESP32 web server allows users to configure devices via a browser, monitor sensor data, control hardware remotely, and expose REST APIs for IoT systems.

This guide explains how ESP32 web servers work, available frameworks, architectural choices, and best practices for production-ready systems.

1. ESP32 Networking Fundamentals

Wi-Fi Modes

  • Station (STA) – connects to an existing router
  • Access Point (AP) – creates its own Wi-Fi network
  • AP + STA – simultaneous client and access point

AP mode is commonly used for first-time configuration, while STA mode is used during normal operation.

TCP/IP Stack

The ESP32 uses the lwIP TCP/IP stack, providing TCP, UDP, DHCP, DNS, and HTTP/HTTPS functionality. The number of concurrent sockets is limited and must be considered in system design.

2. Web Server Models on ESP32

Blocking (Synchronous) Server

  • Handles one request at a time
  • Simple to implement
  • Low resource usage

Synchronous servers do not scale well and can block other tasks.

Asynchronous Web Server (Recommended)

  • Non-blocking architecture
  • Handles multiple clients efficiently
  • Ideal for real-time dashboards

3. ESP32 Web Server Frameworks

Arduino WebServer

A simple, synchronous server suitable for small projects and quick prototypes.

ESPAsyncWebServer

  • Asynchronous and high-performance
  • WebSockets and Server-Sent Events
  • File upload and download support

ESP-IDF HTTP Server

The native Espressif HTTP server with tight FreeRTOS integration and HTTPS support. Best suited for production firmware.

4. HTTP Fundamentals

  • GET – retrieve data
  • POST – send data
  • PUT – update data
  • DELETE – remove data

ESP32 web servers commonly implement REST-style APIs.

5. Serving Web Content

Static Files

  • HTML, CSS, JavaScript
  • Images (PNG, JPG, SVG)
  • Stored in SPIFFS or LittleFS

Embedded HTML

Small pages can be embedded directly as strings in firmware, reducing filesystem dependencies but increasing maintenance complexity.

6. Dynamic Content and APIs

  • Template placeholders for live data
  • JSON responses for APIs
  • AJAX-based dashboards

7. Real-Time Communication

  • WebSockets for bi-directional updates
  • Server-Sent Events for streaming data

8. FreeRTOS Integration

  • Separate networking and application tasks
  • Use queues and mutexes
  • Pin networking to core 0 when possible

9. Security Considerations

  • Authentication (Basic Auth, tokens)
  • HTTPS with TLS (memory intensive)
  • Input validation and port restriction

10. Performance Optimization

  • Use asynchronous servers
  • Minimize dynamic memory allocation
  • Compress web assets (gzip)
  • Cache static files when possible

11. OTA Updates via Web Server

ESP32 web servers frequently include OTA (Over-The-Air) firmware updates. This allows firmware to be uploaded directly through a browser.

  • Browser-based firmware upload
  • Upload progress feedback
  • Validation and safe reboot

12. Debugging and Testing

  • Serial logging
  • Browser developer tools
  • Postman or cURL for API testing

Common issues include heap fragmentation, socket exhaustion, and watchdog resets.

13. Example Applications

  • Smart home dashboards
  • Industrial control panels
  • Configuration portals
  • Sensor monitoring systems
  • Local IoT hubs

14. Recommended Development Path

  • Start with a simple HTTP server
  • Add static file serving
  • Implement REST APIs
  • Introduce authentication
  • Optimize performance and security

The ESP32 is well-suited for lightweight web servers when designed within its constraints. By using asynchronous architectures, managing memory carefully, and applying proper security practices, responsive and reliable embedded web interfaces can be built directly on the ESP32.

[mai mult...]

ESP32 Offline Text-to-Speech

An offline Text-to-Speech (TTS) system allows an ESP32-based device to convert text into spoken audio without relying on cloud services. Offline TTS is essential for privacy-sensitive applications, deterministic latency, industrial systems, and deployments without internet connectivity.

Unlike voice recognition, TTS is a speech synthesis problem and is computationally intensive. This guide explains what is realistically achievable on ESP32 hardware and how to design a robust offline TTS system.

1. ESP32 Hardware Constraints

  • Dual-core Xtensa LX6 CPU up to 240 MHz
  • ~520 KB shared SRAM
  • 4–16 MB external flash (typical)
  • Optional PSRAM on WROVER modules
  • No dedicated DSP or GPU

These constraints make modern neural TTS models infeasible. ESP32 systems must rely on rule-based or concatenative synthesis approaches.

2. Offline TTS Approaches on ESP32

Phrase-Based (Pre-Recorded Audio)

  • Store WAV/PCM files in flash or SPIFFS
  • Playback using DAC or I2S

This approach provides excellent audio quality with minimal CPU usage but limited flexibility.

Phoneme-Based Concatenative TTS

  • Text to phoneme conversion
  • Phoneme sequencing
  • Audio concatenation and playback

This method allows dynamic speech generation at the cost of voice naturalness and complexity.

Formant / Rule-Based Synthesis

Speech is generated mathematically using vocal tract models. This requires very little memory but produces highly robotic speech.

3. Recommended System Architecture

The most practical ESP32 TTS systems use a hybrid architecture combining phrase playback for common prompts and phoneme synthesis for dynamic data such as numbers.

4. Audio Output Options

ESP32 Internal DAC

  • 8-bit resolution
  • Low audio quality
  • External amplifier required

I2S Audio Output (Recommended)

  • External DAC or MAX98357A amplifier
  • 16-bit PCM audio
  • Sample rates: 16 kHz or 22.05 kHz

5. Text Processing Pipeline

Text Normalization

Text normalization converts raw text into speakable words. This includes expanding numbers, abbreviations, and symbols.

Tokenization

Text is split into words or phrases that can be mapped to audio assets or phonemes.

Phoneme Conversion

Words are mapped to phonemes using lookup tables or simplified grapheme-to-phoneme rules.

6. Audio Asset Design

  • 16-bit PCM, mono
  • Consistent pitch and speed
  • Normalized volume

Asset Type Typical Size
Single phoneme 1–4 KB
40 phonemes 80–120 KB
Phrase set 100 KB–2 MB

7. Timing and Prosody Control

Basic prosody improvements include inserting silence, adjusting phoneme duration, and optional pitch shifting.

8. Firmware Architecture

  • Text processing task
  • Audio synthesis task
  • Audio playback task

Use DMA buffering for I2S and avoid dynamic memory allocation during playback.

9. Existing ESP32 Offline TTS Libraries

  • SAM-based ESP32 TTS (very small footprint)
  • Flite (requires large flash and PSRAM)
  • Custom phrase engines

10. Power Optimization

  • Disable Wi-Fi and Bluetooth during playback
  • Lower CPU frequency when streaming audio
  • Precompute phoneme sequences

11. Debugging and Testing

  • Serial logging of phoneme sequences
  • Check for audio buffer underflows
  • Verify DAC/I2S gain levels

12. Security and Privacy

Offline TTS ensures that no text or audio data leaves the device, making it suitable for privacy-critical applications.

[mai mult...]

ESP32 Offline Voice Recognition

Offline voice recognition on the ESP32 enables devices to understand spoken commands without an internet connection. This is critical for low-latency response, privacy-sensitive applications, and battery-powered or remote systems.

Typical use cases include smart switches, robotics, industrial controls, toys, and assistive devices. This guide focuses on keyword spotting (KWS) and command recognition, which are the only practical forms of offline voice recognition on ESP32-class microcontrollers.

1. Understanding ESP32 Constraints

Hardware Limitations

  • Dual-core Xtensa LX6 CPU up to 240 MHz
  • ~520 KB shared SRAM
  • 4–16 MB external flash (typical)
  • No hardware floating-point unit

These constraints mean full speech-to-text is not feasible. ESP32-based systems are limited to small vocabularies (usually 5–50 commands) using highly optimized models.

2. Voice Recognition Approaches

Keyword Spotting (KWS)

Keyword spotting detects predefined words or phrases such as “Hey Device” or “Turn on light”.

  • Low memory usage
  • Fast and reliable
  • Always-on capable

Command Classification

Command classification selects one command from a known set (e.g., start, stop, left, right). It is often triggered after a wake word.

3. Audio Capture Fundamentals

Microphone Selection

I2S MEMS microphones are strongly recommended for ESP32 voice projects.

  • INMP441
  • SPH0645
  • ICS-43434

Analog microphones are discouraged unless paired with high-quality external ADC and filtering.

Audio Configuration

  • Sample rate: 16 kHz
  • Bit depth: 16-bit PCM
  • Channels: Mono

4. Audio Preprocessing Pipeline

Accurate voice recognition depends heavily on audio preprocessing.

  • Audio framing (20–30 ms)
  • Windowing (Hamming)
  • FFT
  • Feature extraction

MFCC Features

  • Frame length: 25 ms
  • Frame stride: 10 ms
  • FFT size: 512
  • MFCC count: 10–20

ESP32 implementations typically use fixed-point MFCCs for performance.

5. Machine Learning Models

Model Accuracy Speed Memory
DNN Medium Fast Low
CNN High Medium Medium
DS-CNN Very High Fast Low

Depthwise Separable CNNs (DS-CNN) are the industry standard for embedded keyword spotting.

6. ESP32 Voice Recognition Frameworks

ESP-SR (Espressif)

  • Wake word detection
  • Command recognition
  • Fully offline
  • Pre-trained models

Memory usage typically ranges from 300–600 KB RAM and 1–2 MB flash.

TensorFlow Lite for Microcontrollers

  • Custom-trained models
  • INT8 quantization
  • Higher flexibility

7. Training a Custom Model

  • 100–300 samples per keyword
  • Multiple speakers
  • Noise and silence samples

Target model size should remain under 250 KB, with inference RAM usage below 100 KB.

8. Firmware Architecture

  • Audio capture task
  • Feature extraction task
  • Inference task
  • Application logic task

Pin inference to a single core and avoid dynamic memory allocation for real-time stability.

9. Wake Word + Command Flow

  • Always-on wake word detection
  • Switch to command recognition
  • Timeout and return to wake mode

10. Power Optimization

  • Disable Wi-Fi and Bluetooth
  • Lower CPU frequency
  • Use light sleep
  • Optimize audio frame rate

11. Debugging and Testing

  • Log confidence scores
  • Monitor audio energy levels
  • Test with background noise

12. Security and Privacy

Offline voice recognition ensures no audio data is transmitted or stored externally, improving privacy and predictability.

[mai mult...]

Arduino Soil Moisture Sensor

 How the Soil Moisture Sensor Works

Resistive Sensor

Uses two metal probes to measure electrical resistance. Wet soil has lower resistance, while dry soil has higher resistance.

Capacitive Sensor

Measures changes in soil capacitance and has no exposed metal parts. It provides more stable and long-lasting performance.

Both sensors provide an analog output that Arduino reads.

Wiring the Soil Moisture Sensor

Soil Sensor → Arduino
VCC         → 5V
GND         → GND
AO          → A0

The digital output (DO) pin is optional and can be used with a preset threshold.

Arduino Code (Basic Reading)


int soilPin = A0;
int soilValue = 0;

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

void loop() {
  soilValue = analogRead(soilPin);

  Serial.print("Soil Moisture Value: ");
  Serial.println(soilValue);

  delay(1000);
}

Understanding Soil Moisture Values

Sensor Value Soil Condition
0 – 300 Very Wet
300 – 600 Moist
600 – 900 Dry
900 – 1023 Very Dry

Values may vary depending on soil type. Always calibrate with dry and wet soil.

Improved Code with Moisture Status


int soilPin = A0;
int soilValue = 0;

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

void loop() {
  soilValue = analogRead(soilPin);

  Serial.print("Soil Moisture: ");
  Serial.print(soilValue);

  if (soilValue < 300) {
    Serial.println(" - WET");
  }
  else if (soilValue < 600) {
    Serial.println(" - MOIST");
  }
  else {
    Serial.println(" - DRY");
  }

  delay(1000);
}

Testing the Sensor

  1. Upload the code to Arduino
  2. Open the Serial Monitor
  3. Set baud rate to 9600
  4. Insert the sensor into soil
  5. Add water and observe changes

Wet soil produces lower values, while dry soil produces higher values.

Troubleshooting

  • Always reads 1023: Sensor not properly inserted
  • No value change: Loose wiring or faulty sensor
  • Unstable readings: Electrical noise or dry air
  • Corrosion: Use capacitive sensor instead of resistive

Optional Upgrades

  • Add relay and water pump for automatic irrigation
  • Add LCD or OLED display
  • Use ESP8266/ESP32 for IoT monitoring
  • Log data to SD card for analysis.
[mai mult...]

Arduino Fingerprint Sensor

Required Components

Component Quantity Description
Arduino Uno / Nano / Mega 1 Main controller
Fingerprint Sensor (R307 / ZFM-20 / Adafruit) 1 Biometric identification
16×2 LCD with I2C Module 1 Display user messages
12V Solenoid Lock 1 Door/box locking mechanism
5V Relay Module 1 Controls solenoid lock
12V Power Supply 1 Powers solenoid
Jumper Wires – Connections

The fingerprint sensor scans the user’s finger. Arduino checks if the fingerprint matches a stored ID. If it matches, the relay is activated and unlocks the solenoid lock. The LCD shows:

  • Scanning
  • Access Granted
  • Access Denied

Fingerprint Sensor → Arduino

VCC → 5V
GND → GND
TX  → D2
RX  → D3

I2C LCD → Arduino

VCC → 5V
GND → GND
SDA → A4
SCL → A5

Relay Module → Arduino

IN  → D8
VCC → 5V
GND → GND

Solenoid Lock Power Wiring

12V+ → COM on Relay
NO   → Solenoid +
Solenoid - → 12V -

IMPORTANT: Use a diode (1N4007) across solenoid terminals to prevent voltage spikes.

Arduino Code (Copy & Paste)

This code controls the fingerprint module, LCD display, and solenoid lock.


#include <Adafruit_Fingerprint.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <SoftwareSerial.h>

SoftwareSerial fingerSerial(2, 3); // RX, TX
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&fingerSerial);
LiquidCrystal_I2C lcd(0x27, 16, 2);

int relayPin = 8;

void setup() {
lcd.init();
lcd.backlight();

pinMode(relayPin, OUTPUT);
digitalWrite(relayPin, LOW); // lock OFF at start

lcd.setCursor(0, 0);
lcd.print("Fingerprint");
lcd.setCursor(0, 1);
lcd.print("Access System");

delay(2000);
lcd.clear();

finger.begin(57600);
if (finger.verifyPassword()) {
lcd.print("Sensor Ready");
} else {
lcd.print("Sensor Error");
while (1);
}
delay(2000);
lcd.clear();
}

void loop() {
lcd.setCursor(0, 0);
lcd.print("Place Finger...");
lcd.setCursor(0, 1);
lcd.print(" ");

int result = getFingerprintID();

if (result >= 0) {
lcd.clear();
lcd.print("Access Granted");
unlockDoor();
} else if (result == -1) {
lcd.clear();
lcd.print("Access Denied");
delay(1500);
}

lcd.clear();
}

int getFingerprintID() {
finger.getImage();
if (finger.image2Tz() != FINGERPRINT_OK) return -1;
if (finger.fingerSearch() != FINGERPRINT_OK) return -1;

return finger.fingerID; // valid ID returned
}

void unlockDoor() {
digitalWrite(relayPin, HIGH); // open lock
delay(3000); // unlock duration
digitalWrite(relayPin, LOW); // lock again
}

You must add fingerprints before using the system.

  1. In Arduino IDE, go to File → Examples → Adafruit Fingerprint Sensor Library → Enroll
  2. Upload the sketch
  3. Open Serial Monitor
  4. Type the fingerprint ID number (1–127)
  5. Place finger twice when instructed

Fingerprint is now stored.

LCD Display Messages

Event Message
Startup Fingerprint Access System
Ready Sensor Ready
Waiting Place Finger…
Match Access Granted
No Match Access Denied

Troubleshooting

  • Fingerprint not detected: TX/RX wiring reversed
  • LCD not showing text: Wrong I2C address (try 0x3F)
  • Solenoid not activating: Check relay NO/COM wiring
  • Machine resets: Solenoid drawing current — use separate 12V supply.
[mai mult...]

Arduino Air Quality Monitoring System

Build your own Arduino-based Air Quality Monitor using sensors like the MQ-135, MQ-7, and DHT11/DHT22. This guide explains how the sensors work, how to wire them, and includes a fully commented Arduino code example.

Components Needed

Component Qty Description
Arduino Uno / Nano / Mega 1 Main microcontroller
MQ-135 Gas Sensor 1 Detects VOCs, NH₃, CO₂, smoke, pollution
DHT11 or DHT22 1 Temperature & Humidity
MQ-7 (optional) 1 Carbon Monoxide sensor
0.96″ OLED (optional) 1 Displays readings
Breadboard & Jumper Wires – Wiring
USB Cable 1 Power + programming

How the Sensors Work

MQ-135 (Air Quality Sensor)

Detects harmful gases such as CO₂, NH₃, NOx, benzene, and VOCs. The analog output value increases when the air becomes more polluted. Requires a short preheat time for accuracy.

MQ-7 (Carbon Monoxide)

Detects CO gas. Optional component for advanced monitoring.

DHT11 / DHT22

Reads temperature and humidity. These values help interpret gas sensor readings more accurately.

MQ-135 Wiring

MQ135 → Arduino
VCC   → 5V
GND   → GND
A0    → A0

DHT11 / DHT22

DHT Sensor → Arduino
VCC        → 5V
GND        → GND
DATA       → D2

OLED (I2C)

OLED → Arduino
VCC  → 5V
GND  → GND
SDA  → A4
SCL  → A5

Arduino Code (Copy & Paste)


#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT22 // change to DHT11 if needed
DHT dht(DHTPIN, DHTTYPE);

int mq135Pin = A0;

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

void loop() {

// --- Read MQ135 Sensor ---
int mqValue = analogRead(mq135Pin);
float airQuality = map(mqValue, 0, 1023, 0, 500);
// 0 = clean air, 500 = very polluted

// --- Read Temperature & Humidity ---
float humidity = dht.readHumidity();
float temperature = dht.readTemperature();

// --- Output Data ---
Serial.println("----------- AIR QUALITY MONITOR -----------");
Serial.print("MQ135 Raw Value: ");
Serial.println(mqValue);

Serial.print("Air Quality Index (approx): ");
Serial.print(airQuality);
Serial.println(" / 500");

Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" *C");

Serial.print("Humidity: ");
Serial.print(humidity);
Serial.println(" %");

Serial.println("-------------------------------------------\\n");

delay(1000);
}

Understanding the Readings

MQ135 Reading Air Quality Description
0–80 Excellent Very clean air
80–150 Good Normal indoor air
150–250 Moderate Needs ventilation
250–350 Poor Polluted environment
350–500+ Hazardous High VOCs or smoke detected

Troubleshooting

  • Sensor always reads high: MQ-135 needs 1–5 minutes warm-up time.
  • No DHT readings: Check DATA pin and DHT type in code.
  • Unstable values: Add a 100nF decoupling capacitor to MQ sensor.
  • OLED not showing: Wrong I2C address — run an I2C scanner.
[mai mult...]

Arduino Ultrasonic Sensor

The sensor sends out an ultrasonic sound wave from the TRIG pin. When the sound wave hits an object, it reflects back and is detected by the ECHO pin.
The Arduino measures the time it takes for the signal to return and uses that to calculate the distance.

Distance (cm) = (Time in microseconds × 0.034) / 2

The speed of sound is 0.034 cm/µs. We divide by 2 because the sound travels to the object and back.

Required Components

Component Quantity Purpose
Arduino Uno / Nano / Mega 1 Main microcontroller
HC-SR04 Ultrasonic Sensor 1 Measures distance
Jumper Wires 4 Connections
Breadboard (optional) 1 Easy wiring
USB Cable 1 Power & programming

Pin Connections

Connect the HC-SR04 sensor to the Arduino as shown below:

HC-SR04 Pin Arduino Pin
VCC 5V
GND GND
TRIG Digital Pin 9
ECHO Digital Pin 10

Note: The ECHO pin outputs 5V, which is safe for Arduino Uno/Nano/Mega.

Arduino Code

Upload the following code to your Arduino:


#define TRIG_PIN 9
#define ECHO_PIN 10

void setup() {
Serial.begin(9600);
pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);
}

void loop() {
long duration;
float distance;

// Clear trigger
digitalWrite(TRIG_PIN, LOW);
delayMicroseconds(2);

// Trigger ultrasonic burst
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);

// Measure echo time
duration = pulseIn(ECHO_PIN, HIGH);

// Convert time to distance
distance = (duration * 0.034) / 2;

// Output result
Serial.print("Distance: ");
Serial.print(distance);
Serial.println(" cm");

delay(500);
}

Code Explanation

  • pulseIn() measures the duration of the ECHO signal.
  • The sensor sends a 40 kHz ultrasonic burst using the TRIG pin.
  • Arduino calculates the distance based on the speed of sound.
  • Distance is printed in centimeters to the Serial Monitor.

Testing the Sensor

  1. Upload the code to your Arduino
  2. Open the Serial Monitor
  3. Set the baud rate to 9600
  4. Move your hand in front of the sensor
  5. Watch the distance update live

You should see something like:

Distance: 15.4 cm

Troubleshooting

Issue Cause Solution
Always reads 0 cm Incorrect pin wiring Check TRIG and ECHO
Values jump around Object surface curved or too small Use a flat object
No Serial output Wrong baud rate Set Serial Monitor to 9600
Sensor not working No power Ensure 5V and GND connected properly

 

[mai mult...]

Arduino Weather Station guide

The DHT11 and DHT22 measure temperature and humidity. DHT22 offers higher accuracy and a wider range.

Pin Description
VCC +5V
DATA Data output (connect to D2)
NC Not connected
GND Ground

BMP180 / BME280

Measures pressure and temperature using the I2C interface.

Pin Description
VIN +3.3V or +5V
GND Ground
SCL I2C Clock (A5)
SDA I2C Data (A4)

LCD (16×2 I2C)

Displays data using the I2C interface — only two wires are required (SDA, SCL).
The most common I2C addresses are 0x27 or 0x3F.

Wiring Diagram

Component Arduino Pin Notes
DHT11 Data D2 Use 10kΩ pull-up resistor (optional)
BMP180 SDA A4 I2C Data
BMP180 SCL A5 I2C Clock
LCD SDA A4 Shared with BMP180
LCD SCL A5 Shared with BMP180
Power (+) 5V Common power line
Ground (–) GND Common ground

On Arduino Mega, use SDA = 20 and SCL = 21 instead.

Arduino Code Example


#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085.h>
#include <DHT.h>
#include <LiquidCrystal_I2C.h>

// Define sensors
#define DHTPIN 2
#define DHTTYPE DHT11   // or DHT22

DHT dht(DHTPIN, DHTTYPE);
Adafruit_BMP085 bmp;
LiquidCrystal_I2C lcd(0x27, 16, 2); // Change address if needed (0x3F or 0x27)

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.backlight();
  dht.begin();

  if (!bmp.begin()) {
    Serial.println("BMP180 not found!");
    lcd.print("BMP Error!");
    while (1);
  }

  lcd.clear();
  lcd.print("Weather Station");
  delay(2000);
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float p = bmp.readPressure() / 100.0; // hPa

  if (isnan(h) || isnan(t)) {
    Serial.println("DHT read error!");
    return;
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("T:");
  lcd.print(t);
  lcd.print((char)223);
  lcd.print("C H:");
  lcd.print(h);
  lcd.print("%");

  lcd.setCursor(0, 1);
  lcd.print("P:");
  lcd.print(p);
  lcd.print(" hPa");

  Serial.print("Temp: "); Serial.print(t);
  Serial.print(" °C  Hum: "); Serial.print(h);
  Serial.print("%  Pressure: "); Serial.print(p);
  Serial.println(" hPa");

  delay(2000);
}

Explanation: This program reads data from the DHT and BMP sensors, then prints it to both the Serial Monitor and the LCD screen.

How It Works

  1. The sensors measure temperature, humidity, and pressure.
  2. Arduino reads and formats this data.
  3. The LCD displays readings in real time.
  4. Every few seconds, the data updates automatically.

Troubleshooting

Problem Possible Cause Solution
LCD shows random text Wrong I2C address Try 0x3F instead of 0x27
“BMP180 not found!” Wiring issue Check SDA/SCL and power
DHT readings show NaN Missing library or bad sensor Install DHT library, recheck wiring
LCD blank Contrast too low or backlight off Adjust contrast screw or enable backlight

Install these from Arduino IDE → Sketch → Include Library → Manage Libraries:

  • DHT sensor library by Adafruit
  • Adafruit Unified Sensor
  • Adafruit BMP085 Library or Adafruit BME280
  • LiquidCrystal_I2C

Optional: IoT Integration

Add an ESP8266 or ESP32 to send data to cloud platforms such as:

  • ThingSpeak
  • Blynk
  • Adafruit IO

Use libraries like ESP8266WiFi.h and HTTPClient.h to upload readings as HTTP requests.

Expansion Ideas

  • Add a rain sensor or anemometer (wind speed)
  • Store data on an SD card
  • Add a real-time clock (RTC) for timestamped data
  • Display graphs on a web dashboard.
[mai mult...]

Arduino Distance Sensor with OLED Display

This project uses an HC-SR04 Ultrasonic Distance Sensor and a 0.96” I2C OLED display to measure and display the distance to an object in real-time.
It’s an excellent beginner-to-intermediate Arduino project that teaches sensor interfacing, I2C communication, and real-time data display.

In this guide, you’ll learn how to:

  • Connect and use the HC-SR04 Ultrasonic Sensor
  • Display the measured distance on an OLED screen
  • Format readings for easy readability

Components Required

Component Quantity Description
Arduino Uno / Nano / Mega 1 Main controller
HC-SR04 Ultrasonic Sensor 1 Measures distance via sound waves
0.96” OLED Display (SSD1306) 1 I2C display for output
Breadboard 1 For wiring
Jumper wires 6–8 Male-to-male connections
USB cable 1 For programming and power

The HC-SR04 measures distance by sending out an ultrasonic pulse and timing how long it takes to bounce back.
The Arduino calculates the distance based on the time delay and the known speed of sound.

Distance Formula:

Distance (cm) = (Time in microseconds × 0.034) / 2

The division by 2 accounts for the round trip of the sound wave (out and back).

Pin Connections

Component Arduino Pin Notes
HC-SR04 VCC 5V Power supply
HC-SR04 GND GND Common ground
HC-SR04 TRIG D9 Trigger pin
HC-SR04 ECHO D10 Echo pin
OLED VCC 5V Power
OLED GND GND Ground
OLED SDA A4 I2C Data
OLED SCL A5 I2C Clock

Note: On Arduino Mega, use SDA = 20 and SCL = 21 instead.

Arduino Code Example


#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define TRIG_PIN 9
#define ECHO_PIN 10
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

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

void setup() {
Serial.begin(9600);
pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);

// Initialize OLED
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println("OLED not found!");
while (true);
}

display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, 0);
display.println("Distance Sensor");
display.display();
delay(1500);
}

void loop() {
long duration;
float distance;

// Send trigger pulse
digitalWrite(TRIG_PIN, LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);

// Measure echo time
duration = pulseIn(ECHO_PIN, HIGH);
distance = (duration * 0.034) / 2;

// Print to Serial Monitor
Serial.print("Distance: ");
Serial.print(distance);
Serial.println(" cm");

// Display on OLED
display.clearDisplay();
display.setTextSize(1);
display.setCursor(0, 0);
display.println("Distance Sensor");

display.setTextSize(2);
display.setCursor(0, 30);
display.print(distance, 1);
display.println(" cm");
display.display();

delay(500);
}

Explanation: The Arduino sends a pulse from the HC-SR04 and measures the time it takes to return.
It then converts this time into distance and displays it on the OLED screen.

Code Breakdown

  • pulseIn() measures the length of time the echo pin is HIGH.
  • Distance is calculated using the speed of sound (0.034 cm/μs).
  • Adafruit_SSD1306 and Adafruit_GFX libraries drive the OLED.
  • Display refreshes every 0.5 seconds for updated readings.

Install these via Arduino IDE → Sketch → Include Library → Manage Libraries:

  • Adafruit SSD1306
  • Adafruit GFX

Search for “Adafruit SSD1306” and “Adafruit GFX” and click Install.

Troubleshooting

Issue Cause Solution
OLED blank Wrong I2C address Try changing 0x3C to 0x3D
Distance always 0 Echo pin not connected Check TRIG and ECHO wiring
Unstable readings Object too close or far HC-SR04 range: 2–400 cm
Serial Monitor empty Wrong baud rate Ensure 9600 baud in Serial Monitor

Optional Upgrades

  • Add a buzzer that activates when an object is too close.
  • Display a bar graph or animation on the OLED.
  • Send readings to the cloud using ESP8266 / ESP32.
  • Log readings to an SD card.

Applications

  • Parking assist system
  • Object detection robot
  • Smart trash bin (auto open lid)
  • Liquid level detector.
[mai mult...]

Arduino Motion Sensor Guide (Using a PIR Sensor)

A PIR (Passive Infrared) sensor detects motion by measuring changes in infrared radiation emitted by objects (like humans or animals) within its field of view.

PIR sensors are commonly used for:

Component Quantity Notes
Arduino Uno (or Nano, Mega, etc.) 1 Any compatible board
PIR Motion Sensor (HC-SR501 or similar) 1 Adjustable sensitivity and delay
Breadboard 1 For easy connections
Jumper wires ~5 Male-to-male recommended
LED 1 Optional for visual indication
220Ω resistor 1 For LED current limiting
USB cable 1 For programming and power

 Understanding the PIR Sensor

Typical PIR module (e.g., HC-SR501) has 3 pins:

Pin Label Function
1 VCC Power (connect to +5V)
2 OUT Sends HIGH when motion is detected
3 GND Connects to Ground

Adjustable knobs (optional):

  • Sensitivity: changes detection range (typically 3–7 meters)
  • Time delay: how long output stays HIGH after motion (usually 0.3s–5min)

Wiring Diagram

PIR Sensor Arduino Notes
VCC 5V Power supply
OUT D2 Digital input pin
GND GND Common ground
LED (+) D13 Visual output (optional)
LED (–) GND (via 220Ω resistor) Current limit

Connect VCC → 5V, GND → GND, OUT → D2, LED → D13 (optional)

Arduino Code Example


// PIR Motion Sensor with LED Example

int pirPin = 2; // PIR sensor output pin
int ledPin = 13; // LED pin

int pirState = LOW; // Default state
int val = 0; // Variable for reading the pin status

void setup() {
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
Serial.println("PIR Motion Sensor Active");
}

void loop() {
val = digitalRead(pirPin); // Read input value from PIR

if (val == HIGH) {
digitalWrite(ledPin, HIGH); // Turn LED ON
if (pirState == LOW) {
Serial.println("Motion detected!");
pirState = HIGH;
}
} else {
digitalWrite(ledPin, LOW); // Turn LED OFF
if (pirState == HIGH) {
Serial.println("Motion ended!");
pirState = LOW;
}
}
}

Explanation: The PIR output goes HIGH when motion is detected. The LED turns on and a message is printed to the Serial Monitor.

How It works

  1. Warm-up time: After powering up, the PIR sensor takes ~30–60 seconds to stabilize.
  2. Detection: When an object moves, the sensor’s output pin goes HIGH.
  3. Reset: After the set delay, the output returns LOW until new motion is detected.

1. Control a Relay

Use motion detection to control a light or appliance:


int relayPin = 8; // connect to relay module IN pin
// Replace ledPin with relayPin in code

2. Buzzer Alarm

Add a buzzer that sounds when motion is detected:


int buzzerPin = 9;
digitalWrite(buzzerPin, HIGH);

3. Serial Logging

Send motion logs to a computer or IoT platform for analysis.

4. Automation

Combine PIR with an LDR (light sensor) so it only triggers lights at night.

[mai mult...]