SIM800L GSM/GPRS Module

Name: SIM800L GSM/GPRS Module
Brand: ESP32
Price: 6.00 USD
Availability: InStock

View on Amazon

Overview

The SIM800L is a GSM/GPRS communication module that supports voice, SMS, and data transmission. It is ideal for IoT applications requiring wireless connectivity over quad-band GSM networks.

Quick Navigation

📋 Specs 📍 Pinout 🔌 Wiring 🔧 Debug

Code Examples

Arduino

C++ Framework

ESP-IDF

Native Framework

ESPHome

YAML Configuration

PlatformIO

IDE & Toolchain

MicroPython

Python Framework

About SIM800L GSM/GPRS Module

The SIM800L is a quad-band GSM/GPRS module (850/900/1800/1900MHz) designed for SMS, voice, and data communication in IoT and embedded systems.

⚡ Key Features

Quad-Band GSM Connectivity – Works worldwide on 850/900/1800/1900MHz networks.
Compact & Low Power – Ideal for battery-powered IoT applications.
Versatile Communication – Supports SMS, voice calls, and GPRS data transfer.
Internet-Ready – Built-in TCP/IP, HTTP, FTP, and MMS support for online communication.

🔗 Still choosing a SIM module? Check the ESP32 SIM Modules Comparison Table for a detailed breakdown of LTE, 3G, and GPRS options.

Where to Buy

Get Your SIM800L

Starting from

6.00$ per unit

Amazon.com Ships worldwide

View Price

Amazon.de Ships to EU

View Price

AliExpress Best value option

View Price

💡 Prices are subject to change. We earn from qualifying purchases as an Amazon Associate.

Technical Specs

SIM800L Specifications

Complete technical specification details for SIM800L GSM/GPRS Module

📊 Technical Parameters

Frequency Bands Quad-band 850/900/1800/1900MHz

Voltage Range 3.4V to 4.4V

Current Consumption (Sleep Mode) 0.7mA

Dimensions 15.8mm x 17.8mm x 2.4mm

Temperature Range -40°C to +85°C

Protocol Support TCP/IP, HTTP, FTP, MMS

SIM Card Supports 1.8V and 3V SIM cards

Interface UART (AT Command)

Download Full Datasheet

Pin Configuration

SIM800L Pinout

The **SIM800L** is a compact GSM/GPRS module with UART communication:

Visual Pinout Diagram

Pinout Diagram Primary

Total Pins

Pin Types

Power

Communication

Control

Quick Tips

📡

**GSM Bands**: Quad-band 850/900/1800/1900MHz,⚡ **Power**: 3.4V-4.4V (use dedicated power supply!),🔌 **Interface**: UART (typically 9600 or 115200 baud)

⚠️

**Current**: Peak 2A during transmission,📶 **Antenna**: External antenna required on NET pad,💳 **SIM Card**: Nano-SIM or adapter needed

📞

**Features**: Voice calls, SMS, GPRS data,🌐 **Protocols**: TCP/IP, HTTP, FTP, MMS,🎯 **Applications**: IoT, SMS alerts, remote monitoring

Pin Descriptions

Pin Name	Type	Description	Notes
1 VCC	Power	Power input	3.4V to 4.4V (NOT 5V tolerant!)
2 GND	Power	Ground connection
3 TXD	Communication	UART transmit	Sends data from module (connect to ESP32 RX)
4 RXD	Communication	UART receive	Receives commands (connect to ESP32 TX)
5 RST	Control	Reset pin	Active low reset
6 NET	Control	Network status indicator	External antenna connection pad

Connection Guide

Wiring SIM800L to ESP32

To interface the **SIM800L** with an **ESP32** via UART:

Visual Wiring Diagram

Wiring Diagram Recommended

SIM800L GSM/GPRS Module wiring with ESP32

Connections

Connection Status

Required

Optional

Protocol

UART

Pin Connections

SIM800L Pin	ESP32 Pin	Description
1 VCC Required	External 4V	Stable power supply (NOT from ESP32!)
2 GND Required	GND	Ground (shared with ESP32)
3 TXD Required	GPIO16 (RX2)	Module transmit to ESP32 receive
4 RXD Required	GPIO17 (TX2)	Module receive from ESP32 transmit
5 RST Optional	GPIO5	Reset control (optional)
6 NET Required	External Antenna	GSM antenna connection

⚡

**Power Warning**: SIM800L requires 3.4-4.4V with 2A peak current - do NOT power from ESP32!

🔋

**Power Supply**: Use dedicated power supply or LiPo battery (3.7V) with large capacitors (100µF + 1000µF)

📊

**Baud Rate**: Default 9600 or 115200 bps (check module specs)

🔄

**TX/RX**: Connect module TXD to ESP32 RX, module RXD to ESP32 TX

📶

**Antenna**: External GSM antenna is mandatory for reliable operation

💳

**SIM Card**: Insert nano-SIM with PIN disabled

⚠️

**Voltage Drop**: Use thick wires (22AWG) and low-ESR capacitors

🎯

**AT Commands**: Control via AT command set

Help & Support

SIM800L Troubleshooting

Common issues and solutions to help you get your sensor working

Common Issues

Debugging Tips

Additional Resources

Datasheet

Technical specifications and guidelines

Code Examples

SIM800L Programming Examples

Ready-to-use code examples for different platforms and frameworks

#include <Arduino.h>

// Define baud rate for Serial communication
#define SERIAL_BAUD 115200
#define SIM800_BAUD 9600  // SIM800L default baud rate

// Initialize Serial2 (UART2) on ESP32 (RX=16, TX=17)
HardwareSerial serial2(2);

void setup() {
  // Initialize Serial Monitor
  Serial.begin(SERIAL_BAUD);
  delay(1000);  // Small delay to stabilize serial

  // Initialize SIM800L Serial (Serial2)
  serial2.begin(SIM800_BAUD, SERIAL_8N1, 16, 17); // TX=17, RX=16
  delay(1000);

  Serial.println("
SIM800 EVB to ESP32 Serial port 2 test");
  Serial.println("Sending AT commands to check communication...
");

  // Send AT command and check response
  sendATCommand("AT");          // Check if module is responding
  sendATCommand("AT+CGMI");     // Get manufacturer name
  sendATCommand("AT+CGMM");     // Get module model number
  sendATCommand("AT+CGMR");     // Get firmware version
  sendATCommand("AT+CGSN");     // Get serial number
}

void loop() {
  // Read data from SIM800L and print to Serial Monitor
  while (serial2.available() > 0) {
    Serial.write(serial2.read());
  }

  // Read data from Serial Monitor and send to SIM800L
  while (Serial.available() > 0) {
    serial2.write(Serial.read());
  }
}

// Function to send AT command and wait for response
void sendATCommand(const char *command) {
  Serial.print("Sending: ");
  Serial.println(command);
  serial2.println(command);  // Send command to SIM800L
  delay(1000);               // Wait for response

  // Print response from SIM800L
  while (serial2.available()) {
    Serial.write(serial2.read());
  }
  Serial.println("----------------------");
}

This Arduino sketch interfaces with the SIM800L module using the ESP32's hardware serial communication (UART2). The ESP32 has multiple hardware serial ports, and this code uses Serial2 for communication with the SIM800L module. ### **Hardware Serial (UART2)** Unlike SoftwareSerial, which is used on boards like Arduino Uno, ESP32 has dedicated hardware UARTs. This code initializes Serial2 with the correct baud rate and assigns GPIO pins for RX and TX: - serial2.begin(9600, SERIAL_8N1, 16, 17); - Pin 16 (RX) and Pin 17 (TX) are used for UART communication. - The baud rate for SIM800L is set to 9600. ### **Setup Process** 1. Serial.begin(115200); initializes the Serial Monitor for debugging. 2. serial2.begin() initializes communication with SIM800L over hardware serial. 3. The sketch sends a series of AT commands (AT, AT+CGMI, AT+CGMM, AT+CGMR, AT+CGSN) to check the module’s response. ### **Loop Function** - Any data received from the SIM800L module is read and printed to the Serial Monitor. - Any input from the Serial Monitor is forwarded to the SIM800L module. ### **Sending AT Commands** A function sendATCommand() is used to send commands and wait for responses: - It prints the command to the Serial Monitor. - Sends the command to the SIM800L module. - Waits for a response and prints it. This sketch allows real-time communication with the SIM800L module through Serial Monitor, making it useful for debugging and testing AT commands.

#include <stdio.h>
#include <string.h>
#include "driver/uart.h"
#include "freertos/task.h"

#define TX_PIN 17
#define RX_PIN 16
#define UART_PORT UART_NUM_1

void app_main(void) {
    uart_config_t uart_config = {
        .baud_rate = 9600,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
    };

    uart_param_config(UART_PORT, &uart_config);
    uart_set_pin(UART_PORT, TX_PIN, RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    uart_driver_install(UART_PORT, 1024, 0, 0, NULL, 0);

    char *test_cmd = "AT\r\n";
    uart_write_bytes(UART_PORT, test_cmd, strlen(test_cmd));

    while (true) {
        char data[128];
        int len = uart_read_bytes(UART_PORT, data, sizeof(data), 100 / portTICK_PERIOD_MS);
        if (len > 0) {
            data[len] = '\0';
            printf("Response: %s\n", data);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

This ESP-IDF example demonstrates UART communication with the SIM800L module. The UART interface is configured with GPIO17 as TX and GPIO16 as RX. An AT command is sent to test communication, and responses from the module are printed to the console. The module’s replies are read using the uart_read_bytes function in a loop.

uart:
  baud_rate: 9600
  tx_pin: TX
  rx_pin: RX

sim800l:
  on_sms_received:
    - logger.log:
        format: "Received '%s' from %s"
        args: [ 'message.c_str()', 'sender.c_str()' ]

logger:
  baud_rate: 0 # disable uart logger on esp 8266

This ESPHome configuration sets up UART communication with the SIM800L module at a baud rate of 9600. The SIM800L integration allows receiving SMS messages and logging them. The **UART component** is used to communicate with the SIM800L module. The `tx_pin` and `rx_pin` should be set according to the GPIO pins connected to the module, and the baud rate is set to 9600 to match the default communication speed of the SIM800L. The **SIM800L integration** includes an event that triggers whenever an SMS is received. The message content and sender number are logged using the ESPHome logger component. The **logger component** is configured with `baud_rate: 0` to disable UART logging, which is necessary when using ESP8266, as it only has one hardware UART. For more details on integrating SIM800L with ESPHome, refer to the official documentation: 🔗 [ESPHome SIM800L Integration](https://esphome.io/components/sim800l.html)

platformio.ini

[env:sim800l]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

main.cpp

#include <HardwareSerial.h>

HardwareSerial sim800l(1);

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

    sim800l.println("AT"); // Test AT command
    delay(1000);
    while (sim800l.available()) {
        Serial.write(sim800l.read());
    }
}

void loop() {
    sim800l.println("AT+CMGF=1"); // Set SMS to text mode
    delay(1000);
    sim800l.println("AT+CMGS=\"+1234567890\""); // Replace with recipient's number
    delay(1000);
    sim800l.print("Hello from PlatformIO");
    delay(1000);
    sim800l.write(26); // CTRL+Z to send SMS
    delay(5000);
}

This PlatformIO code interfaces with the SIM800L module using HardwareSerial on an ESP32. The AT command is sent to test communication, and SMS functionality is implemented in the loop. GPIO16 (RX) and GPIO17 (TX) are configured as serial pins.

from machine import UART
import time

# Initialize UART
uart = UART(2, baudrate=9600, tx=17, rx=16)

def send_at(command):
    uart.write(command + '\r\n')
    time.sleep(1)
    while uart.any():
        print(uart.read().decode('utf-8'), end='')

# Test communication
send_at('AT')

# Send SMS
send_at('AT+CMGF=1')  # Set SMS to text mode
send_at('AT+CMGS="+1234567890"')  # Replace with recipient's number
uart.write("Hello from MicroPython" + chr(26))

This MicroPython code communicates with the SIM800L module over UART. It defines a function to send AT commands and display the response. The script tests communication with an AT command and sends an SMS by setting the module to SMS text mode, specifying the recipient, and finalizing the message with CTRL+Z (ASCII 26).

Summary

Wrapping Up SIM800L

The ESP32 SIM800L GSM/GPRS Module is a powerful SIM sensor that offers excellent performance and reliability. With support for multiple development platforms including Arduino, ESP-IDF, ESPHome, PlatformIO, and MicroPython, it's a versatile choice for your IoT projects.