↓Salta al contenuto principale
Marco Papi
G-code Flow Gradient
  1. Blogs/

G-code Flow Gradient

·569 parole·3 minuti
Stampa 3D Stampa 3D Python PrusaSlicer G-Code
Indice dei contenuti

Introduzione
#

Lo script Python qui fornito consente di elaborare un file G-code, precedentemente creato con un software di slicing, per applicare un gradiente verticale di flusso al processo fisico di estrusione.

Lo script può trovare utilità qualora si necessiti, per esempio, di ottenere un gradiente verticale della densità di strutture alveolari (es. giroidi) senza intervenire sul tracciato di deposizione o variando nello slicer la densità di infill per ogni singolo strato.

Funzionamento
#

Lo script:

  1. Conteggia il numero di strati (layer) cercando nel file G-code il commento NEW_LAYER.
  2. Attribuisce uniformemente agli strati un incremento di flusso attraverso l’istruzione M221 (https://marlinfw.org/docs/gcode/M221.html) , applicando allo strato superiore il massimo valore di flusso indicato al momento del lancio del comando.
  3. Salva le modifiche in un nuovo file G-code con il suffisso _gradient.g.

Utilizzo
#

Impostare nel software di slicing (es. PrusaSlicer) l’introduzione automatica nel G-code del commento ; NEW_LAYER all’inizio di ogni nuovo strato.

Successivamente, immaginando:

  1. di salvare lo script Python con il nome flow-gradient.py,
  2. che il file Gcode da processare sia denominato print.gcode,
  3. che il flusso massimo da applicare all’ultimo strato più alto sia di 300,

lanciare da Terminale il comando:

py flow-gradient.py print.gcode 300

NOTA: per applicare un gradiente inverso (flusso massimo alla base e 100% allo strato più alto), modificare il valore della variabile reverse_direction da False a True.

Il codice
#

Il codice seguente:

  • È stato verificato come funzionante con G-code prodotto da PrusaSlicer.
  • Potrebbe non essere immediatamente funzionante e/o necessitare di modifiche in relazione alla natura del G-code trattato.
  • È distribuito con licenza Creative Commons CC-BY.
# GCODE FLOW GRADIENT - Ver. 0.1
# This script apply a flow gradient, using the M221 parameter, to a Gcode previously created by your preferred slicer

# Coded by Marco Papi - www.marcopapi.it
# License: Creative Commons CC-BY

import re
import sys
import os.path
import shutil
import fileinput

# SET GLOBAL VARIABLES
######################
global next_layer_flag
global new_suffix
global layers
global lin_steps
global reverse_direction
next_layer_flag = 'STRATO'
new_suffix = '_gradient.g'
lin_steps = []
reverse_direction = False

# GET ARGUMENTS
###############
source_gcode = sys.argv[1]
max_flow = int(sys.argv[2])

# GET PATH
##########
script_dir = os.path.dirname(os.path.realpath(__file__))

# DUPLICATE SOURCE FILE
#######################
def duplicate_gcode():
    # Define source
    source_file = os.path.join(script_dir,source_gcode)
    # Define destination, changing the name of the file
    destination_file = os.path.join(script_dir,(source_gcode.split('.')[0] + new_suffix))
    # Copy the content
    try:
         shutil.copy(source_file, destination_file)
         print("File copied successfully.")
    # If source and destination are same
    except shutil.SameFileError:
         print("Source and destination represents the same file.")
    # If there is any permission issue
    except PermissionError:
         print("Permission denied.")
    # For other errors
    except:
         print("Error occurred while copying file.")

# LAYERS COUNT
##############
def layer_count(): 
    global layers
    global next_layer_flag
    # Read the source gcode
    gcode = open(os.path.join(script_dir,(source_gcode.split('.')[0] + new_suffix))).read()
    # Count the "next_layer_flag" content recurrences
    layers = (gcode.lower()).count((next_layer_flag).lower())
    print('Total layers: ', layers)
    return layers

# LINEAR STEPS
##############
def linear_steps(top_flow): 
    global layers
    global lin_steps
    # Finding step values
    a = 0
    while a <= (layers - 1):
        step_value = (round(( (top_flow - 100) / (layers - 1) ) * a))+100
        # Populate the steps list from 0% to top flow %
        lin_steps.append([step_value])
        a += 1
    if reverse_direction == True:
        lin_steps.reverse()
    return lin_steps


# APPLY LINEAR GRADIENT
#######################
def write_gcode(): 
    a = 0
    for line in fileinput.input((os.path.join(script_dir,(source_gcode.split('.')[0] + new_suffix))), inplace=1):
        print(line, end="")
        if ((next_layer_flag).lower()) in line.lower():
            # Extract the M221 percentage from linear steps values array
            step_line = "M221 S"+ str(lin_steps[a][0])  
            print(step_line)
            a += 1          

# LAUNCH FUNCTIONS
##################
duplicate_gcode()
layer_count()
linear_steps(max_flow)
write_gcode()
Marco Papi
Autore
Marco Papi