1

CORSO SERALE (Classe V/STE)

Area di progetto anno scolastico 2006/2007

Allievo: Lazzari Matteo Tutor: Prof. Zaniol Italo

Termostato controllato tramite modulo GSM

IL PROGETTO REALIZZATO

2

Indice

Introduzione Pag 3 Schema a blocchi del sistema Pag 3 Descrizione schema a blocchi Pag 4 Schema elettrico Pag 5 Descrizione schema elettrico Circuito di alimentazione Pag 6 Circuito di programmazione Pag 6 Modulo GSM Pag 7 Descrizione della piedinatura Pag 8 Perché utilizzare un modulo GSM? Pag 9 Caratteristiche principali Pag 9 Funzioni principali Pag 10 Programmare il modulo GSM Pag 11 Il Pic16F877 Pag 12 La porta seriale nel pic Pag 13 Il sensore di temperatura DS18B20 Pag 14 Analisi del software Programma del modulo GSM Pag 21 Analisi di alcune routine del pic Pag 28 Istruzioni d’uso Pag 29

3

Introduzione Come conclusione di una serie di progetti sviluppati durante l’anno scolastico inerenti l’acquisizione ed il controllo di grandezze fisiche, si è deciso di realizzare un controllo di temperatura che, utilizzando un modulo GSM prodotto dalla Sony-Ericsson, consente anche un controllo a distanza di tale grandezza fisica. Con il sistema realizzato è possibile infatti interagire sia localmente che a distanza mediante un telefono cellulare. Localmente è possibile:

• Leggere la temperatura ambiente su un display LCD • Attivare \ disattivare un generatore di calore • Impostare il Set Point di intervento del generatore di calore • controllare la temperatura nell’ambiente in cui è situato il termostato in modo

ON/OFF A distanza, mediante trasmissione/ricezione di SMS, è possibile:

• conoscere la temperatura dell’ambiente controllato • conoscere lo stato del generatore di calore • Attivare \ disattivare il generatore di calore • Impostare il Set Point • ricevere una segnalazione di allarme (ad esempio da un antifurto)

Schema a blocchi del sistema

4

Descrizione dello schema a blocchi Lo schema a blocchi evidenzia come il pic 16f877 sia il cuore del sistema. Esso controlla:

� Il sensore di temperatura � I pulsanti di set point � Il pulsante ON/OFF � Un ingresso di allarme � La comunicazione con il modulo GSM � Il display LCD

Il Modulo GSM, invece, svolge le seguenti funzioni:

� Interfaccia con la rete GSM � Invio e ricezione di messaggi SMS � comunicazione con il PIC

Una porta seriale viene utilizzata per programmare il modulo GSM on board tramite un personal computer in cui è installato un opportuno software di programmazione fornito gratuitamente dalla casa costruttrice e scaricabile dal sito della multinazionale. Grazie a questa porta si risparmia tempo in fase di programmazione e messa a punto oltre a ridurre le possibili rotture del modulo dovute al continuo “leva e metti” su un connettore a 60 pin di tipo SMD.

Schema elettrico

Trattandosi di un prototipo, ed essendo poco il tempo a disposizione per la realizzazione del progetto, è stata utilizzata, come base di partenza, una demoboard che prevede:

• Un connettore per la programmazione in-circuit ( il programmatore usato è il PICkit 2 della Microchip che viene collegato al PC tramite porta USB )

• Uno strip femmina a 14 pin per controllare un display LCD • Uno strip femmina a 8 pin per collegare un tastierino esadecimale o simile • 6 led che possono essere scollegati dalle relative uscite che li comandano mediante dei

jumper. • Due pulsanti • Due strip femmina a 20 pin che riflettono la piedinatura del PIC e possono essere

utilizzati per alloggiare schede di espansione • Un regolatore di tensione che fornisce i 5 volt alla scheda a partire da un alimentatore

esterno ( ad esempio 12V ) che si collega alla demoboard tramite plug di alimentazione. La demoboard è di seguito mostrata. Ulteriori notizie si possono trovare nel sito della scuola ( vedi materiale didattico ).

5

Sui due strip femmina è stata collocata la scheda che riguarda in modo particolare il progetto realizzato. Lo schema elettrico di questa scheda è quello di seguito riportato.

Da una prima analisi si può notare:

• una porta seriale che utilizza due MAX 232 per l’interfacciamento con il PC • un circuito di alimentazione del modulo GSM • il connettore per l’interfacciamento di questa scheda con la demoboard • il circuito di interfaccia tra microcontrollore e modulo GSM

6

• il sensore di temperatura

Descrizione schema elettrico

Circuito di alimentazione

Poiché il modulo GSM e i due MAX232 devono essere alimentati a 3.6V, si utilizza questo semplice circuito per convertire i 12V di alimentazione nei 3.6V richiesti. Il componente principale è un LM317; la tensione voluta si ottiene regolando opportunamente il trimmer di 3,6Volt. Il led segnala la presenza della tensione. Per quanto concerne i criteri di progetto ci si è attenuti a quelli forniti dal costruttore ( si vedano i data sheet ).

Porta seriale

Visto che il modulo GSM comunica con il PC tramite protocollo asincrono RS232 su sette linee ( il MAX 232 dispone di 2 ingressi e due uscite ) è necessario utilizzare due MAX232. I segnali della porta sono: DCD = Data Carrier Detect RD = Received Data TD = Trasmitted Data DTR = Data Terminal Ready RI = Ring Indicator CTS = Clear To Send RTS =Request To Send La programmazione avviene configurando la porta seriale del PC alla velocità di 9600 Bit/Sec

7

Modulo GSM Il modulo GSM è montato su un circuito stampato di cui si riporta il layout. Esso è stato realizzato per poter utilizzare il modulo in diversi progetti senza la necessità di saldare ogni volta il connettore smd a 60 pin che tra l’altro ha un costo di circa sette euro.

PAKAGE SCHEDA GSM

Tale schedina implementa: • il connettore a 60 pin per alloggiare il modulo GSM • il dispositivo per alloggiare la SIM card • due connettori strip maschio per poter alloggiare la scheda su un circuito applicativo • alcuni componenti di supporto

Nella foto si può vedere tale schedina

8

Per interfacciare la scheda al circuito che la ospiterà, mediante programma EAGLE, è stato realizzato il simbolo di figura a cui è associato il pakage precedentemente visto.

SIMBOLO SCHEDA GSM

Tale simbolo riporta i pin del modulo GSM. Oltre alla citata porta seriale usata per la programmazione, il modulo controlla due diodi led:

• LD2 per segnalare ricezione SMS • LD3 segnala la connessione alla rete GSM ( lampeggia quando ha trovato la rete )

Tramite il transistore Q1, che fa da adattatore di tensione ( si ricorda che il PIC lavora con 5V mentre il modulo con 3.6V ), il modulo comunica al PIC lo stato della rete che viene proposto sul display LCD. Tramite Q4 il GSM invia dati al PIC utilizzando la porta seriale; il transistore viene utilizzato ancora come adattatore di tensione . Il diodo shottky D2 serve ad adattare il livello di tensione proveniente dalla seriale del PIC ( che è a 5V ), con le esigenze del modulo il cui livello riconosciuto come alto non deve essere superiore a 3.6V. Tale diodo presenta il catodo collegato all’uscita della seriale e l’anodo connesso al pin Vio che fornisce 3.6V. Quando il PIC invia un livello alto, il diodo è interdetto e quindi sull’ingresso abbiamo 3.6V. Quando invece il livello è basso, il diodo è in conduzione e sull’ingresso del modulo abbiamo la tensione tra anodo e catodo del diodo che essendo di tipo shottky è di circa 0.1V e quindi tale valore viene riconosciuto come basso dal modulo GSM. Abbiamo infine un pulsante che consente di attivare/disattivare il modulo.

9

INTERFACCIAMENTO TRA MODULO GSM ED IL RESTO DEL CIR CUITO

Analisi del modulo GSM

Piedinatura del modulo GSM

10

Perché utilizzare un modulo GSM

Il modulo GM47 prodotto dalla Sony Ericsson appartiene ad una nuova generazione di dispositivi GSM destinata ad essere integrata all’interno di applicazioni che richiedono una comunicazione macchina/macchina o uomo/macchina di tipo wireless. Il GR47 può essere utilizzato in tutte quelle situazioni che richiedono l’invio e la ricezione di dati (attraverso gli SMS ) oppure che richiedono la realizzazione di chiamate vocali attraverso la rete GSM. Sebbene il modulo sia dotato di porte di ingresso e uscita, è possibile interfacciarlo, come nel nostro caso, con sistemi basati su microprocessore. Il microcontrollore interagisce col GR47 attraverso una connessione seriale.

Caratteristiche principali Il dispositivo ha dimensioni e peso estremamente ridotti. E’ di tipo dual band (lavora infatti alle frequenze di 900 e 1800MHz); è in grado di trasmettere dati mediante SMS, oppure mediante modem alla velocità di 9,6Kbps ( GSM ) o tramite protocollo GPRS fino a 86,6 Kbps. Permette inoltre di effettuare chiamate vocali e gestire gli SMS e la rubrica sia all’interno del modulo che all’interno di una SIMCard.

11

La programmazione del modulo si effettua in un ambiente di sviluppo che utilizza un linguaggio di programmazione simile all’ANSI C.

Analisi delle funzioni principali Servizio SMS: Il modulo supporta l’invio e la ricezione di SMS, sia attraverso il protocollo PDU che text mode. La massima lunghezza di un SMS è di 160 caratteri utilizzando una codifica a 7bit e di 140 caratteri con codifica a 8bit. Servizio Dati: Il modulo supporta l’invio e la ricezione di dati secondo il protocollo GSM e GPRS. Servizio Chiamata vocale: Il GR47 presenta la capacità di generare, ricevere e terminare chiamate vocali. Sono inoltre disponibili i servizi di multichiamate, attesa di chiamata e deviazione di chiamata (dipendenti dal gestore di rete GSM). SIM Card:

12

Il dispositivo supporta il collegamento a una SIMCard esterna che rispetti la tecnologia 3 o 5V. Alimentazione: Il modulo richiede una tensione nominale di 3,6V, ma è in grado di funzionare correttamente anche all’interno del range 3,4V÷4V; l’assorbimento di corrente dipende dal tipo di applicazione e se è in corso una trasmissione. Il GR47 non dispone di capacità interne per supportare i picchi di corrente richiesti dalla trasmissione; per questo motivo sull’alimentazione viene richiesta l’aggiunta di condensatori elettrolitici di adeguata capacità. La porta seriale: Il modulo dispone di tre porte seriali UART, utilizzabili per realizzare comunicazioni asincrone verso dispositivi esterni. La UART1 è conforme allo standard RS232 a 9 pin; UART2 e UART3 realizzano invece collegamenti dati seriali full duplex di utilizzo generale. A causa dei livelli di tensione, per l’interfacciamento verso l’esterno delle UART, è necessario utilizzare degli integrati MAX232. I dati vengono trasmessi secondo il seguente standard: 1 bit di start, 8 bit di dati, nessuna parità e 1 bit di stop. Il baud rate di default della UART1 è di 9,6Kbit/s, anche se tramite comandi AT è possibile arrivare fino a 460Kbit/s.

Programmazione del modulo GSM

Per la programmazione del modulo, la Sony Ericsson fornisce il pacchetto M2mpower che realizza un completo ambiente di sviluppo IDE . La figura mostra una schermata di tale ambiente.

13

Ambiente di sviluppo M2mpower

La scheda di espansione realizzata

14

Il Pic16f877

Come già detto il Pic16f877 è il cuore del progetto. Oltre alle periferiche gestite dalla demoboard ( tastierino, display LCD, led di segnalazione, pulsanti ), esso gestisce, tramite la scheda di espansione, il sensore digitale di temperatura, il pulsante di allarme, un led di segnalazione per simulare l’allarme, e, tramite i piedini RC6 e RC7, la comunicazione seriale con il modulo GSM. Ci soffermeremo ora sulle caratteristiche essenziali della porta seriale presente nel PIC e sulla gestione del sensore di temperatura.

15

La porta seriale nel pic

Il PIC 16F877 dispone di una porta seriale che consente il dialogo tra microcontrollore e altri dispositivi pure dotati di porta seriale ( ad esempio un PC ). I pin dedicati sono sono RC7 che viene utilizzato come ingresso seriale e RC6 come uscita seriale. Il tipo di comunicazione può essere sincrona o asincrona. In questa analisi ci occupiamo della sola modalità asincrona. I registri dedicati ( ad esclusione di quelli di interrupt ), sono: PIR1, RCSTA, TXREG, TXSTA, SPBRG. - SPBRG ( banco1): il valore caricato in questo registro consente di stabilire la velocità di trasmissione. Riferirsi alle tabelle 10.4 e 10.5 ( pag. 108 e 109 del manuale ) per determinare il valore da caricare nel registro in base alla velocità di trasmissione desiderata. Il valore si può anche calcolare con la formula Vt = Fosc/ ( 64 ( X + 1 )) dove X è il valore da caricare in SPBRG e Fosc è la frequenza del clock del processore. Questa formula è valida quando il bit 2 del registro TXSTA è 0 ovvero è selezionato un Baud rate a bassa velocità. Se questo bit è 1, ovvero è selezionato un Baud rate ad alta velocità, la formula da usare è Vt = Fosc/ ( 16 ( X + 1 )). Esempio: sia Fosc = 4 MHz , Vt = 9600 bit/sec, Baud rate a bassa velocità. Dalla formula si ottiene X = Fosc/ (64 * Vt ) –1 = 5.51 Stabilito un valore 6 si ottiene Vt = 10.416.6 con un errore dato da (10417 – 9600)/9600 = 8.5% che è un errore non accettabile (NA) . Utilizzando un Baud rate ad alta velocità si ottiene: X = Fosc/ (16 * Vt ) –1 = 25.04. Stabilito un valore 25 si ottiene Vt = 9615.38 con un errore dato da (9615 – 9600)/9600 = 0.16 % che è un errore accettabile. - TXSTA (banco1): questo registro consente di configurare i parametri della porta di trasmissione e cioè: - comunicazione sincrona/asincrona - abilitare/disabilitare il bit di parità - abilitare/disabilitare trasmissione - RCSTA ( banco0 ): questo registro consente di configurare i parametri della porta di ricezione e cioè: - abilitare/disabilitare porta seriale - abilitare/disabilitare ricezione del nono bit ( bit di parità) - riconoscere errori di framing e di overrun - TXREG (banco 0): in questo registro si carica il valore a 8 bit da inviare - RCREG (banco 0): in questo registro si legge il valore ricevuto a 8 bit - PIR1 (banco 0 ): il bit 5 di questo registro si porta a 1 quando il registro RCREG contiene un dato pronto.

16

Il sensore di temperatura DS18B20 ed il protocollo di comunicazione con il processore

Il trasduttore, in grado di misurare temperature tra -55°C e +125°C con una precisione di 0.5°C nel range compreso tra -10°C e +85°C, è di tipo digitale e quindi è capace di fornisce in codice binario il valore di temperatura misurato. I trasduttori digitali, rispetto a quelli analogici come LM35 o l’AD590 ecc., presentano il grande vantaggio di semplificare notevolmente l’hardware in quanto non sono necessari il circuito di condizionamento e il convertitore analogico/digitale. Tutto ciò, naturalmente, in presenza di un circuito di elaborazione di tipo digitale; tenuto conto che l’elettronica digitale ha soppiantato le tecniche analogiche, la soluzione di trasduttori che forniscono l’informazione sulla misura di una grandezza fisica in formato numerico, è sicuramente vantaggiosa sia in termini di costi che di affidabilità e precisione. Naturalmente è necessario un certo impegno per scrivere il software adeguato a gestire la comunicazione tra circuito di elaborazione e trasduttore. Di seguito sono riassunte le prestazioni del componete che sono state ricavate dai datasheet forniti dal costruttore.

17

Caratteristiche del trasduttore di temperatura DS18B20 Come si può notare dai dati di presentazione del componente, esso dispone di una unica linea per comunicare col circuito programmabile. Tale linea ( si veda lo schema elettrico ) è collegata alla tensione di alimentazione tramite una resistenza di pullup di 4.7Kohm come consigliato dal costruttore e ad un pin del PIC. Senza analizzare tutte le caratteristiche del trasduttore, ci occuperemo del protocollo di comunicazione e di parte del software che consente di leggere la temperatura; il protocollo si deduce dai datasheet forniti dal costruttore. Il software è di uso generale ( è stato utilizzato anche in altri progetti ) ed è suddiviso in tanti sottoprogrammi che saranno richiamati in genere dal programma principale o da un sottoprogramma che gestisce tutte le routine. L’operazione di lettura della temperatura consiste nei seguenti passi: 1) PROCEDURA DI RESET

la comunicazione deve iniziare con la procedura di reset indicata in figura. a) La linea di comunicazione tenuta alta dalla resistenza di pullup ( il pin del controllore è configurato come ingresso ) deve essere portata bassa per almeno 480 microsecondi. Ciò si ottiene configurando il pin del PIC collegato alla linea del trasduttore come uscita a livello basso. b) successivamente la linea va rilasciata ( si configura il pin del PIC come ingresso ) e questa viene portata alta dalla resistenza di pullup per un tempo compreso tra 15 e 60 microsecondi. c) il trasduttore porta la linea a livello basso per un tempo compreso tra 60 e 240 microsecondi per poi rilasciarla. La seguente routine, chiamata R_ESET, esegue la procedura di reset. Si noti che l’interrupt viene disabilitato in modo che eventuali chiamate non possano disturbare le temporizzazioni richieste dalla procedura di reset. L’interrupt viene riabilitato al termine della routine.

18

;********** ROUTINE RESET SENSORE R_ESET BCF INTCON,7 ;DISABILITA INTERRUPT BSF STATUS,5 ;BANCO 1 BCF TRISB,0 ;LINEA COME USCITA BCF STATUS,5 ;BANCO 0 BCF PORTB,0 ;LINEA BASSA CALL RIT_500 ;RITARDO 500 MICROSECONDI BSF STATUS,5 ;BANCO 1 BSF TRISB,0 ;LINEA COME INGRESSO BCF STATUS,5 ;BANCO 0 NOP NOP LP BTFSS PORTB,0 ;CONTROLLA SE LINEA ALTA GOTO LP NOP NOP LP1 BTFSC PORTB,0 ;CONTROLLA SE BASSA GOTO LP1 NOP NOP LP11 BTFSS PORTB,0 ;CONTROLLA SE LINEA ALTA GOTO LP11 CALL RIT_500 ;RITARDO 500 MICROSECONDI BSF INTCON,7 ;ABILITA INTERRUPT RETURN

2) INVIO COMANDO SKIP ROM

Se non si desidera modificare i parametri nella EEPROM del trasduttore, si deve inviare un comando di SKIP ROM ( codice CCH ) . 3) INVIO COMANDO CONVERSIONE

Si può ora inviare un comando di Start conversione ( codice 44 H ); il tempo di conversione dipende dalla risoluzione desiderata che va da 9 a 12 bit. Per default la risoluzione è di 12 bit. Se si desidera modificarla bisogna caricare il registro di configurazione della memoria EEPROM con adeguati valori. Con la massima risoluzione il tempo di conversione è di 750 millesimi di secondo al massimo. Durante la conversione la linea di comunicazione è tenuta bassa dal trasduttore; al termine della conversione la linea viene portata alta. Il PIC è quindi in grado di sapere quando la conversione è terminata interrogando tale linea. 4) SI RIPETONO LE PRODEDURE 1) E 2) DI RESET E SKIP ROM 5) INVIO COMANDO LETTURA MAPPA DI MEMORIA ( SCRATCH PAD )

Mediante il codice BEH si comanda di leggere la mappa di memoria del trasduttore; questa memoria è costituita da 9 byte come mostrato in figura.

19

I primi 2 byte contengono le informazioni riguardanti la temperatura acquisita. Non è necessario leggere tutti i byte; la procedura di lettura può essere bloccata inviando un comando di reset. Per i nostri scopi il comando di reset viene dato dopo la lettura dei primi due byte. Il contenuto dei primi due registri presenta l’informazione secondo il formato indicato in figura.

I bit 15, 14, 13, 12, 11 contengono l’informazione riguardante il segno positivo ( tutti i bit sono a 0 ) o negativo ( tutti i bit sono a 1 ) della temperatura. I bit da 0 a 10 contengono il peso degli undici bit che forniscono il valore di temperatura. Ad esempio il bit 26, se a 1, significa che nel calcolo della temperatura in decimale si dovrà sommare un contributo pari a 64. Le potenze con esponente negativo indicano valori decimali cioè 0.5, 0.25, 0.125 e 0.0625. Per quanto riguarda la lettura/scrittura di un bit bisogna rispettare le temporizzazioni indicate in figura che cercheremo di analizzare in sintesi. Scrittura di un bit 0

1) Il pin del PIC è configurato come ingresso e la linea di comunicazione è tenuta alta dalla resistenza di pullup 2) Il pin del PIC viene configurato come uscita a livello basso. Essa viene tenuta bassa per un tempo compreso tra 60 e 120 microsecondi.

20

3) Il pin viene configurato come ingresso. La linea si porta a livello alto grazie alla resistenza di pullup. Prima di inviare un nuovo bit deve trascorrere almeno 1 microsecondo.

Scrittura di un bit 1 1) Il pin del PIC è configurato come ingresso e la linea di comunicazione è tenuta alta dalla resistenza di pullup 2) Il pin del PIC viene configurato come uscita a livello basso. Essa viene tenuta bassa per un tempo compreso tra 1 e 15 microsecondi. 3) Il pin viene configurato come ingresso. La linea si porta a livello alto grazie alla resistenza di pullup e tale deve rimanere per almeno 60 microsecondi. Lettura di un bit 1) Il pin del PIC è configurato come ingresso e la linea di comunicazione è tenuta alta dalla resistenza di pullup 2) Il pin del PIC viene configurato come uscita a livello basso. Essa viene tenuta bassa per un tempo massimo di 15 microsecondi. 3) Il pin viene configurato come ingresso. Nei successivi 45 microsecondi è possibile leggere lo stato della linea. Riportiamo di seguito alcune routine che realizzano alcuni dei passi analizzati. I commenti chiariscono il senso delle varie istruzioni.

21

;********** ROUTINE START CONVERSIONE (0X44=0100010 0)*************************** CONVERTI CALL ZERO ;SCRIVI UNO ZERO CALL ZERO CALL UNO ;SCRIVI UN UNO CALL ZERO CALL ZERO CALL ZERO CALL UNO CALL ZERO BSF STATUS,5 ;BANCO 1 BSF TRISB,0 ;LINEA COME INGRESSO BCF STATUS,5 ;BANCO 0 LPTC BTFSS PORTB,0 ;CONTROLLA SE FINITA CONVERSION E GOTO LPTC RETURN

;********** ROUTINE CHE SCRIVE UN0 ZERO *********** ************************** ZERO BCF INTCON,7 ;DISABILITA INTERRUPT BSF STATUS,5 ;BANCO 1 BCF TRISB,0 ;LINEA COME USCITA ( RB4 ERA GIA’ BAS SO ) BCF STATUS,5 ;BANCO 0 CALL RIT_100 ;ATTESA DI CIRCA 100 MICROSECONDI (L IVELLO BASSO IN

;USCITA) BSF STATUS,5 ;BANCO 1 BSF TRISB,0 ;LINEA COME INGRESSO BCF STATUS,5 ;BANCO 0 NOP ;RITARDO 5 MICROSECONDI NOP NOP NOP NOP BSF INTCON,7 ;ABILITA INTERRUPT RETURN

;********** ROUTINE SKIP COMAND (0XCC=11001100) COMANDO

CALL ZERO ;CHIAMA ROUTINE CHE SCRIVE 0 CALL ZERO CALL UNO ;CHIAMA ROUTINE CHE SCRIVE 1 CALL UNO CALL ZERO CALL ZERO CALL UNO CALL UNO RETURN

22

Analisi del software

Programmazione del modulo GSM

Da una prima analisi del software, si deduce che il linguaggio di programmazione del modulo, nella sintassi, è molto simile al linguaggio C. La differenza sostanziale consiste nel fatto che esso è di tipo interpretato, cioè la traduzione in codice oggetto viene effettuata al momento dell’esecuzione, mentre il C è un linguaggio compilato. Questa differenza causa non pochi problemi di collaudo del software in quanto, a seconda delle diverse condizioni che lanciano o meno una routine o impongono l’esecuzione di un ciclo invece di un altro, l’intercettazione degli errori risulta piuttosto laboriosa. Un certo sforzo richiede anche la ricerca, mediante l’help in linea, delle funzioni che svolgono una certa funzione. Ad esempio la funzione SMSRM consente di trasferire il contenuto di un SMS in un array di testo. smsrm Read Short Message Service (SMS) Message Data int smsrm ( char *msgData, int msgDataSize, int msgSlotNumber ); Return Value 0 Failure to read SMS message > 0 Successfull read of SMS message (size of SMS message) Parameters msgData Read SMS message data msgDataSize Number of bytes of SMS message data to read msgSlotNumber Slot number to read SMS message data from

La funzione MCMP consente di confrontare due buffer che contengono rispettivamente, ad esempio, il messaggio SMS ricevuto e un codice sotto forma di testo ( all’atto della ricezione di un SMS, per comprendere il comando da eseguire, tale testo viene confrontato con tutti quelli programmati) . Mcmp Memcmp - compares two buffers of a specified length for equality char *mcmp(char *Buf1,char *Buf2,int count); Return Value Returns >0 if Buf1 > Buf2 <0 if Buf1 < Buf2 0 if Buf1 == Buf2

Numerose sono le funzioni utilizzate nel programma: per una analisi più approfondita si rimanda all’help in linea dell’ambiente di sviluppo. Si riporta il codice sorgente completo caricato nel processore del modulo che ha il compito di interagire con l’interfaccia radio.

23

/* SISTEMA DI CONTROLLO GSM */ /* AREA DI PROGETTO */ /* LAZZARI MATTEO */ /* TUTOR PROF. ZANIOL ITALO */ char testo[160]; /* variabili globali */ char number_sms[160]; main () { int chiamata=0,conf,pos; /* variabili locali */ int nuovosms=29; int STATO_RETE=10; int i,val; char zero[160]= "0" ; /* Configura variabili*/ char uno[160]= "1" ; char due[160]= "2" ; char tre[160]= "3" ; char quattro[160]= "4" ; char ricall[2]; char parole1[150]; char parole[150]; char numero[16]; char sms_num[16]; char trasm0[2]= "0" ; char trasm1[2]= "1" ; char trasm2[2]= "2" ; char trasm3[2]= "3" ; char trasm4[2]= "4" ; char trasm5[2]= "5" ; char trasm6[2]= "6" ; char trasm7[2]= "7" ; char trasm8[2]= "8" ; char trasm9[2]= "9" ; char cinque[160]= "5" ; char sei[160]= "6" ; char sette[160]= "7" ; char otto[160]= "8" ; char nove[160]= "9" ; prs (0); utc (1,3,0); /*apri porta seriale a 9600bit/sec)*/ io (2,2,1); /*accendi diodo segnalazione funzione per 5 secondi */ io (1,2,1); dlys (5); io (1,2,0); for (i=0;i<20;i++) { val= gtb (STATO_RETE); /*controlla connessione alla rete*/ if (val==1) { break ; /*esci dal ciclo*/ } dlys (2); /*attesa 2 secondi*/ } for (;;) /*ciclo infinito*/ { if ( gtf (nuovosms)) /*controlla se c’è chiamata */ { chiamata=1; /*segnala ricevuto sms*/ } if (chiamata==1) /*se ricevuto sms*/ { chiamata=0; /*azzera chiamate*/

24

atcrt (); /*apri canale AT*/ pos= smsrs (); /*rileva posizione sms*/ smsrm(testo,160,pos); /*copia sms in array testo*/ sms_num = smsra (number_sms, 160, pos); conf= mcmp(testo,zero,1); /*ricevuto 0? */ if (conf==0) { io (1,2,1); /*se si accendi ld1*/ temperatura(); /*chiama routine che invia temperatura*/ smsd(pos); /*cancella sms*/ io (1,2,0); /*spegni led*/ } conf= mcmp(testo,uno,1); if (conf==0) { io (1,2,1); /*se si accendi ld1*/ richiesta(); /*chiama routine che richiede stato*/ smsd(pos); /*cancella sms*/ io (1,2,0); /*spegni led*/ } conf= mcmp(testo,due,1); if (conf==0) { io (1,2,1); /*se si accendi ld1*/ attiva(); /*chiama routine che attiva periferica*/ smsd(pos); /*cancella sms*/ io (1,2,0); /*spegni led*/ } conf= mcmp(testo,tre,1); if (conf==0) { io (1,2,1); /*se si accendi ld1*/ disattiva(); /*disattiva periferica*/ smsd(pos); /*cancella sms*/ io (1,2,0); /*spegni led*/ } conf= mcmp(testo,quattro,1); if (conf==0) { uts (trasm4,1); /*trasmetti codice quattro al PIC*/ dlys (1); /*ritardo*/ io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); conf= mcmp(testo+2,zero,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm0,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,uno,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm1,1); /*trasmetti al PIC*/

25

} conf= mcmp(testo+2,due,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm2,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,tre,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm3,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,quattro,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm4,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,cinque,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm5,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,sei,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm6,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,sette,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm7,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,otto,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm8,1); /*trasmetti al PIC*/ } conf= mcmp(testo+2,nove,1); /*confronta testo ricevuto*/ if (conf==0) /*invia decine*/ { uts (trasm9,1); /*trasmetti al PIC*/ } dlys (1); /*ritardo*/ io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); conf= mcmp(testo+3,zero,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm0,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,uno,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm1,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,due,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm2,1); /*trasmetti al PIC*/

26

} conf= mcmp(testo+3,tre,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm3,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,quattro,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm4,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,cinque,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm5,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,sei,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm6,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,sette,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm7,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,otto,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm8,1); /*trasmetti al PIC*/ } conf= mcmp(testo+3,nove,1); /*confronta testo ricevuto*/ if (conf==0) /*invia unità*/ { uts (trasm9,1); /*trasmetti al PIC*/ } io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); io (1,2,1); dlys (1); io (1,2,0); smsd(pos); } prs (1); atdst (); } } } /*----------------------------------------------*/ /* routine che invia al PIC uno 0 attende */ /* di ricevere la temperatura e invia sms */

27

/*----------------------------------------------*/ temperatura() { int i,val=0; char trasm[2]= "0" ; char btemp [160]= "TEMPERATURA = GRADI CENTIGRADI" ; char ricevuto[2]; uts (trasm,1); /*trasmetti zero al PIC*/ for (i=0;i<20;i++) /*attendi risposta dal pic*/ { val= utr (ricevuto,2); /*controlla se ricevuto 2 byte*/ if (val) /*se ricwvuto dato invia sms*/ { if (ricevuto[0]==0) { sncpy (btemp + 14, "0" , 1); } if (ricevuto[0]==1) { sncpy (btemp + 14, "1" , 1); } if (ricevuto[0]==2) { sncpy (btemp + 14, "2" , 1); } if (ricevuto[0]==3) { sncpy (btemp + 14, "3" , 1); } if (ricevuto[0]==4) { sncpy (btemp + 14, "4" , 1); } if (ricevuto[0]==5) { sncpy (btemp + 14, "5" , 1); } if (ricevuto[0]==6) { sncpy (btemp + 14, "6" , 1); } if (ricevuto[0]==7) { sncpy (btemp + 14, "7" , 1); } if (ricevuto[0]==8) { sncpy (btemp + 14, "8" , 1); } if (ricevuto[0]==9) { sncpy (btemp + 14, "9" , 1); } if (ricevuto[1]==0) { sncpy (btemp + 15, "0" , 1); } if (ricevuto[1]==1) { sncpy (btemp + 15, "1" , 1); } if (ricevuto[1]==2) { sncpy (btemp + 15, "2" , 1); }

28

if (ricevuto[1]==3) { sncpy (btemp + 15, "3" , 1); } if (ricevuto[1]==4) { sncpy (btemp + 15, "4" , 1); } if (ricevuto[1]==5) { sncpy (btemp + 15, "5" , 1); } if (ricevuto[1]==6) { sncpy (btemp + 15, "6" , 1); } if (ricevuto[1]==7) { sncpy (btemp + 15, "7" , 1); } if (ricevuto[1]==8) { sncpy (btemp + 15, "8" , 1); } if (ricevuto[1]==9) { sncpy (btemp + 15, "9" , 1); } smss(number_sms,btemp,145, slen (number_sms), slen (btemp)); val=0; io (1,1,1); /*accendi led1 per 2 secondi*/ dlys (2); io (1,1,0); break ; } dlys (1); /*attesa 1 secondi*/ } } /*----------------------------------------------*/ /* routine che invia al PIC un 1 attende */ /* di ricevere informazione e invia sms */ /*----------------------------------------------*/ richiesta() { int ii,val1=0; char trasm1[2]= "1" ; char risp1 [160]= "Periferica off" ; char risp2 [160]= "Periferica on" ; char ricevuto1[2]; atcrt (); /*apri canale AT*/ uts (trasm1,1); /*trasmetti uno al PIC*/ for (ii=0;ii<20;ii++) /*attendi risposta dal pic*/ { val1= utr (ricevuto1,1); /*controlla se ricevuto 1 byte*/ if (val1) /*se ricwvuto dato invia sms*/ { if (ricevuto1[0]==0) { smss(number_sms,risp1,145, slen (number_sms), slen (risp1)); } if (ricevuto1[0]==1) { smss(number_sms,risp2,145, slen (number_sms), slen (risp2)); } val1=0; io (1,1,1); /*accendi led1 per 2 secondi*/

29

dlys (2); io (1,1,0); break ; } dlys (1); /*attesa 1 secondi*/ } } /*----------------------------------------------*/ /* routine che invia al PIC un 2 */ /* attiva periferica */ /*----------------------------------------------*/ attiva() { char trasm2[2]= "2" ; uts (trasm2,1); /*trasmetti due al PIC*/ io (1,1,1); /*accendi led1 per 2 secondi*/ dlys (2); io (1,1,0); } /*----------------------------------------------*/ /* routine che invia al PIC un 3 */ /* disattiva periferica */ /*----------------------------------------------*/ disattiva() { char trasm3[2]= "3" ; uts (trasm3,1); /*trasmetti due al PIC*/ io (1,1,1); /*accendi led1 per 2 secondi*/ dlys (2); io (1,1,0); } /* ***** FINE ****** */

Alcune routine del Pic

;***********ROUTINE INVIA TEMPERATURA AL MODULO GSM ******************* INV_TEMP MOVF TEL_H,0 ;sposta il valore di tel_h in dato;decine MOVWF DATO CALL SER_TX ;invia il valore di dato tramite seriale MOVF TEL_L,0 ;sposta il valore di tel_l in dato;unità MOVWF DATO CALL SER_TX CLRF DATO RETURN

Con la seguente routine il Pic invia, tramite seriale, al modulo GSM i valori di temperatura letti dal sensore di temperatura e convertiti in codice BCD. Al modulo prima arrivano le decine e poi le unità ;**************ROUTINE INPOSTA TEMPERATURA SU RICHI ESTA GSM******************* PLUTO BTFSS PIR1,5 ;CONTROLLA SE ARRIVATO DATO SU PORTA SERIALE GOTO PLUTO MOVF RCREG,0 MOVWF DATO ;SE SI, SALVA IN DATO BCF PIR1,5 MOVF DATO,0 ;MASHERA BIT NON VALIDI ANDLW 0X0F ;CONVERTE DA ASCII A DECIMALE MOVWF DECINE2 ;PRONTO PER ESSERE VISALIZZATO PLUTO2 BTFSS PIR1,5 ;RICEZIONE UNITà

30

GOTO PLUTO2 MOVF RCREG,0 MOVWF DATO BCF PIR1,5 MOVF DATO,0 ANDLW 0X0F MOVWF UNITA2 MOVF DECINE2,W ;CONVERTI DATO IN BINARIO PER CONTROLLO MOVWF CONFRONT ;TEMPERATURA BCF STATUS,0 RLF CONFRONT,F RLF CONFRONT,F RLF CONFRONT,F MOVF DECINE2,W MOVWF DECINE4 BCF STATUS,0 RLF DECINE4,F MOVF DECINE4,W ADDWF CONFRONT,F MOVF UNITA2,W ADDWF CONFRONT,F MOVLW D'1' ;PREDISPONI PER ATTIVARE IMPIANTO MOVWF ONOFF2 RETURN

In questa routine il pic controlla continuamente se gli arriva un dato da porta seriale per poi trasferire ciò che ha ricevuto in due registri: Decine2,Unita2 utilizzati per la gestione del display. ;************ROUTINE VERIFICA SE RICEVUTO DATO DA P ORTA SERIALE SER_RX BTFSS PIR1,5 ;RICEVUTO DATO? RETURN ;SE NO, ESCI MOVF RCREG,0 ;ALTRIMENTI SALVA SU MEMORIA MOVWF DATO BCF PIR1,5 ;AZZERA FLAG RETURN ;*************ROUTINE TRASMISSIONE DI UN BYTE CONTE NUTO IN DATO************ SER_TX MOVF DATO,0 MOVWF TXREG ;INVIA DATO RETURN CONTROLTEMP MOVF PROVA,0 SUBWF CONFRONT,0 BTFSS STATUS,0 GOTO BOO1 BSF PORTE,0 GOTO BOO BOO1 BCF PORTE,0 BOO BTFSC STATUS,2 BCF PORTE,0 RETURN

Semplicissima routine ma fondamentale. Il registro ‘prova’ contenente la temperatura reale presente nell’ambiente, viene confrontato con il set point che si trova in ‘confront’; se quest’ultima risulta superiore si diattiva il carico altrimenti lo dattiva.

31

Istruzioni d’uso Di seguito si riportano i codici da inviare tramite SMS per la gestione del sistema:

• Richiesta temperatura 0 • Richiesta stato periferica 1 • Attivazione periferica 2 • Disattiva periferica 3 • Imposta temperatura di riferimento 4 xx dove xx è il valore che si vuole impostare

N.B. Per le funzioni 0 e 1il modulo risponde a qualsiasi cellulare chiamante e non a quelli con numero preimpostato. Esso è in grado di estrapolare, dal messaggio ricevuto, il numero del cellulare chiamante. Nella pagina seguente vengono riportate le schermate di alcuni messaggi ricevuti

Il display del telefono dopo aver ricevuto la temperatura dal modulo

32

Il display dopo aver ricevuto lo stato della periferica

Gestione del sistema localmente Quando si alimenta il termostato, il controllo è impostato off. Sul display appare la temperatura dell’ambiente e il valore preimpostato di set-point (20 ˚C) ( valore di default ).

La temperatura di set-point si può regolare localmente tramite i due pulsanti presenti sulla demoboard oppure tramite cellulare; in quest’ultimo

33

caso, una volta ricevuta la temperatura di nuovo set point, il controllo automatico di temperatura è avviato. Localmente l’attivazione viene effettuata tramite pulsante ON/OFF. Una volta attivato il controllo, il microcontrollore confronta la temperatura dell’ambiente con quella di set-point; se la temperatura ambientale è inferiore viene attivato un sistema di riscaldamento che si disattiva un volta raggiunta la temperatura predefinita. Per controllare il generatore non è stato previsto un relè; un led simula lo stato di questo attuatore. Inoltre è presente un ingresso di allarme, anche in questo caso simulato da un pulsante, e un segnalatore ottico a led. Tuttavia nulla toglie di inserire al posto del pulsante un sensore e al posto del led una sirena. Quando si attiva l’allarme, il sistema invia un messaggio al numero di telefono preimpostato che, tramite SMS, segnala una situazione di allarme.

Approfondimenti teorici

Telefonia mobile

Introduzione: La telefonia mobile e in particolar modo il sistema radiomobile, ha avuto, dagli anni novanta a oggi, una enorme evoluzione tanto che al giorno d’oggi gli utenti di telefonia mobile superano quelli di telefonia fissa. Struttura di un sistema cellulare: Un sistema radiomobile terrestre deve contemporaneamente soddisfare 2 esigenze:

• Garantire una adeguata copertura radio sul territorio di competenza • Servire un gran numero di utenti in relazione alla richiesta effettiva del servizio

Per soddisfare queste esigenze si utilizza il concetto di riutilizzo delle frequenze. Il riutilizzo delle frequenze consiste nel riutilizzare le stesse frequenze a patto che la distanza tra le due antenne sia tale da non creare interferenze fra loro. Per far questo il sistema radiomobile utilizza un sistema a celle dove ciascuna cella utilizza frequenze diverse da quelle contingue e celle non contigue possono riutilizzare la stessa frequenza. In realtà le celle non sono mai tutte uguali tra loro ma dipendono dalla conformazione del suolo e dal livello di utenze che si vuole assegnare a ciascuna

cella. Per irradiare il segnale all’interno di una cella si utilizzano due metodi:

34

• Center excited: essa consiste nel porre un’antenna omnidirezionale al centro di una cella.

• Cornerexcited: essa consiste nel porre una serie di antenne all’incrocio di tre celle svasando la direzione dei vari segnali di 120°.

FDMA-TDMA Per servire all’interno di ogni cella un numero elevato di utenti in presenza di un numero contenuto di canali radio, viene utilizzata la tecnica FDMA-TDMA. Con tale tecnica (tecnica di accesso multiplo a divisione di frequenza e a divisione di tempo) la banda radio a disposizione, ad esempio 890÷915 MHz, viene suddivisa in n canali e ogni canale viene suddiviso in m slot utilizzando una multiplazione TDM. In pratica ogni telefono utilizza,durante la comunicazione, un canale solo per la durata di uno slot. Ogni canale ha a disposizione otto slot.

35

Come evidenziato in figura, in analogia al sistema TDM telefonico, le trame sono poi organizzate in multitrame, supertrame e ipertrame per far viaggiare le informazioni all’interno della rete mobile e per l’interfacciamento con la rete fissa. GSM900 Il sistema GSM utilizza la banda 890÷915 MHz per l’uplink e la banda 935÷960 MHz per il downlink; quindi ogni banda radio dispone di 45 MHz. Questa banda viene suddivisa in 124 canali di 200 KHz, ciascuno dei quali è in grado di portare fino a otto segnali numerici multiplati con tecnica TDM

GSM1800 Analogo al GSM900 con l’unica differenza che la banda utilizzata si trova a 1800 MHz con il vantaggio di utilizzare una banda più ampia rispetto al fratello minore e quindi disporre di un maggior numero di canali radio. La modulazione utilizzata è una variante della modulazione a spostamento di frequenza ( FSK ). Rispetto a questa, filtri formatori limitano la larghezza di banda del segnale modulato in modo da evitare interferenze tra canali radio adiacenti ed aumentare l’efficienza spettrale vale a dire il numero di bit trasmessi per ogni Hz di banda.