Bouclier SIM900 GSM GPRS avec Arduino

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

Dans ce guide, nous couvrirons :

• Présentation du bouclier SIM900 GSM GPRS
• Matériel de blindage SIM900 GSM GPRS
• Commandes SIM900 AT
• Test du bouclier
• Envoi et réception de SMS – exemple
• Passer et répondre à des appels téléphoniques – exemple

Présentation du bouclier SIM900 GSM GPRS

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

GSM signifie gglobal Ssystème pour Mobile Communications et est la norme mondiale pour les communications mobiles.

GPRS signifie ggénéral Paccuser Raudio Sservice. 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 :

• Se connecter à 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 les données du 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 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 sur Maker Advisor et trouvez le meilleur prix.

Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Étapes préliminaires

Avant de commencer avec votre module SIM900 GSM GPRS, vous devez considérer certains aspects concernant la carte SIM et l’alimentation du shield.

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, si quelque chose ne va pas, vous devrez peut-être payer une facture énorme pour des centaines de messages texte 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 d’obtenir un Adaptateur de taille de carte SIM.

Désactiver le verrouillage PIN

Pour utiliser la carte SIM avec le bouclier, vous devez désactiver le verrouillage des broches. Le moyen le plus simple de le faire est d’insérer la carte SIM dans votre smartphone et de désactiver le verrouillage des broches dans les paramètres de sécurité du téléphone.

Dans mon cas, je devais passer par : Réglages > Avancée Réglages > Sécurité > Verrouillage SIM et éteignez la carte sim de verrouillage avec la broche.

Obtenir la bonne alimentation

Le blindage a une prise CC pour l’alimentation, comme illustré 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 à 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 illustrée ci-dessous. Il peut également être alimenté en 9V 1A, ou 12V 1A.

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

Matériel de blindage SIM900 GSM GPRS

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

La figure ci-dessous montre les composants les plus importants de la carte auxquels vous devez prêter 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 la sélection du port série, assurez-vous que le capuchon du cavalier est connecté comme indiqué dans la figure ci-dessous pour utiliser la série logicielle.

4) Alimentez le blindage à 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.

Noter: vous pouvez activer automatiquement le bouclier via le logiciel. Voyez comment faire cela dans le Activer automatiquement le bouclier section, après les exemples de code.

sept) 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

• mettez le SIM900 en mode texte : AT+CMGF=1r
• envoyer des SMS à un numéro : AT+CMGS=NUMÉRO DE TÉLÉPHONE (au format international)
• lire le premier SMS de la boîte de réception : AT+CMGR=1r
• lire le deuxième SMS de la boîte de réception : AT+CMGR=2r
• lire tous les SMS de la boîte de réception : AT+CMGR=TOUSr
• appeler un numéro : ATDP+ NUMÉRO DE TÉLÉPHONE (au format international)
• raccrocher un appel : ATH
• recevoir un appel entrant : À

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 shield en envoyant des commandes AT depuis le 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 programmeur FTDI au blindage GSM comme indiqué dans la figure ci-dessous.

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

3) Ouvrez le moniteur série

4) Sélectionner 19200 débit en bauds – le paramètre par défaut du blindage est 19200 – et Retour chariot. Écrivez À dans la case surlignée en rouge, puis appuyez sur Entrée. Voir la figure ci-dessous.

5) Le bouclier répondra avec d’accord, si tout fonctionne correctement.

Connecter le 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.

/*********
  Complete project details at https://www.raspberryme.com  
*********/

#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=1r"); 
  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); 
}

Afficher le code brut

Dans ce code, vous commencez par inclure le SoftwareSerial.h bibliothèque 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>
SoftwareSerial SIM900(7, 8);

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

Vous devez changer le numéro de portable du destinataire à : (remplacez le X‘s avec 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.

// REPLACE WITH YOUR OWN SMS MESSAGE CONTENT
SIM900.println("Message example from 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 pour que le bouclier établisse la communication. Ensuite, testez le script en envoyant un SMS au numéro de carte SIM du shield. Le SMS est affiché sur le moniteur série Arduino – débit en bauds : 19200.

/*********
  Complete project details at https://www.raspberryme.com  
*********/

#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=1r"); 
  delay(100);
  // Set module to send SMS data to serial out upon receipt 
  SIM900.print("AT+CNMI=2,2,0,0,0r");
  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); 
  }
}

Afficher le code brut

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,0r");

Vous enregistrez les caractères entrants du message SMS sur le entrant_char variable. Vous lisez les caractères en utilisant le SIM900.lire() une fonction.

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.

/*********
  Complete project details at https://www.raspberryme.com  
*********/

#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
}

Afficher le code brut

Pour passer l’appel, vous utilisez le Appeler quelqu’un() fonction qui utilise le ATD commander.

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

Vous devez remplacer le X‘s (surligné en rouge) avec 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é après 30 secondes, en utilisant le ATH commander:

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 le ATH commande lorsqu’un événement est déclenché. Par exemple, connectez un bouton-poussoir à l’Arduino, qui, lorsqu’il est enfoncé, envoie le ATH commande pour raccrocher le téléphone.

Répondre aux appels téléphoniques entrants

Le code suivant répond aux appels entrants.

/*********
  Complete project details at https://www.raspberryme.com  
*********/

#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=1r"); // 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("ATAr");
          }
        }
      }
    }
  }
}

Afficher le code brut

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 le À commande pour répondre au téléphone.

Activer automatiquement le bouclier

Au lieu d’appuyer manuellement sur la touche « alimentation » pour allumer le bouclier, vous pouvez activer automatiquement le bouclier via le logiciel.

1) Tout d’abord, vous devez souder les connexions R13 sur le blindage comme indiqué dans la figure ci-dessous – surlignée en rouge.

2) Connectez D9 sur le blindage à la broche D9 Arduino 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 « alimentation » du bouclier.

digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay(5000);

Dépannage

Le bouclier ne répond pas avec 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é la 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 sur le moniteur série

Pour voir les messages sur le moniteur série, le blindage et le débit en bauds du port série de l’Arduino doivent être les mêmes. 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 à 19200.

Cependant, si vous devez modifier le débit en bauds du blindage, vous pouvez envoyer la commande AT suivante pour le modifier à 19 200 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 :

Si vous aimez les projets Arduino, assurez-vous de consulter notre dernier Arduino : Projets Arduino étape par étape – Construisez 25 projets

Nous espérons que vous avez trouvé ce guide utile.

Merci d’avoir lu.