SIM800L mit Arduino: SMS senden, Relais schalten und anrufen

Das SIM800L GSM-Modul ist ein winziges, sehr günstiges 2G-Modem in Briefmarkengröße, das deinem Arduino-Projekt eine eigene Telefonleitung gibt. Mit einer eingelegten Micro-SIM-Karte kannst du SMS senden und empfangen, Anrufe tätigen und über GPRS kleine Datenmengen ins Internet schicken. Wo WLAN und Bluetooth nicht hinreichen, etwa im Gartenhaus, Gewächshaus, Lager oder Fahrzeug, ist ein SIM800L am Arduino der einfachste Weg, ein Gerät von überall mit Mobilfunkempfang fernzusteuern. Das Modul spricht über eine zweiadrige serielle Verbindung (UART) mit dem Arduino und wird mit kurzen Textbefehlen gesteuert, den sogenannten AT-Befehlen.

Allerdings gehört der SIM800L zu den Modulen, die Einsteigern den meisten Ärger machen, und fast alle Probleme haben zwei Ursachen: eine unzureichende Stromversorgung und fehlende 2G-Abdeckung. In dieser Anleitung lernst du, das Modul passend zu seinem Bereich von 3,4–4,4 V und 2 A Spitzenstrom zu versorgen, was dir die Blinkfrequenz der LED auf der Platine verrät, wie du es Schritt für Schritt mit AT-Befehlen testest, wie du mit einem Arduino Uno eine SMS sendest, ein Relais per SMS ein- und ausschaltest und eine Schaltung baust, die dich bei Alarm anruft. Danach machst du dasselbe mit dem ESP32, dem fertigen TTGO-T-Call-Board und dem Raspberry Pi Pico, und am Ende findest du die Lösungen für Probleme bei der Netzanmeldung in einer Tabelle.

Was ist der SIM800L und wie funktioniert er?

Der SIM800L ist ein GSM/GPRS-Modul von SIMCom und misst nur 17,8 × 15,8 mm. Die rote Platine, die du kaufst, ist ein kleines Breakout-Board, das um das Modul herum einen SIM-Halter, einen Antennenanschluss, eine Status-LED und Stiftleisten ergänzt. Das Modul durchsucht automatisch alle vier GSM-Bänder (850, 900, 1800 und 1900 MHz), meldet sich wie ein Handy im Netz an und führt dann die Befehle aus, die über die serielle Schnittstelle kommen: „Schick diese Nachricht an diese Nummer“, „Ruf diese Nummer an“, „Gib eingehende Nachrichten an mich weiter“ und so weiter. Stell es dir als Handy ohne Display und Tastatur vor; beides übernimmt der Arduino. Schließt du ein Mikrofon und einen Lautsprecher an die Pins MIC und SPK an, kannst du sogar richtig telefonieren.

SIM800L-Pinbelegung

Die beiliegende Spiralantenne wird an das Loch NET in der Ecke der Platine gelötet; manche Platinen haben zusätzlich eine kleine u.FL-Buchse (IPEX) für eine externe Antenne. Ohne Antenne findet das Modul kein Netz und die Signalstärke liegt nahe null; ist der Empfang im Haus schwach, bringt eine Klebeantenne mit Kabel gegenüber der Spirale einen deutlichen Unterschied. Die Micro-SIM kommt in den Halter auf der Rückseite, mit der abgeschrägten Ecke passend zur Zeichnung auf dem Halter. Bevor du die Karte einlegst, deaktiviere die PIN-Abfrage in einem Handy und stell sicher, dass die Karte SMS senden und telefonieren kann und genug Guthaben hat.

Stromversorgung: 3,4–4,4 V und 2 A Spitzenstrom

Die Stromversorgung ist der kritischste Punkt beim SIM800L und der, bei dem am häufigsten Fehler passieren. GSM arbeitet im Zeitmultiplex: Innerhalb jedes 4,615 ms langen Rahmens sendet das Modul nur in seinem eigenen 577 µs langen Zeitschlitz. In diesen kurzen Momenten zieht es bis zu 2 A, gleich danach fällt der Strom wieder auf einige zehn Milliampere. Kann die Quelle diesen plötzlichen Strom nicht liefern, bricht die Spannung ein. Laut SIMCom-Datenblatt meldet das Modul bei 3,5 V über die serielle Schnittstelle UNDER-VOLTAGE WARNNING, unter 3,4 V schreibt es UNDER-VOLTAGE POWER DOWN und schaltet sich ab (der Tippfehler in WARNNING stammt aus der Firmware des Herstellers). Nach oben hin kommt bei 4,3 V die Warnung OVER-VOLTAGE WARNNING, über 4,4 V schaltet das Modul ebenfalls ab. Bei manchen Firmware-Versionen ist diese automatische Abschaltung ab Werk deaktiviert und wird mit AT+CBATCHK=1 eingeschaltet; aber auch dann arbeitet das Modul außerhalb dieser Grenzen instabil und startet immer wieder neu. Deshalb ist der 5V-Pin des Arduino zu hoch für den SIM800L. Der 3.3V-Pin liegt unter dem Minimum und ist offiziell nur mit 50 mA belastbar; außerdem liefert ein USB-Port am Computer höchstens 500 mA.

Was sagt dir die LED? Die Blinkcodes erklärt

Gewöhne dir an, die LED als Diagnosewerkzeug zu nutzen: Siehst du schon vor dem Programmieren, dass das Modul auf Blinken alle 3 Sekunden wechselt, ist die Hälfte der möglichen Fehler ausgeschlossen. Blinkt das Modul minutenlang einmal pro Sekunde, bringt Herumprobieren an der Software nichts; schau dir zuerst den Abschnitt zur Netzanmeldung weiter unten an. Die größten Stromimpulse treten genau bei der Anmeldung auf, wenn das Modul zum ersten Mal mit der Basisstation spricht; ist die Versorgung schwach, schaltet das Modul genau dann ab und alles beginnt von vorn.

SIM800L am Arduino anschließen: Verkabelung und Pegelanpassung

Der SIM800L kommuniziert per UART mit dem Arduino, und die Datenleitungen werden gekreuzt: Der TXD-Pin des Moduls geht an den RX-Pin des Boards, der RXD-Pin des Moduls an den TX-Pin des Boards. Die einzige Hardware-Schnittstelle des Arduino Uno (D0 und D1) wird für den Upload per USB und den seriellen Monitor gebraucht, deshalb schließen wir das Modul mit SoftwareSerial an D2 und D3 an; SoftwareSerial arbeitet bei 9600 Baud zuverlässig. Beim ESP32 und Pico brauchst du keine Software-Schnittstelle, dort kommen Hardware-UARTs zum Einsatz. Die Grundlagen der seriellen Kommunikation findest du in unserem Beitrag zur seriellen UART-Kommunikation.

Erster Test mit AT-Befehlen

1. Schließ das Modul wie in der Tabelle an, befestige die Antenne und lege eine Micro-SIM mit deaktivierter PIN-Abfrage ein.
2. Schalte die Versorgung ein und beobachte die LED: Nach einigen Sekunden Blinken im Sekundentakt sollte sie auf Blinken alle 3 Sekunden wechseln.
3. Lade den Brücken-Sketch unten auf den Arduino; SoftwareSerial gehört zur Arduino IDE, eine zusätzliche Bibliothek ist nicht nötig.
4. Öffne den seriellen Monitor, stell 9600 Baud und als Zeilenende Both NL & CR ein (in der deutschen IDE „Sowohl NL als auch CR“).
5. Tippe AT und drück Enter. Das Modul passt sich per Autobauding deiner Geschwindigkeit an; die ersten Versuche bleiben eventuell ohne Antwort, wiederhole, bis OK erscheint.
6. Prüfe dann mit den Befehlen aus der Tabelle unten nacheinander SIM-Karte, Signalstärke und Netzanmeldung.

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}

Aus der ersten Zahl der Antwort auf AT+CSQ kannst du die Signalstärke in dBm berechnen: dBm ≈ −113 + 2 × Wert. 18 entspricht zum Beispiel etwa −77 dBm und ist recht gut; unter 10 ist schwach, und unter 5 kommt selbst eine SMS kaum noch durch. Die Antwort 99 bedeutet, dass das Modul noch nicht messen konnte. Der Befehl AT+CBC eignet sich perfekt, um Versorgungsprobleme aufzuspüren: Zeigt er im Leerlauf etwa 4,0 V, das Modul schaltet aber beim Senden einer SMS oder beim Anrufen ab, liegt das Problem eindeutig an der Strombelastbarkeit deiner Quelle. Im voreingestellten Autobaud-Modus gibt das Modul beim Start nichts aus; legst du die Geschwindigkeit mit AT+IPR=9600 fest und speicherst sie mit AT&W, bleibt die Einstellung dauerhaft erhalten und das Modul meldet sich bei jedem Start mit RDY, +CFUN: 1 und +CPIN: READY betriebsbereit.

Keine Netzanmeldung? 2G-Abdeckung, SIM und IMEI

Der SIM800L nutzt ausschließlich das 2G-Netz (GSM/GPRS); 3G, 4G oder 5G kennt er nicht. In Deutschland betreiben die Netzbetreiber 2G noch, die Telekom plant die Abschaltung jedoch zum 30. Juni 2028, und auch bei den anderen Anbietern ist das Ende absehbar. In der Schweiz ist 2G seit Anfang 2023 komplett abgeschaltet, in Frankreich verschwindet es bis Ende 2026, in den USA ging das letzte 2G-Netz im August 2026 vom Netz und in Australien schon vor Jahren. Wo es kein 2G gibt, kann sich der SIM800L nicht anmelden, egal wie gut er versorgt ist; dort brauchst du ein 4G-LTE-Modul wie den SIM7600 oder A7670 bzw. ein LTE-M/NB-IoT-Modul wie den SIM7080G. Für ein Projekt, das viele Jahre laufen soll, ist das auch in Deutschland schon heute die zukunftssichere Wahl. Bei Anmeldeproblemen gehst du in dieser Reihenfolge vor:

• Gibt es bei dir 2G? Stell in den Mobilfunkeinstellungen deines Handys den bevorzugten Netztyp auf „nur 2G“ und versuch, mit derselben SIM-Karte zu telefonieren. Findet das Handy im 2G-Modus kein Netz, findet es der SIM800L auch nicht.
• Wird die SIM-Karte gelesen? AT+CCID sollte eine Nummer liefern und AT+CPIN? mit +CPIN: READY antworten. Bei einem Fehler legst du die Karte richtig herum neu ein; verwendest du eine Nano-SIM im Adapter, achte darauf, dass der Adapter nicht ungleichmäßig auf die Kontakte drückt.
• Reicht das Signal? AT+CSQ sollte mindestens 10 ergeben. Löte die Antenne an oder schließe eine externe an und stell das Modul ans Fenster.
• Wird die Anmeldung abgelehnt? Antwortet AT+CREG? mit 0,3, weist das Netz das Modul ab: Die Karte kann gesperrt oder die IMEI des Geräts blockiert sein.
• IMEI-Registrierung: Manche Länder sperren Geräte, deren IMEI nicht registriert ist; in der Türkei etwa werden unregistriert eingeführte Geräte nach einer Übergangsfrist abgeschaltet. Lies die IMEI des Moduls mit AT+GSN aus und kaufe in solchen Ländern bei einem lokalen Händler, der Module mit registrierter IMEI anbietet.
• Reicht die Versorgung? Startet das Modul genau bei der Anmeldung neu, liegt das Problem nicht am Netz, sondern an der Stromversorgung; geh zurück zum Abschnitt Stromversorgung.

SMS mit dem Arduino senden

Um eine SMS zu senden, schaltest du zuerst mit AT+CMGF=1 in den Textmodus. Danach folgt AT+CMGS="+905551112233"; am sichersten schreibst du die Nummer mit Ländervorwahl (+90 im Beispiel ist die Türkei, für Deutschland nimmst du +49, für Österreich +43, für die Schweiz +41). Das Modul antwortet mit dem Prompt > und wartet auf den Text. Nach dem Text sendest du statt Enter das Zeichen Strg+Z (ASCII 26, 0x1A); sobald das Netz die Nachricht angenommen hat, liefert das Modul eine Referenznummer wie +CMGS: 12 und danach OK. Diese Bestätigung kann ein paar Sekunden, bei schwachem Signal bis zu 60 Sekunden dauern. Der Sketch unten synchronisiert sich mit dem Modul, wartet auf die Netzanmeldung und sendet eine einzige SMS; trag in der Zeile PHONE deine eigene Nummer ein:

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}

Im Sketch gibt die Funktion waitReply() jedes Zeichen vom Modul im seriellen Monitor aus und sucht dabei nach der erwarteten Antwort (OK, > oder +CMGS:) und dem Wort ERROR; so siehst du das Ergebnis jedes Befehls. waitForNetwork() wartet, bis die +CREG-Antwort 0,1 (Heimnetz) oder 0,5 (Roaming) zeigt, denn eine SMS vor der Anmeldung schlägt fehl. Im Textmodus darf eine SMS höchstens 160 Zeichen lang sein. Umlaute gehören zwar zum GSM-Alphabet, aus dem Sketch kommen sie aber als UTF-8 und werden verstümmelt dargestellt; schreib deshalb ae, oe, ue und ss, wie im Beispiel ohne Sonderzeichen.

Relais per SMS schalten und per Anruf umschalten

Zum Lesen eingehender Nachrichten verwenden wir AT+CNMI=1,2,0,0,0: Damit speichert das Modul neue SMS nicht auf der SIM-Karte, sondern gibt sie direkt als zwei Zeilen seriell aus. Die erste Zeile, etwa +CMT: "+905551112233","","26/10/30,14:05:12+12", enthält Absendernummer und Zeit (das +12 am Ende ist die Zeitzone in Viertelstunden, hier UTC+3), die zweite Zeile die Nachricht selbst. Der Sketch unten steuert ein Relaismodul an D7 mit den Nachrichten „ROLE AC“ (Relais an), „ROLE KAPA“ (Relais aus) und „DURUM“ (Status), schickt nach jedem Befehl eine Antwort-SMS und akzeptiert nur Nachrichten von deiner eigenen Nummer; die Befehle kannst du im Code natürlich in EIN, AUS und STATUS umbenennen. Dank AT+CLIP=1 wird außerdem dein Anruf beim Modul abgewiesen, ohne angenommen zu werden, und das Relais schaltet um; da ein nicht angenommener Anruf nichts kostet, ist das der günstigste Fernschalter überhaupt. Manche Netze übermitteln die Absendernummer im nationalen Format (mit führender 0) statt international; werden Befehle ignoriert, schau dir die +CMT-Zeile im seriellen Monitor an und trag OWNER im selben Format ein.

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}

Mit dem SIM800L anrufen: Bei Alarm ruft er dich an

Für einen Anruf schreibst du nach dem Befehl ATD die Nummer und ein Semikolon: ATD+905551112233;. Das Semikolon am Ende kennzeichnet einen Sprachanruf; vergisst du es, startet das Modul einen Datenanruf und es kommt kein Sprachanruf zustande. Lehnt die Gegenseite ab oder endet das Gespräch, meldet das Modul NO CARRIER oder BUSY, nimmt niemand ab, NO ANSWER, und ohne Netz NO DIALTONE. ATH beendet den Anruf jederzeit. Ein klingelndes Handy erregt bei einem Alarm viel mehr Aufmerksamkeit als eine SMS. Der Sketch unten sendet eine SMS, sobald ein PIR-Bewegungsmelder an D4 auslöst, lässt dann dein Handy bis zu 20 Sekunden klingeln und wartet zwischen zwei Alarmen 2 Minuten:

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}

Auch in den ersten 2 Minuten nach dem Einschalten bleibt der Sketch still; das gibt dem PIR-Sensor Zeit zum Aufwärmen und dir Zeit, das Haus zu verlassen. Nimmst du den Anruf an, wird die Verbindung hergestellt; mit einem Elektretmikrofon und einem kleinen 8-Ω-Lautsprecher an MIC und SPK des SIM800L kannst du über das Gerät sprechen. Um eingehende Anrufe automatisch anzunehmen, sendest du einfach ATA, sobald die Zeile RING erscheint. Während eines Anrufs zieht das Modul im Mittel 130–220 mA und in Spitzen weiterhin 2 A; reicht deine Versorgung für SMS, schaltet das Modul aber beim Telefonieren ab, nimm einen größeren Kondensator oder eine stärkere Quelle.

SIM800L mit dem ESP32 und dem TTGO-T-Call-Board

Beim ESP32 brauchst du kein SoftwareSerial; einer seiner drei Hardware-UARTs lässt sich beliebigen Pins zuweisen. Um die Uno-Sketches oben auf einem ESP32 laufen zu lassen, löschst du die SoftwareSerial-Zeilen, schreibst stattdessen HardwareSerial sim800(2); und verwendest in setup() sim800.begin(9600, SERIAL_8N1, 16, 17);; der Rest des Codes läuft unverändert. Da der ESP32 mit 3,3 V arbeitet, genügt ein Teiler aus 1 kΩ + 5,6 kΩ in der TX-Leitung. Versorgst du den SIM800L aus derselben schwachen Quelle wie den ESP32, ziehen die 2-A-Impulse auch dessen Spannung herunter und das Board startet mit dem Fehler „Brownout detector was triggered“ neu; versorge beide Boards getrennt und verbinde nur die GNDs. Diesen Fehler erklären wir ausführlich in unserem Beitrag zum ESP32-Brownout.

Wenn du dir die Verkabelung sparen willst, vereint das LilyGO TTGO T-Call einen ESP32 und ein SIM800-Modem auf einer Platine. Darauf sitzen ein ESP32-WROVER-B-Modul, ein SIM800L (bei manchen Chargen der SIM800H aus derselben Familie), ein SIM-Kartenhalter, ein LiPo-Akkuanschluss und der Power-Management-Chip IP5306, der den Akku lädt und den nötigen Strom für das Modem bereitstellt. Das Modem wird nicht über externe Pins, sondern über bestimmte GPIOs des ESP32 ein- und ausgeschaltet, deshalb laufen gewöhnliche SIM800L-Sketches auf dem T-Call nicht ohne Weiteres.

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}

Diese Pins gelten für die T-Call-SIM800L-Versionen von LilyGO mit IP5306. Bei der Version mit dem Power-Chip AXP192 wird dieser mit anderem Code eingerichtet, und bei der SIM800C-Version liegt der Versorgungspin des Modems auf GPIO 25; schau auf das Versionsdatum auf deiner Platine und in die Pintabelle des Herstellers. Die Funktion setPowerBoostKeepOn() schreibt 0x37 in Register 0x00 des IP5306 und verhindert so, dass sich der Chip im Akkubetrieb bei geringer Last selbst abschaltet. Schaltet das Modem bei der Anmeldung ab, wenn das Board nur am USB-Port des Computers hängt, steck zusätzlich den LiPo-Akku an; er fängt die 2-A-Impulse ab. Beim ESP32-WROVER sind GPIO 16 und 17 für das interne PSRAM reserviert, deshalb hängt das Modem an 26 und 27. Für GPRS-Aufgaben wie HTTP-Anfragen oder MQTT unterstützt die Bibliothek TinyGSM dieses Board mit der Definition TINY_GSM_MODEM_SIM800.

SIM800L mit dem Raspberry Pi Pico und MicroPython

Am Raspberry Pi Pico schließen wir das Modul an UART0 an: TXD des SIM800L geht an GP1, RXD über einen Teiler aus 1 kΩ + 5,6 kΩ an GP0, und die GNDs werden verbunden. Die Pins VBUS und 3V3 des Pico können den SIM800L nicht versorgen, also kommt auch hier eine externe 4-V-Quelle zum Einsatz. Der MicroPython-Code unten erledigt dasselbe wie das Relais-Beispiel für den Arduino: Er schaltet das Relais an GP15 per SMS ein und aus und sendet eine Antwort. Die Funktion to_text() verwirft durch Störungen verfälschte Bytes und behält nur ASCII-Zeichen, sodass ein Dekodierfehler das Programm nicht anhält. Eine zusätzliche Bibliothek ist nicht nötig; wenn du nicht weißt, wie man den Code mit Thonny ausführt, lies zuerst unseren Beitrag zu den MicroPython-Grundlagen.

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

Projektideen mit dem SIM800L

• Einbruchalarm mit SMS: Ein System, das bei Bewegung an einem PIR- oder Türsensor eine SMS sendet und dich danach anruft; Details findest du in unserem Beitrag zur Arduino-Alarmanlage.
• Gaswarnung: Eine SMS aufs Handy, sobald der MQ-2-Gassensor seinen Schwellwert überschreitet, auch wenn niemand zu Hause ist.
• GPS-Tracker mit SMS-Antwort: Mit einem NEO-6M-GPS-Modul ein Auto- oder Fahrradtracker, der auf die Nachricht „POSITION“ mit einem Google-Maps-Link antwortet.
• Fernbewässerung: Ein System für Garten oder Schrebergarten, das den Wert des Bodenfeuchtesensors per SMS meldet und auf „GIESSEN“ die Pumpe startet.
• Temperaturwächter: Eine DS18B20-Schaltung, die warnt, wenn Gewächshaus, Hühnerstall oder Gefriertruhe den Sollbereich verlassen.
• Garagentor per Anruf: Eine kostenlose Fernbedienung, die das Relais nur bei Anrufen von registrierten Nummern für eine Sekunde anziehen lässt.
• Stromausfallmelder: Eine kleine Schaltung, die bei Netzausfall am Akku weiterläuft und eine SMS „Stromausfall“ verschickt.

Keine Netzverbindung, SMS geht nicht raus: häufige Fehler und Lösungen

Richtig versorgt und dort eingesetzt, wo es 2G gibt, ist der SIM800L der günstigste Weg, deine Arduino-Projekte aus beliebiger Entfernung zu erreichen: Eine stabile 4-V-Quelle, ein großer Kondensator und eine Handvoll AT-Befehle genügen. Wenn du die anderen Funkoptionen vergleichen willst, wirf einen Blick in unseren Beitrag zu Funkmodulen für den Arduino. In der BlueGrays-App findest du Projekte, die du leicht um einen SIM800L erweitern kannst, etwa einen Alarm mit Bewegungsmelder, einen Gas- und Flammenalarm, die Steuerung einer 230-V-Lampe, eine smarte Bewässerung und einen ESP32-Alarm mit Telegram-Benachrichtigung, jeweils mit Schaltplan und Schritt-für-Schritt-Code.