Arduino UNO Q - Capteur d'Alcool MQ3
Le capteur d'alcool MQ3 détecte la vapeur d'éthanol dans l'air. Il fournit à la fois une sortie numérique (alcool/pas d'alcool) et une sortie analogique (niveau de concentration d'alcool). Avec Bridge et Telegram, votre Arduino UNO Q peut envoyer des alertes instantanées de détection d'alcool sur votre téléphone et même servir d'éthylomètre.
Dans ce tutoriel, vous apprendrez :
- Comment fonctionne le capteur d'alcool MQ3 et pourquoi il a besoin d'un temps de chauffe
- Comment câbler le MQ3 au MCU Arduino UNO Q
- Comment lire les sorties numérique (DO) et analogique (AO)
- Comment construire un éthylomètre simple avec des niveaux de seuil sur Arduino UNO Q
- Comment utiliser Bridge pour exposer l'état et les événements d'alcool au côté Linux (Python)
- Comment recevoir des alertes de détection d'alcool Telegram depuis Arduino UNO Q
- Comment utiliser OpenClaw sur Arduino UNO Q avec le capteur d'alcool MQ3
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.
À Propos du Capteur d'Alcool MQ3
Le capteur d'alcool MQ3 est un capteur MOS (Semi-conducteur à Oxyde Métallique) qui détecte la vapeur d'éthanol (alcool). Son élément sensible interne en Dioxyde d'Étain (SnO2) change de résistance en présence de vapeur d'alcool — une concentration d'alcool plus élevée réduit la résistance, ce qui augmente la tension de sortie.
Brochage
- Broche VCC : Alimentation 5V (l'élément chauffant nécessite 5V)
- Broche GND : Masse
- Broche DO : Sortie numérique — HIGH = pas d'alcool, LOW = alcool détecté. Sensibilité ajustée par le potentiomètre intégré.
- Broche AO : Sortie analogique — valeur plus élevée = concentration d'alcool plus importante
Indicateurs LED
- LED-PWR : Indicateur d'alimentation
- LED-DO : S'allume lorsque de l'alcool est détecté (broche DO LOW)
Spécifications Techniques
- Tension de fonctionnement : 5V DC
- Résistance du chauffage : 33 Ω ± 5%
- Consommation du chauffage : < 800 mW
- Plage de détection : 25 – 500 ppm (parties par million)
Temps de Chauffe Requis
- Première utilisation ou après un long stockage (>1 mois) : Chauffage pendant 24 à 48 heures
- Utilisation normale : 5 à 10 minutes ; les premières mesures peuvent être élevées et se stabiliseront
Le code inclut un délai de chauffe de 20 secondes dans setup() comme délai de travail minimum.
※ Note:
La broche AO du MQ3 peut produire jusqu'à ~5V lorsqu'elle est alimentée en 5V. La référence ADC du MCU Arduino UNO Q est 3,3V — les valeurs AO supérieures à 3,3V seront saturées à 4095. Utilisez la broche DO comme méthode de détection principale. Les lectures AO servent uniquement d'indicateurs d'intensité relative.
Calibrage des Seuils d'Éthylomètre
Les seuils d'éthylomètre dépendent de votre capteur spécifique et de l'environnement. Pour calibrer :
- Ligne de base en air pur : Faites fonctionner le capteur en air pur et enregistrez la valeur AO (généralement 300 à 600 en gamme 12 bits après chauffe)
- Test avec vapeur d'alcool : Utilisez de l'alcool isopropylique ou du gel hydroalcoolique (vapeurs seulement — ne mettez pas de liquide sur le capteur) et notez la valeur AO
- Définissez les seuils : Définissez SOBER_THRESHOLD juste au-dessus de votre ligne de base en air pur ; définissez DRUNK_THRESHOLD sur la base des mesures en présence d'alcool
L'exemple de code utilise SOBER_THRESHOLD = 480 et DRUNK_THRESHOLD = 1600 — remplacez-les par vos valeurs calibrées.
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Broche Capteur d'Alcool MQ3 | MCU Arduino UNO Q |
|---|---|
| VCC | 5V |
| GND | GND |
| DO | D2 |
| AO | A0 |
Comment Programmer le Capteur d'Alcool MQ3
- Configurez la broche DO comme entrée numérique :
pinMode(DO_PIN, INPUT);
- Lisez les deux sorties :
int do_state = digitalRead(DO_PIN); // HIGH = no alcohol, LOW = detected
int ao_value = analogRead(AO_PIN); // 0-4095, higher = more alcohol
- Vérifiez la présence d'alcool depuis la sortie numérique :
if (do_state == LOW) {
Serial.print("Alcohol DETECTED! Intensity (AO): ");
Serial.println(ao_value);
}
Code Arduino UNO Q
L'Arduino UNO Q dispose de deux processeurs fonctionnant ensemble :
- Le STM32 MCU chauffe le capteur pendant 20 secondes, puis lit DO et AO toutes les 500 ms
- Le Qualcomm MPU exécute Debian Linux avec Wi-Fi — dans cette section, seul le MCU est programmé. Une section ultérieure montre comment les deux processeurs fonctionnent ensemble via 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-mq3-alcohol-sensor
*/
// MQ3 Alcohol Sensor:
// DO pin: HIGH = no alcohol, LOW = alcohol detected
// AO pin: analog — higher value = more alcohol (12-bit ADC: 0-4095)
// VCC = 5V (heating element requires 5V)
// The MCU ADC reference is 3.3V. AO readings above 3.3V saturate at 4095.
// Use the DO pin as the primary alcohol detection method.
#define DO_PIN 2 // The Arduino UNO Q MCU pin connected to DO of the MQ3 sensor
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the MQ3 sensor
void setup() {
Serial.begin(9600);
pinMode(DO_PIN, INPUT);
Serial.println("Warming up the MQ3 alcohol sensor...");
delay(20000); // allow sensor to warm up
Serial.println("Arduino UNO Q MQ3 Alcohol Sensor ready");
}
void loop() {
int do_state = digitalRead(DO_PIN); // HIGH = no alcohol, LOW = detected
int ao_value = analogRead(AO_PIN); // 0-4095, higher = more alcohol
if (do_state == LOW) {
Serial.print("Alcohol DETECTED! Intensity (AO): ");
Serial.println(ao_value);
} else {
Serial.print("No alcohol. AO value: ");
Serial.println(ao_value);
}
delay(500);
}
Étapes Rapides
Première utilisation d'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q avant de continuer.
- Connectez : Câblez le capteur d'alcool MQ3 à l'Arduino UNO Q MCU comme indiqué dans le schéma de câblage.
- Ouvrez Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créez une nouvelle App : Cliquez sur le bouton Create New App.
- Donnez un nom à l'App, par exemple : AlcoholSensor
- Cliquez sur Create pour confirmer.
- Collez le sketch : Copiez le code MCU ci-dessus et collez-le dans sketch/sketch.ino.
- Téléversez : Cliquez sur le bouton Run dans Arduino App Lab.
- Attendez le message de chauffe de 20 secondes dans le Moniteur Série.
- Tenez délicatement des vapeurs d'alcool isopropylique près du capteur (ne renversez pas de liquide dessus) et observez la sortie du Moniteur Série.
- Ajustez le potentiomètre si la LED DO ne répond pas comme prévu.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Warming up the MQ3 alcohol sensor...
[2026-04-29 09:00:21] Arduino UNO Q MQ3 Alcohol Sensor ready
[2026-04-29 09:00:22] No alcohol. AO value: 385
[2026-04-29 09:00:23] No alcohol. AO value: 382
[2026-04-29 09:00:24] Alcohol DETECTED! Intensity (AO): 1564
[2026-04-29 09:00:25] Alcohol DETECTED! Intensity (AO): 2418
[2026-04-29 09:00:26] No alcohol. AO value: 390
Code Arduino UNO Q — Éthylomètre
Utilisez la sortie analogique (AO) pour mesurer l'intensité de l'alcool et classer le résultat en niveaux : Sobre, Dans les limites ou Élevé.
※ Note:
Calibrez les seuils pour votre capteur spécifique. Remplacez SOBER_THRESHOLD et DRUNK_THRESHOLD par les valeurs mesurées avec votre propre capteur en air pur et lors d'une exposition à l'alcool.
/*
* 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-mq3-alcohol-sensor
*/
// Breathalyzer mode using AO pin
// Thresholds are approximate for 12-bit ADC (0-4095) — calibrate for your sensor!
// Run the sensor in clean air to find the baseline AO value, then blow near the sensor
// after drinking to find an appropriate DRINKING_THRESHOLD.
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the MQ3 sensor
// REPLACE THESE with your calibrated values!
#define SOBER_THRESHOLD 480 // Below this = sober (≈ 120 × 4 for 12-bit)
#define DRUNK_THRESHOLD 1600 // Above this = over limit (≈ 400 × 4 for 12-bit)
void setup() {
Serial.begin(9600);
Serial.println("MQ3 Alcohol Sensor - Breathalyzer Mode");
Serial.println("Warming up sensor...");
delay(20000);
Serial.println("Sensor ready! Blow near the sensor to measure.");
}
void loop() {
int ao_value = analogRead(AO_PIN);
Serial.print("AO value: ");
Serial.print(ao_value);
Serial.print(" | Status: ");
if (ao_value < SOBER_THRESHOLD) {
Serial.println("Sober");
} else if (ao_value < DRUNK_THRESHOLD) {
Serial.println("Alcohol detected — within limits");
} else {
Serial.println("HIGH alcohol level detected!");
}
delay(1000);
}
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:05:21] MQ3 Alcohol Sensor - Breathalyzer Mode
[2026-04-29 09:05:21] Warming up sensor...
[2026-04-29 09:05:41] Sensor ready! Blow near the sensor to measure.
[2026-04-29 09:05:42] AO value: 382 | Status: Sober
[2026-04-29 09:05:43] AO value: 385 | Status: Sober
[2026-04-29 09:05:44] AO value: 1321 | Status: Alcohol detected — within limits
[2026-04-29 09:05:45] AO value: 2865 | Status: HIGH alcohol level detected!
[2026-04-29 09:05:46] AO value: 480 | Status: Sober
Bridge : Linux + MCU
Cette section montre comment programmer les deux processeurs de l'Arduino UNO Q pour que le côté Linux puisse lire l'état de l'alcool, la valeur d'intensité et le niveau d'éthylomètre via Bridge :
- Le capteur d'alcool est connecté au MCU — le MCU chauffe pendant 20 secondes, puis lit DO et AO toutes les 500 ms
- Le MPU ne peut pas lire les broches du capteur directement — il appelle des fonctions Bridge pour obtenir l'état, la valeur, le niveau ou les événements
- Le MPU dispose du Wi-Fi — exécutant Debian Linux complet, il peut envoyer des alertes Telegram instantanées lorsque de l'alcool est détecté
- Arduino_RouterBridge permet la communication RPC entre les deux processeurs
- ⚠️ /dev/ttyHS1 (Linux) et Serial1 (MCU) sont RÉSERVÉS par le router — ne les ouvrez jamais dans le code utilisateur
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-mq3-alcohol-sensor
*/
#include "Arduino_RouterBridge.h"
#define DO_PIN 2 // The Arduino UNO Q MCU pin connected to DO of the MQ3 sensor
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the MQ3 sensor
// Breathalyzer thresholds (12-bit ADC) — calibrate for your sensor!
#define SOBER_THRESHOLD 480
#define DRUNK_THRESHOLD 1600
bool cached_alcohol = false;
int cached_ao = 0;
bool alcohol_event = false;
bool prev_alcohol = false;
unsigned long last_read_ms = 0;
const unsigned long READ_INTERVAL = 500;
String get_state(String arg) {
return cached_alcohol ? "alcohol" : "no_alcohol";
}
String get_value(String arg) {
return String(cached_ao);
}
String get_level(String arg) {
if (cached_ao < SOBER_THRESHOLD) return "sober";
if (cached_ao < DRUNK_THRESHOLD) return "within_limits";
return "high";
}
String get_event(String arg) {
if (alcohol_event) {
alcohol_event = false;
return "alcohol_detected";
}
return "none";
}
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(DO_PIN, INPUT);
Monitor.println("Warming up the MQ3 alcohol sensor...");
delay(20000);
Bridge.provide("get_state", get_state);
Bridge.provide("get_value", get_value);
Bridge.provide("get_level", get_level);
Bridge.provide("get_event", get_event);
Monitor.println("Arduino UNO Q MQ3 Alcohol Sensor Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= READ_INTERVAL) {
last_read_ms = now;
int do_state = digitalRead(DO_PIN); // LOW = alcohol detected
cached_ao = analogRead(AO_PIN);
cached_alcohol = (do_state == LOW);
if (cached_alcohol && !prev_alcohol) {
alcohol_event = true;
Monitor.print("ALCOHOL DETECTED! AO value: ");
Monitor.println(cached_ao);
} else if (!cached_alcohol && prev_alcohol) {
Monitor.println("Alcohol cleared.");
}
prev_alcohol = cached_alcohol;
}
}
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-mq3-alcohol-sensor
*/
from arduino.app_utils import *
import time
def loop():
state = Bridge.call("get_state")
value = Bridge.call("get_value")
level = Bridge.call("get_level")
print(f"Alcohol state: {state} AO value: {value} Level: {level}")
time.sleep(0.5)
App.run(user_loop=loop)
Étapes Rapides
- Connectez : Câblez le capteur d'alcool MQ3 à l'Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrez Arduino App Lab et créez une nouvelle App nommée AlcoholSensorBridge.
- Collez le sketch MCU dans sketch/sketch.ino.
- Collez le code Python dans le fichier Python.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino 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éversez : Cliquez sur le bouton Run. Attendez la fin de la période de chauffe.
- Exposez le capteur à des vapeurs d'alcool et observez l'événement apparaître dans les deux consoles.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Warming up the MQ3 alcohol sensor...
[2026-04-29 09:00:21] Arduino UNO Q MQ3 Alcohol Sensor Bridge ready
[2026-04-29 09:00:26] ALCOHOL DETECTED! AO value: 1564
[2026-04-29 09:00:30] Alcohol cleared.
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:22] Alcohol state: no_alcohol AO value: 385 Level: sober
[2026-04-29 09:00:23] Alcohol state: no_alcohol AO value: 382 Level: sober
[2026-04-29 09:00:26] Alcohol state: alcohol AO value: 1564 Level: within_limits
[2026-04-29 09:00:28] Alcohol state: alcohol AO value: 2418 Level: high
[2026-04-29 09:00:30] Alcohol state: no_alcohol AO value: 390 Level: sober
Telegram
Recevez des alertes instantanées de détection d'alcool Telegram depuis l'Arduino UNO Q, et interrogez l'état, l'intensité ou le niveau d'éthylomètre du capteur à distance.
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-mq3-alcohol-sensor
*/
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
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():
# Auto-alert on alcohol detection
event = Bridge.call("get_event")
if event == "alcohol_detected":
value = Bridge.call("get_value")
level = Bridge.call("get_level")
print(f"ALCOHOL DETECTED! AO value: {value} Level: {level}")
send_message(CHAT_ID, f"🍺 ALCOHOL DETECTED! AO intensity: {value}, Level: {level}")
# 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 Alcohol Sensor Bot\n"
"/state - Alcohol state (alcohol / no_alcohol)\n"
"/value - AO intensity value (0-4095)\n"
"/level - Breathalyzer level (sober / within_limits / high)\n"
"Automatic alert when alcohol is detected!")
elif text == "/state":
result = Bridge.call("get_state")
send_message(chat_id, f"Alcohol state: {result}")
elif text == "/value":
result = Bridge.call("get_value")
send_message(chat_id, f"AO intensity value: {result}")
elif text == "/level":
result = Bridge.call("get_level")
send_message(chat_id, f"Breathalyzer level: {result}")
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(0.3)
App.run(user_loop=loop)
Étapes Rapides
- Remplacez YOUR_TELEGRAM_BOT_TOKEN par votre token de bot réel obtenu depuis BotFather.
- Remplacez YOUR_CHAT_ID par votre identifiant de chat Telegram.
- Collez ce code Python dans le fichier Python de votre App (conservez le même sketch MCU).
- Cliquez sur le bouton Run — attendez la chauffe, puis exposez le capteur à des vapeurs d'alcool pour déclencher l'alerte Telegram.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:21] Waiting for Telegram messages...
[2026-04-29 09:10:26] ALCOHOL DETECTED! AO value: 1564 Level: within_limits
[2026-04-29 09:10:32] Received: /state
[2026-04-29 09:10:35] Received: /value
[2026-04-29 09:10:38] Received: /level
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 construire de nombreux projets utiles avec le capteur d'alcool MQ3 et Arduino UNO Q :
- Éthylomètre intelligent avec rapport Telegram : Soufflez près du capteur et recevez automatiquement un message Telegram avec votre niveau d'éthylomètre (sobre / dans les limites / élevé) et la valeur d'intensité AO brute — utile pour une démonstration ou un projet éducatif
- Verrouillage d'allumage de voiture : Combinez le capteur d'alcool avec un module relais — si le capteur détecte de l'alcool au-dessus de DRUNK_THRESHOLD, le relais empêche le circuit d'allumage de se fermer, et une alerte Telegram est envoyée au téléphone d'un tuteur
- Moniteur de sécurité de fête : Installez le capteur dans une pièce — quand de l'alcool est détecté au-dessus d'un niveau défini pendant plus de 5 mesures consécutives, le MPU envoie une notification Telegram pour surveiller l'environnement
- Enregistreur d'exposition à l'alcool : Enregistrez la valeur AO et le niveau d'éthylomètre chaque minute dans un fichier CSV côté Linux — envoyez un résumé Telegram quotidien avec les pics de mesures et les horodatages
- Système de sécurité multi-capteurs : Combinez le capteur d'alcool avec le tutoriel capteur de gaz — si les deux détectent des niveaux dangereux simultanément, envoyez une alerte Telegram combinée avec les deux mesures
Défiez-vous
Prêt à aller plus loin avec le capteur d'alcool MQ3 sur Arduino UNO Q ? Essayez ces défis :
- Facile : Ajoutez une commande Telegram /history qui retourne les 5 derniers événements de détection d'alcool avec leurs valeurs AO et niveaux d'éthylomètre, stockés dans une liste Python.
- Moyen : Implémentez une période de refroidissement : après l'envoi d'une alerte alcohol_detected, attendez au moins 60 secondes avant d'envoyer une autre alerte — même si le capteur continue de détecter de l'alcool — pour éviter le spam Telegram.
- Avancé : Construisez un enregistreur automatique d'éthylomètre — à chaque événement de détection, Python sauvegarde une entrée horodatée (date, heure, valeur AO, niveau) dans un fichier JSON sur Linux, et une commande Telegram /report retourne les 10 dernières entrées formatées en journal lisible.