ESP32 SIM900 / SIM900A GSM/GPRS Module

Name: SIM900 / SIM900A GSM/GPRS Module
Brand: ESP32
Price: 10.50 USD
Availability: InStock

Specs Pinout Wiring Troubleshooting

SIM UART

SIM900 / SIM900A

Protocol: UART

Overview

The SIM900 is a versatile GSM/GPRS module that provides reliable communication capabilities for various applications. Its compact design and multiple interfaces make it an ideal choice for projects requiring cellular connectivity.

Choose Your Platform

Arduino

C++ Framework

ESP-IDF

Native Framework

ESPHome

YAML Configuration

PlatformIO

IDE & Toolchain

MicroPython

Python Framework

About SIM900 / SIM900A GSM/GPRS Module

The SIM900 is a complete GSM/GPRS module designed for M2M (Machine-to-Machine) communication. It supports voice, SMS, data, and fax over quad-band GSM networks, making it suitable for a wide range of embedded applications.

⚡ Key Features

Quad-Band GSM (850/900/1800/1900MHz) – Ensures global network compatibility.
Versatile Communication – Supports voice calls, SMS, GPRS data, and fax transmission.
Compact & Easy Integration – Standard interface for seamless device integration.
Ideal for IoT & M2M – Used in remote monitoring, security systems, and automation.

🔗 Still choosing a SIM module? Check the ESP32 SIM Modules Comparison Table to compare LTE, 3G, and GPRS options.

Where to Buy

Starting from

10.50$ per unit

Amazon.com Ships worldwide

View Price

Amazon.de Ships to EU

View Price

AliExpress Best value

View Price

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

Technical Specifications

Frequency Bands GSM 850/900/1800/1900 MHz

GPRS Class 10

Operating Voltage 3.2V to 4.8V

Operating Temperature -40°C to +85°C

Dimensions 24mm x 24mm x 3mm

View Full Datasheet

Pinout Configuration

The VCC pin is used to supply power to the sensor, and it typically requires 3.3V or 5V (refer to the datasheet for specific voltage requirements). The GND pin is the ground connection and must be connected to the ground of your ESP32.

The SIM900 pinout includes:

VBAT: Power supply input (3.2V to 4.8V).
GND: Ground connection.
TXD: UART Transmit Data (connects to microcontroller RX).
RXD: UART Receive Data (connects to microcontroller TX).
PWRKEY: Power on/off control (active low).
NETLIGHT: Network status indication.
STATUS: Module operating status indication.
ANT: Antenna connection.
SIM_VDD: SIM card power supply.
SIM_DATA: SIM card data I/O.
SIM_CLK: SIM card clock.
SIM_RST: SIM card reset.

Wiring with ESP32

To interface the SIM900 with a microcontroller, follow these steps:

Connect VBAT to a stable power supply within the range of 3.2V to 4.8V.
Connect GND to the system ground.
Connect TXD to the microcontroller's RX pin.
Connect RXD to the microcontroller's TX pin.
Control the PWRKEY pin to power the module on or off (active low).
Connect the ANT to a suitable GSM antenna for network connectivity.
Connect the SIM card interface pins (SIM_VDD, SIM_DATA, SIM_CLK, SIM_RST) to a SIM card holder as per the hardware design guidelines.

Troubleshooting Guide

Common Issues

🔌 Module Fails to Power On

📶 SIM Card Not Recognized

📡 Poor Network Signal or Connectivity Issues

⌨️ AT Commands Not Responding

🌡️ Module Overheating

Debugging Tips

🔍 Serial Monitor

⚡ Voltage Checks

Additional Resources

Datasheet

Technical specifications and guidelines

Code Examples

⚡

Arduino Example

C++

#include <Arduino.h>

// Define ESP32 hardware serial port for SIM900
#define SIM900_TX 17  // ESP32 TX connected to SIM900 RX
#define SIM900_RX 16  // ESP32 RX connected to SIM900 TX
#define PWRKEY 9      // SIM900 Power Key pin (adjust if needed)

// Initialize hardware serial for SIM900
HardwareSerial sim900(2);

void powerOnSIM900() {
    pinMode(PWRKEY, OUTPUT);
    digitalWrite(PWRKEY, LOW);
    delay(1000);  // Hold PWRKEY low for 1 second
    digitalWrite(PWRKEY, HIGH);
    delay(5000);  // Wait for the module to initialize
}

void setup() {
    Serial.begin(115200);  // Serial Monitor
    sim900.begin(9600, SERIAL_8N1, SIM900_RX, SIM900_TX);  // SIM900 UART
    
    powerOnSIM900();

    Serial.println("Testing AT communication...");
    
    // Test AT command
    sendATCommand("AT");

    // Set SMS text mode
    sendATCommand("AT+CMGF=1");

    // Send SMS
    Serial.println("Sending SMS...");
    sim900.println("AT+CMGS="+1234567890"");  // Replace with recipient's number
    delay(1000);
    sim900.print("Hello from ESP32 and SIM900");
    sim900.write(26); // CTRL+Z to send
    delay(5000);
    printResponse();
}

void loop() {
    // Add code to handle incoming messages or other functionalities
}

// Function to send an AT command and print response
void sendATCommand(const char *command) {
    Serial.print("Sending: ");
    Serial.println(command);
    sim900.println(command);
    delay(1000);
    printResponse();
}

// Function to print response from SIM900
void printResponse() {
    while (sim900.available()) {
        Serial.write(sim900.read());
    }
    Serial.println("----------------------");
}

This Arduino sketch interfaces with the SIM900 GSM module using the ESP32's hardware serial communication (UART2) instead of SoftwareSerial. The SIM900 module is powered on by toggling the PWRKEY pin (GPIO9).

Hardware Serial Communication #

The ESP32 has multiple hardware serial ports, and this code uses Serial2 (UART2) for direct communication with the SIM900 module.

RX (GPIO16) is connected to SIM900 TX.
TX (GPIO17) is connected to SIM900 RX.
The baud rate is set to 9600, which matches the default communication speed of SIM900.

Code Functionality #

Powering on the SIM900 Module
- The powerOnSIM900() function sets PWRKEY to LOW, then HIGH, ensuring proper startup.
- A delay allows the module to initialize.
Testing AT Communication
- The sendATCommand( AT ) function is used to check if the SIM900 module is responsive.
Configuring SMS Mode
- The command AT+CMGF=1 sets the SIM900 module to text mode for SMS messaging.
Sending an SMS
- The AT+CMGS command is used to specify the recipient’s phone number.
- The message ** Hello from ESP32 and SIM900 ** is sent.
- The SMS is finalized by sending CTRL+Z (ASCII 26).
Reading Responses from SIM900
- The printResponse() function captures and prints responses from the SIM900 module to the Serial Monitor.

Additional Features #

The loop() function is currently empty but can be modified to handle incoming messages, monitor network status, or send additional AT commands.

This setup allows stable communication using ESP32’s hardware UART instead of SoftwareSerial, improving reliability and performance.

🔧

ESP-IDF Example

C++

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

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

void init_uart() {
    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);
}

void power_on_sim900() {
    gpio_set_direction(PWRKEY_PIN, GPIO_MODE_OUTPUT);
    gpio_set_level(PWRKEY_PIN, 0);
    vTaskDelay(1000 / portTICK_PERIOD_MS); // Hold PWRKEY low for 1 second
    gpio_set_level(PWRKEY_PIN, 1);
    vTaskDelay(5000 / portTICK_PERIOD_MS); // Wait for the module to initialize
}

void app_main(void) {
    init_uart();
    power_on_sim900();

    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 initializes UART communication with the SIM900 module and powers it on using the PWRKEY pin (GPIO4). 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. This code can be extended to handle SMS, GPRS, or other functionalities provided by the SIM900 module.

🏠

ESPHome Example

YAML

uart:
  tx_pin: GPIO17
  rx_pin: GPIO16
  baud_rate: 9600

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

switch:
  - platform: template
    name: "Send AT Command"
    turn_on_action:
      - uart.write: "AT\r\n"

sensor:
  - platform: custom
    lambda: |-
      return {nullptr};
    sensors:
      - name: "SIM900 Response"

This ESPHome configuration sets up UART communication with the SIM900 using GPIO17 (TX) and GPIO16 (RX) at 9600 baud. A GPIO-based switch is used to control the PWRKEY pin (GPIO4) for powering the module on or off. A template switch allows sending the AT command, and a custom sensor can be implemented to process responses from the module. Additional configurations can be added for SMS or data functionalities.

🛠️

PlatformIO Example

C++

platformio.ini

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

PlatformIO Example Code

#include <HardwareSerial.h>
#include <Arduino.h>

HardwareSerial sim900(1);
#define PWRKEY 4

void power_on_sim900() {
    pinMode(PWRKEY, OUTPUT);
    digitalWrite(PWRKEY, LOW);
    delay(1000); // Hold PWRKEY low for 1 second
    digitalWrite(PWRKEY, HIGH);
    delay(5000); // Wait for initialization
}

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

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

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

void loop() {
    // Handle incoming data or other functionalities
}

This PlatformIO code interfaces with the SIM900 module using HardwareSerial on an ESP32. The power_on_sim900 function toggles the PWRKEY pin (GPIO4) to activate the module. The AT command is sent to test communication, and SMS functionality is implemented in the setup. Additional functionalities like GPRS or data handling can be added in the loop.

🐍

MicroPython Example

Python

from machine import UART, Pin
import time

# Initialize UART
uart = UART(2, baudrate=9600, tx=17, rx=16)
pwrkey = Pin(4, Pin.OUT)

def power_on_sim900():
    pwrkey.value(0)
    time.sleep(1)  # Hold PWRKEY low for 1 second
    pwrkey.value(1)
    time.sleep(5)  # Wait for module to initialize

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

# Power on the module
power_on_sim900()

# 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 SIM900 module over UART. The power_on_sim900 function activates the module using the PWRKEY pin (GPIO4). The send_at function sends AT commands and prints the responses. The script initializes the module, tests communication, and demonstrates how to send an SMS. Additional logic for handling GPRS data or incoming messages can be added.

Conclusion

The ESP32 SIM900 / SIM900A 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.

For optimal performance, ensure proper wiring and follow the recommended configuration for your chosen development platform.

Always verify power supply requirements and pin connections before powering up your project to avoid potential damage.