GPIO et monde numérique ADC et PWM
Les niveaux logiques
| Numérique | Analogique | |
|---|---|---|
| Valeurs possibles | 2 (LOW / HIGH) |
continues, de 0 à 3,3 V |
| Fonction Arduino | digitalRead / digitalWrite |
analogRead (ADC) |
| Dans votre montage | les boutons | les axes du joystick |
Toute la séance tient dans ce tableau : d’abord le tout-ou-rien, ensuite le continu.
GPIO et monde numérique ADC et PWM
| Seuil | Valeur | Interprétation |
|---|---|---|
| $V_{IL}$ (LOW max) | ≤ 0,25 × VDD ≈ 0,8 V | lu comme LOW |
| Zone indéterminée | ~0,8 V à ~2,5 V | lecture imprévisible |
| $V_{IH}$ (HIGH min) | ≥ 0,75 × VDD ≈ 2,5 V | lu comme HIGH |
En sortie, la puce garantit à l’inverse des niveaux francs : proche de 0 V, ou proche de 3,3 V.
Cette zone grise au milieu explique tout ce qui suit sur les entrées flottantes. Retenez-la.
Une broche mise en sortie produit 3,3 V, pas 5 V comme sur un Arduino Uno. Et un signal 5 V appliqué en entrée peut endommager la puce. Avant de brancher un module trouvé dans un tiroir, cherchez sa tension d’alimentation.
GPIO et monde numérique ESP32-S3-DevKitC-1
Piloter une LED
pinMode(LED_PIN, OUTPUT); // la broche devient une sortie
digitalWrite(LED_PIN, HIGH); // 3,3 V : LED allumée
digitalWrite(LED_PIN, LOW); // 0 V : LED éteinte
GPIO veut dire General Purpose Input/Output : la même broche peut servir d’entrée ou de sortie, et c’est le logiciel qui décide, à l’exécution.
Derrière pinMode, un registre de configuration. Derrière digitalWrite, un registre de sortie.
GPIO et monde numérique Architecture d’un microcontrôleur
Une LED n’a quasiment pas de résistance propre : branchée seule, elle tire tout le courant que la broche peut fournir, et l’une des deux grille.
Pour une LED rouge ($V_f \approx 2$ V) à 10 mA : 150 Ω en valeur normalisée E12.
Courant maximal par broche : ~40 mA. En pratique, rester sous 12 mA. ↓ pour le calculateur en ligne.
12 mA
par broche, en pratique. Soit une LED correctement calibrée.
~40 mA
le maximum absolu de la datasheet. Au-delà, la broche est endommagée.
Pour piloter plus de courant (un moteur, un ruban de LED, un relais), la broche ne fournit pas la puissance : elle commande un transistor, qui lui la fournit.
Le mode par défaut d’OUTPUT. Deux transistors tirent activement la broche vers HIGH et vers LOW.
La broche ne peut que tirer vers LOW, ou relâcher. Indispensable sur un bus partagé comme l’I2C.
Deux composants en push-pull sur le même fil, l’un imposant 0 et l’autre 1 : c’est un court-circuit. L’open-drain règle ce problème, on le retrouvera au CM3 avec l’I2C.
GPIO et monde numérique Les bus de communication
Lire un bouton, vraiment
pinMode(BTN_PIN, INPUT);
void loop() {
if (digitalRead(BTN_PIN) == HIGH) Serial.println("Appui !");
}
Une broche en entrée non connectée est en haute impédance : presque aucun courant ne la traverse, et rien ne fixe sa tension.
Elle capte alors le bruit ambiant (un câble voisin, le secteur à 50 Hz, votre main qui s’approche) et sa lecture devient aléatoire. C’est l’état flottant.
Le symptôme est reconnaissable : le programme « détecte des appuis » que personne ne fait.
flowchart LR
A["INPUT<br/>sans rappel"] --> B["Haute impédance"]
B --> C{"Une tension<br/>est-elle imposée ?"}
C -->|"Non"| D["Flottant :<br/>lecture imprévisible"]
C -->|"Oui"| F["Niveau garanti<br/>au repos"]
graph LR
V33["3,3 V"] -->|"R 10 kΩ"| N(("GPIO"))
N -->|"Bouton"| GND["GND"]
Pressé → LOW
graph LR
GND["GND"] -->|"R 10 kΩ"| N(("GPIO"))
N -->|"Bouton"| V33["3,3 V"]
Pressé → HIGH
La résistance est là pour fixer un niveau au repos sans créer de court-circuit quand le bouton se ferme.
| Mode | Au repos | Câblage requis |
|---|---|---|
INPUT |
flottant | résistance externe |
INPUT_PULLUP |
HIGH, tiré en interne |
bouton vers GND |
INPUT_PULLDOWN |
LOW, tiré en interne |
bouton vers 3,3 V |
pinMode(BTN_PIN, INPUT_PULLUP); // pull-up interne (~45 kΩ)
bool presse = (digitalRead(BTN_PIN) == LOW); // logique inversée
La logique est inversée : LOW veut dire « pressé ».
GPIO et monde numérique Boutons, joystick et moniteur série
Les lamelles métalliques d’un bouton mécanique rebondissent pendant quelques millisecondes : une rafale de HIGH/LOW avant stabilisation, parfaitement visible à l’oscilloscope.
Un digitalRead() naïf compte alors plusieurs appuis là où vous n’en avez fait qu’un. Dans un menu de jeu, cela se traduit par une sélection qui saute deux lignes.
La parade : après un changement d’état, ignorer les lectures pendant 20 à 50 ms.
Un seul appui, et le signal bascule une dizaine de fois en moins de 2 ms. Photo : Tomoldbury, via Wikimedia Commons, domaine public.
const unsigned long ANTIREBOND = 30; // ms
int dernierEtat = HIGH; unsigned long dernierChangement = 0;
void loop() {
int etat = digitalRead(BTN_PIN); // INPUT_PULLUP : LOW = pressé
if (etat != dernierEtat) { // le signal vient de bouger
dernierChangement = millis();
dernierEtat = etat;
}
if (millis() - dernierChangement > ANTIREBOND && etat == LOW) {
// appui confirmé : stable depuis 30 ms
}
}
Même motif qu’au CM1 : comparer millis() à une date mémorisée.
Tant qu’il n’y a pas d’écran à rafraîchir, un delay(20) dans la fonction de lecture du bouton est acceptable, et beaucoup plus court à écrire. Dès qu’il faut dessiner à 60 images par seconde, il faut passer à la version millis() ci-dessus : retenez que c’est une solution provisoire, pas la bonne pratique.
Boutons, joystick et moniteur série
volatile bool drapeau = false;
void IRAM_ATTR surAppui() {
drapeau = true; // rien de plus
}
attachInterrupt(digitalPinToInterrupt(BTN_PIN), surAppui, FALLING);
Plus d’attente : la puce interrompt le CPU au changement de broche.
IRAM_ATTR sur l’ISR, volatile sur la variable partagée, et rien de plus.
La GPIO matrix route UART, SPI, I2C et PWM vers presque n’importe quelle broche. Sur un Arduino Uno, le SPI est câblé en dur.
Deux exceptions à connaître :
Vérifiez le brochage de la carte avant de câbler, pas après.
GPIO et monde numérique ESP32-S3-DevKitC-1
| Rôle | Broche | Mode |
|---|---|---|
| Bouton joueur 1 : HAUT | GPIO5 | INPUT_PULLUP |
| Bouton joueur 1 : BAS | GPIO6 | INPUT_PULLUP |
| Joystick joueur 2 : axe X | GPIO1 (ADC1) | analogRead |
| Joystick joueur 2 : axe Y | GPIO2 (ADC1) | analogRead |
| Bouton du joystick (START / RETRY) | GPIO7 | INPUT_PULLUP |
Ce câblage ne change plus jusqu’au projet : l’écran viendra s’y ajouter sur d’autres broches, sans rien défaire.
Boutons, joystick et moniteur série
Le sens inverse pose rarement problème : un 5 V lit un 3,3 V comme un HIGH.
L’ADC
Une température, une position de joystick, une luminosité produisent des tensions qui varient en continu entre 0 et 3,3 V. Le microcontrôleur, lui, ne manipule que des entiers.
Le convertisseur analogique-numérique (ADC) fait la traduction.
int valeur = analogRead(JOY_X); // 0 à 4095
Pas besoin de pinMode : analogRead() configure la broche lui-même.
| Position du stick | Tension | Valeur ADC |
|---|---|---|
| Butée gauche ou bas | 0 V | 0 |
| Centre, au repos | 1,65 V | ≈ 2048 |
| Butée droite ou haut | 3,3 V | 4095 |
L’ADC de l’ESP32 n’est pas parfaitement linéaire, surtout près des extrémités. Pour une mesure précise, analogReadMilliVolts() donne une tension calibrée ; pour un joystick, l’approximation suffit largement.
Sur ESP32, le bloc ADC2 partage du matériel avec la radio : dès que le Wi-Fi est actif, ses lectures échouent. Utilisez uniquement les broches ADC1, GPIO1 à GPIO10. Le symptôme est déroutant : le montage marche parfaitement pendant des semaines, jusqu’au jour où vous activez le Wi-Fi pour le projet.
ADC et PWM Boutons, joystick et moniteur série
Le montage du Pong
int x = analogRead(JOY_X);
int y = analogRead(JOY_Y);
bool btn = !digitalRead(JOY_BTN);
Deux axes lus par l’ADC, un bouton sous le stick en INPUT_PULLUP.
Cinq fils : VCC, GND, VRx, VRy, SW.
Boutons, joystick et moniteur série
enum Direction { CENTRE, HAUT, BAS, GAUCHE, DROITE };
Direction lireDirection() {
int x = analogRead(JOY_X), y = analogRead(JOY_Y);
if (x < 1500) return GAUCHE;
if (x > 2500) return DROITE;
if (y < 1500) return BAS;
if (y > 2500) return HAUT;
return CENTRE;
}
Le centre n’est jamais à 2048 : sans zone morte, la raquette dérive.
map()int lecture = analogRead(POT_PIN); // 0 à 4095
int angle = map(lecture, 0, 4095, 0, 180); // 0 à 180°
int pwm = map(lecture, 0, 4095, 0, 255); // 0 à 255
map() fait la règle de trois d’un coup, mais ne borne pas son résultat :
pwm = constrain(pwm, 0, 255);
Une lecture analogique bruite toujours un peu : deux analogRead() consécutifs sur un stick immobile ne rendent pas la même valeur.
long somme = 0;
for (int i = 0; i < 16; i++) somme += analogRead(PIN);
int lisse = somme / 16;
Seize lectures coûtent quelques dizaines de microsecondes : négligeable dans une boucle à 60 images par seconde, et l’affichage arrête de sautiller.
Le PWM
Un GPIO ne produit que 0 V ou 3,3 V. Et l’ESP32-S3 n’a pas de DAC matériel.
Comment régler une demi-luminosité, une vitesse de moteur, la position d’un servo ?
En alternant très vite.
Le PWM (Pulse Width Modulation) bascule entre HIGH et LOW à haute fréquence. La proportion de temps passée à HIGH est le rapport cyclique.
| Duty cycle | Effet perçu |
|---|---|
| 0 % | Toujours éteint |
| 50 % | Mi-luminosité |
| 100 % | Plein éclat |
À 1 à 50 kHz, ni l’œil ni un moteur ne perçoivent le clignotement : seulement la moyenne. ↓ pour le démonstrateur.
analogWrite(LED_PIN, 0); // éteint
analogWrite(LED_PIN, 128); // ~50 % : demi-luminosité
analogWrite(LED_PIN, 255); // plein éclat
Derrière, Arduino-ESP32 utilise le périphérique LEDC : 8 canaux matériels indépendants, fréquence et résolution configurables jusqu’à 16 bits.
Le CPU n’intervient pas. Une fois le canal réglé, le signal est généré par le matériel, même si la loop() est occupée ailleurs. C’est tout l’intérêt d’un périphérique dédié.
ADC et PWM Architecture d’un microcontrôleur
| Application | Principe |
|---|---|
| LED dimmable | Duty cycle proportionnel à la luminosité |
| Moteur à courant continu | Duty cycle proportionnel à la vitesse |
| Servomoteur | Impulsion de 1 à 2 ms toutes les 20 ms |
| Buzzer | La fréquence devient un ton |
Un servomoteur n’écoute pas le rapport cyclique mais la largeur de l’impulsion : c’est le même périphérique, lu autrement.
Pour chacun, dites quel type de broche et quelle fonction Arduino :
| Besoin | Broche | Fonction |
|---|---|---|
| Capot fermé | GPIO en INPUT_PULLUP |
digitalRead |
| Luminosité | broche ADC1 | analogRead |
| Vitesse d’un ventilateur | GPIO en PWM, via un transistor | analogWrite |
| Voyant de défaut | GPIO en OUTPUT + résistance |
digitalWrite |
Quatre lignes, et vous avez déjà couvert l’essentiel de ce que fait un microcontrôleur dans l’industrie.
GPIO et monde numérique ADC et PWM
LOW sous ~0,8 V, HIGH au-dessus de ~2,5 V, rien entre les deuxINPUT_PULLUP, logique inverséemap() change d’échelle, constrain() borne le résultatanalogWrite(pin, 0..255)GPIO et monde numérique ADC et PWM
INPUT_PULLUP, bouton vers GND, logique inverséeCes quatre réflexes couvrent la quasi-totalité des bugs de câblage et de lecture d’entrées.
GPIO et monde numérique ADC et PWM Boutons, joystick et moniteur série
