Sommaire
Transformer votre Arduino en un Communicateur Puissant avec le Shield SIM800C
Si vous avez déjà plongé dans l’univers des Power Rangers, vous connaissez le moment épique où chaque personnage invoque son robot personnel pour combattre le mal. Imaginez maintenant pouvoir fusionner ces robots individuels pour créer un Megazord imparable.
Notre équivalent à cette fusion incroyable ?
L’assemblage du Shield SIM800C avec un Shield Carte SD sur une Arduino UNO pour des communications hors normes ! Avec cette combinaison puissante, vous pouvez transformer votre Arduino en un communicateur ultra-performant, capable de gérer des tâches de communication complexes et de stocker des données de manière efficace.
Présentation du Module SIM800C
Le Shield SIM800C représente l’épine dorsale de la communication pour votre projet Arduino. Compatible avec la 2G, il offre un accès fluide aux fonctionnalités GSM GPRS, permettant l’envoi de SMS, de MMS et la gestion des appels.
Compatibilité et Alimentation Simplifiée
- Compatibilité : Conçu pour une parfaite intégration avec les cartes Arduino UNO et MEGA.
- Alimentation : Peut être alimenté soit par la carte Arduino, soit via une source externe, garantissant une flexibilité optimale. Nous optons pour une alimentation simple via la carte Arduino UNO.
- Cartes nécessaires : Carte Nano SIM et carte SD (ou micro) d’au moins 4Go pour tirer pleinement parti de ses capacités.
Mise en Route et Activation
- Alimentation : Lorsque la carte Arduino est mise sous tension, la LED PWR du Shield SIM800C s’allume, signalant l’alimentation.
- Activation : Pour activer le module, maintenez enfoncé le bouton On/Off du Shield pendant au moins 3 secondes. Alternativement, l’utilisation du mode AutoStart via un programme Arduino peut contrôler l’allumage et l’extinction du module de manière automatisée.
Statut Opérationnel
- Indicateurs LED : Une fois activé, le module réveillé est signalé par l’allumage de la LED STA (pour STATUS = ÉTAT).
- Recherche de réseau : Accompagné d’un clignotement rapide de la LED NET (pour NETWORK = RÉSEAU) au démarrage (recherche du réseau).
- Connexion au réseau : Suivi d’un clignotement toutes les 3 secondes environ (réseau trouvé). À ce stade, votre Shield est opérationnel et prêt à gérer les appels, les SMS et les MMS.
L'Assemblage du Megazord Arduino
Pour atteindre cette fusion incroyable, nous utilisons le Shield SIM800C et le Shield Carte SD, montés sur une carte Arduino UNO. Ensemble, ces composants transforment votre Arduino en un communicateur ultra-puissant, capable de gérer des tâches de communication complexes tout en stockant et en récupérant des données efficacement.
- Arduino UNO : La base de votre projet, offrant la puissance de traitement nécessaire pour contrôler les autres composants.
- Shield SIM800C : Ajoute des capacités de communication GSM/GPRS à votre Arduino, permettant l’envoi de SMS, de MMS et la gestion des appels.
- Shield Carte SD : Fournit un espace de stockage pour les données, essentiel pour des applications nécessitant la sauvegarde et la récupération d’informations.
Comment ça Marche ?
L’assemblage du Megazord Arduino est simple. Connectez le Shield SIM800C et le Shield Carte SD à votre Arduino UNO. Insérez une carte Nano SIM dans le Shield SIM800C pour les communications, et une carte Micro SD dans le Shield Carte SD pour le stockage. Une fois tout connecté, programmez votre Arduino via l’IDE Arduino pour gérer les communications et le stockage de données selon vos besoins spécifiques.
Avec ce montage, vous pouvez non seulement envoyer et recevoir des messages, mais aussi enregistrer et accéder à des données critiques, le tout en utilisant une seule plateforme compacte et puissante.
Les Programmes Arduino pour une Communication Avancée
Attention : pour l’envoi de MMS, le firmware du module doit être mis à jour afin d’être compatible avec la France. C’est pourquoi nos modules SIM800C sont mis à jour et sont compatibles MMS avec les réseaux de France et d’Europe.
APPELS
- Fonctionnalité : Permet d’initier et de recevoir des appels téléphoniques via le module SIM800C.
- Utilisation : Idéal pour des applications nécessitant une communication vocale, comme des projets de sécurité ou des systèmes d’alerte.
ENVOI DE SMS
- Fonctionnalité : Envoi de messages SMS à des numéros de téléphone spécifiques.
- Utilisation : Parfait pour des notifications automatiques, des alertes et des rappels. Programmez votre Arduino pour envoyer des SMS en réponse à des capteurs ou des événements.
Envoi de MMS : Configuration et Préparation
- Fonctionnalité : Permet l’envoi de messages multimédias (MMS) incluant des images, des vidéos et du texte.
- Utilisation : Après avoir mis à jour le firmware du module SIM800C pour la compatibilité avec les réseaux français et européens, vous pouvez envoyer des MMS pour des applications plus riches en contenu, telles que la surveillance par caméra ou l’envoi de rapports détaillés.
AUTOSTART : Contrôle du Module SIM800 via Arduino
- Fonctionnalité : Automatisation de l’allumage et de l’extinction du module SIM800C via des commandes Arduino.
- Utilisation : Simplifie la gestion de l’énergie et assure que le module est prêt à fonctionner dès que nécessaire sans intervention manuelle.
Ces programmes sont conçus pour maximiser les capacités de votre module SIM800C et faciliter la communication pour une variété de projets Arduino. En combinant ces fonctionnalités, vous pouvez créer des systèmes de communication robustes et polyvalents pour répondre à tous vos besoins technologiques.
Maîtrisez les Appels avec l'IDE Arduino
Utilisation des Commandes dans l’IDE Arduino
Une fois que vous avez copié le code ci-dessous, suivez ces étapes pour interagir avec le module GSM via l’IDE Arduino :
Ouverture du Moniteur Série
- Ouvrez l’IDE Arduino et accédez au Moniteur Série (Serial Monitor) via le menu “Outils”. Assurez-vous que la vitesse de transmission (baud rate) correspond à celle spécifiée dans le code.
Envoi de Commandes
- Après avoir ouvert le Moniteur Série, saisissez les commandes suivantes, suivies de la touche Entrée pour les exécuter :
- Commande 2 : Identifiez le modèle de votre module GSM.
- Commande 3 : Obtenez la version du firmware actuellement installée.
- Commande 5 : Effectuez un appel vers un numéro de téléphone spécifié.
- Commande 6 : Répondez à un appel entrant.
- Commande 7 : Mettez fin à un appel en cours.
- Après avoir ouvert le Moniteur Série, saisissez les commandes suivantes, suivies de la touche Entrée pour les exécuter :
Explications des Commandes
- Commande 2 : Identifiez le modèle de votre module GSM pour vous assurer qu’il est correctement reconnu par le système.
- Commande 3 : Obtenez la version du firmware actuellement installée afin de vérifier que vous disposez de la version la plus récente et compatible.
- Commande 5 : Permet d’initier un appel vers un numéro de téléphone spécifié, utile pour des applications de communication directe.
- Commande 6 : Répondez à un appel entrant, ce qui est essentiel pour les systèmes d’alerte ou de surveillance.
- Commande 7 : Mettez fin à un appel en cours pour gérer les communications de manière efficace et éviter les appels en attente inutiles.
/*
Projet: APPELS avec le Shield SIM800C
Auteur: Christian Joseph
Cartes utilisées: Arduino UNO + Shield SIM800C
Date: 21/07/2021
Website: https://www.eagle-robotics.com
*/
#include "SoftwareSerial.h"
SoftwareSerial SIM800 (7,8);
unsigned char data=0;
void setup()
{
Serial.begin(9600);
SIM800.begin(9600);
}
void loop()
{ //Entrer des valeurs depuis le moniteur série pour activer les fonctions du SIM800C:
//1,2,3,4,5,6,7,8,9
if(SIM800.available())
{
while(SIM800.available())
{
data=SIM800.read();
Serial.write(data);
}
data=0;
}
if(Serial.available())
{
data=Serial.read();
}
if(data=='p')
{
SIM800.print("AT+CPIN=2107\r"); //Faire le code Pin carte SIM si activé (remplacer 2107 par votre pin)
// Si code Pin désactivé, ignorer
}
if(data=='1')
{
SIM800.print("AT+CGMI\r"); // Identification du fabricant
}
if(data=='2')
{
SIM800.print("AT+CGMM\r"); //Identification du modèle
}
if(data=='3')
{
SIM800.print("AT+CGMR\r"); //Version du Firmware
}
if(data=='4')
{
SIM800.print("AT+CGSN\r"); //Numéro IMEI
}
if(data=='5')
{
SIM800.print("ATD+33644757223;\r"); //Appeler un numéro
}
if(data=='6')
{
SIM800.print("ATA\r"); //Décrocher un appel
}
if(data=='7')
{
SIM800.print("ATH\r"); //Raccrocher un appel
}
}
Envoi de SMS : Optimisez vos Messages pour une Communication Efficace
Lorsqu’il s’agit d’envoyer des SMS avec le module SIM800C, il est important de noter que le support des accents en mode Texte est limité. Ce module, tout comme ses homologues, n’est pas compatible avec les caractères accentués dans la notation traditionnelle.
Limitation des Caractères Accentué
Le module SIM800C fonctionne principalement avec la notation anglo-saxonne. Cela signifie qu’il est préférable d’éviter les caractères spéciaux ou accentués lors de la rédaction des SMS. Pour l’instant, le module ne prend en charge que les messages sans accents.
Mode PDU : Complexité et Alternative
Si l’utilisation d’accents est essentielle, une alternative serait de passer au mode PDU. Cependant, ce mode est considéré comme complexe et demande une compréhension plus approfondie du fonctionnement du module. Il est recommandé pour des utilisateurs expérimentés.
Conseil pour les Messages
En attendant une solution plus accessible, il est conseillé d’opter pour des messages sans caractères accentués. Par exemple, privilégiez des phrases comme “les chaussettes de l’Archiduchesse sont seches” pour garantir la bonne réception du message.
/*
* Projet: Envoi de SMS avec le Shield SIM800C
* Cartes utilisées: Arduino UNO + Shield SIM800C
* Auteur: Christian Joseph
* Date: 22/07/2021
* Website: www.eagle-robotics.com
*/
#include "SoftwareSerial.h" // Librarie pour la communication Série
SoftwareSerial SIM800(7, 8); // //Utilisation du port virtuel de la SIM800C
String message = ""; // Donnée pour enregistrer le message à envoyer
void setup()
{
SIM800.begin(9600); //Démarrage liaison série avec le module SIM800
Serial.begin(9600);//Démarrage liaison série arduino <-> PC
delay(30000); // Si votre module SIM800C n'est pas allumé, ce délai de 30 secondes vous laisse le temps d'appuyer sur le bouton ON du SIM800 et ce délai permet aussi au module SIM800C de se connecter au réseau mobile
// Si votre module est déjà allumé, alors vous pouvez ramener ce délai à 2 ou 3 secondes par exemple en remplaçant 30000 par 2000 ou 3000
}
void loop()
{
message = "Bonjour cher utilisateur,Je suis le MEGAZORD Arduino";
send_message(message);
delay(3000);
message = "Je suis fait de Arduino Uno + Shield SD + Shield SIM800C";
send_message(message);
while(1); // Boucle infinie de fin de programme
}
void send_message(String message) //Envoi du SMS
{
SIM800.println("AT"); //Réveil du module SIM800C
delay(1000);
updateSerial();
SIM800.println("AT+CMGF=1"); //Module GSM en mode Texte
updateSerial();
delay(1000);
SIM800.println("AT+CMGS=\"+33644757223\""); // Numéro du destinataire
updateSerial();
delay(1000);
SIM800.print(message); // Message à envoyer
delay(1000);
updateSerial();
SIM800.write((char)26); // Envoi du message
delay(1000);
}
void updateSerial() // Permet d'afficher l'echange de données entre L'arduino Uno et le Shield SD
{
delay(500);
while (Serial.available())
{
SIM800.write(Serial.read());
}
while(SIM800.available())
{
Serial.write(SIM800.read());
}
}
3-3 Envoi de MMS : Configuration et Préparation
Pour l’envoi de MMS, suivez ces étapes :
1. Préparation de l’Image
Enregistrez l’image que vous souhaitez envoyer dans la carte SD ou micro SD. Nous utiliserons les paramètres de l’opérateur SFR pour cette démonstration. L’image utilisée ici est nommée “Pic777.jpg”, mais vous pouvez choisir un nom différent pour vos propres images. Il est recommandé d’utiliser une carte de 4 Go ou 8 Go avec Arduino pour une compatibilité optimale. Les cartes de capacité supérieure pourraient ne pas être reconnues par le système Arduino.
2. Paramètres pour Différents Opérateurs
Opérateur SFR (Paramètres par défaut) :
- CMMSCURL : http://mms.sfr.fr
- CMMSPROTO : 10.151.0.1
- APN : mms
Autres Opérateurs :
ORANGE :
- CMMSCURL : http://mms.orange.fr
- CMMSPROTO : 192.168.10.200
- APN : orange.acte
BOUYGUES :
- CMMSCURL : mms.bouygtel.com
- CMMSPROTO : 62.201.129.226
- APN : mmsbouygtel
LA POSTE MOBILE :
- CMMSCURL : mmsdebitel
- CMMSPROTO : 10.143.156.003
- APN : mmsdebitel
3. Vérification de la Taille de l’Image
Avant de l’enregistrer dans votre carte SD, vérifiez la taille de votre image. Cliquez avec le bouton droit dessus, puis sélectionnez “Propriétés” pour connaître la taille ou le poids de l’image en octets.
Suivi des Échanges et Chargement de l’Image
Une fois le code transféré dans l’IDE Arduino, ouvrez le Moniteur Série pour observer les échanges entre les composants (Arduino, Shield carte SD et Shield SIM800C).
Cette fenêtre affichera les interactions en temps réel, offrant un aperçu direct des communications entre les éléments de votre projet.
/*
* Projet: Envoi de MMS à partir d'une carte SD
* Cartes utilisées: Arduino UNO + Shield SIM800C + Shield SD CARD
* Auteur: Christian Joseph
* Date: 22/07/2021
* Website: www.eagle-robotics.com
*/
#include "SPI.h"
#include "SD.h"
#include "SoftwareSerial.h"
#define CS 10
SoftwareSerial SIM800 (7,8); //Utilisation du port virtuel de la SIM800C
File dataFile;
int a;
unsigned char data=0;
void setup()
{
pinMode(CS,OUTPUT);
SIM800.begin(9600); //Démarrage liaison série avec le module SIM800
Serial.begin(9600);//Démarrage liaison série arduino <-> PC
while (!Serial) {
}
// Initialisation Shield CARTE SD
Serial.print("Initialisation Carte SD...");
if (!SD.begin(CS)) {
Serial.println("initialisation KO!");
return;
}
Serial.println("initialisation Faite.");
//Fin d'initialisation
delay(30000); // Si votre module SIM800C n'est pas allumé, ce délai de 30 secondes vous laisse le temps d'appuyer sur le bouton ON du SIM800 et ce délai permet aussi au module SIM800C de se connecter au réseau mobile
// Si votre module est déjà allumé, alors vous pouvez ramener ce délai à 2 ou 3 secondes par exemple en remplaçant 30000 par 2000 ou 3000
}
void loop()
{
sendMMS();// Sous-programme d'envoi de MMS
while(1); // Boucle infinie de fin de programme
}
void sendMMS()
{
SIM800.println("AT");
delay(1000);
updateSerial();
SIM800.println("AT+CMMSINIT"); // Activation du Mode MMS
delay(1000);
updateSerial();
SIM800.print("AT+CMMSCURL=\"mms1\"\r");
delay(1000);
updateSerial();
SIM800.print("AT+CMMSCID=1\r");
delay(1000);
updateSerial();
SIM800.print("AT+CMMSPROTO=\"10.151.0.1\",8080\r");
delay(1000);
updateSerial();
SIM800.print("AT+CMMSSENDCFG=6,3,0,0,2,4,1,0\r");
delay(1000);
updateSerial();
SIM800.print("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS"r");
delay(1000);
updateSerial();
SIM800.print("AT+SAPBR=3,1,\"APN\",\"sl2sfr\"\r");
delay(1000);
updateSerial();
SIM800.print("AT+SAPBR=1,1\r");
delay(4000);
updateSerial();
SIM800.print("AT+SAPBR=2,1\r");
delay(1000);
updateSerial();
SIM800.print("AT+CMMSEDIT=0\r"); // On vide la mémoire du SIM800C, autrement les MMS envoyés précédemment pourraient être envoyés avec le nouveau MMS.
delay(100);
updateSerial();
SIM800.print("AT+CMMSEDIT=1\r");
delay(1000);
updateSerial();
SIM800.print("AT+CMMSDOWN=\"PIC\",6589,50000,\"pic777.jpg\"\r"); //Ici on indique au module SIM800C qu'on va lui envoyer une image appelée "pic777.jpg" pesant 6589 octets à partir de la carte SD dans un délai maximal de 50 secondes. Augmentez le délai si nécessaire en fonction de la taille de votre image, car plus l'image est grande, plus il faut du temps pour la télécharger vers le module SIM800C. Si le temps est trop court, votre image ne sera pas entièrement chargée et vous aurez une erreur.
delay(1000);
updateSerial();
dataFile=SD.open("pic777.jpg"); // Ouverture de notre image Pic777.jpg image dans la carte SD
a=0;
if(dataFile)
{
while(dataFile.available())
{
data=dataFile.read();
if(data<0x10) Serial.print("0");
Serial.print(data,HEX);
a++;
if((a%40)==0) Serial.println();
SIM800.write(data); //Envoi de l'image Octet par Octet vers le SIM800C
}
dataFile.close();
}
else
{
Serial.println("erreur ouverture du fichier");
}
delay(1000);
SIM800.print("AT+CMMSRECP=\"+33644757223\"\r"); // Numéro de téléphone du destinataire
delay(1000);
updateSerial();
SIM800.print("AT+CMMSVIEW\r"); // Visualisation du MMS avant envoi
delay(1000);
updateSerial();
SIM800.print("AT+CMMSSEND\r"); // Envoi du MMS
delay(1000);
updateSerial();
SIM800.print("AT+CMMSEDIT=0\r"); // On efface la mémoire du SIM800C
delay(100);
updateSerial();
SIM800.print("AT+CMMSTERM\r"); // Sortie du mode MMS
delay(1000);
updateSerial();
}
void updateSerial()
{
delay(500);
while (Serial.available())
{
SIM800.write(Serial.read());
}
while(SIM800.available())
{
Serial.write(SIM800.read());
}
}
AutoStart : Contrôle du Module SIM800 via Arduino
Le module SIM800C offre la possibilité de contrôler son alimentation directement depuis le programme Arduino, éliminant ainsi le besoin d’intervention manuelle sur le bouton ON/OFF.
Utilisation de la Broche 9
Une broche spécifique de la carte Arduino UNO, la broche 9, est dédiée à cette fonctionnalité. En manipulant cette broche, vous pouvez gérer l’allumage et l’extinction du module SIM800C.
Procédure d’Activation/Extinction
Pour activer ou éteindre le module SIM800C à l’aide du programme Arduino, utilisez la séquence suivante :
void setup() {
pinMode(9, OUTPUT); // Configuration de la broche 9 en SORTIE
delay(1000);
}
void loop() {
digitalWrite(9, HIGH); // Passage de la broche 9 à l'état HAUT pour 4 secondes environ
delay(4000);
digitalWrite(9, LOW); // Revenir à l'état BAS pour éteindre le module
delay(15000); // Allumage ou extinction programmés toutes les 15 secondes
}
Cette procédure permet d’allumer ou d’éteindre le module SIM800C selon son état actuel. Si le module est éteint lors de l’application de cette séquence, il s’allumera. En revanche, s’il est déjà allumé, cette procédure permettra de l’éteindre.
Conclusion
En intégrant le Shield SIM800C à votre Arduino, vous ouvrez un monde de possibilités en matière de communication. Que ce soit pour passer des appels, envoyer des SMS, ou même des MMS, ce module offre une solution complète et flexible pour vos projets de communication. Avec la capacité de contrôler le module via l’IDE Arduino, vous pouvez automatiser et optimiser vos projets pour des performances maximales.
Ne laissez pas vos projets stagner avec des fonctionnalités limitées. Adoptez le Shield SIM800C et transformez votre Arduino en un centre de communication puissant et polyvalent. Commandez maintenant et découvrez comment vous pouvez révolutionner vos projets électroniques avec des capacités de communication avancées. L’avenir de la communication Arduino commence ici !