diff --git a/README.md b/README.md index 960fca9..8d932c5 100644 --- a/README.md +++ b/README.md @@ -1,125 +1,537 @@ # IMP3D Corrector -Correction de plan XYZ pour imprimantes 3D avec problèmes de calibration. +Outil de correction de plan XYZ pour imprimantes 3D avec probleme de calibration. Permet de detecter et compenser les erreurs mecaniques pour obtenir des impressions dimensionnellement correctes. -## Problèmes résolus +## Problemes resolus -- **Skew X-Y**: Axes X et Y non perpendiculaires -- **Erreurs d'échelle**: Dimensions incorrectes sur les bords -- **Décalage d'origine**: Position zéro mal alignée -- **Rotation du plateau**: Léger angle du plateau -- **Asymétries**: Différences de dimensions selon la position +- **Skew X-Y**: Axes X et Y non perpendiculaires (angle different de 90 degres) +- **Erreurs d'echelle**: Dimensions incorrectes (pieces trop grandes ou trop petites) +- **Decalage d'origine**: Position zero mal alignee +- **Rotation du plateau**: Legere rotation de l'ensemble du plateau +- **Asymetries**: Differences de dimensions selon la position sur le plateau ## Installation +### Prerequis + +- Python 3.8 ou superieur +- pip (gestionnaire de paquets Python) + +### Etapes d'installation + +1. Cloner le depot: + ```bash + git clone + cd imp3d_corrector + ``` + +2. Creer un environnement virtuel: + ```bash + python -m venv .venv + ``` + +3. Activer l'environnement virtuel: + ```bash + # Linux/macOS + source .venv/bin/activate + + # Windows + .venv\Scripts\activate + ``` + +4. Installer le paquet: + ```bash + pip install -e . + ``` + +5. Verifier l'installation: + ```bash + imp3d-corrector --help + ``` + +## Workflow de calibration complet + +### Etape 1: Generer le G-code de calibration + +La calibration avancee utilise 5 carres (4 coins + centre) pour detecter tous les problemes. + ```bash -python -m venv .venv -.venv/bin/pip install -e . +imp3d-corrector calibrate-advanced -w 220 -d 220 -o calibration.gcode ``` -## Utilisation +**Parametres disponibles:** -### Calibration simple (1 carré) - -Pour une calibration rapide: +| Parametre | Description | Defaut | +|-----------|-------------|--------| +| `-w, --width` | Largeur du plateau en mm | 220 | +| `-d, --depth` | Profondeur du plateau en mm | 220 | +| `-s, --size` | Taille des carres de test en mm | 30 | +| `-m, --margin` | Distance entre les coins du plateau et les carres en mm | 20 | +| `--nozzle-temp` | Temperature de la buse en C | 200 | +| `--bed-temp` | Temperature du plateau en C | 60 | +| `-o, --output` | Fichier de sortie | calibration_advanced.gcode | +**Exemple avec parametres personnalises:** ```bash -# Générer le G-code de calibration -imp3d-corrector calibrate -w 220 -d 220 -o calibration.gcode - -# Imprimer, mesurer, puis créer le profil -imp3d-corrector create ma_printer +imp3d-corrector calibrate-advanced \ + -w 250 -d 210 \ + -s 25 \ + -m 25 \ + --nozzle-temp 210 \ + --bed-temp 65 \ + -o ma_calibration.gcode ``` -### Calibration avancée (5 carrés) - RECOMMANDÉE +### Etape 2: Imprimer le fichier de calibration -Pour une calibration précise avec détection des problèmes: +1. Transferez le fichier `calibration.gcode` vers votre imprimante (carte SD, USB, reseau) +2. Lancez l'impression avec vos reglages habituels +3. Assurez-vous que l'adhesion au plateau est correcte (brim, raft si necessaire) +4. Laissez l'impression se terminer completement + +**Ce qui sera imprime:** +- 5 carres de la taille specifiee (defaut: 30mm) +- Position: 4 coins du plateau + centre +- Chaque carre a une epaisseur de 2 couches (0.6mm avec 0.3mm par couche) + +### Etape 3: Mesurer les carres + +Pour chaque carre, mesurez avec un pied a coulisse: + +1. **Cote X**: Largeur du carre dans l'axe X +2. **Cote Y**: Hauteur du carre dans l'axe Y +3. **Diagonale**: Diagonale du carre (important pour detecter le skew) + +**Ordre des positions:** +- Bas-Gauche (BL): coin inferieur gauche +- Bas-Droite (BR): coin inferieur droit +- Centre (C): centre du plateau +- Haut-Gauche (TL): coin superieur gauche +- Haut-Droite (TR): coin superieur droit + +**Valeurs attendues pour un carre de 30mm:** +- Cote X: 30.00 mm +- Cote Y: 30.00 mm +- Diagonale: 42.43 mm (30 * 1.414) + +### Etape 4: Creer le profil de calibration + +Lancez la creation de profil et entrez vos mesures: ```bash -# 1. Générer le G-code avec 5 carrés (coins + centre) -imp3d-corrector calibrate-advanced -w 220 -d 220 -o calibration_advanced.gcode - -# 2. Imprimer le fichier - -# 3. Mesurer chaque carré et créer le profil imp3d-corrector create-advanced ma_printer ``` -Le système analysera: -- **Échelle moyenne** (compensation globale) -- **Skew** (angle entre X et Y) -- **Asymétrie** (différence gauche/droite, haut/bas) -- **Variance** (uniformité des dimensions sur le plateau) +Le programme vous demandera: +1. Les dimensions du plateau +2. La taille des carres de test +3. Les mesures pour chaque position -### Analyser sans créer de profil +**Exemple de session:** +``` +Dimensions du plateau: + Largeur X (mm) [220]: 220 + Profondeur Y (mm) [220]: 220 + Taille des carres de test (mm) [30]: 30 + +--- Bas-Gauche (BL) --- + Cote X (mm): 30.12 + Cote Y (mm): 29.95 + Diagonale (mm): 42.50 + +--- Bas-Droite (BR) --- + Cote X (mm): 29.98 + ... +``` + +### Etape 5: Analyser le rapport + +Le programme affiche un rapport complet avec: +- Moyenne des mesures +- Ecart-type (uniformite) +- Erreur de skew detectee +- Asymetries gauche/droite et haut/bas +- Corrections recommandees + +**Exemple de rapport:** +``` +====================================================================== +RAPPORT DE CALIBRATION +====================================================================== + +Moyennes: + Echelle X: 1.0023 (+0.23%) + Echelle Y: 0.9987 (-0.13%) + Skew: -0.45 deg + +Asymetrie: + Gauche vs Droite: 0.15% + Haut vs Bas: 0.08% + +Variance (uniformite): + X: 0.12% + Y: 0.09% +``` + +### Etape 6: Appliquer les corrections + +Une fois le profil cree, appliquez-le a vos fichiers G-code: + +```bash +imp3d-corrector correct mon_modele.gcode -p ma_printer -o mon_modele_corrige.gcode +``` + +Le fichier corrige compense automatiquement: +- Les erreurs d'echelle (scale) +- L'angle entre les axes (skew) +- Le decalage d'origine (offset) +- La rotation du plateau + +## Reference des commandes + +### calibrate-advanced + +Genere un G-code de calibration avec 5 carres. + +```bash +imp3d-corrector calibrate-advanced [options] +``` + +**Options:** +- `-w, --width FLOAT`: Largeur du plateau en mm [defaut: 220] +- `-d, --depth FLOAT`: Profondeur du plateau en mm [defaut: 220] +- `-s, --size FLOAT`: Taille des carres en mm [defaut: 30] +- `-m, --margin FLOAT`: Marge depuis les bords en mm [defaut: 20] +- `--nozzle-temp INTEGER`: Temperature buse en C [defaut: 200] +- `--bed-temp INTEGER`: Temperature plateau en C [defaut: 60] +- `-o, --output PATH`: Fichier de sortie + +### create-advanced + +Cree un profil a partir des mesures multi-points. + +```bash +imp3d-corrector create-advanced +``` + +**Arguments:** +- `nom`: Nom du profil a creer + +**Processus interactif:** +1. Demande les dimensions du plateau +2. Demande la taille des carres +3. Pour chaque position: demande X, Y, diagonale +4. Affiche le rapport d'analyse +5. Propose des ajustements manuels +6. Sauvegarde le profil + +### correct + +Applique la correction a un fichier G-code. + +```bash +imp3d-corrector correct -p [-o ] +``` + +**Arguments:** +- `input`: Fichier G-code a corriger + +**Options:** +- `-p, --profile TEXT`: Profil a utiliser (obligatoire) +- `-o, --output PATH`: Fichier de sortie [defaut: _corrected.gcode] + +**Exemple:** +```bash +imp3d-corrector correct benchy.gcode -p ender3 -o benchy_corrige.gcode +``` + +### list + +Liste tous les profils disponibles. + +```bash +imp3d-corrector list +``` + +Affiche pour chaque profil: +- Nom +- Dimensions du plateau +- Skew et echelles + +### show + +Affiche les details d'un profil. + +```bash +imp3d-corrector show +``` + +**Informations affichees:** +- Dimensions du plateau +- Offset X et Y +- Facteurs d'echelle X et Y +- Angle de skew +- Rotation + +### edit + +Modifie un profil existant. + +```bash +imp3d-corrector edit +``` + +Permet de modifier interactivement: +- Tous les parametres de calibration + +### delete + +Supprime un profil. + +```bash +imp3d-corrector delete +``` + +Demande confirmation avant suppression. + +### analyze + +Analyse des mesures sans creer de profil. ```bash imp3d-corrector analyze ``` -### Appliquer les corrections +Utile pour: +- Diagnostiquer des problemes avant de creer un profil +- Comparer differentes configurations +- Verifier l'evolution de l'imprimante dans le temps + +### calibrate + +Genere un G-code de calibration simple (1 carre au centre). ```bash -imp3d-corrector correct mon_fichier.gcode -p ma_printer -o fichier_corrigé.gcode +imp3d-corrector calibrate [-w WIDTH] [-d DEPTH] [-o OUTPUT] ``` -### Gestion des profils +**Usage recommande:** Validation rapide apres calibration avancee. + +### create + +Cree un profil simple a partir d'un seul carre. ```bash -# Lister les profils -imp3d-corrector list +imp3d-corrector create +``` -# Afficher un profil -imp3d-corrector show ma_printer +**Usage recommande:** Configuration rapide, moins precis que create-advanced. -# Modifier un profil +## Fichier de configuration + +### Emplacement + +Les profils sont stockes dans: +``` +~/.config/imp3d_corrector/profiles/.yaml +``` + +### Structure d'un profil + +```yaml +# Informations de base +name: ma_printer + +# Dimensions du plateau +bed_width: 220.0 # Largeur en mm (axe X) +bed_depth: 220.0 # Profondeur en mm (axe Y) + +# Corrections de calibration +skew_xy: -0.45 # Angle de skew en degres + # Positif = Y tourne vers X + # Negatif = Y tourne vers -X + +offset_x: 0.0 # Decalage origine X en mm +offset_y: 0.0 # Decalage origine Y en mm + +scale_x: 1.0023 # Facteur d'echelle X + # >1.0 agrandit, <1.0 retrecit + # Exemple: 1.0023 corrige 100mm mesure a 99.77mm + +scale_y: 0.9987 # Facteur d'echelle Y + +rotation: 0.0 # Rotation du plateau en degres + +# Parametres de generation G-code +calibration_margin: 20 # Marge pour les carres de test +square_size: 30 # Taille des carres de test +nozzle_temp: 200 # Temperature buse +bed_temp: 60 # Temperature plateau +``` + +### Modification manuelle + +Vous pouvez editer directement les fichiers YAML: + +```bash +nano ~/.config/imp3d_corrector/profiles/ma_printer.yaml +``` + +Ou utiliser la commande edit: +```bash imp3d-corrector edit ma_printer - -# Supprimer un profil -imp3d-corrector delete ma_printer ``` +## Interpretation des resultats + +### Skew eleve (|skew_xy| > 1.0) + +**Cause probable:** Axes X et Y non perpendiculaires. + +**Solutions:** +1. Ajustement mecanique: Verifier l'alignement des rails et courroies +2. Compensation logicielle: Le profil corrige automatiquement le skew + +### Asymetrie X ou Y elevee (> 0.5%) + +**Cause probable:** Tension de courroie inegale. + +**Solutions:** +1. Verifier la tension des courroies X et Y +2. S'assurer que les poulies sont alignees +3. Controler l'usure des roulements + +### Variance elevee (> 0.3%) + +**Cause probable:** Probleme de linearite des rails. + +**Solutions:** +1. Nettoyer et lubrifier les rails +2. Verifier l'etat des roulements +3. Controler la tension des courroies + +### Echelle incorrecte mais uniforme + +**Cause probable:** Pas de moteur ou diametre de courroie incorrects. + +**Solutions:** +1. Verifier les reglages steps/mm dans le firmware +2. Le profil compense automatiquement via scale_x et scale_y + +## G-code de calibration: details techniques + +### Sequence d'impression + +Le G-code genere suit cette sequence: + +1. **Prechauffage** + - M140 S{bed_temp}: Demarre le chauffage du plateau + - M104 S{nozzle_temp}: Demarre le chauffage de la buse + - M190 S{bed_temp}: Attend que le plateau soit a temperature + - M109 S{nozzle_temp}: Attend que la buse soit a temperature + +2. **Initialisation** + - G28: Home tous les axes + - G90: Positionnement absolu + - M82: Extrusion absolue + - G92 E0: Reset de l'extrusion + +3. **Ligne de priming** (60mm) + - Trace une ligne pour assurer le flux de filament + - Nettoie la buse avant l'impression des carres + +4. **Impression des 5 carres** + - Pour chaque carre: + - Retraction (1mm) + - Deplacement au point de depart + - Prime (2mm) + - Impression du carre (2 couches) + +5. **Fin** + - G28 X Y: Home X et Y + - M104 S0: Eteint la buse + - M140 S0: Eteint le plateau + - M84: Desactive les moteurs + +### Parametres d'impression + +| Parametre | Valeur | Description | +|-----------|--------|-------------| +| Layer height | 0.3 mm | Epaisseur de couche | +| Line width | 0.45 mm | Largeur de ligne | +| Print speed | 30 mm/s | Vitesse d'impression | +| Travel speed | 100 mm/s | Vitesse de deplacement | +| Retraction | 1.0 mm | Distance de retraction | +| Prime amount | 2.0 mm | Extra extrusion apres deplacement | + +### Calcul d'extrusion + +L'extrusion est calculee selon la formule: +``` +E = distance * (layer_height * line_width) / (pi * filament_diameter^2 / 4) +``` + +Avec filament_diameter = 1.75mm par defaut. + ## Structure du projet ``` imp3d_corrector/ -├── cli.py # Interface en ligne de commande +├── cli.py # Interface ligne de commande ├── config/ -│ └── profile_manager.py # Gestion des profils +│ ├── __init__.py +│ └── profile_manager.py # Gestion des profils YAML └── core/ - ├── corrector.py # Logique de correction XYZ - ├── gcode_parser.py # Parser G-code - └── advanced_calibration.py # Calibration multi-points + ├── __init__.py + ├── corrector.py # Logique de correction XYZ + ├── gcode_parser.py # Parser G-code + └── advanced_calibration.py # Calibration multi-points ``` -## Workflow recommandé +## Resolution de problemes -1. **Première calibration**: Utilisez `calibrate-advanced` pour avoir une vue complète -2. **Analysez** les résultats - si des problèmes d'asymétrie sont détectés, vérifiez votre matériel -3. **Créez le profil** avec les corrections calculées -4. **Testez** avec un carré simple pour valider +### Le G-code ne s'imprime pas correctement -## Exemple de configuration YAML +1. **Verifiez les temperatures:** + ```bash + imp3d-corrector calibrate-advanced --nozzle-temp 210 --bed-temp 65 + ``` -Les profils sont stockés dans `~/.config/imp3d_corrector/profiles/`: +2. **Augmentez la marge si les carres debordent:** + ```bash + imp3d-corrector calibrate-advanced -m 30 + ``` -```yaml -name: ma_printer -skew_xy: 0.5 -offset_x: 0.0 -offset_y: 0.0 -scale_x: 1.002 -scale_y: 0.998 -rotation: 0.0 -bed_width: 220.0 -bed_depth: 220.0 +3. **Reduisez la vitesse dans le slicer** pour les premieres couches + +### Les mesures semblent incoherentes + +1. **Verifiez votre pied a coulisse** (etalonnage) +2. **Mesurez plusieurs fois** et faites la moyenne +3. **Assurez-vous que les carres sont bien colles** au plateau + +### La correction ne semble pas fonctionner + +1. **Verifiez que le profil existe:** + ```bash + imp3d-corrector list + ``` + +2. **Verifiez le profil:** + ```bash + imp3d-corrector show ma_printer + ``` + +3. **Imprimez un carre de validation** apres correction + +### Erreur "profil existe deja" + +Le programme demande confirmation avant d'ecraser: ``` +Le profil 'ma_printer' existe deja. Ecraser? (o/N): +``` +Repondez 'o' pour ecraser. -## Interprétation des résultats +## Licence -| Problème détecté | Cause probable | Solution | -|-----------------|----------------|----------| -| Skew élevé | Axes non perpendiculaires | Ajustement mécanique ou compensation logicielle | -| Asymétrie X | Courroie X détendue d'un côté | Vérifier la tension de courroie | -| Asymétrie Y | Courroie Y détendue d'un côté | Vérifier la tension de courroie | -| Variance élevée | Problème de linéarité | Vérifier les rails/roulements | +MIT License - voir le fichier LICENSE pour plus de details. diff --git a/config.example.yaml b/config.example.yaml index 2528c20..623a822 100644 --- a/config.example.yaml +++ b/config.example.yaml @@ -1,10 +1,53 @@ +# IMP3D Corrector - Exemple de configuration de profil +# Ce fichier montre les parametres disponibles pour un profil de calibration +# Copiez ce fichier et adaptez-le a votre imprimante + +# === Informations de base === name: example_printer -skew_xy: 0.5 -offset_x: 0.0 -offset_y: 0.0 -scale_x: 1.002 -scale_y: 0.998 -rotation: 0.0 -bed_width: 220.0 -bed_depth: 220.0 + +# === Dimensions du plateau === +bed_width: 220.0 # Largeur du plateau en mm (axe X) +bed_depth: 220.0 # Profondeur du plateau en mm (axe Y) + +# === Corrections de calibration === +# Ces valeurs sont calculees automatiquement par le processus de calibration +# Vous pouvez aussi les ajuster manuellement si necessaire + +skew_xy: 0.0 # Angle de skew entre X et Y en degres + # Positif = Y tourne vers X + # Negatif = Y tourne vers -X + # Valeur typique: -2.0 a 2.0 + +offset_x: 0.0 # Decalage de l'origine sur X en mm +offset_y: 0.0 # Decalage de l'origine sur Y en mm + +scale_x: 1.000 # Facteur d'echelle sur X + # >1.0 = agrandit, <1.0 = retrecit + # Exemple: 1.002 corrige une piece de 100mm mesuree a 99.8mm + +scale_y: 1.000 # Facteur d'echelle sur Y + +rotation: 0.0 # Rotation du plateau en degres + +# === Parametres de calibration (utilises pour generer le G-code) === +calibration_margin: 20 # Distance entre les coins du plateau et les carres de test + # Augmentez si vos carres sont hors du plateau + # Valeur recommandee: 15-30 mm + +square_size: 30 # Taille des carres de test en mm + # Valeur recommandee: 20-50 mm + +# === Parametres d'impression pour le G-code de calibration === +nozzle_temp: 200 # Temperature de la buse en C +bed_temp: 60 # Temperature du plateau en C + +# === Points de calibration avances (rempli automatiquement) === calibration_points: [] +# Format apres calibration avancee: +# calibration_points: +# - position: center +# measured_x: 30.05 +# measured_y: 29.98 +# measured_diagonal: 42.40 +# - position: bottom_left +# ... diff --git a/imp3d_corrector/cli.py b/imp3d_corrector/cli.py index ba77542..6b7636a 100644 --- a/imp3d_corrector/cli.py +++ b/imp3d_corrector/cli.py @@ -165,12 +165,14 @@ def cmd_generate_calibration(args): def cmd_generate_advanced_calibration(args): - """Génère un G-code de calibration avancé (5 carrés).""" + """Genere un G-code de calibration avance (5 carres).""" generator = AdvancedCalibrationGCode( bed_width=args.width or 220, bed_depth=args.depth or 220, square_size=args.size or 30, - margin=args.margin or 15 + margin=args.margin or 20, + nozzle_temp=args.nozzle_temp, + bed_temp=args.bed_temp ) gcode = generator.generate() @@ -380,11 +382,13 @@ def main(): # Commande: calibrate-advanced cal_adv_parser = subparsers.add_parser('calibrate-advanced', - help='Générer un G-code de calibration avancé (5 carrés)') + help='Generer un G-code de calibration avance (5 carres)') cal_adv_parser.add_argument('-w', '--width', type=float, help='Largeur du plateau (mm)') cal_adv_parser.add_argument('-d', '--depth', type=float, help='Profondeur du plateau (mm)') - cal_adv_parser.add_argument('-s', '--size', type=float, help='Taille des carrés (mm) [30]') - cal_adv_parser.add_argument('-m', '--margin', type=float, help='Marge depuis les bords (mm) [15]') + cal_adv_parser.add_argument('-s', '--size', type=float, help='Taille des carres (mm) [30]') + cal_adv_parser.add_argument('-m', '--margin', type=float, help='Marge depuis les bords (mm) [20]') + cal_adv_parser.add_argument('--nozzle-temp', type=int, dest='nozzle_temp', help='Temperature buse (C) [200]') + cal_adv_parser.add_argument('--bed-temp', type=int, dest='bed_temp', help='Temperature plateau (C) [60]') cal_adv_parser.add_argument('-o', '--output', help='Fichier de sortie') cal_adv_parser.set_defaults(func=cmd_generate_advanced_calibration) diff --git a/imp3d_corrector/core/advanced_calibration.py b/imp3d_corrector/core/advanced_calibration.py index 3f4d285..21d63a2 100644 --- a/imp3d_corrector/core/advanced_calibration.py +++ b/imp3d_corrector/core/advanced_calibration.py @@ -239,14 +239,74 @@ class MultiPointCalibration: class AdvancedCalibrationGCode: - """Générateur de G-code de calibration avancé.""" + """Generateur de G-code de calibration avance. + + Genere un fichier G-code avec 5 carres de test (4 coins + centre) + pour permettre une calibration complete du plateau. + """ + + # Parametres d'impression par defaut + DEFAULT_NOZZLE_TEMP = 200 # Temperature buse (C) + DEFAULT_BED_TEMP = 60 # Temperature plateau (C) + DEFAULT_LAYER_HEIGHT = 0.3 # Hauteur de couche (mm) + DEFAULT_LINE_WIDTH = 0.45 # Largeur de ligne (mm) + DEFAULT_PRINT_SPEED = 30 # Vitesse d'impression (mm/s) + DEFAULT_TRAVEL_SPEED = 100 # Vitesse de deplacement (mm/s) + DEFAULT_RETRACTION = 1.0 # Retraction (mm) + DEFAULT_PRIME_AMOUNT = 2.0 # Quantite de prime apres retraction (mm) def __init__(self, bed_width: float = 220.0, bed_depth: float = 220.0, - square_size: float = 30.0, margin: float = 15.0): + square_size: float = 30.0, margin: float = 20.0, + nozzle_temp: int = None, bed_temp: int = None): self.bed_width = bed_width self.bed_depth = bed_depth self.square_size = square_size self.margin = margin + self.nozzle_temp = nozzle_temp or self.DEFAULT_NOZZLE_TEMP + self.bed_temp = bed_temp or self.DEFAULT_BED_TEMP + + def _calc_extrusion(self, distance: float) -> float: + """Calcule la quantite d'extrusion pour une distance donnee. + + Base sur: E = distance * (layer_height * line_width) / (pi * filament_diameter^2 / 4) + Avec filament de 1.75mm et les parametres par defaut. + """ + layer_h = self.DEFAULT_LAYER_HEIGHT + line_w = self.DEFAULT_LINE_WIDTH + filament_diameter = 1.75 + + # Section du filament + filament_area = math.pi * (filament_diameter / 2) ** 2 + + # Volume de plastique depose + volume = distance * layer_h * line_w + + return volume / filament_area + + def _generate_priming_line(self, start_x: float, start_y: float) -> tuple: + """Genere une ligne de priming pour preparer le filament. + + Retourne (lignes_gcode, nouvelle_position_x, nouvelle_position_y, nouvelle_extrusion) + """ + lines = [] + prime_length = 60 # Longueur de la ligne de prime (mm) + prime_speed = 40 # mm/s + + lines.append("; === Ligne de priming ===") + lines.append(f"G1 X{start_x:.3f} Y{start_y:.3f} F{self.DEFAULT_TRAVEL_SPEED * 60}") + lines.append(f"G1 Z{self.DEFAULT_LAYER_HEIGHT:.3f} F{30 * 60}") + + # Ligne de prime + extrusion = self._calc_extrusion(prime_length) * 1.5 # Un peu plus pour bien amorcer + lines.append(f"G1 X{start_x + prime_length:.3f} Y{start_y:.3f} E{extrusion:.3f} F{prime_speed * 60}") + + # Petit aller-retour pour nettoyer + current_e = extrusion + extrusion = current_e + self._calc_extrusion(10) + lines.append(f"G1 X{start_x + prime_length:.3f} Y{start_y + 10:.3f} E{extrusion:.3f} F{self.DEFAULT_PRINT_SPEED * 60}") + current_e = extrusion + + return lines, start_x + prime_length, start_y + 10, current_e def get_positions(self) -> Dict[CalibrationPosition, Tuple[float, float]]: """Retourne les positions centrales de chaque carré.""" @@ -265,39 +325,70 @@ class AdvancedCalibrationGCode: return positions def generate(self, include_labels: bool = True) -> str: - """Génère le G-code de calibration complet.""" + """Genere le G-code de calibration complet. + + Inclut: + - Prechauffage buse et plateau + - Ligne de priming pour preparer le filament + - 5 carres de test avec retraction entre chaque + - Fin d'impression propre + """ positions = self.get_positions() + print_speed = self.DEFAULT_PRINT_SPEED * 60 # mm/min + travel_speed = self.DEFAULT_TRAVEL_SPEED * 60 # mm/min + z_speed = 30 * 60 # mm/min pour Z lines = [ - "; " + "=" * 50, - "; G-CODE DE CALIBRATION AVANCÉ", - "; " + "=" * 50, + "; " + "=" * 60, + "; G-CODE DE CALIBRATION AVANCE - IMP3D CORRECTOR", + "; " + "=" * 60, f"; Plateau: {self.bed_width} x {self.bed_depth} mm", - f"; Carrés de test: {self.square_size} x {self.square_size} mm", + f"; Carres de test: {self.square_size} x {self.square_size} mm", + f"; Marge des coins: {self.margin} mm", + f"; Temperature buse: {self.nozzle_temp} C", + f"; Temperature plateau: {self.bed_temp} C", ";", - "; Instructions:", + "; INSTRUCTIONS:", "; 1. Imprimez ce fichier", - "; 2. Mesurez CHAQUE carré (X, Y, diagonale)", + "; 2. Mesurez CHAQUE carre (X, Y, diagonale) avec un pied a coulisse", "; 3. Notez les valeurs pour chaque position", "; 4. Utilisez 'imp3d-corrector calibrate-advanced' pour entrer les mesures", ";", - "; Positions:", - "; TL = Top Left (haut gauche)", - "; TR = Top Right (haut droit)", - "; BL = Bottom Left (bas gauche)", - "; BR = Bottom Right (bas droit)", - "; C = Center (centre)", - "; " + "=" * 50, + "; POSITIONS DES CARRES:", + "; BL = Bottom Left (bas gauche) - coin inferieur gauche", + "; BR = Bottom Right (bas droit) - coin inferieur droit", + "; C = Center (centre) - centre du plateau", + "; TL = Top Left (haut gauche) - coin superieur gauche", + "; TR = Top Right (haut droit) - coin superieur droit", + "; " + "=" * 60, "", - "G21 ; Unités en millimètres", + "; === INITIALISATION ===", + "G21 ; Unites en millimetres", "G90 ; Positionnement absolu", "M82 ; Extrusion absolue", - "G28 ; Home", - "G1 Z10 F3000 ; Monter la buse", + "M107 ; Ventilateur off", + "", + "; === PRECHAUFFAGE ===", + f"M140 S{self.bed_temp} ; Prechauffer le plateau", + f"M104 S{self.nozzle_temp} ; Prechauffer la buse", + f"M190 S{self.bed_temp} ; Attendre temperature plateau", + f"M109 S{self.nozzle_temp} ; Attendre temperature buse", + "", + "; === HOMING ===", + "G28 ; Home tous les axes", + f"G1 Z5 F{z_speed} ; Monter la buse", + "M106 S127 ; Ventilateur a 50%", "", ] - extrusion = 0 + # Generer la ligne de priming + prime_x = self.margin + prime_y = self.margin + prime_lines, prime_end_x, prime_end_y, current_e = self._generate_priming_line(prime_x, prime_y) + lines.extend(prime_lines) + lines.append("") + + # Ordre d'impression optimise pour minimiser les deplacements order = [ CalibrationPosition.BOTTOM_LEFT, CalibrationPosition.BOTTOM_RIGHT, @@ -318,38 +409,72 @@ class AdvancedCalibrationGCode: CalibrationPosition.TOP_RIGHT: "TR", }[pos] - lines.append(f"; --- Carré {label} ({pos.value}) ---") + lines.append(f"; " + "-" * 50) + lines.append(f"; === CARRE {label} ({pos.value}) ===") lines.append(f"; Position centre: X={cx:.1f} Y={cy:.1f}") + lines.append(f"; Taille attendue: {self.square_size} mm") - # Aller au point de départ - lines.append(f"G1 X{cx - half:.3f} Y{cy - half:.3f} F6000") - lines.append("G1 Z0.3 F3000") + # Retraction avant deplacement + retracted_e = current_e - self.DEFAULT_RETRACTION + lines.append(f"; Retraction") + lines.append(f"G1 E{retracted_e:.3f} F{40 * 60}") - # Dessiner le carré - extrusion += 5 - lines.append(f"G1 X{cx + half:.3f} Y{cy - half:.3f} E{extrusion:.1f} F1500") - extrusion += 5 - lines.append(f"G1 X{cx + half:.3f} Y{cy + half:.3f} E{extrusion:.1f} F1500") - extrusion += 5 - lines.append(f"G1 X{cx - half:.3f} Y{cy + half:.3f} E{extrusion:.1f} F1500") - extrusion += 5 - lines.append(f"G1 X{cx - half:.3f} Y{cy - half:.3f} E{extrusion:.1f} F1500") + # Monter et aller au point de depart du carre + lines.append(f"G1 Z{self.DEFAULT_LAYER_HEIGHT + 2:.3f} F{z_speed}") + start_x = cx - half + start_y = cy - half + lines.append(f"G1 X{start_x:.3f} Y{start_y:.3f} F{travel_speed}") - lines.append("G1 Z2 F3000") + # Deretraction (prime) + prime_e = retracted_e + self.DEFAULT_RETRACTION + self.DEFAULT_PRIME_AMOUNT + lines.append(f"; Prime") + lines.append(f"G1 E{prime_e:.3f} F{40 * 60}") + current_e = prime_e + + # Descendre et dessiner le carre + lines.append(f"G1 Z{self.DEFAULT_LAYER_HEIGHT:.3f} F{z_speed}") + lines.append(f"; Dessin du carre") + + # Cote 1: bas (X- vers X+) + dist = self.square_size + current_e += self._calc_extrusion(dist) + lines.append(f"G1 X{cx + half:.3f} Y{start_y:.3f} E{current_e:.3f} F{print_speed}") + + # Cote 2: droit (Y- vers Y+) + current_e += self._calc_extrusion(dist) + lines.append(f"G1 X{cx + half:.3f} Y{cy + half:.3f} E{current_e:.3f} F{print_speed}") + + # Cote 3: haut (X+ vers X-) + current_e += self._calc_extrusion(dist) + lines.append(f"G1 X{start_x:.3f} Y{cy + half:.3f} E{current_e:.3f} F{print_speed}") + + # Cote 4: gauche (Y+ vers Y-) + current_e += self._calc_extrusion(dist) + lines.append(f"G1 X{start_x:.3f} Y{start_y:.3f} E{current_e:.3f} F{print_speed}") + + lines.append(f"G1 Z{self.DEFAULT_LAYER_HEIGHT + 2:.3f} F{z_speed}") lines.append("") # Terminer - lines.append("; --- Fin ---") - lines.append("G1 Z10 F3000") - lines.append(f"G1 X0 Y{self.bed_depth} F6000") - lines.append("M84 ; Désactiver les moteurs") + lines.append("; " + "=" * 60) + lines.append("; === FIN D'IMPRESSION ===") + lines.append(f"G1 Z{self.DEFAULT_LAYER_HEIGHT + 10:.3f} F{z_speed}") + lines.append(f"G1 X0 Y{self.bed_depth} F{travel_speed}") + lines.append("M106 S0 ; Ventilateur off") + lines.append("M104 S0 ; Buse off") + lines.append("M140 S0 ; Plateau off") + lines.append("M84 ; Desactiver les moteurs") lines.append("") - lines.append("; " + "=" * 50) - lines.append("; MESURES À PRENDRE:") - lines.append("; Pour chaque carré, mesurez:") - lines.append(f"; - Côté X (attendu: {self.square_size} mm)") - lines.append(f"; - Côté Y (attendu: {self.square_size} mm)") + lines.append("; " + "=" * 60) + lines.append("; MESURES A PRENDRE APRES IMPRESSION:") + lines.append("; Pour chaque carre, mesurez avec un pied a coulisse:") + lines.append(f"; - Cote X (attendu: {self.square_size} mm)") + lines.append(f"; - Cote Y (attendu: {self.square_size} mm)") lines.append(f"; - Diagonale (attendu: {self.square_size * 1.414:.2f} mm)") - lines.append("; " + "=" * 50) + lines.append(";") + lines.append("; Puis utilisez:") + lines.append("; imp3d-corrector calibrate-advanced") + lines.append("; pour entrer les mesures et calculer les corrections") + lines.append("; " + "=" * 60) return "\n".join(lines)