GSM-modul gränssnitt med pic-mikrokontroller

GSM-moduler är fascinerande att använda, särskilt när vårt projekt kräver fjärråtkomst. Dessa moduler kan göra alla åtgärder som vår vanliga mobiltelefon kan göra, som att ringa / ta emot ett samtal, skicka / ta emot ett SMS, ansluta till internet med GPRS etc. Du kan också ansluta en vanlig mikrofon och högtalare till den här modulen och samtala på din mobilsamtal. Detta kommer att öppna dörrar för många kreativa projekt om det kan kopplas till en mikrokontroller. Därför kommer vi att lära oss hur vi kan koppla in GSM-modulen (SIM900A) med vår PIC-mikrokontroller och visa det genom att ringa och ta emot samtal med GSM-modulen. Vi har tidigare kopplat det med Arduino och Raspberry Pi för att ringa och skicka meddelanden:

Samtal och meddelande med Arduino och GSM-modulen
Ring och sms med Raspberry Pi och GSM-modulen

Material som krävs:

PIC-mikrokontroller (PIC16F877A)
GSM-modul (SIM900 eller något annat)
Anslutande ledningar
12V-adapter
PicKit 3

GSM-modul:

GSM-modulen kan användas även utan mikrokontroller med AT-kommandoläget. Som visas ovan kommer GSM-modulen med en USART-adapter som kan kopplas direkt till datorn med hjälp av en MAX232-modul eller så kan Tx- och Rx-stiften användas för att ansluta den till en mikrokontroller. Du kan också se andra stift som MIC +, MIC-, SP +, SP- etc där en mikrofon eller en högtalare kan anslutas. Modulen kan drivas av en 12V-adapter via ett vanligt likströmsuttag.

Sätt i ditt SIM-kort i kortplatsen på modulen och slå på det, du bör märka att en strömlampa tänds. Vänta nu en minut eller så, och du bör se en röd (eller någon annan färg) LED blinkar en gång var tredje sekund. Det betyder att din modul kunde upprätta anslutning till ditt SIM-kort. Nu kan du fortsätta med att ansluta din modul till telefon eller vilken mikrokontroller som helst.

Kommunicera med GSM-modulen med AT-kommandon:

Som du kanske har gissat det kan GSM-modulen kommunicera via seriell kommunikation och kunde bara förstå ett språk och det är " AT-kommandon ". Oavsett vad du kanske vill berätta eller fråga till GSM-modulen ska det bara ske via AT-kommandon. Till exempel om du vill veta om din modul är aktiv. Du bör be (skicka) ett kommando som "AT" och din modul svarar "OK".

Dessa AT-kommandon förklaras väl i dess datablad och finns här i dess officiella datablad. Okej! Okej! Det är ett 271-sidars datablad och du kan ta dagar att läsa igenom dem. Så jag har gett några viktigaste AT-kommandon nedan för att du ska få igång detta snart.

PÅ	Svarar med OK för bekräftelse
AT + CPIN?	Kontrollera signalkvalitet
AT + COPS?	Hitta tjänsteleverantörens namn
ATD96XXXXXXXX;	Ring till det specifika numret, slutar med semikolon
AT + CNUM	Hitta antalet SIM-kort (kanske inte fungerar för vissa SIM-kort)
ATA	Svara på det inkommande samtalet
ATH	Avsluta det aktuella inkommande samtalet
AT + COLP	Visa inkommande samtalsnummer
AT + VTS = (antal)	Skicka DTMF-nummer. Du kan använda valfritt nummer på din mobila knappsats för (nummer)
AT + CMGR	AT + CMGR = 1 läser meddelandet vid första positionen
AT + CMGD = 1	Radera meddelande vid första position
AT + CMGDA = ”DEL ALL”	Ta bort alla meddelanden från SIM-kortet
AT + CMGL = ”ALL”	Läs alla meddelanden från SIM
AT + CMGF = 1	Ställ in SMS-konfiguration. “1” är endast för textläge
AT + CMGS = “+91 968837XXXX” > CircuitDigest Text	Skickar SMS till ett visst nummer här 968837XXXX. När du ser “>” börja skriva in texten. Tryck på Ctrl + Z för att skicka texten.
AT + CGATT?	För att söka efter internetanslutning på SIM-kortet
AT + CIPSHUT	För att stänga TCP-anslutningen, vilket innebär att koppla från internet
AT + CSTT = "APN", "användarnamn", "Godkänd"	Anslut till GPRS med din APN och Pass-nyckel. Kan fås från nätverksleverantören.
AT + CIICR	Kontrollera om SIM-kortet har datapaket
AT + CIFSR	Få IP för SIM-nätverket
AT + CIPSTART = “TCP”, ”SERVER IP”, “PORT”	Används för att ställa in en TCP IP-anslutning
AT + CIPSEND	Detta kommando används för att skicka data till servern

Kretsschema:

Anslutningsdiagrammet för gränssnitts GSM-modul med PIC-mikrokontroller visas nedan.

Vi har helt enkelt kopplat Tx- och Rx-stiften på GSM-modulen med Rx- och Tx-stiften på PIC MCU PIC16F877A. Detta skapar en seriell anslutning mellan båda. Också, så glöm inte att gemensamma grunder både GSM- och PIC-modulen. Vi har också använt en LCD-skärm för att veta statusen för vår GSM-modul. När anslutningarna är klar ser din hårdvara ut som något nedan.

PIC Perf-kortet skapades för vår PIC-handledningsserie, där vi lärde oss hur man använder PIC-mikrokontroller. Du kanske vill gå tillbaka till dessa PIC Microcontroller-handledning med MPLABX och XC8 om du inte vet hur man bränner ett program med Pickit 3, eftersom jag hoppar över all denna grundläggande information.

Programmering av din PIC Microcontroller:

Det fullständiga programmet för detta projekt finns längst ner i denna handledning. Här kommer jag att förklara några viktiga funktioner och kodbitar. Detta program har också en LCD-kod som var från Interfacing LCD med PIC Microcontroller, du kan besöka den självstudien om du är nyfiken på att veta hur LCD kan användas med PIC-mikrokontroller.

Som sagt tidigare kommer vi att kommunicera mellan PIC och GSM med hjälp av AT-kommandon via Serial mode of communication. Så först måste vi initialisera USART-kommunikationsmodulen i vår PIC-mikrokontroller med hjälp av Initialisera _SIM900 (); fungera. Inuti denna funktion deklarerar vi Tx- och RX-stiften och initierar asynkron mottagning och överföring vid 9600 baudhastighet och 8-bitars läge.

// *** Initiera UART för SIM900 ** // ogiltigt Initialisera_SIM900 (ogiltigt) {// **** Ställa in I / O-stift för UART **** // TRISC6 = 0; // TX-stift som utgång TRISC7 = 1; // RX-stift som ingång // ________ I / O-stift inställd __________ // / ** Initiera SPBRG-register för erforderlig baudhastighet och ställ in BRGH för snabb baud_rate ** / SPBRG = 129; // SIM900 arbetar vid 9600 Baudhastighet så 129 BRGH = 1; // för hög baudhastighet // _________ Slut för inställning av baudhastighet _________ // // **** Aktivera asynkron seriell port ******* // SYNC = 0; // Asynkron SPEN = 1; // Aktivera seriella portstift // _____ Asynkron seriell port aktiverad _______ // // ** Låt oss förbereda för överföring och mottagning ** // TXEN = 1; // aktivera överföring CREN = 1; // aktivera mottagning // __ UART-modul upp och redo för överföring och mottagning __ // // ** Välj 8-bitars läge ** // TX9 = 0; // 8-bitars mottagning vald RX9 = 0;// 8-bitars mottagningsläge valt // __ 8-bitars läge valt __ //} // ________ UART-modul Initialiserad __________ //

Nu måste vi läsa och skriva information från / till vår GSM-modul. För detta använder vi funktionerna _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Dessa funktioner använder överförings- och mottagningsbuffertregistret som TXREG och RCREG för att läsa eller skriva data seriellt.

// ** Funktion för att skicka en byte av datum till UART ** // ogiltig _SIM900_putch (char bt) {medan (! TXIF); // håll programmet tills TX-buffert är gratis TXREG = bt; // Ladda sändarbufferten med det mottagna värdet} // _____________ Funktionens slut ________________ // // ** Funktion för att få en byte av datum från UART ** // char _SIM900_getch () {if (OERR) // kontrollera fel { CREN = 0; // Om fel -> Återställ CREN = 1; // Om fel -> Återställ} medan (! RCIF); // håll programmet tills RX-buffert är fri retur RCREG; // ta emot värdet och skicka det till huvudfunktionen} // _____________ Funktionens slut ________________ // // ** Funktion för att konvertera sträng till byte ** // ogiltig SIM900_send_string (char * st_pt) {medan (* st_pt) // om det är en char _SIM900_putch (* st_pt ++);// bearbeta det som en byte-data} // ___________ Funktionens slut ______________ // // ** Slut på modifierade koder ** // ogiltig _SIM900_print (osignerad const char * ptr) {medan (* ptr! = 0) {_SIM900_putch (* ptr ++); }

Ovanstående funktioner är universella och behöver inte ändras för några applikationer. De förklarades bara för att ge en grov introduktion. Du kan dyka djupt in i dem om du vill genom förståelse.

Nu inuti vår huvudfunktion initialiserar vi USART-anslutningen och kontrollerar om vi kan få ett "OK" när vi skickar "AT" med hjälp av nedanstående kodrad

gör {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modulen hittades inte"); } medan (! SIM900_isStarted ()); // vänta tills GSM skickar tillbaka "OK" Lcd_Set_Cursor (2,1); Lcd_Print_String ("Modulen upptäckt"); __fördröja_ms (1500);

Funktionen SIM900_isStarted (); skickar "AT" till GSM och väntar på svar "OK" från det. Om ja, kommer den att returnera 1 annan 0;

Om modulen inte upptäcks eller om det finns något anslutningsproblem kommer LCD-skärmen att visa "Modulen hittades inte", annars kommer den att visa att modulen detekteras och fortsätt till nästa steg där vi kontrollerar om SIM-kortet kan detekteras av nedanstående kodrad.

/ * Kontrollera om SIM-kortet upptäcks * / gör {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM hittades inte"); } medan (! SIM900_isReady ()); // vänta tills GSM skickar tillbaka "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM upptäckt"); __fördröja_ms (1500);

Funktionen SIM900_isReady () skickar “AT + CPIN?” till GSM och väntar på svar “+ CPIN: READY” från det. Om ja, kommer den att returnera 1 annan 0;

Om ett SIM-kort hittas kommer SIM att upptäckas visas på LCD-skärmen. Sedan kan vi försöka ringa ett samtal med kommandot ” ATD- mobilnummer ; ”. Här som ett exempel har jag använt mitt nummer som ATD93643159XX;. Du måste byta ut ditt respektive mobilnummer där.

/ * Ringa ett telefonsamtal * / gör {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Här ringer vi till numret 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Ringa samtal…."); } medan (_SIM900_waitResponse ()! = SIM900_OK); // vänta tills ESP skickar tillbaka "OK" Lcd_Set_Cursor (1,1); Lcd_Print_String ("Samtal placeras…."); __fördröja_ms (1500);

När samtalet har ringts upp visar LCD-skärmen samtal och du bör få ett inkommande samtal till det angivna numret.

Du kan också ringa till det mobilnummer som är anslutet till GSM-modulen och få ett meddelande om det på din LCD-skärm y med hjälp av nedanstående kod

medan (1) {if (_SIM900_waitResponse () == SIM900_RING) // Kontrollera om det finns ett inkommande samtal {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Inkommande samtal !!."); }}

När GSM-modulen upptäcker ett inkommande samtal kommer det att visas inkommande samtal på LCD-modulens andra rad. Funktionen _SIM900_waitResponse () söker efter inkommande data från GSM-modulen. När den tar emot SIM900_RING, vilket motsvarar “RING” på grund av waitResponce () , visar vi statusen “Inkommande samtal”.

Du kan skapa dina egna funktioner så här för att utföra nästan alla typer av aktiveringar med hjälp av GSM-modulen. Om du vill ha hårdkodade saker kan du helt enkelt använda funktionen __SIM900_print () för att skicka något AT-kommando som det här nedan.

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

Kom ihåg att allt du kommandot ska följas med “\ r \ n” för att indikera att kommandot avslutas.

Simulering:

När du väl har förstått hur programmet fungerar kan du prova att simulera och göra ändringar för att passa dina behov. Simulering sparar mycket tid. Simuleringen görs med Proteus och ser ut som nedan.

Som du ser har vi använt ett virtuellt terminalalternativ i Proteus för att kontrollera om programmet svarar som förväntat. Vi kan mata in värdena via popup-dialogrutan. Till exempel så snart vi trycker på run kommer en svart dialogruta som ovan att visas och AT visar, det betyder att den har skickat GSM-modulen AT, nu kan vi svara på PIC genom att skriva i rutan som "OK" och trycka på enter och PIC kommer att svara på det. På samma sätt kan vi testa alla AT-kommandon.

Ringa och ta emot samtal med GSM och PIC:

När du förstår hur koden och hårdvaran fungerar laddar du bara upp programmet nedan till PIC och slår på modulen. Din LCD-skärm ska visa "Modulen upptäckt", "SIM upptäckt" och "Samtal placerad" om allt fungerar bra. När du ser “Samtal placerat” får du ett inkommande samtal till det nummer som anges i programmet.

Du kan också prova att ringa till numret som finns i GSM-modulen och LCD-skärmen visar "Inkommande samtal" för att indikera att SIM-kortet ringer.

Hela arbetet med projektet visas i videon nedan. Hoppas att du förstod projektet och tyckte om att göra det. Om du har några problem med att få saker att fungera, lägg din fråga i kommentarsektionen eller på våra forum så hjälper jag dig gärna.