[TUTO/INTER] Regler les vitesses et accélérations de votre trancheur.

[Yo']

Hello,

 

Dernièrement, grâce à @fran6p , j'ai découvert PrusaSlicer.

 

Au fil de mes lectures, j'ai lu un message fort intéressant de @Kachidoki.

Citation

la limite sera le débit admissible par la hotend. Les valeurs "standard" de ce débit sont : 15mm³/s pour du PLA, 11mm³/s pour l'ABS, et seulement 8mm³/s pour le PETG

 

Puis en cherchant à comprendre pourquoi mon imprimante se déplaçait "lentement", j'ai ouvert le Gcode généré par PrusaSlicer et j'ai vu ces quelques lignes en début de fichier.

M201 X500 Y500 Z100 E5000 ; sets maximum accelerations, mm/sec^2
M203 X500 Y500 Z10 E60 ; sets maximum feedrates, mm/sec
M204 P500 R1000 T500 ; sets acceleration (P, T) and retract acceleration (R), mm/sec^2
M205 X8.00 Y8.00 Z0.40 E5.00 ; sets the jerk limits, mm/sec

Pour les personnes qui ne connaissent pas, ces lignes de codes modifient les paramètres qui sont définies dans le firmware de la machine et qui indiquent les valeurs maximums de débit, d'accélération, de vitesse et de jerk.

 

Le plus beau n'est pas encore là.

Le plus beau, c'est que lors du tranchage, PrusaSlicer prend en compte ces valeurs pour calculer le temps d'impression.

 

Par exemple.

En prenant les profils par défaut de la ENDER3, en tranchant le STL de la visière, j'obtiens un temps de 4H27

Maintenant, je vais dans les réglages et je modifie une valeur dans les limites de la machine.

Ici, le "mouvement brusque" (jerk en anglais).

Comme on peut le voir sur l'image du dessous, il est réglé à 8 pour X et 8 pour Y.

Je vais y mettre une valeur fantaisiste de 80 (à ne pas utiliser car potentiellement destructrice pour votre imprimante)

Maintenant, je tranche de nouveau la pièce à imprimer et voici le nouveau temps.

3H48 au lieu de 4H27.

 

L'idée derrière tout ça, c'est d'utiliser la capacité de ce trancheur pour trouver des vitesses qui se veulent optimum, ou quasi optimum pour vos impressions.

 

Avant de vous lancer, il faut prendre en compte le fait que le réglage que vous allez faire sera optimum pour la pièce qui est découpée mais ne le sera pas forcement pour une autre pièce.

Il n’empêche qu'il sera probablement très bon pour cette autre pièce.

 

Il y a des valeurs qui peuvent être destructrices pour votre imprimante.

En premier lieu, le mouvement brusque.

Sur certains mouvements, la machine va se mettre à vibrer et certaines pièces peuvent casser / se dévisser / se dérégler / etc...

Au début, je vous recommande de ne pas déplacer 30 en X et en Y

En second lieu, l'accélération.

Lors d'accélérations trop violentes, le moteur peut sauter des pas (car il n'a pas assez de couple, un réglage s'impose peut-être).

Ceci va provoquer un décalage entre les couches imprimées.

Votre pièce peut également se décrocher du plateau.

 

Il est à noter également que des valeurs trop élevées (et ça concerne tous les réglages) vont impacter le rendu final.

 

Dernièrement, il faut garder à l'esprit que les réglages que vous allez faire sont théoriques et ne concernent que certains paramètres.

Votre imprimante ne va pas forcement pouvoir atteindre les valeurs max que vous aurez choisi mais dans l'ensemble, le résultat sera pas mal.

Par la suite, il faudra s'occuper de la ventilation, du débit, de la température, etc... mais ce n'est pas le but de ce tuto.

Il y en a d'autres --> ici <-- et --> là <-- plu tout ceux des autres sections.

 

Bref, après le blabla, l'action.

Le but du jeu est de régler les valeurs à un niveau minimum afin de préserver une bonne qualité, mais pas trop bas, pour ne pas perdre de temps sur l'impression.

Pour commencer, il faut mettre des valeurs fantaisistes.

Je n'ai pas touché la vitesse de la première couche car ce n'est pas elle qui va faire la différence et une première couche ratée, c'est une impression qui ne se terminera pas.

Maintenant, il faut trancher.

La nouvelle valeur est de 1h21.

Ensuite, il faut s'assurer que la valeur limitante actuelle est la vitesse volumétrique maximale.

Attention à bien choisir votre filament.

Pour vérifier que cette valeur est bien la valeur limitante, il faut la modifier et trancher de nouveau.

Ceci confirme que la valeur limitante est bien ce réglage.

Maintenant, il faut remettre la valeur d'origine.

Et on sait que quoi quelque soit les réglages, la durée d'impression théorique ne pourra être inférieure à 1 heure et 21 minutes.

Maintenant, le travail répétitif mais productif commence.

Il faut trouver les bonnes valeurs.

Je vous montrer le réglage de quelques unes, puis ce sera à vous de faire la suite jusqu'à ce que toutes vos valeurs soient judicieusement réglées.

Ensuite, il faudra faire un test d'impression pour valider.

Il faut garder en tête le précédent temps.

Dans notre cas : 1h21.

Je modifie la vitesse des périmètres.

Je découpe à nouveau

Le temps n'a pas bougé.

La valeur n'est donc pas limitante.

Je vais la baisser jusqu'à ce qu'elle influe sur la durée d'impression.

Là, la durée a augmenter.

Maintenant, il faut y aller à tâtons entre 80 et 100 (de 5 en 5 suffira) pour trouver un bon compromis.

95 ou 100 sont des valeurs intéressantes qu'il faudra confirmer lors d'une impression.

Maintenant, les périmètres courts.

Je m'aperçois qu'une valeur très faible n'a aucun impact sur la durée d'impression.

Plutôt que de garder cette valeur, je vais remettre celle d'origine car cette valeur (10) pourrait être fortement limitante pour l'impression d'un autre objet.

 

Pensez bien à enregistrer de temps en temps, surtout si vous allez voir un autre profil.

 

Après être allé voir le profil d'origine, j'ai modifié la valeur.

La valeur étant celle d'origine, le nom passe en vert.

 

Maintenant, c'est à vous de jouer.

Je vous conseille de commencer par les vitesses.

 

Puis de régler les limites de la machine.

 

Je vous le répète : pas plus de 30 en jerk en X et Y et pas plus de 900 en X et Y en accélération !

Avec suffisamment d'expérience (et de pièces pétées ? / d'impressions échouées ?), vous pourrez adapter ces valeurs.

 

Modifié (le) Avril 13, 2020 par Yo'
Correction de faute

[Kachidoki]

Magnifique post ! Merci !

Alors je répète ce que je viens de te dire sur l'autre topic, qui a tout a fait sa place ici :

il y a 4 minutes, Kachidoki a dit :

de mémoire, les machine limits correspondent aux valeurs qui sont censées être configurées dans le firmware

Ce qui veut dire que si tu configure une valeur plus élevée que la limite du firmware, tu auras un temps d'impression réel plus lent qu'estimé. Le machine limit doit correspondre exactement à ce qui est défini dans le firmware.

Parcontre dans Print settings -> Speed, là ce sont les valeurs pour ce tranchage, limité par les machine limits.

[Yo']

il y a 3 minutes, Kachidoki a dit :

Ce qui veut dire que si tu configure une valeur plus élevée que la limite du firmware, tu auras un temps d'impression réel plus lent qu'estimé

Nop, les valeurs du firmware sont écrasées par les M201, M203, M204 et M 205.

 

Par contre, les limites physiques de la machine vont augmenter le temps d'impression

 

[Kachidoki]

il y a 9 minutes, Yo' a dit :

Nop, les valeurs du firmware sont écrasées par les M201, M203, M204 et M 205.

Tu m'a mis le doute l'espace d'un instant, donc j'ai été vérifier. Tout du moins dans le Marlin de Prusa, les valeurs sont bien bornées si un G-code pour XY est reçu supérieur aux valeurs :

• M201 à 2500
• M203 à 200
• M205 à 10

Parcontre je n'ai pas été voir si ces limites existent dans le Marlin standard.

[Yo']

Sur ma GeeeTech, un M205 change la valeur réglée dans le firmware.

Par exemple, j'ai un M205 X40 Y40 en début de fichier qui change la valeur enregistrée, le temps de l'impressioàn.

Une fois que je fais un reset de l'imprimante, la valeur revient à celle du firmware.

 

Pour bien faire, faudrait que je fasse un M500 pour stocker les valeur une bonne fois pour toutes.

 

Modifié (le) Avril 3, 2020 par Yo'

[Kachidoki]

Je suis d'accord avec toi, ce que je dis c'est que ces valeurs sont limitées à un maximum. Extrait de code :

    case 205: 
    {
      if(code_seen('S')) cs.minimumfeedrate = code_value();
      if(code_seen('T')) cs.mintravelfeedrate = code_value();
      if(code_seen('B')) cs.minsegmenttime = code_value() ;
      if(code_seen('X')) cs.max_jerk[X_AXIS] = cs.max_jerk[Y_AXIS] = code_value();
      if(code_seen('Y')) cs.max_jerk[Y_AXIS] = code_value();
      if(code_seen('Z')) cs.max_jerk[Z_AXIS] = code_value();
      if(code_seen('E'))
      {
          float e = code_value();
#ifndef LA_NOCOMPAT

          e = la10c_jerk(e);
#endif
          cs.max_jerk[E_AXIS] = e;
      }
      if (cs.max_jerk[X_AXIS] > DEFAULT_XJERK) cs.max_jerk[X_AXIS] = DEFAULT_XJERK;
      if (cs.max_jerk[Y_AXIS] > DEFAULT_YJERK) cs.max_jerk[Y_AXIS] = DEFAULT_YJERK;
    }
    break;

C'est le même principe pour les autres G-Code, toutes les valeurs en dessous de ces limites imposées par le firmware sont acceptées.

En théorie, si tu met une valeur farfelue (très élevée), ton imprimante n'ira pas plus vite que ce maximum, ou alors elle perdra des pas car physiquement elle ne pourra pas suivre.

Je viens d'aller voir sur Marlin 2.0, ces limites existent aussi, mais peuvent ne pas être compilées.

[Yo']

Il y a 13 heures, Kachidoki a dit :

Parcontre je n'ai pas été voir si ces limites existent dans le Marlin standard

Notre malentendu se trouve là.

 

J'ai fouillé les coins et recoins des Marlins que j'ai sous la main et je n'ai pas trouvé les lignes de code que tu as posté.

Voici le code pour la commande M205 d'un Marlin 1.1.9 standard.

/**
 * M205: Set Advanced Settings
 *
 *    Q = Min Segment Time (µs)
 *    S = Min Feed Rate (units/s)
 *    T = Min Travel Feed Rate (units/s)
 *    X = Max X Jerk (units/sec^2)
 *    Y = Max Y Jerk (units/sec^2)
 *    Z = Max Z Jerk (units/sec^2)
 *    E = Max E Jerk (units/sec^2)
 *    J = Junction Deviation (mm) (Requires JUNCTION_DEVIATION)
 */
inline void gcode_M205() {
  if (parser.seen('Q')) planner.min_segment_time_us = parser.value_ulong();
  if (parser.seen('S')) planner.min_feedrate_mm_s = parser.value_linear_units();
  if (parser.seen('T')) planner.min_travel_feedrate_mm_s = parser.value_linear_units();
  #if ENABLED(JUNCTION_DEVIATION)
    if (parser.seen('J')) {
      const float junc_dev = parser.value_linear_units();
      if (WITHIN(junc_dev, 0.01f, 0.3f)) {
        planner.junction_deviation_mm = junc_dev;
        planner.recalculate_max_e_jerk();
      }
      else {
        SERIAL_ERROR_START();
        SERIAL_ERRORLNPGM("?J out of range (0.01 to 0.3)");
      }
    }
  #else
    #if ENABLED(HANGPRINTER)
      if (parser.seen('A')) planner.max_jerk[A_AXIS] = parser.value_linear_units();
      if (parser.seen('B')) planner.max_jerk[B_AXIS] = parser.value_linear_units();
      if (parser.seen('C')) planner.max_jerk[C_AXIS] = parser.value_linear_units();
      if (parser.seen('D')) planner.max_jerk[D_AXIS] = parser.value_linear_units();
    #else
      if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units();
      if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units();
      if (parser.seen('Z')) {
        planner.max_jerk[Z_AXIS] = parser.value_linear_units();
        #if HAS_MESH
          if (planner.max_jerk[Z_AXIS] <= 0.1f)
            SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses.");
        #endif
      }
    #endif
    if (parser.seen('E')) planner.max_jerk[E_AXIS] = parser.value_linear_units();
  #endif
}

C'est no limit

 

Au passage, voici le script qui me permet de fouiller tous les fichiers d'un dossier, en les filtrant par leur extension (.h et .cpp dans ce cas là)

find.py

Il faut mettre le fichier dans le dossier, ouvrir une console et lancer la commande "python find.py"

 

Maintenant, je voudrai trouver le moyen de piloter PrusaSlicer en ligne de commande.

Je pense que ces réglages sont automatisables.

 

Modifié (le) Avril 4, 2020 par Yo'

[Kachidoki]

Je suis développeur soft embarqué de métier, je sais fouiller du code source

Le même code dans Marlin 2.0.x :

/**
 * M205: Set Advanced Settings
 *
 *    B = Min Segment Time (µs)
 *    S = Min Feed Rate (units/s)
 *    T = Min Travel Feed Rate (units/s)
 *    X = Max X Jerk (units/sec^2)
 *    Y = Max Y Jerk (units/sec^2)
 *    Z = Max Z Jerk (units/sec^2)
 *    E = Max E Jerk (units/sec^2)
 *    J = Junction Deviation (mm) (If not using CLASSIC_JERK)
 */
void GcodeSuite::M205() {
  #if DISABLED(CLASSIC_JERK)
    #define J_PARAM  "J"
  #else
    #define J_PARAM
  #endif
  #if HAS_CLASSIC_JERK
    #define XYZE_PARAM "XYZE"
  #else
    #define XYZE_PARAM
  #endif
  if (!parser.seen("BST" J_PARAM XYZE_PARAM)) return;

  //planner.synchronize();
  if (parser.seen('B')) planner.settings.min_segment_time_us = parser.value_ulong();
  if (parser.seen('S')) planner.settings.min_feedrate_mm_s = parser.value_linear_units();
  if (parser.seen('T')) planner.settings.min_travel_feedrate_mm_s = parser.value_linear_units();
  #if DISABLED(CLASSIC_JERK)
    if (parser.seen('J')) {
      const float junc_dev = parser.value_linear_units();
      if (WITHIN(junc_dev, 0.01f, 0.3f)) {
        planner.junction_deviation_mm = junc_dev;
        #if ENABLED(LIN_ADVANCE)
          planner.recalculate_max_e_jerk();
        #endif
      }
      else
        SERIAL_ERROR_MSG("?J out of range (0.01 to 0.3)");
    }
  #endif
  #if HAS_CLASSIC_JERK
    if (parser.seen('X')) planner.set_max_jerk(X_AXIS, parser.value_linear_units());
    if (parser.seen('Y')) planner.set_max_jerk(Y_AXIS, parser.value_linear_units());
    if (parser.seen('Z')) {
      planner.set_max_jerk(Z_AXIS, parser.value_linear_units());
      #if HAS_MESH && DISABLED(LIMITED_JERK_EDITING)
        if (planner.max_jerk.z <= 0.1f)
          SERIAL_ECHOLNPGM("WARNING! Low Z Jerk may lead to unwanted pauses.");
      #endif
    }
    #if HAS_CLASSIC_E_JERK
      if (parser.seen('E')) planner.set_max_jerk(E_AXIS, parser.value_linear_units());
    #endif
  #endif
}

Ça passe par une méthode planner::set_max_jerk :

void Planner::set_max_jerk(const AxisEnum axis, float targetValue) {
  #if HAS_CLASSIC_JERK
    #if ENABLED(LIMITED_JERK_EDITING)
      constexpr xyze_float_t max_jerk_edit =
        #ifdef MAX_JERK_EDIT_VALUES
          MAX_JERK_EDIT_VALUES
        #else
          { (DEFAULT_XJERK) * 2, (DEFAULT_YJERK) * 2,
            (DEFAULT_ZJERK) * 2, (DEFAULT_EJERK) * 2 }
        #endif
      ;
      limit_and_warn(targetValue, axis, PSTR("Jerk"), max_jerk_edit);
    #endif
    max_jerk[axis] = targetValue;
  #else
    UNUSED(axis); UNUSED(targetValue);
  #endif
}

La fonction limit_and_warn fait ce job de limitation. Comme tu peux le voir, c'est conditionné par des macros, donc désactivable.

No limit ?

Pour aller plus loin, ça serait intéressant de trouver une méthode qui permette de définir ces limites physique de manière quantifiable. Comment savoir jusqu'où on peut pousser ces paramètres avant que la machine n'en souffre ?

 

Pour piloter PrusaSlicer en ligne de commande, j'ai trouvé ça ==> https://github.com/prusa3d/PrusaSlicer/wiki/Command-Line-Interface

Tu dois pouvoir utiliser prusa-slicer-console.exe pour avoir la version sans IHM.

Modifié (le) Avril 4, 2020 par Kachidoki

[Yo']

J'ai édité mon message pour préciser que le code que j'ai affiché est celui de Marlin 1.1.9.

 

Il y a 5 heures, Kachidoki a dit :

Pour aller plus loin, ça serait intéressant de trouver une méthode qui permette de définir ces limites physique de manière quantifiable. Comment savoir jusqu'où on peut pousser ces paramètres avant que la machine n'en souffre ?

Pour trouver les limites d'accélération de ma GeeeTech, je me suis fait un Gcode dans lequel

• Je calibre la vitesse au max
• Je calibre l'accélération à 500 (de mémoire)
• Je fais faire quelques aller-retour à un axe (Y en premier car c'est lui qui sera limitant) sur toute sa longueur.
• J'augmente l'accélération de 100
• Je fais faire quelques aller-retour à un axe sur toute sa longueur.
• J'augmente l'accélération de 100
• etc ...

 

Jusqu'à ce que le moteur saute des pas.

Il n'est pas nécessaire de peaufiner ce réglages vu qu'il est fait à vide et que lors de l'impression, avec le poids de la pièce, le plateau risque de sauter des pas si le réglage est trop optimisé à vide.

 

Pour le jerk, je l'ai réglé lors d'une impression lorsque j'ai entendu vibrer ma tête d'impression depuis la pièce d’à coté.

 

Modifié (le) Avril 4, 2020 par Yo'
Correction de faute

[palouf34]

Super merci pour se tuto fort instructif.

J le garde sous le coude..

[Keryn]

@Yo' Superbe tuto. Merci.

[Maya35]

Pour info prusaslicer dans la vue type de fonctionnalité indique maintenant le temps passé par fonctionnalité (infill, périmètre,.. ) bien pratique pour décider sur quelle vitesse jouer pour diminuer efficacement le temps de print

[Kachidoki]

En effet c'est hyper-pratique, je m'en sers tout le temps en combinaison avec la vue "Volumetric flow rate".

Exemple d'impression facilement optimisable sans dégrader le visuel :

Et ici une autre plus difficilement optimisable sans dégrader l'aspect :

On peut même masquer les fonctionnalités au choix en cliquant dessus, utile pour mieux voir certains détails internes.

[Maya35]

il y a 53 minutes, Kachidoki a dit :

On peut même masquer les fonctionnalités au choix en cliquant dessus, utile pour mieux voir certains détails internes.

Cool je n'avais pas vu cette possibilité. ..

RTFM