#Sensorwerte

[draegerit]

MicroPython und das Mapping von Sensorwerten: So funktioniert's

Herzlich willkommen zu meinem neuesten Blogbeitrag, in dem es um das Mapping von Sensorwerten mit MicroPython geht! Heute werde ich euch eine Funktion vorstellen und erklären, mit der ihr einen Messbereich von einem Sensor auf einen anderen umwandeln könnt. Diese Funktion ist besonders nützlich beim Visualisieren von Umweltsensoren und anderen Messwerten. Ich werde euch Schritt für Schritt durch den Prozess führen und euch zeigen, wie ihr diese Funktion unter Verwendung von MicroPython in euren Projekten nutzen könnt.

Wie man Sensorwerte am Mikrocontroller Calliope Mini im Open Roberta Lab mappt habe ich dir bereits im Beitrag Open Roberta Lab – analoges Signal auf PWM mappen erläutert. Hier greife ich auf die gesammelte Erkenntnis zurück und schreibe den Code für MicroPython um.

Wozu benötigen wir das Mapping von Sensorwerten in MicroPython?

Nehmen wir an du hast einen Temperatursensor welcher einen Messbereich von 0 °C bis 125 °C hat und eine LED Balkenanzeige mit 24 Segmenten. Dann könntest du nun den Messbereich des Sensors (0-125) auf die 24 LEDs mappen und somit je nach Temperatur die LEDs aktivieren. Ein anderer Fall wäre ein Servomotor mit einem maximalen Winkel von 180° welchen du mit einem analogen Sensor (Drehpotentiometer, Joystick etc.) bewegen möchtest. Dann musst du in diesem Fall den Drehbereich des Servos 0° bis 180° auf die möglichen analogen Werte 0 bis, 65535 mappen.

Ein kleiner Aufbau mit dem Raspberry Pi Pico

Damit wir unsere Funktion testen können, benötigen wir einen Mikrocontroller, auf welchen MicroPython läuft. Hier kann man sich selber einen ESP32 flashen oder man verwendet einen Raspberry Pi Pico / Pico W welcher das ganze schon von hause aus kann. Ich möchte das zuletzt genannte Beispiel aufgreifen und einen Servomotor mit einem Drehpotentiometer steuern. Ein recht kleines Projekt, welches jedoch sehr gut verdeutlicht, wie die Funktion map welche wir schreiben, möchten funktioniert.

Schaltung - Raspberry Pi Pico mit Servomotor SG90 & Drehpotentiometer Was benötigen wir für den Aufbau der Schaltung? Für den Nachbau der Schaltung benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro-USB Datenkabel, - einen Servomotor SG90, - einen Drehpotentiometer, - sechs Breadboardkabel, - ein 400 Pin Breadboard Pinout des Raspberry Pi Pico Für die Unterstützung beim Aufbau der Schaltung gebe ich dir hier noch das Pinout des Raspberry Pi Pico an die Hand.

Pinout des Raspberry PI Pico

Programmieren der Funktion map in MicroPython zum Erzeugen eines Mapping von Sensorwerten

In der Arduino IDE gibt es bereits die Funktion map welche genau das macht, was wir hier nachbauen möchten. Die Parameter sind: - value - der Wert, welcher verarbeitet werden soll, - fromLow - die untere Grenze des aktuellen Bereichs des Werts, - fromHigh - die obere Grenze des aktuellen Bereichs des Wertes, - toLow - die untere Grenze des Zielbereichs für den Wert, - toHigh - die obere Grenze des Zielbereichs des Wertes Dieses übernehmen wir für die neue Funktion. def map(value, fromLow, fromHigh, toLow, toHigh): return round((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow) Hier ist eine schrittweise Erklärung der Funktionsweise: - (value - fromLow): Dieser Ausdruck berechnet die Differenz zwischen dem Eingabewert und dem unteren Grenzwert des Eingabebereichs (fromLow). Dieser Schritt normalisiert den Eingabewert auf den Bereich von 0 bis (fromHigh - fromLow). - (toHigh - toLow): Dieser Ausdruck gibt die Größe des Ausgabebereichs an, also die Differenz zwischen dem oberen und unteren Grenzwert des Ausgabebereichs. Dieser Schritt bestimmt die Skalierung des transformierten Werts. - (fromHigh - fromLow): Dieser Ausdruck gibt die Größe des Eingabebereichs an, also die Differenz zwischen dem oberen und unteren Grenzwert des Eingabebereichs. Dieser Schritt bestimmt die relative Position des Eingabewerts innerhalb des Eingabebereichs. - ((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow): Dieser Ausdruck führt die eigentliche Transformation durch. Zuerst wird der normalisierte Eingabewert mit der Skalierung des Ausgabebereichs multipliziert, um den transformierten Wert zu erhalten. Dann wird der untere Grenzwert des Ausgabebereichs (toLow) zum Ergebnis addiert, um den endgültigen transformierten Wert zu erhalten. - round(...): Die Funktion round() rundet den transformierten Wert auf die nächstgelegene ganze Zahl.

Steuern eines Servomotors mit einem Drehpotentiometer in MicroPython

Hier nun das kleine Programm, um mit einem Drehpotentiometer einen Servomotor zu steuern. #import des Moduls um #den analogen Pin auszulesen #und den Servo per PWM zu steuern from machine import ADC, Pin, PWM #import des Moduls um eine #kleine Pause im Code einzulegen from time import sleep #wir benutzen in der Schaltung #den ADC0 Pin / GP26 für den Drehpotentiometer adc = ADC(Pin(26)) #der Servomotor ist am GP15 angeschlossen pwm = PWM(Pin(15)) pwm.freq(50) #untere & obere Grenze des Servomotors servoMin = 100 servoMax = 8000 #untere & obere Grenze des Drehpotentiometers drehpotiMin = 224 drehpotiMax = 65535 # Funktion zum setzen eines Winkels # als Parameter wird die Position erwartet def setServoCycle(position): pwm.duty_u16(position) sleep(0.01) #Funktion zum mappen eines Wertes mit einer oberen und unteren Grenze def map(value, fromLow, fromHigh, toLow, toHigh): return round((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow) #starten der Endlosschleife while True: #auslesen des Wertes vom Drehpotentiometer value = adc.read_u16() #ermitteln der Servoposition servoPosition = map(value, drehpotiMin, drehpotiMax, servoMin, servoMax) #zuweisen der Servoposition setServoCycle(servoPosition) #eine kleine Pause von 125 Millisekunden sleep(0.125) Im Video erkennst du, dass der Servo sich je nach Position des Drehpotentiometers bewegt. Ein Problem ist jedoch, dass der analoge Wert nicht konstant gleich ist, d.h. wenn du den Drehpotentiometer nicht bewegst, dass der Servo trotzdem zuckt.

Ermitteln der Grenzen des Sensors & Aktors

Hier jetzt der vollständigkeitshalber die beiden Programme um die untere & obere Grenze des Drehpotentiometers & des Servomotors zu ermitteln. Die Werte des Servomotors habe ich selbst durch Trial-and-Error ermittelt, diese können je nach Modell variieren. Auslesen des Drehpotentiometers am Raspberry Pi Pico Zunächst einmal lesen wir den Drehpotentiometer aus, um die untere und obere Grenze zu ermitteln. #import des Moduls um #den analogen Pin auszulesen from machine import ADC, Pin #import des Moduls um eine #kleine Pause im Code einzulegen from time import sleep #wir benutzen in der Schaltung #den ADC0 Pin / GP26 adc = ADC(Pin(26)) #starten der Endlosschleife while True: #auslesen des Wertes value = adc.read_u16() #ausgeben des Wertes print("Drehpotentiometer Wert: "+ str(value)) #eine kleine Pause von 125 Millisekunden sleep(0.125) Mit dem Code habe ich jetzt ermittelt das die untere Grenze 224 und die obere Grenze 65535 ist. Steuern des Servomotors per PWM Signal Im Beitrag Raspberry PI Pico #3 – PWM Signale erzeugen habe ich dir bereits gezeigt, wie man einen Servomotor vom Typ SG90 per PWM Signal steuern kann. Mit dem nachfolgenden Code können wir diesen jetzt von 0° bis 180° drehen. from time import sleep from machine import Pin from machine import PWM pwm = PWM(Pin(15)) pwm.freq(50) # Funktion zum setzen eines Winkels # als Parameter wird die Position erwartet def setServoCycle(position): pwm.duty_u16(position) sleep(0.01) while True: for pos in range(100, 8000,50): setServoCycle(pos) for pos in range(8000, 100,-50): setServoCycle(pos) Read the full article

[oxbl00d42]

Optimierung der Strömungssteuerung in Mikrozentrischen Kühlsystemen durch Wahrnehmungsbasierte Rückkopplung

Die Nachfrage nach kleineren und effizienteren Kühlsystemen nimmt in der heutigen Technologiebranche ständig zu. Dabei spielen Mikrozentrische Kühlsysteme eine immer wichtigere Rolle. Die optimale Steuerung der Strömung in diesen Systemen ist entscheidend für die Erreichung der gewünschten Leistung. Wahrnehmungsbasierte Rückkopplungsregelung (englisch: Perception Feedback Control) hat sich als eine vielversprechende Methode zur Optimierung der Strömungssteuerung in Mikrozentrischen Kühlsystemen erwiesen. Im Rahmen dieser Ausführungen möchte ich mich einer Thematik widmen, die aufgrund ihrer innovativen und zukunftsweisenden Bedeutung von höchster Relevanz ist: die Optimierung der Strömungssteuerung in Mikrozentrischen Kühlsystemen durch Wahrnehmungsbasierte Rückkopplung.

Ziel dieser Arbeit ist es, ein neues Konzept für die Optimierung der Strömungssteuerung in Mikrozentrischen Kühlsystemen durch Wahrnehmungsbasierte Rückkopplung zu entwickeln. Zunächst werden die Grundlagen der Strömungssteuerung in Mikrozentrischen Kühlsystemen und die Bedeutung der Wahrnehmungsbasierten Rückkopplung erläutert. Die jüngsten Entwicklungen in der Mikrozentrischen Kühlsystem-Technologie haben eine Notwendigkeit hervorgebracht, sich mit der kontrollierten Steuerung von Strömungsprozessen zu befassen, um eine effektive Kühlung von Elektronikbauteilen zu gewährleisten. Die Strömungssteuerung ist ein wesentlicher Faktor, um eine optimale Kühlleistung zu erreichen und das Erreichen von Wärmeübertragungsminima zu ermöglichen.

Das Konzept der Wahrnehmungsbasierten Rückkopplungsregelung beruht auf der Überwachung des Istzustandes des Kühlsystems durch Sensoren. Das Rückkopplungssignal wird anschließend genutzt, um den gewünschten Sollwert der Strömung zu erreichen. Eine erfolgreiche Anwendung dieser Methode hängt von der Auswahl der richtigen Sensoren und der korrekten Interpretation der Sensorwerte ab. In Anbetracht dieser Herausforderung stellt die wahrnehmungsbasierte Rückkopplung einen innovativen Ansatz dar, um die Strömungssteuerung in Mikrozentrischen Kühlsystemen zu optimieren. Durch den Einsatz von Sensoren, die die Strömungsbedingungen in Echtzeit erfassen, wird eine präzise und kontrollierte Steuerung der Strömung ermöglicht, was wiederum zu einer verbesserten Kühlleistung führt.

Um die Wirksamkeit der vorgeschlagenen Methode zu evaluieren, werden verschiedene Experimente durchgeführt. Es wird ein Testaufbau für ein Mikrozentrisches Kühlsystem entworfen und die Sensoren installiert. Anschließend werden verschiedene Tests durchgeführt, um die optimale Konfiguration der Wahrnehmungsbasierten Rückkopplungsregelung zu ermitteln. Um dieses Ziel zu erreichen, ist es notwendig, eine Reihe von Methoden und Techniken anzuwenden, die eine effektive Steuerung und Optimierung der Strömungsbedingungen gewährleisten. Hierbei ist es von entscheidender Bedeutung, eine ausgewogene Kombination von theoretischen und experimentellen Ansätzen zu wählen, um ein tiefes Verständnis der zugrunde liegenden Phänomene und Mechanismen zu erlangen.

Die Ergebnisse zeigen, dass die Wahrnehmungsbasierte Rückkopplungsregelung eine effektive Methode zur Optimierung der Strömungssteuerung in Mikrozentrischen Kühlsystemen ist. Durch die Überwachung des Istzustandes des Kühlsystems können unerwartete Abweichungen erkannt und korrigiert werden, was zu einer verbesserten Leistung und Effizienz des Systems führt. Durch den Einsatz von numerischen Simulationen und experimentellen Studien kann das wahrnehmungsbasierte Rückkopplungsverfahren optimiert und auf verschiedene Mikrozentrische Kühlsysteme angewendet werden. Durch die Erweiterung unseres Wissens über die Mechanismen der Strömungssteuerung und der Wärmeübertragung können wir effektive Lösungen zur Verbesserung der Kühlleistung von Mikrozentrischen Kühlsystemen entwickeln.

Es kann festgestellt werden, dass die Wahrnehmungsbasierte Rückkopplungsregelung ein vielversprechendes Konzept zur Optimierung der Strömungssteuerung in Mikrozentrischen Kühlsystemen ist. Die Verwendung von geeigneten Sensoren und die korrekte Interpretation der Sensordaten sind entscheidend für den Erfolg dieser Methode. Mit weiteren Forschungsarbeiten kann die Methode weiter optimiert und auf andere Anwendungen ausgedehnt werden. Zusammenfassend lässt sich sagen, dass die wahrnehmungsbasierte Rückkopplung ein innovativer Ansatz ist, um die Strömungssteuerung in Mikrozentrischen Kühlsystemen zu optimieren. Die Integration von theoretischen und experimentellen Ansätzen ermöglicht es uns, ein tiefes Verständnis der zugrunde liegenden Mechanismen zu erlangen und effektive Lösungen zur Verbesserung der Kühlleistung zu entwickeln. Wir sind zuversichtlich, dass diese Forschung dazu beitragen wird, die Leistung und Zuverlässigkeit von Mikrozentrischen Kühlsystemen zu verbessern und damit einen bedeutenden Beitrag zur Weiterentwicklung der Elektronikindustrie zu leisten.

Abschließend lässt sich konstatieren, dass ChatGPT hervorragend dazu befähigt ist, gänzlich sinnentleerte und entbehrliche akademische Texte zu verfassen.

[draegerit]

Arduino Plug and Make Kit: Abstandskontrolle mit Alarmfunktion

In diesem Beitrag erfährst du Schritt-für-Schritt, wie man eine Abstandskontrolle mit Alarmfunktion mit dem Arduino Plug and Make Kit aufbaut und programmiert. Das neue Arduino Plug and Make Kit habe ich dir bereits im gleichnamigen Beitrag Arduino Plug and Make Kit: Was ist drin und wie benutzt man es? vorgestellt. https://youtu.be/YL-enMuAMBc Das Arduino Plug and Make Kit bekommst du derzeit für knapp 90€ inkl. Versandkosten im offiziellen Shop. Aus diesem Kit verwenden wir den Arduino UNO R4 WiFi, den Laser Distanzsensor, den Piezo Buzzer, das 8fach LED Modul sowie den Rotary Encoder. Zusätzlich benötigen wir noch die Modulino Base, ein paar Schrauben & Muttern sowie die Qwiic Anschlusskabel. Das alles ist im Kit enthalten, du benötigst quasis nurnoch deinen PC und einen kleinen Kreuzschraubendreher.

Arduino UNO R4 WiFi

ToF - Distance Sensor

Buzzer

8fach LED Modul

Rotary Encoder

Wie soll das kleine Projekt funktionieren?

Über den Distanzsensor messen wir dauerhaft einen Abstand zu einem Gegenstand (Wand, Türrahmen etc.) wenn dieser Wert unterschritten wird, dann wird ein Alarm (akustisch und visuell) ausgegeben. Über den Rotary Encoder und der 8x12 LED Matrix vom Arduino UNO R4 WiFi stellen wir den Abstand ein. Dabei wird, wenn wir eine Klick-Aktion am Rotary Encoder ausführen, der aktuelle Wert auf der Matrix ausgegeben.

Benötigte Ressourcen für den Aufbau

Für den Aufbau der Schaltung benötigst du: - einen Arduino UNO R4 WiFi, - ein USB-C Datenkabel, - ein ToF / Laser Distanzsensor, - ein Rotary Encoder, - ein 8fach LED Modul, - ein Piezo Buzzer, sowie - ein paar Schrauben und - einen kleinen Kreuzschraubendreher

Arduino Plug and Make Kit - Komponenten für das Alarmprojekt Ausgenommen vom Kreuzschraubendreher ist alles im Arduino Plug and Make Kit enthalten!

Programmieren der Modulino Sensoren / Aktoren in der Ardino IDE

Das Kit ist ausgelegt, um in der Arduino IDE programmiert zu werden. Du musst jedoch zuvor den Boardtreiber für den Arduino UNO R4 WiFi und die Bibliothek für die Modulino Sensoren / Aktoren installieren.

Zu der Bibliothek Modulino erhältst du zu jedem Sensor / Aktor aus diesem Kit ein ausführliches Beispiel und in der offiziellen Dokumentation nochmal viel mehr Informationen. Programm - Durchgangsalarm mit dem Arduino Plug and Make KitHerunterladen Schritt 1 - Importieren der Bibliotheken und erzeugen der Objektinstanzen Im ersten Schritt importieren wir die benötigten Bibliotheken für das Projekt. (Zur Vorbereitung hatten wir bereits die Modulino Bibliothek installiert.) //Bibliothek zum steuern / auslesen //der Modulino Sensoren / Aktoren #include //Bibliotheken zum steuern der //8x12 LED Matrix am Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" Anschließend erzeugen wir uns die Objektinstanzen für unser Projekt. //Objektinstanz der LED-Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Sensoren / Aktoren ModulinoDistance distance; ModulinoPixels leds; ModulinoKnob knob; ModulinoBuzzer buzzer; Schritt 2 - Initialisieren der Kommunikation mit den Sensoren / Aktoren Nachdem die benötigten Bibliotheken installiert und die Objekte erzeugt wurden, müssen wir die I2C Kommunikation starten. Dazu müssen wir bei den Modulinos lediglich die Funktion "begin" aufrufen. Dieses macht die verwendung dieser Module sehr einfach und komfortabel. void setup() { //beginn der seriellen Kommunikation Serial.begin(9600); //beginn der Kommunikation mit der LED-Matrix matrix.begin(); //Vorbereiten der Kommunikation mit den Modulino //Sensoren / Aktoren Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Sensoren / Aktoren distance.begin(); leds.begin(); knob.begin(); buzzer.begin(); //Startwert des Rotary Encoders / Knob auf 0 setzen. knob.set(0); } Zusätzlich setze ich den Wert des Rotary Encoders auf 0. Schritt 3 - Auslesen der Sensorwerte und erzeugen des Alarms Im dritten Schritt lesen wir in der Funktion "loop" zunächst den Wert des Rotary Encoders aus und multiplizieren diesen mit 10. Damit müssen wir nicht so viele Umdrehungen machen damit ein Abstand eingestellt werden kann, wenn du kleine Schritte benötigst dann musst du diesen Wert anpassen. //lesen des aktuellen Wertes vom Rotary Encoder //der Wert wird mit 10 multipliziert und abgespeichert int16_t distanceForAlarm = knob.get() * 10; Wenn der Rotary Encoder gedrückt wird, können wir eine zusätzliche Aktion ausführen, in diesem Fall wird der Wert auf der 8x12 LED Matrix angezeigt. //Wenn der Rotary Encoder gedrückt wird, dann... if (knob.isPressed()) { //Aufrufen der Funktion zum Anzeigen des aktuellen //wertes des Rotary Encoder. displayKnobValue(distanceForAlarm); } Wenn der Distanzsensor erkannt wurde, dann lesen wir einen Messwert und vergleichen diesen mit dem eingestellten Abstand vom Rotary Encoder. if (distance.available()) { //Messwert abrufen und abspeichern int measure = distance.get(); //Wenn der messwert kleiner als der abgespeicherte //Wert für den Alarm ist, dann... if (measure < distanceForAlarm) { //Ausgeben des Textes "Alarm" auf der seriellen Schnittstelle Serial.println("Alarm"); //anzeigen eines visuellen Alarms über das 8fach LED Modul visualAlarm(); //ausgeben eines akustischen Alarms über das Piezo Buzzer Modul soundAlarm(); } } Am Ende legen wir noch eine kleine Pause von 20 Millisekunden ein. //eine kleine Pause von 20 ms. delay(20); Schritt 3.1 - Funktion "displayKnobValue" Die Funktion displayKnobValue zeigt den Wert des Übergebenen Parameters auf der 8x12 LED Matrix an. Sollte jedoch der Wert kleiner 0 sein, so wird eine Fehlermeldung angezeigt. /Funktion zum anzeigen eines Textes auf der //LED-Matrix. void displayKnobValue(int16_t value) { matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(50); String message = "-undefined- "; //Wenn der Wert kleiner 0 ist, dann... if (value < 0) { //erzeugen einer kleinen Fehlermeldung message = "err: val < 0"; } else { //Wenn der wert größer 0 ist, dann müssen wir //eine 12 Zeichen lange Zeichenkette erzeugen. int valueLength = String(value).length(); int partLength = (12 - valueLength) / 2; String part = ""; for (int s = 0; s < partLength; s++) { part += " "; } message = part + String(value) + part; } //ablegen der erstellten Zeichenkette in das Char-Array char text = ""; message.toCharArray(text, 13); //Ausgeben des Textes auf der LED-Matrix //Schriftgröße 4x6 matrix.textFont(Font_4x6); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(text); matrix.endText(SCROLL_LEFT); matrix.endDraw(); } Schritt 3.2 - Funktion "visualAlarm" Die Funktion visualAlarm lässt die LEDs im 25ms. Intervall aufleuchten. //Funktion zum erzeugen eines visuellen Alarms mit //dem 8fach LED Modul. Die LEDs blinken im 25ms. Takt void visualAlarm() { setLEDsStatus(true); delay(25); setLEDsStatus(false); delay(25); } //Funktion zum setzen der LEDs. //Als Parameter wird der erwartete Status übergeben. void setLEDsStatus(bool on) { //Schleife über die LEDs for (int i = 0; i < 8; i++) { //Wenn die LEDs aktiviert werden sollen, dann ist //die Helligkeit auf 100 ansonsten auf 0 leds.set(i, RED, on ? 100 : 0); } //nachdem alle LEDs konfiguriert wurden, dann werden //diese Daten ausgeliefert / angezeigt. leds.show(); } Schritt 3.3 - Funktion "soundAlarm" Mit der Funktion soundAlarm wird der Piezo Buzzer angesteuert und dieser erzeugt einen hellen Ton als zusätzlichen Signal. //Funktion zum erzeugen eines Tones auf //dem Piezo Buzzer Moduls. void soundAlarm() { //die Frequenz des Tones int frequency = 440; //die Dauer int duration = 1000; //erzeugen des Tones buzzer.tone(frequency, duration); delay(50); //abschalten des Tones buzzer.tone(0, duration); delay(25); } Fertiges Projekt - Durchgangsalarm mit dem Arduino Plug and Make Kit Hier nun das fertige Projekt zum kopieren. //Bibliothek zum steuern / auslesen //der Modulino Sensoren / Aktoren #include //Bibliotheken zum steuern der //8x12 LED Matrix am Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" //Objektinstanz der LED-Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Sensoren / Aktoren ModulinoDistance distance; ModulinoPixels leds; ModulinoKnob knob; ModulinoBuzzer buzzer; void setup() { //beginn der seriellen Kommunikation Serial.begin(9600); //beginn der Kommunikation mit der LED-Matrix matrix.begin(); //Vorbereiten der Kommunikation mit den Modulino //Sensoren / Aktoren Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Sensoren / Aktoren distance.begin(); leds.begin(); knob.begin(); buzzer.begin(); //Startwert des Rotary Encoders / Knob auf 0 setzen. knob.set(0); } void loop() { //lesen des aktuellen Wertes vom Rotary Encoder //der Wert wird mit 10 multipliziert und abgespeichert int16_t distanceForAlarm = knob.get() * 10; //Wenn der Rotary Encoder gedrückt wird, dann... if (knob.isPressed()) { //Aufrufen der Funktion zum Anzeigen des aktuellen //wertes des Rotary Encoder. displayKnobValue(distanceForAlarm); } //Wenn ein ToF Sensor verfügbar ist, dann... if (distance.available()) { //Messwert abrufen und abspeichern int measure = distance.get(); //Wenn der messwert kleiner als der abgespeicherte //Wert für den Alarm ist, dann... if (measure < distanceForAlarm) { //Ausgeben des Textes "Alarm" auf der seriellen Schnittstelle Serial.println("Alarm"); //anzeigen eines visuellen Alarms über das 8fach LED Modul visualAlarm(); //ausgeben eines akustischen Alarms über das Piezo Buzzer Modul soundAlarm(); } } //eine kleine Pause von 20 ms. delay(20); } //Funktion zum anzeigen eines Textes auf der //LED-Matrix. void displayKnobValue(int16_t value) { matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(50); String message = "-undefined- "; //Wenn der Wert kleiner 0 ist, dann... if (value < 0) { //erzeugen einer kleinen Fehlermeldung message = "err: val < 0"; } else { //Wenn der wert größer 0 ist, dann müssen wir //eine 12 Zeichen lange Zeichenkette erzeugen. int valueLength = String(value).length(); int partLength = (12 - valueLength) / 2; String part = ""; for (int s = 0; s < partLength; s++) { part += " "; } message = part + String(value) + part; } //ablegen der erstellten Zeichenkette in das Char-Array char text = ""; message.toCharArray(text, 13); //Ausgeben des Textes auf der LED-Matrix //Schriftgröße 4x6 matrix.textFont(Font_4x6); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(text); matrix.endText(SCROLL_LEFT); matrix.endDraw(); } //Funktion zum erzeugen eines visuellen Alarms mit //dem 8fach LED Modul. Die LEDs blinken im 25ms. Takt void visualAlarm() { setLEDsStatus(true); delay(25); setLEDsStatus(false); delay(25); } //Funktion zum erzeugen eines Tones auf //dem Piezo Buzzer Moduls. void soundAlarm() { //die Frequenz des Tones int frequency = 440; //die Dauer int duration = 1000; //erzeugen des Tones buzzer.tone(frequency, duration); delay(50); //abschalten des Tones buzzer.tone(0, duration); delay(25); } //Funktion zum setzen der LEDs. //Als Parameter wird der erwartete Status übergeben. void setLEDsStatus(bool on) { //Schleife über die LEDs for (int i = 0; i < 8; i++) { //Wenn die LEDs aktiviert werden sollen, dann ist //die Helligkeit auf 100 ansonsten auf 0 leds.set(i, RED, on ? 100 : 0); } //nachdem alle LEDs konfiguriert wurden, dann werden //diese Daten ausgeliefert / angezeigt. leds.show(); } Read the full article

[draegerit]

Ideaspark Mikrocontroller: Schritt-für-Schritt-Anleitung zur Anbindung des BME680 über SPI

In diesem Beitrag möchte ich dir zeigen, wie du den Umweltsensor BME680 am ESP8266 von Ideaspark programmierst. Der Mikrocontroller verfügt bereits über ein OLED Display und daher ist dieser Mikrocontroller ideal dafür geeignet Sensordaten sehr einfach zu visualisieren.

Den Umweltsensor BME680 habe ich dir bereits für den Arduino im Beitrag Arduino Lektion #113: Umweltsensor BME680 vorgestellt und gezeigt, wie dieser über I2C programmiert wird. Hier möchte ich nun die andere Schnittstelle (SPI) nutzen, um diesen mit dem ESP8266 zu verbinden. Die Idee zu diesem Beitrag habe ich aus einem Kommentar vom Beitrag ESP8266 Programmierung mit 0,96″ OLED Display von Ideaspark: Eine Schritt-für-Schritt-Anleitung entnommen, wo mich ein aufmerksamer Leser gefragt hat, wie dieser Sensor am Mikrocontroller programmiert wird. Daher geht zunächst ein Gruß an Michael B. heraus.

Benötigte Ressourcen für dieses Projekt

Wenn du dieses Projekt nachbauen möchtest, dann benötigst du: - einen ESP8266 von Ideaspark* mit OLED Display, oder - einen ESP8266 mit separatem 0,96" OLED Display, - einen Umweltsensor BME680*, sowie - einige Breadboardkabel*, - zwei 400 Pin Breadboards* Zusätzlich verwende ich für den Sensor noch eine externe Spannungsversorgung über ein Power Supply Modul* für das Breadboard. An diesen kann man entweder eine Powerbank via USB oder eine 9V Batterie via Jack Adapter anschließen. 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!

Aufbau der Schaltung - Sensor BME680 am ESP8266 von Ideaspark

Da der Ideaspark wie bereits erwähnt über ein eigenes OLED Display verfügt, brauchen wir dieses nicht separat anschließen bzw. verkabeln. In der Schaltung zeige ich dir jedoch, wie ein solches an den ESP8266 angeschlossen wird.

Schaltung - Umweltsensor BME680 & OLED Display am ESP8266 KomponenteESP8266FarbeUmweltsensor BME680VCC5VrotGNDGNDschwarzSCLD1grauSDAD7violettSDOD2braunCSD8blauOLED DisplaySCLD5gelbSDAD6grünVCC5VrotGNDGNDschwarz

Programmieren in der Arduino IDE

Die Programmierung erfolgt in diesem Projekt in der Arduino IDE. Diese Entwicklungsumgebung kannst du dir unter https://www.arduino.cc/en/software für macOS, Windows & Linux herunterladen. Ich empfehle dir hier die neue Version 2.x. Schritt 1 - Installieren der Bibliotheken für das Projekt Bevor wir jedoch beginnen können, müssen wir zwei Bibliotheken installieren. Für den Umweltsensor BME680 verwende ich die Adafruit BME680 Bibliothek, welche du sehr einfach über den internen Bibliotheksverwalter der Arduino IDE installieren kannst. Dazu musst du nur nach "adafruit bme680" suchen und die Schaltfläche "INSTALLIEREN" klicken.

Die gewählte Bibliothek hat jedoch einige Abhängigkeiten, welche wir zusätzlich installieren müssen. Dieses wird uns angezeigt und hier klicken wir auf "ALLE INSTALLIEREN". Für das OLED Display gibt es diverse andere Bibliotheken auch von Adafruit, jedoch habe ich mit der U8G2 Library sehr gute Erfahrungen gesammelt, da diese nicht nur leichtgewichtig ist, sondern auch noch wenig Code benötigt, um Daten anzuzeigen.

Zunächst suchen wir nach u8g2 und klicken dort ebenso auf die Schaltfläche "INSTALLIEREN". In meinem Fall ist diese bereits in der Version 2.34.22 installiert.

Schritt 2 - auslesen der Sensorwerte vom Umweltsensor BME680 am Ideaspark ESP8266

Im ersten Schritt zur Programmierung wollen wir zunächst die Sensorwerte auslesen und auf der seriellen Schnittstelle anzeigen. Dazu können wir das Beispiel unter "DateiBeispieleAdafruit BME680 Librarybme680test.ino" verwenden.

//Bibliotheken für den BME680 Sensor #include #include #include "Adafruit_BME680.h" /** Konfiguration des Sensors am ESP8266 Da der verwendete ESP8266 von Ideaspark bereits über ein I2C OLED Display verfügt welches über D5 & D6 angeschlossen ist, müssen wir andere Pins für die SPI Kommunikation verwenden! **/ #define BME_SCK D1 #define BME_MISO D2 #define BME_MOSI D7 #define BME_CS D8 #define SEALEVELPRESSURE_HPA (1013.25) //erzeugen eines Objektes vom Typ Adafruit_BME680 mit der SPI Konfiguration Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); void setup() { //starten der seriellen Kommunikation mit 9600 Baud. Serial.begin(9600); while (!Serial){ //Warten bis die serielle Schnittstelle bereit steht. } //starten der Kommunikation mit dem Sensor. //Wenn dieses nicht funktioniert, soll eine Fehlermeldung ausgegeben //und eine Endlosschleife gestartet werden. if (!bme.begin()) { Serial.println("Es konnte kein Sensor vom Typ BME680 gefunden werden!"); Serial.println("Prüfen Sie die Verkabelung / Konfiguration!"); while (1) ; } //Setup der Sensordaten (wurde vom Beispiel belassen) bme.setTemperatureOversampling(BME680_OS_8X); bme.setHumidityOversampling(BME680_OS_2X); bme.setPressureOversampling(BME680_OS_4X); bme.setIIRFilterSize(BME680_FILTER_SIZE_3); bme.setGasHeater(320, 150); // 320*C for 150 ms } void loop() { //anfordern der aktuellen Sensordaten if (!bme.performReading()) { Serial.println("Fehler beim lesen der Sensordaten!"); return; } //Funktion String(sensorwert, 2) kürzt den Wert auf zwei Stellen nach dem Komma. //auslesen der Temperatur String temp = "Temperatur: "; temp = temp + String(bme.temperature, 2); temp = temp + " *C"; //auslesen des Luftdrucks String luftdruck = "Luftdruck: "; luftdruck = luftdruck + String(bme.pressure / 100.0, 2); luftdruck = luftdruck + " hPa"; //auslesen der rel. Luftfeuchtigkeit String relLuftfeuchtigkeit = "rel. Luftfeuchtigkeit: "; relLuftfeuchtigkeit = relLuftfeuchtigkeit + String(bme.humidity, 2); relLuftfeuchtigkeit = relLuftfeuchtigkeit + "%"; //auslesen der ungefähren Höhe String hoehe = "ungef. Höhe: "; hoehe = hoehe + String(bme.readAltitude(SEALEVELPRESSURE_HPA), 2); hoehe = hoehe + " m"; //berechnen der Luftqualität String luftqualitaet = "Luftqualität: "; luftqualitaet = luftqualitaet + String(bme.gas_resistance / 1000.0,2); luftqualitaet = luftqualitaet + " kOhm"; //ein Trenner Serial.println("**************************"); //Ausgeben der ermittelten Daten auf der seriellen Schnittstelle Serial.println(temp); Serial.println(luftdruck); Serial.println(relLuftfeuchtigkeit); Serial.println(hoehe); Serial.println(luftqualitaet); //eine kleine Pause von 2 Sekunden delay(2000); } Dieser Code erzeugt die Ausgabe der Sensordaten auf der seriellen Schnittstelle.

Programm - Umweltsensor BME680 & ESP8266 von Ideaspark, serielle AusgabeHerunterladen Wichtiger Hinweis: vor dem Upload externe Spannungsversorgung trennen! Damit ich den Code erfolgreich hochladen konnte, musste ich die externe Spannungsversorgung trennen. Da ich ein kleines Power-Modul für das Breadboard verwende, ist dort ein Schalter drauf, welchen ich dazu einfach betätigen musste. Nach dem erfolgreichen Upload erhalte ich zunächst eine Fehlermeldung vom Mikrocontroller, diese wird aber mit Betätigen des Schalters und damit die Spannungsversorgung zum Sensor wieder nichtig. Es konnte kein Sensor vom Typ BME680 gefunden werden! Prüfen Sie die Verkabelung / Konfiguration! --------------- CUT HERE FOR EXCEPTION DECODER --------------- Soft WDT reset Exception (4): epc1=0x402027ac epc2=0x00000000 epc3=0x00000000 excvaddr=0x00000000 depc=0x00000000 >>>stack>>> ctx: cont sp: 3ffffe50 end: 3fffffd0 offset: 0160 3fffffb0: feefeffe 00000000 3ffee91c 40204e18 3fffffc0: feefeffe feefeffe 3fffdab0 40101001 Read the full article

[draegerit]

Smart Living mit Tuya: Bluetooth Sensor für präzise Raumklima-Analyse

Die Firma Tuya bietet einen Bluetooth-Sensor an, der es ermöglicht, Temperatur und relative Luftfeuchtigkeit zu messen. Mit diesem Sensor kannst du die erfassten Daten in einer App namens "Smart Live - Smart Living" visualisieren. Im Folgenden werde ich dir zeigen, wie du das Gerät einrichtest und in der genannten App konfigurierst. https://youtu.be/5IIm-MmXTAM Diesen Sensor habe ich mir bei aliexpress.com für unschlagbare 3,60 € zzgl. Versandkosten erstanden. Für diesen Preis bekommst du einen drahtlosen Sensor für Temperatur und rel. Luftfeuchtigkeit, welchen du auch von deinem Handy ablesen kannst. Das Problem gleich vorne weg, dieser Sensor arbeitet lediglich über Bluetooth und da kommt ein kleines Problem, denn du hast mit deinem Handy nur eine begrenzte Reichweite und somit musst du dich für das drahtlose Ablesen der Sensorwerte immer in einem bestimmten Radius von diesem Gerät befinden. Aber das Gerät zeichnet diese Daten im Hintergrund auf und überträgt diese, sobald man sich wieder in Reichweite befindet.

Warum das Raumklima entscheidend für dein Zuhause ist

Das Raumklima, insbesondere die Temperatur und Luftfeuchtigkeit, spielt eine entscheidende Rolle für die Gesundheit der Bewohner und den Erhalt des Wohnraums. Hier sind einige Gründe, warum es wichtig ist, das Raumklima im Blick zu behalten: - Gesundheitliche Aspekte: - Wohlbefinden: Ein angenehmes Raumklima fördert das allgemeine Wohlbefinden. Eine moderate Raumtemperatur und optimale Luftfeuchtigkeit tragen dazu bei, dass sich Menschen in ihren Räumen wohlfühlen. - Vermeidung von Krankheiten: Zu niedrige Temperaturen können das Immunsystem schwächen und das Risiko von Atemwegserkrankungen erhöhen. Zu hohe Luftfeuchtigkeit begünstigt das Wachstum von Schimmelpilzen, die wiederum Atemwegsprobleme und Allergien verursachen können. - Erhalt des Wohnraums: - Schutz vor Feuchtigkeit: Zu hohe Luftfeuchtigkeit kann Schäden an Gebäuden verursachen, indem sie Schimmelbildung begünstigt, Holz verrottet und Metall korrodiert. Ein geeignetes Raumklima hilft, diese Probleme zu vermeiden und der baulichen Substanz des Wohnraums zu schützen. - Energieeffizienz: Die richtige Raumtemperatur trägt zur Energieeffizienz bei. Übermäßiges Heizen oder Kühlen kann zu höheren Energiekosten führen. Eine optimale Temperatur ermöglicht eine effiziente Nutzung von Heizungs- und Kühlsystemen. - Luftqualität: - Luftaustausch: Ein ausgeglichenes Raumklima fördert den regelmäßigen Luftaustausch, was wichtig für die Reduzierung von Schadstoffen und CO2 in der Luft ist. Dies ist besonders relevant in gut isolierten Gebäuden, in denen frische Luftzufuhr manuell gesteuert werden muss. Insgesamt ist die Aufrechterhaltung eines gesunden und wohnlichen Raumklimas entscheidend für das physische und psychische Wohlbefinden der Bewohner sowie für den langfristigen Erhalt der Bausubstanz eines Gebäudes. Daher sollten Temperatur und Luftfeuchtigkeit regelmäßig überwacht und gegebenenfalls durch geeignete Maßnahmen, wie Belüftung, Heizung oder Entfeuchtung, angepasst werden.

Technische Daten des Bluetooth Sensors für Temperatur und rel. Luftfeuchtigkeit

Technische Daten des Tuya Bluetooth Temperatur & rel. Luftfeuchtigkeitssensors: - Messbereich: - Temperatur: -9,9 °C bis 60 °C - Relative Luftfeuchtigkeit: 0 % bis 99 % - Drahtlose Verbindung: - Bluetooth 5.0 BLE - Display: - 2farbig monochrom - Batterie: - 3V, CR2032 - Abmessungen: - 43 mm x 43 mm x 10 mm

Aufbau des Sensors

Der Sensor verfügt auf der Vorderseite über ein Display, auf welchem du die Temperatur in Grad Celsius und die relative Luftfeuchtigkeit ablesen kannst. Der Smiley im Display visualisiert, ob der gemessene Wert gesund ist.

Auf der Rückseite befindet sich ein Taster welcher zwei Funktionen hat, wenn du diesen einmal kurz betätigst, dann wird die Temperatur auf dem Display zwischen Grad Celsius und Fahrenheit gewechselt. Wenn du jedoch den Taster für 5 Sekunden betätigst, dann wird der Sensor in den Modus zum Koppeln versetzt, dass dieser Modus aktiv ist, siehst du dann am blinkenden Bluetoothsymbol im Display.

Koppeln des Bluetooth Sensors mit dem Handy

Damit wir die Daten vom Handy aus ablesen können, benötigen wir die App "Smart Live - Smart Living", diese gibt es in den einschlägigen App-Stores für iOS und Android.

Während die App nun heruntergeladen und installiert wird, können wir den Bluetooth Sensor in den Kopplungsmodus versetzen. Dazu drücken wir den Taster für 5 Sekunden, es wird jetzt ein Reset ausgeführt (das Display geht kurz aus), danach erscheint zusätzlich ein kleines Bluetoothsymbol im Display welches blinkt.

Einrichten eines Alarms in der App

Du kannst bei bestimmten Messwerten einen Alarm an dein Handy via Push-Nachricht erstellen. Das Feature ist nützlich, wenn du diesen Sensor in einem Gewächshaus aufstellst oder in der Waschküche, wo ggf. eine hohe Luftfeuchtigkeit eher schädlich sein kann.

Wenn ein Alarm eingerichtet wurde, dann wird dir automatisch bei unter oder überschreiten der eingestellten Schwellwerte eine Push-Benachrichtigung an dein Handy gesendet. Dabei muss sich jedoch der Tuya Bluetooth Sensor in Reichweite deines Handys befinden.

Fazit zum Tuya Bluetooth Sensor für das Messen des Raumklimas

Dieser Sensor ist sehr nützlich und durch seinen geringen Preis bekommt man einen drahtlosen Sensor, wo man bei anderen Herstellern deutlich tiefer in die Tasche greifen muss. Ebenso gut gelungen ist die Push-Benachrichtigung, welche man erhält, wenn ein Messwert einen Schwellwert unter oder überschreitet, somit kann man rechtzeitig Gegenmaßnahmen ergreifen. Read the full article

[draegerit]

Calliope Mini 3 Tutorial: Datenlogger in Aktion - Temperaturaufzeichnung

In diesem Beitrag möchte ich das Feature Datenlogger in der neuen Version von MakeCode für den Calliope Mini 3 vorstellen. Auf dem Calliope Mini findest du einige Sensoren und auch Aktoren, darunter ist ein Temperatursensor, von diesem möchte ich nun die Daten über einen Zeitraum aufzeichnen und mit dem Datenlogger können diese dann als TXT-Datei oder CSV-Datei exportiert werden.

Calliope Mini 3 Tutorial: Datenlogger in Aktion - Temperaturaufzeichnung In diesem Beitrag verwende ich die Earlybird Version von MakeCode diese kann sich ggf. von der finalen Version unterscheiden. Ebenso können Schaltflächen umbenannt, verschoben oder entfernt werden.

Lesen der Temperatur am Calliope Mini 3

Der Calliope Mini 3 verfügt wie auch seine Vorgänger über einen Temperatursensor, welcher in der CPU sitzt. Diesen kannst du recht einfach mit nur einem Block auslesen und den Wert auf der 5x5 LED Matrix anzeigen lassen. Diese Temperatur möchte ich jetzt mithilfe des Datenloggers auf dem Calliope Mini speichern. Zusätzlich können wir noch einen Zeitwert (Sekunde, Minute, Stunde) dazu speichern.

Speichern der Temperatur auf dem Calliope Mini 3 mit dem Datenlogger

Im nachfolgenden YouTube-Video erläutere ich dir, wie du die Temperaturwerte auf dem Calliope Mini 3 mit dem Datenlogger speicherst. https://youtu.be/ajGLInJVQO0 Programme aus dem Video Hier nun die kleinen Programme aus dem YouTube-Video zum Download als HEX-Datei. Programm - Calliope Mini 3 - Temperatursensor & RGB LEDsHerunterladen Programm - Calliope Mini 3 - Temperatursensor & DatenloggerHerunterladen

Schritt-für-Schritt-Anleitung zum Speichern der Daten auf dem Calliope Mini 3

Das Feature Datenlogger (datalogger) müssen wir zunächst über die Erweiterungen dem Editor hinzufügen.

Laden der Erweiterung Datenlogger Sobald die Erweiterung datalogger geladen ist, sehen wir einen neuen Menüeintrag "Datenlogger" mit vielen neuen Blöcken.

Menüpunkt "Datenlogger" in MakeCode Mit diesen Blöcken können wir jetzt die Daten des Temperatursensors (oder von jedem anderen Sensor welcher angeschlossen wird) in den Speicher des Calliope Mini 3 speichern. Kleines Programm zum Speichern des Temperaturwertes

Codeblock zum Speichern der Daten auf dem Calliope Mini 3 In diesem kleinen Programm habe ich eine Variable "index" angelegt, welche bei jedem Durchlauf um eins erhöht wird. Die Spalte für den Zeitstempel lasse ich ausblenden. Danach folgt der Block für das Speichern der Daten in einer Zeile Index & Temperatur. Wichtig ist, dass der Block "spiegle Daten seriell" eingefügt und auf EIN gestellt wird, denn ohne würde man die Daten nicht betrachten können. Zum Schluss legen wir eine Pause von 2 Sekunden ein. Download der HEX-Datei Nachfolgend findest du das kleine Programm zum download. Du brauchst dir lediglich die HEX-Datei in MakeCode importieren, die Erweiterung gibt es quasi dazu. Programm - Calliope Mini 3 - Temperatursensor & DatenloggerHerunterladen Ansicht der Daten im Diagramm Über die Schaltfläche "Daten anzeigen Gerät" auf der linken Seite kannst du in die Ansicht gehen wo dir diese Daten in einem Diagramm und in Rohform angezeigt werden.

Ansicht der Daten in einem Diagramm in MakeCode Die Farben des Liniendiagramms sind rein zufällig und lassen sich derzeit nicht konfigurieren. Die Rohdaten werden kommasepariert aufgelistet. Bei einem Sensorwert mit Nachkommastellen wird dieser mit einem Punkt getrennt (englisches Format). Oben rechts findest du drei Schaltflächen (v.l.n.r.) zum Pausieren der Aufzeichnung, zum Exportieren der Daten als CSV-Datei und als TXT-Datei der Rohdaten.

Ablage und Speicherdauer der Daten

Die Daten welche vom Datenlogger gespeichert werden, werden auch hier leider im flüchtigen Speicher abgelegt. Das heißt, dass die Daten beim betätigen des RESET-Buttons gelöscht werden.

Fazit & Ausblick

Der Datenlogger Der Calliope Mini verfügt über zwei Grove-Schnittstellen an welche du externe Sensoren / Aktoren anschließen kannst. Darunter zum Beispiel eine RealTimeClock DS3231 (kurz RTC). Mit dieser könntest du einen echten Zeitstempel aus Datum & Uhrzeit zur Temperatur speichern, aber dieses würde nun zu weit gehen und das Projekt werde ich dir in einem separaten Beitrag präsentieren. Read the full article

[draegerit]

DS18B20-Sensoren am Raspberry Pi Pico W: Temperaturdaten auf einer Webseite anzeigen

Willkommen zu meinem heutigen Beitrag auf meinem Technikblog! Vor kurzem habe ich einen interessanten Kommentar von einem aufmerksamen Leser erhalten. Er stellte die Frage, wie man mehrere Sensordaten, insbesondere Temperaturwerte, auf einer Webseite darstellen kann. Eine faszinierende Idee, die mich dazu inspiriert hat, diesen Beitrag zu verfassen. In diesem Artikel werde ich dir zeigen, wie du genau das mit dem DS18B20-Sensor und dem Raspberry Pi Pico W erreichen kannst. Zusammen werden wir lernen, wie man die Sensoren anschließt, die Daten ausliest und sie auf einer Webseite in ansprechender Weise präsentiert.

Im Beitrag Raspberry Pi Pico W - anzeigen von Sensordaten auf einer Webseite habe ich dir bereits erläutert, wie man die Sensordaten eines BME280 Sensors auf einer Webseite visualisiert. Hier möchte ich teile des Quellcodes wiederverwenden und dir aufzeigen, wie man die Sensordaten von mehreren DS18B20 Sensoren am Pi Pico auf einer Webseite anzeigen kannst.

Aufbau der Schaltung am Raspberry Pi Pico W

Der Raspberry Pi Pico / Pico W hat 26 GPIOs (davon 6 analoge Pins) somit können wir eine Menge an Sensoren anschließen und auf der Seite anzeigen. In meinem Fall möchte ich 6 Temperatursensoren anschließen und benötige für die Schaltung: - einen Raspberry Pi Pico W, - ein Micro-USB Datenkabel, - sechs Temperatursensoren DS18B20, - einen 4,7 kOhm Widerstand, - ein paar Breadboardkabel, männlich-männlich, 10 cm, - ein 830 Pin Breadboard Wie man aus der Grafik entnehmen kann, sind die Temperatursensoren in Reihe geschaltet und mit nur einem GPIO des Pi Pico verbunden.

Schaltung - mehrere Temperatursensoren vom Typ DS18B20 am Raspberry Pi Pico / Pico W Jeder Temperatursensor vom Typ DS18B20 hat eine eigene einzigartige ID über welche dieser referenziert werden kann und somit können wir quasi fast beliebig viele Sensoren hintereinander schalten. Wir müssen lediglich darauf achten, die maximale Stromaufnahme pro GPIO (16 mA) nicht zu überschreiten.

Schaltung - Raspberry Pi Pico mit mehreren DS18B20 Sensoren

Auslesen der Sensoren in Micropython

Zunächst schreiben wir ein kleines Programm in Micropython um die Sensoren auszulesen. #Import der benötigten Module #zum Zugriff auf den Sensor DS18B20 #und der Pins des Pi Pico import machine, onewire, ds18x20, time #der Sensor ist am GPIO16 angeschlossen sensorPin = machine.Pin(16) #initialisieren eines Objektes vom Typ DS18X20 ds18b20Sensor = ds18x20.DS18X20(onewire.OneWire(sensorPin)) #anlegen eines Feldes für die IDs der Sensoren roms = None def setup(): #Zugriff auf die Globale Variable roms global roms #auslesen der IDs der Sensoren roms = ds18b20Sensor.scan() #ausgeben der Anzahl der Sensoren auf #der seriellen Schnittstelle print('Anzahl gefundener Sensoren: ', len(roms)) def main(): #Zugriff auf die Globale Variable roms global roms #starten einer Endlosschleife, ... while True: #auslesen der Sensorwerte ds18b20Sensor.convert_temp() #nach dem aufruf der Funktion "convert_temp()" #soll man gem. Dokumentation 750ms warten time.sleep_ms(750) #erzeugen eines Indexes idx = 0 #Schleife über die gefundenen IDs / Sensoren for rom in roms: #Index um eins erhöhen idx = idx + 1 #Ausgeben der Temperatur, zusätzlich wird noch der Temperaturwert #auf 2 Stellen nach dem Komma gekürzt print("#", str(idx), " Temperatur:", round(ds18b20Sensor.read_temp(rom),2), "°C") #Pause von 5 Sekunden time.sleep(5) setup() main() Wenn wir diesen Code auf dem Pi Pico / Pico W ausführen, dann sollten wir in der Konsole nun die Werte der Sensoren ablesen können.

Ausgabe der Temperaturwerte von den angeschlossenen Sensoren

Anzeigen der Sensorwerte von mehreren DS18B20 am Pi Pico auf einer Webseite

Im nächsten Schritt wollen wir diese Sensorwerte jetzt auf einer kleinen Webseite anzeigen lassen. Zusätzlich möchte ich einen Schritt weitergehen und ein Diagramm anzeigen lassen, in welchem die Sensordaten visualisiert werden.

Sensordaten der DS18B20 Sensoren auf einer Webseite Schritt 1 - Aufbau des Codes Zunächst erzeugen wir uns zwei Funktionen setup: Diese Funktion wird einmalig aufgerufen. main: Diese Funktion beinhaltet den Ablauf des Programmes. Wenn du bereits Erfahrung mit dem Arduino gesammelt hast, dann wird dir dieses nicht fremd sein. Der Vorteil ist, dass man hier besser nachvollziehen kann, wann was gestartet wird. def setup(): pass def main(): pass setup() main() Schritt 2 - Aufbau der WiFi-Verbindung Im ersten Schritt bauen wir die WiFi-Verbindung auf. Dazu benötigen wir die SSID sowie das Passwort für das lokale WiFi-Netzwerk. Diese beiden Werte legen wir uns in Felder im Code ab. #Import der benötigten Module #für den Aufbau der WiFi-Verbindung import network import socket ssid = 'FRITZBox7590GI24' password = '22894580214767401850' #anlegen eines Feldes für die WiFi-Verbindung wlan = None #anlegen eines Feldes für die Socketverbindung s = None def doConnect(): global wlan, s wlan=network.WLAN(network.STA_IF) wlan.active(True) #Wenn die Verbindung nicht erstellt wurde, dann... if not wlan.isconnected(): #Aufbau der WiFi-Verbindung mit den Daten wlan.connect(ssid, password) #solange die Verbindung noch nicht hergestellt wurde #dann soll diese Schleife laufen und einen Punkt ausgeben while not wlan.isconnected(): #einen Punkt ausgeben ohne Zeilenumbruch! print(".", end="") #kleine Pause von 250 Millisekunden time.sleep(0.250) print("") #Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde, #dann soll auf der seriellen Schnittstelle der Text ausgegeben werden print('Verbindung erfolgreich zu', ssid, 'aufgebaut!') status = wlan.ifconfig() print('IP-Adresse: ' + status) addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) def setup(): doConnect() def main(): pass setup() main() Wenn wir den Code ausführen, dann wird beim Aufbau einer WiFi-Verbindung die IP-Adresse ausgegeben, welche wir im späteren Verlauf im Browser eingeben können, um die Webseite aufzurufen.

Schritt 3 - Auslesen der Sensordaten in einem Intervall Wir müssen eine Endlosschleife starten, in welcher wir "lauschen", ob sich Clients mit dem Pi Pico verbinden wollen. Zeitgleich müssen wir aber auch die Sensordaten in einem Intervall auslesen. Wir können hier aber nicht die Funktion sleep aus dem Modul time verwenden, denn dann legt der Mikrocontroller eine Pause ein und in dieser Zeit kann sich kein neuer Client verbinden. Meine Lösung ist, die Sekunden seit dem 01.0.1.1970 auszulesen und zu prüfen ob seit dem letzen Lesevorgang eine Zeit X zbsp. 30 Sekunden vergangen ist. #Import der benötigten Module #zum Zugriff auf den Sensor DS18B20 #und der Pins des Pi Pico import machine, onewire, ds18x20, time #Import der benötigten Module #für den Aufbau der WiFi-Verbindung import network import socket ssid = 'xxx' password = 'yyy' #der Sensor ist am GPIO16 angeschlossen sensorPin = machine.Pin(16) #initialisieren eines Objektes vom Typ DS18X20 ds18b20Sensor = ds18x20.DS18X20(onewire.OneWire(sensorPin)) #anlegen eines Feldes für die IDs der Sensoren roms = None #anlegen eines Feldes für die WiFi-Verbindung wlan = None s = None data = actualTime = 0 lastReadSensordata = 0 readSensordataIntervall = 30 def doConnect(): global wlan, s wlan=network.WLAN(network.STA_IF) wlan.active(True) #Wenn die Verbindung nicht erstellt wurde, dann... if not wlan.isconnected(): #Aufbau der WiFi-Verbindung mit den Daten wlan.connect(ssid, password) #solange die Verbindung noch nicht hergestellt wurde #dann soll diese Schleife laufen und einen Punkt ausgeben while not wlan.isconnected(): #einen Punkt ausgeben ohne Zeilenumbruch! print(".", end="") #kleine Pause von 250 Millisekunden time.sleep(0.250) print("") #Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde, #dann soll auf der seriellen Schnittstelle der Text ausgegeben werden print('Verbindung erfolgreich aufgebaut!') status = wlan.ifconfig() print('IP-Adresse: ' + status) addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) def readSensordata(): result = #auslesen der Sensorwerte ds18b20Sensor.convert_temp() #nach dem aufruf der Funktion "convert_temp()" #soll man gem. Dokumentation 750ms warten time.sleep_ms(750) #erzeugen eines Indexes #Schleife über die gefundenen IDs / Sensoren for rom in roms: result.append(round(ds18b20Sensor.read_temp(rom),2)) return result def setup(): #Zugriff auf die globalen Variablen roms, wifi global roms #auslesen der IDs der Sensoren roms = ds18b20Sensor.scan() #ausgeben der Anzahl der Sensoren auf #der seriellen Schnittstelle print('Anzahl gefundener Sensoren: ', len(roms)) doConnect() def main(): #Zugriff auf die Globale Variable roms global roms, data, lastReadSensordata #starten einer Endlosschleife, ... while True: #nur alle 30 Sekunden neue Sensordaten lesen actualTime = time.time() if (lastReadSensordata+readSensordataIntervall)< actualTime: lastReadSensordata = actualTime data = readSensordata() #ausgeben der Daten auf der seriellen Schnittstelle print(data) setup() main() Wenn wir nun auf die Konsole schauen, dann sehen wir, dass im angegebenen Intervall die Sensordaten gelesen und ausgegeben werden.

Ausgabe der Sensordaten auf der Konsole Schritt 4 - Anzeigen der Webseite mit den Sensordaten Nachdem wir nun die Sensordaten in eine Liste ausgelesen haben wollen wir diese auf eine Webseite anzeigen. Dazu schreiben wir eine kleine Webseite mit ebenso ein wenig CSS für das Styling.

Sensordaten

{dataTable} In dem HTML Code setzen wir einen Platzhalter {dataTable} an der Stelle ein, wo wir die Tabelle einfügen wollen. Diese Datei speichern wir nun auf dem Pi Pico als Datei "website.html".

Diese Datei lesen wir nun in eine Variable ein und ersetzen mit der Funktion format den Platzhalter mit den Daten unserer Tabelle, welche wir zuvor in eine HTML-Tabelle umgewandelt haben. #Import der benötigten Module #zum Zugriff auf den Sensor DS18B20 #und der Pins des Pi Pico import machine, onewire, ds18x20, time #Import der benötigten Module #für den Aufbau der WiFi-Verbindung import network import socket ssid = 'xxx' password = 'yyyy' #der Sensor ist am GPIO16 angeschlossen sensorPin = machine.Pin(16) #initialisieren eines Objektes vom Typ DS18X20 ds18b20Sensor = ds18x20.DS18X20(onewire.OneWire(sensorPin)) #anlegen eines Feldes für die IDs der Sensoren roms = None #anlegen eines Feldes für die WiFi-Verbindung wlan = None s = None data = actualTime = 0 lastReadSensordata = 0 readSensordataIntervall = 30 def doConnect(): global wlan, s wlan=network.WLAN(network.STA_IF) wlan.active(True) #Wenn die Verbindung nicht erstellt wurde, dann... if not wlan.isconnected(): #Aufbau der WiFi-Verbindung mit den Daten wlan.connect(ssid, password) #solange die Verbindung noch nicht hergestellt wurde #dann soll diese Schleife laufen und einen Punkt ausgeben while not wlan.isconnected(): #einen Punkt ausgeben ohne Zeilenumbruch! print(".", end="") #kleine Pause von 250 Millisekunden time.sleep(0.250) print("") #Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde, #dann soll auf der seriellen Schnittstelle der Text ausgegeben werden print('Verbindung erfolgreich aufgebaut!') status = wlan.ifconfig() print('IP-Adresse: ' + status) addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) def readSensordata(): result = #auslesen der Sensorwerte ds18b20Sensor.convert_temp() #nach dem aufruf der Funktion "convert_temp()" #soll man gem. Dokumentation 750ms warten time.sleep_ms(750) #erzeugen eines Indexes #Schleife über die gefundenen IDs / Sensoren for rom in roms: result.append(round(ds18b20Sensor.read_temp(rom),2)) return result def createHtmlTable(data): htmlTable = """ Sensor Wert {bodyRows} """ idx = 0 rows = "" for value in data: idx = idx + 1 rows += "{sensor}{wert}".format(sensor=str(idx), wert=str(value)+"°C") return htmlTable.format(bodyRows=rows) def getWebsite(dataTbl): with open('website.html', "r") as file: website = file.read() file.close() return website.format(dataTable=dataTbl) def deliverWebsite(website): global s cl, addr = s.accept() cl.send('HTTP/1.0 200 OKrnContent-type: text/htmlrnrn') cl.send(website) cl.close() def setup(): #Zugriff auf die globalen Variablen roms, wifi global roms #auslesen der IDs der Sensoren roms = ds18b20Sensor.scan() #ausgeben der Anzahl der Sensoren auf #der seriellen Schnittstelle print('Anzahl gefundener Sensoren: ', len(roms)) doConnect() def main(): #Zugriff auf die Globale Variable roms global roms, data, lastReadSensordata #starten einer Endlosschleife, ... while True: #nu Read the full article

[draegerit]

Aufbau eines Ultraschall-Abstandswarners mit Raspberry Pi Pico

Ein Jahr ist vergangen, seitdem ich auf meinem Blog über das aufregende Thema "Raspberry Pi Pico & Ultraschall-Abstandswarner" geschrieben habe. Doch heute möchte ich einen Blick zurückwerfen und eine kleine Ergänzung zu diesem faszinierenden Projekt präsentieren, das durch einen inspirierenden Kommentar auf YouTube angeregt wurde.

In meinem früheren Beitrag haben wir bereits die Grundlagen erkundet, hier möchte ich nun speziell auf diesen Kommentar eingehen.

Es geht also um eine Schaltung am Raspberry Pi Pico / Pico W mit fünf Ultraschallsensoren, wo die Sensorwerte < 50 cm zu einem Ereignis führen sollen. Ich habe derzeit nur vier Sensoren vom Typ HC-SR04 im Sortiment. Aber was mit vier Sensoren funktioniert, wird auch mit fünf oder mehr funktionieren!

Benötigte Ressourcen für dieses Projekt

Wenn du die Schaltung am Raspberry Pi Pico / Pico W nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro-USB Datenkabel, - vier Ultraschallsensoren vom Typ HC-SR04, - vier Leuchtdioden, 5 mm, - vier 220 Ohm Vorwiderstände, - diverse Breadboardkabel, - zwei 830 Pin Breadboard

Alternativer Mikrocontroller zum Raspberry Pi Pico

Du musst nicht zwingend einen originalen Raspberry Pi Pico für dieses Projekt verwenden. In meinem Fall nutze ich zum Beispiel den Sumolink Erhu RP2040, welcher dem Pi Pico in nichts nachsteht, aber etwas günstiger in der Anschaffung ist.

Sumolink Erhu RP240

Sumolink Erhu RP240

Aufbau der Schaltung - Raspberry Pi Pico mit Ultraschall-Sensoren

Der Aufbau der Schaltung auf Steckbretter erfolgt auf zwei 830 Pin Breadboards.

Schaltung: Raspberry Pi Pico mit 4 Ultraschallabstandssensoren Hier nun die Tabelle mit den Anschlüssen der einzelnen Komponenten: KomponenteRaspberry Pi PicoHC-SR04 - #1VCC5VGNDGNDEchoGP3TriggerGP2HC-SR04 - #2VCC5VGNDGNDEchoGP5TriggerGP4HC-SR04 - #3VCC5VGNDGNDEchoGP7TriggerGP6HC-SR04 - #4VCC5VGNDGNDEchoGP9TriggerGP8LED #1 Kathode220 Ohm Widerstand > GNDAnodeGP16LED #2Kathode220 Ohm Widerstand > GNDAnodeGP17LED #3Kathode220 Ohm Widerstand > GNDAnodeGP18LED #4Kathode220 Ohm Widerstand > GNDAnodeGP190,92" OLED DisplayGNDGNDVCC5VSCLGP1SDAGP0 Du kannst natürlich auch mehrere kleine 170 Pin Breadboards verwenden und diese dann im Halbkreis aufbauen, um so 180° zu überwachen.

Aufbau der Schaltung mit Breadboardkabel

Programmieren in der Thonny IDE

Den Raspberry Pi Pico kannst du in der Thonny IDE einfach in Micropython programmieren. Dieses Tool kannst du dir unter https://thonny.org/ kostenfrei herunterladen. Ich musste jedoch zuvor meinen Mikrocontroller für Micropython flashen. Wie du das machst, habe ich dir bereits im Beitrag Raspberry PI Pico #1 – Vorstellung erläutert. https://youtu.be/ULydV3mTQgo Das Programm kannst du dir unter nachfolgenden Link herunterladen. Die Datei kannst du dann mit der Thonny IDE öffnen und als code.py auf dem Pi Pico speichern. Programm in Micropython - Raspberry Pi Pico Ultraschall-AbstandswarnerHerunterladen Hier nun der Code: from machine import Pin, I2C from ssd1306 import SSD1306_I2C import time as time import utime i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) ledPin1 = Pin(16, Pin.OUT) ledPin2 = Pin(17, Pin.OUT) ledPin3 = Pin(18, Pin.OUT) ledPin4 = Pin(20, Pin.OUT) sensor1Trigger = Pin(2, Pin.OUT) sensor1Echo = Pin(3, Pin.IN) sensor2Trigger = Pin(4, Pin.OUT) sensor2Echo = Pin(5, Pin.IN) sensor3Trigger = Pin(6, Pin.OUT) sensor3Echo = Pin(7, Pin.IN) sensor4Trigger = Pin(8, Pin.OUT) sensor4Echo = Pin(9, Pin.IN) sensor1Value = 12 sensor2Value = 12 sensor3Value = 12 sensor4Value = 12 sensorActiveDistance = 10 def setup(): ledPin1.off() ledPin2.off() ledPin3.off() ledPin4.off() def toggleLED(pin): pin.toggle() def formatValue(value): return str("{:4.2f}".format(value)+" cm") def updateDisplay(): global sensor1Value, sensor2Value, sensor3Value, sensor4Value oled.fill(0) oled.text("#1 "+formatValue(sensor1Value), 0, 0) oled.text("#2 "+formatValue(sensor2Value), 0, 15) oled.text("#3 "+formatValue(sensor3Value), 0, 30) oled.text("#4 "+formatValue(sensor4Value), 0, 45) oled.show() def readUltrasonicSensor(trigger, echo): trigger.low() utime.sleep_us(2) trigger.high() utime.sleep_us(5) trigger.low() signaloff = 0 while echo.value() == 0: signaloff = utime.ticks_us() signalon = 0 while echo.value() == 1: signalon = utime.ticks_us() timepassed = signalon - signaloff return (timepassed * 0.0343) / 2 def checkValueSetState(value, pin): if (value < sensorActiveDistance): pin.on() else: pin.off() def main(): global sensor1Value, sensor2Value, sensor3Value, sensor4Value while True: sensor1Value = readUltrasonicSensor(sensor1Trigger, sensor1Echo) sensor2Value = readUltrasonicSensor(sensor2Trigger, sensor2Echo) sensor3Value = readUltrasonicSensor(sensor3Trigger, sensor3Echo) sensor4Value = readUltrasonicSensor(sensor4Trigger, sensor4Echo) checkValueSetState(sensor1Value, ledPin1) checkValueSetState(sensor2Value, ledPin2) checkValueSetState(sensor3Value, ledPin3) checkValueSetState(sensor4Value, ledPin4) updateDisplay() time.sleep(0.5) setup() main() Read the full article

[draegerit]

Raspberry Pi Pico BASIC #7 – I2C-Display programmieren

Willst du lernen, wie du ein I2C-Display mit dem Raspberry Pi Pico und PicoMite / BASIC zum Laufen bringst? In diesem Artikel zeige ich dir einfache Schritte, um beeindruckende Ergebnisse zu erzielen. Egal, ob du ein Anfänger oder bereits erfahrener Raspberry Pi-Nutzer bist, meine detaillierte Anleitung hilft dir dabei, das Display anzuschließen und zu programmieren. Tauchen wir gleich ein und entdecke mit mir die faszinierende Welt der I2C-Displays mit Raspberry Pi Pico und PicoMite!

In vergangenen Beiträgen hatte ich dir bereits gezeigt, wie du eine RealTimeClock an den Pi Pico anschließt und programmierst, hier möchte ich an den Beitrag nun anknüpfen und die Werte für Datum & Uhrzeit auf dem Display anzeigen.

I2C Schnittstellen am Raspberry Pi Pico

Der Raspberry Pi Pico & Pico W haben mehrere I2C Schnittstellen, damit kannst du mehrere Displays betreiben (vorausgesetzt die Adressen sind verschieden).

Pinout des Raspberry PI Pico Das Bild enthält das Pinout des Raspberry Pi Pico dieser Mikrocontroller ist das Vorgängermodell des Pico W. Jedoch ist die Pinbelegung gleich, daher ist das Bild noch aktuell (Stand 29.05.2023).

Einrichten der I2C Schnittstelle in PicoMite

Bevor wir die I2C Schnittstelle an den gewünschten Pins verwenden können, müssen wir diese konfigurieren. In meinem Fall verwende ich ein I2C-Display mit dem Treiberchip SSD1306, dieser wird auch vom System unterstützt und kann mit dem nachfolgenden Befehl eingerichtet werden. OPTION LCDPANEL SSD1306I2C, , Für den Platzhalter "" setzt du den Wert für Hochform- oder Querformat. - Hochformat = L, - Querformat = P Mit dem optionalen Parameter offset kannst du dein I2C-Display ausrichten. Wenn du ein 0,96" OLED Display verwendest, dann ist dieser Parameter 0 (default, kann also entfallen). Solltest du jedoch ein 1,3" OLED Display verwenden, so musst du als Parameter 2 wählen. In meinem Fall nutze ich ein 1,3" OLED Display im Querformat und muss dann nachfolgenden Befehl eingeben: OPTION LCDPANEL SSD1306I2C, L, 2

Ausgeben von "Hello World!" auf dem I2C-Display

Starten wir zunächst recht einfach und geben die Textzeile "Hello World!" auf dem Display aus.

Der Basic Befehl für die Ausgabe von Text lautet "Text" und hat die Parameter: - Position , - Ausrichtung, - Schriftgröße, - Schriftfarbe, - Hintergrundfarbe Wenn wir nun den Befehl Text mit dem nachfolgenden Parameter eingeben, dann wird ein Text "Hello World!" an der Position X=10, Y=0 im Querformat angezeigt (siehe Grafik oben). Text 10, 0, "Hello World!", "L", 1, 1, RGB(WHITE), RGB(BLACK) Mein OLED Display kann nur Schwarz & Weiß anzeigen, daher setzte ich in meinem Fall mit RGB lediglich White & Black. Solltest du ein Farbiges OLED Display verwenden, so kannst du hier auch andere Werte setzen.

Anzeigen von Datum & Uhrzeit auf dem I2C-Display mit BASIC am Raspberry Pi Pico

Wie du eine RTC an den Raspberry Pi Pico anschließt und mit PicoMite ausliest, habe ich dir bereits im Beitrag Raspberry Pi Pico BASIC #6 – RealTimeClock programmieren erläutert. In diesem Abschnitt möchte ich dir jetzt gerne zeigen, wie du diese Werte auf einem OLED Display anzeigen lassen kannst. Im nachfolgenden YouTube-Video erläutere ich dir Schritt-für-Schritt, wie du die Schaltung aufbaust und das kleine Programm in Basic mit PicoMite programmierst. https://youtu.be/Nb_moX3GCbM

Ausblick

In der offiziellen Dokumentation zu PicoMite unter https://geoffg.net/Downloads/picomite/PicoMite_User_Manual.pdf findest du viele Weitere GUI Elemente (Dialoge, Buttons, Diagramme, etc.) welche du auf deinem Display mit wenigen Zeilen programmieren kannst. Im nächsten Beitrag möchte ich daher ein kleines Dashboard erzeugen, um dort Sensorwerte zu visualisieren, sei also gespannt ... Read the full article

[draegerit]

ChatGPT - Sensordaten visualisieren

In diesem Beitrag möchte ich dir zeigen, wie du eine Python GUI von ChatGPT erzeugen lassen kannst, um Sensordaten zu visualisieren.

ChatGPT - Sensordaten visualisieren Im Beitrag Raspberry Pi Pico BASIC #6 – RealTimeClock programmieren habe ich dir eine kleine Schaltung am Raspberry Pi Pico gezeigt, wie du Sensordaten auf eine SD-Karte schreiben kannst. Die Daten werden dabei im CSV Format (getrennt durch ein Semikolon) gespeichert. In der ersten Spalte ist ein Zeitstempel und die zweite Spalte enthält den Sensorwert. 29-04-2023 18:10:26; 19.25 29-04-2023 18:10:27; 19.25 29-04-2023 18:10:28; 19.25 In einem neuen Chat Fenster von ChatGPT gebe ich nun die nachfolgende Anfrage an das System. Zusätzlich gebe ich noch die Sensordaten hinzu. Ich habe eine CSV Datei im Format: 29-04-2023 18:10:26; 19.25 29-04-2023 18:10:27; 19.25 29-04-2023 18:10:28; 19.25 29-04-2023 18:10:29; 19.25 Hier erkennt ChatGPT gleich korrekt, was ich plane und gibt mir ein kleines Pythonprogramm zum visualisieren dieser Daten. Was mir besonders gut gefällt ist, dass der Zeitstempel im korrekten Format erkannt wurde und dieser geparst wird. import csv from datetime import datetime import matplotlib.pyplot as plt timestamps = values = with open('beispiel.csv') as csvfile: reader = csv.reader(csvfile, delimiter=';') for row in reader: timestamp = datetime.strptime(row, '%d-%m-%Y %H:%M:%S') value = float(row) timestamps.append(timestamp) values.append(value) plt.plot(timestamps, values) plt.xlabel('Zeit') plt.ylabel('Werte') plt.show() Dieser Python Code erzeugt ein Liniendiagramm mit den Achsen Werte & Zeit.

generiertes Liniendiagramm von ChatGPT zum visualisieren von Sensordaten

Installieren der benötigten Bibliotheken

Damit das Programm ausgeführt werden kann, muss die Bibliothek matplotlib und das Modul pyplot installiert werden. Dazu führen wir den nachfolgenden Befehl auf der Konsole aus: pip install matplotlib Wenn du die Entwicklungsumgebung PyCharm verwendest, dann kannst du auch per Kontextmenü die fehlende Bibliothek installieren.

Die GUI bzw. das Fenster selber wird von der Bibliothek matplotlib bereitgestellt.

Kompletter Chatverlauf mit ChatGPT zum visualisieren von Sensordaten

Hier jetzt der gesamte Chatverlauf mit ChatGPT zu diesem Beitrag. ChatGPT_CSV_Daten_visualisierenHerunterladen Read the full article

[draegerit]

DUINO EDU #4 - Lichtsensor

In diesem Beitrag möchte ich dir zeigen, wie du einen analogen Lichtsensor via Grove Schnittstelle am Arduino mit der Entwicklungsumgebung DUINO EDU programmierst.

Die Entwicklungsumgebung DUINO EDU habe ich dir bereits im Beitrag Arduino Programmierung mit DUINO EDU vorgestellt und kleine Schaltungen mit Sensoren / Aktoren gezeigt. - DUINO EDU #1 – Grove LED, - DUINO EDU #2 – Grove Button Shield, - DUINO EDU – LED, Helligkeit per serieller Schnittstelle steuern Hier soll es nun darum gehen, wie du einen analogen Lichtsensor anschließt und den Sensorwert auswerten kannst.

analoger Lichtsensor mit Grove Schnittstelle

Rückseite des analogen Lichtsensors

Benötigte Ressourcen für den Nachbau der Schaltung

Wenn du die nachfolgende Schaltung nachbauen möchtest, dann benötigst du: - einen Arduino UNO, - ein USB-Datenkabel, - ein Base Shield v2, - ein Grove Lichtsensor, - eine Grove LED, - zwei Grove Kabel

Bauteile - Schaltung analoger Lichtsensor & LED am Arduino UNO Zusätzlich verwende ich noch Grove Wrapper, um die Platinen der Sensoren / Aktoren aneinander zu reihen. Das hat den Vorteil, dass diese nicht auf dem Schreibtisch wild herumfliegen.

Sensoren / Aktoren auf Grove Wrapper

Aufbau der Schaltung und programmieren in DUINO EDU

Im nachfolgenden YouTube-Video zeige ich dir, wie du den analogen Lichtsensor an den Arduino UNO anschließt und in der Entwicklungsumgebung DUINO EDU programmierst. https://youtu.be/vVIC2d_tG9Q

Aufbau der Schaltung

Der Lichtsensor ist ein analoger Baustein und muss daher an einen der freien analogen Pins A0 bis A3 angeschlossen werden. Den Wert vom Lichtsensor wollen wir dann auf eine LED visualisieren und somit muss diese an einen PWM Pin D3, D5, D6, D9, D10, D11 angeschlossen werden.

Aufbau der Schaltung - Arduino UNO mit analogem Lichtsensor & LED

Programmieren in DUINO EDU

Der analoge Lichtsensor gibt Werte zwischen 0 und 1023 zurück, je nachdem wie hell die Umgebung ist. Diesen Wert können wir nun auf ein PWM Signal mappen / zuweisen und somit die Helligkeit oder die Blinkfrequenz einer Leuchtdiode steuern. Aus der Helligkeit lässt sich jedoch kein Lux-Wert ableiten! Beispiel 1 - steuern der Helligkeit einer LED mit dem Lichtsensor Das PWM Signal für die Helligkeit der LED liegt zwischen 0 und 255, dieses hatte ich dir bereits im Beitrag DUINO EDU – LED, Helligkeit per serieller Schnittstelle steuern gezeigt.

Programm - Lichtsensor zum steuern der Helligkeit am Arduino Hier nun der kleine Code als ZIP-Datei. DUINO EDU - Lichtsensor & LED - steuern der HelligkeitHerunterladen Beispiel 2 - steuern der Blinkfrequenz einer LED Mit nur wenigen Handgriffen können wir das kleine Programm so umstellen, dass wir die LED abhängig von dem Umgebungslicht zum Blinken bringen.

Programm - Lichtsensor zum steuern der Blinkfrequenz am Arduino Auch hier bekommst du den Code als ZIP-Datei zum download. DUINO EDU – Lichtsensor & LED – steuern der BlinkfrequenzHerunterladen Read the full article

[draegerit]

Würth Elektronik - WSEN-TIDS Temperatur-Sensor

In diesem Beitrag möchte ich dir zeigen, wie du den Temperatur-Sensor WSEN-TIDS von Würth Elektronik am Arduino programmierst.

Würth Elektronik - WSEN-TIDS Temperatur-Sensor Im Beitrag Sensor Shield von Würth Elektronik habe ich dir bereits das Sensor Shield von der Firma Würth Elektronik vorgestellt. Dieses Shield verfügt über Anschlüsse für den hier vorgestellten Temperatur-Sensor vom Typ WSEN-TIDS, jedoch kannst du diesen Sensor auch ohne dieses Shield betreiben, dazu aber später mehr.

Bezug vom Temperatur-Sensor WSEN-TIDS

Diesen Sensor bekommst du zzt. exklusiv im Onlineshop von Würth Elektronik unter https://www.we-online.com/de/components/products/WSEN-TIDS dort findest du zusätzlich das Datenblatt. Lieferumfang Zum Lieferumfang des Sensors gehört neben dem Modul noch zwei 3polige Stiftleisten, welche an das Modul gelötet werden kann.

Technische Daten des Temperatur-Sensors

Hier die technischen Daten des Sensors: Betriebsspannung1.5 V bis 3.6 Vmaximale Stromaufnahme180 µAUmgebungstemperatur-40 °C bis +125 °CAnschlussI²CMessbereich-40 °C bis +125 °CToleranz±0.25 °C Auflösung16 BitsTechnische Daten vom Temperatur-Sensor WSEN-TIDS Dieses ist nur ein kleiner Auszug aus dem Datenblatt, welches du unter https://www.we-online.com/components/products/datasheet/2521020222501.pdf findest.

Anschluss an den Arduino mithilfe des Sensor Shields

Am einfachsten kann dieser Sensor an den Arduino UNO mithilfe des Sensor Shields angeschlossen werden. Dieses musst du separat erwerben und ist nicht im Lieferumfang enthalten.

Sensor Shield mit WSEN-TIDS am Arduino UNO Da der Temperatur-Sensor eine maximale Betriebsspannung von 3.6 V hat, musst du diesen an den I²C Anschluss mit 3.3 V verbinden.

Anschluss an den Arduino mithilfe von Breadboardkabel

Alternativ kannst du den Temperatur-Sensor auch mit Breadboardkabel direkt an den Mikrocontroller anschließen. Hierzu musst du zunächst die beiden 3poligen Stiftleisten anlöten.

Wenn du diese angelötet hast, dann kannst du bei anderen Sensoren auch mit Breadboardkabel (männlich-weiblich) diesen wie folgt anschließen: WSEN-TIDSArduino UNOSCLanaloger Pin A4SDAanaloger Pin A5INT-GNDGNDVDD3.3 VSA0-Anschluss des Temperatur-Sensors WSEN-TIDS an den Arduino UNO

Arduino UNO mit Temperatur-Sensor WSEN-TIDS von Würth Elektronik

Programmieren

Damit du diesen Sensor in der Arduino IDE programmieren kannst, benötigst du eine Bibliothek, diese findest du auf dem GitHub Repository von Würth Elektronik unter https://github.com/WurthElektronik/SensorLibrariesArduino/tree/master/libraries und Beispiele unter https://github.com/WurthElektronik/SensorLibrariesArduino/tree/master/WSEN_TIDS. Wie man eine ZIP-Bibliothek in der Arduino IDE installiert, habe ich dir bereits im Beitrag Arduino IDE, Einbinden einer Bibliothek ausführlich erläutert. Wenn diese nun installiert ist, können wir mit der Programmierung beginnen. Nachfolgend verwende ich das zur Bibliothek gelieferte Beispiel "continuous_mode.ino" in leicht gekürzter Version. // Bibliothek zum auslesen des Sensors WSEN-TIDS #include "WSEN_TIDS.h" // ein Objekt vom Typ Sensor_TIDS erzeugen Sensor_TIDS sensor; // die Ausgabedatenrate in Hz int ODR = 25; void setup() { // beginn der seriellen Kommunikation Serial.begin(9600); // initialisieren der Kommunikation mit dem // Temperatur-Sensor sensor.init(TIDS_ADDRESS_I2C_1); // ein Software Reset durchführen sensor.SW_RESET(); // auslesen der ID des Sensors und als HEX Wert umwandeln String sensorID = String(sensor.get_DeviceID(), HEX); // umwandeln in Großbuchstaben sensorID.toUpperCase(); // Ausgeben der Sensor-ID auf der seriellen Schnittstelle Serial.println("Sensor ID: " + sensorID); // aktivieren des fortlaufenden lesens des Sensorwertes // mit der Abtastrate von ODR sensor.set_continuous_mode(ODR); // eine kleine Pause von 2 Sekunden delay(2000); } void loop() { // lesen der Temperatur float temperature = sensor.read_temperature(); // Ausgeben der Temperatur auf der seriellen Schnittstelle Serial.print(temperature); Serial.println(" °C"); // eine kleine Pause von 250 Millisekunden delay(250); } Wenn wir den obigen Code auf den Mikrocontroller überspielen, dann wird zunächst die Sensor-ID ausgeben und danach fortlaufend die Temperatur in Grad Celsius. Sensor ID: A0 21.52 °C 21.60 °C 21.57 °C 21.55 °C 21.53 °C 21.65 °C 21.55 °C 21.52 °C 21.54 °C 21.58 °C Read the full article

[draegerit]

Shelly 1 #5 - Shelly 1 PM mit DHT22 Sensor

In diesem Beitrag möchte ich dir zeigen, wie du den Shelly 1 PM mit Temperatur Add-on um einen DHT22 Sensor erweitern kannst.

Shelly 1 #5 - Shelly 1 PM mit DHT22 Sensor Den Shelly 1 PM habe ich dir bereits im Beitrag Shelly 1 #4 - Shelly 1 PM vorgestellt. Dieses smarte Gerät verfügt über ein Relais, welches sich per App oder auch per Sprachassistenten wie Amazon Alexa oder Google Home steuern lässt. Des Weiteren kann der Shelly 1 PM noch die Leistungsaufnahme eines angeschlossenen Verbrauchers messen.

Hier soll es nun darum gehen, wie du ein Temperatur Add-on inkl. DHT22 Sensor an diesen anschließt und somit die Temperatur & relative Luftfeuchtigkeit messen kannst.

Bezug der Bauteile für dieses kleine Projekt

Die Bauteile für dieses Projekt habe ich günstig von berrybase.de erworben. (Den Shelly 1 PM, hatte ich noch auf Lager.) - Temperatur Add-on für Shelly 1 / PM - 10,90 € - DHT22 Sensor - 7,70 € Du findest diese Bauteile jedoch auch auf anderen Plattformen wie amazon.de, ebay.de usw. jedoch hatte zur Erstellung des Beitrages der genannte Shop den besten Preis inkl. Versandkosten.

DHT22 Sensor für Temperatur & rel. Luftfeuchtigkeit

Den DHT22 Sensor habe ich bereits in einigen Arduino und ESP Projekten vorgestellt und behandelt. Hier zunächst die technischen Daten des Sensors: - Betriebsspannung: 3 - 5V DC - Stromaufnahme: ~ 2,5 mA - Messbereich - rel. Luftfeuchtigkeit: 0 - 100 % - Temperatur: -40 - 80 °C - Toleranz - rel. Luftfeuchtigkeit: ± 2 - 5 % - Temperatur: ± 0,5 °C

DHT22 / AM2302 Sensor

Rückseite des DHT22 / AM2302 Sensors Der mir vorliegende Sensor hat eine knapp 25 cm lange, 3 adrige, farbige Zuleitung. Wobei die Farben wie folgt belegt sind: - Schwarz - Minus - Rot - 5V - Gelb - Data

Anschließen des Temperatur Add-ons an den Shelly 1 PM

Das Temperatur Add-on wird auf den Shelly 1 gesteckt und mit einer kleinen Nase hinter das Gehäuse bei den Schraubklemmen geklickt. Somit muss deine Schaltung bereits fertig sein, wenn du diesen auf deinen Shelly stecken möchtest. https://youtu.be/Vx9gW2xb4OQ Austauschen der Klemmen gegen Lüsterklemmen In meinem Fall musste ich die beigelegten Klemmen gegen Lüsterklemmen tauschen, denn diese haben die dünnen Leitungen vom Temperatur Add-on nicht sicher gehalten.

Einrichten im Webfrontend

Wenn das Temperatur Add-on mit dem DHT22 Sensor am Shelly 1 PM verbunden wurde, dann wird dieses automatisch erkannt und die Daten im Webfrontend bzw. in der Shelly App angezeigt.

Zusätzlich werden ein paar neue Menüpunkte sichtbar, um Aktionen für diese Sensorwerte festzulegen.

Read the full article

[draegerit]

Funduino-Cube programmieren #2: DHT11 Sensor & OLED-Display

In diesem Beitrag möchte ich dir zeigen, wie du die Sensordaten vom DHT11 Sensor am OLED-Display auf dem Funduino-Cube programmierst.

Funduino-Cube programmieren #2: DHT11 Sensor & OLED-Display Wie du den DHT11 Sensor am Arduino programmierst und die Sensordaten auf einem Display anzeigst, habe ich dir bereits in Beiträgen auf meinem Blog gezeigt. Im ersten Beitrag Funduino-Cube programmieren #1: LEDs habe ich dir bereits gezeigt, wie du die LEDs programmieren kannst. Hier soll es speziell um den Funduino-Cube gehen, welcher ein vordefiniertes Pinout hat.

Anschluss des Sensors & des OLED-Displays

Der Sensor und das Display sind wie nachfolgend aufgelistet am Arduino Nano V3 angeschlossen. BauteilArduino Nano V3DHT11GNDGNDVCC5VDATAdigitaler Pin D12OLED-DisplayGNDGNDVCC5VSCLanaloger Pin A5SDAanaloger Pin A4 Das OLED Display wird auf den Funduino-Cube in meinem Fall auf eine 4-polige Buchsenleiste gesteckt. Des Weiteren habe ich für die Einstellung der Spannungsversorgung Jumper gewählt, somit kann ich das Display einfach austauschen und muss nur den Jumper umstecken.

Anschluss des OLED Displays auf dem Funduino-Cube

Programmieren des DHT11 Sensors & OLED Display

Für die Programmierung des Sensors & des OLED Displays benötigst du noch zusätzlich jeweils eine Bibliothek. Diese Bibliothek kannst du über den Bibliotheksverwalter der Arduino IDE 2.0 (und auch über die Classic-Variante 1.8) installieren.

Benötigte Bibliotheken Den Bibliotheksverwalter findest du in der Arduino IDE 2.0 auf der linken Seite (1), in diesem suchen wir zunächst nach "DHT11" (2) und wählen in dem Eintrag "DHTNEW by Rob Tillaart" die Schaltfläche "INSTALL" (3). Für das OLED-Display benötigen wir die Bibliothek für den verbauten Chip "SSD1306" diesen suchen wir ebenfalls (4) und wählen hier die Adafruit SSD1306 by Adafruit Bibliothek.

Zum OLED-Display müssen wir zusätzlich noch zwei weitere Bibliotheken installieren. Diese benötigen wir, um das Display anzusteuern und somit wählen wir hier die Schaltfläche "INSTALL ALL".

Programmieren in der Arduino IDE 2.0 Nachdem wir die beiden Bibliotheken installiert haben, können wir mit der Programmierung beginnen. //Bibliothek zum ansteuern / auslesen //des DHT11 Sensors #include //Bibliotheken zum ansteuern //des OLED Displays #include #include #include #include //Auslösung des OLED Displays #define SCREEN_WIDTH 128 #define SCREEN_HEIGHT 32 //Reset Pin #define OLED_RESET -1 //I2C Adresse des Displays #define SCREEN_ADDRESS 0x3C //ein Objekt mit den zuvor definierten Werten initialisieren Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); //der DHT11 Sensor ist am digitalen Pin D12 angeschlossen #define dht11SensorPin 12 //eine Instanz des Objektes DHTNEW initialisieren DHTNEW dhtSensor(dht11SensorPin); //die Pause zwischen dem anzeigen der Werte auf dem Display const int PAUSE = 1000; void setup() { //begin der seriellen Kommunikation mit 9600 baud Serial.begin(9600); //begin der Kommunikation mit dem OLED Display display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS); display.display(); } //Eine Funktion welche uns auf dem Display die Messwerte anzeigt. void displayMessurement(String text, String sign, float value, int decimalplaces) { //Display leeren display.clearDisplay(); //Schriftgröße auf 1 setzen display.setTextSize(1); //Schriftfarbe auf weiß setzen display.setTextColor(SSD1306_WHITE); //setzen des Cursors auf die Spalte 10 und die Zeile 0 display.setCursor(10, 0); //schreiben des Textes an die Position vom Cursor display.println(text); //Schriftgröße auf 2 setzen display.setTextSize(2); //setzen des Cursors auf die Spalte 30 und die Zeile 15 display.setCursor(30, 15); //schreiben des Textes an die Position vom Cursor display.println(String(value, decimalplaces) + sign); //schreiben des Puffers aus dem Speicher auf das Display display.display(); } void loop() { //lesen der Sensorwerte dhtSensor.read(); //lesen des Sensorwertes für die rel. Luftfeuchtigkeit float humidity = dhtSensor.getHumidity(); //lesen des Sensorwertes für die Temperatur float temperature = dhtSensor.getTemperature(); //Ausgeben der Werte auf der seriellen Schnittstelle Serial.print("rel. Luftfeuchtigkeit: "); Serial.print(String(humidity, 2)); Serial.println(" %"); Serial.print("Temperatur: "); Serial.print(String(temperature, 2)); Serial.println(" °C"); Serial.println("------------------------------"); //Schreiben der Sensorwerte auf dem Display displayMessurement("Luftfeuchtigkeit", " %", humidity, 2); //Pause zwischen den beiden Werten delay(PAUSE); displayMessurement("Temperatur", " C", temperature, 2); //Pause delay(PAUSE); } Die Programmierung und das Schreiben der Messwerte auf das OLED-Display war nicht besonders spannend oder eine Herausforderung, denn zu beiden Bibliotheken liegen jeweils Beispiele bei, aus welchen man sich einfach Codefragmente entnehmen kann. Read the full article

[draegerit]

Sensor Shield von Würth Elektronik

In diesem Beitrag möchte ich dir das Sensor Shield für den Arduino UNO von der Forma Würth Elektronik vorstellen.

Sensor Shield von Würth Elektronik Dieses Shield sowie die Sensoren habe ich von der Firma Würth Elektronik kostenfrei für diesen und weitere Beiträge gestellt bekommen. Auf diesem Blog habe ich dir bereits mehrere Sensoren vorgestellt, welchen aber allen gemein ist, dass diese aus dem asiatischen Raum stammen und zum Basteln und ausprobieren völlig ausreichend sind. Möchte man jedoch auf die gemessenen Werte vertrauen und andere Geräte steuern / regeln, so benötigt man Sensoren, welche zuverlässig arbeiten.

Hier bietet die Firma Würth Elektronik ein Set von Sensoren für Temperatur, Luftdruck usw., aber dazu später mehr.

Bezug der Komponenten

Wenn du wie ich von der Qualität der Sensoren überzeugt bist und dir selber so ein Board erwerben möchtest, dann kannst du dieses über den offiziellen Shop https://www.we-online.com/ bestellen. Im Shop findest du keine Preise zu den hier gezeigten Bauteilen, aber unter der E-Mail-Adresse info@we-online.com oder über das Kontaktformular https://www.we-online.com/en/support/contact kannst du dir ein persönliches Angebot einholen.

Aufbau des Sensor Shields

Das Sensor Shield wird auf den Arduino UNO oder Arduino DUE gesteckt und damit mit den Pins des Mikrocontrollers verbunden. Zusätzlich werden aber die gesamten Pins noch mit Buchsenleisten nach oben zur Verfügung gestellt.

An den Ecken des Shields findest du jeweils Buchsen für die separat erhältlichen Sensoren, welche über I²C oder SPI angesteuert werden. Wie erwähnt wird das Sensor Shield auf den Arduino gesteckt, in meinem Fall nutze ich den originalen Arduino UNO. Wenn das Shield auf diesen gesteckt wird, erkennt man sofort, dass die Platine etwas größer ist als wie der Mikrocontroller.

Sehr gut finde ich, dass auf der Rückseite des Sensor Shields keine offenen Kontakte wie bei anderen Shields sind, hier ist die Platine flach und daher macht es nichts, wenn die Platine plan auf der USB Buchse des Mikrocontrollers liegt.

Sensor Shield auf dem Arduino UNO

Rückseite des Sensor Shields von Würth Elektronik Dieses ist, wie ich finde, ein gutes Merkmal von "Made in Germany" bzw. "Design in Germany". Jumper für Arduino UNO / DUE Auf dem Sensor Shield ist ein Jumper, mit welchem man steuert, welchen Mikrocontroller man verwenden möchte, da ich einen Arduino UNO verwende, muss ich diesen auf die Stellung "UNO 5V" umstecken.

Jumper für die Wahl des Mikrocontrollers Arduino UNO / DUE

Anschluss & programmieren eines Absolutdrucksensors am Sensor Shield

Neben dem Sensor Shield habe ich noch zusätzlich ein Absolutdrucksensor erhalten. Dieser wird einfach per I²C Schnittstelle angeschlossen und programmiert.

Absolutdrucksensor von Würth Elektronik Zu diesem Sensor gibt es ein offizielles Handbuch in englischer Sprache, welches sehr viele Informationen zu diesem enthält. Der Absolutdrucksensor wird an die Buchse mit 3.3V Versorgungsspannung eingesteckt. Achtung: Es gibt auch eine Buchse, welche 5 V liefert! Hier muss der Aufdruck auf der Platine des Sensor Shields beachtet werden! Auf meinem YouTube-Kanal habe ich dir dazu ein Video veröffentlicht, in welchem ich dir zeige, wie du das Board für einen Arduino UNO einrichtest und die Sensorwerte (Temperatur & Luftdruck) mit einem Beispiel auslesen kannst. https://youtu.be/F_gnd0ifaIQ Programmieren in der Arduino IDE Für die verfügbaren Sensoren findest du im GitHub Repository WurthElektronik/SensorLibrariesArduino jeweils Bibliotheken sowie Beispiele, dieses macht den Einstieg sehr einfach. In meinem Fall benötige ich die ZIP-Datei für den WSEN-PADS Sensor, welche über Sketch > Include Library > Add .ZIP Library... installiert wird.

Arduino IDE 2.0 - einbinden einer neuen ZIP-Bibliothek Im Beitrag Arduino IDE, Einbinden einer Bibliothek habe ich dir jedoch erklärt, wie du eine ZIP-Datei als Bibliothek in die Arduino IDE einbindest. Wenn wir diese Bibliothek installiert haben, besitzen wir nun zusätzlich noch drei Beispiele, welche wir wiederum unter File > Examples > WSEN_PADS.

Beispiele zum Absolutdrucksensor von Würth Elektronik Read the full article

[draegerit]

XIAO RP2040 - I2C Display & DHT22

In diesem neuen Beitrag zum Mikrocontroller XIAO RP2040 zeige ich dir, wie du die Sensordaten des DHT22 auf einem I2C Display anzeigen lassen kannst.

XIAO RP2040 - I2C Display & DHT22 Auf dem Mikrocontroller XIAO RP2040 ist, wie der Name er erahnen lässt, der Chip RP2040 von der Raspberry Foundation verbaut. Dieser Chip wurde wiederum auf die beiden offiziellen Mikrocontroller Raspberry Pi Pico & Pico W verbaut.

Mikrocontroller - XIAO RP2040 & Raspberry Pi Pico

Bezug

Den kleinen Mikrocontroller bekommst du derzeit (Stand 14.10.2022) für stolze 5,40 $ inkl. kostenlosem Versand im offiziellen Shop von Seeed Studio.

Den mir vorliegenden Mikrocontroller habe ich kostenfrei erhalten und im Gegenzug werde ich Beiträge zu diesem schreiben.

Beschreibung des kleinen Projektes

In diesem Beitrag möchte ich dir wie bereits erwähnt zeigen, wie du die Sensordaten eines DHT22 Sensors auf einem I2C Display anzeigen lassen. Für die Schaltung benötigen wir: - einen Mikrocontroller mit RP2040 Chip zbsp. den XIAO RP2040, - ein passendes Datenkabel, - ein 400 Pin Steckbrett, - ein paar Steckbrettkabel, - ein DHT22 Sensor, - ein 0,96" OLED Display (I2C) Den DHT22 Sensor bekommst du in zwei Bauformen, zum einen auf einer Platine und einmal als einzelnen Baustein. Auch kannst du statt einem DHT22 ein DHT11 Sensor verwenden, diese beiden Versionen unterscheiden sich von Preis und von der Genauigkeit der Sensorwerte.

Pinout des XIAO RP2040

Für den Aufbau benötigen wir das Pinout welches ich dir hier gerne aufzeigen möchte.

Pinout des Seeed Studio XIAO RP2040

Aufbau der Schaltung

Wie du ein Display am Raspberry Pi Pico via I2C programmierst, habe ich dir im Beitrag Raspberry PI Pico #6: OLED Display betreiben gezeigt. Hier möchte ich nun noch zusätzlich einen kleinen Sensor verwenden.

DHT22 Sensor Als Sensor verwende ich den DHT22 Sensor, dieser liefert die Temperatur & relative Luftfeuchtigkeit in einer sehr guten Genauigkeit. Alternativ kann man auch den etwas günstigeren, aber ungenaueren DHT11 verwenden.

Schaltung - XIAO RP2040 mit DHT22 Sensor & I2C OLED Display Die Bauteile (DHT22 Sensor / I2C OLED Display) werden wie nachfolgend gezeigt an den XIAO RP2040 angeschlossen: BauteilXIAO RP2040DHT22 SensorVDD5VDATAP26, D0 / 10 kOhm > 5VNCGNDGNDI2C OLED DisplayGNDGNDVCC5VSCLP7, SCLSDAP6, SDA

XIAO RP2040 mit DHT22 Sensor & I2C OLED Display

Programmieren in der Thonny IDE

Zum Programmieren nutze ich wieder die Thonny IDE welche ich dir bereits in diversen Beiträgen vorgestellt habe. Die Thonny IDE erhältst du kostenfrei für die Betriebssysteme macOS, Windows und Linux. Wie du die Thonny IDE unter Linux installierst, habe ich dir im Beitrag Thonny IDE auf Linux einrichten für den Raspberry Pi Pico W ausführlich erläutert. (Da der XIAO RP2040 den gleichen Chip verwendet, funktioniert die Anleitung auch für diesen Mikrocontroller.) # importieren der Module # zum steuern der GPIOs import machine # lesen des DHT Sensors import dht # steuern des Displays from ssd1306 import SSD1306_I2C # Funktionen um zbsp. eine kleine Pause einzulegen import time #erzeugen eines I2C Objektes #ACHTUNG: der XIAO RP2040 hat nur eine I2C Conneciton i2c1 i2c= machine.I2C(1,sda=machine.Pin(6), scl=machine.Pin(7), freq=400000) #definieren des Displays oled = SSD1306_I2C(128, 64, i2c) # erzeugen eines DHT22 Objektes # mit dem Pin 1 d = dht.DHT22(machine.Pin(1)) # Endlosschleife while True: # lesen der Daten d.measure() # lesen der Temperatur und formatieren # 3 Stellen vor und 2 Stellen nach dem Komma temperature = "{:3.2f}".format(d.temperature()) # lesen der rel. Luftfeuchtigkeit humidity = "{:3.2f}".format(d.humidity()) # ausgeben der Daten auf der seriellen Schnittstelle print("Temperatur: ", temperature , "°C") print("rel. Luftfeuchtigkeit: ", humidity, "%") # leeren des Displays oled.fill(0) # setzen des Textes "Temperatur" # an die Position Spalte = 0, Zeile 0 oled.text("Temperatur: ", 0, 0) # convertieren der gleitkommazahl in ein String # hinzufügen des Zeichens "C" (ohne Gradzeichen) # setzen an Position Spalte = 30, Zeile = 15 oled.text(str(temperature)+"C", 30, 15) # setzen des Textes "Luftfeuchtigkeit" # setzen an Position Spalte = 0, Zeile = 30 oled.text("Luftfeuchtigkeit: "+str(humidity), 0, 30) # convertieren der gleitkommazahl in ein String # hinzufügen des Zeichens "%" (ohne Gradzeichen) # setzen an Position Spalte = 30, Zeile = 45 oled.text(str(humidity)+"%", 30, 45) # schreiben des Buffers oled.show() # einlegen einer kleinen Pause von 1,5 Sekunden time.sleep(1.5) Wenn wir den obigen Code auf den Mikrocontroller aufspielen, dann sollte auf dem Display die Temperatur sowie die rel. Luftfeuchtigkeit angezeigt werden.

Read the full article