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.

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.
| Kenmerk | Waarde |
|---|---|
| Module | SIMCom SIM800L, 2G GSM/GPRS |
| Frequentiebanden | Quad-band: GSM 850, EGSM 900, DCS 1800, PCS 1900 MHz |
| Voedingsspanning | 3,4–4,4 V (4,0 V aanbevolen) |
| Piekstroom | Tot 2 A (korte pulsen tijdens het zenden) |
| Gemiddelde stroom | Uitgeschakeld ~0,1 mA, slaapstand ~1–2 mA, stand-by ~15 mA, spraakgesprek 130–220 mA, GPRS 150–450 mA (afhankelijk van band en datasheetrevisie) |
| Zendvermogen | 2 W (850/900 MHz), 1 W (1800/1900 MHz) |
| Interface | UART en AT-commando's; autobauding 1200–115200 |
| Logisch niveau | 2,8 V-uitgang; RXD-ingang max. 3,1 V |
| Simkaart | Micro-sim (kaarten van 1,8 V en 3 V) |
| GPRS-snelheid | Tot 85,6 kbps |
| Bedrijfstemperatuur | -40 tot +85 °C |
SIM800L-pinout
| Pin | Functie | Opmerking |
|---|---|---|
| NET | Antenneaansluiting | Hier is de veerantenne aan gesoldeerd; zit er een u.FL-(IPEX-)aansluiting op, steek dan een externe antenne erin |
| VCC | Voeding (+) | 3,4–4,4 V; sluit hem nooit aan op de 5V- of 3.3V-pin van de Arduino |
| RST | Hardwarereset | Minstens 105 ms LOW trekken herstart de module; mag onaangesloten blijven |
| RXD | Seriële ingang van de module | Gaat naar de TX-pin van het board; max. 3,1 V |
| TXD | Seriële uitgang van de module | Gaat naar de RX-pin van het board; niveau van 2,8 V |
| GND | Massa | Naar zowel de voeding als de Arduino (gemeenschappelijke massa) |
| RING | Oproep-/sms-indicator | Wordt LOW bij een inkomende oproep en geeft een LOW-puls van 120 ms als er een sms binnenkomt |
| DTR | Slaapbesturing | Met AT+CSCLK=1 slaapt de module zolang DTR HIGH is en wordt hij wakker als DTR LOW wordt getrokken |
| MIC+ / MIC− | Microfooningang | Voor een elektretmicrofoon |
| SPK+ / SPK− | Luidsprekeruitgang | Er 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.
| Voedingsoptie | Geschikt? | Details |
|---|---|---|
| Enkele cel 3,7 V LiPo- of 18650-li-ionbatterij | Ja, de makkelijkste optie | Een 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-)module | Ja, voor projecten op een adapter | Stel 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 board | De schakeling op het board verlaagt de spanning; je hebt nog steeds een 5V-voeding nodig die 2 A kan leveren |
| 5V-pin van de Arduino | Nee | Overschrijdt de limiet van 4,4 V, de module schakelt uit of raakt beschadigd; USB kan geen 2 A leveren |
| 3.3V-pin van de Arduino | Nee | Onder 3,4 V en veel te weinig stroom; de module start niet of blijft herstarten |
| 3,3V-regelaars zoals de AMS1117 | Nee | Een uitgang van 3,3 V zit onder het minimum van de module |



Wat vertelt de led je? Knippercodes uitgelegd
| Gedrag van de led | Betekenis | Wat te doen |
|---|---|---|
| Uit | De module draait niet | Controleer 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 netwerk | Normaal 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 netwerk | Klaar voor sms en gesprekken |
| Heel snel, ongeveer 3 keer per seconde (64 ms aan, 300 ms uit) | GPRS-dataverbinding actief | Er is een internetverbinding tot stand gebracht |
| Knippert een paar keer, gaat uit en begint dan opnieuw | De spanning stort in en de module schakelt uit | Gebruik 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-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | Externe 4,0 V (+) | Externe 4,0 V (+) | Externe 4,0 V (+) |
| GND | GND + voeding (−) | GND + voeding (−) | GND + voeding (−) |
| TXD | D2 (SoftwareSerial RX) | GPIO 16 (RX2) | GP1 (UART0 RX) |
| RXD | D3, 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Ω |
| RST | Mag onaangesloten blijven | Mag onaangesloten blijven | Mag onaangesloten blijven |
| NET | Antenne | Antenne | Antenne |
Eerste test met AT-commando's
- Sluit de module aan zoals in de tabel, plaats de antenne en steek een micro-simkaart erin waarvan de pincode-vraag is uitgeschakeld.
- 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.
- Upload de onderstaande bridge-sketch naar de Arduino; SoftwareSerial wordt met de Arduino IDE meegeleverd, dus je hebt geen extra bibliotheek nodig.
- Open de Serial Monitor, stel de snelheid in op 9600 baud en het regeleinde op Both NL & CR.
- 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.
- Controleer daarna met de commando's in de onderstaande tabel één voor één de simkaart, de signaalsterkte en de netwerkregistratie.
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}| Commando | Voorbeeldantwoord | Betekenis |
|---|---|---|
| AT | OK | De module draait en de baudrate komt overeen |
| AT+CPIN? | +CPIN: READY | De sim is klaar; zie je SIM PIN, schakel dan de pincode uit of stuur AT+CPIN="1234" |
| AT+CSQ | +CSQ: 18,0 | Signaalsterkte van 0 tot 31 (99 = onbekend); 10 of meer is genoeg |
| AT+CREG? | +CREG: 0,1 | 1 = geregistreerd, 5 = geregistreerd (roaming), 2 = zoeken, 3 = geweigerd |
| AT+COPS? | +COPS: 0,0,"OPERATOR" | Naam van de netwerkoperator |
| AT+CBC | +CBC: 0,82,4012 | Voedingsspanning in millivolt (hier 4,012 V) |
| AT+GSN | Getal van 15 cijfers | Het IMEI van de module |
| AT+CCID | Getal van 19–20 cijfers | Serienummer van de simkaart (ICCID); laat zien dat de kaart wordt gelezen |
| AT+CMGF=1 | OK | Tekstmodus voor sms |
| AT+CMGS="+905551112233" | > | Wacht op de berichttekst; verstuurd met Ctrl+Z (26) |
| AT+CNMI=1,2,0,0,0 | OK | Geeft binnenkomende sms'jes direct door aan de seriële poort zonder ze op te slaan |
| ATD+905551112233; | OK | Start een spraakgesprek (de afsluitende ; is verplicht) |
| ATA / ATH | OK | Beantwoordt een inkomende oproep / hangt op |
| AT+CLIP=1 | OK | Toont bij inkomende oproepen het nummer van de beller in een +CLIP-regel |
| AT+IPR=9600 | OK | Zet de snelheid vast op 9600 baud in plaats van autobauding; stuur daarna AT&W om dit permanent te maken |
| AT+CMEE=2 | OK | Meldt 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:
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.
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.
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-element | Wat het doet |
|---|---|
| ATE0 | Schakelt 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,0 | Print een nieuwe sms op de seriële poort als een +CMT-regel, direct gevolgd door de berichttekst |
| AT+CLIP=1 | Meldt 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 |
| ATH | Beëindigt de inkomende oproep zonder op te nemen |
| RELAY_ON | Zet op LOW voor relaismodules die op een laag niveau schakelen (active-low) |
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:
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.

| T-Call define | GPIO | Functie |
|---|---|---|
| MODEM_PWRKEY | 4 | Schakelt het modem in met een LOW-puls van 1 seconde |
| MODEM_RST | 5 | Modemreset; blijft HIGH |
| MODEM_POWER_ON | 23 | Schakelt de voeding van het modem in als hij HIGH wordt gezet |
| MODEM_TX | 27 | Van de ESP32 naar de RXD-ingang van het modem |
| MODEM_RX | 26 | Van de TXD-uitgang van het modem naar de ESP32 |
| I2C SDA / SCL | 21 / 22 | IP5306-voedingschip (adres 0x75) |
| LED | 13 | Gebruikersled op het board |
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.
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 = TrueProjectideeë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
| Symptoom | Mogelijke oorzaak | Oplossing |
|---|---|---|
| Helemaal geen antwoord als je AT typt | TXD en RXD omgewisseld, geen gemeenschappelijke GND, verkeerde instelling van het regeleinde of autobauding niet gesynchroniseerd | Sluit TXD aan op D2, verbind de GND's, kies Both NL & CR en stuur AT meerdere keren |
| Onleesbare tekens | Baudrate komt niet overeen of een grensgeval bij het logische niveau | Stel zowel de Serial Monitor als de sketch in op 9600, gebruik een niveauconverter |
| Led knippert een paar keer en gaat dan uit, module herstart | De spanning zakt tijdens de registratie onder 3,4 V | Een voeding die 2 A kan leveren, een condensator van 1000 µF, korte dikke draden |
| UNDER-VOLTAGE POWER DOWN verschijnt op de seriële poort | De voeding zakte onder 3,4 V | Laad de batterij op of stel de uitgang van de buck in op 4,0–4,1 V |
| OVER-VOLTAGE WARNNING of OVER-VOLTAGE POWER DOWN | De spanning is hoger dan 4,3–4,4 V | Verlaag de uitgang naar 4,0 V; sluit de module nooit aan op 5 V |
| Led blijft eens per seconde knipperen | Geen antenne, simkaart niet gelezen, pincode ingeschakeld of geen 2G in het gebied | Plaats de antenne, controleer met AT+CPIN? en AT+CSQ, test het 2G-bereik met een telefoon |
| Antwoord +CREG: 0,3 | Netwerkregistratie geweigerd | Controleer of de lijn actief is en het IMEI niet is geblokkeerd |
| Sms mislukt met +CMS ERROR | Geen tegoed, verkeerd nummerformaat of ontbrekend nummer van het sms-centrum | Controleer je tegoed, schrijf het nummer met landcode, controleer het sms-centrum met AT+CSCA? |
| Arduino reset tijdens het versturen van een sms | De SIM800L en de Arduino delen dezelfde zwakke voeding | Scheid de voedingen en verbind alleen de GND's |
| Inkomende sms'jes verschijnen niet op de seriële poort | AT+CNMI is niet ingesteld, of de instelling ging verloren toen de module herstartte | Stuur AT+CMGF=1 en AT+CNMI=1,2,0,0,0 tijdens setup |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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…

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.

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…

Alarm met vlam- en gassensor
Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

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.

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.

Slim bewateringsstation
Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

