SIM900 / SIM900A GSM/GPRS Module

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

View on Amazon

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.

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 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

Get Your SIM900 / SIM900A

Starting from

10.50$ 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

SIM900 / SIM900A Specifications

Complete technical specification details for SIM900 / SIM900A GSM/GPRS Module

📊 Technical Parameters

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

Download Full Datasheet

Pin Configuration

SIM900 / SIM900A Pinout

The SIM900 pinout includes power, UART communication, control, status indication, antenna connection, and SIM card interface pins for quad-band GSM/GPRS connectivity. This is the original and widely-used GSM/GPRS module.

Visual Pinout Diagram

Pinout Diagram Primary

Total Pins

Pin Types

Power

Control

Quick Tips

Original

and widely-used quad-band GSM/GPRS module (850/900/1800/1900MHz),Supports voice calls, SMS, GPRS data transfer, and fax transmission,GPRS multi-slot class 10

GPRS

mobile station class B,Wider voltage range: 3.2V to 4.8V,Requires SIM card for cellular connectivity

Power

consumption: 2A peak during transmission,Default baud rate: 9600 bps (configurable via AT commands)

Pin Descriptions

Pin Name	Type	Description	Notes
1 VBAT	Power	Power supply input (3.2V to 4.8V)	Requires stable power supply with peak current up to 2A
2 GND	Ground	Ground connection	Connect to common ground
3 TXD	UART TX	UART Transmit Data (connects to microcontroller RX)	Default baud rate: 9600 bps
4 RXD	UART RX	UART Receive Data (connects to microcontroller TX)	Default baud rate: 9600 bps
5 PWRKEY	Control	Power on/off control (active low)	Pull low for at least 1 second to power on
6 NETLIGHT	Status	Network status indication	LED indicator for network registration status
7 STATUS	Status	Module operating status indication	Shows module power state
8 ANT	Antenna	Antenna connection	Requires external GSM antenna

Connection Guide

Wiring SIM900 / SIM900A to ESP32

Connect the SIM900 to your ESP32 via UART for AT command communication. The module requires a stable 3.2V-4.8V power supply with sufficient current capacity (peak 2A). An external GSM antenna is required for network connectivity.

Visual Wiring Diagram

Wiring Diagram Recommended

SIM900 / SIM900A GSM/GPRS Module wiring with ESP32

Connections

Connection Status

Required

Optional

Protocol

UART

Pin Connections

SIM900 / SIM900A Pin	ESP32 Pin	Description
1 VBAT Required	3.7V-4.8V Power Supply	Provide stable power (NOT from ESP32 pin)
2 GND Required	GND	Common ground connection
3 TXD Required	GPIO16 (RX2)	SIM900 TX to ESP32 RX
4 RXD Required	GPIO17 (TX2)	SIM900 RX to ESP32 TX
5 PWRKEY Optional	GPIO4	Power control (pull low to power on)
6 ANT Required	External GSM Antenna	Connect GSM antenna

⚠️

CRITICAL: Use a dedicated power supply (3.2V-4.8V, 2A peak) - DO NOT power from ESP32 pin!

Original

GSM/GPRS module with proven reliability

Wider

voltage range (3.2V-4.8V) compared to newer SIM800 series

Default

UART baud rate is 9600 bps

External

GSM antenna is mandatory for network connectivity

Pull

PWRKEY low for at least 1 second to power on the module

Monitor

NETLIGHT pin for network registration status

Insert

active SIM card before powering on

Ensure

good antenna placement for optimal signal reception

Supports

fax transmission in addition to voice and data

Help & Support

SIM900 / SIM900A 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

SIM900 / SIM900A Programming Examples

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

#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** 1. **Powering on the SIM900 Module** - The `powerOnSIM900()` function sets **PWRKEY** to LOW, then HIGH, ensuring proper startup. - A delay allows the module to initialize. 2. **Testing AT Communication** - The `sendATCommand( AT )` function is used to check if the SIM900 module is responsive. 3. **Configuring SMS Mode** - The command `AT+CMGF=1` sets the SIM900 module to **text mode** for SMS messaging. 4. **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)**. 5. **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.

#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.

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.ini

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

main.cpp

#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.

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.

Summary

Wrapping Up SIM900 / SIM900A

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.