GSM GPS shield for Arduino

By Boris Landoni on September 3, 2012

Shield for Arduino designed and based on the module GSM/GPRS SIM900 or the GSM/G
PRS & GPS module SIM908, to make calls, voice and data connections via GPRS.

HARDWARE INNOVATIONS

This new version (old Arduino GSM shield) has several new hardware features, tha
t allow maximum customization and provide many configurations.
We begin with the supply circuit a simple LM7805. To work, it is necessary to pr
ovide an input voltage between 7.5V and 12V. As shown in the circuit diagram, th
e input voltage, after being stabilized at 5 V, is reduced to 4.3 V by using a d
iode and provide power to modules that need a voltage between the 3.2 and 4.8 V.
During the operations such as the use of GPRS, the module absorbs a current of
about 1 A, therefore it is necessary that the power source is able to provide th
is current intensity.
An important technical feature is the serial adapter for the communication betwe
en the GSM module and Arduino. To reduce the tension has been used a simple volt
age divider, while for raising the voltage from the GSM module to Arduino we cho
se a MOSFET BS170.

The news that is immediately evident is the presence of two jacks for audio. Wit
h a microphone and a headset with a 3.5 mm jack (just the standard headphones fo
r computers), you can make a voice call !!

To preserve compatibility with the Arduino Mega, we changed the selection method
for the serial communication. The two different serial communication modes (har
dware or software) are selectable by jumper, leaving the user the choice between
the two configurations ( for serial software in this new version we adopted pin
s 2 and 3) or possibly use the pin to your choice with a simple wire connection.
With this solution you can use the Arduino Mega using two of the four serial th
at it has, or possibly carry out the communication through a serial software via
two pins of your choice.

Always to preserve maximum flexibility and customization, there are some pins on
the back of PCB, which allow to make the connections from the Arduino digital p
orts and the control signals data flow (CTS, RTS) or alerts for incoming calls o
r unread SMS (RI). In this new version, you can then disable these connections t
o save inputs or outputs pins.

Comparing the new card with the previous one, you can see the presence of two co
nnectors on the top.These additional connections allow the use of the shield als
o with the new small breakout for SIM900 and SIM908. The new module Simcom SIM90
8, is characterized by the presence of a GPS with 42 channels.
The scenery offered by this new module SIMCOM, in addition to GSM GPRS shield, i
t is quite remarkable: the creation of a GPS tracking device that can communicat
e the location via the Internet (or SMS) is now available to everyone, avoiding
all the problems due to assembly and low-level programming.

A further feature of this new version, concerns the presence of a supercap for c
ircuit dedicated to the RTC (Real Time Clock). Inside the SIM900, as well as the
SIM908, there is a circuit that is responsible for updating the clock even with
out power.

GSM GPS SHIELD SCHEMATICS

[CODE]
R1: 10
R2: 10
R3: 10
R4: 10

kohm
kohm
kohm
kohm

C1: 100 nF
C2: 470 F 25 VL
C3: 100 nF
C4: 220 F 16 VL

C5: 47 pF
C6: 47 pF
C7: 47 pF
C8: 47 pF
C9: 47 pF
C10: 47 pF
C11: 220 F 16 VL
C12: 100 nF
CRCT: 0,1F
U1: 7805
T1: BS170
D1: 1N4007
P1: Microswitch
MIC: jack 3,5 mm
SPK: jack 3,5 mm
[/CODE]

SOFTWARE INNOVATIONS
The software library related to the GSM GPRS shield has been updated. The libra
ry is open-source and uses the hosting service Google Project, located at http:/
/code.google.com/p/gsm-shield-arduino/ . The library is constantly updated and i
mproved with the addition of new features, so please check that you always have
the latest release.
The main enhancement is the TPC/IP communication support through GPRS.
With a simple function, you can connect Arduino to internet using the APN (Acces
s Point Name) you choose. After that we will automatically get an IP address by
the provider.
To establish communication you must define which device performs the function of
the server (still waiting for some connection), such as that client (requires a
connection to the server according to the information you want to achieve) and
that leads to exchange data .
In the library there are two functions that allow us to set the device to listen
on a particular port for connections (server), or to establish a connection bas
ed on the server address and port chosen (client) .
Once connected, you can send the data, which can be command strings or just the
data you want to monitor, for this action there is a high-level function, which
simplifies the management.

LIBRARY FUNCTIONS GSM GPRS

First, you must have the folder libraries, in the root directory of the Arduino,
the folder GSM_GPRS containing all the functions you can use.

Now if you want to change the serial port, through the jumper, you have to modif
y the file GSM.cpp.
To save memory, we decided to divide the functions into different classes contai
ned in different files, to allow you to include or not the code parts needed, th
us going to save memory RAM, leaving it free for the rest of the program. For th
e basic operation is always necessary to include files SIM900.h and SoftwareSeri
al.h, while depending on the needs you may include call.h (for call handling), s
ms.h (for sending, receiving and saving SMS) and inetGSM.h (containing functions
related to HTTP, and GPRS).
SIM900.h
You should always include this file. It contains the basic functions for startin
g and configuring the GSM module. Simply call the functions using GSM. As a prefi
x.

int gsm.begin(int baudrate)

Turn the power on and sets the baud rate for communication.
gsm.TurnOn(9600);

void SimpleRead()
Reads a byte from the serial buffer.
gsm.SimpleRead();

void SimpleWrite(char* cmd)

Writes the string (or an integer) on the serial port.
gsm.SimpleRead( AT+CSQ );

char SendATCmdWaitResp (char const* AT_cmd_string, uint16_t start_comm_tmout, ui

nt16_t max_interchar_tmout, char const* response_string,byte no_of_attempts)
Sends an AT command passed as a parameter, controlling the time of timeout for t
he receipt of a response and between one character and another. After receiving
the response, compares it with that expected, if different resends the command f
or the set number of times.The possible outputs are shown below, with the relati
ve enumeration. AT_RESP_ERR_NO_RESP or -1: No response received.AT_RESP_ERR_DIF_
RESP or 0: Response different from that expected.AT_RESP_OK or 1: The response c
ontains the expected string.
If (gsm.SendATCmdWaitResp ( AT ,500,50, OK ,3)== AT_RESP_OK)
Serial.println( OK );

call.h
In case you want to make a call, or simply refuse to answer an incoming call, yo
u must use this class. To use these functions simply instantiate the object in t
he sketch. The functions listed in the table below refers to an object created w
ith the following command at the beginning of the sketch: CallGSM call;

void Call(char* number_string)

Makes a call to the number contained in the string
call.Call( +393471234567 )

void PickUp(void)
During an incoming call, it responds and activates the audio communication.
call.PickUp();

void HangUp(void)
During an active call, hang up and disables audio communication.
call.HangUp();

byte CallStatus(void);
Returns the state about the phone calls.The possible output byte are listed unde
r the following names:CALL_NONE or 0: No call.CALL_INCOM_VOICE or 1: An incoming
call.CALL_ACTIVE_VOICE or 2: Active Call.
If (call.CallStatus()== CALL_ACTIVE_VOICE)
Serial.println( CALL ACTIVE );

byte CallStatusWithAuth (char* phone_number,

rst_authorized_pos, byte last_authorized_pos);

byte fi

Unlike the previous distinguish if the active call, or incoming belongs to a num
ber stored on the SIM in a position between the start and end, passed as paramet
ers. The possible output byte are listed under the following names:CALL_NONE or
0: No call.CALL_INCOM_VOICE_AUTH or 3: Incoming call from a number authenticate
d. CALL_INCOM_VOICE_NOT_AUTH or 4: Incoming call from a number not authenticated
.
If (call.CallStatusWithAuth() == CALL_INCOM_VOICE_AUTH)
Serial.println ( INCOMING CALL FROM A AUTH NUMBER );

SMS.h
For managing text messages must use this special class. As before, it is necessa
ry to recall it within the sketch and then instantiate an object. For example, i
n the following functions refers to an object created at the beginning of the sk
etch, with the command SMSGSM sms;

char SendSMS(char *number_str, char *message_str)

Using the following command is sent an SMS to the number contained in the first
string passed as a parameter with the text in the second.
sms.SendSMS ( +393471234567

Hello Arduino );

char SendSMS(byte sim_phonebook_position, char *message_str)

Send an SMS as before, where instead of the string is passed to the recipient s co
ntact position stored on the SIM.
sms.SendSMS(1, Hello Arduino );

char GetSMS(byte position, char *phone_number, char *SMS_text, byte max_SMS_len)

Reads the SMS stored on the SIM in the position passed as a parameter, saving th
e sender s number in the first string passed in the second and the content of spec
ified length.
char number[13];
char text[200];
sms.GetSMS(1,number,text,200);

inetGSM.h
In this class are included functions to connect and manage communications via HT
TP protocol. In the following examples was an object created with the command In
etGSM inet;

int httpGET(const char* server, int port, const char* path, char* result, int re
sultlength)
Send a GET request to the specified server on the specified port, requiring a ce
rtain path and saving the response to a string of the specified length. Returns
the number of bytes read.
char text[200];
inet.httpGET ( www.open-electronics.org , 80, / ,text,200);

int httpPOST(const char* server, int port, const char* path, const char* paramet
ers, char* result, int resultlength)
Send a POST request to the specified server on the specified port, requiring a c
ertain path, passing the parameters set and saving the response string of the sp
ecified length. Returns the number of bytes read.
char text[200];
inet.httpGET ( www.open-electronics.org , 80, / ,text,200);

int attachGPRS(char* domain, char* dom1, char* dom2)

Initiates the connection using the GPRS APN passed as the first parameter. The
second and third arguments are two strings that contain the username and passwor
d. If no authentication is required, just pass the last two strings empty.
inet.attachGPRS ( internet.wind ,

, );

int deattachGPRS(void)
Disconnects the module from the GPRS network.
inet.deattachGPRS();

int connectTCP(const char* server, int port)

Establishes a connection as a client to the server passed as a parameter on the
port defined by the second parameter.
inet.connectTCP ( www.open-electronics.org , 80);

int disconnectTCP(void)
Closes the communication with the server.
inet.disconnectTCP();

int connectTCPServer(int port)

Puts the module listens on the specified port waiting for a connection from a cl
ient.
inet.connectTCPServer(80);

boolean connectedClient(void)
Returns true if a client is connected to the module, otherwise false.

inet.connectedClient();

EXAMPLE FOR CALLS AND SMS WITH THE GSM GPRS SHIELD
Let us now, step by step, our first sketch to use the shield using the Arduino I
DE version 1.00. We will write a program that when it receives a call from a pre
set number (stored in a specific location on the SIM), rejects the call and send
s an SMS in response to the caller with the value read from an input.
First you have to extract the files from the compressed folder within the Librar
y folder libraries contained within the installation folder of Arduino.
To first load the libraries using the following commands
#include

SIM900.h

#include <SoftwareSerial.h>
Then load, uncomment properly, the files related to classes containing functions
that we want to use for the management of phone calls and SMS.
#include

sms.h

#include

call.h

We will perform the initialization procedure in the

he value which will then be sent via SMS, configure
initialize the module with the function gsm.begin,
ly for proper communication of data through GPRS is
0 baud).

setup. Set the pin to read t

the serial communication and
and set the baud rate (usual
advisable not rise above 480

At this point we enter the heart of the program, which will periodically check t
he status of incoming calls. To do this within the cycle loop will use the funct
ion call.CallStatusWithAuth saving the byte returned. In the case of incoming or
in progress call, the sender (or recipient) number is stored in the string numb
er.
Compared with the value stored CALL_INCOM_VOICE_AUTH, which describes an incomin
g call by a number in that set, we reject the call using the GSM.Hangup and afte
r waiting 2 seconds, read the input value and send the message.The value read is
an integer and must be first converted into a string using the function itoa.
Let us remember to insert a delay, inside the loop function, to ensure that the
module is interrogated at intervals of not less than a second. Commands sent in
rapid sequence could corrupt the stability of the module.
If we do not receive the result of proper initialization, you will need to check
the power supply. Remember that it is recommended to use an external power sour
ce because the only power supplied by the USB port is not enought.
If the power is found to be correct, you should check that the file GSM.cpp, in
the library are declared properly pin for the serial. Basically the new version
uses pins 2 and 3, while the old version used pins 4 and 5.
#define _GSM_TXPIN_ 2
#define _GSM_RXPIN_ 3

The full program is as follows:

1234567891011121314151617181920212223242526272829303132333435363738
#include "SIM900.h"#include <SoftwareSerial.h>//carichiamo i file necessari allo
sketch#include "sms.h"#include "call.h" CallGSM call;
SMSGSM sms;
char number[20];byte stat=0;int value=0;int pin=1;char value_str[5];
void setup(){ pinMode(pin,INPUT); Serial.begin(9600); Serial.println("GSM GP
RS Shield"); //init the module if (gsm.begin(2400))
Serial.println("\nstatu
s=READY"); else Serial.println("\nstatus=IDLE");}; void loop(){ stat=call.Call
StatusWithAuth(number,1,3); if(stat==CALL_INCOM_VOICE_AUTH){
call.HangUp();
delay(2000);
value=digitalRead(1);
itoa(value,value_str,10);
sms.Sen
dSMS(number,value_str); } delay(1000);};

EXAMPLE FOR INTERNET

We analyze one of the examples contained within the library to connect Arduino t
o the internet with GPRS connection.
We will make a program capable of receiving HTML content from a web page and sav
e the first 50 characters.
Because we use only the functions relating to the Internet and HTTP, we load in
addition to the standard library file, the file inetGSM.h
Instantiate an object management functions
InetGSM inet;
and as before we execute the initialization routine. Then we establish a GPRS co
nnection. In this step you need to run the command AT+CIFSR that requires the prov
ider the IP address assigned to the GSM module. This step is important. Some pro
viders garantee the connection only if previously it s made this request. Through
the function gsm.WhileSimpleRead contained in the GSM class, we read the entire
contents of the buffer. Once emptied the buffer, the sketch will go to the follo
wing functions.
At this point we are connected, we have to establish a TCP connection with the s
erver, send a GET request to a web page and store the contents of the response i
n a previously declared array. All this is done by the function HttpGet in class
inetGSM. In addition to the server and port (80 in the case of HTTP protocol),
we have to indicate the path which contains the requested page.For example if yo
u want to download the Wikipedia page on the Arduino to be reached at the follow
ing address it.wikipedia.org/wiki/Arduino_(hardware), the path will be /wiki/Ard
uino_ (hardware) while the server is it.wikipedia.org.
numdata=inet.httpGET( it.wikipedia.org

, 80,

/wiki/Arduino_(hardware)

, msg, 50);

Obviously if we wish to save a greater number of characters of the answer, it is

sufficient to initialize a string of larger dimensions, taking care not to satu
rate the RAM is made available by Arduino, otherwise we risk getting abnormal be

havior, such as stalls or restarts.

1234567891011121314151617181920212223242526272829303132333435363738394041
#include "SIM900.h"#include <SoftwareSerial.h>#include "inetGSM.h" InetGSM inet;
char msg[50];int numdata;char inSerial[50];int i=0;boolean starte
d=false; void setup(){ Serial.begin(9600); Serial.println("GSM Shield testing.
"); if (gsm.begin(2400)){
Serial.println("\nstatus=READY");
started=true;
} else Serial.println("\nstatus=IDLE"); if(started){
if (inet.attachGPR
S("internet.wind","", ""))
Serial.println("status=ATTACHED");
else Seria
l.println("status=ERROR");
delay(1000);
gsm.SimpleWriteln("AT+CIFSR");
delay(5000);
gsm.WhileSimpleRead();
numdata=inet.httpGET("www.google.com"
, 80, "/", msg, 50);
Serial.println("\nNumero di byte ricevuti:");
Serial.
println(numdata);
Serial.println("\nData recived:");
Serial.println(msg);
}};void loop(){};

The shield has various connectors to accept more GSM/GPRS modules manufactured b
y SIMCOM and mounted on breakout board. In addition to the popular SIM900, our n
ew shield for Arduino supports the recent SIM908, which is an evolution and aims
to capture the market of GSM/GPRS quad-band providing a variety of additional f
eatures that make it unique, especially in the field of low-cost products. The S
IM908 implements a GPS with 42 channels, characterized by an excellent accuracy
and by a very reduced time required to perform the first fix (1 second in mode ho
t start and 30 seconds with the mode cold start ).
This module can be used powered by a lithium battery, and can charge it, greatl
y simplifying this process that would require dedicated hardware.
The SIM908 has two serial, used one for the GSM and the other for the GPS. More
exactly, the first serial interface is provided with a UART which belongs to the
lines TXD, RXD, DTR, which go outside through the contacts, respectively, 12, 1
4, 10 of connector; for the GPS, instead, the serial is GPSTXD (contact 4) and G
PSRXD (pin 5). The first serial port is actually intended for total control of S
IM908, then it can also configure the GPS receiver and ask him to provide data o
n the location, the number of satellites hooked, etc. From the second serial por
t (GPSTXD / GPSRXD) instead, go out continuously strings in standard NMEA GPS sy
stem.

THE GSM SHIELD LIBRARY

Providing also use the SIM908, the library for the management of this module has
been modified to provide a quick access to all the new features made available,
the new library is derived from that used for the SIM900 module, and is availab
le on the Internet at http://code.google.com/p/gsm-shield-arduino/ .
Note that you can use the new library for managing mobile SIM900, provided you d
o not call functions dedicated to SIM908. While it is completely compatible usin

g the sketch for the version without GPS with this new one.
Let s consider some new features introduced: first of all has been added the funct
ion ForceON(); used to check the status of the module and to force the power on.
The SIM908 supports the charge of lithium batteries, the module can be started
to perform the charger without the management of the GSM network. If we want to
avoid this mode and make sure it s really turned on then you need to call the func
tion mentioned above.
gsm.forceON();
Intended for the use of GPS (and battery), we made a class which you can instant
iate an object with GPSGSM gps, after including its # include files gps.h , in orde
r to invoke their functions by prefixing GSM. to the desired function.
This subdivision into different files
, for example, all the variables used
ted in memory will not be included if
allows you to choose which variables

is designed to minimize RAM usage: in fact

by the class on the GPS will not be alloca
the relevant files using #include gps.h .This
to use.

As already mentioned, also for the management of the battery there ara functions
which enable the measurement of the voltage and battery temperature; for practi
cal reasons, occupying little memory, these have been included in the class of G
PS. For use them, after including the file #include gps.h you must instantiate the
object related with GPSGSM gps. In the next sections will show the control func
tions of the GPS and battery.

HOW TO USE THE SIM908 GPS

Before using GPS, you need to make a small set-up: first let s make a bridge on ju
mper J1 on the SIM908 Breakout (cod. FT971).
The bridge on J1 enables power to the GPS antenna.
This serves to bring power to the active GPS antenna. Next, load the sketch exam
ple (in the examples directory) called GSM_GPRS_GPS_Library_AT (or even GSM_GPRS
Library_AT) and once launched and completed initialization send the following co
mmands:

AT
AT+CGPSPWR=1
AT+CGSPRST=0

We wait a minute, at which point the GPS should be working, to verify

continue sending the command:

AT+CGPSINF=0

If you can see the coordinates, it means that everything is working and we can p
roceed with the standard use by the implemented functions.

char attachGPS()
Follow the steps to activate the GPS: turn on the power and set the mode to
tart .

hot s

gps.attachGPS()

char deattachGPS()
power off, disabling the power supply to save energy.
gps.deattachGPS()

char getStat()
Check the GPS status, the possible outputs are:0: GPS not started.1: Fix not per
formed (can be caused by a signal of poor quality).2: Fix 2D run.3: Fix 3D execu
ted.
char stat;
stat=gps.getStat();
if(stat==3)
Serial.println( FIXED );

char getPar(char* str_long, char* str_lat, char* str_alt, char* str_time, char*
speed);
Save in variables, respectively, longitude, latitude, altitude, time and speed.
char lon[10];
char lat[10];
char alt[10];
char time[15];
char vel[10];
gps.getPar(lon,lat,alt,time,vel);

Now we proceed with a simple example that allows us to understand how to get the
coordinates from the GPS module SIM908 mounted on the shield, the firmware is d
escribed here:

12345678910111213141516171819202122232425262728293031323334353637383940414243444
546474849505152535455565758596061626364
#include "SIM900.h" #include <SoftwareSerial.h> #include "gps.h"
G
PSGSM gps;
char lon[10]; char lat[10]; char alt[10]; ch
ar time[15]; char vel[10]; char stat;
boolean started=false; void setup(
){ //Serial connection. Serial.begin(9600); Serial.println("GSM GPRS GPS Shie
ld"); if (gsm.begin(2400)){
Serial.println("\nstatus=READY");
gsm.force
ON();
started=true; } else Serial.println("\nstatus=IDLE");
if(started){
if (gps.attachGPS())
Serial.println("status=GPSON");
e
lse Serial.println("status=ERROR");
delay(20000);
stat=gps
.getStat();
if(stat==1)
Serial.
println("NOT FIXED");
else if(stat==0)
S
erial.println("GPS OFF");
else if(stat==2)
Serial.println("2D FIXED");
else if(stat==3)
Serial.println("3D FIXED");
delay(5000);
gps.
getPar(lon,lat,alt,time,vel);
Serial.println(lon);
Ser
ial.println(lat);
Serial.println(alt);
Serial.println(
time);
Serial.println(vel); }}; void loop() { };

THE BATTERY

In order to use the lithium battery as the power source for our FT971 module tha
t houses the SIM908 (note: the SIM900 is not able to manage the barrery charge)
is sufficient to close the bridge on this shield called with CHRG and set on VEX
T the second bridge near the battery connector.
Through the two library functions is possible to obtain the percentage of remain
ing charge, the battery voltage and the voltage read by the temperature sensor.
In the case of applications poorly ventilated, with prolonged periods of work an
d in climatic conditions not exactly optimal, it is advisable to monitor this va
lue to make sure that the battery works within the limits for a correct operatio
n. The temperature can be calculated according to the relationship voltage/tempe
rature sensor.
It is also possible to set the module so that automatically determine if the bat
tery is working outside the permissible range, with consequent shutdown of the s
ame.
To activate this mode, you need to send the command:

AT+CMTE=1

To disable it you have to send the command:

AT+CMTE=0

While to know which mode is configured must issue the command:

AT+CMTE?

To know the exact syntax of the functions and their return refer to Table:

char getBattInf(char* str_perc, char* str_vol);

Save the remaining battery in percentage terms, and battery voltage.
char str_perc[5];
char str_vol[6];
gps.getBattInf(str_perc,str_vol);
Serial.print( BATTERY: );
Serial.print(str_perc);
Serial.println( % );

char getBattTVol(char* str_vol);

Saves the voltage value of the temperature sensor.
char str_Tvol[6];
gps.getBattTVol(str_Tvol);
Serial.println(str_Tvol);
Also in this case we see how to implement these functions in a sketch, referring
to this sketch, which contains the corresponding code.

12345678910111213141516171819202122232425262728293031323334353637383940414243444
54647484950515253545556
#include "SIM900.h" #include <SoftwareSerial.h> #include "inetGSM.h" #include "g
ps.h"
GPSGSM gps;
char perc[5];
char vol

t[6];

char tvolt[6];
long prevmillis=millis();
int interval=10000;
void setup(){ Serial.begin(9600); Se
rial.println("GSM GPRS GPS Shield."); if (gsm.begin(4800)){
Serial.println("
\nstatus=READY");
gsm.forceON(); } else Serial.println("\nstatus=IDLE"); }
; void loop() { if(millis()-prevmillis>interval){
gps.getBattInf(perc
,volt);
gps.getBattTVol(tvolt);
Serial.print("Batt
ery charge: ");
Serial.print(perc);
Serial.println("%");
Serial.print(
"Battery voltage: ");
Serial.print(volt);
Serial.println(" mV");
Seria
l.print("Temperature sensor voltage: ");
Serial.print(tvolt);
Serial.print
ln(" mV");
Serial.println("");
prevmillis=millis(); }}

DEBUG MODE GSM & GPS SHIELD

During the use of the shield, sometimes you fail to get the desired results with
out understanding why, for help, libraries can be configured to provide output s
ome debug messages during the execution of functions called. Inside the file GSM
.h there is the following line:

//#define DEBUG_ON

Uncomment it, you are going to enable this mode, commenting, no diagnostic messa
ge will be shown on the serial output.

HOW TO USE THE GSM & GPS SHIELD WITH ARDUINO MEGA
For problems with the RAM, or simply for projects that require a larger number o
f input/output, we can use with the GSM/GPRS & GPS shield the Arduino Mega. Tha
nks to four serial port, we can use one of these instead of the serial software
to communicate with the shield.
With the latest release, the library can be used completely with Arduino Mega. Y
ou must open the file GSM.h and select the tab used appropriately commenting lin
es of code.
Using the shield with Arduino Mega we comment as follows:

//#define UNO
#define MEGA
If we want to use Arduino UNO:
#define UNO
//#define MEGA

Similarly, also the file HWSerial.h, must be configured. As before, we see the f
irst example for Arduino Mega:

#define MEGA

Using the file HWSerial.h is not necessary to define the possible use with Ardui
no Uno, as implemented in the class it is only used by the hardware serial.
The library uses the serial Serial0 (TX 1 RX 0) for external communication and t
he serial Serial1 (RX 18 TX 19) to communicate with SIM900 and SIM908. Nothing p
revents you replace every occurrence of Serial1 with Serial2 or one that you pre
fer.
Please note that to use the serial hardware you need to create the connection be
tween the shield and Arduino Mega using a bridge: the TX pin of the shield must
be connected to TX1 18 and the RX pin with the RX1 19.

THE STORE