🔍 Interface Principale

Voici l'écran que tu utiliseras tout le temps. C'est ici qu'on écrit le code, qu'on l'envoie à la carte et qu'on écoute ce qu'elle nous répond.

1

2

3

4

5

6

• ✔ Vérifier (V)
  En haut à gauche. Il vérifie que ton code ne contient pas de fautes d'orthographe (erreurs de syntaxe). Il ne l'envoie pas à la carte.
• ➡ Téléverser (=>)
  Juste à côté. Il vérifie le code et l'inscrit dans la mémoire de l'Arduino. Dès que c'est fini, l'Arduino lance ton programme.
• 📋 Carte & Port
  Le menu déroulant en haut. Crucial ! Si tu branches une Nano mais que le logiciel s'attend à une Uno, le téléversement plantera. Tu dois dire au logiciel "je parle à une Uno sur le port USB 3".
• 📚 Librairies
  L'icône "livres" dans la barre de gauche. Certaines pièces (comme l'écran LCD, servo moteur ou capteur de température) sont trop complexes à utiliser de zéro. Une librairie est un morceau de code pré-écrit par quelqu'un d'autre qui simplifie le travail. Ex: au lieu d'écrire 50 lignes de code électrique, tu importes `Servo.h` et tu écris juste `monServo.write(90)`.
• 🔍 Moniteur Série
  L'icône loupe en haut à droite. Il ouvre le panneau du bas. C'est le "chat" entre toi et l'Arduino ! Si ton code contient Serial.println("Hello");, c'est ici que tu le liras. Si tu veux écrire un message (comme "start" pour un chronomètre), tu tapes ici.
• ⚡ Baudrate
  En bas à droite du Moniteur Série ("115200 baud"). C'est la vitesse de communication. Si l'Arduino parle à 115200 et que ton moniteur écoute à 9600, tu liras des caractères incompréhensibles (`⸮⸮⸮`). Ils doivent être à la même vitesse !

🔌 Les Broches (Pins) de l'Arduino

Le code te permet de contrôler les "pattes" électriques (qu'on appelle Pins) de la carte Arduino. Il en existe deux grandes familles :

💡 Astuces rapides avant de commencer

La Breadboard (Platine d'essai)

La breadboard te permet de relier des composants sans faire de soudure. Voici comment elle fonctionne :

• Les lignes numérotées au centre : Tous les trous d'une même ligne horizontale (ex: la ligne 10) sont reliés entre eux électriquement sous le plastique. Si tu branches deux fils sur la ligne 10, le courant passe de l'un à l'autre.
• Les rails d'alimentation verticaux (+ et -) : Sur les côtés, tu as de longues lignes rouges (+) et bleues ou noires (-). Tous les trous de cette ligne verticale sont connectés ensemble. On y relie généralement le 5V (sur le rouge) et le GND (sur le bleu) venant de l'Arduino. Cela te permet d'avoir plein de trous disponibles pour alimenter tous tes composants !

🎨 Lire la valeur d'une résistance

Les résistances sont souvent trop petites pour qu'on y écrive des nombres. On utilise donc un code couleur !

• Les premiers anneaux (généralement 2 ou 3) donnent les chiffres significatifs.
• L'avant-dernier anneau est le multiplicateur (combien de zéros on rajoute).
• Le dernier anneau (souvent espacé et de couleur or ou argent) indique la tolérance (la précision).

Exemple pour notre résistance de 220Ω : Rouge (2) - Rouge (2) - Marron (×10)

➔ 22 × 10 = 220 Ohms !

💡 Anatomie d'une LED — C'est dans quel sens ?

Une LED est polarisée : elle a un sens ! Si tu la branches à l'envers, rien ne s'allume (et c'est OK). Mais il faut savoir identifier les deux pattes.

• + long
  Anode (patte longue) — branche vers le courant positif. Se connecte via une résistance au pin de la carte Arduino (ex: pin 13).
• - court
  Cathode (patte courte) — branche vers le 0V. Se connecte directement au GND de la carte.
• méplat
  Le corps de la LED a aussi une face plate du côté cathode — utile si les pattes sont coupées à la même longueur.

🌍 Pourquoi le GND est crucial ?

Le GND (Ground = masse) est le point de référence à 0 Volt. Pour qu'un courant circule, il faut une différence de tension entre deux points — le + et le GND.

Si Arduino et une autre carte (comme Godot via USB/adaptateur) n'ont pas le même GND, les signaux UART ne fonctionnent pas : les 0 et 1 électriques ne sont pas mesurés depuis la même référence.

Règle d'or : tous les composants d'un même circuit doivent partager le GND commun.

🚀 Ton premier code — Allumer la LED

Une fois le montage réalisé, téléverse ce code sur ta carte Arduino pour allumer la LED, puis modifie le delay pour la faire clignoter !

const int LED_PIN = 13; // Broche de la LED

void setup() {
  // Configure la broche en mode SORTIE
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH); // Allume (5V)
  delay(500); // Attend 500 ms
  digitalWrite(LED_PIN, LOW); // Eteint (0V)
  delay(500); // Attend 500 ms
}

💡 Défi : Change les valeurs de delay() pour faire clignoter la LED très vite, puis très lentement. Que remarques-tu ?

🌍 Le Courant dans la vie de tous les jours

Prenons l'exemple d'un chargeur de téléphone ou de l'alimentation d'un PC :

🔘 Comment brancher un bouton poussoir ?

Un bouton standard a 4 pattes. Les deux qui se font face (courbées l'une vers l'autre) sont toujours reliées électriquement. Les deux sur le même bord plat ne sont pas reliées au repos — c'est l'appui qui crée ce pont.

En bas à droite de l'image (sur le schéma électrique) on distingue que les pins 1–2 et les pins 3–4 sont reliés. On peut observer le sigle de l'interrupteur entre 1–2 et 3–4. Lors d'un appui, les 4 pins sont connectés (voir en bas à gauche à quel pin correspond quel numéro).

🟡 Côté Arduino (pin 2) Prends une des 2 pattes qui se font face sur un côté du bouton → branche sur le pin 2. Ces deux pattes sont identiques électriquement.

🟢 Côté GND Prends une patte de l'autre paire (de l'autre côté) → branche sur GND. Avec INPUT_PULLUP, pas besoin de résistance externe.

🚀 À toi de coder : Contrôler la LED

Une fois ta LED reliée à pin 13 et ton bouton à pin 2, téléverse ce code :

const int LED = 13;
const int BTN = 2;

void setup() {
  pinMode(LED, OUTPUT);
  pinMode(BTN, INPUT_PULLUP); // Active la résistance interne
}

void loop() {
  int etat = digitalRead(BTN);
  if (etat == LOW) { // LOW = bouton appuyé (avec INPUT_PULLUP)
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }
}

🎮 Utiliser le projet test-communication-arduino

Maintenant que l'Arduino sait recevoir des commandes via UART, on peut créer une interface riche avec Godot ! Tu trouveras le projet test-communication-arduino dans tes fichiers.

🏆 Challenges Godot-Arduino

🔴 Avec delay() — Simple mais bloquant

Ce code fonctionne pour une seule LED. Mais dès que tu ajoutes une 2ème tâche, tu ne peux plus — le programme est gelé pendant chaque delay().

const int LED = 13;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(500); // ← TOUT le programme stop ici !
  digitalWrite(LED, LOW);
  delay(500); // ← Et ici aussi...
  // Impossible de lire le port série pendant ce temps !
}

🟢 Avec millis() — Non-bloquant et multitâche

millis() retourne le nombre de millisecondes écoulées depuis le démarrage. Au lieu d'attendre, on vérifie régulièrement si assez de temps s'est écoulé. La boucle ne s'arrête jamais !

const int LED_R = 13;
const int LED_J = 12;

unsigned long dernierR = 0; // heure du dernier flash rouge
unsigned long dernierJ = 0; // heure du dernier flash jaune

void setup() {
  Serial.begin(115200);
  pinMode(LED_R, OUTPUT);
  pinMode(LED_J, OUTPUT);
}

void loop() {
  unsigned long now = millis();

  if (now - dernierR >= 500) { // 500ms écoulées ?
    dernierR = now;
    digitalWrite(LED_R, !digitalRead(LED_R));
  }

  if (now - dernierJ >= 1200) { // 1200ms écoulées ?
    dernierJ = now;
    digitalWrite(LED_J, !digitalRead(LED_J));
  }
  // La boucle continue à tourner — rien n'est bloqué !
}

👨‍🍳 L'analogie du chef cuisinier

Imagine un cœur comme un chef cuisinier. Il ne peut faire qu'une chose à la fois — mais il le fait à une vitesse insensée !

La fréquence d'horloge (en MHz) est la vitesse du chef. À 16 MHz, il fait 16 millions d'actions par seconde. À 240 MHz, il en fait 240 millions.

Avec 2 cœurs (comme l'ESP32), c'est comme avoir 2 chefs qui cuisinent en parallèle. Certaines tâches comme l'affichage et la communication peuvent se faire vraiment en même temps.

⏱️ Combien de temps coûte une instruction ?

Sur Arduino Nano à 16 MHz : 1 cycle = 62.5 nanosecondes. Allumer une LED coûte environ 3 cycles = 187 ns. Sur ESP32 à 240 MHz : 1 cycle = 4.2 ns, soit 15× plus rapide !

🔬 Benchmark : mesure toi-même la vitesse

Ce code mesure combien de temps l'Arduino met à toggler une LED 10 000 fois. Essaie sur ta carte Arduino et observe un temps d'exécution similaire à la théorie dans le moniteur série !

🎮 Contrôle l'angle du servo

Déplace le curseur pour changer l'angle. Observe comment le signal PWM change en dessous — c'est exactement ce qu'Arduino envoie au servo !

📊 Comment fonctionne le PWM ?

Le PWM (Pulse Width Modulation) envoie un signal qui passe très rapidement de 0V à 5V. La durée à l'état HAUT (pulse) détermine l'angle du servo.

Le servo attend un signal toutes les 20 ms (50 Hz). La largeur de l'impulsion lui dit où se positionner :

🔌 Branchement & code de base

Le SG90 a 3 fils : Rouge = 5V, Marron = GND, Orange = Signal (pin PWM). Sur Arduino, les pins PWM sont marqués ~ (3, 5, 6, 9, 10, 11).

// Bibliothèque servo (incluse dans Arduino IDE)
#include <Servo.h>

Servo monServo;

void setup() {
  monServo.attach(9); // Signal sur pin 9
}

void loop() {
  monServo.write(0);   // 0° : tout à gauche
  delay(1000);
  monServo.write(90);  // 90° : centre
  delay(1000);
  monServo.write(180); // 180° : tout à droite
  delay(1000);
}