GeekOnFire GSM/GPRS Shield

De MCHobby - Wiki
Aller à : navigation, rechercher

Introduction

Le shield GSM/GPRS est basé sur un module SIM900 de SIMCOM, il est compatible avec Arduino et ses clones. Le shield GPRS permet à votre Arduino de communiquer en utilisant le réseau GSM. Ce shield permet d'envoyer des SMS, MMS, GPRS et de Audio en envoyant des commandes AT à l'UART (voir wikipedia pour plus d'information). Les commandes AT supportées sont GSM 07.07 ,07.05 et SIMCOM enhanced AT Commands. Le shield dispose aussi des 12 GPIOs, 2 sorties PWM et du convertisseur Analogique/Digital ADC du module SIM900 (accessible sur la carte, logique 2.8volts).

Shield disponible chez MCHobby.be

GSM-Shield-01.jpg

Note de MC Hobby:

L'UART permet d'établir une connexion série avec le module SIM900. A l'aide de cette connexion série, le programme de votre Arduino sera capable d'envoyer des commandes "textuelle" au module (ce sont les fameuses commandes "AT"). Le module réagira à ces commandes et fournira le service demandé et une réponse sur la liaison série.

Par exemple, pour former un numéro de téléphone, le programme Arduino doit envoyer la commande "ATD+32499123456;" sur la connexion série.

En réponse, le module SIM900 formera le numéro.

Dans le même ordre d'idée, lorsque le module reçoit un appel téléphonique, l'UART envois le message "Ring" sur la connexion série.

Pour contrôler toutes les fonctionnalités du module GSM/GPRS, il faut donc maîtriser les commandes AT correspondantes. Une liste complète et documentée de ces commandes AT est mise à disposition par Geek On Fire (voir plus loin).

Caractéristiques

  • Quadri-Bande 850 / 900/ 1800 / 1900 MHz - devrait fonctionner avec tous les réseaux GSM de tous les pays.
  • GPRS multi-slot class 10/8
  • GPRS mobile station class B
  • Conforme à GSM phase 2/2+
    • Class 4 (2 W @ 850 / 900 MHz)
    • Class 1 (1 W @ 1800 / 1900MHz)
  • Contrôle à l'aide de commandes AT - Commandes standard : GSM 07.07 & 07.05 | Commandes étendues: SIMCOM AT Commands.
  • Messages SMS (Short Message Service) - Il est ainsi possible d'envoyer de petites quantités de données via le réseau mobile (ASCII ou données hexadécimales).
  • Embarque une stack TCP/UDP - Permettant d'envoyer des données sur un serveur web.
  • Support RTC.
  • Port série sélectionnable.
  • Prise pour micro et casque.
  • Basse consommation - 1.5mA(en mode veille)
  • Supporte la norme de température industrielle - -40°C a +85 °C

Spécifications

Dimensions 68.7mm X 53.5mm X 19.6mm
Protocole de communication UART
Indicateur LEDs PWR: Alimentation (Vert), Statut (Bleu), Netlight: Réseau(Rouge)
Alimentation 5V provenant de la carte Arduino.
Vbat 4.1V (pour module SIM900)
Consommation en Courant 2A(max)
Baud rate(par défault) 19200bps
RoHS Yes

Note de MC Hobby:

La consommation pouvant atteindre occasionnellement 2 ampères (réseau distant, déplacement), il est vivement conseillé d'utiliser un module d'alimentation séparé pour alimenter votre Arduino. Bien que le GPRS shield soit pourvu d'une "réserve", l'alimentation via le câble USB (limité à ~500mA) de votre PC sera insuffisant en cas de pic de courant sur le GPRS Shield. Le module SIM900 disposant d'une protection en surtension et en sous-tensions, ce dernier se coupera volontairement si le pic de courant provoque une chute de tension trop importante (la LED bleue s’éteindra).

Idées d'applications

  • Dialogue Machine to Machine (M2M).
  • Commande d'appareils à distance.
  • Réseau de senseurs à distance, station météo distante.
  • Système de suivit de véhicule.

Précautions

  • Assurez-vous que vous disposez d'une carte SIM débloquée (Unlocked SIM card). Voir aussi les réseaux déjà testés
  • Le produit est livré sans boitier protecteur. Il est important de suivre les précautions ESD (protection contre les décharges électrostatique), spécialement par temps sec (basse humidité).
  • La configuration d'usine de l'UART du GPRS shield est 19200 bauds 8-N-1. (peut-être changé à l'aide de commandes AT).

Arduino IDE < v1.0

  • La librairie NewSoftLibrary ne supporte que les débit inférieurs à 38400 bauds. Vous pourriez perdre des données en essayant de communiquer au dessus de 38400 bauds.
  • La librairie standard NewSoftSerial n'a pas support de réception pour le Mega.

Arduino IDE >= v1.0

  • La librairie NewSoftSerial est disponible depuis Arduino 1.0. Elle est nommée SoftwareSerial et non NewSoftSerial.
  • La limitation de 38400 bauds décrite ci-dessus devrait rester d'application.

Version de NewSoftSerial compatible avec Mega

Bhagman à écrit une nouvelle version de la librairie qui supporte la réception. Voir soit sur ici sur Arduino.cc ou NewSoftSerial10c-withMegaAndStream.zip sur Google Code.

GOF a essayé cette nouvelle librairie. La limitation c'est qu'elle ne fonctionne qu'avec les broches supportant les interruptions (Pin11,12), donc le méga ne fonctionne qu'avec la configuration "Hardware UART communication" (synchronisation matérielle).

Note de MC Hobby: Nous n'avons pas encore eu l'occasion de tester un GPRS shield sur un AT Mega + Arduino V1.0. En fonction des résultats, cette note serait susceptible d'être modifiée.

Description du matériel

GSM-Shield-02-fr.jpg

1*) Déclenchement logiciel

Le déclenchement logiciel n'est possible que si JP est soudé.

2*) LEDs de status

Le statut de la carte est affiché à l'aide de 3 LEDs de couleurs différentes.

La LED VERTE indique si la carte est alimentée (doit être allumée et fixe).

La LED BLEUE indique le statut de la carte GPRS (doit être allumée et fixe).

La LED ROUGE indique le statut de la connexion du réseau. Lorsque vous êtes connecté sur un réseau GSM, cette LED clignote brièvement toutes les 0.8 sec.

Mise en route

GSM-Shield-03-fr.jpg
Les quelques étapes pour démarrer avec votre Shield GPRS

Note:

Si vous utilisez votre Monitor Arduino pour tester votre shield (avec le sketch proposé plus loin), n'oubliez pas de configurer votre connexion en 19200 bauds et Carriage Return.

Syntaxe des commandes AT

Les commandes AT (AT Command ) sont de simple ordres textuels envoyés au Shield GPRS via son interface série (UART). Le préfix "AT" ou "at" doit être présent au début de chaque ligne de commande. Une ligne de commande est terminée par un retour à la ligne (touche <CR> pour Carriage Return). Les commandes sont généralement suivie d'une réponse qui se présente comme suit "<CR><LF><réponse><CR><LF>".

CR signifie Carriage Return (caractère #13)

LF signifie Line Feed (caractère #10)

Seul les réponses seront présentées dans ce document, les <CR><LF> seront intentionnellement omit.

Note: La chaine HEX telle que "00 49 49 49 49 FF FF FF FF" est envoyée via le port série à 115200 baud immédiatement après la mise sous tension du SIM900. Cette chaîne peut être ignorée puisqu'elle sert à la synchronisation avec des outils PC.

N'envoyez des commandes AT sur le port série après la mise sous tension du SIM900 que lorsque vous recevez le code "RDY" sur le port série ("RDY" est envoyé sans aucune sollicitation préalable). Si l'auto-bauding est activé, le code "RDY" (et autres messages non sollicités) n'est pas envoyé quand vous démarrez le shield et le préfix "AT" (et non "at") doit être présent au début de chaque ligne de commande.

Pour plus d'information sur les commandes AT, référez vous au Manuel des commandes AT v1.03.

Mise sous tension et extinction du shield GPRS

Mise sous tension du shield GPRS

Le shield GPRS peut être allumé de deux façons:

  • 1, Déclenchement Matériel; Presser le bouton Marche/Arrêt (ON/OFF) pendant environ deux secondes. Le scénario de mise sous tension s'illustre par les étapes suivantes:
GSM-Shield-04-On-Off.jpg
Graphique de synchronisation lorsque le GPRS shield est mis sous tension par déclenchement matériel
  • 2, Déclenchement logiciel; si vous utilisez cette façon d'allumer votre shield Shield, le contact JP doit être soudé et ensuite la pin digitale n° 9 de votre Arduino agit comme un déclencheur logiciel. La pin 9 ne peut plus être utilisée pour autre chose.

Ensuite, l'envoi d'une impulsion de mise-en-marche la Pin 9 provoque la mise sous tension du shield GPRS. Le scénario de mise sous tension s'illustre par les étapes suivantes:

GSM-Shield-05-On-Off.jpg
Graphique de synchronisation lorsque le GPRS shield est mis sous tension par déclenchement logiciel

Le code suivant présente une sous routine de mise sous tension du shield GPRS par déclenchement logiciel. Cette fonctionnalité n'est pas activée par défaut. Utilisez le déclenchement matériel à la place.

void powerUp()
{
  pinMode(9, OUTPUT); 
  digitalWrite(9,LOW);
  delay(1000);
  digitalWrite(9,HIGH);
  delay(2000);
  digitalWrite(9,LOW);
  delay(3000);
}

Lorsque la procédure de mise sous tension est achevée, le SIM900 envoi un code de résultat (result code) pour indiqué qu'il est prêt; Lorsqu'il est configuré comme fixed baud rate (ce qui est le cas par défaut), le SIM900 envoi le code: RDY

Ce code de résultat n'apparaît pas lorsque le SIM900 est configuré en auto baud rate.

Extinction du shield GPRS

Le shield GPRS peut-être arrêté de plusieurs façons:

  • 1, Procédure d'extinction Normale: éteindre le shield GPRS en utilisant le déclenchement matériel; pressez le bouton marche/arrêt (ON/OFF) pendant environ deux secondes.

Le scénario d'extinction s'illustre par les étapes suivantes:

GSM-Shield-06-On-Off.jpg
Graphique de synchronisation lorsque le GPRS shield est mis sous tension par déclenchement matériel
  • 2, Procédure d'extinction Normale: éteindre le shield GPRS en utilisant le déclenchement matériel; si JP est soudé alors la pin digital n° 9 de votre Arduino agit comme un déclencheur logiciel. Une impulsion d'extinction peut éteindre le shield GPRS. Le scénario d'extinction s'illustre par les étapes suivantes:
GSM-Shield-07-On-Off.jpg
Graphique de synchronisation lorsque le GPRS shield est mis sous tension par déclenchement logiciel

La sous routine suivante utilise le déclenchement logiciel du shield GPRS: Pas activé par défaut, utilisez le déclenchement matériel à la place.

void powerDown()
{
  pinMode(9, OUTPUT); 
  digitalWrite(9,LOW);
  delay(1000);
  digitalWrite(9,HIGH);
  delay(2000);
  digitalWrite(9,LOW);
  delay(3000);
}


  • 3, Procédure d'extinction Normale: Extinction du shield GPRS à l'aide d'une commande AT. Envoyez la commande “AT+CPOWD=1” au module SIM900 éteint le shield GPRS.
Lorsque le shield GPRS est éteint en suivant une '''procédure d'extinction normale''', cette procédure 
permet au SIM900 de se déconnecter (log off) du réseau et permet au logiciel d'entrer dans un état 
stable (secure state) et de sauver les données avant de couper completement l'alimentation. 
Avant l'achèvement de cette procédure Normale, le SIM900 renvoi le code de résultat: '''NORMAL POWER DOWN'''
  • 4, Extinction automatique pour sur-tension ou sous-tension: (Over-voltage or Under-voltage Automatic Power Down) Le module SIM900 surveille constamment le tension appliquée sur VBAT.
    • ①Si la tension ≤ 3.3V, le code de résultat suivant est affiché (URC - Unsolicited Result Code): UNDER-VOLTAGE WARNNING
    • ②Si la tension ≥ 4.7V, le code de résultat suivant est affiché (URC): OVER-VOLTAGE WARNNING
    • ③La gamme de tension non critique est situé entre 3.2V et 4.8V. Si la tension > 4.8V ou < 3.2V, Le SIM900 s'éteindra automatiquement et rapidement. si la tension < 3.2V, le code de résultat suivant est affiché (URC): UNDER-VOLTAGE POWER DOWN
    • ④Si la tension > 4.8V, le code de résultat suivant est affiché: OVER-VOLTAGE POWER DOWN
  • 5, Extinction automatique pour Sur-chauffe ou Sous-chauffe: (Over-temperature or Under-temperature Automatic Power Down) le SIM900 surveille constamment la température du module.
    • ①Si la température > 80℃, le code de résultat (URC) suivant est affiché: +CMTE:1
    • ②Si la température < -30℃, le code de résultat (URC) suivant est affiché: +CMTE:-1
    • ③La gamme de température non critique est situé entre -40℃ et +85℃. Si la température > +85℃ ou < -40℃, le module s'éteindra automatiquement et rapidement. Si la température est > +85℃, le code de résultat (URC) suivant est affiché: +CMTE:2
    • ④Si la température < -40℃, le code de résultat suivant (URC) est affiché: +CMTE:-2

Quand le shield GPRS rencontre une scénario d'extinction (POWER DOWN), les commandes AT ne peuvent pas être exécutées. Le module SIM900 se déconnecte dy réseau (logs off) et entre dans le mode extinction (POWER DOWN mode), seul le RTC reste actif. Le mode d'extinction (POWER DOWN) est également visible sur la LED indicatrice (Blue), qui est éteinte dans ce mode.

Note:

  • Pour surveiller la température, l'utilisateur peut utiliser la commande “AT+CMTE” pour lire la température lorsque le shield GPRS est sous tension.
  • Pour surveiller la tension d'alimentation, l'utilisateur peut utiliser la commande “AT+CBC” lorsque le shield GPRS est sous tension. Commande qui inclus un paramètre: valeur de tension en mV (voltage value in mV).

Port de communication série (UART)

Le shield GPRS utilise un protocole UART pour communiquer avec un Arduino/Clone Arduino; L'utilisateur peut utiliser des raccords (jumpers) pour connecter le shield soit en communication série Logiciel (D8,D7 pour Software Seriel) ou en communication série Matérielle (D1,D0 pour Hardware Seriel) avec votre Arduino.

Voir l'image ci-dessous pour plus de détails:

GSM-Shield-08-UART-fr.jpg
Selecteur du port de communication série du Shield GPRS

Notes:

  • L'utilisateur peut utiliser la commande “AT+IPR=?” pour connaître les débits (baudrate) supportés, la réponse sera une liste des débits (baudrate) supportés.
  • L'utilisateur peut utiliser “AT+IPR=x”(x étant une valeur de débit/baudrate supporté) pour fixer le débit à utiliser et mémoriser la configuration dans la mémoire flash non-volatile.
  • Quand l'utilisateur communique avec le shield GPRS en utilisant la librairie Software Serial, la librairie NewSoftLibrary doit être installé dans les librairies d'Arduino.
  • La librairie NewSoftLibrary supporte uniquement des débits inférieurs à 38400bps.

Indicateurs LEDs

Le shield est équipé de 3 LEDs indicatrices (PWR (Vert), Status (Bleu), Netlight (Rouge)), il est possible d'identifier l'état du fonctionnement du shield à l'aide de ces 3 LEDs indicatrices.

  • PWR indique si le shield est alimenté. PWR pour POWER (alimentation)
  • Status indique le Statut.
  • Netlight indique l'état de communication/connexion avec le réseau mobile.

Pour plus de détails, référez vous à la table suivante:

LEDs(Couleur) Statut Description
PWR(Vert) ALLUMEE Le GPRS shield est alimenté
Éteinte Le GPRS shield est hors tension
Statut(Bleu) ALLUMEE Le module SIM900 est actif
Éteinte Le module SIM900 est inactif
Netlight (Rouge) 64ms allumée/800ms éteinte Le SIM900 n'est pas enregistré sur un réseau mobile
64ms allumée/3000ms éteinte Le SIM900 est enregistré sur un réseau mobile
64ms allumée/300ms éteinte En communication GPRS
OFF Le module SIM900 est inactif


Installation de la Carte SIM

Une carte SIM déSimLockée (unlocked) doit être insérée dans le support de carte SIM situé sous le shield. Le SIM900 supporte les cartes SIM utilisant les tensions 1.8 volts et 3.0 volts (le type de carte SIM et sa tension d'utilisation est automatiquement détecté par le module SIM900).

Note: Assurez-vous que votre carte SIM soit bien débloquée; Si vous n'êtes pas certain, vérifiez avec votre fournisseur de service.

L'antenne

Le shield est fournit avec une antenne GSM quadri-band (qurd-band antenna); Assurez-vous que l'antenne est montée/visée sur le shield et que son fils soit correctement raccordée sur sa borne de raccordement.

Connexion Audio

Le shield GPRS dispose d'une interface 3.5mm pour le microphone et le haut-parleur. Si vous désirez faire des appels vocaux, vous aurez également besoin d'un casque incluant un microphone.

Charger le Sketch sur Arduino

Le sketch suivant configure votre Arduino/Clone Arduino comme un "relais série" entre votre ordinateur et le shield GPRS Shield (Jumpers connectés du côté "SW serial"/communication série logicielle). L'ordinateur aura besoin d'un logiciel de type Terminal pour vous permettre de communiquer avec votre shield GPRS par l'intermédiaire de votre Arduino. Par exemple HyperTerminal de Windows, le moniteur série de l'IDE Arduino, Serial Terminals(sscom32) ou Bray++ Terminal.

GSM-Shield-09-SerialRelay-fr.jpg
Flux de données entre l'ordinateur, Arduino et le shield GPRS

Note de MC Hobby:

  1. Vous pouvez utiliser le moniteur série d'Arduino pour communiquer directement avec l'UART du SIM900 à l'aide de ce sketch. Dans ce cas, il faut configurer le débit de la connexion du moniteur série sur "19.200 Bauds" et "Carriage Return". En effet, l'UART du SIM900 réagit au retour clavier!
  2. Le retour clavier, souvent symbolisé par CR correspond à touche "enter"/"Entrée". Cette touche correspond au caractère ASCII 13 aussi codé en C à l'aide de "/r".

Après avoir téléchargé votre sketch sur la carte Arduino, pressez le bouton ON/OFF du GPRS shield pour l'allumer; Vous pourrez ensuite voir ce qui s'affiche sur votre Terminal série, le statut des 3 indicateurs LEDs et finalement communiquer avec votre GPRS shield.

// Serial Relay - Arduino < 1.0 
// Arduino servira d'intermédiaire de 
// communication série entre votre ordinateur et le
// shield GPRS (19200 bps 8-N-1)
// 
// L'ordinateur est connecté à un UART matériel, 
// Le shield GPRS est connecté à un UART logiciel 

#include <NewSoftSerial.h>
 
NewSoftSerial mySerial(7, 8);
 
void setup()
{
  mySerial.begin(19200);               // GPRS baud rate   
  Serial.begin(19200);                 // GPRS baud rate   
}
 
void loop()
{
    if(Serial.available())
    {
       mySerial.print((unsigned char)Serial.read());
     }  
    else  if(mySerial.available())
    {
       Serial.print((unsigned char)mySerial.read());
     }   
 
}

La version ci-dessous convient pour Arduino 1.0 :

//Serial Relay - pour Arduino 1.0 
//
// Arduino will patch a serial link between the computer 
// and the GPRS Shield at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART 
 
#include <SoftwareSerial.h>    // For Arduino 1.0
 
SoftwareSerial mySerial(7, 8); // For Arduino 1.0
 
void setup()
{
  mySerial.begin(19200);               // the GPRS baud rate   
  Serial.begin(19200);                 // the GPRS baud rate   
}
 
void loop()
{
    if(Serial.available())
    {
       char c = Serial.read();
       mySerial.print(c);
     }  
    else  if(mySerial.available())
    {
        char c = mySerial.read();
       Serial.print(c);
     }   
}


Notes:

  • Pour une version Arduino IDE:
    • < 1.0 : assurez vous que vous avez bien installé la librairie NewSoftLibrary.
    • >= 1.0: pas besoin d'installer la librairie NewSoftSerial, elle est disponible dans l'installation par défaut comme SoftwareSerial.
  • Le préfix "AT" ou "at" doit être présent au début de chaque ligne. Pour terminer une commande, pressez la touche Retour/Enter <CR>.

Version Améliorée du Sketch

Note de MC Hobby:

Bien que cela ne soit pas nécessaire lors de vos premiers tests avec le GPRS shield, MCHobby vous propose d'utiliser sa version améliorée SerialRelay 2.

Cette nouvelle version permet d'envoyer la séquence d'échappement Ctrl-z au GPRS shield depuis le Moniteur Série d'Arduino. Ce sera un allier vraiment précieux.

Exemples

Note préliminaire

Les exemples ci-dessous partent du principe que la carte SIM utilisée ne nécessite pas de code PIN. Si votre carte SIM nécessite l'utilisation d'un code PIN, vous pouvez utiliser la commande AT+CPIN.

Arduino V1.0 et versions antérieures

Les programmes ci-dessous sont écrits pour des Arduino < 1.0.

Dans ce cas, la librairie est NewSoftSerial doit être utilisée.

Depuis la version Arduino 1.0, NewSoftSerial à été intégrée à la plateforme Arduino sous le nom de SoftwareSerial.

Si vous utilisez un Arduino 1.0, il faut remplacer les occurrences de "NewSoftSerial" par "SoftwareSerial" et opérer, au cas par cas, quelques modifications.

Sending SMS: using Software UART

La plupart des cartes SIM vendues nécessites la saisie d'un code pin avant d'accéder au réseau mobile. Si c'est le cas de votre carte SIM vous avez deux choix:

  • Annuler l'usage du code pin avec la carte SIM (si cela est possible, voir avec votre opérateur).
  • Consulter les FAQ à propos de la commande AT "AT+CPIN". Utiliser SerialRelay2 sera bien utile pour conduire vos tests.

Version du programme pour Arduino IDE < 1.0.

Cette version utilise la libraire NewSoftSerial pour communiquer avec la GPRS shield.

// Version pour Arduino IDE < 1.0
#include <NewSoftSerial.h>    
 
NewSoftSerial mySerial(7, 8);

void setup()
{
  mySerial.begin(19200);  // Paramètres par défaut du port série du GPRS shield (19200bps 8-N-1)
  mySerial.print("\r");   // Envoyer un retour à la ligne <CR>
  delay(1000);                    // Attendre une seconde que le modem retourne "OK"
  mySerial.print("AT+CMGF=1\r");  // Envoyer un SMS en mode texte
  delay(1000);
 
  //mySerial.print("AT+CSCA=\"+919032055002\"\r");// Configurer le centre de message SMS,  
  //delay(1000);                                  // Retirer les commentaire seulement si nécessaire et
                                                  // remplacer le No avec celui obtenu auprès de votre
                                                  // fournisseur de service mobile.
                                                  //Note: pour inclure un " dans une chaine de caractère
                                                  //  il faut utiliser la notation \"
 
  mySerial.print("AT+CMGS=\"+9184460xxxx\"\r");   // Commencer un SMS à envoyer au numéro +91....
                                                  // l'encodage du texte suivra plus bas.
                                                  // Remplacer le No avec celui de votre destinataire.
  delay(1000);
  mySerial.print("Bienvenu chez MCHobby!\r");     // Le texte du message
  delay(1000);
  mySerial.print(26,BYTE);  // Equivalent du Ctrl+Z (fin de texte du SMS) 
}
 
void loop()
{
      // Nous voulons seulement envoyer le SMS une seule fois, il n'y a donc rien dans la boucle loop().
      // Si nous mettons le code du SMS ici, alors il sera envoyer encore et encore (Oups! cela couterait cher).
}

Version du programme pour Arduino IDE >= 1.0.

Cette version utilise la libraire SoftwareSerial, intégrée à l'installation d'Arduino IDE 1.0, pour communiquer avec la GPRS shield.

// Version pour Arduino IDE < 1.0
#include <SoftwareSerial.h>    
 
SoftwareSerial mySerial(7, 8);

void setup()
{
  mySerial.begin(19200);  // Paramètres par défaut du port série du GPRS shield (19200bps 8-N-1)
  mySerial.print("\r");   // Envoyer un retour à la ligne <CR>
  delay(1000);                    // Attendre une seconde que le modem retourne "OK"
  mySerial.print("AT+CMGF=1\r");  // Envoyer un SMS en mode texte
  delay(1000);
 
  //mySerial.print("AT+CSCA=\"+919032055002\"\r");// Configurer le centre de message SMS,  
  //delay(1000);                                  // Retirer les commentaire seulement si nécessaire et
                                                  // remplacer le No avec celui obtenu auprès de votre
                                                  // fournisseur de service mobile.
                                                  //Note: pour inclure un " dans une chaine de caractère
                                                  //  il faut utiliser la notation \"
 
  mySerial.print("AT+CMGS=\"+9184460xxxx\"\r");   // Commencer un SMS à envoyer au numéro +91....
                                                  // l'encodage du texte suivra plus bas.
                                                  // Remplacer le No avec celui de votre destinataire.
  delay(1000);
  mySerial.print("Bienvenu chez MCHobby!\r");     // Le texte du message
  delay(1000);
  mySerial.write(26);  // Equivalent du Ctrl+Z (fin de texte du SMS)
                       // Note: ici il faut utiliser l'instruction write pour écrire un byte. 
}
 
void loop()
{
      // Nous voulons seulement envoyer le SMS une seule fois, il n'y a donc rien dans la boucle loop().
      // Si nous mettons le code du SMS ici, alors il sera envoyer encore et encore (Oups! cela couterait cher).
}

Faire un appel: en utilisant l'UART logiciel

Version d'Arduino < 1.0

Dans ce cas, nous utilisons la librairie NewSoftSerial

#include <NewSoftSerial.h>   
 
NewSoftSerial mySerial(7, 8); 

void setup()
{
  mySerial.begin(19200);   // GPRS baud rate   
  Serial.begin(19200);     // GPRS baud rate   
  delay(2000);
  mySerial.println("ATDxxxxxxxxx;"); // xxxxxxxxx est le numéro a appeler.  
         
  if(mySerial.available())
  {
    Serial.print((unsigned char)mySerial.read());
  }  
  
  delay(10000); 
  delay(10000); 

  mySerial.println("ATH"); // Fin d'appel.
  if(mySerial.available())
  {
    Serial.print((unsigned char)mySerial.read());
  }    
}
 
void loop()
{
  // Ne rien faire
}

Version d'Arduino >= 1.0

Dans ce cas, nous utilisons la librairie SoftwareSerial incluse dans l'installation d'Arduino

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

// relayer la réponse de fromSerial (type SoftwareSerial) vers
//   le port serie d'Arduino (19200baud). Facile le deboggage
void relayResponse( SoftwareSerial &fromSerial ){
  // Attention, il faut attendre que l'UART réponde
  // avant de lire mySerial (temps conseillé= 1sec)
  //
  while(fromSerial.available())
  {
     // Envoi le résultat sur la connexion série
     char c = fromSerial.read();
     Serial.print(c);
  }
} 

void setup()
{
  mySerial.begin(19200);   // GPRS baud rate   
  Serial.begin(19200);     // GPRS baud rate   
  delay(2000);
  mySerial.println("ATDxxxxxxxxx;"); // xxxxxxxxx est le numéro a appeler.  
         
  // NB: Une boucle while serait plus appropriée que la section de code ci-dessous.
  //     Je vous propose d'appeler la fonction suivante: 
  //     relayResponse( mySerial ) 
  if(mySerial.available()) 
  {
    char c = mySerial.read();
    Serial.print( c );
  }  
  
  delay(10000); 
  delay(10000); 

  mySerial.println("ATH"); // Fin d'appel.
  if(mySerial.available()) // Voir commentaire précédent.
  {
    char c = mySerial.read();
    Serial.print( c );
  }    
}
 
void loop()
{
  // Ne rien faire
}

Commandes AT pour contrôler les broches GPIO et PWM

Attention!!! les broches GPIOs,PWMs et ADC du module SIM900 utilisent toutes une logique en 2,8 volts.

Comme pour tous les autres exemples, il suffit de remplacer NewSoftSerial par SoftwareSerial si vous utilisez un Arduino V1.0.

#include <NewSoftSerial.h>
 
NewSoftSerial mySerial(7, 8);

void setup()
{
  mySerial.begin(19200);  // GPRS baud rate   
  Serial.begin(19200);    // GPRS baud rate   
  delay(2000);
}
 
void loop()
{
  mySerial.println("AT+SPWM=1,63,100");// assigner une valeur PWM à la sortie PWM 1
  mySerial.println("AT+SPWM=2,63,50"); // assigner une valeur PWM à la sortie PWM 2
  
  mySerial.println("AT+SGPIO=0,1,1,1");// Assigner la valeur 1 à la broche GPIO 1
  mySerial.println("AT+SGPIO=0,12,1,1");
  delay(1000);  

  mySerial.println("AT+SGPIO=0,1,1,0");// Assigner la valeur 1 à la broche GPIO 1
  mySerial.println("AT+SGPIO=0,12,1,0");
  delay(1000);    
}

Schéma

Voir chez le lien suivant chez le constructeur GPRSshield_sch.pdf

Ressources

Ou acheter

Le shield GPRS peut être acheté chez MC Hobby. La page du GSM/GPRS Shield est accessible ici

Licence GeekOnFire

Cette document est fournie sous la licence Creative Commons Attribution-ShareAlike License 3.0. Le code source et les librairies sont sous licence GPL/LGPL, voir le code source des fichiers pour plus d'information.

Note de traduction

Le contenu de cette page est une traduction "At the best" des informations mise à disposition par Geek On Fire (page originale).

En aucun cas, MC Hobby ne peut être tenu responsable de l'exactitude des informations fournie par Geek On Fire ainsi que des conséquences qui pourraient en découler.

Cette traduction est proposée gratuitement comme aide ponctuelle visant à accélérer la prise en main. Une erreur de traduction n'engage, en aucun cas, la responsabilité de MC Hobby.

En cas de doute, l'utilisateur peut se référer au document d'origine mis à disposition par Geek On Fire.


Traduit avec l'autorisation de Geek On Fire - Translated with the permission from Geek On Fire - [1]

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.