Arduino UNO Q - Capteur de Température - OLED
Vous souhaitez afficher la température en direct sur un écran OLED avec votre Arduino UNO Q et recevoir des alertes Telegram à distance ? Ce tutoriel combine le capteur DS18B20 avec un écran OLED SSD1306 128x64.
Dans ce tutoriel, vous apprendrez :
- Comment câbler le capteur DS18B20 et l'écran OLED au MCU de l'Arduino UNO Q
- Comment programmer le MCU (code Arduino C/C++) pour lire la température et l'afficher centré sur l'OLED
- Comment programmer côté Linux (Python) et côté MCU (C/C++) pour surveiller la température via Bridge
- Comment recevoir des alertes Telegram lorsque la température dépasse un seuil sur l'Arduino UNO Q
- Comment utiliser OpenClaw sur l'Arduino UNO Q avec le capteur de température et l'OLED
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
Note d'achat: De nombreux capteurs DS18B20 sur le marché sont de faible qualité. Nous recommandons vivement d'acheter le capteur de la marque DIYables en utilisant le lien ci-dessus. Nous l'avons testé et il a bien fonctionné.
Note d'achat: Si vous souhaitez un écran OLED plus grand, utilisez le Arduino UNO Q - Écran OLED SSD1309 (2,42 pouces).
À Propos du Capteur de Température et de l'OLED
Si vous êtes nouveau sur le capteur DS18B20 ou l'écran OLED SSD1306, consultez d'abord ces tutoriels :
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Nous recommandons d'acheter un capteur DS18B20 avec adaptateur de câblage. L'adaptateur a la résistance de pull-up intégrée.
Connexions DS18B20 :
| Broche DS18B20 | MCU Arduino UNO Q |
|---|---|
| GND | GND |
| VCC | 3,3V ou 5V |
| DATA | D4 |
Connexions OLED I2C :
| Broche OLED | MCU Arduino UNO Q |
|---|---|
| VCC | 3,3V ou 5V |
| GND | GND |
| SDA | A4 |
| SCL | A5 |
Code Arduino UNO Q
L'Arduino UNO Q possède deux processeurs fonctionnant ensemble :
- Le MCU STM32 lit le capteur DS18B20 et pilote directement l'écran OLED
- Le MPU Qualcomm exécute Debian Linux et gère le Wi-Fi, Python et la connectivité cloud
- Dans cette section, seul le MCU est programmé — le côté Linux reste inactif. Une section ultérieure montre comment les deux processeurs fonctionnent ensemble via Bridge.
Le MCU lit la température chaque seconde et l'affiche centrée sur l'OLED.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
}
※ Note:
Le code centre automatiquement le texte de température horizontalement et verticalement sur l'écran OLED. Le symbole degré est affiché en utilisant char(247).
Étapes Rapides
Première utilisation d'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q avant de continuer.
- Connecter : Câblez le capteur DS18B20 et l'écran OLED au MCU de l'Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créer une nouvelle application : Cliquez sur le bouton Créer une nouvelle application.
- Donnez un nom à l'application, par exemple : TemperatureSensorOled
- Cliquez sur Créer pour confirmer.
- Coller le sketch : Copiez le code MCU ci-dessus et collez-le dans sketch/sketch.ino. Laissez les autres fichiers par défaut.
- 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
- Téléverser : Cliquez sur le bouton Exécuter dans Arduino App Lab.
- Tenez le capteur dans votre main ou plongez-le dans de l'eau chaude/froide — regardez la température se mettre à jour sur l'OLED.
Sortie de la Console App Lab
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
Cette section montre comment programmer les deux processeurs de l'Arduino UNO Q pour que le côté Linux puisse surveiller la température via Bridge tandis que l'OLED continue de se mettre à jour automatiquement :
- Le capteur DS18B20 et l'OLED sont tous deux connectés au MCU (STM32) — le MCU lit la température chaque seconde et met à jour l'OLED automatiquement
- Le MPU ne peut pas accéder directement au capteur ou à l'OLED — il doit appeler les fonctions Bridge pour récupérer les relevés ou effacer l'affichage
- Le MPU dispose du Wi-Fi — exécutant Debian Linux complet, il peut enregistrer les lectures, publier sur des tableaux de bord ou envoyer des alertes via Internet
- Arduino_RouterBridge permet la communication RPC entre les deux processeurs
- ⚠️ /dev/ttyHS1 (Linux) et Serial1 (MCU) sont RÉSERVÉS par le routeur — ne les ouvrez jamais dans le code utilisateur
En résumé : Le MCU lit le capteur chaque seconde et met à jour l'OLED → le MPU lit la température via Bridge → le MPU publie, enregistre ou alerte via Wi-Fi.
Code MCU (Bridge)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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");
}
}
Code Python (Bridge)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
Étapes Rapides
- Connecter : Câblez le capteur DS18B20 et l'OLED à l'Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez que la carte soit détectée.
- Créer une nouvelle application : Cliquez sur Créer une nouvelle application, nommez-la TemperatureSensorOledBridge, puis cliquez sur Créer.
- Coller le sketch MCU : Copiez le code MCU Bridge ci-dessus et collez-le dans sketch/sketch.ino.
- Coller le code Python : Copiez le code Python Bridge ci-dessus et collez-le dans le fichier Python de l'application.
- Téléverser : Cliquez sur le bouton Exécuter dans Arduino App Lab.
- Regardez les lectures de température apparaître dans la console Python tandis que l'OLED se met à jour automatiquement.
Sortie de la Console App Lab
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
Surveillez la température à distance et recevez des alertes Telegram automatiques lorsque la température dépasse 35°C.
Sketch MCU : Conservez le même sketch MCU de la section Bridge précédente.
Code Python (Telegram)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
Étapes Rapides
- Remplacez YOUR_TELEGRAM_BOT_TOKEN par votre vrai token de bot de BotFather.
- Remplacez YOUR_CHAT_ID par votre identifiant de chat Telegram.
- Collez ce code Python dans le fichier Python de votre application (conservez le même sketch MCU).
- Cliquez sur le bouton Exécuter. Envoyez /temp depuis Telegram ou tenez le capteur pour déclencher l'alerte de haute température.
Sortie de la Console App Lab
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
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées de Projets
Vous pouvez réaliser de nombreux projets utiles combinant le capteur de température et l'OLED avec l'Arduino UNO Q :
- Thermomètre Numérique Portable : Un thermomètre alimenté par batterie qui affiche la température sur l'OLED en grand texte lisible — l'OLED s'éteint après 30 secondes sans changement pour économiser l'énergie
- Moniteur de Salle Serveur : Montez le capteur dans un rack serveur et affichez la température en temps réel sur l'OLED ; le MPU envoie des alertes Telegram en cas de défaillance du refroidissement
- Bandeau LED Contrôlé par Température : Le MCU lit la température et ajuste la couleur d'un bandeau LED selon les plages (bleu = froid, vert = normal, rouge = chaud) tandis que l'OLED affiche la lecture actuelle
- Tableau de Bord OLED Multi-Lignes : Affichez la température à la ligne 1, le min/max de la session à la ligne 2, et l'heure actuelle (depuis le MPU via Bridge) à la ligne 3 de l'OLED
- Enregistreur de Température Cloud : Le MPU Linux lit la température chaque minute via Bridge, stocke les données dans un fichier CSV et les télécharge vers Google Sheets ou un tableau de bord IoT quotidiennement
Défiez-Vous
Prêt à aller plus loin avec le capteur de température et l'OLED sur l'Arduino UNO Q ? Essayez ces défis :
- Facile : Modifiez le sketch MCU pour que l'OLED affiche à la fois Celsius et Fahrenheit sur des lignes séparées, en basculant l'affichage toutes les 3 secondes.
- Moyen : Ajoutez une fonction Bridge set_unit(String) qui accepte "C" ou "F" et définit l'unité affichée par l'OLED, sans modifier le code sous-jacent du capteur.
- Avancé : Construisez un tableau de bord de station météo : lisez la température du DS18B20 et l'humidité d'un capteur DHT11 (si connecté), affichez les deux sur l'OLED dans une mise en page formatée, et faites publier toutes les lectures par le MPU sur un broker MQTT toutes les 30 secondes.