Last Seen Blogs
Text
Calliope Mini 3 Tutorial: JacDac Sensoren und Aktoren - Ein praktischer Workshop für Anfänger
In diesem neuen Beitrag präsentiere ich dir die Calliope Mini Startbox mit JacDac Sensoren & Aktoren. In dieser Box findest du alles, was du für spannende Projekte am Calliope Mini 3 benötigst, ausgenommen den Mikrocontroller! Du bekommst diese im offiziellen Shop unter Jacdac Erweiterungen StartKit A für derzeit 49,95 € zzgl. Versandkosten.
https://youtu.be/CD8PCHjmaRE
Disclaimer: Die in diesem Tutorial verwendete Calliope Mini 3 Startbox mit JacDac Sensoren und -Aktoren wurde mir freundlicherweise von der Firma Calliope gesponsert. Trotz dieser Unterstützung bleibt meine Meinung zu den Produkten und den hier vorgestellten Inhalten unabhängig und basiert auf meinen eigenen Erfahrungen und Einschätzungen.
Für diesen Beitrag benötigst du den neuen Mikrocontroller, da die Vorgängermodelle über keine JacDac Schnittstelle verfügen.
Calliope Mini 1.3 & Calliope Mini 3
Was ist die JacDac Schnittstelle und wie funktioniert diese?
Die JacDac-Schnittstelle ist so konzipiert, dass sie eine nahtlose Integration von Sensoren und Aktoren mit dem Calliope Mini 3 ermöglicht. Die Magie liegt darin, dass die Geräte automatisch erkannt werden, ohne dass du komplizierte Konfigurationen durchführen musst.
Chip mit Informationen zum Sensor auf einem Magnset Sensor mit JacDac Schnittstelle
Dies geschieht, weil die JacDac-Schnittstelle ein standardisiertes Protokoll verwendet, das es den Sensoren und Aktoren ermöglicht, sich selbst zu identifizieren, sobald sie an den Calliope Mini 3 angeschlossen werden. Jeder Sensor und Aktor verfügt über einen eingebauten Chip, der dem Calliope Mini 3 mitteilt, welche Art von Gerät angeschlossen ist und welche Funktionen es bietet.
Durch diese automatische Erkennung wird die Verwendung von Sensoren und Aktoren deutlich vereinfacht, insbesondere für Anfänger. Du musst dir keine Gedanken über komplizierte Konfigurationen oder Treiberinstallationen machen. Stattdessen kannst du dich darauf konzentrieren, deine Ideen in die Tat umzusetzen und kreative Projekte zu realisieren.
Was ist in der Startbox A enthalten?
In dieser Startbox A findest du nachfolgende Sensoren & Aktoren:
- zwei Taster,
- einen Drehregler,
- einen Schieberegler,
- ein RGB-Ring,
- ein Magnetsensor,
- ein Lichtsensor,
- ein Hub,
- Kabel in diversen Längen
Du benötigst quasi nur noch einen Calliope Mini 3 und einen PC zum Loslegen.
Erster Schritt - Upload eines leeren Programmes mit dem JacDac Service
Bevor wir in MakeCode mit den JacDac Sensoren arbeiten können, müssen wir zunächst ein leeres Programm mit dem JacDac Service auf den Calliope Mini 3 hochladen.
Dazu wird der Mikrocontroller via USB an den Computer angeschlossen und im Browser (Google Chrome) gekoppelt. In MakeCode navigieren wir zu den Erweiterungen (1) und suchen dort nach "jacdac" (2). Aus den Suchergebnissen wählen wir nun den JacDac Client (3) aus. Wenn diese Erweiterung hinzugefügt wurde, dann sollten wir den Eintrag Module (4) sehen.
Dieses leere Programm müssen wir jetzt auf den Calliope hochladen und können danach JacDac Sensoren & Aktoren anschließen.
Aufbau einer kleinen Schaltung mit JacDac am Calliope Mini 3
Kommen wir jetzt zum interessanten Teil des Beitrages und bauen eine kleine Schaltung am Calliope Mini 3 auf.
Taster via JacDac am Calliope Mini 3 anschließen und programmieren in MakeCode
Im ersten Schritt möchte ich den mechanischen Taster nutzen, um am Calliope Mini die 3 RGB LEDs durchzuschalten. Der Calliope hat zwar zwei Taster und somit müsste man keinen zusätzlichen verwenden, jedoch bietet sich dieses kleine Beispiel als Einstieg an, da man hier bereits bekanntes auf den Taster anwenden kann.
Der Taster verfügt über zwei JacDac Schnittstellen, somit können wir diesen nicht nur mit dem Calliope verbinden, sondern an diesen noch weitere Sensoren / Aktoren anschließen.
Dem Set liegen Kabel in verschiedene Längen bei und damit verbinden wir jetzt den Taster mit dem Calliope.
Calliope Mini 3 mit Taster über JacDac Schnittstelle verbunden
Sobald wir den Taster an den Calliope angeschlossen haben, wird dieser in MakeCode angezeigt.
Um jetzt die passenden Blöcke zum Auswerten der Aktion am Taster zu erhalten, müssen wir noch auf die Schaltfläche "ADD BLOCKS" klicken.
Unter dem Menüpunkt Module findest du jetzt den Knopf bzw. den Taster mit seinen Blöcken.
Den Block "wenn knopfX..." kennst du sicherlich schon von den Tastern des Calliope jedoch hat dieser drei Status, unten, gedrückt und halten.
Das kleine Programm zum Steuern der RGB LED Leiste am Calliope Mini 3 sieht wie folgt aus:
Im oben verlinkten YouTube Video zeige ich dir noch eine weitere Schaltung mit dem 8bit RGB LED Ring und dem Schieberegler.
Fazit zur Startbox A mit JacDac Sensoren & Aktoren für den Calliope Mini 3
Die Startbox enthält vieles, was du für einen Einstieg in die Erstellung von kleinen Projekten mit JacDac Sensoren & Aktoren benötigst. Besonders in Verbindung mit MakeCode und dem Calliope Mini 3 ist es sehr einfach für Anfänger diese Komponenten zu programmieren.
Da die JacDac Schnittstelle nicht speziell für den Calliope Mini 3 entwickelt wurde, kannst du dieses Set auch nutzen um mit anderen Mikrocontroller wie den BBC micro:bit oder einen speziellen RP2040 Mikrocontroller zu programmieren. Das Set kostet bei Calliope im Shop der Zeit knapp 50 € jedoch ist dieses vergleichsweise mit anderen Shops sehr günstig und somit ist dieses Angebot ggf. auch für andere Mikrocontroller interessant.
Read the full article
0 notes
Text
Raspberry Pi Projekt: Prozessinformationen auf OLED Display anzeigen
Wie du am Raspberry Pi ein OLED Display anschließt und programmierst, habe ich dir bereits gezeigt. Im heutigen Beitrag soll es darum gehen wie du Prozessinformationen auf dem OLED Display visualisierst. Es ist hier empfehlenswert ein großes Display zu verwenden, da die Daten, welche angezeigt werden sollen, doch recht umfangreich sind (oder man muss Abstriche bei den Daten machen).
https://youtu.be/nOQnx6_ekVE
Für diesen Beitrag verwende ich den Raspberry Pi Zero 2 WH, da mein eigentlich für solche Beiträge verwendete Raspberry Pi 3b+ nun in ein RetroPi verwandelt wurde. Jedoch steht der kleine Pi Zero 2 dem großen in nichts nach und kann für solche Projekte ebenso verwendet werden und du kannst dieses auch auf dein Pi nachbauen.
Acrylgehäuse für den Raspberry Pi Zero
Splashscreen des Python Projektes - "pyTop Screen"
Daten aktuellen Prozessen auf dem OLED-Display
Die Idee zu diesem Beitrag kommt aus einem Kommentar zu meinem YouTube-Video OLED Display am Raspberry Pi anschließen und per I2C steuern: So geht’s!. Ich bin immer froh, wenn solch Input aus meiner Community kommt und ich damit euch helfen kann und ich ebenso neuen Content generieren kann.
Benötigte Ressourcen für dieses Projekt
Wenn du dieses kleine Projekt nachbauen möchtest, dann benötigst du:
- einen Raspberry Pi* inkl. Netzteil, SD-Karte etc.,
- ein OLED Display mit I2C Anschluss*,
- ein paar Breadboardkabel*,
- ein 400 Pin Breadboard*
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Was soll dargestellt werden?
Auf dem Display möchte ich die laufenden Prozesse darstellen, diese kann man sich recht einfach über den Befehl top anzeigen lassen.
pi@raspberrypi:~ $ top
top - 10:27:00 up 1:27, 1 user, load average: 0,07, 0,06, 0,09
Tasks: 194 total, 1 running, 193 sleeping, 0 stopped, 0 zombie
%CPU(s): 0,5 us, 0,6 sy, 0,0 ni, 98,8 id, 0,1 wa, 0,0 hi, 0,0 si, 0,0 st
MiB Spch: 426,7 total, 102,6 free, 132,7 used, 191,5 buff/cache
MiB Swap: 100,0 total, 7,6 free, 92,4 used. 229,0 avail Spch
PID USER PR NI VIRT RES SHR S %CPU %MEM ZEIT+ BEFEHL
17628 mysql 20 0 614080 67592 9212 S 1,3 15,5 3:49.26 mariadbd
22393 pi 20 0 11476 3204 2612 R 1,3 0,7 0:01.13 top
839 zabbix 20 0 128416 3552 2988 S 0,3 0,8 0:01.97 zabbix_server
857 zabbix 20 0 132984 2092 1808 S 0,3 0,5 0:00.36 zabbix_server
1 root 20 0 34948 5260 3568 S 0,0 1,2 0:28.14 systemd
2 root 20 0 0 0 0 S 0,0 0,0 0:00.03 kthreadd
3 root 0 -20 0 0 0 I 0,0 0,0 0:00.00 rcu_gp
4 root 0 -20 0 0 0 I 0,0 0,0 0:00.00 rcu_par_gp
5 root 0 -20 0 0 0 I 0,0 0,0 0:00.00 slub_flushwq
6 root 0 -20 0 0 0 I 0,0 0,0 0:00.00 netns
10 root 0 -20 0 0 0 I 0,0 0,0 0:00.00 mm_percpu_wq
Jedoch interessieren mich hier nur die Werte, PID, %CPU, %MEM sowie der BEFEHL.
Da wir diese Daten in Python weiterverarbeiten möchten, exportieren wir diese Daten mit einem Befehl in eine Semikolonseparierte CSV-Datei. (Das Komma wird in den Daten für die Gelitkommazahlen verwendet!)
echo "PID;Befehl;CPU Zeit;Speicherverbrauch" > prozesse.csv && top -b -n 1 | awk 'NR > 7 { print $1 ";" $12 ";" $9 ";" $10 }' >> prozesse.csv
Damit erhalten wir wie gewünscht lediglich die Daten für die Spalten PID, %CPU, %MEM, BEFEHL.
PID;Befehl,CPU Zeit,Speicherverbrauch
22545;top;111;0,7
1;systemd;0,0;1,2
2;kthreadd;0,0;0,0
3;rcu_gp;0,0;0,0
4;rcu_par_gp;0,0;0,0;
Aufbau der Schaltung - Raspberry Pi mit OLED Display
Wie bereits erwähnt baue ich die Schaltung am Raspberry Pi Zero 2 WH auf, du kannst diese aber ebenso am normalen Raspberry Pi nachbauen (solltest jedoch zusätzlich auf das ggf. geänderte Pinout achten).
OLED-DisplayRaspberry Pi Zero 2 WHVCC5V (Pin 2)GNDGND (Pin 6)SDASDA (Pin 3)SCLSCL (Pin 5)
Python Skript im Hintergrund laufen lassen
Ich möchte das kleine Skript einmal starten und dann über die Tasten Funktionen ausführen können, während ich gleichzeitig weiterhin im geöffneten Terminalfenster arbeite. Deshalb soll das Skript im Hintergrund laufen.
Es gibt hier mehrere Möglichkeiten, in diesem Beitrag möchte ich die einfachste nutzen und hänge lediglich ein & Zeichen an den Befehl und als Rückgabe erhalte ich eine PID. Mit dieser Prozess-ID kann ich dieses Skript auch jederzeit mit dem Befehl kill beenden.
pi@raspberrypi:~/Python/DisplayTop $ python3 displayHello.py &
23467
pi@raspberrypi:~/Python/DisplayTop $ kill 23467
pi@raspberrypi:~/Python/DisplayTop $
Programmieren des Skriptes zum anzeigen der laufenden Prozesse
Starten wir nun und lassen die laufenden Prozesse auf dem OLED Display am Raspberry Pi anzeigen. Das Skript erstellen wir iterativ und nach jedem Schritt hast du quasi ein kleines lauffähiges Skript mit einer zusätzlichen Funktion.
Schritt 1 - Willkommensnachricht anzeigen
Im ersten Schritt lassen wir auf dem Display zunächst einen Text anzeigen, welcher kurz erläutert welche Daten angezeigt werden.
import time
from luma.core.interface.serial import i2c, spi, pcf8574
from luma.core.interface.parallel import bitbang_6800
from luma.core.render import canvas
from luma.oled.device import sh1106
from PIL import ImageFont
serial = i2c(port=1, address=0x3C)
device = sh1106(serial)
fontBig = ImageFont.truetype('FreeSans.ttf', 14)
fontNormal = ImageFont.truetype('FreeSans.ttf', 10)
while True:
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((25, 3), "pyTop Screen", font=fontBig, fill="white")
draw.text((5, 20), "Anzeige fuer PID, Befehl,", font=fontNormal, fill="white")
draw.text((5, 30), "CPU Zeit sowie", font=fontNormal, fill="white")
draw.text((5, 40), "Speicherverbrauch", font=fontNormal, fill="white")
In meinem Fall nutze ich ein 1.3" OLED Display und musste die Schriftgröße auf 14 & 10 setzen. Hier gilt wie zuvor ein möglichst großes Display zu verwenden.
Splashscreen des Python Projektes - "pyTop Screen"
Schritt 2 - exportieren der laufenden Prozesse als CSV Datei
In einem Abschnitt zuvor habe ich dir gezeigt, wie der Befehl lautet, um die benötigten Daten der laufenden Prozesse in eine CSV Datei zu schreiben. Diesen wollen wir jetzt alle 2 Minuten ausführen.
Damit wir eine Funktion im Hintergrund laufen lassen können, benötigen wir zusätzlich das Modul "schedule" dieses muss über den Befehl "python3 -m pip install schedule" installiert werden.
pi@raspberrypi:~/Python/DisplayTop $ python3 -m pip install schedule
Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
Collecting schedule
Downloading https://www.piwheels.org/simple/schedule/schedule-1.2.1-py3-none-any.whl (11 kB)
Installing collected packages: schedule
Successfully installed schedule-1.2.1
pi@raspberrypi:~/Python/DisplayTop $
import subprocess
import schedule
import time
...
def loadProcessInformations():
command = 'echo "PID;Befehl;CPU Zeit;Speicherverbrauch" > prozesse.csv && top -b -n 1 | awk 'NR > 7 { print $1 ";" $12 ";" $9 ";" $10 }' >> prozesse.csv'
subprocess.run(command, shell=True)
loadProcessInformations()
schedule.every(2).minutes.do(loadProcessInformations)
...
while True:
schedule.run_pending()
Wenn wir das Skript ausgeführt wird, dann wird im aktuellen Verzeichnis die Datei "prozesse.csv" mit einem auszug der Daten von top angezeigt.
pi@raspberrypi:~/Python/DisplayTop $ python3 pyTopScreen.py &
24037
pi@raspberrypi:~/Python/DisplayTop $ ls -ll
insgesamt 12
-rw-r--r-- 1 pi pi 4987 21. Apr 11:43 prozesse.csv
-rw-r--r-- 1 pi pi 1242 21. Apr 11:38 pyTopScreen.py
pi@raspberrypi:~/Python/DisplayTop $
Schritt 3 - Parsen der CSV Datei in ein Dictionary
Für einen einfachen Zugriff auf die exportierten Daten, parsen wir die CSV Datei in ein Dictionary.
Es interessieren mich jedoch nur laufende Prozesse, diese haben eine CPU Zeit und einen Speicherverbrauch größer 0.
import csv
...
def loadProcessInformations():
command = 'echo "PID;Befehl;CPU Zeit;Speicherverbrauch" > prozesse.csv && top -b -n 1 | awk 'NR > 7 { print $1 ";" $12 ";" $9 ";" $10 }' >> prozesse.csv'
subprocess.run(command, shell=True)
prozesse_dict = {}
with open('prozesse.csv', 'r') as file:
csv_reader = csv.DictReader(file, delimiter=';')
for row in csv_reader:
pid = row
cpu_zeit = float(row.replace(',', '.'))
speicherverbrauch = float(row.replace(',', '.'))
if cpu_zeit > 0 and speicherverbrauch > 0:
befehl = row
prozesse_dict = {'Befehl': befehl, 'CPU Zeit': cpu_zeit, 'Speicherverbrauch': speicherverbrauch}
print(prozesse_dict)
Immer wenn die neuen Daten geladen werden, werden diese zusätzlich im Terminalfenster ausgegeben.
pi@raspberrypi:~/Python/DisplayTop $ python3 pyTopScreen.py
{
'24261': {'Befehl': 'python3', 'CPU Zeit': 100.0, 'Speicherverbrauch': 3.2},
'24530': {'Befehl': 'top', 'CPU Zeit': 5.9, 'Speicherverbrauch': 0.7}
}
Schritt 4 - Anzeigen der Prozessinformationen auf dem OLED Display am Raspberry Pi
Kommen wir nun zum letzten Schritt und lassen die Prozessinformationen auf dem OLED Display anzeigen. Dazu müssen wir unseren bisherigen Code etwas anpassen, denn das Dictionary muss global abgelegt werden.
prozesse_dict = {}
def loadProcessInformations():
...
global prozesse_dict
...
In der Endlosschleife in welchem der Code zum anzeigen der Daten wiederholt wird, legen wir dann eine For-Each-Schleife an welche über das Dictionary mit den Daten läuft.
while True:
schedule.run_pending()
total = len(prozesse_dict)
index = 1
for entry in prozesse_dict:
showProcessEntry(entry, index, total)
index += 1
time.sleep(2)
Als Nächstes legen wir dann eine neue Funktion an welche einen Eintrag aus diesem Dictionary behandelt, bzw. wir übergeben lediglich die ID (die Prozess-ID / PID), zusätzlich wird noch die länge des Dictionarys sowie der aktuelle Index als Parameter übergeben (diese beiden Daten werden oben rechts im Display angezeigt).
def showProcessEntry(entry, index, total):
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((25, 3), "pyTop Screen", font=fontBig, fill="white")
draw.text((105, 20), str(index) + "/"+ str(total), font=fontNormal, fill="white")
draw.text((5, 20), "PID: "+ str(entry), font=fontNormal, fill="white")
draw.text((5, 30), "Befehl: "+prozesse_dict, font=fontNormal, fill="white")
draw.text((5, 40), "CPU Zeit: "+str(prozesse_dict), font=fontNormal, fill="white")
draw.text((5, 50), "MEM: "+str(prozesse_dict), font=fontNormal, fill="white")
Damit ist nun unser kleines Programm fertig und wir erhalten nun die Ausgabe der aktuellen Prozesse auf dem OLED-Display.
Daten aktuellen Prozessen auf dem OLED-Display
Das fertige Python Skript zum anzeigen der Prozessinformationen auf einem OLED-Display
Hier nun das fertige Python Skript als ZIP-Datei zum download.
Programm - "pyTop-Screen" für das Anzeigen von Prozessinformationen auf einem OLED-DisplayHerunterladen
import csv
import subprocess
import schedule
import time
from luma.core.interface.serial import i2c, spi, pcf8574
from luma.core.interface.parallel import bitbang_6800
from luma.core.render import canvas
from luma.oled.device import sh1106
from PIL import ImageFont
serial = i2c(port=1, address=0x3C)
device = sh1106(serial)
fontBig = ImageFont.truetype('FreeSans.ttf', 14)
fontNormal = ImageFont.truetype('FreeSans.ttf', 10)
fontSmall = ImageFont.truetype('FreeSans.ttf', 8)
prozesse_dict = {}
def loadProcessInformations():
command = 'echo "PID;Befehl;CPU Zeit;Speicherverbrauch" > prozesse.csv && top -b -n 1 | awk 'NR > 7 { print $1 ";" $12 ";" $9 ";" $10 }' >> prozesse.csv'
subprocess.run(command, shell=True)
global prozesse_dict
prozesse_dict.clear()
with open('prozesse.csv', 'r') as file:
csv_reader = csv.DictReader(file, delimiter=';')
for row in csv_reader:
pid = row
cpu_zeit = float(row.replace(',', '.'))
speicherverbrauch = float(row.replace(',', '.'))
if cpu_zeit > 0 and speicherverbrauch > 0:
befehl = row
prozesse_dict = {'Befehl': befehl, 'CPU Zeit': cpu_zeit, 'Speicherverbrauch': speicherverbrauch}
print(prozesse_dict)
def showProcessEntry(entry, index, total):
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((25, 3), "pyTop Screen", font=fontBig, fill="white")
draw.text((105, 20), str(index) + "/"+ str(total), font=fontNormal, fill="white")
draw.text((5, 20), "PID: "+ str(entry), font=fontNormal, fill="white")
draw.text((5, 30), "Befehl: "+prozesse_dict, font=fontNormal, fill="white")
draw.text((5, 40), "CPU Zeit: "+str(prozesse_dict), font=fontNormal, fill="white")
draw.text((5, 50), "MEM: "+str(prozesse_dict), font=fontNormal, fill="white")
loadProcessInformations()
schedule.every(15).seconds.do(loadProcessInformations)
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((25, 3), "pyTop Screen", font=fontBig, fill="white")
draw.text((5, 20), "Anzeige fuer PID, Befehl,", font=fontNormal, fill="white")
draw.text((5, 30), "CPU Zeit sowie", font=fontNormal, fill="white")
draw.text((5, 40), "Speicherverbrauch", font=fontNormal, fill="white")
draw.text((15, 52), "https://draeger-it.blog", font=fontNormal, fill="white")
time.sleep(3)
while True:
schedule.run_pending()
total = len(prozesse_dict)
index = 1
for entry in prozesse_dict:
showProcessEntry(entry, index, total)
index += 1
time.sleep(2)
Fazit & Ausblick zu Raspberry Pi Prozessinformationen am OLED Display anzeigen
Als Fazit ziehe ich ich jedoch das, dass kleine 1,3" OLED Display zu klein ist für die Informationen hier muss ich mal schauen ob es deutlich größere gibt um dieses kleine Projekt deutlich aufzuwerten.
Die Nächste Ausbaustufe zu diesem Projekt könnte nun sein, drei Taster anzuschließen mit welchen man durch die aktiven Prozesse blättern kann. Zusätzlich mit einem roten Taster könnte man den Befehl kill auf einen Prozess anstoßen um den angezeigten Prozess hart zu beenden.
Read the full article
0 notes
Text
DIY-Gewitterdetektor: Bausatzvorstellung für Arduino Nano V3
In diesem neuen Beitrag möchte ich dir den Gewitterdetektor Bausatz für den Arduino Nano V3 vorstellen. Mit diesem kleinen Bausatz kannst du, wie die Bezeichnung es erahnen lässt, dich vor Gewitter warnen lassen. Einen ähnlichen Bausatz habe ich dir bereits für den Arduino UNO R3 im Beitrag BLITZ-O-SHIELD für den Arduino UNO von Ramser Elektronik vorgestellt.
DIY-Gewitterdetektor: Bausatzvorstellung für Arduino Nano V3
Auch diesen Bausatz habe ich wieder von der Firma Ramser Elektronik aus Österreich gesponsert bekommen, weshalb ich mich zunächst dafür bedanken möchte.
Wie funktioniert der Gewitterdetektor am Arduino Nano?
Das Blitz-O Shield für den Arduino Nano V3 funktioniert als Gewitterdetektor, indem es die breitbandigen Radiowellen, die von Blitzen ausgesendet werden und hauptsächlich im AM-Band liegen, empfängt.
Hierzu wird der AM-Empfänger IC TA7642 verwendet. Dieser empfängt, vorverstärkt, demoduliert und verstärkt die empfangenen Signale. Das verstärkte Signal wird dann dem Arduino Nano über den Analogeingang A0 zugeführt.
Jede Blitzentladung verursacht einen "Spannungseinbruch" am A0-Eingang des Arduino, der ausgewertet wird. Je mehr solcher Einbrüche detektiert werden, desto näher ist das Gewitter.
Die Verstärkung des TA7642 wird durch eine geglättete Spannung eines PWM-Signals reguliert, wodurch die Dynamik des AGC (Automatic Gain Control) besser angepasst werden kann.
Das Shield selbst bietet alle notwendigen Hardwarekomponenten, um Blitze und Gewitter zu detektieren und ist kompatibel mit einem standardmäßigen Arduino Nano.
Zusammenbau / Aufbau des Bausatzes
Zunächst müssen wir diesen Bausatz aufbauen, dazu benötigst du einige Werkzeuge:
- einen Lötkolben*,
- Lötzinn*,
- eine hitzebeständige Unterlage*,
- einen kleinen Seitenschneider*,
- eine Biegelehre für Widerstände*, sowie
- eine Entlötpumpe*
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Bevor ich mit dem Löten beginne, lege ich mir die elektronischen Bauteile auf den Tisch und prüfe, ob diese Vollzählig sind. Dem Bausatz liegt ein kleiner Zettel bei, aus welchem du die einzelnen Komponenten sowie deren Platzierung auf der Platine entnehmen kannst, dieser dient auch gleich als Stückliste.
Bauteile aus dem Bausatz des Gewitter Detektors für den Arduino Nano V3
Die Widerstände sind nicht markiert, da es jedoch nur zwei einzelne gibt, kann man sich diese beiden recht einfach anhand der farbigen Ringe ausrechnen oder aber man nimmt ein Messgerät.
Eine sehr ausführliche Anleitung, wie du diesen Bausatz zusammenbaust, erhältst du auf der Seite https://www.ramser-elektro.at/blitz-o-shield-nano-der-gewitter-detektor/.
Für mich reichte der kleine Zettel aus, denn die Platine ist beschriftet und auf dem Zettel findest du alle Informationen.
Wichtig ist das die Beschriftungen der Kondensatoren auf der Platine mit einem Plus Symbol bezeichnet sind und auf dem Kondensator findest du einen weißen Strich mit einem Minus Symbol.
Programmieren des Gewitterdetektors am Arduino Nano V3
Wichtiger Schritt vor dem Programmieren
Für den Fall, dass du deinen Arduino Nano bereits in anderen Projekten eingesetzt hast, wäre es ratsam, zunächst ein neues, leeres Projekt auf diesem zu installieren. Anschließend kannst du den Mikrocontroller auf das Shield setzen und es mit dem Computer verbinden.
Download des Quellcodes vom Hersteller
Den Code kannst du dir vom Hersteller als ZIP-Datei herunterladen, dieser ist derselbe welcher auch für den Arduino UNO R3 verwendet wird. Da die beiden Mikrocontroller sehr ähnlich sind, ist dieses auch nicht sehr verwunderlich.
Ausprobieren des Gewitterdetektors
Um diesen Gewitter Detektor zu testen, müssen wir nun eben auf ein Gewitter warten, oder wir benutzen zusätzlich den Blitzsimulator von Ramser Elektronik welchen du auch im Shop erhältst.
Der Blitzsimulator hat drei Tasten über welche Impulse generiert werden, welche vom Gewitterdetektor als Gewitter erkannt werden. In der Konsole der Arduino IDE wird dieses dann ebenso wie über die LEDs quittiert.
https://youtu.be/wQtRqzZ_ONM
Read the full article
0 notes
Text
OLED Display am Raspberry Pi anschließen und per I2C steuern: So geht's!
In diesem Beitrag möchte ich dir erläutern, wie du ein 1,3" OLED Display am Raspberry Pi via I2C & Python3 programmieren kannst. Die OLED Displays erhältst du für diverse Anwendungsfälle in verschiedenen Größen. Das 1,3" OLED Display ist hier besonders geeignet, dass dieses nicht nur günstig ist, sondern auch viel Platz für Text & Grafiken bietet.
https://youtu.be/xlZF_utaJqI
Die Idee zu diesem Beitrag stammt von einem Kommentar vom YouTube-Video Schritt-für-Schritt-Anleitung: OLED-Display am ESP8266 via I2C programmieren (Teil1) wo ich erläutert habe, wie man dieses am ESP8266 mit der Arduino IDE macht. Hier soll es jedoch nun darum gehen, wie du dieses Display am Raspberry Pi mit Python3 programmiert.
In meinem Fall nutze ich den recht betagten Raspberry Pi 3B+, dieser ist etwas älter, aber für dieses und viele weitere Anwendungsfälle noch bestens geeignet.
Aufbau der Schaltung - OLED Display via I2C am Raspberry Pi
Als erstes schließen wir das OLED Display an den Raspberry Pi an. Wie erwähnt verwende ich den Raspberry Pi 3B+ welcher nachfolgendes Pinout hat.
Pinout des Raspberry Pi 3B+
Wenn du den neuen Raspberry Pi 5 verwendest, dann kannst du das Pinout ebenso verwenden, denn es ist mit dem 3er-Pi gleich.
Für den Aufbau der Schaltung benötigst du:
- einen Raspberry Pi*,
- vier Breadboardkabel*, 10 cm, männlich - weiblich,
- ein 400 Pin Breadboard*
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Schaltung - Raspberry Pi mit OLED-Display am I2C Bus
OLED-DisplayRaspberry PiGNDGND (Pin 6)VCC3.3V (Pin 1)SCLGPIO3SDAGPIO2
Aktiven der I2C Schnittstelle am Raspberry Pi
Bevor wir über der I2C Schnittstelle kommunizieren können, müssen wir diese zunächst aktivieren. Dazu starten wir die Konfiguration mit dem Befehl "sudo raspi-config".
Durch die Menüs kannst du dich mit den Pfeiltasten auf der Tastatur bewegen. Deine Auswahl bestätigst du jeweils immer mit der Enter-Taste.
Wenn jetzt die I2C Schnittstelle aktiviert wurde, kann nun im nächsten Schritt nach Geräten gesucht werden. Zum Suchen von I2C Geräten am Raspberry Pi können wir das Kommandozeilentool i2cdetect wie folgt aufrufen:
i2cdetect -y 1
Die Zahl 1 repräsentiert in diesem Fall den I2C Bus, an welchem gesucht werden soll. Die Ausgabe ist dann eine Tabelle, aus welcher wir die gefundenen Adressen ablesen können.
Installieren der benötigten Module
Bevor wir mit dem Programmieren beginnen können, müssen wir ein paar Module auf dem Raspberry Pi installieren.
sudo apt-get update
sudo apt-get install python3-dev libffi-dev libssl-dev python3-pil libjpeg-dev zlib1g-dev libfreetype6-dev liblcms2-dev libopenjp2-7 libtiff5 -y
sudo apt-get install python3-rpi.gpio python3-pip -y
Programm für Text "Hello World!"
Als Erstes wollen wir mit einem typischen Beispiel starten und zeigen auf dem OLED-Display den Text "Hello World!" an.
import time
from luma.core.interface.serial import i2c, spi, pcf8574
from luma.core.interface.parallel import bitbang_6800
from luma.core.render import canvas
from luma.oled.device import sh1106
from PIL import ImageFont
serial = i2c(port=1, address=0x3C)
device = sh1106(serial)
font = ImageFont.truetype('FreeSans.ttf', 14)
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((25, 25), "Hello World!", font=font, fill="white")
time.sleep(5)
Wichtig ist, dass wir am Ende eine Zeit x warten, damit der Inhalt des Displays angezeigt wird. Es wird beim Beenden des Programmes der Bildschirminhalt geleert!
Ausgabe von "Hello World!" auf einem OLED-Display am Raspberry Pi
Alternativ können wir auch um den Block "with canvas..." eine Endlosschleife starten und auf ein Abbrechen durch die Tastenkombination Strg+C warten.
import time
from luma.core.interface.serial import i2c, spi, pcf8574
from luma.core.interface.parallel import bitbang_6800
from luma.core.render import canvas
from luma.oled.device import sh1106
from PIL import ImageFont
serial = i2c(port=1, address=0x3C)
device = sh1106(serial)
font = ImageFont.truetype('FreeSans.ttf', 18)
try:
while True:
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((15, 20), "Hello World!", font=font, fill="white")
except KeyboardInterrupt:
print("Programm wurde beendet!")
Wenn wir jetzt das Programm wie gewohnt mit "python3 " starten, sollten wir auf dem Display die Ausgabe sehen. Das Programm können wir jetzt jederzeit mit der Tastenkombination Strg+C abbrechen.
pi@raspberrypi:~/Python/OLEDDisplay $ python3 t2.py
^CProgramm wurde beendet!
pi@raspberrypi:~/Python/OLEDDisplay $
Einrichten einer Grußbotschaft beim Starten des Raspberry Pi
Den Raspberry Pi kannst du auch ohne Display & Tastatur verwenden. Da bietet sich das kleine Display an, um Informationen anzuzeigen, wenn dieser gestartet wurde und einsatzbereit ist.
Ausführen des Python3 Skripts mit systemd
In meinem Fall erstelle ich einen neuen Service unter /etc/systemd/system mit:
pi@raspberrypi:~ $ cd /etc/systemd/system
pi@raspberrypi:/etc/systemd/system $ sudo nano greeting.service
Dieser Service ist nach folgendem Schema aufgebaut:
Description=display greetings message when raspi status is done
After=network.target
WorkingDirectory=/home/pi/Python/OLEDDisplay
ExecStart=/usr/bin/python3 /home/pi/Python/OLEDDisplay/greeting.py
WantedBy=default.target
Erläuterungen:
- Unit
- Description: eine Beschreibung des Services
- After: wann soll das Script / der Befehl ausgeführt werden?
- Service
- WorkingDirectory: das Arbeitsverzeichnis des Scripts / Befehls
- ExecStart: das Script / der Befehl, welcher ausgeführt werden soll (mit vollen Pfadangaben!)
- Install
- WantedBy: das Zielsystem, in meinem Fall default
Abschließend müssen wir den systemd Daemon neu starten, um den neuen Service zu registrieren und starten unseren neuen Service.
sudo systemctl daemon-reload
sudo systemctl enable greeting.service
sudo systemctl start greeting.service
Troubleshooting: Status des Service abfragen
Wenn der neue Service nicht startet, dann können wir mit dem nachfolgenden Befehl uns den Status ausgeben lassen.
sudo service greeting status
Im nachfolgenden Fall ist der Service erfolgreich gestartet und hat keinen Fehler erzeugt.
pi@raspberrypi:/etc/systemd/system $ sudo service greeting status
● greeting.service - My Script
Loaded: loaded (/etc/systemd/system/greeting.service; enabled; vendor preset: enabled)
Active: inactive (dead) since Sun 2024-03-17 11:31:38 CET; 48min ago
Process: 509 ExecStart=/usr/bin/python3 /home/pi/Python/OLEDDisplay/greeting.py (code=exited, status=0/SUCCESS)
Main PID: 509 (code=exited, status=0/SUCCESS)
CPU: 664ms
Mär 17 11:31:19 raspberrypi systemd: Started My Script.
Mär 17 11:31:38 raspberrypi systemd: greeting.service: Succeeded.
Read the full article
0 notes
Text
Innovativ und widerstandsfähig: Der Shelly BLU H&T im Detail
Was der neue Shelly BLU H&T kann, möchte ich dir hier im neuen Beitrag zeigen. Dieser Sensor dient zum Messen der Temperatur und der relativen Luftfeuchtigkeit. Das Besondere an diesem neuen Sensor ist, dass dieser sehr robust aufgebaut ist und somit auch oder besonders für den Außenbereich geeignet ist.
Disclaimer: Die Informationen in diesem Beitrag stammen von der Webseite des Herstellers sowie aus dem beigefügten Informationsmaterial des Sensors. Ich möchte darauf hinweisen, dass der Sensor von der Firma Shelly gesponsert wurde. Ich übernehme keine Gewähr für die Richtigkeit oder Vollständigkeit der bereitgestellten Informationen.
Aufbau des Sensors
Der Sensor ist von einem gummierten Gehäuse umgeben. Dieses bietet einen Schutz nach IP65 und somit ist dieser geschützt vor Staub und Wasser.
Der Sensor sendet alle 11 Sekunden ein Datenpaket, mit dem Taster hinter dem Logo auf der Vorderseite, kannst du jedoch sofort ein solches Datenpaket absenden. Das Datenpaket enthält die Informationen zur Temperatur in Grad Celsius und die relative Luftfeuchtigkeit in Prozent.
Ein kleiner Nachteil von der Gummierung ist, dass diese fast magisch Staub und Schmutz anzieht und dieses besonders beim hellen Modell auffällt. Ich würde dir daher das Schwarze Modell empfehlen, weil es bei diesem nicht so auffallen wird.
Montage des Sensors
Im Lieferumfang findest du ein doppelseitiges Klebepatch, mit diesem kannst du deinen Sensor an eine fast beliebige Stelle anbringen. Durch seine geraden Kanten kann dieser aber auch aufgestellt werden.
Ich habe jedoch mit dem Klebepatch keine guten Erfahrungen gesammelt, da dieser ja beim Batteriewechsel nur hinderlich ist. Für diesen Sensor habe ich eine Haltung erstellt, welche du dir von Thingiverse herunterladen und mit einem 3D Drucker selber erstellen kannst.
Technische Daten des Shelly BLU H&T
Hier nun die technischen Daten des Sensors:
- Größe und Gewicht: Mit einer Größe von 37x37x10 mm und einem Gewicht von 13 g ist der Sensor kompakt und leicht, was eine einfache Montage auf einer flachen Oberfläche ermöglicht.
- Gehäuse: Das Gehäuse besteht aus robustem Kunststoff und ist in den Farben Schwarz, Mocca und Elfenbein erhältlich, was eine Anpassung an verschiedene Umgebungen ermöglicht.
- Umgebungstemperatur und Luftfeuchtigkeit: Der Sensor ist für einen Temperaturbereich von -20 °C bis 60 °C und eine Luftfeuchtigkeit von 0 % bis 100 % RH ausgelegt, was ihn vielseitig einsetzbar macht.
- Schutzklasse: Mit der Schutzklasse IP54 ist der Sensor vor Staub und Spritzwasser geschützt, was ihn ideal für den Einsatz im Innen- und Außenbereich macht.
- Stromversorgung und Batterielaufzeit: Der Sensor wird mit einer 3-Volt-Batterie vom Typ CR2032 betrieben, die eine geschätzte Batterielebensdauer von bis zu 3 Jahren bietet.
- Konnektivität: Der Sensor verwendet das Bluetooth-Protokoll 4.2 und arbeitet im Frequenzband von 2400 bis 2483,5 MHz. Die maximale Funkleistung beträgt weniger als 4 dBm.
- Reichweite und Verschlüsselung: Der Sensor bietet eine Reichweite von bis zu 30 m im Freien und bis zu 10 m in Innenräumen, abhängig von den örtlichen Bedingungen. Die Datenübertragung ist durch AES-Verschlüsselung im CCM-Modus gesichert.
Einrichten in der Shelly Smart Control App
Für den Sensor benötigst du zusätzlich eine Bluetoothbridge, dieses kannst du mit einem Shelly Pro oder Plus Gerät machen oder aber du nimmst den Shelly BLU Gateway. Den Shelly BLU Gateway habe ich dir bereits im Beitrag Smarte Vernetzung leicht gemacht: Alles über das Shelly BLU Gateway vorgestellt und ausführlich beschrieben. Für diesen Sensor verwende ich ebenso das Gateway, da ich an dem Platz, wo ich den Sensor platzieren möchte, keinen Shelly in Reichweite habe. (jedenfalls kein Pro / Plus Gerät)
Zunächst benötigen wir die Shelly Smart Control App, diese bekommst du in den bekannten Stores für dein Betriebssystem.
Wie du ein Shelly BLU Gerät in der App einrichtest, habe ich dir im nachfolgenden kleinen YouTube Video erläutert.
https://youtu.be/2XsbCDfVOOM
Über die App kannst du die Daten für die Temperatur und die relative Luftfeuchtigkeit in einem Diagramm für einen frei wählbaren Zeitraum anzeigen und auch als CSV Datei exportieren.
Einsatz im Garten
Durch seine Robustheit kann dieser Sensor auch perfekt im Garten eingesetzt werden, speziell in Gewächshäuser, hier ist es sinnvoll die Temperatur und vor allem die Luftfeuchtigkeit im Blick zu haben. Mit dem Sensor und einer intelligenten Szene kannst du dir eine Pushbenachrichtigung senden lassen, wenn die Werte nicht stimmen. (oder besser noch davor)
Für das Gewächshaus habe ich die Halterung mit Öse erstellt, damit man diesen Sensor einfach mit einem Kabelbinder einhängen kann.
Besonders im Frühjahr, wo nachts noch mit Frösten zu rechnen ist, kann dieser Sensor besonders nützlich sein. Dieser kann dich auch warnen, wenn es mal zu kalt wird und du dann geeignete Gegenmaßnahmen ergreifen kannst.
In meinem Fall habe ich mir eine Gewächshausheizung aus einem Tontopf gebastelt.
Erstellen der Szene für ein Gewächshaus
Erstellen wir nun die Szene für das Gewächshaus, damit wir eine Pushbenachrichtigung erhalten, wenn die Temperatur 24 °C und die Luftfeuchtigkeit 80 % überschreitet. Wenn einer dieser Werte diesen Grenzwert überschreitet, dann soll eine Pushbenachrichtigung an ein Handy gesendet werden.
https://youtu.be/e_kBP1yNbmI
Fazit zum neuen Shelly BLU H&T
Nachdem ich den neuen Shelly Sensor genauer unter die Lupe genommen habe, kann ich sagen, dass er definitiv flexibler einsetzbar ist als sein Vorgänger, dank seiner robusten Bauweise. Allerdings muss ich gestehen, dass die Entscheidung für eine gummierte Oberfläche nicht ganz mein Fall ist - der Sensor scheint förmlich Schmutz und Staub anzuziehen, als hätte er magische Kräfte.
In meinem nächsten Beitrag werfe ich einen genaueren Blick auf den BLU H&T und vergleiche ihn eingehend mit seinem Vorgänger. Welche Verbesserungen wurden gemacht? Welche neuen Funktionen erwarten uns? Bleib dran, um herauszufinden, ob sich das Upgrade lohnt!
Read the full article
0 notes
Text
Smarte Pflanzenpflege: Der Bluetooth Plant Monitor im Test
Was der smarte Bluetooth Plant Monitor leistet und wie dieser eingerichtet wird, zeige ich dir hier in meinem neuen Beitrag. Dieser Sensor liefert dir die Daten der Bodenfeuchte und der Temperatur via Bluetooth an dein Handy oder Tablet.
Diesen drahtlosen Bodenfeuchtesensor habe ich mir von der Plattform Aliexpress.com für knapp 10€ zzgl. Versandkosten gekauft und wurde innerhalb von 2 Wochen geliefert.
Aufbau des Bluetooth Plant Monitor
Der Sensor verfügt über einen kapazitiven Bodenfeuchtesensor. Diese Art des Bodenfeuchtesensors ist besonders langlebig und arbeitet nicht mit blanken Drähten oder Kontakten, welche im Boden korrodieren können. Des Weiteren liefert dieser Sensor auch die Temperatur.
Bluetooth Plant Monitor
Bluetooth Plant Monitor
Ich hätte mir hier noch gewünscht, dass zusätzlich die rel. Luftfeuchtigkeit und die Helligkeit geliefert wird, denn damit hätte man so ziemlich die wichtigsten Parameter für ein gesundes Pflanzenwachstum.
Silikonhülle am Plant Monitor
Batteriefach für 2 AAA-Batterien am Plant Monitor
Vorderseite des Bluetooth Plant Monitor
Rückseite des Bluetooth Plant Monitor
Unter der Silikonhülle, welchen den Sensor vor Feuchtigkeit schützen soll, befindet sich das Batteriefach in welches wir 2 AAA-Batterien einlegen und damit betreiben. Zusätzlich findest du bei diesem Batteriefach noch den RESET-Taster sowie eine kleine Status-LED.
Hinweis zur Bluetoothkommunikation und Bluetooth Gateway
Da der Sensor die Daten via Bluetooth sendet, müssen wir uns mit dem Handy oder Tablet im näheren Umkreis des Sensors befinden, um die Daten auszulesen.
Wenn wir die Daten von weiter weg oder von der Cloud aus lesen möchten, dann benötigen wir ein Bluetooth Gateway. Dieses Bluetooth Gateway ist die Brücke zwischen Bluetooth und WiFi und damit kannst du quasi deine Bluetoothgeräte in dein lokales WiFi Netzwerk einbinden.
Bluetoothgateway
Einrichten des Plant Monitor in der App "Smart Life - Smart Living"
Für die Einrichtung musst du an deinem Handy / Tablet zunächst Bluetooth aktivieren und kannst danach in der App nach neue Geräte suchen.
Im ersten Schritt musst du oben rechts auf das blaue Plus klicken und aus dem Menü wählst du dann "Gerät hinzufügen".
Es wurde dann ein Gerät erkannt und aus dem Bild ist zu erkennen, dass es sich um einen Bodenfeuchtesensor handelt. Hier klicken wir nun auf die Schaltfläche "Hinzufügen".
Die Einrichtung geht sehr schnell und im Verhältnis zu einem WiFi Gerät ist das auch deutlich frustfreier.
Zum Abschluss muss man jetzt nur noch auf Fertigstellung klicken und der Sensor ist fertig eingerichtet und kann verwendet werden.
Dashboard des Bluetooth Plant Monitor in der App Smart Life - Smart Living
Im Dashboard kannst du die gemessene Feuchtigkeit sowie die Temperatur ablesen.
Über die beiden Schaltflächen im unteren Bereich kannst du dann die Daten im Verlauf ansehen (linke Schaltfläche) und auch einige Einstellungen treffen.
Der Plant Monitor im Einsatz
Den Plant Monitor habe ich jetzt in eine kleine Pflanze gesteckt und schaue mir das ganze einmal an wie die Daten gemessen werden und wie der Verlauf dieser ist. Interessant wird wie ich finde der Einsatz im Außenbereich, da möchte ich in meinem Garten in diverse Kräutertöpfe einen solchen Sensor stecken.
Plant Monitor im Blumentopf
Da wir jetzt jedoch erst Anfang März haben, fängt diese Saison erst an und somit lässt ein Test im Außenbereich noch auf sich warten.
Read the full article
0 notes
Text
ESP32 & Touchscreen - Bildschirmtastatur programmieren
Auf dem ESP32 mit Touchscreen kannst du nicht nur geometrische Figuren zeichnen, sondern mit etwas Geschick und Zeit auch Dashboards. In diesem Beitrag möchte ich dir daher nun zeigen, wie eine Bildschirmtastatur programmiert wird.
https://youtu.be/oQ_NSk1W470
Die hier vorgestellte Bildschirmtastatur wird in einem weiteren Beitrag benötigt, jedoch finde ich das es ein Eigner Beitrag wert ist, weil dieses kleine Feature kannst du für viele Anwendungsfälle verwenden.
Wie soll die Bildschirmtastatur am ESP32 mit Touchscreen aussehen?
Eine Bildschirmtastatur kennst du bestimmt schon von deinem Handy und genau von dort nehme ich mir eine Vorlage.
Aus dieser Vorlage streiche ich jedoch die Funktion für die Smileys und füge für die Sonderzeichen eine zusätzliche Taste ein.
Hier jetzt ein Bild wie das Ergebnis aussieht, wenn du diesen Beitrag durcharbeitest oder dir ganz bequem vom GitHub Repository StefanDraeger / ESP32_Development_Board_ESP32-2432S028R dir den Code herunterlädst und ausführst.
Programmieren der Bildschirmtastatur in der Arduino IDE
Fangen wir jetzt an und programmieren die Bildschirmtastatur. Wie man geometrische Figuren zeichnet und auf ein Touch Event reagiert, habe ich dir bereits in den nachfolgenden Beiträgen gezeigt.
- ESP32 Development Board mit 2,8 Zoll Touch Display: Programmieren für Anfänger
- ESP32 Development Board: Touchfunktion programmieren
Ausgangsstruktur für das Programm
Zunächst das kleine Programm, welches wir als Basis nutzen möchten:
#define LGFX_USE_V1
#include
#include "lgfx_ESP32_2432S028.h"
//Größe der Zeichenfläche definieren
#define MAX_X 319
#define MAX_Y 239
//Felder für die ermittelte Position
//bei einem klick
uint16_t x = 0, y = 0;
//Instanz des Displays
static LGFX lcd;
void setup(void) {
//beginn der seriellen Kommunikation mit
//115200 Baud
Serial.begin(115200);
//beginn der Kommunikation mit dem Display
lcd.init();
//drehen des Displays
lcd.setRotation(1);
//füllen des Displays mit der Farbe Schwarz
lcd.fillScreen(lcd.color332(0,0,0));
//eine kleine Pause von 100ms.
delay(100);
}
void loop() {
if (lcd.getTouch(&x, &y) == 1) {
if (x > MAX_X || y > MAX_Y) {
return;
}
}
//eine Pause von 50 Millisekunden.
delay(50);
}
Zusätzlich benötigst du noch die Datei "lgfx_ESP32_2432S028.h" welche du vom GitHub Repository OttoMeister/ARDUINO_ESP32-2432S028R herunterladen kannst. Nachfolgend eine ZIP-Datei mit dem Code und der benötigten Datei.
Grundprogramm - ESP32 Development Board mit TFT TouchdisplayHerunterladen
Schritt 1 - Struktur für die GUI Elemente anlegen
Zunächst erstellen wir die Strukturen für die Schaltflächen und das Eingabefeld, denn schließlich wollen wir unseren Code effizient und optimiert aufbauen.
Auf der Tastatur findest du zwei verschiedene Buttons, zum einen für die Buchstaben, Zahlen und Sonderzeichen sowie die Funktionstasten, Löschen (BACK), Umschalten (SHIFT), Leerzeichen (SPACE), Schließen (X) und OK. Dafür benötigen wir nun zwei Strukturen.
Schritt 1.1 - Struktur für die Funktionstasten
struct ButtonFunction {
uint8_t backgroundcolor; //Hintergrundfarbe
uint8_t textcolor; //Textfarbe
int coord_x; //X Koordinate der Schaltfläche
int coord_y; //Y Koordinate der Schaltfläche
int width; //Breite
int height; //Höhe
int roundEdge; //Wert ffür die Rundung der Ecke
String caption; //Text
};
Schritt 1.2 - Struktur für die Schaltflächen Buchstaben, Zahlen & Sonderzeichen
Die Buttons haben alle eine gleiche Größe & Farbe und daher entfallen hier die Attribute für backgroundcolor, textcolor, width & height.
struct Button {
int coord_x; //X Koordinate der Schaltfläche
int coord_y; //Y Koordinate der Schaltfläche
String caption1; //Text normal
String caption2; //Text umgeschaltet
};
Schritt 1.3 - Struktur für das Eingabefeld
Das Eingabefeld hat zusätzlich ein Attribut für eine Rahmenfarbe.
struct InputField {
uint8_t backgroundcolor; //Hintergrundfarbe
uint8_t bordercolor; //Rahmenfarbe
uint8_t textcolor; //Textfarbe
int coord_x; //X Koordinate
int coord_y; //Y Koordinate
int width; //Breite
int height; //Höhe
};
Schritt 2 - Anlegen der Schaltflächen und speichern im Array
Wie erwähnt schreiben wir unseren Code optimiert, dazu reduzieren wir Redundanzen im Code, wo es geht. Die Schaltflächen werden dazu gleich im Array erzeugt, was jetzt nicht so gut lesbar ist, aber die Codezeilen reduziert (Die Belegung des Speichers bleibt dieselbe.).
Da die Zeilen der Tastatur nicht gleichartig aufgebaut sind, habe ich ein zusätzliches Array implementiert, in welchem die Anzahl der Schaltflächen pro Zeile definiert sind.
//Wieviele Schaltflächen sollen pro Zeile angezeigt werden?
int rowButtonCount = {10, 10, 9, 7};
//Maximale Anzahl der Schaltflächen pro Zeile
const int NUM_BUTTONS = 10;
//Anzahl der Zeilen
const int NUM_ROWS = 4;
Button keyboard = {
{ { 0, 0, "1", "!" }, { 0, 0, "2", """ }, { 0, 0, "3", ":" }, { 0, 0, "4", "$" }, { 0, 0, "5", "%" }, { 0, 0, "6", "&" }, { 0, 0, "7", "/" }, { 0, 0, "8", "(" }, { 0, 0, "9", ")" }, { 0, 0, "0", "=" } },
{ { 0, 0, "Q", "q" }, { 0, 0, "W", "w" }, { 0, 0, "E", "e" }, { 0, 0, "R", "r" }, { 0, 0, "T", "t" }, { 0, 0, "Z", "z" }, { 0, 0, "U", "u" }, { 0, 0, "I", "i" }, { 0, 0, "O", "o" }, { 0, 0, "P", "p" } },
{ { 0, 0, "A", "a" }, { 0, 0, "S", "s" }, { 0, 0, "D", "d" }, { 0, 0, "F", "f" }, { 0, 0, "G", "g" }, { 0, 0, "H", "h" }, { 0, 0, "J", "j" }, { 0, 0, "K", "k" }, { 0, 0, "L", "l" } },
{ { 0, 0, "Y", "y" }, { 0, 0, "X", "x" }, { 0, 0, "C", "c" }, { 0, 0, "V", "v" }, { 0, 0, "B", "b" }, { 0, 0, "N", "n" }, { 0, 0, "M", "m" }}
};
Dasselbe machen wir auch für die Schaltflächen der Sonderzeichen:
//Anzahl der Schaltflächen pro Zeile
const int NUM_BTN_SYMBOL = 5;
//Anzahl der Zeilen
const int NUM_BTN_SYMBOL_ROWS = 4;
Button symbols = {
{{ 0, 0, "+", "" }, { 0, 0, "-", "" }, { 0, 0, "/", "" }, { 0, 0, "#", "" }, { 0, 0, "'", "" }},
{{ 0, 0, "_", "" }, { 0, 0, ".", "" }, { 0, 0, ":", "" }, { 0, 0, ",", "" }, { 0, 0, ";", "" }},
{{ 0, 0, "", "" }, { 0, 0, "|", "" }, { 0, 0, "?", "" }, { 0, 0, "!", "" }},
{{ 0, 0, "{", "" }, { 0, 0, "}", "" }, { 0, 0, "", "" }, { 0, 0, "~", "" }}
};
Schritt 3 - Zeichnen der Schaltflächen
Die Schaltflächen haben wir zuvor in einem Array abgelegt und den "Style" in einem weiteren Array definiert, mit diesen Informationen läßt sich nun recht einfach die Schaltfläche zeichnen.
Wie du sicherlich gesehen hast, sind die Koordinaten jeweils mit 0 vorbelegt, diese Koordinaten werden beim Zeichnen berechnet und an die Schaltfläche gespeichert.
//Zeichnen eines Buttons
void drawButton(int row, int btnIndex, Button &button, int offset_X) {
int x = start_X + offset_X;
//Für den ersten Button die Berechnung der neuen X Koordinate überspringen
if (btnIndex > 0) {
x = start_X + (BTN_WIDTH + BTN_MARGIN_HORIZONTAL) + offset_X;
}
// Y Koordinate vom durchlauf zuvor verwenden
int y = start_Y;
lcd.fillRoundRect(x, y, BTN_WIDTH, BTN_HEIGHT, 2, LIGHT_GREY);
lcd.setTextColor(WHITE, LIGHT_GREY);
lcd.setCursor(x + 7, y + 2);
lcd.print(isShiftActive ? button.caption2 : button.caption1);
//Speichern der Koordinaten am Button
button.coord_x = x;
button.coord_y = y;
//Speichern der Koordinaten an den Feldern für den nächsten durchlauf
start_X = x;
start_Y = y;
}
Die Funktionstasten sind ähnlich, jedoch haben diese zusätzliche Attribute welche behandelt werden müssen.
//Zeichnen einer Funktionstaste
void drawFunctionButton(ButtonFunction &button) {
//Wenn die Shift-Taste oder die Symbol-Taste betätigt wurde, dann soll die jeweilige
//Taste mit dunkelgrauem hintergrund dargestellt werden.
if ((button.caption == "SHIFT" && isShiftActive) || (button.caption == "#" && isSymbolActive)) {
lcd.fillRoundRect(button.coord_x, button.coord_y, button.width, button.height, BTN_ROUNDEDGE, DARKER_GREY);
lcd.setTextColor(button.textcolor, button.backgroundcolor);
} else {
lcd.fillRoundRect(button.coord_x, button.coord_y, button.width, button.height, BTN_ROUNDEDGE, button.backgroundcolor);
lcd.setTextColor(button.textcolor, button.backgroundcolor);
}
//Die Leertaste ist deutlich länger und damit der Text zentriert angezeigt wird, muss hier eine If-Bedingung erfolgen.
if (button.caption == "Space") {
lcd.setCursor(button.coord_x + 50, button.coord_y + 3);
} else {
lcd.setCursor(button.coord_x + 6, button.coord_y + 3);
}
lcd.print(button.caption);
}
Schritt 4 - Zeichnen des Eingabefeldes
Das Eingabefeld ist eigentlich nur ein Rechteck in welchem ein Text geschrieben wird. Daher ist das Zeichnen von diesem recht einfach.
void drawInputField(InputField inputField) {
lcd.drawRect(inputField.coord_x, inputField.coord_y, inputField.width, inputField.height, inputField.bordercolor);
lcd.fillRect(inputField.coord_x + 1, inputField.coord_y + 1, inputField.width - 2, inputField.height - 2, BK_GREY);
lcd.setTextColor(inputField.textcolor, inputField.backgroundcolor);
lcd.setCursor(inputField.coord_x + 4, inputField.coord_y + 5);
int maxTextLength = 15;
int textLength = inputText.length();
if (textLength > maxTextLength) {
lcd.print(inputText.substring(textLength - maxTextLength, textLength));
} else {
lcd.print(inputText);
}
}
Da keine TrueType Font zur Verfügung steht habe ich zur ermittlung der maximalen Eingabe den Buchstaben "W" genutzt, es wurde ermittelt das maximal 15 Zeichen in dieses Eingabefeld passt.
struct InputField {
uint8_t backgroundcolor; //Hintergrundfarbe
uint8_t bordercolor; //Rahmenfarbe
uint8_t textcolor; //Textfarbe
int coord_x; //X Koordinate
int coord_y; //Y Koordinate
int width; //Breite
int height; //Höhe
};
Schritt 5 - Anzeigen / Zeichnen der Bildschirmtastatur
Die Funktion showKeyboard wird genutzt um die Bildschirmtastatur zu zeichnen und wird auch aufgerufen wenn die SHIFT / Symbol-Taste betätigt wird.
//Zeigt die Bildschirmtastatur an, wird ebenso verwendet um
//die Bildschirmtastatur neu zu zeichnen.
void showKeyboard() {
//Die Bildschirmtastatur ist sichtbar!
keyboardIsVisible = true;
//Koordinaten der Bildschirmtastatur
start_X = DEFAULT_START_X;
start_Y = DEFAULT_START_Y;
//Hintergrundfarbe
lcd.fillScreen(BK_GREY);
//Rahmen zeichnen
lcd.drawRoundRect(30, 30, 250, 155, 10, DARK_GREY);
//Zeichnen der Funktionstasten
drawFunctionButton(closeBtn);
drawFunctionButton(backBtn);
//Wenn die Symbol-Taste aktiviert ist, dann soll
//die Shift-Taste nicht gezeichnet werden
if (!isSymbolActive) {
drawFunctionButton(shiftBtn);
}
drawFunctionButton(symbolsBtn);
drawFunctionButton(spaceBtn);
drawFunctionButton(okBtn);
//Zeichnen des Eingabefeldes
drawInputField(inputField);
//Wenn nicht die Symbol-Taste aktiviert ist,
//dann soll die normale Tastatur gezeichnet werden.
if (!isSymbolActive) {
//Schleifen über die Arrays
for (int row = 0; row < NUM_ROWS; row++) {
start_X = DEFAULT_START_X;
//Berechnen der X Koordinate für Zeilen größer als 1
if (row > 0) {
start_Y = DEFAULT_START_Y + (row * (BTN_HEIGHT + BTN_MARGIN_VERTIKAL));
}
//Schleife über die Schaltflächen im Array, zusätzlich wird hier aus dem Array
//rowButtonCount die maximale Anzahl entnommen
for (int btnIndex = 0; btnIndex < rowButtonCount; btnIndex++) {
int offset_X = 0;
//Berechnen eines Offsets
if (rowButtonCount < 10 && btnIndex == 0) {
//Abhängig von der Anzahl der Schaltflächen soll die Zeile eingerückt werden.
switch (rowButtonCount) {
case 9: offset_X = BTN_WIDTH / 2; break;
case 7: offset_X = BTN_WIDTH * 1.5 + BTN_MARGIN_HORIZONTAL; break;
}
}
//Zeichnen der Bildschirmtastatur
drawButton(row, btnIndex, keyboard, offset_X);
}
}
} else { //Wenn die Symbol-Taste aktiviert wurde, dann sollen die Sonderzeichen gezeichnet werden
//Die Sonderzeichen sind als Block von 5x4 abgelegt.
for (int row = 0; row < NUM_BTN_SYMBOL_ROWS; row++) {
start_X = DEFAULT_START_X;
if (row > 0) {
start_Y = DEFAULT_START_Y + (row * (BTN_HEIGHT + BTN_MARGIN_VERTIKAL));
}
for (int btnIndex = 0; btnIndex < NUM_BTN_SYMBOL; btnIndex++) {
int offset_X = 0;
if (btnIndex == 0) {
offset_X = 60;
}
drawButton(row, btnIndex, symbols, offset_X);
}
}
}
}
Schritt 6 - Aktionen an der Bildschirmtastatur am ESP32 behandeln
Wie man eine Aktion am Touchscreen am ESP32 behandelt habe ich dir bereits im Beitrag ESP32 Development Board: Touchfunktion programmieren erläutert, hier nutzen wir den Code und wandeln diesen lediglich etwas ab.
//Aktionen an der Bildschirmtastatur behandeln
//Als Parameter werden die geklickten Koordinaten am Display erwartet.
void handleKeyboard(int x, int y) {
//Felder ob die komplette Bildschirmtastatur neugezeichnet werden soll, oder
//nur das Eingabefeld.
bool redrawKeyboard = false;
bool redrawInputField = false;
//prüfen ob die Symbold-Taste aktiviert ist.
//Hintergrund: Es wird geprüft ob sich an einer X/Y Koordinate eine Schaltfläche
//befindet. Da die Bildschirmtastatur jedoch zweischichtig ist, kommt es hier zu
//Überlagerungen von Schaltflächen.
if (!isSymbolActive) {
for (int row = 0; row < NUM_ROWS; row++) {
for (int btnIndex = 0; btnIndex < NUM_BUTTONS; btnIndex++) {
Button button = keyboard;
if (checkCoordButton(button, x, y)) {
redrawInputField = true;
addSignToInputField(isShiftActive ? button.caption2 : button.caption1);
}
}
}
} else {
for (int row = 0; row < NUM_BTN_SYMBOL_ROWS; row++) {
for (int btnIndex = 0; btnIndex < NUM_BTN_SYMBOL; btnIndex++) {
Button button = symbols;
if (checkCoordButton(button, x, y)) {
addSignToInputField(button.caption1);
redrawInputField = true;
}
}
}
}
//Prüfen der Funktionstasten
if (checkCoordButton(closeBtn, x, y)) {
//Hier wird die Schaltfläche X behandelt.
} else if (checkCoordButton(shiftBtn, x, y)) {
//Wenn die Shift-Taste betätigt wurde dann soll der
//boolsche Wert umgekert werden
isShiftActive = !isShiftActive;
//Auf jedenfall soll dann auch die Symboltaste als deaktiviert gelten
isSymbolActive = false;
//neuzeichnen der Bildschirmtastatur, entweder werden nun
//die kleinen Buchstaben oder die großen angezeigt.
redrawKeyboard = true;
} else if (checkCoordButton(symbolsBtn, x, y)) {
isSymbolActive = !isSymbolActive;
isShiftActive = false;
redrawKeyboard = true;
} else if (checkCoordButton(spaceBtn, x, y)) {
//Ein Leerzeichen dem Eingabefeld hinzufügen.
addSignToInputField(" ");
} else if (checkCoordButton(okBtn, x, y)) {
//Hier wird die Schaltfläche OK behandelt.
} else if (checkCoordButton(backBtn, x, y)) {
//Taste zum löschen des letzten Zeichens im Eingabefeld
//Wird jedoch nur ausgehührt wenn die Länge des Feldes größer 0 ist.
if (inputText.length() > 0) {
inputText = inputText.substring(0, inputText.length() - 1);
//nur das Eingabefeld neuzeichnen
redrawInputField = true;
}
}
if (redrawKeyboard) {
showKeyboard();
} else if (redrawInputField) {
drawInputField(inputField);
}
}
Schritt 7 - Einbinden der Bildschirmtastatur in die Loop
In der Funktion loop müssen wir nun nurnoch eine kleine If-Bedingung implementieren in welcher zunächst geprüft wird ob die Bildschirmtastatur sichtbar ist und wenn dieses so ist, dann soll der Klick bzw. die Koordinaten ausgewertet werden.
void loop() {
long currentMillis = millis();
if (lcd.getTouch(&x, &y) == 1 && (lastClick + CLICK_DELAY < currentMillis)) {
lastClick = currentMillis;
if (x > MAX_X || y > MAX_Y) {
return;
}
//Nur wenn die Bildschirmtastatur sichtbar ist, soll diese behandelt werden.
if(keyboardIsVisible){
//Aufrufen der Funktion mit den geklickten Koordinaten.
handleKeyboard(x, y);
}
}
//eine Pause von 50 Millisekunden.
delay(50);
Read the full article
0 notes
Text
Grove 8x8 LED Matrix am Arduino: Einsteigerfreundliche Programmieranleitung
In diesem Beitrag möchte ich dir zeigen, wie du die Grove 8x8 LED Matrix am Arduino UNO R3 programmierst. Der Vorteil von diesem Modul ist es, dass du keine umständliche Verkabelung vornehmen musst, da die Grove Schnittstelle einheitlich ist und ein vorkonfektioniertes Kabel verwendet wird.
Grove 8x8 LED Matrix am Arduino: Einsteigerfreundliche Programmieranleitung
Im Beitrag Arduino Lektion 8: Max7219 8×8 LED Shield habe ich dir bereits ein ähnliches Modul mit dem Chip MAX7219 vorgestellt. Hier soll es nun um eine Matrix mit dem Treiber HT16K33 gehen.
Bezug einer 8x8 LED Matrix mit Grove Schnittstelle
Das mir vorliegende Modul habe ich auf ebay.de für rund 9 € zzgl. Versandkosten erstanden. Du bekommst dieses Modul aber etwas günstiger bei BerryBase für derzeit 8 € zzgl. Versandkosten.
Lieferumfang
Im Lieferumfang der LED Matrix ist neben der Matrix noch ein kleines Grove Kabel für den Anschluss, sowie ein Zettel mit den wichtigsten technischen Daten.
Auf der LED Matrix ist noch eine kleine Schutzfolie, welche du abziehen kannst, ich lasse diese jedoch drauf.
Aufbau der 8x8 LED Matrix
Auf der Rückseite findest du die Grove Schnittstelle, sowie zwei Lötpunkte für die optionale externe Stromversorgung. Des Weiteren kannst du die I2C Adresse 0x70 via 3 Lötbrücken ändern.
I2C Adressen via Lötbrücken
Wenn du die Lötbrücken verbindest, dann kannst du diese Matrix über nachfolgende I2C Adressen ansteuern. Dabei kannst du auch mehrere Muster wählen und so zwischen 8 I2C Adressen auswählen.
Verbundene PinsI2C Adresse-0x70A00x71A10x72A20x72A0 & A10x73A0 & A20x75A1 & A20x76A0, A1 & A20x77
Zur Ermittlung der I2C Adressen habe ich den I2C Scanner von https://playground.arduino.cc/Main/I2cScanner/ verwendet.
Zusätzliche Ressourcen für die Programmierung am Arduino
Damit du diese LED Matrix programmieren kannst, benötigst du entweder
- ein Grove Adapterkabel, oder
- ein Grove Base Shield für den Arduino UNO R3, oder
- ein Seeeduino Nano
Grove Adapterkabel zu Breadboardpins
Grove Base Shield für den Arduino UNO R3
Seeeduino Nano
Das Grove Base Shield hat mehrere Grove Buchsen digital & analog und somit bietet dieses eine sehr große Bandbreite an Möglichkeiten für Projekte. Wenn du lediglich die LED Matrix programmieren möchtest und du hast bereits einen Arduino Nano oder Arduino UNO dann
Programmieren der LED Matrix am Arduino via I2C
Damit die LED Matrix mit HT16K33 Treiber angesteuert werden kann, müssen wir in der Arduino IDE eine zusätzliche Bibliothek installieren. Diese können wir uns als ZIP-Datei vom GitHub Repository Seeed-Studio/Grove_LED_Matrix_Driver_HT16K33 herunterladen.
Weitere Informationen zu diesem Modul findest du auf der englischen Wikiseite von Seeedstudio https://wiki.seeedstudio.com/Grove-LED_Matrix_Driver-HT16K33/.
Anzeigen eines Smileys auf der LED Matrix
Für die Erstellung eines Smileys kannst du den LED Matrix Editor unter https://xantorohara.github.io/led-matrix-editor/ verwenden. Dieser Onlineeditor gibt dir die Möglichkeit, mit der Maus auf der LED Matrix einzelne LEDs zu aktivieren / deaktivieren.
LED Matrix Editor von Xantorohara
Auf der rechten Seite findest du ein Stück Code, welchen du in dein Arduino Programm integrieren kannst. In meinem Fall habe ich ein lachendes Smiley gezeichnet und erhalte den Wert "0x3c4299a581a5423c".
Die Bibliothek liefert zusätzlich ein paar Beispiele, welche mit der default I2C Adresse 0x70 lauffähig sind. Von diesen Beispielen wähle ich zunächst "displaycustom_pictures" und modifiziere dieses etwas.
//Bibliotheken zum kommunizieren mit der LED Matrix
#include
#include "Grove_LED_Matrix_Driver_HT16K33.h"
//Wert für ein lachenden Smiley
const uint64_t smiley = 0x3c4299a581a5423c;
//instanz einer LED Matrix
Matrix_8x8 matrix;
void setup() {
//beginn der I2C kommunikation
Wire.begin();
//beginn der kommunikation mit der LED Matrix
matrix.init();
//setzen der Helligkeit der Matrix
//Werte sind zwischen 0 und 15
//wobei 0 dunkel ist und 15 das hellste
matrix.setBrightness(5);
//In welcher Frequenz die LED Matrix blinken soll,
//Werte sind:
//- BLINK_OFF > kein blinken,
//- BLINK_1HZ > langsames blinken,
//- BLINK_2HZ > schnelles blinken,
matrix.setBlinkRate(BLINK_OFF);
}
void loop() {
//anzeigen eines Bildes
matrix.writeOnePicture(smiley);
//absenden der Daten
matrix.display();
//eine Pause von 10 Sekunden
delay(10000);
}
Auf der Matrix hat man natürlich nur begrenzte Möglichkeiten zur Darstellung von Bildern, jedoch für so kleine Smileys und Pfeile ist dieses bestens geeignet.
lachender Smiley auf der 8x8 LED Matrix
Ausgabe von Scrolltext auf der LED Matrix
Da wie erwähnt die kleine LED Matrix nur begrenzten Platz für Zeichen bietet, gibt es die Möglichkeit Text auf diesem durchscrollen zu lassen.
void loop() {
//Funktion zum anzeigen eines Textes auf der LED Matrix,
//Parameter:
//String - die Zeichenkette welche ausgegeben werden soll,
//Zahl - Wert in Millisekunden pro Zeichen
//Typ
//ACTION_SHIFT - jedes Zeichen einzeln anzeigen,
//ACTION_SCROLLING - den Text durch die Matrix scrollen lassen
matrix.writeString("Hallo Welt!", 1000, ACTION_SCROLLING);
matrix.display();
}
Damit ich das Video aufnehmen konnte, sodass meine Kamera den Text erfasst, habe ich ein kleines Tuch vor die LED Matrix gehängt.
Ändern der default I2C Adresse im Programm
Wenn du bereits Sensoren oder Aktoren am I2C Bus angeschlossen hast, dann kann es vorkommen, dass die default I2C Adresse der LED Matrix bereits belegt ist und du diese im Programm überschreiben musst. (Oder auch, wenn du mehrere solcher Matrixen an einem I2C Bus anschließen möchtest.)
Dazu findest du in der Funktion setup den Aufruf der Funktion "matrix.ini();". Diese Funktion kann einen Parameter vom Typ uint8_t übernehmen und hat als default den Wert des Feldes HT16K33_DEFAULT_I2C_ADDR.
#define HT16K33_DEFAULT_I2C_ADDR 0x70
Wir übergeben also nun den Hexadezimalen Wert, welchen wir aus der Tabelle (siehe I2C Adressen via Lötbrücken) entnehmen können. Und brauchen quasi in unserem Programm nichts weiter anpassen.
matrix.init(0x71);
Vergleich zwischen 8x8 LED Matrix - MAX7219 & HT16K33
Zum Schluss möchte ich dir noch gerne die Unterschiede zur LED Matrix mit dem MAX7219 Chip aufzeigen. Diese LED Matrix verfügt ebenso wie die vorgestellte Matrix über 8x8 LEDs und kann ebenso einfach programmiert werden.
8x8 LED Matrix mit HT16K33 Treiberchip
8x8 LED Matrix mit MAX7219 Treiberchip
Jedoch kannst du diese Matrix zu mehreren zusammenstecken und so eine schier endlose Anzeige aufbauen.
MAX7219 Shields auf einem Stativ
Die LED Matrix mit Grove Schnittstelle jedoch kannst du nicht so kaskadierend aufbauen und somit bist du mit dem Modul in deinen Möglichkeiten stärker beschränkt.
Fazit zur Programmierung der 8x8 LED Matrix mit Grove Schnittstelle am Arduino
Die LED Matrix von Seeedstudio mit Grove Schnittstelle und HT16K33 Treiberchip lässt sich super einfach programmieren. Du benötigst wenig Code und über die I2C Schnittstelle und dem Grovekabel hast du deutlich weniger Verkablung als bei der LED Matrix mit MAX7219, leider vermisse ich hier die Möglichkeit die Module kaskadierend zu verbinden und so ein langes Display für Laufschrift aufzubauen.
Mit dem Online LED Matrix Editor kannst du dir jedoch recht einfach kleine Frames für die Matrix erstellen und in den Code kopieren.
Ausblick
Ich werde nun mal schauen, welche kleinen Projekte man mit dieser Matrix aufbauen kann. Jedoch würde ich eher zu einer RGB Matrix tendieren, denn diese kann bei gleicher Baugröße verschiedenfarbige Pixel anzeigen.
Read the full article
0 notes
Text
Schritt-für-Schritt-Anleitung: OLED-Display am ESP8266 via I2C programmieren
In diesem Beitrag möchte ich dir Schritt-für-Schritt zeigen, wie du ein OLED-Display am ESP8266 programmierst. Ich gehe hier speziell auf den ESP8266 von Ideaspark der hier etwas anspruchsvoller ist, denn dieser zickt manchmal etwas herum und damit du keinen Frust bekommst, sondern Freude an der Programmierung gewinnst ist dieser Beitrag gedacht.
https://youtu.be/iAp3UHIquxU
Zusätzlich werde ich dir auch andere Mikrocontroller zeigen, welche ebenso über ein OLED-Display verfügen und kleine passende Programme dazu.
Heltec HTIT-W8266
ESP8266 von Ideaspark
ESP8266 von Wemos
Wemos D1 Mini Pro mit OLED Shield
Schritt-für-Schritt-Anleitung zum Programmieren eines OLED-Display am ESP8266
Hier folgt nun die Schritt-für-Schritt-Anleitung, wie du dein OLED-Display programmieren kannst.
-
-
Bibliothek einbinden > U8g2 in unser leeres Projekt ein.
einbinden der Bibliothek U8g2
Wobei wir von diesen drei Bibliotheken zunächst nur eine benötigen, die U8g2lib.h.
#include
Als Nächstes definieren wir unser OLED Display, in meinem Fall habe ich ein 128x64 Pixel Display welches über I2C angeschlossen wurde. Als default Adresse wird hier 0x3c verwendet, welche wir für die beiden Mikrocontroller von Wemos & Ideaspark nicht anpassen müssen.
Einzig müssen wir die I2C Pins anpassen, welche wir der Objektinstanziierung übergeben. Welche I2C Pins du verwenden musst, kannst du aus dem Pinout des Mikrocontrollers übernehmen.
//das OLED Display ist über I2C angeschlossen
#define SDA_PIN 12
#define SCL_PIN 14
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL_PIN, SDA_PIN, U8X8_PIN_NONE);
Da wir im ersten Beispiel nur den Text "Hallo Welt!" anzeigen wollen, reicht es aus den Code in die Setup-Funktion zu schreiben.
Eine Liste mit allen verfügbaren Schriftarten findest du unter https://github.com/olikraus/u8g2/wiki/fntlistall.
//beginn der Kommunikation mit dem Display
u8g2.begin();
//leeren des Speichers
u8g2.clearBuffer();
//setzen der Schriftart
u8g2.setFont(u8g2_font_ncenB08_tr);
//Schreiben des Textes "Hallo Welt!",
//an die Spalte 0, Zeile 10
u8g2.drawStr(0, 10, "Hallo Welt!");
//Anzeigen des Textes
u8g2.sendBuffer();
Das Programm erzeugt wie erwartet auf dem OLED-Display des ESP8266 von Ideaspark die Ausgabe von "Hallo Welt!" in der ersten Zeile, welche bei diesem Mikrocontroller bzw. Display gelb ist.
Ausgabe von "Hallo Welt!" auf dem Mikrocontroller ESP8266 von Ideaspark
Ausgabe von "Hallo Welt!" auf dem Mikrocontroller ESP8266 von Wemos
Der ESP8266 von Wemos hat auf der Rückseite die Beschriftung für die I2C Pins (SDA-D1 & SCL-D2) welche wir im Code entsprechend anpassen müssen. Wenn dieses geschehen ist, dann ist das kleine Programm auch auf diesem lauffähig und der Text "Hallo Welt!" wird angezeigt.
Beispiel - U8g2, Ausgabe "Hallo Welt!" auf OLED-Display am ESP8266Herunterladen
Schritt 4 - Ausgabe von "Hallo Welt!" auf dem OLED-Display mit Adafruit SSD1306
Bauen wir nun das kleine Beispiel mit der Bibliothek von Adafruit auf, um einen Vergleich zu haben. Die Bibliothek von Adafruit ist nicht nur größer, sondern bietet auch deutlich mehr Features und ist somit deutlich mächtiger als U8g2.
Schritt 4.1 - Einbinden der Bibliothek in die Arduino IDE
Zunächst binden wir wieder die benötigte Bibliothek über den Bibliotheksverwalter der Arduino IDE ein. Dazu klicken wir wieder auf der linken Seite auf das Symbol vom Bibliotheksverwalter (1) und suchen nach "Adafruit SSD1306" (2). Aus den Suchergebnissen wählen wir die Schaltfläche "INSTALLIEREN" (3) im Eintrag "Adafruit SSD1306 von Adafruit" aus. Wenn diese Bibliothek installiert ist, wird dir dieses über den Tag (4) angezeigt.
Bibliothek - Adafruit SSD1306 im Bibliotheksverwalter der Arduino IDE
Installieren der Abhängigkeiten von der Bibliothek Adafruit SSD1306
Die Bibliothek Adafruit SSD1306 hat einige Abhängigkeiten, welche wir zusätzlich installieren müssen. In dem Dialog wählen wir "ALLE INSTALLIEREN" aus.
Schritt 4.2 - Aufbau des Programmes
Auch hier binden wir die Bibliothek über Sketch> Bibliothek einbinden > Adafruit SSD1306 in unser leeres Projekt ein.
einbinden der Bibliothek Adafruit SSD1306
Von den beiden eingebundenen Bibliotheken benötigen wir jedoch lediglich Adafruit_SSD1306.h.
#include
#include
Jedoch müssen wir noch zusätzlich die Wire.h Bibliothek hinzufügen.
Nun müssen wir unser Display noch konfigurieren. Das hier verwendete OLED Display hat eine Auflösung von 128x64 Pixel. Die I2C Pins sind SDA - D1 & SCL - D2.
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C
#define SDA D1
#define SCL D2
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
In der Funktion setup müssen wir nun noch die I2C Kommunikation einrichten. Dazu habe ich zuvor die beiden Felder SDA & SCL angelegt.
void setup() {
...
Wire.begin(SDA, SCL);
...
}
Da ich wie zuvor auch lediglich den Text "Hallo Welt!" anzeigen möchte, reicht es wieder den Text in der Funktion setup zu schreiben.
void setup() {
Serial.begin(9600);
Wire.begin(SDA, SCL);
if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println("Verbindung mit dem Display nicht möglich!");
while (true)
;
}
Serial.println("Hallo");
display.display();
delay(2000);
display.clearDisplay();
display.setTextSize(3);
display.setTextColor(SSD1306_WHITE);
display.setCursor(10, 0);
display.println("Hallo Welt!");
display.display();
}
Wenn das Programm auf dem Mikrocontroller ausgeführt wird, dann wird zunächst das Logo von Adafruit angezeigt und danach der Text "Hallo Welt!". Da der Text länger als der verfügbare Platz ist, wird dieser automatisch umgebrochen.
Alternativ können wir jetzt über die Funktion setTextSize die Textgröße anpassen. In der offiziellen englischen Dokumentation findest du weitere Informationen zu den Funktionen rund um Schrift & Fonts.
Für das OLED Display am ESP8266 von Ideaspark musst du die Felder für die I2C Pins anpassen (SDA - D6 & SCL - D5).
Adafruit SSD1306 - Beispiel, Ausgabe von "Hallo Welt!" auf einem OLED-DisplayHerunterladen
Fazit - Programmieren eines OLED-Display am ESP8266
Die Integration und Verwendung der beiden Bibliotheken U8g2 & Adafruit SSD1306 gestalten sich unkompliziert. Jede Bibliothek bietet Beispiele, die theoretisch direkt auf deinen Mikrocontroller hochgeladen werden können. Allerdings sind bei Verwendung des ESP8266 einige Anpassungen erforderlich, da die I2C-Pins nicht immer den Standardpins entsprechen.
Als nächster Schritt werde ich erforschen, wie Grafiken auf diesen Displays dargestellt werden können, und dazu einen entsprechenden Beitrag veröffentlichen.
Read the full article
0 notes
Text
Shelly Plus PM Mini: Cleverer Einsatz für eine intelligente Energieüberwachung
Wie du mit dem Shelly Plus PM Mini intelligent deine Stromverbraucher überwachen kannst, erfährst du hier in meinem neuen Beitrag. Mit dem kleinen Shelly Plus PM Mini kannst du zwei Verbraucher gleichzeitig überwachen und das mit einer Leistung von 3840W. Somit kannst du deine Waschmaschine, welche im Keller steht, überwachen und wenn diese Fertig ist dir eine Pushbenachrichtigung senden lassen, aber dazu später mehr.
https://youtu.be/wEUXLevuE-g
Disclaimer: Der Shelly Plus PM Mini wurde persönlich erworben, während die dritte Generation des Shelly-Produkts für diesen Beitrag freundlicherweise von der Firma Shelly zur Verfügung gestellt wurde. Diese Sponsoring-Zusammenarbeit ermöglicht es, einen objektiven Vergleich der beiden Produkte zu präsentieren. Die Meinungen im Beitrag spiegeln jedoch stets meine eigene Erfahrung und unabhängige Sichtweise wider.
Technische Daten des Shelly Plus PM Mini
Schauen wir uns zunächst den Shelly Plus PM Mini genauer an und vergleichen diesen auch gleich einmal mit der neuen Version.
Shelly Plus PM Mini Shelly Plus PM Mini Gen. 3Preis15,35 €max. Messspannung240 VACmax. Messstrom16 Amax. Messleistung3840 WFeaturesinterner TemperatursensorWiFi2,4 GHz, 802.11 b/g/n
bis zu 30 m drinnen, 50 m draußenCPUESP32ESP-Shelly-C38FSpeicher4 MB Flash8 MB FlashVergleich der technischen Daten des Shelly Plus PM Mini & Gen. 3
Aus der Tabelle können wir entnehmen, dass die Leistung beider Geräte gleich sind, ausgenommen von der CPU und dem Speicher. Ein weiterer Unterschied ist, dass bei dem neuen Gerät Kabel mit größerem Querschnitt angeschlossen werden können. Dadurch das der Preis auch gleich ist, würde ich derzeit zum neuen Gerät tendieren, denn dieses ist mit der leistungsst��rkeren CPU auch besser für kommende Features gerüstet.
Aufbau der Schaltung - Shelly Plus PM Mini zum Messen von zwei Verbraucher
Wie du einen Shelly zum Messen von Stromverbrauch in eine Schaltung einbaust, habe ich dir bereits anhand des Shelly Plus 1 PM gezeigt. An diesem Shelly haben wir jedoch "nur" vier Schraubanschlüsse, welche mit N, L, O, O (v.r.n.l.) bezeichnet sind.
Jedem Shelly liegt eine kleine Anleitung bei, aus welcher wir zusätzlich entnehmen können, wie die Schaltung aufgebaut wird. Auf der Seite https://kb.shelly.cloud/knowledge-base/shelly-plus-pm-mini findest du die offizielle englische Seite mit der Dokumentation zu diesem Gerät.
Aus der Grafik können wir nun entnehmen, dass die Verbraucher mit dem Leiter "L" mit dem Shelly verbunden werden. Die Stromquelle des Shellys wird hierbei an die Verbraucher durchgeschleift.
Ich habe dir hier einfach mal exemplarisch eine Lampe und eine Steckdose in die Grafik eingebaut, du kannst natürlich auch zwei Steckdosen einbauen und messen. Du musst jedoch beachten, dass die Summe der Leistung niemals über das Maximum von 3840 Watt erreicht wird!
Da ich viel mit den Shellys experimentiere, habe ich mir etwas gebastelt an welchem ich eine Lampe, Steckdose, Schalter und Taster habe. Mit diesem kann ich die meisten Schaltungen, welche du im Smarthome erstellen kannst, nachstellen.
Als Zuleitung benutze ich ein 3 adriges, flexibles Kabel mit einem Schukostecker.
Besonderheiten des Shelly Plus PM Mini
Der hier vorgestellte Shelly hat kein Relais und kann somit keinen Verbraucher schalten! Du kannst somit nur den Stromverbrauch messen. Auch wird dir in der App der kumulierte Verbrauch angezeigt, dir fehlt also eine separate Anzeige für den Stromverbrauch der beiden Kanäle.
Wenn du einen Verbraucher schalten und den Stromverbrauch messen möchtest, dann benötigst du einen Shelly Plus 1PM Mini oder den Shelly 1PM.
Shelly Plus 1PM Mini
Shelly 1 PM - Vorderseite
Einrichten in der App - Shelly Smart Controll
Wenn wir die Schaltung wie folgt aufgebaut haben, dann können wir dieses smarte Gerät in der App Shelly Smart Controll einrichten. Die App Shelly Smart Controll bekommst du für iOS und Android in den einschlägigen Stores kostenfrei zum download.
Ich gehe im nachfolgenden davon aus, dass du dir die App bereits eingerichtet hast und wir somit gleich mit dem Einbinden des Shelly beginnen können.
Das kleine smarte Gerät kann mit wenigen Klicks in der App eingerichtet werden und wird zum Schluss in die Cloud eingebunden. Mit dem Feature der Cloud kannst du quasi von jedem Punkt der Welt aus auf dein Gerät zugreifen (vorausgesetzt du hast Internet).
Um ein neues Gerät einzurichten müssen wir zunächst auf das kleine blaue Plus unten rechts klicken.
Im nächsten Schritt wählen wir im neuen Dialog "+ Fügen Sie ein neues Gerät hinzu" aus.
Der kleine Shelly Plus PM Mini verfügt über Bluetooth und kann somit recht einfach darüber hinzugefügt werden.
Daher wählen wir hier den ersten Auswahlpunkt aus und klicken auf "Weiter".
In meinem Fall wurde das Gerät nach wenigen Sekunden gefunden.
Sollte dein Gerät nicht gefunden werden so kannst du über den RESET-Taster auf der Rückseite des Gerätes diesen zurücksetzen.
Die Shellys arbeiten nur in einem 2,4 GHz Netzwerk, ich habe hier ein separates Netzwerk für diese eingerichtet und das wurde automatisch gefunden, somit muss ich nur die Schaltfläche "+ Gerät hinzufügen" wählen.
Das Gerät wird nun in das Netzwerk eingebunden, dieser Vorgang kann etwas dauern und auch bleibt scheinbar der Prozess stehen, aber in jedem Fall wird das Gerät eingerichtet.
Im nächsten Schritt vergeben wir dem Gerät einen Namen, da ich den Shelly später an eine Waschmaschine anschließen möchte, vergebe ich den Namen "Waschmaschine" und bestätige diese Auswahl mit "Weiter".
Zum Abschluss wählen wir noch einen Raum aus und beenden diesen Prozess mit dem klick auf "Speichern".
Der Shelly wird nun mit dem Konto verknüpft und kann später somit in der Cloud gefunden werden.
Wenn das Gerät in der App hinzugefügt wurde, dann wartet die App auf eine Verbindung. Diese Zeit kann man etwas verkürzen, indem man den kleinen RESET-Taster auf der Rückseite betätigt.
In meinem Fall habe ich in die Schaltung eine 15W LED eingebaut, welche jetzt leuchtet und der Verbrauch wird mir sogleich angezeigt.
Du kannst jetzt in der App den aktuellen Verbrauch sowie den Verbrauch in der Vergangenheit einsehen.
In dem oben verlinkten YouTube-Video erläutere ich dir zusätzlich, wie du jetzt noch eine intelligente Szene erstellen kannst, um dir eine Benachrichtigung senden zu lassen.
Read the full article
0 notes
Text
ESP32 Development Board mit 2,8 Zoll Touch Display: Programmieren für Anfänger
In diesem Beitrag möchte ich dir ein ESP32 Development Board mit Touch Display vorstellen und zeigen wie dieser programmiert wird.
https://youtu.be/xEy-4FJiRHs
Ein herzliches Dankeschön an lowstreaming für die großzügige Unterstützung mit dem ESP32 Mikrocontroller. Diese Geste ermöglicht mir, die spannenden Möglichkeiten des Mikrocontrollers und des 2,8 Zoll (ca. 7 cm) Touch Displays zu erkunden und gemeinsam Lösungen zu finden. Deine Unterstützung macht diese technologische Reise besonders inspirierend. Vielen Dank!
Bezug
Diesen Mikrocontroller bekommst du auf ebay.de für derzeit knapp 18 €* inkl. Versandkosten.
Auf alieexpress.com findest du dieses Modul unter "ESP32 Development Board 2.8inch LCD TFT" jedoch deutlich günstiger, jedoch musst du dort mit einer längeren Lieferzeit rechnen.
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Lieferumfang
Zum Lieferumfang gehört neben dem Mikrocontroller noch:
- ein Micro-USB-Kabel,
- ein Stift für den Touch Screen,
- ein Anschlusskabel
Pinout des ESP32 Development Board 2.8inch LCD TFT
Schauen wir uns zunächst den Aufbau des ESP32 Development Boards an. Auf der Vorderseite findest du das 2,8 Zoll TFT Touch Display. Auf der Rückseite wird es schon spannender, denn dort findest du einige Schnittstellen.
Aufbau ESP32 Development Board mit 2,8 Zoll TFT Touch Display
An den beiden seitlichen Schnittstellen kannst du zusätzliche Sensoren / Aktoren anschließen und programmieren. Des Weiteren findest du noch eine RGB LED, an welcher du die Farben separat via PWM Signal steuern kannst (es ist also keine WS18B20 LED oder ähnliches).
Beschriftung der Schnittstellen und RGB LED am ESP32 Development Board
Technische Daten des ESP32 Development Board mit 2,8 Zoll Touch Display
ModellESP32-2432S028RProzessorESP32-WROOM-32(ESP32-D0WDQ6)
Espressif ESP32 32 Bit Dual Core ProzessorBildschirmTFT Display mit ILI9341 Treiber,
Auflösung: 240 px x 320 px,
2,8 Zoll (ca. 7 cm) TFT-Display, TouchscreenBetriebstemperatur -20 bis + 70 °CVersorgungsspannung5V, ca. 90 mAGewicht44 gModulgröße8,6 cm x 5,4 cm
Anschluss an den Computer und installieren des CH340 Treibers
Wenn du diesen Mikrocontroller an deinen Computer mit dem mitgelieferten Micro-USB-Kabel anschließt, dann sollte dieser sofort erkannt werden.
Wenn dieser nicht erkannt wird, wie in der Grafik zu sehen, dann musst du den Treiber für den USB-Serial Converter CH340 installieren. Diesen Treiber kannst du dir unter https://www.wch.cn/download/CH341SER_ZIP.html herunterladen.
Die Webseite ist leider auf Chinesisch, aber du kannst dir diese recht einfach im Browser mit wenigen Klicks übersetzen lassen.
Programmieren des ESP32 Development Board in der Arduino IDE
Zunächst möchte ich dieses Board in der Arduino IDE programmieren.
Sämtlichen Quellcode von den Beispielen findest du auch auf meinem GitHub Repository unter StefanDraeger/ESP32_Development_Board_ESP32-2432S028R.
Installieren des Boardtreibers für den ESP32
Dazu muss zunächst der Boardtreiber für den Mikrochip ESP-WROOM-32 installiert werden.
Im ersten Schritt müssen wir wie erwähnt den Boardtreiber installieren, dazu navigieren wir zu den Einstellungen und wählen dort die Schaltfläche hinter "Zusätzliche Boardverwalter URLs"(1).
Im neuen Dialog geben wir nun die nachfolgende Adresse(2) ein.
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Und bestätigen dieses mit der Schaltfläche OK (3).
Jetzt können wir zum Boardverwalter (4) wechseln und nach ESP32(5) suchen. Aus der Ergebnisliste wählen wir im Eintrag "esp32 von Espressif Systems" (6) die Schaltfläche INSTALLIEREN. In meinem Falle ist diese bereits in der derzeit aktuellen Version 2.014 installiert und ich habe hier die Schaltfläche ENTFERNEN (7).
Programmieren der RGB LED
Auf der Rückseite des ESP32 Development Boards findest du eine RGB LED, welche du über die nachfolgenden Pins via PWM Signal steuern kannst.
- Rot > IO17
- Grün > IO4
- Blau > IO16
Beispiel - setzen einer Farbe an der RGB LED via PWM Signal
Auf der Seite https://www.rapidtables.com/web/color/RGB_Color.html findest du einen einfachen ColorPicker aus welchem du dir eine Farbe auswählen und den RGB Wert ablesen kannst.
Diesen RGB Wert (R = red, G = green, B = blue) setzt sich aus den Farben rot, grün und blau zusammen. Diese Farbe kannst du dann mit der Funktion "analogWrite(, )" setzen.
//RGB LED
//LED, Farbe rot
#define ledRed 17
//LED, Farbe grün
#define ledGreen 4
//LED, Farbe blau
#define ledBlue 16
void setup() {
//definieren das die Pins als Ausgang dienen
pinMode(ledRed, OUTPUT);
pinMode(ledGreen, OUTPUT);
pinMode(ledBlue, OUTPUT);
//setzen der Farbe lila an der RGB LED
//Farbe rot mit 178 von max. 255
analogWrite(ledRed, 178);
//Farbe grün mit 102 von max. 255
analogWrite(ledGreen, 102);
//Farbe blau mit dem maximalen Wert von 255
analogWrite(ledBlue, 255);
}
void loop() { }
Wenn der Quellcode nun übertragen wurde, dann sollte die RGB LED in der Farbe Lila aufleuchten.
Programm - setzen der Farbe Lila an der RGB LED des ESP32 Development BoardHerunterladen
Beispiel - anzeigen aller Farbkombinationen an der RGB LED
Wir können jetzt mit drei For-Schleifen alle Farbkombinationen auf der RGB LED aufleuchten lassen. Dazu müssen wir lediglich in jeder Schleife den entsprechenden Farbwert setzen.
//RGB LED
//LED, Farbe rot
#define ledRed 17
//LED, Farbe grün
#define ledGreen 4
//LED, Farbe blau
#define ledBlue 16
void setup() {
//definieren das die Pins als Ausgang dienen
pinMode(ledRed, OUTPUT);
pinMode(ledGreen, OUTPUT);
pinMode(ledBlue, OUTPUT);
}
void loop() {
//For-Schleifen über die einzelnen Farbwerte
for (int red = 0; red < 255; red++) {
//setzen der Farbe rot mit dem aktuellen Wert aus der For-Schleife
analogWrite(ledRed, red);
for (int green = 0; green < 255; green++) {
//setzen der Farbe grün mit dem aktuellen Wert aus der For-Schleife
analogWrite(ledGreen, green);
for (int blue = 0; blue < 255; blue++) {
//setzen der Farbe blau mit dem aktuellen Wert aus der For-Schleife
analogWrite(ledBlue, blue);
//eine kleine Pause von 25 Millisekunden
delay(25);
}
}
}
}
TFT-Touchdisplay programmieren
Als Nächstes möchte ich dir gerne zeigen, wie das TFT-Touchdisplay programmiert wird.
Installieren der benötigten Bibliothek zum Ansteuern des TFT-Touchdisplays
Bevor wir Text, Bilder oder geometrische Formen auf dem TFT-Display anzeigen können, müssen wir eine Bibliothek installieren.
In der Arduino IDE öffnen wir dazu den Bibliotheksverwalter (1) und suchen dort nach "TFT_eSPI" (2), um diese Bibliothek jetzt zu installieren, müssen wir auf die Schaltfläche "INSTALLIEREN" klicken.
In meinem Fall habe ich diese Bereits installiert und bei mir wird die Schaltfläche "ENTFERNEN" angezeigt.
Diese Bibliothek kommt mit sehr vielen Beispielen daher, welche wir jedoch erst nach einer kleinen Änderung i lauffähig auf den Mikrocontroller aufspielen können.
Konfiguration für das TFT-Display setzen
Bevor wir jedoch mit dem TFT-Display arbeiten können, müssen wir die Konfiguration setzen, diese geben wir in der Datei "User_Setup.h" ein. Die Datei findest du im Ordner C:Users%username%DocumentsArduinolibrariesTFT_eSPI
Es ist ratsam sich von der originalen Datei eine kopie zu erstellen so das man ggf. noch andere Displays später programmieren kann.
Die nachfolgende Konfiguration habe ich vom GitHub Repository https://github.com/OttoMeister/ARDUINO_ESP32-2432S028R entnommen und funktioniert für den hier gezeigten Mikrocontroller.
#define ILI9341_2_DRIVER
#define TFT_WIDTH 240
#define TFT_HEIGHT 320
#define TFT_BL 21
#define TFT_BACKLIGHT_ON HIGH
#define TFT_MOSI 13
#define TFT_SCLK 14
#define TFT_CS 15
#define TFT_DC 2
#define TFT_RST 12
#define TFT_BL 21
#define TOUCH_CS 33
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT
#define SPI_FREQUENCY 55000000
#define SPI_READ_FREQUENCY 20000000
//Touch Screen: ?????????ß
#define XPT2046_IRQ 36
#define XPT2046_MOSI 32
#define XPT2046_MISO 39
#define XPT2046_CLK 25
#define XPT2046_CS 33
#define SPI_TOUCH_FREQUENCY 2500000
Beispiel - Text "Hallo Welt!" auf dem TFT-Display anzeigen
Schreiben wir zunächst auf das TFT-Display den Text "Hallo Welt!" in unterschiedlicher Textgröße, Farbe und Position.
//Bibliothek zum ansteuern des TFT Displays
#include
#include
//Datei mit den definierten Schriftarten
#include "Free_Fonts.h"
//eine instanz vom TFT Display Objekt erstellen
TFT_eSPI tft = TFT_eSPI();
void setup(void) {
//beginn der kommunikation mit dem TFT Display
tft.init();
//drehen des Displays
tft.setRotation(3);
//Hintergrundfarbe auf Schwarz setzen
tft.fillScreen(TFT_BLACK);
//Textfarbe Magenta mit Hintergrundfarbe Schwarz
tft.setTextColor(TFT_MAGENTA, TFT_BLACK);
//Schriftart FSB9 setzen
tft.setFreeFont(FSB9);
//den Cursor an die Position x=10 & y=45 setzen
tft.setCursor(10, 45);
//den Text "Hallo Welt!" an die gesetzte Cursorposition
//schreiben
tft.print("Hallo Welt!");
//Weitere Texte mit unterschiedlichen Farben, Positionen und
//Schriftgrößen auf dem TFT-Display anzeigen
tft.setTextColor(TFT_VIOLET, TFT_BLACK);
tft.setFreeFont(FSB12);
tft.setCursor(10, 65);
tft.print("Hallo Welt!");
tft.setTextColor(TFT_PINK, TFT_BLACK);
tft.setFreeFont(FSB18);
tft.setCursor(10, 95);
tft.print("Hallo Welt!");
tft.setTextColor(TFT_GREEN, TFT_BLACK);
tft.setFreeFont(FSB24);
tft.setCursor(10, 130);
tft.print("Hallo Welt!");
}
void loop() {
}
Der Code bewirkt nun das auf dem Display der Text "Hallo Welt!" in unterschiedlichen Textgrößen, Farben und Positionen angezeigt wird.
Programm - schreiben von Text auf dem TFT-Display des ESP32 Development BoardHerunterladen
Beispiel - Bild auf dem TFT-Display anzeigen
Zur Bibliothek TFT_eSPI erhältst du wie erwähnt sehr viele Beispiele, eines davon ist "LittleFS_PNG". Dieses Beispiel demonstriert wie du ein Bild auf dem Display anzeigen lassen kannst.
Einrichten eines LittleFS Dateisystems auf dem ESP32
Das LittleFS ist ein eigenes kleines, leichtgewichtiges Dateisystem welches auf Embeddedsystems wie dem ESP32 anwendung findet. Die Dateien werden dabei auf dem ESP32 Chip gespeichert und nicht auf der SD-Karte!
Damit du Daten auf den Chip in diesem speziellen Format speichern kannst, benötigst du ein Plugin als JAR-Datei, jedoch kann du dieses nur in die klassische Arduino IDE (Version 1.8.x) integrieren.
Ich habe mir nun die derzeitige Version 1.8.19 als ZIP-Datei heruntergeladen und entpackt. Im nächsten Schritt muss nun der Pfad wiefolgt angelegt werden arduino-1.8.19toolsESP32FStool und in diesen Ordner die Datei esp32fs.jar abgelegt werden.
Ablegen von Dateien auf dem LittleFS Dateisystems
In meinem Fall wechsel ich jetzt also nun von der neuen Arduino IDE 2.x zur klassischen Version um eine Datei auf den Mikrocontroller hochzuladen.
Das Plugin findest du unter Werkzeuge > ESP32 Sketch Data Upload.
Wenn nun auf den Menüeintrag "ESP32 Sketch Data Upload" geklickt wird, öffnet sich ein Dialog in welchem wir das Dateisystem auswählen.
Im Ersten durchgang existiert der Ordner "data" im Sketch Ordner nicht und daher muss dieser zunächst angelegt werden. Daher bestätigen wir diesen Dialog mit der Schaltfläche "Yes".
Wenn der Ordner und der Mikrocontroller vorbereitet wurden dann wird dir dieses in der Konsole mit dem Text "Hard resetting via RTC pin..." angezeigt.
Wir können jetzt mit der Tastenkombination Strg + K oder über das Menü Sketch > Sketch-Ordner anzeigen in den Sketch Ordner wechsel und sollten nun einen zusätzlichen Ordner "data" sehen.
Dieser Data liegt quasi paralell zur unserer INO-Datei.
Read the full article
0 notes
Text
Datenpanne? Kein Problem mit MiniTool Data Recovery V11.8
Datenverlust kann in einem Augenblick alles verändern. Ein falscher Klick, ein unerwarteter Systemabsturz, und wichtige Dateien sind verschwunden. Vor einem Jahr stellte ich die Version 11.4 von MiniTool Data Recovery vor und betonte die Notwendigkeit solcher Tools. Heute präsentiere ich die überarbeitete Version 11.8, die noch effizienter und zuverlässiger ist.
https://youtu.be/O_1510D6_sw
Ein Beispiel aus dem Alltag verdeutlicht die Wichtigkeit: Stundenlange Arbeit an einem Projektbericht gehen durch einen Systemabsturz verloren. Hier kommt MiniTool Data Recovery V11.8 ins Spiel, um verlorene/gelöschte Dateien auf verschiedenen Speichergeräten wiederherzustellen. Entdecken Sie in diesem Artikel, warum ein zuverlässiges Datenrettungstool unverzichtbar ist, und erfahren Sie mehr über die neuen Funktionen von Version 11.8. Datenverlust muss nicht das Ende bedeuten – MiniTool steht bereit, um Ihre wertvollen Dateien zu retten.
MiniTool Data Recovery V11.8 im Fokus
Unterstützte Datenträger
Egal, ob Sie Daten von einer Festplatte, einer SSD, einem USB-Laufwerk, einer SD-Karte oder einem anderen Speichermedium wiederherstellen müssen – MiniTool Data Recovery V11.8 steht Ihnen zur Seite. Hier finden Sie eine Übersicht der unterstützten Datenträger:
DatenträgerHDD (Festplatten)SSD (Solid State Drives)USB-LaufwerkeSD-KartenAndere Speichergeräte
Unterstützte Dateiformate
Für eine umfassende Datenrettung bietet MiniTool Data Recovery V11.8 eine Vielzahl unterstützter Dateiformate. Egal, ob es sich um Dokumente, Bilder, Videos, Archive oder E-Mails handelt – die Software deckt eine breite Palette ab. Hier finden Sie eine detaillierte Auflistung:
BezeichnungUnterstützte DateiformateDokumenteDOC, DOCX, XLS, XLSX, PPT, PPTX, PDF, VSD, MPP, PUB, ODT, ODS, usw.BilderJPG, JPEG, TIFF, TIF, PNG, GIF, PSD, BMP, CRW, DCR, DNG, ARW, PSP, usw.VideoMP4, MP3, MKV, AVI, MPEG, FLV, RM/RMVB, MID/MIDI, WMA, WAV, OGG, usw.ArchiveZIP, 7Z, RAR, CAB, JAR, usw.E-MailsPST, DBX, EMLX, usw.AndereHTM/HTML, TXT, XML, HLP, CHM, PZF, ICC, MHT, QPW, QXP, QPT, VEG, usw.
Schnell und Effektiv: Die Drei Schritte zur Datenrettung
Ein herausragendes Merkmal von MiniTool Power Data Recovery ist der "Schnelle Scan", der eine zügige und erfolgreiche Dateiwiederherstellung ermöglicht. Dieses Feature macht dieses kostenlose Datenrettungstool besonders mächtig.
Wie können gelöschte Dateien auf dem PC oder externen Festplatten mit diesem schnellen Verfahren wiederhergestellt werden? Solange die Dateien noch vorhanden und nicht überschrieben wurden, gewährleistet MiniTool Power Data Recovery eine mühelose Wiederherstellung in nur 3 einfachen Schritten:
1. Ein Gerät zum Scannen wählen:
- Starten Sie MiniTool Power Data Recovery und wählen Sie das betroffene Gerät aus, von dem Sie Daten wiederherstellen möchten. Dies kann Ihre interne Festplatte, eine externe Festplatte, ein USB-Laufwerk oder eine andere Speicherquelle sein.
2. Die gefundenen Dateien in der Vorschau anzeigen:
- Der Schnelle Scan durchsucht das ausgewählte Gerät rasch nach verlorenen Dateien. Nach Abschluss des Scans präsentiert Ihnen MiniTool Power Data Recovery eine Vorschau der gefundenen Dateien. Sie erhalten die Möglichkeit, sich einen Überblick über die wiederherstellbaren Elemente zu verschaffen.
3. Dateien zum Speichern wählen:
- Nachdem Sie die Vorschau durchgesehen haben, wählen Sie die gewünschten Dateien aus, die Sie wiederherstellen möchten. MiniTool Power Data Recovery ermöglicht es Ihnen, gezielt einzelne Dateien oder ganze Ordner auszuwählen.
Die ausgewählte Datei kann dann in drei einfachen Schritten auf deinem Computer gespeichert werden.
Die einfache Anwendung des schnellen Scans in nur drei Schritten macht MiniTool Power Data Recovery zu einem effizienten Werkzeug für die rasche Rettung Ihrer verlorenen Dateien. Nutzen Sie diese Funktion, um ohne Aufwand wichtige Daten zurückzuholen und Ihrem digitalen Leben eine Extra-Sicherheit zu verleihen.
Die kostenfreie Version von MiniTool Data Recovery hat als Einschränkung jedoch, dass maximal 1 GB an Daten wiederhergestellt werden können. D.h. möchten Sie mehr als diese Beschränkung wiederherstellen, so benötigen Sie ein Upgrade.
Upgrade auf das Monatliche oder jährliche Abo: Erweiterte Vorteile für Anspruchsvolle
Während die kostenlose Version von MiniTool Data Recovery bereits beeindruckende Funktionen bietet, eröffnen die kostenpflichtigen Abonnements eine neue Dimension der Datenwiederherstellung. Hier sind einige der herausragenden Vorteile, die Sie mit dem Monatlichen oder jährlichen Abo erhalten:
1. Unbegrenzte Datenwiederherstellung:
- Mit dem kostenpflichtigen Abo haben Sie uneingeschränkten Zugriff auf die Datenwiederstellungsfunktionen. Vergessen Sie Beschränkungen in der Datenmenge und stellen Sie so viele Dateien wieder her, wie Sie benötigen.
2. Mehrere PC-Unterstützung:
- Während die kostenlose Version nur einen PC unterstützt, ermöglichen die Abonnements die Nutzung auf mehreren Computern. Dies ist besonders vorteilhaft, wenn Sie mehrere Geräte sichern oder Daten auf verschiedenen PCs wiederherstellen müssen.
3. Schnellerer Zugriff auf vorherige Scanergebnisse:
- Mit dem Monatlichen oder jährlichen Abo können Sie Scanergebnisse Ihrer früheren Wiederherstellungen schneller laden. Dies spart Zeit und ermöglicht einen effizienteren Wiederherstellungsprozess.
4. Datei-Previewer inklusive:
- Nutzen Sie den integrierten Datei-Previewer, um einen Blick auf wiederherstellbare Dateien zu werfen, bevor Sie sie wiederherstellen. Dieses Feature ist besonders nützlich, um sicherzustellen, dass Sie genau die Dateien wiederherstellen, die Sie benötigen.
5. WinPE Bootfähige Medien:
- Die kostenpflichtigen Abonnements bieten die Möglichkeit, bootfähige Medien mit WinPE zu erstellen. Im Falle eines Systemabsturzes können Sie Ihr System von einem externen Medium starten und Daten wiederherstellen, ohne das Betriebssystem zu laden.
6. Erweiterte Funktionen bei Systemabstürzen:
- Die Abonnements erlauben Ihnen, Dateien auch bei Systemabstürzen wiederherzustellen. Diese zusätzliche Sicherheit sorgt dafür, dass Sie selbst in kritischen Situationen auf Ihre Daten zugreifen können.
7. Kostenloses Upgrade für lebenslangen Schutz:
- Durch das Abonnement erhalten Sie nicht nur fortlaufenden Premium-Support, sondern auch lebenslange kostenlose Upgrades. Bleiben Sie stets auf dem neuesten Stand und profitieren Sie von den kontinuierlichen Verbesserungen der Software.
Das Upgrade auf das Monatliche oder jährliche Abo bietet somit erweiterte Funktionen und Annehmlichkeiten, um den unterschiedlichen Anforderungen anspruchsvoller Nutzer gerecht zu werden. Entdecken Sie die volle Bandbreite der Datenwiederherstellung mit MiniTool Data Recovery Abo-Modellen.
Read the full article
0 notes
Text
Programmierung des 2fach Joystickshield HU-M16 am Raspberry Pi Pico mit CircuitPython
In diesem Beitrag möchte ich dir zeigen, wie du das 2fach Joystickshield HU-M16 am Raspberry Pi Pico via CircuitPython programmiert. Das Shield habe ich dir bereits für den Arduino UNO vorgestellt und auch am Arduino Leonardo gezeigt, wie du mit diesem Shield deine Maus ersetzen kannst. Hier möchte ich dir nun gerne zeigen, wie dieses Shield ebenso am Pi Pico programmiert wird.
https://youtu.be/M9l6msFhADQ
Die Idee zu diesem Beitrag kommt von einem Kommentar zum YouTube-Video Arduino Joystick Shield Basics: Programmierung leicht gemacht für Anfänger wo ich gefragt wurde, wie dieses für den Pico bzw. ESP32 in Python umgesetzt wird.
ArduPico für den Formfaktor des Arduino UNO
Es gibt mit dem ArduPico von der Firma WisdPi die Möglichkeit den Raspberry Pi Pico in das Format des Arduino UNO R3 zu bringen.
Der Vorteil an diesem Board ist, dass du somit das Shield nicht mit Breadboardkabel anschließen musst, sondern einfach wie am Arduino dieses aufstecken und verwenden kannst. Der Preis für dieses Modul ist mit derzeit 9,51 $ (ca. 8,69 €) zzgl. Versandkosten recht erschwinglich.
Der WisdPi ArduPico verfügt ausschließlich über die analogen Pins A0 bis A2, was bedeutet, dass ein analoger Pin für die X-Koordinate des rechten Joysticks fehlt. Dennoch ist das Shield so konzipiert, dass es mit beiden Händen oder mit den Daumen bedient werden kann. In diesem Fall ist es akzeptabel, jeweils nur eine Achse mit einem Daumen zu steuern, wodurch auf die fehlende Achse verzichtet werden kann.
Auf der Vorderseite des ArduPico findest du die Beschriftungen für den Arduino und auf der Rückseite diese für den Pi Pico.
Programmieren des Shields HU-M16 in CircuitPython
Damit wir dieses Shield programmieren können, schauen wir uns zunächst das Pinout an.
Aufbau des Joystick Shields für den Arduino
Nachfolgend eine Tabelle mit den Pins am Raspberry Pi Pico.
HU-M16Arduino UNO R3Raspberry Pi PicoJoystick (links)XA0GP26YA1GP27TasterD2GP2Joystick (rechts)XA3YA2GP28TasterD4GP4LEDD3GP3
Einrichten des Pi Pico für die Programmierung in CircuitPython
Bevor wir das eigentliche Programm schreiben können, müssen wir unseren Mikrocontroller für CircuitPython flashen. In meinem Fall habe ich den Raspberry Pi Pico W und müsste nun die passende UF2 Datei suchen, herunterladen und auf den Mikrocontroller spielen.
Die Entwicklungsumgebung Thonny bietet hier einen sehr einfachen Weg den Mikrocontroller für CircuitPython zu flashen und das mit wenigen Klicks.
Bevor wir jedoch eine neue Firmware auf den Mikrocontroller flashen können, müssen wir diesen zunächst in den Modus bringen. Dazu trennen wir zunächst den Pi Pico vom Computer und halten den
Taster BOOTSEL gedrückt und verbinden diesen erneut mit dem Computer. Es sollte jetzt im Explorer ein neues Laufwerk erscheinen.
In dem Tool Thonny wählen wir unten rechts aus der Auswahlliste den Eintrag "Konfiguriere den Interpreter...".
Im neuen Dialog wählen wir als erstes "CircuitPython (generic)" (1) und unter Port das korrekte Board (2) aus. Um nun das Board für CircuitPython zu flashen, müssen wir unten rechts auf den Hyperlink "CircuitPython installieren oder aktualisieren (UF2)" (3) klicken.
Jetzt müssen wir das Laufwerk auswählen (4) sollte ggf. bereits vorlegt sein und danach die Variante des Pi Pico wählen. In meinem Fall nutze ich den Raspberry Pi Pico mit WiFi Chip und wähle daher den Pico W aus. Zum Schluss nun noch die Version wählen (6) und auf die Schaltfläche "Installieren" (7) klicken.
Wenn der Vorgang abgeschlossen ist, sollte der Text "Done" bei der Position (8) erscheinen.
Wenn wir jetzt zur IDE zurückkehren, dann sollte der in der Grafik angezeigte Text erscheinen (ggf. einmal oben in der Menüleiste auf Stopp klicken).
Download des Moduls Adafruit HID
Zum Steuern des Mauszeigers habe ich sehr gute Erfahrung mit dem Modul Adafruit Mouse gesammelt, es gibt dazu auch eine sehr ausführliche Dokumentation mit einigen Beispielen. Zu den Beispielen findet man auch immer gleich das Modul und somit muss man nicht lange suchen, sondern lädt sich einfach das Beispiel als ZIP-Datei herunter und kann dann aus dem entpackten Ordner das Modul auf den Mikrocontroller kopieren.
Auslesen der aktuellen Position der Joysticks
Im ersten Abschnitt habe ich dir bereits gezeigt, an welche Pins die Joysticks und auch die LED angeschlossen sind. Zunächst lesen wir die x-Achse aus und geben die Werte in der Konsole aus.
import board
from analogio import AnalogIn
from time import sleep
joystickLeftX = AnalogIn(board.A0)
while True:
print(joystickLeftX.value)
sleep(0.125)
Wenn wir den Code ausführen und den linken Joystick nach rechts / links bewegen, dann ändert sich der gelesene analoge Wert, welchen wir aus dem Reiter Kommandozeile auslesen können.
Thonny - lesen von analogen Werten
Bewegen des Mauszeigers mit den Joysticks
Die Funktion move für das Bewegen des Mauszeigers erwartet 3 ganzzahlige Parameter.
move(x: int = 0, y: int = 0, wheel: int = 0)
Wenn wir nun den Mauszeiger in der X & Y Achse bewegen wollen, dann übergeben wir für die Bewegung nach oben eine 1 und nach unten eine -1, wenn wir jedoch die Achse nicht bewegen wollen eine 0.
Die Joysticks sind in der Mittelposition und wir lesen einen Wert zwischen 45000 & 48000 (jedenfalls bei meinem Modell). Ich definiere jetzt, dass Werte, kleiner als 45000 als -1 interpretiert werden und größer als 48000 als 1.
import board
from analogio import AnalogIn
from time import sleep
import usb_hid
from adafruit_hid.mouse import Mouse
joystickLeftX = AnalogIn(board.A0)
joystickRightY = AnalogIn(board.A2)
m = Mouse(usb_hid.devices)
while True:
if joystickLeftX.value > 48000:
posX = 1
elif joystickLeftX.value < 44000:
posX = -1
else:
posX = 0
if joystickRightY.value > 49000:
posY = 1
elif joystickRightY.value < 45000:
posY = -1
else:
posY = 0
m.move(posX, posY, 0)
sleep(0.01)
Taster der Joysticks auswerten
Beide analoge Joysticks haben jeweils einen zusätzlichen Taster, diese beiden Taster können wir als Maustasten einsetzen, jeweils als linke und rechte Maustaste. Wir benötigen dazu zwei Funktionsaufrufe, zum einen um den Taster zu drücken und zum anderen um diese wieder loszulassen.
- Mouse.press,
- Mouse.release
Hintergrund ist, dass wir theoretisch per Drag'n Drop Objekte wie Dateien, Ordner verschieben können und dabei halten wir die Maustaste gedrückt. In meinem Fall möchte ich jedoch lediglich einen einfachen Klick ausführen.
import board
from time import sleep
import usb_hid
from adafruit_hid.mouse import Mouse
import digitalio
led = digitalio.DigitalInOut(board.GP3)
led.direction = digitalio.Direction.OUTPUT
joystickLeftButton = digitalio.DigitalInOut(board.GP2)
joystickLeftButton.switch_to_input(pull=digitalio.Pull.UP)
joystickRightButton = digitalio.DigitalInOut(board.GP4)
joystickRightButton.switch_to_input(pull=digitalio.Pull.UP)
m = Mouse(usb_hid.devices)
while True:
if not joystickLeftButton.value:
led.value = True
m.press(Mouse.LEFT_BUTTON)
sleep(0.010)
m.release(Mouse.LEFT_BUTTON)
if not joystickRightButton.value:
led.value = True
m.press(Mouse.RIGHT_BUTTON)
sleep(0.010)
m.release(Mouse.RIGHT_BUTTON)
led.value = False
sleep(0.01)
Fertiges Programm zum Steuern des Mauszeigers mit dem Joystickshield HU-M16 in CircuitPython
import board
from analogio import AnalogIn
from time import sleep
import usb_hid
from adafruit_hid.mouse import Mouse
import digitalio
led = digitalio.DigitalInOut(board.GP3)
led.direction = digitalio.Direction.OUTPUT
joystickLeftX = AnalogIn(board.A0)
joystickRightY = AnalogIn(board.A2)
joystickLeftButton = digitalio.DigitalInOut(board.GP2)
joystickLeftButton.switch_to_input(pull=digitalio.Pull.UP)
joystickRightButton = digitalio.DigitalInOut(board.GP4)
joystickRightButton.switch_to_input(pull=digitalio.Pull.UP)
m = Mouse(usb_hid.devices)
while True:
if not joystickLeftButton.value:
led.value = True
m.press(Mouse.LEFT_BUTTON)
sleep(0.010)
m.release(Mouse.LEFT_BUTTON)
if not joystickRightButton.value:
led.value = True
m.press(Mouse.RIGHT_BUTTON)
sleep(0.010)
m.release(Mouse.RIGHT_BUTTON)
led.value = False
if joystickLeftX.value > 48000:
posX = 1
elif joystickLeftX.value < 44000:
posX = -1
else:
posX = 0
if joystickRightY.value > 49000:
posY = 1
elif joystickRightY.value < 45000:
posY = -1
else:
posY = 0
m.move(posX, posY, 0)
sleep(0.01)
Fazit
Die Programmierung des Joystickshield HU-M16 in CircuitPython ist mit dem Modul von Adafruit deutlich einfacher als beim Arduino.
Eine Erweiterung des Codes könnte nun die Funktionalität für Drag'n Drop sein.
Solltest du Fragen zu diesem Programm / Beitrag haben, so kannst hier einen Kommentar hinterlassen oder mir eine E-Mail an [email protected] senden.
Read the full article
0 notes
Text
Arduino Programmierung: Effiziente Datenverwaltung mit struct
In der Welt der Arduino Programmierung bietet das Schlüsselwort "struct" eine kraftvolle Möglichkeit zur effizienten Datenverwaltung. Anders als Arrays erlaubt ein struct die Gruppierung verschiedener Datentypen unter einem Dach – und das mit variablen, aussagekräftigen Namen. Bevor wir jedoch tiefer in die Vorteile von struct eintauchen, werfen wir einen Blick auf das Problem, dem viele Entwickler gegenüberstehen: Arrays. Diese, obwohl leistungsstark, sind auf einen Datentyp beschränkt und verlangen eine festgelegte Größe. Das Finden spezifischer Daten wird so zu einer Herausforderung.
Arduino Programmierung: Effiziente Datenverwaltung mit struct
Verkürzt kann man quasi sagen: Ein struct (Abkürzung für "structure") ist in der Welt der Arduino Programmierung, die auf C++ basiert, eine Datenstruktur, die es ermöglicht, verschiedene Datentypen unter einem gemeinsamen Namen zu organisieren und zu gruppieren.
Wie ist ein struct aufgebaut?
Ein struct ist eine Datenstruktur, die es erlaubt, verschiedene Datentypen unter einem gemeinsamen Namen zu gruppieren. Technisch gesehen wird ein struct als benutzerdefiniertes Datentyp betrachtet, der aus einer Sammlung von Datenmitgliedern besteht. Im Gegensatz zu Klassen, haben structs standardmäßig öffentlichen Zugriff auf ihre Datenmitglieder, während Klassen standardmäßig private Zugriffsbereiche haben.
struct Sensordaten{
// Datentyp1 variablenname1;
// Datentyp2 variablenname2;
// ...
};
Wir können also für einen Sensor folgendes struct erzeugen.
struct Sensordaten{
String typ;
float value;
};
Wie wird ein struct erzeugt?
Das struct wird behandelt wie eine Variable, d.h. zunächst nennen wir den Datentypen, was in unserem Fall der Name des struct ist und danach einen Namen.
Du kannst dann entweder gleich Werte zuweisen oder dieses später in einer Funktion erledigen.
Sensordaten temperatur = { "Temperatur", 12.64 };
Wenn du die Initialisierung der Daten des struct später erledigst, dann solltest du sicherstellen, dass dieses vor dem Lesen / verwenden der Daten erfolgt. Es würde dir kein Fehler geworfen werden, sondern du erhältst einfach irgendwelche Daten aus dem Speicher.
Sensordaten temperatur;
void setup(){
temperatur.type = "Temperatur";
temperatur.value = 12.56;
}
Ein Beispiel für den Einsatz eines struct am Arduino
Steigen wir nun mit einem Beispiel ein, ich möchte gerne die Sensordaten eines DHT11 Sensors verwalten. Dieser Sensor liefert die Temperatur, sowie die relative Luftfeuchtigkeit.
Arduino UNO R3 mit DHT11 Sensor
Diese Daten wollen wir jetzt in einem struct speichern. Dazu legen wir uns zunächst erstmal die Struktur an.
struct Sensordaten {
String type; //der Typ (Temperatur, rel. Luftfeuchtigkeit, Luftdruck etc.)
String symbol; //das Zeichen/Symbol für die Maßeinheit (°C, %, hPa)
float value; //der aktuelle Wert
float max; //der maximal gemessene Wert
float min; //der minimal gemessene Wert
};
Hier der komplette Code zum Auslesen der Temperatur und rel. Luftfeuchtigkeit eines DHT11 Sensors am Arduino UNO R3.
//Bibliothek zum kommunizieren mit dem DHT Sensor
#include
//der Sensor ist am digitalen Pin D5 angeschlossen
DHTNEW dht11Sensor(5);
//struct für die Verwaltung der Sensordaten
struct Sensordaten {
String type;
String symbol;
float value;
float max;
float min;
};
//erzeugen von Feldern für die Sensordaten
//des DHT11 Sensors
Sensordaten temperatur;
Sensordaten luftfeuchte;
void setup() {
//begin der kommunikation mit 9600 Baud
//auf der seriellen Schnittstelle
Serial.begin(9600);
//definieren der Daten für den Temperaturwert
temperatur.type = "Temperatur";
temperatur.symbol = "°C";
temperatur.value = 0;
//maximale und minimale Grenze setzen
temperatur.max = -999;
temperatur.min = 999;
//definieren der Daten für
//die relative Luftfeuchtigkeit
luftfeuchte.type = "rel. Luftfeuchtigkeit";
luftfeuchte.symbol = "%";
luftfeuchte.value = 0;
luftfeuchte.max = -999;
luftfeuchte.min = 999;
}
//Funktion zum ausgeben von Sensordaten
//auf der seriellen Schnittstelle
//Als Parameter wird das struct übergeben.
void printValues(Sensordaten data) {
Serial.println(data.type);
Serial.print("taktueller Wert: ");
Serial.print(data.value);
Serial.print(data.symbol);
Serial.print("t");
Serial.print("(max.: ");
Serial.print(data.max);
Serial.print(data.symbol);
Serial.print(", min.: ");
Serial.print(data.min);
Serial.print(data.symbol);
Serial.print(")");
Serial.println();
}
void loop() {
//anfordern der Sensordaten
dht11Sensor.read();
//behandeln der Werte für die rel. Luftfeuchtigkeit
float luftfeuchteValue = dht11Sensor.getHumidity();
luftfeuchte.value = luftfeuchteValue;
luftfeuchte.max = max(luftfeuchteValue, luftfeuchte.max);
luftfeuchte.min = min(luftfeuchteValue, luftfeuchte.min);
//behandeln der Werte für die Temperatur
float temperatureValue = dht11Sensor.getTemperature();
temperatur.value = temperatureValue;
temperatur.max = max(temperatureValue, temperatur.max);
temperatur.min = min(temperatureValue, temperatur.min);
//ausgeben der Daten auf der seriellen Schnittstelle
printValues(luftfeuchte);
printValues(temperatur);
//eine kleine Pause von 1,5 Sekunden
delay(1500);
}
Der Code erzeugt eine Ausgabe auf der seriellen Schnittstelle aus welcher wir die aktuellen sowie der maximale und minimale Wert ablesen können.
Beispiel - struct zum speichern von Sensordaten eines DHT11 Sensors am ArduinoHerunterladen
Erkannte Vorteile eines struct
Wenn wir nun auf den Code blicken, erkennen wir zunächst vier eindeutige Vorteile eines struct.
Datenorganisation: structs ermöglichen die Gruppierung verschiedener Datentypen unter einem gemeinsamen Namen. Dies fördert die organisierte Strukturierung von Daten, was besonders nützlich ist, wenn verschiedene Informationen zu einem einzigen Konzept gehören.
Verbesserte Lesbarkeit: Durch die Verwendung von structs können Daten mit aussagekräftigen Namen versehen werden. Dies verbessert die Lesbarkeit des Codes, da Entwickler auf einen Blick erkennen können, welche Daten ein bestimmtes struct repräsentiert.
Einfacher Zugriff: Der Zugriff auf die Mitglieder eines structs erfolgt über die Punkt-Notation, was den Code einfacher und intuitiver macht. Dies erleichtert das Lesen, Schreiben und Verstehen von Daten, insbesondere im Vergleich zu komplexen Indizierungsmechanismen bei Arrays.
Flexibilität und Erweiterbarkeit: structs bieten Flexibilität, da sie verschiedene Datentypen enthalten können. Dies ermöglicht die Definition komplexer Datenstrukturen, die leicht erweitert oder angepasst werden können, ohne den gesamten Code umzuschreiben. Dies ist besonders nützlich, wenn neue Daten hinzugefügt werden müssen.
Nachteile eines struct durch die öffentliche, einfache Struktur
Wo Vorteile sind, sind auch Nachteile. Daher ergeben sich aus dem sehr geöffneten Aufbau des struct folgende Nachteile.
Keine Methoden: Im Gegensatz zu Klassen in einigen Programmiersprachen können structs keine Methoden enthalten. Das bedeutet, dass du keine Funktionen direkt an ein struct binden kannst.
Begrenzte Vererbung: Im Vergleich zu Klassen bieten structs eine begrenzte Vererbungsfähigkeit. Du kannst nur öffentliche Datenmitglieder erben, und es gibt keine Möglichkeit, den Zugriff zu steuern oder Funktionen zu überschreiben.
Keine Kontrollmechanismen: structs bieten standardmäßig keinen Schutzmechanismus für ihre Datenmitglieder. Alle Daten sind standardmäßig öffentlich zugänglich, was potenzielle Probleme in Bezug auf Datenintegrität und -sicherheit verursachen kann.
Keine Zugriffsmodifikatoren: Anders als bei Klassen, bei denen du private, geschützte und öffentliche Zugriffsmodifikatoren verwenden kannst, haben structs standardmäßig nur öffentlichen Zugriff. Das kann die Kontrolle über den Zugriff auf die Daten beeinträchtigen.
Read the full article
0 notes
Text
Arduino Joystick Shield Basics: Programmierung leicht gemacht für Anfänger
In diesem Beitrag möchte ich dir das Arduino Joystick Shield vorstellen und zeigen, wie dieses in der Arduino IDE programmiert wird. Du kannst mit diesem einfachen Shield einen Roboterarm oder auch ein kleines Fahrzeug über Bluetooth steuern.
https://youtu.be/n9Yng6M20iE
Das Joystick Shield verfügt über zwei analoge Joysticks, eine separate Schnittstelle für ein Bluetoothmodul sowie eine Stiftleiste für freie digitale Pins vom Mikrocontroller. Der aktive Betrieb des Moduls wird dir über eine 5 mm LED angezeigt.
Joystick Shield für den Arduino UNO R3
Schnittstellen am Arduino Joystick Shield
Bezug des Arduino Joystick Shield
Das hier vorgestellte Shield bekommst du besonders günstig bei aliexpress.com. Auf ebay.de bekommst du andere Shields welche über einen Joystick und ein Tastenkreuz verfügen und ähnlich funktionieren.
Aufbau des Joystick Shields
Das Joystick Shield verfügt wie bereits erwähnt über:
- zwei analoge Joysticks,
- eine rote, 5 mm LED,
- eine separate Schnittstelle für Bluetoothmodule vom Typ HC-05 & HC-06, sowie
- eine Stiftleiste für Servomotoren
Buchsenleiste für Bluetoothmodule
Stiftleiste für den Anschluss von Servomotoren
Das Shield lässt sich auf die bestehenden Buchsenleisten der Arduinos stecken (ausgenommen natürlich dem Nano V3 und den Minis). Beim Arduino Mega 2560 R3 musst du auf die Buchsenbeschriftungen achten, denn dieser hat deutlich mehr Pins zur Verfügung.
Arduino UNO R3 mit Joystick Shield
Arduino Mega 2560 R3 mit Joystick Shield
Pinout des Shields
Das Joystick Shield ist wie in der Grafik zu sehen aufgebaut.
Aufbau des Joystick Shields für den Arduino
KomponentePin am ArduinoLEDdigitaler Pin D3Joystick 1 (links)Xanalog A0Yanalog A1Tasterdigitaler Pin D2Joystick 2 (rechts)Xanalog A3Yanalog A2Tasterdigitaler Pin D4
Auf meinem Shield ist der Taster vom linken Joystick nicht mit dem Shield verbunden.
Anschluss von Servomotoren an das Joystick Shield
Das Shield hat, wie du in der Grafik siehst, 6 paar Stiftenleisten für Servomotoren. An diese kannst du theoretisch den Servomotor direkt anschließen, denn diese sind korrekt dafür ausgelegt.
Joystick Shield mit Servomotoren
Für die kleinen Servomotoren ist dieses auch voll okay.
Jedoch haben die großen Servomotoren deutlich mehr Kraft und ziehen dadurch auch mehr Leistung, das kann dieses Shield nicht leisten und dein Mikrocontroller würde einen Schaden nehmen!
Für den großen Servomotor vom Typ MG996R benötigst du eine zusätzliche Stromversorgung mit min. 2A bei 5V. Also bevor du deinen Servomotor an dieses Shield anschließt, prüfe zunächst in den technischen Daten des Servomotors wie viel Last / Strom dieser zieht.
Programmieren in der Arduino IDE
Einen Mikrocontroller der Arduino-Familie kannst du am einfachsten in der Arduino IDE programmieren. Diese bringt die meisten Features gleich mit und wenn dir doch eins fehlt, kannst du dieses über die internen Board- /Bibliotheksverwalter nachinstallieren.
Bevor wir jedoch mit der Programmierung beginnen und das Shield auf den Mikrocontroller stecken, spielen wir ein leeres Programm auf den Mikrocontroller auf. Mit diesem leeren Programm stellen wir sicher, dass keine Pins auf HIGH gesetzt werden, welche ggf. das Modul beschädigen kann.
Auslesen der Werte der analogen Joysticks
Bevor wir etwas steuern können, müssen wir erst einmal die Joysticks auslesen und die Werte speichern. Das nachfolgende kleine Programm dient uns auch später als Grundgerüst.
//Koordinaten des linken Joysticks
#define joystick1X_Pin A0 //X
#define joystick1Y_Pin A1 //Y
#define joystick1Button_Pin 4 //Taster
//Koordinaten des rechten Joysticks
#define joystick2X_Pin A3 //X
#define joystick2Y_Pin A2 //Y
#define joystick2Button_Pin 2 //Taster
//rote, 5mm LED am digitalen Pin D3
//angeschlossen
#define led 3
//Felder zum speichern der letzten Werte
//linker Joystick
int lastJ1X = -1; //X
int lastJ1Y = -1; //Y
//rechter Joystick
int lastJ2X = -1; //X
int lastJ2Y = -1; //Y
void setup() {
//begin der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);
//Pins der Taster an den Joysticks
//als Ausgang definieren, zusätzlich
//werden diese Pins über den internen 10 kOhm
//Widerstand umgeleitet.
pinMode(joystick1Button_Pin, INPUT_PULLUP);
pinMode(joystick2Button_Pin, INPUT_PULLUP);
//Pin der LED als Ausgang definieren
pinMode(led, OUTPUT);
}
//Funktion um die Werte eines Joysticks auszugeben.
void printJoyStickValues(String joystick, int valueX, int valueY) {
Serial.print("Joystick :" + joystick);
//lesen der X-Position und umwandeln in ein String
Serial.print(" X: " + String(valueX, DEC));
Serial.print(", ");
//lesen der Y-Position und umwandeln in ein String
Serial.println("Y: " + String(valueY, DEC));
}
void loop() {
//lesen der aktuellen Position des linken Joysticks
int joyStick1X = analogRead(joystick1X_Pin);
int joyStick1Y = analogRead(joystick1Y_Pin);
//Wenn die gelesenen Werte sich von den zuvor gespeicherten
//Werten unterscheiden, dann...
if (joyStick1X != lastJ1X || joyStick1Y != lastJ1Y) {
lastJ1X = joyStick1X;
lastJ1Y = joyStick1Y;
printJoyStickValues("links", joyStick1X, joyStick1Y);
}
//lesen der aktuellen Position des rechten Joysticks
int joyStick2X = analogRead(joystick2X_Pin);
int joyStick2Y = analogRead(joystick2Y_Pin);
//Wenn die gelesenen Werte sich von den zuvor gespeicherten
//Werten unterscheiden, dann...
if (joyStick2X != lastJ2X || joyStick2Y != lastJ2Y) {
lastJ2X = joyStick2X;
lastJ2Y = joyStick2Y;
printJoyStickValues("rechts", joyStick2X, joyStick2Y);
}
//Wenn der Taster am linken Joystick gedrückt wird, dann...
if (digitalRead(joystick1Button_Pin) == LOW) {
Serial.println("Taster Joystick links gedrückt!");
}
//Wenn der Taster am rechten Joystick gedrückt wird, dann...
if (digitalRead(joystick2Button_Pin) == LOW) {
Serial.println("Taster Joystick rechts gedrückt!");
}
//kleine Pause von 450 ms.
//Diese wird lediglich benötigt um die Ausgaben im seriellen Monitor
//der Arduino IDE zu lesen. Im Live betrieb sollte dieser entfernt werden!
delay(450);
}
Der Code bewirkt, dass die Daten auf der seriellen Schnittstelle ausgegeben werden, jedoch, nur wenn diese sich ändern.
Steuern eines Servomotors mit dem Joystick Shield
Über die bereits gezeigten Stiftleisten kannst du wie erwähnt kleine, einfache Servomotoren anschließen und mit recht wenig Code steuern.
Arduino Joystick Shield mit Servomotor Typ SG90
Dabei musst du beachten, dass der Joystick sich in der Mittelposition befindet und somit einen ungefähren Wert von 511 liefert.
//Einbinden der Bibliothek
//zum steuern eines Servomotors.
#include
//Der Servomotor ist am
//digitalen Pin D6 angeschlossen.
#define servoPin 6
//Die X Koordinate des linken Joysticks
//ist am analogen Pin A0 angeschlossen.
#define joystickXPin A0
//initialisieren eines Servoobjektes
Servo servo;
void setup() {
//verbinden des Pins vom Servo zum Objekt
servo.attach(servoPin);
}
void loop() {
//auslesen der aktuellen Position der X Koordinate
//des Joysticks
int joystickXPos = analogRead(joystickXPin);
//anlegen einer Variable für den berechneten Wert
//des Servos
int servoValue = -1;
//Der Joystick befindet sich in der Mittelposition,
//das bedeutet das wir ca. 511 als analogen Wert empfangen.
if (joystickXPos > 511) {
//Den Wert der Variable joystickXPos mit dem Gültigkeitsbereich
// 511 bis 1023 auf die Winkel 90 bis 0 mappen.
servoValue = map(joystickXPos, 511, 1023, 90, 0);
} else {
//Den Wert der Variable joystickXPos mit dem Gültigkeitsbereich
// 511 bis 0 auf die Winkel 90 bis 180 mappen.
servoValue = map(joystickXPos, 511, 0, 90, 180);
}
//Zuweisen der neuen Position am Servoobjekt
servo.write(servoValue);
}
Damit du den Code nicht abtippen oder kopieren musst, kannst du dir diesen hier als ZIP-Datei herunterladen.
Code - steuern eines Servomotors vom Typ SG90 am Arduino Joystick ShieldHerunterladen
Im nachfolgenden kleinen Video siehst du, dass wenn der linke Joystick nach links bewegt wird, sich das Ruderhorn des Servos ebenso in diese Richtung bewegt und andersherum.
Wenn wir nun diesen Code etwas erweitern, dann können wir einen kleinen Pan-Tilt Bausatz steuern. Dieser Bausatz verfügt über zwei Servomotoren und eine kleine Adapterplatte, wo wir eine Kamera montieren können.
Hier im Bild zusehen der Pan-Tilt Bausatz mit der M5Stack Kamera welche ich dir bereits im Beitrag Kleine Kamera, große Leistung: Vorstellung der ESP32 S3 CAM von M5Stack vorgestellt habe.
Dieser Bausatz hat wie erwähnt zwei Servomotoren, welche wir ebenso an das Joystick Shield anschließen können und mit den beiden Joysticks lässt dieses dich dann super einfach in fast alle Richtungen bewegen.
Code - steuern eines Pan-Tilt Bausatzes mit M5Stack CAM mit dem Arduino Joystick ShieldHerunterladen
Fazit und Ausblick
Ich habe dir nun den Aufbau des Shields gezeigt sowie ein erstes kleines Programm, mit welchen die X/Y Position der Joysticks ausgelesen werden können. Im nächsten Beitrag werde ich dir dann zeigen, wie du mit diesem Shield einen 3DOF Roboterarm steuern kannst.
3DOF Roboterarm / Claw
Ein weiterer Beitrag wird darum gehen, wie du mit diesem Shield ein kleines Fahrzeug mit dem Calliope Mini 3 steuern kannst.
Tinysuperlab MotionKit2 für den Calliope Mini 3
Bleib also dran und erfahre, wie du mit diesem Shield coole Projekte umsetzen kannst.
Read the full article
0 notes
Text
Smart Home und Data Science: Die Verbindung zwischen Technologie und Daten
Einleitung: Die Evolution des Smart Home
Smart Home-Technologien haben in den letzten Jahren eine rasante Entwicklung erlebt, wobei immer mehr Haushalte auf vernetzte Geräte zurückgreifen, um Komfort, Sicherheit und Energieeffizienz zu verbessern.
Ein Smart Home bezeichnet ein Wohnkonzept, bei dem verschiedene elektronische Geräte und Systeme miteinander vernetzt sind und zentral gesteuert werden können, oft über das Internet, eine Cloud oder lokale Netzwerke. Das Hauptziel eines Smart Homes ist es, den Wohnkomfort, die Sicherheit, die Energieeffizienz und die Lebensqualität der Bewohner zu verbessern.
Diese Geräte generieren eine Fülle von Daten, die mithilfe von Data Science und künstlicher Intelligenz analysiert werden können, um die Funktionalität und Leistungsfähigkeit des Smart Home-Systems zu optimieren.
Die Rolle von Data Science im Smart Home
Daten sind der Treibstoff, der das Smart Home antreibt. Durch den Einsatz von Data Science-Techniken können diese Daten analysiert und interpretiert werden, um nützliche Erkenntnisse zu gewinnen. Mithilfe von Algorithmen können Muster und Trends identifiziert werden, die Einblicke in das Verhalten der Bewohner und die Leistung der Geräte bieten. Dies ermöglicht eine personalisierte und effiziente Nutzung des Smart Home-Systems.
Künstliche Intelligenz für die Automatisierung im Smart Home
Künstliche Intelligenz (KI) spielt eine entscheidende Rolle bei der Automatisierung von Prozessen im Smart Home. Durch maschinelles Lernen können Algorithmen das Verhalten der Bewohner verstehen und entsprechend reagieren. Zum Beispiel können Smart-Home-Systeme lernen, wann die Bewohner normalerweise das Licht einschalten, und dieses automatisch aktivieren, wenn sie nach Hause kommen. Dies führt zu einem nahtlosen und komfortablen Nutzererlebnis.
Big Data und personalisierte Dienste
Die enorme Menge an Daten, die von Smart-Home-Geräten generiert wird, stellt eine wertvolle Ressource dar, um personalisierte Dienste anzubieten.
Durch die Analyse großer Datenmengen können Muster im Verhalten der Bewohner identifiziert werden, die zur Bereitstellung maßgeschneiderter Empfehlungen und Verbesserungsvorschläge genutzt werden können. Dies kann von Energieeinsparungen bis hin zur Verbesserung des täglichen Komforts reichen.
Datenschutz und Sicherheit im Smart Home
Daten sind der Schlüssel zu einem effektiven Smart Home. Durch die Analyse von Daten aus verschiedenen Quellen können Smart-Home-Systeme Muster und Trends identifizieren, die Einblicke in das Verhalten der Bewohner bieten. Diese Daten werden oft von Data-Science-Techniken verarbeitet, um personalisierte Dienste anzubieten und die Effizienz des Smart Homes weiter zu verbessern.
Angesichts der Sensibilität der gesammelten Daten ist Datenschutz und Sicherheit von größter Bedeutung im Smart Home. Hersteller und Entwickler müssen robuste Sicherheitsmaßnahmen implementieren, um persönliche Informationen zu schützen und das Risiko von Datenschutzverletzungen zu minimieren.
Die Zukunft des Wohnens: Herausforderungen und Chancen
Während Smart Homes immer beliebter werden, stehen sie auch vor Herausforderungen. Die Integration verschiedener Geräte und Systeme kann komplex sein, und Datenschutzbedenken bleiben bestehen. Dennoch bieten Smart Homes ein enormes Potenzial, um das Wohnen komfortabler, sicherer und effizienter zu gestalten. Durch kontinuierliche Innovation und die Integration neuer Technologien werden Smart Homes weiterhin eine zentrale Rolle in unserem Leben spielen und die Art und Weise, wie wir wohnen, grundlegend verändern.
Fazit: Die Zukunft von Smart Home und Data Science
Die Verbindung zwischen Smart Home und Data Science bietet eine Vielzahl von Möglichkeiten zur Verbesserung der Benutzererfahrung, zur Steigerung der Effizienz und zur Erhöhung der Sicherheit. Durch die Integration von Datenanalyse, künstlicher Intelligenz und Big Data können Smart-Home-Systeme noch intelligenter und effektiver werden. Es ist jedoch entscheidend, auch die Datenschutzaspekte im Blick zu behalten und sicherzustellen, dass angemessene Schutzmaßnahmen implementiert sind, um das Vertrauen der Nutzer zu gewährleisten und ihre Privatsphäre zu schützen.
Read the full article
0 notes
Text
Arduino I2C-Scanner für ESP8266 & ESP32 anpassen: Eine Schritt-für-Schritt-Anleitung
In diesem Beitrag möchte ich dir eine Schritt-für-Schritt-Anleitung geben, wie du den I2C Scanner von Arduino.cc für die ESP8266 & ESP32 Mikrocontroller anpassen kannst.
Arduino I2C-Scanner für ESP8266 & ESP32 anpassen: Eine Schritt-für-Schritt-Anleitung
Die Idee zu diesem Beitrag kam von einem Leser meines Blogs, welcher Probleme mit dem ESP8266 speziell den von Ideaspark hatte und keine Geräte mit dem IC2 Scanner von Arduino.cc gefunden hat.
Wie funktioniert die I2C Kommunikation?
Um das Beispiel von Arduino.cc für den I2C-Scanner auf ESP8266 und ESP32 anzupassen, ist es zunächst wichtig zu verstehen, wie die I2C-Kommunikation funktioniert. Die I2C-Kommunikation ermöglicht es, verschiedene Geräte wie Sensoren und Aktoren mit einem Mikrocontroller zu verbinden. Hierbei erfolgt die Verbindung über zwei Drähte, die als Bus bezeichnet werden und an die Pins des Mikrocontrollers angeschlossen sind.
Die I2C-Geräte, die an den Bus angeschlossen sind, verfügen über eindeutige Adressen. Diese Adressen bestehen aus 7 Bits und ermöglichen die eindeutige Identifikation jedes angeschlossenen Geräts. Durch diese Adressierung ist es möglich, mehrere Geräte an einer I2C-Schnittstelle anzuschließen und gleichzeitig zu betreiben.
Die I2C-Schnittstelle nutzt zwei Signalleitungen: eine für die Datenübertragung (SDA) und eine für die Taktfrequenz (SCL). Die Kommunikation erfolgt über ein Master-Slave-Prinzip, wobei der Mikrocontroller als Master agiert und die angeschlossenen Geräte als Slaves. Der Master initiiert die Kommunikation, sendet Befehle und fordert Daten von den Slaves an.
Master / Slave auf dem I2C-Bus
Nachdem das Grundverständnis für die I2C-Kommunikation etabliert ist, können wir das Beispiel von Arduino.cc für den I2C-Scanner anpassen, um die Geräte auf ESP8266 und ESP32 Mikrocontrollern zu erkennen.
I2C Adressen der verschiedenen Mikrocontroller
Zunächst möchte ich dir eine Tabelle geben, mit den Pins SDA & SCL für die I2C Schnittstellen der verschiedenen Mikrocontroller.
MikrocontrollerSDASCLArduino UNO, Arduino NanoA5A4Arduino MicroD2D3Arduino Mega 2560 R3D20D21Arduino DUED20D21Wemos D1 Mini - ESP8266D2 (GPIO04)D1 (GPIO05)ESP8266 - IdeasparkD6 (GPIO12)D5 (GPIO14)ESP32GPIO21GPIO21ESP32 S3GPIO08GPIO09
Den Mikrocontroller Raspberry Pi Pico / Pico W kannst du ebenso in der Arduino IDE programmieren, dieser hat zwei I2C Schnittstellen (I2C0 & I2C1) und diese sind an allen 26 GPIOs verfügbar.
Pinout des Raspberry PI Pico
Suchen nach I2C Geräte
Nachdem wir ermittelt haben an welche Pins die I2C Schnittstellen anliegen, möchten wir nun nach Geräten an diesen Pins suchen. Dazu nutze ich zunächst wie erwähnt den I2C Scanner von Arduino.cc.
#include
byte error, address;
int nDevices = 0;
void setup() {
Wire.begin();
Serial.begin(9600);
while (!Serial)
;
Serial.println("nI2C Scanner");
}
void loop() {
Serial.println("Scanning...");
nDevices = 0;
for (address = 1; address < 127; address++) {
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0 || error == 4) {
if (error == 0) {
Serial.print("I2C device found at address 0x");
nDevices++;
} else {
Serial.print("Unknown error at address 0x");
}
Serial.print((address < 16 ? "0" : "") + String(address, HEX) + "!");
}
}
if (nDevices == 0) {
Serial.println("No I2C devices found");
} else {
Serial.println("done");
}
delay(5000);
}
Ausgabe der I2C Adresse eines Displays vom I2C Scanner
I2C Scanner für ESP8266 & ESP32 umschreiben
Um die Suche nach Geräten auf anderen Pins des I2C-Busses zu ermöglichen, ist es erforderlich, der Funktion "begin" des Wire-Objekts die entsprechenden SDA- und SCL-Pins zu übergeben. Das kann man aber nur, wenn die Implementierung es zulässt und das ist abhängig vom gewählten Mikrocontroller!
Daher muss geprüft werden, welcher Mikrocontroller / welches Board in der Arduino IDE ausgewählt wurde.
#if defined(ARDUINO_ESP8266_GENERIC)
#define otherBoard
//Boardconfiguration for Heltec HTIT-W8266 board with oboard OLED Display
BoardConfiguration bc = { "Generic ESP8266 Module", 1, { { 16, 24 } } };
#endif
Eine Liste an den möglichen Werten findest du in der Datei boards.txt im Ordner zum Mikrocontroller bzw. zum Boardtreiber.
%user%AppDataLocalArduino15packagesesp8266hardwareesp82663.1.2
Aus dieser Datei können wir den Namen entnehmen und das Board welches dann später erkannt wird.
generic.name=Generic ESP8266 Module
generic.build.board=ESP8266_GENERIC
Wo kommt der Präfix "ARDUINO_" her?
Wenn du den Code gelesen hast, dann siehst du, dass die Bezeichnung immer den Präfix "ARDUINO_" trägt. Diese kommt daher, dass dieses als Parameter übergeben wird.
Datei "platform.txt"
-DARDUINO_{build.board}
Prüfen des gewählten Boards
In der Funktion loop wird nun geprüft, ob ein Feld "otherBoard" oder "arduinoBoard" existiert. Diese wurden zuvor abhängig vom Board erzeugt. Das funktioniert mit dem precompile Befehl #define.
Danach wird dann abhängig vom Board entweder eine For-Schleife oder der default gestartet.
void loop() {
Serial.print("An ");
Serial.print(bc.boardname);
Serial.println(" was recognized!");
#if defined(otherBoard)
uint8_t numI2CInterfaces = bc.numI2CInterfaces;
Serial.println("The microcontroller has " + String(numI2CInterfaces, DEC) + " I2C Interfaces!");
for (int pair = 0; pair < numI2CInterfaces; pair++) {
uint8_t(*i2cPins) = bc.i2cPins;
uint8_t sda = i2cPins;
uint8_t scl = i2cPins;
Serial.println("t SDA: " + String(SDA, DEC) + ", SCL: " + String(SCL, DEC));
Wire.begin(sda, scl);
Serial.println("tScanning...");
findDevices();
}
#else
#ifdef defined(notDeclaredBoard)
Serial.println("Boardtype not found, try default!");
#endif
Wire.begin();
Serial.println("tScanning...");
findDevices();
#endif
Serial.println("End.");
delay(10000);
}
Wenn die Suche ausgeführt wird, dann erhalten wir wie beim Original im seriellen Monitor die Ausgabe der gefundenen I2C Adressen.
Ausgabe der gefundenen I2C Adressen im seriellen Monitor
Download vom GitHub Repository
Das Programm findest du auf meinem GitHub Repository StefanDraeger/universal-I2C-Scanner. Dort kannst du dir dieses dann als ZIP-Datei herunterladen.
Es gibt derzeit sehr viele Mikrocontroller auf dem Markt, daher ist die Implementierung aller Konfigurationen sehr aufwändig. Jedoch habe ich begonnen, bereits einige einzutragen. Sollte dir ein Mikrocontroller fehlen, so schreibe mir eine Mail an [email protected].
Read the full article
0 notes