Noch während der Arbeit am LED-Streifen-Roulette hatte ich die Idee für eine weitere Verwendung dieser universellen Beleuchtungskörper. Flugs entstand nun aus einem LED-Streifen von 1 m Länge mit 60 Neopixel-LEDs ein Thermometer. Der Aufbau ist derart einfach, dass das Projekt sehr gut für Einsteiger in die Microcontroller-Thematik geeignet ist – es werden im einfachsten Fall nur vier Teile benötigt. Das Vorgehen zeige ich Ihnen in dieser neuen Folge aus der Reihe
MicroPython auf dem ESP8266, ESP32 und Raspberry Pi Pico
heute
Das LED-Streifen-Thermometer
Das Programm für das Thermometer ist natürlich in MicroPython geschrieben und zwar so, dass es für alle in der Überschrift genannten Controller ohne Änderung lauffähig ist. Mit zusätzlichen zwei Tastern, die aber nur für das Brennen der Firmware gebraucht werden, kann sogar der kleinste Vertreter der ESP8266-Familie, der ESP8266-01S, als Steuereinheit für den LED-Streifen dienen. An diesem Controller mit seinen beiden herausgeführten GPIO-Pins ist das Betriebsprogramm für das Thermometer ausgerichtet – GPIO0 steuert die LEDs des Streifens an, während GPIO2 die One-Wire-Bus-Verbindung zum DS18B20 realisiert. Weil das Board des ESP8266-01S keinen Spannungswandler von 5V auf 3,3V enthält, brauchen wir dafür eine externe Schaltung. Auch der Anschluss an den USB muss durch einen externen USB-TTL-Adapter bereitgestellt werden. Damit ist die gesamte Hardware bereits aufgeführt.
Hardware
|
1 |
ESP32 Dev Kit C unverlötet oder ESP32 Dev Kit C V4 unverlötet oder ESP32 NodeMCU Module WLAN WiFi Development Board mit CP2102 oder NodeMCU-ESP-32S-Kit oder ESP8266 01S esp-01S Wlan WiFi module with breadboard adapter oder D1 Mini V3 NodeMCU mit ESP8266-12F oder NodeMCU Lua Lolin V3 Module ESP8266 ESP-12F WIFI Wifi Development Board mit CH340 oder NodeMCU Lua Amica Modul V2 ESP8266 ESP-12F WIFI Wifi Development Board mit CP2102 oder D1 Mini V4 NodeMCU ESP8266EX WLAN Modul mit USB-C Anschluss kompatibel mit Arduino oder |
|
1 |
|
|
1 |
DS18B20 digitaler Temperatursensor TO92 oder |
|
1 |
Widerstand 10kΩ |
|
2 |
Optional für ESP8266-01S Tasten zum Beispiel KY-004 Taster Modul |
|
1 |
bei Verwendung eines ESP8266-01S |
|
1 |
bei Verwendung eines ESP8266-01S |
|
1 |
Wie die nachfolgenden Schaltbilder zeigen, ist der Aufbau mit einem ESP32 oder ESP8266 am einfachsten zu bewerkstelligen. Beim ESP8266-01S brauchen Sie einen Converter von 5V auf 3,3V und außerdem zum Brennen der Firmware zwei Taster, weil das kleine Board weder über eine Brennautomatik verfügt, wie die großen Brüder und auch keinen Spannungsregler an Bord hat. Dafür kann man sich den Pullupwiderstand an der Signalleitung des DS18B20 sparen. Für den Anschluss an den USB ist ferner ein USB-zu-TTL–Adapter erforderlich, den man aber nur während der Entwicklungszeit des Programms und danach zum Brennen des Betriebsprogramms ledstrip_thermo.py braucht.
Die Spannungsversorgung des LED-Streifens sollte für den Langzeitbetrieb mit 5V aus einem Steckernetzteil erfolgen, die maximale Stromaufnahme von Controller und LEDs liegt bei ca. 80 bis 120 mA. Einige der ESP8266-Boards nehmen über den Anschluss Vin zwar externe Spannungen an, geben aber die 5V vom USB-Anschluss dort nicht ab. Bei den ESP32-Boards und dem Raspberry Pi Pico klappt das schon. Der LED-Streifen kann bei diesen Controllern also direkt aus dem USB erfolgen. Wer das fertige Gerät unabhängig vom PC betreiben möchte, kommt um den Einsatz eines Netzteils kaum herum, außer man bedient sich eines Li-Akkus in Verbindung mit einem passenden Batteriehalter. Der bietet außerdem 5V und 3,3V mit je 1A Belastbarkeit. Mit einer Ladung läuft die Schaltung ca. 24 Stunden.
Hier kommen jetzt die Schaltbilder.
Abbildung 1: LED-Thermometer-ESP8266 D1 mini
Abbildung 2: LED-Thermometer-ESP32
Abbildung 3: LED-Thermometer-ESP8266-01S
Abbildung 4: LED-Thermometer- Raspi Pi Pico
Die Schaltbilder spiegeln auch die Art des Aufbaus wider. Etwas chaotisch ist der Aufbau mit dem ESP8266-01S durch die zusätzlichen Bauteile. Die Verwendung eines Batteriehalters mit Li-Akku erspart den Einsatz des Spannungsreglers von 5V auf 3,3V. Auf allen ESPs befindet sich die Firmware 19.1.
Abbildung 5: Aufbau mit ESP8266-01S
Sehr übersichtlich sieht das mit einem ESP8266 NodeMcu V3 aus.
Abbildung 6: Aufbau mit ESP8266-NodeMcu V3
Die Software
Fürs Flashen und die Programmierung des ESP32:
Thonny oder
Zum Darstellen von Bussignalen
SALEAE – Logic-Analyzer-Software (64 Bit) für Windows 8, 10, 11
Verwendete Firmware für den ESP32:
Verwendete Firmware für den ESP8266:
ESP8266_GENERIC-FLASH_1M-20220618-v1.19.1.bin
Verwendete Firmware für den Raspberry Pi Pico (W):
RPI_PICO_W-20240602-v1.23.0.uf2
Die MicroPython-Programme zum Projekt:
ledstrip_thermo.py: Betriebsprogramm des Thermometers
MicroPython - Sprache - Module und Programme
Zur Installation von Thonny finden Sie hier eine ausführliche Anleitung (english version). Darin gibt es auch eine Beschreibung, wie die Micropython-Firmware (Stand 25.01.2024) auf den ESP-Chip gebrannt wird. Wie Sie den Raspberry Pi Pico einsatzbereit kriegen, finden Sie hier.
MicroPython ist eine Interpretersprache. Der Hauptunterschied zur Arduino-IDE, wo Sie stets und ausschließlich ganze Programme flashen, ist der, dass Sie die MicroPython-Firmware nur einmal zu Beginn auf den ESP32 flashen müssen, damit der Controller MicroPython-Anweisungen versteht. Sie können dazu Thonny, µPyCraft oder esptool.py benutzen. Für Thonny habe ich den Vorgang hier beschrieben.
Sobald die Firmware geflasht ist, können Sie sich zwanglos mit Ihrem Controller im Zwiegespräch unterhalten, einzelne Befehle testen und sofort die Antwort sehen, ohne vorher ein ganzes Programm kompilieren und übertragen zu müssen. Genau das stört mich nämlich an der Arduino-IDE. Man spart einfach enorm Zeit, wenn man einfache Tests der Syntax und der Hardware bis hin zum Ausprobieren und Verfeinern von Funktionen und ganzen Programmteilen über die Kommandozeile vorab prüfen kann, bevor man ein Programm daraus strickt. Zu diesem Zweck erstelle ich auch gerne immer wieder kleine Testprogramme. Als eine Art Makro fassen sie wiederkehrende Befehle zusammen. Aus solchen Programmfragmenten entwickeln sich dann mitunter ganze Anwendungen.
Autostart
Soll das Programm autonom mit dem Einschalten des Controllers starten, kopieren Sie den Programmtext in eine neu angelegte Blankodatei. Speichern Sie diese Datei unter main.py im Workspace ab und laden Sie sie zum ESP-Chip hoch. Beim nächsten Reset oder Einschalten startet das Programm automatisch.
Programme testen
Manuell werden Programme aus dem aktuellen Editorfenster in der Thonny-IDE über die Taste F5 gestartet. Das geht schneller als der Mausklick auf den Startbutton, oder über das Menü Run. Lediglich die im Programm verwendeten Module müssen sich im Flash des ESP32 befinden.
Zwischendurch doch mal wieder Arduino-IDE?
Sollten Sie den Controller später wieder zusammen mit der Arduino-IDE verwenden wollen, flashen Sie das Programm einfach in gewohnter Weise. Allerdings hat der ESP32/ESP8266 dann vergessen, dass er jemals MicroPython gesprochen hat. Umgekehrt kann jeder Espressif-Chip, der ein kompiliertes Programm aus der Arduino-IDE oder die AT-Firmware oder LUA oder … enthält, problemlos mit der MicroPython-Firmware versehen werden. Der Vorgang ist immer so, wie hier beschrieben.
Das Betriebsprogramm
Ähnlich übersichtlich wie die Aufbauten gestaltet sich das Programm. Durch die Wahl von GPIO2 als One-Wire-Bus-Anschluss und GPIO0 als Steuerbus-Leitung für den Neopixelstreifen läuft das Programm auf allen oben genannten Controllern ohne Änderung. Die einzelnen Funktionseinheiten sind in Form von Funktionen definiert.
Für die ESP8266-Familie habe ich schon des Öfteren festgestellt, dass der Controller kurz nach dem Start abstürzt. Das scheint daran zu liegen, dass der versucht, über die WLAN-Einheit einen Kontakt zu einem Accesspoint aufzubauen. Als Workaround schalte ich gleich nach dem Flashen einer neuen Firmware web-REPL aus. Das hat das Startverhalten deutlich stabilisiert.
Die GPIOs bei den 8266-ern haben auch die Bezeichnungen von LUA. Eine Übersetzungstabelle ist in diesem Zusammenhang beim Programmieren ganz nützlich, vor allem im Hinblick auf diverse Spannungspegel, die beim Booten eingehalten werden müssen, damit der Vorgang fehlerfrei abläuft. Besprechen wir jetzt die Programmteile und deren Funktion.
# ledstrip_thermo.py
# Nach dem Flashen der Firmware auf dem ESP8266:
# import webrepl_setup
# > d fuer disable
# Dann RST; Neustart!
# Pintranslator fuer ESP8266-Boards
#LUA-Pins D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
#ESP8266 Pins 16 5 4 0 2 14 12 13 15 3 1
#Achtung hi sc sd hi hi lo hi hi
# used DS LE
from machine import Pin
from time import sleep
from onewire import OneWire
from ds18x20 import DS18X20
from neopixel import NeoPixel
from sys import exit, platform
Beim Importgeschäft greifen wir nur auf Module zurück, die fest im MicroPython-Kernel eingebaut sind. Wir wollen GPIO-Pins ansprechen, zwischendrin den Controller ein wenig schlummern lassen, den One-Wire-Bus brauchen wir für den Temperatursensor DS18B20 und NeoPixel liefert uns ein Array für die Farbinformationen sowie die Funktion write(), mit der wir den Pufferinhalt über den Neopixelbus schicken.
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 wird unser One-Wire-Bus-Anschluss. OneWire(dsPin) Erzugt das Bus-Objekt, das wir sofort an den Konstruktor der Klasse DS18X20 übergeben. Die Funktion scan() des DS18X20-Objekts sucht nach Bausteinen am Bus und wird hoffentlich den einen, nämlich unseren DS18B20, finden. Die ROM-Kennung des Bausteins ist ein bytearray-Objekt mit acht Werten, das zusammen mit eventuellen weiteren Kennungen in einer Liste gecovert wird.
>>> ds.scan()
[bytearray(b'(\xffd\x0ei\x0f\x01>')]
Weil wir nur einen DS18B20 am Bus haben, picken wir das 0-te Element aus der Liste heraus.
>>> ds.scan()[0]
bytearray(b'(\xffd\x0ei\x0f\x01>')
Die Kennung wird gebraucht, um die einzelnen Chips am Bus getrennt anzusprechen. convert_temp() weist alle Chips an, eine Messung zu starten. Nach mindestens 750ms können wir das Ergebnis mit Hilfe der Funktion read_temp() abholen. Zu übergeben ist die jeweilige Kennung des Bausteins. Wir haben sie uns in device gemerkt.
led=Pin(0,Pin.OUT,value=0) # ESP8266 (D3)
numOfPix=60
np=NeoPixel(led,numOfPix)
pos0 = 20
maxTemp=39
minTemp=-20
temp=[0 for i in range(60)]
Den Neopixel-Bus-Anschluss GPIO0 definieren wir als Ausgang und legen den Pegel auf 0. Der Bus soll numOfPix = 60 LEDs bedienen. Der Konstruktor der Klasse NeoPixel erzeugt uns das Objekt np. Die LED mit der Nummer 20 zeigt uns den Nullpunkt der Thermometer-Skala an. Unsere Skala reicht somit von -20°C (LED Nummer 0) bis 39°C (LED Nummer 59. In der Liste temp erzeugen wir mit Hilfe einer List-Komprehension 60 Elemente, die zunächst einfach den Wert 0 haben. Die Liste wird später die Farbdarstellung der Skala aufnehmen.
aus=(0,0,0)
gruen=(0,64,0)
dunkelblau=(0,0,4)
hellblau=(0,0,128)
dunkelrot=(4,0,0)
hellrot=(128,0,0)
magenta=(2,0,2)
statered=0
stateblue=0
stategreen=0
Die Farbwerte für die Neopixel-LEDs werden durch Dreier-Tupel angegeben. Die drei Werte stehen für Rot-, Grün- und Blau-Anteil.
Die LEDs oberhalb der aktuellen Temperaturanzeige werden gelöscht (aus=(0,0,0)), der Nullpunkt wird durch ein helles Grün dargestellt. Die Zehnerstufen im positiven Bereich leuchten in Hellem Rot, im negativen Bereich in hellem Blau. Die Zwischenwerte werden dunkler dargestellt. Die Fünfer lasse ich zur leichteren Orientierung in dunklerem Magenta leuchten. Bei Temperaturen über 40°C soll die oberste LED blinken, bei unter -20°C blinkt die unterste LED. Der Nullpunkt wird immer erleuchtet. Um -1°C von 0°C unterscheiden zu können, blinkt in letzterem Fall die Null-Grad-LED. Für die Steuerung dieser Zustände setze ich die drei State-Variablen ein.
def setScale():
for i in range(20):
temp[i]=dunkelblau
for i in range(21,60):
temp[i]=dunkelrot
for i in [0,10]:
temp[i]=hellblau
for i in [30,40,50]:
temp[i]=hellrot
for i in range(5,60,10):
temp[i]=magenta
temp[20]=gruen
Die Funktion setScale() füllt die Liste temp mit den Farbwerten. Der negative Bereich wird zunächst durchgehend in Dunkelblau, der positive in Dunkelrot eingefärbt. Die Bereichsgrenzen und Listenwerte bei den for-Anweisungen sind die Platznummern der LEDs in dem Streifen. In Hellblau und Hellrot werden danach die 10-er-Stufen überschrieben. Die Fünferstufen beginnend mit der LED Nummer 5 überschreibe ich in Zehnerschritten bis zur Nummer 55 in dunklem Magenta. Platz 20 setze ich abschließend auf Grün.
def fillAndShow(temperatur):
t=min(temperatur,maxTemp)
t=max(minTemp,t)
maxpix = int(t) + pos0
for i in range(maxpix + 1):
np[i]=temp[i]
for i in range(maxpix + 1,numOfPix):
np[i]=aus
if t < 0:
np[pos0]=gruen
np.write()
Die Funktion fillAndShow() ist quasi der Kernpunkt des Programms, die Temperaturanzeige. Dabei werden Farbwerte aus der Liste temp in den Pufferspeicher np des NeoPixel-Objekts übertragen.
Hintergrund-Info:
Der Pufferspeicher des NeoPixel-Objekts ist eigentlich ein bytearray mit dem Bezeichner buf. In unserem Fall kann es mit np.buf referenziert werden. Der Inhalt besteht aus fortlaufenden Dreiergruppen für jede LED. Wird mit np[2]=(1,2,3) der Farbwert für LED Nummer 2 als Tupel übergeben, dann wandelt die verborgene Funktion __setitem__() das Tupel in eine Folge von bytes-Objekten um und schreibt die Werte in das bytearray np.buf. Wenn wir uns den Inhalt von np.buf anschauen, stellen wir fest, dass die Reihenfolge der Bytes verändert wurde.
>>> np[2]=(1,2,3)
>>> np.buf
bytearray(b'\x00\x00\x80\x00\x00\x04\x02\x01\x03\x00\x00\x04\x00\x00\x04 …
Die RGB-Werte werden so umgesetzt, wie es das Attribut np.ORDER vorgibt.
>>> np.ORDER
(1, 0, 2, 3)
Wenn wir R=1, G=2 und B=3 übergeben, landen die Werte als G, R, B im Buffer. Mit 3 würde ein Weiß-Wert übergeben der aber beim verwendeten LED-Typ nicht unterstützt wird.
Aber schauen wir uns jetzt die Funktion fillAndShow() näher an. Dem Parameter temperatur wird beim Aufruf der aktuelle Temperaturwert übergeben, der im zulässigen Fenster liegen muss, damit das Programm nicht mit einem Fehler abgebrochen wird. t=min(temperatur,maxTemp) sorgt dafür, dass t die maximal anzeigbare Temperatur nicht überschreitet. min() gibt das Minimum der übergebenen Werte zurück. t=max(minTemp,t) ist zuständig für die Einhaltung der unteren Grenze.
Jetzt muss die Nummer der LED für die Temperatur in t ermittelt werden. Wir nehmen den ganzzahligen Anteil des Temperaturwerts und nivellieren den Nullpunkt der Celsiusskala auf die Position 20 der LED-Kette. maxpix = int(t) + pos0
Dann füllen wir den Buffer bis zur berechneten Grenze mit den Skaleninhalten.
for i in range(maxpix + 1):
np[i]=temp[i]
Den darüberliegenden Rest der LEDs setzen wir auf aus=0,0,0.
for i in range(maxpix + 1,numOfPix):
np[i]=aus
Liegt die Temperatur im negativen Bereich, machen wir noch den Nullpunkt an. Dann schicken wir den Bufferinhalt zum Display.
if t < 0:
np[pos0]=gruen
np.write()
Den gesamten LED-Streifen können wir mit der Funktion clearStrip() ausschalten. Den Buffer beschreiben wir mit lauter (0,0,0)-Tupeln.
def clearStrip():
for i in range(numOfPix):
np[i]=aus
np.write()
Die drei Blink-Events für Über- und Unter-Temperatur sowie 0°C managen wir mit Hilfe der drei Funktionen binkRed(), blinkBlue() und blinkGreen(). Sie haben alle den gleichen Aufbau. Wir schauen uns stellvertretend blinkRed() genauer an.
def blinkRed():
global statered
if statered == 1:
np[numOfPix-1]=aus
np.write()
statered = 0
else:
np[numOfPix-1]=dunkelrot
np.write()
statered = 1
Der Wert der Variablen statered wird in der Prozedur verändert und muss beim nächsten Aufruf wieder verfügbar sein. Ein Weg, das zu erreichen, führt über globale Variablen. Ohne die global-Deklaration würde sich die Variable beim Verlassen der Funktion ins Nirwana verabschieden. Ein weiterer Weg, die Variable statisch zu machen, wäre der Einsatz einer Closure. Folgen Sie dem Link, wenn Sie mehr darüber erfahren wollen. Für Einsteiger bleiben wir bei der einfacheren ersten Lösung.
Falls statered gleich 1 ist, ist die oberste LED auszuschalten. numOfPix hat den Wert 60. Die oberste LED hat somit die Nummer 59, weil die Nummerierung bei 0 beginnt. Wir schicken den Zustand (aller!) LEDs mit np.write() zum Streifen und setzen statered auf 0.
Beim nächsten Aufruf wird der else-Zweig durchlaufen. Wir setzen den Inhalt für die oberste LED auf dunkelrot, senden den Buffer und belegen statered mit 1.
Analog behandeln wir die unterste LED (Nummer 0) und die Nullpunk-LED auf Position pos0 = 20.
def blinkBlue():
global stateblue
if stateblue == 1:
np[0]=aus
np.write()
stateblue = 0
else:
np[0]=hellblau
np.write()
stateblue = 1
def blinkGreen():
global stategreen
if stategreen == 1:
np[pos0]=aus
np.write()
stategreen = 0
else:
np[pos0]=gruen
np.write()
stategreen = 1
Durch den Einsatz von Funktionen schaffen wir Übersicht im Hauptprogramm, das somit grade mal 15 Zeilen umfasst.
Wir erzeugen die Thermometerskala und löschen die LEDs, dann betreten wir die Hauptschleife.
setScale()
clearStrip()
Die Messung des aktuellen Temperaturwerts wird angestoßen. Der Controller darf eine Sekunde lang Schäfchen zählen und bestimmt dann den ganzzahligen Wert der eingelesenen Temperatur mit Aufrunden.
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()
Den Print-Befehl können wir im Produktionsbetrieb löschen. fillAndShow() zeigt die Temperatur, wie oben beschrieben, am Streifen an. Mit den if-Konstrukten behandeln wir die Sonderfälle.
Hier kommt das komplette Listing des Programms ledstrip_thermo.py:
# ledstrip_thermo.py
# Nach dem Flashen der Firmware auf dem ESP8266:
# import webrepl_setup
# > d fuer disable
# Dann RST; Neustart!
# Pintranslator fuer ESP8266-Boards
#LUA-Pins D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
#ESP8266 Pins 16 5 4 0 2 14 12 13 15 3 1
#Achtung hi sc sd hi hi lo hi hi
# used OLED DS LE
from machine import Pin
from time import sleep
from onewire import OneWire
from ds18x20 import DS18X20
from neopixel import NeoPixel
from sys import exit, platform
taste=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,value=0) # ESP8266 (D3)
numOfPix=60
np=NeoPixel(led,numOfPix)
pos0 = 20
maxTemp=39
minTemp=-20
temp=[0 for i in range(60)]
aus=(0,0,0)
gruen=(0,64,0)
dunkelblau=(0,0,4)
hellblau=(0,0,128)
dunkelrot=(4,0,0)
hellrot=(128,0,0)
magenta=(2,0,2)
statered=0
stateblue=0
stategreen=0
def setScale():
for i in range(20):
temp[i]=dunkelblau
for i in range(21,60):
temp[i]=dunkelrot
for i in [0,10]:
temp[i]=hellblau
for i in [30,40,50]:
temp[i]=hellrot
for i in range(5,60,10):
temp[i]=magenta
temp[20]=gruen
def fillAndShow(temperatur):
t=min(temperatur,maxTemp)
t=max(minTemp,t)
maxpix = int(t) + pos0
for i in range(maxpix + 1):
np[i]=temp[i]
for i in range(maxpix + 1,numOfPix):
np[i]=aus
if t < 0:
np[pos0]=gruen
np.write()
def clearStrip():
for i in range(numOfPix):
np[i]=aus
np.write()
def blinkRed():
global statered
if statered == 1:
np[numOfPix-1]=aus
np.write()
statered = 0
else:
np[numOfPix-1]=dunkelrot
np.write()
statered = 1
def blinkBlue():
global stateblue
if stateblue == 1:
np[0]=aus
np.write()
stateblue = 0
else:
np[0]=hellblau
np.write()
stateblue = 1
def blinkGreen():
global stategreen
if stategreen == 1:
np[pos0]=aus
np.write()
stategreen = 0
else:
np[pos0]=gruen
np.write()
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()
Um vom PC und USB unabhängig zu sein, können wir das Programm unter dem Namen main.py in den Flash des Controllers hochladen. Jetzt reicht eine 5V-Versorgung, damit beim nächsten Neustart oder nach einem Reset das Programm automatisch gestartet wird.
So sieht die Partie um die Nullmarke im Betrieb aus.
Abbildung 7: Thermometeranzeige von -6°C bis 2°C
Ausblick:
Die Farbwahl für die LEDs lässt uns einige Dinge offen. So könnte man an den One-Wire-Bus einen zweiten Sensor für die Außentemperatur anschließen und die Anzeige alle fünf Sekunden umschalten. Durch andere Farben für die Bereiche kann man Außen- und Innentemperatur problemlos unterscheiden.
Durch den Einsatz eines SD-Card-Readers und einer RTC lassen sich die Messungen zeitgenau für die spätere Auswertung festhalten.
Wenn wir die WLAN-Fähigkeit unserer Controller nutzen, lassen sich die Messdaten auch gut aufs Handy oder Tablet oder zu einem Server übertragen.
Viel Freude am weiteren Forschen, Basteln und Programmieren.
