G-Code Programmazione per macchine CNC

Percorso utensile lavorazione CNC. Cornice ottagonale con lati obliqui G01, G02, G03

In questo articolo sono stati riportati una serie di programmini per realizzare figure elementari con una fresatrice CNC. La programmazione tramite G-code non è banale per vari motivi: la sintassi da rispettare nell’esecuzione dei cicli o delle procedure è per certi aspetti antiquata. Nonostante linuxcnc sia una buona piattaforma, la fase di Debug non è immediata. Per ora la strada seguita è questa: Simulare tutto tramite la programmazione in matlab e solo nella fase finale convertire il codice in linguaggio in G-code. La lavorazione di geometrie semplici è un ottimo spunto per insegnare le nozioni fondamentali di un linguaggio di programmazione: variabili, funzioni, cicli e condizioni.

Le complicazione più grande che si può riscontrare quando si prova a scrivere degli algoritmi di lavorazione è che il processo di sgrossatura può avere delle differenze (spesso anche di carattere tecnologico) rispetto alla fase finale di finitura.

Cornice rettangolare

Questo programmino serve a realizzare una cornice di sezione rettangolare. La cornice viene raccordata lungo l’asse z con un raggio R. La variabile # può assumere due valori: -1 e 1, a seconda se si vuole un raccordo concavo o convesso. Il programma esegue tutte le fasi di lavorazione di una fresatrice a tre assi: sgrossatura e finitura. [cnccode] consiste nel realizzare il codice per eseguire una lavorazione di scavo di una forma ottagonale raccordata. Ogni lato dell’ottagono è raccordato con opzione di raccordo variabile in due modi: Nel caso della figura l’area della sagoma ottagonale è più grande a livello z = 0; tende invece a diminuire all’aumentare della profondità z
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
% Autori
% Prof. Danilo Pasquini IPSIA Parodi Delfino, Colleferro (Roma)
% Prof. Paolo Sordi IPSIA A. Pacinotti, Pontedera (Pisa) 
%
o200 sub
	# = #<_raccordo>
	# = #<_raggio>
	# = #<_xx>
	# = #<_yy>
	# = #<_cick>
	# = #<_latoy>
	# = #<_latox>
	# = #<_accuratezzafinitura>
	# = #<_accuratezzasgrosso>
	# = #<_sgrossaturamm>
 
(-------------------------------------------------------------------------------------)
	# = [-#]
	# = #
	# = #
	# = [2 * 3.14 * # / 4]
	# = [FIX[[#-1] / #]]
      		           (PRINT,value of variable 123 is: #)
		           (MSG, This is a message)
 			   (DEBUG,value of variable numeropassate is: #)
	# =  -1
	g00 z5
	(pausa di 1 s)
	g4 p1
	g01 f1000
	# = 1 
	o101 while [# LT #]
 
	     # = [# + 1]
	     # = #
	     (DEBUG,sgrosso: #)
	     # = [# / #] 
	     #<i> = -1  
 
	     o140 if [# EQ 1]
		 #<i> = [#] 
	     o140 endif
 
	     o103 while [#<i> LT [#]]
 
			o141 if [# EQ 1]
				#<i> = [#<i> - 1]
			o141 else
				#<i> = [#<i> + 1]
			o141 endif
			# = [[# - #] * #]
			# = [# *  #<i> / #]
			# = [# + # + # ]	 
		        o104 if [# EQ -1]
			   # = [#  + #]
			o104 endif
			# = [# + [# + #] *  1]
			# = [# + [# + #] * -1]
			# = [# + [# + #] *  1]
			# = [# + [# + #] * -1] 
			o120 if [# lt [# + #]]
			   # = [# + #]
		        o120 else
		           # = [#]
		        o120 endif
 
			o105 if [# lt [#]]
				o130 if [# EQ 1]
					g01 x[# + # /2 ] y[# - # /2] z5
					# = 0
				o130 endif
				g01 x[# + # /2 ] y[# - # /2] z[#]
				g01 x[# + # /2] y[# - # /2] 
				g01 x[# - # /2] y[# - # /2] 
				g01 x[# - # /2] y[# - # /2] 
				g01 x[# - # /2] y[# + # /2] 
				g01 x[# - # /2] y[# + # /2] 
				g01 x[# + # /2] y[# + # /2] 
				g01 x[# + # /2] y[# + # /2] 
				g01 x[# + # /2 ] y[# - # /2] 
		                g00 z0
			o105 endif
	     o103 endwhile
	o101 endwhile
	# = #
	(DEBUG,finitura: #)
	# = [#/#] 
	#<i> = [# +1]
	g01 f200
	g00 z10
	o108 while [#<i> GE 0]
		#<i> = [#<i> - 1]
		# = [# + # * #]	 
		o109 if [# EQ -1]
		   # = [#  + #]
		o109 endif
		# = [# *  #<i> / #]
		# = [# + [# + #] *  1]
		# = [# + [# + #] * -1]
		# = [# + [# + #] *  1]
		# = [# + [# + #] * -1]
		o121 if [# lt [# + #]]
		   # = [# + #]
		o121 else
		   # = [#]
		o121 endif
		o110 if [# lt [#]]
			g01 x[# + # /2] y[# - # /2] z[#]
			g01 x[# + # /2] y[# - # /2] 
			g01 x[# - # /2] y[# - # /2] 
			g01 x[# - # /2] y[# - # /2] 
			g01 x[# - # /2] y[# + # /2] 
			g01 x[# - # /2] y[# + # /2] 
			g01 x[# + # /2] y[# + # /2] 
			g01 x[# + # /2] y[# + # /2] 
			g01 x[# + # /2] y[# - # /2] 
		o110 endif
	o108 endwhile
o200 endsub
 
#&lt;_raccordo&gt; = 12
#&lt;_raggio&gt; = 12
#&lt;_xx&gt; = 0
#&lt;_yy&gt; = 0
#&lt;_cick&gt; = 1
#&lt;_latoy&gt; = 20
#&lt;_latox&gt; = 20
#&lt;_accuratezzafinitura&gt; = 1.5
#&lt;_accuratezzasgrosso&gt; = 12
#&lt;_sgrossaturamm&gt; = 120
o200 call 
 
#&lt;_raccordo&gt; = 12
#&lt;_raggio&gt; = 12
#&lt;_xx&gt; = 0
#&lt;_yy&gt; = 0
#&lt;_cick&gt; = -1
#&lt;_latoy&gt; = 70
#&lt;_latox&gt; = 70
#&lt;_accuratezzafinitura&gt; = 1.5
#&lt;_accuratezzasgrosso&gt; = 12
#&lt;_sgrossaturamm&gt; = 12
o200 call 
 
%
</i></i></i></i></i></i></i></i></i></i></i></i></i>
Il codice seguente serve a realizzare una superficie di tipo rettangolare raccordata in modo concavo o convesso.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
% Autori
% Prof. Danilo Pasquini IPSIA Parodi Delfino, Colleferro (Roma)
% Prof. Paolo Sordi IPSIA A. Pacinotti, Pontedera (Pisa) 
%
o sub
 
# = #&lt;_raggio&gt;
# = #&lt;_x1&gt;
# = #&lt;_y1&gt;
# = #&lt;_cick&gt; 
# = #&lt;_lato_y&gt;
# = #&lt;_lato_x&gt;
# = #&lt;_accuratezza&gt;
# = #&lt;_accuratezza_finitura&gt;
# = #&lt;_accuratezza_sgrosso&gt;
# = #&lt;_sgrossatura_mm&gt;
 
# = #&lt;_zcentro&gt; ;
# = # ;
# = # ;
# = [2 * 3.14159 * # / 4]
# = FIX[# / #]
 
# = -1
g01 f[#&lt;_velocita_finitura&gt;]
g00 z5
 
(pausa di 1 s)
g4 p1
o101 repeat [#+1]
    # = [# + 1]
    o102 if [# EQ #]
        # = # ;
        (DEBUG,finitura: #)
    o102 else
        # = # ;
        (DEBUG,sgrosso: #)
    o102 endif
    # = FIX[# / #]
    # = [#] 
    o130 if [# EQ 1]
	 # = 0
    o130 endif
    o104 repeat[#]	
	o131 if [# EQ 1]
		# = [# + 1]
	o131 else
		# = [# - 1]
 
	o131 endif
	# = [[# - #] * #]
	# = [# + # + # * # * SIN[180 * [1/2] * # / #]]
	o105 if [# EQ -1]
		# = [# + #]
	o105 endif
	# = [# * COS[180 * 0.5 * # / #]]
	# = [# * COS[180 * [1/2] * [# - #] / #]]
	# = [# + # * -1]
	# = [# + # * -1]
	# = [# + #]
	# = [# + #]
	o120 if [# lt [# + #]]
		   # = [# + #]
	o120 else
		   # = [#]
	o120 endif  
	o106 if [# LT #]
	(o106 if [# LT 500])
 
                 g01 z[3]
		 g01 x[# + #/2 * -1]                y[# + #/2 + #] 
		 g01 z[#]
		 g01 x[# + #/2 * -1]                y[# - #/2 - #]
		 g00 x[# - #/2 - #] y[# + #/2 * -1  ] 
		 g01 x[# + #/2 + #] y[# + #/2 * -1  ] 
		 g00 x[# + #/2 + #] y[# + #/2 * -1  ] 
		 g01 x[# + #/2 + #] y[# + #/2 + # ] 
		 g01 x[# + #/2 * -1]                y[# + #/2 + #] 
 
 
	o106 endif
    o104 endrepeat 
o101 endrepeat 
g00 z10
o endsub
Al termine di un lavoro sorge spesso il problema di ritagliare la tavola a misura. Per non avere collisioni dopo il distacco del pezzo finito dalla cornice avanzata conviene lasciare un piccolo tassello sui quattro lati che saranno tagliati successivamente a mano
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
% Autori
% Prof. Danilo Pasquini IPSIA Parodi Delfino, Colleferro (Roma)
% Prof. Paolo Sordi IPSIA A. Pacinotti, Pontedera (Pisa) 
%
o200 sub
	# = #&lt;_raccordo&gt;
	# = #&lt;_xx&gt;
	# = #&lt;_yy&gt;
	# = #&lt;_latoy&gt;
	# = #&lt;_latox&gt;
 
	# = #&lt;_sgrossaturamm&gt;
 
(-------------------------------------------------------------------------------------)
	# = [-#&lt;_spessoretavola&gt;]
	# = #
	# = #
 
	# = [FIX[[#&lt;_spessoretavola&gt;-1] / #]]
      		           (PRINT,value of variable 123 is: #)
		           (MSG, This is a message)
 			   (DEBUG,value of variable numeropassate is: #)
	# =  -1
	g00 z5
	(pausa di 1 s)
	g4 p1
	g01 f1000
	# = 1 
	o101 while [# LT #]
 
	     # = [# + 1]
 
	     (DEBUG,sgrosso: #)
 
			# = [[# - #] * #]
			# = [# + #  ]	 
 
			o130 if [# EQ 1]
				g01 x[# + # /2 ] y[# - # /2] z5
				# = 0
			o130 endif
			g01 x[# + # /2 ] y[# - # /2] z[#]
 
 
			g01 x[# + # /2] y[# - # /2] 
			o131 if [# lt [#&lt;_tassellinoz&gt;-#&lt;_spessoretavola&gt;]]
				g01 x[# + #&lt;_tassellinox&gt;] y[# - # /2] 
				g00 z5 
				g00 x[# - #&lt;_tassellinox&gt;] y[# - # /2] 
				g01 z[#] 
 
			o131 endif
 
			g01 x[# - # /2] y[# - # /2]
			o132 if [# lt [#&lt;_tassellinoz&gt;-#&lt;_spessoretavola&gt;]]
				g01 x[# - # /2] y[# - #&lt;_tassellinox&gt;]
				g00 z5 
				g00 x[# - # /2] y[# + #&lt;_tassellinox&gt;]
				g01 z[#] 
			o132 endif
 
			g01 x[# - # /2] y[# + # /2]
			o133 if [# lt [#&lt;_tassellinoz&gt;-#&lt;_spessoretavola&gt;]]
				g01 x[# - #&lt;_tassellinox&gt;] y[# + # /2]
 
				g00 z5 
				g00 x[# + #&lt;_tassellinox&gt;] y[# + # /2]
 
				g01 z[#] 
			o133 endif 
			g01 x[# + # /2] y[# + # /2]
			o134 if [# lt [#&lt;_tassellinoz&gt;-#&lt;_spessoretavola&gt;]]
				g01 x[# + # /2] y[# + #&lt;_tassellinox&gt; /2]
 
				g00 z5 
				g00 x[# + # /2] y[# - #&lt;_tassellinox&gt; /2]
 
				g01 z[#]
			o134 endif 
 
			g01 x[# + # /2] y[# - # /2] 
	                g00 z0
	o101 endwhile
o200 endsub
 
#&lt;_raccordo&gt; = 0
#&lt;_spessoretavola&gt; = 10
#&lt;_tassellinoz&gt; = 3
#&lt;_tassellinox&gt; = 2
 
#&lt;_xx&gt; = 0
#&lt;_yy&gt; = 0
#&lt;_latoy&gt; = 70
#&lt;_latox&gt; = 70
#&lt;_sgrossaturamm&gt; = 1
o200 call 
 
%