Componenten · 15 min leestijd

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.

EigenschapWaarde
Uitgang10 mV/°C, 0 V bij 0 °C (250 mV bij 25 °C, 1000 mV bij 100 °C)
Voedingsspanning4–30 V
VoedingsstroomMinder dan 60 µA (typisch 56 µA bij 5 V)
ZelfopwarmingOngeveer 0,08 °C in stilstaande lucht
Niet-lineariteitTypisch ±0,25 °C
Uitgangsimpedantie0,1 Ω bij 1 mA belasting
Capacitieve belastingTot 50 pF zonder extra maatregelen
BehuizingTO-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.

ModelMeetbereikGegarandeerde nauwkeurigheid bij 25 °CSlechtste 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.

De LM35 en de DS18B20 hebben dezelfde zwarte TO-92-behuizing en zijn bijna niet uit elkaar te houden, maar hun voedingspins zijn omgekeerd: bij de DS18B20 is, met de platte kant naar je toe, het linkerpootje GND en het rechterpootje VDD. Als je op de LM35 +Vs en GND verwisselt, loopt er een grote stroom door de diodestructuren in de chip, wordt de sensor binnen enkele seconden zo heet dat je je vinger brandt en worden de metingen betekenisloos. Raak de sensor aan wanneer je hem voor het eerst van stroom voorziet; wordt hij heet, haal dan meteen de voeding eraf. Een sensor die maar even omgekeerd stond overleeft het meestal, maar zijn nauwkeurigheid kan beschadigd zijn; als de metingen daarna niet kloppen, vervang je hem.

LM35 met Arduino aansluiten: Uno, ESP32 en Pico

LM35-pinArduino UnoESP32Raspberry Pi Pico
1 · +Vs (links)5V5V / VIN (5 V via USB)VBUS, pin 40 (5 V via USB)
2 · Vout (midden)A0GPIO 34 (ADC1)GP26 / ADC0, pin 31
3 · GND (rechts)GNDGNDAGND pin 33 of GND pin 38
Condensator van 0,1 µFTussen +Vs en GND, vlak bij de sensorTussen +Vs en GND, vlak bij de sensorTussen +Vs en GND, vlak bij de sensor
In een omgeving met veel ruis raadt de fabrikant een keramische condensator van 0,1 µF aan tussen +Vs en GND, direct naast de sensor; hij is gemarkeerd met "104" en je kunt de code ontcijferen met de tool Condensatorcode. De uitgang van de LM35 kan hooguit 50 pF capacitieve belasting zonder problemen aansturen; een paar meter kabel is al meer en dan kan de uitgang gaan oscilleren. Zet bij een lange kabel een weerstand van 2 kΩ in serie met de uitgang, of voeg een R-C-demper van 75 Ω + 1 µF in serie toe tussen de uitgang en GND; een getwiste kabel (twisted pair) verkleint ook merkbaar de storing.

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-waardeSpanning (5V-referentie)Temperatuur
410,200 V20,0 °C
510,249 V24,9 °C
520,254 V25,4 °C
610,298 V29,8 °C
2051,001 V100,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

  1. Steek de LM35 in het breadboard; sluit met de platte kant naar je toe het linkerpootje aan op 5V en het rechterpootje op GND.
  2. 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.
  3. 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.
  4. Upload de onderstaande code en open de Serial Monitor op 9600 baud.
  5. Houd de sensor tussen je vingers; je zou de waarde langzaam moeten zien stijgen en weer zien dalen als je loslaat.
C++ (Arduino IDE)
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.

ReferentieCommandoEén stapTemperatuurstapHoogste meetbare waarde
5 V (standaard)analogReference(DEFAULT)4,88 mV0,49 °C150 °C (limiet van de sensor)
3,3 V (aangesloten op AREF)analogReference(EXTERNAL)3,22 mV0,32 °C150 °C (limiet van de sensor)
1,1 V internanalogReference(INTERNAL)1,07 mV0,11 °C110 °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:

C++ (Arduino IDE)
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}
analogReference(INTERNAL) geldt voor elke analoge ingang van het board: lees je in hetzelfde project ook een potentiometer of een LDR uit, dan wordt alles boven 1,1 V als 1023 gelezen. Zet nooit een externe spanning op de AREF-pin zolang de interne referentie is gekozen; wil je 3,3 V op AREF aansluiten, dan moet je analogReference(EXTERNAL) aanroepen vóór de eerste analogRead, anders worden de interne referentie en de externe bron kortgesloten en kan de microcontroller beschadigen. Op de Arduino Mega heet deze optie INTERNAL1V1; op de Leonardo en Micro geeft INTERNAL 2,56 V, en op de Uno R4 is analogReference(AR_INTERNAL) 1,5 V.

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 bereikEquivalent voor de LM35
ADC_0db100–950 mV10–95 °C
ADC_2_5db100–1250 mV10–125 °C
ADC_6db150–1750 mV15–150 °C
ADC_11db (standaard)150–2450 mV15–150 °C, grofste resolutie
C++ (Arduino IDE)
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}
Omdat de ESP32, welke demping je ook kiest, onder 100 mV niet betrouwbaar kan meten, kloppen LM35-metingen onder 10 °C op de ESP32 niet. Gebruik voor koude ruimtes, buiten of een koelkast de DS18B20. Wil je een analoge sensor in een schakeling die alleen 3,3 V heeft, dan is de TMP36 een goed alternatief: hij werkt op 2,7–5,5 V en geeft 500 mV bij 0 °C. Zijn pinout is gelijk aan die van de LM35 en de formule is temperatuur = (mV − 500) / 10.

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.

MicroPython
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

DS18B20
DS18B20
DHT11
DHT11
EigenschapLM35 (LM35DZ)DS18B20DHT11
UitgangAnalog, 10 mV/°CDigitaal (1-Wire)Digitaal (één draad)
Meetbereik0 … +100 °C (LM35: −55 … +150 °C)−55 … +125 °C0 … +50 °C
NauwkeurigheidTypisch ±0,6 °C, maximaal ±1,5 °C bij 25 °C±0,5 °C (−10 … +85 °C)±2 °C
Voeding4–30 V3,0–5,5 V3–5,5 V
LuchtvochtigheidNeeNeeJa
BibliotheekNiet nodigOneWire + DallasTemperatureDHT sensor library
UitleestijdDirect, continue uitgangTot 750 ms bij 12 bitsMaximaal 1 meting per seconde
Met ESP32 en PicoMet 5V-voeding; let op de ADC-beperkingenDirect op 3,3 VDirect op 3,3 V
Meerdere sensoren op één pinNee, elk een eigen analoge pinJaNee
Waterdichte uitvoeringNee, je moet hem zelf afdichtenSonde van roestvrij staalNee

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:

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

SymptoomWaarschijnlijke oorzaakOplossing
De sensor wordt te heet om aan te raken+Vs en GND zijn verwisseldHaal meteen de voeding eraf; met de platte kant naar je toe moet de volgorde +Vs, Vout, GND zijn
De waarde is altijd 0Er komt geen voeding bij de sensor, of Vout zit op een andere pin dan in de codeMeet met een multimeter 5 V tussen +Vs en GND en controleer of Vout naar A0 gaat
Waarden springen willekeurig rondA0 zweeft of het breadboardcontact is slechtVervang de jumperdraad en zet de sensor in een andere rij van het breadboard
De waarde wisselt in stappen van 0,5 °CResolutie van de 5V-referentieGebruik analogReference(INTERNAL) en middel de metingen
De waarde springt wanneer een relais of motor schakeltSpanningsval en ruis op de gedeelde massaLeid 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 temperatuurDe sensor zit naast de regelaar of de ESP32-moduleVerplaats de sensor met een kabel weg van het board
Andere analoge sensoren lezen 1023De INTERNAL-referentie beperkt elke analoge ingang tot 1,1 VLees de andere sensoren uit met de 5V-referentie of deel hun spanning
Onzinwaarden op de ESP32 in de kouDe ADC van de ESP32 kan onder 100 mV niet nauwkeurig metenGebruik onder 10 °C een DS18B20
Een eenvoudige manier om de nauwkeurigheid van je LM35 te controleren is hem een paar minuten naast een betrouwbare thermometer te leggen; is het verschil constant (bijvoorbeeld altijd 0,8 °C te hoog), trek het dan als offset af in je code. Meet je een oppervlak, lijm de sensor en zijn pootjes dan met een klein druppeltje epoxy op het oppervlak; volgens de fabrikant volgt de LM35 dan de oppervlaktetemperatuur heel nauwkeurig. Komt de sensor in een vloeistof, isoleer dan altijd zijn pootjes, want lekstroom tussen natte pootjes laat de metingen wegdrijven.

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.

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
Lichtsterkte meten met een LDR
AR-11Beginner

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.

4.6(83)
143
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

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.

4.6(36)
55
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

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…

4.5(33)
44
Digitale voltmeter met lcd-scherm
AR-56Gemiddeld
Premium

Digitale voltmeter met lcd-scherm

Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

4.5(27)
36
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

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.

4.8(38)
57
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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.

4.7(7)
12
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

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…

4.8(53)
70