plantage de Pronterface et ideamakers avec fichier gcode (poids supérieurs 200Mo)

[sudtek]

Bonjour à tous ,

j'ai dessiné une pièce en 3D paramétrique sous Catia pour faire un aspirateur cyclone grand format en deux parties et forte épaisseur 5mm section 200mx200 par 300mm de hauteur chacune. 

 

 

Je sclice le STL de la partie supérieure "la chambre" sous ideamaker avec mes paramètres habituels et mon  I3 et 8Go de ram c'est lent mais j'obtiens un fichier gcode de 256Mo pour 130 heures de print que je sauvegarde.

PB : 1 si je veux re loader le fichier gcode dans ideamaker ca mouline de la mort ... et fini par planter... j'ai testé sur une autre machine i7 16Go idem plantage direct + freeze de la machine ... (les deux sont sous windows 7 et il y a des ssd et du cache à gogo.

PB 2 : Si je veux imprimer sur ma X1 ce gros fichier je passe par pronterface sur un pc linux lenovo + 4 go de ram et ssd mais pronterface :

- met des lustres pour loader le fichier dans pronterface.

- Je visualise bien le fichier en rouge mais si je touche la souris pour manipuler le fichier dans l'espace ca plante systématiquement.

- Si l'économiseur d'écran se lance le pc freeze alors que habituellement tout va bien.

légende : La led vert c'est le SSD qui pédale a fond et bloque le pc impossible de reprendre la main ... Je peux rajouter du swap mais bon c'est quand même du SSD le support de ce pc cela devrait loader un fichier de 256Mo. 

J'ai comme l'impression que passé une certaine taille de fichier GCODE pronterface maximum et cela débloque sec ... et part en vrille !

certains ont-ils déjà eu ce cas ?

A titre d'information quels sont les plus gros slice que vous ayez fait en mo ? avez-vous eu des pb de ce style ?

merci pour votre aide

SUDSUD

 

 

Modifié (le) Juin 4, 2024 par sudtek
oublie photo ecran ...

[PPAC]

Salutation !

 

Et si tu passe ton fichier .gcode dans ArcWelder ? ( https://github.com/FormerLurker/ArcWelderLib pour plus d'info voir la description de la version plugin Octo Print https://plugins.octoprint.org/plugins/arc_welder/ )

 

Aussi souvent on conseil de ne pas imprimer depuis un PC car la moindre charge sur le PC ( mise a jour Windows, économiseur d'écran un peut gourmand (ou si il y a d'activé le mode économie d’énergie qui coupe l'USB) , visualiser en 3D l'impression en cours dans une fenêtre en plein écran sans une carte graphique suffisamment puissante ou sans les bon driver de la carte graphique et paramétrage de l'accélération de l'affichage si la carte graphique le permet ) , scan anti-virus, ... ) ou le moindre parasitage du câble USB, peut planter la connexion USB série.

 

Donc je dirais de tenter une impression depuis une carte SD, de la version passé sous ArcWelder.

 

Sinon pour le plus gros .gcode que j'ai imprimé je dirais 100 Mo ( mais toujours depuis une carte SD ou clé USB pour éviter les problème de déco d'une liaison USB série)

[sudtek]

Bonjour PPAC,

Citation

Aussi souvent on conseil de ne pas imprimer depuis un PC car la moindre charge sur le PC ( mise a jour Windows, économiseur d'écran un peut gourmand (ou si il y a d'activé le mode économie d’énergie qui coupe l'USB) , visualiser en 3D l'impression en cours dans une fenêtre en plein écran sans une carte graphique suffisamment puissante ou sans les bon driver de la carte graphique et paramétrage de l'accélération de l'affichage si la carte graphique le permet ) , scan anti-virus, ... ) ou le moindre parasitage du câble USB, peut planter la connexion USB série.

oui mais .... pour une raison que j'ignore ma X1 qui avait eu des des soucis la CM il ya 2 / 3 ans avait plantée et cramé pendant une impression. Elle a été remplacé avec l'aide de MrMagounet on a réussi à la faire "revenir d'entre les morts " le truc c'est que malgré tout nos efforts via des clef usb les impressions posent pbs (le ports usb a aussi été remplacé et les clefs sont cleans et mise à zero avec dd avant reformatage + tests ) ... mais  la X1 plante aléatoirement si on utilise une clef USB alors que les impressions via pronterface posent pas de pb. Je suis sur du Xubuntu en hyperminimaliste même pas une mise a jour possible pendant impression car hors réseaux  et j'ai viré l'économiseur d'écran dans le doute. Pronterface utilisé en SU au cas ou. Coté ram j'ai 4go et un swap fixe 22G le tout sur du SSD. Dmesg ne remonte pas de pb donc en théorie cela devrait être bon mais je pense que je vais essayer de tester avec  une version de pronterface plus récente car celle doit dater.

Merci PPAC pour ton retour d'information c'est très intéressant merci m'avoir fait découvrir ArcWelder .... même si c'est violent comme soft !

je reposte ici la traduction et informations de arcwelder pour mémoire car mon hex de marlin 2.1.2.1 n'intègre pas cette fonction à la dernière compilation ... je vais tester plus tard des que j'ai chopé une autre imprimante 3D car cela m'intéresse de tester ce mode d'interpolation pour tester mais avant j'ai besoin d'avoir une autre imprimante qui tourne à coté pour imprimer mes pièces. comme dit le proverbe survivaliste : 1 c'est 0, 2 c'est 1 et 3 c'est 2 !

Lien Référence G2-G3 - Arc or Circle Move de chez marlin : https://marlinfw.org/docs/gcode/G002-G003.html

Pour activer les commandes G2 et G3 dans le firmware Marlin pour imprimantes 3D, il faut tout d'abord s'assurer que la fonctionnalité "ARC_SUPPORT" est activée dans le fichier de configuration du firmware. -> ok j'ai un merlin 2.1.2.1 qui supporte les fonctions G2 et G3 mais également G5  mais je vais devoir recompiler.

Note perso 1 :  Ne pas oublier de décommenter le bloc CNC_WORKSPACE_PLANES

Note perso 2 : Pour mémoire dispo dans fichier Configuration_adv.h ligne 2284 

 

 G2/G3 Arc Support
//
#define ARC_SUPPORT                   // Requires ~3226 bytes
#if ENABLED(ARC_SUPPORT)
  #define MIN_ARC_SEGMENT_MM      0.1 // (mm) Minimum length of each arc segment
  #define MAX_ARC_SEGMENT_MM      1.0 // (mm) Maximum length of each arc segment
  #define MIN_CIRCLE_SEGMENTS    72   // Minimum number of segments in a complete circle
  //#define ARC_SEGMENTS_PER_SEC 50   // Use the feedrate to choose the segment length
  #define N_ARC_CORRECTION       25   // Number of interpolated segments between corrections
  //#define ARC_P_CIRCLES             // Enable the 'P' parameter to specify complete circles
  //#define SF_ARC_FIX                // Enable only if using SkeinForge with "Arc Point" fillet procedure
#endif

// G5 Bézier Curve Support with XYZE destination and IJPQ offsets
//#define BEZIER_CURVE_SUPPORT        // Requires ~2666 bytes

#if EITHER(ARC_SUPPORT, BEZIER_CURVE_SUPPORT)
  //#define CNC_WORKSPACE_PLANES      // Allow G2/G3/G5 to operate in XY, ZX, or YZ planes
#endif

 

Je constate qu'il y a plusieurs modes de déplacements Arc / cercles avec   sens horaire G2 ou anti horaire G3 et courbes de BezierG5 sur marlin.

Je présume qu'arcwelder en fonction du sens de déplacement de chaque mouvement d'interpolation linéaire dans le le fichier de slice original definit si un mouvement est de type G2 ou G3.

J'ai interrogé Mistral  : "Pourquoi le fait de transformer un fichier Gcode avec interpolation linéaire en interpolation arc ou circulaire réduit la taille intrinsèque du fichier gcode ?"

Citation

Lorsque l'on utilise une interpolation linéaire pour déplacer un outil (par exemple, la tête d'impression d'une imprimante 3D ou la fraise d'une machine CNC), l'outil se déplace en ligne droite entre deux points. Cela signifie que pour décrire un mouvement le long d'une courbe ou d'un cercle, il est nécessaire de décomposer cette courbe en de nombreux petits segments de ligne droite. Plus la courbe est complexe, plus il faudra de segments de ligne droite pour la représenter de manière précise.

En revanche, lorsque l'on utilise une interpolation arc ou circulaire, l'outil se déplace le long d'un arc ou d'un cercle entre deux points. Cela signifie qu'il est possible de représenter des courbes complexes avec un nombre beaucoup plus réduit de segments, car chaque segment d'arc ou de cercle peut couvrir une plus grande partie de la courbe.

Par conséquent, lorsque l'on convertit un fichier G-code qui utilise une interpolation linéaire en un fichier qui utilise une interpolation arc ou circulaire, il est souvent possible de réduire considérablement le nombre de lignes de code dans le fichier. Cela se traduit par une taille de fichier plus petite, ce qui peut être utile pour réduire le temps de traitement et de transfert du fichier vers la machine.

Il convient toutefois de noter que la conversion d'une interpolation linéaire en une interpolation arc ou circulaire n'est pas toujours possible ou souhaitable. Dans certains cas, la précision de l'outil ou les contraintes mécaniques de la machine peuvent rendre l'interpolation arc ou circulaire moins précise ou moins efficace que l'interpolation linéaire. Il est donc important de bien comprendre les avantages et les inconvénients de chaque type d'interpolation avant de décider de convertir un fichier G-code.

 

ok effectivement des suites d'approximation d'arc sur des courbes au plus proche d'un trajet / chemin sont plus optimisés que des droites ce qui me semble d'autant plus vrais que l'on à des formes courbes et/ou "organiques".

 

 Pour ceux qui sont intéressés voici par la traduction du Readme de Arcwelder via Mistral : 

Citation

ArcWelderLib est une bibliothèque logicielle qui permet de convertir les commandes GCode G0/G1 (déplacements en ligne droite) en commandes G2/G3 (déplacements circulaires) et inversement. Cette conversion peut permettre de réduire considérablement la taille de la plupart des fichiers GCode et d'améliorer potentiellement la qualité d'impression en prévenant la saturation du planificateur. Elle est particulièrement utile lors de l'impression en streaming via une connexion série (OctoPrint, Pronterface, Slicer direct printing), mais peut également présenter des avantages dans d'autres cas en fonction de votre firmware et de votre carte.

Pour que les fichiers GCode générés par ArcWelder fonctionnent sur votre imprimante, les commandes G2/G3 (arc) doivent être activées. Si ces commandes ne sont pas activées, elles seront ignorées et le résultat sera un désordre. Des instructions pour détecter si les commandes G2/G3 sont activées seront ajoutées à l'avenir.

La plupart des visualiseurs de GCode ne prennent pas correctement en charge les commandes G2/G3, ce qui peut donner l'impression que le résultat est un désordre. Cependant, cela ne signifie pas que les commandes GCode générées par ArcWelder sont incorrectes ou cassées. Il est probable qu'elles s'imprimeront correctement si les commandes G2/G3 sont activées dans le firmware de votre imprimante.

Voici quelques visualiseurs de GCode qui ne prennent pas en charge les commandes G2/G3 :

• Cura
• PrusaSlicer
• Slic3r
• Slic3r PE
• SuperSlicer

Et voici quelques visualiseurs qui les prennent en charge :

• Simplify3D
• OctoPrint's built in 2D GCode Viewer
• PrettyGCode plugin for OctoPrint
• ncviewer.com (attention, ce visualiseur a des problèmes avec les miniatures intégrées et peut parfois afficher des arcs ou des cercles de manière incorrecte)

L'installation d'ArcWelderLib est simple, il suffit de télécharger et d'extraire la dernière version. Vous pouvez trouver toutes les versions ici, avec la dernière version en haut de la liste. Il vous suffit de faire défiler la page jusqu'en bas et de télécharger l'archive correspondant à votre système d'exploitation.

L'archive contient deux dossiers :

• bin : dans ce dossier, vous trouverez les deux applications console ArcWelder et ArcStraightener. Il vous suffit de copier ces applications sur votre ordinateur pour pouvoir les exécuter depuis la ligne de commande, un script ou directement depuis la plupart des slicers. Vous trouverez des instructions sur l'utilisation de ces applications ci-dessous.
• lib : ce dossier contient des bibliothèques ArcWelder précompilées qui peuvent être intégrées dans des applications. La bibliothèque GcodeProcessorLib contient des fonctions pour analyser le GCode, suivre l'état et la position de l'imprimante, ainsi que d'autres fonctionnalités utiles. La bibliothèque ArcWelder (qui nécessite GcodeProcessorLib) contient l'algorithme de soudage principal.

Si vous souhaitez compiler ArcWelderLib à partir des sources, vous pouvez le faire en suivant ces étapes depuis le répertoire racine du dépôt :

1. Créez un répertoire de build : mkdir build
2. Accédez au répertoire de build : cd build
3. Générez le fichier Makefile : cmake ..
4. Compilez le projet : make

L'application console compilée se trouvera dans le répertoire build/ArcWelderConsole/. Vous pouvez créer le répertoire de build en dehors du dépôt ou ajouter le répertoire de build à la liste .gitignore pour éviter d'avoir un arbre de travail sale.

L'application console ArcWelder peut être utilisée pour exécuter l'algorithme de soudage à partir d'une invite de commande. Des versions binaires sont disponibles pour Windows, Linux, Raspbian et MacOS. Vous trouverez des informations sur le téléchargement de l'application console dans la section Installation.

Pour exécuter l'application console ArcWelder, vous devez fournir le chemin d'accès à un fichier GCode source et éventuellement le chemin d'accès à un fichier GCode de sortie. Si vous souhaitez remplacer le fichier source, vous n'avez pas besoin de fournir de chemin de sortie. Par exemple, si vous exécutez la version Windows à partir de la racine du lecteur C et que vous souhaitez souder un fichier nommé C:\thing.gcode, vous pouvez exécuter la commande suivante à partir de l'invite de commande :

C:\ArcWelder.exe C:\thing.gcode

Cela remplacera thing.gcode par une version soudée du fichier.

Si vous souhaitez conserver le fichier source, vous pouvez spécifier un chemin de sortie.

Exemple sous Windows :

ArcWelder thing.gcode thing.aw.gcode

Exemple sous Linux/Raspbian :

./ArcWelder thing.gcode thing.aw.gcode

Cela créera un nouveau fichier nommé thing.aw.gcode et laissera le fichier thing.gcode inchangé.

Vous pouvez également fournir un chemin d'accès pour les fichiers GCode source et de sortie :

ArcWelder c:\my_gcode\thing.gcode c:\my_gcode\arc_welded_files\thing.aw.gcode

Notez que vous devrez peut-être entourer les chemins d'accès de guillemets si ceux-ci contiennent des espaces.

Vous pouvez obtenir une liste de toutes les options disponibles en exécutant la commande suivante sous Windows :

ArcWelder --help

Pour afficher la version actuelle d'ArcWelder, qui peut être utile à des fins de débogage ou si vous soumettez un problème sur GitHub, vous pouvez exécuter la commande suivante :

ArcWelder --version

ArcWelder a des valeurs par défaut qui conviennent à la plupart des applications, mais vous pouvez parfois souhaiter un contrôle plus précis. De nombreuses options sont disponibles et peuvent s'avérer utiles en fonction de votre situation.

ArcWelder utilise le parseur de ligne de commande TCLAP (Templatized C++ Command Line Parser) pour la mise en œuvre des arguments, et j'ai été très impressionné par ses performances.

Notez que certaines des options décrites ci-dessous sont spécifiques à l'application console ArcWelder et ne s'appliquent pas à l'utilisation d'ArcWelder dans un slicer ou une autre application.

G90 Influences Extruder

Pour certaines imprimantes, l'envoi d'une commande G90 ou G91 modifie également le mode de l'axe E (extrudeur). Cela est nécessaire pour toute imprimante fonctionnant sous Marlin 2+ ou une version dérivée de Marlin 2, pour Smoothieware et pour le firmware Prusa Buddy (Prusa Mini). Ne pas ajouter ce drapeau si vous utilisez un autre firmware. Si votre firmware n'est pas dans cette liste mais nécessite ce paramètre, veuillez créer un problème et je mettrai à jour la documentation.

• Type : Drapeau
• Valeur par défaut : Désactivé
• Paramètre court : -g
• Paramètre long : --g90-influences-extruder
• Exemple : ArcWelder "C:\thing.gcode" -g

Résolution (Déviation Maximum du Chemin)

ArcWelder est capable de compresser des segments de ligne en GCode en tirant parti du fait qu'un tas de petits segments de ligne peuvent, lorsqu'ils sont vus de loin, approcher une courbe. Cependant, un chemin courbe réel ne correspondra jamais exactement à un tas de lignes droites, donc ArcWelder a besoin d'une certaine marge de manœuvre pour créer des commandes d'arc. L'argument de résolution indique à ArcWelder la marge de manœuvre dont il dispose par rapport au chemin d'origine pour créer un arc. L'augmentation de cette valeur entraînera une compression plus importante, tandis que la réduction de cette valeur améliorera la précision. Il s'agit d'un compromis, mais dans la plupart des cas, les tracés générés par ArcWelder sont pratiquement indiscernables de l'original à l'œil nu. Pour les pièces nécessitant une précision extrêmement élevée, vous pouvez réduire cette valeur, mais cela réduira la quantité de compression qui peut être réalisée.

La résolution par défaut est de 0,05 mm, ce qui signifie que vos tracés peuvent s'écarter de plus ou moins 0,025 mm. Dans l'ensemble, cela donne d'excellents résultats et des tracés pratiquement identiques aux originaux. Pour les pièces nécessitant une précision extrêmement élevée, vous pouvez réduire cette valeur, mais cela réduira la quantité de compression qui peut être réalisée.

Les valeurs supérieures à 0,1 ne sont pas recommandées, car vous risquez d'obtenir des tracés qui se chevauchent. Lorsque vous utilisez des valeurs supérieures à 0,1, je vous recommande d'utiliser un visualiseur qui prend en charge les arcs avant d'effectuer l'impression.

• Type : Valeur (en millimètres)
• Valeur par défaut : 0,05 (± 0,025)
• Contraintes : Seules les valeurs supérieures à 0 sont autorisées.
• Paramètre court : -r=<decimal_value>
• Paramètre long : --resolution-mm=<decimal_value>
• Exemple : ArcWelder "C:\thing.gcode" -r=0.1

Tolérance de Chemin (Longueur)

Ce paramètre vous permet de contrôler dans quelle mesure la longueur de l'arc final peut s'écarter de la longueur du chemin d'origine. La valeur par défaut de 5 % est tout à fait acceptable dans la plupart des cas, même si cela peut sembler beaucoup. L'élément clé à retenir ici est que votre firmware divisera les commandes G2/G3 en de nombreux petits segments, ce qui revient essentiellement à annuler le processus, de sorte que la longueur du chemin dans votre firmware correspondra beaucoup plus étroitement à la longueur d'origine.

À l'origine, ce réglage a été ajouté comme mesure de sécurité pour éviter la création d'arcs incorrects dans certains cas limites. Cependant, depuis lors, un nouvel algorithme de détection d'erreurs a été ajouté, ce qui rend cela inutile. Dans certains cas, en particulier si votre paramètre de résolution est important (supérieur à 0,1), ce réglage peut être utilisé pour ajuster les arcs générés, c'est pourquoi je l'ai laissé tel quel. Dans 99 % des cas, aucun ajustement ne sera nécessaire ici.

• Type : Valeur (en pourcentage)
• Valeur par défaut : 0,05 (5 %)
• Contraintes : Seules les valeurs supérieures à 0 (0 %) et inférieures à 1,0 (100 %) sont autorisées.
• Paramètre court : -t=<decimal_value>
• Paramètre long : --path-tolerance-percent=<decimal_value>
• Exemple : ArcWelder "C:\thing.gcode" --path-tolerance-percent=0.10

Rayon Maximum d'Arc

Ce paramètre vous permet de contrôler le rayon maximum de l'arc qui sera généré par ArcWelder. Il a été ajouté comme mesure de sécurité pour éviter la création d'arcs géants pour des lignes essentiellement droites. ArcWelder dispose d'une détection intégrée pour éviter que des lignes colinéaires ne soient transformées en arcs, mais des écarts légers dus à la précision des gcodes (généralement fixée à 3 décimales) peuvent entraîner la création d'arcs là où des lignes droites seraient plus appropriées. En règle générale, aucun ajustement n'est nécessaire par rapport aux valeurs par défaut, mais vous pouvez ajuster cette valeur si vous le souhaitez.

• Type : Valeur (décimal, en millimètres)
• Valeur par défaut : 9999,0 mm
• Contraintes : Seules les valeurs supérieures à 0,0 sont autorisées.
• Paramètre court : -m=<decimal_value>
• Paramètre long : --max-radius-mm=<decimal_value>
• Exemple : ArcWelder "C:\thing.gcode" --max-radius-mm=1000.0

Autoriser les Arcs 3D

Cette option permet la génération de commandes G2/G3 lors de l'utilisation du mode vase. Il s'agit d'une option expérimentale et il est possible qu'il existe des problèmes de firmware inconnus lors de l'ajout de coordonnées Z aux commandes d'arc. Cependant, j'ai obtenu de bons résultats avec cette option. À un moment donné, cette option sera activée par défaut.

• Type : Drapeau
• Valeur par défaut : Désactivé
• Paramètre court : -z
• Paramètre long : --allow-3d-arcs
• Exemple : ArcWelder "C:\thing.gcode" --allow-3d-arcs

Autoriser les Arcs de Déplacement

Cette option permet la génération de commandes G2/G3 pour les déplacements (déplacements sans extrusion). En général, la plupart des déplacements ne seront pas convertis pour une impression 3D moyenne. Cependant, pour les traceurs ou les CNC, ou certains slicers qui effectuent des actions d'essuyage tout en se rétractant, cette fonction peut être utile. Il s'agit d'une option expérimentale.

Remarque : Lorsque vous utilisez l'option allow-travel-arcs, vous verrez des statistiques séparées pour la conversion des déplacements ou un message indiquant qu'aucun déplacement n'a été converti.

• Type : Drapeau
• Valeur par défaut : False
• Paramètre court : -y
• Paramètre long : --allow-travel-arcs
• Exemple : ArcWelder "C:\thing.gcode" --allow-travel-arcs

Autoriser la Précision Dynamique

Tous les gcodes n'ont pas la même précision pour les paramètres X, Y et Z. L'activation de cette option permettra à la précision d'augmenter à mesure qu'ArcWelder rencontrera des gcodes avec une précision plus élevée. Cela peut augmenter la taille du gcode dans une certaine mesure, en fonction de la précision des commandes gcode dans votre fichier.

Remarque importante : Cette option était activée par défaut auparavant, mais dans certains cas, j'ai vu des fichiers avec une précision anormalement élevée. Si elle est trop élevée, le gcode résultant peut dépasser la taille du tampon de gcode, ce qui entraîne l'échec de l'impression. C'est pourquoi cette option a été désactivée par défaut. Je n'ai vu que quelques cas où cela se produit, et c'est toujours dû à un code de démarrage/d'arrêt personnalisé avec une précision extrêmement élevée. Consultez la section sur la longueur maximale du gcode pour plus de détails.

• Type : Drapeau
• Valeur par défaut : Désactivé
• Paramètre court : -d
• Paramètre long : --allow-dynamic-precision
• Exemple : ArcWelder "C:\thing.gcode" --allow-dynamic-precision

Précision XYZ par Défaut

ArcWelder génère une précision fixe pour les paramètres X, Y, Z, I et J. Dans 99 % des cas, la valeur par défaut de 3 décimales est tout à fait acceptable. Si vous avez besoin (ou souhaitez) d'une précision supérieure ou inférieure, vous pouvez modifier cette valeur.

Remarque : Lorsqu'elle est utilisée conjointement avec l'argument --allow-dynamic-precision, cette valeur représente la précision minimale. Elle augmentera si ArcWelder rencontre des commandes gcode avec une précision supérieure.

Remarque importante : Certains firmwares ne sont pas capables d'exécuter des gcodes qui sont trop longs. L'augmentation de la précision entraînera la création de gcodes plus longs. Consultez la section sur la longueur maximale du gcode pour plus de détails.

• Type : Valeur (décimales entières)
• Valeur par défaut : 3 (3 décimales, par exemple : 1,001)
• Contraintes : Les valeurs autorisées sont 3, 4, 5 ou 6.
• Paramètre court : -x=<integer_value>
• Paramètre long : --default-xyz-precision=<integer_value>
• Exemple : ArcWelder "C:\thing.gcode" --default-xyz-precision=5

Précision E par Défaut

ArcWelder génère une précision fixe pour le paramètre E (déplacement de l'extrudeur). Dans 99 % des cas, la valeur par défaut de 5 décimales est ce que vous voulez. Si vous avez besoin (ou souhaitez) d'une précision supérieure ou inférieure, vous pouvez modifier cette valeur. En règle générale, je ne recommande pas une valeur inférieure à 3 ou supérieure à 5.

Remarque : Lorsqu'elle est utilisée conjointement avec l'argument --allow-dynamic-precision, cette valeur représente la précision minimale. Elle augmentera si ArcWelder rencontre des commandes gcode avec une précision supérieure.

Remarque importante : Certains firmwares ne sont pas capables d'exécuter des gcodes qui sont trop longs. L'augmentation de la précision entraînera la création de gcodes plus longs. Consultez la section sur la longueur maximale du gcode pour plus de détails.

• Type : Valeur (décimales entières)
• Valeur par défaut : 5 (5 décimales, par exemple : 1,00001)
• Contraintes : Les valeurs autorisées sont 3, 4, 5 ou 6.
• Paramètre court : -e=<integer_value>
• Paramètre long : --default-e-precision=<integer_value>
• Exemple : ArcWelder "C:\thing.gcode" --default-e-precision=3

Compensation de Firmware

Remarque importante : Ne pas activer la compensation de firmware à moins d'en avoir réellement besoin ! La qualité d'impression et la compression seront réduites si elle est activée inutilement.

Certains firmwares ne gèrent pas correctement les arcs avec un petit rayon (inférieur à environ 5 mm en fonction de vos paramètres), ce qui les fait apparaître à plat au lieu d'être courbés. Si des arcs plus grands apparaissent à plat, il est probable que les commandes G2/G3 soient désactivées. Consultez ce problème fermé pour plus de détails, y compris des illustrations montrant ce que la compensation de firmware fait à votre gcode.

Cela s'applique à Marlin 1.x (mais pas à Marlin 2), à Klipper (peut être corrigé en modifiant les paramètres) et à quelques autres. Si vous remarquez des arcs avec un petit rayon qui s'impriment avec un bord plat, vous devrez peut-être activer la compensation de firmware. Notez que la compression peut être réduite (parfois de manière drastique) lorsque la compensation de firmware est activée.

Cette fonctionnalité n'est qu'un correctif et la meilleure solution sera toujours de mettre à niveau votre firmware, ce qui est particulièrement important pour les personnes qui utilisent Marlin 1.x ou un dérivé, ou de modifier vos paramètres d'interpolation d'arc (Marlin 2.x et versions ultérieures, Klipper, et autres). Si vous ne pouvez absolument pas mettre à niveau votre firmware, cela peut être votre seule option.

Il y a deux arguments qui doivent être ajoutés pour activer la compensation de firmware :

Longueur de Segment d'Arc en mm

Il s'agit de la longueur de segment par défaut dans votre firmware. Ce paramètre doit correspondre exactement au paramètre de votre firmware pour que la compensation de firmware fonctionne. Dans 99 % des cas, ce paramètre doit être de 1,0 pour que la compensation de firmware fonctionne.

• Type : Valeur (en millimètres)
• Valeur par défaut : 0 (désactivé)
• Contraintes : Seules les valeurs supérieures ou égales à 0,0 sont autorisées. Si elle est définie à une valeur supérieure à 0, min-arc-segments doit également être défini.
• Paramètre court : -s=<decimal_value>
• Paramètre long : --mm-per-arc-segment=<decimal_value>
• Exemple : ArcWelder "C:\thing.gcode" --mm-per-arc-segment=1.0 --min-arc-segments=14

Nombre Minimum de Segments d'Arc

Il s'agit du nombre minimum de segments qu'un cercle de même rayon doit avoir, et c'est le paramètre qui détermine la quantité de compensation qui sera appliquée. Cet argument a été inspiré par l'algorithme d'interpolation d'arc de Marlin 2.0 et tente de le suivre aussi étroitement que possible. Plus la valeur est élevée, plus la compensation sera importante et plus la compression sera faible. Une valeur minimale de 14 est recommandée. Les valeurs supérieures à 24 ne sont pas recommandées. En règle générale, elle doit être réglée aussi bas que possible.

Si ArcWelder détecte qu'un arc généré aurait moins de segments que spécifié, il rejettera l'arc et générera des codes G0/G1 à la place. Il est possible qu'un seul arc soit divisé en plusieurs commandes G2/G3, en fonction de la situation exacte. Notez qu'ArcWelder ne générera jamais plus de codes GCode que dans le fichier source, il est donc limité par la résolution du fichier GCode source.

• Type : Valeur entière
• Valeur par défaut : 0 (désactivé)
• Contraintes : Seules les valeurs supérieures ou égales à 0,0 sont autorisées. Si elle est définie à une valeur supérieure à 0, mm-per-arc-segment doit également être défini.
• Paramètre court : -a=<integer_value>
• Paramètre long : --min-arc-segments=<integer_value>
• Exemple : ArcWelder "C:\thing.gcode" --mm-per-arc-segment=1.0 --min-arc-segments=14

Exemple de Compensation de Firmware

Si vous devez activer la compensation de firmware en raison de l'apparition de petits arcs à plat, je vous recommande de commencer par les paramètres suivants :

ArcWelder --mm-per-arc-segment=1.0 --min-arc-segments=14

Cela devrait produire des arcs beaucoup plus arrondis. Cependant, dans certains cas, vous voudrez peut-être plus de détails (au détriment de la compression, ce qui réduit l'efficacité d'ArcWelder), auquel cas vous pouvez augmenter --min-arc-segments jusqu'à environ 24. Je ne recommande pas de dépasser cette valeur car vous commencerez à obtenir beaucoup de gcode non compressé dans les zones qui en ont besoin.

Variance de Taux d'Extrusion

Cette fonctionnalité permet à ArcWelder d'interrompre un arc si le taux d'extrusion change de plus de la valeur spécifiée. Notez qu'une valeur de 0,050 = 5,0 %. Cette option est particulièrement utile pour les impressions utilisant le moteur d'Arachne de Cura, mais elle est également utile pour les impressions régulières. Définissez cette valeur à 0 pour désactiver cette fonctionnalité.

• Type : Valeur
• Valeur par défaut : 0,05 (5,0 %)
• Contraintes : Seules les valeurs supérieures ou égales à 0,0 sont autorisées.
• Paramètre court : -v=<decimal_value> (0,05 = 5,0 %, 0 pour désactiver)
• Paramètre long : --extrusion-rate-variance-percent=<decimal_value>
• Exemple : ArcWelder "C:\thing.gcode" --extrusion-rate-variance-percent=0.025

Longueur Maximale de GCode

Certains firmwares ont des problèmes avec les commandes gcode longues, et les commandes G2/G3 sont parmi les plus longues. Vous pouvez spécifier une longueur de gcode maximale pour éviter la création de commandes longues, ce qui réduira la compression d'une petite quantité.

Les valeurs non nulles inférieures à 31 ne sont pas autorisées.

• Type : Valeur
• Valeur par défaut : 0 (aucune limite)
• Contraintes : Peut être définie à 0, ou à des valeurs supérieures à 30.
• Paramètre court : -c=<integer_value>
• Paramètre long : --max-gcode-length=<integer_value>
• Exemple : ArcWelder "C:\thing.gcode" --max-gcode-length=50

Type de Progression

Ce paramètre vous permet de contrôler le type de messages de progression que l'application console ArcWelder affichera. Il existe trois options :

• SIMPLE : Il s'agit du paramètre par défaut. Voici un exemple de message de progression simple : Progress: 21,9 % complete - Estimated 35 of 45 seconds remaing.

• FULL : Il s'agit d'un message de progression beaucoup plus détaillé, qui est utile pour toute application qui souhaite récupérer les messages de progression détaillés. Voici un exemple de message de progression complet : Progress: percent_complete:100.00, seconds_elapsed:0.01, seconds_remaining:0.00, gcodes_processed: 4320, current_file_line: 4320, points_compressed: 2092, arcs_created: 81, arcs_aborted_by_flowrate: 59, num_firmware_compensations: 0, num_gcode_length_exceptions: 0, compression_ratio: 2.27, size_reduction: 55.96%

• NONE : Aucun message de progression ne sera affiché.

• Type : Valeur

• Valeur par défaut : SIMPLE

• Paramètre court : -P=<SIMPLE|FULL|NONE>

• Paramètre long : --progress-type=<SIMPLE|FULL|NONE>

• Exemple : ArcWelder "C:\thing.gcode" --progress-type=FULL

Niveau de Journalisation

Lorsqu'il est défini, ArcWelder journalisera sur la console. Cela peut être utilisé pour suivre les problèmes ou pour savoir exactement ce qu'ArcWelder fait.

Remarque importante : La définition du niveau de journalisation peut entraîner la sortie d'une grande quantité de données sur la console et ralentira ArcWelder. Je vous recommande de rediriger la sortie de la console pour accélérer les choses si vous utilisez les niveaux de journalisation DEBUG, VERBOSE ou NOSET.

• Type : Valeur
• Valeur par défaut : INFO
• Paramètre court : -l=<NOSET|VERBOSE|DEBUG|INFO|WARNING|ERROR|CRITICAL>
• Paramètre long : --log-level=<NOSET|VERBOSE|DEBUG|INFO|WARNING|ERROR|CRITICAL>
• Exemple : ArcWelder "C:\thing.gcode" --log-level=DEBUG

Intégrations de Slicer

Il est facile d'intégrer ArcWelder dans la plupart des slicers.

Exécution d'ArcWelder à partir de Cura

Il n'existe pas de moyen d'intégrer l'application console ArcWelder dans Cura. Heureusement, il existe un plugin dans le marketplace qui intègre ArcWelder dans Cura, développé par FieldOfView, donc aucun souci !

Remarque : Si vous utilisez Marlin 2, un dérivé de Marlin 2, Prusa Buddy (Prusa Mini) ou Smoothieware, activez le paramètre "G90 Influences Extruder". Consultez la section sur G90 Influences Extruder pour plus d'informations.

Si vous utilisez Marlin 1 ou un dérivé de Marlin 1 (firmware Prusa pour Mk2/Mk3, par exemple) ou Klipper, vous pouvez envisager d'activer la compensation de firmware. Cela dépend de vos paramètres de firmware, mais en général, vous voudrez définir MM Per Arc Segment à 1,0 et Min Arc Segments à 14 pour activer la compensation de firmware. La définition de l'une ou l'autre de ces valeurs à 0 désactive cette fonctionnalité. Consultez la section sur la compensation de firmware pour plus d'informations.

Exécution d'ArcWelder à partir de Slic3r, Slic3rPE, PrusaSlicer et SuperSlicer

Il existe des différences mineures entre ces différents slicers, mais heureusement, la méthode d'intégration d'ArcWelder est la même.

Placez le binaire ArcWelder quelque part sur votre ordinateur et copiez le chemin d'accès complet (consultez la section sur l'installation ci-dessus). Par exemple : C:\ArcWelder Sélectionnez "Print Settings". En fonction du slicer que vous utilisez, vous devrez peut-être activer le mode "Advanced" ou "Expert" (PrusaSlicer nécessite au moins cela). Sélectionnez le sous-menu "Output options". Dans les "Post-processing scripts", ajoutez la commande suivante (le chemin d'accès à ArcWelder peut être différent) : c:\ArcWelder.exe Cela exécutera ArcWelder sur chaque impression découpée avec les paramètres par défaut.

Sauvegardez vos modifications de paramètres. Découpez un fichier de test et ouvrez-le, en vérifiant l'en-tête ArcWelder en haut, qui devrait ressembler à ceci : ; Postprocessed by [ArcWelder](https://github.com/FormerLurker/ArcWelderLib) Maintenant, vous devriez être prêt à partir !

Il existe quelques paramètres que vous pouvez ajouter. Par exemple, si vous utilisez une imprimante fonctionnant sous Marlin 1.0 ou un dérivé de Marlin 1, vous pouvez envisager d'activer la compensation de firmware. Voici un exemple de cela :

{path_to_arc_welder_here}\ArcWelder.exe --mm-per-arc-segment=1.0 --min-arc-segments=14 Consultez la section sur la compensation de firmware pour plus d'informations.

Si vous utilisez Marlin 2.0, un dérivé de Marlin 2.0, Smoothieware ou Prusa Buddy (pour la Prusa Mini), vous voudrez ajouter le paramètre --g90-influences-extruder comme suit :

{path_to_arc_welder_here}\ArcWelder.exe --g90-influences-extruder Consultez la section sur G90 Influences Extruder pour plus d'informations.

Exécution d'ArcWelder à partir de Simplify3D

Modifiez vos paramètres de processus actuels. Cliquez sur l'onglet "Scripts". Ajoutez la commande suivante (le chemin d'accès à ArcWelder peut être différent) : c:\ArcWelder.exe "[output_filepath]" Remarque importante : Les guillemets autour du jeton [output_filepath] sont CRITIQUES ! Le fait de les omettre entraînera des problèmes intermittents en fonction de votre chemin d'accès gcode et de votre nom de fichier. De plus, ne pas définir de chemin d'accès de sortie ou de nom de fichier dur. Simplify3D remplacera automatiquement le jeton [output_filepath] par le chemin d'accès et le nom de fichier de notre fichier de sortie.

Cliquez maintenant sur "OK" pour enregistrer vos modifications de paramètres, chargez et découpez un fichier, et enregistrez-le quelque part. Ouvrez-le et vérifiez que l'en-tête ArcWelder apparaît en haut de votre fichier. Elle devrait ressembler à ceci : ; Postprocessed by [ArcWelder](https://github.com/FormerLurker/ArcWelderLib) Maintenant, vous devriez produire des fichiers soudés directement à partir de Simplify3D !

Il existe quelques paramètres que vous pouvez ajouter. Par exemple, si vous utilisez une imprimante fonctionnant sous Marlin 1.0 ou un dérivé de Marlin 1, vous pouvez envisager d'activer la compensation de firmware. Voici un exemple de cela :

c:\ArcWelder.exe --mm-per-arc-segment=1.0 --min-arc-segments=14 "[output_filepath]" Consultez la section sur la compensation de firmware pour plus d'informations.

Si vous utilisez Marlin 2.0, un dérivé de Marlin 2.0, Smoothieware ou Prusa Buddy (pour la Prusa Mini), vous voudrez ajouter le paramètre --g90-influences-extruder comme suit :

c:\ArcWelder.exe --g90-influences-extruder "[output_filepath]" Consultez la section sur G90 Influences Extruder pour plus d'informations.

ArcStraightener

Il s'agit de l'inverse d'ArcWelder. Il trouvera toutes les commandes G2/G3 et les remplacera par des commandes G1. Cela est utile pour tester les paramètres de firmware et pour voir en général ce que le firmware fait avec vos commandes d'arc.

La dernière version comprend plusieurs implémentations des algorithmes d'interpolation d'arc de différents types et versions de firmware. Cet outil peut être extrêmement utile pour suivre les problèmes de firmware liés à l'exécution de commandes G2/G3.

Exécution de la console ArcStraightener

Une fois que vous avez téléchargé et copié ArcStraightener (ou ArcStraightener.exe pour Windows) sur votre ordinateur, vous pouvez l'exécuter de la manière suivante :

{Path_To_Arc_Straightener} {Options_Parameters} {Source_Path} {Optional_Target_Path}

Vous pouvez également placer le chemin d'accès à la source et (facultatif) au chemin d'accès à la cible en premier :

{Path_To_Arc_Straightener} {Source_Path} {Optional_Target_Path} {Options_Parameters}

Remarque importante : Par défaut, ArcStraightener traitera votre gcode en utilisant l'algorithme d'interpolation d'arc de la dernière version de Marlin 2 avec les paramètres de firmware par défaut. Consultez les paramètres --firmware-type et --firmware-version pour obtenir des informations sur les types et versions de firmware pris en charge.

Remplacement du fichier source

Si vous souhaitez remplacer le fichier source, aucun chemin de cible n'est nécessaire. Par exemple, si vous exécutez la version Windows à partir de la racine de votre lecteur C et que vous souhaitez redresser un fichier nommé C:\thing.aw.gcode, vous pouvez exécuter la commande suivante à partir de l'invite de commande :

C:\ArcStraightener.exe C:\thing.aw.gcode

Cela remplacera thing.aw.gcode par une version redressée du fichier.

Création d'un nouveau fichier

Si vous souhaitez conserver le fichier source, vous pouvez spécifier un chemin de cible.

Exemple sous Windows :

ArcStraightener thing.aw.gcode thing.gcode

Exemple sous Linux/Raspbian :

./ArcStraightener thing.aw.gcode thing.gcode

Cela créera un nouveau fichier nommé thing.gcode et laissera le fichier thing.aw.gcode inchangé.

Vous pouvez également spécifier un chemin d'accès pour les fichiers gcode source et de sortie :

ArcStraightener c:\my_gcode\thing.aw.gcode c:\my_gcode\arc_welded_files\thing.gcode

Remarque : Vous devrez peut-être entourer les chemins d'accès de guillemets s'ils contiennent des espaces.

Aide de la console ArcStraightener

Vous pouvez obtenir la liste complète des paramètres en utilisant le paramètre --help comme suit :

ArcStraightener --help

Cela affichera également les types et versions de firmware pris en charge.

Informations sur la version d'ArcStraightener

Pour afficher la version actuelle d'ArcStraightener, qui peut être utile à des fins de débogage ou si vous soumettez un problème sur GitHub, vous pouvez exécuter la commande suivante :

ArcStraightener --version

Arguments de la console ArcStraightener

ArcStraightener dispose de paramètres qui représentent les paramètres d'interpolation d'arc pour les firmwares qui sont implémentés. Les paramètres acceptés varient en fonction du type et de la version du firmware. ArcStraightener n'acceptera aucun paramètre qui ne fonctionnera pas avec le type et la version de firmware sélectionnés. Il peut également fournir une liste des paramètres disponibles et des valeurs par défaut pour le type et la version de firmware sélectionnés.

ArcStraightener utilise également le parseur de ligne de commande TCLAP (Templatized C++ Command Line Parser) pour la mise en œuvre des arguments.

Paramètres non spécifiques au firmware

Les arguments suivants s'appliquent quel que soit le type et la version du firmware sélectionnés.

Type de Firmware

Actuellement, il existe 5 types de firmware différents disponibles : MARLIN_1, MARLIN_2, REPETIER, PRUSA, SMOOTHIEWARE.

• Type : Valeur
• Valeur par défaut : MARLIN_2
• Paramètre court : -f=<value>
• Paramètre long : --firmware-type=<value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --firmware-type=MARLIN_1

Version du Firmware

Utilisez ce paramètre pour spécifier la version du firmware. Toutes les versions ne sont pas prises en charge. Pour obtenir une liste des versions disponibles pour chaque type de firmware, utilisez le paramètre --help. Notez que le paramètre LATEST_RELEASE ne pointe pas toujours vers la version la plus récente, mais plutôt vers la version la plus récente stable. De plus, la version du firmware PRUSA V3_11_0 n'est pas encore publiée, mais a été ajoutée en supposant que de nouveaux paramètres d'interpolation d'arc seront inclus dans la feuille de route.

Remarque : Vous devrez peut-être spécifier le paramètre --firmware_type pour choisir la version de firmware appropriée.

• Type : Valeur
• Valeur par défaut : LATEST_RELEASE
• Paramètre court : -V=<value>
• Paramètre long : --firmware_version=<value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --firmware-type=MARLIN_1 --firmware_version=1.1.9.1

Afficher les Valeurs par Défaut du Firmware

Affiche toutes les valeurs par défaut disponibles et prises en charge pour le type et la version de firmware fournis. Lorsque vous utilisez ce paramètre, tous les autres paramètres valides seront ignorés.

Remarque : Fournissez les paramètres --firmware_type et --firmware_version pour afficher les valeurs par défaut et les paramètres pris en charge. Lorsque vous affichez les valeurs par défaut du firmware, vous n'avez pas besoin de fournir un emplacement de fichier source.

• Type : Drapeau
• Paramètre court : -p
• Paramètre long : --print-firmware-defaults
• Exemple : ArcStraightener --print-firmware-defaults --firmware_type=MARLIN_1 --firmware_version=1.1.9.1

Paramètres spécifiques au firmware

Les différents types et versions de firmware prennent en charge différents paramètres d'interpolation d'arc. Consultez la section sur l'affichage des valeurs par défaut du firmware pour savoir comment découvrir les paramètres qu'un firmware spécifique prend en charge, ainsi que les valeurs par défaut.

G90/G91 Influences Extruder

Définit le comportement du firmware pour l'axe de l'extrudeur lorsque les commandes G90 ou G91 sont envoyées. Par défaut, ce comportement est déterminé par le type et la version du firmware.

• Type : Valeur
• Valeur par défaut : Définie par le type et la version du firmware
• Paramètre court : -g=<TRUE,FALSE>
• Paramètre long : --g90-influences-extruder=<value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --firmware_type=PRUSA --firmware_version=V1_1_9_1 --g90-influences-extruder=TRUE

Dans l'exemple ci-dessus, le comportement par défaut du firmware prusa est remplacé par l'argument.

MM par Segment d'Arc

Il s'agit de la longueur de segment par défaut pour l'interpolation d'arc. En fonction de la mise en œuvre, les arcs peuvent être plus longs ou plus courts que cette valeur.

• Type : Valeur (en millimètres)
• Valeur par défaut : 1,0
• Paramètre court : -m=<decimal_value>
• Paramètre long : --mm-per-arc-segment=<decimal_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --mm-per-arc-segment=0.5

Max Arc Segment MM

Il s'agit de la longueur maximale qu'un segment d'arc peut avoir. Il est similaire à --arc-segments-per-r, mais est utilisé dans un firmware différent. Cela a remplacé et a une signification légèrement différente de --mm-per-arc-segment dans les versions plus récentes de Marlin 2.0.

• Type : Valeur (en millimètres)
• Valeur par défaut : 1,0
• Paramètre court : -d=<decimal_value>
• Paramètre long : --max-arc-segment-mm=<decimal_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --max-arc-segment-mm=0.5

Arc Segments par R

Il s'agit de la longueur maximale qu'un segment d'arc peut avoir. Il est similaire à --max-arc-segment-mm, mais est utilisé dans un firmware différent.

• Type : Valeur (en millimètres)
• Valeur par défaut : 0 (désactivé)
• Paramètre court : -i=<decimal_value>
• Paramètre long : --arc-segments-per-r=<decimal_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --arc-segments-per-r=0.5

MM Minimum par Segment d'Arc

Il s'agit de la longueur minimale qu'un segment d'arc peut avoir. Il est similaire à --min_arc_segment_mm, mais est utilisé dans un firmware différent.

• Type : Valeur (en millimètres)
• Valeur par défaut : 1,0
• Paramètre court : -n=<decimal_value>
• Paramètre long : --min-mm-per-arc-segment=<decimal_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --min-mm-per-arc-segment=0.5

Min Arc Segments

Le nombre minimum de segments dans un cercle de même rayon que l'arc. Peut être utilisé pour augmenter le détail sur les petits arcs. Il s'agit du même paramètre que --min-circle-segments utilisé dans certaines versions de firmware.

• Type : Valeur entière
• Valeur par défaut : 24
• Paramètre court : -r=<integer_value>
• Paramètre long : --min-arc-segments=<integer_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --min-arc-segments=24

Min Circle Segments

Le nombre minimum de segments dans un cercle de même rayon que l'arc. Peut être utilisé pour augmenter le détail sur les petits arcs. Il s'agit du même paramètre que --min-arc-segments utilisé dans certaines versions de firmware.

• Type : Valeur entière
• Valeur par défaut : 72
• Paramètre court : -a=<integer_value>
• Paramètre long : --min-circle-segments=<integer_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --min-circle-segments=24

N Arc Correction

Le nombre de segments qui seront interpolés en utilisant une approximation de petit angle avant que les corrections sin/cos réelles ne soient appliquées. Une valeur inférieure ou égale à 1 désactivera cette fonctionnalité. L'activation de cette fonctionnalité peut entraîner des erreurs d'interpolation visibles, en particulier sur les arcs avec un rayon très grand. La désactivation de cette fonctionnalité peut entraîner des problèmes de performances sur un matériel plus lent.

• Type : Valeur entière
• Valeur par défaut : 24
• Paramètre court : -c=<integer_value>
• Paramètre long : --n-arc-correction=<integer_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --n-arc-correction=8

Arc Segments par Seconde

Le nombre de segments par seconde. Cela produira un nombre constant de arcs, plafonné entre mm-per-arc-segment et min-mm-per-arc-segment. Peut être utilisé pour prévenir les bégaiements lors de l'impression à des vitesses élevées. Une valeur inférieure ou égale à 0 désactivera cette fonctionnalité.

• Type : Valeur entière
• Valeur par défaut : 0 (désactivé)
• Paramètre court : -s=<integer_value>
• Paramètre long : --arc-segments-per-second=<integer_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --arc-segments-per-second=24

MM Max Arc Error

Je ne suis pas sûr à 100 % de ce que cela fait, mais je pense que cela tente de limiter la dérive dans le chemin de l'arc à cette valeur en mm. Lorsque j'en saurai plus, je mettrai à jour cette description. Cela n'est actuellement utilisé que dans Smoothieware. Définissez à 0 pour désactiver.

• Type : Valeur (en millimètres)
• Valeur par défaut : 0,01
• Paramètre court : -e=<decimal_value>
• Paramètre long : --mm-max-arc-error=<decimal_value>
• Exemple : ArcStraightener "C:\thing.aw.gcode" --mm-max-arc-error=0.25"

 

Merci PPAC pour ces infos je vais regarder ce soft de prés des que j'ai plus de temps et tester tout cela.

SUDSUD

Modifié (le) Juin 6, 2024 par sudtek

[sudtek]

Bonjour,

j'ai testé sur une autre machine avec pronterface de loader ce gros gcode idem cela rame au taquet pour loader le fichier fige l'appli pendant un moment mais je pense avoir compris ! C'est pas le fichier gcode qui a un PB mais bien pronterface qui n'aime pas le nombres de lignes à loader. Il load  environ 400K lignes  puis quelque soit le pc il me fait un malaise ... ce que j'avais pas percuté c'est que c'est pas un soft récent printrun et qu'il probablement pas prévu pour avaler des centaines de milliers de lignes de Gcode d'où le message "d'insulte" d'une instanciation d'objet foireuse qui ne peut être réalisée (je me doute de ce qui doit se passer):

 

Du coup j'ai ressayé d'imprimer direct via l'imprimante sans le PC  + clef usb et j'ai eu "ENFIN" droit à un message un message d'erreur de type : "“thermal runaway” E0  / system halted" sur la X1 après 5 minutes d'impression alors que d'habitude dans ce mode elles plantée mais sans afficher aucun message ...  MrMagounet avait intuité ce PB de stabilité mais bizarrement via printrun jamais rien n'a été détecté malgré l'option debug impossible à mettre en évidence ... Au passage je viens de comprendre pourquoi il y a avait un capuchon de silicone sur la tête de l'extrudeur pour limiter les variation de détections de la sonde et maintenir une température constante ...   bref mieux vaut comprendre tard que jamais dommage le capuchon et je ne sais où dans l'atelier ...

Par contre ce qui me tue c'est que la sonde est bien connectée au corps de chauffe et que via printrun pas de pb d'impression en autonome via la clef USB.

 

Bon je vais essayer de tester avec le slicer appimage de artillerie histoire de voir si je peux imprimer ce gcode monstrueux.

 

SUDSUD

[sudtek]

Bonjour à tous,

Le projet séparateur cyclone a bien avancé et grâce à votre aide a pu être imprimé. J'ai fait une vidéo qui résume la situation actuelle reste plus qu'a  faire des tests d'aspirations et séparation...

avant de finaliser le connecteur d'attache rapide à verrouillage / maintient  magnétique :

 

 

et la collerette fixe :

A terme si c'est le résulta est satisfaisant les fichiers stl seront disponibles sur mon github pour une utilisation personnelle seulement.

 

SUDSUD

Modifié (le) Juillet 31, 2024 par sudtek