GSM-modul som grensesnitt med pic-mikrokontroller

GSM-moduler er fascinerende å bruke, spesielt når prosjektet vårt krever ekstern tilgang. Disse modulene kan utføre alle handlinger som vår vanlige mobiltelefon kan gjøre, som å ringe / motta et anrop, sende / motta en SMS, koble til internett ved hjelp av GPRS osv. Du kan også koble en vanlig mikrofon og høyttaler til denne modulen og snakke på mobilsamtaler. Dette vil åpne dører for mange kreative prosjekter hvis det kan grensesnittet med en mikrokontroller. Derfor vil vi i denne opplæringen lære hvordan vi kan grensesnitt GSM-modulen (SIM900A) med vår PIC-mikrokontroller, og vil demonstrere det ved å ringe og motta anrop ved hjelp av GSM-modul. Vi har tidligere grensesnittet med Arduino og Raspberry Pi for å ringe og sende meldinger:

Ring og melding ved hjelp av Arduino og GSM-modulen
Ring og tekst ved hjelp av Raspberry Pi og GSM-modulen

Nødvendige materialer:

PIC-mikrokontroller (PIC16F877A)
GSM-modul (SIM900 eller andre)
Koble ledninger
12V adapter
PicKit 3

GSM-modul:

GSM-modulen kan brukes selv uten mikrokontroller ved hjelp av AT-kommandomodus. Som vist ovenfor kommer GSM-modulen med en USART-adapter som kan kobles direkte til datamaskinen ved hjelp av en MAX232-modul, eller Tx- og Rx-pinnene kan brukes til å koble den til en mikrokontroller. Du kan også legge merke til de andre pinnene som MIC +, MIC-, SP +, SP- osv. Der en mikrofon eller en høyttaler kan kobles til. Modulen kan drives av en 12V adapter via en vanlig likestrømsjekk.

Sett inn SIM-kortet i sporet på modulen og slå det på, du bør merke at en strøm-LED lyser. Vent nå et minutt eller så, og du skal se en rød (eller annen farge) LED blinker en gang hvert 3. sekund. Dette betyr at modulen din var i stand til å opprette forbindelse med SIM-kortet. Nå kan du fortsette med å koble deg til modulen med telefonen eller en hvilken som helst mikrokontroller.

Kommunisere med GSM-modul ved hjelp av AT-kommandoer:

Som du kanskje har gjettet det, kan GSM-modulen kommunisere gjennom seriell kommunikasjon og kunne bare forstå ett språk, og det er " AT-kommandoer ". Uansett hva du kanskje vil fortelle eller spørre til GSM-modulen, bør det bare være via AT-kommandoer. For eksempel hvis du vil vite om modulen din er aktiv. Du bør be (sende) en kommando som "AT", og modulen din vil svare "OK".

Disse AT-kommandoene er godt forklart i databladet og finnes her i det offisielle databladet. Greit! Greit! Det er et 271-siders datablad, og du kan ta dager å lese gjennom dem. Så jeg har gitt noen viktigste AT-kommandoer nedenfor for at du skal komme i gang snart.

PÅ	Svar med OK for bekreftelse
AT + CPIN?	Sjekk signalkvalitet
AT + COPS?	Finn tjenesteleverandørens navn
ATD96XXXXXXXX;	Ring til det spesifikke nummeret, slutter med semipunkt
AT + CNUM	Finn antall SIM-kort (fungerer kanskje ikke for noen SIM-kort)
ATA	Svar på innkommende samtale
ATH	Avslutt gjeldende innkommende samtale
AT + COLP	Vis innkommende nummer
AT + VTS = (antall)	Send DTMF-nummer. Du kan bruke hvilket som helst nummer på mobiltastaturet til (nummer)
AT + CMGR	AT + CMGR = 1 leser meldingen ved første posisjon
AT + CMGD = 1	Slett meldingen ved første posisjon
AT + CMGDA = ”DEL ALL”	Slett alle meldinger fra SIM
AT + CMGL = ”ALL”	Les alle meldinger fra SIM
AT + CMGF = 1	Angi SMS-konfigurasjon. “1” er kun for tekstmodus
AT + CMGS = “+91 968837XXXX” > CircuitDigest Text	Sender SMS til et bestemt nummer her 968837XXXX. Når du ser ">" begynn å skrive inn teksten. Trykk Ctrl + Z for å sende teksten.
AT + CGATT?	For å se etter internettforbindelse på SIM-kortet
AT + CIPSHUT	For å lukke TCP-tilkobling, det vil si å koble fra internett
AT + CSTT = "APN", "brukernavn", "Pass"	Koble til GPRS med APN og Pass-tasten. Kan fås fra nettverksleverandør.
AT + CIICR	Sjekk om SIM-kortet har datapakke
AT + CIFSR	Få IP til SIM-nettverket
AT + CIPSTART = “TCP”, “SERVER IP”, “PORT”	Brukes til å angi en TCP IP-tilkobling
PÅ + CIPSEND	Denne kommandoen brukes til å sende data til serveren

Kretsdiagram:

Koblingsskjemaet for grensesnitt GSM-modul med PIC-mikrokontroller er vist nedenfor.

Vi har ganske enkelt koblet Tx- og Rx-pinnene på GSM-modulen med Rx- og Tx-pinnene på henholdsvis PIC MCU PIC16F877A. Dette vil etablere en seriell forbindelse mellom begge. Også, så ikke glem å feste både GSM- og PIC-modulen. Vi har også brukt en LCD-skjerm for å vite statusen til GSM-modulen vår. Når tilkoblingene er gjort, vil maskinvaren din se ut som noe nedenfor.

PIC Perf-kortet ble laget for vår PIC-opplæringsserie, der vi lærte å bruke PIC-mikrokontroller. Det kan være lurt å gå tilbake til disse PIC Microcontroller-opplæringene ved hjelp av MPLABX og XC8 hvis du ikke vet hvordan du skal brenne et program ved hjelp av Pickit 3, siden jeg vil hoppe over all den grunnleggende informasjonen.

Programmering av PIC Microcontroller:

Hele programmet for dette prosjektet finner du nederst i denne veiledningen. Her vil jeg forklare noen viktige funksjoner og kodestykker. Dette programmet har også en LCD-kode som var fra Interfacing LCD med PIC Microcontroller, du kan besøke den veiledningen hvis du er nysgjerrig på å vite hvordan LCD kan brukes med PIC-mikrokontroller.

Som sagt tidligere, skal vi kommunisere mellom PIC og GSM ved hjelp av AT-kommandoer gjennom seriell kommunikasjonsmodus. Så først må vi initialisere USART-kommunikasjonsmodulen i PIC-mikrokontrolleren vår ved å bruke Initialize _SIM900 (); funksjon. Inne i denne funksjonen erklærer vi Tx- og RX-pinnene og initialiserer asynkron mottak og overføring ved 9600 baudrate og 8-biters modus.

// *** Initialiser UART for SIM900 ** // ugyldig Initialiser_SIM900 (ugyldig) {// **** Innstilling av I / O-pinner for UART **** // TRISC6 = 0; // TX Pin satt som utgang TRISC7 = 1; // RX-pinne satt som inngang // ________ I / O-pinnesett __________ // / ** Initialiser SPBRG-register for ønsket baudrate og sett BRGH for rask baud_rate ** / SPBRG = 129; // SIM900 opererer ved 9600 Baud rate så 129 BRGH = 1; // for høy baudhastighet // _________ Slutt for innstilling av baudhastighet _________ // // **** Aktiver asynkron seriell port ******* // SYNC = 0; // Asynkron SPEN = 1; // Aktiver pinporter for seriell port // _____ Asynkron seriell port aktivert _______ // // ** Lar oss forberede for overføring og mottak ** // TXEN = 1; // aktivere overføring CREN = 1; // aktiver mottakelse // __ UART-modul oppe og klar for overføring og mottakelse __ // // ** Velg 8-biters modus ** // TX9 = 0; // 8-bit mottak valgt RX9 = 0;// 8-bits mottaksmodus valgt // __ 8-bits modus valgt __ //} // ________ UART-modul initialisert __________ //

Nå må vi lese og skrive informasjon fra / til GSM-modulen vår. For dette bruker vi funksjonene _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Disse funksjonene bruker buffer- og overføringsregisteret Sende og motta som TXREG og RCREG for å lese eller skrive data serielt.

// ** Funksjon for å sende en byte av dato til UART ** // ugyldig _SIM900_putch (char bt) {mens (! TXIF); // hold programmet til TX-bufferen er gratis TXREG = bt; // Last senderbufferen med den mottatte verdien} // _____________ Funksjonsslutt ________________ // // ** Funksjon for å få en databyte fra UART ** // char _SIM900_getch () {if (OERR) // sjekk etter feil { CREN = 0; // Hvis feil -> Tilbakestill CREN = 1; // Hvis feil -> Tilbakestill} mens (! RCIF); // hold programmet til RX buffer er gratis retur RCREG; // motta verdien og sende den til hovedfunksjonen} // _____________ Funksjonens slutt ________________ // // ** Funksjon for å konvertere streng til byte ** // ugyldig SIM900_send_string (char * st_pt) {mens (* st_pt) // hvis det er en char _SIM900_putch (* st_pt ++);// behandle det som en byte-data} // ___________ Funksjonens slutt ______________ // // ** Slutt på modifiserte koder ** // ugyldig _SIM900_print (usignert const char * ptr) {mens (* ptr! = 0) {_SIM900_putch (* ptr ++); }

Ovennevnte funksjoner er universelle og trenger ikke endres for noen applikasjoner. De ble forklart bare for å gi en grov intro. Du kan dykke dypt inn i dem hvis du vil gjennom forståelse.

Nå i vår hovedfunksjon initialiserer vi USART-tilkoblingen og sjekker om vi er i stand til å motta et "OK" når vi sender "AT" ved å bruke nedenstående kodelinje.

gjør {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modulen ble ikke funnet"); } mens (! SIM900_isStarted ()); // vent til GSM sender "OK" Lcd_Set_Cursor (2,1) tilbake; Lcd_Print_String ("Modul oppdaget"); __forsink_ms (1500);

Funksjonen SIM900_isStarted (); vil sende “AT” til GSM og venter på svar “OK” fra den. Hvis ja, vil den returnere 1 annen 0;

Hvis modulen ikke blir oppdaget, eller hvis det er noe tilkoblingsproblem, vil LCD-skjermen vise "Modulen ble ikke funnet", ellers vil den vise Modulen oppdages og fortsett til neste trinn hvor vi sjekker om SIM-kortet kan oppdages av nedenstående linje med kode.

/ * Sjekk om SIM-kortet er oppdaget * / gjør {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM ikke funnet"); } mens (! SIM900_isReady ()); // vent til GSM sender "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM oppdaget"); __forsink_ms (1500);

Funksjonen SIM900_isReady () vil sende “AT + CPIN?” til GSM og venter på svar “+ CPIN: READY” fra den. Hvis ja, vil den returnere 1 annen 0;

Hvis et SIM-kort blir funnet, vil vi få oppdaget SIM vises på LCD-skjermen. Deretter kan vi prøve å ringe ved å bruke kommandoen “ ATD mobilnummer ; ”. Her som et eksempel har jeg brukt nummeret mitt som ATD93643159XX;. Du må erstatte ditt respektive mobilnummer der.

/ * Ringe * / gjør {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Her ringer vi til nummer 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Ringer…"); } mens (_SIM900_waitResponse ()! = SIM900_OK); // vent til ESP sender tilbake "OK" Lcd_Set_Cursor (1,1); Lcd_Print_String ("Anrop utført…."); __forsink_ms (1500);

Når samtalen er plassert, vil LCD-skjermen vise Ring ut, og du skal motta et innkommende anrop til det angitte nummeret.

Du kan også ringe til mobilnummeret som er koblet til GSM-modulen og få beskjed om det på LCD-skjermen y ved hjelp av koden nedenfor

mens (1) {if (_SIM900_waitResponse () == SIM900_RING) // Sjekk om det er en innkommende samtale {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Innkommende samtale !!."); }}

Når GSM-modulen oppdager et innkommende anrop, vil den vise innkommende anrop på den andre linjen i LCD-modulen. Funksjonen _SIM900_waitResponse () vil se etter innkommende data fra GSM-modulen. Når den mottar SIM900_RING, som tilsvarer “RING” på grunn av waitResponce () , viser vi statusen “Innkommende samtale”.

Du kan lage dine egne funksjoner som dette for å utføre nesten alle typer aktiveringer ved hjelp av GSM-modulen. Hvis du vil ha ting hardkodet, kan du bare bruke __SIM900_print () -funksjonen til å sende en AT-kommando som dette nedenfor.

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

Husk at alt du kommandoen skal følges med “\ r \ n” for å indikere at kommandoen avsluttes.

Simulering:

Når du har forstått hvordan programmet fungerer, kan du prøve å simulere og gjøre endringer som passer dine behov. Simulering vil spare deg for mye tid. Simuleringen er gjort ved hjelp av Proteus, og det ser ut som nedenfor.

Som du ser har vi brukt virtuelt terminalalternativ i Proteus for å sjekke om programmet svarer som forventet. Vi kan mate inn verdiene gjennom popup-dialogboksen. For eksempel så snart vi trykker på run, vises en svart dialogboks som ovenfor og viser AT, dette betyr at den har sendt GSM-modulen AT, nå kan vi svare på PIC ved å skrive i boksen som "OK" og trykke enter og PIC vil svare på det. På samme måte kan vi prøve for alle AT-kommandoer.

Ringe og motta anrop ved hjelp av GSM og PIC:

Når du har forstått hvordan koden og maskinvaren fungerer, kan du bare laste opp programmet nedenfor til PIC og slå på modulen. LCD-skjermen din skal vise "Modul oppdaget", "SIM oppdaget" og "Ring oppringt" hvis alt fungerer bra. Når du ser “Ring ringt”, får du et innkommende anrop til nummeret som er spesifisert i programmet.

Du kan også prøve å ringe til nummeret som er tilstede i GSM-modulen, og LCD-skjermen viser "Innkommende samtale" for å indikere at SIM-kortet blir ringt.

Fullstendig bearbeiding av prosjektet er vist i videoen nedenfor. Håper du forsto prosjektet og likte å gjøre det. Hvis du har problemer med å få ting til å fungere, kan du legge inn spørsmålet ditt i kommentarfeltet eller på forumene våre, så hjelper jeg deg gjerne.