SIM800L et Arduino : envoyer des SMS, piloter un relais, appeler

Le module GSM SIM800L est un modem 2G minuscule et très bon marché, de la taille d'un timbre-poste, qui donne à ton projet Arduino sa propre ligne téléphonique. Avec une carte micro SIM, tu peux envoyer et recevoir des SMS, passer des appels et envoyer de petites quantités de données sur Internet en GPRS. Là où le Wi-Fi et le Bluetooth n'arrivent pas, comme une maison de campagne, une serre, un local de stockage ou un véhicule, associer un SIM800L à un Arduino est le moyen le plus simple de commander un appareil à distance depuis n'importe quel endroit couvert par le réseau mobile. Le module dialogue avec l'Arduino par une liaison série à deux fils (UART) et se pilote avec de courtes commandes texte appelées commandes AT.

Attention toutefois : le SIM800L fait partie des modules qui posent le plus de problèmes aux débutants, et presque tous viennent de deux sources : une alimentation insuffisante et la couverture 2G. C'est d'autant plus important en France, où les opérateurs éteignent la 2G d'ici fin 2026. Dans ce guide, tu apprendras à alimenter correctement le module selon sa plage de 3,4–4,4 V et ses pics de 2 A, ce que signifie la fréquence de clignotement de la LED de la carte, comment le tester pas à pas avec des commandes AT, comment envoyer un SMS avec un Arduino Uno, allumer et éteindre un relais par SMS et réaliser un circuit qui t'appelle en cas d'alarme. Tu feras ensuite la même chose avec l'ESP32, la carte TTGO T-Call et le Raspberry Pi Pico, et tu trouveras à la fin un tableau de solutions aux problèmes d'enregistrement sur le réseau.

Qu'est-ce que le SIM800L et comment fonctionne-t-il ?

Le SIM800L est un module GSM/GPRS fabriqué par SIMCom qui ne mesure que 17,8 × 15,8 mm. La carte rouge que tu achètes est un petit breakout qui ajoute autour du module un support SIM, une connexion d'antenne, une LED d'état et des barrettes de broches. Le module balaye automatiquement les quatre bandes GSM (850, 900, 1800 et 1900 MHz), s'enregistre sur le réseau comme un téléphone portable, puis exécute les commandes reçues sur le port série : « envoie ce message à ce numéro », « appelle ce numéro », « transmets-moi les messages reçus », etc. Vois-le comme un téléphone sans écran ni clavier ; l'Arduino fait le travail des deux. En branchant un micro et un haut-parleur sur les broches MIC et SPK, tu peux même tenir une vraie conversation.

Brochage du SIM800L

L'antenne en spirale fournie se soude sur le trou NET dans le coin de la carte ; certaines cartes ont aussi un petit connecteur u.FL (IPEX) pour une antenne externe. Sans antenne, le module ne trouve pas le réseau et le niveau de signal reste proche de zéro ; si la réception est faible à l'intérieur, une antenne GSM adhésive avec câble fait une vraie différence par rapport à la spirale. La micro SIM se glisse dans le support au dos, le coin coupé orienté comme sur le dessin du support. Avant de l'insérer, désactive la demande de code PIN dans un téléphone et vérifie que la ligne peut envoyer des SMS, appeler et dispose d'un crédit suffisant.

Alimentation : 3,4–4,4 V et pics de 2 A

L'alimentation est le point le plus critique du SIM800L et celui où l'on se trompe le plus souvent. Le GSM fonctionne par partage du temps : dans chaque trame de 4,615 ms, le module n'émet que pendant son propre intervalle de 577 µs. Pendant ces courts instants, il consomme jusqu'à 2 A, puis redescend aussitôt à quelques dizaines de milliampères. Si la source ne peut pas fournir ce courant soudain, la tension s'effondre. D'après la fiche technique de SIMCom, quand la tension descend à 3,5 V, le module écrit UNDER-VOLTAGE WARNNING sur le port série, et sous 3,4 V il écrit UNDER-VOLTAGE POWER DOWN et s'éteint (la faute dans WARNNING vient du firmware du fabricant). Côté haut, l'avertissement OVER-VOLTAGE WARNNING apparaît à 4,3 V et au-delà de 4,4 V le module s'éteint aussi. Sur certaines versions du firmware, cette coupure automatique est désactivée par défaut et s'active avec AT+CBATCHK=1 ; même dans ce cas, hors de ces limites, le module devient instable et redémarre sans cesse. C'est pourquoi la broche 5V de l'Arduino est trop élevée pour le SIM800L. La broche 3.3V est sous le minimum et n'est officiellement prévue que pour 50 mA ; de plus, le port USB d'un ordinateur ne fournit pas plus de 500 mA.

Que t'indique la LED ? La signification des clignotements

Prends l'habitude d'utiliser la LED comme outil de diagnostic : voir le module passer à un clignotement toutes les 3 secondes avant même d'écrire du code élimine d'emblée la moitié des problèmes. Si le module continue de clignoter une fois par seconde pendant des minutes, inutile de toucher au logiciel ; consulte d'abord la section sur l'enregistrement réseau plus bas. Les plus gros pics de courant arrivent au moment de l'enregistrement, quand le module parle pour la première fois à l'antenne relais ; si l'alimentation est faible, il s'éteint précisément à ce moment et le cycle recommence.

Branchement du SIM800L à l'Arduino et adaptation des niveaux

Le SIM800L communique avec l'Arduino en UART et les lignes de données se croisent : la broche TXD du module va sur la broche RX de la carte, et la broche RXD du module sur la broche TX de la carte. L'unique port série matériel de l'Arduino Uno (D0 et D1) sert au téléversement par USB et au moniteur série, nous branchons donc le module sur D2 et D3 avec SoftwareSerial, qui fonctionne de façon fiable à 9600 bauds. Sur l'ESP32 et le Pico, pas besoin de port série logiciel : on utilise leurs UART matériels. Tu trouveras les bases de la communication série dans notre guide sur la communication série UART.

Premier test avec les commandes AT

1. Branche le module comme dans le tableau, fixe l'antenne et insère une micro SIM sans code PIN.
2. Mets sous tension et observe la LED : après quelques secondes à un clignotement par seconde, elle doit passer à un clignotement toutes les 3 secondes.
3. Téléverse le sketch passerelle ci-dessous dans l'Arduino ; SoftwareSerial est fourni avec l'IDE Arduino, aucune bibliothèque supplémentaire n'est nécessaire.
4. Ouvre le moniteur série, choisis 9600 bauds et la fin de ligne Both NL & CR (« Les deux, NL et CR »).
5. Tape AT et appuie sur Entrée. Le module s'adapte à ton débit grâce à la détection automatique ; les premiers essais peuvent rester sans réponse, recommence jusqu'à voir OK.
6. Vérifie ensuite une à une la carte SIM, la force du signal et l'enregistrement réseau avec les commandes du tableau ci-dessous.

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);        // RX = D2 (SIM800L TXD), TX = D3 (SIM800L RXD, bölücüyle / via divider)
4
5void setup() {
6  Serial.begin(9600);               // Seri Monitör hızı / Serial Monitor speed
7  sim800.begin(9600);               // SIM800L bu hıza kendini ayarlar / SIM800L autobauds to this rate
8  Serial.println(F("AT yaz ve Enter'a bas / Type AT and press Enter"));
9}
10
11void loop() {
12  if (Serial.available()) sim800.write(Serial.read());   // bilgisayar → modül / PC → module
13  if (sim800.available()) Serial.write(sim800.read());   // modül → bilgisayar / module → PC
14}

Le premier nombre de la réponse à AT+CSQ se convertit en dBm : dBm ≈ −113 + 2 × valeur. Par exemple, 18 correspond à environ −77 dBm, ce qui est plutôt bon ; sous 10 c'est faible, et sous 5 même un SMS a du mal à partir. Une réponse 99 signifie que le module n'a pas encore pu mesurer. La commande AT+CBC est parfaite pour repérer les problèmes d'alimentation : si tu lis environ 4,0 V au repos mais que le module s'éteint pendant l'envoi d'un SMS ou un appel, le problème vient à coup sûr de la capacité en courant de ta source. En mode de détection automatique, réglage par défaut, le module n'affiche rien au démarrage ; si tu fixes le débit avec AT+IPR=9600 puis l'enregistres avec AT&W, le réglage est conservé en mémoire permanente et le module annonce qu'il est prêt avec RDY, +CFUN: 1 et +CPIN: READY à chaque mise sous tension.

Pas d'enregistrement sur le réseau ? Couverture 2G, SIM et IMEI

Le SIM800L n'utilise que le réseau 2G (GSM/GPRS) ; il ne connaît ni la 3G, ni la 4G, ni la 5G. En France, c'est un point décisif : Orange a totalement arrêté sa 2G en métropole le 20 octobre 2026 (hors zones blanches, coupées début décembre), et SFR comme Bouygues Telecom l'éteignent entre mi-novembre et le 15 décembre 2026 ; Free Mobile n'a jamais eu de réseau 2G propre. Concrètement, dès la fin 2026, le SIM800L ne pourra plus s'enregistrer en métropole. En Suisse, la 2G est coupée depuis début 2023 ; en Belgique et au Canada, renseigne-toi auprès de ton opérateur. Là où il n'y a plus de 2G, le SIM800L ne peut pas s'enregistrer, aussi bien alimenté soit-il ; il faut alors passer à un module 4G LTE comme le SIM7600 ou l'A7670, ou à un module LTE-M/NB-IoT comme le SIM7080G. Si tu peux encore l'utiliser, suis cet ordre pour diagnostiquer l'enregistrement :

• Y a-t-il de la 2G chez toi ? Dans les réglages réseau de ton téléphone, choisis « 2G uniquement » comme type de réseau préféré et essaie d'appeler avec la même carte SIM. Si le téléphone ne trouve pas de réseau en 2G, le SIM800L n'en trouvera pas non plus.
• La carte SIM est-elle lue ? AT+CCID doit renvoyer un numéro et AT+CPIN? doit répondre +CPIN: READY. En cas d'erreur, réinsère la carte dans le bon sens ; si tu utilises une nano SIM avec un adaptateur, vérifie que l'adaptateur n'appuie pas de travers sur les contacts.
• Le signal est-il suffisant ? AT+CSQ doit donner au moins 10. Soude l'antenne ou branche une antenne externe, et rapproche le module d'une fenêtre.
• L'enregistrement est-il refusé ? Si AT+CREG? répond 0,3, le réseau refuse le module : la ligne est peut-être résiliée ou l'IMEI de l'appareil bloqué.
• Enregistrement de l'IMEI : certains pays bloquent les appareils dont l'IMEI n'est pas enregistré ; en Turquie, par exemple, les appareils importés sans déclaration sont coupés après un délai de grâce. Lis l'IMEI du module avec AT+GSN et, dans ces pays, achète auprès d'un vendeur local qui propose des modules à IMEI enregistré.
• L'alimentation suffit-elle ? Si le module redémarre au moment de l'enregistrement, le problème ne vient pas du réseau mais de l'alimentation ; reviens à la section sur l'alimentation.

Envoyer un SMS avec Arduino

Pour envoyer un SMS, on passe d'abord en mode texte avec AT+CMGF=1. On envoie ensuite AT+CMGS="+905551112233" ; le plus sûr est d'écrire le numéro avec l'indicatif du pays (le +90 de l'exemple est celui de la Turquie ; pour la France, utilise +33, pour la Belgique +32, pour la Suisse +41). Le module répond par l'invite > pour montrer qu'il attend le texte. Une fois le texte tapé, au lieu d'Entrée on envoie le caractère Ctrl+Z (ASCII 26, 0x1A) ; quand le réseau a accepté le message, le module renvoie un numéro de référence comme +CMGS: 12 suivi de OK. Cette confirmation peut prendre quelques secondes, voire jusqu'à 60 secondes avec un signal faible. Le sketch ci-dessous se synchronise avec le module, attend l'enregistrement réseau et envoie un seul SMS ; mets ton numéro sur la ligne PHONE :

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);                // RX = D2 ← SIM TXD, TX = D3 → SIM RXD
4const char PHONE[] = "+905551112233";      // kendi numaran, uluslararası biçimde / your number, international format
5
6// ok gelirse 1, ERROR gelirse -1, süre dolarsa 0 / 1 on ok, -1 on ERROR, 0 on timeout
7int waitReply(const char *ok, unsigned long timeoutMs) {
8  const char *err = "ERROR";
9  byte m1 = 0, m2 = 0;
10  unsigned long start = millis();
11  while (millis() - start < timeoutMs) {
12    if (!sim800.available()) continue;
13    char c = sim800.read();
14    Serial.write(c);                        // modülün cevabını göster / show the module's reply
15    m1 = (c == ok[m1]) ? m1 + 1 : (c == ok[0] ? 1 : 0);
16    if (ok[m1] == '\0') return 1;
17    m2 = (c == err[m2]) ? m2 + 1 : (c == err[0] ? 1 : 0);
18    if (err[m2] == '\0') return -1;
19  }
20  return 0;
21}
22
23// Şebeke kaydını bekle: +CREG: 0,1 (ev ağı) ya da 0,5 (dolaşım) / wait for registration: home or roaming
24bool waitForNetwork(unsigned long timeoutMs) {
25  unsigned long start = millis();
26  while (millis() - start < timeoutMs) {
27    sim800.println("AT+CREG?");
28    String reply = "";
29    unsigned long t = millis();
30    while (millis() - t < 1000) {
31      while (sim800.available()) reply += (char)sim800.read();
32    }
33    Serial.print(reply);
34    if (reply.indexOf("+CREG: 0,1") >= 0 || reply.indexOf("+CREG: 0,5") >= 0) return true;
35    delay(2000);
36  }
37  return false;
38}
39
40bool sendSms(const char *number, const char *text) {
41  sim800.print("AT+CMGS=\"");
42  sim800.print(number);
43  sim800.print("\"\r");
44  if (waitReply(">", 5000) != 1) return false;   // metin istemi gelmedi / no text prompt
45  sim800.print(text);
46  sim800.write(26);                               // Ctrl+Z (0x1A): mesajı gönder / send the message
47  return waitReply("+CMGS:", 60000) == 1;         // ağ onayı 60 sn sürebilir / network ack may take 60 s
48}
49
50void setup() {
51  Serial.begin(9600);
52  sim800.begin(9600);
53  delay(3000);                                    // modül açılsın / let the module boot
54
55  bool alive = false;
56  for (byte i = 0; i < 10 && !alive; i++) {       // otomatik baud için birkaç kez AT / several ATs for autobaud
57    sim800.println("AT");
58    alive = (waitReply("OK", 1000) == 1);
59  }
60  if (!alive) {
61    Serial.println(F("\nModul cevap vermiyor / Module not responding"));
62    return;
63  }
64
65  sim800.println("AT+CMGF=1");                    // SMS metin modu / SMS text mode
66  waitReply("OK", 1000);
67
68  Serial.println(F("\nSebeke bekleniyor / Waiting for network"));
69  if (!waitForNetwork(60000)) {
70    Serial.println(F("Sebekeye kayit olunamadi / Not registered"));
71    return;
72  }
73
74  if (sendSms(PHONE, "BlueGrays: SIM800L calisiyor!")) Serial.println(F("\nSMS gonderildi / SMS sent"));
75  else Serial.println(F("\nSMS gonderilemedi / SMS failed"));
76}
77
78void loop() {
79  if (sim800.available()) Serial.write(sim800.read());   // sonraki mesajları göster / show later messages
80}

Dans le sketch, la fonction waitReply() affiche dans le moniteur série chaque caractère venant du module tout en cherchant la réponse attendue (OK, > ou +CMGS:) et le mot ERROR ; tu vois ainsi le résultat de chaque commande. waitForNetwork() attend que la réponse +CREG indique 0,1 (réseau national) ou 0,5 (itinérance), car un SMS envoyé avant l'enregistrement échoue. En mode texte, un SMS fait au maximum 160 caractères. Les caractères tapés dans l'IDE Arduino sont encodés en UTF-8, si bien que les accents et le ç arrivent déformés ; écris tes messages sans accents, comme dans l'exemple.

Piloter un relais par SMS et le basculer par un appel

Pour lire les messages reçus, on utilise AT+CNMI=1,2,0,0,0 : avec ce réglage, le module ne stocke pas les nouveaux SMS sur la carte SIM mais les écrit directement sur le port série en deux lignes. La première, comme +CMT: "+905551112233","","26/10/30,14:05:12+12", contient le numéro de l'expéditeur et l'heure (le +12 final est le fuseau horaire en quarts d'heure, ici UTC+3), la seconde le message lui-même. Le sketch ci-dessous commande un module relais sur D7 avec les messages « ROLE AC » (relais allumé), « ROLE KAPA » (relais éteint) et « DURUM » (état), répond par SMS après chaque commande et n'accepte que les messages venant de ton numéro ; tu peux bien sûr renommer les commandes en ON, OFF et ETAT dans le code. De plus, grâce à AT+CLIP=1, quand tu appelles le module depuis ton numéro, l'appel est rejeté sans être décroché et le relais change d'état ; comme un appel non décroché n'est pas facturé, c'est l'interrupteur à distance le moins cher qui soit. Certains réseaux transmettent le numéro de l'expéditeur au format national (commençant par 0) plutôt qu'international ; si les commandes sont ignorées, regarde la ligne +CMT dans le moniteur série et écris OWNER au même format.

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);                 // RX = D2 ← SIM TXD, TX = D3 → SIM RXD
4const byte RELAY_PIN = 7;                    // röle modülü IN / relay module IN
5const bool RELAY_ON = HIGH;                  // düşük seviyeli modülde LOW yap / set LOW for active-low modules
6const char OWNER[] = "+905551112233";        // komut kabul edilen tek numara / the only accepted number
7
8char line[100];                              // gelen satır tamponu / incoming line buffer
9byte lineLen = 0;
10bool bodyNext = false;                       // sonraki satır SMS metni mi? / is the next line the SMS text?
11bool fromOwner = false;
12bool relayState = false;
13
14int waitReply(const char *ok, unsigned long timeoutMs) {
15  const char *err = "ERROR";
16  byte m1 = 0, m2 = 0;
17  unsigned long start = millis();
18  while (millis() - start < timeoutMs) {
19    if (!sim800.available()) continue;
20    char c = sim800.read();
21    Serial.write(c);
22    m1 = (c == ok[m1]) ? m1 + 1 : (c == ok[0] ? 1 : 0);
23    if (ok[m1] == '\0') return 1;
24    m2 = (c == err[m2]) ? m2 + 1 : (c == err[0] ? 1 : 0);
25    if (err[m2] == '\0') return -1;
26  }
27  return 0;
28}
29
30bool sendSms(const char *number, const char *text) {
31  sim800.print("AT+CMGS=\"");
32  sim800.print(number);
33  sim800.print("\"\r");
34  if (waitReply(">", 5000) != 1) return false;
35  sim800.print(text);
36  sim800.write(26);                          // Ctrl+Z: gönder / send
37  return waitReply("+CMGS:", 60000) == 1;
38}
39
40void setRelay(bool on) {
41  relayState = on;
42  digitalWrite(RELAY_PIN, on ? RELAY_ON : !RELAY_ON);
43}
44
45void handleCommand(char *text) {
46  for (char *p = text; *p; p++) *p = toupper(*p);       // büyük harfe çevir / convert to upper case
47  if (strstr(text, "ROLE AC")) {
48    setRelay(true);
49    sendSms(OWNER, "Role ACILDI / Relay ON");
50  } else if (strstr(text, "ROLE KAPA")) {
51    setRelay(false);
52    sendSms(OWNER, "Role KAPANDI / Relay OFF");
53  } else if (strstr(text, "DURUM")) {
54    sendSms(OWNER, relayState ? "Role ACIK / Relay ON" : "Role KAPALI / Relay OFF");
55  }
56}
57
58void handleLine() {
59  Serial.println(line);
60  if (bodyNext) {                            // +CMT satırından sonraki satır SMS metnidir / the line after +CMT is the SMS text
61    bodyNext = false;
62    if (fromOwner) handleCommand(line);
63  } else if (strncmp(line, "+CMT:", 5) == 0) {
64    fromOwner = (strstr(line, OWNER) != NULL);           // gönderen kontrolü / sender check
65    bodyNext = true;
66  } else if (strncmp(line, "+CLIP:", 6) == 0 && strstr(line, OWNER) != NULL) {
67    sim800.println("ATH");                   // aramayı reddet, ücret yazılmaz / reject the call, nothing is charged
68    setRelay(!relayState);                   // her çağrıda aç-kapa / toggle on every call
69  }
70}
71
72void setup() {
73  pinMode(RELAY_PIN, OUTPUT);
74  setRelay(false);
75  Serial.begin(9600);
76  sim800.begin(9600);
77  delay(3000);
78  for (byte i = 0; i < 10; i++) {            // otomatik baud eşleşmesi / autobaud sync
79    sim800.println("AT");
80    if (waitReply("OK", 1000) == 1) break;
81  }
82  const char *initCmds[] = {"ATE0", "AT+CMGF=1", "AT+CNMI=1,2,0,0,0", "AT+CLIP=1"};
83  for (byte i = 0; i < 4; i++) {
84    sim800.println(initCmds[i]);             // yankı kapalı, metin modu, SMS'i ilet, arayanı göster / echo off, text mode, push SMS, caller ID
85    waitReply("OK", 1000);
86  }
87  Serial.println(F("\nHazir / Ready"));
88}
89
90void loop() {
91  while (sim800.available()) {
92    char c = sim800.read();
93    if (c == '\r') continue;
94    if (c == '\n') {                         // satır tamamlandı / line complete
95      line[lineLen] = '\0';
96      if (lineLen > 0) handleLine();
97      lineLen = 0;
98    } else if (lineLen < sizeof(line) - 1) {
99      line[lineLen++] = c;
100    }
101  }
102}

Passer des appels avec le SIM800L : qu'il t'appelle en cas d'alarme

Pour appeler, on écrit le numéro suivi d'un point-virgule après la commande ATD : ATD+905551112233;. Le point-virgule final indique un appel vocal ; si tu l'oublies, le module lance un appel de données et aucun appel vocal n'est établi. Si le correspondant refuse l'appel ou si la conversation se termine, le module écrit NO CARRIER ou BUSY ; sans réponse, NO ANSWER ; et sans réseau, NO DIALTONE. ATH raccroche à tout moment. Pour une alarme, un téléphone qui sonne attire bien plus l'attention qu'un SMS. Le sketch ci-dessous envoie un SMS quand un détecteur de mouvement PIR branché sur D4 se déclenche, fait ensuite sonner ton téléphone pendant 20 secondes au maximum et attend 2 minutes entre deux alarmes :

1#include <SoftwareSerial.h>
2
3SoftwareSerial sim800(2, 3);                 // RX = D2 ← SIM TXD, TX = D3 → SIM RXD
4const byte SENSOR_PIN = 4;                   // PIR çıkışı / PIR output
5const char OWNER[] = "+905551112233";        // aranacak numara / number to call
6const unsigned long RING_MS = 20000;         // en fazla 20 sn çaldır / ring for at most 20 s
7const unsigned long COOLDOWN_MS = 120000;    // iki alarm arası 2 dk; açılışta da 2 dk bekler / 2 min between alarms, also after power-up
8unsigned long lastAlarm = 0;
9
10int waitReply(const char *ok, unsigned long timeoutMs) {
11  const char *err = "ERROR";
12  byte m1 = 0, m2 = 0;
13  unsigned long start = millis();
14  while (millis() - start < timeoutMs) {
15    if (!sim800.available()) continue;
16    char c = sim800.read();
17    Serial.write(c);
18    m1 = (c == ok[m1]) ? m1 + 1 : (c == ok[0] ? 1 : 0);
19    if (ok[m1] == '\0') return 1;
20    m2 = (c == err[m2]) ? m2 + 1 : (c == err[0] ? 1 : 0);
21    if (err[m2] == '\0') return -1;
22  }
23  return 0;
24}
25
26bool sendSms(const char *number, const char *text) {
27  sim800.print("AT+CMGS=\"");
28  sim800.print(number);
29  sim800.print("\"\r");
30  if (waitReply(">", 5000) != 1) return false;
31  sim800.print(text);
32  sim800.write(26);                          // Ctrl+Z: gönder / send
33  return waitReply("+CMGS:", 60000) == 1;
34}
35
36void callOwner() {
37  sim800.print("ATD");
38  sim800.print(OWNER);
39  sim800.println(";");                       // sondaki ; sesli arama demektir / the trailing ; means a voice call
40  waitReply("NO CARRIER", RING_MS);          // açıp kapatırsan erken biter / ends early if you answer and hang up
41  sim800.println("ATH");                     // aramayı sonlandır / hang up
42  waitReply("OK", 2000);
43}
44
45void setup() {
46  pinMode(SENSOR_PIN, INPUT);
47  Serial.begin(9600);
48  sim800.begin(9600);
49  delay(3000);
50  for (byte i = 0; i < 10; i++) {            // otomatik baud eşleşmesi / autobaud sync
51    sim800.println("AT");
52    if (waitReply("OK", 1000) == 1) break;
53  }
54  sim800.println("AT+CMGF=1");               // SMS metin modu / SMS text mode
55  waitReply("OK", 1000);
56}
57
58void loop() {
59  if (digitalRead(SENSOR_PIN) == HIGH && millis() - lastAlarm > COOLDOWN_MS) {
60    lastAlarm = millis();
61    Serial.println(F("Hareket! / Motion!"));
62    sendSms(OWNER, "ALARM: Hareket algilandi / Motion detected");
63    callOwner();
64  }
65  while (sim800.available()) Serial.write(sim800.read());
66}

Le sketch reste aussi silencieux pendant les 2 premières minutes après la mise sous tension ; cela laisse au capteur PIR le temps de se stabiliser et à toi le temps de quitter la maison. Si tu décroches, l'appel s'établit ; avec un micro électret et un petit haut-parleur de 8 Ω sur les broches MIC et SPK du SIM800L, tu peux parler à travers l'appareil. Pour décrocher automatiquement les appels entrants, il suffit d'envoyer ATA quand la ligne RING apparaît. Pendant un appel, le module consomme en moyenne 130 à 220 mA avec toujours des pics de 2 A ; si ton alimentation tient pour les SMS mais que le module s'éteint pendant les appels, mets un condensateur plus gros ou une source plus puissante.

Le SIM800L avec l'ESP32 et la carte TTGO T-Call

Sur l'ESP32, SoftwareSerial est inutile : chacun de ses trois UART matériels peut être affecté aux broches de ton choix. Pour faire tourner les sketches Uno ci-dessus sur un ESP32, supprime les lignes SoftwareSerial, écris à la place HardwareSerial sim800(2); et utilise sim800.begin(9600, SERIAL_8N1, 16, 17); dans setup() ; le reste du code fonctionne tel quel. Comme l'ESP32 travaille en 3,3 V, un pont diviseur 1 kΩ + 5,6 kΩ sur la ligne TX suffit. Si tu alimentes le SIM800L avec la même source faible que l'ESP32, les pics de 2 A font aussi chuter la tension de l'ESP32 et la carte redémarre avec l'erreur « Brownout detector was triggered » ; alimente les deux cartes séparément et relie seulement les GND. Nous détaillons cette erreur dans notre guide sur le brownout de l'ESP32.

Si tu veux t'épargner le câblage, la carte LilyGO TTGO T-Call réunit un ESP32 et un modem SIM800 sur une seule carte. Elle porte un module ESP32-WROVER-B, un SIM800L (sur certains lots le SIM800H de la même famille), un support de carte SIM, un connecteur de batterie LiPo et la puce de gestion d'énergie IP5306, qui charge la batterie et fournit le courant dont le modem a besoin. Le modem s'allume et s'éteint par des GPIO précis de l'ESP32 et non par des broches externes, c'est pourquoi les sketches SIM800L classiques ne fonctionnent pas tels quels sur la T-Call.

1#include <Wire.h>
2
3// LilyGO TTGO T-Call SIM800L (IP5306'lı sürüm) pinleri / pins of the IP5306 version
4#define MODEM_PWRKEY     4
5#define MODEM_RST        5
6#define MODEM_POWER_ON  23
7#define MODEM_TX        27      // ESP32 TX → modem RX
8#define MODEM_RX        26      // ESP32 RX ← modem TX
9#define I2C_SDA         21
10#define I2C_SCL         22
11#define IP5306_ADDR   0x75      // güç yönetim yongası / power management chip
12
13HardwareSerial &modem = Serial1;
14const char OWNER[] = "+905551112233";
15
16// Pille çalışırken IP5306 kendini kapatmasın / keep the IP5306 boost on when running from battery
17bool setPowerBoostKeepOn() {
18  Wire.beginTransmission(IP5306_ADDR);
19  Wire.write(0x00);             // SYS_CTL0 yazmacı / SYS_CTL0 register
20  Wire.write(0x37);             // boost keep-on biti açık / boost keep-on bit set
21  return Wire.endTransmission() == 0;
22}
23
24// token gelirse true; ERROR ya da süre dolarsa false / true on token, false on ERROR or timeout
25bool waitFor(const char *token, unsigned long timeoutMs) {
26  String reply = "";
27  unsigned long start = millis();
28  while (millis() - start < timeoutMs) {
29    while (modem.available()) reply += (char)modem.read();
30    if (reply.indexOf(token) >= 0) break;
31    if (reply.indexOf("ERROR") >= 0) break;
32  }
33  Serial.print(reply);
34  return reply.indexOf(token) >= 0;
35}
36
37bool at(const char *cmd) {
38  modem.println(cmd);
39  return waitFor("OK", 2000);
40}
41
42bool registered() {
43  modem.println("AT+CREG?");
44  return waitFor("+CREG: 0,1", 1000);       // ev şebekesine kayıtlı / registered on the home network
45}
46
47bool sendSms(const char *number, const char *text) {
48  modem.printf("AT+CMGS=\"%s\"\r", number);
49  if (!waitFor(">", 5000)) return false;
50  modem.print(text);
51  modem.write(26);                           // Ctrl+Z: gönder / send
52  return waitFor("+CMGS:", 60000);
53}
54
55void setup() {
56  Serial.begin(115200);
57  Wire.begin(I2C_SDA, I2C_SCL);
58  Serial.println(setPowerBoostKeepOn() ? "IP5306 OK" : "IP5306 yok / not found");
59
60  pinMode(MODEM_RST, OUTPUT);
61  pinMode(MODEM_PWRKEY, OUTPUT);
62  pinMode(MODEM_POWER_ON, OUTPUT);
63  digitalWrite(MODEM_RST, HIGH);             // reset bırakılmış / reset released
64  digitalWrite(MODEM_POWER_ON, HIGH);        // modemin beslemesini aç / switch on the modem supply
65  digitalWrite(MODEM_PWRKEY, HIGH);
66  delay(100);
67  digitalWrite(MODEM_PWRKEY, LOW);           // PWRKEY 1 sn düşük: modem açılır / PWRKEY low for 1 s: modem starts
68  delay(1000);
69  digitalWrite(MODEM_PWRKEY, HIGH);
70
71  modem.begin(115200, SERIAL_8N1, MODEM_RX, MODEM_TX);
72  delay(3000);
73
74  for (int i = 0; i < 10 && !at("AT"); i++) delay(500);   // otomatik baud / autobaud
75  at("AT+CMGF=1");                           // SMS metin modu / SMS text mode
76  at("AT+CNMI=1,2,0,0,0");                   // gelen SMS'i seri porta ver / push incoming SMS to the UART
77
78  unsigned long start = millis();
79  while (!registered() && millis() - start < 60000) delay(2000);
80
81  if (sendSms(OWNER, "TTGO T-Call hazir / ready")) Serial.println("\nSMS gonderildi / sent");
82}
83
84void loop() {
85  while (modem.available()) Serial.write(modem.read());   // gelen SMS ve aramalar / incoming SMS and calls
86  while (Serial.available()) modem.write(Serial.read());  // Seri Monitör'den AT komutu / AT commands from the monitor
87}

Ces broches concernent les versions T-Call SIM800L de LilyGO équipées de l'IP5306. Sur la version avec la puce d'alimentation AXP192, celle-ci se configure avec un autre code, et sur la version SIM800C la broche d'alimentation du modem est le GPIO 25 ; regarde la date de version imprimée sur ta carte et le tableau de brochage du fabricant. La fonction setPowerBoostKeepOn() écrit 0x37 dans le registre 0x00 de l'IP5306, ce qui empêche la puce de se couper toute seule à faible charge quand elle fonctionne sur batterie. Si le modem s'éteint au moment de l'enregistrement quand la carte n'est alimentée que par l'USB de l'ordinateur, branche aussi la batterie LiPo : elle absorbe les pics de 2 A. Sur l'ESP32-WROVER, les GPIO 16 et 17 sont réservés à la PSRAM interne, d'où le branchement du modem sur 26 et 27. Pour les tâches GPRS comme les requêtes HTTP ou MQTT, la bibliothèque TinyGSM prend en charge cette carte avec la définition TINY_GSM_MODEM_SIM800.

Le SIM800L avec le Raspberry Pi Pico et MicroPython

Sur le Raspberry Pi Pico, on branche le module sur l'UART0 : le TXD du SIM800L va sur GP1, son RXD sur GP0 via un pont diviseur 1 kΩ + 5,6 kΩ, et les GND sont reliées. Les broches VBUS et 3V3 du Pico ne peuvent pas alimenter le SIM800L, utilise donc ici aussi une source externe de 4 V. Le code MicroPython ci-dessous fait la même chose que l'exemple du relais sur Arduino : il allume et éteint le relais de GP15 par SMS et envoie une réponse. La fonction to_text() écarte les octets corrompus par le bruit et ne garde que les caractères ASCII, si bien qu'une erreur de décodage n'arrête pas le programme. Aucune bibliothèque supplémentaire n'est nécessaire ; si tu ne sais pas l'exécuter avec Thonny, lis d'abord notre guide des bases de MicroPython.

1from machine import UART, Pin
2import time
3
4# GP0 (TX) → SIM RXD (1k + 5,6k bölücü / divider), GP1 (RX) ← SIM TXD
5sim = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1), timeout=100, timeout_char=50)
6relay = Pin(15, Pin.OUT, value=0)              # röle modülü IN / relay module IN
7OWNER = "+905551112233"                        # yetkili numara / authorised number
8
9def to_text(raw):
10    # yalnız ASCII karakterleri al / keep ASCII characters only
11    return "".join(chr(b) for b in raw if 9 < b < 128)
12
13def wait_for(token, timeout_ms):
14    # token ya da ERROR gelene kadar oku / read until token or ERROR
15    buf = ""
16    t0 = time.ticks_ms()
17    while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
18        if sim.any():
19            buf += to_text(sim.read())
20            if token in buf:
21                return True
22            if "ERROR" in buf:
23                return False
24    return False
25
26def at(cmd, timeout_ms=2000):
27    sim.write(cmd + "\r\n")
28    return wait_for("OK", timeout_ms)
29
30def send_sms(number, msg):
31    sim.write('AT+CMGS="{}"\r'.format(number))
32    if not wait_for(">", 5000):
33        return False
34    sim.write(msg)
35    sim.write(b"\x1a")                         # Ctrl+Z: gönder / send
36    return wait_for("+CMGS:", 60000)
37
38for _ in range(10):                            # otomatik baud eşleşmesi / autobaud sync
39    if at("AT", 1000):
40        break
41at("ATE0")                                     # yankıyı kapat / echo off
42at("AT+CMGF=1")                                # SMS metin modu / SMS text mode
43at("AT+CNMI=1,2,0,0,0")                        # gelen SMS'i UART'a ver / push incoming SMS to the UART
44print("Hazir / Ready")
45
46body_next = False
47from_owner = False
48while True:
49    raw = sim.readline()
50    if not raw:
51        continue
52    line = to_text(raw).strip()
53    if not line:
54        continue
55    print(line)
56    if body_next:                              # +CMT'den sonraki satır SMS metni / line after +CMT is the text
57        body_next = False
58        cmd = line.upper()
59        if not from_owner:
60            continue
61        if "ROLE AC" in cmd:
62            relay.value(1)
63            send_sms(OWNER, "Role ACILDI / Relay ON")
64        elif "ROLE KAPA" in cmd:
65            relay.value(0)
66            send_sms(OWNER, "Role KAPANDI / Relay OFF")
67        elif "DURUM" in cmd:
68            send_sms(OWNER, "Role ACIK / ON" if relay.value() else "Role KAPALI / OFF")
69    elif line.startswith("+CMT:"):             # yeni SMS başlığı / new SMS header
70        from_owner = OWNER in line
71        body_next = True

Idées de projets avec le SIM800L

• Alarme antivol par SMS : un système qui envoie un SMS puis t'appelle quand un capteur PIR ou un capteur d'ouverture détecte un mouvement ; tous les détails dans notre guide du système d'alarme Arduino.
• Alerte fuite de gaz : reçois un SMS sur ton téléphone quand le capteur de gaz MQ-2 dépasse son seuil, même quand personne n'est à la maison.
• Traceur GPS qui répond par SMS : avec un module GPS NEO-6M, un traceur pour voiture ou vélo qui répond au message « POSITION » par un lien Google Maps.
• Arrosage à distance : un système pour un potager ou une maison de campagne qui envoie par SMS la valeur du capteur d'humidité du sol et lance la pompe sur le message « ARROSER ».
• Surveillance de température : un montage DS18B20 qui prévient quand une serre, un poulailler ou un congélateur sort de sa plage.
• Porte de garage par appel : une télécommande gratuite qui active le relais une seconde uniquement quand un numéro enregistré appelle.
• Détecteur de coupure de courant : un petit circuit qui continue de tourner sur batterie quand le secteur tombe et envoie le SMS « Coupure de courant ».

Pas de réseau, SMS non envoyé : erreurs fréquentes et solutions

Bien alimenté et utilisé là où la 2G existe encore, le SIM800L est le moyen le moins cher de joindre tes projets Arduino à n'importe quelle distance : une source 4 V solide, un gros condensateur et quelques commandes AT suffisent. En France, pense toutefois dès maintenant à un module 4G pour les projets durables. Pour comparer les autres solutions sans fil, jette un œil à notre guide des modules de communication sans fil. Dans l'application BlueGrays, tu trouveras des projets faciles à compléter avec un SIM800L, comme une alarme à détecteur de mouvement, une alarme gaz et flamme, la commande d'une lampe 230 V, un arrosage intelligent et une alarme ESP32 avec notifications Telegram, chacun avec son schéma de câblage et son code pas à pas.