abonnel-www/a9474a83-43b3-484c-950e-37a27ff663fe/index.md

# Game & Watch DIY — Du prototype à la console fabriquée

> Guide d'atelier pour concevoir une mini-console portable type *Game & Watch*, du prototypage sur Arduino Uno jusqu'à la gravure du PCB sur fraiseuse CNC. Document orienté reproduction en fablab.

## 1. Vue d'ensemble du projet

### 1.1 Objectif

Fabriquer une mini-console portable inspirée des *Game & Watch* Nintendo des années 1980. Le jeu retenu est un arcade de type *Asteroids* : un vaisseau qui tire sur des ennemis arrivant par la droite, affiché sur un écran LCD 16×2 caractères.

### 1.2 Démarche

Le projet se déroule en deux ateliers principaux :

1. **Atelier 1 — Prototype et schématisation.** Câblage sur platine d'expérimentation (*breadboard*), validation du code, puis transposition du schéma sous KiCad.
2. **Atelier 2 — Fabrication.** Routage du PCB, export des fichiers, gravure CNC, soudure, mise en boîtier.

### 1.3 Versions des logiciels utilisés

| Logiciel | Version de référence | Rôle |
|---|---|---|
| Arduino IDE | 2.x | Programmation du microcontrôleur |
| KiCad | 9.0 | Conception du schéma et du PCB |
| FlatCAM | 8.994 bêta | Conversion Gerber → SVG |
| Inkscape | 1.3 | Retouche optionnelle des SVG |
| Easel | en ligne | Pilotage de la fraiseuse CNC |

> ⚠️ Les menus et raccourcis peuvent légèrement différer sur d'autres versions. Les noms de menus sont donnés ici tels qu'ils apparaissent dans les versions ci-dessus.

---

## 2. Sécurité et préparation de l'atelier

### 2.1 Sécurité usinage CNC

La gravure de PCB produit des **poussières de FR4** (résine époxy + fibre de verre) irritantes pour la peau, les yeux et les voies respiratoires.

- **Lunettes de protection** obligatoires pendant l'usinage.
- **Aspiration** des copeaux à proximité de la fraise (aspirateur dédié ou bras d'aspiration de la CNC).
- **Masque FFP2** recommandé en cas d'absence d'aspiration efficace.
- Ne **pas souffler** sur la plaque : utiliser un pinceau pour évacuer les résidus.
- Vérifier que la fraise est correctement serrée dans le mandrin **avant chaque cycle**.
- Ne jamais passer la main dans la zone d'usinage lorsque la broche est en rotation.

### 2.2 Sécurité soudure

- Fer à souder à 350 °C maximum.
- Aération de la pièce ou aspirateur de fumées (la rosine de la soudure est irritante).
- Repose-fer stable, éponge humide ou laine de cuivre.
- Se laver les mains après la soudure (plomb dans certaines soudures encore disponibles).

### 2.3 Liste de matériel par poste

**Matériel électronique** (par participant) :

| Quantité | Désignation | Référence indicative |
|---|---|---|
| 1 | Arduino Uno R3 | A000066 |
| 1 | Écran LCD 16×2, contrôleur HD44780, interface parallèle 16 broches | 1602A standard |
| 3 | Boutons-poussoirs tactiles 6×6 mm, 4 broches, traversants | TC-1212T-AGB |
| 1 | Buzzer piézoélectrique passif Ø 12 mm | TDK PS1240 ou équivalent |
| 1 | Potentiomètre 10 kΩ ajustable horizontal | Bourns 3296W |
| 1 | Résistance 220 Ω, 1/4 W (rétroéclairage LCD) | — |
| 1 | Coupleur pour pile 9 V avec cosse à souder | — |
| 1 | Pile alcaline 9 V | — |
| 1 | Plaque PCB cuivrée simple face FR4, 1,4 mm, ≥ 70×100 mm | — |

**Outillage commun :** platine d'expérimentation, fils Dupont mâle-mâle, fer à souder, étain, pince coupante, multimètre.

---

## 3. Prototypage sur Arduino

### 3.1 Câblage du prototype

Le câblage du prototype suit la disposition classique d'un LCD HD44780 en mode 4 bits. Ce brochage **diffère volontairement** du brochage final retenu pour le PCB (voir §6.4) : le prototype privilégie la lisibilité des fils, le PCB privilégie la facilité de routage.

#### Écran LCD (mode 4 bits, prototype)

| Broche LCD | Repère | Connexion |
|---|---|---|
| 1 | VSS | GND |
| 2 | VDD | +5 V |
| 3 | V0 | Curseur du potentiomètre 10 kΩ (extrémités sur +5 V et GND) |
| 4 | RS | D12 de l'Arduino |
| 5 | R/W | GND (le LCD est utilisé uniquement en écriture) |
| 6 | E | D11 |
| 11 | D4 | D5 |
| 12 | D5 | D4 |
| 13 | D6 | D3 |
| 14 | D7 | D2 |
| 15 | A (anode rétroéclairage) | +5 V via résistance 220 Ω |
| 16 | K (cathode rétroéclairage) | GND |

> 💡 Une variante sans potentiomètre (V0 directement à la masse) a été testée et abandonnée : le contraste est trop sombre et illisible selon l'angle de vue.

#### Boutons-poussoirs

Câblage en pull-up interne. Une borne du bouton va à la masse, l'autre à la broche numérique. La résistance de tirage est activée par logiciel via `INPUT_PULLUP`. Lorsque le bouton est relâché, la broche lit `HIGH` ; pressée, elle lit `LOW`.

| Bouton | Broche Arduino |
|---|---|
| Tir | D7 |
| Haut | D8 |
| Bas | D9 |

Pour comprendre le principe du montage pull-up : <https://www.locoduino.org/spip.php?article122>.

#### Buzzer passif

Une broche à la masse, l'autre sur D6. La broche D6 ne « alimente » pas le buzzer en continu : la fonction `tone()` y génère un signal carré dont la fréquence détermine la hauteur du son.

### 3.2 Code du prototype

Ce code correspond au **câblage de prototypage ci-dessus**. Le brochage utilisé sur le PCB final est différent : la version du code adaptée au PCB est fournie en §6.5.

```cpp
#include <LiquidCrystal.h>

// ---- Brochage prototype ----
// LiquidCrystal(rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int PIN_BUZZER  = 6;
const int boutonTir   = 7;
const int boutonHaut  = 8;
const int boutonBas   = 9;

// ---- Sons ----
inline void beepShoot() { tone(PIN_BUZZER, 2000, 40);  } // tir : court et aigu
inline void beepHit()   { tone(PIN_BUZZER, 1200, 80);  } // impact : moyen
inline void beepOver()  { tone(PIN_BUZZER,  400, 600); } // game over : long et grave

// ---- Sprites 5x8 pixels ----
byte CH_VAISSEAU[8] = {
  B00100, B01110, B11111, B11111, B01110, B00100, B00100, B00000
};
byte CH_MISSILE[8] = {
  B00100, B00100, B00100, B11111, B00100, B00100, B00100, B00000
};
byte CH_ENNEMI[8] = {
  B11111, B10101, B11111, B01010, B11111, B10101, B11111, B00000
};

// ---- État du jeu ----
int vaisseauLigne = 1; // 0 (haut) ou 1 (bas)

struct Ennemi { int colonne; int ligne; bool actif; };
const int MAX_ENNEMIS = 3;
Ennemi ennemis[MAX_ENNEMIS];

struct Projectile { int colonne; int ligne; bool actif; };
const int MAX_TIRS = 6;
Projectile tirs[MAX_TIRS];

unsigned long dernierDeplacement = 0;
unsigned long intervalDeplacement = 500;

unsigned long dernierTir = 0;
const unsigned long delaiTir = 180;

int score = 0;

// ---- Setup ----
void setup() {
  pinMode(boutonTir,  INPUT_PULLUP);
  pinMode(boutonHaut, INPUT_PULLUP);
  pinMode(boutonBas,  INPUT_PULLUP);
  pinMode(PIN_BUZZER, OUTPUT);

  lcd.begin(16, 2);
  lcd.createChar(0, CH_VAISSEAU);
  lcd.createChar(1, CH_MISSILE);
  lcd.createChar(2, CH_ENNEMI);
  lcd.print("Vaisseau Pret!");
  delay(600);
  lcd.clear();

  // Entropie : on utilise une broche analogique laissée FLOTTANTE.
  // A5 n'est pas utilisée par le jeu ; sa lecture varie au gré du bruit ambiant.
  randomSeed(analogRead(A5));

  for (int i = 0; i < MAX_ENNEMIS; i++) ennemis[i].actif = false;
  for (int i = 0; i < MAX_TIRS;    i++) tirs[i].actif    = false;
}

// ---- Boucle principale ----
void loop() {
  unsigned long now = millis();

  // Déplacement du vaisseau
  if      (digitalRead(boutonHaut) == LOW) vaisseauLigne = 0;
  else if (digitalRead(boutonBas)  == LOW) vaisseauLigne = 1;

  // Tir
  if (digitalRead(boutonTir) == LOW && now - dernierTir >= delaiTir) {
    int idx = slotTirLibre();
    if (idx >= 0) {
      tirs[idx].actif   = true;
      tirs[idx].colonne = 1;
      tirs[idx].ligne   = vaisseauLigne;
      dernierTir = now;
      beepShoot();
    }
  }

  // Mise à jour périodique
  if (now - dernierDeplacement > intervalDeplacement) {
    dernierDeplacement = now;

    // Avancée des tirs
    for (int t = 0; t < MAX_TIRS; t++) {
      if (!tirs[t].actif) continue;
      tirs[t].colonne++;
      if (tirs[t].colonne > 15) tirs[t].actif = false;
    }

    // Avancée des ennemis et collisions
    for (int i = 0; i < MAX_ENNEMIS; i++) {
      if (!ennemis[i].actif) continue;
      ennemis[i].colonne--;

      for (int t = 0; t < MAX_TIRS; t++) {
        if (!tirs[t].actif) continue;
        if (ennemis[i].colonne == tirs[t].colonne
            && ennemis[i].ligne == tirs[t].ligne) {
          ennemis[i].actif = false;
          tirs[t].actif    = false;
          score++;
          beepHit();
          break;
        }
      }

      if (ennemis[i].colonne <= 0) {
        beepOver();
        gameOver();
      }
    }

    // Apparition d'ennemis
    int actifs = 0;
    for (int i = 0; i < MAX_ENNEMIS; i++) if (ennemis[i].actif) actifs++;
    if (actifs < MAX_ENNEMIS && random(0, 10) > 7) {
      for (int i = 0; i < MAX_ENNEMIS; i++) if (!ennemis[i].actif) {
        ennemis[i].actif   = true;
        ennemis[i].colonne = 15;
        ennemis[i].ligne   = random(0, 2);
        break;
      }
    }

    updateLCD();
  }
}

// ---- Utilitaires ----
int slotTirLibre() {
  for (int i = 0; i < MAX_TIRS; i++) if (!tirs[i].actif) return i;
  return -1;
}

static inline void printIfOnScreen(int col, int row, uint8_t ch) {
  if (col >= 0 && col <= 15 && row >= 0 && row <= 1) {
    lcd.setCursor(col, row);
    lcd.write(ch);
  }
}

void updateLCD() {
  lcd.clear();
  lcd.setCursor(10, 0); lcd.print("S:"); lcd.print(score);

  printIfOnScreen(0, vaisseauLigne, 0);

  for (int t = 0; t < MAX_TIRS; t++) {
    if (!tirs[t].actif) continue;
    if (tirs[t].colonne >= 0 && tirs[t].colonne <= 15) {
      lcd.setCursor(tirs[t].colonne, tirs[t].ligne);
      lcd.write((uint8_t)1);
    }
  }

  for (int i = 0; i < MAX_ENNEMIS; i++) {
    if (!ennemis[i].actif) continue;
    if (ennemis[i].colonne >= 0 && ennemis[i].colonne <= 15) {
      lcd.setCursor(ennemis[i].colonne, ennemis[i].ligne);
      lcd.write((uint8_t)2);
    }
  }
}

void gameOver() {
  lcd.clear();
  lcd.setCursor(3, 0); lcd.print("GAME OVER");
  lcd.setCursor(4, 1); lcd.print("Score:"); lcd.print(score);
  // Boucle infinie : la console ne peut redémarrer qu'avec le bouton RESET
  // (sur Arduino, ou bouton dédié sur le PCB final).
  while (true) {}
}
```

### 3.3 Validation du prototype

Avant de passer à la conception du PCB, **valider chaque sous-ensemble** :

1. LCD seul : afficher `"Vaisseau Pret!"` puis effacer.
2. LCD + un bouton : afficher l'état du bouton.
3. LCD + buzzer : émettre un son au démarrage.
4. Jeu complet sur breadboard.

Cette progression évite de chercher un bug dans un câblage de quinze fils alors qu'il provient d'un seul.

---

## 4. Règles de conception du PCB

Cette section résume les règles applicables à **ce projet** (PCB simple face, gravure CNC, signaux lents). Les règles non applicables (USB différentiel, dissipation thermique de puissance, etc.) sont rassemblées en annexe §11.2 pour vos prochains projets.

### 4.1 Type de fabrication

- **PCB simple face** : une seule couche cuivre, sur la face inférieure.
- Les composants traversants sont insérés depuis la face supérieure ; leurs broches sortent côté cuivre et y sont soudées.
- Dans KiCad, le routage se fait donc exclusivement sur la couche `B.Cu`.

> 💡 Conséquence importante : ce qu'on voit dans KiCad côté `B.Cu` est l'image **miroir** de ce qu'on verra en regardant le dessus de la carte finie. Cela impose une étape de symétrie au moment de l'usinage (voir §7.5).

### 4.2 Familles de composants

- **THT** (*Through-Hole Technology*) : composants traversants. Faciles à souder, robustes, recommandés pour ce projet.
- **CMS / SMD** (*Composants Montés en Surface / Surface Mount Device*) : composants posés sur la face cuivre, sans perçage. Hors-périmètre ici.

### 4.3 Outils de vérification dans KiCad

- **ERC** (*Electrical Rule Check*) : vérifie la cohérence électrique du **schéma** (broches non connectées, sorties en conflit, etc.).
- **DRC** (*Design Rule Check*) : vérifie le respect des **règles physiques** du PCB (espacements, largeurs minimales, recouvrements).

Lancer l'ERC après la schématisation, le DRC après le routage. **Ne jamais ignorer une erreur sans l'avoir comprise.**

### 4.4 Broches non connectées

Une broche d'entrée logique laissée flottante (ni à `VCC`, ni à `GND`, ni reliée à un signal) capte le bruit ambiant et peut commuter aléatoirement. Sur le schéma KiCad, les broches volontairement non utilisées doivent être marquées avec un **indicateur de non-connexion** (symbole `X` bleu, raccourci `Q`). Cela indique à l'ERC qu'il s'agit d'un choix délibéré.

Sur ce projet : marquer ainsi toutes les broches de l'Arduino qu'on n'utilise pas (les broches restantes du connecteur après réaffectation, broches AREF, ICSP non utilisé, etc.).

### 4.5 Angles des pistes

Privilégier des angles à **45°** plutôt qu'à 90°. Sur ce projet (signaux lents), l'enjeu n'est pas la haute fréquence mais la **qualité de gravure** : un angle à 90° côté intérieur peut accumuler du résidu de fraisage et créer un point faible.

### 4.6 Routage soigné

- Trajets courts et directs.
- Éviter les boucles inutiles.
- Conserver une proximité avec la masse pour le retour de courant.
- Largeur de piste **0,4 mm** par défaut pour les signaux, **0,8 mm** pour `VCC` et `GND` (ce projet ne consomme pas plus de 100 mA).

### 4.7 Plan de masse

Sur un PCB gravé à la CNC, le **plan de masse vient naturellement** : tout le cuivre non gravé reste connecté. Dans KiCad, on définit une **zone cuivrée** (`Add filled zone`) sur `B.Cu`, affectée au réseau `GND`, couvrant tout le contour de la carte. Au moment de la génération des fichiers, la zone est « remplie » (raccourci `B`).

### 4.8 Découplage

Sur ce projet, l'Arduino Uno embarque déjà ses propres condensateurs de découplage. Aucun condensateur supplémentaire n'est nécessaire sur le shield. Pour un PCB autonome avec un ATmega328P nu, prévoir un condensateur 100 nF entre `VCC` et `GND` au plus près du microcontrôleur.

### 4.9 Pas standard 2,54 mm

L'Arduino, les barrettes de connecteurs, le LCD et les boutons traversants partagent tous le **pas standard 2,54 mm** (1/10 de pouce). Toutes les empreintes du projet doivent respecter ce pas, sinon les composants ne s'enfichent pas.

> ⚠️ Ne pas confondre **pas** (entraxe entre broches du composant) et **clearance** (distance d'isolation piste/pad). Le pas est imposé par le composant, la clearance est un paramètre de routage (voir §7.2).

---

## 5. Conception sous KiCad

### 5.1 Créer le projet

Deux possibilités :

- **Projet vierge** : *Fichier → Nouveau projet*.
- **Projet « Arduino UNO Shield »** : *Fichier → Nouveau projet à partir d'un modèle → Arduino UNO Shield*. Ce modèle contient déjà le contour de la carte, les connecteurs et l'attribution des broches Arduino.

Enregistrer dans un dossier dédié (par exemple `gameNwatch/`). Le projet contient deux fichiers principaux :

| Fichier | Rôle |
|---|---|
| `*.kicad_sch` | Schéma électrique |
| `*.kicad_pcb` | Routage du circuit imprimé |

### 5.2 Ajouter des composants au schéma

1. Ouvrir le fichier `.kicad_sch`.
2. Outil **Ajouter un symbole** (raccourci `A`).
3. Saisir le nom du composant **en anglais** : `LED`, `Resistor`, `Buzzer`, `Switch_Push`, `Conn_01x16` (pour un connecteur 16 broches), etc.
4. Sélectionner le composant ; son symbole apparaît dans le volet de droite.
5. **Empreinte** : via *Footprint Library Browser*, choisir l'empreinte physique correspondant au composant réel (dimensions, type de boîtier).

> **Empreinte** : représentation physique du composant sur le PCB — emplacement des pastilles, taille des perçages, contour de sérigraphie.

Si l'empreinte n'est pas trouvée immédiatement, ce n'est pas grave : elle pourra être attribuée plus tard.

### 5.3 Attribuer les empreintes a posteriori

Bouton **Assigner des empreintes** (icône en haut). Une fenêtre liste tous les composants. On peut alors :

- modifier les empreintes déjà attribuées,
- en attribuer aux composants qui n'en ont pas.

En cas de doute : *clic droit sur l'empreinte → Afficher l'empreinte sélectionnée* pour vérifier visuellement la cohérence (taille des pads, pas, contour).

Si un composant n'existe dans aucune bibliothèque, il est possible de **créer une empreinte personnalisée** depuis l'éditeur d'empreintes.

### 5.4 Câbler le schéma

Dans l'éditeur de schéma, raccourcis utiles :

| Touche | Action |
|---|---|
| `A` | Ajouter un symbole |
| `M` | Déplacer (*Move*) |
| `R` | Pivoter (*Rotate*) |
| `Ctrl+D` | Dupliquer |
| `W` | Ajouter un fil (*Wire*) |
| `Q` | Ajouter un indicateur de non-connexion |
| `L` | Ajouter un label (étiquette de réseau) |

**Astuce labels.** Plutôt que de tirer un fil physique de chaque bouton jusqu'à l'Arduino, attribuer un **label** (`L`) à chaque signal (`BTN_TIR`, `LCD_E`, etc.) et un label identique côté Arduino. KiCad considère les deux extrémités comme reliées. Le schéma reste lisible même avec 25 connexions.

**Astuce GND.** Les broches `GND` de l'Arduino ne sont pas pré-reliées dans le symbole KiCad. Utiliser le symbole **GND** (depuis la bibliothèque *power*) sur chaque broche de masse plutôt que de tirer des fils entre elles.

### 5.5 Annoter et vérifier

- **Annotation de la schématique** : renomme automatiquement les composants (`R?` → `R1`, `R2`...). Indispensable avant de passer au PCB.
- **ERC** : lance le contrôle de cohérence électrique. Corriger toutes les erreurs.

### 5.6 Passer à l'éditeur de PCB

Une fois le schéma validé, sauvegarder puis **Commuter vers l'éditeur de PCB** (icône en haut).

L'éditeur ouvre un PCB vide. Pour y importer les composants du schéma : *Outils → Mettre à jour le PCB depuis le schéma* (raccourci `F8`).

Les composants apparaissent reliés par des **chevelus** (en anglais *ratsnest*) — des fils virtuels qui indiquent les connexions à réaliser. C'est à partir de là que commence le routage proprement dit.

### 5.7 Paramétrer les contraintes

Avant de tracer la moindre piste, paramétrer les contraintes adaptées à la gravure CNC : *Fichier → Configurer les règles → Contraintes*.

| Paramètre | Valeur | Justification |
|---|---|---|
| Largeur de piste minimale | 0,4 mm | Compatible avec une V-bit 30° |
| Largeur de piste par défaut (signaux) | 0,4 mm | — |
| Largeur de piste alimentation | 0,8 mm | Courant pile 9 V via Vin |
| Clearance (isolation) | 0,3 mm | Marge pour la passe d'isolation CNC |
| Taille de pad par défaut | 1,6 mm | Pad confortable, lisible |
| Diamètre de perçage | 0,8 mm | Compatible fraise 1/32" (0,79 mm) |

> 💡 La **clearance** (espace minimal entre deux conducteurs) est ce qui détermine la largeur du tracé d'isolation de la fraise V-bit lors de la gravure. Une clearance plus large = une fraise qui peut être plus profonde = des pistes plus nettes mais une carte plus grande.

### 5.8 Router le PCB

Outil **Ajouter une piste** (raccourci `X`).

Lorsqu'on clique sur une broche source, l'écran s'assombrit et seules les broches électriquement reliées restent éclairées : cela aide à identifier la cible.

- **Trait rouge** : la piste tracée.
- **Contour gris** : la zone d'isolation minimum (clearance) — KiCad la maintient automatiquement.

**Choix de la couche** : sélectionner la couche dans la liste de droite **avant** de tracer.

| Couche | Usage |
|---|---|
| `F.Cu` *(front)* | Cuivre côté composants — non utilisé sur ce projet simple face |
| `B.Cu` *(back)* | Cuivre côté soudure — **toutes les pistes ici** |
| `Edge.Cuts` | Contour mécanique de la carte |

> ⚠️ **Pourquoi `B.Cu` et pas `F.Cu` ?** Sur une CNC, on grave une plaque pré-cuivrée d'un seul côté. Le cuivre est posé là où sortent les pattes des composants, donc côté **opposé** au côté d'insertion. Si on route sur `F.Cu`, on n'a aucun moyen de souder ensuite : les pattes ne touchent rien.

Vérifier le rendu via *Affichage → Visualisation 3D*. Cela révèle immédiatement les empreintes oubliées ou mal orientées.

---

## 6. Application au projet : du schéma au PCB final

### 6.1 Méthode itérative

Le routage d'un PCB est un **processus itératif** : on réorganise plusieurs fois le schéma et la disposition avant d'arriver à un tracé satisfaisant.

```
┌─────────────────────────────────────────────────────────────┐
│  1. Lister les composants                                   │
│  2. Choisir form factor, faces, alimentation                │
│  3. Tester l'implantation physique (papier ou breadboard)   │
│  4. Saisir le schéma sous KiCad                             │
│  5. Router le PCB                                           │
│     └─ Si impasse : revenir à 4 (réaffecter des broches)    │
│  6. Adapter le code aux nouvelles broches                   │
│  7. Re-prototyper si possible                               │
│  8. Exporter Gerber + Excellon                              │
└─────────────────────────────────────────────────────────────┘
```

### 6.2 Choix d'implantation

#### Équipements et positionnement

| Élément | Position | Remarque |
|---|---|---|
| Shield Arduino custom | Forme **non-standard** | Déborde au-delà du form factor Uno |
| Écran LCD 16×2 | Centré, déborde de 8 mm vers le haut | Broches à ≥ 4 mm du bord |
| Pile 9 V | Connectée sur `Vin` via cosse à souder | À droite des broches du LCD |
| Interrupteur d'alimentation | Sur le fil + de la pile (hors PCB) | Anticipé pour le boîtier |
| Potentiomètre de contraste | Sous le LCD | Caché, réglé une fois pour toutes |
| Port USB de l'Arduino | Accessible par découpe | Pour reprogrammation |
| Bouton Reset | Bouton dédié sur le PCB | Aussi pour relancer après *Game Over* |
| Buzzer | Sur la face arrière | Aligné à gauche du module LCD, centré en hauteur |

> ⚠️ Le buzzer en face arrière ne doit ni être obstrué par la main qui tient la console, ni court-circuiter les broches sous le LCD.

#### Dimensions

| | Hauteur | Largeur |
|---|---|---|
| Idéal | 78 mm | 80 mm |
| Plaque cuivrée disponible | 70 mm | 100 mm |
| **PCB retenu** | **65 mm** | **80 mm** |

### 6.3 Autonomie sur pile 9 V

Une pile 9 V alcaline a une capacité d'environ **500 mAh**. La consommation typique d'un Arduino Uno + LCD avec rétroéclairage est de **70 à 100 mA**. Cela donne une autonomie pratique de **5 à 7 heures**, suffisante pour un usage atelier mais limitée pour un usage prolongé.

> 💡 **Alternatives** :
> - **4 piles AA** (6 V, ~2500 mAh) : bien plus d'autonomie, mais nécessite un porte-pile encombrant.
> - **Accumulateur Li-ion 18650 + module *boost* 5 V** : recharge USB, autonomie de 10+ heures. Plus complexe à intégrer.
> - **Alimentation par USB** : option la plus simple, mais la console n'est plus portable.

### 6.4 Réaffectation des broches pour le PCB

Pour faciliter le routage, les broches utilisées par le LCD ont été **regroupées de manière contiguë** sur l'Arduino. Les boutons sont placés sur les broches restantes — y compris `A0` réutilisée en numérique, ce que l'Arduino permet sans restriction.

#### Brochage final du PCB

| Fonction | Broche Arduino | Remarques |
|---|---|---|
| LCD RS | D6 | — |
| LCD E | D5 | — |
| LCD D4 | D7 | — |
| LCD D5 | D8 | — |
| LCD D6 | D9 | — |
| LCD D7 | D10 | — |
| LCD R/W | GND | **Souder un pont entre R/W et VSS sur le LCD** |
| LCD VSS | GND | — |
| LCD VDD | +5 V | — |
| LCD V0 | Curseur du potentiomètre 10 kΩ | — |
| LCD A | +5 V via résistance 220 Ω | Rétroéclairage |
| LCD K | GND | — |
| Bouton **Haut** (SW1) | D12 | Autre borne sur GND |
| Bouton **Bas** (SW2) | D13 | Autre borne sur GND |
| Bouton **Tir** (SW3) | A0 (utilisée en numérique) | Autre borne sur GND |
| Buzzer | D11 | Autre borne sur GND |
| Bouton Reset | Broche RESET | Autre borne sur GND |

> ⚠️ **Sur l'écran LCD** : souder un petit pont (fil ou goutte d'étain) entre les broches `R/W` (5) et `VSS` (1) directement sur le module LCD. Cela libère une broche Arduino et simplifie le routage.

### 6.5 Code adapté au PCB final

Seuls les `#define` et le constructeur `LiquidCrystal` changent. Le reste du code de §3.2 est conservé tel quel.

```cpp
#include <LiquidCrystal.h>

// ---- Brochage PCB final ----
// LiquidCrystal(rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(6, 5, 7, 8, 9, 10);

const int PIN_BUZZER = 11;
const int boutonHaut = 12;
const int boutonBas  = 13;
const int boutonTir  = A0;   // A0 utilisée en entrée numérique

// ...le reste du code est identique à §3.2,
// avec randomSeed(analogRead(A5)) qui reste sur A5 (flottante)
```

> ⚠️ **Source d'entropie pour `random()`** : le prototype utilisait `analogRead(A0)`. Comme A0 est désormais un bouton avec pull-up activé, sa valeur sera toujours ≈ 1023 et la graine sera prévisible. **Utiliser A5** (ou toute autre broche analogique laissée flottante) pour `randomSeed`.

### 6.6 Conseils de routage spécifiques

D'après le retour d'expérience de l'atelier :

- **Travailler sur double écran** si possible : schéma à gauche, PCB à droite.
- Le schéma KiCad n'a pas besoin d'être beau, il doit être **exploitable pour le routage** : pré-organiser les composants comme ils seront physiquement disposés.
- Éviter au maximum les croisements **dès le schéma** : un croisement à plat sur le schéma deviendra une impasse au routage.
- Relier directement les composants à leur broche source plutôt que de chaîner les composants entre eux.
- ⚠️ **Une fois les pistes tracées, déplacer un composant rompt les connexions.** Positionner précisément dès le départ. Au besoin : *double-clic sur l'empreinte → onglet Position → saisir X et Y au millimètre*.
- **Empreintes modifiables.** Pour faire passer une piste sous un composant, il est parfois utile de supprimer un perçage inutile de l'empreinte. Procéder ainsi : *double-clic sur l'empreinte → Éditer l'empreinte → Enregistrer sous → créer une bibliothèque personnelle*. Travailler toujours sur une copie, jamais sur l'empreinte d'origine.
- **Pistes sous les composants** : c'est permis, et souvent indispensable sur un PCB simple face.
- **Éviter les « prisons »** : deux broches éloignées reliées par une grande boucle qui enferme d'autres broches sans accès. Privilégier des pistes parallèles.
- **Ponts filaires** : en dernier recours, accepter un pont filaire (un cavalier soudé sur le dessus) pour franchir une zone impossible à router.

### 6.7 Contour de la carte

**Définir la couche `Edge.Cuts`** : c'est elle qui décrira le contour mécanique du PCB (ce que la fraise découpera). Tracer un rectangle de 65×80 mm avec l'outil rectangle sur la couche `Edge.Cuts`. Si on est parti du modèle « Arduino UNO Shield », supprimer d'abord le contour fourni par défaut.

### 6.8 Validation finale

Avant export :

- [ ] Tous les chevelus résolus (aucun fil bleu restant).
- [ ] DRC sans erreur.
- [ ] Visualisation 3D conforme aux attentes.
- [ ] Contour `Edge.Cuts` fermé et de la bonne taille.
- [ ] Zone de masse remplie (raccourci `B`).
- [ ] Tous les éléments sur la couche `B.Cu` côté pistes.

---

## 7. Préparation des fichiers et usinage CNC

### 7.1 Vue d'ensemble du flux

```
KiCad                FlatCAM              Inkscape         Easel
  │                     │                    │               │
  ▼                     ▼                    ▼               ▼
Gerber B.Cu  ───┐                                       Gravure pistes
Gerber Edge ───┼─► Géométries ─► SVG ─► Retouches ─►  Perçages
Excellon PTH ──┘                                       Découpe contour
```

### 7.2 Étape 1 — Export depuis KiCad

#### Vérifier les contraintes une dernière fois

- Diamètre **extérieur** des pads : 1,6 mm (pas le perçage, qui est plus petit).
- Pas des composants traversants : 2,54 mm (standard, **à ne pas modifier** sous peine d'incompatibilité avec les boîtiers traversants).
- Clearance : 0,3 mm.

#### Exporter les Gerber

*Fichier → Tracer (Plot)*. Cocher au minimum :

- `B.Cu` — pistes côté cuivre,
- `Edge.Cuts` — contour mécanique.

Format **Gerber**, dossier de sortie au choix. Cliquer **Tracer**.

#### Exporter les perçages

*Fichier → Fichier de fabrication → Fichier de perçage*. Format **Excellon**. Cocher **Créer le fichier de plan de perçage**. Deux fichiers sont produits :

- `*-PTH.drl` — *Plated Through Holes*, perçages électriquement connectés (broches de composants).
- `*-NPTH.drl` — *Non-Plated Through Holes*, perçages mécaniques uniquement.

### 7.3 Étape 2 — FlatCAM

**Téléchargement** : <https://bitbucket.org/jpcgt/flatcam/downloads/>. À la date de rédaction, la version 8.994 dispose d'un `.exe` Windows.

#### Charger les fichiers

- **File → Open Gerber** pour `B.Cu.gbr` puis `Edge.Cuts.gbr`.
- **File → Open Excellon** pour `PTH.drl` (et `NPTH.drl` si nécessaire).

#### Convertir en géométries

Sélectionner les fichiers dans le panneau de gauche, puis : *Edit → Conversion → Convert Any to Geo*. Chaque objet devient une géométrie modifiable.

#### Joindre les contours

L'objectif est de produire **deux fichiers SVG distincts mais alignés** — un pour les pistes, un pour les perçages — chacun contenant le contour mécanique comme référence d'alignement.

**Pour les pistes :**
1. Sélectionner `B.Cu` géométrie + `Edge.Cuts` géométrie.
2. *Edit → Join Geometry*. Cela produit un objet `Combo` regroupant pistes + contour.

**Pour les perçages :**
1. Sélectionner `PTH` géométrie + `Edge.Cuts` géométrie.
2. *Edit → Join Geometry*. Nouveau `Combo` perçages + contour.

> ⚠️ Ne pas joindre `B.Cu` + `PTH` + `Edge.Cuts` dans un seul Combo : les pistes effacent visuellement les perçages dans le rendu SVG.

#### Exporter en SVG

Pour chaque `Combo` : *File → Export → Export SVG*. Conserver les unités en millimètres.

Vous obtenez :
- `pistes_combo.svg`
- `percages_combo.svg`

### 7.4 Étape 3 — Inkscape (optionnel mais recommandé)

Cette étape sert à **fusionner les deux SVG en un seul fichier propre** et à appliquer le miroir.

1. Ouvrir `pistes_combo.svg`.
2. Importer `percages_combo.svg` (*Fichier → Importer*).
3. Aligner les deux **par leur contour** (utiliser le contour `Edge.Cuts` commun comme référence).
4. **Dégrouper** les éléments (`Ctrl+Maj+G`).
5. **Combiner** les pistes ensemble (`Ctrl+K`), de même pour les perçages.
6. Affecter une couleur distincte à chaque groupe (rouge pour les pistes, bleu pour les perçages) pour les retrouver dans Easel.
7. Supprimer les contours superflus, n'en conserver qu'un seul.
8. Enregistrer sous `gameNwatch_final.svg`.

> 💡 **Miroir** : appliquer un retournement horizontal à l'ensemble (`H`) **uniquement si** la gravure se fait sur la face cuivre vue de **dessus** dans Easel. Tester sur une chute avant de graver le PCB définitif.

### 7.5 Étape 4 — Easel et usinage CNC

#### Préparer le projet

1. *New project*, le nommer (cliquer sur *Untitled*).
2. Unités en **millimètres**.
3. Matériau : *Other*. Épaisseur **1,4 mm** (PCB FR4 du fablab).
4. Dimensions du brut : adapter à la plaque (par exemple 70×100 mm).

#### Fixer la plaque

- Travailler **en bas à gauche** du plateau de la fraiseuse pour rester dans une zone bien calibrée.
- Fixation au **double-face puissant** (ruban moquette) : tient bien sans tabs, simple à retirer.
- Vérifier la planéité : une plaque bombée donnera des passes inégales (certaines zones gravées trop profond, d'autres pas assez).

#### Gravure des pistes (passe 1)

**Fraise** : V-bit pointe javelot 30°, queue 1/8 in.

**Montage** :
1. Insérer et serrer la fraise dans le mandrin.
2. *Homing* (retour à l'origine machine).
3. Définir le zéro pièce (X, Y, Z) en bas à gauche de la plaque.

**Réglages de coupe** (onglet *Manual*) :

| Paramètre | Valeur |
|---|---|
| Feed rate | 60 mm/min |
| Plunge rate | 60 mm/min |
| Depth per pass | 0,05 mm |
| Profondeur totale | 0,2 mm |

> 💡 La V-bit pointe javelot a un angle conique : plus on plonge profond, plus le trait est large. **0,2 mm** est un bon compromis trait visible / fragilité de la pointe.

**Import du SVG** : *Project → Import SVG → gameNwatch_final.svg*. Le placer à l'origine : `Ctrl+A` puis position `X=0, Y=0`.

**Sélection :**
- Supprimer la partie perçages (laisser seulement les pistes + contour de référence).
- Sélectionner toutes les pistes : `Ctrl+A`, puis *Edit → Combine*.
- *Cut → Cut on path* (gravure exactement sur le tracé d'isolation).

**Lancer** *Carve*. Observer la première passe : si le trait est trop fin, augmenter légèrement la profondeur totale.

#### Perçages (passe 2)

> 💡 Pendant que la V-bit refroidit après la gravure, on prépare le fichier de perçage.

**Fraise** : 1/32 in (0,79 mm).

**Montage** :
1. Changer la fraise.
2. *Probe → Use Last XY Zero* (on conserve la même origine X/Y, on redéfinit seulement Z).
3. Définir le nouveau zéro Z sur la surface du PCB.

**Réglages de coupe :**

| Paramètre | Valeur |
|---|---|
| Feed rate | 300 mm/min |
| Plunge rate | 100 mm/min |
| Depth per pass | 0,4 mm |
| Profondeur totale | 1,4 mm + 0,2 mm = **1,6 mm** |

Le `+0,2 mm` garantit que la fraise traverse totalement la plaque même en cas de léger défaut de planéité.

**Sélection** : conserver uniquement les perçages dans le SVG importé.

*Cut → Cut inside shape path*. Lancer *Carve*.

#### Découpe du contour (passe 3)

**Fraise** : 1/32 in (la même).

**Montage** :
1. *Probe → Use Last Position* (mêmes origines X/Y/Z).

**Réglages de coupe** : identiques à la passe 2.

**Sélection** : conserver uniquement le contour `Edge.Cuts`.

*Cut → Cut outside shape path*. Lancer *Carve*.

> 💡 **Tabs ?** Avec une fixation au double-face puissant, les tabs (petits ponts de matière qui retiennent la pièce) sont inutiles. Si la plaque est fixée par les coins seulement, **prévoir 3 ou 4 tabs de 1,5 mm** pour éviter que la pièce ne se libère en cours de découpe et casse la fraise.

#### Récupérer le PCB

- Décoller la plaque (chauffer légèrement le dos avec un sèche-cheveux si le double-face résiste).
- Évacuer les copeaux avec un pinceau.
- Limer/ébavurer les bords si nécessaire.

---

## 8. Tests, soudure et mise en service

### 8.1 Tests **avant** soudure

C'est la phase la plus négligée et celle qui sauve le plus de PCB. Avec un multimètre en mode **continuité** :

1. **Vérifier l'absence de court-circuit** entre les rails `+5 V` et `GND`. Tester aussi `Vin` vs `GND`.
2. **Vérifier la continuité** de chaque piste prévue : poser une sonde à chaque extrémité de la piste, on doit entendre le bip.
3. **Vérifier l'isolation** : sur des pistes voisines, on ne doit PAS entendre de bip.
4. Inspecter les pastilles à la loupe : pas de cuivre arraché, pas de bavure entre pads adjacents.

Tout défaut détecté maintenant se corrige avec un cutter (rayer pour interrompre) ou une goutte d'étain (combler). Une fois les composants soudés, c'est beaucoup plus délicat.

### 8.2 Ordre de soudure recommandé

Du plus bas au plus haut, du moins fragile au plus fragile :

1. **Cavaliers** (ponts filaires) éventuels.
2. **Résistance 220 Ω**.
3. **Connecteurs de barrette femelle** pour l'Arduino (les broches qui s'enficheront sur l'Uno).
4. **Potentiomètre** de contraste.
5. **Boutons-poussoirs** (incluant le bouton Reset).
6. **Cosses** pour la pile 9 V.
7. **Connecteur femelle** pour le LCD (le LCD lui-même reste enfichable).
8. **Buzzer** (face arrière).

> 💡 Souder le LCD **sur connecteur enfichable** plutôt qu'en direct : si un jour il faut le changer, c'est instantané.

### 8.3 Premier démarrage

1. **Sans l'Arduino** : brancher la pile et vérifier qu'aucune fumée ne sort. Mesurer `+5 V` sur les rails (devrait être 0 V puisque le régulateur est sur l'Arduino).
2. **Avec l'Arduino, sans le LCD** : reprogrammer l'Arduino avec le code §6.5. Brancher la pile. Vérifier `+5 V` entre les bonnes pastilles.
3. **Avec le LCD** : ajuster le potentiomètre de contraste jusqu'à voir les caractères.
4. **Tester chaque bouton** : ajouter temporairement un `Serial.print` pour visualiser leur état si nécessaire.

### 8.4 Points de test

Si possible, prévoir dès la conception du PCB **2 ou 3 pastilles libres** étiquetées `TP_5V`, `TP_GND`, `TP_BTN_TIR`. On y pose la pointe du multimètre sans avoir à chercher où sonder. C'est invisible une fois la console refermée mais salvateur en cas de panne.

---

## 9. Boîtier et finitions

### 9.1 Approches possibles

| Méthode | Avantages | Inconvénients |
|---|---|---|
| **Impression 3D** (PLA, PETG) | Forme libre, customisable, robuste | Demande modélisation CAO |
| **Découpe laser** (MDF 3 mm, contreplaqué) | Rapide, esthétique « rétro » | Nécessite assemblage par tenons |
| **Vacuum forming** sur master imprimé | Aspect Game & Watch original | Outillage spécifique |
| **Boîtier du commerce** (Hammond, Bopla) | Le plus rapide | Form factor peu adapté |

### 9.2 Contraintes à anticiper

- Découpe pour le **port USB** de l'Arduino (reprogrammation).
- Découpe pour l'**interrupteur** d'alimentation.
- Fenêtre transparente ou découpe pour l'**écran LCD**.
- Trous pour les **3 boutons-poussoirs** et le **bouton Reset**.
- **Grille ou trous** en face arrière au niveau du buzzer (pour laisser passer le son).
- Logement pour la **pile 9 V** avec accès pour la remplacer.
- **Vis** ou clips pour ouvrir le boîtier (privilégier les fixations démontables pour la maintenance).

La modélisation détaillée du boîtier fait l'objet d'un document séparé.

---

## 10. Pour aller plus loin

### 10.1 Améliorations logicielles

- **Niveaux de difficulté** : réduire `intervalDeplacement` progressivement avec le score.
- **Power-ups** : tir multiple, bouclier temporaire, ennemi bonus.
- **Sauvegarde du meilleur score** en EEPROM (`EEPROM.put()` / `EEPROM.get()`).
- **Écran de démarrage** avec animation.
- **Mode démo** automatique au repos.

### 10.2 Améliorations matérielles

- Passer à un **OLED I²C** 128×64 (SSD1306) : 2 fils, bien plus de pixels, plus joli — mais plus de programmation.
- **Joystick analogique** à la place des deux boutons haut/bas.
- **ATmega328P nu** avec quartz 16 MHz et condensateurs de découplage, monté sur support DIP : élimine la carte Arduino et divise l'épaisseur par deux.
- **Module BMS Li-ion** pour recharge USB-C.

### 10.3 Prolongements pédagogiques

- **Exposition** au fablab des consoles fabriquées par les participants.
- **Atelier suite** : programmation d'un second jeu (Snake, Pong, mini-RPG).
- **Création d'un club** : entretien d'une bibliothèque de jeux LCD partagée.
- **Tournoi** entre participants sur leurs propres consoles.

---

## 11. Annexes

### 11.1 Ressources

- **Site officiel KiCad** : <https://www.kicad.org/>
- **Documentation KiCad en français (Fabmanager)** : <https://fabmanager.csc49.fr/#!/projects/guide-du-debutant-kicad>
- **Tutoriel pull-up Locoduino** : <https://www.locoduino.org/spip.php?article122>
- **Tutoriel vidéo FlatCAM** : <https://www.youtube.com/watch?v=--Cb11heuHc>
- **Téléchargement FlatCAM** : <https://bitbucket.org/jpcgt/flatcam/downloads/>

### 11.2 Règles de conception non utilisées ici (pour vos prochains projets)

Ces règles sont importantes mais ne s'appliquent pas à ce projet précis. Elles sont rassemblées ici pour référence future.

**Routage USB.** Les paires différentielles D+/D− doivent avoir des longueurs **identiques** (matched length) pour préserver l'intégrité du signal. Espacement constant entre les deux pistes (impédance différentielle ~90 Ω). Non applicable ici puisque on utilise le port USB déjà câblé de l'Arduino.

**Multicouche.** Pour des projets denses ou rapides, un PCB **4 couches** (signal / GND / VCC / signal) offre une bien meilleure intégrité de signal grâce aux plans pleins internes. Non utilisable en gravure CNC simple face.

**Dissipation thermique.** Les régulateurs de tension, transistors de puissance, drivers de moteur génèrent de la chaleur. Prévoir des **zones de cuivre étendues** autour de leurs broches dissipantes, voire des vias thermiques. Non applicable ici (consommation < 100 mA).

**Séparation des alimentations.** Pour les projets mêlant **moteurs**, **logique numérique** et **chaînes analogiques sensibles** (audio, capteurs précis) : tracer des pistes d'alimentation séparées, reliées en un seul point (« étoile »). Non applicable ici.

**Largeur de piste selon le courant.** Pour les pistes véhiculant plus de 500 mA, consulter un calculateur (par exemple [4PCB Trace Width Calculator](https://www.4pcb.com/trace-width-calculator.html)) pour dimensionner la largeur en fonction de l'épaisseur de cuivre (typiquement 35 µm) et de l'échauffement acceptable.

### 11.3 Glossaire

| Terme | Définition |
|---|---|
| **BOM** | *Bill Of Materials*, nomenclature des composants |
| **Chevelu** | *Ratsnest*, fil virtuel indiquant une connexion à router |
| **CMS / SMD** | Composant Monté en Surface / *Surface Mount Device* |
| **DRC** | *Design Rule Check*, vérification des règles physiques du PCB |
| **ERC** | *Electrical Rule Check*, vérification des règles électriques du schéma |
| **Empreinte** | *Footprint*, représentation physique d'un composant sur le PCB |
| **Excellon** | Format de fichier décrivant les perçages |
| **FR4** | Matériau standard des PCB : résine époxy + fibre de verre |
| **Gerber** | Format de fichier standard décrivant les couches d'un PCB |
| **Pad** | Pastille de cuivre où vient se souder une broche |
| **PCB** | *Printed Circuit Board*, circuit imprimé |
| **Pull-up / pull-down** | Résistance maintenant une broche à un état logique défini |
| **THT** | *Through-Hole Technology*, composant traversant |
| **V-bit** | Fraise conique en pointe, utilisée pour la gravure de pistes |
| **Via** | Perçage métallisé reliant deux couches du PCB |

### 11.4 Crédits

Document élaboré dans le cadre d'un atelier en fablab. Code de jeu, brochage et processus de fabrication issus du travail collectif des participants.

Toutes remarques, corrections et propositions d'amélioration sont les bienvenues.