Znaleziono 9 wyników

autor: szary11
13 lis 2021, 07:59
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

kamar pisze:Ma ktoś sprawdzonego suba na centrowanie w otworze ?


Suba nie mam, ale działa mi dobrze od dwu lat Probe Screen na frezarkach i drutówce.
Mój stary filmik
autor: szary11
30 lip 2020, 17:48
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

moją kobyłką można
parametr 10 i 25

Kod: Zaznacz cały

( ------------------------------ )
(          GWINT STOŻEK          )
( ------------------------------ )
( Adam                          )
( Time-stamp: <13-07-2018 17:33> )
( ------------------------------ )

(info: Gwint )

o<gwint> sub


#<nr> = #1 (=10 numer narzędzia)
#<obr> = #2 (=400 obroty)
#<odboczka> = #3 (=0 <> odboczka)
#<x_pocz> = #4 (=30 średnica początkowa X)
#<z_pocz> = #5 (=0  początek gwintu Z)
#<skok> = #6 (=2 skok gwintu [P])
#<dlugosc> = #7 (=-20 koniec gwintu [Z])
#<rodzaj> = #8 (=0 <> wewnętrzny )
#<ukos> = #9 (=0 kierunek pochylenia 0 =  1 <  2 >)
#<gl_pocz> = #10 (=0.6 Dobieranie [J])
#<gl_koncowa> = #11 (=1.5 Głębokość gwintu / na promieniu)
#<offset_wlacz> = #12 (=0 <> odjazd od gwintu | 0=skok, 1=ręcznie)
#<offset> = #13 (=1 wartość offsetu)
#<dosuw> = #14 (=27.5 dobieranie boczne [kąt])
#<pochylenie_dlugosc> = #15 (=50 dlugosc pochyl. [E] np.E=Z )
#<wygladzanie> = #16 (=1 <> przejscie wygladzajace)
#<woda> = #17 (=0 <> chłodzenie)
#<w_z> = #18 (=100  Z  do zmiany)
#<w_x> = #19 (=50  X  do zmiany)
#<korekta> = #20 (=0 <> korekta)
#<wielkosc_korekty> = #21 (=0 wielkość korekty)
#<stala_pr_skrawania> = #22 (=0 <> stala_pr_skrawania)
#<obroty_max> = #23 (=0 obroty max)
#<pr_skrawania> = #24 (=0 predkosc skrawania [m/min])
#<degresja> = #25 (=1.5 Dobranie: stała gł. [1] - [2] stała pow.)


o20 if [#<rodzaj> eq 0]  (ZEWNETRZNY)
		o21 if [#<w_z> lt 0 or #<w_x> lt [#<x_pocz>+#<gl_koncowa>] ]
		(msg, KOLIZJA ! zły wyjazd)
		M30
		o21 endif
o20 else  (WEWNETRZNY)
		o22 if [#<w_z> lt 0 or #<w_x> gt [#<x_pocz>-#<gl_koncowa>] ]
		(msg, KOLIZJA ! zły wyjazd)
		M30
		o22 endif
o20 endif


o2 if [#<odboczka> eq 1]
  #<obr> = [#<obr> * 8]
o2 endif


(Tu sie zastanow)
g18   
g7

M6 T#<nr> G43

m3 s#<obr>

o100 if [#<woda> eq 1]
m8
o100 endif


 o111 if [#<wygladzanie> eq 1] 
 #<wygladzanie> = 2 
 o111 endif 


#<bzwgl_wielkosc_korekty> = #<wielkosc_korekty>

o101 if [#<rodzaj> eq 1]  (wewnetrzny)

			#<wielkosc_korekty>= -#<wielkosc_korekty>

		o120 if [#<offset_wlacz> eq 1]
		#<offset> = #<offset>
		o120 else
		#<offset> = 0.2
		o120 endif

	g0 z#<z_pocz>
	g0 x[#<x_pocz> -3]
	g0 x[#<x_pocz> - #<offset>]
	
o101 endif


o102 if [#<rodzaj> eq 0]   (zewnetrzny)
		o130 if [#<offset_wlacz> eq 1]
		#<offset> = -#<offset>
		o130 else
		#<offset> = -0.2
		o130 endif

(dla wlaczonej korekty musimy calosc przesunac w lewo o z=Tan[dobieranie_boczne]*wartosc_korekty_promieniowa)

	o104 if [#<korekta> eq 0]
		g0 x[#<x_pocz> + 3]
		g0 z#<z_pocz>
		g0 x[#<x_pocz> - #<offset>]
	o104 else
		#<z_pocz> = [#<z_pocz> - tan[#<dosuw>] * #<wielkosc_korekty> / 2]
		g0 x[#<x_pocz> + 3]
		g0 z#<z_pocz>
		g0 x[#<x_pocz> - #<offset>]
	o104 endif	
	
o102 endif


 o103 if [#<korekta> eq 0] (bez mkorekty)
 
		o11 if [#<stala_pr_skrawania> eq 1]
		G96 s#<pr_skrawania> D#<obroty_max>
		o11 endif
 
	g76 p#<skok> z#<dlugosc> i#<offset>  j#<gl_pocz> k[#<gl_koncowa>*2] e#<pochylenie_dlugosc> l#<ukos> r#<degresja> q#<dosuw> h#<wygladzanie> 
 
 o103 else  (korekta wlaczona)
	(musimy calosc przesunac w lewo o z=Tan[dobieranie_boczne]*wartosc_korekty_promieniowa)
	
 
 
		o12 if [#<stala_pr_skrawania> eq 1]
		G96 s#<pr_skrawania> D#<obroty_max>
		o12 endif
 
	g76 p#<skok> z#<dlugosc> i[#<offset> - #<wielkosc_korekty>] j[#<gl_koncowa>*2-#<bzwgl_wielkosc_korekty>] k[#<gl_koncowa>*2] e#<pochylenie_dlugosc> l#<ukos> r#<degresja> q#<dosuw> h#<wygladzanie> 
	(g76 p#<skok> z#<dlugosc> i[#<offset> - #<wielkosc_korekty>] j[#<gl_koncowa> - #<bzwgl_wielkosc_korekty>] k[#<gl_koncowa>*2] e#<pochylenie_dlugosc> l#<ukos> r#<degresja> q#<dosuw> h#<wygladzanie>)
 o103 endif 

g18
m9
m5
g0 x#<w_x>
g0 z#<w_z>

o<gwint> endsub 
Ale gdzieś to kiedyś już wystawiałem .
autor: szary11
29 sty 2020, 19:50
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

Troszkę przerobiony sub skanowania/próbkowania materiału, może komuś się przyda,
w orginale jest dla trzech osi, ale u mnie działa i na tokarce :

Kod: Zaznacz cały

( Rectangular area probe )
( adapted for ngcgui-compatibility from smartprobe.ngc written by Chris Radek )
( This program repeatedly probes a regular XY grid and writes the )
( probed locations to the file 'probe_result.txt' in the same directory )
( as the .ini file )

( Requires a probe connected to motion.probe-input )
( or use scripts/simulate_probe )

(info: Probe a rectangular area)
o<probe> sub
      #<xmin> =  #1 (=  0.0)
      #<xmax> =  #2 (=   10.0)
 #<xinterval> =  #3 (=   0.1)
      #<ymin> =  #4 (=  0.0 nie dotykaj dla tokarki) 
      #<ymax> =  #5 (=   0.0 zostaw dla tokarki)	
 #<yinterval> =  #6 (=   1.0 nierusz dla tokarki)
     #<zsafe> =  #7 (=   1.0)
  #<zretract> =  #8 (=   2.0 wycofanie Z offset)
    #<zprobe> =  #9 (=  -10.)
#<probespeed> =  #10 (=  200)
  #<in_or_mm> = #11 (=  21 in|mm 20|21)
      #<wait> = #12 (=   1 Wait for Start)

O1 if [ [#<in_or_mm> ne 20] and [#<in_or_mm> ne 21]]
     (debug, in_or_mm invalid: #<in_or_mm> - EXITING)
     (print, in_or_mm invalid: #<in_or_mm> - EXITING)
     (AXIS,notify, probe: in_or_mm invalid - EXITING)
     m2
O1 endif

#<xsteps> = [fix [abs[#<xmax> - #<xmin>]/#<xinterval> + 1]]
#<ysteps> = [fix [abs[#<ymax> - #<ymin>]/#<yinterval> + 1]]

G#<in_or_mm>
#<points> = [#<xsteps> * #<ysteps>]

(debug, Probing #<xsteps> * #<ysteps> = #<points> points)
(LOGOPEN,probe_result.txt)
(LOG,# xmin = #<xmin> xmax = #<xmax> xinterval = #<xinterval> xsteps = #<xsteps>)
/(LOG,# ymin = #<ymin> ymax = #<ymax> yinterval = #<yinterval> ysteps = #<ysteps>)

#<yct> = 0
#<xct> = 0
G0Z#<zsafe>
F#<probespeed>

O2 while [#<yct> lt #<ysteps>]
     #<xct> = 0
/     G0 Y[#<ymin>+#<yinterval>*#<yct>]
O3   while [#<xct> lt #<xsteps>]
       #<xtarget> = 0
O4     if [[#<yct>/2] - fix[#<yct>/2] eq 0]
         #<xtarget> = [#<xmin> + #<xinterval> * #<xct>]
O4     else
         #<xtarget> = [#<xmin> + #<xinterval> * [#<xsteps> - #<xct> - 1]]
O4     endif
       #<probesuccess> = 1
O5     while [#<probesuccess> NE 0]
         G38.5 z#<zsafe>   (probe until no contact away from work, no error)
         #<probesuccess> = #5070
         G38.3 x#<xtarget> (probe until contact, toward work, no error)
         #<probesuccess> = #5070
O5     endwhile
O6     if [[#<wait> eq 1] and [[#<yct> eq 0] and [#<xct> eq 0]]]
         (debug, S to Begin Probe)
         m0 (mandatory stop)
  /       M110 (axisui.notifications-clear)
O6     endif
       G38.2Z#<zprobe> (probe until contact, toward work, with error)
		(G0z#<zsafe>)
		G91
		G0Z#<zretract>
		G90
       #<probex> = #5061
       #<probey> = #5062
       #<probez> = #5063
 /      (LOG,X#<probex> Y#<probey> Z#<probez>)  odkomentuj dla frezarki
        (LOG,X#<probex> Z#<probez>)
       #<xct> = [#<xct> + 1]
O3    endwhile
      (G0Z#<zsafe>)
      G91
      G0Z#<zretract>
      G90
      #<yct> = [#<yct> + 1]
O2 endwhile

(LOG,# Finished: total points = #<points>)
(LOGCLOSE)
(debug, Finished: see probe_result.txt)

G0Z#<zsafe>
G0X#<xmin>
/Y#<ymin>
o<probe> endsub
autor: szary11
06 sie 2019, 18:40
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

Może ten Ci podpasuje.
Da się zrobić jeden.
Osnowa suba z Kozienic. :)

Kod: Zaznacz cały

( ------------------------------ )
(  O T W O R Y  P O  O K R E G U )
( ------------------------------ )
( ADAM                         )
( Time-stamp: <2018-11-30 18:29> )
( ------------------------------ )
(          USTAWIENIA            )
( ------------------------------ )

(info: Wycinanie otworów po okręgu)
o<otwory_po_okregu> sub

#<frez> = #1 (=50 frez)
#<sr_otworu> = #2 (=50 średnica otworu)
#<pelny> = #3 (=0 <> kontur[0] / pełny[1])
#<srednica> = #4 (=0 średnica podziału)
#<il_otworow> = #5 (=1 ilosc otworow )
#<kat_poczatkowy> = #6 (=0 kąt początkowy)
#<glebokosc> = #7 (=-1 glebokosc [-])
#<skok> = #8 (=2 skok)
#<wyjazd> = #9 (=5 wyjazd)
#<wys_przejazd> = #10 (=30 wysokość przejazdu)
#<posuw> = #11 (=60 posuw)
#<predkosc_dol> = #12 (=200 prędkosć dół)
#<glebokosc_lba> = #13 (=0 głębokość łba [-])
#<srednica_lba> = #14 (=0 średnica łba)
#<woda> = #15 (=0 <> chłodzenie)
#<mgla> = #16 (=0 <> mgła)
#<pompowanie> = #17 (=2 pompowanie)
#<wyjazd_wiertla> = #18 (=2 wyjazd wiertła)
#<obr> = #19  (=500  obroty)

( ------------------------------ )
(-----NOWY KOD POCZATEK-----)
#<stala_pr_skrawania> = #20 (=1 <> stała pr. skrawania)
#<pr_skrawania> = #21 (=100 predkosc skrawania [m/min])
#<sr_narzedzia> = #22 (=50 średnica nadzędzia [mm])

#<stale_dobranie> = #23 (=1 <> stałe dobranie)
#<dobranie_zab> = #24 (=0.2 dobranie/ząb [mm])
#<liczba_zebow> = #25 (=5 liczba zębów)

#<bieg1> = #26 (=0 <> bieg: 150 Sr,Cz,Cz)
#<bieg2> = #27 (=0 <> bieg: 480 Zi,Ni,Ni)
#<bieg2> = #28 (=0 <> bieg: 1200 Zi,Cz,Cz)
#<bieg4> = #29 (=0 <> bieg: 3000 Zi,Żó,Żó)
#<nr> = #30 (=1 nr narzędzia)


(-----NOWY KOD KONIEC-----)

(-----NOWY KOD POCZATEK-----)

o2 if [#<stala_pr_skrawania> eq 1]
	#<Pi> = 3.141593
	#<obwod_mm> = [2*#<Pi>*#<sr_narzedzia>/2]
	#<obwod_m> = [#<obwod_mm> / 1000]
	#<obr> = [#<pr_skrawania> / #<obwod_m>]
o2 endif

o3 if [#<stale_dobranie> eq 1] 
	#<dobranie_obrot_mm> = [#<liczba_zebow> * #<dobranie_zab>]
	#<posuw> = [#<dobranie_obrot_mm> * #<obr>]
o3 endif

o4 if [[#<bieg1> + #<bieg2> + #<bieg2> + #<bieg4>] gt 1]
	M100 P1   (Message) 
o4 elseif [#<bieg4> eq 1]
	#<obr> = #<obr> 
o4 elseif [#<bieg2> eq 1]	
	#<obr> = [#<obr> * 2.5]
o4 elseif [#<bieg2> eq 1]	
	#<obr> = [#<obr> * 6.25]
o4 elseif [#<bieg1> eq 1]		
	#<obr> = [#<obr> * 20]	
o4 else
	M100 P2
o4 endif

o5 if [#<obr> gt 3000]
	M100 P3
	
o5 endif

(-----NOWY KOD KONIEC-----)

#<promien> = [#<srednica> / 2] ( promien )
#<kat> = [360 / #<il_otworow>] ( kat )
#<akt_otwor> = 0 ( aktualny otwor - od 0)
#<przesuniecie> = [[#<sr_otworu > / 2] - [#<frez> / 2]]
#<przesuniecie_lba> = [[#<srednica_lba> / 2] - [#<frez> / 2]]

o6 if [#<glebokosc_lba> LT 0 AND #<pelny> EQ 0]
	M100 P4
o6 endif

o100 while [#<akt_otwor> LT #<il_otworow>]

#<akt_kat> = [[#<akt_otwor> * #<kat>] + #<kat_poczatkowy>] ( kat * otwor )
#<poz_x> = [COS[#<akt_kat>] * #<promien>] ( X to RcosA )
#<poz_y> = [SIN[#<akt_kat>] * #<promien>] ( Y to RsinA )

g17 G21 (G61)
G64

( ustawiam pozycję startową )
/G0 Z#<wys_przejazd>
/G0 X#<poz_x> Y#<poz_y> ( ustawiam pozycje )
/G0 Z#<wyjazd>

( ------------------------------ )
(           OPERACJA             )
( ------------------------------ )


M6 T#<nr> G43

m3 s #<obr>
o1 if [#<woda> eq 1]
m8
o1 endif




o7 if [#<mgla> eq 1]
m7
o7 endif

o105 if [#<sr_otworu> gt #<frez>]
	( frezuję )
	
	#<akt_glebokosc> = 0
	

	o40 if [#<pelny> eq 0]
		
		g0 x[#<poz_x>] y[#<poz_y> + #<przesuniecie>]
		G0 Z#<wyjazd>
		g1 z#<akt_glebokosc> F#<predkosc_dol>
			
		o19 while [#<akt_glebokosc> GT #<glebokosc>]
		#<akt_glebokosc> = [#<akt_glebokosc> - #<skok>] ( ustalenie glebokosci )
		
			( jezeli wyliczylo ponizej limitu to zaglebiam tylko do limitu )
			o30 if [#<akt_glebokosc> LT #<glebokosc>] 
			#<akt_glebokosc> = #<glebokosc>
			o30 endif
			
			
			g2 x[#<poz_x>] y[[#<poz_y> + #<przesuniecie>]] i0 j[#<przesuniecie> * -1] z[#<akt_glebokosc>] F#<posuw>
			(g0 y[#<poz_y>])
		
		o19 endwhile
		
			g2 x[#<poz_x>] y[[#<poz_y> + #<przesuniecie>]] i0 j[#<przesuniecie> * -1] F#<posuw>
			
			(g0 x[#<poz_x>] y[#<poz_y>]) (rysiek do środka)
			G0 Z#<wys_przejazd>
		
		
		
	o40 else
			
			
			#<szerokosc_zbierania> = [#<frez> / 2]
			#<akt_przesuniecie> = 0
			
			g0 x[#<poz_x>] y[#<poz_y> + #<akt_przesuniecie> + #<szerokosc_zbierania>]
			
			o21 while [#<akt_przesuniecie> LT #<przesuniecie>]
				
				#<akt_glebokosc> = 0
				
				#<akt_przesuniecie> = [#<akt_przesuniecie> + #<szerokosc_zbierania>] (dobieranie w poziomie o 1 trzecia srednicy freza) 
				
				o42 if [#<akt_przesuniecie> gt #<przesuniecie>]
					#<akt_przesuniecie> = #<przesuniecie>
				o42 endif
				
				g0 x[#<poz_x>] y[#<poz_y> + #<akt_przesuniecie> ] F#<posuw>
				g0 z#<wyjazd>
				g1 z#<akt_glebokosc> F#<predkosc_dol>
				
				o20 while [#<akt_glebokosc> GT #<glebokosc>]
					#<akt_glebokosc> = [#<akt_glebokosc> - #<skok>] ( ustalenie glebokosci )
				
					( jezeli wyliczylo ponizej limitu to zaglebiam tylko do limitu )
					o31 if [#<akt_glebokosc> LT #<glebokosc>] 
					#<akt_glebokosc> = #<glebokosc>
					o31 endif
					
			
					g2 x[#<poz_x>] y[[#<poz_y> + #<akt_przesuniecie>]] i0 j[#<akt_przesuniecie> * -1] z[#<akt_glebokosc>] F#<posuw>
						
				o20 endwhile
				
					g2 x[#<poz_x>] y[[#<poz_y> + #<akt_przesuniecie>]] i0 j[#<akt_przesuniecie> * -1] F#<posuw>
					
					(g0 x[#<poz_x>] y[#<poz_y>]) (rysiek do środka)
					
					g0 Z#<wyjazd>
				
				
			
		o21 endwhile
			
		g0 z#<wys_przejazd>
			
		
	o40 endif
			
	


o105 else

	G83 X#<poz_x> Y#<poz_y> Z#<glebokosc> R#<wyjazd_wiertla> Q#<pompowanie> F#<predkosc_dol>

o105 endif
(g0 x[#<poz_x>] y[#<poz_y>]) (rysiek do środka)

G0 Z#<wyjazd>



( wybieram leb )

o110 if [#<glebokosc_lba> LT 0 and #<pelny> eq 1]
     #<akt_glebokosc_lba> = 0
     #<szerokosc_zbierania> = [#<frez> / 2]
     


#<akt_glebokosc_lba> = 0
#<szerokosc_zbierania> = [#<frez> / 2]
#<akt_przesuniecie_lba> = #<przesuniecie>  (przesuniecie w Y po wywierceniu otworu)


o25 while [#<akt_przesuniecie_lba> LT #<przesuniecie_lba>]		
	
	#<akt_przesuniecie_lba> = [#<akt_przesuniecie_lba> + #<szerokosc_zbierania>]   (dobieranie lba w poziomie o 1 trzecia srednicy freza) 
	
	o41 if [#<akt_przesuniecie_lba> gt #<przesuniecie_lba>]
		#<akt_przesuniecie_lba> = #<przesuniecie_lba>
	o41 endif
						
	g0 x[#<poz_x>] y[#<poz_y> + #<akt_przesuniecie_lba>]
	g1 z#<akt_glebokosc_lba> F#<predkosc_dol>

	(wiercenie)
		 o120 while [#<akt_glebokosc_lba> GT #<glebokosc_lba>]
			  #<akt_glebokosc_lba> = [#<akt_glebokosc_lba> - #<skok>] ( ustalenie glebokosci )

			( jezeli nizej limitu to jade max )
			  o130 if [#<akt_glebokosc_lba> LT #<glebokosc_lba>] 
				   #<akt_glebokosc_lba> = #<glebokosc_lba>
			  o130 endif

			g2 x[#<poz_x>] y[#<poz_y> + #<akt_przesuniecie_lba>] i0 j[#<akt_przesuniecie_lba> * -1] z[#<akt_glebokosc_lba>] F#<posuw>
			

		 o120 endwhile
		 
		 g2 x[#<poz_x>] y[#<poz_y> + #<akt_przesuniecie_lba>] i0 j[#<akt_przesuniecie_lba> * -1] F#<posuw>
		 
		 #<akt_glebokosc_lba> = 0
		 (G0 Z#<wyjazd>)
(g0 x[#<poz_x>] y[#<poz_y>]) (rysiek do środka)

o25 endwhile



o110 endif


(g0 z#<wys_przejazd>)

( ------------------------------ )
( ------------------------------ )

#<akt_otwor> = [#<akt_otwor> + 1] ( nastepny otwor )


o100 endwhile
(g0 x[#<poz_x>] y[#<poz_y>]) (rysiek do środka)
g0 z#<wys_przejazd>
g0 x0 y0

o<otwory_po_okregu> endsub
autor: szary11
23 lut 2019, 13:19
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

Dorobiłem sobie dodatek do subów we frezarce na Vc i fz, u mnie działa.
Linie z biegami można wyrzucić lub dostosować do swoich potrzeb. (oczywiście falownik u mnie jest)
M100 wyrzuca u mnie duże komentarze na środek ekranu.

Kod: Zaznacz cały

(-----NOWY KOD POCZATEK-----)
#<stala_pr_skrawania> = #19 (=1 <> stała pr. skrawania)
#<pr_skrawania> = #20 (=40 predkosc skrawania [m/min])
#<sr_narzedzia> = #21 (=10 średnica nadzędzia [mm])

#<stale_dobranie> = #22 (=1 <> stałe dobranie)
#<dobranie_zab> = #23 (=0.04 dobranie/ząb [mm])
#<liczba_zebow> = #24 (=4 liczba zębów)

#<bieg1> = #25 (=0 <> bieg: 150 Sr,Cz,Cz)
#<bieg2> = #26 (=0 <> bieg: 480 Zi,Ni,Ni)
#<bieg3> = #27 (=0 <> bieg: 1200 Zi,Cz,Cz)
#<bieg4> = #28 (=1 <> bieg: 3000 Zi,Żó,Żó)


( ------------------------------ )


o2 if [#<stala_pr_skrawania> eq 1]
	#<Pi> = 3.141593
	#<obwod_mm> = [2*#<Pi>*#<sr_narzedzia>/2]
	#<obwod_m> = [#<obwod_mm> / 1000]
	#<obr> = [#<pr_skrawania> / #<obwod_m>]
o2 endif

o3 if [#<stale_dobranie> eq 1] 
	#<dobranie_obrot_mm> = [#<liczba_zebow> * #<dobranie_zab>]
	#<predkosc_bok> = [#<dobranie_obrot_mm> * #<obr>]
o3 endif

o4 if [[#<bieg1> + #<bieg2> + #<bieg3> + #<bieg4>] gt 1]
	M100 P1   (Message) 
o4 elseif [#<bieg4> eq 1]
	#<obr> = #<obr> 
o4 elseif [#<bieg3> eq 1]	
	#<obr> = [#<obr> * 2.5]
o4 elseif [#<bieg2> eq 1]	
	#<obr> = [#<obr> * 6.25]
o4 elseif [#<bieg1> eq 1]		
	#<obr> = [#<obr> * 20]	
o4 else
	M100 P3
o4 endif

o5 if [#<obr> gt 3000]
	(Obroty poza osiągalnym zakresem)
o5 endif

(-----NOWY KOD KONIEC-----)
autor: szary11
23 sty 2019, 14:06
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

Tego to mi brakowało, dzięki.
autor: szary11
08 sty 2019, 20:20
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

Wydaje mi się że gdzieś kiedyś wstawiałem,
wiercenie ze sterowalnym urwaniem wióra, oczywiście tokarka:

Kod: Zaznacz cały

	
( ------------------------------ )
(       W I E R C E N I E   2    )
( ------------------------------ )
( Adam                           )
( Time-stamp: <2018-06-10 13:33> )

( ------------------------------ )

(info: wiercenie )

o<wier> sub

#<glebokosc> = #1 (=-15 Glebokość wiercenia)
#<skok> = #2 (=2 Co ile urwanie)
#<cofniecie_urwania> = #3 (=0.5 Cofnięcie przy urwaniu)
#<skok_cof> = #4 (=5 Co ile wycofanie)
#<predkosc> = #5 (=30 prędkosć)
#<wyjazd> = #6 (=60 wyjazd koncowy)
#<woda> = #7 (=0 <> chłodzenie)
#<nr> = #8 (=12 nr narzędzia)

M6 T#<nr> G43

g61
g17
m3 s500 
o1 if [#<woda> eq 1]
   M8
o1 endif

g0 z10

g0 z2


o90 if [#<skok_cof> gt 0]  (właczone wyrzucanie wiora)

#<aktualna_glebokosc> = 0
#<nowy_start> = #<aktualna_glebokosc>
o95 while [#<aktualna_glebokosc> gt #<glebokosc>]
	
	#<aktualna_glebokosc> = [#<aktualna_glebokosc> - #<skok_cof>]
	o96 if[#<aktualna_glebokosc> le #<glebokosc>]
		#<aktualna_glebokosc> = #<glebokosc>
	o96 endif
	
	g1 z#<nowy_start> F#<predkosc>
	o100 if [#<skok> gt 0]  (wlaczone urywanie wiora)

		#<aktualna_glebokosc_urywania> = #<nowy_start>
		
		o110 while [#<aktualna_glebokosc_urywania> gt #<aktualna_glebokosc>]
			
			#<aktualna_glebokosc_urywania> = [#<aktualna_glebokosc_urywania> - #<skok>]
				
			o97 if[#<aktualna_glebokosc_urywania> le #<aktualna_glebokosc>]
				#<aktualna_glebokosc_urywania> = #<aktualna_glebokosc>
			o97 endif
			g1 z[#<aktualna_glebokosc_urywania>]  F#<predkosc> 							(wierc az do kolejnego urwania)
			g0 z[#<aktualna_glebokosc_urywania> + #<cofniecie_urwania>]  	(urwij i wycofaj na zdefiniowana odlegosc)
			g0 z[#<aktualna_glebokosc_urywania> + 0.1]  					(powroć na pozycje do kontunowania wiercenia _ offset 0.1 mm)
			
		o110 endwhile
		
	o100 else
		g81 z#<aktualna_glebokosc> R#<nowy_start> F#<predkosc>
	o100 endif
	
	
	#<nowy_start> = #<aktualna_glebokosc>
	g0 z2    (wyrzucenie wior)
	g0 z[#<nowy_start> + 0.5]  (powrot nowy start zeby kontynuowac)
	
o95 endwhile

o90 else

	o101 if [#<skok> gt 0]  (wlaczone urywanie wiora)
	g73 z#<glebokosc> R2 Q#<skok> F#<predkosc>
	o101 else
	g81 z#<glebokosc> R2 F#<predkosc>
	o101 endif


o90 endif


g80

m5 m9
g0 z#<wyjazd>
m2
o<wier> endsub 
autor: szary11
10 sty 2018, 09:31
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Re: Suby ngcgui

sub do rowków klinowych dla przecinaka
może komuś się przyda

Kod: Zaznacz cały


( ------------------------------ )
(       WYBRANIE     PASEK       )
( ------------------------------ )
( Adam                  )
( Time-stamp: <2017-12-23 21:00>  )
( ------------------------------ )
(info: klin )

o<klin> sub



#<nr> = #1 (=1 nr narzędzia)
#<obr> = #2 (=400 obroty)
#<odboczka> = #3 (=0 <> odboczka)

#<z_pocz> = #4 (=-5 Z początkowe)
#<sr_zew_duza> = #5 (=17 szerokość zewn.)
#<sr_wew_duza> = #6 (=5 szerokość wewn.)
#<kat> = #7 (=15.5 ...lub kąt) 
#<szer_noza> = #8 (=4 szerokość noża) 

#<poczatek> = #9 (=100 średnica duża)
#<koniec> = #10 (=80 średnica mała)
#<dobieranie> = #11 (=1 dobieranie)

#<posuw> = #12 (=0.1 posuw [mm/obr] v [mm/min])
#<posuw_na_obrot> = #13 (=0 <> posuw/obrot)

#<w_z> = #14 (=50 Z  do zmiany)
#<w_x> = #15 (=110 X  do zmiany)

#<woda> = #16 (=1 <> chłodzenie)

#<stala_pr_skrawania> = #17 (=0 <> stała pr. skrawania)
#<obroty_max> = #18 (=1200 obroty max)
#<pr_skrawania> = #19 (=200 prędkość skrawania [m/min])
#<dlugosc_z> = #20 (=1 długość fazki)


	o1 if [#<w_x> lt #<poczatek> or #<w_z> lt 0]
	(msg, KOLIZJA ! zły wyjazd)
	M30
	o1 endif
	
	
#<glebokosc_promieniowa> = [#<poczatek> - #<koniec>]


(kąt nachylenia paska liczony z wymiarow, potrzebny do obliczenia kątu sfazowania)

#<kat_paska> = atan[#<sr_zew_duza> - #<sr_wew_duza>]/[#<glebokosc_promieniowa>]
	
(obliczenia pomocnicze kątowe)



(wymiar katowy - zamiana srednicy wew jako wynikowej kata)
o10 if [#<kat> gt 0]
	#<sr_wew_duza> = [#<sr_zew_duza> - [2 * tan[#<kat>] * #<glebokosc_promieniowa> / 2]]
	#<kat_paska> = #<kat>
o10 endif
	
(roznica sredni to tak naprawde polowa roznicy szerokosci duzej i malej)
#<roznica_srednic> = [[#<sr_zew_duza> - #<sr_wew_duza>]/2]


(koniec obliczen)	
	
	

	o2 if [#<sr_zew_duza> lt #<sr_wew_duza>]
	(msg, chyba coś Ci zewnetrzne srednice popierniczyły)
	M30
	o2 endif



	

(M6 T#<nr> G43)

	o5 if [#<odboczka> eq 1]
	  #<obr> = [#<obr> * 8]
	o5 endif


	o6 if [#<odboczka> eq 1]
	  #<pr_skrawania> = [#<pr_skrawania> * 8]
	  #<obroty_max> = [#<obroty_max> * 8]
	o6 endif


	o7 if [#<woda> eq 1]
	   M8
	o7 endif


	o8 if [#<posuw_na_obrot> eq 1]
		G95 
	o8 endif

M3 s#<obr>



g0 x[#<poczatek> + 10]
g0 z#<z_pocz>

#<akt_pozycja> = #<poczatek> 






o4 if [#<stala_pr_skrawania> eq 1]
		G96 s#<pr_skrawania> D#<obroty_max>
o4 endif

	
	
	
(Zagłebiania prostopadłe, schodki na ukosach z prawej)

#<z_teoretyczny> = #<z_pocz> 
#<przesuw_limit_lewo_teoretyczny> =  [#<z_pocz>  - #<roznica_srednic>]

#<przesuw_limit_lewo> = [#<przesuw_limit_lewo_teoretyczny>  - #<szer_noza>]  (w drugim wariancie będzie prawo)
#<akt_przesuw> = [#<z_teoretyczny> - #<szer_noza>]
#<zaglebienie> = [[#<z_pocz> - #<z_teoretyczny>] * #<glebokosc_promieniowa> / #<roznica_srednic>]  (zagłebienie  proporcjonalne do przesuniecia z na ukosie)

o101 while [#<z_teoretyczny> gt #<przesuw_limit_lewo_teoretyczny>]

	o151 if [#<z_teoretyczny> lt #<przesuw_limit_lewo_teoretyczny>]  (ostatni przejazd)
		 #<z_teoretyczny>  = #<przesuw_limit_lewo_teoretyczny>
		o151 endif 
		 
		#<przesuw_limit_lewo> = [#<przesuw_limit_lewo_teoretyczny>  - #<szer_noza>]  (przelicz wartosci z uwzglednieniem kompensacji narzedzia)
		#<akt_przesuw> = [#<z_teoretyczny> - #<szer_noza>]
		#<zaglebienie> = [[#<z_pocz> - #<z_teoretyczny>] * #<glebokosc_promieniowa> / #<roznica_srednic>]  (zagłebienie  proporcjonalne do przesuniecia z na ukosie)
		
		
	    g0 z#<akt_przesuw> 
		g0 x[#<poczatek> + 2] 
		g1 x#<poczatek> f#<posuw> 
		
		g1 x[#<poczatek> - #<zaglebienie>] f#<posuw> 
		
		g0 x[#<poczatek> + 2] 
	
		#<z_teoretyczny> = [#<z_teoretyczny> - [#<szer_noza> /2]]   (przesuniecie w lewo na kolejne zaglebienie)
		
o101 endwhile

g0 x[#<poczatek> + 10] 



(Zrob cześć prostą rowka.)


#<akt_przesuw> = [#<z_pocz> - #<roznica_srednic> - #<szer_noza>]
#<przesuw_limit_lewo> = [#<z_pocz>  - #<roznica_srednic> - #<sr_wew_duza>]   (usuniete dzielenie szerokosci noza przez 2)

#<akt_przesuw> = [#<akt_przesuw> + [#<szer_noza>/2]] (sztuczna inkrementacja bo na poczatku pętli jest dekrementowane)

o100 while [#<akt_przesuw> gt #<przesuw_limit_lewo>]
	
	#<akt_przesuw> = [#<akt_przesuw> - [#<szer_noza>/2]]

	o150 if [#<akt_przesuw> lt #<przesuw_limit_lewo>]  (ostatni przejazd)
		 #<akt_przesuw>  = #<przesuw_limit_lewo>
	o150 endif
		
		g0 z#<akt_przesuw> 
		g0 x[#<poczatek> + 2] 
		g1 x#<poczatek> f#<posuw>
		g1 x#<koniec> 
		g0 x[#<poczatek> + 2]
		
			
		
o100 endwhile	 

g0 x[#<poczatek> + 10] 






(Zagłebiania prostopadłe, schodki na ukosach z lewej)

#<z_teoretyczny> = [#<z_pocz> - #<sr_zew_duza>]
#<przesuw_limit_prawo_teoretyczny> =  [#<z_teoretyczny> + #<roznica_srednic>]
#<przesuw_limit_prawo> = #<przesuw_limit_prawo_teoretyczny>      (w drugim wariancie będzie prawo)

#<akt_przesuw> = #<z_teoretyczny> 
#<zaglebienie> = [[#<z_pocz> - #<z_teoretyczny>] * #<glebokosc_promieniowa> / #<roznica_srednic>] (zagłebienie  proporcjonalne do przesuniecia z na ukosie)


o102 while [#<z_teoretyczny> lt #<przesuw_limit_prawo_teoretyczny>]

	o152 if [#<z_teoretyczny> gt #<przesuw_limit_prawo_teoretyczny>]  (ostatni przejazd)
		 #<z_teoretyczny>  = #<przesuw_limit_prawo_teoretyczny>
	o152 endif		 
		 
		#<przesuw_limit_prawo> = #<przesuw_limit_prawo_teoretyczny>  (tutaj nie trzeba kompensacji szerokosci, bo zerowanie Z bylo do lewej krawędzi noża)
		#<akt_przesuw> = #<z_teoretyczny>
		#<zaglebienie> = [[#<z_teoretyczny> - [#<z_pocz> - #<sr_zew_duza>]] * #<glebokosc_promieniowa> / #<roznica_srednic>]  (zagłebienie  proporcjonalne do przesuniecia z na ukosie)
		
		
	    g0 z#<akt_przesuw> 
		g0 x[#<poczatek> + 2] 
		g1 x#<poczatek> f#<posuw> 
		
		g1 x[#<poczatek> - #<zaglebienie>] f#<posuw> 
		
		g0 x[#<poczatek> + 2] 
	
		#<z_teoretyczny> = [#<z_teoretyczny> + #<szer_noza> /2]   (przesuniecie w lewo na kolejne zaglebienie)
			
o102 endwhile

g0 x[#<poczatek> + 10] 


(wygładzanie ukos  - prawy)

#<poszerzenie> = 0
#<wygladzenie_dna> = 1


o20 repeat[2]

g0 z[#<z_pocz>  - #<szer_noza> + #<poszerzenie>]
g0 x[#<poczatek> + 2]
g1 x[#<poczatek>] f#<posuw>
g1 x[#<koniec>] z[#<z_pocz> - #<szer_noza> - #<roznica_srednic> + #<poszerzenie>]


	o31 if[#<wygladzenie_dna> eq 1]
		
		g1 z[#<z_pocz> - #<roznica_srednic> - #<sr_wew_duza>]
	
		#<wygladzenie_dna> = 0
	o31 endif


g0 x[#<poczatek> + 2]

#<poszerzenie> = 0.1

o20 endrepeat

g0 x[#<poczatek> + 10] 


(wygładzanie ukos  - lewy)

#<poszerzenie> = 0
o21 repeat[2]

g0 z[#<z_pocz> - #<sr_zew_duza> - #<poszerzenie>]
g0 x[#<poczatek> + 2]
g1 x[#<poczatek>]
g1 x[#<koniec>] z[#<z_pocz> - #<sr_zew_duza> + #<roznica_srednic> - #<poszerzenie>]
g0 x[#<poczatek> + 2]

#<poszerzenie> = 0.1

o21 endrepeat

g0 x[#<poczatek> + 10]

(fazowanie - kąt w zaleznosci od nachylenia paska)



#<kat_fazy> = [[180 - #<kat_paska> - 90]/2]
#<dlugosc_x> = [tan[#<kat_fazy>] * #<dlugosc_z>]

	(lewa fazka)
	
#<start> = [#<z_pocz> - #<sr_zew_duza> - #<poszerzenie> - [#<dlugosc_z>/2]]

g0 z[#<start>]
g0 x[#<poczatek> + 2]
g1 x[#<poczatek>] f#<posuw>
g1 x[#<poczatek> - #<dlugosc_x>*2] z[#<start> + #<dlugosc_z>] f#<posuw>

g0 x[#<poczatek> + 10]

	(prawa fazka)
	
#<start> = [#<z_pocz>  + #<poszerzenie> - #<szer_noza> + [#<dlugosc_z>/2]]

g0 z[#<start>]
g0 x[#<poczatek> + 2]
g1 x[#<poczatek>] f#<posuw>
g1 x[#<poczatek> - #<dlugosc_x>*2] z[#<start> - #<dlugosc_z>] f#<posuw>





g0 x[#<poczatek> + 10]
m5
g0 z#<z_pocz>	

g0 x#<w_x>
g0 z#<w_z>





o<klin> endsub

autor: szary11
04 gru 2015, 06:51
Forum: LinuxCNC (dawniej EMC2)
Temat: Suby ngcgui
Odpowiedzi: 301
Odsłony: 26513

Pewnie każdy ma jakiś sposób na nesting, przedstawiam mój troche prosty, ale zawsze coś jest:

Kod: Zaznacz cały

( ------------------------------ )
(       Pętla dla DXF2GCODE      )
( ------------------------------ )
( Adam                          )
( Time-stamp: <2015-10-14 10:56> )

( ------------------------------ )
(          USTAWIENIA            )
( ------------------------------ )

o<petla> sub


#<powt_x> = #1 (=1 wystąpienia X)
#<powt_y> = #2 (=1 wystąpienia Y)
#<odl_x> = #3 (=0 skok X)
#<odl_y> = #4 (=0 skok Y)

(definuje poczatek ukladu wspolrzednych aby potem inkrementowac wartosci)

#<y_pocz> = 0
#<x_pocz> = 0

o100 repeat[#<powt_x>]  (PETLA po x)

	g0 x#<x_pocz> y#<y_pocz>
	
	G92 x0 y0
	
	/g1 x10 y10 f1000

	o<input> call 
	
	
	o110 repeat[#<powt_y>-1] (pętla po Y)
	
		#<y_pocz> = #<odl_y>
		
		g0 x0 y#<y_pocz>
	
		G92 x0 y0 
		
		/g1 x10 y10 f1000
	
		o<input> call
	

	o110 endrepeat

	
#<y_pocz> = -[#<odl_y> * [#<powt_y>-1] ]		
#<x_pocz> = #<odl_x>

o100 endrepeat	


o<petla> endsub

generuje w subie , lub camie jakiś kształt, zapisuje jako "input", otwieram pentelke i rozrzucam jak obornik :lol:, bo ja ze wsi i niechce do miasta

Wróć do „Suby ngcgui”