Gsm-module interface met pic-microcontroller

GSM-modules zijn fascinerend om te gebruiken, vooral wanneer ons project externe toegang vereist. Deze modules kunnen alle acties uitvoeren die onze normale mobiele telefoon zou kunnen uitvoeren, zoals bellen / gebeld worden, een sms verzenden / ontvangen, verbinding maken met internet via GPRS enz. U kunt ook een normale microfoon en luidspreker op deze module aansluiten en op uw mobiele oproepen. Dit zal deuren openen voor veel creatieve projecten als het zou kunnen worden gekoppeld aan een microcontroller. Daarom zullen we in deze tutorial leren hoe we de GSM-module (SIM900A) kunnen koppelen met onze PIC-microcontroller en dit demonstreren door te bellen en gebeld te worden met de GSM-module. We hebben het eerder gekoppeld aan Arduino en Raspberry Pi voor bellen en berichten verzenden:

Bel en bericht met behulp van Arduino en GSM-module
Bellen en sms'en met Raspberry Pi en GSM-module

Vereiste materialen:

PIC-microcontroller (PIC16F877A)
GSM-module (SIM900 of een andere)
Draden aansluiten
12V adapter
PicKit 3

GSM-module:

De GSM-module kan zelfs zonder microcontroller worden gebruikt door de AT-opdrachtmodus te gebruiken. Zoals hierboven getoond, wordt de GSM-module geleverd met een USART-adapter die rechtstreeks op de computer kan worden aangesloten met behulp van een MAX232-module of de Tx- en Rx-pinnen kunnen worden gebruikt om deze op een Microcontroller aan te sluiten. Je kunt ook de andere pinnen opmerken zoals MIC +, MIC-, SP +, SP- etc waar een microfoon of een luidspreker kan worden aangesloten. De module kan worden gevoed door een 12V-adapter via een normale DC-bus.

Plaats uw simkaart in de sleuf van de module en schakel deze in, u zou moeten zien dat een aan / uit-LED gaat branden. Wacht nu ongeveer een minuut en je zou een rode (of een andere kleur) LED moeten zien knipperen om de 3 seconden. Dit betekent dat uw module in staat was om verbinding te maken met uw simkaart. Nu kunt u doorgaan met het verbinden van uw module met Phone of een andere microcontroller.

Communiceren met GSM-module met AT-opdrachten:

Zoals je misschien al geraden hebt, kan de GSM-module communiceren via seriële communicatie en kan hij maar één taal verstaan en dat zijn " AT-commando's ". Wat u ook aan de GSM-module wilt vertellen of vragen, het mag alleen via AT-opdrachten zijn. Bijvoorbeeld als u wilt weten of uw module actief is. Je zou een commando moeten vragen (sturen) zoals "AT" en je module zal "OK" antwoorden.

Deze AT-commando's worden goed uitgelegd in het gegevensblad en zijn hier te vinden in het officiële gegevensblad. Oke! Oke! Het is een gegevensblad van 271 pagina's en het kan dagen duren voordat u ze doorleest. Daarom heb ik hieronder enkele van de belangrijkste AT-opdrachten gegeven, zodat je dit snel kunt gebruiken.

BIJ	Antwoorden met OK voor bevestiging
AT + CPIN?	Controleer de signaalkwaliteit
AT + COPS?	Zoek de naam van de serviceprovider
ATD96XXXXXXXX;	Bel naar het specifieke nummer, eindigt met een puntkomma
OP + CNUM	Zoek het nummer van de simkaart (werkt mogelijk niet voor sommige simkaarten)
ATA	Beantwoord de inkomende oproep
ATH	Hang het huidige inkomende gesprek af
AT + COLP	Toon inkomend oproepnummer
AT + VTS = (nummer)	Stuur DTMF-nummer. U kunt elk nummer op uw mobiele toetsenbord gebruiken voor (nummer)
AT + CMGR	AT + CMGR = 1 leest bericht op eerste positie
AT + CMGD = 1	Verwijder bericht op eerste positie
AT + CMGDA = "DEL ALL"	Verwijder alle berichten van de simkaart
AT + CMGL = "ALL"	Lees alle berichten van de simkaart
AT + CMGF = 1	Stel de SMS-configuratie in. "1" is alleen voor tekstmodus
AT + CMGS = "+91 968837XXXX" > CircuitDigest-tekst	Stuurt hier een sms naar een bepaald nummer 968837XXXX. Als je ">" ziet, begin dan met het invoeren van de tekst. Druk op Ctrl + Z om de tekst te verzenden.
AT + CGATT?	Om de internetverbinding op de simkaart te controleren
OP + CIPSHUT	Om de TCP-verbinding te sluiten, wat betekent dat u de verbinding met internet verbreekt
AT + CSTT = "APN", "gebruikersnaam", "Pass"	Maak verbinding met GPRS met uw APN en Pass-sleutel. Verkrijgbaar bij netwerkprovider.
AT + CIICR	Controleer of de simkaart een datapakket heeft
AT + CIFSR	Krijg IP van het SIM-netwerk
AT + CIPSTART = "TCP", "SERVER IP", "PORT"	Wordt gebruikt om een TCP IP-verbinding in te stellen
AT + CIPSEND	Deze opdracht wordt gebruikt om gegevens naar de server te verzenden

Schakelschema:

Het aansluitschema voor de interface van de GSM-module met de PIC-microcontroller wordt hieronder weergegeven.

We hebben eenvoudigweg de Tx- en Rx-pinnen van de GSM-module gekoppeld aan de Rx- en Tx-pinnen van respectievelijk de PIC MCU PIC16F877A. Dit zal een seriële verbinding tot stand brengen tussen beide. Vergeet dus niet om zowel de GSM- als de PIC-module gemeenschappelijk te aarden. We hebben ook een LCD-scherm gebruikt om de status van onze GSM-module te kennen. Zodra de verbindingen zijn gemaakt, ziet uw hardware er als volgt uit.

Het PIC Perf-bord is gemaakt voor onze PIC-tutorialserie, waarin we hebben geleerd hoe we PIC-microcontrollers moeten gebruiken. Misschien wil je teruggaan naar die PIC Microcontroller-tutorials met MPLABX en XC8 als je niet weet hoe je een programma moet branden met Pickit 3, aangezien ik al die basisinformatie zal overslaan.

Programmering van uw PIC-microcontroller:

Het complete programma voor dit project vind je onderaan deze tutorial. Hier zal ik enkele belangrijke functies en stukjes code uitleggen. Dit programma heeft ook LCD-codes die afkomstig waren van Interfacing LCD met PIC Microcontroller, je kunt die tutorial bezoeken als je nieuwsgierig bent naar hoe LCD kan worden gebruikt met PIC-microcontroller.

Zoals eerder gezegd, gaan we communiceren tussen PIC en GSM met behulp van AT-opdrachten via de seriële communicatiemodus. We moeten dus eerst de USART-communicatiemodule initialiseren in onze PIC-microcontroller met behulp van Initialize _SIM900 (); functie. Binnen deze functie declareren we de Tx- en RX-pinnen en initialiseren we asynchrone ontvangst en verzending op 9600 baudrate en 8-bit-modus.

// *** Initialize UART voor SIM900 ** // void Initialize_SIM900 (ongeldig) {// **** I / O-pinnen instellen voor UART **** // TRISC6 = 0; // TX Pin ingesteld als uitvoer TRISC7 = 1; // RX-pin ingesteld als invoer // ________ I / O-pinnen ingesteld __________ // / ** Initialiseer SPBRG-register voor vereiste baudrate en stel BRGH in voor snelle baud_rate ** / SPBRG = 129; // SIM900 werkt op 9600 baudrate, dus 129 BRGH = 1; // voor hoge baud_rate // _________ Einde van baud_rate-instelling _________ // // **** Asynchrone seriële poort inschakelen ******* // SYNC = 0; // Asynchrone SPEN = 1; // Schakel seriële poortpinnen in // _____ Asynchrone seriële poort ingeschakeld _______ // // ** Laten we ons voorbereiden op verzending en ontvangst ** // TXEN = 1; // schakel transmissie CREN = 1 in; // ontvangst inschakelen // __ UART-module klaar voor verzending en ontvangst __ // // ** Selecteer 8-bit-modus ** // TX9 = 0; // 8-bits ontvangst geselecteerd RX9 = 0;// 8-bit ontvangstmodus geselecteerd // __ 8-bit modus geselecteerd __ //} // ________ UART-module geïnitialiseerd __________ //

Nu moeten we informatie van / naar onze GSM-module lezen en schrijven. Hiervoor gebruiken we de functies _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Deze functies gebruiken het bufferregister voor verzenden en ontvangen, zoals TXREG en RCREG, om gegevens serieel te lezen of te schrijven.

// ** Functie om een byte van de datum naar UART ** // void _SIM900_putch (char bt) {while (! TXIF) te sturen; // houd het programma vast totdat TX-buffer vrij is TXREG = bt; // Laad de zenderbuffer met de ontvangen waarde} // _____________ Einde van de functie ________________ // // ** Functie om één byte van de datum van UART ** // char _SIM900_getch () {if (OERR) // controleer op fout { CREN = 0; // Als fout -> Reset CREN = 1; // If error -> Reset} while (! RCIF); // houd het programma vast totdat de RX-buffer vrij is, geef RCREG terug; // ontvang de waarde en stuur deze naar de hoofdfunctie} // _____________ Einde van de functie ________________ // // ** Functie om tekenreeks naar byte te converteren ** // void SIM900_send_string (char * st_pt) {while (* st_pt) // indien aanwezig is een char _SIM900_putch (* st_pt ++);// verwerk het als een bytegegevens} // ___________ Einde van functie ______________ // // ** Einde van gewijzigde codes ** // void _SIM900_print (unsigned const char * ptr) {while (* ptr! = 0) {_SIM900_putch (* ptr ++); }

De bovenstaande functies zijn universeel en hoeven voor geen enkele toepassing te worden gewijzigd. Ze werden alleen uitgelegd om een grove intro te geven. Je kunt er diep in duiken als je wilt door begrip.

Nu in onze hoofdfunctie initialiseren we de USART-verbinding en controleren of we een "OK" kunnen ontvangen wanneer we "AT" verzenden met behulp van de onderstaande coderegel

doe {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Module niet gevonden"); } while (! SIM900_isStarted ()); // wacht tot de GSM "OK" Lcd_Set_Cursor (2,1) terugstuurt; Lcd_Print_String ("Module gedetecteerd"); __delay_ms (1500);

De functie SIM900_isStarted (); zal "AT" naar de GSM sturen en wacht op een antwoord "OK" ervan. Zo ja, dan retourneert het 1 anders 0;

Als de module niet wordt gedetecteerd of als er een verbindingsprobleem is, toont het LCD-scherm "Module niet gevonden", anders wordt Module is gedetecteerd en gaan we verder met de volgende stap waar we controleren of de simkaart kan worden gedetecteerd door het onderstaande regel code.

/ * Controleer of de simkaart is gedetecteerd * / doe {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM niet gevonden"); } while (! SIM900_isReady ()); // wacht tot de GSM "+ CPIN: READY" Lcd_Set_Cursor (2,1) terugstuurt; Lcd_Print_String ("SIM gedetecteerd"); __delay_ms (1500);

De functie SIM900_isReady () zal "AT + CPIN?" naar de GSM en wacht op het antwoord "+ CPIN: READY" ervan. Zo ja, dan retourneert het 1 anders 0;

Als er een simkaart wordt gevonden, wordt de simkaart op het LCD-scherm weergegeven. Vervolgens kunnen we proberen een oproep te plaatsen door het commando " ATD mobiel nummer ; ”. Hier als voorbeeld heb ik mijn nummer gebruikt als ATD93643159XX;. U moet daar uw respectieve gsm-nummer vervangen.

/ * Plaats een telefoongesprek * / do {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Hier plaatsen we een oproep naar nummer 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Oproep plaatsen…"); } while (_SIM900_waitResponse ()! = SIM900_OK); // wacht tot de ESP "OK" Lcd_Set_Cursor (1,1) terugstuurt; Lcd_Print_String ("Oproep geplaatst…"); __delay_ms (1500);

Zodra de oproep is geplaatst, wordt op het LCD-scherm Gesprek geplaatst weergegeven en moet u een inkomende oproep ontvangen op dat opgegeven nummer.

U kunt ook bellen naar het mobiele nummer dat op de GSM-module is aangesloten en daarover op uw LCD-scherm y worden geïnformeerd met behulp van de onderstaande code

while (1) {if (_SIM900_waitResponse () == SIM900_RING) // Controleer of er een inkomende oproep is {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Inkomend gesprek !!."); }}

Wanneer de GSM-module een inkomende oproep detecteert, wordt Inkomende oproep weergegeven op de tweede regel van de LCD-module. De functie _SIM900_waitResponse () controleert op inkomende gegevens van de GSM-module. Wanneer het SIM900_RING ontvangt, wat gelijk is aan "RING" vanwege de waitResponce () , zullen we de status "Inkomend gesprek" weergeven.

U kunt op deze manier uw eigen functies creëren om bijna alle soorten activaties uit te voeren met behulp van de GSM-module. Als u dingen hardcoded wilt hebben, kunt u eenvoudig de __SIM900_print () functie gebruiken om een AT-commando zoals hieronder te verzenden.

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

Onthoud dat alles wat je commando moet worden gevolgd door "\ r \ n" om aan te geven dat het commando wordt beëindigd.

Simulatie:

Als u eenmaal begrijpt hoe het programma werkt, kunt u proberen te simuleren en wijzigingen aanbrengen om aan uw behoeften te voldoen. Simulatie bespaart u veel tijd. De simulatie is gedaan met Proteus en het ziet er als volgt uit.

Zoals u kunt zien, hebben we de virtuele terminaloptie in Proteus gebruikt om te controleren of het programma reageert zoals verwacht. We kunnen de waarden invoeren via het pop-upvenster. Zodra we bijvoorbeeld op Uitvoeren klikken, zal een zwart dialoogvenster zoals hierboven verschijnen en AT weergeven, dit betekent dat het de GSM-module AT heeft verzonden, nu kunnen we op PIC antwoorden door in het vak "OK" te typen en op enter te drukken en de PIC zal erop reageren. Evenzo kunnen we proberen voor alle AT-commando's.

Bellen en gebeld worden via GSM en PIC:

Zodra u begrijpt hoe de code en hardware werken, uploadt u eenvoudig het onderstaande programma naar PIC en schakelt u de module in. Uw LCD-scherm zou "Module gedetecteerd", "SIM gedetecteerd" en "oproep geplaatst" moeten weergeven als alles goed werkt. Zodra u "Oproep geplaatst" ziet, krijgt u een inkomende oproep naar het nummer dat in het programma is opgegeven.

U kunt ook proberen te bellen naar het nummer dat aanwezig is in de GSM-module en uw LCD zal "Inkomende oproep" weergeven om aan te geven dat de SIM wordt gebeld.

De volledige werking van het project wordt getoond in de onderstaande video. Ik hoop dat je het project hebt begrepen en ervan hebt genoten. Als je een probleem hebt om dingen voor elkaar te krijgen, plaats je vraag dan in het commentaargedeelte of op onze forums en ik help je graag verder.