CAM scripting/it: Difference between revisions

From FreeCAD Documentation
(Updating to match new version of source page)
(Updating to match new version of source page)
 
(6 intermediate revisions by the same user not shown)
Line 1: Line 1:
<languages/>
<languages/>

{{TutorialInfo/it
{{Docnav
|Topic=Path
|[[CAM_Preferences|Preferences]]
|Level=Intermedio
|
|Time=
|[[CAM_Workbench|CAM]]
|Author=
|IconL=
|FCVersion=
|Files=
|IconR=
|IconC=Workbench_CAM.svg
}}
}}


{{TOCright}}

<span id="Introduction"></span>
==Introduzione==
==Introduzione==


<div class="mw-translate-fuzzy">
L'ambiente Path offre strumenti per importare, creare, manipolare e esportare [http://en.wikipedia.org/wiki/G-code percorsi delle macchine utensili] in FreeCAD. Con esso, l'utente è in grado di importare, visualizzare e modificare i programmi GCode esistenti, generare percorsi di forme 3D, ed esportare questi percorsi utensile in Gcode.
L'ambiente Path offre strumenti per importare, creare, manipolare e esportare [http://en.wikipedia.org/wiki/G-code percorsi delle macchine utensili] in FreeCAD. Con esso, l'utente è in grado di importare, visualizzare e modificare i programmi GCode esistenti, generare percorsi di forme 3D, ed esportare questi percorsi utensile in Gcode.
</div>


<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Line 17: Line 23:
</div>
</div>


<span id="Quickstart"></span>
== Avvio rapido ==
== Avvio rapido ==


Gli oggetti Path (percorso) di FreeCAD sono fatti di una sequenza di comandi di movimento. Un utilizzo tipico è questo:
Gli oggetti Path (percorso) di FreeCAD sono fatti di una sequenza di comandi di movimento. Un utilizzo tipico è questo:

<syntaxhighlight>
{{Code|code=
>>> import Path
>>> c1 = Path.Command("g1x1")
>>> import Path
>>> c2 = Path.Command("g1y4")
>>> c1 = Path.Command("g1x1")
>>> c3 = Path.Command("g1 x2 y2") # spaces end newlines are not considered
>>> c2 = Path.Command("g1y4")
>>> c3 = Path.Command("g1 x2 y2") # spaces end newlines are ignored
>>> p = Path.Path([c1,c2,c3])
>>> p = Path.Path([c1,c2,c3])
>>> o = App.ActiveDocument.addObject("Path::Feature","mypath")
>>> o = App.ActiveDocument.addObject("Path::Feature","mypath")
>>> o.Path = p
>>> print p.toGCode()
>>> o.Path = p
>>> print (p.toGCode())
</syntaxhighlight>
}}

<span id="The_FreeCAD_Internal_G-code_Format"></span>
<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
== Formato del GCode all'interno di FreeCAD ==
== Formato del GCode all'interno di FreeCAD ==
</div>
</div>


<div class="mw-translate-fuzzy">
Un concetto preliminare che importante da afferrare. La maggior parte della realizzazione sottostanti si basa prevalentemente sui comandi di movimento che hanno gli stessi nomi dei comandi GCode, ma non sono destinati ad avvicinarsi all'implementazione di un particolare controller. Abbiamo scelto nomi come 'G0' per rappresentare i movimento in 'rapida' o 'G1' per rappresentare i movimenti di 'alimentazione' per motivi di prestazioni (efficienza nel salvataggio dei file) e per ridurre al minimo il lavoro necessario per tradurre in/da altri formati GCode. Dal momento che il mondo CNC parla migliaia di dialetti GCode, abbiamo scelto di iniziare con un sottoinsieme molto semplificato di esso. Si potrebbe descrivere il formato GCode di FreeCAD come una forma "macchina-agnostica" di GCode.
Un concetto preliminare che importante da afferrare. La maggior parte della realizzazione sottostanti si basa prevalentemente sui comandi di movimento che hanno gli stessi nomi dei comandi GCode, ma non sono destinati ad avvicinarsi all'implementazione di un particolare controller. Abbiamo scelto nomi come 'G0' per rappresentare i movimento in 'rapida' o 'G1' per rappresentare i movimenti di 'alimentazione' per motivi di prestazioni (efficienza nel salvataggio dei file) e per ridurre al minimo il lavoro necessario per tradurre in/da altri formati GCode. Dal momento che il mondo CNC parla migliaia di dialetti GCode, abbiamo scelto di iniziare con un sottoinsieme molto semplificato di esso. Si potrebbe descrivere il formato GCode di FreeCAD come una forma "macchina-agnostica" di GCode.
</div>


<div class="mw-translate-fuzzy">
All'interno dei file .FCStd, i dati Path vengono salvati direttamente in quella forma di GCode.
All'interno dei file .FCStd, i dati Path vengono salvati direttamente in quella forma di GCode.
</div>


<div class="mw-translate-fuzzy">
Tutte le traduzioni dai/nei dialetti del GCode di FreeCAD vengono effettuate tramite pre e post script. Ciò significa che, se si desidera lavorare con una macchina che utilizza uno specifico controller LinuxCNC, Fanuc, Mitusubishi o HAAS, ecc, si deve usare (o scrivere se è inesistente) un post processore per quel particolare controllo (vedere più avanti la sezione "Importare ed esportare GCode).
Tutte le traduzioni dai/nei dialetti del GCode di FreeCAD vengono effettuate tramite pre e post script. Ciò significa che, se si desidera lavorare con una macchina che utilizza uno specifico controller LinuxCNC, Fanuc, Mitusubishi o HAAS, ecc, si deve usare (o scrivere se è inesistente) un post processore per quel particolare controllo (vedere più avanti la sezione "Importare ed esportare GCode).
</div>


<span id="G-code_Reference"></span>
<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
=== Riferimenti GCode ===
=== Riferimenti GCode ===
</div>
</div>


<div class="mw-translate-fuzzy">
Le seguenti regole e linee guida definiscono il sottoinsieme di GCode utilizzato all'interno di FreeCAD:
Le seguenti regole e linee guida definiscono il sottoinsieme di GCode utilizzato all'interno di FreeCAD:
</div>


<div class="mw-translate-fuzzy">
* I dati GCode, all'interno degli oggetti Path di FreeCAD, sono separati in "Commands" (comandi). Un comando è definito dal nome del comando, che deve iniziare con G o M, e da argomenti(opzionali), che sono nella forma Lettera = Float (flottante), ad esempio X 0.02 o Y 3.5 o F 300. Questi sono esempi di tipici comandi Gcode in FreeCAD:
* I dati GCode, all'interno degli oggetti Path di FreeCAD, sono separati in "Commands" (comandi). Un comando è definito dal nome del comando, che deve iniziare con G o M, e da argomenti(opzionali), che sono nella forma Lettera = Float (flottante), ad esempio X 0.02 o Y 3.5 o F 300. Questi sono esempi di tipici comandi Gcode in FreeCAD:
</div>


<div class="mw-translate-fuzzy">
G0 X2.5 Y0 (Il nome del comando è G0, gli argomenti sono X=2.5 e Y=0)
G0 X2.5 Y0 (Il nome del comando è G0, gli argomenti sono X=2.5 e Y=0)
</div>


<div class="mw-translate-fuzzy">
G1 X30 (Il nome del comando è G1, l'unico argomento è X=30)
G1 X30 (Il nome del comando è G1, l'unico argomento è X=30)
</div>


<div class="mw-translate-fuzzy">
G90 (Il nome del comando è G90, non ci sono argomentis)
G90 (Il nome del comando è G90, non ci sono argomentis)
</div>


<div class="mw-translate-fuzzy">
* Per la parte numerica di un comando G o M, sono supportate sia la forma "G1" sia "G01" .
* Per la parte numerica di un comando G o M, sono supportate sia la forma "G1" sia "G01" .
* In questo momento sono supportati solo i comandi che iniziano per G o M.
* In questo momento sono supportati solo i comandi che iniziano per G o M.
Line 63: Line 91:
* X, Y, o Z (e A, B, C) possono essere omessi. In questo caso, sono mantenuti le precedenti coordinate X, Y o Z.
* X, Y, o Z (e A, B, C) possono essere omessi. In questo caso, sono mantenuti le precedenti coordinate X, Y o Z.
* I comandi GCode diversi da quelli elencati nella seguente tabella sono supportati, cioè, vengono salvati all'interno dei dati del percorso ( naturalmente, a patto che siano conformi alle regole di cui sopra), ma non producono alcun risultato visibile sullo schermo. Ad esempio, è possibile aggiungere un comando G81, esso viene memorizzato, ma non visualizzato.
* I comandi GCode diversi da quelli elencati nella seguente tabella sono supportati, cioè, vengono salvati all'interno dei dati del percorso ( naturalmente, a patto che siano conformi alle regole di cui sopra), ma non producono alcun risultato visibile sullo schermo. Ad esempio, è possibile aggiungere un comando G81, esso viene memorizzato, ma non visualizzato.
</div>


<span id="List_of_currently_supported_G-code_commands"></span>
<div class="mw-translate-fuzzy">
=== Elenco dei comandi Gcode attualmente supportati ===
=== Elenco dei comandi Gcode attualmente supportati ===
</div>


<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Line 106: Line 138:
</div>
</div>


<span id="The_Command_object"></span>
== L'oggetto Command ==
== L'oggetto Command ==


<div class="mw-translate-fuzzy">
L'oggetto Command rappresenta un comando Gcode. Ha tre attributi: Name, Parameters e Placement (Nome,Parametri e posizione), e due metodi: toGCode() e setFromGCode(). Internamente, contiene solo un nome e un dizionario di parametri. Il resto (posizionamento e gcode) viene calcolato da/a questi dati.
L'oggetto Command rappresenta un comando Gcode. Ha tre attributi: Name, Parameters e Placement (Nome,Parametri e posizione), e due metodi: toGCode() e setFromGCode(). Internamente, contiene solo un nome e un dizionario di parametri. Il resto (posizionamento e gcode) viene calcolato da/a questi dati.
</div>
<syntaxhighlight>

>>> import Path
{{Code|code=
>>> c=Path.Command()
>>> c
>>> import Path
Command ( )
>>> c=Path.Command()
>>> c.Name = "G1"
>>> c
Command ( )
>>> c
>>> c.Name = "G1"
Command G1 ( )
>>> c
>>> c.Parameters= {"X":1,"Y":0}
Command G1 ( )
>>> c
>>> c.Parameters= {"X":1,"Y":0}
Command G1 ( X:1 Y:0 )
>>> c.Parameters
>>> c
{'Y': 0.0, 'X': 1.0}
Command G1 ( X:1 Y:0 )
>>> c.Parameters= {"X":1,"Y":0.5}
>>> c.Parameters
{'Y': 0.0, 'X': 1.0}
>>> c
Command G1 ( X:1 Y:0.5 )
>>> c.Parameters= {"X":1,"Y":0.5}
>>> c.toGCode()
>>> c
'G1X1Y0.5'
Command G1 ( X:1 Y:0.5 )
>>> c2=Path.Command("G2")
>>> c.toGCode()
'G1X1Y0.5'
>>> c2
Command G2 ( )
>>> c2=Path.Command("G2")
>>> c2
>>> c3=Path.Command("G1",{"X":34,"Y":1.2})
Command G2 ( )
>>> c3
Command G1 ( X:34 Y:1.2 )
>>> c3=Path.Command("G1",{"X":34,"Y":1.2})
>>> c3.Placement
>>> c3
Command G1 ( X:34 Y:1.2 )
Placement [Pos=(34,1.2,0), Yaw-Pitch-Roll=(0,0,0)]
>>> c3.toGCode()
>>> c3.Placement
Placement [Pos=(34,1.2,0), Yaw-Pitch-Roll=(0,0,0)]
'G1X34Y1.2'
>>> c3.setFromGCode("G1X1Y0")
>>> c3.toGCode()
'G1X34Y1.2'
>>> c3
>>> c3.setFromGCode("G1X1Y0")
Command G1 [ X:1 Y:0 ]
>>> c3
>>> c4 = Path.Command("G1X4Y5")
>>> c4
Command G1 [ X:1 Y:0 ]
Command G1 [ X:4 Y:5 ]
>>> c4 = Path.Command("G1X4Y5")
>>> c4
>>> p1 = App.Placement()
Command G1 [ X:4 Y:5 ]
>>> p1.Base = App.Vector(3,2,1)
>>> p1
>>> p1 = App.Placement()
>>> p1.Base = App.Vector(3,2,1)
Placement [Pos=(3,2,1), Yaw-Pitch-Roll=(0,0,0)]
>>> p1
>>> c5=Path.Command("g1",p1)
Placement [Pos=(3,2,1), Yaw-Pitch-Roll=(0,0,0)]
>>> c5
Command G1 [ X:3 Y:2 Z:1 ]
>>> c5=Path.Command("g1",p1)
>>> c5
>>> p2=App.Placement()
Command G1 [ X:3 Y:2 Z:1 ]
>>> p2.Base = App.Vector(5,0,0)
>>> p2=App.Placement()
>>> c5
>>> p2.Base = App.Vector(5,0,0)
Command G1 [ X:3 Y:2 Z:1 ]
>>> c5.Placement=p2
>>> c5
Command G1 [ X:3 Y:2 Z:1 ]
>>> c5
>>> c5.Placement=p2
Command G1 [ X:5 ]
>>> c5.x
>>> c5
5.0
Command G1 [ X:5 ]
>>> c5.x=10
>>> c5.x
5.0
>>> c5
>>> c5.x=10
Command G1 [ X:10 ]
>>> c5.y=2
>>> c5
Command G1 [ X:10 ]
>>> c5
>>> c5.y=2
Command G1 [ X:10 Y:2 ]
>>> c5
</syntaxhighlight>
Command G1 [ X:10 Y:2 ]
}}

<span id="The_Path_object"></span>
== L'oggetto Path ==
== L'oggetto Path ==


L'oggetto Path contiene un elenco di comandi
L'oggetto Path contiene un elenco di comandi

<syntaxhighlight>
{{Code|code=
>>> import Path
>>> import Path
>>> c1=Path.Command("g1",{"x":1,"y":0})
>>> c2=Path.Command("g1",{"x":0,"y":2})
>>> c1=Path.Command("g1",{"x":1,"y":0})
>>> p=Path.Path([c1,c2])
>>> c2=Path.Command("g1",{"x":0,"y":2})
>>> p=Path.Path([c1,c2])
>>> p
>>> p
Path [ size:2 length:3 ]
Path [ size:2 length:3 ]
>>> p.Commands
>>> p.Commands
[Command G1 [ X:1 Y:0 ], Command G1 [ X:0 Y:2 ]]
[Command G1 [ X:1 Y:0 ], Command G1 [ X:0 Y:2 ]]
>>> p.Length
>>> p.Length
3.0
3.0
>>> p.addCommands(c1)
>>> p.addCommands(c1)
Path [ size:3 length:4 ]
Path [ size:3 length:4 ]
>>> p.toGCode()
>>> p.toGCode()
'G1X1G1Y2G1X1'
'G1X1G1Y2G1X1'

lines = """
lines = """
G0X-0.5905Y-0.3937S3000M03
G0X-0.5905Y-0.3937S3000M03
G0Z0.125
G0Z0.125
G1Z-0.004F3
G1Z-0.004F3
G1X0.9842Y-0.3937F14.17
G1X0.9842Y0.433
G1X0.9842Y-0.3937F14.17
G1X-0.5905Y0.433
G1X0.9842Y0.433
G1X-0.5905Y-0.3937
G1X-0.5905Y0.433
G1X-0.5905Y-0.3937
G0Z0.5
G0Z0.5
"""
"""

slines = lines.split('\n')
p = Path.Path()
slines = lines.split('\n')
p = Path.Path()
for line in slines:
for line in slines:
p.addCommands(Path.Command(line))
p.addCommands(Path.Command(line))

o = App.ActiveDocument.addObject("Path::Feature","mypath")
o = App.ActiveDocument.addObject("Path::Feature","mypath")
o.Path = p
o.Path = p

# but you can also create a path directly form a piece of gcode.
# but you can also create a path directly form a piece of G-code.
# The commands will be created automatically:
# The commands will be created automatically:

p = Path.Path()
p = Path.Path()
p.setFromGCode(lines)
p.setFromGCode(lines)
</syntaxhighlight>
}}

<div class="mw-translate-fuzzy">
Come scorciatoia, un oggetto Path può anche essere creato direttamente da una sequenza completa di GCode. Sarà diviso automaticamente in una sequenza di comandi.
Come scorciatoia, un oggetto Path può anche essere creato direttamente da una sequenza completa di GCode. Sarà diviso automaticamente in una sequenza di comandi.
</div>
<syntaxhighlight>

>>> p = Path.Path("G0 X2 Y2 G1 X0 Y2")
{{Code|code=
>>> p
Path [ size:2 length:2 ]
>>> p = Path.Path("G0 X2 Y2 G1 X0 Y2")
>>> p
</syntaxhighlight>
Path [ size:2 length:2 ]
}}


<span id="The_Path_feature"></span>
== La funzione Path ==
== La funzione Path ==


La funzione Path è un oggetto documento di FreeCAD, che contiene un percorso, e lo rappresenta nella vista 3D.
La funzione Path è un oggetto documento di FreeCAD, che contiene un percorso, e lo rappresenta nella vista 3D.

<syntaxhighlight>
{{Code|code=
>>> pf = App.ActiveDocument.addObject("Path::Feature","mypath")
>>> pf = App.ActiveDocument.addObject("Path::Feature","mypath")
>>> pf
>>> pf
<Document object>
<Document object>
>>> pf.Path = p
>>> pf.Path
>>> pf.Path = p
>>> pf.Path
Path [ size:2 length:2 ]
Path [ size:2 length:2 ]
</syntaxhighlight>
}}

La funzione Path detiene inoltre una proprietà Placement. Cambiando il valore del posizionamento si cambia la posizione della funzionalità nella vista 3D, anche se le informazioni sul percorso sono invariate. La trasformazione è puramente visiva. Ciò consente, ad esempio, di creare un percorso attorno a una faccia che ha un particolare orientamento nel modello, e che non è lo stesso orientamento che il materiale da tagliare avrà sulla macchina CNC.
La funzione Path detiene inoltre una proprietà Placement. Cambiando il valore del posizionamento si cambia la posizione della funzionalità nella vista 3D, anche se le informazioni sul percorso sono invariate. La trasformazione è puramente visiva. Ciò consente, ad esempio, di creare un percorso attorno a una faccia che ha un particolare orientamento nel modello, e che non è lo stesso orientamento che il materiale da tagliare avrà sulla macchina CNC.


Tuttavia, i Path Compounds possono usufruire del Placement (posizionamento) dei propri figli (vedi sotto).
Tuttavia, i Path Compounds possono usufruire del Placement (posizionamento) dei propri figli (vedi sotto).


<span id="The_Tool_and_Tooltable_objects"></span>
<div class="mw-translate-fuzzy">
== Gli utensili e la tabella utensili ==
== Gli utensili e la tabella utensili ==
</div>


'''NOTE:''' This type of tool usage is depreciated as of the 0.19 official release. In 0.19 the new ToolBit tool system was implemented to supersede this older, Legacy, system. Therefore, coding has changed from what is represented below. Please visit [[Path_Tools|Path Tools]] page for more information.

===Scripting <= 0.18===


L'oggetto strumento contiene le definizioni di un utensile CNC. L'oggetto Tooltable contiene un elenco ordinato di strumenti. Le Tooltable sono unite come una proprietà alle funzioni Path Project, e possono anche essere modificate tramite l'interfaccia grafica, facendo doppio clic su un progetto nella vista ad albero, e facendo clic sul pulsante "Modifica tooltable" nelle vista azioni che viene aperta.
L'oggetto strumento contiene le definizioni di un utensile CNC. L'oggetto Tooltable contiene un elenco ordinato di strumenti. Le Tooltable sono unite come una proprietà alle funzioni Path Project, e possono anche essere modificate tramite l'interfaccia grafica, facendo doppio clic su un progetto nella vista ad albero, e facendo clic sul pulsante "Modifica tooltable" nelle vista azioni che viene aperta.


Da questa finestra, le tooltable possono essere importate dai formati .xml di FreeCAD e .tooltable di HeeksCad, ed esportate nel formato .xml di FreeCAD.
Da questa finestra, le tooltable possono essere importate dai formati .xml di FreeCAD e .tooltable di HeeksCad, ed esportate nel formato .xml di FreeCAD.

<syntaxhighlight>
{{Code|code=
>>> import Path
>>> t1=Path.Tool()
>>> import Path
>>> t1
>>> t1=Path.Tool()
>>> t1
Tool Default tool
Tool Default tool
>>> t1.Name = "12.7mm Drill Bit"
>>> t1.Name = "12.7mm Drill Bit"
>>> t1
>>> t1
Tool 12.7mm Drill Bit
Tool 12.7mm Drill Bit
>>> t1.ToolType
>>> t1.ToolType
'Undefined'
'Undefined'
>>> t1.ToolType = "Drill"
>>> t1.Diameter= 12.7
>>> t1.ToolType = "Drill"
>>> t1.LengthOffset = 127
>>> t1.Diameter= 12.7
>>> t1.CuttingEdgeAngle = 59
>>> t1.LengthOffset = 127
>>> t1.CuttingEdgeHeight = 50.8
>>> t1.CuttingEdgeAngle = 59
>>> t1.CuttingEdgeHeight = 50.8
>>> t2 = Path.Tool("my other tool",tooltype="EndMill",diameter=10)
>>> t2 = Path.Tool("my other tool",tooltype="EndMill",diameter=10)
>>> t2
>>> t2
Tool my other tool
Tool my other tool
>>> t2.Diameter
>>> t2.Diameter
10.0
10.0
>>> table = Path.Tooltable()
>>> table
>>> table = Path.Tooltable()
>>> table
Tooltable containing 0 tools
Tooltable containing 0 tools
>>> table.addTools(t1)
>>> table.addTools(t1)
Tooltable containing 1 tools
Tooltable containing 1 tools
>>> table.addTools(t2)
>>> table.addTools(t2)
Tooltable containing 2 tools
Tooltable containing 2 tools
>>> table.Tools
>>> table.Tools
{1: Tool 12.7mm Drill Bit, 2: Tool my other tool}
{1: Tool 12.7mm Drill Bit, 2: Tool my other tool}
>>>
>>>
</syntaxhighlight>
}}

<span id="Features"></span>
== Funzioni ==
== Funzioni ==


<span id="The_Path_Compound_feature"></span>
=== La funzione Path Compound ===
=== La funzione Path Compound ===


Lo scopo di questa funzione è quello di raccogliere uno o più percorsi utensile e di associarlo/i con una tooltable. La funzione Compound si comporta anche come un gruppo standard di FreeCAD, in modo da poter aggiungere o rimuovere oggetti direttamente dalla visualizzazione struttura. È inoltre possibile riordinare gli elementi facendo doppio clic sull'oggetto Compound nella struttura ad albero, e riordinare gli elementi nella vista azioni che viene aperta.
Lo scopo di questa funzione è quello di raccogliere uno o più percorsi utensile e di associarlo/i con una tooltable. La funzione Compound si comporta anche come un gruppo standard di FreeCAD, in modo da poter aggiungere o rimuovere oggetti direttamente dalla visualizzazione struttura. È inoltre possibile riordinare gli elementi facendo doppio clic sull'oggetto Compound nella struttura ad albero, e riordinare gli elementi nella vista azioni che viene aperta.

<syntaxhighlight>
{{Code|code=
>>> import Path
>>> p1 = Path.Path("G1X1")
>>> import Path
>>> p1 = Path.Path("G1X1")
>>> o1 = App.ActiveDocument.addObject("Path::Feature","path1")
>>> o1 = App.ActiveDocument.addObject("Path::Feature","path1")
>>> o1.Path=p1
>>> p2 = Path.Path("G1Y1")
>>> o1.Path=p1
>>> p2 = Path.Path("G1Y1")
>>> o2 = App.ActiveDocument.addObject("Path::Feature","path2")
>>> o2 = App.ActiveDocument.addObject("Path::Feature","path2")
>>> o2.Path=p2
>>> o2.Path=p2
>>> o3 = App.ActiveDocument.addObject("Path::FeatureCompound","compound")
>>> o3 = App.ActiveDocument.addObject("Path::FeatureCompound","compound")
>>> o3.Group=[o1,o2]
>>> o3.Group=[o1,o2]
</syntaxhighlight>
}}

Una caratteristica importante di Path Compounds è la possibilità di tenere conto o no della posizione dei percorsi dei loro figli, impostando la loro proprietà UsePlacements su True o False. In caso contrario, i dati Percorso dei loro figli saranno semplicemente aggiunti in sequenza. Se True, ogni comando dei percorsi figli, qualora contengano informazioni di posizione (G0, G1, ecc ..), prima di essere aggiunto verrà trasformato dal posizionamento.
Una caratteristica importante di Path Compounds è la possibilità di tenere conto o no della posizione dei percorsi dei loro figli, impostando la loro proprietà UsePlacements su True o False. In caso contrario, i dati Percorso dei loro figli saranno semplicemente aggiunti in sequenza. Se True, ogni comando dei percorsi figli, qualora contengano informazioni di posizione (G0, G1, ecc ..), prima di essere aggiunto verrà trasformato dal posizionamento.


Creating a compound with just one child path allows you therefore to turn the child path's Placement "real" (it affects the Path data).
Creating a compound with just one child path allows you therefore to turn the child path's Placement "real" (it affects the Path data).


<span id="The_Path_Project_feature"></span>
=== La funzione Path Project ===
=== La funzione Path Project ===


<div class="mw-translate-fuzzy">
Il progetto Path è un tipo di Compound esteso, che ha un paio di ulteriori proprietà correlate alla macchina, come una tooltable. È fatto principalmente per essere il principale tipo di oggetto che si desidera esportare in Gcode quando la configurazione dell'intero percorso è pronta. L'oggetto Project è codificato in python, per cui il suo meccanismo di creazione è un po 'diverso:
Il progetto Path è un tipo di Compound esteso, che ha un paio di ulteriori proprietà correlate alla macchina, come una tooltable. È fatto principalmente per essere il principale tipo di oggetto che si desidera esportare in Gcode quando la configurazione dell'intero percorso è pronta. L'oggetto Project è codificato in python, per cui il suo meccanismo di creazione è un po 'diverso:
</div>
<syntaxhighlight>

>>> from PathScripts import PathProject
{{Code|code=
>>> o4 = App.ActiveDocument.addObject("Path::FeatureCompoundPython","prj")
>>> PathProject.ObjectPathProject(o4)
>>> from PathScripts import PathProject
>>> o4 = App.ActiveDocument.addObject("Path::FeatureCompoundPython","prj")
>>> o4.Group = [o3]
>>> PathProject.ObjectPathProject(o4)
>>> o4.Tooltable
>>> o4.Group = [o3]
Tooltable containing 0 tools
>>> o4.Tooltable
</syntaxhighlight>
Tooltable containing 0 tools
}}

<div class="mw-translate-fuzzy">
Il modulo Path dispone anche di un editor GUI per la tooltable che può essere chiamato in python, dandogli un oggetto che ha una proprietà ToolTable:
Il modulo Path dispone anche di un editor GUI per la tooltable che può essere chiamato in python, dandogli un oggetto che ha una proprietà ToolTable:
</div>
<syntaxhighlight>

>>> from PathScripts import TooltableEditor
{{Code|code=
>>> TooltableEditor.edit(o4)
>>> from PathScripts import TooltableEditor
</syntaxhighlight>
>>> TooltableEditor.edit(o4)
}}


<span id="Getting_Path_from_Shape"></span>
<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
=== La funzione Path Shape ===
=== La funzione Path Shape ===
Line 312: Line 381:
Questa funzione è un normale oggetto Path con una proprietà Shape aggiuntiva. Dando alla proprietà una forma Wire, il percorso verrà calcolato automaticamente dalla forma. Si noti che in questo caso il posizionamento viene impostato automaticamente al primo punto del wire, e quindi l'oggetto non è più movibile modificando il suo posizionamento. Per spostarlo, si deve spostare la forma sottostante.
Questa funzione è un normale oggetto Path con una proprietà Shape aggiuntiva. Dando alla proprietà una forma Wire, il percorso verrà calcolato automaticamente dalla forma. Si noti che in questo caso il posizionamento viene impostato automaticamente al primo punto del wire, e quindi l'oggetto non è più movibile modificando il suo posizionamento. Per spostarlo, si deve spostare la forma sottostante.
</div>
</div>
<syntaxhighlight>
>>> import Part
>>> import Path
>>> v1 = FreeCAD.Vector(0,0,0)
>>> v2 = FreeCAD.Vector(0,2,0)
>>> v3 = FreeCAD.Vector(2,2,0)
>>> v4 = FreeCAD.Vector(3,3,0)
>>> wire = Part.makePolygon([v1,v2,v3,v4])
>>> o = FreeCAD.ActiveDocument.addObject("Path::Feature","myPath2")
>>> o.Path = Path.fromShape(wire)
>>> FreeCAD.ActiveDocument.recompute()
>>> p = o.Path
>>> print(p.toGCode())
</syntaxhighlight>


{{Code|code=
>>> import Part
>>> import Path
>>> v1 = FreeCAD.Vector(0,0,0)
>>> v2 = FreeCAD.Vector(0,2,0)
>>> v3 = FreeCAD.Vector(2,2,0)
>>> v4 = FreeCAD.Vector(3,3,0)
>>> wire = Part.makePolygon([v1,v2,v3,v4])
>>> o = FreeCAD.ActiveDocument.addObject("Path::Feature","myPath2")
>>> o.Path = Path.fromShape(wire)
>>> FreeCAD.ActiveDocument.recompute()
>>> p = o.Path
>>> print(p.toGCode())
}}

<span id="Python_features"></span>
=== Funzioni Python ===
=== Funzioni Python ===


<div class="mw-translate-fuzzy">
Le funzioni Path::Feature e Path::FeatureShape hanno una versione Python, chiamate rispettivamente, Path::FeaturePython e Path::FeatureShapePython, che possono essere utilizzate nel codice python per creare oggetti parametrici avanzati derivati da esse.
Le funzioni Path::Feature e Path::FeatureShape hanno una versione Python, chiamate rispettivamente, Path::FeaturePython e Path::FeatureShapePython, che possono essere utilizzate nel codice python per creare oggetti parametrici avanzati derivati da esse.
</div>


<span id="Importing_and_exporting_G-code"></span>
<div class="mw-translate-fuzzy">
== Importare e esportare GCode ==
== Importare e esportare GCode ==
</div>


<span id="Native_format"></span>
=== Formato nativo ===
=== Formato nativo ===


<div class="mw-translate-fuzzy">
I file gcode possono essere importati ed esportati direttamente tramite l'interfaccia grafica, utilizzandole voci "Esporta", "Apri" o "Inserisci" del menu. Quando il nome del file è acquisito, si apre una finestra che chiede quale script di elaborazione deve utilizzare. Può anche essere fatto in python:
I file gcode possono essere importati ed esportati direttamente tramite l'interfaccia grafica, utilizzandole voci "Esporta", "Apri" o "Inserisci" del menu. Quando il nome del file è acquisito, si apre una finestra che chiede quale script di elaborazione deve utilizzare. Può anche essere fatto in python:
</div>


<div class="mw-translate-fuzzy">
Le informazioni sul Percorso vengono memorizzate in oggetti Path utilizzando un sottoinsieme di gcode descritto nella sezione "Formato del GCode all'interno di FreeCAD" di cui sopra. Questo sottoinsieme può essere importato o esportato "come è", o convertito in/da una particolare versione di GCode adatto alla vostra macchina.
Le informazioni sul Percorso vengono memorizzate in oggetti Path utilizzando un sottoinsieme di gcode descritto nella sezione "Formato del GCode all'interno di FreeCAD" di cui sopra. Questo sottoinsieme può essere importato o esportato "come è", o convertito in/da una particolare versione di GCode adatto alla vostra macchina.
</div>


<div class="mw-translate-fuzzy">
Se si dispone di un programma di GCode molto semplice e standard, che compila le regole descritte nella sezione "Formato del GCode all'interno di FreeCAD" di cui sopra, per esempio, il boomerang da http://www.cnccookbook.com/GWESampleFiles.html , esso può essere importato direttamente in un oggetto Path, senza traduzione (questo equivale a utilizzare l'opzione "None" della finestra GUI):
Se si dispone di un programma di GCode molto semplice e standard, che compila le regole descritte nella sezione "Formato del GCode all'interno di FreeCAD" di cui sopra, per esempio, il boomerang da http://www.cnccookbook.com/GWESampleFiles.html , esso può essere importato direttamente in un oggetto Path, senza traduzione (questo equivale a utilizzare l'opzione "None" della finestra GUI):
</div>


{{Code|code=
<syntaxhighlight>
import Path
import Path
f = open("/path/to/boomerangv4.ncc")
f = open("/path/to/boomerangv4.ncc")
s = f.read()
s = f.read()
p = Path.Path(s)
p = Path.Path(s)
o = App.ActiveDocument.addObject("Path::Feature","boomerang")
o = App.ActiveDocument.addObject("Path::Feature","boomerang")
o.Path = p
o.Path = p
}}
</syntaxhighlight>


<div class="mw-translate-fuzzy">
Allo stesso modo, è possibile ottenere le informazioni sul percorso come gcode "agnostico", e memorizzarle manualmente in un file:
Allo stesso modo, è possibile ottenere le informazioni sul percorso come gcode "agnostico", e memorizzarle manualmente in un file:
</div>


{{Code|code=
<syntaxhighlight>
text = o.Path.toGCode()
text = o.Path.toGCode()
print text
print text
myfile = open("/path/to/newfile.ngc")
myfile = open("/path/to/newfile.ngc")
myfile.write(text)
myfile.write(text)
myfile.close()
myfile.close()
}}
</syntaxhighlight>


<div class="mw-translate-fuzzy">
Se serve un output diverso, però, è necessario convertire questo GCode agnostico in un formato adatto alla macchina. Questo è compito dello script di post-processing.
Se serve un output diverso, però, è necessario convertire questo GCode agnostico in un formato adatto alla macchina. Questo è compito dello script di post-processing.
</div>


<span id="Using_pre-_and_post-processing_scripts"></span>
=== Utilizzare gli script di pre e post-elaborazione ===
=== Utilizzare gli script di pre e post-elaborazione ===


<div class="mw-translate-fuzzy">
Se si dispone di un file gcode scritto per una macchina particolare, che non è conforme alle regole interne utilizzate dai FreeCAD, descritte nella sezione "Formato GCode interno a FreeCAD" di cui sopra, si potrebbe non riuscire a importarlo e/o renderlo correttamente nella 3D vista. Per rimediare a questo, è necessario utilizzare uno script di pre-elaborazione, che converte dal formato di una specifica macchina al formato di FreeCAD.
Se si dispone di un file gcode scritto per una macchina particolare, che non è conforme alle regole interne utilizzate dai FreeCAD, descritte nella sezione "Formato GCode interno a FreeCAD" di cui sopra, si potrebbe non riuscire a importarlo e/o renderlo correttamente nella 3D vista. Per rimediare a questo, è necessario utilizzare uno script di pre-elaborazione, che converte dal formato di una specifica macchina al formato di FreeCAD.
</div>


<div class="mw-translate-fuzzy">
Se si conosce il nome dello script di pre-elaborazione da utilizzare, è possibile importare il file usando, dalla console python questo:
Se si conosce il nome dello script di pre-elaborazione da utilizzare, è possibile importare il file usando, dalla console python questo:
</div>
<syntaxhighlight>

import example_pre
{{Code|code=
example_pre.insert("/path/to/myfile.ncc","DocumentName")
import example_pre
</syntaxhighlight>
example_pre.insert("/path/to/myfile.ncc","DocumentName")
}}

<div class="mw-translate-fuzzy">
Allo stesso modo, è possibile emettere un oggetto tracciato per GCode, utilizzando uno script post_processor in questo modo:
Allo stesso modo, è possibile emettere un oggetto tracciato per GCode, utilizzando uno script post_processor in questo modo:
</div>
<syntaxhighlight>

import example_post
{{Code|code=
example_post.export (myObjectName,"/path/to/outputFile.ncc")
import example_post
</syntaxhighlight>
example_post.export (myObjectName,"/path/to/outputFile.ncc")
}}

<span id="Writing_processing_scripts"></span>
=== Scrivere script di elaborazione ===
=== Scrivere script di elaborazione ===


Gli script di pre e post-elaborazione si comportano come gli altri comuni importatori e esportatori di FreeCAD. Quando si sceglie uno script di /post elaborazione dalla finestra di dialogo, il processo di import/export viene reindirizzato allo script specificato. Gli script di pre-elaborazione devono contenere almeno i seguenti metodi open(nome del file) e insert(nome del file, nome del documento). Gli script di post-elaborazione devono implementare export(objectslist,filename).
Gli script di pre e post-elaborazione si comportano come gli altri comuni importatori e esportatori di FreeCAD. Quando si sceglie uno script di /post elaborazione dalla finestra di dialogo, il processo di import/export viene reindirizzato allo script specificato. Gli script di pre-elaborazione devono contenere almeno i seguenti metodi open(nome del file) e insert(nome del file, nome del documento). Gli script di post-elaborazione devono implementare export(objectslist,filename).


<div class="mw-translate-fuzzy">
Gli script vengono inseriti nella cartella Mod/Path/PathScripts o nella directory delle macro definita dell'utente. Si può dare loro un nome a piacere, ma per convenzione, e per essere scelti dalla finestra di dialogo GUI, i nomi degli script di pre-elaborazione devono terminare con "_pre", gli script di post-elaborazione con "_post" (assicuratevi di usare il carattere sottolineato, non il trattino, altrimenti python non può importarli). Questo è un esempio molto, molto semplice di preprocessore. Esempi più complessi si trovano nella cartella Mod/Path/PathScripts:
Gli script vengono inseriti nella cartella Mod/Path/PathScripts o nella directory delle macro definita dell'utente. Si può dare loro un nome a piacere, ma per convenzione, e per essere scelti dalla finestra di dialogo GUI, i nomi degli script di pre-elaborazione devono terminare con "_pre", gli script di post-elaborazione con "_post" (assicuratevi di usare il carattere sottolineato, non il trattino, altrimenti python non può importarli). Questo è un esempio molto, molto semplice di preprocessore. Esempi più complessi si trovano nella cartella Mod/Path/PathScripts:
</div>
<syntaxhighlight>

def open(filename):
{{Code|code=
gfile = __builtins__.open(filename)
def open(filename):
inputstring = gfile.read()
gfile = __builtins__.open(filename)
# the whole gcode program will come in as one string,
inputstring = gfile.read()
# for example: "G0 X1 Y1\nG1 X2 Y2"
# the whole gcode program will come in as one string,
output = ""
# we add a comment
# for example: "G0 X1 Y1\nG1 X2 Y2"
output += "(This is my first parsed output!)\n"
output = ""
# we split the input string by lines
# we add a comment
lines = inputstring.split("\n")
output += "(This is my first parsed output!)\n"
for line in lines:
# we split the input string by lines
lines = inputstring.split("\n")
output += line
for line in lines:
# we must insert the "end of line" character again
output += line
# because the split removed it
output += "\n"
# we must insert the "end of line" character again
# another comment
# because the split removed it
output += "(End of program)"
output += "\n"
import Path
# another comment
output += "(End of program)"
p = Path.Path(output)
import Path
myPath = FreeCAD.ActiveDocument.addObject("Path::Feature","Import")
myPath.Path = p
p = Path.Path(output)
FreeCAD.ActiveDocument.recompute()
myPath = FreeCAD.ActiveDocument.addObject("Path::Feature","Import")
myPath.Path = p
</syntaxhighlight>
FreeCAD.ActiveDocument.recompute()
}}

<div class="mw-translate-fuzzy">
Pre e post-processori funzionano esattamente allo stesso modo. Fanno solo il contrario: Gli script pre convertono da un GCode specifico al GCode "agnostico" di FreeCAD, mentre gli script post convertono dal GCode "agnostico" di FreeCAD al GCode specifico della macchina.
Pre e post-processori funzionano esattamente allo stesso modo. Fanno solo il contrario: Gli script pre convertono da un GCode specifico al GCode "agnostico" di FreeCAD, mentre gli script post convertono dal GCode "agnostico" di FreeCAD al GCode specifico della macchina.
</div>


== Adding all faces of a ShapeString to the BaseFeature's list of a ProfileFromFaces operation ==
== Adding all faces of a ShapeString to the BaseFeature's list of a ProfileFromFaces operation ==

This example is based on a [https://forum.freecadweb.org/viewtopic.php?f=13&t=33310&p=279991#p279959 discussion in the german forum].
This example is based on a [https://forum.freecadweb.org/viewtopic.php?f=13&t=33310&p=279991#p279959 discussion in the german forum].


=== Prerequisits ===
=== Prerequisites ===

* Create a solid with ShapeString as Cutout
* Create a solid with ShapeString as Cutout
* Create a Job using this solid as its BaseObject
* Create a Job using this solid as its BaseObject
Line 416: Line 523:


=== The code ===
=== The code ===

The following code will then add all faces from ShapeString and create the paths:
The following code will then add all faces from ShapeString and create the paths:

<syntaxhighlight>
{{Code|code=
doc = App.ActiveDocument
doc = App.ActiveDocument
list_of_all_element_faces = []
list_of_all_element_faces = []
Line 423: Line 532:
list_of_all_element_faces.append('Face' + str(i + 1))
list_of_all_element_faces.append('Face' + str(i + 1))


<!--T:64-->
doc.Profile_Faces.Base = [(doc.ShapeString, tuple(list_of_all_element_faces))]
doc.Profile_Faces.Base = [(doc.ShapeString, tuple(list_of_all_element_faces))]
doc.recompute()
doc.recompute()
}}
</syntaxhighlight>




{{Docnav
[[Category:Poweruser Documentation{{#translation:}}]]
|[[CAM_Preferences|Preferences]]
|
|[[CAM_Workbench|CAM]]
|IconL=
|IconR=
|IconC=Workbench_CAM.svg
}}

{{CAM_Tools_navi{{#translation:}}}}
{{Powerdocnavi{{#translation:}}}}
[[Category:Developer Documentation{{#translation:}}]]
[[Category:Python Code{{#translation:}}]]
[[Category:Python Code{{#translation:}}]]
{{clear}}

Latest revision as of 14:37, 26 March 2024

Introduzione

L'ambiente Path offre strumenti per importare, creare, manipolare e esportare percorsi delle macchine utensili in FreeCAD. Con esso, l'utente è in grado di importare, visualizzare e modificare i programmi GCode esistenti, generare percorsi di forme 3D, ed esportare questi percorsi utensile in Gcode.

Allo stato attuale, però, lo sviluppo dell'ambiente Path è appena iniziato, e non offre la funzionalità molto avanzate che si trovano in alcune alternative commerciali. Tuttavia, la sua ampia interfaccia di script Python rende facile modificare o sviluppare degli strumenti più potenti, e quindi per ora è rivolto più agli utenti con una certa conoscenza di script Python che agli utenti finali.

Avvio rapido

Gli oggetti Path (percorso) di FreeCAD sono fatti di una sequenza di comandi di movimento. Un utilizzo tipico è questo:

>>> import Path
>>> c1 = Path.Command("g1x1")
>>> c2 = Path.Command("g1y4")
>>> c3 = Path.Command("g1 x2 y2") # spaces end newlines are ignored
>>> p = Path.Path([c1,c2,c3])
>>> o = App.ActiveDocument.addObject("Path::Feature","mypath")
>>> o.Path = p
>>> print (p.toGCode())

Formato del GCode all'interno di FreeCAD

Un concetto preliminare che importante da afferrare. La maggior parte della realizzazione sottostanti si basa prevalentemente sui comandi di movimento che hanno gli stessi nomi dei comandi GCode, ma non sono destinati ad avvicinarsi all'implementazione di un particolare controller. Abbiamo scelto nomi come 'G0' per rappresentare i movimento in 'rapida' o 'G1' per rappresentare i movimenti di 'alimentazione' per motivi di prestazioni (efficienza nel salvataggio dei file) e per ridurre al minimo il lavoro necessario per tradurre in/da altri formati GCode. Dal momento che il mondo CNC parla migliaia di dialetti GCode, abbiamo scelto di iniziare con un sottoinsieme molto semplificato di esso. Si potrebbe descrivere il formato GCode di FreeCAD come una forma "macchina-agnostica" di GCode.

All'interno dei file .FCStd, i dati Path vengono salvati direttamente in quella forma di GCode.

Tutte le traduzioni dai/nei dialetti del GCode di FreeCAD vengono effettuate tramite pre e post script. Ciò significa che, se si desidera lavorare con una macchina che utilizza uno specifico controller LinuxCNC, Fanuc, Mitusubishi o HAAS, ecc, si deve usare (o scrivere se è inesistente) un post processore per quel particolare controllo (vedere più avanti la sezione "Importare ed esportare GCode).

Riferimenti GCode

Le seguenti regole e linee guida definiscono il sottoinsieme di GCode utilizzato all'interno di FreeCAD:

  • I dati GCode, all'interno degli oggetti Path di FreeCAD, sono separati in "Commands" (comandi). Un comando è definito dal nome del comando, che deve iniziare con G o M, e da argomenti(opzionali), che sono nella forma Lettera = Float (flottante), ad esempio X 0.02 o Y 3.5 o F 300. Questi sono esempi di tipici comandi Gcode in FreeCAD:

G0 X2.5 Y0 (Il nome del comando è G0, gli argomenti sono X=2.5 e Y=0)

G1 X30 (Il nome del comando è G1, l'unico argomento è X=30)

G90 (Il nome del comando è G90, non ci sono argomentis)

  • Per la parte numerica di un comando G o M, sono supportate sia la forma "G1" sia "G01" .
  • In questo momento sono supportati solo i comandi che iniziano per G o M.
  • Per ora, sono accettati solo i millimetri. G20/G21 non sono considerati.
  • Gli argomenti sono sempre in ordine alfabetico. Questo significa che se si crea un comando con "G1 X2 Y4 F300", viene memorizzato come "G1 F300 X2 Y4"
  • Gli argomenti non possono essere ripetuti all'interno di uno stesso comando. Ad esempio, "G1 X1 X2 Y2 Y3" non funziona. Deve essere diviso in due comandi, per esempio: "G1 X1 Y2, Y3 G1 X2"
  • Gli argomenti X, Y, Z, A, B, C sono assoluti o relativi, secondo la modalità attiva G90/G91. Predefinito (se non specificato) è assoluto.
  • I, J, K sono sempre relativi all'ultimo punto. K può essere omesso.
  • X, Y, o Z (e A, B, C) possono essere omessi. In questo caso, sono mantenuti le precedenti coordinate X, Y o Z.
  • I comandi GCode diversi da quelli elencati nella seguente tabella sono supportati, cioè, vengono salvati all'interno dei dati del percorso ( naturalmente, a patto che siano conformi alle regole di cui sopra), ma non producono alcun risultato visibile sullo schermo. Ad esempio, è possibile aggiungere un comando G81, esso viene memorizzato, ma non visualizzato.

Elenco dei comandi Gcode attualmente supportati

Comando Descrizione Argomenti supportati
G0 rapida X,Y,Z,A,B,C
G1 avanzamento normale X,Y,Z,A,B,C
G2 arco orario X,Y,Z,A,B,C,I,J,K
G3 arco antiorario X,Y,Z,A,B,C,I,J,K
G81, G82, G83 foratura X,Y,Z,R,Q
G90 coordinate assolute
G91 coordinate relative
(Message) commento

L'oggetto Command

L'oggetto Command rappresenta un comando Gcode. Ha tre attributi: Name, Parameters e Placement (Nome,Parametri e posizione), e due metodi: toGCode() e setFromGCode(). Internamente, contiene solo un nome e un dizionario di parametri. Il resto (posizionamento e gcode) viene calcolato da/a questi dati.

>>> import Path
>>> c=Path.Command()
>>> c
Command  ( )
>>> c.Name = "G1"
>>> c
Command G1 ( )
>>> c.Parameters= {"X":1,"Y":0}
>>> c
Command G1 ( X:1 Y:0 )
>>> c.Parameters
{'Y': 0.0, 'X': 1.0}
>>> c.Parameters= {"X":1,"Y":0.5}
>>> c
Command G1 ( X:1 Y:0.5 )
>>> c.toGCode()
'G1X1Y0.5'
>>> c2=Path.Command("G2")
>>> c2
Command G2 ( )
>>> c3=Path.Command("G1",{"X":34,"Y":1.2})
>>> c3
Command G1 ( X:34 Y:1.2 )
>>> c3.Placement
Placement [Pos=(34,1.2,0), Yaw-Pitch-Roll=(0,0,0)]
>>> c3.toGCode()
'G1X34Y1.2'
>>> c3.setFromGCode("G1X1Y0")
>>> c3
Command G1 [ X:1 Y:0 ]
>>> c4 = Path.Command("G1X4Y5")
>>> c4
Command G1 [ X:4 Y:5 ]
>>> p1 = App.Placement()
>>> p1.Base = App.Vector(3,2,1)
>>> p1
Placement [Pos=(3,2,1), Yaw-Pitch-Roll=(0,0,0)]
>>> c5=Path.Command("g1",p1)
>>> c5
Command G1 [ X:3 Y:2 Z:1 ]
>>> p2=App.Placement()
>>> p2.Base = App.Vector(5,0,0)
>>> c5
Command G1 [ X:3 Y:2 Z:1 ]
>>> c5.Placement=p2
>>> c5
Command G1 [ X:5 ]
>>> c5.x
5.0
>>> c5.x=10
>>> c5
Command G1 [ X:10 ]
>>> c5.y=2
>>> c5
Command G1 [ X:10 Y:2 ]

L'oggetto Path

L'oggetto Path contiene un elenco di comandi

>>> import Path
>>> c1=Path.Command("g1",{"x":1,"y":0})
>>> c2=Path.Command("g1",{"x":0,"y":2})
>>> p=Path.Path([c1,c2])
>>> p
Path [ size:2 length:3 ]
>>> p.Commands
[Command G1 [ X:1 Y:0 ], Command G1 [ X:0 Y:2 ]]
>>> p.Length
3.0
>>> p.addCommands(c1)
Path [ size:3 length:4 ]
>>> p.toGCode()
'G1X1G1Y2G1X1'

lines = """
G0X-0.5905Y-0.3937S3000M03
G0Z0.125
G1Z-0.004F3
G1X0.9842Y-0.3937F14.17
G1X0.9842Y0.433
G1X-0.5905Y0.433
G1X-0.5905Y-0.3937
G0Z0.5
"""

slines = lines.split('\n')
p = Path.Path()
for line in slines:
    p.addCommands(Path.Command(line))

o = App.ActiveDocument.addObject("Path::Feature","mypath")
o.Path = p

# but you can also create a path directly form a piece of G-code.
# The commands will be created automatically:

p = Path.Path()
p.setFromGCode(lines)

Come scorciatoia, un oggetto Path può anche essere creato direttamente da una sequenza completa di GCode. Sarà diviso automaticamente in una sequenza di comandi.

>>> p = Path.Path("G0 X2 Y2 G1 X0 Y2")
>>> p
Path [ size:2 length:2 ]

La funzione Path

La funzione Path è un oggetto documento di FreeCAD, che contiene un percorso, e lo rappresenta nella vista 3D.

>>> pf = App.ActiveDocument.addObject("Path::Feature","mypath")
>>> pf
<Document object>
>>> pf.Path = p
>>> pf.Path
Path [ size:2 length:2 ]

La funzione Path detiene inoltre una proprietà Placement. Cambiando il valore del posizionamento si cambia la posizione della funzionalità nella vista 3D, anche se le informazioni sul percorso sono invariate. La trasformazione è puramente visiva. Ciò consente, ad esempio, di creare un percorso attorno a una faccia che ha un particolare orientamento nel modello, e che non è lo stesso orientamento che il materiale da tagliare avrà sulla macchina CNC.

Tuttavia, i Path Compounds possono usufruire del Placement (posizionamento) dei propri figli (vedi sotto).

Gli utensili e la tabella utensili


NOTE: This type of tool usage is depreciated as of the 0.19 official release. In 0.19 the new ToolBit tool system was implemented to supersede this older, Legacy, system. Therefore, coding has changed from what is represented below. Please visit Path Tools page for more information.

Scripting <= 0.18

L'oggetto strumento contiene le definizioni di un utensile CNC. L'oggetto Tooltable contiene un elenco ordinato di strumenti. Le Tooltable sono unite come una proprietà alle funzioni Path Project, e possono anche essere modificate tramite l'interfaccia grafica, facendo doppio clic su un progetto nella vista ad albero, e facendo clic sul pulsante "Modifica tooltable" nelle vista azioni che viene aperta.

Da questa finestra, le tooltable possono essere importate dai formati .xml di FreeCAD e .tooltable di HeeksCad, ed esportate nel formato .xml di FreeCAD.

>>> import Path
>>> t1=Path.Tool()
>>> t1
Tool Default tool
>>> t1.Name = "12.7mm Drill Bit"
>>> t1
Tool 12.7mm Drill Bit
>>> t1.ToolType
'Undefined'
>>> t1.ToolType = "Drill"
>>> t1.Diameter= 12.7
>>> t1.LengthOffset = 127
>>> t1.CuttingEdgeAngle = 59
>>> t1.CuttingEdgeHeight = 50.8
>>> t2 = Path.Tool("my other tool",tooltype="EndMill",diameter=10)
>>> t2
Tool my other tool
>>> t2.Diameter
10.0
>>> table = Path.Tooltable()
>>> table
Tooltable containing 0 tools
>>> table.addTools(t1)
Tooltable containing 1 tools
>>> table.addTools(t2)
Tooltable containing 2 tools
>>> table.Tools
{1: Tool 12.7mm Drill Bit, 2: Tool my other tool}
>>>

Funzioni

La funzione Path Compound

Lo scopo di questa funzione è quello di raccogliere uno o più percorsi utensile e di associarlo/i con una tooltable. La funzione Compound si comporta anche come un gruppo standard di FreeCAD, in modo da poter aggiungere o rimuovere oggetti direttamente dalla visualizzazione struttura. È inoltre possibile riordinare gli elementi facendo doppio clic sull'oggetto Compound nella struttura ad albero, e riordinare gli elementi nella vista azioni che viene aperta.

>>> import Path
>>> p1 = Path.Path("G1X1")
>>> o1 = App.ActiveDocument.addObject("Path::Feature","path1")
>>> o1.Path=p1
>>> p2 = Path.Path("G1Y1")
>>> o2 = App.ActiveDocument.addObject("Path::Feature","path2")
>>> o2.Path=p2
>>> o3 = App.ActiveDocument.addObject("Path::FeatureCompound","compound")
>>> o3.Group=[o1,o2]

Una caratteristica importante di Path Compounds è la possibilità di tenere conto o no della posizione dei percorsi dei loro figli, impostando la loro proprietà UsePlacements su True o False. In caso contrario, i dati Percorso dei loro figli saranno semplicemente aggiunti in sequenza. Se True, ogni comando dei percorsi figli, qualora contengano informazioni di posizione (G0, G1, ecc ..), prima di essere aggiunto verrà trasformato dal posizionamento.

Creating a compound with just one child path allows you therefore to turn the child path's Placement "real" (it affects the Path data).

La funzione Path Project

Il progetto Path è un tipo di Compound esteso, che ha un paio di ulteriori proprietà correlate alla macchina, come una tooltable. È fatto principalmente per essere il principale tipo di oggetto che si desidera esportare in Gcode quando la configurazione dell'intero percorso è pronta. L'oggetto Project è codificato in python, per cui il suo meccanismo di creazione è un po 'diverso:

>>> from PathScripts import PathProject
>>> o4 = App.ActiveDocument.addObject("Path::FeatureCompoundPython","prj")
>>> PathProject.ObjectPathProject(o4)
>>> o4.Group = [o3]
>>> o4.Tooltable
Tooltable containing 0 tools

Il modulo Path dispone anche di un editor GUI per la tooltable che può essere chiamato in python, dandogli un oggetto che ha una proprietà ToolTable:

>>> from PathScripts import TooltableEditor
>>> TooltableEditor.edit(o4)

La funzione Path Shape

Questa funzione è un normale oggetto Path con una proprietà Shape aggiuntiva. Dando alla proprietà una forma Wire, il percorso verrà calcolato automaticamente dalla forma. Si noti che in questo caso il posizionamento viene impostato automaticamente al primo punto del wire, e quindi l'oggetto non è più movibile modificando il suo posizionamento. Per spostarlo, si deve spostare la forma sottostante.

>>> import Part
>>> import Path
>>> v1 = FreeCAD.Vector(0,0,0)
>>> v2 = FreeCAD.Vector(0,2,0)
>>> v3 = FreeCAD.Vector(2,2,0)
>>> v4 = FreeCAD.Vector(3,3,0)
>>> wire = Part.makePolygon([v1,v2,v3,v4])
>>> o = FreeCAD.ActiveDocument.addObject("Path::Feature","myPath2")
>>> o.Path = Path.fromShape(wire)
>>> FreeCAD.ActiveDocument.recompute()
>>> p =  o.Path
>>> print(p.toGCode())

Funzioni Python

Le funzioni Path::Feature e Path::FeatureShape hanno una versione Python, chiamate rispettivamente, Path::FeaturePython e Path::FeatureShapePython, che possono essere utilizzate nel codice python per creare oggetti parametrici avanzati derivati da esse.

Importare e esportare GCode

Formato nativo

I file gcode possono essere importati ed esportati direttamente tramite l'interfaccia grafica, utilizzandole voci "Esporta", "Apri" o "Inserisci" del menu. Quando il nome del file è acquisito, si apre una finestra che chiede quale script di elaborazione deve utilizzare. Può anche essere fatto in python:

Le informazioni sul Percorso vengono memorizzate in oggetti Path utilizzando un sottoinsieme di gcode descritto nella sezione "Formato del GCode all'interno di FreeCAD" di cui sopra. Questo sottoinsieme può essere importato o esportato "come è", o convertito in/da una particolare versione di GCode adatto alla vostra macchina.

Se si dispone di un programma di GCode molto semplice e standard, che compila le regole descritte nella sezione "Formato del GCode all'interno di FreeCAD" di cui sopra, per esempio, il boomerang da http://www.cnccookbook.com/GWESampleFiles.html , esso può essere importato direttamente in un oggetto Path, senza traduzione (questo equivale a utilizzare l'opzione "None" della finestra GUI):

import Path
f = open("/path/to/boomerangv4.ncc")
s = f.read()
p = Path.Path(s)
o = App.ActiveDocument.addObject("Path::Feature","boomerang")
o.Path = p

Allo stesso modo, è possibile ottenere le informazioni sul percorso come gcode "agnostico", e memorizzarle manualmente in un file:

text = o.Path.toGCode()
print text
myfile = open("/path/to/newfile.ngc")
myfile.write(text)
myfile.close()

Se serve un output diverso, però, è necessario convertire questo GCode agnostico in un formato adatto alla macchina. Questo è compito dello script di post-processing.

Utilizzare gli script di pre e post-elaborazione

Se si dispone di un file gcode scritto per una macchina particolare, che non è conforme alle regole interne utilizzate dai FreeCAD, descritte nella sezione "Formato GCode interno a FreeCAD" di cui sopra, si potrebbe non riuscire a importarlo e/o renderlo correttamente nella 3D vista. Per rimediare a questo, è necessario utilizzare uno script di pre-elaborazione, che converte dal formato di una specifica macchina al formato di FreeCAD.

Se si conosce il nome dello script di pre-elaborazione da utilizzare, è possibile importare il file usando, dalla console python questo:

import example_pre
example_pre.insert("/path/to/myfile.ncc","DocumentName")

Allo stesso modo, è possibile emettere un oggetto tracciato per GCode, utilizzando uno script post_processor in questo modo:

import example_post
example_post.export (myObjectName,"/path/to/outputFile.ncc")

Scrivere script di elaborazione

Gli script di pre e post-elaborazione si comportano come gli altri comuni importatori e esportatori di FreeCAD. Quando si sceglie uno script di /post elaborazione dalla finestra di dialogo, il processo di import/export viene reindirizzato allo script specificato. Gli script di pre-elaborazione devono contenere almeno i seguenti metodi open(nome del file) e insert(nome del file, nome del documento). Gli script di post-elaborazione devono implementare export(objectslist,filename).

Gli script vengono inseriti nella cartella Mod/Path/PathScripts o nella directory delle macro definita dell'utente. Si può dare loro un nome a piacere, ma per convenzione, e per essere scelti dalla finestra di dialogo GUI, i nomi degli script di pre-elaborazione devono terminare con "_pre", gli script di post-elaborazione con "_post" (assicuratevi di usare il carattere sottolineato, non il trattino, altrimenti python non può importarli). Questo è un esempio molto, molto semplice di preprocessore. Esempi più complessi si trovano nella cartella Mod/Path/PathScripts:

def open(filename):
    gfile = __builtins__.open(filename)
    inputstring = gfile.read()
    # the whole gcode program will come in as one string,
    # for example: "G0 X1 Y1\nG1 X2 Y2"
    output = ""
    # we add a comment
    output += "(This is my first parsed output!)\n"
    # we split the input string by lines
    lines = inputstring.split("\n")
    for line in lines:
        output += line
        # we must insert the "end of line" character again
        # because the split removed it
        output += "\n"
    # another comment
    output += "(End of program)"
    import Path
    p = Path.Path(output)
    myPath = FreeCAD.ActiveDocument.addObject("Path::Feature","Import")
    myPath.Path = p
    FreeCAD.ActiveDocument.recompute()

Pre e post-processori funzionano esattamente allo stesso modo. Fanno solo il contrario: Gli script pre convertono da un GCode specifico al GCode "agnostico" di FreeCAD, mentre gli script post convertono dal GCode "agnostico" di FreeCAD al GCode specifico della macchina.

Adding all faces of a ShapeString to the BaseFeature's list of a ProfileFromFaces operation

This example is based on a discussion in the german forum.

Prerequisites

  • Create a solid with ShapeString as Cutout
  • Create a Job using this solid as its BaseObject
  • Create a ProfileFromFaces operation named "Profile_Faces" with empty BaseGeometry.

The code

The following code will then add all faces from ShapeString and create the paths:

doc = App.ActiveDocument
list_of_all_element_faces = []
for i, face in enumerate(doc.ShapeString.Shape.Faces):
    list_of_all_element_faces.append('Face' + str(i + 1))

doc.Profile_Faces.Base = [(doc.ShapeString, tuple(list_of_all_element_faces))]
doc.recompute()