In this tutorial, I’ll walk you through exactly how I use an ESP8266 relay board, from understanding the hardware to writing the firmware and controlling a relay over Wi‑Fi. This is written as if I’m personally guiding you through the process.

What Is an ESP8266 Relay Board?

An ESP8266 relay board combines two things on one PCB:

• ESP8266 Wi‑Fi microcontroller (usually ESP‑12 / ESP‑12F)
• One or more mechanical relays for switching higher‑voltage or higher‑current loads

Because the ESP8266 has built‑in Wi‑Fi, the relay can be controlled:

• From a web browser
• From a phone app
• From another server or IoT platform

This makes it perfect for:

• Home automation
• Smart switches
• Remote power control
• IoT experiments

Typical ESP8266 1-Channel Relay Board Features

This guide is specifically written for a 1-channel ESP8266 relay board, which is the most common and beginner-friendly version.

• A: 7-30V+ DC power supply
• B: Power supply ground
• C: ESP8266 Serial Port (Used to program the ESP8266)
• D: ESP8266 Boot Select
• E: Normally closed (NC) relay contact
• F: Common (COM) relay contact
• G: Normally open (NO) relay contact
• H: 5V+ out
• I: ESP8266 GPIO5 Optocoupler Input
• J: Ground (isolated optocoupler input)

 Important: Even though the ESP8266 runs at 3.3V, the relay side may switch 110V / 220V AC.

Understanding the Relay Terminals (Very Important)

Each relay has three main terminals:

• COM (Common) – the moving contact
• NO (Normally Open) – disconnected when relay is OFF
• NC (Normally Closed) – connected when relay is OFF

How I usually wire it

• For devices that should be OFF by default → I use COM + NO
• For devices that should be ON by default → I use COM + NC

Powering the ESP8266 Relay Board

This is where many beginners make mistakes.

Common power options

1. 5V via Micro‑USB (recommended if available)
2. 5V to VIN pin
3. External regulated 5V supply

The onboard regulator converts 5V → 3.3V for the ESP8266.

I avoid powering relays from weak USB ports. Relays draw surge current when switching.

ESP8266 GPIO Pin Used for a 1-Channel Relay

On a 1-channel relay board, only one GPIO is used to control the relay.

Before coding, I always:

• Check the board schematic or silkscreen
• Test the relay manually with a simple sketch

My board uses GPIO4 to control the relay. This is shown in the schematic:

Some GPIOs affect boot mode (GPIO0, GPIO2, GPIO15). Using the wrong pin can prevent booting.

Programming the ESP8266 Relay Board

What I use

• Arduino IDE
• ESP8266 Board Package
• USB‑to‑Serial driver (CH340 or CP2102)

Adding ESP8266 to Arduino IDE

1. Open Arduino IDE
2. Go to Preferences
3. Add this URL to Additional Boards Manager URLs: https://arduino.esp8266.com/stable/package_esp8266com_index.json
4. Install ESP8266 Boards from Boards Manager

Simple Relay Control Code (My Go‑To Test Sketch)

This is the first sketch I upload to confirm the hardware works.

#define RELAY_PIN 4  // change based on your board

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW); // relay OFF (some boards are inverted)
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH); // relay ON
  delay(2000);
  digitalWrite(RELAY_PIN, LOW);  // relay OFF
  delay(2000);
}

If the relay clicks every 2 seconds, your board is working.

Relay Logic: Normal vs Inverted

Many ESP8266 relay boards are active‑LOW, meaning:

• LOW → Relay ON
• HIGH → Relay OFF

If your relay behaves backward, simply invert the logic in software.

Controlling the Relay via Wi‑Fi (Web Server Example)

This is where the ESP8266 really shines.

What I usually do

• Run a small HTTP server
• Add /on and /off endpoints
• Control the relay from any browser

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

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

ESP8266WebServer server(80);

// Pin definitions
#define RELAY_PIN 4   // Relay control (active LOW)
#define OPTO_PIN  5   // Optocoupler input (INPUT_PULLUP)

// State tracking
volatile bool relayState = false;
volatile bool optoState  = false;

// -------------------- Relay handlers --------------------

void handleOn() {
  relayState = true;
  digitalWrite(RELAY_PIN, LOW);   // active LOW
  server.send(200, "text/plain", "Relay ON");
}

void handleOff() {
  relayState = false;
  digitalWrite(RELAY_PIN, HIGH);
  server.send(200, "text/plain", "Relay OFF");
}

// -------------------- Optocoupler handler --------------------

bool readOptoDebounced() {
  // Read optocoupler (normally HIGH, pulled LOW when active)
  if (digitalRead(OPTO_PIN) == LOW) {
    delay(20); // debounce
    if (digitalRead(OPTO_PIN) == LOW) {
      return true;   // opto active
    }
  }
  return false;      // opto inactive
}

void handleInput() {
  optoState = readOptoDebounced();

  if (optoState) {
    server.send(200, "text/plain", "Opto INPUT: ON");
  } else {
    server.send(200, "text/plain", "Opto INPUT: OFF");
  }
}

// -------------------- Setup --------------------

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(OPTO_PIN, INPUT_PULLUP);

  // Relay OFF at boot (safe default)
  digitalWrite(RELAY_PIN, HIGH);

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

  // HTTP endpoints
  server.on("/on", handleOn);
  server.on("/off", handleOff);
  server.on("/input", handleInput);

  server.begin();
}

// -------------------- Main loop --------------------

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

Now I can control the relay by opening:

• http://ESP_IP/on
• http://ESP_IP/off

Additional Notes:

1. You must connect a separate and appropriate power supply independent of the USB‑to‑Serial programmer when programming. The USB‑to‑Serial programmer probably has insufficient power.
2. P5 connector (labeled D in the guide image above) is meant to be jumped together only during programming. When programming is complete, remove the jumper and reboot.
3. Connect your USB‑to‑Serial RX to P6 (labeled C) TX, and USB‑to‑Serial TX to P6 RX, and USB‑to‑Serial ground to the ground.

Common Problems 

Relay clicks randomly

• Power supply is weak
• Add bulk capacitor (470µF–1000µF)

ESP8266 keeps rebooting

• Relay coil noise
• Poor grounding
• Use opto‑isolated relay board

Board won’t boot

• Wrong GPIO used
• GPIO0 or GPIO2 held LOW at boot

Safety Notes 

When switching AC mains:

• Never touch the board while powered
• Use proper enclosures
• Keep high‑voltage and low‑voltage sides separated
• If unsure, test with low‑voltage DC first

I always prototype with a 12V load before moving to AC.

Home Assistant via REST (HTTP)

Relay as a Home Assistant switch

Add this to configuration.yaml:

switch:
  - platform: rest
    name: ESP8266 Relay
    resource: http://ESP_IP/on
    method: GET
    body_on: ""
    body_off: ""
    state_resource: http://ESP_IP/input
    is_on_template: "{{ value == 'Relay ON' }}"

Limitation:

• REST switch does not automatically know the relay state
• Home Assistant assumes success if HTTP 200 is returned

When this is OK

• Manual switching
• Simple dashboards
• No complex automations

Optocoupler input as a binary sensor

Add this:

binary_sensor:
  - platform: rest
    name: ESP8266 Opto Input
    resource: http://ESP_IP/input
    scan_interval: 1
    value_template: >
      {{ 'ON' in value }}

Now Home Assistant sees the optocoupler as:

• Door sensor
• Button
• External trigger
• Dry contact

This is very powerful.

Automation example (opto → relay)

automation:
  - alias: "Opto turns relay ON"
    trigger:
      - platform: state
        entity_id: binary_sensor.esp8266_opto_input
        to: "on"
    action:
      - service: switch.turn_on
        target:
          entity_id: switch.esp8266_relay

REST drawbacks 

No guaranteed state
No retain
Polling overhead
Hard to scale

That’s why MQTT exists.

Home Assistant via MQTT (recommended)

This is how commercial IoT devices do it.

MQTT concept (simple view)

Home Assistant ──▶ MQTT ──▶ ESP8266
Home Assistant ◀─ MQTT ◀── ESP8266

• Commands and state are decoupled
• Works even if HA restarts
• Instant updates (no polling)

MQTT topics for your device

I recommend this structure:

Home Assistant MQTT config

mqtt:
  switch:
    - name: "ESP8266 Relay"
      command_topic: "home/relay1/set"
      state_topic: "home/relay1/state"
      payload_on: "ON"
      payload_off: "OFF"
      state_on: "ON"
      state_off: "OFF"
      retain: true

  binary_sensor:
    - name: "ESP8266 Opto Input"
      state_topic: "home/relay1/opto"
      payload_on: "ON"
      payload_off: "OFF"

Now:

• Relay state is authoritative
• Opto input is event-driven

ESP8266 MQTT behavior (logic summary)

Your ESP8266 should:

On boot

• Publish relay state
• Publish opto state

On relay change

• Publish

  home/relay1/state

On opto change

• Publish

  home/relay1/opto

This eliminates guesswork.

ESPHome (cleanest long-term option)

If you’re OK reflashing firmware, ESPHome is unbeatable.

ESPHome YAML for your board

esphome:
  name: esp8266_relay

esp8266:
  board: esp12e

wifi:
  ssid: "YOUR_WIFI"
  password: "YOUR_PASSWORD"

switch:
  - platform: gpio
    pin:
      number: GPIO4
      inverted: true
    name: "Relay"

binary_sensor:
  - platform: gpio
    pin:
      number: GPIO5
      mode: INPUT_PULLUP
      inverted: true
    name: "Opto Input"

The post How To Use an ESP8266 WiFi Relay Board appeared first on Microcontroller Tutorials.

Components Needed

1. ESP8266 (NodeMCU or D1 Mini recommended)
2. L298N Motor Driver Module
3. DC Motor (6V-12V)
4. External Power Supply (for the motor, such as a 9V battery or a suitable DC adapter)
5. Jumper Wires
6. Arduino Cloud account

Set Up Your Arduino Cloud Account

1. Go to Arduino Cloud and sign in or create an account if you haven’t already.
2. Once logged in, create a new thing in Arduino Cloud, which represents your device.
3. Add variables for controlling the motor:
   • motorState (type: Boolean) – to turn the motor ON or OFF
   • motorSpeed (type: Integer, 0-100) – to control the speed of the motor
4. Go to Devices > Add Device and select Set up an ESP8266 device. Follow the instructions to add your ESP8266 to your Arduino Cloud account. This will link your ESP8266 to the variables in the thing.

Connect the ESP8266 to the L298N Motor Driver and DC Motor

L298N Motor Driver Pinout:

• IN1 and IN2 control the direction of the motor.
• ENA controls the speed of the motor.
• GND and VCC provide power to the L298N module.
• OUT1 and OUT2 connect to the motor terminals.

Wiring:

1. Connect the IN1 and IN2 pins on the L298N to D1 and D2 pins on the ESP8266.
2. Connect the ENA pin on the L298N to D3 on the ESP8266.
3. Connect OUT1 and OUT2 on the L298N to the motor terminals.
4. Connect the GND pin on the L298N to the GND pin on the ESP8266.
5. Provide power to the motor driver module:
   • Connect the +12V input on the L298N to an external 9V or 12V power supply (depending on your motor’s requirement).
   • Connect the GND of the external power supply to the GND of the ESP8266.

Programming the ESP8266 in Arduino Cloud

1. In Arduino Cloud, open the code editor for your ESP8266.
2. Replace the generated code with the following code to control the motor through the Arduino Cloud variables.

<arduinoiotcloud.h><arduino_connectionhandler.h><span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string"><ArduinoIoTCloud.h></span></span> 
<span class="hljs-meta">#<span class="hljs-keyword">include</span> <span class="hljs-string"><Arduino_ConnectionHandler.h></span></span>

// Motor control pins
const int IN1 = D1;
const int IN2 = D2;
const int ENA = D3;

<span class="hljs-comment">// Replace with your network credentials</span> 
<span class="hljs-type">const</span> <span class="hljs-type">char</span> SSID[] = <span class="hljs-string">"your_SSID"</span>; 
<span class="hljs-type">const</span> <span class="hljs-type">char</span> PASS[] = <span class="hljs-string">"your_PASSWORD"</span>;

<span class="hljs-comment">// Initialize connection to Arduino IoT Cloud</span> 
<span class="hljs-function">WiFiConnectionManager <span class="hljs-title">ArduinoIoTPreferredConnection</span><span class="hljs-params">(SSID, PASS)</span></span>;

// Arduino Cloud variables
bool motorState;
int motorSpeed;

void setup() {
  // Initialize serial communication for debugging
  Serial.begin(115200);
  
  // Configure motor control pins
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
  
  // Arduino Cloud connection
  initProperties();
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
}

void loop() {
  // Arduino Cloud loop
  ArduinoCloud.update();
  
  // Update motor control based on cloud variables
  if (motorState) {
    digitalWrite(IN1, HIGH);  // Set motor direction
    digitalWrite(IN2, LOW);
    analogWrite(ENA, map(motorSpeed, 0, 100, 0, 255));  // Adjust speed
  } else {
    digitalWrite(IN1, LOW);
    digitalWrite(IN2, LOW);
    analogWrite(ENA, 0);  // Turn off motor
  }
}

void initProperties() {
  ArduinoCloud.addProperty(motorState, READWRITE, ON_CHANGE, NULL);
  ArduinoCloud.addProperty(motorSpeed, READWRITE, ON_CHANGE, NULL);
}
</arduino_connectionhandler.h></arduinoiotcloud.h>

Upload the Code

1. Ensure your ESP8266 is connected to your computer and select the correct board and port in Arduino Cloud.
2. Upload the code from the Arduino Cloud editor.

Test Your Setup

1. In Arduino Cloud, navigate to the thing dashboard.
2. You should see the motorState and motorSpeed variables.
3. Toggle motorState to ON to start the motor.
4. Adjust motorSpeed (0-100) to change the motor’s speed.

Explanation of the Code

• motorState variable controls the motor’s ON/OFF state.
• motorSpeed variable (0-100) is mapped to the range 0-255, which is the PWM range for controlling speed on the ENA pin.
• The loop() function reads the cloud variables and adjusts the motor’s behavior based on their values.

Additional Tips

• Motor Direction Control: You can reverse the motor direction by swapping digitalWrite(IN1, HIGH)  and digitalWrite(IN2, LOW) with digitalWrite(IN1, LOW) and digitalWrite(IN2, HIGH).
• Add Indicators: Connect an LED to the ESP8266 to show when the motor is active or use the serial monitor to debug issues.

Conclusion

With this setup, you can control your DC motor remotely via Arduino Cloud. This project can be expanded with additional features, such as a feedback system using sensors to monitor motor performance.

The post How to Use L298N Motor Driver with ESP8266 appeared first on Microcontroller Tutorials.

We will walk through setting up an example project where the ESP8266 communicates with another nRF24L01 module, allowing wireless data transmission.

Table of Contents

1. Understanding ESP8266 and nRF24L01
2. Wiring the ESP8266 and nRF24L01
3. Setting up the Arduino IDE
4. Writing the Code for the ESP8266
5. Example Project: Wireless Data Transmission
6. Testing the Project

Understanding ESP8266 and nRF24L01

ESP8266 Overview

The ESP8266 is a low-cost microcontroller with built-in Wi-Fi, ideal for IoT projects. It can be programmed using the Arduino IDE or other platforms, and it has several GPIO pins that can be used for digital input/output, PWM, and communication protocols like SPI and I2C.

nRF24L01 Overview

The nRF24L01 is a 2.4GHz RF transceiver that uses SPI communication. It supports multiple data rates and has a range of up to 100 meters in line-of-sight conditions. It is ideal for short-range wireless communication between microcontrollers and other devices.

Key features:

• Frequency: 2.4 GHz
• Data rate: Up to 2 Mbps
• Range: ~100 meters
• Power consumption: Low (in microamperes when on standby)

Wiring the ESP8266 and nRF24L01

The nRF24L01 uses SPI to communicate with the ESP8266. The pinout of both devices is as follows:

nRF24L01 Pinout

Wiring to ESP8266 (NodeMCU/ESP-12E)

Setting up the Arduino IDE

To program the ESP8266 using the Arduino IDE, follow these steps:

Step 1: Install the ESP8266 Board Package

1. Open the Arduino IDE.
2. Go to File > Preferences.

Add the following URL in the "Additional Boards Manager URLs":

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Go to Tools > Board > Boards Manager, search for ESP8266, and install the package.

Step 2: Install the RF24 Library

1. In the Arduino IDE, go to Sketch > Include Library > Manage Libraries.
2. Search for RF24 by TMRh20 and install it. This library is necessary for interfacing with the nRF24L01 module.

Writing the Code for the ESP8266

We will now write the code to transmit data from the ESP8266 to another nRF24L01 module.

Transmitter Code for ESP8266

#include <SPI.h><spi.h>
#include <RF24.h><rf24.h>

// Define nRF24L01 pins
#define CE_PIN 4  // GPIO4 (D2)
#define CSN_PIN 15 // GPIO15 (D8)

// Create an RF24 object
RF24 radio(CE_PIN, CSN_PIN);

// Define the address (must match on both transmitter and receiver)
const byte address[6] = "00001";

// Data to send
const char text[] = "Hello from ESP8266!";

void setup() {
  // Start the serial communication for debugging
  Serial.begin(115200);

  // Initialize the radio
  radio.begin();
  
  // Set the communication address
  radio.openWritingPipe(address);
  
  // Set the data rate and power level (can be adjusted for range)
  radio.setPALevel(RF24_PA_LOW);
  radio.setDataRate(RF24_1MBPS);

  // Ensure radio is in transmit mode
  radio.stopListening();
}

void loop() {
  // Send the data
  bool success = radio.write(&text, sizeof(text));

  // Check if data was sent successfully
  if (success) {
    Serial.println("Data sent successfully");
  } else {
    Serial.println("Failed to send data");
  }

  // Delay before sending the next data
  delay(1000);
}
</rf24.h></spi.h>

Receiver Code (Arduino/ESP8266)

You can also use an Arduino or another ESP8266 as a receiver for the data. The wiring for the nRF24L01 will remain the same.

#include <SPI.h><spi.h>
#include <RF24.h><rf24.h>

#define CE_PIN 9   // Use appropriate pin for your board
#define CSN_PIN 10 // Use appropriate pin for your board

RF24 radio(CE_PIN, CSN_PIN);
const byte address[6] = "00001";
char receivedText[32] = ""; // Buffer to hold received data

void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setPALevel(RF24_PA_LOW);
  radio.setDataRate(RF24_1MBPS);
  radio.startListening();
}

void loop() {
  if (radio.available()) {
    radio.read(&receivedText, sizeof(receivedText));
    Serial.print("Received data: ");
    Serial.println(receivedText);
  }
}
</rf24.h></spi.h>

Example Project: Wireless Data Transmission

In this example project, the ESP8266 acts as a transmitter that sends data to another device (either an Arduino or another ESP8266) equipped with an nRF24L01 module. The data is sent wirelessly at intervals of one second.

Steps:

1. Wire the components as shown in the wiring diagram.
2. Upload the transmitter code to the ESP8266.
3. Upload the receiver code to the second ESP8266 or Arduino.
4. Open the Serial Monitor on both devices to see the data being sent and received.

Testing the Project

After uploading the code, open the Serial Monitor on both the transmitter and receiver. You should see the message "Data sent successfully" on the transmitter and the message "Received data: Hello from ESP8266!" on the receiver.

Troubleshooting:

• Ensure the wiring is correct.
• Make sure both the transmitter and receiver have matching communication addresses.
• Check if the power supply to the nRF24L01 module is stable. You may need a capacitor (10µF) across the VCC and GND of the nRF24L01 module to prevent power fluctuations.

Conclusion

In this tutorial, you learned how to interface an ESP8266 with the nRF24L01 wireless module for wireless communication. We set up a simple project where the ESP8266 transmits data to another nRF24L01 module. This setup is useful for short-range wireless communication between ESP8266 devices, such as in IoT projects or sensor networks.

The post ESP8266 nRF24L01 Interfacing appeared first on Microcontroller Tutorials.

The ESP8266 is a popular Wi-Fi microcontroller that enables wireless communication between devices. One of the most efficient ways to transfer data between two ESP8266 modules is using the UDP protocol (User Datagram Protocol). UDP is a connectionless protocol that sends data packets without needing an established connection, making it fast and lightweight—ideal for real-time communication in IoT projects.

In this article, we’ll create a project where one ESP8266 collects sensor data and sends it to another ESP8266 using UDP. The second ESP8266 hosts a web server that displays the sensor data in real-time.

How UDP Communication Works

UDP is a simple communication protocol that sends packets called datagrams between devices on a network. Unlike TCP, it doesn't require a connection to be maintained, so it's faster but less reliable since there's no guarantee that packets will be delivered. This makes UDP suitable for use cases where speed is critical, and occasional packet loss can be tolerated.

Advantages of Using UDP

• Fast: No need to establish or maintain a connection, reducing overhead.
• Efficient: Ideal for real-time applications where speed is more important than reliability.
• Lightweight: Lower memory and processing requirements compared to TCP.

Disadvantages

• No reliability: Packets can get lost or arrive out of order.
• No error checking: UDP doesn't ensure the data is intact.

Project Overview

In this project, two ESP8266 modules will communicate over Wi-Fi using UDP:

1. Sender ESP8266: Reads data from a sensor (e.g., temperature or humidity sensor) and sends it via UDP.
2. Receiver ESP8266: Hosts a web server, receives the UDP packets, and displays the sensor data on a web page.

Components Needed

• Two ESP8266 modules (e.g., ESP-01 or NodeMCU)
• A DHT11 or DHT22 sensor (for temperature and humidity)
• Jumper wires
• Breadboard

Wiring Diagram

1. Sender ESP8266 (with DHT sensor)
   • Connect the DHT sensor as follows:
     • VCC → 3.3V on ESP8266
     • GND → GND
     • DATA → GPIO 2 (D4 on NodeMCU)
2. Receiver ESP8266: No additional connections needed, as it only serves to host the webserver.

Setting Up UDP Communication Between Two ESP8266 Modules

We'll first write code for the sender ESP8266, which reads data from the sensor and sends it via UDP. Then, we'll create a receiver ESP8266 that listens for incoming UDP packets and displays the data on a web page.

Code for Sender ESP8266

The sender reads data from a DHT sensor and sends it as a UDP packet to the receiver ESP8266.

Install the DHT Sensor Library

In the Arduino IDE, go to Sketch > Include Library > Manage Libraries and install the DHT sensor library by Adafruit.

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include "DHT.h"

#define DHTPIN 2 // Pin where the DHT sensor is connected
#define DHTTYPE DHT11 // DHT 11 or DHT22, change accordingly

// Your network credentials
const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";

// Receiver ESP8266 IP address and port
const char* receiverIP = "192.168.1.100"; // Replace with the actual IP of the receiver
const unsigned int receiverPort = 4210; // The UDP port number

DHT dht(DHTPIN, DHTTYPE);
WiFiUDP udp;

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

// Connect to Wi-Fi
   WiFi.begin(ssid, password);
   while (WiFi.status() != WL_CONNECTED) {
      delay(1000);
      Serial.println("Connecting to WiFi...");
   }
   Serial.println("Connected to WiFi");
}

void loop() {
// Read temperature and humidity
   float h = dht.readHumidity();
   float t = dht.readTemperature();

   if (isnan(h) || isnan(t)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }

// Prepare the UDP message
   String message = "Temperature: " + String(t) + " C, Humidity: " + String(h) + " %";
   Serial.println("Sending message: " + message);

// Send the message to the receiver ESP8266
   udp.beginPacket(receiverIP, receiverPort);
   udp.print(message);
   udp.endPacket();

   delay(2000); // Wait 2 seconds before sending the next packet
}

1. WiFi Setup: The ESP8266 connects to the local Wi-Fi network using your SSID and password.
2. DHT Sensor: Reads temperature and humidity from the DHT sensor.
3. UDP Communication: The data is formatted as a string and sent via UDP to the receiver ESP8266 using WiFiUDP.

Code for Receiver ESP8266 (Web Server)

The receiver listens for UDP packets and displays the sensor data on a web page.

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <ESP8266WebServer.h>

// Your network credentials
const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";

// UDP settings
WiFiUDP udp;
unsigned int localPort = 4210; // The port to listen on
char incomingPacket[255]; // Buffer to hold incoming packets

// Web server object
ESP8266WebServer server(80);

String sensorData = "No data received";

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

// Connect to Wi-Fi
   WiFi.begin(ssid, password);
   while (WiFi.status() != WL_CONNECTED) {
      delay(1000);
      Serial.println("Connecting to WiFi...");
   }
   Serial.println("Connected to WiFi");
   Serial.print("IP Address: ");
   Serial.println(WiFi.localIP());

// Start UDP
   udp.begin(localPort);
   Serial.printf("Listening on UDP port %d\n", localPort);

// Start the web server
   server.on("/", handleRoot);
   server.begin();
   Serial.println("Web server started");
}

void loop() {
// Listen for incoming UDP packets
   int packetSize = udp.parsePacket();
   if (packetSize) {
      int len = udp.read(incomingPacket, 255);
      if (len > 0) {
         incomingPacket[len] = 0;
      }
      Serial.printf("UDP packet received: %s\n", incomingPacket);
      sensorData = String(incomingPacket);
   }

// Handle web server requests
   server.handleClient();
}

// Function to handle the web page
void handleRoot() {
   String html = "<html><body><h1>Sensor Data</h1>";
   html += "<p>" + sensorData + "</p>";
   html += "</body></html>";
   server.send(200, "text/html", html);
}

Code Breakdown (Receiver):

1. UDP Listener: The ESP8266 listens for incoming UDP packets on a specified port. When a packet is received, the sensor data is extracted and stored.
2. Web Server: Hosts a simple web server that serves a page displaying the latest sensor data. The data is refreshed every time the user accesses the page.

Setting Up the IP Address of the Receiver

To ensure communication between the two ESP8266 modules, you need to know the IP address of the receiver ESP8266. After uploading the code, open the Serial Monitor to find the IP address of the receiver. Then, update the receiverIP in the sender code with this address.

Viewing the Sensor Data

1. Power up both ESP8266 modules. The sender will read data from the DHT sensor and send it to the receiver via UDP.
2. Open a web browser on a device connected to the same Wi-Fi network and enter the IP address of the receiver ESP8266 (as shown in the Serial Monitor).
3. The web page will display the current sensor readings (temperature and humidity), which are updated every 2 seconds.

Conclusion

By using UDP communication between two ESP8266 modules, you can efficiently send real-time sensor data from one ESP to another and visualize the data via a web server. This project demonstrates how easy it is to set up wireless communication for IoT applications, offering a foundation to build more complex systems such as remote monitoring, smart home devices, or industrial sensors.

The post ESP8266 UDP: Sending Data Between Two ESPs appeared first on Microcontroller Tutorials.

Mini Water Pump Specification

Here's some information about the pump:

• Operating Current : 130 ~ 220mA
• Flow Rate : 80 ~ 120 L/H
• Maximum Lift : 40 ~ 110 mm
• Continuous Working Life: 500 hours
• Driving Mode: DC, Magnetic Driving
• Material: Engineering Plastic
• Outlet Outside Diameter: 7.5 mm
• Outlet Inside Diameter : 5 mm

It is a submersible pump and should be used that way. It tends to heat too much that there's a risk of overheating if you turn it on unsubmerged.

Water Pump and WeMos D1 Mini Connection

The first thing I noticed is that it requires a wider tube pipe compared to the ones used by aquarium air pumps so I had to purchase one separately. The operating current also makes it impossible to connect the wires directly to one of the GPIO pins of the ESP8266 (which maxes out at 12 mA). So naturally, I had to design a way to turn on/off the pump with enough power for it.

Here I have a 2N7000 MOSFET switch triggered by a signal coming from the WeMos D1. With this, the power through the pump is from the external power supply and not from the WeMos D1.

Next, I created a WiFi server application so that I may able to control the pump through my smartphone. Basically, the WeMos D1 Mini broadcasts an access point and then I connect to that access point. I then visit an IP address using a web browser and there an interface is shown for controlling the water pump.

As of now, the only thing I can do is turn on or turn off the water pump. Inside this Arduino water pump is a motor so I may try to control it by using PWM. That would be an update in the days to come.

Full Sketch

Here's the full sketch for the WiFi server:

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

const char* ssid = "Pump Controller";
const char* password = "12345678";

ESP8266WebServer server(80);

const int pump = 8;
static const String page PROGMEM = "<h1>Water Pump Controller</h1><p><a href=\"PumpOn\"><button>ON</button></a> <a href=\"PumpOff\"><button>OFF</button></a></p>";
 
void setup(void) {
  
  pinMode(pump, OUTPUT);
  digitalWrite(pump, 0);
  Serial.begin(115200);
 
  WiFi.softAP(ssid, password);
  Serial.println("");

  Serial.println(ssid);
  Serial.print("WiFi Server started at IP address: ");
  Serial.println(WiFi.softAPIP());


  server.on("/", [](){
    server.send(200, "text/html", page);
  });
  
  server.on("/PumpOn", [](){
    server.send(200, "text/html", page);
    digitalWrite(pump, HIGH);
    delay(1000);
  });
  
  server.on("/PumpOff", [](){
    server.send(200, "text/html", page);
    digitalWrite(pump, LOW);
    delay(1000);
  });

  server.begin();
  Serial.println("HTTP server started");
}

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

The interface is just simple HTML but I'm planning more things for it in the future.

If you're interested in this project, updates will be made on its repository.

The post Controlling a Water Pump with WeMos D1 Mini appeared first on Microcontroller Tutorials.

Required Libraries

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

const char* ssid = "<YOUR WIFI SSID>";
const char* password = "<YOUR WIFI PASSWORD>";

ESP8266WebServer server(80);

WiFi.softAP(ssid, password);

<h1>WeMos D1 Mini Web Server</h1><p><a href=\"LEDOn\"><button>ON</button></a> <a href=\"LEDOff\"><button>OFF</button></a></p>

String index = "<h1>Simple NodeMCU Web Server</h1><p><a href=\"LEDOn\"><button>ON</button></a> <a href=\"LEDOff\"><button>OFF</button></a></p>";

server.on("/", [](){
    server.send(200, "text/html", index);
});

server.on("/LEDOn", [](){
    server.send(200, "text/html", index);
    digitalWrite(13, HIGH);
    delay(1000);
});

server.on("/LEDOff", [](){
    server.send(200, "text/html", index);
    digitalWrite(13, LOW);
    delay(1000);
});

server.begin();

server.handleClient();

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>


// Replace with your network credentials
const char* ssid = "<YOUR WIFI SSID>";
const char* password = "<YOUR WIFI PASSWORD>";
ESP8266WebServer server(80);   //instantiate server at port 80 (http port)


void setup(void){

  //the HTML of the web page
  String index = "<h1>Simple NodeMCU Web Server</h1><p><a href=\"LEDOn\"><button>ON</button></a> <a href=\"LEDOff\"><button>OFF</button></a></p>";
  //make the LED pin output and initially turned off
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
  
  delay(1000);
  Serial.begin(115200);
  WiFi.softAP(ssid, password); //begin WiFi access point
  Serial.println("");
  
  server.on("/", [](){
    server.send(200, "text/html", index);
  });
  server.on("/LEDOn", [](){
    server.send(200, "text/html", index);
    digitalWrite(13, HIGH);
    delay(1000);
  });
  server.on("/LEDOff", [](){
    server.send(200, "text/html", index);
    digitalWrite(13, LOW);
    delay(1000);
  });
  server.begin();
  Serial.println("Web server started!");
}
void loop(void){
  server.handleClient();
}

The post WeMos D1 Mini WiFi Server appeared first on Microcontroller Tutorials.

Video Tutorial

Why Use SPIFFS?

In my NodeMCU web server article, I used a sketch that presents a simple web page for controlling an external LED.

When this sketch is uploaded to an ESP8266 board, the server page is now viewable in the local network through the device's IP address. This how to server page looks like on a desktop browser:

Clicking the ON button turns on the LED while the OFF button turns off the LED. It looks super simple because the HTML for this page is just this:

<h1>Simple NodeMCU Web Server</h1>
<p>
  <a href=\"LEDOn\"><button>ON</button></a>
  <a href=\"LEDOff\"><button>OFF</button></a>
</p>

A much better looking web page is one with styling, images or scripts. We could do that but we are always mindful of the memory limitations of the ESP8266. Defining a long HTML in sketch means using a long string which jumps from one memory location to another for every compilation. This proves an inefficient memory management scheme and more likely to crash your ESP8266.

The best solution is to store the page files outside of the sketch memory location. The ESP8266 flash memory has the following allocations for the Arduino platform:

Note that the File System and EEPROM size may vary as per user allocation. You can use EEPROM to store data but it still limited. The SPIFFS (File System) size, in contrast, is up to 3 MB. That’s 75% of the total flash size of the ESP8266.

Setting up SPIFFS

To start using SPIFFS, download this file: https://github.com/esp8266/arduino-esp8266fs-plugin/releases/download/0.5.0/ESP8266FS-0.5.0.zip

Inside this zip file is a folder named ESP8266FS. Extract this to /tools inside your Arduino sketchbook location. Create the tools folder if you don’t have one. By default, the sketchbook location is at Documents/Arduino for Windows and Mac or /home/Sketchbook for Linux.

After this, open your Arduino IDE. A new option should appear in Tools:

This tool allows you to add files to your device’s SPIFFS. To add the files, open or create a sketch and place a data folder inside the sketch folder. For example, if I would add an HTML file, that html file is inside a data folder in the same location as my .ino file.

To store the contents of the data folder to SPIFFS, just click the Tools > ESP8266 Sketch Data Upload. Of course you’ll still need to upload the sketch to your NodeMCU because that’s in another location.

In addition, you can specify how much memory you want to allocate to SPIFFS. This is one of the options as you select your ESP8266 board type:

Modifying the Simple Web Server Page

Now that we have SPIFFS set up, we modify the old HTML to make it more pleasing. I created three HTML pages: index.html, LEDOn.html, LEDOff.html. I also added some images and a css file for styling. These are all the contents of my data folder:

When writing HTML, it’s best to code it on text-editor first and view it on a local browser. This way, you can finalize what the pages look like before uploading them to SPIFFS. Here’s my index.html file:

<html>
<head>
<meta name='viewport' content='width=device-width, initial-scale=1.0'>
<link rel='stylesheet' href='style.css'> 
</head>
<body>
      <h1>ESP8266 Web Server with SPIFFS</h1>
      <p><a href='https://www.teachmemicro.com/esp8266-spiffs-web-server-nodemcu/'>Full tutorial</a></p>
      <p> Example showing how to host a web server using ESP8266 Flash File System. This controls the on-board LED. Click button to begin.</p>
      <a href="LEDOff.html"><button id='start-button'>START!</button></a>
</body>
</html>

This is the first file the client reads on the server.

Here’s the LEOn and LEDOff html files:

html>
<head>
<meta name='viewport' content='width=device-width, initial-scale=1.0'>
<link rel='stylesheet' href='style.css'> 
</head>
<body>
      <h1>ESP8266 Web Server with SPIFFS</h1>
      <p><a href='https://www.teachmemicro.com/esp8266-spiffs-web-server-nodemcu/'>Full tutorial</a></p>
      <a href="LEDOff.html"><img id="LED-ON" src="led-on-img.jpg"></a>
</body>
</html>

<html>
<head>
<meta name='viewport' content='width=device-width, initial-scale=1.0'>
<link rel='stylesheet' href='style.css'> 
</head>
<body>
      <h1>ESP8266 Web Server with SPIFFS</h1>
      <p><a href='https://www.teachmemicro.com/esp8266-spiffs-web-server-nodemcu/'>Full tutorial</a></p>
      <a href="LEDOn.html"><img id="LED-OFF" src="led-off-img.jpg"></a>
</body>
</html>

Here's my CSS file:

body{
  background-color:white;
  font-family: 'Roboto', sans-serif;
  border: 1px solid;
  border-color: gray;
  border-radius: 20px;
  margin-left: 35%;
  width: 30%;
  height: 50%;
  padding: 20px;
}

#LED-ON, #LED-OFF{
  margin-left: 25%;
}

#start-button{
  width: 40%;
  height: 20%;
  background-color: darkseagreen;
  border: 1px solid forestgreen;
  border-radius: 10px;
  margin-left: 30%;
  margin-top: 10%;
}

The two images are for showing on and off bulbs:

All in all these files are around 56 kB. Still too small for our 3 MB SPIFFS!

As for the sketch, there are also some changes to the original.

/*

ESP8266 WiFi Server with SPIFFS
by Roland Pelayo

Full tutorial: https://www.teachmemicro.com/esp8266-spiffs-web-server-nodemcu/

Rev 1.0 - Initial code - September 19, 2020

*/

//Declare libraries
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <FS.h>

//provide your own WiFi SSID and password
const char* ssid = "<Your WiFi SSID>";
const char* password = "<Your WiFi Password>";

//Create WebServer instance
ESP8266WebServer server(80);

void setup() {
  //Setup on-board LED
  pinMode(2, OUTPUT);
  //For debugging
  Serial.begin(115200);
  //Initiate WiFi Connection
  WiFi.begin(ssid, password);
  Serial.println("");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  //Print your WiFi's SSID (might be insecure)
  Serial.println(ssid);
  Serial.print("IP address: ");
  //Print your local IP address (needed for browsing the app)
  Serial.println(WiFi.localIP());

  if(!SPIFFS.begin())
  {
    // Serious problem
    Serial.println("SPIFFS Mount failed");
  } else {
    Serial.println("SPIFFS Mount succesfull");
  }

  server.onNotFound([]() { // If the client requests any URI
    if (!handleFileRead(server.uri())) // send it if it exists
      server.send(404, "text/plain", "404: Not Found"); // otherwise, respond with a 404 (Not Found) error
  });

  //start web server
  server.begin();
  //Just stating things
  Serial.println("HTTP server started");
}

void loop() {
  server.handleClient(); //make the ESP32 respond to web clients
}

bool handleFileRead(String path) { // send the right file to the client (if it exists)
  Serial.println("handleFileRead: " + path);
  if (path.endsWith("/")) path += "index.html"; // If a folder is requested, send the index file
  String contentType = getContentType(path); // Get the MIME type
  if (SPIFFS.exists(path)) { // If the file exists
    File file = SPIFFS.open(path, "r"); // Open it
    size_t sent = server.streamFile(file, contentType); // And send it to the client
    if(path == "/LEDOn.html"){
      digitalWrite(2, LOW);
    }else if(path == "/LEDOff.html"){
      digitalWrite(2, HIGH);
    }
    file.close(); // Then close the file again
    return true;
  }
  Serial.println("\tFile Not Found");
  return false; // If the file doesn't exist, return false
}

String getContentType(String filename){
  if(filename.endsWith(".htm")) return "text/html";
  else if(filename.endsWith(".html")) return "text/html";
  else if(filename.endsWith(".css")) return "text/css";
  else if(filename.endsWith(".jpg")) return "image/jpeg";
  return "text/plain";
}

First is the inclusion of the FS library:

#include <FS.h>

This already comes with the ESP8266 core so no need to install it.

Then we start SPIFFS like this:

if (!SPIFFS.begin())
{
  // Serious problem
  Serial.println("SPIFFS Mount failed");
} else {
  Serial.println("SPIFFS Mount succesfull");
}

This way, if SPIFFS fail, we will know via serial monitor.

We will not be using server.on() as before. Instead, we’ll do the opposite:

server.onNotFound([]() { // If the client requests any URI
  if (!handleFileRead(server.uri())) // send it if it exists
    server.send(404, "text/plain", "404: Not Found"); // otherwise, respond with a 404 (Not Found) error
});

The way the server works now is that it will search for files that a client requests. When the client accesses a URL on the server, the file associated with that URL is read from SPIFFS. If the file is not found, a “404:Not Found” is shown on the page. File reading is in a function I call handleFileRead():

bool handleFileRead(String path) { // send the right file to the client (if it exists)
  Serial.println("handleFileRead: " + path);
  if (path.endsWith("/")) path += "index.html"; // If a folder is requested, send the index file
  String contentType = getContentType(path); // Get the MIME type
  if (SPIFFS.exists(path)) { // If the file exists
    File file = SPIFFS.open(path, "r"); // Open it
    size_t sent = server.streamFile(file, contentType); // And send it to the client
    if(path == "/LEDOn.html"){
       digitalWrite(2, LOW);
    }else if(path == "/LEDOff.html"){
       digitalWrite(2, HIGH);
    }
    file.close(); // Then close the file again
    return true;
  }
  Serial.println("\tFile Not Found");
  return false;
}

This is also where we control the LED. When the user accesses the file LEDOn.html, we turn on the LED by making it LOW (the LED is active LOW). Alternatively, when the user accesses the file LEDOff.html, we turn off the LED.

You’ll also notice this function:

String getContentType(String filename){
  if(filename.endsWith(".htm")) return "text/html";
  else if(filename.endsWith(".html")) return "text/html";
  else if(filename.endsWith(".css")) return "text/css";
  else if(filename.endsWith(".jpg")) return "image/jpeg";
  return "text/plain";
}

This returns the MIME type of the file being accessed. This is important as browsers need to know what type of file they are presenting. This is similar to how operating systems view different file extensions.

Upload the sketch, open the serial monitor to acquire the IP address and use that in your browser. This should appear:

Click START and you’ll be on the LEDOff page:

Click the bulb image to turn on the on-board LED!

With a dedicated file system, we have improved our basic ESP8266 web server!

The post ESP8266 SPIFFs | File System for NodeMCU appeared first on Microcontroller Tutorials.

Materials

• WeMos D1 Mini
• Tower Pro SG90 Micro Servo
• Connecting wires, power source

The WeMos D1 Mini is one of the smallest breakout boards for the ESP8266. In this project, I will write the code for the WeMos D1 using the Arduino IDE.

All digital pins of the WeMos D1 Mini support PWM so there’s a lot of options in connecting the servo motor. I will presume that you already know how a servo motor works with a microcontroller.

The SG90 servo motor was chosen primarily because of its lower power consumption. I haven’t tried a larger servo motor but I presume using it, with the WeMos D1 on WiFi, will strain the device.

Wiring Diagram

The WeMos D1 Mini connects to the servo motor as shown:

As previously mentioned, all digital pins of the WeMos D1 Mini supports PWM. I chose D4 because it’s the closest one to the power pins.

WiFi Servo Controller App

Most WiFi servo controllers I see use buttons to move the servo motor arm between positions. For this project, I decided to use a rotating wheel to move the servo motor arm.

To achieve this, I need to use JQuery UI to make the wheel rotatable and then AJAX to send the angle of the wheel to be read by the WeMos D1 server. JQuery UI is for desktop web applications so I also needed to add a plugin for the app to work on touch devices. Finally, I also used bootstrap to position the elements on the app.

All in all, these were the needed Javascript libraries:

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script>
<script type='text/javascript' src='https://code.jquery.com/ui/1.11.4/jquery-ui.js'></script>
<script type='text/javascript' src='https://www.jqueryscript.net/demo/jQuery-UI-Rotatable-Elements/jquery.ui.rotatable.js'></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/jqueryui-touch-punch/0.2.3/jquery.ui.touch-punch.min.js'></script>
<script src='https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js'></script>

These are all in the <head> tag of the app.

Here’s the HTML code for the <body> of the app:

<div class='container'>
  <h1>WeMos D1 Servo Controller</h1> "
  <h4>Rotate wheel to rotate servo</h4>"
  <a href='https://www.teachmemicro.com/wifi-servo-controller-using-wemos-d1-mini'>Full tutorial</a>"
  <div class='row'>
     <div class='col-xs-12'>
       <div id='wheel'></div>
     </div>
     <div class='col-xs-12'>
        <img id='tmm-logo' src='https://i.imgur.com/G80eVhL.png' />
      </div>
   </div>
</div>

$(document).ready(function(){
            $('#wheel').draggable({handle: '.ui-rotatable-handle'}).rotatable({
               rotate: function(e, ui){
               var degrees = ui.angle.current * 180/Math.PI;
               if ( degrees > 90 ) {    
                  ui.angle.current = Math.PI/2;    
               } else if ( degrees < -90) {        
                  ui.angle.current = -1*Math.PI/2;  
               }
               degrees = degrees + 90;
               console.log(degrees);
               var s = String(degrees);
            $.ajax({
               type: 'POST',
               url: 'dataHandler',
               data: s,
               contentType: 'application/x-www-form-urlencoded'
            });
           },snap: true   //for the wheel to snap at discrete angles
          });
});;

$('#wheel').draggable({handle: '.ui-rotatable-handle'}).rotatable({
               rotate: function(e, ui){
               var degrees = ui.angle.current * 180/Math.PI;
               ...

if ( degrees > 90 ) {    
      ui.angle.current = Math.PI/2;    
  } else if ( degrees < -90) {        
      ui.angle.current = -1*Math.PI/2;  
  }
  ...

...
    degrees = degrees + 90;
    console.log(degrees);    //for debugging on the browser
    var s = String(degrees);
    $.ajax({
         type: 'POST',
         url: 'dataHandler',
         data: s,
         contentType: 'application/x-www-form-urlencoded'
    });

//Home page. Contents of 'page' is in mainpage.h
server.on("/", []() {
  server.send(200, "text/html", page);
});
//JavaScript! Contents of 'javascript' is in jscript.h
server.on("/jscript.js", []() {
  server.send(200, "text/javascript", javascript);
});
//POST data handler
server.on("/dataHandler",HTTP_POST,dataHandler);
//start web server
server.begin();
//Just stating things
Serial.println("HTTP server started");
}

<script type='text/javascript' src='jscript.js'></script>

//JavaScript! Contents of 'javascript' is in jscript.h
server.on("/jscript.js", []() {
  server.send(200, "text/javascript", javascript);
});

//POST data handler
server.on("/dataHandler",HTTP_POST,dataHandler);

void dataHandler(){
  String angle = server.arg("plain");
  Serial.print("Received: ");
  Serial.println(angle);
  server.sendHeader("Location","/");
  server.send(303);
  int pos = angle.toInt();
  myservo.write(pos);
  delay(15);
}

String angle = server.arg("plain");

Serial.print("Received: ");
Serial.println(angle);

server.sendHeader("Location","/");
server.send(303);

int pos = angle.toInt();
myservo.write(pos);
delay(15);

The post WiFi Servo Controller using WeMos D1 Mini appeared first on Microcontroller Tutorials.

The service I’m talking about is ThingSpeak by MathWorks. Most engineering students and professors might be familiar with MathWorks which is the same company behind MATLAB. ThingSpeak has already been featured in one of my projects. However, in that project, I used cellular data to connect to the Internet. This tutorial will use the WiFi connection through the ESP8266 NodeMCU.

Video Tutorial

Setting Up a ThingSpeak Account

ThingSpeak requires a MathWorks account for login. So before anything else, go to mathworks.com/mwaccount/register and provide the required information:

Make sure you can access the email you provided as it's required to verify your email:

Open your email and click on the “verify” button. You will then be redirected to this page which asks for additional information:

If you or your university owns a licensed MATLAB software, you can enter the activation key or license number on the form shown:

If you don't have any MATLAB license, just skip this part. I haven't explored the benefits of adding a MATLAB license here but maybe your account gets upgraded.

After this, your MathWorks profile is now ready!

Creating a ThingSpeak Channel

Now that you have a MathWorks account, go to thingspeak.com/login:

Enter your MathWorks email and password to sign in. A pop-up window will appear. Select one of the options; the other field is optional.

You should now be in the "channels" page. ThingSpeak requires you to create a channel with up to 8 fields. Free users are limited to 4 channels and 255 characters per field.

Clicking the "New Channel" button directs you to this page:

Here, I named my channel Soil Moisture, gave a brief description and named 1 field. After creating the channel, you’ll be on a page where you’ll see an empty time plot of your created field.

Updating the field requires simple HTTP GET requests. For free accounts, the field updates every 15 seconds.

Click the API Keys tab:

Here we can see the possible API requests. For example, to update the field SoilMoisture, I copy the URL https://api.thingspeak.com/update?api_key=UTB05H415R3M0SIX&field1=0

The last part of this URL is the updates to the SoilMoisture field. We can test this by copy-pasting the URL above to a browser and just change the last number to any number. Here, I changed the number to 100 and pressed enter:

The time plot on the “private view” tab now updates:

Uploading Sketch to NodeMCU

Now that we know how to send data to ThingSpeak through HTTP GET request, it’s time to create a sketch for the ESP8266 NodeMCU board.

Modify the sketch below at lines 5 & 6 to your own WiFi SSID and password. Also, modify line 9 to your own ThingSpeak API key.

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

const char* ssid     = "your-ssid";
const char* password = "your-password";

const char* host = "api.thingspeak.com";
const char* APIKey = "UTB05H415R3M0SIX";

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

    // We start by connecting to a WiFi network

    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);

    WiFi.begin(ssid, password);

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

    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
}

int value = 0;

void loop()
{
    delay(5000);
    value = analogRead(A0);

    Serial.print("connecting to ");
    Serial.println(host);

    // Use WiFiClient class to create TCP connections
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
        Serial.println("connection failed");
        return;
    }

    // We now create a URI for the request
    String url = "/update";
    url += "?api_key=";
    url += APIKey;
    url += "&field1=";
    url += value;

    Serial.print("Requesting URL: ");
    Serial.println(url);

    // This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Connection: close\r\n\r\n");
    unsigned long timeout = millis();
    while (client.available() == 0) {
        if (millis() - timeout > 5000) {
            Serial.println(">>> Client Timeout !");
            client.stop();
            return;
        }
    }

    // Read all the lines of the reply from server and print them to Serial
    while(client.available()) {
        String line = client.readStringUntil('\r');
        Serial.print(line);
    }

    Serial.println();
    Serial.println("closing connection");
}

This sketch sends reading from the sensor with about 5 seconds interval. The sensor, from the previous tutorial, connects to the A0 pin of the NodeMCU.

The graph on the ThingSpeak private view now updates regularly (see video for output).

For the next part of this tutorial, we will embed the data from ThingSpeak to a website.

The post Send Sensor Data to ThingSpeak via ESP8266 appeared first on Microcontroller Tutorials.

Soil Moisture Sensor

The soil moisture sensor for this project is an inexpensive sensor that reads the resistance of the soil.

Soil moisture is inversely proportional to its resistance, i.e., the higher the water content in the soil, the lower its resistance. The sensor is designed as an electrode whose resistance varies with both the moisture and how deep it is plunged into the soil.

The type of soil and temperature are other factors that determine soil moisture. Thus, reading soil moisture through this sensor might not be enough for more complex applications or scientific researches. However, for our intended purpose -- which is to simply notify the user if the plant needs watering -- this sensor fits the bill.

The sensor comes with a LM393 module that helps give out a digital or an analog signal. If the soil moisture reaches a value (adjustable through the potentiometer on the module), the digital pin (D0) goes high and the D0-LED on the module turns on. On the other hand, the analog pin (A0) gives a voltage proportional to the soil moisture. The higher the soil moisture, the lower this voltage goes.

Sending  Sensor Values through WiFi

For a user to be able to read the soil moisture through WiFi, a microcontroller with wireless network capabilities is required. For this project, I will be using the ESP8266 microcontroller, particularly the NodeMCU V2.0 board.

The soil moisture sensor connects to the NodeMCU like this:

Next, load the sketch below to the NodeMCU. Modify lines 6 and 7 according to your WiFi SSID and password. Make sure your NodeMCU can be programmed with the Arduino IDE.

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

// Replace with your network credentials
const char* ssid = "<Your WiFI SSID>";
const char* password = "<Your WiFI Password>";

ESP8266WebServer server(80);   //instantiate server at port 80 (http port)

String page = "";
double data; 
void setup(void){

  pinMode(A0, INPUT);
  
  delay(1000);
  Serial.begin(115200);
  WiFi.begin(ssid, password); //begin WiFi connection
  Serial.println("");
  
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  server.on("/", [](){
    page = "<h1>Soil Moisture Sensor with ESP8266</h1><h3>Value:</h3> <h4>"+String(data)+"</h4>";
    server.send(200, "text/html", page);
  });
  
  server.begin();
  Serial.println("Web server started!");
}
 
void loop(void){
  data = analogRead(A0);
  delay(1000);
  server.handleClient();
}

Upload the sketch and if successful, open serial monitor (make sure baud rate is set to 115200!). The serial monitor displays the IP address of the NodeMCU.

Using your preferred browser, visit that IP address. The soil moisture value is now on the web page!

The disadvantage of the given sketch is that you need to refresh the page to get updates. You can check out my AJAX tutorial for dynamically changing sensor values on a web page. Also, what does those numbers mean? We'll make our project better in the next part of this tutorial!

The post WiFi Soil Moisture Sensor with Arduino Program appeared first on Microcontroller Tutorials.