Modulo GSM interfacciato con microcontrollore pic

I moduli GSM sono affascinanti da usare soprattutto quando il nostro progetto richiede l'accesso remoto. Questi moduli possono eseguire tutte le azioni che il nostro normale telefono cellulare potrebbe eseguire, come effettuare / ricevere una chiamata, inviare / ricevere un SMS, connettersi a Internet tramite GPRS ecc. È inoltre possibile collegare un normale microfono e altoparlante a questo modulo e conversare sul proprio chiamate mobili. Questo aprirà le porte a molti progetti creativi se potesse essere interfacciato con un microcontrollore. Quindi in questo tutorial impareremo come possiamo interfacciare il modulo GSM (SIM900A) con il nostro microcontrollore PIC e lo dimostreremo effettuando e ricevendo chiamate utilizzando il modulo GSM. Lo abbiamo precedentemente interfacciato con Arduino e Raspberry Pi per chiamate e messaggi:

Chiama e invia messaggi utilizzando Arduino e il modulo GSM
Chiama e invia SMS utilizzando Raspberry Pi e il modulo GSM

Materiali richiesti:

Microcontrollore PIC (PIC16F877A)
Modulo GSM (SIM900 o qualsiasi altro)
Cavi di collegamento
Adattatore 12V
PicKit 3

Modulo GSM:

Il modulo GSM può essere utilizzato anche senza microcontrollore utilizzando la modalità di comando AT. Come mostrato sopra, il modulo GSM viene fornito con un adattatore USART che può essere interfacciato direttamente al computer utilizzando un modulo MAX232 oppure i pin Tx e Rx possono essere utilizzati per collegarlo a un microcontrollore. Puoi anche notare gli altri pin come MIC +, MIC-, SP +, SP- ecc. Dove è possibile collegare un microfono o un altoparlante. Il modulo può essere alimentato da un adattatore 12V tramite un normale jack barilotto CC.

Inserisci la tua scheda SIM nello slot del modulo e accendilo, dovresti notare un LED di alimentazione che si accende. Ora aspetta circa un minuto e dovresti vedere un LED rosso (o di qualsiasi altro colore) lampeggiare una volta ogni 3 secondi. Ciò significa che il modulo è stato in grado di stabilire una connessione con la scheda SIM. Ora puoi procedere con il collegamento del tuo modulo con il telefono o qualsiasi microcontrollore.

Comunicare con il modulo GSM utilizzando i comandi AT:

Come avrete intuito, il modulo GSM può comunicare attraverso la comunicazione Seriale e potrebbe comprendere solo una lingua e cioè i “ comandi AT ”. Qualunque cosa tu voglia dire o chiedere al modulo GSM dovrebbe essere solo tramite comandi AT. Ad esempio, se vuoi sapere se il tuo modulo è attivo. Dovresti chiedere (inviare) un comando come "AT" e il tuo modulo risponderà "OK".

Questi comandi AT sono ben spiegati nella sua scheda tecnica e possono essere trovati qui nella sua scheda tecnica ufficiale. Va bene! Va bene! È un datasheet di 271 pagine e potrebbero essere necessari giorni per leggerli. Quindi ho fornito alcuni comandi AT più importanti di seguito affinché tu possa farlo funzionare presto.

A	Risponde con OK per il riconoscimento
AT + CPIN?	Verificare la qualità del segnale
AT + POLIZIOTTI?	Trova il nome del fornitore di servizi
ATD96XXXXXXXX;	Chiamata al numero specifico, termina con punto e virgola
AT + CNUM	Trova il numero della scheda SIM (potrebbe non funzionare per alcune SIM)
ATA	Rispondi alla chiamata in arrivo
ATH	Riaggancia la chiamata in arrivo corrente
AT + COLP	Mostra il numero della chiamata in arrivo
AT + VTS = (numero)	Invia numero DTMF. È possibile utilizzare qualsiasi numero sulla tastiera del cellulare per (numero)
AT + CMGR	AT + CMGR = 1 legge il messaggio in prima posizione
AT + CMGD = 1	Elimina messaggio in prima posizione
AT + CMGDA = "DEL TUTTO"	Elimina tutti i messaggi dalla SIM
AT + CMGL = "ALL"	Leggi tutti i messaggi dalla SIM
AT + CMGF = 1	Imposta la configurazione degli SMS. "1" è per la modalità solo testo
AT + CMGS = "+91 968837XXXX" > CircuitDigest Text	Invia SMS a un numero particolare qui 968837XXXX. Quando vedi ">" inizia a inserire il testo. Premi Ctrl + Z per inviare il testo.
AT + CGATT?	Per verificare la connessione a Internet sulla carta SIM
AT + CIPSHUT	Per chiudere la connessione TCP, ovvero disconnettersi da Internet
AT + CSTT = "APN", "username", "Pass"	Connettiti a GPRS con il tuo APN e pass key. Può essere ottenuto dal provider di rete.
AT + CIICR	Controlla se la scheda SIM ha un pacchetto dati
AT + CIFSR	Ottieni l'IP della rete SIM
AT + CIPSTART = "TCP", "SERVER IP", "PORT"	Utilizzato per impostare una connessione TCP IP
AT + CIPSEND	Questo comando viene utilizzato per inviare dati al server

Schema elettrico:

Di seguito è riportato lo schema di collegamento per l' interfacciamento del modulo GSM con il microcontrollore PIC.

Abbiamo semplicemente interfacciato i pin Tx e Rx del modulo GSM rispettivamente con i pin Rx e Tx del PIC MCU PIC16F877A. Questo stabilirà una connessione seriale tra entrambi. Inoltre, quindi non dimenticare di mettere a terra entrambi i moduli GSM e PIC. Abbiamo anche utilizzato un display LCD per conoscere lo stato del nostro modulo GSM. Una volta completate le connessioni, il tuo hardware apparirà come qualcosa di seguito.

La scheda PIC Perf è stata realizzata per la nostra serie di tutorial PIC, in cui abbiamo imparato a usare il microcontrollore PIC. Potresti voler tornare a quei tutorial sul microcontrollore PIC usando MPLABX e XC8 se non sai come masterizzare un programma usando Pickit 3, poiché salterò tutte quelle informazioni di base.

Programmazione del microcontrollore PIC:

Il programma completo per questo progetto può essere trovato in fondo a questo tutorial. Qui spiegherò alcune importanti funzioni e pezzi di codice. Questo programma ha anche un codice LCD che proveniva da Interfacing LCD with PIC Microcontroller, puoi visitare quel tutorial se sei curioso di sapere come LCD può essere utilizzato con il microcontroller PIC.

Come detto in precedenza, comunicheremo tra PIC e GSM utilizzando i comandi AT attraverso la modalità di comunicazione seriale. Quindi, prima dobbiamo inizializzare il modulo di comunicazione USART nel nostro microcontrollore PIC utilizzando Initialize _SIM900 (); funzione. All'interno di questa funzione dichiariamo i pin Tx e RX e inizializziamo la ricezione e la trasmissione asincrona a 9600 baud rate e modalità 8 bit.

// *** Inizializza UART per SIM900 ** // void Initialize_SIM900 (void) {// **** Impostazione dei pin I / O per UART **** // TRISC6 = 0; // Pin TX impostato come uscita TRISC7 = 1; // Pin RX impostato come input // ________ Pin I / O impostati __________ // / ** Inizializza il registro SPBRG per la velocità di trasmissione richiesta e imposta BRGH per velocità_baud veloce ** / SPBRG = 129; // SIM900 funziona a 9600 Baud rate quindi 129 BRGH = 1; // per baud_rate alto // _________ Fine impostazione baud_rate _________ // // **** Abilita porta seriale asincrona ******* // SYNC = 0; // SPEN asincrono = 1; // Abilita i pin della porta seriale // _____ Porta seriale asincrona abilitata _______ // // ** Prepariamo la trasmissione e la ricezione ** // TXEN = 1; // abilita la trasmissione CREN = 1; // abilita la ricezione // __ Modulo UART attivo e pronto per la trasmissione e la ricezione __ // // ** Seleziona la modalità a 8 bit ** // TX9 = 0; // Ricezione a 8 bit selezionata RX9 = 0;// Modalità di ricezione a 8 bit selezionata // __ Modalità a 8 bit selezionata __ //} // ________ Modulo UART inizializzato __________ //

Ora dobbiamo leggere e scrivere informazioni dal / al nostro modulo GSM. Per questo utilizziamo le funzioni _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Queste funzioni utilizzano il registro del buffer di trasmissione e ricezione come TXREG e RCREG per leggere o scrivere i dati in modo seriale.

// ** Funzione per inviare un byte di data a UART ** // void _SIM900_putch (char bt) {while (! TXIF); // tiene il programma finché il buffer TX è libero TXREG = bt; // Carica il buffer del trasmettitore con il valore ricevuto} // _____________ Fine della funzione ________________ // // ** Funzione per ottenere un byte di data da UART ** // char _SIM900_getch () {if (OERR) // verifica errori { CREN = 0; // Se errore -> Reimposta CREN = 1; // If error -> Reset} while (! RCIF); // trattiene il programma fino a quando il buffer RX è free return RCREG; // riceve il valore e lo invia alla funzione principale} // _____________ Fine della funzione ________________ // // ** Funzione per convertire la stringa in byte ** // void SIM900_send_string (char * st_pt) {while (* st_pt) // se presente è un carattere _SIM900_putch (* st_pt ++);// elaboralo come un byte di dati} // ___________ Fine della funzione ______________ // // ** Fine dei codici modificati ** // void _SIM900_print (unsigned const char * ptr) {while (* ptr! = 0) {_SIM900_putch (* ptr ++); }

Le funzioni di cui sopra sono universali e non devono essere modificate per nessuna applicazione. Sono stati spiegati solo per dare un'introduzione approssimativa. Puoi immergerti in profondità se vuoi attraverso la comprensione.

Ora all'interno della nostra funzione principale, inizializziamo la connessione USART e controlliamo se siamo in grado di ricevere un "OK" quando inviamo "AT" utilizzando la riga di codice sottostante

do {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modulo non trovato"); } while (! SIM900_isStarted ()); // aspetta che il GSM rispedisca "OK" Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modulo rilevato"); __delay_ms (1500);

La funzione SIM900_isStarted (); invierà "AT" al GSM e attende la risposta "OK" da esso. Se sì, restituirà 1 altrimenti 0;

Se il modulo non viene rilevato o se c'è qualche problema di connessione, il display LCD mostrerà "Modulo non trovato", altrimenti mostrerà Modulo rilevato e procedere al passaggio successivo in cui controlliamo se la scheda SIM può essere rilevata da quanto segue riga di codice.

/ * Controlla se la scheda SIM viene rilevata * / do {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM non trovata"); } while (! SIM900_isReady ()); // aspetta che il GSM rispedisca "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM rilevata"); __delay_ms (1500);

La funzione SIM900_isReady () invierà "AT + CPIN?" al GSM e attende la risposta "+ CPIN: READY" da esso. Se sì, restituirà 1 altrimenti 0;

Se viene rilevata una scheda SIM, verrà visualizzata la SIM rilevata sul display LCD. Quindi, possiamo provare a effettuare una chiamata utilizzando il comando “ ATD mobilenumber ; ". Qui come esempio ho usato il mio numero come ATD93643159XX;. Devi sostituire il tuo rispettivo numero di cellulare lì.

/ * Effettua una telefonata * / do {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Qui stiamo effettuando una chiamata al numero 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Placing Call…."); } while (_SIM900_waitResponse ()! = SIM900_OK); // aspetta che l'ESP rispedisca "OK" Lcd_Set_Cursor (1,1); Lcd_Print_String ("Call Placed…."); __delay_ms (1500);

Una volta effettuata la chiamata, il display LCD visualizzerà Chiamata effettuata e dovresti ricevere una chiamata in arrivo a quel numero specificato.

È inoltre possibile chiamare il numero di cellulare connesso al modulo GSM e ricevere una notifica sullo schermo LCD utilizzando il codice sottostante

while (1) {if (_SIM900_waitResponse () == SIM900_RING) // Controlla se c'è una chiamata in arrivo {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Chiamata in arrivo !!."); }}

Quando il modulo GSM rileva una chiamata in arrivo, visualizzerà Chiamata in arrivo sulla seconda riga del modulo LCD. La funzione _SIM900_waitResponse () verificherà i dati in arrivo dal modulo GSM. Quando riceve SIM900_RING, che è equivalente a "RING" a causa di waitResponce () , visualizzeremo lo stato "Chiamata in arrivo".

Puoi creare le tue funzioni come questa per eseguire quasi tutti i tipi di attivazioni utilizzando il modulo GSM. Se vuoi che le cose siano codificate, puoi semplicemente usare la funzione __SIM900_print () per inviare qualsiasi comando AT come questo sotto.

_SIM900_print ("AT + CPIN? \ R \ n");

Ricorda che tutto ciò che comandi dovrebbe essere seguito da "\ r \ n" per indicare che il comando sta terminando.

Simulazione:

Una volta compreso come funziona il programma, puoi provare a simulare e apportare modifiche per soddisfare le tue esigenze. La simulazione ti farà risparmiare molto tempo. La simulazione viene eseguita utilizzando Proteus e appare come sotto.

Come puoi vedere, abbiamo utilizzato l'opzione del terminale virtuale in Proteus per verificare se il programma risponde come previsto. Possiamo inserire i valori tramite la finestra di dialogo a comparsa. Ad esempio non appena premiamo run, apparirà una finestra di dialogo nera come sopra e visualizzerà AT, questo significa che ha inviato il modulo GSM AT, ora possiamo rispondere al PIC digitando nella casella "OK" e premere invio e il PIC risponderà ad esso. Allo stesso modo possiamo provare per tutti i comandi AT.

Effettuare e ricevere chiamate utilizzando GSM e PIC:

Una volta compreso come funzionano il codice e l'hardware, è sufficiente caricare il programma seguente su PIC e accendere il modulo. Il display LCD dovrebbe visualizzare "Modulo rilevato", "SIM rilevata" e "chiamata effettuata" se tutto funziona correttamente. Quando vedrai "Chiamata effettuata" riceverai una chiamata in arrivo al numero specificato nel programma.

Puoi anche provare a chiamare il numero presente nel modulo GSM e il tuo display LCD visualizzerà “Chiamata in arrivo” per indicare che la SIM è in fase di chiamata.

Il funzionamento completo del progetto è mostrato nel video sottostante. Spero che tu abbia capito il progetto e ti sia piaciuto farlo. Se hai problemi a far funzionare le cose, posta la tua domanda nella sezione commenti o sui nostri forum e sarò felice di aiutarti.