Files

T

Cédrix 4ec461b2f7 draft: Game & Watch DIY — Fabrication

2026-05-16 09:09:17 +02:00

42 KiB

Raw Blame History

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 :

Atelier 1 — Prototype et schématisation. Câblage sur platine d'expérimentation (breadboard), validation du code, puis transposition du schéma sous KiCad.
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.

#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 :

LCD seul : afficher "Vaisseau Pret!" puis effacer.
LCD + un bouton : afficher l'état du bouton.
LCD + buzzer : émettre un son au démarrage.
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

Ouvrir le fichier .kicad_sch.
Outil Ajouter un symbole (raccourci A).
Saisir le nom du composant en anglais : LED, Resistor, Buzzer, Switch_Push, Conn_01x16 (pour un connecteur 16 broches), etc.
Sélectionner le composant ; son symbole apparaît dans le volet de droite.
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.

#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 :

Sélectionner B.Cu géométrie + Edge.Cuts géométrie.
Edit → Join Geometry. Cela produit un objet Combo regroupant pistes + contour.

Pour les perçages :

Sélectionner PTH géométrie + Edge.Cuts géométrie.
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.

Ouvrir pistes_combo.svg.
Importer percages_combo.svg (Fichier → Importer).
Aligner les deux par leur contour (utiliser le contour Edge.Cuts commun comme référence).
Dégrouper les éléments (Ctrl+Maj+G).
Combiner les pistes ensemble (Ctrl+K), de même pour les perçages.
Affecter une couleur distincte à chaque groupe (rouge pour les pistes, bleu pour les perçages) pour les retrouver dans Easel.
Supprimer les contours superflus, n'en conserver qu'un seul.
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

New project, le nommer (cliquer sur Untitled).
Unités en millimètres.
Matériau : Other. Épaisseur 1,4 mm (PCB FR4 du fablab).
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 :

Insérer et serrer la fraise dans le mandrin.
Homing (retour à l'origine machine).
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 :

Changer la fraise.
Probe → Use Last XY Zero (on conserve la même origine X/Y, on redéfinit seulement Z).
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 :

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é :

Vérifier l'absence de court-circuit entre les rails +5 V et GND. Tester aussi Vin vs GND.
Vérifier la continuité de chaque piste prévue : poser une sonde à chaque extrémité de la piste, on doit entendre le bip.
Vérifier l'isolation : sur des pistes voisines, on ne doit PAS entendre de bip.
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 :

Cavaliers (ponts filaires) éventuels.
Résistance 220 Ω.
Connecteurs de barrette femelle pour l'Arduino (les broches qui s'enficheront sur l'Uno).
Potentiomètre de contraste.
Boutons-poussoirs (incluant le bouton Reset).
Cosses pour la pile 9 V.
Connecteur femelle pour le LCD (le LCD lui-même reste enfichable).
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

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).
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.
Avec le LCD : ajuster le potentiomètre de contraste jusqu'à voir les caractères.
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) 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.

42 KiB Raw Blame History Unescape Escape

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

1. Vue d'ensemble du projet

1.1 Objectif

1.2 Démarche

1.3 Versions des logiciels utilisés

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

2.1 Sécurité usinage CNC

2.2 Sécurité soudure

2.3 Liste de matériel par poste

3. Prototypage sur Arduino

3.1 Câblage du prototype

Écran LCD (mode 4 bits, prototype)

Boutons-poussoirs

Buzzer passif

3.2 Code du prototype

3.3 Validation du prototype

4. Règles de conception du PCB

4.1 Type de fabrication

4.2 Familles de composants

4.3 Outils de vérification dans KiCad

4.4 Broches non connectées

4.5 Angles des pistes

4.6 Routage soigné

4.7 Plan de masse

4.8 Découplage

4.9 Pas standard 2,54 mm

5. Conception sous KiCad

5.1 Créer le projet

5.2 Ajouter des composants au schéma

5.3 Attribuer les empreintes a posteriori

5.4 Câbler le schéma

5.5 Annoter et vérifier

5.6 Passer à l'éditeur de PCB

5.7 Paramétrer les contraintes

5.8 Router le PCB

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

6.1 Méthode itérative

6.2 Choix d'implantation

Équipements et positionnement

Dimensions

6.3 Autonomie sur pile 9 V

6.4 Réaffectation des broches pour le PCB

Brochage final du PCB

6.5 Code adapté au PCB final

6.6 Conseils de routage spécifiques

6.7 Contour de la carte

6.8 Validation finale

7. Préparation des fichiers et usinage CNC

7.1 Vue d'ensemble du flux

7.2 Étape 1 — Export depuis KiCad

Vérifier les contraintes une dernière fois

Exporter les Gerber

Exporter les perçages

7.3 Étape 2 — FlatCAM

Charger les fichiers

Convertir en géométries

Joindre les contours

Exporter en SVG

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

7.5 Étape 4 — Easel et usinage CNC

Préparer le projet

Fixer la plaque

Gravure des pistes (passe 1)

Perçages (passe 2)

Découpe du contour (passe 3)

Récupérer le PCB

8. Tests, soudure et mise en service

8.1 Tests avant soudure

8.2 Ordre de soudure recommandé

8.3 Premier démarrage

8.4 Points de test

9. Boîtier et finitions

9.1 Approches possibles

9.2 Contraintes à anticiper

10. Pour aller plus loin

10.1 Améliorations logicielles

10.2 Améliorations matérielles

10.3 Prolongements pédagogiques

11. Annexes

42 KiB

Raw Blame History