Introduction
In this article, I am going to walk you through on how to use Arduino and GSM SIM 900 modem for Sending and Receiving SMS.
Please note, I am using a 2G Modem; which means it works only with 2G compatible SIM card. That being said, it will not work with 3G or 4G LTE SIM cards. If you have questions regarding the SIM card with which I have tested is,T-Mobile Standard Prepaid SIM card.
http://www.codeproject.com/Articles/38705/Send-and-Read-SMS-through-a-GSM-Modem-using-AT-Com
I will be covering the below topics.
Prerequisites
Background
Using Code
Below is the snapshot of the GSM SIM 900 Shield with Arduino Uno
1) Arduino, the most commonly used ones are Arduino Uno.
2) GSM SIM 900 – It’s a cheap and easy to use shield. You can buy one from Ebay. Please note, the GSM Shield for Arduino comes with a 2G, 3G etc. The one which I'm using is a Quad band; which means it only works with 2G compatible GSM Sim cards.
3) SIM 900 Library for Arduino – You can download from http://www.gsmlib.org/download.html.
Download BETA_GSM_GPRS_GPS_IDE100_v307_1.zip or the latest one.
If you are a beginner to Arduino, take a look into the official Arduino website
http://arduino.cc/en/Guide/HomePage
Introduction to AT Commands
http://www.developershome.com/sms/atCommandsIntro.asp
http://www.codeproject.com/Articles/85636/Introduction-to-AT-commands-and-its-uses
SIM900 Documentation
http://www.seeedstudio.com/wiki/GPRS_Shield_V1.0
Simple Arduino Serial Communication basics
http://arduinobasics.blogspot.com/2012/07/arduino-basics-simple-arduino-serial.html
We will be programming the Arduino in a very generic way for receiving the AT Commands, which is being sent by the program running on PC.
You can make use of the below tool, which basically connects the Arduino using Serial communication. Once connected, you should be able to send “AT Commands” and receive the response from Arduino.
Sscom32E Serial tool
http://www.seeedstudio.com/wiki/images/b/b2/Sscom32E.zip
Below is the code snippet that we are making use of for receiving the AT commands and sending back the response through serial communication with the baud rate of 9600.
The below code snippet for Arduino GSM/GPRS Shield Code is being reused from http://www.seeedstudio.com/wiki/GPRS_Shield_V1.0
Here’s what we do.
- The first thing, we should be doing is to include the SoftwareSerial library.
- Let us open the serial port and set the serial baud rate to 9600. We will begin with 9600 bits per second over the serial communication. More information about the same can be found at http://arduino.cc/en/Serial/Begin
- Within the loop method, we have to code to receive the AT commands sent from the application running on our PC. Also we do code for sending the GSM Shield response back to PC. Notice below, when we are sending the response back to PC, we read one character at a time and hold the same in buffer with the size as 64 and then write the same over serial port. Finall we will clearing the buffer and reset the count back to zero.
#include <SoftwareSerial.h>
SoftwareSerial GPRS(7, 8);
unsigned char buffer[64];
int count=0;
void setup()
{
GPRS.begin(9600);
Serial.begin(9600);
}
void loop()
{
if (GPRS.available())
{
while(GPRS.available())
{
buffer[count++]=GPRS.read();
if(count == 64)break;
}
Serial.write(buffer,count);
clearBufferArray();
count = 0;
}
if (Serial.available())
GPRS.write(Serial.read());
}
void clearBufferArray()
{
for (int i=0; i<count;i++)
{ buffer[i]=NULL;}
}
Using the above code in Arduino IDE, let us compile and upload the same to Arduino connected with the GSM Shield, should be all fine for receiving the AT Commands and responding back with the response to from Shield.
Let us make use of “Sscom32E” tool and get our hands wet in using AT commands. First you need to select the appropriate serial com port, leave the default data, stop bit etc. and hit “OpenCom” button so that should open the serial communication with Arduino.
Below is the code snippet, where we are trying to read all SMS by using an AT command, AT+CMGL=”ALL”
Check whether SIM Ready
AT+CPIN?
+CPIN: READY
OK
Get network Info
AT+COPS?
+COPS: 0,0,”T-Mobile”
OK
Voice Call
ATD1224XXX31XX;
Hang Up
ATH
Test Signal Strength
AT+CSQ
+CSQ: 11,0
OK
Read Unread messages
AT+CMGL="REC UNREAD"
Read All messages
AT+CMGL="ALL"
Let us dig into the .NET WinForm application and try to understand how the AT Commands are sent over to Arduino using serial communication.
Below is the code snippet which gets all the “COM” ports and adds them to combo box so that you can select the specific port for communicating with your Arduino.
Note – When you are connecting the Arduino to your PC, you should be able to see the COM port it’s using. That is the port you have to select for sending AT Commands.
string[] ports = SerialPort.GetPortNames();
foreach (string port in ports)
{
this.cboPortName.Items.Add(port);
}
Next we see how to open a serial connection. In the UI, you see a “Connect” button, on click on that triggers the below code. You can see below, we are making use of SMSHelper for open the COM port with the specified COM port name, baud rate, data bits etc.
private void btnOK_Click(object sender, EventArgs e)
{
try
{
this.port = smsHelper.OpenPort(this.cboPortName.Text,
Convert.ToInt32(this.cboBaudRate.Text),
Convert.ToInt32(this.cboDataBits.Text),
Convert.ToInt32(this.txtReadTimeOut.Text),
Convert.ToInt32(this.txtWriteTimeOut.Text));
if (this.port != null)
{
this.gboPortSettings.Enabled = false;
this.statusBar1.Text = "Modem is connected at PORT " + this.cboPortName.Text;
}
else
{
this.statusBar1.Text = "Invalid port settings";
}
}
catch (Exception ex)
{
ErrorLog(ex.Message);
}
}
Now we take a look into in understanding on how to open and close serial com port by using System.IO.Ports. SerialPort class. Below is the code snippet for the same.
We will be creating an instance of SerailPort and set all the required properties like portname, baudrate, data and stop bits etc. Then we open a serial port connection so that we can send AT commands and receive the response. Also notice the DataReceived event is being handled which gets triggered when the Arduino sends data over the specified serial port for communication.
There is one interesting thing that you will see, that is we are creating an instance of AutoResetEvent. It represents a wait handle event. In the below code snippet, on data received event you will see that when we have received some data, we can set the wait handle event signaling the availability of data that can be read.
Coming next, you will see how the AT Commands and the response are read from the designated serial port for communication between Arduino and PC.
public SerialPort OpenPort(string portName, int baudRate,
int dataBits, int readTimeout, int writeTimeout)
{
receiveNow = new AutoResetEvent(false);
SerialPort port = new SerialPort();
try
{
port.PortName = portName;
port.BaudRate = baudRate;
port.DataBits = dataBits;
port.StopBits = StopBits.One;
port.Parity = Parity.None;
port.ReadTimeout = readTimeout;
port.WriteTimeout = writeTimeout;
port.Encoding = Encoding.GetEncoding("iso-8859-1");
port.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
port.Open();
port.DtrEnable = true;
port.RtsEnable = true;
}
catch (Exception ex)
{
throw ex;
}
return port;
}
public void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
try
{
if (e.EventType == SerialData.Chars)
{
receiveNow.Set();
}
}
catch (Exception ex)
{
throw ex;
}
}
public void ClosePort(SerialPort port)
{
try
{
port.Close();
port.DataReceived -= new SerialDataReceivedEventHandler(port_DataReceived);
port = null;
}
catch (Exception ex)
{
throw ex;
}
}
Below is the code snippet for sending the AT Commands over the opened COM port.
We are making a call to “Write” method of SerialPort instance, with the command to be executed. Read the response to make sure the command executed successfully, if not we can throw a generic error message.
public string SendATCommand(SerialPort port,string command,
int responseTimeout, string errorMessage)
{
try
{
port.DiscardOutBuffer();
port.DiscardInBuffer();
receiveNow.Reset();
port.Write(command + "\r");
string input = ReadResponse(port, responseTimeout);
if ((input.Length == 0) || ((!input.EndsWith("\r\n> "))
&& (!input.EndsWith("\r\nOK\r\n"))))
throw new ApplicationException("No success message was received.");
return input;
}
catch (Exception ex)
{
throw ex;
}
}
Below is the code snippet for reading the AT Command response.
We are going to read the serial data by making a call to ReadExisting method of SerialPort instance; which returns a partial response, so we have to loop through and append the data until the serial data that we received contain a substring “OK” or “\r\n>” means we have completely read the AT command response.
public string ReadResponse(SerialPort port, int timeout)
{
string serialPortData = string.Empty;
try
{
do
{
if (receiveNow.WaitOne(timeout, false))
{
string data = port.ReadExisting();
serialPortData += data;
}
else
{
if (serialPortData.Length > 0)
throw new ApplicationException("Response received is incomplete.");
else
throw new ApplicationException("No data received from phone.");
}
}
while (!serialPortData.EndsWith("\r\nOK\r\n") &&
!serialPortData.EndsWith("\r\n> ") && !serialPortData.EndsWith("\r\nERROR\r\n"));
}
catch (Exception ex)
{
throw ex;
}
return serialPortData;
}
Let us dig into in understanding how to trigger an SMS. Below is the snapshot of the application UI looks like.
Here’s the code snippet for sending SMS using AT Command. The syntax for sending SMS message is as follows.
AT+CMGF=1 <ENTER> - Indicates we are interesting in sending text messages. Please note, using this one you cannot send a Unicode message.
AT+CMGS="+1224XXXXXX" <ENTER>
Test message from CodeProject Send and Receive SMS with IOT Device (Arduino and GSM Shield) <CTRL-Z>
Here’s what we do for sending SMS.
- Send an “AT” Command to check whether the phone is connected.
- Send a command with AT+CMGF=1, indicating that we will be sending a text message.
- Send a command with AT+CMGS="+1224XXXXXX" <ENTER>
Now send a command with the text message that you wish to send with a <CTRL-Z> in the end.
public bool SendMessage(SerialPort port, string phoneNo, string message)
{
bool isSend = false;
try
{
string recievedData = SendATCommand(port,"AT", 300, "No phone connected");
string command = "AT+CMGF=1" + char.ConvertFromUtf32(13);
recievedData = SendATCommand(port,command, 300, "Failed to set message format.");
command = "AT+CMGS=\"" + phoneNo + "\"" + char.ConvertFromUtf32(13);
recievedData = SendATCommand(port, command, 300,
"Failed to accept phoneNo");
command = message + char.ConvertFromUtf32(26);
recievedData = SendATCommand(port, command, 3000,
"Failed to send message");
if (recievedData.EndsWith("\r\nOK\r\n"))
isSend = true;
else if (recievedData.Contains("ERROR"))
isSend = false;
return isSend;
}
catch (Exception ex)
{
throw ex;
}
}
Below is the debug code snapshot, where you can see when the message is being sent to trigger an SMS, the GSM Modem replays back with the response. If everything goes well, the message will be sent and you should be able to receive the message within a second.
Now it’s the time to look into how we can read SMS messages from SIM memory.
Let us try to understand the AT commands for reading messages.
1) Read all messages - "AT+CMGL=\"ALL\""
2) Read unread messages - "AT+CMGL=\"REC UNREAD\""
3) Read store sent messages - "AT+CMGL=\"STO SENT\""
4) Read store unsent messages - AT+CMGL=\"STO UNSENT\""
We will be sending the above mentioned AT commands to GSM Modem using serial communication. Once we receive the response, we will be parsing the same and retuning back to the caller.
public ShortMessageCollection ReadSMS(SerialPort port, string atCommand)
{
ShortMessageCollection messages = null;
try
{
#region Execute Command
SendATCommand(port,"AT", 300, "No phone connected");
SendATCommand(port,"AT+CMGF=1", 300, "Failed to set message format.");
string input = SendATCommand(port, atCommand, 5000, "Failed to read the messages.");
#endregion
#region Parse messages
messages = ParseMessages(input);
#endregion
}
catch (Exception ex)
{
throw ex;
}
if (messages != null)
return messages;
else
return null;
}
Below is the code snippet for parsing the SMS messages. The response contains string with CMGL, we will be making use of a Regular expression to match and get the formatted SMS messages.
Notice below, we are building a collection of short SMS messages and returning the same to the caller.
public ShortMessageCollection ParseMessages(string input)
{
ShortMessageCollection messages = new ShortMessageCollection();
try
{
Regex r = new Regex(@"\+CMGL: (\d+),""(.+)"",""(.+)"",(.*),""(.+)""\r\n(.+)\r\n");
Match m = r.Match(input);
while (m.Success)
{
ShortMessage msg = new ShortMessage();
msg.Index = m.Groups[1].Value;
msg.Status = m.Groups[2].Value;
msg.Sender = m.Groups[3].Value;
msg.Alphabet = m.Groups[4].Value;
msg.Sent = m.Groups[5].Value;
msg.Message = m.Groups[6].Value;
messages.Add(msg);
m = m.NextMatch();
}
}
catch (Exception ex)
{
throw ex;
}
return messages;
}
Let us see how we can remove or delete message by index or delete all message (All or Read) ones. Below is the code snippet where you can see how the SMS messages are deleted based on the specified AT command that will be sent over the opened serial com port.
Before we dig into the code for deleting the SMS, let us first understand the AT command usage.
AT+CMGD=<index><CR> - Deletes the message based on the specified index.
Here’s the high level syntax for deleting SMS. More understanding on the same can be found at http://www.developershome.com/sms/cmgdCommand.asp
+CMGD=index[,flag]
In order to delete all SMS, the below mentioned AT command is sent. Where the value “4” is used to simply ignore the index and delete all the SMS from the storage area.
AT+CMGD=1,4
public bool DeleteMessage(SerialPort port, string atCommand)
{
bool isDeleted = false;
try
{
#region Execute Command
string recievedData = SendATCommand(port,"AT", 300, "No phone connected");
recievedData = SendATCommand(port,"AT+CMGF=1", 300, "Failed to set message format.");
String command = atCommand;
recievedData = SendATCommand(port,command, 300, "Failed to delete message");
#endregion
if (recievedData.EndsWith("\r\nOK\r\n"))
{
isDeleted = true;
}
if (recievedData.Contains("ERROR"))
{
isDeleted = false;
}
return isDeleted;
}
catch (Exception ex)
{
throw ex;
}
}
Below is the snapshot of the Delete SMS tab
Points of Interest
When I was researching and working with IOT devices, I realized the SMS integration is something which is required and helpful for almost all applications. There are numerous application that you can think off in using the SMS functionality. Ofcourse, this is not the only solution but it is a cost effective one as you really don't have to worry about third party sevices for sending SMS. There are times when the IOT devices can function based on the received on some specific message, in such scenarios you can definitely make use of these solution.
Reference
Note – The front end, .NET WinForm Application was originally coded by
Syeda Anila Nusrat. This article reuses the most and does some small enhancements and code refactoring.
History
Version 1.0 - Initial publishing on how to send, receive and delete SMS using Arduino and GSM Sheild - 03/15/2015.