Vous êtes sur la page 1sur 32

Envoyer Recevoir des SMS et

des appels avec le bouclier GSM


SIM900 et Arduino

Que vous souhaitiez écouter ce qui se passe dans votre maison à des
kilomètres de chez vous ou activer le système d'arrosage dans votre jardin
simplement avec un appel silencieux; Ensuite, le bouclier SIM900 GSM / GPRS
sert de point de départ solide pour vous permettre de démarrer avec l'IoT!

Le shield SIM900 GSM / GPRS est un modem GSM, qui peut être intégré dans
un grand nombre de projets IoT. Vous pouvez utiliser ce bouclier pour
accomplir presque tout ce qu'un téléphone portable normal peut; SMS, passez
ou recevez des appels téléphoniques, connectez-vous à Internet via GPRS,
TCP / IP, et plus encore! Pour couronner le tout, le bouclier prend en charge le
réseau GSM / GPRS quadri-bande, ce qui signifie qu'il fonctionne à peu près
partout dans le monde.
Présentation matérielle du bouclier GSM /
GPRS SIM900
Le bouclier SIM900 GSM / GPRS est conçu pour entourer la puce SIM900 de
tout le nécessaire pour s'interfacer avec Arduino, ainsi que de quelques bonus
supplémentaires pour profiter des fonctionnalités uniques de la puce.

Familiarisons-nous avec ces caractéristiques et capacités du bouclier. Voici


un bref aperçu:
Le bouclier SIM900 intègre une quantité surprenante de fonctionnalités dans
son petit cadre. Certains d'entre eux sont énumérés ci-dessous:

 Prend en charge la quadri-bande: GSM850, EGSM900, DCS1800 et


PCS1900

 Connectez-vous à n'importe quel réseau GSM mondial avec n'importe


quelle carte SIM 2G

 Passer et recevoir des appels vocaux à l'aide d'un écouteur externe et


d'un microphone électret

 Envoyer et recevoir des SMS

 Envoyer et recevoir des données GPRS (TCP / IP, HTTP, etc.)

 Balayez et recevez des émissions de radio FM

 Puissance de transmission:

 Classe 4 (2W) pour GSM850

 Classe 1 (1W) pour DCS1800


 Jeu de commandes AT basé sur la série

 Connecteurs U.FL et SMA pour antenne cellulaire

 Accepte la carte SIM pleine taille

Indicateurs d'état LED


Il y a trois LED sur le blindage GSM / GPRS SIM900 qui indiquent la
connectivité ou l'état de l'alimentation. En observant ces LED, vous pouvez
obtenir un retour visuel sur ce qui se passe avec le bouclier.

PWR : Cette LED est connectée à la ligne d'alimentation du blindage. Si ce


voyant est allumé, le blindage est alimenté.

État : ce voyant indique l'état de fonctionnement du SIM900. Si cette LED est


allumée, la puce est en mode de fonctionnement.

Netlight : ce voyant indique l'état de votre réseau cellulaire. Il clignotera à


différents taux pour montrer dans quel état il se trouve.

 éteint: la puce SIM900 ne fonctionne pas

 64 ms allumé, 800 ms éteint: la puce SIM900 est en cours d'exécution


mais n'est pas encore enregistrée sur le réseau cellulaire.

 64 ms allumé, 3 secondes éteint: la puce SIM900 est enregistrée sur le


réseau cellulaire et peut envoyer / recevoir de la voix et des SMS.

 64 ms allumé, 300 ms éteint: la connexion de données GPRS que vous


avez demandée est active.
Alimentation du bouclier SIM900
L'un des éléments les plus importants pour faire fonctionner le blindage
SIM900 est de lui fournir suffisamment d'énergie.

Selon l'état dans lequel il se trouve, le SIM900 peut être un appareil


relativement gourmand en énergie. La consommation maximale de courant de
la puce est d'environ 2A pendant la transmission en rafale. Il ne tire
généralement pas beaucoup, mais peut nécessiter environ 216 mA pendant
les appels téléphoniques ou 80 mA pendant les transmissions réseau. Ce
tableau de la fiche technique résume ce à quoi vous pouvez vous attendre:

Les modes La fréquence Consommation de courant

Éteindre 60 uA

Mode veille 1 mA

Etre prêt 18 mA

GSM850 199 mA

EGSM900 216 mA
Appel
DCS1800 146 mA

PCS1900 131 mA

GPRS 453 mA

Rafale de transmission 2A

La tension de fonctionnement de la puce SIM900 est comprise entre 3,4 V et


4,4 V. Pour maintenir la tension d'alimentation sûre à 4,1 V, le blindage est livré
avec un régulateur de tension MIC29302WU à courant élevé, haute précision et
à faible chute de tension de Micrel - capable de gérer des courants de charge
jusqu'à 3A.
Vous pouvez ajouter une alimentation externe au blindage avec la prise jack
5,5 mm DC, à laquelle vous pouvez connecter n'importe quel adaptateur mural
5V-9V DC que vous avez. À côté de la prise CC, se trouve un interrupteur à
glissière pour sélectionner la source d'alimentation étiquetée EXTERN . Pour
utiliser une source d'alimentation externe, déplacez le curseur comme indiqué
ci-dessus.

Avertissement:

L'alimentation doit être capable de fournir au minimum 2 A de courant de


surtension, sinon la puce continuera à s'éteindre.

Communication UART
Le blindage SIM900 GSM / GPRS utilise le protocole UART pour communiquer
avec un Arduino. La puce prend en charge le débit en bauds de 1200 bps à
115200 bps avec détection automatique en bauds.
À l'aide de cavaliers, vous pouvez connecter (RX, TX) du blindage à la série
logicielle (D8, D7) ou série matérielle (D1, D0) de l'Arduino.

Haut-parleur et microphone
Le bouclier est livré avec deux prises jack 3,5 mm standard. Un pour écouteurs
stéréo et un autre pour microphone mono. Il vous permet d'utiliser l'interface
audio du SIM900 pour passer et recevoir des appels vocaux et écouter la radio
FM.
Micro : vous pouvez connecter un microphone électret externe à cette prise.

Écouteurs : vous pouvez connecter des écouteurs à cette prise. Tous les


écouteurs compatibles «iPhone» ou «Android» devraient fonctionner.

Antenne
Une antenne est nécessaire pour utiliser le SIM900 pour tout type de
communications vocales ou de données ainsi que pour certaines commandes
SIM.
Le bouclier a deux interfaces pour connecter l'antenne à savoir. un connecteur
U.FL et un connecteur SMA. Ils sont connectés via un cordon de
raccordement.

Le bouclier est généralement livré avec une antenne GSM 3dBi et vous permet
de placer le bouclier dans un boîtier métallique (tant que l'antenne est à
l'extérieur).

Prise SIM
Il y a une prise SIM à l'arrière. Toute carte SIM pleine grandeur 2G activée
fonctionnerait parfaitement.

Le fonctionnement de la prise de la carte SIM peut prendre un certain temps


pour s'y habituer. Pour déverrouiller le loquet, poussez la partie supérieure de
l'assemblage, puis soulevez-la. Placez la carte SIM dans la partie inférieure de
la prise. Repliez ensuite le bras dans le corps de la douille et poussez-le
doucement vers l'avant vers la position LOCK.

RTC (horloge en temps réel)


Le bouclier SIM900 peut être configuré pour conserver l'heure. Il n'y a donc pas
besoin d'un RTC séparé. Cela gardera l'heure même lorsque l'alimentation est
coupée.
Si vous souhaitez utiliser un RTC interne, vous devez installer une pile CR1220
à l'arrière du bouclier.

Votre fournisseur de réseau peut ne pas prendre en charge le réglage


automatique de l'heure. Dans ce cas, vous pouvez le faire manuellement à
l'aide de la AT+CCLKcommande AT.

Connexion du blindage SIM900 GSM / GPRS


à Arduino UNO
Maintenant que nous savons tout sur le bouclier, nous pouvons commencer à
le connecter à notre Arduino!

Pour commencer, connectez les broches D7 (Tx) et D8 (Rx) du blindage aux


broches numériques # 7 et # 8 sur Arduino. Comme nous allons utiliser le
logiciel série pour parler au bouclier, assurez-vous que le capuchon du cavalier
est placé sur le port série logiciel sélectionné.
Alimentez le blindage à l'aide d'une alimentation externe de 5V 2A. Ne soyez
pas tenté de connecter cette broche à une alimentation 5V sur Arduino, car le
blindage peut ne pas fonctionner en raison du manque de courant
d'alimentation. Assurez-vous également de sélectionner la source
d'alimentation externe avec l'interrupteur à glissière à côté de la prise CC.

Connectez maintenant toute la masse du circuit.

Enfin, connectez l'antenne, insérez la carte SIM entièrement activée dans la


prise.

Connexion du bouclier GSM SIM900 au PC


Pour faire fonctionner le SIM900 GSM Shield directement sur PC, vous devez
le connecter au PC à l'aide de n'importe quel convertisseur USB vers TTL.
L'image ci-dessous montre le bouclier GSM SIM900 connecté au PC via le
convertisseur USB vers TTL PL2303.

Mise sous / hors tension de la puce SIM900


Même si vous allumez le bouclier, vous devez activer la puce SIM900 pour la
faire fonctionner.

Selon la fiche technique, tirer la broche PWRKEY sur la puce LOW pendant au


moins 1 seconde allumera / éteindra la puce. Il y a deux façons de faire cela
avec notre bouclier.

Déclencheur matériel
Le bouclier est livré avec un interrupteur tactile à angle droit situé près de
l'indicateur LED PWR. Vous devez appuyer sur cet interrupteur pendant environ
2 secondes pour allumer / éteindre le bouclier.

Déclencheur logiciel
Au lieu d'appuyer manuellement sur la touche PWRKEY à chaque fois, vous
pouvez monter / descendre le SIM900 par programmation.

Tout d'abord, vous devez souder le cavalier SMD nommé R13 sur le bouclier


comme indiqué dans l'image.

Ensuite, vous devez connecter la broche D9 sur le blindage à la broche D9 sur


Arduino.
Enfin, vous devez ajouter la fonction personnalisée suivante dans votre
programme.

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

Code Arduino - Test des commandes AT


Pour envoyer des commandes AT et communiquer avec le blindage SIM900,
nous utiliserons le moniteur série. L'esquisse ci-dessous permettra à l'Arduino
de communiquer avec le blindage SIM900 sur le moniteur série. Avant de
procéder à la ventilation détaillée du code, connectez votre Arduino au PC,
compilez le code ci-dessous et téléchargez-le sur l'Arduino.

Une fois que vous ouvrez un moniteur série, assurez-vous que l'option «À la


fois NL et CR» est sélectionnée!

#include <SoftwareSerial.h>

//Create software serial object to communicate with SIM900


SoftwareSerial mySerial(7, 8); //SIM900 Tx & Rx is connected to Arduino #7 &
#8

void setup()
{
//Begin serial communication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(9600);

//Begin serial communication with Arduino and SIM900


mySerial.begin(9600);

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

mySerial.println("AT"); //Handshaking with SIM900


updateSerial();
mySerial.println("AT+CSQ"); //Signal quality test, value range is 0-31 , 31
is the best
updateSerial();
mySerial.println("AT+CCID"); //Read SIM information to confirm whether the
SIM is plugged
updateSerial();
mySerial.println("AT+CREG?"); //Check whether it has registered in the
network
updateSerial();
}

void loop()
{
updateSerial();
}

void updateSerial()
{
delay(500);
while (Serial.available())
{
mySerial.write(Serial.read());//Forward what Serial received to Software
Serial Port
}
while(mySerial.available())
{
Serial.write(mySerial.read());//Forward what Software Serial received to
Serial Port
}
}

Explication du code:
L'esquisse commence par inclure une bibliothèque SoftwareSerial.h et
l'initialiser avec les broches Arduino auxquelles Tx et Rx du blindage SIM900
sont connectés.

#include <SoftwareSerial.h>

//Create software serial object to communicate with SIM900


SoftwareSerial mySerial(7, 8); //SIM900 Tx & Rx is connected to Arduino #7 &
#8

En fonction de configuration: nous initialisons une liaison de communication


série entre Arduino, Arduino IDE et le blindage SIM900 à un débit de 9600
bauds.

//Begin serial communication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(9600);

//Begin serial communication with Arduino and SIM900


mySerial.begin(9600);
Maintenant que nous avons établi une connexion de base, nous allons essayer
de communiquer avec le blindage SIM900 en envoyant des commandes AT.

AT - C'est la commande AT la plus élémentaire. Il initialise également l'Auto-


baud'er. Si cela fonctionne, vous devriez voir l'écho des caractères AT, puis OK,
vous disant que c'est OK et qu'il vous comprend correctement! Vous pouvez
ensuite envoyer des commandes pour interroger le bouclier et obtenir des
informations à son sujet telles que

AT + CSQ - Vérifiez la «force du signal» - le premier # est la force en dB, il doit


être supérieur à environ 5. Plus haut est mieux. Bien sûr, cela dépend de votre
antenne et de votre emplacement!

AT + CCID - obtenir le numéro de la carte SIM - cela teste que la carte SIM est
trouvée OK et vous pouvez vérifier que le numéro est écrit sur la carte.

À + CREG? Vérifiez que vous êtes enregistré sur le réseau. Le deuxième


numéro doit être 1 ou 5. 1 indique que vous êtes enregistré sur le réseau
domestique et 5 indique un réseau itinérant. En dehors de ces deux chiffres,
vous n'êtes inscrit sur aucun réseau.

mySerial.println("AT"); //Handshaking with SIM900


updateSerial();
mySerial.println("AT+CSQ"); //Signal quality test, value range is 0-31 , 31
is the best
updateSerial();
mySerial.println("AT+CCID"); //Read SIM information to confirm whether the
SIM is plugged
updateSerial();
mySerial.println("AT+CREG?"); //Check whether it has registered in the
network
updateSerial();

Dans la partie en boucle du code, nous appelons la fonction personnalisée


appelée updateSerial()qui attend en permanence les entrées du moniteur série
et l'envoie au blindage SIM900 via la broche D8 (Rx du blindage). Il lit
également en continu la broche D7 (Tx du bouclier) si le bouclier a des
réponses.
void updateSerial()
{
delay(500);
while (Serial.available())
{
mySerial.write(Serial.read());//Forward what Serial received to Software
Serial Port
}
while(mySerial.available())
{
Serial.write(mySerial.read());//Forward what Software Serial received to
Serial Port
}
}

Vous devriez voir la sortie ci-dessous sur le moniteur série.

Vous êtes maintenant libre d'envoyer toutes les commandes via le moniteur
série comme ci-dessous, ce qui donne plus d'informations sur la connexion
réseau et l'état de la batterie:

ATI - Obtenez le nom et la révision du bouclier

AT + COPS? - Vérifiez que vous êtes connecté au réseau


AT + COPS =? - Retourne la liste des opérateurs présents dans le réseau

AT + CBC - retournera l'état de la batterie lipo. Le deuxième nombre est le%


plein (dans ce cas, ses 93%) et le troisième nombre est la tension réelle en mV
(dans ce cas, 3,877 V)

Code Arduino - Envoi de SMS


Passons aux choses intéressantes. Programmons notre Arduino pour envoyer
un SMS à n'importe quel numéro de téléphone que vous souhaitez. Avant
d'essayer le croquis, vous devez entrer le numéro de téléphone. Recherchez la
chaîne ZZxxxxxxxxxx et remplacez ZZ par le code du comté et xxxxxxxxxx par
le numéro de téléphone à 10 chiffres.

#include <SoftwareSerial.h>

//Create software serial object to communicate with SIM900


SoftwareSerial mySerial(7, 8); //SIM900 Tx & Rx is connected to Arduino #7 &
#8

void setup()
{
//Begin serial communication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(9600);

//Begin serial communication with Arduino and SIM900


mySerial.begin(9600);

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

mySerial.println("AT"); //Handshaking with SIM900


updateSerial();

mySerial.println("AT+CMGF=1"); // Configuring TEXT mode


updateSerial();
mySerial.println("AT+CMGS=\"+ZZxxxxxxxxxx\"");//change ZZ with country code
and xxxxxxxxxxx with phone number to sms
updateSerial();
mySerial.print("Last Minute Engineers | lastminuteengineers.com"); //text
content
updateSerial();
mySerial.write(26);
}

void loop()
{
}

void updateSerial()
{
delay(500);
while (Serial.available())
{
mySerial.write(Serial.read());//Forward what Serial received to Software
Serial Port
}
while(mySerial.available())
{
Serial.write(mySerial.read());//Forward what Software Serial received to
Serial Port
}
}
L'esquisse est presque la même que précédemment, sauf l'extrait de code ci-
dessous. Une fois la connexion établie, nous envoyons ci-dessous les
commandes AT:

AT + CMGF = 1 - Sélectionne le format de message SMS sous forme de


texte. Le format par défaut est P rotocol D ata U nit (PDU)

AT + CMGS = + ZZxxxxxxxxxx - Envoie un SMS au numéro de téléphone


spécifié. Le message texte saisi suivi d'un caractère «Ctrl + z» est traité
comme un SMS. «Ctrl + z» est en fait un 26ème caractère non imprimable décrit comme
«substitut» dans la table ASCII . Nous devons donc envoyer le 26 décembre (1A Hex )
une fois que nous avons envoyé un message.

mySerial.println("AT+CMGF=1"); // Configuring TEXT mode


updateSerial();
mySerial.println("AT+CMGS=\"+ZZxxxxxxxxxx\"");//change ZZ with country code
and xxxxxxxxxxx with phone number to sms
updateSerial();
mySerial.print("Last Minute Engineers | lastminuteengineers.com"); //text
content
updateSerial();
mySerial.write(26);

La boucle est maintenue vide car nous ne voulons envoyer des SMS qu'une
seule fois. Si vous souhaitez envoyer des SMS une fois de plus, appuyez
simplement sur la touche RESET de votre Arduino. La capture d'écran ci-
dessous montre les SMS envoyés depuis le bouclier SIM900 GSM / GPRS.
Code Arduino - Lecture de SMS
Programmons maintenant notre Arduino pour lire les messages
entrants. Cette esquisse est très utile lorsque vous devez déclencher une
action lors de la réception d'un SMS spécifique. Par exemple, lorsque l'Arduino
reçoit un SMS, vous pouvez lui demander d'activer ou de désactiver un
relais. Vous avez l'idée!

#include <SoftwareSerial.h>

//Create software serial object to communicate with SIM900


SoftwareSerial mySerial(7, 8); //SIM900 Tx & Rx is connected to Arduino #7 &
#8

void setup()
{
//Begin serial communication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(9600);

//Begin serial communication with Arduino and SIM900


mySerial.begin(9600);

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

mySerial.println("AT"); //Handshaking with SIM900


updateSerial();

mySerial.println("AT+CMGF=1"); // Configuring TEXT mode


updateSerial();
mySerial.println("AT+CNMI=1,2,0,0,0"); // Decides how newly arrived SMS
messages should be handled
updateSerial();
}

void loop()
{
updateSerial();
}

void updateSerial()
{
delay(500);
while (Serial.available())
{
mySerial.write(Serial.read());//Forward what Serial received to Software
Serial Port
}
while(mySerial.available())
{
Serial.write(mySerial.read());//Forward what Software Serial received to
Serial Port
}
}

L'esquisse est similaire à celle précédente sauf ci-dessous l'extrait de


code. Une fois la connexion établie, nous envoyons ci-dessous les
commandes AT:

AT + CMGF = 1 - Sélectionne le format de message SMS sous forme de


texte. Le format par défaut est P rotocol D ata U nit (PDU)

AT + CNMI = 1,2,0,0,0 - spécifie comment les messages SMS nouvellement


arrivés doivent être traités. De cette façon, vous pouvez dire au bouclier
SIM900 soit de transférer les messages SMS nouvellement arrivés
directement vers le PC, soit de les enregistrer dans le stockage des messages,
puis d'informer le PC de leur emplacement dans le stockage des messages.

Sa réponse commence par + CMT: Tous les champs de la réponse sont


séparés par des virgules, le premier champ étant le numéro de téléphone. Le
deuxième champ est le nom de la personne qui envoie des SMS. Le troisième
champ est un horodatage tandis que le quatrième champ est le message réel.

mySerial.println("AT+CMGF=1"); // Configuring TEXT mode


updateSerial();
mySerial.println("AT+CNMI=1,2,0,0,0"); // Decides how newly arrived SMS
messages should be handled
updateSerial();

Notez que cette fois, nous n'avons PAS laissé la fonction de boucle vide car
nous interrogeons les messages SMS nouvellement arrivés. Une fois que vous
envoyez le SMS au bouclier SIM900 GSM / GPRS, vous verrez ci-dessous la
sortie sur le moniteur série.
Extension du logiciel Arduino Taille du tampon série
Si votre message est assez long comme le nôtre, vous le recevrez
probablement avec quelques caractères manquants. Ce n'est pas à cause d'un
code défectueux. Votre tampon de réception SoftwareSerial se remplit et
supprime des caractères. Vous ne lisez pas assez vite à partir du tampon.

La solution la plus simple consiste à augmenter la taille du tampon


SoftwareSerial de sa taille par défaut de 64 octets à 256 octets (ou moins,
selon ce qui fonctionne pour vous).

Sur un PC Windows, accédez à C: \ Program Files (x86) -> Arduino -> matériel -


> Arduino -> avr -> bibliothèques -> SoftwareSerial (-> src pour la nouvelle
version d'Arduino IDE) Ouvrez SoftwareSerial.h et modifiez la ligne:

// RX buffer size
#define _SS_MAX_RX_BUFF 64

// RX buffer size
#define _SS_MAX_RX_BUFF 256

Enregistrez le fichier et réessayez votre esquisse.


Ext
ension du logiciel Arduino Taille du tampon série

Code Arduino - Passer un appel


Maintenant, programmons notre Arduino pour passer un appel. Ce croquis est
très utile lorsque vous souhaitez que votre Arduino effectue un appel SOS / de
détresse en cas d'urgence comme un dépassement de la température ou une
effraction dans votre maison. Vous avez l'idée!

Avant d'essayer le croquis, vous devez entrer le numéro de


téléphone. Recherchez la chaîne ZZxxxxxxxxxx et remplacez ZZ par le code du
comté et xxxxxxxxxx par le numéro de téléphone à 10 chiffres.

#include <SoftwareSerial.h>

//Create software serial object to communicate with SIM900


SoftwareSerial mySerial(7, 8); //SIM900 Tx & Rx is connected to Arduino #7 &
#8

void setup()
{
//Begin serial communication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(9600);

//Begin serial communication with Arduino and SIM900


mySerial.begin(9600);

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

mySerial.println("AT"); //Handshaking with SIM900


updateSerial();

mySerial.println("ATD+ +ZZxxxxxxxxxx;"); // change ZZ with country code and


xxxxxxxxxxx with phone number to dial
updateSerial();
delay(20000); // wait for 20 seconds...
mySerial.println("ATH"); //hang up
updateSerial();
}

void loop()
{
}

void updateSerial()
{
delay(500);
while (Serial.available())
{
mySerial.write(Serial.read());//Forward what Serial received to Software
Serial Port
}
while(mySerial.available())
{
Serial.write(mySerial.read());//Forward what Software Serial received to
Serial Port
}
}

Pour passer un appel, les commandes AT sont utilisées:

ATD + + ZZxxxxxxxxxx; - Compose un numéro spécifié. Le ;modificateur


de point-virgule à la fin sépare la chaîne de numérotation en plusieurs
commandes de numérotation. Toutes les commandes sauf la dernière doivent
se terminer par le ;modificateur de point-virgule .

ATH - Raccroche l'appel

mySerial.println("ATD+ +ZZxxxxxxxxxx;"); // change ZZ with country code and


xxxxxxxxxxx with phone number to dial
updateSerial();
delay(20000); // wait for 20 seconds...
mySerial.println("ATH"); //hang up
updateSerial();

La capture d'écran ci-dessous montre l'appel effectué à partir du bouclier


SIM900 GSM / GPRS.
Code Arduino - Recevoir un appel
La réception d'un appel ne nécessite aucun code spécial; il vous suffit de
continuer à écouter le shield SIM900. Pourtant, vous pouvez trouver ce croquis
très utile, lorsque vous devez déclencher une action lorsqu'un appel d'un
numéro de téléphone spécifique est reçu.

#include <SoftwareSerial.h>

//Create software serial object to communicate with SIM900


SoftwareSerial mySerial(7, 8); //SIM900 Tx & Rx is connected to Arduino #7 &
#8

void setup()
{
//Begin serial communication with Arduino and Arduino IDE (Serial Monitor)
Serial.begin(9600);
//Begin serial communication with Arduino and SIM900
mySerial.begin(9600);

Serial.println("Initializing...");
}

void loop()
{
updateSerial();
}

void updateSerial()
{
delay(500);
while (Serial.available())
{
mySerial.write(Serial.read());//Forward what Serial received to Software
Serial Port
}
while(mySerial.available())
{
Serial.write(mySerial.read());//Forward what Software Serial received to
Serial Port
}
}

L'appel entrant est généralement indiqué par «SONNERIE» sur le moniteur


série suivi du numéro de téléphone et de l'ID de l'appelant. Pour accepter /
suspendre un appel, les commandes AT sont utilisées:

ATA - Accepte les appels entrants.

ATH - Raccroche l'appel. En raccrochant l'appel, il envoie NO CARRIER sur le


moniteur série indiquant que l'appel n'a pas pu se connecter.

La sortie ci-dessous sur le moniteur série montre l'appel reçu par le bouclier
SIM900 GSM / GPRS.