Réception de SMS avec Arduino et la SIM808
Cet article est le premier d’une série consacrée à l’utilisation d’Arduino avec la carte de développement SIM808. Il y est décrit la prise en main de la carte SIM808 au travers d’un programme de réception de SMS.
Le matériel nécessaire
Pour ce projet, nous utilisons les éléments suivants.
Prise en main de la carte SIM808
Présentation de la SIM808 EVB-V3.2
La carte de développement SIM808 EVB-V3.2 est une carte plutôt complète pour son prix abordable. Elle inclue en effet:
- un modem GSM / GPRS quadribande compatible avec les fréquences 850, 900, 1800 et 1900MHz
- un modem GPS
- un modem Bluetooth
La répartition des 3 connecteurs coaxiaux SMA des antennes est la suivante:
Carte SIM
Pour fonctionner, la carte de développement SIM808 nécessite une carte téléphonique SIM au format mini SIM, c’est à dire “le gros format”.
Il est important de choisir un opérateur téléphonique émettant sur au moins une bande de fréquences compatible avec les fréquences SIM808 EVB-V3.2 (listées au chapitre précédent). Vous trouverez la liste des bandes de fréquences par opérateur au lien suivant pour la France métropolitaine.
Pour ma part j’ai souscrit un abonnement de téléphonie spécifique pour mes tests auprès de l’opérateur SYMA qui utilise le réseau mobile d’Orange (offre à 1€90 par mois). La SIM que j’ai reçue était au bon format (mini SIM) avec le prédécoupage micro et nano.
Démarrage de la carte SIM808
La carte SIM808 EVB-V3.2 nécessite d’être démarrée après chaque mise sous tension afin d’être utilisable. La procédure à suivre pour démarrer la carte est la suivante:
- Brancher le connecteur Jack d’alimentation sur la carte (1)
- Pousser le bouton d’alimentation de la carte en position ON vers l’intérieur de la carte (2). La LED d’indication de carte sous tension s’allume (3).
- Réaliser un appui long sur le bouton poussoir de démarrage de la carte (4) jusqu’à ce que les LED d’état de la carte se mettent à clignoter (5).
Pour une meilleur compréhension, voici la vidéo des étapes à réaliser:
Câblage de la carte SIM808 avec Arduino
La carte de développement SIM808 nécessite une puissance d’alimentation de l’ordre de 10 watts. La puissance transmise à la carte Arduino par le PC à travers le câble USB n’est pas suffisante. Dans le cadre de ce projet nous utilisons un transformateur 9V de 2A pour fournir la puissance nécessaire à la carte SIM808. Un transformateur délivrant une tension entre 5 à 26V de puissance équivalente est également utilisable.
La communication entre la carte Arduino et la carte SIM808, repose sur une liaison TTL. Dans ce tutoriel nous choisissons les ports 2 et 3 de l’Arduino. Ne pas oublier de relier les masses des deux carte afin que les signaux échangés aient la même référence:
- La broche RXD de la SIM808 est reliée à la sortie 3 de l’Arduino,
- la broche TXD de la SIM808 est reliée à l’entrée 2 de l’Arduino.
- Les deux masses ensembles (GND).
Bibliothèque de gestion de la carte de développement SIM808:
La gestion de la communication TTL avec la carte de développement SIM808 nécessite l’installation d’une bibliothèque non-standard Arduino, la bibliothèque “GSM/GPRS & GPS Shield”.
Téléchargement de la bibliothèque “GSM/GPRS & GPS Shield”:
Cette bibliothèque n’est pas disponible dans le gestionnaire de bibliothèques de l’Arduino IDE. Il est nécessaire de la télécharger sur le site GitHub du projet: https://github.com/MarcoMartines/GSM-GPRS-GPS-Shield
ou bien en utilisant ce lien.
Emplacement des bibliothèques Arduino sur votre PC:
Pour savoir à quel endroit sont stockées les bibliothèques Arduino sur votre PC, il suffit de consultez le paramétrage de l’IDE Arduino. Pour cela, dans le menu “Fichier”, cliquez sur “Préférences”:
… dans la zone de saisie “Emplacement du carnet de croquis” se trouve renseignée l’emplacement du répertoire racine “croquis”. Les bibliothèques Arduino installées sur le PC sont localisées dans le sous-répertoire “libraries”.
Installation de la bibliothèque “GSM/GPRS & GPS Shield”:
Après avoir décompressé votre fichier zippé, vous obtenez un dossier “GSM-GPRS-GPS-Shield-GSMSHIELD” contenant deux dossiers “doc” et “exemples” ainsi que le code source de la bibliothèque.
L’installation de la bibliothèque consiste simplement à déplacer ce dossier “GSM-GPRS-GPS-Shield-GSMSHIELD” dans le dans le sous-répertoire “libraries” identifié précédemment.
Suppression des traces de déverminage de la bibliothèque “GSM/GPRS & GPS Shield”:
Par défaut, toutes les traces de déverminage sont activées dans la librairie “GSM/GPRS & GPS Shield”. Nous allons désactiver cette configuration afin de faciliter la lecture des nouvelles traces que nous ajouterons dans le programme applicatif.
Dans le dossier “GSM-GPRS-GPS-Shield-GSMSHIELD” que vous venez de déplacer, ouvrez le fichier “GSM.h” avec un simple éditeur de code source comme par exemple Notepad++, puis recherchez la directive de précompilation “#define DEBUG_ON”:
#define DEBUG_ON
Passez cette ligne en commentaire:
//#define DEBUG_ON
Vous venez de terminer l’installation de la bibliothèque de gestion de la carte de développement SIM808.
Le programme de réception de SMS
Ce programme a pour objectif la réception de SMS et l’affichage de leur contenu sur liaison série.
Comme d’habitude, nous démarrons l’écriture du logiciel par l’ossature de code Arduino suivante:
// Fonction de démarrage, s'exécute une seule fois:
void setup()
{
}
// Fonction principale du programme, s'exécute en boucle:
void loop()
{
}
Bibliothèque nécessaire
Pour cette partie du programme, seul le module de gestion SMS de la bibliothèque « GSM-GPRS-GPS-Shield-GSMSHIELD » est nécessaire. Il se déclare par les lignes:
// Déclaration des bibliothèques utilisées #include "sms.h"
Fonction d’initialisation de la carte SIM808
Afin de faciliter la lecture de notre code nous regroupons l’initialisation de la SIM808 dans une seule fonction “initialiser_sim808”. Voici le prototype de cette fonction:
// Prototypes de fonction void initialiser_Sim808(void);
Nous déclarons ensuite un objet global pour la classe “SMSGSM”. Cette classe regroupe l’ensemble des méthodes de la bibliothèque “GSM-GPRS-GPS-Shield-GSMSHIELD” permettant d’envoyer, recevoir ou effacer les SMS:
// Variables globales SMSGSM *gestionnaire_sms;
L’initialisation de la SIM808 s’effectue au démarrage du programme après avoir initialiser le port série pour les traces de notre programme applicatif :
// Fonction de démarrage, s'exécute une seule fois:
void setup()
{
// Ouverture du port USB pour l'envoi des traces au PC
Serial.begin(115200);
// Initialisation de la communication avec la carte SIM808
initialiser_sim808();
}
Passons maintenant à l’écriture du contenu de la fonction “initialiser_sim808”.
La commande proposées par la bibliothèque “GSM-GPRS-GPS-Shield-GSMSHIELD” pour initialiser la carte SIM808 est la méthode “begin” de l’objet statique “gsm” . Cette méthode possède comme paramètre la vitesse de communication série de la liaison TTL exprimée en bauds. (Pour rappel la carte Arduino et la carte SIM808 communique par liaison série). Étant donné les capacités limitées de la SIM808 il est nécessaire de choisir une vitesse pas trop élevée, ce sera 9600 dans notre cas.
Une fois cette initialisation réalisée, l’objet “gestionnaire_sms” peut-être instancié. Il ne faut pas oublier de libérer la mémoire dans le cas d’un nouvel appel à cette fonction d’initialisation de la la carte SIM808 en cours de programme.
En ajoutant l’envoie de traces par le port série, nous arrivons au code suivant pour la fonction “initialiser_sim808” :
void initialiser_sim808(void)
{
if(gestionnaire_sms!=NULL)
{
free(gestionnaire_sms);
}
Serial.println(F("Connexion avec la carte SIM808."));
while(!gsm.begin(9600))
{
Serial.println(F("Echec de communication avec la carte SIM808. Nouvelle tentative..."));
}
Serial.println(F("La communication avec la carte SIM808 est établie."));
gestionnaire_sms = new SMSGSM();
}
Lire les SMS
Commençons par définir la taille maximale du texte SMS (100 caractères) et la taille maximale d’un numéro de téléphone (15 chiffres):
// Dimensionnement des variables #define TAILLE_MAX_MESSAGE 100 #define TAILLE_NUMERO 15
Puis la structure de stockage d’un SMS:
// Définitions des types
typedef struct
{
char telephone[TAILLE_NUMERO];
char message[TAILLE_MAX_MESSAGE];
} sms_t;
Les 2 principales méthodes permettant d’accéder aux SMS reçues sont les méthodes “IsSMSPresent” et “GetSMS” de notre objet “gestionnaire_sms”.
La méthode “IsSMSPresent” examine la liste des SMS en mémoire et retourne un index sur le premier SMS correspondant aux critères recherchés. Les critère de recherche sont passés à cette méthode sous la forme d’un paramètre d’un octet. Les valeurs possibles pour ce paramètre sont:
- SMS_UNREAD: recherche les SMS non lus
- SMS_READ: recherche les SMS déjà lus
- SMS_ALL: recherche tout les SMS (non lus ou déjà lus)
Une fois l’index du SMS obtenu, l’utilisation de la méthode “GetSMS” permet de récupérer le contenu du SMS correspondant. Cet méthode prend 5 paramètres:
- l’index du SMS concerné
- un pointeur sur la variable de réception du numéro de téléphone
- le nombre de chiffre maximum pour le numéro de téléphone
- un pointeur sur la variable de réception du texte du SMS
- le nombre de caractères maximum pour le texte du SMS
A partir de cette réflexion nous en déduisons la fonction “lire_premier_sms_non_lu” suivante permettant de lire un nouveau SMS reçu:
bool lire_premier_sms_non_lu(sms_t *sms_p)
{
char code_retour, position_sms;
byte statut_sms;
bool sms_trouve;
// Valeurs par defaut
sms_trouve = false;
code_retour = gestionnaire_sms->IsSMSPresent(SMS_UNREAD);
if(code_retour<0)
{
// Reinitialisation de la communication avec la carte SIM808
initialiser_sim808();
}
else if(code_retour > 0)
{
position_sms = code_retour;
// Il y a au moins un SMS non lu:
code_retour = gestionnaire_sms->GetSMS(position_sms, sms_p->telephone, TAILLE_NUMERO, sms_p->message, TAILLE_MAX_MESSAGE);
if(code_retour<0)
{
// Reinitialisation de la communication avec la carte SIM808
initialiser_sim808();
}
else
{
sms_trouve = true;
}
}
return(sms_trouve);
}
Il ne reste plus qu’à appeler cette fonction “lire_premier_sms_non_lu” et transmettre le contenu des SMS sur la liaison série:
// Fonction principale du programme, s'exécute en boucle:
void loop()
{
sms_t sms;
if(lire_premier_sms_non_lu(&sms))
{
// Un nouveau SMS a été trouvé:
Serial.print(sms.telephone);
Serial.print(F(" --> "));
Serial.println(sms.message);
}
}
Ces précédentes lignes de code marque la fin de notre programme. Pour synthèse, voici le code complet:
// Déclaration des bibliothèques utilisées
#include "sms.h"
// Dimensionnement des variables
#define TAILLE_MAX_MESSAGE 100
#define TAILLE_NUMERO 15
// Définitions des types
typedef struct
{
char telephone[TAILLE_NUMERO+1];
char message[TAILLE_MAX_MESSAGE+1];
} sms_t;
// Prototypes de fonction
void initialiser_Sim808(void);
// Variables globales
SMSGSM *gestionnaire_sms;
// Fonction de démarrage, s'exécute une seule fois:
void setup()
{
// Ouverture du port USB pour l'envoi des traces au PC
Serial.begin(115200);
// Initialisation de la communication avec la carte SIM808
initialiser_sim808();
}
// Fonction principale du programme, s'exécute en boucle:
void loop()
{
sms_t sms;
if(lire_premier_sms_non_lu(&sms))
{
// Un nouveau SMS a été trouvé:
Serial.print(sms.telephone);
Serial.print(F(" --> "));
Serial.println(sms.message);
}
}
void initialiser_sim808(void)
{
if(gestionnaire_sms!=NULL)
{
free(gestionnaire_sms);
}
Serial.println(F("Connexion avec la carte SIM808."));
while(!gsm.begin(9600))
{
Serial.println(F("Echec de communication avec la carte SIM808. Nouvelle tentative..."));
}
Serial.println(F("La communication avec la carte SIM808 est établie."));
gestionnaire_sms = new SMSGSM();
}
bool lire_premier_sms_non_lu(sms_t *sms_p)
{
char code_retour, position_sms;
bool sms_trouve;
// Valeurs par defaut
sms_trouve = false;
code_retour = gestionnaire_sms->IsSMSPresent(SMS_UNREAD);
if(code_retour<0)
{
// Reinitialisation de la communication avec la carte SIM808
initialiser_sim808();
}
else if(code_retour > 0)
{
position_sms = code_retour;
// Il y a au moins un SMS non lu:
code_retour = gestionnaire_sms->GetSMS(position_sms, sms_p->telephone, TAILLE_NUMERO, sms_p->message, TAILLE_MAX_MESSAGE);
if(code_retour<0)
{
// Reinitialisation de la communication avec la carte SIM808
initialiser_sim808();
}
else
{
sms_trouve = true;
}
}
return(sms_trouve);
}
Démarrage et tests
La procédure à suivre pour tester le programme est la suivante:
- Compiler puis transférer ce programme dans le microcontrôleur Arduino
- Démarrer la carte SIM808
- Effectuer un redémarrage de votre Arduino Uno en appuyant sur le bouton “Reset”.
- Ouvrir une console série à 115200 bauds.
Dans un premier temps va s’afficher la ligne:
Connexion avec la carte SIM808.
puis au bout de quelques secondes:
La communication avec la carte SIM808 est établie.
Si vous n’arrivez pas à obtenir cette dernière ligne, je vous invite à vérifier les éléments suivants:
- Le câblage entre votre carte Arduino Uno et votre carte SIM808.
- L’alimentation de votre carte SIM808.
- La bonne mis en place de la mini SIM dans le support SIM situé au dos de la carte SIM808.
Si au contraire cette ligne s’affiche bien, vous pouvez envoyer vos SMS au numéro de votre carte SIM de test. Le numéro de l’appelant ainsi que le contenu de message s’affichera sur la console série:
Attention toutefois à ne pas dépasser la taille maximale de 100 caractères par message que nous avons définie dans notre programme.
Pour une meilleurs compréhension, voici la vidéo avec les différentes étapes de test:
Le programme de réception de SMS avec Avec Arduino et la carte SIM808 est terminé. D’autres articles avec la SIM808 sont en préparation afin de découvrir le pilotage du modem GPS et enfin réaliser un projet de balise GPS autonome.
Pour continuer:
Pour continuer avec Arduino, voici deux projets qui pourrait vous intéresser:
Bonjour,
Est ce que la SIM808 fonctionne en 3G ou en 2G?
Bonne journée.
Bonjour Jcat,
c’est du GPRS, donc 2G.
tres beau travail, svp faite de meme pour l’ESP32 avec la SIM808 cet a dire schema de cablage , le fonctionnement et le mode operatoire. Merci