GSM Shield per Arduino

Schema elettrico GSM Shield Arduino

Le grandi potenzialità di Arduino risiedono certamente nel fatto che è un potente microcontrollore posto su una scheda e di cui vengono facilmente rese accessibili tutte le porte e le periferiche interne, ma anche e soprattutto nella disponibilità di routine firmware open-source condivisibili tra gli utenti e che permettono di eseguire, utilizzando il software di programmazione ufficiale, qualsiasi funzione; insomma, il bello di Arduino è che il suo ambiente di sviluppo ci mette a disposizione funzionalità già pronte da eseguire, quindi se vogliamo fare qualcosa dobbiamo semplicemente dirgli di farlo ed esso lo farà nel migliore dei modi. Ad esempio, se intendiamo instaurare una connessione di rete locale dobbiamo procurarci un’interfaccia ethernet e dire ad Arduino su quale indirizzo e con quali parametri di rete deve collegarsi.

Ebbene, l’interfaccia è lo “shield”, che nel caso specifico è uno shield LAN; ma in generale con il termine shield si definisce una qualsiasi scheda che interconnette Arduino con il mondo esterno e gli permette di collegarsi ad altri apparati o comandare utilizzatori e controllare processi. In queste pagine vi proponiamo uno shield che vi permetterà, con Arduino, di realizzare applicazioni che coinvolgono il mondo della telefonia cellulare, quindi gestire invio e ricezione di SMS, inviare toni di segnalazione, effettuare il controllo a distanza via GSM, accedere ad Internet o svolgere servizi dati sfruttando la connessione GPRS. Insomma, diciamo pure che con un modulo Arduino e lo shield GSM che trovate in queste pagine potete realizzare la gran parte dei progetti che avete visto in questi anni nelle nostre pagine e che si avvalgono della connessione telefonica: telecontrolli, teleallarmi, sistemi di telemetria e pubblicazione a distanza di dati sul web, termostati controllati a distanza e tante altre soluzioni similari.

Il circuito che realizza tutto ciò è molto semplice ed è reso tale dal fatto che il grosso del lavoro viene compiuto da Arduino, per il quale abbiamo scritto una libreria ed una routine software in grado di gestire correttamente il dialogo con il modulo cellulare e le segnalazioni di controllo che esso fornisce. Per ora, lo sketch che abbiamo preparato e che vi mettiamo a disposizione consente la gestione delle chiamate e degli SMS, oltre che della rubrica nella SIM del cellulare, tuttavia se ve la sentite, sulla base del nostro programma potete svilupparne uno qualitativamente più completo, allo scopo di accedere alle funzionalità GPRS e quindi ad Internet: il modulo può farlo e Arduino non ha difficoltà; si tratta solo di preparare uno sketch adatto.


Schema Elettrico

Piano di Montaggio dello GSM Shield Arduino

Elenco Componenti:

R1: 470 ohm

R2: 1 kohm

C1: 100 nF multistrato

C2: 470 µF 25 VL elettrolitico

C3: 100 nF multistrato

C4: 470 µF 16 VL elettrolitico

U1: LM317

GSM: Modulo TDGGSM_900

SW1: Deviatore 2 vie miniatura

P1: Microswitch

Varie:

– Pin strip M/F 6 vie (2 pz.)

– Pin strip M/F 8 vie (2 pz.)

– Pin strip femmina 3 vie

– Pin strip femmina 16 vie

– Circuito Stampato

Vediamo subito in cosa consiste il nostro shield, analizzandone lo schema elettrico pubblicato in queste pagine: il circuito è semplicissimo e consta essenzialmente del modulo GSM/GPRS e del regolatore che provvede ad alimentarlo, ma anche di quattro pin-strip ed altrettanti connettori femmina S.I.L. a passo 2,54 min, che realizzano le connessioni passanti col modulo Arduino e verso eventuali altri shield montabili a sandwich sopra il nostro. Per l’esattezza, i connettori dello shield sono J1 (dati D8÷D13 di Arduino) J3 (dati D4÷D7 ed RX e TX di Arduino) e J4 (alimentazione dello shield e linea di reset di Arduino).

Oltre ai pin-strip per la connessione con Arduino, lo shield dispone di due file di contatti femmina a passo 2,54 mm single-in-line (una da 3 e l’altra da 16 contatti) nei quali si inserisce il modulo cellulare; in realtà sullo stampato abbiamo sdoppiato tali connessioni, in modo che chi lo desidera possa prelevare segnali come l’audio o i segnali di controllo del cellulare senza mettere mani sui connettori dedicati al montaggio del modulo che ospita il cellulare. Ciò grazie al fatto che le file da 3 e 16 contatti che abbiamo aggiunto sono in parallelo a quelle del modulo cellulare.

Dunque, nel circuito shield in realtà vi sono due file di tre contatti femmina accostate da una parte ed altrettante da 16 contatti (sempre femmina) dal lato opposto. Partiamo analizzando il modulo cellulare inserito nello shield, basato sul cellulare SIM900 della SimCom, che attualmente è il più economico modulo cellulare GSM/GPRS disponibile sul mercato; per renderne semplice il montaggio (dato che ha i contatti posti immediatamente sotto i bordi e che sporgono lateralmente di pochissimo) l’abbiamo previsto già montato su una basetta adattatrice, che ne porta i piedini su dei pin-strip.

Listato 1

Libreria scaricabile cliccando QUI

{codecitation brush:cpp}

/* GSM Shield exampleCREATEd 2011by Boris Landoni

 

This example code is in the public domain.

 

*/

 

#include <GSM_Shield.h>

//for enable disable debug rem or not the string #define DEBUG_PRINT

// definition of instance of GSM class

GSM gsm;

 

void setup() {

Serial.begin(9600);

Serial.println(“system startup”);

gsm.TurnOn(9600); //module power on

gsm.InitParam(PARAM_SET_1);//configure the module

gsm.Echo(1); //enable AT echo

}

 

void loop()

{

 

int call;

call=gsm.CallStatus();

switch (call){

case CALL_NONE:

Serial.println(“no call”);

break;

case CALL_INCOM_VOICE:

Serial.println(“incoming voice call”);

delay(5000);

gsm.PickUp();

break;

case CALL_ACTIVE_VOICE:

Serial.println(“active voice call”);

delay(5000);

gsm.HangUp();

break;

case CALL_NO_RESPONSE:

Serial.println(“no response”);

break;

}

delay(1000);

}

{/codecitation}

Commento al LISTATO

Questo sketch per Arduino restituisce lo stato delle chiamate. Quando non c’è alcuna chiamata in arrivo, restituisce la scritta ” no call “, mentre quando arriva una chiamata, Arduino darà come segnalazione la scritta ” incoming voice call ” e dopo 5 secondi risponderà alla chiamata. Fino a quando non si interrompe la comunicazione la scritta sarà ” active voice call “

Quindi sappiate che i numeri dei contatti mostrati nello schema elettrico si riferiscono ai contatti dei pin-strip della basetta adattatrice e non al modulo SIM900 vero e proprio; del modulo restano i nomi dei pin. Sappiate inoltre che quello che nello schema elettrico vedete siglato GSM, è in realtà il modulo cellulare, ossia la basetta adattatrice che contiene il SIM900. Vediamo dunque -per prima cosa- com’è fatto il circuito (basetta adattatrice) che contiene il cellulare: si tratta di un piccolo stampato che dispone di un connettore maschio a 20 contatti (due file da 10 l’una) a passo 2 mm che permette di inserirlo nel connettore femmina corrispondente sul circuito base ospitante il microcontrollore.

Il connettore trasporta l’alimentazione (Vcc, contatti 17 e 19) oltre alla linea di controllo dell’accensione (PWR), a tutti i segnali e alle linee di comunicazione seriale da e verso il modulo GSM, ma anche la massa (GND, contatti 18 e 20). Oltre ai connettori, il modulo con il cellulare ospita anche tre transistor, un LED, il porta SIM e un gruppo di diodi Zener. Quanto alle connessioni del cellulare, vediamo la linea PWR, la quale serve al microcontrollore del circuito per comandare l’accensione e lo spegnimento del modulo GSM, che comunque rimane sempre sotto tensione, quest’ultima fornita dalla linea Vcc ai piedini 55, 56, 57; la linea, dotata di una resistenza di pull-up interna, è attiva a zero logico, quindi Arduino, per accendere il modulo cellulare, pone a livello logico alto PWR (contatto 1 del pin-strip) e manda in saturazione il transistor T2, il quale pone a livello basso la linea PWR del GSM.

Il controllo del reset avviene mediante una linea dedicata (il SIM900 prevede un ingresso di reset NRESET attivo a zero logico e provvisto di resistere interno di pull-up) e si ottiene facendo inviare al micro l’1 logico sulla linea RST, allorchè il transistor T3 va in saturazione e pone a livello basso la linea NRESET del GSM1; contestualmente, RST viene portata ad 1 logico. Procediamo ora con le linee di controllo dell’UART, ossia TXD, RXD, DTR, RTS, CTS, DCD, che vanno all’esterno mediante i contatti, rispettivamente, 12,14,10,2, 4 e 6 del connettore; lo stesso dicasi per VRTC (contatto 5) e ADCO (25).

L’audio, facente capo a due contatti per il microfono (ad ingresso differenziale) ed altrettanti per l’altoparlante, transita dai contatti 19, 20, 21,22, che corrispondono rispettivamente a MIC1P e MIC1N (positivo e negativo del microfono) ed SPK1N e SPK1P (rispettivamente negativo e positivo dell’altoparlante). Il segnale di RI (indicatore di arrivo chiamata) esce dal contatto 18 del connettore e viene usato per informare il microcontrollore o altro dispositivo che si interfaccia con il cellulare (nel nostro caso, il modulo Arduino) dell’arrivo di una telefonata. L’antenna del modulo GSM in questo caso si collega direttamente sullo stampato del cellulare. La presa d’antenna è localizzata al piedino 60. Il transistor T1 viene usato per comandare localmente il LED di campo del cellulare: la sua base viene polarizzata dal livello logico presente sul piedino 52 (NETLED) del GSM1.

Dal collettore del transistor parte la linea che porta al contatto 3 del connettore che fa capo alla linea LED, con la quale Arduino potrà, tramite il contatto 19 della scheda adattatrice, ovvero il 7 dello shield (corrispondente alla linea D6 di Arduino) informarsi sulla presenza della rete GSM e sullo stato di connessione del modulo (assenza segnale di rete, presenza rete ecc.).

Concludiamo l’analisi del modulo del cellulare descrivendo delle linee di gestione della SIM, che si interfaccia al cellulare tramite il bus formato da SIM_CLK (clock) SIM_RST (reset) e SIM_DATA (canale dati); la linea SIM_VDD viene usata per accendere e spegnere la SIM ed è gestita dal modulo GSM. Notate la presenza del quadruplo Zener D1, i cui diodi proteggono la SIM-Card da eventuali picchi di tensione dovuti a disturbi, che possono arrivare dalla linea di alimentazione a quelle del bus di comunicazione tra SIM e cellulare.

Bene, stabilito cosa contiene il modulo che ospita il SIM900, vediamo il resto dello shield, che consta, oltre che dei connettori S.I.L. femmina a passo 2,54 mm per accogliere i pin-strip del modulo cellulare, di un doppio deviatore e di un regolatore di tensione integrato; il doppio deviatore consente di smistare i canali TXD ed RXD dell’UART interno al SIM900 sulle linee TXD ed RXD di Arduino (accessibili dagli omonimi contatti del connettore di inserzione J3).

Lo stadio d’alimentazione si basa sul regolatore LM317, un classico che permette di ottenere una tensione d’uscita di valore compreso fra circa 1,25 e 35 V in continua, alimentato con un massimo di 40 V, erogando fino ad 1,5 ampere. Per l’esattezza, la tensione d’uscita Vo è legata ai valori delle resistenze R1 ed R2 che vedete nello schema elettrico dello shield, dalla relazione:

Vo = 1,25 V(1+R2/R1) + Iadj x R2

dove Iadj è la corrente che normalmente fluisce nella resistenza collegata tra il piedino ADJ e massa e che sostanzialmente dipende dal potenziale del pin ADJ, che è 1,25 V. Normalmente tale corrente ammonta a 50 µA. Nel nostro caso, essendo R1 da 470 ohm ed R2 da 1 kohm, la tensione ottenuta dall’LM317 vale:

Vo=1,25 V (1+1KΩ/0,47kΩ) + Iadj x 1 kΩ = (3,9 + 0,05)V=3,95V

Questo è il valore della tensione erogata dal regolatore e fornita al modulo che ospita il cellulare e da esso, tramite il contatto Vcc, al cellulare SIM900. Notate che lo shield prende alimentazione dal connettore J4 e perciò dal modulo Arduino sul quale viene applicato; il modulo va quindi alimentato a 9-5-12 Vcc (bastano 9 V) tenendo conto dell’assorbimento dello shield, che con il cellulare in funzione può raggiungere i 400 mA.

Quanto al doppio deviatore SW1, lo abbiamo previsto per consentire allo shield di indirizzare la linea seriale del SIM900 verso quella hardware (posizione HW) prevista in Arduino oppure verso due pin che, con un opportuno firmware, possono emulare una seriale (si tratta dei piedini 5 e 6 del J3, corrispondenti alle linee D4 e D5 di Arduino); ciò corrisponde alla posizione SW. Il doppio deviatore SW1 può servire ad esempio se ad Arduino sono applicati più shield e già uno di essi utilizza la porta seriale, nel qual caso bisogna dirottare TXD ed RXD del cellulare verso D4 e D5 ed emulare la seriale da firmware.

 

Realizzazione Pratica

Lo shield è di semplice costruzione, dato che si tratta di un semplice stampato a singola faccia che contiene pochissimi componenti; una volta ottenuta la basetta, con un saldatore da non pià di 30 watt, saldate le due resistenze e i quattro condensatori occorrenti, prestando attenzione alla polarità degli elettrolitici, poi sistemate il doppio deviatore a slitta ed il pulsante miniatura per c.s., da collocare lateralmente al circuito.

Procedete inserendo e saldando l’integrato LM317, che dovete sdraiare sulla basetta dopo averne piegato i terminali ad angolo retto. Per le connessioni, utilizzate delle file di connettori single-in-line femmina a passo 2,54 mm (adatte ai pin-strip di pari passo…) di due tipi: tradizionale e con terminali lunghi 20 mm; del primo servono due file da 3 e due da 16 contatti, mentre del secondo tipo ci occorrono due file da 6 ed altrettante da 8 contatti. Noterete che introducendo i connettori femmina coi terminali lunghi nei rispettivi fori dello stampato dello shield, i terminali stessi faranno da pin-strip e permetteranno allo shield stesso di introdursi nei connettori del modulo Arduino.

Sistemato il circuito, potete pensare al modulo contenente il cellulare GSM, che potete acquistare già fatto e collaudato (si chiama TDGGSM_900 e viene venduto dalla ditta Futura Elettronica –www.futurashop.it-) oppure costruire seguendo il relativo schema elettrico illustrato in questo articolo, oppure seguendo le indicazioni fornite a pagina 39 nel fascicolo n° 147, dove il modulo viene usato nel progetto del telecontrollo GSM. Completate le saldature e verificato che non vi siano falsi contatti o cortocircuiti, il vostro shield è pronto; inseritevi il modulo col SIM900 sfruttando i contatti disposti trasversalmente e potete poi inserire il tutto su Arduino.


Usare lo Shield

La prima cosa da fare prima di utilizzare lo shield è caricare lo sketch firmware in Arduino, in modo da poterlo gestire; se oltre a quello qui descritto, il sistema ospita altri shield, potrebbe essere necessario verificare se la seriale di Arduino è già occupata: se lo è, dovete spostare il doppio deviatore SW1 sulla posizione SW, assegnando, così, la comunicazione tra SIM900 e Arduino alle linee D4 e D5 di quest’ultimo.

In tal caso dovete attivare l’emulazione firmware della seriale, assegnandola a D4 e D5. Nel caso il nostro sia l’unico shield montato o l’unico, tra quelli montati, che adopera la seriale hardware di Arduino, spostate pure SW1 sulla posizione HW. Fatto ciò, siete pronti per lavorare con lo shield GSM. Prima di dare tensione all’insieme, ricordate di collegare al connettore d’antenna del modulo cellulare il cavetto dell’antenna GSM che avete scelto e che, lo ricordiamo, deve essere compatibile con le bande 850/900/1.800/1.900 MHz.

Per la comunicazione tra shield e Arduino, una volta impostata la seriale (hardware o software) selezionate la velocità di comunicazione; rammentate che usando la seriale fisica (hardware) non ci sono problemi di baud-rate (quello predefinito è 115.200) ma potreste incontrare difficoltà programmando il modulo, perchè la seriale viene usata per caricare gli sketch. Invece, usando i pin 5 e 6 del J3 (seriale software) non ci sono problemi nel caricare gli sketch, tuttavia il massimo baud-rate ammesso dalla libreria che emula la comunicazione seriale (NewScftSerial) è 57.600.

Per la gestione del cellulare SIM900 abbiamo messo a punto una libreria, derivata dalla di HWKitchen, modificata per il nostro modulo. Con la nostra versione controlliamo il modulo attraverso i contatti 5 e 6 del connettore J3 (sono le linee digitali D4 e D5 di Arduino) perchè la nostra libreria GSM include NewSoftSerial; ciò vi permette di gestire il modulo, inviare e leggere SMS, effettuare chiamate, verificare lo stato del cellulare (rete agganciata ecc.) ed altro ancora. Trovate tutte le funzioni di libreria nella Tabella 1, opportunamente commentate: ognuna corrisponde a una funzionalità permessa dallo shield.

 

Funzione Descrizione
int LibVer(void) restituisce la versione della libreria in formato XYY, che significa X.YY: ad esempio 100 vuol dire vers. 1.00)
void TurnOn(baud) accende il modulo GSM e invia i comandi AT di inizializzazione inviabili senza bisogno di registrazione
void InitParam (byte group) invia i parametri per l’inizializzazione del modulo GSM
void Echo(byte state) abilita o disabilita l’eco dei comandi: Echo(1) abilita ed Echo(0) disabilita l’eco
byte CheckRegistration(void) verifica se il GSM è stato registrato nella rete cellulare; questa funzione comunica direttamente col modulo, diversamente da IsRegiste-red() che legge il flag da module_status
byte IsRegistered(void) ritorna un flag se il GSM è registrato nella rete; la procedura è veloce (richiede solo 20 ms.) e conviene utilizzarla quando è necessario veri ficare che il GSM sia registrato nella rete quali la verifica degli SMS e delle chiamate in arrivo
byte CallStatus(void) verifica lo stato delle chiamate e fornisce CALL_N0NE se non c’è chiamata, CALL_INCOM_VOICE se c’è una chiamata a voce in arrivo, CALL_ACTI-VE_V0ICE se è in corso una chiamata vocale e CALL_NO_RESPONSE in caso di chiamata senza risposta
byte CallStatusWithAuth(char *pho-ne_number, byte tirst_authorized_pos, byte last_authorized_pos) verifica lo stato delle chiamate (in entrata o in corso) e autorizza le posizioni di SIM; ritorna:

–  phone_number: puntatore dove viene collocato il numero telefonico della chiamata in corso in modo da memorizzarlo;

– first_authorized_pos: prima posizione della rubrica nella SIM da cui sono iniziano i numeri delle chiamate autorizzate;

–  last_authorized_pos: ultima posizione della rubrica SIM dove finiscono i numeri autorizzati alle chiamate;

void PickUp(void) risponde alla chiamata in arrivo
void HangUp(void) rifiuta la chiamata in arrivo o interrompe quella in corso
void Cali(char *number_string) chiama il numero indicato
void Call(int sim_position) chiama il numero memorizzato nella posizione indicata della SIM
char SendSMS(char *number_str, char *message_str) invia l’SMS di cui è specificato il testo, al numero indicato
char SendSMS(byte sim_phonebo-ok_position, char *message_str) invia l’SMS di cui è specificato il testo, al numero di cui è indicata la posizione in SIM
char lsSMSPresent(byte required_status) verifica se è presente almeno un SMS nello stato specificato; se c’è un SMS prima che la funzione sia eseguita e risulta non letto, viene automaticamente convertito in “letto”; i valori che la funzione ritorna sono:

– SMS_UNREAD = SMS non ancora letto);

– SMS_READ = SMS già letto;

– ALL_SMS = tutti gli SMS memorizzati;

char GetSMS(byte position, char *phone_number, char *SMS_text, byte max_SMS_len) legge l’SMS dalla posizione indicata della SIM, ritornando i seguenti valori:

–  position = posizione SMS ( <1..20> );

–  phone_number: puntatore dove viene messa il numero da cui proviene l’SMS, in modo che la posizione possa essere riservata;

–  SMS_text: puntatore dove viene collocato il testo delI’SMS;

–  max_SMS_len: massima lunghezza dell’SMS, escludendo il carattere terminatore 0x00

char GetAuthorizedSMS( byte position, char *phone_number, char *SMS_text, byte max_SMS_len, byte first_authorized_pos, byte last_autho-rized_pos) legge l’SMS dalla posizione specificata della SIM e dà l’autorizzazione ad eseguirlo se proviene da un numero telefonico autorizzato; in tal caso ritorna GETSMS_AUTH_SMS, altrimenti restituisce GETSMS_NOT_AUTH_SMS
char DeleteSMS(byte position) cancella l’SMS che si trova nella posizione specificata
char GetPhoneNumber(byte position, char *phone_number) legge il numero telefonico dalla posizione specificata della SIM
char WritePhoneNumberfbyte position. char *phone_number) scrive il numero telefonico nella posizione specificata della SIM
char DelPhoneNumber(byte position) cancella il numero telefonico dalla posizione specificata della SIM
char ComparePhoneNumberfbyte position, char *phone_number) confronta il numero specificato con quello memorizzato nella posizione specificata della SIM

Altri esempio di Sketch

Listato 2°

{codecitation brush:cpp}

/* GSM Shield example CREATEd 2011 by Boris Landoni

This example code is in the public domain.

*/

#include <GSM_Shield.h>

//for enable disable debug rem or not the string #define DEBUG_PRINT

// definition of instance of GSM class

GSM gsm;

void setup() {

Serial.begin(9600);

Serial.println(“system startup”);

gsm.TurnOn(9600); //module power on

gsm.InitParam(PARAM_SET_1);//configure the module

gsm.Echo(1); //enable AT echo

}

void loop()

{

int ver;

ver=gsm.LibVer();

Serial.print(“Response Ver “);

Serial.println(ver);

delay(50000);

}

{/codecitation

Listato 3°

{codecitation brush:cpp}

/* GSM Shield exampleCREATEd 2011by Boris Landoni

This example code is in the public domain.

*/

#include <GSM_Shield.h>

//**************************************************************************

char number[]=”+39123456789″; //Destination number

char text[]=”hello world”; //SMS to send

byte type_sms=SMS_UNREAD; //Type of SMS

byte del_sms=0; //0: No deleting sms – 1: Deleting SMS

//**************************************************************************

GSM gsm;

char sms_rx[122]; //Received text SMS

//int inByte=0; //Number of byte received on serial port

char number_incoming[20];

int call;

int error;

void setup()

{

Serial.begin(9600);

Serial.println(“system startup”);

gsm.TurnOn(9600); //module power on

gsm.InitParam(PARAM_SET_1);//configure the module

gsm.Echo(0); //enable AT echo

}

void loop()

{

char inSerial[5];

int i=0;

delay(2000);

Check_Call(); //Check if there is an incoming call

Check_SMS(); //Check if there is SMS

//Check data serial com

if (Serial.available() > 0)

{

while (Serial.available() > 0) {

inSerial[i]=(Serial.read()); //read data

i++;

}

inSerial[i]=’\0′;

Check_Protocol(inSerial);

}

}

void Check_Protocol(String inStr)

{

Serial.print(“Command: “);

Serial.println(inStr);

Serial.println(“Check_Protocol”);

switch (inStr[0])

{

case ‘a’ : //Answer

if (gsm.CallStatus()==CALL_INCOM_VOICE){

gsm.PickUp();

Serial.println(“Answer”);

}

else

{

Serial.println(“No incoming call”);

}

break;

case ‘c’: // C //Call

if (inStr.length()<2) //To call variable ‘number’ comand c

{

Serial.print(“Calling “);

Serial.println(number);

gsm.Call(number);

}

if (inStr.length()==2) //To call number in phone book position comand cx where x is the SIM position

{

error=gsm.GetPhoneNumber(inStr[1],number);

if (error!=0)

{

Serial.print(“Calling “);

Serial.println(number);

gsm.Call(number);

}

else

{

Serial.print(“No number in pos “);

Serial.println(inStr[1]);

}

}

break;

case ‘h’: //H //HangUp if there is an incoming call

if (gsm.CallStatus()!=CALL_NONE)

{

Serial.println(“Hang”);

gsm.HangUp();

}

else

{

Serial.println(“No incoming call”);

}

break;

case ‘s’: //S //Send SMS

Serial.print(“Send SMS to “);

Serial.println(number);

error=gsm.SendSMS(number,text);

if (error==0) //Check status

{

Serial.println(“SMS ERROR \n”);

}

else

{

Serial.println(“SMS OK \n”);

}

break;

case ‘p’: //Read-Write Phone Book

if (inStr.length()==3)

{

switch (inStr[1])

{

case ‘d’: //Delete number in specified position pd2

error=gsm.DelPhoneNumber(inStr[2]);

if (error!=0)

{

Serial.print(“Phone number position “);

Serial.print(inStr[2]);

Serial.println(” deleted”);

}

break;

case ‘g’: //Read from Phone Book position pg2

error=gsm.GetPhoneNumber(inStr[2],number);

if (error!=0) //Find number in specified position

{

Serial.print(“Phone Book position “);

Serial.print(inStr[2]);

Serial.print(“: “);

Serial.println(number);

}

else //Not find number in specified position

{

Serial.print(“No Phone number in position “);

Serial.println(inStr[2]);

}

break;

case ‘w’: //Write from Phone Book Position pw2

error=gsm.WritePhoneNumber(inStr[2],number);

if (error!=0)

{

Serial.print(“Number “);

Serial.print(number);

Serial.print(” writed in Phone Book position “);

Serial.println(inStr[2]);

}

else Serial.println(“Writing error”);

break;

}

}

break;

}

delay(1500);

return;

}

void Check_Call() //Check status call if this is available

{

call=gsm.CallStatus();

switch (call)

{

case CALL_NONE:

Serial.println(“no call”);

break;

case CALL_INCOM_VOICE:

gsm.CallStatusWithAuth(number_incoming,0,0);

Serial.print(“incoming voice call from “);

Serial.println(number_incoming);

break;

case CALL_ACTIVE_VOICE:

Serial.println(“active voice call”);

break;

case CALL_NO_RESPONSE:

Serial.println(“no response”);

break;

}

return;

}

void Check_SMS() //Check if there is an sms ‘type_sms’

{

char pos_sms_rx; //Received SMS position

pos_sms_rx=gsm.IsSMSPresent(type_sms);

if (pos_sms_rx!=0)

{

//Read text/number/position of sms

gsm.GetSMS(pos_sms_rx,number_incoming,sms_rx,120);

Serial.print(“Received SMS from “);

Serial.print(number_incoming);

Serial.print(“(sim position: “);

Serial.print(word(pos_sms_rx));

Serial.println(“)”);

Serial.println(sms_rx);

if (del_sms==1) //If ‘del_sms’ is 1, i delete sms

{

error=gsm.DeleteSMS(pos_sms_rx);

if (error==1)Serial.println(“SMS deleted”);

else Serial.println(“SMS not deleted”);

}

}

return;

}

{/codecitation}

Share This