If you want a live demo of this, please register from the link given below. (Only in Pune)

A GSM/GPRS Module like SIM300 can be used for any embedded application that requires a long range communication, like a robot in Chennai controlled by a person sitting in New Delhi! Or simply a water pump in a rice field turned on in the morning by a farmer sitting in his house few kilometers away! You have few communication options depending on the application, they may be as follows.

  • Simple SMS based communication
    • Turn on/off loads using simple SMS commands, so the controlling device is a standard handset. You can use any mobile phone to control the device.
    • A intruder alarm/fire alarm that informs about the panic situation to the house owner on his/her mobile via SMS.
  • Call based communication
    • A smart intruder alarm/fire alarm that calls the police or fire station and plays a pre recorded audio message to inform about the emergency.
  • Internet Based Communication (GPRS)
    • User can control the end application using any PC/Tablet/Mobile with internet connection. Example: LED Message Displays installed on highways/expressways controlled from a central control room to inform users or traffic conditions ahead.
    • A robot controlled over internet. That means the robot can be accessed from any device having internet any where in the world.
    • A portable device installed on vehicles that connects to internet using the GPRS Module SIM300 and uploads current position(using Global Position System) to a server. The server stores those location in a database with the ID of vehicle. Then a client(using a PC) can connect with the server using World Wide Web to see the route of the vehicle.

Advantage of using SIM300 Module.

The SIM300 KIT is a fully integrated module with SIM card holder, power supply etc. This module can be easily connected with low cost MCUs like AVR/PIC/8051. The basic communication is over asynchronous serial line. This is the most basic type of serial communication that’s why it is very popular and hardware support is available in most MCUs. The data is transmitted bit by bit in a frame consisting a complete byte. Thus at high level it is viewed as a simple text stream. Their are only two streams one is from MCU to SIM300 and other is from SIM300 to MCU. Commands are sent as simple text. Their are several tutorials that describes how to send and receive strings over the serial line.

If you have never heard of serial communication and never did it in practice then it is highly recommend to go and understand clearly using some thing simpler (experiments given in above links).

Communication with SIM300 Module using AVR UART.

The hardware(inside the AVR MCU Chip) that is used to to serial communication is called the UART, we use this UART to communicate with the SIM300 module (the UART can also be used to communicate with other devices like RFID Readers, GPS Modules, Finger Print Scanner etc.). Since UART is such a common method of communication in embedded world that we have made a clean and easy to use library that we use in all our UART based projects.

Since a byte can arrive to MCU any time from the sender (SIM300), suppose if the MCU is busy doing something else, then what happens? To solve this, we have implemented a interrupt based buffering of incoming data. A buffer is maintained in the RAM of MCU to store all incoming character. Their is a function to inquire about the number of bytes waiting in this queue.

Following are the functions in AVR USART library

void USARTInit(uint16_t ubrrvalue)

Initializes the AVR USART Hardware. The parameter ubrrvalue is required to set desired baud rate for communication. By default SIM300 communicates at 9600 bps. For an AVR MCU running at 16MHz the ubrrvalue comes to be 103.

char UReadData()

Reads a single character from the queue. Returns 0 if no data is available in the queue.

void UWriteData(char data)

Writes a single byte of data to the Tx Line, used by UWriteString() function.

uint8_t UDataAvailable()

Tells you the amount of data available in the FIFO queue.

void UWriteString(char *str)

Writes a complete C style null terminated string to the Tx line.

Example #1:

UWriteString("Hello World !");

Example #2:

char name[]="Avinash !";


void UReadBuffer(void *buff,uint16_t len)

Copies the content of the fifo buffer to the memory pointed by buff, the amount of data to be copied is specified by len parameter. If UART incoming fifo buffer have fewer data than required (as per len parameter) then latter areas will contain zeros.


char gsm_buffer[128];

The above example will read 16 bytes of data (if available) from the incoming fifo buffer to the variable gsm_buffer. Please note that we have allocated gsm_buffer as 128 byte array because latter we may need to read more than 16 bytes. So the same buffer can be used latter to read data up to 128 bytes.

The above function is used generally along with UDataAvailable() function.

    	//Do nothing

char gsm_buffer[128];

The above code snippet waits until we have 16 bytes of data available in the buffer, then read all of them.

 void UFlushBuffer()

Removes all waiting data in the fifo buffer. Generally before sending new command to GSM Module we first clear up the data waiting in the fifo.

The above functions are used to send and receive text stream from the GSM Module SIM300.

SIM300 AT Command Set

Now you know the basics of AVR USART library and how to use it to initialize the USART, send and receive character data, its time for us to move ahead and look what commands are available with SIM300 module and how we issue commands and check the response. SIM300 supports several functions like sending text messages, making phone call etc. Each of the tasks is done using a command, and sim300 has several commands known as the command set.

All SIM300 commands are prefixed with AT+ and are terminated by a Carriage Return (or <CR> in short). The ASCII code of CR is 0x0D (decimal 13). Anything you write to SIM300 will be echoed back from sim300′s tx line. That means if you write a command which is 7 bytes long (including the trailing CR) then immediately you will have same 7 bytes in the MCU’s UART incoming buffer. If you don’t get the echo back then it means something is wrong !

So the first function we develop is SIM300Cmd(const char *cmd) which does the following job :-

(NOTE: All sim300 related function implementations are kept in file sim300.c, and prototypes and constants are kept in sim300.h)

  • Writes the command given by parameter cmd.
  • Appends CR after the command.
  • Waits for the echo, if echo arrives before timeout it returns SIM300_OK(constant defined in sim300.h). If we have waited too long and echo didn’t arrive then it returns SIM300_TIMEOUT.

Implementation of SIM300Cmd()

int8_t SIM300Cmd(const char *cmd)
   UWriteString(cmd);   //Send Command
   UWriteData(0x0D); //CR

   uint8_t len=strlen(cmd);

   len++;   //Add 1 for trailing CR added to all commands

   uint16_t i=0;

   //Wait for echo


         //We got an echo
         //Now check it
         UReadBuffer(sim300_buffer,len);  //Read serial Data

         return SIM300_OK;


   return SIM300_TIMEOUT;


Commands are usually followed by a response. The form of the response is like this


LF is Line Feed whose ASCII Code is 0x0A (10 in decimal)

So after sending a command we need to wait for a response, three things can happen while waiting for a response :

  • No response is received after waiting for a long time, reason can be that the SIM300 is not connected properly with the MCU.
  • Response is received but not as expected, reason can be faulty serial line or incorrent baud rate setting or MCU is running at some other frequency than expected.
  • Correct response is received.

For example, command Get Network Registration is executed like this :-

Command String: "AT+CREG?"


<CR><LF>+CREG: <n>,<stat><CR><LF>


So you can see the correct response is 20 bytes. So after sending command "AT+CREG?" we wait until we have received 20 bytes of data or certain amount of time has elapsed. The second condition is implemented to avoid the risk of hanging up if the sim300 module malfunctions. That means we do not keep waiting forever for response we simply throw error if SIM300 is taking too long to respond (this condition is called timeout)

If correct response is received we analyses variable <stat> to get the current network registration.

depending on current network registration status the value of stat can be

  • 0 – not registered, SIM300 is not currently searching a new operator to register to
  • 1 registered, home network
  • 2 not registered, but SIM300 is currently searching a new operator to register to
  • 3 registration denied
  • 4 unknown
  • 5 registered, roaming

Implementation of SIM300GetNetStat() Function

int8_t SIM300GetNetStat()
   //Send Command

   //Now wait for response
   uint16_t i=0;

   //correct response is 20 byte long
   //So wait until we have got 20 bytes
   //in buffer.


         //We got a response that is 20 bytes long
         //Now check it
         UReadBuffer(sim300_buffer,20);   //Read serial Data

            return SIM300_NW_REGISTERED_HOME;
         else if(sim300_buffer[11]=='2')
            return SIM300_NW_SEARCHING;
         else if(sim300_buffer[11]=='5')
            return SIM300_NW_REGISTED_ROAMING;
            return SIM300_NW_ERROR;

   //We waited so long but got no response
   //So tell caller that we timed out

   return SIM300_TIMEOUT;


Similarly we have implemented the following functions :-

  • int8_t SIM300IsSIMInserted()

In another type of response we don’t exactly know the size of response like we knew for the above command. Example is the Get Service Provider Name command where the provider name’s length cannot be known in advance. It can be Airtel or Reliance or TATA Docomo. To handle that situation we make use of the fact that all response are followed by a CR LF pair. So we simple buffer in all characters until we encounter a CR, that indicates end of response.

To simplify handling of such commands we have made a function called SIM300WaitForResponse(uint16_t timeout)

This function waits for a response from SIM300 module (end of response is indicated by a CR), it returns the size if response received, while the actual response is copied to the global variable sim300_buffer[].

If no response is received before timeout it returns 0. Timeout in millisecond can be specified by the parameter timeout. It does not count the trailing LF or the last <CR><LF>OK<CR><LF>, they remain in the UART fifo queue. So before returning we call UFlushBuffer() to remove those from the queue.

Implementation of function SIM300WaitForResponse(uint16_t timeout)

int8_t SIM300WaitForResponse(uint16_t timeout)
   uint8_t i=0;
   uint16_t n=0;

      while (UDataAvailable()==0 && n<timeout){n++; _delay_ms(1);}

         return 0;

         if(sim300_buffer[i]==0x0D && i!=0)
            return i+1;

Implementation of function SIM300GetProviderName(char *name)

The function does the following :-

  1. Flush the USART buffer to get rid of any leftover response from the last command or errors.
  2. It send the command "AT+CSPN?" using SIM300Cmd("AT+CSPN?"); function call.
  3. Then it waits for a response using the function SIM300WaitForResponse()
  4. If we receive a response of non zero length we parse it to extract string describing the service provider name.
  5. If SIM300WaitForResponse() returns zero that means no valid response is received within specified time out period. In this case we also return SIM300_TIMEOUT.

In the same way we have implemented the following functions :-

  • uint8_t SIM300GetProviderName(char *name)
  • int8_t SIM300GetIMEI(char *emei)
  • int8_t SIM300GetManufacturer(char *man_id)
  • int8_t SIM300GetModel(char *model)

uint8_t SIM300GetProviderName(char *name)

   //Send Command

   uint8_t len=SIM300WaitForResponse(1000);

      return SIM300_TIMEOUT;

   char *start,*end;



   return strlen(name);

SIM300 and ATmega32 Hardware Setup

NOTE: To learn AVR Microcontrollers and do hands on experiments at home you can purchase xBoard. It is a low cost development board designed to get started with minimum efforts and to easily perform common tasks. Lots of sample programs helps you easily complete projects. It is a must have tool if you want to do something real and instead of just wasting time just trying to achieve basic things and avoid problems that dont let you move forward to the real task.
Buy xBoard NOW !
Free shipping across India ! Pay Cash on Delivery ! 15 Days Money Back!

To run the basic demo showing communication with SIM300 using AVR ATmega32 we need the following circuit :-

  • ATmega32 Core circuit, including the reset register, ISP header, 16MHz crystal oscillator.
  • Power Supply circuit to supply 5v to the ATmega32 and the LCD Module.
  • A 16×2 Alphanumeric LCD Module to show programs output.
  • SIM300 Module.
atmega32 gsm module connection

Fig. SIM300 and ATmega32 Schematic

We have made the prototype using xBoard development board because it has ATmega32 core circuit, 5v power supply circuit and the LCD module.

avr gsm module interface

Fig. SIM300 and ATmega32 Connection


xboard sim300 connection

Fig. SIM300′s PINs


xboard's usart pins

Fig. xBoard’s USART PINs




avr gsm module program

Fig. GSM Module connected with ATmega32


The board shown below is the new version of SIM300 Modem, it can also be used to make this project. New version is much smaller and low cost.

sim300 module new version

Fig. SIM300 Module New Version


Demo Source Code for AVR and SIM300 Interface

The demo source code is written in C language and compiled using free avr-gcc compiler using the latest Atmel Studio 6 IDE. The project is split into the following modules.

  • LCD Library
  • USART Library
    • Files usart.c,usart.h
    • Job is to control the USART hardware of AVR MCU. Includes functions to initialize the USART, Send/Receive chars, Send/Receive Strings.
  • SIM300 Library
    • Files sim300.c, sim300.h

To build the project you need to be have working knowledge of the Atmel Studio 6 IDE. Please refer to the following tutorial.

Steps to configure the AS6 Project

  • Create a new AS6 Project with name "Sim300Demo".
  • Using solution explorer create a folder named "lib" in current folder.
  • Inside the "lib" folder create the following sub folders "lcd", "usart" and "sim300".
  • copy followings files to the lcd folder (using Windows File Manager) lcd.c, lcd.h, myutils.h, custom_char.h
  • copy followings files to the usart folder (using Windows File Manager) usart.c,usart.h
  • copy followings files to the sim300 folder (using Windows File Manager sim300.c, sim300.h
  • Add the files lcd.c, lcd.h, myutils.h, custom_char.h to the project using solution explorer.
  • Add the filesusart.c,usart.h to the project using solution explorer.
  • Add the files sim300.c, sim300.h to the project using solution explorer.
  • Define a symbol F_CPU=16000000 using AS6′s
  • in the main application file Sim300Demo.c copy paste the following demo program.
  • Build the project to get the executable hex file.
  • Burn this hex file to the xBoard using USB AVR Programmer.
  • If you are using a new ATMega32 MCU from the market set the LOW FUSE as 0xFF and HIGH FUSE are 0xC9.
Setting AVR Fuse Byte

Fig.: Setting the Fuse bytes.

 * Sim300Demo.c
 * Created: 10-07-2012 PM 12:23:08
 *  Author: Avinash

#include <avr/io.h>
#include <util/delay.h>

#include "lib/lcd/lcd.h"
#include "lib/sim300/sim300.h"

void Halt();
int main(void)
   //Initialize LCD Module

   //Intro Message
   LCDWriteString("SIM300 Demo !");
   LCDWriteStringXY(0,1,"By Avinash Gupta");



   //Initialize SIM300 module
   LCDWriteString("Initializing ...");
   int8_t r= SIM300Init();


   //Check the status of initialization
      case SIM300_OK:
         LCDWriteStringXY(0,1,"OK !");
      case SIM300_TIMEOUT:
         LCDWriteStringXY(0,1,"No response");
         LCDWriteStringXY(0,1,"Inv response");
      case SIM300_FAIL:
         LCDWriteStringXY(0,1,"Unknown Error");


   //IMEI No display

   char imei[16];


      LCDWriteString("Comm Error !");

   LCDWriteString("Device IMEI:");


   //Manufacturer ID

   char man_id[48];


      LCDWriteString("Comm Error !");



   //Manufacturer ID

   char model[48];


      LCDWriteString("Comm Error !");



   //Check Sim Card Presence
   LCDWriteString("Checking SIMCard");



   if (r==SIM300_SIM_NOT_PRESENT)
      //Sim card is NOT present
      LCDWriteStringXY(0,1,"No SIM Card !");

   else if(r==SIM300_TIMEOUT)
      //Communication Error
      LCDWriteStringXY(0,1,"Comm Error !");

   else if(r==SIM300_SIM_PRESENT)
      //Sim card present
      LCDWriteStringXY(0,1,"SIM Card Present");


   //Network search

   uint8_t     nw_found=0;
   uint16_t tries=0;
   uint8_t     x=0;




         if(x==16) x=0;





      LCDWriteString("Network Found");
      LCDWriteString("Cant Connt to NW!");



   //Show Provider Name
   char pname[32];

      LCDWriteString("Comm Error !");




void Halt()

What the Demo Program does?

  • Initializes the LCD Module and SIM300 module.
  • Check if the SIM300 module is present on the USART and responding properly.
  • Displays the IMEI No of the SIM300 Module.
  • Displays Manufacturer ID
  • Then checks for the SIM card presence.
  • Searches for a GSM Network and establishes a connection. The sim card need to be valid in order to connect to the GSM network.
  • Shows the Network Provider’s name like Airtel or Vodafone.


  • NO Display on LCD
    • Make sure AVR Studio Project is set up for clock frequency of 16MHz (16000000Hz)
    • Adjust the Contrast Adj Pot.
    • Press reset few times.
    • Power On/Off few times.
    • Connect the LCD only as shown on schematic above.
  • On SIM300 Initialization phase if you get error "No Response"
    • Check Rx,Tx and GND line connection between SIM300 and the xBoard.
    • Make sure crystal frequency is 16MHz only.
    • Fuse bits are set as described above.
  • Compiler Errors
    1. Many people these days has jumped to embedded programming without a solid concept of computer science and programming. They don’t know the basics of compiler and lack experience. To learn basic of compilers and their working PC/MAC/Linux( I mean a desktop or laptop) are great platform. But embedded system is not good for learning about compilers and programming basics. It is for those who already have these skills and just want to apply it.
    2. Make sure all files belonging to the LCD Library are "added" to the "Project".
    3. avr-gcc is installed. (The Windows Binary Distribution is called WinAVR)
    4. The AVR Studio project Type is AVR GCC.
    5. Basics of Installing and using AVR Studio with avr-gcc is described in this tutorial
  • General Tips for newbies

Downloads for GSM Module Demo.

Liked this Article ? Want More ?

Well see this !

Help Us!

We try to publish beginner friendly tutorials for latest subjects in embedded system as fast as we can. If you like these tutorials and they have helped you solve problems, please help us in return. You can donate any amount as you like securely using a Credit or Debit Card or Paypal.

We would be very thankful for your kind help.

Avinash Gupta
Facebook, Follow on Twitter.


Avinash Gupta is solely focused on free and high quality tutorial to make learning embedded system fun !

More Posts - Website

Follow Me:
FacebookLinkedInGoogle Plus