Componenten · 18 min leestijd

SIM800L Arduino-gids: sms versturen, een relais schakelen en bellen

Zo gebruik je de SIM800L GSM-module met Arduino: voeding van 4 V/2 A, led-knippercodes, AT-commando's, sms versturen, relais schakelen via sms, bellen, code voor ESP32 en Pico.

De SIM800L GSM-module is een piepklein, spotgoedkoop 2G-modem ter grootte van een postzegel, waarmee je Arduino-project een eigen telefoonlijn krijgt. Met een micro-simkaart erin kun je sms'jes versturen en ontvangen, bellen en via GPRS kleine hoeveelheden data naar internet sturen. Op plekken waar wifi en Bluetooth niet reiken, zoals een hut, kas, opslagbox of voertuig, is een SIM800L met een Arduino de eenvoudigste manier om een apparaat op afstand te bedienen, overal waar mobiel bereik is. De module praat met de Arduino via een seriële verbinding met twee draden (UART) en wordt aangestuurd met korte tekstcommando's, de zogeheten AT-commando's.

Toch is de SIM800L een van de modules waar beginners de meeste moeite mee hebben, en bijna elk probleem komt door twee dingen: een ontoereikende voeding en 2G-bereik. In deze gids leer je hoe je de module goed voedt voor het bereik van 3,4–4,4 V en een piekstroom van 2 A, wat het knippertempo van de led op de module je vertelt, hoe je hem stap voor stap test met AT-commando's, en hoe je met een Arduino Uno een sms verstuurt, een relais via sms aan- en uitzet en een schakeling bouwt die je belt als er alarm is. Daarna doe je hetzelfde met een ESP32, het kant-en-klare TTGO T-Call-board en een Raspberry Pi Pico, en aan het eind vind je de oplossingen voor netwerkregistratieproblemen in een tabel.

SIM800L GSM/GPRS-module met spiraalantenne
SIM800L-board: bovenaan de opgerolde veerantenne, ernaast een voedingscondensator en twee rijen headerpins; de micro-simhouder zit aan de achterkant van het board (onder).

Wat is de SIM800L en hoe werkt hij?

De SIM800L is een GSM/GPRS-module van SIMCom die slechts 17,8 × 15,8 mm meet. Het rode board dat je koopt is een kleine breakout die eromheen een simhouder, een antenneaansluiting, een statusled en headerpins toevoegt. De module scant automatisch alle vier de GSM-banden (850, 900, 1800 en 1900 MHz), registreert zich op het netwerk zoals een gewone mobiele telefoon en voert daarna de commando's uit die hij via de seriële poort ontvangt: "stuur dit bericht naar dit nummer", "bel dit nummer", "geef binnenkomende berichten aan mij door", enzovoort. Zie het als een telefoon zonder scherm of toetsenbord; de Arduino doet het werk van beide. Sluit een microfoon en een luidspreker aan op de pinnen MIC en SPK en je kunt zelfs een echt gesprek voeren.

KenmerkWaarde
ModuleSIMCom SIM800L, 2G GSM/GPRS
FrequentiebandenQuad-band: GSM 850, EGSM 900, DCS 1800, PCS 1900 MHz
Voedingsspanning3,4–4,4 V (4,0 V aanbevolen)
PiekstroomTot 2 A (korte pulsen tijdens het zenden)
Gemiddelde stroomUitgeschakeld ~0,1 mA, slaapstand ~1–2 mA, stand-by ~15 mA, spraakgesprek 130–220 mA, GPRS 150–450 mA (afhankelijk van band en datasheetrevisie)
Zendvermogen2 W (850/900 MHz), 1 W (1800/1900 MHz)
InterfaceUART en AT-commando's; autobauding 1200–115200
Logisch niveau2,8 V-uitgang; RXD-ingang max. 3,1 V
SimkaartMicro-sim (kaarten van 1,8 V en 3 V)
GPRS-snelheidTot 85,6 kbps
Bedrijfstemperatuur-40 tot +85 °C

SIM800L-pinout

PinFunctieOpmerking
NETAntenneaansluitingHier is de veerantenne aan gesoldeerd; zit er een u.FL-(IPEX-)aansluiting op, steek dan een externe antenne erin
VCCVoeding (+)3,4–4,4 V; sluit hem nooit aan op de 5V- of 3.3V-pin van de Arduino
RSTHardwareresetMinstens 105 ms LOW trekken herstart de module; mag onaangesloten blijven
RXDSeriële ingang van de moduleGaat naar de TX-pin van het board; max. 3,1 V
TXDSeriële uitgang van de moduleGaat naar de RX-pin van het board; niveau van 2,8 V
GNDMassaNaar zowel de voeding als de Arduino (gemeenschappelijke massa)
RINGOproep-/sms-indicatorWordt LOW bij een inkomende oproep en geeft een LOW-puls van 120 ms als er een sms binnenkomt
DTRSlaapbesturingMet AT+CSCLK=1 slaapt de module zolang DTR HIGH is en wordt hij wakker als DTR LOW wordt getrokken
MIC+ / MIC−MicrofooningangVoor een elektretmicrofoon
SPK+ / SPK−LuidsprekeruitgangEr kan een kleine luidspreker van 8 Ω worden aangesloten

De opgerolde veerantenne uit het zakje wordt gesoldeerd op het gat NET in de hoek van het board; sommige boards hebben ook een kleine u.FL-(IPEX-)aansluiting voor een externe antenne. Zonder antenne kan de module het netwerk niet vinden en is de signaalsterkte bijna nul; is de ontvangst binnenshuis zwak, dan maakt een zelfklevende GSM-antenne op een kabel een duidelijk verschil ten opzichte van de veer. De micro-simkaart gaat in de houder aan de achterkant, met de afgeschuinde hoek zoals getekend op de houder. Schakel de pincode-vraag uit in een telefoon voordat je de kaart plaatst, en controleer of de lijn sms'jes kan versturen, kan bellen en genoeg tegoed heeft.

Voeding: 3,4–4,4 V en 2 A piekstroom

De voeding is het kritiekste onderdeel van de SIM800L en het onderdeel waar mensen de meeste fouten mee maken. GSM werkt met tijdverdeling: binnen elk frame van 4,615 ms zendt de module alleen in zijn eigen tijdslot van 577 µs. In die korte momenten neemt hij tot 2 A op, en meteen daarna zakt hij terug naar enkele tientallen milliampères. Kan de voeding die plotselinge stroom niet leveren, dan klapt de spanning in elkaar. Volgens de datasheet van SIMCom stuurt de module bij een spanning van 3,5 V UNDER-VOLTAGE WARNNING naar de seriële poort, en onder 3,4 V UNDER-VOLTAGE POWER DOWN, waarna hij zichzelf uitschakelt (de spelfout WARNNING komt uit de firmware van de fabrikant). Aan de bovenkant krijg je bij 4,3 V OVER-VOLTAGE WARNNING, en boven 4,4 V schakelt de module weer uit. Bij sommige firmwareversies is deze automatische uitschakeling standaard uitgeschakeld en schakel je hem in met AT+CBATCHK=1; ook dan wordt de module buiten deze grenzen instabiel en blijft hij herstarten. Daarom is de 5V-pin van de Arduino te hoog voor de SIM800L. De 3.3V-pin zit onder het minimum en is officieel maar goed voor 50 mA; bovendien levert de USB-poort van een computer niet meer dan 500 mA.

VoedingsoptieGeschikt?Details
Enkele cel 3,7 V LiPo- of 18650-li-ionbatterijJa, de makkelijkste optieEen volle cel is 4,2 V; het werkt prima tot de cel zakt naar 3,6–3,7 V, daaronder kan hij uitvallen tijdens zendpieken. Kies minstens 1000 mAh en een cel die 2 A kan leveren, en laad hem op met een TP4056
LM2596 step-down-(buck-)moduleJa, voor projecten op een adapterStel hem in op 4,0–4,1 V vanaf een adapter van 7–12 V; levert tot 3 A
SIM800L-boards met 5V-ingang (bijv. "SIM800L V2")Ja, volgens de instructies van het boardDe schakeling op het board verlaagt de spanning; je hebt nog steeds een 5V-voeding nodig die 2 A kan leveren
5V-pin van de ArduinoNeeOverschrijdt de limiet van 4,4 V, de module schakelt uit of raakt beschadigd; USB kan geen 2 A leveren
3.3V-pin van de ArduinoNeeOnder 3,4 V en veel te weinig stroom; de module start niet of blijft herstarten
3,3V-regelaars zoals de AMS1117NeeEen uitgang van 3,3 V zit onder het minimum van de module
LM2596
LM2596
18650 Li-Ion
18650 Li-Ion
TP4056
TP4056
Gebruik je een LM2596, stel de uitgang dan met de trimmer in op 4,0–4,1 V terwijl je met een multimeter meet, voordat je de SIM800L aansluit. Je weet niet waarop de module in de fabriek is ingesteld; een uitgang dicht bij de 12 V-ingang maakt de SIM800L in de eerste seconde kapot. Gebruik je een batterij, laad de cel dan op met een TP4056-oplaadmodule en let op dat je hem niet verkeerd om aansluit; het SIM800L-board heeft geen beveiliging tegen omgekeerde polariteit.
Plaats een elco van 470–1000 µF met lage ESR en een keramische condensator van 100 nF tussen VCC en GND, zo dicht mogelijk bij de pinnen van de module; het eigen referentieontwerp van SIMCom adviseert minstens 100 µF met lage ESR. De condensator levert de pulsen van 2 A in plaats van de voedingsbron en voorkomt dat de spanning instort; hoe dat werkt leggen we uit in Wat is een condensator?. Houd de voedingsdraden kort en dik, laat 2 A niet door de veercontacten van een breadboard lopen en verbind de GND van de module altijd met de GND van de Arduino.

Wat vertelt de led je? Knippercodes uitgelegd

Gedrag van de ledBetekenisWat te doen
UitDe module draait nietControleer de voeding en de polariteit van VCC–GND, meet de spanning
Ongeveer eens per seconde (64 ms aan, 800 ms uit)Draait, maar niet geregistreerd op het netwerkNormaal gedurende de eerste 10–60 seconden; duurt het langer, controleer dan simkaart, pincode, antenne en 2G-bereik
Ongeveer eens per 3 seconden (64 ms aan, 3000 ms uit)Geregistreerd op het netwerkKlaar voor sms en gesprekken
Heel snel, ongeveer 3 keer per seconde (64 ms aan, 300 ms uit)GPRS-dataverbinding actiefEr is een internetverbinding tot stand gebracht
Knippert een paar keer, gaat uit en begint dan opnieuwDe spanning stort in en de module schakelt uitGebruik een sterkere voeding, een grote condensator en korte, dikke draden

Maak er een gewoonte van de led als diagnosehulpmiddel te gebruiken: als je ziet dat de module overschakelt op knipperen om de 3 seconden voordat je ook maar een regel code hebt geschreven, sluit je meteen de helft van de mogelijke problemen uit. Blijft de module minutenlang eens per seconde knipperen, dan heeft het geen zin aan de software te prutsen; kijk dan eerst naar de sectie over netwerkregistratie hieronder. De grootste stroompulsen komen op het moment van registratie, wanneer de module voor het eerst met het basisstation praat; is de voeding zwak, dan schakelt de module precies dan uit en begint de cyclus helemaal opnieuw.

SIM800L-bedrading met Arduino en logische niveaus

De SIM800L communiceert met de Arduino via UART en de datalijnen worden gekruist: de pin TXD van de module gaat naar de RX-pin van het board en de pin RXD van de module naar de TX-pin van het board. De enige hardware-seriële poort van de Arduino Uno (D0 en D1) wordt gebruikt voor het uploaden van code via USB en voor de Serial Monitor, dus sluiten we de module met SoftwareSerial aan op D2 en D3, wat betrouwbaar werkt op 9600 baud. Op de ESP32 en de Pico heb je geen software-seriële poort nodig; daar gebruik je de hardware-UART's. De basis van seriële communicatie vind je in onze gids UART seriële communicatie.

SIM800L-pinArduino UnoESP32Raspberry Pi Pico
VCCExterne 4,0 V (+)Externe 4,0 V (+)Externe 4,0 V (+)
GNDGND + voeding (−)GND + voeding (−)GND + voeding (−)
TXDD2 (SoftwareSerial RX)GPIO 16 (RX2)GP1 (UART0 RX)
RXDD3, via een spanningsdeler van 10 kΩ + 15 kΩGPIO 17 (TX2), via een spanningsdeler van 1 kΩ + 5,6 kΩGP0 (UART0 TX), via een spanningsdeler van 1 kΩ + 5,6 kΩ
RSTMag onaangesloten blijvenMag onaangesloten blijvenMag onaangesloten blijven
NETAntenneAntenneAntenne
Volgens de datasheet accepteert de RXD-ingang van de SIM800L maximaal 3,1 V. De D3-pin van de Uno geeft 5 V af, dus zet er een spanningsdeler tussen: D3 → 10 kΩ → RXD en RXD → 15 kΩ → GND geeft ongeveer 3,0 V. De deler van 10 kΩ + 20 kΩ die je vaak online ziet, geeft 3,3 V; die werkt meestal, maar zit net boven de limiet van de fabrikant. Voor de 3,3V-uitgang van de ESP32 en de Pico geven de door SIMCom aanbevolen weerstanden van 1 kΩ in serie + 5,6 kΩ naar GND ongeveer 2,8 V. In de andere richting leest de Uno het TXD-signaal van 2,8 V van de module meestal goed, maar volgens de datasheet van de Uno is voor een HIGH bij 5 V 3,0 V nodig; in een permanente opstelling is een bidirectionele logische niveauconverter de schoonste oplossing.

Eerste test met AT-commando's

  1. Sluit de module aan zoals in de tabel, plaats de antenne en steek een micro-simkaart erin waarvan de pincode-vraag is uitgeschakeld.
  2. Zet hem onder spanning en kijk naar de led: na een paar seconden eens per seconde knipperen zou hij moeten overschakelen op eens per 3 seconden.
  3. Upload de onderstaande bridge-sketch naar de Arduino; SoftwareSerial wordt met de Arduino IDE meegeleverd, dus je hebt geen extra bibliotheek nodig.
  4. Open de Serial Monitor, stel de snelheid in op 9600 baud en het regeleinde op Both NL & CR.
  5. Typ AT en druk op Enter. De module past zich met autobauding aan je snelheid aan; de eerste pogingen krijgen mogelijk geen antwoord, dus herhaal het tot je OK ziet.
  6. Controleer daarna met de commando's in de onderstaande tabel één voor één de simkaart, de signaalsterkte en de netwerkregistratie.
C++ (Arduino IDE)
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}
CommandoVoorbeeldantwoordBetekenis
ATOKDe module draait en de baudrate komt overeen
AT+CPIN?+CPIN: READYDe sim is klaar; zie je SIM PIN, schakel dan de pincode uit of stuur AT+CPIN="1234"
AT+CSQ+CSQ: 18,0Signaalsterkte van 0 tot 31 (99 = onbekend); 10 of meer is genoeg
AT+CREG?+CREG: 0,11 = geregistreerd, 5 = geregistreerd (roaming), 2 = zoeken, 3 = geweigerd
AT+COPS?+COPS: 0,0,"OPERATOR"Naam van de netwerkoperator
AT+CBC+CBC: 0,82,4012Voedingsspanning in millivolt (hier 4,012 V)
AT+GSNGetal van 15 cijfersHet IMEI van de module
AT+CCIDGetal van 19–20 cijfersSerienummer van de simkaart (ICCID); laat zien dat de kaart wordt gelezen
AT+CMGF=1OKTekstmodus voor sms
AT+CMGS="+905551112233">Wacht op de berichttekst; verstuurd met Ctrl+Z (26)
AT+CNMI=1,2,0,0,0OKGeeft binnenkomende sms'jes direct door aan de seriële poort zonder ze op te slaan
ATD+905551112233;OKStart een spraakgesprek (de afsluitende ; is verplicht)
ATA / ATHOKBeantwoordt een inkomende oproep / hangt op
AT+CLIP=1OKToont bij inkomende oproepen het nummer van de beller in een +CLIP-regel
AT+IPR=9600OKZet de snelheid vast op 9600 baud in plaats van autobauding; stuur daarna AT&W om dit permanent te maken
AT+CMEE=2OKMeldt fouten als beschrijvende tekst in plaats van getallen

Je kunt het eerste getal in het antwoord op AT+CSQ omrekenen naar dBm: dBm ≈ −113 + 2 × waarde. 18 betekent bijvoorbeeld ongeveer −77 dBm, en dat is best goed; onder 10 is zwak en onder 5 is een signaal waarbij zelfs een sms er moeilijk doorheen komt. Een antwoord van 99 betekent dat de module nog niet heeft kunnen meten. Het commando AT+CBC is ideaal om stroomproblemen op te sporen: zie je ongeveer 4,0 V terwijl de module stand-by staat, maar schakelt hij uit bij het versturen van een sms of bij bellen, dan ligt het probleem zeker bij de stroomcapaciteit van je voeding. In de standaard autobaudmodus stuurt de module bij het opstarten niets; zet je de snelheid vast met AT+IPR=9600 en sla je die op met AT&W, dan wordt de instelling in niet-vluchtig geheugen bewaard en meldt de module bij elk opstarten dat hij klaar is met RDY, +CFUN: 1 en +CPIN: READY.

Registreert hij niet op het netwerk? 2G-bereik, simkaart en IMEI

De SIM800L gebruikt alleen het 2G-netwerk (GSM/GPRS); 3G, 4G of 5G kent hij niet. 2G verdwijnt in veel landen: in de VS ging het laatste 2G-netwerk in augustus 2026 uit, Australië en Zwitserland hebben 2G jaren geleden uitgeschakeld, Franse operators schakelen het eind 2026 uit en in Duitsland mikt Telekom op 2028, terwijl Japan en Zuid-Korea nooit GSM hebben gebruikt. In het Verenigd Koninkrijk hebben operators gezegd dat 2G langer blijft, met uiterlijk in 2033 de definitieve uitschakeling, en in Turkije is de uitschakeling gepland voor 2029. Waar geen 2G is, kan de SIM800L zich niet registreren, hoe goed je hem ook voedt; in die gebieden heb je een 4G LTE-module nodig zoals de SIM7600 of A7670, of een LTE-M/NB-IoT-module zoals de SIM7080G. Volg bij het oplossen van registratieproblemen deze volgorde:

  • Is er 2G waar je bent? Stel in de mobiele netwerkinstellingen van je telefoon het voorkeursnetwerk in op alleen 2G en probeer te bellen met dezelfde simkaart. Kan de telefoon op 2G geen netwerk vinden, dan lukt het de SIM800L ook niet.
  • Wordt de simkaart gelezen? AT+CCID hoort een getal terug te geven en AT+CPIN? hoort +CPIN: READY te antwoorden. Krijg je een foutmelding, plaats de kaart dan opnieuw de goede kant op; gebruik je een nano-sim in een adapter, controleer dan of de adapter niet ongelijk op de contacten drukt.
  • Is het signaal sterk genoeg? AT+CSQ hoort minstens 10 te zijn. Soldeer de antenne vast of plaats een externe en zet de module bij een raam.
  • Wordt de registratie geweigerd? Antwoordt AT+CREG? met 0,3, dan weigert het netwerk de module: de lijn is misschien niet actief of het IMEI van het apparaat is geblokkeerd.
  • IMEI-registratie: Sommige landen blokkeren apparaten waarvan het IMEI niet is geregistreerd; in Turkije worden bijvoorbeeld apparaten die zonder registratie uit het buitenland zijn meegebracht na een overgangsperiode afgesloten. Lees het IMEI van de module uit met AT+GSN en koop, als je in zo'n land woont, bij een lokale verkoper die modules met een geregistreerd IMEI aanbiedt.
  • Is de voeding toereikend? Als de module op het moment van registratie herstart, ligt het probleem niet bij het netwerk maar bij de voeding; ga terug naar de sectie over de voeding hierboven.

Een sms versturen met Arduino

Om een sms te versturen schakel je eerst met AT+CMGF=1 over op tekstmodus. Daarna stuur je AT+CMGS="+905551112233"; het nummer met landcode schrijven is de veiligste keuze (+90 in het voorbeeld is de code van Turkije; gebruik +31 voor Nederland, +32 voor België, +44 voor het Verenigd Koninkrijk, +1 voor de VS, enzovoort). De module antwoordt met een >-prompt om aan te geven dat hij op de berichttekst wacht. Na het typen van de tekst stuur je in plaats van Enter het teken Ctrl+Z (ASCII 26, 0x1A); zodra het netwerk het bericht accepteert, geeft de module een referentienummer zoals +CMGS: 12 terug, gevolgd door OK. Deze bevestiging kan een paar seconden duren, of tot 60 seconden bij een zwak signaal. De onderstaande sketch synchroniseert met de module, wacht op netwerkregistratie en verstuurt één sms; zet je eigen nummer in de regel PHONE:

C++ (Arduino IDE)
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}

In de sketch print de functie waitReply() elk teken dat van de module komt naar de Serial Monitor, terwijl hij zoekt naar het verwachte antwoord (OK, > of +CMGS:) en het woord ERROR, zodat je het resultaat van elk commando ziet. waitForNetwork() wacht tot het +CREG-antwoord 0,1 (thuisnetwerk) of 0,5 (roaming) toont, want een sms die vóór de registratie wordt verstuurd, mislukt. In tekstmodus mag een sms maximaal 160 tekens lang zijn. De tekens die je in de Arduino IDE typt zijn UTF-8-gecodeerd, dus letters met accenten en niet-Latijnse letters komen verminkt aan; houd het bij gewone ASCII-tekst zoals in het voorbeeld in de code.

Elke sms kost geld. Zet nooit code die sms'jes verstuurt zonder voorwaarde in loop(): een fout die één keer per seconde afgaat betekent binnen enkele minuten honderden berichten en een hoge rekening. Voeg voor terugkerende gebeurtenissen zoals alarmen met millis() een wachttijd tussen twee berichten toe; hoe dat werkt lees je in onze gids millis() vs delay().

Een relais bedienen via sms en omschakelen met een oproep

Om binnenkomende berichten te lezen gebruiken we AT+CNMI=1,2,0,0,0: met deze instelling slaat de module nieuwe sms'jes niet op de simkaart op maar print hij ze direct op de seriële poort als twee regels. De eerste regel, zoals +CMT: "+905551112233","","26/10/30,14:05:12+12", bevat het nummer van de afzender en de tijd (de afsluitende +12 is de tijdzone in kwartieren, dus UTC+3) en de tweede regel bevat het bericht zelf. De onderstaande sketch bedient een relaismodule op D7 met de berichten "ROLE AC" (relais aan), "ROLE KAPA" (relais uit) en "DURUM" (status), stuurt na elk commando een antwoord-sms en accepteert alleen berichten van je eigen nummer; je kunt de commando's in de code natuurlijk hernoemen naar ON, OFF en STATUS. Dankzij AT+CLIP=1 wordt bovendien, als je de module vanaf je nummer belt, de oproep geweigerd zonder op te nemen en schakelt het relais om; omdat een niet-beantwoorde oproep niets kost, is dit de goedkoopste schakelaar op afstand die er is. Sommige netwerken geven het nummer van de afzender door in nationaal formaat (beginnend met 0) in plaats van internationaal formaat; worden commando's genegeerd, kijk dan naar de +CMT-regel in de Serial Monitor en schrijf OWNER in hetzelfde formaat.

C++ (Arduino IDE)
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}
Code-elementWat het doet
ATE0Schakelt de echo uit, zodat de module de commando's die je stuurt niet meer herhaalt; binnenkomende regels worden schoner
AT+CNMI=1,2,0,0,0Print een nieuwe sms op de seriële poort als een +CMT-regel, direct gevolgd door de berichttekst
AT+CLIP=1Meldt bij een inkomende oproep het nummer van de beller in een +CLIP-regel na RING
strstr(line, OWNER)Controleert of het geautoriseerde nummer in de regel voorkomt; commando's van andere nummers worden genegeerd
toupper()Zet de tekst om in hoofdletters, zodat "role ac" en "ROLE AC" hetzelfde worden behandeld
ATHBeëindigt de inkomende oproep zonder op te nemen
RELAY_ONZet op LOW voor relaismodules die op een laag niveau schakelen (active-low)
Schakel je met het relais netspanning (230 V of 120 V), doe de bedrading dan met het apparaat losgekoppeld en raak de hoogspanningskant nooit aan; heb je weinig ervaring, probeer het dan eerst met een led of een belasting van 12 V. Houd er ook rekening mee dat het nummer van de afzender dat in een sms staat kan worden vervalst. Bedien je iets belangrijks zoals een deurslot of een boiler, voeg dan aan het commando een wachtwoord toe dat alleen jij kent (bijvoorbeeld "ROLE AC 4827") en controleer het ook in de code.

Bellen met de SIM800L: laat hem je bellen bij alarm

Om te bellen schrijf je het nummer en een puntkomma achter het commando ATD: ATD+905551112233;. De afsluitende puntkomma markeert het als spraakgesprek; vergeet je hem, dan start de module een dataverbinding en komt er geen spraakgesprek tot stand. Weigert de andere kant de oproep of eindigt het gesprek, dan print de module NO CARRIER of BUSY; neemt niemand op, dan NO ANSWER; en zonder netwerk NO DIALTONE. ATH beëindigt het gesprek op elk moment. Bij alarmen trekt een rinkelende telefoon veel meer aandacht dan een sms. De onderstaande sketch verstuurt een sms als een PIR-bewegingssensor op D4 afgaat, laat daarna maximaal 20 seconden je telefoon rinkelen en wacht 2 minuten tussen twee alarmen:

C++ (Arduino IDE)
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}

De sketch blijft de eerste 2 minuten na het inschakelen ook stil; dat geeft de PIR-sensor tijd om op te warmen en geeft jou tijd om het huis te verlaten. Neem je de oproep aan, dan wordt er verbinding gemaakt; met een elektretmicrofoon en een kleine luidspreker van 8 Ω op de pinnen MIC en SPK van de SIM800L kun je via het apparaat praten. Om inkomende oproepen automatisch aan te nemen, stuur je gewoon ATA zodra je de RING-regel ziet. Tijdens een gesprek neemt de module gemiddeld 130–220 mA op en piekt hij nog steeds op 2 A; kan je voeding sms'jes aan maar schakelt de module uit tijdens gesprekken, gebruik dan een grotere condensator of een sterkere voeding.

SIM800L met ESP32 en het TTGO T-Call-board

Op de ESP32 heb je geen SoftwareSerial nodig; een van de drie hardware-UART's kan aan alle gewenste pinnen worden toegewezen. Om de Uno-sketches hierboven op een ESP32 te draaien, verwijder je de SoftwareSerial-regels, schrijf je in plaats daarvan HardwareSerial sim800(2); en gebruik je in setup() sim800.begin(9600, SERIAL_8N1, 16, 17);; de rest van de code werkt ongewijzigd. Omdat de ESP32 op 3,3 V draait, heb je op de TX-lijn genoeg aan een spanningsdeler van 1 kΩ + 5,6 kΩ. Voed je de SIM800L met dezelfde zwakke voeding als de ESP32, dan trekken de pulsen van 2 A ook de spanning van de ESP32 omlaag en herstart het board met de fout "Brownout detector was triggered"; voed de twee boards met aparte voedingen en verbind alleen hun GND's. Deze fout behandelen we uitgebreid in onze gids ESP32 brownout.

Wil je de bedrading liever overslaan, dan combineert het LilyGO TTGO T-Call-board een ESP32 en een SIM800-modem op één board. Het heeft een ESP32-WROVER-B-module, een SIM800L (bij sommige batches de SIM800H uit dezelfde familie), een simkaarthouder, een LiPo-batterijaansluiting en een IP5306-voedingschip dat de batterij oplaadt en de stroom levert die het modem nodig heeft. Het modem wordt in- en uitgeschakeld door specifieke GPIO's van de ESP32 in plaats van externe pinnen, dus gewone SIM800L-sketches werken niet zonder aanpassing op de T-Call.

LilyGO TTGO T-Call ESP32 SIM800-board
TTGO T-Call: aan de voorkant de ESP32-WROVER-B en het SIM800-modem, aan de achterkant de simkaarthouder en de LiPo-batterijaansluiting.
T-Call defineGPIOFunctie
MODEM_PWRKEY4Schakelt het modem in met een LOW-puls van 1 seconde
MODEM_RST5Modemreset; blijft HIGH
MODEM_POWER_ON23Schakelt de voeding van het modem in als hij HIGH wordt gezet
MODEM_TX27Van de ESP32 naar de RXD-ingang van het modem
MODEM_RX26Van de TXD-uitgang van het modem naar de ESP32
I2C SDA / SCL21 / 22IP5306-voedingschip (adres 0x75)
LED13Gebruikersled op het board
C++ (Arduino IDE)
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}

Deze pinnen gelden voor de T-Call SIM800L-versies van LilyGO met de IP5306. Bij de versie met de AXP192-voedingschip wordt de voedingschip met andere code ingesteld, en bij de SIM800C-versie is de voedingspin van het modem GPIO 25; controleer de versiedatum die op je board staat en de pintabel van de fabrikant. De functie setPowerBoostKeepOn() schrijft 0x37 naar register 0x00 van de IP5306, waardoor de chip zichzelf niet uitschakelt bij lage belasting op batterijvoeding. Schakelt het modem uit op het moment van registratie terwijl het board alleen via de USB van je computer wordt gevoed, sluit dan ook de LiPo-batterij aan; de batterij vangt de pulsen van 2 A op. Op de ESP32-WROVER zijn GPIO 16 en 17 gereserveerd voor het interne PSRAM, daarom is het modem op 26 en 27 aangesloten. Voor GPRS-taken zoals HTTP-verzoeken of MQTT ondersteunt de bibliotheek TinyGSM dit board met de define TINY_GSM_MODEM_SIM800.

SIM800L met Raspberry Pi Pico en MicroPython

Op de Raspberry Pi Pico sluiten we de module aan op UART0: de TXD van de SIM800L gaat naar GP1, de RXD gaat via een spanningsdeler van 1 kΩ + 5,6 kΩ naar GP0 en de GND's worden verbonden. De pinnen VBUS en 3V3 van de Pico kunnen de SIM800L niet voeden, dus voed de module ook hier met een externe voeding van 4 V. De onderstaande MicroPython-code doet hetzelfde als het Arduino-relaisvoorbeeld: hij schakelt het relais op GP15 via sms aan en uit en stuurt een antwoord. De functie to_text() gooit door ruis beschadigde bytes weg en houdt alleen ASCII-tekens over, zodat een decodeerfout het programma niet kan stoppen. Je hebt geen extra bibliotheek nodig; weet je niet hoe je het met Thonny uitvoert, lees dan eerst onze gids MicroPython-basis.

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

Projectideeën met de SIM800L

  • Inbraakalarm met sms: een systeem dat een sms stuurt en je daarna belt wanneer een PIR- of deursensor beweging detecteert; zie onze gids Arduino-alarmsysteem voor thuis voor details.
  • Gaslekwaarschuwing: krijg een sms op je telefoon als de MQ-2-gassensor zijn drempel overschrijdt, ook als er niemand thuis is.
  • GPS-tracker die per sms antwoordt: met een NEO-6M GPS-module een auto- of fietstracker die op een bericht "LOCATION" antwoordt met een Google Maps-link.
  • Irrigatie op afstand: een systeem voor een tuin of volkstuin dat de waarde van de bodemvochtsensor per sms doorgeeft en bij een bericht "WATER" de pomp start.
  • Temperatuurbewaking: een DS18B20-schakeling die een waarschuwing stuurt als een kas, kippenhok of diepvriezer buiten het bereik komt.
  • Garagedeur die opengaat met een oproep: een gratis afstandsbediening die het relais één seconde pulseert, alleen als een geregistreerd nummer belt.
  • Stroomuitvalmelder: een kleine schakeling die op een batterij blijft draaien als de netspanning uitvalt en een sms "Stroomstoring" stuurt.

Geen netwerkverbinding, sms wordt niet verstuurd: veelvoorkomende problemen en oplossingen

SymptoomMogelijke oorzaakOplossing
Helemaal geen antwoord als je AT typtTXD en RXD omgewisseld, geen gemeenschappelijke GND, verkeerde instelling van het regeleinde of autobauding niet gesynchroniseerdSluit TXD aan op D2, verbind de GND's, kies Both NL & CR en stuur AT meerdere keren
Onleesbare tekensBaudrate komt niet overeen of een grensgeval bij het logische niveauStel zowel de Serial Monitor als de sketch in op 9600, gebruik een niveauconverter
Led knippert een paar keer en gaat dan uit, module herstartDe spanning zakt tijdens de registratie onder 3,4 VEen voeding die 2 A kan leveren, een condensator van 1000 µF, korte dikke draden
UNDER-VOLTAGE POWER DOWN verschijnt op de seriële poortDe voeding zakte onder 3,4 VLaad de batterij op of stel de uitgang van de buck in op 4,0–4,1 V
OVER-VOLTAGE WARNNING of OVER-VOLTAGE POWER DOWNDe spanning is hoger dan 4,3–4,4 VVerlaag de uitgang naar 4,0 V; sluit de module nooit aan op 5 V
Led blijft eens per seconde knipperenGeen antenne, simkaart niet gelezen, pincode ingeschakeld of geen 2G in het gebiedPlaats de antenne, controleer met AT+CPIN? en AT+CSQ, test het 2G-bereik met een telefoon
Antwoord +CREG: 0,3Netwerkregistratie geweigerdControleer of de lijn actief is en het IMEI niet is geblokkeerd
Sms mislukt met +CMS ERRORGeen tegoed, verkeerd nummerformaat of ontbrekend nummer van het sms-centrumControleer je tegoed, schrijf het nummer met landcode, controleer het sms-centrum met AT+CSCA?
Arduino reset tijdens het versturen van een smsDe SIM800L en de Arduino delen dezelfde zwakke voedingScheid de voedingen en verbind alleen de GND's
Inkomende sms'jes verschijnen niet op de seriële poortAT+CNMI is niet ingesteld, of de instelling ging verloren toen de module herstartteStuur AT+CMGF=1 en AT+CNMI=1,2,0,0,0 tijdens setup
De snelste manier om te zien of het probleem in je code of je hardware zit, is de module direct met je computer te verbinden via een 3,3V-USB-TTL-converter en de AT-commando's met de hand te typen. Stuur tijdens het oplossen van problemen AT+CMEE=2: de module toont dan leesbare foutmeldingen zoals "+CME ERROR: SIM not inserted" in plaats van "+CME ERROR: 10".

Goed gevoed en gebruikt waar 2G-bereik is, is de SIM800L de goedkoopste manier om je Arduino-projecten van kilometers ver te bereiken: een solide voeding van 4 V, een grote condensator en een handvol AT-commando's is alles wat je nodig hebt. Wil je de andere draadloze opties vergelijken, kijk dan eens naar onze gids draadloze communicatiemodules. In de BlueGrays-app vind je projecten die je makkelijk kunt uitbreiden met een SIM800L, zoals een bewegingssensoralarm, een gas- en vlammelder, netspanningslampbediening, slimme irrigatie en een ESP32-alarm met Telegram-meldingen, allemaal met schakelschema's en code stap voor stap.

Veelgestelde vragen

Welke spanning heeft de SIM800L nodig en kan ik hem op 5V aansluiten?

De SIM800L werkt op 3,4–4,4 V, met 4,0 V als aanbeveling. Sluit je hem aan op de 5V-pin van de Arduino, dan schakelt de module uit door overspanning of raakt hij beschadigd. Gebruik een enkele LiPo- of 18650-batterij of een LM2596 ingesteld op 4,0 V; de voeding moet ook korte pulsen van 2 A aankunnen.

Werkt de SIM800L in 2026 nog?

Alleen waar nog een 2G-netwerk draait. 2G is uitgeschakeld in de VS, Australië en Zwitserland, en Frankrijk schakelt het eind 2026 uit, terwijl Duitsland, het Verenigd Koninkrijk en Turkije voorlopig nog 2G hebben. Controleer de 2G-plannen van je operator voordat je een project voor de lange termijn bouwt; kies anders een 4G LTE-module.

Waarom maakt mijn SIM800L geen verbinding met het netwerk?

De meest voorkomende oorzaken zijn een ontoereikende voeding, een ontbrekende antenne, een simkaart met ingeschakelde pincode en geen 2G-bereik in het gebied. Controleer het signaal met AT+CSQ, de simkaart met AT+CPIN? en de registratiestatus met AT+CREG?. Herstart de module tijdens de registratie, dan ligt het probleem zeker bij de voeding.

Wat betekenen de knipperpatronen van de SIM800L-led?

Eens per seconde knipperen betekent dat de module draait maar niet op het netwerk is geregistreerd, en eens per 3 seconden knipperen betekent dat hij geregistreerd is en klaar voor sms en gesprekken. Heel snel knipperen betekent dat er een GPRS-dataverbinding actief is. Knippert de led een paar keer en gaat hij dan uit, dan herstart de module door een spanningsdaling.

Kan de SIM800L verbinding maken met internet?

Ja, via GPRS kan hij data verzenden en ontvangen met maximaal 85,6 kbps, genoeg om sensordata naar een server te sturen, HTTP-verzoeken te doen of MQTT te gebruiken. Je moet de APN-instellingen van je operator invoeren, en de bibliotheek TinyGSM maakt dat makkelijker. Voor afbeeldingen of grote bestanden is hij echter veel te traag.

Wat kan ik gebruiken in plaats van de SIM800L?

Gebruik in landen waar 2G is of wordt uitgeschakeld een 4G LTE-module zoals de SIM7600 of A7670, of een LTE-M/NB-IoT-module zoals de SIM7080G. De meeste AT-commando's lijken op elkaar, dus code voor sms en bellen is met kleine aanpassingen over te zetten. De SIM800C en de oudere SIM900 uit dezelfde familie gebruiken vergelijkbare commando's, maar zijn ook alleen 2G.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9
Bewegingsmelder met bewegingssensor
AR-24Beginner
Premium

Bewegingsmelder met bewegingssensor

Een eenvoudige bewaker die laat weten wanneer iemand de kamer binnenkomt. De bewegingssensor merkt de warmte op die het menselijk lichaam afgeeft; de Arduino houdt de led aan zolang er beweging is en…

4.6(47)
67
Alarm met vlam- en gassensor
AR-52Gevorderd
Premium

Alarm met vlam- en gassensor

Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

4.8(52)
67
230V-lamp laten branden met een drukknop
AR-19Gevorderd
Premium

230V-lamp laten branden met een drukknop

Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.

4.4(30)
38
230V-lamp laten branden met een afstandsbediening
AR-21Gevorderd
Premium

230V-lamp laten branden met een afstandsbediening

Zet een echte lamp in huis aan en uit met een tv-afstandsbediening, zonder van de bank te komen.

4.4(23)
31
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57