LM35-temperatuursensor met Arduino: bedrading, formule en code
LM35 met Arduino: bedrading en pinout, de formule van analogRead naar °C, 0,1 °C resolutie met de 1,1V-referentie, middelen, code voor ESP32 en Pico, LM35 vs DS18B20.
De LM35 is een goedkope analoge temperatuursensor met drie pootjes die temperatuur rechtstreeks omzet in een spanning in graden Celsius. De LM35 gebruiken met Arduino vraagt geen bibliotheek en geen ingewikkeld protocol: je sluit het middelste pootje aan op een analoge pin, leest hem uit met analogRead() en krijgt de temperatuur met een formule van één regel. De uitgangsspanning stijgt precies 10 mV per 1 °C, dus je krijgt 250 mV bij 25 °C en 1 V bij 100 °C.
In deze gids leer je hoe de LM35 werkt, wat zijn pinout is en welke omgekeerde-bedradingsfout bijna iedereen één keer maakt, hoe je °C berekent uit de analogRead-waarde, hoe je je metingen meer dan vier keer fijner maakt met de interne 1,1V-referentie van de Arduino Uno en hoe je schommelende waarden kalmeert door te middelen. Daarna zie je waar je op moet letten bij de 3,3V-boards ESP32 en Raspberry Pi Pico, hoe je negatieve temperaturen meet en wanneer je de LM35 verkiest boven de DS18B20 of DHT11.
Wat is de LM35 en hoe werkt hij?
In de LM35 zitten twee transistors die bij verschillende stroomdichtheden werken. Het verschil tussen hun basis-emitterspanningen verandert recht evenredig met de absolute temperatuur; deze techniek heet delta-VBE. Een interne versterker vergroot dit piepkleine verschil en schaalt het zo dat de uitgang bij 0 °C 0 V is. Daarom hoef je, anders dan bij sensoren op basis van kelvin zoals de LM335, geen grote constante spanning van de uitgang af te trekken: temperatuur (°C) = uitgangsspanning (mV) / 10. De sensor wordt tijdens de productie op waferniveau getrimd, dus hij heeft geen extra kalibratie nodig en zijn uitgangskromme is vrijwel perfect recht; de typische niet-lineariteit is slechts ±0,25 °C.
| Eigenschap | Waarde |
|---|---|
| Uitgang | 10 mV/°C, 0 V bij 0 °C (250 mV bij 25 °C, 1000 mV bij 100 °C) |
| Voedingsspanning | 4–30 V |
| Voedingsstroom | Minder dan 60 µA (typisch 56 µA bij 5 V) |
| Zelfopwarming | Ongeveer 0,08 °C in stilstaande lucht |
| Niet-lineariteit | Typisch ±0,25 °C |
| Uitgangsimpedantie | 0,1 Ω bij 1 mA belasting |
| Capacitieve belasting | Tot 50 pF zonder extra maatregelen |
| Behuizing | TO-92 (meest gebruikt), TO-220, SOIC-8 en metalen TO-46 |
De LM35 is niet één onderdeel maar een familie. De letter erachter bepaalt het meetbereik en de gegarandeerde nauwkeurigheid, terwijl een Z aan het eind de plastic TO-92-behuizing aangeeft. Volgens de datasheet zijn de plastic TO-92-versies de LM35C, LM35CA en LM35D, en de meeste onderdelen die in hobbywinkels als "LM35" worden verkocht zijn in werkelijkheid de LM35DZ. Je sensor is dus hoogstwaarschijnlijk alleen gegarandeerd voor 0–100 °C en kan bij 25 °C tot ±1,5 °C afwijken, hoewel de typische fout rond ±0,6 °C ligt. Lees de opdruk op het onderdeel om te weten welke je hebt.
| Model | Meetbereik | Gegarandeerde nauwkeurigheid bij 25 °C | Slechtste geval aan de bereikgrenzen |
|---|---|---|---|
| LM35A | −55 … +150 °C | ±0,5 °C | ±1 °C |
| LM35 | −55 … +150 °C | ±1 °C | ±1,5 °C |
| LM35CA | −40 … +110 °C | ±0,5 °C | ±1,5 °C |
| LM35C | −40 … +110 °C | ±1 °C | ±2 °C |
| LM35D (LM35DZ) | 0 … +100 °C | ±1,5 °C | ±2 °C |
LM35-pinout en de meest gemaakte fout: omgekeerd aansluiten
Met de platte kant van de LM35 naar je toe en de pootjes naar beneden is de volgorde van links naar rechts: pin 1 +Vs (voeding), pin 2 Vout (uitgang) en pin 3 GND (massa). Omdat de tekening in de datasheet een onderaanzicht is, draaien veel mensen hem in hun hoofd om en sluiten ze hem verkeerd om aan. Op LM35-modules op een klein printje zijn de pins meestal gelabeld VCC (of +), OUT (of S) en GND (of −); vertrouw in dat geval op de labels op het printje.
LM35 met Arduino aansluiten: Uno, ESP32 en Pico
| LM35-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| 1 · +Vs (links) | 5V | 5V / VIN (5 V via USB) | VBUS, pin 40 (5 V via USB) |
| 2 · Vout (midden) | A0 | GPIO 34 (ADC1) | GP26 / ADC0, pin 31 |
| 3 · GND (rechts) | GND | GND | AGND pin 33 of GND pin 38 |
| Condensator van 0,1 µF | Tussen +Vs en GND, vlak bij de sensor | Tussen +Vs en GND, vlak bij de sensor | Tussen +Vs en GND, vlak bij de sensor |
Van analogRead naar °C: de LM35-formule
De analoog-digitaalomzetter (ADC) van de Arduino Uno heeft 10 bits: hij verdeelt het bereik tussen 0 V en de referentiespanning in 1024 stappen en geeft je een getal van 0 tot 1023. Omdat de referentie standaard 5 V is, is elke stap 5 / 1024 = 4,88 mV. Eerst reken je de ruwe waarde om naar een spanning en daarna de spanning naar een temperatuur: spanning = ruwe waarde × 5,0 / 1024 en temperatuur = spanning × 100. Samengevat: temperatuur ≈ ruwe waarde × 0,488. Sommige voorbeelden gebruiken 1023 in plaats van 1024; het verschil is één duizendste en verwaarloosbaar naast de eigen fout van de LM35, maar 1024 is de juiste waarde. Wil je de ADC beter begrijpen, lees dan het artikel over analoog-digitaalomzetting (ADC).
| analogRead-waarde | Spanning (5V-referentie) | Temperatuur |
|---|---|---|
| 41 | 0,200 V | 20,0 °C |
| 51 | 0,249 V | 24,9 °C |
| 52 | 0,254 V | 25,4 °C |
| 61 | 0,298 V | 29,8 °C |
| 205 | 1,001 V | 100,1 °C |
Kijk goed naar de tabel: bij kamertemperatuur geeft de ADC maar een getal rond de 50 en een verandering van één stap verschuift de temperatuur met ongeveer 0,5 °C. Daarom springt je meting heen en weer tussen 24,9 en 25,4; de sensor is niet defect, dit is gewoon de resolutie van de 5V-referentie. Dit lossen we zo op met de interne referentie.
Je eerste meting, stap voor stap
- Steek de LM35 in het breadboard; sluit met de platte kant naar je toe het linkerpootje aan op 5V en het rechterpootje op GND.
- Verbind het middelste pootje (Vout) met een jumperdraad met A0. Heb je er een, voeg dan een condensator van 0,1 µF toe tussen +Vs en GND.
- Sluit de Arduino aan via USB en raak na een paar seconden de sensor aan: voelt hij als kamertemperatuur, dan is alles goed; is hij heet, dan is de bedrading omgekeerd.
- Upload de onderstaande code en open de Serial Monitor op 9600 baud.
- Houd de sensor tussen je vingers; je zou de waarde langzaam moeten zien stijgen en weer zien dalen als je loslaat.
1const int LM35_PIN = A0; // LM35 orta bacak (Vout) / LM35 middle leg (Vout)
2
3void setup() {
4 Serial.begin(9600);
5}
6
7void loop() {
8 int raw = analogRead(LM35_PIN); // 0–1023 ham değer / raw value 0–1023
9 float voltage = raw * 5.0 / 1024.0; // 5 V referansla volta çevir / convert to volts (5 V reference)
10 float tempC = voltage * 100.0; // 10 mV/°C: 0,25 V = 25 °C / 0.25 V = 25 °C
11
12 Serial.print(F("Ham / Raw: "));
13 Serial.print(raw);
14 Serial.print(F(" Gerilim / Voltage: "));
15 Serial.print(voltage, 3);
16 Serial.print(F(" V Sicaklik / Temp: "));
17 Serial.print(tempC, 1);
18 Serial.println(F(" C"));
19 delay(1000);
20}Elke seconde leest de code de ruwe waarde op A0, rekent die eerst om naar een spanning en daarna naar een temperatuur, en print alle drie naar de Serial Monitor. De ruwe waarde printen is erg handig bij het debuggen: is hij altijd 0, dan komt er geen spanning uit Vout; zit hij dicht bij 1023, dan is de analoge pin per ongeluk met 5 V verbonden; springt hij willekeurig rond, dan zweeft A0. Vaste teksten in de macro F() schrijven bespaart het RAM-geheugen van 2 KB van de Uno. Meer tips over de Serial Monitor vind je in het artikel over de Arduino Serial Monitor gebruiken.
Resolutie verhogen met de interne 1,1V-referentie
De 5V-referentie heeft twee problemen. Het eerste is de grove resolutie die je net zag. Het tweede is verraderlijker: de 5 V via USB ligt vaak ergens tussen 4,7 en 5,1 V en omdat je code 5,0 aanneemt, gaat het verschil rechtstreeks de temperatuur in. Draait je board bijvoorbeeld echt op 4,8 V, dan zie je 26 °C in plaats van 25 °C, en als de USB-poort van je computer onder belasting inzakt, lijkt de temperatuur uit zichzelf te veranderen. De oplossing is de interne 1,1V-referentie van de ATmega328P op de Arduino Uno en Nano. Na analogReference(INTERNAL) is elke stap 1,1 / 1024 = 1,07 mV, ofwel ongeveer 0,11 °C. In ruil daarvoor kun je hooguit 1,1 V meten, dus 110 °C, wat ruim voldoende is voor het bereik van 0–100 °C van de LM35DZ.
| Referentie | Commando | Eén stap | Temperatuurstap | Hoogste meetbare waarde |
|---|---|---|---|---|
| 5 V (standaard) | analogReference(DEFAULT) | 4,88 mV | 0,49 °C | 150 °C (limiet van de sensor) |
| 3,3 V (aangesloten op AREF) | analogReference(EXTERNAL) | 3,22 mV | 0,32 °C | 150 °C (limiet van de sensor) |
| 1,1 V intern | analogReference(INTERNAL) | 1,07 mV | 0,11 °C | 110 °C |
De 1,1V-referentie is niet op elke chip precies 1,1 V; volgens de datasheet van de ATmega328P kan hij overal tussen 1,0 en 1,2 V liggen. Zonder kalibratie betekent dat een schaalfout tot 9%. De oplossing is eenvoudig: upload de onderstaande code, meet met een multimeter de spanning tussen de AREF-pin en GND en schrijf de waarde in de constante VREF (bijvoorbeeld const float VREF = 1.083;). Dit hoef je maar één keer per board te doen en het resultaat blijft geldig. De code middelt ook 32 metingen voor elke uitlezing:
1const int LM35_PIN = A0;
2const float VREF = 1.1; // AREF'te ölçtüğün değeri yaz (ör. 1.083) / write the voltage you measured on AREF (e.g. 1.083)
3const int SAMPLES = 32; // ortalama için ölçüm sayısı / number of samples to average
4
5void setup() {
6 Serial.begin(9600);
7 analogReference(INTERNAL); // Uno/Nano: 1,1 V dahili referans / 1.1 V internal reference
8 for (int i = 0; i < 5; i++) { // referans değişti, ilk okumaları at / discard the first readings after switching
9 analogRead(LM35_PIN);
10 delay(10);
11 }
12}
13
14float readTempC() {
15 long sum = 0;
16 for (int i = 0; i < SAMPLES; i++) {
17 sum += analogRead(LM35_PIN);
18 delay(2);
19 }
20 float raw = sum / (float)SAMPLES; // ortalama ham değer / average raw value
21 return raw * VREF / 1024.0 * 100.0; // her basamak ~0,107 °C / each step is ~0.107 °C
22}
23
24void loop() {
25 float t = readTempC();
26 Serial.print(F("Sicaklik / Temp: "));
27 Serial.print(t, 2);
28 Serial.println(F(" C"));
29 if (t > 108.0) {
30 Serial.println(F("Uyari: 1,1 V sinirina yakin / Warning: close to the 1.1 V limit"));
31 }
32 delay(1000);
33}Middelen en ruis verminderen
Een enkele analogRead kan een of twee stappen schommelen door ruis op de draden en rimpel op de voeding. De eenvoudigste en meest effectieve oplossing is meerdere metingen te middelen: willekeurige ruis neemt af met de wortel van het aantal metingen, dus 16 metingen middelen verlaagt de ruis tot een kwart en 64 metingen tot een achtste. Temperatuur verandert langzaam, dus tientallen metingen binnen een paar milliseconden kosten je niets. Voor een nog gladdere kromme gebruik je een exponentieel filter: gefilterd = gefilterd + 0,1 × (nieuw − gefilterd). Dit filter neemt van elke nieuwe meting maar 10 procent mee en houdt één variabele in het geheugen. Andere methoden, zoals het voortschrijdend gemiddelde en de mediaan, vergelijken we in het artikel over sensorgegevens filteren.
- Gooi de eerste meting weg na het wisselen van kanaal: als je meerdere analoge sensoren uitleest, houdt de samplecondensator van de ADC even de spanning van het vorige kanaal vast; lees dezelfde pin twee keer en negeer het eerste resultaat.
- Leid de GND van de sensor rechtstreeks naar de GND-pin van de Arduino: als de stroom van een relais, motor of ledstrip door dezelfde massadraad loopt, ontstaan verschuivingen van millivolts, en bij de LM35 staat elke 10 mV gelijk aan één graad.
- Houd de kabel kort en uit de buurt van voedingsdraden: lange, onafgeschermde draden werken als antennes; gebruik zo nodig getwiste of afgeschermde kabel.
- Houd de sensor uit de buurt van warmtebronnen: een LM35 vlak naast een spanningsregelaar, een ESP32-module of een relais meet de temperatuur van het board, niet van de kamer.
- Kalibreer de offset één keer: leg de LM35 naast een betrouwbare thermometer en trek het constante verschil in je code af.
LM35 met ESP32: 3,3V-voeding en ADC-lineariteit
De ESP32 werkt op 3,3 V, maar de datasheet van de LM35 vereist minstens 4 V voeding. Een LM35 op 3,3 V lijkt bij kamertemperatuur misschien te werken, maar de nauwkeurigheid is niet gegarandeerd. De juiste manier is de sensor te voeden vanaf de 5V-pin van het board (op sommige boards VIN), dus de 5 V die via USB binnenkomt. Dit schaadt de ESP32 niet, want zelfs bij 150 °C komt de uitgang van de LM35 nooit boven 1,5 V. Sluit de uitgang altijd aan op een ADC1-pin (GPIO 32–39), omdat de ADC2-pins niet bruikbaar zijn zolang Wi-Fi aan staat. Voor de gedetailleerde pinindeling van je board zie je de tool Pinout, en ben je nieuw met de ESP32, lees dan Wat is de ESP32.
Het tweede punt is de lineariteit van de ADC van de ESP32. Hij heeft 12 bits (0–4095), maar is aan de uiteinden niet lineair: spanningen onder 100 mV kan hij nauwelijks onderscheiden en de afwijking verschilt van board tot board. Omdat de LM35 bij kamertemperatuur maar 200–300 mV geeft, raakt dit je direct. De oplossing heeft twee stappen: kies de demping (attenuation) passend bij het spanningsbereik van de LM35 en gebruik in plaats van de ruwe waarde analogReadMilliVolts(), die de kalibratiegegevens toepast die tijdens de productie in de chip zijn geschreven. Omdat deze functie direct millivolts teruggeeft, deel je het resultaat gewoon door 10 voor de temperatuur.
| Demping (attenuation) | Nauwkeurig gemeten bereik | Equivalent voor de LM35 |
|---|---|---|
| ADC_0db | 100–950 mV | 10–95 °C |
| ADC_2_5db | 100–1250 mV | 10–125 °C |
| ADC_6db | 150–1750 mV | 15–150 °C |
| ADC_11db (standaard) | 150–2450 mV | 15–150 °C, grofste resolutie |
1const int LM35_PIN = 34; // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
2const int SAMPLES = 64; // ortalama için ölçüm sayısı / number of samples to average
3
4void setup() {
5 Serial.begin(115200);
6 analogReadResolution(12); // 0–4095
7 analogSetPinAttenuation(LM35_PIN, ADC_2_5db); // ~100–1250 mV, yani 10–125 °C / i.e. 10–125 °C
8}
9
10void loop() {
11 uint32_t sum = 0;
12 for (int i = 0; i < SAMPLES; i++) {
13 sum += analogReadMilliVolts(LM35_PIN); // kalibre edilmiş mV / calibrated millivolts
14 delay(1);
15 }
16 float mv = sum / (float)SAMPLES;
17 float tempC = mv / 10.0; // 10 mV = 1 °C
18 Serial.printf("Gerilim / Voltage: %.1f mV Sicaklik / Temp: %.2f C\n", mv, tempC);
19 delay(1000);
20}LM35 met Raspberry Pi Pico en MicroPython
De 12-bits ADC van de Pico zit op de pins GP26, GP27 en GP28; als referentie gebruikt hij ADC_VREF, een gefilterde versie van de 3,3V-lijn. In MicroPython schaalt read_u16() het resultaat naar 0–65535, dus spanning = ruwe waarde × 3,3 / 65535. De theoretische resolutie is 0,8 mV, ofwel ongeveer 0,08 °C, maar in de praktijk is de ADC van de Pico wat ruisgevoelig en vertoont hij bij bepaalde waarden kleine sprongen, dus ook hier is middelen een must. Voed de LM35 vanaf VBUS (pin 40), die de 5 V van USB voert; draai je de Pico op batterijen in plaats van USB, zorg dan dat de spanning op VSYS boven 4 V ligt en voed de sensor daarvandaan. Gebruik je voor het eerst een Pico, dan vind je de MicroPython-installatie in Wat is de Raspberry Pi Pico.
1from machine import ADC, Pin
2import time
3
4# Pin(23, Pin.OUT, value=1) # yalnız Pico (W değil): regülatör PWM modu, daha az gürültü / Pico (not W) only: SMPS PWM mode, less noise
5lm35 = ADC(26) # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6VREF = 3.3 # ADC_VREF'i multimetreyle ölçüp yaz / measure ADC_VREF with a multimeter
7SAMPLES = 64 # ortalama için ölçüm sayısı / number of samples to average
8
9
10def read_temp_c():
11 total = 0
12 for _ in range(SAMPLES):
13 total += lm35.read_u16() # 0–65535, 12 bit sonuç 16 bite ölçeklenir / 12-bit result scaled to 16 bits
14 raw = total / SAMPLES
15 volts = raw * VREF / 65535
16 return volts * 100 # 10 mV/°C
17
18
19while True:
20 t = read_temp_c()
21 print("Sicaklik / Temp: {:.2f} C".format(t))
22 time.sleep(1)De chip van de Pico heeft ook een eigen temperatuursensor (ADC(4)), maar die meet de temperatuur van de chip zelf, niet van de kamer, en geeft tijdens het draaien meestal een paar graden te hoog aan; voor kamertemperatuur heb je een externe sensor zoals de LM35 nodig. Voor schonere resultaten op een standaard Pico kun je GP23 op HIGH zetten om de spanningsregelaar van het board in PWM-modus te brengen; dit vermindert de rimpel op ADC_VREF maar gebruikt in rust wat meer stroom. Op de Pico W is deze pin gereserveerd voor de draadloze chip, daarom staat die regel in de code als commentaar.
Negatieve temperaturen meten met de LM35
In de basisschakeling meet de LM35 alleen van 2 °C tot 150 °C, omdat zijn uitgangstrap stroom kan leveren maar bijna geen stroom kan opnemen, zodat de uitgang niet onder massa kan komen. Voor negatieve temperaturen toont de datasheet twee opties. De eerste is de uitgang via een weerstand met een negatieve voeding te verbinden (R = Vs / 50 µA; 100 kΩ voor −5 V), wat zelden in Arduino-projecten wordt gebruikt omdat er geen negatieve voeding is. De tweede is de methode met enkele voeding: je tilt de GND-pin van de LM35 ongeveer 1 V boven massa met twee diodes in serie (bijvoorbeeld 1N4148), zet een weerstand van 18 kΩ tussen de uitgang en massa en leest dan de uitgang uit op A0 en de GND-pin van de LM35 op A1. De temperatuur is (spanning A0 − spanning A1) × 100. Om in deze schakeling minstens 4 V over de eigen pins van de LM35 te houden, voed je +Vs vanaf VIN (bijvoorbeeld een 9V-adapter) in plaats van 5 V en gebruik je de 5V-referentie. Bedenk dat de gangbare LM35DZ onder 0 °C niet gegarandeerd is; heb je vaak negatieve waarden nodig, dan is de DS18B20 veel minder gedoe.
LM35 vs DS18B20 vs DHT11


| Eigenschap | LM35 (LM35DZ) | DS18B20 | DHT11 |
|---|---|---|---|
| Uitgang | Analog, 10 mV/°C | Digitaal (1-Wire) | Digitaal (één draad) |
| Meetbereik | 0 … +100 °C (LM35: −55 … +150 °C) | −55 … +125 °C | 0 … +50 °C |
| Nauwkeurigheid | Typisch ±0,6 °C, maximaal ±1,5 °C bij 25 °C | ±0,5 °C (−10 … +85 °C) | ±2 °C |
| Voeding | 4–30 V | 3,0–5,5 V | 3–5,5 V |
| Luchtvochtigheid | Nee | Nee | Ja |
| Bibliotheek | Niet nodig | OneWire + DallasTemperature | DHT sensor library |
| Uitleestijd | Direct, continue uitgang | Tot 750 ms bij 12 bits | Maximaal 1 meting per seconde |
| Met ESP32 en Pico | Met 5V-voeding; let op de ADC-beperkingen | Direct op 3,3 V | Direct op 3,3 V |
| Meerdere sensoren op één pin | Nee, elk een eigen analoge pin | Ja | Nee |
| Waterdichte uitvoering | Nee, je moet hem zelf afdichten | Sonde van roestvrij staal | Nee |
Kort samengevat: wil je een eenvoudige thermometer die snel reageert, geen bibliotheek nodig heeft, één analoge pin gebruikt en op een 5V-Arduino draait, dan is de LM35 ideaal; hij is ook de leerzaamste sensor om analoge metingen en ADC-referenties te leren. Is de kabel lang, heb je negatieve temperaturen nodig, komt de sensor in een vloeistof of werk je met 3,3V-boards zoals de ESP32 en Pico, dan is de DS18B20 de betere keuze. Wil je ook luchtvochtigheid, gebruik dan de DHT11 of zijn nauwkeurigere broertje, de DHT22. Voor een bredere vergelijking met ook NTC-thermistors, de BME280 en andere sensoren zie je Temperatuursensoren voor Arduino vergeleken.
Projectideeën met de LM35
Het populairste LM35-project is een thermostaat die een ventilator inschakelt als de temperatuur een ingestelde waarde overschrijdt. De sleutel is hysterese: als de ventilator bij 30 °C aan gaat en bij 28 °C uit, klikt het relais niet elke seconde aan en uit wanneer de temperatuur precies rond de drempel zweeft, en slijten de contacten niet. Je kunt de ventilator aansturen met een relaismodule die op D7 is aangesloten:
1const int LM35_PIN = A0;
2const int RELAY_PIN = 7; // röle modülünün IN pini / relay module IN pin
3const float ON_TEMP = 30.0; // bu değerde fan açılır / fan turns on here
4const float OFF_TEMP = 28.0; // bu değerde fan kapanır / fan turns off here
5const float VREF = 1.1; // ölçtüğün AREF değeri / your measured AREF value
6bool fanOn = false;
7
8float readTempC() {
9 long sum = 0;
10 for (int i = 0; i < 32; i++) {
11 sum += analogRead(LM35_PIN);
12 }
13 return (sum / 32.0) * VREF / 1024.0 * 100.0;
14}
15
16void setup() {
17 Serial.begin(9600);
18 pinMode(RELAY_PIN, OUTPUT);
19 digitalWrite(RELAY_PIN, LOW);
20 analogReference(INTERNAL); // 1,1 V referans / 1.1 V reference
21 analogRead(LM35_PIN); // ilk okumayı at / discard the first reading
22 delay(10);
23}
24
25void loop() {
26 float t = readTempC();
27 if (!fanOn && t >= ON_TEMP) fanOn = true; // eşik aşıldı / threshold exceeded
28 if (fanOn && t <= OFF_TEMP) fanOn = false; // yeterince soğudu / cooled down enough
29 digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW); // aktif-HIGH röle varsayıldı / assumes an active-HIGH relay
30 Serial.print(t, 1);
31 Serial.println(fanOn ? " C fan ON" : " C fan OFF");
32 delay(1000);
33}- Instelbare ventilatorthermostaat: combineer de bovenstaande code met een gelijkstroomventilator en een relais en verhoog of verlaag de drempel met twee knoppen.
- Digitale thermometer met LCD: toon de temperatuur op een I2C-LCD of een OLED-display samen met het minimum en maximum van de dag.
- Oververhittingsalarm: laat een buzzer klinken en een led branden wanneer een voeding, een acculader of de motor van een 3D-printer te heet wordt.
- Wi-Fi-kamerthermometer: toon de temperatuur die de ESP32 meet op een webpagina die je op je telefoon opent.
- Kas- en broedmachineregeling: bouw een systeem dat op basis van de temperatuur een verwarming en een ventilator aanstuurt; details staan in het artikel over het slimme-kasproject.
- Temperatuurlogger: schrijf elke minuut een meting naar een SD-kaart en teken de dagelijkse temperatuurkromme in Excel.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De sensor wordt te heet om aan te raken | +Vs en GND zijn verwisseld | Haal meteen de voeding eraf; met de platte kant naar je toe moet de volgorde +Vs, Vout, GND zijn |
| De waarde is altijd 0 | Er komt geen voeding bij de sensor, of Vout zit op een andere pin dan in de code | Meet met een multimeter 5 V tussen +Vs en GND en controleer of Vout naar A0 gaat |
| Waarden springen willekeurig rond | A0 zweeft of het breadboardcontact is slecht | Vervang de jumperdraad en zet de sensor in een andere rij van het breadboard |
| De waarde wisselt in stappen van 0,5 °C | Resolutie van de 5V-referentie | Gebruik analogReference(INTERNAL) en middel de metingen |
| De waarde springt wanneer een relais of motor schakelt | Spanningsval en ruis op de gedeelde massa | Leid de GND van de sensor rechtstreeks naar de Arduino en voeg een condensator van 0,1 µF toe |
| Leest 2–3 °C boven de echte temperatuur | De sensor zit naast de regelaar of de ESP32-module | Verplaats de sensor met een kabel weg van het board |
| Andere analoge sensoren lezen 1023 | De INTERNAL-referentie beperkt elke analoge ingang tot 1,1 V | Lees de andere sensoren uit met de 5V-referentie of deel hun spanning |
| Onzinwaarden op de ESP32 in de kou | De ADC van de ESP32 kan onder 100 mV niet nauwkeurig meten | Gebruik onder 10 °C een DS18B20 |
De LM35 is een perfect instaponderdeel om analoge sensormetingen, ADC-referenties en signaalfiltering te leren: je begint met één formule en gebruikt daarna de juiste referentie, middelen en kalibratie om je meting zo betrouwbaar als een thermometer te maken. Dezelfde aanpak gebruik je bij andere analoge sensoren, zoals de NTC-thermistor. In de BlueGrays-app vind je projecten zoals temperatuurmeting met een NTC en LCD, temperatuur en luchtvochtigheid met de DHT11, een ESP32-temperatuurstation met LCD en een temperatuurlogger, elk met schakelschema's stap voor stap en kant-en-klare code.
Veelgestelde vragen
Welke spanning heeft de LM35 nodig en kan hij op 3,3 V werken?
De datasheet van de LM35 specificeert een voeding van 4–30 V. Op 3,3 V geeft hij bij kamertemperatuur meestal nog wel een waarde, maar de nauwkeurigheid is niet gegarandeerd. Voed de sensor op de ESP32 en Pico vanaf de 5V-pin (VIN of VBUS); zijn uitgang komt nooit boven 1,5 V, dus hij kan direct naar een analoge ingang van 3,3 V.
Waarom wordt mijn LM35 heet?
Bij normaal gebruik neemt de LM35 maar ongeveer 60 µA op en warmt hij zichzelf minder dan 0,1 °C op; voelt hij heet, dan zijn de voedings- en GND-pin bijna altijd omgekeerd. Met de platte kant naar je toe is de juiste volgorde van links naar rechts +Vs, Vout, GND. Haal meteen de voeding eraf; een sensor die lang omgekeerd blijft staan, kan blijvend beschadigen.
Wat is de temperatuurformule van de LM35?
Op een Arduino Uno met de 5V-referentie is temperatuur (°C) = analogRead × 5,0 / 1024 × 100, ofwel ongeveer analogRead × 0,488. Met de interne 1,1V-referentie wordt de factor 1,1 / 1024 × 100 ≈ 0,107. Deel op de ESP32 het resultaat van analogReadMilliVolts() gewoon door 10.
Kan de LM35 negatieve temperaturen meten?
In de basisschakeling meet de LM35 alleen van 2 °C tot 150 °C. Voor negatieve waarden moet je de uitgang via een weerstand naar een negatieve voeding trekken, of de GND-pin met twee diodes optillen en het verschil met twee analoge ingangen meten; de sensor moet bovendien een versie zijn die onder nul is gespecificeerd, zoals de LM35 of LM35C. In de praktijk is de DS18B20 veel eenvoudiger voor temperaturen onder nul.
Wat is beter, de LM35 of de DS18B20?
In een 5V-Arduino-project met een korte kabel is de LM35 erg praktisch, omdat hij geen bibliotheek nodig heeft en direct uitleest. Voor lange kabels, negatieve temperaturen, metingen in vloeistoffen, meerdere sensoren op één pin of 3,3V-boards geeft de digitale DS18B20 nauwkeuriger en betrouwbaarder resultaat. Bij kamertemperatuur zijn de LM35A en DS18B20 even nauwkeurig, terwijl de gangbare LM35DZ iets achterblijft.
Waarom blijft de meetwaarde van mijn LM35 veranderen?
Met de 5V-referentie is elke ADC-stap ongeveer 0,5 °C, dus de waarde wisselt tussen twee stappen, en rimpel op de USB-spanning beïnvloedt het resultaat ook. Schakel over op de 1,1V-referentie met analogReference(INTERNAL), middel 16–64 metingen en voeg een condensator van 0,1 µF toe over de voedingspins van de sensor. Zit er een relais of motor in de schakeling, leid dan de GND van de sensor rechtstreeks naar de Arduino.
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…

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Lichtsterkte meten met de ESP32 en een LDR-module
Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

Temperatuur meten met NTC en 2x16 LCD-display
Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

Een lcd-scherm gebruiken met I2C
Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…
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

