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

# Game & Watch DIY — Fabrication

> Document de travail consolidant le prototypage Arduino, la conception du PCB sous KiCad, les règles de conception et la préparation des fichiers pour la CNC.

---

## 1. Rappel : prototypage

### 1.1 Liste du matériel

- 1 × Arduino Uno
- 1 × écran LCD 16 broches (non I²C)
- 3 × boutons poussoirs
- 1 × buzzer
- 1 × résistance 220 Ω
- 1 × potentiomètre 10 kΩ *(facultatif — voir remarque ci-dessous)*

### 1.2 Câblage

**Écran LCD** — câblage identique au projet n° 11 du livre de référence ; consulter les pages 116 et 117 pour le détail des broches.

Une variante sans potentiomètre a été testée (LCD branché directement à la masse) mais elle a été abandonnée.

**Boutons poussoirs** — montés en pull-up interne :

```
GND → Poussoir → broches 7, 8, 9 (avec INPUT_PULLUP dans le code)
```

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

**Buzzer** — deux broches : l'une à la masse, l'autre sur la broche 6 (qui assure également l'alimentation lors du pilotage par `tone()`). Voir notamment le projet n° 6, p. 71.

### 1.3 Type de jeu

Jeu d'arcade type *Asteroids*.

### 1.4 Code de référence

```cpp
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// ---- Buzzer ----
const int PIN_BUZZER = 6;
inline void beepShoot() { tone(PIN_BUZZER, 2000, 40);  } // court
inline void beepHit()   { tone(PIN_BUZZER, 1200, 80);  } // moyen
inline void beepOver()  { tone(PIN_BUZZER,  400, 600); } // long

// ---- Boutons ----
const int boutonTir  = 7;
const int boutonHaut = 8;
const int boutonBas  = 9;

// ---- Affichage ----
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
};

int vaisseauLigne = 1; // 0..1

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;

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();

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

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

  if      (digitalRead(boutonHaut) == LOW) vaisseauLigne = 0;
  else if (digitalRead(boutonBas)  == LOW) vaisseauLigne = 1;

  // Tir multi-missiles + bip
  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();
    }
  }

  if (now - dernierDeplacement > intervalDeplacement) {
    dernierDeplacement = now;

    // Déplacer les 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;
    }

    // Déplacer les ennemis + détection des 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();
  }
}

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); // vaisseau

  // Tirs
  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); // missile
    }
  }

  // Ennemis
  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); // ennemi
    }
  }
}

void gameOver() {
  lcd.clear();
  lcd.setCursor(3, 0); lcd.print("GAME OVER");
  lcd.setCursor(4, 1); lcd.print("Score:"); lcd.print(score);
  while (true) {}
}
```

---

## 2. Tutoriel : préparation sous KiCad

### 2.1 Atelier — KiCad → PCB → CNC

> ⚠️ Tutoriel expérimental : à revérifier, tester et adapter au besoin.

Site officiel : <https://www.kicad.org/> — éditeur de PCB libre et gratuit.

### 2.2 Création du projet

Deux possibilités :

- **Projet vierge** : *Fichier → Nouveau projet*
- **Projet « shield Arduino »** : *Fichier → Nouveau projet à partir d'un modèle → Arduino UNO Shield*

L'exemple suivant porte sur la création d'un shield Arduino Uno comportant 3 LED, 3 résistances de 220 Ω et 3 boutons.

Enregistrer le projet dans un dossier dédié (ici, `shieldDynalab`). Il contient deux fichiers principaux :

- `*.kicad_sch` — conception du circuit électronique (schéma)
- `*.kicad_pcb` — agencement des composants sur le circuit imprimé et dessin des pistes

Ouvrir le fichier `.kicad_sch`. Le modèle Arduino Uno Shield contient déjà les broches correspondant aux pins de l'Arduino.

### 2.3 Ajout des composants

Cliquer sur le bouton **Ajouter un symbole** (barre d'outils de droite, en haut). Dans le champ de recherche, saisir le nom du composant *en anglais* (par exemple `led`).

Sélectionner le composant dans la liste : son symbole électrique s'affiche dans le volet de droite. Puis, via le menu déroulant **Pas d'empreinte par défaut**, sélectionner l'empreinte qui correspond au composant physique (par exemple via la référence constructeur ou les dimensions).

> **Empreinte** : espace physique occupé par le composant sur le PCB ainsi que la position de ses broches.

- **SMD** *(Surface Mount Device)* — composant monté en surface
- **THT** *(Through-Hole Technology)* — composant traversant

Vérifier que l'empreinte qui s'affiche en dessous semble cohérente, valider, puis poursuivre avec les autres composants (par exemple une résistance 220 Ω).

Si une empreinte n'est pas trouvée dans la liste déroulante, ce n'est pas grave : il sera possible de l'attribuer plus tard, par exemple pour le bouton poussoir.

### 2.4 Attribution des empreintes a posteriori

Pour attribuer une empreinte aux composants qui n'en ont pas encore, utiliser le bouton **Assigner des empreintes**. Une fenêtre liste tous les composants du projet ; il devient possible :

- de modifier les empreintes déjà attribuées,
- d'en attribuer de nouvelles depuis la liste à droite (recherche par mot-clé ou référence, en anglais ; double-clic pour valider).

En cas de doute, faire un *clic droit* sur le nom de l'empreinte → **Affichage de l'empreinte sélectionnée**, pour vérifier visuellement la cohérence.

Si un composant n'existe pas dans la bibliothèque, il est possible de fabriquer une empreinte personnalisée à partir de zéro.

### 2.5 Conception du circuit

Dans l'espace de travail, survoler un composant et utiliser les raccourcis suivants :

| Touche | Action |
|---|---|
| `M` | *Move* — déplacer le composant |
| `R` | *Rotate* — pivoter le composant |
| `Ctrl + D` | *Duplicate* — dupliquer le composant (cliquer ailleurs pour le poser) |

Le bouton **Ajouter un fil** (barre d'outils de droite) permet de relier les broches entre elles.

Survoler les noms des broches de l'Arduino et faire `Ctrl + D` pour les dupliquer à proximité du module en cours de conception (par exemple le module LED). Procéder de même pour la masse (GND).

Le bouton **Annotation de la schématique** renomme automatiquement les composants pour éviter les conflits.

Ajouter des **indicateurs de non-connexion** sur toutes les broches qui ne seront reliées à rien : cela évite les erreurs lors du contrôle des règles électriques (ERC).

> *Point à vérifier* : sur quelles broches exactement faut-il placer ces indicateurs ?

Il est possible de sélectionner plusieurs composants à la fois pour les dupliquer en bloc (utile lorsqu'un même sous-module se répète sur le circuit).

### 2.6 Passage à l'éditeur de PCB

Une fois le schéma terminé : **sauvegarder**, puis cliquer sur **Commuter vers l'éditeur de PCB** (barre d'outils en haut). Cela ouvre le fichier `.kicad_pcb`.

Au départ, l'éditeur ne contient pas encore les composants du schéma. Pour les importer : **Outils → Mettre à jour le PCB depuis le schéma**.

Les composants apparaissent à l'écran, reliés par des « chevelus » aux broches correspondantes. Reste à les positionner, les orienter et les router de manière à éviter les croisements de pistes (le casse-tête commence ici).

### 2.7 Paramétrage des contraintes (CNC)

Avant de tracer les pistes, paramétrer les contraintes liées à la CNC : **Options du CI → Contraintes**.

Modifier les valeurs minimales pour permettre le passage de la fraise lors de l'isolation des pistes. Se baser sur les diamètres de fraises disponibles.

### 2.8 Tracé des pistes

Le bouton de tracé de piste permet de dessiner les connexions. Au clic sur une broche, l'écran s'assombrit et seules les broches reliées électriquement restent éclairées, ce qui facilite l'identification des connexions à réaliser.

- **Trait rouge** : la piste elle-même
- **Contour gris** : la zone d'isolation minimum

KiCad maintient automatiquement la distance minimale par rapport aux autres broches et pistes.

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

- `F.Cu` *(front)* — pistes en cuivre côté composants
- `B.Cu` *(back)* — pistes en cuivre côté soudure

Vérifier le rendu via **Affichage → Visualisation 3D** pour s'assurer que le résultat est physiquement réalisable et cohérent.

> 💡 **Cas de la gravure CNC** : le cuivre ne traverse pas la plaque au niveau des perçages. Les pistes doivent donc être placées de l'autre côté par rapport aux composants. On travaille donc sur la couche `B.Cu`.
>
> Faire les pistes sur `F.Cu` donne certes un rendu plus clair, mais ne permet pas de souder les composants une fois la plaque gravée à la CNC.

### 2.9 Export des fichiers de fabrication

**Pistes (Gerber)** : *Fichier → Fichier de fabrication → Gerber `.gbr`*. Sélectionner les couches concernées, tracer ; la fenêtre du bas confirme l'enregistrement.

**Perçages (Excellon)** : *Fichier → Fichier de fabrication → Fichier de perçage `.drl`*. Créer le fichier de perçage ET le plan de perçage.

### 2.10 Conversion Gerber → SVG

Utiliser **FlatCam** : il permet d'ouvrir des fichiers Gerber, de définir le diamètre et le type de fraise utilisée, et de générer automatiquement le tracé vectoriel du chemin que la CNC empruntera. Il est également possible d'ajouter manuellement des traits si nécessaire.

Étapes :

1. Import des fichiers Gerber
2. Paramétrage de l'isolation
3. Création de la géométrie
4. Adaptation manuelle du tracé si besoin
5. Géométrie sélectionnée → **Export SVG** ou **DXF**, ou bien génération directe du chemin CNC

Tutoriel vidéo : <https://www.youtube.com/watch?v=--Cb11heuHc>

### 2.11 Ressources complémentaires

Documentation KiCad en français sur Fabmanager : <https://fabmanager.csc49.fr/#!/projects/guide-du-debutant-kicad>

---

## 3. Atelier 2 — déroulé

1. Retour sur les règles de conception
2. Retour d'expérience sur le projet
3. Préparation des fichiers pour la CNC
4. Usinage sur CNC
5. **Et après ?** Exposition, autres ateliers, création d'un club ?

---

## 4. Règles de conception du PCB

### 4.1 Points abordés ensemble

#### 1. Type de fabrication et couches utilisées

PCB simple face : les pistes sont gravées sur la face cuivre inférieure, les composants traversants sont placés sur la face supérieure. Dans KiCad, router donc les pistes sur la couche `B.Cu`.

#### 2. Types de composants électroniques

- **CMS** (Composants Montés en Surface) = **SMD** (*Surface Mount Device*) : même chose, en français et en anglais.
- **THT** (*Through-Hole Technology*) : composants traversants.

#### 3. Outils de vérification dans KiCad

- **DRC** (*Design Rule Check*) : contrôle du respect des règles de conception du PCB.
- **ERC** (*Electrical Rule Check*) : contrôle de la cohérence électrique du schéma.

#### 4. Gestion des entrées non connectées

Ne pas laisser d'entrée non connectée (dite « flottante ») : cela peut entraîner des comportements imprévisibles. Sur un microcontrôleur, une broche inutilisée peut rester non connectée à condition d'être correctement configurée par programmation (en sortie, ou avec un état défini par exemple en pull-up/pull-down interne).

#### 5. Routage et angles des pistes

Éviter les angles à 90°, privilégier les angles à 45°. Cela améliore la qualité de fabrication et limite les discontinuités électriques, particulièrement sur les signaux rapides.

#### 6. Gestion des interférences

Éloigner les éléments susceptibles de générer des interférences (liaisons USB, signaux rapides, lignes d'horloge) des entrées analogiques (notamment audio).

Règle générale : plus un signal est rapide, plus il est susceptible de générer ou de subir des interférences. Dans ce cas, privilégier des pistes courtes. À l'inverse, pour des signaux lents (bouton poussoir, LED, commande de relais, UART à faible débit), il est possible de déporter le composant avec des pistes plus longues sans risque significatif.

#### 7. Notion de routage soigné

Un routage soigné consiste à tracer les pistes de manière logique et maîtrisée :

- privilégier des trajets courts et directs,
- éviter les boucles inutiles,
- limiter les croisements entre signaux sensibles et signaux bruyants,
- conserver une proximité cohérente avec la masse pour assurer un bon retour de courant.

Un tracé clair et structuré facilite également la lecture, la maintenance et le dépannage du circuit.

#### 8. Routage des signaux USB

Les lignes D+ et D− doivent avoir des longueurs identiques afin de préserver les caractéristiques du signal différentiel et maintenir une impédance cohérente.

#### 9. Intérêt des PCB multicouches

Lorsque cela est possible, un PCB à quatre couches est une solution idéale : les couches internes dédiées à l'alimentation et à la masse améliorent la stabilité électrique et réduisent les interférences (notamment grâce à leur effet capacitif).

#### 10. Prototypage avec Arduino et intégration

Une carte Arduino Uno est un dispositif complet adapté au prototypage rapide.

Dans une mise en œuvre intégrée, il est possible de ne conserver que le microcontrôleur — par exemple l'ATmega328P — accompagné des éléments minimaux nécessaires à son fonctionnement :

- un quartz (généralement 16 MHz) avec ses deux condensateurs associés,
- une résistance de pull-up sur la broche `RESET`,
- les condensateurs de découplage pour l'alimentation.

Pour faciliter l'usage, monter le microcontrôleur sur un support DIP (support tulipe) : cela permet de le retirer aisément pour le reprogrammer sur une carte Arduino.

### 4.2 Bonnes pratiques supplémentaires (bonus à vérifier)

#### 11. Découplage des alimentations

Chaque circuit intégré doit posséder un condensateur de découplage (typiquement 100 nF) placé au plus près de ses broches `VCC` et `GND`. Cela absorbe les variations rapides de courant, stabilise la tension et évite les comportements aléatoires difficiles à diagnostiquer. Pratique particulièrement importante pour les microcontrôleurs et les circuits logiques rapides.

#### 12. Plan de masse (GND)

Plutôt que de relier la masse uniquement par des pistes fines, utiliser une zone de cuivre continue. Cela réduit les interférences électromagnétiques, améliore le retour de courant et simplifie le routage.

Dans le cas d'une gravure CNC, cette pratique est facilement réalisable : le plan de masse correspond au reste de cuivre non gravé, isolé autour des pistes et pastilles. Dans KiCad, on peut remplir la carte avec un *copper pour* (zone cuivrée) affectée à `GND` et relier tous les points de masse.

#### 13. Boucle de courant et retour de masse

Un signal électrique forme toujours une boucle complète : aller + retour. Si le chemin de retour n'est pas proche de la piste du signal, le circuit peut capter ou émettre du bruit. Toujours garder un retour de masse continu et proche pour tous les signaux, en particulier les signaux rapides ou sensibles.

#### 14. Largeur des pistes adaptée au courant

Toutes les pistes ne doivent pas avoir la même largeur :

- les signaux logiques peuvent passer sur des pistes fines,
- les pistes d'alimentation et celles transportant un courant important doivent être plus larges pour éviter surchauffe, chute de tension ou destruction de la piste.

Il existe des calculateurs en ligne pour déterminer la largeur adaptée selon le courant et l'épaisseur du cuivre.

#### 15. Points de test pour le débogage

Prévoir sur le PCB des points de test accessibles pour mesurer rapidement la tension d'alimentation, vérifier les signaux critiques et suivre les lignes de communication importantes.

Concrètement, ce sont de petites pastilles ou trous métallisés sur lesquels on peut poser la sonde d'un multimètre ou d'un oscilloscope. Cela facilite le dépannage sans avoir à dessouder des composants.

#### 16. Dissipation thermique

Certains composants génèrent de la chaleur (régulateurs de tension, transistors de puissance). Pour éviter la surchauffe et préserver la fiabilité du circuit, prévoir une surface de cuivre suffisante pour dissiper cette chaleur :

- pistes plus larges connectées aux broches concernées,
- raccordement de ces broches à des zones de cuivre étendues qui agissent comme dissipateurs thermiques.

L'objectif est d'offrir un chemin efficace d'évacuation de la chaleur vers le PCB.

#### 17. Séparation des alimentations

Si le circuit comporte des parties analogiques, numériques et de puissance, séparer les plans ou pistes d'alimentation pour chaque domaine. Par exemple, les moteurs et autres charges fortes peuvent disposer de leur propre piste, tandis que la logique numérique et l'analogique sensible utilisent des pistes ou zones distinctes.

Même si toutes les alimentations proviennent de la même source, cette séparation physique sur le PCB limite les interférences et améliore la stabilité du circuit.

---

## 5. Application au projet

### 5.1 Processus itératif (retour d'expérience)

#### Conception du PCB

**#1 — Listing des composants**

Inventorier l'ensemble des composants nécessaires.

**#2 — Premiers choix de conception**

- forme globale du PCB,
- composants accessibles ou non,
- répartition face supérieure / face inférieure,
- type d'alimentation (ne pas oublier la batterie !).

**#3 — Test de positionnement et d'implantation réelle** *(si possible)*

- repérer les conflits potentiels (ponts notamment),
- prendre les mesures critiques,
- définir la forme et la taille du PCB.

**#4 — Schématisation sous KiCad**

> 💡 Travailler si possible sur un double écran.

- positionner et anticiper a minima l'implantation des éléments ;
- l'objectif n'est pas nécessairement de produire un schéma facilement lisible, mais un schéma exploitable pour le routage ;
- éviter au maximum les croisements ;
- relier directement les composants à la broche source (ne pas chercher à les relier entre eux dans un premier temps) ;
- si besoin, utiliser l'empreinte d'un autre composant (exemple : une batterie peut être représentée par l'empreinte d'une résistance).

À explorer : sous KiCad, les broches `GND` d'un Arduino ne sont pas reliées entre elles. Affecter un `GND` symbolique à chacune via des labels.

**#5 — Routage sous KiCad (éditeur de PCB)**

Dernier moment pour vérifier les empreintes — vérifier notamment que le pas est bien un multiple de 2,54 mm.

> ⚠️ Après création des pistes, déplacer un composant rompt les connexions. Implanter donc précisément les composants dès le départ (au besoin, double-clic + saisie des coordonnées).

Pour Arduino : supprimer si nécessaire les limites de la carte.

- imaginer les premiers regroupements de pistes (vrai aussi pour la masse) et les ajuster progressivement sur le schéma ;
- éviter les **prisons** (deux broches éloignées reliées par une boucle qui bloque l'accès aux autres broches) → privilégier les pistes en parallèle ;
- pour le passage des pistes, modifier les empreintes si nécessaire (par exemple suppression d'un perçage) : *double-clic sur l'empreinte → Éditer l'empreinte → Créer une nouvelle bibliothèque personnalisée (la placer en favoris) → la modifier puis enregistrer sous cette nouvelle bibliothèque* ;
- garder en tête qu'il est possible de faire passer des pistes **sous** les composants ;
- dans certains cas, créer des ponts filaires (parfois inévitable).

> **Important** : définir la couche `Edge.Cuts` (contour du PCB).

**#6 — Réaffectation des broches**

Objectif : faciliter le routage.

- veiller à la capacité de chaque broche ;
- bon à savoir : sur Arduino, les broches analogiques peuvent être réaffectées en numérique ;
- noter toutes les modifications pour adapter le code en conséquence.

**#7 — Modification du code**

Reporter les réaffectations de broches dans le code source.

**#8 — Nouveau prototypage** *(facultatif)*

#### Préparation des fichiers pour l'usinage

**#9 — Export des fichiers Gerber et Excellon**

Exporter a minima : `B.Cu` + `Edge.Cuts` + `.drl`.

**#10 — Traitement dans FlatCam**

Génération des fichiers SVG.

**#11 — Traitement dans Inkscape** *(facultatif)*

Fusionner les « combos », supprimer les contours superflus.

### 5.2 Liste des équipements et positionnement

- Shield Arduino custom avec PCB **débordant du form factor** standard.
- L'écran déborde de **8 mm minimum vers le haut** ; les broches sont à **4 mm minimum** du bord de la carte.
- **Pile 9 V** pour alimentation sur `Vin` (anticiper l'emplacement d'un futur interrupteur d'alimentation). Branchement filaire sur le PCB via une cosse de raccordement, à droite des broches de l'écran.
- **Potentiomètre de contraste** : utile uniquement pour la mise au point, pas besoin d'être accessible une fois la carte dans son boîtier. Position classique conservée, mais il sera caché sous le capot.
- **Port USB de l'Arduino** : accessible pour reprogrammation.
- **Bouton reset** : ajout d'un bouton dédié pour relancer le jeu (ou aménager la forme du PCB pour conserver l'accès au bouton reset d'origine de l'Arduino).
- **Buzzer** : monté en face arrière du PCB. Attention à :
  - ce que la position des mains lors du jeu ne bouche pas le son,
  - ce qu'il ne touche pas / ne court-circuite pas les broches en sous-face de l'écran (le centrer sur la hauteur, l'aligner à gauche sur le bord du module écran).

#### Dimensions du PCB

| | Hauteur | Largeur |
|---|---|---|
| Idéal | 78 mm | 80 mm |
| Plaque à graver disponible | 70 mm | 100 mm |
| **PCB final retenu** | **65 mm** | **80 mm** |

### 5.3 Schéma KiCad — réaffectation des broches

#### Boutons

| Bouton | Broche Arduino | Rôle |
|---|---|---|
| SW1 | D12 (+ GND) | Bouton **haut** |
| SW2 | D13 (broche 3 du SW2 sur GND, « 14 » à côté du 13) | Bouton **bas** |
| SW3 | A0 (broches 1 et 3) + GND (broches 2 et 4, à côté du 5 V) | Bouton **tir** |

#### Buzzer

- Broche **D11** + GND.

#### Écran LCD

| Broche LCD | Broche Arduino |
|---|---|
| D7 | D10 |
| D6 | D9 |
| D5 | D8 |
| D4 | D7 |
| E  | D5 |
| RS | D6 |
| RW | GND |

#### Masses

`VSS` du LCD, GND du buzzer, GND de SW1 et GND de SW2 sont tous reliés à la masse commune.

> ⚠️ **Important** : sur l'écran LCD, il faudra **souder un pont** entre `R/W` et `VSS` pour relier `R/W` à la masse.

---

## 6. Tutoriel : préparation pour la CNC

### 6.1 Création d'un PCB à la CNC (gravure « à l'anglaise »)

**Logiciels utilisés :**

- KiCad — version 9.0
- FlatCam — version bêta 8.994
- Inkscape
- Easel (pilotage de la CNC)

### 6.2 Étapes dans KiCad

#### Règles de conception → contraintes

Vérifier :

- le **diamètre des pads** : 3 mm (double-clic sur les pads → *Propriétés*) ;
- la **distance entre pads** : 2,54 mm.

> Proposition : passer à 2,34 mm (= 2,54 − 2 × 0,1) pour ménager une marge ?

#### Ajouter le contour du circuit

- sélectionner la couche `Edge.Cuts`,
- utiliser par exemple l'outil **Rectangle**, clic simple.

#### Export des fichiers de fabrication

*Fichier → Fichiers de fabrication → Gerber → Tracer*, puis créer les **fichiers de perçage** (Excellon).

> ⚠️ Ne pas oublier d'exporter la couche `Edge.Cuts`.

### 6.3 FlatCam

**Téléchargement** : <https://bitbucket.org/jpcgt/flatcam/downloads/>

> En date du 01/04/2026, la version 8.994 est disponible avec un `.exe` pour Windows.

#### 1. Ouvrir FlatCam

#### 2. Charger les fichiers

- **Open Gerber** pour le fichier de la face cuivre + `Edge.Cuts`,
- **Open Excellon** pour les fichiers de perçage :
  - `PTH` → perçage des composants,
  - `NPTH` → autres perçages.

#### 3. Convertir Gerber et Excellon en géométries

- sélectionner les fichiers,
- *Edit → Conversion → Convert Any to Geo*.

#### 4. Joindre les contours aux géométries

**Pour les pistes** : sélectionner `B.Cu` + `Edge.Cuts` → *Edit → Join Objects → Join Geo / Gerber / Excellon*. Cela génère une nouvelle géométrie « Combo… ».

**Pour les perçages** : même opération avec `PTH.drl` + `Edge.Cuts`.

> ⚠️ Il n'est *a priori* pas possible de joindre efficacement les géométries `PTH.drl` et `B.Cu` directement : le fichier de pistes efface / écrase le fichier de perçage.

#### Variante (ancienne version)

Ajouter manuellement une forme contour sur toutes les géométries :

1. sélectionner la géométrie → *Properties → Geometry Editor* ;
2. choisir l'outil souhaité (par exemple **Rectangle**) ;
3. dessiner le contour.

Toutes les géométries doivent partager le même contour pour garantir leur alignement par la suite.

#### 5. Exporter les géométries « Combo » en SVG

Sélectionner chaque géométrie puis *File → Export → SVG* (autant de fichiers SVG que de géométries).

### 6.4 Inkscape *(facultatif)*

1. Ouvrir les fichiers SVG « Combo » et faire copier / coller.
2. Appliquer un **effet miroir** si nécessaire (réfléchir au résultat attendu).
3. Séparément, **dégrouper** puis **unir** les pistes d'un côté, les perçages de l'autre.
4. Regrouper chacun avec son contour respectif.
5. Aligner les deux fichiers via leurs contours.
6. Supprimer les contours superflus pour n'en conserver qu'un seul.
7. Enregistrer le tout dans un seul fichier SVG final.

> Option : conserver 2 contours est possible mais sans réel intérêt.

### 6.5 Easel — usinage CNC

#### Préparation du projet

1. *Nouveau projet* → donner un nom au projet (cliquer sur *Untitled*).
2. Régler l'unité en **millimètres**.
3. Spécifier le **matériau PCB** et ses dimensions — **surtout l'épaisseur** (PCB du Lab = **1,4 mm**).

> ⚠️ Appliquer un **miroir** si nécessaire (réfléchir au résultat).
>
> Vérifier la bonne superposition des SVG si besoin.

#### Gravure des pistes

> ⚠️ Vérifier de nouveau l'effet miroir.
>
> Important : **monter la fraise** et faire un **homing**.

**Fraise utilisée** : V-bits → *Other* → **pointe javelot 30°, 0,125 in (⅛ pouce)**.

**Cut settings** *(onglet Manual)* :

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

**Import du SVG** : *Project → Import SVG*. Le placer à l'origine via `Ctrl + A` puis position `X = 0`, `Y = 0` (veiller à avoir un remplissage interne sur la couche extérieure, ou équivalent).

Supprimer le contour et, au besoin, les trous de perçage. Combiner les pistes : `Ctrl + A` puis *Edit → Combine*.

**Définir la profondeur de passe et le mode** : `Ctrl + A` → *Cut* → `Depth = 0,1 mm` *(à vérifier — proposition : 0,2 mm ?)* → **Cut outside shape path**.

#### Perçages

> ⚠️ Vérifier l'effet miroir.
>
> 💡 Préparer le fichier pendant que la fraise refroidit !

- monter la fraise et faire un homing ;
- *Probe* → **Use Last XY Zero** ;
- ré-importer le SVG, le placer à `(0, 0)` (ou `Ctrl + Z`), puis supprimer le contour et les pistes ;
- au besoin, supprimer aussi tout reste de contour ou de pistes.

**Fraise utilisée** : 1/32 in (0,03125 in).

**Profondeur et mode** : `Ctrl + A` → *Cut* → `Depth = max` (+ ajouter `0,2 mm` via **Add depth**) → **Cut inside shape path**.

**Cut settings** :

| Paramètre | Valeur |
|---|---|
| Feed rate | 300 mm/min |
| Plunge rate | 100 mm/min |
| Depth per pass | 0,4 mm |

#### Découpe du contour

- **Work Zero** : *Manual* → **Use Last Position** ;
- ré-importer le SVG à `(0, 0)`, supprimer perçages et pistes (ou tracer directement le contour avec les outils d'Easel).

**Fraise utilisée** : 1/32 in.

**Profondeur et mode** : `Ctrl + A` → *Cut* → `Depth = max` (+ `0,2 mm` supplémentaires) → **Cut outside shape path**.

> Sans les **tabs** ?

**Cut settings** :

| Paramètre | Valeur |
|---|---|
| Feed rate | 300 mm/min |
| Plunge rate | 100 mm/min |
| Depth per pass | 0,4 mm |

#### Fixation de la plaque PCB

> 💡 Conseil : travailler **en bas à gauche** de la fraiseuse.

---

## 7. Et après ?

À définir : exposition, autres ateliers, création d'un club, prolongements logiciels et matériels…

---

## Notes éditoriales (à traiter)

- Harmoniser / reprendre la cohérence des notes encore en suspens.
- Vérifier les points marqués `?` (notamment indicateurs de non-connexion, valeur de profondeur à 0,1 ou 0,2 mm, pas à 2,34 ou 2,54 mm).
- Compléter la section « Et après ? ».
- Réinsérer les illustrations du document original aux emplacements pertinents (KiCad, FlatCam, Easel).