Arduino — Systèmes Embarqués
Un cours complet depuis zéro : GPIO, ADC, PWM, DHT11, I2C, LCD, capteurs et projet final. Chaque ligne de code expliquée, aucune hypothèse.
Sommaire
1. Introduction à Arduino
Arduino est une plateforme de prototypage électronique open source créée en 2005. Elle combine une carte matérielle (microcontrôleur + connecteurs) et un environnement de développement (Arduino IDE). L'objectif : rendre la programmation de microcontrôleurs accessible à tous.
| Carte | CPU | Flash | RAM | Spécialité |
|---|---|---|---|---|
| Arduino Uno R3 | ATmega328P 16 MHz | 32 KB | 2 KB | Débutant — référence absolue |
| Arduino Nano | ATmega328P 16 MHz | 32 KB | 2 KB | Compact — même puce que l'Uno |
| Arduino Mega 2560 | ATmega2560 16 MHz | 256 KB | 8 KB | Grands projets, beaucoup d'I/O |
| Arduino Due | AT91SAM3X8E 84 MHz | 512 KB | 96 KB | Haute performance, 3.3 V |
- 1
Tu écris le code en C++
Dans l'Arduino IDE ou VS Code avec l'extension PlatformIO.
- 2
L'IDE compile
Le compilateur
avr-g++transforme ton code en binaire machine pour l'ATmega. - 3
Upload via USB
avrdudeenvoie le binaire par le câble USB. Le chip convertisseur USB/UART (CH340 ou ATmega16U2) sert de pont. - 4
Stocké en Flash
Le programme est gravé dans les 32 KB de mémoire Flash — il persiste après extinction.
- 5
L'ATmega328P exécute en boucle
setup()une seule fois au démarrage, puisloop()indéfiniment jusqu'à l'extinction.
// Tout programme Arduino a exactement ces 2 fonctions : // setup() → exécutée UNE SEULE FOIS au démarrage // loop() → exécutée EN BOUCLE INFINIE ensuite const int LED = 13; // LED intégrée sur broche 13 void setup() { Serial.begin(9600); // démarrer la com série à 9600 bauds pinMode(LED, OUTPUT); // broche 13 en SORTIE Serial.println("Arduino démarré !"); } void loop() { digitalWrite(LED, HIGH); // allumer LED delay(500); // attendre 500 ms digitalWrite(LED, LOW); // éteindre LED delay(500); }
2. Architecture & Broches
L'ATmega328P est un microcontrôleur 8 bits de la famille AVR d'Atmel. Il exécute une instruction par cycle d'horloge à 16 MHz, soit 16 millions d'instructions par seconde.
| Composant | Taille | Rôle |
|---|---|---|
| Flash | 32 KB | Stockage du programme (non-volatile — persiste après extinction) |
| SRAM | 2 KB | Variables, stack, heap (volatile — s'efface à l'extinction) |
| EEPROM | 1 KB | Données permanentes modifiables (compteur, config — 100 000 cycles) |
| ADC | 10 bits × 6 | Convertit 0–5 V en 0–1023 sur les broches A0–A5 |
| Timers | 3 (0, 1, 2) | Génèrent millis(), micros() et le PWM — ne pas modifier Timer0 ! |
| Broche | Alias | Fonction spéciale | Remarque |
|---|---|---|---|
| D0 | RX | UART réception | Ne pas utiliser si câble USB branché |
| D1 | TX | UART émission | Ne pas utiliser si câble USB branché |
| D3,5,6,9,10,11 | ~ | PWM 8 bits (analogWrite) | 490 Hz (D5,D6,D9,D10) ou 980 Hz (D3,D11) |
| D13 | LED_BUILTIN | LED intégrée | LED orange sur la carte — HIGH = allumée |
| A0–A5 | – | ADC 10 bits 0–5 V | Peuvent aussi fonctionner comme GPIO digital |
| A4 / A5 | SDA / SCL | Bus I2C | Pull-up 4,7 kΩ externe vers 5 V recommandé |
3. GPIO — Sorties & Entrées Digitales
Un GPIO digital ne connaît que deux états : HIGH (5 V = logique 1) et LOW (0 V = logique 0). En sortie, tu commandes une LED, un relais. En entrée, tu lis un bouton, un capteur digital.
OUTPUT — tu contrôles la tension. INPUT — tu lis la tension (broche flottante si rien de branché !). INPUT_PULLUP — tu lis avec une résistance interne (~47 kΩ) maintenant la broche à HIGH au repos — le mode à utiliser pour les boutons.const int LED = 13; const int BTN = 7; void setup() { pinMode(LED, OUTPUT); pinMode(BTN, INPUT_PULLUP); // résistance interne activée } void loop() { int etat = digitalRead(BTN); // INPUT_PULLUP → logique inversée ! // Bouton relâché : broche à HIGH (via résistance interne) // Bouton appuyé : broche à LOW (connectée à GND) if (etat == LOW) { digitalWrite(LED, HIGH); // allumer si appuyé } else { digitalWrite(LED, LOW); // éteindre sinon } }
INPUT_PULLUP.delay() que dans des exemples simples. Dès que tu as plusieurs tâches simultanées (lire un capteur ET faire clignoter une LED ET lire un bouton), utilise millis() — la montre interne de l'Arduino. delay() bloque tout le programme pendant qu'il attend.const int LED = 13; unsigned long tDernier = 0; // horodatage du dernier bascule bool etatLED = false; const int INTERVALLE = 500; // clignoter toutes les 500 ms void setup() { pinMode(LED, OUTPUT); } void loop() { unsigned long maintenant = millis(); // ms depuis le démarrage if (maintenant - tDernier >= INTERVALLE) { tDernier = maintenant; // mémoriser l'heure etatLED = !etatLED; // inverser l'état digitalWrite(LED, etatLED); } // ← Ici : tout autre code continue à tourner sans être bloqué ! }
millis() - tDernier fonctionne correctement même après l'overflow (49 jours) si les deux variables sont unsigned long.Les boutons mécaniques rebondissent 5–50 ms à chaque appui : 1 appui réel peut déclencher 10–50 lectures parasites. Solution logicielle :
const int BTN_PIN = 2; const int DEBOUNCE_MS = 50; unsigned long tDernier = 0; int etatBrut = HIGH; int etatStable = HIGH; int compteur = 0; void setup() { Serial.begin(9600); pinMode(BTN_PIN, INPUT_PULLUP); } void loop() { int lecture = digitalRead(BTN_PIN); if (lecture != etatBrut) // signal changé → reset timer tDernier = millis(); if ((millis() - tDernier) > DEBOUNCE_MS) { // stable 50 ms if (lecture != etatStable) { etatStable = lecture; if (etatStable == LOW) { // front descendant = appui compteur++; Serial.print("Appui #"); Serial.println(compteur); } } } etatBrut = lecture; }
4. ADC & PWM — Signaux Analogiques
Le monde physique est analogique. L'ADC (Analog-to-Digital Converter) convertit une tension (0–5 V) en nombre (0–1023). Le PWM (Pulse Width Modulation) simule une sortie analogique en faisant varier la largeur des impulsions numériques.
Formule :
tension = valeur × 5.0 / 1023Exemple : valeur = 512 → tension = 512 × 5.0 / 1023 ≈ 2.50 V
// Câblage potentiomètre : pin 1 → 5V, pin 3 → GND, pin 2 (curseur) → A0 const int POT_PIN = A0; void setup() { Serial.begin(9600); } void loop() { int brut = analogRead(POT_PIN); // 0 à 1023 float tension = brut * 5.0 / 1023.0; // convertir en Volts int pourcent = map(brut, 0, 1023, 0, 100); // map() rééchelonne Serial.print("Brut: "); Serial.print(brut); Serial.print(" Tension: "); Serial.print(tension, 2); Serial.print("V"); Serial.print(" Pot: "); Serial.print(pourcent); Serial.println("%"); delay(200); }
map(val, inMin, inMax, outMin, outMax) — rééchelonnage linéaire. Ex : map(512, 0, 1023, 0, 180) → 90 (utile pour les servos).analogWrite(pin, 0–255) alterne rapidement HIGH/LOW. 255 = 100% HIGH = pleine puissance. 128 = 50% = mi-puissance. 0 = éteint. La fréquence est 490 Hz (ou 980 Hz pour D3 et D11). Disponible uniquement sur les broches marquées ~ : D3, D5, D6, D9, D10, D11.// Fondu progressif sur broche PWM D9 const int LED = 9; const int LDR = A1; // photorésistance (5V → R10kΩ → A1 → LDR → GND) void setup() { pinMode(LED, OUTPUT); } void loop() { // ── Fondu 0→255→0 ─────────────────────────────── for (int i = 0; i <= 255; i++) { analogWrite(LED, i); delay(8); } for (int i = 255; i >= 0; i--) { analogWrite(LED, i); delay(8); } // ── Veilleuse : plus il fait sombre, plus la LED brille ── int lumiere = analogRead(LDR); // 0=sombre, 1023=clair int luminosite = map(lumiere, 0, 1023, 255, 0); // inverser analogWrite(LED, luminosite); delay(100); }
5. Capteur DHT11 — Température & Humidité
Le DHT11 est un capteur numérique de température (0–50°C, ±2°C) et d'humidité relative (20–90%, ±5%). Il communique via un protocole série 1 fil propriétaire. Simple, bon marché, parfait pour débuter.
| DHT11 (bleu) | DHT22 (blanc) | |
|---|---|---|
| Température | 0–50°C, ±2°C | -40–80°C, ±0.5°C |
| Humidité | 20–90%, ±5% | 0–100%, ±2% |
| Vitesse | 1 mesure / seconde | 1 mesure / 2 secondes |
| Prix | ~1–3€ | ~3–7€ |
| Usage | Projets débutants, station météo simple | Mesures précises, industrie légère |
| Broche DHT11 | Connecter à |
|---|---|
| Pin 1 — VCC | 5V Arduino |
| Pin 2 — DATA | D2 Arduino + résistance 10 kΩ vers 5V |
| Pin 3 — NC | Non connecté |
| Pin 4 — GND | GND Arduino |
- 1
Ouvrir le gestionnaire
Arduino IDE → Outils → Gérer les bibliothèques (ou Ctrl+Shift+I).
- 2
Rechercher "DHT sensor library"
Choisir la bibliothèque par Adafruit → Installer.
- 3
Installer la dépendance
Une boîte de dialogue propose d'installer Adafruit Unified Sensor — accepter.
#include "DHT.h" const int DHT_PIN = 2; const int DHT_TYPE = DHT11; // DHT11 ou DHT22 DHT dht(DHT_PIN, DHT_TYPE); void setup() { Serial.begin(9600); dht.begin(); delay(2000); // laisser le capteur se stabiliser } void loop() { delay(2000); // ⚠️ minimum 1 s entre les lectures DHT11 float humidite = dht.readHumidity(); float temperature = dht.readTemperature(); // °C par défaut // .readTemperature(true) → Fahrenheit // Toujours vérifier si la lecture est valide (NaN = erreur) if (isnan(humidite) || isnan(temperature)) { Serial.println("Erreur ! Vérifier câblage et résistance 10kΩ."); return; } float ressenti = dht.computeHeatIndex(temperature, humidite, false); Serial.print("Humidité : "); Serial.print(humidite, 1); Serial.println(" %"); Serial.print("Température : "); Serial.print(temperature, 1); Serial.println(" °C"); Serial.print("Ressenti : "); Serial.print(ressenti, 1); Serial.println(" °C"); Serial.println("---"); }
isnan() détecte la valeur NaN (Not a Number) que la bibliothèque retourne en cas d'erreur. Toujours vérifier avant d'utiliser la valeur !#include "DHT.h" const int DHT_PIN = 2; const int BUZZER = 8; const int LED_ROUGE = 7; const int LED_VERTE = 6; const float SEUIL_TEMP = 28.0; const float SEUIL_HUMI = 75.0; DHT dht(DHT_PIN, DHT11); void setup() { Serial.begin(9600); pinMode(BUZZER, OUTPUT); pinMode(LED_ROUGE, OUTPUT); pinMode(LED_VERTE, OUTPUT); dht.begin(); } void loop() { delay(2000); float t = dht.readTemperature(); float h = dht.readHumidity(); if (isnan(t) || isnan(h)) { Serial.println("Erreur capteur"); return; } bool alarme = (t > SEUIL_TEMP) || (h > SEUIL_HUMI); digitalWrite(LED_VERTE, !alarme); digitalWrite(LED_ROUGE, alarme); if (alarme) { Serial.print("T="); Serial.print(t,1); Serial.print(" H="); Serial.print(h,1); Serial.println(" ⚠️ ALARME !"); tone(BUZZER, 2000, 500); // 2000 Hz pendant 500 ms } else { Serial.println("OK"); noTone(BUZZER); } }
6. Protocoles — I2C, SPI, UART
L'Arduino peut communiquer avec des centaines de capteurs et modules via trois protocoles série principaux. Choisir le bon dépend du nombre de fils disponibles et de la vitesse requise.
| Protocole | Fils | Vitesse | Appareils max | Usage typique |
|---|---|---|---|---|
| UART | 2 (TX + RX) | 1200–115200 bps | 1 à 1 seulement | GPS, Bluetooth HC-05, GSM |
| I2C | 2 (SDA + SCL) | 100–400 kHz | 127 | Capteurs, OLED, RTC, ADC |
| SPI | 4 (MOSI+MISO+SCK+SS) | jusqu'à 8 MHz | plusieurs (1 SS/esclave) | Carte SD, écran TFT, Flash |
#include "Wire.h" void setup() { Wire.begin(); // SDA = A4, SCL = A5 sur Uno Serial.begin(9600); Serial.println("=== Scan I2C ==="); int nb = 0; for (byte addr = 1; addr < 127; addr++) { Wire.beginTransmission(addr); if (Wire.endTransmission() == 0) { Serial.print("Trouvé à 0x"); Serial.println(addr, HEX); nb++; } } Serial.print(nb); Serial.println(" appareil(s) trouvé(s)"); } void loop() {} // le scan se fait une seule fois dans setup()
// HC-05 Bluetooth via UART logiciel // Câblage : HC-05 TX → D10, HC-05 RX → D11 // (éviter D0/D1 = UART matériel = interfère avec USB) #include "SoftwareSerial.h" SoftwareSerial btSerial(10, 11); // RX=D10, TX=D11 void setup() { Serial.begin(9600); // moniteur PC btSerial.begin(9600); // HC-05 (9600 par défaut) Serial.println("Bluetooth prêt."); } void loop() { if (Serial.available()) btSerial.write(Serial.read()); if (btSerial.available()) { char c = btSerial.read(); Serial.write(c); if (c == 'A') digitalWrite(13, HIGH); // allumer LED if (c == 'E') digitalWrite(13, LOW); // éteindre LED } }
7. Afficheurs LCD & OLED
Afficher des données en temps réel sans passer par le moniteur série. Le LCD 16×2 est économique et lisible de loin. L'OLED SSD1306 128×64 permet des graphiques mais est plus délicat à programmer.
// Installer : "LiquidCrystal I2C" par Frank de Brabander // Câblage : VCC→5V, GND→GND, SDA→A4, SCL→A5 #include "LiquidCrystal_I2C.h" LiquidCrystal_I2C lcd(0x27, 16, 2); // adresse 0x27, 16 col, 2 lignes // Caractère personnalisé : signe degré ° byte degre[8] = { 0b00110, 0b01001, 0b01001, 0b00110, 0b00000, 0b00000, 0b00000, 0b00000 }; void setup() { lcd.begin(); lcd.backlight(); // allumer le rétroéclairage lcd.createChar(0, degre); lcd.setCursor(0, 0); lcd.print("Station Meteo"); delay(2000); } void afficher(float temp, float humi) { lcd.setCursor(0, 0); // colonne 0, ligne 0 lcd.print("T:"); lcd.print(temp, 1); lcd.write(byte(0)); // afficher le ° personnalisé lcd.print("C "); lcd.setCursor(0, 1); // colonne 0, ligne 1 lcd.print("H:"); lcd.print(humi, 0); lcd.print("% "); } void loop() { afficher(23.5, 65.0); delay(2000); }
// Installer : "Adafruit SSD1306" + "Adafruit GFX Library" #include "Wire.h" #include "Adafruit_GFX.h" #include "Adafruit_SSD1306.h" Adafruit_SSD1306 oled(128, 64, &Wire, -1); void setup() { Serial.begin(9600); if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Serial.println("OLED introuvable !"); while (true); } oled.clearDisplay(); oled.setTextColor(SSD1306_WHITE); } void afficherDonnees(float temp, float humi) { oled.clearDisplay(); oled.setTextSize(2); // grands caractères 12×16 px oled.setCursor(0, 0); oled.print(temp, 1); oled.print(" C"); oled.setTextSize(1); // petits caractères 6×8 px oled.setCursor(0, 25); oled.print("Humidite: "); oled.print(humi, 0); oled.print("%"); // Barre de progression pour l'humidité int barre = map(humi, 0, 100, 0, 128); oled.fillRect(0, 55, barre, 8, SSD1306_WHITE); oled.drawRect(0, 55, 128, 8, SSD1306_WHITE); oled.display(); // ← INDISPENSABLE : envoyer le buffer à l'écran } void loop() { afficherDonnees(23.5, 65.0); delay(2000); }
oled.display() à la fin, rien n'apparaît. Tout se dessine dans un buffer en RAM, puis display() l'envoie à l'écran en une seule fois.8. Moteurs & Actionneurs
L'Arduino ne peut pas alimenter directement un moteur — ses broches fournissent au maximum 40 mA. Il faut toujours passer par un circuit de puissance : transistor, driver L298N ou MOSFET.
// Câblage SG90 : marron→GND, rouge→5V, orange→D9 // La lib Servo gère le signal PWM 50 Hz (1–2 ms) automatiquement #include "Servo.h" Servo monServo; void setup() { monServo.attach(9); // attacher à la broche D9 } void loop() { // Balayage 0° → 180° → 0° for (int angle = 0; angle <= 180; angle += 5) { monServo.write(angle); delay(50); } for (int angle = 180; angle >= 0; angle -= 5) { monServo.write(angle); delay(50); } // Contrôle par potentiomètre : // int angle = map(analogRead(A0), 0, 1023, 0, 180); // monServo.write(angle); }
// L298N : double pont en H — pilote 2 moteurs DC // Câblage moteur A : IN1→D2, IN2→D3, ENA→D9(PWM) const int IN1 = 2; const int IN2 = 3; const int ENA = 9; // Enable A → vitesse par PWM void avancer(int vitesse) { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); analogWrite(ENA, vitesse); // 0–255 } void reculer(int vitesse) { digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); analogWrite(ENA, vitesse); } void stopper() { digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); analogWrite(ENA, 0); } void setup() { pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(ENA, OUTPUT); } void loop() { avancer(200); delay(2000); stopper(); delay(500); reculer(150); delay(2000); stopper(); delay(500); }
9. Projet Final — Station Météo Complète
Projet de A à Z : Arduino Uno + DHT11 mesure la température et l'humidité toutes les 2 secondes, affiche sur LCD I2C, alerte LED + buzzer si un seuil est dépassé, et sauvegarde les données sur carte SD au format CSV.
- 1
Matériel nécessaire
Arduino Uno, DHT11, LCD 16×2 + module I2C, buzzer passif, 1 LED rouge, 1 LED verte, module carte SD, breadboard, fils dupont.
- 2
Connexions
DHT11 DATA→D2, LCD SDA→A4 SCL→A5, Buzzer→D8, LED rouge→D6, LED verte→D7, SD CS→D4 MOSI→D11 MISO→D12 SCK→D13.
- 3
Bibliothèques à installer
DHT sensor library (Adafruit), LiquidCrystal I2C (Frank de Brabander), SD et SPI (incluses dans l'IDE).
- 4
Préparer la carte SD
Formater en FAT32. Le fichier
meteo.csvsera créé automatiquement au premier démarrage. - 5
Calibrer les seuils
Modifier
SEUIL_TEMPetSEUIL_HUMIselon ton environnement de test. - 6
Tester
Ouvrir le moniteur série à 9600 baud. Souffler sur le DHT11 pour faire monter l'humidité et déclencher l'alarme.
#include "DHT.h" #include "LiquidCrystal_I2C.h" #include "Wire.h" #include "SD.h" #include "SPI.h" // ── Broches ───────────────────────────────────────────── #define DHT_PIN 2 #define BUZZER 8 #define LED_ROUGE 6 #define LED_VERTE 7 #define SD_CS 4 // ── Seuils ────────────────────────────────────────────── const float SEUIL_TEMP = 28.0; // °C const float SEUIL_HUMI = 75.0; // % const long INTERVALLE = 2000; // ms entre mesures // ── Objets ────────────────────────────────────────────── DHT dht(DHT_PIN, DHT11); LiquidCrystal_I2C lcd(0x27, 16, 2); // ── Variables globales ─────────────────────────────────── unsigned long tDerniereLecture = 0; bool sdOk = false; byte degre[8] = {0b00110,0b01001,0b01001,0b00110,0b00000,0b00000,0b00000,0b00000}; void setup() { Serial.begin(9600); Serial.println("=== Station Météo ==="); pinMode(BUZZER, OUTPUT); pinMode(LED_ROUGE, OUTPUT); pinMode(LED_VERTE, OUTPUT); digitalWrite(LED_VERTE, HIGH); // vert au démarrage = OK dht.begin(); lcd.begin(); lcd.backlight(); lcd.createChar(0, degre); lcd.setCursor(0, 0); lcd.print("Station Meteo"); lcd.setCursor(0, 1); lcd.print("Init..."); sdOk = SD.begin(SD_CS); Serial.println(sdOk ? "SD: OK" : "SD: non trouvée"); if (sdOk) { File f = SD.open("meteo.csv", FILE_WRITE); if (f) { f.println("temps_s,temperature,humidite,alarme"); f.close(); } } delay(2000); } void mettreAJourLCD(float t, float h) { lcd.setCursor(0, 0); lcd.print("T:"); lcd.print(t, 1); lcd.write(byte(0)); lcd.print("C "); lcd.setCursor(0, 1); lcd.print("H:"); lcd.print(h, 0); lcd.print("% "); } void sauvegarderSD(float t, float h, bool alarme) { if (!sdOk) return; File f = SD.open("meteo.csv", FILE_WRITE); if (f) { f.print(millis()/1000); f.print(","); f.print(t, 2); f.print(","); f.print(h, 2); f.print(","); f.println(alarme ? 1 : 0); f.close(); } } void loop() { if (millis() - tDerniereLecture < INTERVALLE) return; tDerniereLecture = millis(); float t = dht.readTemperature(); float h = dht.readHumidity(); if (isnan(t) || isnan(h)) { Serial.println("Erreur DHT11 !"); return; } bool alarme = (t > SEUIL_TEMP) || (h > SEUIL_HUMI); digitalWrite(LED_ROUGE, alarme); digitalWrite(LED_VERTE, !alarme); if (alarme) tone(BUZZER, 1500, 200); else noTone(BUZZER); mettreAJourLCD(t, h); sauvegarderSD(t, h, alarme); Serial.print("T="); Serial.print(t, 1); Serial.print(" H="); Serial.print(h, 1); Serial.println(alarme ? " ⚠️ ALARME" : " OK"); }
if (millis() - tDerniereLecture < INTERVALLE) return; est la clé du code non-bloquant. Rien ne bloque le loop(), donc d'autres capteurs ou boutons peuvent être lus entre les mesures.Quiz — 40 Questions
Du niveau débutant à expert — Arduino Uno, GPIO, ADC, DHT11, I2C, mémoire et optimisation. Chaque erreur est expliquée en détail.
analogRead(A0) sur Arduino Uno ?pinMode(7, OUTPUT) ?INPUT_PULLUP pour un bouton plutôt que INPUT ?delay(1000) et millis() ?Serial.begin(9600) ?map(val, 0, 1023, 0, 180) ?loop() sans être globale ?Wire.begin() sur Arduino Uno ?pulseIn(pin, HIGH) ?volatile devant une variable partagée avec une interruption ?analogWrite() sur D3 et D11 de l'Arduino Uno ?millis() après ~49 jours ?F() dans Serial.print(F("message")) ?EEPROM.write() et EEPROM.update() ?PROGMEM et dans quel cas est-il indispensable ?isnan() ?Serial.print() et Serial.println() ?Serial.print() ?oled.display() et pourquoi est-elle indispensable sur SSD1306 ?Mémo Rapide — Cheat Sheet Arduino
GPIO Digital
pinMode(pin, OUTPUT); pinMode(pin, INPUT_PULLUP); digitalWrite(pin, HIGH/LOW); int v = digitalRead(pin); // pull-up : repos=HIGH, appui=LOW // Max 40mA/broche, 200mA total
ADC & PWM
int v = analogRead(A0); // 0–1023 float V = v * 5.0 / 1023.0; int p = map(v,0,1023,0,100); // PWM sur ~ : 3,5,6,9,10,11 analogWrite(9, 0-255); // 490Hz (ou 980Hz D3/D11)
DHT11
#include "DHT.h" DHT dht(2, DHT11); dht.begin(); // Dans loop() : delay(2000); // min 1s ! float t = dht.readTemperature(); float h = dht.readHumidity(); if (isnan(t)) // vérifier !
I2C (Wire.h)
#include "Wire.h" Wire.begin(); // SDA=A4, SCL=A5 // Scanner I2C : Wire.beginTransmission(addr); byte e = Wire.endTransmission(); // e==0 → appareil trouvé // pull-up 4.7kΩ sur SDA et SCL
Millis non-bloquant
unsigned long t = 0; // Dans loop() : if (millis() - t >= 2000) { t = millis(); // action toutes les 2s } // Ne JAMAIS bloquer avec delay() // dans les projets avancés
EEPROM
#include "EEPROM.h" // 100 000 cycles max par adresse EEPROM.update(addr, val); // update = write si changé ! byte v = EEPROM.read(addr); float f; EEPROM.get(10, f); EEPROM.put(10, f); // Uno : 1024 octets (0–1023)
Serial debug
Serial.begin(9600); Serial.print(F("msg")); // Flash ! Serial.print(val, 2); // 2 déc. Serial.println(val); // + newline // F() garde la chaîne en Flash // → économise la SRAM de 2KB
Broches spéciales Uno
// D0/D1 : RX/TX (USB) — éviter // D2/D3 : INT0/INT1 interruptions // D3,5,6,9,10,11 : PWM ~ // D10-D13 : SPI SS/MOSI/MISO/SCK // D13 : LED_BUILTIN intégrée // A4/A5 : I2C SDA/SCL // A0–A5 : ADC (aussi GPIO digital)