Terwijl ik nog bezig was met de LED-strip-roulette, kreeg ik een idee voor een andere toepassing van deze universele verlichtingsarmaturen. Al snel ontstond er een thermometer uit een LED-strip van 1 m lang met 60 Neopixel-LED's. De opbouw is zo eenvoudig dat het project zeer geschikt is voor beginners op het gebied van microcontrollers – in het eenvoudigste geval zijn slechts vier onderdelen nodig. In deze nieuwe aflevering uit de serie laat ik u zien hoe u te werk moet gaan.
MicroPython op de ESP8266, ESP32 en Raspberry Pi Pico
vandaag
De LED-stripthermometer
Het programma voor de thermometer is natuurlijk geschreven in MicroPython en wel zo dat het zonder aanpassingen op alle in de titel genoemde controllers kan worden uitgevoerd. Met twee extra knoppen, die echter alleen nodig zijn voor het branden van de firmware, kan zelfs de kleinste vertegenwoordiger van de ESP8266-familie, de ESP8266-01S, dienen als besturingseenheid voor de LED-strip. Het besturingsprogramma voor de thermometer is afgestemd op deze controller met zijn twee GPIO-pinnen: GPIO0 stuurt de leds van de strip aan, terwijl GPIO2 de one-wire-busverbinding met de DS18B20 realiseert. Omdat het bord van de ESP8266-01S geen spanningsomvormer van 5V naar 3,3V bevat, hebben we hiervoor een externe schakeling nodig. Ook de aansluiting op de USB moet worden verzorgd door een externe USB-TTL-adapter. Hiermee is alle hardware al genoemd.
Hardware
| 1 | ESP32 Dev Kit C ongesoldeerd of ESP32 Dev Kit C V4 ongesoldeerd of ESP32 NodeMCU Module WLAN WiFi Development Board met CP2102 of ESP8266 01S esp-01S Wlan WiFi-module met breadboard-adapter of D1 Mini V3 NodeMCU met ESP8266-12F of NodeMCU Lua Lolin V3 Module ESP8266 ESP-12F WIFI Wifi Development Board met CH340 of NodeMCU Lua Amica Module V2 ESP8266 ESP-12F WIFI Wifi-ontwikkelingskaart met CP2102 of D1 Mini V4 NodeMCU ESP8266EX WLAN-module met USB-C-aansluiting compatibel met Arduino of |
| 1 | |
| 1 | DS18B20 digitale temperatuursensor TO92 of 1 m kabel DS18B20 digitale roestvrijstalen temperatuursensor |
| 1 | Weerstand 10 kΩ |
| 2 | Optioneel voor ESP8266-01S Toetsen bijvoorbeeld KY-004 drukknopmodule |
| 1 | bij gebruik van een ESP8266-01S |
| 1 | bij gebruik van een ESP8266-01S |
| 1 |
Zoals de onderstaande schakelschema's laten zien, is de opbouw het eenvoudigst te realiseren met een ESP32 of ESP8266. Voor de ESP8266-01S hebt u een converter van 5V naar 3,3V nodig en bovendien voor de Branden van de firmware twee knoppen, omdat het kleine bordje niet beschikt over een automatische brandfunctie, zoals zijn grote broers, en ook geen spanningsregelaar aan boord heeft. Daarvoor kan men de pull-upweerstand op de signaalkabel van de DS18B20 achterwege laten. Voor de aansluiting op de USB is bovendien een USB-naar-TTL-adapter nodig, die echter alleen tijdens de ontwikkelingsfase van het programma en daarna voor het branden van het besturingsprogramma ledstrip_thermo.py nodig is.
De LED-strip moet voor langdurig gebruik worden gevoed met 5 V uit een stekkernetvoeding. Het maximale stroomverbruik van de controller en de LED's bedraagt ongeveer 80 tot 120 mA. Sommige ESP8266-boards nemen weliswaar externe spanningen op via de Vin-aansluiting, maar geven de 5 V van de USB-aansluiting daar niet af. Bij de ESP32-boards en de Raspberry Pi Pico werkt dit wel. De ledstrip kan bij deze controllers dus rechtstreeks via de USB worden gevoed. Wie het afgewerkte apparaat onafhankelijk van de pc wil gebruiken, kan bijna niet zonder een voedingsadapter, tenzij men een Li-accu in combinatie met een geschikte batterijhouder gebruikt. Deze biedt bovendien 5 V en 3,3 V metelk 1 A belastbaarheid. Met één lading werkt het circuit ongeveer 24 uur.
Hier zijn nu de schakelschema's.
Afbeelding 1: LED-thermometer ESP8266 D1 mini
Afbeelding 2: LED-thermometer ESP32
Afbeelding 3: LED-thermometer ESP8266-01S
Afbeelding 4: LED-thermometer - Raspi Pi Pico
De schakelschema's weerspiegelen ook het type opbouw. De opbouw met de ESP8266-01S is enigszins chaotisch door de extra componenten. Door een batterijhouder met Li-accu te gebruiken, is het niet nodig om de spanningsregelaar van 5 V naar 3,3 V te gebruiken. Op alle ESP's staat de firmware 19.1.
Afbeelding 5: Opbouw met ESP8266-01S
Met een ESP8266 NodeMcu V3 ziet dat er heel overzichtelijk uit.
Afbeelding 6: Opbouw met ESP8266-NodeMcu V3
De software
Voor het flashen en programmeren van de ESP32:
Thonny of
Voor het weergeven van bussignalen
SALEAE – Logic Analyzer-software (64 bit) voor Windows 8, 10, 11
Gebruikte firmware voor de ESP32:
Gebruikte firmware voor de ESP8266:
ESP8266_GENERIC-FLASH_1M-20220618-v1.19.1.bin
Gebruikte firmware voor de Raspberry Pi Pico (W):
RPI_PICO_W-20240602-v1.23.0.uf2
De MicroPython-programma's voor het project:
ledstrip_thermo.py: bedieningsprogramma van de thermometer
MicroPython - Taal - Modules en programma's
Hier vindt u uitgebreide instructies voor de installatie van Thonny (Engelse versie). Daarin staat ook een beschrijving van hoe de Micropython-firmware (stand 25-01-2024) op de ESP-chip gebrand wordt. Hoe u de Raspberry Pi Pico gebruiksklaar krijgt, vindt u hier.
MicroPython is een interpretatietaal. Het belangrijkste verschil met de Arduino-IDE, waar u altijd en uitsluitend complete programma's flasht, is dat u de MicroPython-firmware slechts één keer aan het begin op de ESP32 hoeft te flashen, zodat de controller MicroPython-instructies begrijpt. Hiervoor kunt u Thonny, µPyCraft of esptool.py gebruiken. Voor Thonny heb ik het proces hier beschreven.
Zodra de firmware is geflashed, kunt u op een informele manier met uw controller communiceren, afzonderlijke commando's testen en direct het antwoord zien, zonder eerst een heel programma te hoeven compileren en over te dragen. Dat is precies wat me stoort aan de Arduino-IDE. Je bespaart gewoon enorm veel tijd als je eenvoudige tests van de syntaxis en de hardware, tot en met het uitproberen en verfijnen van functies en hele programmadelen, vooraf via de opdrachtregel kunt controleren, voordat je er een programma van maakt. Voor dit doel maak ik ook graag steeds weer kleine testprogramma's. Als een soort macro's bundelen ze terugkerende commando's. Uit dergelijke programmadelen ontstaan dan soms hele toepassingen.
Automatisch starten
Als het programma automatisch moet starten wanneer de controller wordt ingeschakeld, kopieert u de programmacode naar een nieuw aangemaakt leeg bestand. Sla dit bestand op onder main.py in de werkruimte en laad het naar de ESP-chip. Bij de volgende reset of inschakeling start het programma automatisch.
Programma's testen
Programma's worden handmatig gestart vanuit het huidige editorvenster in de Thonny-IDE met de F5-toets. Dat gaat sneller dan met de muis op de startknop klikken of via het menu Run. Alleen de modules die in het programma worden gebruikt, moeten zich in het flashgeheugen van de ESP32 bevinden.
Tussendoor weer eens Arduino-IDE?
Als u de controller later weer samen met de Arduino-IDE wilt gebruiken, flasht u het programma gewoon op de gebruikelijke manier. De ESP32/ESP8266 is dan echter vergeten dat hij ooit MicroPython heeft gesproken. Omgekeerd kan elke Espressif-chip die een gecompileerd programma uit de Arduino-IDE of de AT-firmware of LUA of ... bevat, zonder problemen worden voorzien van de MicroPython-firmware. De procedure is altijd zoals hier beschreven.
Het bedrijfsprogramma
Het programma is net zo overzichtelijk als de opbouw. Door Door GPIO2 te kiezen als One-Wire-bus-aansluiting en GPIO0 als stuurbus-leiding voor de Neopixel-strip, werkt het programma op alle bovengenoemde controllers zonder wijzigingen. De afzonderlijke functionele eenheden zijn gedefinieerd in de vorm van functies.
Voor de ESP8266-familie heb ik al vaak gemerkt dat de controller kort na het opstarten crasht. Dat lijkt te komen doordat hij via de wifi-unit contact probeert te maken met een toegangspunt. Als workaround schakel ik web-REPL direct na het flashen van nieuwe firmware uit. Dat heeft het opstartgedrag aanzienlijk gestabiliseerd.
De GPIO's bij de 8266's hebben ook de aanduidingen van LUA. Een vertaaltabel is in dit verband erg handig bij het programmeren, vooral met het oog op diverse spanningsniveaus die bij het opstarten moeten worden aangehouden, zodat het proces foutloos verloopt. Laten we nu de programmadelen en hun functie bespreken.
# ledstrip_thermo.py
# Na het flashen van de firmware op de ESP8266:
# import webrepl_setup
## > d voor uitschakelen
## Dan RST; herstart!
# Pintranslator voor ESP8266-boards
#LUA-pinnen D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
#ESP8266-pinnen 16 5 4 0 2 14 12 13 15 3 1
#Let op hi sc sd hi hi lo hi hi
# gebruikt DSLE-
van machine import Pin
uit time import sleep
van onewire import OneWire
van ds18x20 import DS18X20
van neopixel import NeoPixel
from sys import exit, platform
Bij het importeren gebruiken we alleen modules die vast in de MicroPython-kernel zijn ingebouwd. We willen GPIO-pinnen aanspreken, de controller tussendoor een beetje laten sluimeren, we hebben de One-Wire-Bus nodig voor de temperatuursensor DS18B20 en NeoPixel levert ons een array voor de kleurinformatie en de functie write(), waarmee we de bufferinhoud via de Neopixelbus versturen.
dsPin=Pin(2) # ESP8266 (D4)
ds = DS18X20(OneWire(dsPin))
device = ds.scan()[0]
ds.convert_temp()
sleep(0,750)
print(device,ds.read_temp(device))
GPIO2 wordt onze One-Wire-busverbinding. OneWire(dsPin) genereert het busobject dat we onmiddellijk doorgeven aan de constructor van de klasse DS18X20. De functie scan() van het DS18X20-object zoekt naar componenten op de bus en zal hopelijk de enige vinden, namelijk onze DS18B20. De ROM-identificatie van het bouwsteen is een bytearray-object met acht waarden, dat samen met eventuele andere identificaties in een lijst wordt gecoverd.
>>> ds.scan()
[bytearray(b'(\xffd\x0ei\x0f\x01>')]
Omdat we slechts één DS18B20 op de bus hebben, kiezen we het 0-de element uit de lijst.
>>> ds.scan()[0]
bytearray(b'(\xffd\x0ei\x0f\x01>')
De identificatiecode wordt gebruikt om de afzonderlijke chips op de bus afzonderlijk aan te spreken. convert_temp() geeft alle chips de opdracht om een meting te starten. Na minimaal 750 ms kunnen we het resultaat ophalen met behulp van de functie read_temp(). De betreffende identificatiecode van het onderdeel moet worden doorgegeven. We hebben deze opgeslagen in device.
led=Pin(0,Pin.OUT,value =0) # ESP8266 (D3)
numOfPix=60
# ESP8266 (D3) xml-ph-0000@deepl.internalnp=NeoPixel(led,numOfPix)
pos0 = 20
maxTemp=39
minTemp=-20
temp=[0 for i in range(60)]
We definiëren de Neopixel-busaansluiting GPIO0 als uitgang en stellen het niveau in op 0. De bus moet numOfPix = 60 leds bedienen. De constructor van de klasse NeoPixel genereert het object np. De led met nummer 20 geeft het nulpunt van de thermometerschaal aan. Onze schaal loopt dus van -20 °C (led nummer 0) tot 39 °C (led nummer 59). In de lijst temp genereren we met behulp van een lijstcomprehension 60 elementen, die in eerste instantie gewoon de waarde 0 hebben. De lijst zal later de kleurweergave van de schaal bevatten.
uit=(0,0,0)
groen=(0,64,0)
donkerblauw=(0,0,4)
lichtblauw=(0,0,128)
donkerrood=(4,0,0)
lichtrood=(128,0,0)
magenta =(2,0,2)
statered=0
stateblue=0
stategreen=0
De kleurwaarden voor de Neopixel-leds worden aangegeven doordrietallen. De drie waarden staan voor het aandeel rood, groen en blauw.
De LED's boven de huidige temperatuurweergave worden gewist (uit=(0,0,0)), het nulpunt wordt weergegeven door een heldergroene kleur. De tientallen in het positieve bereik lichten op in helderrood, in het negatieve bereik in helderblauw. De tussenliggende waarden worden donkerder weergegeven. Voor een betere oriëntatie laat ik de vijftallen in donkerder magenta oplichten. Bij temperaturen boven 40 °C moet de bovenste LED knipperen, bij temperaturen onder -20 °C knippert de onderste LED. Het nulpunt wordt altijd verlicht. Om -1 °C van 0 °C te kunnen onderscheiden, knippert in het laatste geval de nulgraden-LED. Voor de besturing van deze toestanden gebruik ik de drie statusvariabelen.
def setScale():
for i in bereik(20):
temp[i]=donkerblauw
for i in bereik(21,60):
temp[i]=donkerrood
for i in [0,10]:
temp[i]=lichtblauw
for i in [30,40,50]:
temp[i]=felrood
for i in range(5,60,10):
temp[i]=magenta
temp[20]=groen
De functie setScale() vult de lijst temp met de kleurwaarden. Het negatieve bereik wordt eerst volledig in donkerblauw gekleurd, het positieve in donkerrood. De bereikgrenzen en lijstwaarden bij de for-instructies zijn de plaatsnummers van de leds in de strip. De stappen van 10 worden vervolgens overschreven in lichtblauw en lichtrood. De stappen van 5, beginnend met LED-nummer 5, overschrijf ik in stappen van 10 tot nummer 55 in donker magenta. Plaats 20 zet ik ten slotte op groen.
def fillAndShow(temperatuur):
t=min(temperatuur,maxTemp)
t=max(minTemp,t)
maxpix = int(t) + pos0
for i in range(maxpix + 1):
np[i]=temp [i]
for i in bereik(maxpix + 1,numOfPix):
np[i]=uit
if t < 0:
np[pos0]=groen
np.schrijven()
De functie fillAndShow() is als het ware het kernpunt van het programma, de temperatuurweergave. Hierbij worden kleurwaarden uit de lijst temp naar het buffergeheugen np van het NeoPixel-object overgebracht.
Achtergrondinformatie:
Het buffergeheugen van het NeoPixel-object is eigenlijk een bytearray met de aanduiding buf. In ons geval kan het worden aangeduid met np.buf. De inhoud bestaat uit opeenvolgende groepen van drie voor elke LED. Wordt met np[2]=(1,2,3) de kleurwaarde voor LED nummer 2 als tuple doorgeeft, dan zet de verborgen functie __setitem__() de tuple om in een reeks bytes-objecten en schrijft de waarden naar de bytearray np.buf. Als we de inhoud van np.buf bekijken, zien we dat de volgorde van de bytes is gewijzigd.
>>> np[2]=(1,2,3)
>>> np.buf
bytearray(b'\x00\x00\x80\x00\x00\x04\x02\x01\x03\x00\x00\x04\x00\x00\x04 …
De RGB-waarden worden omgezet zoals gespecificeerd door het attribuut np.ORDER.
>>> np.ORDER
(1, 0, 2, 3)
Als we R=1, G=2 en B=3 doorgeven, komen de waarden als G, R, B in de buffer terecht. Met 3 zou een witwaarde worden doorgegeven, maar die wordt niet ondersteund door het gebruikte LED-type.
Maar laten we nu eens nader kijken naar de functie fillAndShow(). Bij het aanroepen wordt de parameter temperatuur doorgegeven met de huidige temperatuurwaarde, die binnen het toegestane bereik moet liggen, zodat het programma niet met een fout wordt afgebroken. t=min(temperatuur,maxTemp) zorgt ervoor dat t de maximaal weer te geven temperatuur niet overschrijdt. min() geeft het minimum van de doorgegeven waarden weer. t=max(minTemp,t) is verantwoordelijk voor het naleven van de ondergrens.
Nu moet het nummer van de led voor de temperatuur in t worden bepaald. We nemen het gehele deel van de temperatuurwaarde en stellen het nulpunt van de celsiusschaal in op positie 20 van de led-keten. < span lang="DE" style="font-size: 10.0pt; font-family: 'Courier New'; mso-fareast-font-family: 'Times New Roman'; color: black;">maxpix = int(t) + pos0
Vervolgens vullen we de buffer tot de berekende grens met de schaalinhoud.
for i in bereik(maxpix + 1):
np [i]=temp[i]
De rest van de leds erboven zetten we op uit=0,0,0.
for i in bereik(maxpix + 1,numOfPix):
np[i]=uit
Als de temperatuur onder nul ligt, zetten we nog het nulpunt aan. Vervolgens sturen we de inhoud van de buffer naar het display.
if t < 0:
np[pos0]=groen
np.schrijven()
We kunnen de hele ledstrip uitschakelen met de functie clearStrip(). We beschrijven de buffer met luide (0,0,0)-tuples.
def clearStrip():
for i in bereik(numOfPix):
np[i]=uit
[np.schrijf()
De drie knippergebeurtenissen voor te hoge en te lage temperaturen en 0 °C beheren we met behulp van de drie functies binkRed(), blinkBlue() en blinkGreen(). Ze hebben allemaal dezelfde structuur. We bekijken blinkRed() als voorbeeld eens nader.
def blinkRed():
global statered
if statered == 1:
np[numOfPix-1]=uit
np.schrijven()
statered = 0
else:
np[numOfPix-1]=donkerrood
np.schrijven()
statered = 1
De waarde van de variabele statered wordt in de procedure gewijzigd en moet bij de volgende aanroep weer beschikbaar zijn. Een manier om dat te bereiken is via globale variabelen. Zonder de globale declaratie zou de variabele bij het verlaten van de functie in het niets verdwijnen. Een andere manier om de variabele statisch te maken, zou het gebruik van een closure zijn. Volg de link als u hier meer over wilt weten. Voor beginners blijven we bij de eenvoudigere eerste oplossing.
Als statered gelijk is aan 1, moet de bovenste LED worden uitgeschakeld. numOfPix heeft de waarde 60. De bovenste LED heeft dus het nummer 59, omdat de nummering begint bij 0. We sturen de status (van alle!) LED's met np.write() naar de strip en zetten statered op 0.
Bij de volgende aanroep wordt de else-tak doorlopen. We stellen de inhoud voor de bovenste LED in op donkerrood, verzenden de buffer en wijzen statered de waarde 1 toe.
Op dezelfde manier behandelen we de onderste LED (nummer 0) en de nulpunts-LED op positie pos0 = 20.
def blinkBlue():
global stateblue
if stateblue == 1:
np[0]=uit
np.schrijf()
stateblue = 0
else:
np[0]=lichtblauw
np.schrijven()
stateblue = 1
def blinkGreen():
global stategreen
if stategreen == 1:
np[pos0]=uit
np.schrijf()
stategreen = 0
else:
:np[pos0]=groen
np.schrijven()
stategreen = 1
Door het gebruik van functies creëren we overzicht in het hoofdprogramma, dat daardoor slechts 15 regels omvat.
We genereren de thermometerschaal en wissen de leds, waarna we de hoofdlus betreden.
setScale()
clearStrip()
De meting van de huidige temperatuurwaarde wordt gestart. De controller mag een seconde lang schaapjes tellen en bepaalt vervolgens de gehele waarde van de ingelezen temperatuur door deze naar boven af te ronden.
while 1:
ds.convert_temp()
sleep(1)
t =int(ds.read_temp(device) + 0,5)
print(t,"C")
fillAndShow(t)
if t < minTemp:
blinkBlue()
if t > maxTemp:
blinkRed()
if t == 0:
blinkGreen()
We kunnen het printcommando in de productie verwijderen. fillAndShow() geeft de temperatuur weer op de strook, zoals hierboven beschreven. Met de if-constructies behandelen we de speciale gevallen.
Hier volgt de volledige lijst van het programma ledstrip_thermo.py:
# ledstrip_thermo.py
# Na het flashen van de firmware op de ESP8266:
# import webrepl_setup
## > d voor uitschakelen
## Dan RST; herstart!
# Pintranslator voor ESP8266-boards
#LUA-pinnen D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
#ESP8266-pinnen 16 5 4 0 2 14 12 13 153 1
#Achtung hi sc sd hihi lo hi hi
# gebruikt OLED DS LE
van machine import Pin
uit time import sleep
van onewire import OneWire
van ds18x20 import DS18X20
van neopixel import NeoPixel
from sys import exit, platform
toets=Pin(0,Pin.IN,Pin.PULL_UP)
dsPin=Pin(2) # ESP8266 (D4)
ds = DS18X20(OneWire(dsPin))
device = ds.scan()[0]ds.convert_temp()
sleep(0,750)
print(device,ds.read_temp(device))
led=Pin (0,Pin.OUT,waarde=0) # ESP8266 (D3)
numOfPix=60
# ESP8266 (D3) xml-ph-0000@deepl.internalnp=NeoPixel(led,numOfPix)
pos0 = 20
maxTemp=39
minTemp=-20
temp=[0 for i in range(60)]
uit=(0,0,0)
groen=(0,64,0)
donkerblauw=(0,0,4)
lichtblauw=(0,0,128)
donkerrood=(4,0,0)
lichtrood=(128,0,0 )
magenta=(2,0,2)
statered=0
stateblue=0
stategreen=0
def setScale():
for i in bereik(20):
temp[i]=donkerblauw
for i in bereik(21,60):
temp[i]=donkerrood
for i in [0,10]:
temp[i]=lichtblauw
for i in [30,40,50]:
temp[i]=felrood
for i in bereik(5 ,60,10):
temp[i]=magenta
temp[20]=groen
def fillAndShow(temperatuur):
t=min(temperatuur,maxTemp)
t=max(minTemp,t)
maxpix = int(t) + pos0
for i in bereik(maxpix + 1):
np[i]=temp[i]
for i in range(maxpix + 1,numOfPix):
np[i]=uit
if t < 0:
np [pos0]=groen
np.schrijven()
def clearStrip():
for i in bereik(numOfPix):
np[i]=uit
[np.schrijf()
def blinkRed():
global statered
if statered == 1:
np[numOfPix-1]=uit
np.schrijf()
statered = 0
else:
np [numOfPix-1]=donkerrood
np.schrijven()
statered = 1
def blinkBlue():
global stateblue
if stateblue == 1:
np[0]=uit
np.schrijf()
stateblue = 0
else:
np[0]=lichtblauw
np.schrijven()
stateblue = 1
def blinkGreen():
global stategreen
if stategreen == 1:
np[pos0]=uit
np.schrijf()
stategreen = 0
else:
np[pos0]=groen
np.schrijven()
stategreen = 1
setScale ()
clearStrip()
while 1:
ds.convert_temp()
sleep(1)
t=int(ds.read_temp(device) + 0,5)
print(t,"C")
fillAndShow(t)
if t < minTemp:
blinkBlue()
if t > maxTemp:
blinkRed()
if t == 0:
blinkGreen()
Om onafhankelijk te zijn van de pc en USB, kunnen we het programma onder de naam main.py uploaden naar het flashgeheugen van de controller. Nu volstaat een 5V-voeding om het programma bij de volgende herstart of na een reset automatisch te starten.
Zo ziet het spel rond het nulpunt er tijdens het gebruik uit.
Afbeelding 7: Thermometerweergave van -6 °C tot 2 °C
Vooruitzichten:
De kleurkeuze voor de leds laat ons een aantal mogelijkheden open. Zo zou je een tweede sensor voor de buitentemperatuur op de one-wire-bus kunnen aansluiten en de weergave om de vijf seconden kunnen omschakelen. Door andere kleuren voor de verschillende gebieden te gebruiken, kun je de buiten- en binnentemperatuur gemakkelijk van elkaar onderscheiden.
Door gebruik te maken van een SD-kaartlezer en een RTC kunnen de metingen tijdnauwkeurig worden vastgelegd voor latere evaluatie.
Als we gebruikmaken van de wifi-mogelijkheden van onze controllers, kunnen de meetgegevens ook gemakkelijk worden overgedragen naar een mobiele telefoon, tablet of server.
Veel plezier met verder onderzoek, knutselen en programmeren.
