publish: Game & Watch DIY — Du prototype à la console fabriquée
This commit is contained in:
Cédrix
@@ -1,17 +0,0 @@
|
||||
{
|
||||
"title": "Game & Watch DIY — Du prototype à la console fabriquée",
|
||||
"_updated_at": "2026-05-16 07:09:29",
|
||||
"slug": "game-watch-diy-fabrication",
|
||||
"published": true,
|
||||
"published_at": "2026-05-15 16:00",
|
||||
"category": "fablab",
|
||||
"tags": {
|
||||
"tags": [
|
||||
"DIY",
|
||||
"Arduino Uno",
|
||||
"Game & Watch"
|
||||
]
|
||||
},
|
||||
"seo_title": "",
|
||||
"seo_description": ""
|
||||
}
|
||||
@@ -1,936 +0,0 @@
|
||||
# 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.
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,14 +1,21 @@
|
||||
{
|
||||
"uuid": "a9474a83-43b3-484c-950e-37a27ff663fe",
|
||||
"slug": "game-watch-diy-fabrication",
|
||||
"title": "Game & Watch DIY — Fabrication",
|
||||
"title": "Game & Watch DIY — Du prototype à la console fabriquée",
|
||||
"author": "cedric@abonnel.fr",
|
||||
"published": true,
|
||||
"featured": false,
|
||||
"published_at": "2026-05-15 16:00",
|
||||
"created_at": "2026-05-13 18:12:54",
|
||||
"updated_at": "2026-05-16 07:00:22",
|
||||
"revisions": [],
|
||||
"updated_at": "2026-05-16 07:09:55",
|
||||
"revisions": [
|
||||
{
|
||||
"n": 1,
|
||||
"date": "2026-05-16 07:09:55",
|
||||
"comment": "Titre modifié, contenu modifié",
|
||||
"title": "Game & Watch DIY — Fabrication"
|
||||
}
|
||||
],
|
||||
"cover": "cover.svg",
|
||||
"files_meta": {
|
||||
"9ae9bc58c13ca70c-56046.jpg": {
|
||||
|
||||
@@ -0,0 +1,783 @@
|
||||
# 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).
|
||||
Reference in New Issue
Block a user