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.

Carte Arduino UNO	Câble USB 2.0 Type A/B	Carte SIM808 EVB-V3.2
Transformateur d’alimentation 5V à 26V	Antenne GSM	Câbles mâle/femelle

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:

1. Compiler puis transférer ce programme dans le microcontrôleur Arduino
2. Démarrer la carte SIM808
3. Effectuer un redémarrage de votre Arduino Uno en appuyant sur le bouton “Reset”.
4. 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:

• Horloge connectée avec Arduino
• Caméra Wi-Fi ESP32-CAM avec Arduino