[Tuto] Trianguler la position avec le SIM800L (Arduino)

Pour voir le montage et la prise en main de ce module SIM800L, vous pouvez suivre le tuto sur cette page: Tuto SIM800L – Montage et prise en main 

Le programme suivant affiche dans le moniteur série la position du module SIM800L (latitude,longitude),ainsi que l’heure GMT ,grâce à des commandes AT :

//Importation des librairies
#include <SoftwareSerial.h>
#include <String.h>
#define AT_DELAY  3000    // Delai après envoi commande AT

SoftwareSerial sim800l(9, 10);// RX, TX

String Message, tampon;
String Latitude, Longitude, Time;
//stockage des differentes commandes // Configure le mode positionnement
String AT_COMMAND[9] = {"AT+CGATT =1", "AT+SAPBR =3,1,\"CONTYPE\",\"GPRS\"", "AT+SAPBR =3,1,\"APN\",\"orange.m2m.spec\"",
                        "AT+SAPBR =3,1,\"USER\",\"orange\"", "AT+SAPBR =3,1,\"PWD\",\"orange\"",
                        "AT+SAPBR=1,1", "AT+SAPBR=2,1", "AT+CIPGSMLOC=1,1"
                       };
void setup() {      // début du setup
  sim800l.begin(9600);// Démarrage du modem
  Serial.begin(9600);// Initialisation de la communication série
  Serial.println("start ...");
}

void loop() {    // Début du loop
  delay(2000);
  for (int k = 0; k < 9; k++)
  {
    sim800l.println(AT_COMMAND[k]);//envoie de la commande AT
    delay(650);//délai de réponse
    Message = sim800l.readString();//lecture du retour du sim800l
    Serial.println(Message);// affichage dans le moniteur série des commandes AT + réponse
    if (k == 8)
    {
      Serial.println("##############################################################");
      
      Serial.print("Time: "); 
      //récupération des chaines de caractère correspondant à l'heure
      Time = Message.substring(Message.indexOf('/') + 7, Message.indexOf('/') + 15);
      //affichage dans le moniteur série
      Serial.println(Time);
      
      Serial.println("##############################################################");
      
      Serial.print("Latitude: ");
      Latitude = Message.substring(Message.indexOf("0,") + 11, Message.indexOf(',') + 19);
      Serial.println(Latitude);
      
      Longitude = Message.substring(Message.indexOf(':') + 4, Message.indexOf(',') + 9);
      Serial.print("Longitude: ");
      Serial.println(Longitude);
      
      Serial.println("##############################################################");
    }
  }
  sim800l.println( "AT+SAPBR =0,1");

exit(0);
}


Récapitulatif des AT commandes utilisées pour la localisation:

CommandesRéponsesInfo
AT+CGATTOK
Connexion au service GPRS
AT+SAPBR =3,1, »CONTYPE », »GPRS »OKConfiguration du support en GPRS
AT+SAPBR =3,1, »APN », »orange.m2m.spec »OKConfiguration de l’APN
AT+SAPBR =3,1, »USER », »orange »OKUser de l’APN
AT+SAPBR =3,1, »PWD », »orange »OKMot de passe de l’APN
AT+SAPBR=1,1OKOuverture du support
AT+SAPBR=2,1+SAPBR: 1,1, »IP »
OK
Vérification de la connexion
AT+CIPGSMLOC=1,1+CIPGSMLOC: 0,Longitude,Latitude,AAAA/MM/JJ,H:MIN:SECRécupération de la localisation et de l’heure
AT+SAPBR =0,1OKFermeture du support
  1. Bonjour , le travail s’arrête en cours de travail sur ma cnc sans message d’erreur et ceci malgré différents tests:…

[TUTO] Update Firmware SIM8XX

Il existe plusieurs modules GSM de la série SIM800 de chez SIMCOM possédant chacun des spécificités propres : taille, interfaces, fonctions supplémentaires (GNSS, Bluetooth)… etc. Les firmwares de ces modules sont souvent mis à jour, intégrant alors de nouvelles fonctionnalités (ajout de nouvelles commandes, fix de bugs…). Cet article vous présente comment mettre à jour vos modules SIMCOM de la série SIM8XX et ainsi exploiter tout le potentiel de votre matériel.

Ce tutoriel utilise un flashage du firmware par la liaison série du module (RX / TX). Un Arduino en MultiSerial ou convertisseur UART – USB peuvent être utilisés afin d’interfacer le module avec votre ordinateur.

Le module utilisé pour la démonstration est un SIM800L de chez SIMCOM.

Téléchargement de l’outil :

Télécharger la dernière version du firmware du module sur le site officiel de SIMCOM : http://simcom.ee/documents/?dir

Lancer l’exécutable :

Entrer les configurations de la carte :

  • Target : type de carte utilisé (ici un SIM800L)
  • PortType : type de transfert, via liaison USB ou UART (RX / TX)
  • Com : port COM utilisé
  • Baud rate : vitesse de transmission (souvent 9600 ou 115200 par défaut)
  • Image Folder : sélection du firmware à flasher dans le module

Cliquer sur Image Folder afin de sélectionner le .cfg du firmware à flasher :

Vérifier que le module est bien ETEINT puis cliquer sur Start Download. Le module doit être éteint afin que le logiciel puisse flasher le module avant son démarrage complet. Une indication (waiting) apparait, attendant le démarrage du module.

Allumer le module. La barre de téléchargement doit alors se lancer.

Une fois le download correctement effectué, une fenêtre apparaît indiquant le bon déroulement du processus.

Sources d’erreurs possibles :

  • Mauvais port COM sélectionné
  • Erreur de branchement des signaux RX/TX
  • Ordre d’allumage du module
  • Mauvais firmware

nb : pour le cas du SIM800L, deux versions de firmwares existent. Selon la version du module il faut choisir l’une ou l’autre. La commande AT+GMR retourne la version du firmware dans le module :
1308B0XSIM800L16 = mettre la version de firmware disponible sur le site SIMCOM
1418B0XSIM800L24 = mettre la version de firmware suivante : 1418B05SIM800L24

Arduino Yun et SIM800L: problème de buffer

L’association d’un Arduino Yun et d’un SIM800L peut vous permettre de recevoir et de lire les données http de site web. Néanmoins, vous pouvez rencontrer un problème avec le buffer si vous désirez accéder à une url trop longue. Pour cela, nous vous proposons deux solutions:

Solution 1:

Vous devez modifier votre librairie Arduino SoftwareSerial. Trouvez le fichier SoftwareSerial.h dans votre ordinateur. Il devrait se situer dans Arduino > hardware > arduino > avr > librairies > SoftwareSerial.h

Modifiez la ligne de commande :

  #define _SS_MAX_RX_BUFF 64 // RX buffer size

En :

  #define _SS_MAX_RX_BUFF 256 // RX buffer size

Si cette solution ne fonctionne pas, essayez la suivante:

Solution 2:

Commencez par fermer l’IDE Arduino, puis rouvrez le. Compilez votre programme et copiez le contenu du débogueur dans un éditeur de texte type Word ou NotePad.. Recherchez à présent le fichier HardwareSerial.h et repérer le chemin dans le pc de ce fichier. Il ne vous reste plus qu’à l’ouvrir et à modifier le Serial Buffer Size, en l’augmentant par exemple à 256.

noir
buffe_size

Vous pouvez trouver différents tutoriels sur le SIM800L sur notre blog:

Retrouver également le module SIM800L et son kit sut la boutique letmeknow.fr et au 85 rue de Clery à Paris.

[Tuto] Module GSM SIM800L – Recevoir des données HTTP

Pour voir le montage et la prise en main de ce module SIM800L, vous pouvez suivre le tuto sur cette page: Tuto SIM800L – Montage et prise en main

On souhaite consulter une page web et récupérer son contenu pour pouvoir l’afficher dans le moniteur série. Pour cela, on utilise le réseau GPRS du module. Pour une carte SIM Free, l’APN a renseigné est tout simplement « free ». Pour d’autres opérateurs, il se peut qu’il y ai un identifiant et un mot de passe à renseigner. La commande AT à utiliser est alors : AT+CSTT=<APN>,<identifiant>,<mot de passe>

// Importation des librairies
#include <SoftwareSerial.h>
#include <String.h>
SoftwareSerial sim800l(7,8);          //RX, TX
boolean data;

void setup() {
  // Démarrage du modem
  sim800l.begin(9600);
  // Initialisation de la communication série 
  Serial.begin(9600);
  delay(500);
  data = true;
}

void loop() {
  if(data==true){
    getdata();
    data = false;
  }
  if (sim800l.available()>0) 
    Serial.write(sim800l.read());
}


void getdata(){
  Serial.println("Get data HTTP");
  //set up GPRS, connection type
  sim800l.print("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"\r");
  delay(1000);
  // set the APN
  sim800l.print("AT+SAPBR=3,1,\"APN\",\"free\"\r");
  delay(1000);
  //tries to connect to GPRS
  sim800l.print("AT+SAPBR=1,1\r");
  delay(2000);
  // initialise embedded HTTP ruttine
  sim800l.print("AT+HTTPINIT\r");
  delay(2000);
  // set the HTTP session
  sim800l.print("AT+HTTPPARA=\"CID\",1\r");
  delay(1000); 
  Serial.println("Enter the URL of the website: ");
  char url[100];
  readSerial(url);  // votre URL
  Serial.println(url);
  // set the HTTP URL
  sim800l.print("AT+HTTPPARA=\"URL\",\"");
  sim800l.print(url);
  sim800l.print("\"\r");
  delay(1000);
  // start the session
  sim800l.print("AT+HTTPACTION=0\r");
  delay(10000);
  // read the data of the HTTP server
  sim800l.print("AT+HTTPREAD\r");
  delay(1000);
  // terminate the HTTP server
  sim800l.print("AT+HTTPTERM\r");
  delay(100);
  sim800l.println();
}

int readSerial(char result[]) {
  int i = 0;
  while (1) {
    while (Serial.available() > 0) {
      char inChar = Serial.read();
      if (inChar == '\n') {
        result[i] = '\0';
        Serial.flush();
        return 0;
      }
      if (inChar != '\r') {
        result[i] = inChar;
        i++;
      }
    }
  }
}

Récapitulatif des AT commandes utilisées pour recevoir des données HTTP:

CommandeRéponseInfo
AT+CGATT ?+CGATT : <nbr de réseau>Cherche le nombre de réseau disponible
AT+SAPBR=3,1,”CONTYPE”,”GPRS”OKConfigure le profil 1, type de connexion internet : GPRS
AT+SAPBR=3,1,”APN”,”free”OKConfigure le réseau APN
AT+SAPBR=1,1OKTentative de connexion GPRS
AT+HTTPINITOKInitialisation
AT+HTTPPARA=”CID”,1OKConfiguration http
AT+HTTPPARA=”URL”,”<URL>”OKConfigure l’adresse URL
AT+HTTPACTION=0OKLance la session
AT+HTTPREAD+HTTPREAD :<date_len>,<contenu>Lis les données DATA du serveur http
AT+HTTPTERMOKFin
AT+CIFSR<adresse IP>Retourne l’adresse IP

[Tuto] Module GSM SIM800L – Appeler

Pour voir le montage et la prise en main de ce module SIM800L, vous pouvez suivre le tuto sur cette page: Tuto SIM800L – Montage et prise en main.
Ce programme appellera le numéro entré dans le moniteur série et raccrochera tout seul au bout de 10 secondes.

// Importation des librairies
#include <SoftwareSerial.h>
#include <String.h>
SoftwareSerial sim800l(7,8);          // RX, TX
boolean call;

void setup(){
  sim800l.begin(9600);  // Démarrage du modem
  Serial.begin(9600);   // Initialisation de la communication série
  delay(500); 
  call = true;
  if(sim800l.available()) 
  Serial.write(sim800l.read());
  } 

void loop(){ 
  if(call==true){
    voicecall();
    call = false;
   }
 } 

void voicecall(){ 
  Serial.println("Make voice call"); 
  Serial.println("Enter the phone number you want to call"); 
  char number[20]; 
  readSerial(number); 
  Serial.print("Calling: "); 
  Serial.println(number); 
  delay(100); 
  sim800l.print("ATD");   // Appel 
 sim800l.print(number); 
  sim800l.print(";\r"); 
  delay(3000); 
  Serial.println("Hung up in 10 sec");
  delay(10000); 
  sim800l.print("ATH\r");    
  // Raccroche Serial.println("Call ended"); 
  sim800l.println(); 
} 

int readSerial(char result[]) { 
  int i = 0; 
  while (1) { 
    while (Serial.available() > 0) { 
    char inChar = Serial.read(); 
    if (inChar == '\n') { 
      result[i] = '\0';
      Serial.flush(); 
      return 0; 
    }
    if (inChar != '\r'){
      result[i] = inChar; i++; 
    } 
   }
  }
}

Récapitulatif des commandes AT nécessaires pour passer un appel:

CommandeRéponseInfo
ATD<n° de tél>OKAppel
ATHOKRaccroche
ATAOKRépond à un appel entrant

[Tuto] Module GSM SIM800L – Recevoir un SMS et le lire

Pour voir le montage et la prise en main de ce module SIM800L, vous pouvez suivre le tuto sur cette page: Tuto SIM800L – Montage et prise en main

Le programme suivant reçoit et affiche dans le moniteur série les SMS contenus sur la carte SIM, à l’aide des commandes AT :

 // Importation des librairies
#include <SoftwareSerial.h>
#include <String.h>
SoftwareSerial sim800l(7,8);    // RX, TX
boolean sms;

void setup(){      // début du setup
  // Démarrage du modem
  sim800l.begin(9600);
  // Initialisation de la communication série
  Serial.begin(9600);
  delay(500);    // Délai pour la connexion
  sms = true;
}

void loop(){    // Début du loop
  if(sms==true){
    receivesms();
    sms = false;
  }
  // affichage dans le moniteur série des commandes AT + réponse
  if (sim800l.available()>0)
    Serial.write(sim800l.read());
  }

void receivesms(){
  Serial.println("Receiving text message...");
  sim800l.print("AT+CMGF=1\r");   // Configure le mode SMS
  // Affiche tous les messages
  sim800l.print("AT+CMGL=\"ALL\"\r");
  delay(1000);
  sim800l.println();
receivesms1

En fonction de vos besoin vous pouvez remplacer AT+CMGL= »ALL » par :

  • AT+CMGL= « REC READ » : Affiche tous les messages lus
  • AT+CMGL= « REC UNREAD » : Affiche tous les messages non lus.

Si vous désirez supprimer les SMS contenus sur la carte SIM, il faut exécuter la commander AT+CMGD :

  • AT+CMGD =1 : supprime les SMS déjà lus
  • AT+CMGD=2 : supprime les SMS lus, et envoyés
  • AT+CMGD=3 : supprime les SMS lus, envoyés et non envoyés
  • AT+CMGD=4 : supprimes tous les SMS (lus, non lus, envoyés et non envoyés)

Attention ! Pour pouvoir afficher correctement l’ensemble du contenu de vos messages, vous devez modifier votre librairie Arduino SoftwareSerial.

Trouvez le fichier SoftwareSerial.h et modifiez la ligne de commande :

  #define _SS_MAX_RX_BUFF 64 // RX buffer size

En :

  #define _SS_MAX_RX_BUFF 256 // RX buffer size

Récapitulatif des commandes AT nécessaires pour lire et supprimer des SMS:

CommandeRéponseInfo
AT+CMGL= ”REC UNREAD”+CMGL : <index>, ”REC UNREAD”,”<n° de tél>,””,<Date et heure>

<Message>

OK

Affiche tous les SMS non lus
AT+CMGL= ”REC READ”+CMGL : <index>, ”REC READ”,”<n° de tél>,””,<Date et heure>

<Message>

OK

Affiche tous les SMS lus
AT+CMGL= ”STO UNSENT READ”OKEnregistre les SMS non envoyés
AT+CMGL= ”STO SENT READ”OKEnregistre les SMS envoyés
AT+CMGL=”ALL”+CMGL : <index>, ”ALL”,”<n° de tél>,””,<Date et heure>

<Message>

OK

Affiche tous les messages
AT+CMGD=1OKSupprime les SMS déjà lus
AT+CMGD=2OKSupprime les SMS lus et non envoyés
AT+CMGD=3OKSupprime les SMS lus, envoyés et non envoyés
AT+CMGD=4OKSupprime tous les SMS (lus, non lus, envoyés et non envoyés)

[Tuto] Module GSM SIM800L – Envoyer un SMS

Pour voir le montage et la prise en main de ce module SIM800L, vous pouvez suivre le tuto sur cette page: Tuto SIM800L – Montage et prise en main

Le programme suivant utilise les AT commandes pour envoyer un SMS.

 // Importation des librairies
#include <SoftwareSerial.h>
#include <String.h> 

SoftwareSerial sim800l(7,8); // RX,TX
boolean sms;

void setup(){           // Début du setup
  sim800l.begin(9600);  // Démarrage du modem
  Serial.begin(9600);	// Initialisation de la communication série
  delay(500);		// Délai pour la connexion 
  sms = true;
  
  if(sim800l.available())
  Serial.write(sim800l.read());
  }
  
   void loop(){	// Début du loop
   if(sms==true){
     sendsms();				
     sms = false;
   }
 }
   
  void sendsms(){
    Serial.println("Sending text message...");
    sim800l.print("AT+CMGF=1\r");  // Lance le mode SMS
    delay(100);
    // Entrez votre numéro de téléphone    
    sim800l.print("AT+CMGS=\"+3367617****\"\r");  
    delay(100);
    // Entrez votre message ici    
    sim800l.print("Message ici \r");  
    // CTR+Z en langage ASCII, indique la fin du message
    sim800l.print(char(26));			  
    delay(100);
    sim800l.println();
    Serial.println("Text send");  // Le message est envoyé.
    }

Ou pour modifier les informations (numéro de téléphone, message) dans le moniteur série :

 // Importation des librairies
#include <SoftwareSerial.h>
#include <String.h>
SoftwareSerial sim800l(7,8);
boolean sms;

void setup(){
  sim800l.begin(9600);  // Démarrage du modem
  Serial.begin(9600);   // Initialisation de la communication série
  delay(500);           // Délai connexion
  sms = true;
  if(sim800l.available())
    Serial.write(sim800l.read());
  }

void loop(){
  if(sms==true){   // on ne passe qu’une seule fois dans le loop()
    sendsms();
  sms = false;
}
}

void sendsms(){
  // set SMS mode
  Serial.println("SMS sender");
  sim800l.print("AT+CMGF=1\r");    // initialise le mode SMS
  delay(100);
  // phone number
  Serial.println("Enter the phone number :");
  char number[20] ;
  readSerial(number);
  sim800l.print("AT+CMGS=");
  sim800l.print(number);
  sim800l.print("\"\r");
  // message
  delay(100);
  Serial.print("Enter your message to send to : ");
  Serial.println(number);
  char message[200];
  readSerial(message);
  sim800l.println(message);
  sim800l.print(char(26));
  delay(100);
  sim800l.println();
  Serial.print("Message : ");
  Serial.println(message);
  Serial.println("Text send");
 }

int readSerial(char result[]){
  int i = 0;
  while (1)
  {
  while (Serial.available() > 0){
    char inChar = Serial.read();
    if (inChar == '\n')
    {
  result[i] = '\0';
  Serial.flush();
  return 0;
  }
  if (inChar != '\r'){
    result[i] = inChar;
    i++;
  }}}}

Récapitulatif des commandes AT pour l’envoi d’un SMS

CommandeRéponseInfo
AT+CMGF=1OKConfigure le mode SMS
AT+CMGS=”<numéro de telephone>”  ENTER

> Votre message  CTR+Z

OKEnvoi un SMS au numéro indiqué

[Tuto] Module GSM SIM800L – Prise en main

Le module GSM SIM800L est l’un des plus petits modules GSM du monde avec une taille de 2.2 cm x 1.8 cm. C’est un module puissant qui démarre automatiquement et recherche automatiquement le réseau. Il inclut notamment le Bluetooth 3.0+EDR et la radio FM (récepteur uniquement). Il vous permettra d’échanger des SMS, de passer des appels mais aussi, et c’est nouveau, de récupérer de la data en GPRS 2G+. Ainsi vous pourrez faire transiter des données sur une très longue distance, si par exemple la radio FM ou le Bluetooth ne vous suffit plus.

Librairies : SoftwareSerial.h

Matériel : Arduino, SIM800L, carte SIM, diode 1N4007, jumpers, breadboard

Datasheets : SIM800L | At command

Montage :

Ce module nécessite une alimentation entre 3,4V et 4,4V. L’alimentation 5V de l’Arduino ne lui convient donc pas. Pour contrer ce problème d’alimentation, on ajoute une diode 1N4007 entre le 5V de l’Arduino et le pin VCC du SIM800L. Le SIM800L nécessite un pic de courant d’environ 2A. Le reste du branchement est détaillé ci-dessous. La pin reset doit être relié au 3,3v de l’arduino.

untitled-2
20161003_1223291

Il faut également insérer votre SIM dans le compartiment prévu à cet effet sur le module, comme montré dans la photo ci-dessous. Le sens d’insertion de la carte SIM dans le module à son importance. La carte SIM doit être une micro SIM.

SIM800L

Les AT commands (Commandes Hayes)

Les commandes AT sont définies dans la norme GSM 07.07.AT est l’abréviation de ATtention. Ces 2 caractères sont toujours présents pour commencer une ligne de commande sous forme de texte (codes ASCII). Les commandes permettent la gestion complète du module.

On peut utiliser ces commandes directement dans le moniteur série. Il suffit de compiler, téléverser le programme ci-dessous et d’ouvrir le moniteur série. Vous n’avez plus qu’à entrer les différentes commandes AT pour effectuer ce que vous désirez.

Vous pouvez envoyer ou recevoir des SMS, passer ou recevoir un appel, récupérer des données HTTP en entrant directement dans le moniteur série les commandes nécessaires.

// Connect VCC to +5V
// Connect GND to Ground
// Connect RXD (data into SIM800L) to Digital 8
// Connect TXD (data out from SIM800L) to Digital 7
#include <SoftwareSerial.h>
SoftwareSerial sim800l(7, 8); // RX, TX

void setup() {
 Serial.begin(9600);
 sim800l.begin(9600);
}

void loop(){
 if (sim800l.available())
 Serial.write(sim800l.read());

 if (Serial.available()) {
 while(Serial.available()){
 sim800l.write(Serial.read());
 }
 sim800l.println();
 }
}

Le code PIN

Il se peut que votre carte SIM soit verrouillée à l’aide d’un code PIN. Vous devrez entrer à chaque fois votre code pour déverrouiller votre carte. Ajouter les lignes de commandes suivantes avant le setup() et remplacer les XXXX par votre code PIN.

// Code PIN de la carte SIM

String SIM_PIN_CODE = String( "XXXX" );

Puis, ajoutez dans la boucle setup():

sim800l.print("AT+CPIN=");
sim800l.println( SIM_PIN_CODE );

1er test : Lancer le module et récupérer son IMEI

On peut utiliser les AT commandes pour obtenir l’IMEI. La commande AT+GSN récupère l’IMEI de votre module. Vous pouvez ainsi vérifier que ce que vous obtenez est bien l’IMEI inscrit sur votre module.

On peut trouver dans le logiciel de l’Arduino un programme qui va nous permettre d’afficher l’IMEI de la SIM800L dans le moniteur série. Ce programme se trouve dans Fichier > Exemples > GSM > Tools > TestModem.

Les principales commandes de test :

ATISIM800 R13.08Statut du modem
AT+CREG+CREG : 0,5Statut du réseau.

1er indice : 0 -> GSM

2ème indice : 0 -> pas de réseau

5 -> réseau ok

 

 

AT+CPIN ?+CPIN READYPas de code PIN nécessaire
AT+CSQ+CSQ : <rssi>,<ber>Intensité du signal.

<rssi> : received signal strength indication.

<ber>: bit error rate (%)

0 -> less than 0,2%

AT+COPS ?+COPS : <mode>,<format>,<opérateur>Affiche l’opérateur sélectionné