Module GSM s'interfaçant avec le microcontrôleur pic

Les modules GSM sont fascinants à utiliser en particulier lorsque notre projet nécessite un accès à distance. Ces modules peuvent effectuer toutes les actions que notre téléphone mobile normal pourrait faire, comme passer / recevoir un appel, envoyer / recevoir un SMS, se connecter à Internet en utilisant GPRS, etc. Vous pouvez également connecter un microphone et un haut-parleur normaux à ce module et converser sur votre appels mobiles. Cela ouvrira les portes à de nombreux projets créatifs s'il pouvait être interfacé avec un microcontrôleur. Par conséquent, dans ce tutoriel, nous allons apprendre comment nous pouvons interfacer le module GSM (SIM900A) avec notre microcontrôleur PIC et le démontrer en passant et en recevant un appel à l'aide du module GSM. Nous l'avons précédemment interfacé avec Arduino et Raspberry Pi pour les appels et la messagerie:

Appel et message à l'aide d'Arduino et du module GSM
Appel et SMS à l'aide du Raspberry Pi et du module GSM

Matériaux nécessaires:

Microcontrôleur PIC (PIC16F877A)
Module GSM (SIM900 ou tout autre)
Fils de connexion
Adaptateur 12V
PicKit 3

Module GSM:

Le module GSM peut être utilisé même sans microcontrôleur en utilisant le mode de commande AT. Comme indiqué ci-dessus, le module GSM est livré avec un adaptateur USART qui peut être directement interfacé à l'ordinateur en utilisant un module MAX232 ou les broches Tx et Rx peuvent être utilisées pour le connecter à un microcontrôleur. Vous pouvez également remarquer les autres broches comme MIC +, MIC-, SP +, SP- etc. où un microphone ou un haut-parleur peut être connecté. Le module peut être alimenté par un adaptateur 12V via une prise cylindrique CC normale.

Insérez votre carte SIM dans l'emplacement du module et allumez-le, vous devriez remarquer qu'un voyant d'alimentation s'allume. Maintenant, attendez une minute environ, et vous devriez voir une LED rouge (ou toute autre couleur) clignoter une fois toutes les 3 secondes. Cela signifie que votre module était capable d'établir une connexion avec votre carte SIM. Vous pouvez maintenant procéder à la connexion de votre module avec le téléphone ou n'importe quel microcontrôleur.

Communication avec le module GSM à l'aide des commandes AT:

Comme vous l'avez peut-être deviné, le module GSM peut communiquer via une communication série et ne peut comprendre qu'une seule langue, à savoir les « commandes AT ». Quoi que vous souhaitiez dire ou demander au module GSM, cela ne devrait se faire que via des commandes AT. Par exemple si vous souhaitez savoir si votre module est actif. Vous devriez demander (envoyer) une commande comme «AT» et votre module répondra «OK».

Ces commandes AT sont bien expliquées dans sa fiche technique et peuvent être trouvées ici dans sa fiche technique officielle. D'accord! D'accord! Il s'agit d'une fiche technique de 271 pages et vous pourriez prendre des jours pour les lire. J'ai donc donné ci-dessous quelques commandes AT les plus importantes pour que cela soit opérationnel bientôt.

À	Répond par OK pour accusé de réception
AT + CPIN?	Vérifier la qualité du signal
AT + COPS?	Rechercher le nom du fournisseur de services
ATD96XXXXXXXX;	Appel au numéro spécifique, se termine par un point-virgule
À + CNUM	Trouvez le numéro de la carte SIM (peut ne pas fonctionner pour certaines SIM)
À	Répondre à l'appel entrant
ATH	Suspendre l'appel entrant en cours
AT + COLP	Afficher le numéro d'appel entrant
AT + VTS = (nombre)	Envoyer le numéro DTMF. Vous pouvez utiliser n'importe quel numéro sur votre clavier mobile pour (numéro)
AT + CMGR	AT + CMGR = 1 lit le message en première position
À + CMGD = 1	Supprimer le message en première position
AT + CMGDA = "SUPPRIMER TOUT"	Supprimer tous les messages de la carte SIM
AT + CMGL = "TOUS"	Lire tous les messages de SIM
À + CMGF = 1	Définissez la configuration SMS. «1» correspond au mode texte uniquement
AT + CMGS = "+91 968837XXXX" > Texte CircuitDigest	Envoie des SMS à un numéro particulier ici 968837XXXX. Lorsque vous voyez «>», commencez à saisir le texte. Appuyez sur Ctrl + Z pour envoyer le texte.
AT + CGATT?	Pour vérifier la connexion Internet sur la carte SIM
À + CIPSHUT	Pour fermer la connexion TCP, c'est-à-dire se déconnecter d'Internet
AT + CSTT = "APN", "username", "Pass"	Connectez-vous au GPRS avec votre APN et votre clé d'accès. Peut être obtenu auprès du fournisseur de réseau.
AT + CIICR	Vérifiez si la carte SIM a un pack de données
AT + CIFSR	Obtenir l'IP du réseau SIM
AT + CIPSTART = "TCP", "SERVER IP", "PORT"	Utilisé pour définir une connexion TCP IP
À + CIPSEND	Cette commande est utilisée pour envoyer des données au serveur

Schéma:

Le schéma de connexion pour l' interfaçage du module GSM avec le microcontrôleur PIC est illustré ci-dessous.

Nous avons simplement interfacé les broches Tx et Rx du module GSM avec les broches Rx et Tx du PIC MCU PIC16F877A respectivement. Cela établira une connexion série entre les deux. N'oubliez pas non plus de mettre à la terre les modules GSM et PIC. Nous avons également utilisé un écran LCD pour connaître l'état de notre module GSM. Une fois les connexions effectuées, votre matériel ressemblera à quelque chose ci-dessous.

La carte PIC Perf a été conçue pour notre série de tutoriels PIC, dans lesquels nous avons appris à utiliser le microcontrôleur PIC. Vous voudrez peut-être revenir à ces didacticiels de microcontrôleur PIC utilisant MPLABX et XC8 si vous ne savez pas comment graver un programme à l'aide de Pickit 3, car je vais sauter toutes ces informations de base.

Programmation de votre microcontrôleur PIC:

Le programme complet de ce projet se trouve au bas de ce tutoriel. Ici, je vais vous expliquer quelques fonctions et morceaux de code importants. Ce programme dispose également d'un code LCD provenant de l'interface LCD avec le microcontrôleur PIC, vous pouvez visiter ce didacticiel si vous êtes curieux de savoir comment l'écran LCD peut être utilisé avec le microcontrôleur PIC.

Comme dit précédemment, nous allons communiquer entre PIC et GSM en utilisant des commandes AT via le mode de communication série. Donc, nous devons d'abord initialiser le module de communication USART dans notre microcontrôleur PIC en utilisant Initialize _SIM900 (); fonction. Dans cette fonction, nous déclarons les broches Tx et RX et initialisons la réception et la transmission asynchrones à un débit de 9600 bauds et en mode 8 bits.

// *** Initialiser UART pour SIM900 ** // void Initialize_SIM900 (void) {// **** Définition des broches d'E / S pour UART **** // TRISC6 = 0; // Broche TX définie comme sortie TRISC7 = 1; // Broche RX définie comme entrée // ________ Jeu de broches E / S __________ // / ** Initialise le registre SPBRG pour le débit en bauds requis et règle BRGH pour le débit en bauds rapide ** / SPBRG = 129; // SIM900 fonctionne à un débit de 9600 bauds, donc 129 BRGH = 1; // pour un débit en bauds élevé // _________ Fin du paramètre de débit en bauds _________ // // **** Activer le port série asynchrone ******* // SYNC = 0; // SPEN asynchrone = 1; // Activer les broches du port série // _____ Port série asynchrone activé _______ // // ** Permet de préparer la transmission et la réception ** // TXEN = 1; // activer la transmission CREN = 1; // activer la réception // __ module UART activé et prêt pour la transmission et la réception __ // // ** Sélectionnez le mode 8 bits ** // TX9 = 0; // Réception 8 bits sélectionnée RX9 = 0;// Mode de réception 8 bits sélectionné // __ Mode 8 bits sélectionné __ //} // ________ Module UART Initialisé __________ //

Nous devons maintenant lire et écrire des informations depuis / vers notre module GSM. Pour cela, nous utilisons les fonctions _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Ces fonctions utilisent le registre tampon d'émission et de réception tel que TXREG et RCREG pour lire ou écrire des données en série.

// ** Fonction pour envoyer un octet de date à UART ** // void _SIM900_putch (char bt) {while (! TXIF); // maintient le programme jusqu'à ce que le tampon TX soit libre TXREG = bt; // Charge le tampon de l'émetteur avec la valeur reçue} // _____________ Fin de la fonction ________________ // // ** Fonction pour obtenir un octet de date de UART ** // char _SIM900_getch () {if (OERR) // vérifier l'erreur { CREN = 0; // Si erreur -> Réinitialiser CREN = 1; // Si erreur -> Réinitialiser} while (! RCIF); // maintenez le programme jusqu'à ce que le tampon RX soit libre return RCREG; // recevoir la valeur et l'envoyer à la fonction principale} // _____________ Fin de la fonction ________________ // // ** Fonction pour convertir la chaîne en octet ** // void SIM900_send_string (char * st_pt) {while (* st_pt) // s'il y a est un caractère _SIM900_putch (* st_pt ++);// le traiter comme une donnée d'octet} // ___________ Fin de la fonction ______________ // // ** Fin des codes modifiés ** // void _SIM900_print (unsigned const char * ptr) {while (* ptr! = 0) {_SIM900_putch (* ptr ++); }

Les fonctions ci-dessus sont universelles et n'ont pas besoin d'être modifiées pour aucune application. Ils n'ont été expliqués que pour donner une intro approximative. Vous pouvez les approfondir si vous le souhaitez grâce à la compréhension.

Maintenant, dans notre fonction principale, nous initialisons la connexion USART et vérifions si nous sommes en mesure de recevoir un «OK» lorsque nous envoyons un «AT» en utilisant la ligne de code ci-dessous

faire {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Module non trouvé"); } while (! SIM900_isStarted ()); // attendre que le GSM renvoie "OK" Lcd_Set_Cursor (2,1); Lcd_Print_String ("Module détecté"); __delay_ms (1500);

La fonction SIM900_isStarted (); enverra "AT" au GSM et attend la réponse "OK" de celui-ci. Si oui, il renverra 1 sinon 0;

Si le module n'est pas détecté ou s'il y a un problème de connexion, l'écran LCD affichera "Module not found", sinon il affichera Le module est détecté et passera à l'étape suivante où, nous vérifions si la carte SIM peut être détectée par le ci-dessous ligne de code.

/ * Vérifier si la carte SIM est détectée * / do {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM non trouvée"); } while (! SIM900_isReady ()); // attendez que le GSM renvoie "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM détectée"); __delay_ms (1500);

La fonction SIM900_isReady () enverra "AT + CPIN?" au GSM et attend la réponse «+ CPIN: READY» de celui-ci. Si oui, il renverra 1 sinon 0;

Si une carte SIM est trouvée, la carte SIM détectée sera affichée sur l'écran LCD. Ensuite, nous pouvons essayer de passer un appel en utilisant la commande « ATD mobilenumber ; ». Ici, à titre d'exemple, j'ai utilisé mon numéro ATD93643159XX;. Vous devez y remplacer votre numéro de mobile respectif.

/ * Passer un appel téléphonique * / do {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Nous appelons ici le numéro 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Passer un appel…."); } while (_SIM900_waitResponse ()! = SIM900_OK); // attend que l'ESP renvoie "OK" Lcd_Set_Cursor (1,1); Lcd_Print_String ("Appel placé…."); __delay_ms (1500);

Une fois l'appel passé, l'écran LCD affichera Appel passé et vous devriez recevoir un appel entrant vers ce numéro spécifié.

Vous pouvez également appeler le numéro de mobile connecté au module GSM et en être averti sur votre écran LCD y en utilisant le code ci-dessous

while (1) {if (_SIM900_waitResponse () == SIM900_RING) // Vérifie s'il y a un appel entrant {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Appel entrant !!."); }}

Lorsque le module GSM détecte un appel entrant, il affichera Appel entrant sur la deuxième ligne du module LCD. La fonction _SIM900_waitResponse () vérifiera les données entrantes du module GSM. Lorsqu'il reçoit SIM900_RING, ce qui équivaut à «RING» en raison de waitResponce () , nous afficherons le statut «Appel entrant».

Vous pouvez créer vos propres fonctions comme celle-ci pour effectuer presque tous les types d'activations à l'aide du module GSM. Si vous voulez avoir des choses codées en dur, vous pouvez simplement utiliser la fonction __SIM900_print () pour envoyer n'importe quelle commande AT comme celle-ci ci-dessous.

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

N'oubliez pas que toutes vos commandes doivent être suivies de «\ r \ n» pour indiquer que la commande se termine.

Simulation:

Une fois que vous avez compris le fonctionnement du programme, vous pouvez essayer de simuler et d'apporter des modifications en fonction de vos besoins. La simulation vous fera gagner beaucoup de temps. La simulation se fait à l'aide de Proteus et ressemble à ci-dessous.

Comme vous pouvez le voir, nous avons utilisé l'option de terminal virtuel dans Proteus pour vérifier si le programme répond comme prévu. Nous pouvons alimenter les valeurs via la boîte de dialogue contextuelle. Par exemple, dès que nous appuierons sur exécuter, une boîte de dialogue noire comme ci-dessus apparaîtra et affichera AT, cela signifie qu'il a envoyé le module GSM AT, maintenant nous pouvons répondre à PIC en tapant dans la case "OK" et appuyez sur Entrée et le PIC y répondra. De même, nous pouvons essayer pour toutes les commandes AT.

Passer et recevoir des appels via GSM et PIC:

Une fois que vous avez compris comment le code et le matériel fonctionnent, téléchargez simplement le programme ci-dessous sur PIC et mettez le module sous tension. Votre écran LCD doit afficher «Module détecté», «SIM détecté» et «Appel placé» si tout fonctionne correctement. Une fois que vous voyez «Appel placé», vous recevrez un appel entrant au numéro spécifié dans le programme.

Vous pouvez également essayer d'appeler le numéro présent dans le module GSM et votre écran LCD affichera «Appel entrant» pour indiquer que la carte SIM est appelée.

Le fonctionnement complet du projet est montré dans la vidéo ci-dessous. J'espère que vous avez compris le projet et que vous avez aimé le faire. Si vous avez un problème pour faire fonctionner les choses, postez votre question dans la section des commentaires ou sur nos forums et je serai heureux de vous aider.