Interfață modul GSM cu microcontroler pic

Modulele GSM sunt fascinante de utilizat mai ales atunci când proiectul nostru necesită acces la distanță. Aceste module ar putea face toate acțiunile pe care le-ar putea face telefonul nostru mobil normal, cum ar fi efectuarea / primirea unui apel, trimiterea / primirea unui SMS, conectarea la internet utilizând GPRS etc. apeluri mobile. Acest lucru va deschide ușile multor proiecte creative dacă ar putea fi interfațat cu un microcontroler. Prin urmare, în acest tutorial vom învăța cum putem interfața modulul GSM (SIM900A) cu microcontrolerul nostru PIC și îl vom demonstra efectuând și primind apeluri folosind modulul GSM. L-am interfațat anterior cu Arduino și Raspberry Pi pentru apeluri și mesaje:

Apelați și trimiteți mesaje folosind modulul Arduino și GSM
Apelați și trimiteți text utilizând modulul Raspberry Pi și GSM

Materiale necesare:

Microcontroler PIC (PIC16F877A)
Modul GSM (SIM900 sau orice altul)
Conectarea firelor
Adaptor 12V
PicKit 3

Modul GSM:

Modulul GSM poate fi utilizat chiar și fără niciun microcontroler folosind modul de comandă AT. Așa cum se arată mai sus, modulul GSM vine cu un adaptor USART care poate fi interfațat direct la computer utilizând un modul MAX232 sau pinii Tx și Rx pot fi utilizați pentru a-l conecta la un microcontroler. De asemenea, puteți observa ceilalți pini, cum ar fi MIC +, MIC-, SP +, SP- etc., unde se poate conecta un microfon sau un difuzor. Modulul poate fi alimentat de un adaptor de 12V printr-o mufă normală de tip DC.

Introduceți cartela SIM în fanta modulului și porniți-o, ar trebui să observați un LED de alimentare aprins. Acum așteptați un minut cam cam așa și ar trebui să vedeți un LED roșu (sau orice altă culoare) care să clipească o dată la fiecare 3 secunde. Aceasta înseamnă că modulul dvs. a fost capabil să stabilească conexiunea cu cartela SIM. Acum puteți continua să vă conectați modulul cu telefonul sau orice microcontroler.

Comunicarea cu modulul GSM folosind comenzile AT:

Așa cum ați fi putut ghici, modulul GSM poate comunica prin comunicare serială și nu poate înțelege decât o singură limbă și anume „ comenzi AT ”. Orice ați dori să spuneți sau să cereți modulului GSM ar trebui să fie doar prin comenzi AT. De exemplu, dacă doriți să știți dacă modulul dvs. este activ. Ar trebui să cereți (să trimiteți) o comandă precum „AT”, iar modulul dvs. va răspunde „OK”.

Aceste comenzi AT sunt bine explicate în foaia sa tehnică și pot fi găsite aici în foaia sa tehnică oficială. Bine! Bine! Este o foaie de date de 271 pagini și s-ar putea să durați câteva zile pentru a le citi. Așa că am dat câteva dintre cele mai importante comenzi AT de mai jos, pentru ca tu să poți opera acest lucru în curând.

LA	Răspunde cu OK pentru Confirmare
AT + CPIN?	Verificați calitatea semnalului
AT + COPS?	Găsiți numele furnizorului de servicii
ATD96XXXXXXXX;	Apelați la numărul specific, se termină cu punct și virgulă
AT + CNUM	Găsiți numărul de cartelă SIM (s-ar putea să nu funcționeze pentru unele cartele SIM)
LA O	Răspundeți la apelul primit
ATH	Închideți apelul primit curent
AT + COLP	Afișați numărul de apel primit
AT + VTS = (număr)	Trimiteți numărul DTMF. Puteți utiliza orice număr de pe tastatura mobilă pentru (număr)
AT + CMGR	AT + CMGR = 1 citește mesajul în prima poziție
AT + CMGD = 1	Ștergeți mesajul în prima poziție
AT + CMGDA = ”DEL ALL”	Ștergeți toate mesajele din SIM
AT + CMGL = ”ALL”	Citiți toate mesajele din SIM
AT + CMGF = 1	Setați configurația SMS. „1” este pentru modul numai text
AT + CMGS = „+91 968837XXXX” > CircuitDigest Text	Trimite SMS la un anumit număr aici 968837XXXX. Când vedeți „>” începeți să introduceți textul. Apăsați Ctrl + Z pentru a trimite textul.
AT + CGATT?	Pentru a verifica conexiunea la internet pe cartela SIM
AT + CIPSHUT	Pentru a închide conexiunea TCP, adică pentru a deconecta Internetul
AT + CSTT = „APN”, „nume de utilizator”, „Trecere”	Conectați-vă la GPRS cu cheia APN și Pass. Poate fi obținut de la furnizorul de rețea.
AT + CIICR	Verificați dacă cartela SIM are pachet de date
AT + CIFSR	Obțineți IP-ul rețelei SIM
AT + CIPSTART = „TCP”, „SERVER IP”, „PORT”	Folosit pentru a seta o conexiune IP TCP
AT + CIPSEND	Această comandă este utilizată pentru a trimite date către server

Diagrama circuitului:

Schema de conectare pentru modulul de interfațare GSM cu microcontroler PIC este prezentată mai jos.

Am interfațat pur și simplu pinii Tx și Rx ai modulului GSM cu pinii Rx și Tx ai PIC MCU PIC16F877A. Aceasta va stabili o conexiune serială între ambele. De asemenea, așa că nu uitați să comunicați atât modulul GSM, cât și modulul PIC. De asemenea, am folosit un afișaj LCD pentru a cunoaște starea modulului nostru GSM. Odată ce conexiunile sunt terminate, hardware-ul dvs. va arăta ca ceva mai jos.

Placa PIC Perf a fost realizată pentru seria noastră de tutoriale PIC, în care am învățat cum să folosim microcontrolerul PIC. S-ar putea să doriți să reveniți la acele tutoriale PIC Microcontroller care utilizează MPLABX și XC8 dacă nu știți cum să ardeți un program folosind Pickit 3, deoarece voi sări peste toate acele informații de bază.

Programarea microcontrolerului PIC:

Programul complet pentru acest proiect poate fi găsit în partea de jos a acestui tutorial. Aici voi explica câteva funcții importante și bucăți de cod. Acest program are, de asemenea, un cod LCD care provine de la interfața LCD cu microcontroler PIC, puteți vizita acel tutorial dacă sunteți curios să știți cum LCD poate fi utilizat cu microcontrolerul PIC.

Așa cum am spus mai devreme, vom comunica între PIC și GSM folosind comenzi AT prin modul Serial de comunicare. Deci, mai întâi trebuie să inițializăm modulul de comunicare USART în microcontrolerul nostru PIC folosind Initialize _SIM900 (); funcţie. În interiorul acestei funcții declarăm pinii Tx și RX și inițializăm recepția și transmisia asincronă la 9600 baud rate și modul 8 biți.

// *** Initialize UART for SIM900 ** // void Initialize_SIM900 (void) {// **** Setarea pinilor I / O pentru UART **** // TRISC6 = 0; // TX Pin setat ca ieșire TRISC7 = 1; // RX Pin set ca intrare // ________ I / O pin set __________ // / ** Inițializați registrul SPBRG pentru rata de baud necesară și setați BRGH pentru baud_rate rapid ** / SPBRG = 129; // SIM900 funcționează la 9600 Baud rate deci 129 BRGH = 1; // pentru baud_rate mare // _________ Sfârșitul setării baud_rate _________ // // **** Activați portul serial asincron ******* // SYNC = 0; // SPEN asincron = 1; // Activați pinii portului serial // _____ Portul serial asincron activat _______ // // ** Vă pregătiți pentru transmisie și recepție ** // TXEN = 1; // activați transmisia CREN = 1; // activați recepția // __ Modulul UART este gata de transmisie și recepție __ // // ** Selectați modul 8 biți ** // TX9 = 0; // recepție pe 8 biți selectată RX9 = 0;// Mod de recepție pe 8 biți selectat // __ Mod de 8 biți selectat __ //} // ________ Modul UART Initializat __________ //

Acum trebuie să citim și să scriem informații din / către modulul nostru GSM. Pentru aceasta folosim funcțiile _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Aceste funcții utilizează registrul tampon de transmisie și recepție, cum ar fi TXREG și RCREG, pentru a citi sau scrie date în serie.

// ** Funcția de a trimite un octet de dată către UART ** // void _SIM900_putch (char bt) {while (! TXIF); // țineți programul până când bufferul TX este liber TXREG = bt; // Încărcați bufferul transmițătorului cu valoarea primită} // _____________ Sfârșitul funcției ________________ // // ** Funcția pentru a obține un octet de dată din UART ** // char _SIM900_getch () {if (OERR) // verificați eroarea { CREN = 0; // Dacă eroare -> Resetați CREN = 1; // Dacă eroare -> Resetare} în timp ce (! RCIF); // țineți programul până când bufferul RX este returnat gratuit RCREG; // primiți valoarea și trimiteți-o la funcția principală} // _____________ Sfârșitul funcției ________________ // // ** Funcția de a converti șirul în octet ** // anulați SIM900_send_string (char * st_pt) {while (* st_pt) // dacă există este un caracter _SIM900_putch (* st_pt ++);// procesează-l ca date de octeți} // ___________ Sfârșitul funcției ______________ // // ** Sfârșitul codurilor modificate ** // void _SIM900_print (nesemnat const char * ptr) {while (* ptr! = 0) {_SIM900_putch (* ptr ++); }

Funcțiile de mai sus sunt universale și nu trebuie modificate pentru nicio aplicație. Li s-a explicat doar pentru a da o introducere dură. Vă puteți scufunda adânc în ele dacă doriți prin înțelegere.

Acum, în funcția noastră principală, inițializăm conexiunea USART și verificăm dacă putem primi un „OK” când trimitem „AT” utilizând linia de cod de mai jos

faceți {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modulul nu a fost găsit"); } while (! SIM900_isStarted ()); // așteptați până când GSM va trimite înapoi „OK” Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modul detectat"); __delay_ms (1500);

Funcția SIM900_isStarted (); va trimite „AT” la GSM și așteaptă răspunsul „OK” de la acesta. Dacă da, va întoarce 1 altul 0;

Dacă modulul nu este detectat sau dacă există vreo problemă de conectare, atunci LCD-ul va afișa „Module not found”, altfel va afișa modulul este detectat și vom trece la pasul următor unde, verificăm dacă cartela SIM poate fi detectată de mai jos linie de cod.

/ * Verificați dacă este detectată cartela SIM * / faceți {Lcd_Set_Cursor (2,1); Lcd_Print_String („SIM nu a fost găsit”); } while (! SIM900_isReady ()); // așteptați până când GSM va trimite înapoi "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String („SIM detectat”); __delay_ms (1500);

Funcția SIM900_isReady () va trimite „AT + CPIN?” către GSM și așteaptă răspunsul „+ CPIN: GATA” de la acesta. Dacă da, va întoarce 1 altul 0;

Dacă se găsește o cartelă SIM, vom primi un SIM detectat afișat pe ecranul LCD. Apoi, putem încerca să efectuați un apel folosind comanda „ ATD mobilenumber ; ”. Aici, ca exemplu, mi-am folosit numărul ca ATD93643159XX;. Trebuie să înlocuiți numărul de telefon respectiv.

/ * Faceți un apel telefonic * / faceți {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Aici apelăm la numărul 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String („Plasarea apelului….”); } while (_SIM900_waitResponse ()! = SIM900_OK); // așteptați până când ESP trimite înapoi „OK” Lcd_Set_Cursor (1,1); Lcd_Print_String („Apel efectuat….”); __delay_ms (1500);

Odată ce apelul este plasat, ecranul LCD va afișa Apelul efectuat și ar trebui să primiți un apel primit către acel număr specificat.

De asemenea, puteți apela la numărul de telefon mobil conectat la modulul GSM și puteți primi notificări despre acest lucru pe ecranul LCD y folosind codul de mai jos

while (1) {if (_SIM900_waitResponse () == SIM900_RING) // Verificați dacă există un apel primit {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Apel primit !!."); }}

Când modulul GSM detectează un apel primit, acesta va afișa Apel primit pe a doua linie a modulului LCD. Funcția _SIM900_waitResponse () va verifica datele primite de la modulul GSM. Când primește SIM900_RING, care este echivalent cu „RING” datorită waitResponce () , vom afișa starea „Apel primit”.

Puteți crea propriile funcții ca aceasta pentru a efectua aproape toate tipurile de activări utilizând modulul GSM. Dacă doriți să aveți lucruri codificate, puteți utiliza pur și simplu funcția __SIM900_print () pentru a trimite orice comandă AT de genul acesta mai jos.

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

Amintiți-vă că toate comenzile dvs. trebuie urmate cu „\ r \ n” pentru a indica faptul că comanda se termină.

Simulare:

După ce ați înțeles cum funcționează programul, puteți încerca să simulați și să faceți modificări pentru a se potrivi nevoilor dvs. Simularea vă va economisi mult timp. Simularea se face folosind Proteus și arată ca mai jos.

După cum puteți vedea, am folosit opțiunea terminal virtual în Proteus pentru a verifica dacă programul răspunde așa cum era de așteptat. Putem alimenta valorile prin caseta de dialog pop-up. De exemplu, de îndată ce apăsăm alergare, va apărea o fereastră de dialog neagră ca mai sus și va afișa AT, aceasta înseamnă că a trimis modulul GSM AT, acum putem răspunde la PIC tastând în casetă „OK” și apăsând Enter iar PIC va răspunde la aceasta. În mod similar, putem încerca toate comenzile AT.

Efectuarea și primirea de apeluri folosind GSM și PIC:

Odată ce ați înțeles cum funcționează codul și hardware-ul, pur și simplu încărcați programul de mai jos pe PIC și porniți modulul. LCD-ul dvs. trebuie să afișeze „Module Detected”, „SIM detectat” și „Call Placed” dacă totul funcționează bine. După ce vedeți „Apelul efectuat”, veți primi un apel primit la numărul specificat în program.

De asemenea, puteți încerca să apelați numărul prezent în modulul GSM, iar LCD-ul dvs. va afișa „Apel primit” pentru a indica faptul că SIM este apelat.

Lucrarea completă a proiectului este prezentată în videoclipul de mai jos. Sper că ai înțeles proiectul și ți-a plăcut să îl faci. Dacă aveți vreo problemă în a face ca lucrurile să funcționeze, postați întrebarea dvs. în secțiunea de comentarii sau pe forumurile noastre și vă voi ajuta cu plăcere.