Guide du bouclier SIM900 GSM GPRS avec Arduino

Cet article est un guide complet du Shield SIM900 GSM GPRS avec l’Arduino. Apprenez à envoyer et recevoir des SMS et à passer et recevoir des appels téléphoniques avec Arduino.

Dans ce guide, nous couvrirons :

Présentation du SIM900 GSM GPRS Shield
Matériel de blindage SIM900 GSM GPRS
Commandes SIM900 AT
Tester le bouclier
Envoi et réception de SMS – exemple
Passer et recevoir des appels téléphoniques – exemple

Présentation du SIM900 GSM GPRS Shield

Le bouclier SIM900 GSM GPRS est illustré dans la figure ci-dessous.

GSM signifie Global System for M obile Communications et est la norme mondiale pour les communications mobiles.

GPRS signifie General P acket R adio S ervice . GPRS est un service mobile sur la communication cellulaire 2G et 3G.

Applications:

Le shield GSM GPRS est particulièrement utile car il permet de :

Connectez-vous à Internet via le réseau GPRS
Envoyer et recevoir des SMS
Passer et recevoir des appels téléphoniques

Ses capacités le rendent parfait pour les projets avec Arduino comme :

Contrôle à distance des appareils électroniques – envoi d’un SMS pour allumer quelque chose ;
Recevez des notifications – envoyez des SMS à votre téléphone portable si un mouvement est détecté dans votre maison ;
Recevez des données de capteur – envoyez des SMS périodiques à votre téléphone portable avec des données météorologiques quotidiennes.

Caractéristiques

Voici quelques-unes des caractéristiques les plus importantes du bouclier :

Compatible avec Arduino et les clones
Basé sur le module SIM900 de SIMCOM
Vous permet d’envoyer des SMS, MMS, GPRS et Audio via UART en utilisant les commandes AT.
Il dispose de 12 GPIO, 2 PWM et ADC intégré du module SIM900
Quadri-bande : 850 ; 900 ; 1800 et 1900 MHZ, il devrait donc fonctionner dans tous les pays avec des réseaux GSM (2G)
Contrôle via les commandes AT
Prend en charge RTC (horloge en temps réel) – il a un support pour une pile 3V CR1220 à l’arrière

Possède des prises microphone et casque pour les appels téléphoniques

Où acheter?

Vous pouvez vérifier le bouclier SIM900 GSM GPRS ocraelec.com et trouver le meilleur prix.

Étapes préliminaires

Avant de commencer avec votre module SIM900 GSM GPRS, vous devez prendre en compte certains aspects concernant la carte SIM et l’alimentation du blindage.

Couverture GSM

Assurez-vous d’avoir une couverture sur un réseau GSM 850 MHz, GSM 900 MHz, DCS 1800 MHz ou PCS 1900 MHz. Par GSM, nous entendons 2G.

Carte SIM prépayée

Nous vous recommandons d’utiliser un forfait prépayé ou un forfait avec SMS illimités à des fins de test. Sinon, en cas de problème, vous devrez peut-être payer une facture énorme pour des centaines de SMS envoyés par erreur. Dans ce tutoriel, nous utilisons un forfait prépayé avec SMS illimités.

Le bouclier utilise la taille de la carte SIM d’origine, pas micro ou nano. Si vous avez un micro ou un nano, vous pouvez envisager de vous procurer un adaptateur de la taille d’une carte SIM .

Désactiver le verrouillage par code PIN

Pour utiliser la carte SIM avec le bouclier, vous devez désactiver le verrouillage par broche. Pour ce faire, le moyen le plus simple consiste à insérer la carte SIM dans votre smartphone et à désactiver le verrouillage par code PIN dans les paramètres de sécurité du téléphone.

Dans mon cas, j’ai dû passer par : Paramètres > Paramètres avancés > Sécurité > Verrouillage SIM et désactiver le verrouillage de la carte sim avec le code PIN.

Obtenir la bonne alimentation

Le bouclier a une prise CC pour l’alimentation, comme indiqué dans la figure ci-dessous.

À côté de la prise d’alimentation, il y a un interrupteur à bascule pour sélectionner la source d’alimentation. À côté de l’interrupteur à bascule sur la carte, il y a une flèche indiquant la position de bascule pour utiliser une alimentation externe – déplacez l’interrupteur à bascule pour utiliser l’alimentation externe comme indiqué ci-dessus.

Pour alimenter le shield, il est conseillé d’utiliser une alimentation 5V pouvant fournir 2A comme celle présentée ci-dessous. Il peut également être alimenté en 9V 1A, ou 12V 1A.

Vous pouvez trouver le bon adaptateur secteur pour ce bouclier ici . Assurez-vous de sélectionner le modèle avec 5V et 2A.

Présentation Matérielle du Shield SIM900 GSM GPRS

La figure ci-dessous montre l’arrière du bouclier. Il a un support pour la carte SIM et pour une pile 3V CR1220 pour le RTC (horloge en temps réel).

La figure ci-dessous montre les composants les plus importants du bouclier sur la carte auxquels vous devez faire attention.

Commencer

1) Insérez la carte SIM dans le support de carte SIM – assurez-vous d’avoir lu les étapes préliminaires de la section précédente.

2) Assurez-vous que l’antenne est bien connectée.

3) Sur le port série sélectionné, assurez-vous que le capuchon du cavalier est connecté comme indiqué dans la figure ci-dessous pour utiliser le logiciel série.

4) Alimentez le bouclier à l’aide d’une alimentation externe 5V. Assurez-vous de sélectionner la source d’alimentation externe avec l’interrupteur à bascule à côté de la prise CC.

5) Pour allumer/éteindre le bouclier, appuyez sur la touche d’alimentation pendant environ 2 secondes.

6) Ensuite, la LED d’état s’allumera et la LED NetLight clignotera toutes les 800 ms jusqu’à ce qu’elle trouve le réseau. Lorsqu’il trouve le réseau, le voyant NetLight commence à clignoter toutes les trois secondes.

Remarque : vous pouvez allumer automatiquement le bouclier via un logiciel. Découvrez comment procéder dans la section Activer automatiquement le bouclier , après les exemples de code.

7) Vous pouvez tester si le bouclier fonctionne correctement en envoyant des commandes AT depuis l’IDE Arduino à l’aide d’un programmeur FTDI – comme nous le montrerons plus loin dans ce guide.

Commandes SIM900 AT

configurez le SIM900 en mode texte : AT+CMGF=1\r
envoyer un SMS vers un numéro : AT+CMGS= PHONE_NUMBER (au format international)
lire le premier SMS de la boîte de réception : AT+CMGR=1\r
lire le deuxième SMS depuis la boîte de réception : AT+CMGR=2\r
lire tous les SMS de la boîte de réception : AT+CMGR=ALL\r
appel vers un numéro : ATDP+ PHONE_NUMBER (au format international)
raccrocher un appel : ATH
recevoir un appel entrant : ATA

Pour plus d’informations, vous pouvez consulter le manuel des commandes SIM900 AT ici .

Test du shield avec le programmeur FTDI

Pour tester si tout fonctionne correctement, vous pouvez tester le bouclier en envoyant des commandes AT à partir du moniteur série Arduino IDE. Pour cela, vous avez besoin d’un programmeur FTDI comme celui illustré dans la figure ci-dessous. Vous pouvez obtenir un programmeur FTDI comme celui- ci ici .

1) Connectez le programmateur FTDI au blindage GSM comme indiqué sur la figure ci-dessous.

2) Ouvrez l’IDE Arduino et sélectionnez le bon port COM.

3) Ouvrez le moniteur série

4) Sélectionnez un débit en bauds de 19 200 – le réglage par défaut du blindage est 19 200 – et un retour chariot . Écrivez AT dans la case surlignée en rouge, puis appuyez sur Entrée. Voir la figure ci-dessous.

5) Le bouclier répondra parOK, si tout fonctionne correctement.

Connexion du Shield à Arduino

Connectez le blindage à l’Arduino comme indiqué dans les schémas ci-dessous.

Envoi d’un SMS

Pour envoyer un SMS, téléchargez le code ci-dessous sur votre carte Arduino.

#include <SoftwareSerial.h>

// Configure software serial port
SoftwareSerial SIM900(7, 8); 

void setup() {
  // Arduino communicates with SIM900 GSM shield at a baud rate of 19200
  // Make sure that corresponds to the baud rate of your module
  SIM900.begin(19200);
  // Give time to your GSM shield log on to network
  delay(20000);   
  
  // Send the SMS
  sendSMS();
}

void loop() { 
  
}

void sendSMS() {
  // AT command to set SIM900 to SMS mode
  SIM900.print("AT+CMGF=1\r"); 
  delay(100);

  // REPLACE THE X's WITH THE RECIPIENT'S MOBILE NUMBER
  // USE INTERNATIONAL FORMAT CODE FOR MOBILE NUMBERS
  SIM900.println("AT+CMGS=\"+XXXXXXXXXXXX\""); 
  delay(100);
  
  // REPLACE WITH YOUR OWN SMS MESSAGE CONTENT
  SIM900.println("Message example from Arduino Uno."); 
  delay(100);

  // End AT command with a ^Z, ASCII code 26
  SIM900.println((char)26); 
  delay(100);
  SIM900.println();
  // Give module time to send SMS
  delay(5000); 
}

Dans ce code, vous commencez par inclure la bibliothèque SoftwareSerial.h et créez un port série logiciel sur les broches 7 et 8. (La broche 7 est définie comme RX et 8 comme TX)

#include <SoftwareSerial.h>
LogicielSerial SIM900(7, 8);

La fonction sendSMS() créée est ce qui envoie réellement le SMS. Cette fonction utilise les commandes AT : AT+CMGF=1\ r et AT + CMGS .

Vous devez modifier le numéro de portable du destinataire à : (remplacez les X par le numéro de téléphone du destinataire)

SIM900.println("AT + CMGS = \" ++++++++++++++ "");

Le numéro de portable du destinataire doit être au format international.

Ensuite, à la ligne suivante, vous pouvez modifier le texte que vous souhaitez envoyer.

// REMPLACER PAR VOTRE PROPRE CONTENU DE MESSAGE SMS 
SIM900.println(" Exemple de message d'Arduino Uno. ")

Lecture des SMS reçus

Pour lire les SMS entrants, téléchargez le code ci-dessous sur votre Arduino. Après le téléchargement, attendez 20 secondes que le bouclier établisse la communication. Ensuite, testez le script en envoyant un SMS au numéro de carte SIM shield. Le SMS est affiché sur le moniteur série Arduino – débit en bauds : 19200.

#include <SoftwareSerial.h>

// Configure software serial port
SoftwareSerial SIM900(7, 8);
//Variable to save incoming SMS characters
char incoming_char=0;

void setup() {
  // Arduino communicates with SIM900 GSM shield at a baud rate of 19200
  // Make sure that corresponds to the baud rate of your module
  SIM900.begin(19200);
  // For serial monitor
  Serial.begin(19200); 
  // Give time to your GSM shield log on to network
  delay(20000);

  // AT command to set SIM900 to SMS mode
  SIM900.print("AT+CMGF=1\r"); 
  delay(100);
  // Set module to send SMS data to serial out upon receipt 
  SIM900.print("AT+CNMI=2,2,0,0,0\r");
  delay(100);
}

void loop() {
  // Display any text that the GSM shield sends out on the serial monitor
  if(SIM900.available() >0) {
    //Get the character from the cellular serial port
    incoming_char=SIM900.read(); 
    //Print the incoming character to the terminal
    Serial.print(incoming_char); 
  }
}

Dans ce code, vous configurez le module pour envoyer les données SMS à la sortie série :

SIM900.print("AT+CNMI=2,2,0,0,0\r");

Vous stockez les caractères entrants du message SMS dans la variable coming_char . Vous lisez les caractères en utilisant la fonction SIM900.read() .

Passer un appel téléphonique

Pour passer un appel téléphonique, téléchargez le code suivant sur votre Arduino.

N’oubliez pas de modifier le code avec le numéro de téléphone que vous souhaitez appeler.

#include <SoftwareSerial.h>

// Configure software serial port
SoftwareSerial SIM900(7, 8); 

void setup() {
  // Arduino communicates with SIM900 GSM shield at a baud rate of 19200
  // Make sure that corresponds to the baud rate of your module
  SIM900.begin(19200);
  // Give time to your GSM shield log on to network
  delay(20000);

  // Make the phone call
  callSomeone();
}

void loop() {
  
}

void callSomeone() {
  // REPLACE THE X's WITH THE NUMER YOU WANT TO DIAL
  // USE INTERNATIONAL FORMAT CODE FOR MOBILE NUMBERS
  SIM900.println("ATD + +XXXXXXXXX;");
  delay(100);
  SIM900.println();
  
 // In this example, the call only last 30 seconds
 // You can edit the phone call duration in the delay time
  delay(30000);
  // AT command to hang up
  SIM900.println("ATH"); // hang up
}

Pour effectuer l’appel, vous utilisez la fonction callSomeone() qui utilise la commande ATD .

SIM900.println("ATD + + XXXXXXXXX ;");

Vous devez remplacer les X (surlignés en rouge) par le numéro de téléphone que vous souhaitez appeler.

N’oubliez pas de connecter un microphone et des écouteurs pour passer l’appel.

Dans cet exemple de code, l’appel est raccroché au bout de 30 secondes, à l’aide de la commande ATH :

SIM900.println("ATH");

Raccrocher après 30 secondes n’est pas très utile, mais cela fonctionne bien pour un exemple. L’idée est que vous utilisez la commande ATH lorsqu’un événement est déclenché. Par exemple, connectez un bouton-poussoir à l’Arduino, qui, lorsqu’il est enfoncé, envoie la commande ATH pour raccrocher le téléphone.

Répondre aux appels téléphoniques entrants

Le code suivant répond aux appels entrants.

#include <SoftwareSerial.h>

// Configure software serial port
SoftwareSerial SIM900(7, 8); 
char incoming_char=0;

void setup() {
  // Arduino communicates with SIM900 GSM shield at a baud rate of 19200
  // Make sure that corresponds to the baud rate of your module
  SIM900.begin(19200); // for GSM shield
  // For serial monitor
  Serial.begin(19200); 
  // Give time to log on to network.
  delay(20000); 
  
  SIM900.print("AT+CLIP=1\r"); // turn on caller ID notification
  delay(100);
}

void loop() {
  // Display any text that the GSM shield sends out on the serial monitor
  if(SIM900.available() >0) {
    // Get the character from the cellular serial por
    // With an incomming call, a "RING" message is sent out
    incoming_char=SIM900.read();
    //  Check if the shield is sending a "RING" message
    if (incoming_char=='R') {
      delay(10);
      Serial.print(incoming_char);
      incoming_char=SIM900.read();
      if (incoming_char =='I') {
        delay(10);
        Serial.print(incoming_char);
        incoming_char=SIM900.read();
        if (incoming_char=='N') {
          delay(10);
          Serial.print(incoming_char);
          incoming_char=SIM900.read();
          if (incoming_char=='G') {
            delay(10);
            Serial.print(incoming_char);
            // If the message received from the shield is RING
            // Send ATA commands to answer the phone
            SIM900.print("ATA\r");
          }
        }
      }
    }
  }
}

Lorsque quelqu’un appelle le numéro SIM900, il envoie un message disant « RING ». Pour savoir si quelqu’un vous appelle, vous pouvez attendre les caractères entrants du SIM900, puis comparer s’il s’agissait d’un message RING. C’est ce qui est fait dans ce code. Lorsqu’il reçoit un message RING, vous envoyez la commande ATA pour répondre au téléphone.

Activer automatiquement le shield

Instead of manually pressing the “power” key to turn on the shield, you can automatically turn on the shield via software.

1) First, you need to solder R13 connections on the shield as shown in the figure below – highlighted in red.

2) Connectez D9 sur le blindage à la broche Arduino D9 comme indiqué dans le schéma ci-dessous.

3) Ajoutez l’extrait de code suivant dans la fonction setup(). C’est l’équivalent d’appuyer sur le bouton « power » du bouclier.

digitalWrite(9, ÉLEVÉ);
retard(1000);
digitalWrite(9, BAS);
retard (5000);

Dépannage

Le bouclier ne répond pas par OK

Vérifiez vos connexions TX et RX à l’Arduino. Essayez de répéter le processus en changeant le TX avec les broches RX.

Vérifiez également si vous avez sélectionné le numéro de série du logiciel en plaçant le capuchon du cavalier à l’endroit approprié sur le sélecteur de série.

Impossible de voir les messages dans le moniteur série

Pour voir les messages dans le moniteur série, le blindage et le débit en bauds du port série de l’Arduino doivent être identiques. Le débit en bauds par défaut du bouclier SIM900 GSM GPRS est de 19200. Sélectionnez donc le débit en bauds de l’Arduino sur 19200.

Cependant, si vous devez modifier le débit en bauds du bouclier, vous pouvez envoyer la commande AT suivante pour le modifier à 19200 ou à un autre débit en bauds approprié.

AT+IPR=19200

Conclusion

Ce tutoriel vous montre comment envoyer et recevoir des SMS et passer et recevoir des appels téléphoniques avec l’Arduino. Vous pouvez appliquer les concepts appris dans ce didacticiel pour créer vos propres projets afin de communiquer sur un réseau cellulaire. Nous avons d’autres projets qui utilisent le GSM, vérifiez-les ci-dessous :

Contrôler une lampe 12V par SMS
Demander des données de capteur via SMS à l’aide d’Arduino

By KIRAKOYA51 CEO ocra electronic Burkina Faso

Produits

Guide du bouclier SIM900 GSM GPRS avec Arduino