Sommaire
Présentation du module GSM SIMCOM A7670E
Le module SIMCOM A7670E est un module de communication 4G LTE qui intègre également une fonctionnalité GPS, ce qui en fait un choix polyvalent pour les projets connectés et de géolocalisation. Dans ce tutoriel, nous allons apprendre à l’utiliser avec une carte Arduino afin de mettre en œuvre des fonctions essentielles comme l’envoi et la réception de SMS, ainsi que l’acquisition de données GPS pour suivre la position d’un dispositif.
- Puce A7670E
- Antenne GPS
- Antenne GSM
- Indicateur LED GPS
- Connecteur Micro USB
- Connecteur pour antenne GPS
- Connecteur pour carte Micro SIM
- Indicateur LED GSM
- Connecteur pour antenne GSM
Description des broches :
- S : Sleep (Mode Sommeil)
- G : Ground (Masse)
- V : VCC (+5V à +10V)
- K : PowerKey (Extinction du module)
- T : TX (Emission de données)
- R : RX (Réception de données)
- G : Ground (Masse)
Montage
Dans cette section, nous listons le matériel nécessaire et présentons le câblage entre une Arduino Mega 2560 et la carte SIMCOM A7670E.
Matériel nécessaire
- 1 Carte Arduino Mega 2560
- 1 carte SIMCOM A7670E
- 1 câble USB Type-C
- Câbles de connexion M-M 10 cm
- 1 Breadboard 400 points
- 1 Bloc d’alimentation 5V/2A
- 1 Connecteur Jack femelle 2.1 x 5.5 MM
- 1 Carte SIM au format Nano SIM
Tableau récapitulatif
Le tableau ci-dessous indique la correspondance entre les broches numériques de l’Arduino Mega et le module SIMCOM A7670E
| Arduino MEGA | Module A7670E | Alimentation 5V/2A |
|---|---|---|
| D18 (TX1) | R | |
| D19 (RX1) | T | |
| V | + | |
| GND | G | – |
Mise en route du module A7670E
Branchez les antennes GSM et GPS sur les connecteurs dédiés. Dans ce tutoriel, une carte Nano SIM du réseau ORANGE est utilisée. Le code PIN est désactivé.
À la mise sous tension, l’indicateur LED GSM s’allume d’abord de manière fixe. Après environ 3 secondes, il se met à clignoter à un rythme d’environ une fois par seconde : cela correspond à la phase d’initialisation et de recherche du réseau.
Il faut ensuite patienter une dizaine de secondes pour que le module A7670E puisse se connecter au réseau GSM, à condition que la couverture réseau soit suffisante.
Il est important de noter qu’il n’y a pas de différence réellement perceptible dans la fréquence de clignotement de la LED entre la phase de recherche de réseau et celle où le module A7670E est effectivement connecté. La LED continue de clignoter de manière similaire tout au long de l’exploitation du module 4G LTE A7670E, ce qui peut prêter à confusion.
C’est pourquoi nous recommandons de prévoir un délai d’au moins une vingtaine de secondes afin de garantir que le module A7670E ait bien le temps de s’enregistrer correctement sur le réseau GSM.
Dans nos programmes Arduino, un délai de 20 secondes a été volontairement ajouté pour couvrir ce temps de connexion. Il est également possible d’alimenter le module A7670E en premier et d’attendre qu’il se connecte avant de mettre sous tension la carte Arduino. Dans ce cas, ce délai peut être réduit, voire supprimé, dans le code Arduino.
Programmation Arduino du module A7670E (Arduino Mega 2560)
Nous allons configurer et programmer le module SIMCOM A7670E boutons avec une Arduino Mega 2560 pour réaliser plusieurs applications interactives :
- Envoi de SMS : Le module A7670E envoi un SMS à un numéro de téléphone mobile.
- Réception de SMS : le module A7670E reçoit un SMS d’un téléphone mobile et l’affiche dans le moniteur série de l’IDE Arduino.
- Commande par SMS simple : L’utilisateur pilote une LED par SMS via le module A7670E.
- Commande par SMS avec filtrage de numéro : Seuls les utilisateurs autorisés peuvent piloter un relais via le A7670E
- GPS 1 :Acquisition des coordonnées GPS heure UTC 0 et affichage dans le moniteur série (Longitude, Latitude, Date, Heure UTC 0, vitesse, direction cardinale, altitude, nombre de satellites, etc…)
- GPS 2 : Acquisition des coordonnées GPS heure de Paris et affichage dans le moniteur série (Longitude, Latitude, Date, Heure de Paris, Distance Lieu ↔ Paris)
- GPS 3 : Acquisition des données GPS et envoi des coordonnées + lien Google Maps par SMS
Librairies
TinyGPSPlus.h (nécéssaire uniquement pour le GPS)
Envoi de SMS
Ce code Arduino permet à la carte Arduino MEGA d’envoyer un SMS via le A7670E :
void setup() {
// Initialisation des ports série
Serial.begin(115200); // Pour le moniteur série
Serial1.begin(115200); // Pour le module A7670E
delay(20000); // Laisser le module démarrer
Serial.println("Initialisation...");
sendAT("AT"); // Test
sendAT("ATE0"); // Désactiver l'écho
sendAT("AT+CMGF=1"); // Mode SMS texte
sendAT("AT+CSCS=\"GSM\""); // Jeu de caractères
// Numéro à modifier
Serial1.print("AT+CMGS=\"+33644757223\"\r");
delay(1000);
Serial1.print("Bonjour depuis le A7670E et Arduino MEGA !");
delay(500);
Serial1.write(26); // CTRL+Z pour envoyer
}
void loop() {
// Lecture des réponses du module
while (Serial1.available()) {
Serial.write(Serial1.read());
}
}
// Fonction pour envoyer une commande AT
void sendAT(String cmd) {
Serial1.println(cmd);
delay(1000);
while (Serial1.available()) {
Serial.write(Serial1.read());
}
}
Le résultat attendu
Réception de SMS
Ce code Arduino permet de recevoir et d’afficher le contenu d’un SMS dans le moniteur série Arduino :
void setup() {
Serial.begin(115200); // Moniteur série
Serial1.begin(115200); // Module A7670E
delay(20000);
Serial.println("Initialisation module...");
sendAT("AT"); // Test
sendAT("ATE0"); // Désactiver echo
sendAT("AT+CMGF=1"); // Mode texte SMS
sendAT("AT+CNMI=2,2,0,0,0"); // Réception directe des SMS
Serial.println("Pret a recevoir des SMS...");
}
void loop() {
// Lire les données du module
while (Serial1.available()) {
char c = Serial1.read();
Serial.write(c); // Affiche dans le moniteur série
}
}
// Fonction pour envoyer une commande AT
void sendAT(String cmd) {
Serial1.println(cmd);
delay(1000);
while (Serial1.available()) {
Serial.write(Serial1.read());
}
}
Le résultat attendu
Commande par SMS simple
Le code Arduino suivant permet de piloter la LED intégrée de la carte Arduino MEGA grâce à 2 commandes envoyées par SMS au module A7670E :
- ON : Allume la LED
- OFF : Eteint la LED
La LED est reliée à la broche 13 de la carte Arduino MEGA. libre à vous de modifier le port de commande pour y connecter un module externe (LED 5mm, relais, servomoteur, etc…)
String sms = "";
bool readingMessage = false;
void setup() {
Serial.begin(115200);
Serial1.begin(115200);
pinMode(13, OUTPUT);
delay(20000);
Serial.println("Initialisation...");
sendAT("AT");
sendAT("ATE0");
sendAT("AT+CMGF=1"); // Mode texte
sendAT("AT+CNMI=2,2,0,0,0"); // SMS direct
Serial.println("Pret !");
}
void loop() {
while (Serial1.available()) {
char c = Serial1.read();
Serial.write(c); // debug
// Détection début message
if (c == '\n') {
readingMessage = true;
sms = "";
return;
}
// Lecture du message
if (readingMessage) {
if (c == '\r') {
readingMessage = false;
traiterSMS(sms);
} else {
sms += c;
}
}
}
}
// Fonction pour traiter le SMS
void traiterSMS(String message) {
message.trim();
message.toUpperCase();
Serial.println("\nMessage recu: " + message);
if (message == "ON") {
digitalWrite(13, HIGH);
Serial.println("LED ON");
}
else if (message == "OFF") {
digitalWrite(13, LOW);
Serial.println("LED OFF");
}
}
// Fonction AT
void sendAT(String cmd) {
Serial1.println(cmd);
delay(1000);
while (Serial1.available()) {
Serial.write(Serial1.read());
}
}
Le résultat attendu
Commande par SMS avec filtrage de numéro
Le code Arduino ci-dessous permet de piloter un relais connecté à la broche D7 de la carte Arduino MEGA via les commandes suivantes :
- ON : Activation du relais
- OFF : Désactivation du relais
- STATUS : Etat du relais (ON ou OFF)
→ Pour savoir comment interfacer un relais avec une carte Arduino : https://www.atelierdelarobotique.fr/relais-arduino-esp32
Le code permet de filtrer les numéros de sorte que seuls les numéros autorisés puissent commander le relais :
String authorizedNumber = "644757223"; // sans +33 pour robustesse
void setup() {
Serial.begin(115200);
Serial1.begin(115200);
pinMode(7, OUTPUT);
digitalWrite(7, LOW);
delay(5000);
Serial.println("Init...");
Serial1.println("AT");
delay(1000);
Serial1.println("ATE0");
delay(1000);
Serial1.println("AT+CMGF=1");
delay(1000);
Serial1.println("AT+CPMS=\"SM\",\"SM\",\"SM\"");
delay(1000);
Serial.println("Pret !");
}
void loop() {
Serial.println("Check SMS...");
Serial1.println("AT+CMGL=\"REC UNREAD\"");
delay(3000);
String data = "";
while (Serial1.available()) {
char c = Serial1.read();
data += c;
}
Serial.println(data);
// FILTRAGE NUMERO
if (data.indexOf(authorizedNumber) != -1) {
Serial.println("Numero autorise");
// COMMANDE ON
if (data.indexOf("ON") != -1) {
digitalWrite(7, HIGH);
Serial.println("RELAIS ON");
sendSMS("+33644757223", "Relais ACTIVE");
}
// COMMANDE OFF
else if (data.indexOf("OFF") != -1) {
digitalWrite(7, LOW);
Serial.println("RELAIS OFF");
sendSMS("+33644757223", "Relais DESACTIVE");
}
// STATUS
else if (data.indexOf("STATUS") != -1) {
String etat = digitalRead(7) ? "ON" : "OFF";
sendSMS("+33644757223", "Etat: " + etat);
}
} else {
Serial.println("Numero NON autorise");
}
// SUPPRIMER TOUS LES SMS (simple et efficace)
Serial1.println("AT+CMGD=1,4");
delay(2000);
delay(5000);
}
// ENVOI SMS
void sendSMS(String number, String text) {
Serial.println("Envoi SMS...");
Serial1.print("AT+CMGS=\"");
Serial1.print(number);
Serial1.println("\"");
delay(1000);
Serial1.print(text);
delay(500);
Serial1.write(26);
delay(5000);
}
Le résultat attendu
Utilisation du GPS A7670E
Lors de l’utilisation du module A7670E en mode GPS, l’indicateur LED GPS doit s’allumer en bleu :
L’acquisition des données GPS dépend fortement de l’environnement dans lequel se trouve le module A7670E. Il est important d’être dans un environnement dégagé ou dans un bâtiment permettant une bonne réception du signal, sinon de privilégier une utilisation en extérieur afin d’obtenir une meilleure précision et une acquisition plus fiable.
Lors de l’initialisation du GPS, la récupération des coordonnées peut prendre un certain temps avant d’être pleinement opérationnelle, généralement entre 20 secondes et 2 minutes.
Utilisation simple du GPS 1
Le programme Arduino ci-dessous permet de récupérer les coordonnées GPS via le module A7670E et de les afficher dans le moniteur série. Il fournit plusieurs informations essentielles, telles que :
- Le Nombre de satellites
- La Longitude
- La Latitude
- La Date du jour
- L’Heure (UTC+0)
- La Vitesse
- L’Altitude
- La Direction cardinale (N, O, S, E, NW, NE, SW, SE) par rapport à Londres .
#include
static const uint32_t GPSBaud = 115200;
TinyGPSPlus gps;
void setup()
{
Serial.begin(115200);
Serial1.begin(GPSBaud);
Serial1.println("AT+CGNSSPWR=1");
delay(1000);
Serial1.println("AT+CGNSSTST=1");
delay(1000);
Serial1.println("AT+CGNSSPORTSWITCH=0,1");
delay(1000);
Serial.println(F("Sats HDOP Latitude Longitude Fix Date Time Date Alt Course Speed Card Distance Course Card Chars Sentences Checksum"));
Serial.println(F(" (deg) (deg) Age Age (m) --- from GPS ---- ---- to London ---- RX RX Fail"));
Serial.println(F("----------------------------------------------------------------------------------------------------------------------------------------"));
}
void loop()
{
static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
printInt(gps.satellites.value(), gps.satellites.isValid(), 5);
printFloat(gps.hdop.hdop(), gps.hdop.isValid(), 6, 1);
printFloat(gps.location.lat(), gps.location.isValid(), 11, 6);
printFloat(gps.location.lng(), gps.location.isValid(), 12, 6);
printInt(gps.location.age(), gps.location.isValid(), 5);
printDateTime(gps.date, gps.time);
printFloat(gps.altitude.meters(), gps.altitude.isValid(), 7, 2);
printFloat(gps.course.deg(), gps.course.isValid(), 7, 2);
printFloat(gps.speed.kmph(), gps.speed.isValid(), 6, 2);
printStr(gps.course.isValid() ? TinyGPSPlus::cardinal(gps.course.deg()) : "*** ", 6);
unsigned long distanceKmToLondon =
(unsigned long)TinyGPSPlus::distanceBetween(
gps.location.lat(),
gps.location.lng(),
LONDON_LAT,
LONDON_LON) / 1000;
printInt(distanceKmToLondon, gps.location.isValid(), 9);
double courseToLondon =
TinyGPSPlus::courseTo(
gps.location.lat(),
gps.location.lng(),
LONDON_LAT,
LONDON_LON);
printFloat(courseToLondon, gps.location.isValid(), 7, 2);
const char *cardinalToLondon = TinyGPSPlus::cardinal(courseToLondon);
printStr(gps.location.isValid() ? cardinalToLondon : "*** ", 6);
printInt(gps.charsProcessed(), true, 6);
printInt(gps.sentencesWithFix(), true, 10);
printInt(gps.failedChecksum(), true, 9);
Serial.println();
smartDelay(1000);
if (millis() > 5000 && gps.charsProcessed() < 10)
Serial.println(F("Pas de GPS"));
}
static void smartDelay(unsigned long ms)
{
unsigned long start = millis();
do
{
while (Serial1.available())
gps.encode(Serial1.read());
} while (millis() - start < ms);
}
static void printFloat(float val, bool valid, int len, int prec)
{
if (!valid)
{
while (len-- > 1)
Serial.print('*');
Serial.print(' ');
}
else
{
Serial.print(val, prec);
int vi = abs((int)val);
int flen = prec + (val < 0.0 ? 2 : 1); // . and -
flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
for (int i=flen; i 0)
sz[len-1] = ' ';
Serial.print(sz);
smartDelay(0);
}
static void printDateTime(TinyGPSDate &d, TinyGPSTime &t)
{
if (!d.isValid())
{
Serial.print(F("********** "));
}
else
{
char sz[32];
sprintf(sz, "%02d/%02d/%02d ", d.month(), d.day(), d.year());
Serial.print(sz);
}
if (!t.isValid())
{
Serial.print(F("******** "));
}
else
{
char sz[32];
sprintf(sz, "%02d:%02d:%02d ", t.hour(), t.minute(), t.second());
Serial.print(sz);
}
printInt(d.age(), d.isValid(), 5);
smartDelay(0);
}
static void printStr(const char *str, int len)
{
int slen = strlen(str);
for (int i=0; i
Le résultat attendu
Utilisation simple du GPS 2
Ce code permet aussi d’acquérir les coordonnées GPS via le module A7670E et d’afficher dans le moniteur série Arduino :
- La Longitude
- La Latitude
- La Date
- L’Heure (Heure de Paris)
- La Distance Lieu ↔ Paris
#include
static const uint32_t GPSBaud = 115200;
TinyGPSPlus gps;
void setup()
{
Serial.begin(115200);
Serial1.begin(GPSBaud);
Serial1.println("AT+CGNSSPWR=1");
delay(1000);
Serial1.println("AT+CGNSSTST=1");
delay(1000);
Serial1.println("AT+CGNSSPORTSWITCH=0,1");
delay(1000);
Serial.println(F("Lat Lon Date Heure(Paris)"));
Serial.println(F("------------------------------------------"));
}
void loop()
{
static const double PARIS_LAT = 48.8566;
static const double PARIS_LON = 2.3522;
// Lecture GPS
unsigned long start = millis();
while (millis() - start < 1000)
{
while (Serial1.available())
gps.encode(Serial1.read());
}
if (gps.location.isValid())
{
Serial.print("Lat: ");
Serial.print(gps.location.lat(), 6);
Serial.print(" Lon: ");
Serial.print(gps.location.lng(), 6);
Serial.print(" Date: ");
Serial.print(gps.date.day());
Serial.print("/");
Serial.print(gps.date.month());
Serial.print("/");
Serial.print(gps.date.year());
// Conversion heure Paris (UTC+1)
int hour = gps.time.hour() + 1; // +2 en heure d'été
if (hour >= 24) hour -= 24;
Serial.print(" Heure: ");
if (hour < 10) Serial.print("0");
Serial.print(hour);
Serial.print(":");
if (gps.time.minute() < 10) Serial.print("0");
Serial.print(gps.time.minute());
Serial.print(":");
if (gps.time.second() < 10) Serial.print("0");
Serial.print(gps.time.second());
Serial.println();
// Distance vers Paris
double distanceKm =
TinyGPSPlus::distanceBetween(
gps.location.lat(),
gps.location.lng(),
PARIS_LAT,
PARIS_LON) / 1000;
Serial.print("Distance vers Paris (km): ");
Serial.println(distanceKm);
Serial.println("------------------------------");
}
else
{
Serial.println("Pas de FIX GPS");
}
}
Le résultat attendu
Coordonnées GPS + lien Google MAPS par SMS
Le code Arduino ci-dessous permet d’acquérir les coordonnées GPS du module A7670E et de les envoyer par SMS à un utilisateur avec le lien Google Maps en prime :
#include
TinyGPSPlus gps;
String numero = "+33644757223";
void setup() {
Serial.begin(115200);
Serial1.begin(115200);
delay(5000);
Serial.println("Init GPS + GSM...");
Serial1.println("AT+CMGF=1"); // SMS texte
delay(1000);
Serial1.println("AT+CGNSSPWR=1");
delay(1000);
Serial1.println("AT+CGNSSTST=1");
delay(1000);
}
void loop() {
// Lire GPS pendant 1s
unsigned long start = millis();
while (millis() - start < 1000) {
while (Serial1.available()) {
gps.encode(Serial1.read());
}
}
if (gps.location.isValid() && gps.time.isValid()) {
// Calcul heure Paris (DST inclus)
int offset = getParisOffset(gps.date.day(), gps.date.month(), gps.date.year());
int hour = gps.time.hour() + offset;
if (hour >= 24) hour -= 24;
if (hour < 0) hour += 24;
// Message SMS
String msg = "GPS:\n";
msg += "Lat: " + String(gps.location.lat(), 6) + "\n";
msg += "Lon: " + String(gps.location.lng(), 6) + "\n";
msg += "Heure Paris: ";
if (hour < 10) msg += "0";
msg += String(hour) + ":";
if (gps.time.minute() < 10) msg += "0";
msg += String(gps.time.minute()) + ":";
if (gps.time.second() < 10) msg += "0";
msg += String(gps.time.second()) + "\n";
msg += "https://maps.google.com/?q=";
msg += String(gps.location.lat(), 6);
msg += ",";
msg += String(gps.location.lng(), 6);
Serial.println(msg);
sendSMS(numero, msg);
delay(60000); // envoi toutes les 60s
}
}
// Envoi SMS
void sendSMS(String number, String text) {
Serial1.print("AT+CMGS=\"");
Serial1.print(number);
Serial1.println("\"");
delay(1000);
Serial1.print(text);
delay(500);
Serial1.write(26); // CTRL+Z
delay(5000);
Serial.println("SMS envoye !");
}
// Calcul heure été/hiver (France)
int getParisOffset(int day, int month, int year) {
// UTC+1 par défaut
int offset = 1;
// calcul dernier dimanche mars et octobre
int lastMarchSunday = 31 - ((5 * year / 4 + 4) % 7);
int lastOctoberSunday = 31 - ((5 * year / 4 + 1) % 7);
// période heure été
if (
(month > 3 && month < 10) ||
(month == 3 && day >= lastMarchSunday) ||
(month == 10 && day < lastOctoberSunday)
) {
offset = 2;
}
return offset;
}
Le résultat attendu
Mise en mode Sommeil et Réveil
Le module A7670E peut être placé en mode veille afin de réduire sa consommation d’énergie lorsqu’il n’est pas utilisé, puis réactivé pour communiquer avec la carte Arduino. Cette fonctionnalité est particulièrement intéressante dans des applications d’automatisation, par exemple un système qui collecte des données météo et envoie un rapport quotidien par SMS à un utilisateur, ou encore un dispositif de suivi de niveau (eau, carburant, silo, etc.) qui transmet une seule mesure par jour.
Pour cela, nous allons relier la broche S du module A7670E à la broche D6 de la carte Arduino MEGA, comme indiqué sur le schéma ci-dessous :
Tableau récapitulatif
Le tableau ci-dessous indique la correspondance entre les broches numériques de l’Arduino Mega et le module SIMCOM A7670E
| Arduino MEGA | Module A7670E | Alimentation 5V/2A |
|---|---|---|
| D18 (TX1) | R | |
| D19 (RX1) | T | |
| V | + | |
| GND | G | – |
| D6 | S |
Le code Arduino suivant permet de réveiller le module, d’envoyer un SMS, puis de le mettre en sommeil pendant 1 minute environ :
#define DTR_PIN 6
unsigned long lastSend = 0;
const unsigned long interval = 60000;
void setup() {
Serial.begin(115200);
Serial1.begin(115200);
pinMode(DTR_PIN, OUTPUT);
digitalWrite(DTR_PIN, HIGH); // réveillé
delay(5000);
Serial1.println("AT");
delay(1000);
Serial1.println("AT+CMGF=1");
delay(1000);
Serial.println("Pret");
}
void loop() {
if (millis() - lastSend > interval) {
// REVEIL (IMPORTANT)
digitalWrite(DTR_PIN, HIGH);
delay(1000);
Serial.println("Reveil OK");
// SMS
sendSMS("+33644757223", "Test reveil OK");
delay(3000);
// SLEEP
Serial.println("Sommeil...");
Serial1.println("AT+CSCLK=1");
delay(500);
digitalWrite(DTR_PIN, LOW); // active sommeil
lastSend = millis();
}
}
// SMS
void sendSMS(String number, String text) {
Serial1.print("AT+CMGS=\"");
Serial1.print(number);
Serial1.println("\"");
delay(1000);
Serial1.print(text);
delay(500);
Serial1.write(26);
delay(5000);
}
Le résultat attendu
Conclusion
Ce tutoriel vous a permis de découvrir les bases d’utilisation du module A7670E avec une carte Arduino, en mettant en œuvre des fonctionnalités concrètes et directement exploitables. Vous avez appris à envoyer et recevoir des SMS, à piloter des éléments matériels comme une LED puis un relais à distance via SMS, mais aussi à exploiter le GPS intégré pour acquérir des coordonnées, les afficher et même les transmettre sous forme de lien Google Maps.
Ces différentes briques constituent une base solide pour de nombreux projets connectés. À partir de ce que vous venez de mettre en place, il est tout à fait possible d’aller plus loin en développant des systèmes de suivi de véhicules, des solutions de domotique contrôlées à distance, des dispositifs d’alerte (intrusion, coupure de courant, capteurs environnementaux), ou encore des applications industrielles de télémétrie. Le module A7670E, associé à Arduino, ouvre ainsi la voie à une large gamme de projets IoT autonomes, capables de communiquer et d’interagir avec leur environnement, même sans connexion Wi-Fi.
Il ne vous reste plus qu’à continuer d’explorer, tester et inventer vos propres applications… Les possibilités sont quasiment infinies !




