Introduction

Cellular communication is a powerful addition to any IoT project. With a SIM800L GSM module connected to an ESP8266 NodeMCU, you can send and receive SMS messages, monitor devices remotely, or even trigger actions from anywhere with cellular coverage.

Instead of overloading this post with code, we focus here on the concept and physical setup. All source code, including test sketches and main scripts, is available on our GitHub repository.

Concept

The main idea is to use the ESP8266 as the controller and the SIM800L as the GSM interface. The ESP8266 can:

• Send SMS alerts

• Receive SMS commands

• Monitor network status

• Forward commands from other sensors or devices

The SIM800L responds to AT commands sent from the ESP8266. By sending the right commands, the ESP8266 can control the SIM800L to send messages, check signal strength, or attach to the cellular network.

Hardware Setup

Here’s what you need:

• ESP8266 NodeMCU – acts as the main controller

• SIM800L GSM Module – handles cellular communication

• Stable 4V power supply capable of 2A for the SIM800L (3,7 V - 4,5V)

• LM2596 step-down module with display

• GSM antenna

• Connecting wires ( quality threads)

Wiring Overview

⚠️ Important: Never power the SIM800L directly from the ESP8266 3.3V pin. Use a dedicated supply with common ground.

Workflow

1. Power the SIM800L

2. Connect ESP8266 TX/RX to SIM800L RX/TX .

3. Send AT commands from the ESP8266 to test network registration and SIM card status.

4. Send or receive SMS messages using simple command functions from the ESP8266.

5. Integrate additional sensors or triggers in your IoT project to send alerts or data via SMS.

This approach keeps your code modular: you can start with basic network tests and SMS sending, then add more advanced IoT functions as your project grows.

SIM800 Module LED Behavior

The LED on the SIM800 module indicates the module's status and GSM network connection through different types of blinking. Here's a useful summary:

💡 Practical note: Some SIM800 modules have the LED labeled NET instead of PWR, but the blinking logic is the same.

Next Steps

All the working Arduino sketches, including a connection test and main SMS sending code, are available in our GitHub repository:

👉 ESP8266 + SIM800L GitHub Repository

The GitHub contains:

• connection_test – verify SIM800L is responding and attach to the network

• ESP8266_SIM800L – main sketch to send SMS automatically

• Example secrets.h to store your phone number securely

Conclusion

Adding GSM capabilities to ESP8266 projects allows you to create IoT devices that can communicate anywhere. With the SIM800L module and a few connections, you can start sending and receiving SMS in minutes.

For full code and setup instructions, check out the GitHub link above.

From Idea to Plan

The goal was to use a 4–20 mA current probe to measure changes in the water level and convert those readings into the tank’s total volume in liters.

I also wanted the data to be available both locally on a small OLED display and remotely through Home Assistant.

Hardware Choices

After some experimentation I settled on:

• ESP8266 (NodeMCU) – small, Wi-Fi ready, and with a built-in ADC.

• Hydrostatic probe 4–20 mA 1m(measuring), 10m cable – outputs a current proportional to water pressure.

• 10 Ω shunt resistor – to turn that current into a measurable voltage for the ESP.

• 0.96" OLED (SSD1306) – for instant, on-site readings.

• DC-DC LM2596 step-down converter – takes the 24 V supply down to a safe 5 V.

• **POWER SUPPLY 24V ** .

• A sturdy PVC junction box

Wiring It All Up

The probe is powered from the same 24 V line that feeds the whole unit.
Its negative lead passes through the 10 Ω shunt resistor, and the ESP8266 reads the voltage across that resistor.
Ohm’s law (I = V / 10 Ω) gives the probe current, which is proportional to the water level.

A small prototyping PCB holds the ESP8266, the shunt, and one screw-terminal connector so I can attach or remove wires without soldering each time.

Enclosure and Assembly

Inside the PVC box:

• A power jack is glued into the side wall.

• The OLED display is mounted on the front panel of the PVC enclosure, attached using a hot glue gun.

• The prototyping board acts as a custom socket for the ESP. The prototype board connections, the shunt resistor, and the screw terminal connector are soldered with a soldering station..

  

Probe:

• The probe is installed 10 cm above the bottom of the tank.

Firmware Tasks

The ESP8266 handles all the measurements and calculations:

• Sample ADC voltage to determine the probe current.

• Map 4 mA to “empty” and 20 mA to “full” as calibration points. The actual probe measurements range from 3.6 mA to 19.7 mA, which is caused by the quality of the probe.

• Convert the measured current into the water height and total volume in liters, compensating for the tank’s horizontal cylindrical geometry.

• Update the OLED display with live readings of current (mA), height (cm), and volume (L).

• Send measurements over MQTT for Home Assistant integration and provide optional JSON endpoints for other dashboards.

Calibration Notes

During testing I noticed that the probe didn’t output a perfect 4–20 mA range.
To compensate for this, the firmware includes a two-point calibration:

• Empty calibration – sets the actual current reading when the tank is empty.

• Full calibration – sets the current when the tank is completely full.

The web interface provides simple Calibrate Empty and Calibrate Full buttons so I can quickly adjust these values.
This ensures that the displayed water height and calculated volume remain accurate even if the probe drifts or the supply voltage varies.

Home Assistant Integration

To bring all the measurements into my smart-home dashboard,
the ESP8266 publishes sensor data over MQTT.
Home Assistant subscribes to these MQTT topics and displays:

• Current probe reading (mA)

• Calculated water height (cm)

• Total volume (liters)

• Total volume (%)

This way the tank level appears alongside the rest of my home-automation sensors,
and I can create automations—like alerts when the water drops below a threshold—without any extra hardware.

Results

The system has been running reliably, giving real-time volume data.
Now I can glance at the OLED or check Home Assistant on my phone to know exactly how much water is left.

Next Steps

I’m considering:

Mount physical calibration buttons on the PVC enclosure so the tank can be re-calibrated (empty / full) without opening the box or using the web interface.

Build a 3D-printed case and mount a larger display.

This little project turned a need into a dependable, connected tool built from inexpensive parts and a weekend of tinkering.

Source Code

The complete firmware and calibration logic are available on my GitHub repository:

👉 https://github.com/mihailazar87/esp-water-level-measurement

You’ll find the Arduino source code, configuration files and instructions for flashing the ESP8266.