Arduino UNO Q — De la découverte à la maîtrise des entrées/sorties
- 0 comments
📘 COURS MAGISTRAL SUR LA DOCUMENTATION ARDUINO Q
📑 SOMMAIRE GÉNÉRAL
PARTIE 1 — DÉCOUVERTE DE LA CARTE
Chapitre 1 → Qu'est-ce que l'Arduino UNO Q ?
Chapitre 2 → Les deux cerveaux de la carte
Chapitre 3 → Tour d'horizon du matériel
PARTIE 2 — ALIMENTATION ET SÉCURITÉ ÉLECTRIQUE
Chapitre 4 → Comment alimenter la carte ?
Chapitre 5 → Les tensions de fonctionnement
Chapitre 6 → Les courants et la protection des broches
PARTIE 3 — LES ENTRÉES/SORTIES NUMÉRIQUES
Chapitre 7 → Les broches numériques (D0 à D21)
Chapitre 8 → Le PWM — faire varier une sortie
Chapitre 9 → Les protocoles de communication
PARTIE 4 — LES ENTRÉES ANALOGIQUES
Chapitre 10 → Mesurer une tension avec A0 à A5
Chapitre 11 → La résolution ADC 12 bits
PARTIE 5 — LES CONNECTEURS SPÉCIALISÉS
Chapitre 12 → Le connecteur SPI dédié (JSPI)
Chapitre 13 → Le connecteur Qwiic (I2C plug & play)
Chapitre 14 → Les LEDs intégrées
PARTIE 6 — MISE EN PRATIQUE
Chapitre 15 → Règles d'or et bonnes pratiques
Chapitre 16 → Projets et mini défis progressifs
Chapitre 17 → Résumé et tableau de référence
═══════════════════════════════════════
PARTIE 1 — DÉCOUVERTE DE LA CARTE
═══════════════════════════════════════
📦 CHAPITRE 1 — Qu'est-ce que l'Arduino UNO Q ?
1.1 — Une analogie pour commencer
💡 Imagine un smartphone. Il a un processeur puissant pour les applications, mais aussi une puce dédiée pour gérer l'écran, le son et les capteurs en temps réel.
L'Arduino UNO Q, c'est exactement ce principe appliqué à l'électronique maker : deux processeurs spécialisés sur une seule carte.
1.2 — Pourquoi l'UNO Q est différent ?
L'Arduino UNO Q est une carte nouvelle génération. Elle garde le même format que l'UNO classique mais embarque des capacités radicalement supérieures.
┌──────────────────────────────────────────────────────────┐
│ TABLEAU COMPARATIF GÉNÉRAL │
├──────────────────────┬───────────────┬───────────────────┤
│ Caractéristique │ UNO R3 │ UNO Q │
├──────────────────────┼───────────────┼───────────────────┤
│ Microcontrôleur MCU │ ATmega328P │ STM32U585 │
│ Processeur MPU │ Aucun │ Qualcomm QRB2210 │
│ Architecture MCU │ 8 bits │ 32 bits │
│ Fréquence MCU │ 16 MHz │ 48 MHz │
│ RAM MCU │ 2 Ko │ 32 Ko │
│ Flash MCU │ 32 Ko │ 256 Ko │
│ Système d'exploit. │ Aucun │ Linux (Debian) │
│ USB natif │ ❌ │ ✅ USB-C 3.1 │
│ WiFi intégré │ ❌ │ ✅ 802.11ac │
│ Bluetooth │ ❌ │ ✅ 5.1 │
│ CAN Bus │ ❌ │ ✅ │
│ DAC intégré │ ❌ │ ✅ │
│ Op-amp intégré │ ❌ │ ✅ │
│ Tension broches │ 5 V │ 3,3 V │
│ Résolution ADC │ 10 bits │ 12 bits │
│ Format │ UNO standard │ UNO standard │
└──────────────────────┴───────────────┴───────────────────┘
1.3 — Les domaines d'application
L'UNO Q est conçu pour des projets ambitieux et modernes :
🤖 ROBOTIQUE
→ Robots autonomes avec vision par caméra
→ Bras robotiques avec retour visuel
→ Contrôle moteur temps réel (MCU)
+ décision intelligente (Linux/IA)
🏠 DOMOTIQUE
→ Sonnettes avec reconnaissance faciale
→ Systèmes de contrôle vocal
→ Hubs climatiques personnalisés
🎓 ÉDUCATION
→ Apprentissage de Linux embarqué
→ Initiation à l'IA et la vision par ordinateur
→ Projets pédagogiques avancés
📷 MULTIMÉDIA
→ Caméras intelligentes DIY
→ Affichages interactifs
→ Projets de réalité augmentée
🎮 GAMING
→ Émulation de consoles rétro
→ Contrôleurs gestuels
→ Arcades personnalisées
🧠 CHAPITRE 2 — Les deux cerveaux de la carte
2.1 — Architecture globale
┌──────────────────────────────────────────────────────────┐
│ ARDUINO UNO Q │
│ │
│ ┌───────────────────────┐ ┌─────────────────────────┐ │
│ │ 🧠 CERVEAU 1 : MPU │ │ 🎮 CERVEAU 2 : MCU │ │
│ │ Qualcomm QRB2210 │ │ STM32U585 │ │
│ │ │ │ │ │
│ │ • Fait tourner Linux │ │ • Exécute ton sketch │ │
│ │ • WiFi / Bluetooth │ │ • Gère D0→D21, A0→A5 │ │
│ │ • Caméra / Écran │ │ • PWM, SPI, I2C, UART │ │
│ │ • IA / Python │ │ • CAN Bus, ADC 12 bits │ │
│ │ • Tension I/O : 1,8V │ │ • Tension I/O : 3,3V │ │
│ └──────────┬────────────┘ └──────────┬──────────────┘ │
│ │ │ │
│ └──────────┬───────────────┘ │
│ │ │
│ 🔗 Arduino Bridge (RPC) │
│ Communication bidirectionnelle │
│ entre Linux et le sketch Arduino │
└──────────────────────────────────────────────────────────┘
2.2 — Le cerveau Linux : Qualcomm QRB2210 (MPU)
💡 MPU = MicroProcessor Unit C'est le cerveau "haut niveau" de la carte.
Caractéristiques clés :
4 cœurs Arm Cortex-A53
Fait tourner Debian Linux complet
Gère le WiFi 802.11ac et le Bluetooth 5.1
Pilote les caméras MIPI-CSI-2 (jusqu'à 4 voies)
Gère l'affichage MIPI-DSI → DisplayPort
Ses broches I/O fonctionnent à 1,8 V
⚠️ Point important pour débutant : Tu n'interagis jamais directement avec le Qualcomm depuis ton sketch Arduino. Il tourne en arrière-plan. La communication passe par le Arduino Bridge.
2.3 — Le cerveau Arduino : STM32U585 (MCU)
💡 MCU = MicroController Unit C'est le cerveau "temps réel" de la carte. C'est lui qui exécute ton code Arduino.
Caractéristiques clés :
Arm Cortex-M33, 32 bits, 48 MHz
256 Ko Flash / 32 Ko RAM
Tourne sur Zephyr OS avec le core Arduino
Gère toutes les broches D0 à D21 et A0 à A5
ADC 12 bits (résolution 4 fois supérieure à l'UNO R3)
Ses broches I/O fonctionnent à 3,3 V
Intègre : CAN Bus, SPI, I2C, UART, PWM, DAC, OPAMP
2.4 — Le Arduino Bridge : comment ils se parlent ?
💡 Analogie : Imagine deux collègues dans deux bureaux différents. Ils se parlent par téléphone interne. Le Bridge, c'est ce téléphone.
┌─────────────────────────────────────────────────────┐
│ ARDUINO BRIDGE (RPC) │
│ │
│ MPU (Linux/Python) ←──────→ MCU (Arduino/C++) │
│ │
│ • Appel de fonctions à distance (RPC) │
│ • Communication bidirectionnelle │
│ • Transfert de données structurées │
│ • Notifications asynchrones │
│ │
│ Support physique : USB CDC / UART / SPI │
└─────────────────────────────────────────────────────┘
🔍 CHAPITRE 3 — Tour d'horizon du matériel
3.1 — Les connecteurs de la carte
Arduino UNO Q — Vue d'ensemble des connecteurs
┌─────────────────────────────────────────────────────────┐
│ │
│ [USB-C] [Barrel] [JSPI] [Qwiic] │
│ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ●●●●●●●●●●●●●●●● ← JMISC (Mixte 1.8V/3.3V) │ │
│ │ │ │
│ │ LED Matrix 8×13 │ │
│ │ ● RGB LED 1 ● RGB LED 2 (Qualcomm) │ │
│ │ ● RGB LED 3 ● RGB LED 4 (STM32) │ │
│ │ ● Power LED (3.3V rail) │ │
│ │ │ │
│ │ ●●●●●●●● ← JCTL (Contrôle) │ │
│ │ │ │
│ └──────────────────────────────────────────────────┘ │
│ │
│ ●●●●●● ← JANALOG (A0-A5) JDIGITAL → ●●●●●●●●●● │
│ │
└─────────────────────────────────────────────────────────┘
3.2 — Tableau des connecteurs
┌──────────┬───────────┬────────────────────────────────────┐
│Connecteur│ Position │ Contenu │
├──────────┼───────────┼────────────────────────────────────┤
│ JDIGITAL │ A2 │ D0 à D21 (broches numériques MCU) │
│ JANALOG │ A3 │ A0 à A5 (entrées analogiques MCU) │
│ JSPI │ A5 │ SPI dédié (MISO/MOSI/SCK) │
│ QWIIC │ A4 │ I2C plug & play (SDA/SCL) │
│ JMISC │ B1 │ Mixte MPU (1.8V) + MCU (3.3V) │
│ JMEDIA │ B2 │ MIPI-CSI, MIPI-DSI, Audio │
│ JCTL │ A1 │ Contrôle, GPIO, Debug │
│ USB-C │ Bord │ Alimentation + données + DP │
│ Barrel │ Bord │ Alimentation 7-24V DC │
└──────────┴───────────┴────────────────────────────────────┘
═══════════════════════════════════════
PARTIE 2 — ALIMENTATION ET SÉCURITÉ
═══════════════════════════════════════
⚡ CHAPITRE 4 — Comment alimenter la carte ?
4.1 — Les trois façons d'alimenter l'UNO Q
┌──────────────────────────────────────────────────────────┐
│ MODES D'ALIMENTATION │
├──────────────────────────────────────────────────────────┤
│ │
│ 🔌 MODE 1 — USB-C │
│ Tension : 5 V uniquement │
│ Courant : 3 A minimum recommandé │
│ Usage : Développement, prototypage │
│ ⚠️ Ne pas utiliser un chargeur 1A ou 500mA ! │
│ │
│ 🔋 MODE 2 — Connecteur Barrel (prise jack 5.5mm) │
│ Tension : 7 V à 24 V DC │
│ Usage : Projets autonomes, robotique │
│ ✅ Idéal pour alimenter des actionneurs en plus │
│ │
│ 📌 MODE 3 — Broches VIN / 5V │
│ VIN : 7 V à 24 V (régulé en interne) │
│ 5V : 5 V direct sur le rail 5V_SYS │
│ ⚠️ Ne jamais dépasser les limites ! │
│ │
└──────────────────────────────────────────────────────────┘
4.2 — Le cheminement de l'énergie (diagramme)
USB-C (5V) ──┐
├──→ 5V_SYS ──→ Convertisseur Buck
VIN (7-24V) ──┘ │ │
│ ┌───────┴────────┐
│ ▼ ▼
│ 3,8V Rail 3,3V Rail (PWR_3P3V)
│ (PWR_3P8V) │
│ ┌─────────┴──────────┐
│ ▼ ▼
│ Broches Arduino 1,8V LDO
│ (MCU STM32) │
│ ▼
└──────────────────────────────→ Qualcomm MPU
4.3 — Les erreurs fréquentes d'alimentation
❌ ERREUR 1 : Chargeur USB trop faible
Symptôme : la carte redémarre sans raison
Solution : utiliser une source 5V / 3A minimum
❌ ERREUR 2 : Brancher 12V sur la broche 5V
Symptôme : destruction immédiate
Solution : 12V → uniquement sur VIN ou barrel
❌ ERREUR 3 : Utiliser un câble USB bas de gamme
Symptôme : chutes de tension, instabilité Linux
Solution : câble USB-C de qualité, court (<1m)
❌ ERREUR 4 : Brancher pendant une opération critique
Symptôme : corruption du système Linux
Solution : attendre la fin du boot (20-30 secondes)
📊 CHAPITRE 5 — Les tensions de fonctionnement
5.1 — Tableau des tensions (données datasheet)
ParamètreMinTypiqueMaxUnitéUSB-C (VBUS)4,55,05,5VEntrée DC (VIN / Barrel)7,0—24,0VRail 5V_SYS4,755,05,25VRail 3,3V (PWR_3P3V)3,13,33,5VBroches MCU (JDIGITAL)—3,3—VBroches MPU (JMISC)—1,8—VEntrée analogique A0-A50—3,3VTempérature opérationnelle-10—+60°C
5.2 — ⚠️ La différence critique avec l'UNO R3
🔴 C'est le point le plus important du cours. La plupart des accidents électroniques viennent de là.
┌─────────────────────────────────────────────────────────┐
│ │
│ Arduino UNO R3 → Broches en 5 V │
│ Arduino UNO Q → Broches en 3,3 V │
│ │
│ ⚠️ Un capteur 5V branché directement sur │
│ une broche UNO Q peut DÉTRUIRE le STM32U585 │
│ │
│ ✅ Solution : utiliser un level shifter │
│ (convertisseur de niveaux logiques) │
│ │
└─────────────────────────────────────────────────────────┘
5.3 — Les domaines de tension résumés
┌──────────────┬──────────┬─────────────────────────────┐
│ Domaine │ Tension │ Ce qu'il alimente │
├──────────────┼──────────┼─────────────────────────────┤
│ 5V_SYS │ 5,0 V │ Rail principal carte │
│ PWR_3P3V │ 3,3 V │ Broches MCU (JDIGITAL) │
│ │ │ Connecteur Qwiic │
│ │ │ JSPI (sorties) │
│ VREG_1P8V │ 1,8 V │ Qualcomm MPU │
│ │ │ Broches MPU (JMISC) │
│ │ │ Caméra, écran, audio │
└──────────────┴──────────┴─────────────────────────────┘
🛡️ CHAPITRE 6 — Courants et protection des broches
6.1 — Les limites de courant absolues
💡 Analogie du robinet : Une broche Arduino, c'est comme un robinet. Il peut laisser passer de l'eau, mais si tu l'ouvres trop fort, il casse. Le courant maximum, c'est le débit maximum du robinet.
┌─────────────────────────────────────────────────────┐
│ LIMITES DE COURANT — STM32U585 │
├─────────────────────────────────────────────────────┤
│ │
│ Par broche individuelle → MAX 20 mA │
│ Total toutes broches → MAX 120 mA │
│ Broche en entrée → 1 mA (signal seul) │
│ │
│ ⚠️ Ces limites sont ABSOLUES. │
│ Les dépasser = dommages permanents. │
│ │
└─────────────────────────────────────────────────────┘
6.2 — Calculer la résistance pour une LED
💡 Formule universelle :
┌─────────────────────────────────────────────────┐
│ │
│ R = (V_broche - V_led) / I_cible │
│ │
│ Où : │
│ V_broche = 3,3 V (tension UNO Q) │
│ V_led = 2,0 V (LED rouge typique) │
│ = 3,0 V (LED bleue/blanche) │
│ I_cible = 0,010 A (10 mA, valeur prudente) │
│ │
│ Exemple LED rouge : │
│ R = (3,3 - 2,0) / 0,010 │
│ R = 1,3 / 0,010 = 130 Ω │
│ → On prend 150 Ω ou 220 Ω (valeur standard) │
│ │
│ Exemple LED bleue : │
│ R = (3,3 - 3,0) / 0,010 │
│ R = 0,3 / 0,010 = 30 Ω │
│ → On prend 33 Ω ou 47 Ω (valeur standard) │
│ │
└─────────────────────────────────────────────────┘
6.3 — Les règles d'or de la sécurité électrique
╔═════════════════════════════════════════════════════════╗
║ RÈGLES D'OR ARDUINO UNO Q ║
╠═════════════════════════════════════════════════════════╣
║ ║
║ ✅ Tension max sur broche numérique → 3,3 V ║
║ ✅ Tension max sur broche analogique → 3,3 V ║
║ ✅ Courant max par broche → 20 mA ║
║ ✅ Courant total max toutes broches → 120 mA ║
║ ✅ Résistance LED obligatoire → 150 Ω min ║
║ ✅ Pull-up I2C connecté → vers 3,3 V ║
║ ✅ Alimentation USB-C → 5V / 3A min ║
║ ✅ VIN ou Barrel → 7 à 24 V ║
║ ║
║ ❌ Ne jamais mettre 5 V sur A0 à A5 ║
║ ❌ Ne jamais brancher du 5V logique sans vérif. ║
║ ❌ Ne jamais dépasser 20 mA par broche ║
║ ❌ Ne jamais mettre de résistance pull-up vers 5V ║
╚═════════════════════════════════════════════════════════╝
═══════════════════════════════════════
PARTIE 3 — LES ENTRÉES/SORTIES NUMÉRIQUES
═══════════════════════════════════════
🔢 CHAPITRE 7 — Les broches numériques (D0 à D21)
7.1 — Principe de base
💡 Une broche numérique ne connaît que deux états :
HIGH → 3,3 V → "1" logique → allumé LOW → 0 V → "0" logique → éteintC'est tout. Pas de nuances, pas de valeurs intermédiaires. Juste 0 ou 1. Éteint ou allumé.
7.2 — Le tableau complet JDIGITAL
CONNECTEUR JDIGITAL (A2) — 18 broches MCU
┌────┬──────┬─────────┬──────────────────────────────┬────────┐
│ N° │ Nom │ MCU Pin │ Fonctions disponibles │ Domaine│
├────┼──────┼─────────┼──────────────────────────────┼────────┤
│ 1 │ D0 │ PB7 │ USART1_RX, TIM4_CH2 │ 3,3 V │
│ 2 │ D1 │ PB6 │ USART1_TX, TIM4_CH1 │ 3,3 V │
│ 3 │ D2 │ PB3 │ TIM2_CH2 │ 3,3 V │
│ 4 │ ~D3 │ PB0 │ PWM, OPAMP2_OUTPUT, TIM3_CH3 │ 3,3 V │
│ 5 │ D4 │ PA12 │ FDCAN1_TX, TIM1_ETR │ 3,3 V │
│ 6 │ ~D5 │ PA11 │ PWM, FDCAN1_RX, TIM1_CH4 │ 3,3 V │
│ 7 │ ~D6 │ PB1 │ PWM, TIM3_CH4 │ 3,3 V │
│ 8 │ D7 │ PB2 │ TIM8_CH4N │ 3,3 V │
│ 9 │ D8 │ PB4 │ TIM3_CH1 │ 3,3 V │
│ 10 │ ~D9 │ PB8 │ PWM, TIM4_CH3 │ 3,3 V │
│ 11 │ ~D10 │ PB9 │ PWM, SPI2_SS, TIM4_CH4 │ 3,3 V │
│ 12 │ ~D11 │ PB15 │ PWM, SPI2_MOSI, TIM1_CH3N │ 3,3 V │
│ 13 │ D12 │ PB14 │ SPI2_MISO, TIM1_CH2N │ 3,3 V │
│ 14 │ D13 │ PB13 │ SPI2_SCK, TIM1_CH1N │ 3,3 V │
│ 15 │ GND │ — │ Masse (Ground) │ 0 V │
│ 16 │ AREF │ — │ Référence analogique externe │ — │
│ 17 │ D20 │ PB11 │ I2C2_SDA, TIM2_CH4 │ 3,3 V │
│ 18 │ D21 │ PB10 │ I2C2_SCL, TIM2_CH3 │ 3,3 V │
└────┴──────┴─────────┴──────────────────────────────┴────────┘
~ = broche capable de PWM
7.3 — Premier programme : allumer une LED
Schéma de câblage
Broche D7 ──→ [R 150Ω] ──→ [LED] ──→ GND
D7 (PB2)
│
[150 Ω]
│
[▶ LED] (anode = longue patte vers résistance)
│
GND
Programme complet commenté
// ============================================
// Programme : Allumer et éteindre une LED
// Carte : Arduino UNO Q
// Broche : D7
// ============================================
// Déclaration de la broche de la LED
// On utilise une constante pour faciliter les modifications
const int BROCHE_LED = 7;
void setup() {
// Cette fonction s'exécute UNE SEULE FOIS au démarrage
// On configure D7 comme sortie
// OUTPUT = la broche va envoyer du courant
// INPUT = la broche va recevoir un signal
pinMode(BROCHE_LED, OUTPUT);
// Démarrage du moniteur série pour afficher des messages
Serial.begin(9600);
Serial.println("Démarrage du programme Blink...");
}
void loop() {
// Cette fonction se répète EN BOUCLE indéfiniment
// Mettre la broche à HIGH = 3,3 V → LED allumée
digitalWrite(BROCHE_LED, HIGH);
Serial.println("LED : ALLUMÉE");
delay(1000); // Attendre 1000 millisecondes = 1 seconde
// Mettre la broche à LOW = 0 V → LED éteinte
digitalWrite(BROCHE_LED, LOW);
Serial.println("LED : ÉTEINTE");
delay(1000); // Attendre 1 seconde
}
Résultat attendu
Moniteur Série :
Démarrage du programme Blink...
LED : ALLUMÉE
LED : ÉTEINTE
LED : ALLUMÉE
LED : ÉTEINTE
[...]
Physiquement :
La LED clignote : 1 seconde allumée, 1 seconde éteinte
7.4 — Lire un bouton poussoir
Schéma de câblage
3,3V ──→ [Bouton] ──→ D2
│
[10kΩ] ← résistance pull-down
│
GND
💡 Pourquoi la résistance pull-down ? Sans elle, la broche "flotte" entre 0 et 3,3V. La résistance force la broche à rester à 0V quand le bouton est ouvert.
Programme complet commenté
// ============================================
// Programme : Lecture d'un bouton poussoir
// Carte : Arduino UNO Q
// Broches : D2 (bouton), D7 (LED)
// ============================================
const int BROCHE_BOUTON = 2; // Broche de lecture du bouton
const int BROCHE_LED = 7; // Broche de la LED
void setup() {
// D2 en entrée : elle va recevoir le signal du bouton
pinMode(BROCHE_BOUTON, INPUT);
// D7 en sortie : elle va allumer la LED
pinMode(BROCHE_LED, OUTPUT);
Serial.begin(9600);
Serial.println("Appuyez sur le bouton...");
}
void loop() {
// Lire l'état du bouton
// digitalRead() retourne HIGH (3.3V) ou LOW (0V)
int etat = digitalRead(BROCHE_BOUTON);
if (etat == HIGH) {
// Le bouton est appuyé (circuit fermé → 3,3V sur D2)
digitalWrite(BROCHE_LED, HIGH); // LED allumée
Serial.println("Bouton appuyé → LED allumée");
} else {
// Le bouton est relâché (résistance pull-down → 0V sur D2)
digitalWrite(BROCHE_LED, LOW); // LED éteinte
}
delay(50); // Petite pause pour stabiliser la lecture
}
〰️ CHAPITRE 8 — Le PWM : faire varier une sortie
8.1 — Principe du PWM
💡 Analogie du variateur de lumière : Un interrupteur → allumé OU éteint (tout ou rien) Un variateur → tu règles de 0% à 100% de luminosité
Le PWM (Pulse Width Modulation = Modulation de Largeur d'Impulsion) simule des valeurs intermédiaires en allumant et éteignant très rapidement la broche. L'œil (ou le moteur) perçoit une valeur moyenne.
Signal PWM à 25% : ┌─┐ ┌─┐ ┌─┐
____│ │___│ │___│ │___
Signal PWM à 50% : ┌──┐ ┌──┐ ┌──┐
____│ │__│ │__│ │__
Signal PWM à 75% : ┌───┐ ┌───┐ ┌───┐
____│ │_│ │_│ │_
8.2 — Les broches PWM de l'UNO Q
┌──────────┬─────────┬─────────────────────────────┐
│ Broche │ MCU Pin │ Timer associé │
├──────────┼─────────┼─────────────────────────────┤
│ ~D3 │ PB0 │ TIM3_CH3 (OPAMP2 possible) │
│ ~D5 │ PA11 │ TIM1_CH4 │
│ ~D6 │ PB1 │ TIM3_CH4 │
│ ~D9 │ PB8 │ TIM4_CH3 │
│ ~D10 │ PB9 │ TIM4_CH4 │
│ ~D11 │ PB15 │ TIM1_CH3N │
└──────────┴─────────┴─────────────────────────────┘
analogWrite() → valeur de 0 (0%) à 255 (100%)
8.3 — Programme : respiration d'une LED (effet fade)
// ============================================
// Programme : Effet de respiration d'une LED
// Carte : Arduino UNO Q
// Broche : D9 (PWM)
// Câblage : D9 → [150Ω] → [LED] → GND
// ============================================
const int BROCHE_LED = 9; // Broche PWM obligatoire (~)
void setup() {
pinMode(BROCHE_LED, OUTPUT);
Serial.begin(9600);
Serial.println("Effet respiration LED démarré");
}
void loop() {
// Phase 1 : augmentation progressive de la luminosité
// luminosite va de 0 (éteint) à 255 (plein)
for (int luminosite = 0; luminosite <= 255; luminosite++) {
// analogWrite envoie un signal PWM
// 0 = 0% de la tension = LED éteinte
// 127 = 50% de la tension = LED mi-brillante
// 255 = 100% de la tension = LED au maximum
analogWrite(BROCHE_LED, luminosite);
delay(8); // 8ms × 256 pas = ~2 secondes pour monter
}
// Phase 2 : diminution progressive de la luminosité
for (int luminosite = 255; luminosite >= 0; luminosite--) {
analogWrite(BROCHE_LED, luminosite);
delay(8); // ~2 secondes pour descendre
}
// Pause avant de recommencer
delay(300);
}
🔗 CHAPITRE 9 — Les protocoles de communication
9.1 — Vue d'ensemble des protocoles disponibles
💡 Analogie : Imagine plusieurs langues étrangères. Chaque protocole est une "langue" qu'Arduino peut parler avec d'autres composants.
┌────────────┬──────────────┬──────────────────────────────┐
│ Protocole │ Broches UNO Q│ Utilisation typique │
├────────────┼──────────────┼──────────────────────────────┤
│ UART │ D0(RX)/D1(TX)│ GPS, Bluetooth, moniteur │
│ SPI │ D10-D13 │ MAX7219, écrans, SD card │
│ I2C │ D20/D21 │ Capteurs, OLED, RTC │
│ CAN Bus │ D4/D5 │ Automobile, industrie │
└────────────┴──────────────┴──────────────────────────────┘
9.2 — UART : la communication série (D0 et D1)
💡 Analogie : L'UART c'est comme envoyer des SMS entre deux appareils. Un fil envoie (TX), un fil reçoit (RX).
Arduino UNO Q Autre appareil
TX (D1) ──────→ RX
RX (D0) ←────── TX
GND ────── GND (masse commune obligatoire)
// Programme : Communication UART simple
void setup() {
Serial.begin(9600); // Vitesse de communication : 9600 bauds
Serial.println("UNO Q prêt !");
}
void loop() {
// Lire ce qui arrive sur RX
if (Serial.available() > 0) {
char caractere = Serial.read(); // Lire un caractère
Serial.print("Reçu : ");
Serial.println(caractere); // Renvoyer ce qu'on a reçu
}
}
9.3 — SPI : la communication rapide (D10 à D13)
💡 Analogie : Le SPI c'est comme une chaîne de montage. Il y a un chef (maître) et des ouvriers (esclaves). Le chef distribue les tâches sur 4 fils simultanément.
┌──────────────────────────────────────────────────────┐
│ BROCHES SPI sur JDIGITAL │
├─────────┬─────────┬─────────────────────────────── │
│ Nom │ Broche │ Rôle │
├─────────┼─────────┼─────────────────────────────── │
│ SS │ D10 │ Chip Select → active l'esclave │
│ MOSI │ D11 │ Master Out → données vers esclave│
│ MISO │ D12 │ Master In → données de l'esclave│
│ SCK │ D13 │ Clock → horloge de sync │
└─────────┴─────────┴──────────────────────────────────┘
Correspondance MCU :
D10 → PB9 → SPI2_SS (Chip Select)
D11 → PB15 → SPI2_MOSI
D12 → PB14 → SPI2_MISO
D13 → PB13 → SPI2_SCK
Exemple SPI avec le MAX7219 (afficheur 7 segments)
// ============================================
// Programme : Afficher "1234" sur un MAX7219
// Carte : Arduino UNO Q
// Biblioth. : LedControl.h
// Câblage :
// DIN → D11 (MOSI)
// CLK → D13 (SCK)
// LOAD → D10 (SS)
// ============================================
#include <LedControl.h>
// Création de l'objet LedControl
// LedControl(DIN, CLK, CS, nbDispositifs)
LedControl lc = LedControl(11, 13, 10, 1);
void setup() {
// Réveil du MAX7219 (il démarre en mode veille)
lc.shutdown(0, false); // false = actif
// Réglage de la luminosité (0=min, 15=max)
lc.setIntensity(0, 8); // Luminosité à 50%
// Effacement de l'affichage
lc.clearDisplay(0);
Serial.begin(9600);
Serial.println("MAX7219 initialisé !");
}
void loop() {
// Afficher les chiffres 1, 2, 3, 4
// setDigit(dispositif, position, chiffre, point)
// Position 0 = à droite, position 7 = à gauche
lc.setDigit(0, 3, 1, false); // Pos 3 → chiffre 1
lc.setDigit(0, 2, 2, false); // Pos 2 → chiffre 2
lc.setDigit(0, 1, 3, false); // Pos 1 → chiffre 3
lc.setDigit(0, 0, 4, false); // Pos 0 → chiffre 4
delay(2000);
lc.clearDisplay(0); // Effacement
delay(500);
}
9.4 — I2C : la communication économique (D20 et D21)
💡 Analogie : L'I2C c'est comme un réseau local dans un bureau. Un seul câble relie tout le monde. Chaque appareil a une adresse pour être identifié.
Arduino UNO Q
D21 (SCL) ──┬──── Capteur 1 (adresse 0x48)
D20 (SDA) ──┘──── Capteur 2 (adresse 0x76)
└──── Capteur 3 (adresse 0x3C)
⚠️ Pull-up requis : résistances de 4,7kΩ vers 3,3V
(pas vers 5V !)
9.5 — CAN Bus : la communication industrielle (D4 et D5)
💡 C'est une nouveauté de l'UNO Q ! Le CAN Bus est utilisé dans les voitures et l'industrie. Il permet à des dizaines d'appareils de communiquer sur un seul câble en 2 fils différentiels.
┌─────────┬─────────┬──────────────────────────────┐
│ Broche │ MCU Pin │ Rôle │
├─────────┼─────────┼──────────────────────────────┤
│ D4 │ PA12 │ FDCAN1_TX → Émission CAN │
│ D5 │ PA11 │ FDCAN1_RX → Réception CAN │
└─────────┴─────────┴──────────────────────────────┘
Note : nécessite un transceiver CAN externe
(ex: SN65HVD230) entre D4/D5 et le bus
═══════════════════════════════════════
PARTIE 4 — LES ENTRÉES ANALOGIQUES
═══════════════════════════════════════
📈 CHAPITRE 10 — Mesurer une tension avec A0 à A5
10.1 — Qu'est-ce qu'une entrée analogique ?
💡 Analogie : Une entrée numérique → interrupteur (allumé/éteint) Une entrée analogique → thermomètre (plage de valeurs)
Elle mesure n'importe quelle tension entre 0 et 3,3 V et la convertit en un nombre utilisable dans ton programme.
10.2 — Le connecteur JANALOG complet
CONNECTEUR JANALOG (A3) — Entrées analogiques
┌─────────┬─────────┬──────────────────────────────────────┐
│ Broche │ MCU Pin │ Notes importantes │
├─────────┼─────────┼──────────────────────────────────────┤
│ A0 │ PA4 │ ADC direct STM32 — 0 à 3,3V SEUL │
│ A1 │ PA5 │ ADC direct STM32 — 0 à 3,3V SEUL │
│ A2 │ PA6 │ ADC direct STM32 — 0 à 3,3V SEUL │
│ A3 │ PA7 │ ADC direct STM32 — 0 à 3,3V SEUL │
│ A4 │ PC4 │ Peut servir I2C3_SDA │
│ A5 │ PC5 │ Peut servir I2C3_SCL │
│ 5V_SYS │ — │ Alimentation 5V (sortie seulement) │
│ PWR_3P3V│ — │ Alimentation 3,3V (IOREF) │
│ GND │ — │ Masse │
└─────────┴─────────┴──────────────────────────────────────┘
⚠️ Toutes les broches A0-A5 : tension max = 3,3V
⚠️ Le 5V_SYS est une sortie d'alimentation, pas une entrée
10.3 — Câblage d'un potentiomètre (exemple de base)
3,3V (PWR_3P3V)
│
┌───┤ Patte droite du potentiomètre
│ │
│ [potentiomètre
│ 10kΩ]
│ │──────────────────── A0 (PA4 STM32)
│ │
└───┤ Patte gauche
│
GND
⚠️ JAMAIS brancher la patte droite à 5V !
Le maximum autorisé sur A0 est 3,3V.
10.4 — Programme : voltmètre simple
// ============================================
// Programme : Voltmètre simple
// Carte : Arduino UNO Q
// Broche : A0
// Câblage : potentiomètre entre GND et 3,3V
// curseur → A0
// ============================================
void setup() {
Serial.begin(9600);
Serial.println("=== Voltmètre Arduino UNO Q ===");
Serial.println("Référence : 3,3V | Résolution : 12 bits");
Serial.println("Plage de valeurs : 0 à 4095");
Serial.println("-------------------------------");
}
void loop() {
// Lecture brute de la broche A0
// Sur UNO Q : retourne un entier entre 0 et 4095 (12 bits)
// Sur UNO R3 : retournerait entre 0 et 1023 (10 bits)
int valeurBrute = analogRead(A0);
// Conversion de la valeur brute en tension réelle
// Formule : tension = valeur × (V_ref / résolution_max)
// V_ref = 3,3V | résolution_max = 4095 (2^12 - 1)
float tension = valeurBrute * (3.3 / 4095.0);
// Calcul du pourcentage pour plus de clarté
float pourcentage = (valeurBrute / 4095.0) * 100.0;
// Affichage formaté dans le moniteur série
Serial.print("Brut: ");
Serial.print(valeurBrute);
Serial.print(" / 4095 | ");
Serial.print(tension, 3); // 3 décimales
Serial.print(" V | ");
Serial.print(pourcentage, 1);
Serial.println(" %");
delay(250); // Mise à jour 4 fois par seconde
}
Résultat attendu
=== Voltmètre Arduino UNO Q ===
Référence : 3,3V | Résolution : 12 bits
Plage de valeurs : 0 à 4095
-------------------------------
Brut: 0 / 4095 | 0.000 V | 0.0 %
Brut: 1024 / 4095 | 0.825 V | 25.0 %
Brut: 2047 / 4095 | 1.650 V | 50.0 %
Brut: 3071 / 4095 | 2.474 V | 75.0 %
Brut: 4095 / 4095 | 3.300 V | 100.0 %
🔬 CHAPITRE 11 — La résolution ADC 12 bits
11.1 — Pourquoi 12 bits c'est mieux que 10 bits ?
💡 Analogie de la règle graduée : Une règle avec 1024 graduations (10 bits, UNO R3) vs une règle avec 4096 graduations (12 bits, UNO Q).
La deuxième est 4 fois plus précise.
┌──────────────────────────────────────────────────────┐
│ COMPARAISON DES RÉSOLUTIONS ADC │
├──────────────────┬───────────────┬───────────────────┤
│ Caractéristique │ UNO R3 │ UNO Q │
├──────────────────┼───────────────┼───────────────────┤
│ Résolution │ 10 bits │ 12 bits │
│ Valeurs possibles│ 0 à 1023 │ 0 à 4095 │
│ Précision pour 1V│ ~5 mV/division│ ~0,8 mV/division │
│ Tension de réf. │ 5 V │ 3,3 V (VREF+) │
│ Tolérance entrée │ 0 à 5 V │ 0 à 3,3 V │
└──────────────────┴───────────────┴───────────────────┘
11.2 — Conversion et compatibilité
⚠️ Si tu reprends du code écrit pour UNO R3, il faut adapter les conversions !
// ============================================
// Conversion de code UNO R3 vers UNO Q
// ============================================
// --- ANCIEN CODE (UNO R3, 10 bits) ---
// int val = analogRead(A0); // 0 à 1023
// float tension = val * (5.0 / 1023.0); // référence 5V
// --- NOUVEAU CODE (UNO Q, 12 bits) ---
int val = analogRead(A0); // 0 à 4095
float tension = val * (3.3 / 4095.0); // référence 3,3V
// --- CONVERSION POUR GARDER UNE PLAGE 0-255 (PWM) ---
// Sur UNO R3 : val / 4 (1023 ÷ 4 ≈ 255)
// Sur UNO Q : val / 16 (4095 ÷ 16 ≈ 255)
int pwmValue = val / 16;
// --- OU UTILISER map() POUR PLUS DE CLARTÉ ---
int pwmValue2 = map(val, 0, 4095, 0, 255);
═══════════════════════════════════════
PARTIE 5 — LES CONNECTEURS SPÉCIALISÉS
═══════════════════════════════════════
🔌 CHAPITRE 12 — Le connecteur SPI dédié (JSPI)
12.1 — Pourquoi un second connecteur SPI ?
L'UNO Q dispose d'un connecteur JSPI (A5) dédié, en plus des broches SPI du connecteur JDIGITAL.
💡 Cela permet de connecter des périphériques SPI sans occuper les broches D10 à D13 qui peuvent servir à autre chose simultanément.
CONNECTEUR JSPI (A5)
┌──────────┬─────────┬────────────────────────────────────┐
│ Signal │ MCU Pin │ Description │
├──────────┼─────────┼────────────────────────────────────┤
│ MISO │ PC2 │ Données reçues (5V-tolérant) │
│ MOSI │ PC3 │ Données envoyées (sortie 3,3V) │
│ SCK │ PD1 │ Horloge SPI (sortie 3,3V) │
│ 5V_SYS │ — │ Alimentation 5V pour périphériq. │
│ GND │ — │ Masse │
└──────────┴─────────┴────────────────────────────────────┘
⚠️ MISO seulement est 5V-tolérant en entrée.
MOSI et SCK sont des sorties en 3,3V.
→ Level shifter requis pour périphérique 5V complet.
🔵 CHAPITRE 13 — Le connecteur Qwiic (I2C plug & play)
13.1 — Présentation du Qwiic
💡 Le Qwiic (A4), c'est l'USB de l'I2C. Un connecteur 4 broches standardisé. Pas de risque de brancher à l'envers. Compatible avec des centaines de capteurs.
CONNECTEUR QWIIC (A4)
┌──────────┬─────────┬────────────────────────────────────┐
│ Signal │ MCU Pin │ Description │
├──────────┼─────────┼────────────────────────────────────┤
│ GND │ — │ Masse │
│ 3,3V │ — │ Alimentation (sortie 3,3V) │
│ SDA │ PD13 │ Données I2C (I2C4_SDA) │
│ SCL │ PD12 │ Horloge I2C (I2C4_SCL) │
└──────────┴─────────┴────────────────────────────────────┘
✅ Compatible :
→ Arduino Modulino® nodes
→ SparkFun Qwiic (centaines de capteurs)
→ Adafruit STEMMA QT
💡 CHAPITRE 14 — Les LEDs intégrées
14.1 — Tableau complet des LEDs
┌──────────┬──────────────────┬───────────────────────────────┐
│ LED │ Contrôlée par │ Description │
├──────────┼──────────────────┼───────────────────────────────┤
│ RGB 1 │ Qualcomm (Linux) │ GPIO_41(R), 42(G), 60(B) │
│ RGB 2 │ Qualcomm (Linux) │ WLAN(G), BT(B), PANIC(R) │
│ │ │ Modifiable par l'utilisateur │
│ RGB 3 │ STM32 (MCU) │ PH10(R), PH11(G), PH12(B) │
│ RGB 4 │ STM32 (MCU) │ PH13(R), PH14(G), PH15(B) │
│ Matrice │ STM32 (MCU) │ 8×13 pixels bleus (104 LEDs) │
│ │ │ Logo au démarrage (20-30s) │
│ Power │ Rail 3,3V │ Verte, allumée si alimenté │
└──────────┴──────────────────┴───────────────────────────────┘
14.2 — ⚠️ Les LEDs sont actives-low !
🔴 Attention ! C'est l'inverse de l'habitude.
Sur LED ordinaire connectée à une broche :
digitalWrite(broche, HIGH) → LED allumée ✅
Sur les LEDs RGB intégrées de l'UNO Q :
digitalWrite(broche, LOW) → LED allumée ✅
digitalWrite(broche, HIGH) → LED éteinte ✅
14.3 — Programme : LED RGB MCU (RGB3 et RGB4)
// ============================================
// Programme : Contrôle des LEDs RGB intégrées
// Carte : Arduino UNO Q
// LEDs : RGB3 et RGB4 (pilotées par STM32)
// Note : LEDs actives-low (LOW = allumé)
// ============================================
// Définition des broches des LEDs RGB intégrées
// RGB3 (D27401)
#define LED3_R PH10
#define LED3_G PH11
#define LED3_B PH12
// RGB4 (D27402)
#define LED4_R PH13
#define LED4_G PH14
#define LED4_B PH15
void setup() {
// Configuration de toutes les broches LED en sortie
pinMode(LED3_R, OUTPUT); pinMode(LED3_G, OUTPUT);
pinMode(LED3_B, OUTPUT);
pinMode(LED4