Arduino UNO Q - Temperatursensor - OLED
Möchten Sie die Echtzeit-Temperatur auf einem OLED-Bildschirm mit Ihrem Arduino UNO Q anzeigen und Telegram-Benachrichtigungen remote erhalten? Dieses Tutorial kombiniert den DS18B20-Sensor mit einem 128x64 SSD1306-OLED-Display.
In diesem Tutorial lernen Sie:
- Wie man den DS18B20-Sensor und das OLED-Display mit dem Arduino UNO Q MCU verdrahtet
- Wie man den MCU programmiert (C/C++ Arduino-Code), um die Temperatur zu lesen und zentriert auf dem OLED anzuzeigen
- Wie man sowohl die Linux-Seite (Python) als auch die MCU-Seite (C/C++) programmiert, um die Temperatur über Bridge zu überwachen
- Wie man Telegram-Benachrichtigungen erhält, wenn die Temperatur einen Schwellenwert auf dem Arduino UNO Q überschreitet
- Wie man OpenClaw auf dem Arduino UNO Q mit dem Temperatursensor und OLED verwendet
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Kaufhinweis: Viele DS18B20-Sensoren auf dem Markt sind von geringer Qualität. Wir empfehlen dringend den Kauf des Sensors von der Marke DIYables über den obigen Link. Wir haben ihn getestet und er funktionierte gut.
Kaufhinweis: Wenn Sie ein größeres OLED-Display möchten, verwenden Sie das 2.42 inch OLED Display 128x64.
Über den Temperatursensor und das OLED
Wenn Sie neu beim DS18B20-Sensor oder beim SSD1306-OLED-Display sind, lesen Sie zuerst diese Tutorials:
Schaltplan
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Wir empfehlen, einen DS18B20-Sensor mit Verdrahtungsadapter zu kaufen. Der Adapter hat den Pull-up-Widerstand integriert.
DS18B20-Verbindungen:
| DS18B20 Pin | Arduino UNO Q MCU |
|---|---|
| GND | GND |
| VCC | 3.3V oder 5V |
| DATA | D4 |
OLED I2C-Verbindungen:
| OLED Pin | Arduino UNO Q MCU |
|---|---|
| VCC | 3.3V oder 5V |
| GND | GND |
| SDA | A4 |
| SCL | A5 |
Arduino UNO Q Code
Der Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten:
- Der STM32 MCU liest den DS18B20-Sensor und steuert das OLED-Display direkt
- Der Qualcomm MPU führt Debian Linux aus und verwaltet Wi-Fi, Python und Cloud-Konnektivität
- In diesem Abschnitt wird nur der MCU programmiert - die Linux-Seite bleibt untätig. Ein späterer Abschnitt zeigt, wie beide Prozessoren über Bridge zusammenarbeiten.
Der MCU liest die Temperatur jede Sekunde und zeigt sie zentriert auf dem OLED an.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-temperature-sensor-oled
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define OLED_WIDTH 128
#define OLED_HEIGHT 64
#define SENSOR_PIN 4 // Arduino UNO Q MCU pin connected to DS18B20 DATA pin
Adafruit_SSD1306 oled(OLED_WIDTH, OLED_HEIGHT, &Wire, -1);
OneWire oneWire(SENSOR_PIN);
DallasTemperature DS18B20(&oneWire);
void oled_display_center(String text) {
int16_t x1, y1;
uint16_t width, height;
oled.getTextBounds(text, 0, 0, &x1, &y1, &width, &height);
oled.clearDisplay();
oled.setCursor((OLED_WIDTH - width) / 2, (OLED_HEIGHT - height) / 2);
oled.println(text);
oled.display();
}
void setup() {
Serial.begin(115200);
delay(1500);
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println("SSD1306 allocation failed");
while (true);
}
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
DS18B20.begin();
Serial.println("Arduino UNO Q Temperature Sensor + OLED ready");
}
void loop() {
DS18B20.requestTemperatures();
float temperature_C = DS18B20.getTempCByIndex(0);
float temperature_F = temperature_C * 9.0 / 5.0 + 32.0;
String display_str = String(temperature_C, 1) + char(247) + "C";
oled_display_center(display_str);
Serial.print("Temperature: ");
Serial.print(temperature_C);
Serial.print("°C ~ ");
Serial.print(temperature_F);
Serial.println("°F");
delay(1000);
}
※ Notiz:
Der Code zentriert automatisch den Temperaturtext horizontal und vertikal auf dem OLED-Display. Das Gradsymbol wird mit char(247) angezeigt.
Schnelle Schritte
Erste Schritte mit Arduino UNO Q? Befolgen Sie das Tutorial Erste Schritte mit Arduino UNO Q, bevor Sie fortfahren.
- Verbinden: Verdrahten Sie den DS18B20-Sensor und das OLED-Display mit dem Arduino UNO Q MCU wie im Schaltplan gezeigt.
- Arduino App Lab öffnen: Starten Sie Arduino App Lab und warten Sie, bis es Ihren Arduino UNO Q erkennt.
- Eine neue App erstellen: Klicken Sie auf die Schaltfläche Create New App (Neue App erstellen).
- Geben Sie der App einen Namen, zum Beispiel: TemperatureSensorOled
- Klicken Sie auf Create (Erstellen), um zu bestätigen.
- Die Skizze einfügen: Kopieren Sie den MCU-Code oben und fügen Sie ihn in sketch/sketch.ino ein. Halten Sie andere Dateien als Standard.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Adafruit SSD1306 created by Adafruit and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Search for Adafruit GFX Library created by Adafruit and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Search for DallasTemperature created by Miles Burton
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Search for OneWire created by Jim Studt, Tom Pollard, Robin James, Glenn Trewitt, Jason Dangel, Guillermo Lovato, Paul Stoffregen, Scott Roberts, Bertrik Sikken, Mark Tillotson, Ken Butcher, Roger Clark, Love Nystrom and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Hochladen: Klicken Sie auf die Schaltfläche Run (Ausführen) in Arduino App Lab.
- Halten Sie den Sensor in Ihrer Hand oder legen Sie ihn in heißes/kaltes Wasser - beobachten Sie, wie die Temperatur auf dem OLED aktualisiert wird.
App Lab-Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q Temperature Sensor + OLED ready
[2026-04-29 09:00:02] Temperature: 26.31°C ~ 79.36°F
[2026-04-29 09:00:03] Temperature: 26.44°C ~ 79.59°F
[2026-04-29 09:00:04] Temperature: 27.06°C ~ 80.71°F
[2026-04-29 09:00:05] Temperature: 28.50°C ~ 83.30°F
Bridge: Linux + MCU
Dieser Abschnitt zeigt, wie man beide Prozessoren des Arduino UNO Q programmiert, damit die Linux-Seite die Temperatur über Bridge überwachen kann, während die OLED automatisch aktualisiert wird:
- Der DS18B20-Sensor und das OLED sind beide mit dem MCU (STM32) verbunden - der MCU liest jede Sekunde die Temperatur und aktualisiert das OLED automatisch
- Der MPU kann nicht direkt auf den Sensor oder das OLED zugreifen - er muss Bridge-Funktionen aufrufen, um Ablesungen abzurufen oder das Display zu löschen
- Der MPU hat Wi-Fi - er führt vollständiges Debian Linux aus und kann Ablesungen protokollieren, in Dashboards veröffentlichen oder Benachrichtigungen über das Internet senden
- Arduino_RouterBridge ermöglicht RPC-Kommunikation zwischen den beiden Prozessoren
- ⚠️ /dev/ttyHS1 (Linux) und Serial1 (MCU) sind RESERVIERT vom Router - öffnen Sie sie niemals in Benutzercode
Kurz gesagt: MCU liest Sensor jede Sekunde und aktualisiert OLED → MPU liest Temperatur über Bridge → MPU veröffentlicht, protokolliert oder benachrichtigt über Wi-Fi.
MCU-Code (Bridge)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-temperature-sensor-oled
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <OneWire.h>
#include <DallasTemperature.h>#include "Arduino_RouterBridge.h"
#define OLED_WIDTH 128
#define OLED_HEIGHT 64
#define SENSOR_PIN 4
Adafruit_SSD1306 oled(OLED_WIDTH, OLED_HEIGHT, &Wire, -1);
OneWire oneWire(SENSOR_PIN);
DallasTemperature DS18B20(&oneWire);
float last_temp_c = 0.0;
float last_temp_f = 0.0;
unsigned long last_read_ms = 0;
void oled_display_center(String text) {
int16_t x1, y1;
uint16_t width, height;
oled.getTextBounds(text, 0, 0, &x1, &y1, &width, &height);
oled.clearDisplay();
oled.setCursor((OLED_WIDTH - width) / 2, (OLED_HEIGHT - height) / 2);
oled.println(text);
oled.display();
}
String get_temp_c(String arg) {
return String(last_temp_c, 2);
}
String get_temp_f(String arg) {
return String(last_temp_f, 2);
}
String clear_oled(String arg) {
oled.clearDisplay();
oled.display();
Monitor.println("OLED cleared");
return "OK";
}
String get_status(String arg) {
return "Temp: " + String(last_temp_c, 2) + "°C / " + String(last_temp_f, 2) + "°F";
}
void setup() {
Bridge.begin();
Monitor.begin();
if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Monitor.println("SSD1306 allocation failed");
while (true);
}
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
DS18B20.begin();
DS18B20.requestTemperatures();
last_temp_c = DS18B20.getTempCByIndex(0);
last_temp_f = last_temp_c * 9.0 / 5.0 + 32.0;
oled_display_center(String(last_temp_c, 1) + char(247) + "C");
Bridge.provide("get_temp_c", get_temp_c);
Bridge.provide("get_temp_f", get_temp_f);
Bridge.provide_safe("clear_oled", clear_oled);
Bridge.provide("get_status", get_status);
Monitor.println("Arduino UNO Q Temperature Sensor + OLED Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= 1000) {
last_read_ms = now;
DS18B20.requestTemperatures();
last_temp_c = DS18B20.getTempCByIndex(0);
last_temp_f = last_temp_c * 9.0 / 5.0 + 32.0;
oled_display_center(String(last_temp_c, 1) + char(247) + "C");
Monitor.println("Temp: " + String(last_temp_c, 2) + "°C / " + String(last_temp_f, 2) + "°F");
}
}
Python-Code (Bridge)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-temperature-sensor-oled
*/
from arduino.app_utils import *
import time
def loop():
status = Bridge.call("get_status")
print(status)
time.sleep(1)
App.run(user_loop=loop)
Schnelle Schritte
- Verbinden: Verdrahten Sie den DS18B20-Sensor und das OLED mit dem Arduino UNO Q wie im Schaltplan gezeigt.
- Arduino App Lab öffnen: Starten Sie Arduino App Lab und warten Sie, bis die Platine erkannt wird.
- Eine neue App erstellen: Klicken Sie auf Create New App (Neue App erstellen), nennen Sie sie TemperatureSensorOledBridge, und klicken Sie auf Create (Erstellen).
- Die MCU-Skizze einfügen: Kopieren Sie den MCU-Bridge-Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Den Python-Code einfügen: Kopieren Sie den Python-Bridge-Code oben und fügen Sie ihn in die Python-Datei in der App ein.
- Hochladen: Klicken Sie auf die Schaltfläche Run (Ausführen) in Arduino App Lab.
- Beobachten Sie, wie Temperaturablesungen in der Python-Konsole erscheinen, während sich das OLED automatisch aktualisiert.
App Lab-Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q Temperature Sensor + OLED Bridge ready
[2026-04-29 09:00:02] Temp: 26.31°C / 79.36°F
[2026-04-29 09:00:03] Temp: 26.44°C / 79.59°F
[2026-04-29 09:00:04] Temp: 27.06°C / 80.71°F
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] Temp: 26.31°C / 79.36°F
[2026-04-29 09:00:03] Temp: 26.44°C / 79.59°F
[2026-04-29 09:00:04] Temp: 27.06°C / 80.71°F
[2026-04-29 09:00:05] Temp: 28.50°C / 83.30°F
Telegram
Überwachen Sie die Temperatur remote und erhalten Sie automatische Telegram-Benachrichtigungen, wenn die Temperatur über 35°C ansteigt.
MCU-Skizze: Halten Sie die gleiche MCU-Skizze aus dem vorherigen Bridge-Abschnitt.
Python-Code (Telegram)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-temperature-sensor-oled
*/
from arduino.app_utils import *
import requests
import time
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
CHAT_ID = "YOUR_CHAT_ID"
last_update_id = 0
ALERT_THRESHOLD_C = 35.0
alert_sent = False
def get_updates():
global last_update_id
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates"
params = {"offset": last_update_id + 1, "timeout": 5}
try:
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["ok"]:
return data["result"]
except Exception as e:
print(f"Error getting updates: {e}")
return []
def send_message(chat_id, text):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {"chat_id": chat_id, "text": text}
try:
requests.post(url, data=payload, timeout=10)
except Exception as e:
print(f"Error sending message: {e}")
def loop():
global alert_sent
# Auto-alert on high temperature
temp_c_str = Bridge.call("get_temp_c")
try:
temp_c = float(temp_c_str)
if temp_c > ALERT_THRESHOLD_C and not alert_sent:
alert_sent = True
temp_f = Bridge.call("get_temp_f")
msg = f"⚠️ High temperature alert: {temp_c_str}°C / {temp_f}°F"
print(msg)
send_message(CHAT_ID, msg)
elif temp_c <= ALERT_THRESHOLD_C:
alert_sent = False
except ValueError:
pass
# Handle Telegram commands
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
if "message" not in update:
continue
message = update["message"]
chat_id = message["chat"]["id"]
text = message.get("text", "").strip()
print(f"Received: {text}")
if text == "/start":
send_message(chat_id,
"Arduino UNO Q Temperature Sensor + OLED Bot\n"
"/temp - Read temperature (°C and °F)\n"
"/tempC - Read temperature in Celsius\n"
"/tempF - Read temperature in Fahrenheit\n"
"/clear - Clear the OLED display\n"
"/status - Get sensor status")
elif text == "/temp":
temp_c = Bridge.call("get_temp_c")
temp_f = Bridge.call("get_temp_f")
send_message(chat_id, f"Temperature: {temp_c}°C ~ {temp_f}°F")
elif text == "/tempC":
result = Bridge.call("get_temp_c")
send_message(chat_id, f"Temperature: {result}°C")
elif text == "/tempF":
result = Bridge.call("get_temp_f")
send_message(chat_id, f"Temperature: {result}°F")
elif text == "/clear":
result = Bridge.call("clear_oled")
send_message(chat_id, result)
elif text == "/status":
result = Bridge.call("get_status")
send_message(chat_id, result)
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(1)
App.run(user_loop=loop)
Schnelle Schritte
- Ersetzen Sie YOUR_TELEGRAM_BOT_TOKEN durch Ihren tatsächlichen Bot-Token von BotFather.
- Ersetzen Sie YOUR_CHAT_ID durch Ihre Telegram-Chat-ID.
- Fügen Sie diesen Python-Code in die Python-Datei Ihrer App ein (halten Sie die gleiche MCU-Skizze).
- Klicken Sie auf die Schaltfläche Run (Ausführen). Senden Sie /temp von Telegram oder halten Sie den Sensor, um die Hochtemperatur-Benachrichtigung auszulösen.
App Lab-Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:00] Waiting for Telegram messages...
[2026-04-29 09:10:15] ⚠️ High temperature alert: 36.25°C / 97.25°F
[2026-04-29 09:10:30] Received: /temp
[2026-04-29 09:10:45] Received: /clear
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw
You can adapt the OpenClaw to this tutorial by refering the instruction on Arduino Uno Q - OpenClaw Tutorial
Projektideen
Sie können viele nützliche Projekte erstellen, die den Temperatursensor und das OLED mit dem Arduino UNO Q kombinieren:
- Tragbares Digitalthermometer: Ein batteriebetriebenes Thermometer, das die Temperatur auf dem OLED in großem, lesbarem Text anzeigt - das OLED schaltet sich nach 30 Sekunden ohne Änderung aus, um Strom zu sparen
- Serverraum-Monitor: Montieren Sie den Sensor in einem Serverrack und zeigen Sie die Echtzeit-Temperatur auf dem OLED an; der MPU sendet Telegram-Benachrichtigungen, wenn die Kühlung ausfällt
- Temperaturgesteuerte LED-Leiste: Der MCU liest die Temperatur und passt die Farbe einer LED-Leiste basierend auf Bereichen an (blau = kalt, grün = normal, rot = heiß), während das OLED die aktuelle Ablesung anzeigt
- Multi-Line-OLED-Dashboard: Zeigen Sie die Temperatur auf Zeile 1, Min/Max für die Sitzung auf Zeile 2 und die aktuelle Zeit (vom MPU über Bridge) auf Zeile 3 des OLED an
- Cloud-Temperatur-Logger: Der Linux MPU liest jede Minute die Temperatur über Bridge, speichert Daten in einer CSV-Datei und lädt sie täglich in Google Sheets oder ein IoT-Dashboard hoch
Fordern Sie Sich selbst heraus
Bereit, noch weiter mit dem Temperatursensor und OLED auf dem Arduino UNO Q zu gehen? Versuchen Sie diese Herausforderungen:
- Einfach: Ändern Sie die MCU-Skizze so, dass das OLED Celsius und Fahrenheit auf separaten Zeilen anzeigt und die Anzeige alle 3 Sekunden wechselt.
- Mittel: Fügen Sie eine set_unit(String) Bridge-Funktion hinzu, die "C" oder "F" akzeptiert und einstellt, welche Einheit das OLED anzeigt, ohne den zugrunde liegenden Sensor-Code zu ändern.
- Fortgeschritten: Erstellen Sie ein Wetter-Stations-Dashboard: Lesen Sie die Temperatur vom DS18B20 und die Luftfeuchtigkeit vom DHT11-Sensor (falls verbunden), zeigen Sie beide auf dem OLED in einem formatierten Layout an, und lassen Sie den MPU alle 30 Sekunden alle Ablesungen an einen MQTT-Broker veröffentlichen.