Comment utiliser SIM800L et SIM900 module GSM GPRS avec Arduino

Modules GSM (Global System for Mobile Communications) et GPRS (General Packet Radio Service) sont utilisé pour établir des communications entre des dispositifs mobiles ou des machines informatiques et un système GSM ou GPRS. Dans cet article, nous allons explorer en détail ce qu’est le GSM, ce qu’est le GPRS, les modules GSM, les applications des modules GSM et GPRS, ainsi que les commandes AT (Attention) utilisées pour les contrôler.

Qu’est-ce qu’un module GSM / GPRS?

Module GSM ou GPRS est utilisé pour établir une communication entre un dispositif mobile ou une machine informatique et un système GSM ou GPRS. Le modem (modulateur-démodulateur) joue un rôle crucial dans ce processus. Les modules GSM peuvent être des modems dédiés avec une connexion série, USB ou Bluetooth, ou ils peuvent être des téléphones mobiles offrant des fonctionnalités de modem GSM.

Applications des modules GSM GPRS

Les modules GSM et GPRS offrent de nombreuses applications pratiques. Ils permettent d’envoyer et de recevoir des appels téléphoniques, des SMS (Short Message Service) et des MMS (Multimedia Messaging Service) via un ordinateur ou une machine informatique. Ils sont principalement utilisés pour les services de SMS et de MMS basés sur ordinateur. Par exemple, des projets Arduino peuvent utiliser un module GSM pour envoyer des SMS.

Tâches pouvant être effectuées par les commandes AT

Les commandes AT fournissent un ensemble d’instructions permettant de configurer et de contrôler les fonctionnalités des modules GSM/GPRS SIM800L et SIM900A. Voici quelques-unes des tâches couramment réalisées à l’aide de ces commandes :

1. Gestion générale :
   • ATI[<valeur>] : Affichage des paramètres du module.
   • ATZ[<valeur>] : Réinitialisation des paramètres utilisateur par défaut.
   • AT&F[<valeur>] : Réinitialisation des paramètres du fabricant.
   • ATE[<valeur>] : Activation ou désactivation de l’écho des commandes AT.
   • ATQ[<valeur>] : Activation ou désactivation de l’affichage des résultats.
   • ATV[<valeur>] : Activation ou désactivation du mode verbeux pour les réponses.
2. Gestion des appels :
   • AT+CSTA=[<type>] : Sélection du type de numérotation téléphonique.
   • ATD<option> : Établissement d’un appel vocal ou autre.
   • ATA : Réponse à un appel entrant.
   • ATH : Raccrochage de la communication en cours.
   • AT+CHUP : Raccrochage de l’appel en cours (version GSM).
3. Gestion des SMS :
   • AT+CMGF=[<mode>] : Sélection du format de message (PDU ou texte).
   • AT+CMGS=<da>[,<toda>] : Envoi de messages (terminés par Ctrl+Z).
   • AT+CMGR=<index> : Lecture des messages.
   • AT+CMGD=<index> : Suppression des messages.
4. Gestion des informations réseau :
   • AT+CREG : Informations d’enregistrement sur le réseau.
   • AT+COPS : Liste et sélection de l’opérateur réseau.
   • AT+CLIP : Identification de l’appelant.
   • AT+CLIR : Restriction d’identification de l’appel.
5. Gestion de la batterie et de la puissance :
   • AT+CBC : Vérification de l’état de la batterie.
   • AT+CSQ : Vérification de la qualité du signal.
6. Gestion du répertoire téléphonique :
   • AT+CPBS=<mem> : Sélection de la mémoire du répertoire.
   • AT+CPBR=<ind1>[,<ind2>] : Lecture des entrées du répertoire.
   • AT+CPBW=[<index>][,<number>[,<type>[,<text>]]] : Écriture dans le répertoire.
7. Gestion des paramètres du module :
   • AT+CGMI : Nom du fabricant du module.
   • AT+CGMM : Identification du modèle du module.
   • AT+CGMR : Version et niveau du firmware du module.
   • AT+CGSN : Numéro IMEI du module.
8. Gestion des paramètres SMS :
   • AT+CSMS=<service> : Sélection du service de message.
   • AT+CSCA=<sca>[,<tosca>] : Sélection de l’adresse du SMSC.
   • AT+CSMP : Gestion des paramètres du mode texte des SMS.
   • AT+CSDH : Affichage détaillé du mode texte des SMS.

Note : Ces exemples de commandes AT représentent une partie des fonctionnalités disponibles avec les modules SIM800L et SIM900A. Il est important de se référer à la documentation officielle du fabricant pour obtenir la liste complète des commandes prises en charge et leurs descriptions détaillées.

Module SIM800L

SIM800L V1 est un module GSM/GPRS compact conçu pour ajouter une connectivité GSM/GPRS à différents projets électroniques tels que l’automatisation domestique, les systèmes d’urgence, la télésurveillance et la communication.

Ce module peut être facilement connecté à un microcontrôleur via une interface série UART et prend en charge diverses commandes AT pour l’envoi et la réception de messages SMS, les appels vocaux et la transmission de données sur le réseau GPRS.

Il nécessite une alimentation capable de fournir jusqu’à 2 A en crête, et son connecteur de carte SIM prend en charge uniquement les cartes micro-SIM 2G

Spécifiques techniques du modules

1. Puce cellulaire GSM SIM800L.
2. Plage de tension de fonctionnement : 3,4 V à 4,4 V.
3. Tension d’alimentation recommandée : 4V.
4. Courant de crête : 2A.
5. Consommation électrique en mode veille : <2,0 mA.
6. Consommation électrique en mode inactif : <7,0 mA.
7. Fréquences prises en charge : Quadruple bande 2G (850/950/1800/1900 MHz).
8. Puissance de transmission : Classe 4 (2W) pour GSM850, Classe 1 (1W) pour DCS1800.
9. Interface : UART avec commandes AT.
10. Connecteur de carte SIM : Micro-SIM.
11. Indicateur d’état du réseau : LED.
12. Connecteur d’antenne : U.FL et broche d’en-tête.
13. Plage de température de travail : -40 à +85 °C.
14. Taille du module : 25 x 23 mm.

Pour plus d’information,vous pouvez consulter la fiche technique du module : https://www.makerhero.com/img/files/download/Datasheet_SIM800L.pdf

Module SIM900

Module GSM SIM900A est un module utiliser pour la communication GPRS/GSM. Il est couramment utilisé avec Arduino et les microcontrôleurs dans la plupart des applications embarquées. Le module offre la technologie GPRS/GSM pour communiquer à l’aide d’une carte SIM mobile. Il utilise les bandes de fréquences 850 et 1900 MHz et permet aux utilisateurs de recevoir/envoyer des appels mobiles et des SMS. L’interface du clavier et de l’affichage permet aux développeurs de créer des applications personnalisées avec le module. De plus, il dispose de modes, le mode commande et le mode données

Spécifications techniques du SIM900

• Type de module : SIM900
• Réseaux pris en charge : GSM/GPRS
• Bandes de fréquences : Quad-bande (850/900/1800/1900 MHz) pour les réseaux GSM
• Station mobile GPRS : Classe B
• Puissance de sortie :
  • Niveau 4 (2 W @ 850/900 MHz)
  • Niveau 1 (1 W @ 1800/1900 MHz)
• Commandes AT supportées :
  • Commandes standard : GSM 07.07 et 07.05
• Fonctionnalités de messagerie :
  • Service de messagerie court : Envoi de petites quantités de données sur le réseau (ASCII ou hexadécimal brut).
• Fonctionnalités de communication :
  • Pile TCP/UDP intégrée : Téléchargement de données vers un serveur Web.
  • Prise en charge de RTC (Real-Time Clock – Horloge en temps réel).
• Consommation d’énergie :
  • Mode veille : 1,5 mA (faible consommation)
• Plage de température supportée : -40 à +85 ℃

Pour plus d’information, vous pouvez consulter la fiche technique du module : https://simcom.ee/documents/SIM900/SIM900_Hardware%20Design_V2.05.pdf

Utilisation du module SIM800l avec Arduino

Matériels nécessaires

• Arduino Uno
• Batterie Li-Po 3.7V
• Une carte 2G
• Module SIM800L V1
• Résistance 1,69k et 3,3k
• Cable de connexion

Branchement du module avec Arduino

• Connectez la broche GND (masse) du module SIM800l à la broche GND de l’Arduino UNO.
• Connectez la broche SIM800 TXD à la broche numérique 8 (D8) de l’Arduino UNO.
• Connectez la broche SIM800 RXD à la broche numérique 7 (D7) de l’Arduino UNO.
• Insérez la carte microSIM à l’arrière du module SIM800.
• Pour assurer la compatibilité, utilisez un diviseur de tension à base de résistances pour réduire le signal TX de 5V à 3,3V. Une configuration simple de diviseur de tension avec une résistance de 1,69k en haut et une résistance de 3,3k en bas peut être utilisée
• Connectez la broche GND et Vcc du module à une batterie Li-Po 3.7V
• Connectez l’antenne à la prise mini située dans la partie supérieure gauche du module SIM800.

Arduino Code – Test des AT Commands

Pour vérifier la communication entre l’Arduino et le module SIM800L, nous allons utiliser les commandes AT. Voici un exemple de code :

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 2); // Tx, Rx

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);

  Serial.println("Initialisation...");
  delay(1000);

  mySerial.println("AT");
  updateSerial();
  mySerial.println("AT+CSQ");
  updateSerial();
  mySerial.println("AT+CCID");
  updateSerial();
  mySerial.println("AT+CREG?");
  updateSerial();
}

void loop() {
  updateSerial();
}

void updateSerial() {
  delay(500);
  while (Serial.available()) {
    mySerial.write(Serial.read());
  }
  while (mySerial.available()) {
    Serial.write(mySerial.read());
  }
}

Maintenant que le code est téléchargé sur l’Arduino, ouvrez le moniteur série à une vitesse de 9600 bauds. Vous devriez voir les résultats des commandes AT affichés.

Explication du code

Nous utilisons la bibliothèque SoftwareSerial pour communiquer avec le module SIM800L via les broches 3 (Tx) et 2 (Rx) de l’Arduino.

Dans la fonction setup(), nous initialisons les connexions série et envoyons des commandes AT pour tester la communication.

La fonction loop() appelle la fonction updateSerial() pour maintenir la communication entre l’Arduino et le module SIM800L.

La fonction updateSerial() lit les données disponibles sur le port série de l’Arduino et les transmet au module SIM800L, et vice versa.

Code Arduino – Envoi d’un SMS

Dans cette section, nous allons vous montrer comment envoyer un SMS à l’aide du module SIM800L. Voici un exemple de code :

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 2); // Tx, Rx

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);

  Serial.println("Initialisation...");
  delay(1000);

  mySerial.println("AT");
  updateSerial();
  mySerial.println("AT+CMGF=1");
  updateSerial();
  mySerial.println("AT+CMGS=\"+ZZxxxxxxxxxx\"");
  updateSerial();
  mySerial.print("Message du tutoriel");
  updateSerial();
  mySerial.write(26); // Ctrl+Z
}

void loop() {
}

void updateSerial() {
  delay(500);
  while (Serial.available()) {
    mySerial.write(Serial.read());
  }
  while (mySerial.available()) {
    Serial.write(mySerial.read());
  }
}

Explication du code

Nous utilisons à nouveau la bibliothèque SoftwareSerial pour la communication.

Dans la fonction setup(), nous envoyons les commandes AT nécessaires pour configurer le module SIM800L en mode SMS et spécifier le numéro de téléphone destinataire.

Ensuite, nous utilisons mySerial.print() pour envoyer le contenu du message et mySerial.write() pour envoyer le caractère de fin de message (Ctrl+Z).

La fonction loop() est vide car nous voulons envoyer le SMS une seule fois.

Code Arduino – Lecture d’un SMS

Dans cette section, nous allons vous montrer comment lire un SMS reçu par le module SIM800L. Voici un exemple de code :

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 2); // Tx, Rx

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);

  Serial.println("Initialisation...");
  delay(1000);

  mySerial.println("AT");
  updateSerial();
  mySerial.println("AT+CMGF=1");
  updateSerial();
  mySerial.println("AT+CNMI=1,2,0,0,0");
  updateSerial();
}

void loop() {
  updateSerial();
}

void updateSerial() {
  delay(500);
  while (Serial.available()) {
    mySerial.write(Serial.read());
  }
  while (mySerial.available()) {
    Serial.write(mySerial.read());
  }
}

Explication du code

Comme précédemment, nous utilisons la bibliothèque SoftwareSerial pour la communication.

Dans la fonction setup(), nous envoyons les commandes AT nécessaires pour configurer le module SIM800L en mode SMS et spécifier comment les nouveaux SMS doivent être gérés.

La fonction loop() appelle la fonction updateSerial() pour maintenir la communication et lire les SMS entrants.

Les SMS reçus sont affichés sur le moniteur série.

L’envoie des SMS et appel avec module GSM SIM900 et Arduino

Branchement du module SIM900 avec Arduino

1. Branchez l’alimentation externe de 5V 2A au module SIM900A via le connecteur Jack.
2. Connectez la broche TX du module GSM (transmission) à la broche 7 de l’Arduino (réception).
3. Connectez la broche RX du module GSM (réception) à la broche 8 de l’Arduino (transmission).

Note : Il est important de noter que la broche de mise à la terre (GND) de l’Arduino doit également être connectée à la broche GND du module GSM pour établir une référence de tension commune.

Code pour l’interfaçage du module GSM SIM900A avec Arduino :

Pour faciliter l’utilisation des broches série de l’Arduino pour le téléversement du code, nous utiliserons la bibliothèque SoftwareSerial. Voici un exemple de code pour l’envoi d’un SMS et la réception d’un appel téléphonique :

#include <SoftwareSerial.h>

SoftwareSerial mySerial(7, 8);

void setup() {
  mySerial.begin(9600);   // Configuration du débit en bauds du module GSM
  Serial.begin(9600);    // Configuration du débit en bauds du moniteur série Arduino
  delay(100);
}

void loop() {
  if (Serial.available() > 0) {
    switch (Serial.read()) {
      case 's':
        SendMessage();
        break;
      case 'd':
        DialCall();
        break;
    }
  }
  if (mySerial.available() > 0)
    Serial.write(mySerial.read());
}

void SendMessage() {
  mySerial.println("AT+CMGF=1");   // Configuration du module GSM en mode texte
  delay(1000);
  mySerial.println("AT+CMGS=\"+xxxxxxxxxxx\"\r"); // Remplacer x par le numéro de téléphone mobile
  delay(1000);
  mySerial.println("Je vous envoie un SMS depuis le module GSM");  // Le contenu du SMS à envoyer
  delay(100);
  mySerial.println((char)26);  // Code ASCII de CTRL+Z
  delay(1000);
}

void DialCall() {
  mySerial.println("ATD+xxxxxxxxxxxx;"); // Remplacer x par le numéro de téléphone
  delay(100);
}

Explication du code :

• Nous incluons la bibliothèque SoftwareSerial pour établir une communication série avec le module GSM SIM900.
• Dans la fonction setup(), nous configurons les débits en bauds du module GSM et du moniteur série Arduino, puis nous ajoutons un délai de 100 millisecondes.
• Dans la fonction loop(), nous attendons une entrée de l’utilisateur via le moniteur série Arduino. Si l’entrée est ‘s’, nous appelons la fonction SendMessage() pour envoyer un SMS. Si l’entrée est ‘d’, nous appelons la fonction DialCall() pour effectuer un appel téléphonique. Toutes les données reçues du module GSM sont écrites sur le moniteur série Arduino.
• La fonction SendMessage() envoie un SMS en envoyant des commandes AT au module GSM pour le configurer en mode texte, spécifier le numéro de téléphone destinataire et envoyer le contenu du SMS. Le contenu du SMS se termine par l’envoi du code ASCII de CTRL+Z.
• La fonction DialCall() effectue un appel téléphonique en envoyant une commande AT au module GSM avec le numéro de téléphone à appeler.

Lien outils

Pour découvrir plus de tutoriel, vous pouvez consulter notre bloc : https://www.moussasoft.com/tutoriels-electroniques

Twitter: Moussa Lhoussaine (@Moussasoft_com) / Twitter