Kod: Zaznacz cały

( ------------------------------ )
(          S T O Z E K  2        )
( ------------------------------ )
( Adam                    		)
( Time-stamp: <2016-02-26 15:25 )
( ------------------------------ )

(info: Stożek2 )

 o<stozek2> sub 

 
 #<obr> = #1 (=400 obroty)
 #<odboczka> = #2 (=0 <> odboczka)
 #<sr_materialu> = #3 (=40 Średnica wału / otworu)
 #<rodzaj> = #4 (=0 <> wewnętrzny )
 #<sr_pocz> = #5 (=20 Średnica prawa )
 #<sr_koncowa> = #6 (=30 Średnica lewa...)
 #<kat> = #7 (=0 ...albo kąt < -, > + [kąt ma priorytet])
 #<dl_stozka> = #8 (=20 Długość stożka)
 #<z_pocz> = #9 (=0 Z początkowe )
 #<dobieranie> = #10 (=2 Dobieranie )
 #<ostatnia_warstwa> = #11 (=0.1 ostatnia warstwa)
 
 #<posuw> = #12 (=0.2 posuw [mm/obr] v [mm/min])
 #<posuw_na_obrot> = #13 (=1 <> posuw/obrot)
 #<woda> = #14 (=0 <> chłodzenie )
 
#<stala_pr_skrawania> = #15 (=1 <> stala_pr_skrawania)
#<obroty_max> = #16 (=1200 obroty max)
#<pr_skrawania> = #17 (=200 predkosc skrawania [m/min])

 #<korekta> = #18 (=0 <> korekta )
 #<wielkosc_korekty> = #19 (=0 wielkość korekty)
 #<w_z> = #20 (=5 Z  do zmiany)
#<w_x> = #21 (=50 X  do zmiany)
 
 
#<tangens_kat> = tan[#<kat>]



o1 if [#<rodzaj> eq 0]  (ZEWNETRZNY)
		o20 if [#<sr_materialu> lt #<sr_pocz> or #<sr_materialu> lt #<sr_koncowa>]
			(msg, KOLIZJA ! zły wyjazd)
			M30	
		o20 else
			o21 if [#<w_z> lt 0 or #<w_x> lt #<sr_materialu> ]
			(msg, KOLIZJA ! zły wyjazd)
			M30
			o21 endif
		o20 endif
o1 else  (WEWNETRZNY)
		o22 if [#<sr_materialu> gt #<sr_pocz> or #<sr_materialu> gt #<sr_koncowa>]
			(msg, KOLIZJA ! zły wyjazd)
			M30
		o22 else
			o23 if [#<w_z> lt 0 or #<w_x> gt #<sr_materialu> ]
			(msg, KOLIZJA ! zły wyjazd)
			M30	
			o23 endif
		o22 endif
o1 endif



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

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



m3 s#<obr>

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


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


o7 if [#<kat> gt 0 and  #<sr_koncowa> gt 0]
(msg, Podajemy albo kąt albo druga srednicę)



o7 endif


(uzaleznienie srednicy końcowej od kąta) 
(2 warianty - srenica lub kat-preferowany, albo, srednica lub dlogosc)

	o10 if [#<kat> ne 0]
	 (#<dl_stozka> = [[#<sr_pocz> - #<sr_koncowa>]/ 2 / #<tangens_kat> ])
	 #<sr_koncowa> = [ #<sr_pocz> + 2 *[ #<dl_stozka> * #<tangens_kat> ] ]
	o10 endif



(W teorii ujemny kąt powinien odwrocic kierunek stozka)

(stozek zewnętrzny - z uzyciem roznicy srednic, srednica moze byc tez uzalezniona od kąta)


				o99 if [#<sr_pocz> gt #<sr_koncowa>]
						#<srednica_wieksza> = #<sr_pocz>
						#<srednica_mniejsza> = #<sr_koncowa>
						
					(stozek rosnacy)
			o99 else
						#<srednica_wieksza> = #<sr_koncowa>
						#<srednica_mniejsza> = #<sr_pocz>
					
				o99 endif


o100 if [#<rodzaj> eq 0] (ZEWNETRZNY)

	

	o101 if [#<korekta> eq 0]  (ZEWNETRZNY BEZ KOREKTY)
	
						o11 if [#<stala_pr_skrawania> eq 1]
						G96 s#<pr_skrawania> D#<obroty_max>
						o11 endif
		
			( jezeli srednica koncowa mniejsza niz material to zbieram naddatek)
				
			(zaleznie od kierunku pochylenia wieksza bedzie srednica poczatkowa lub koncowa - musimy sie zabezpieczyc)
			
			
						o12 if [#<sr_materialu> gt #<srednica_wieksza>]  (STACZANIE NADDATKU MATERIAŁU)
						 
							#<akt_poz> = #<sr_materialu>
							#<x_koniec> = #<srednica_wieksza>
							
							o200 while [#<akt_poz> gt #<x_koniec>]
									#<akt_poz> = [#<akt_poz> - #<dobieranie>]
									
										o201 if [#<akt_poz> lt #<x_koniec>]
											#<akt_poz> = #<x_koniec>
										o201 endif
									
							o81 if [#<sr_pocz> gt #<sr_koncowa>]				
						(przy stozku od lewej strony walu wjazd do zbierania materialu zlikwidujemy zeby nie ryc w materiale)			
								g0 z[#<z_pocz>]
								g0 x#<akt_poz>
								g1 z[#<z_pocz> - #<dl_stozka>] F#<posuw>
								g1 x[#<akt_poz> + 2] F#<posuw>
								g0 z[#<z_pocz>]
							o81 else				
								g0 z[#<z_pocz> + 1]
								g0 x#<akt_poz>
								g1 z[#<z_pocz> - #<dl_stozka>] F#<posuw>
								g1 x[#<akt_poz> + 2] F#<posuw>
								g0 z[#<z_pocz> + 1]
							o81 endif
				
								
								
							o200 endwhile
				
						o12 endif

			#<x_start> = #<srednica_wieksza>
		
			g0 x[#<srednica_wieksza> + 2]
			g0 z[#<z_pocz> + 1]	
				
					
			o105  if [#<sr_pocz> gt #<sr_koncowa>]   (SREDNICA PRAWA > LEWA)
					
					o202 while [#<x_start> gt #<srednica_mniejsza>]
									#<x_start> = [#<x_start> - #<dobieranie>]
									
										(o203 if [#<x_start> lt #<srednica_mniejsza>])
										(	#<x_start> = #<srednica_mniejsza>)
										(o203 endif)
					
  (jesli ostatnie dobranie wychodzi mniejsze niz zadana grubosc ostatniej warstwy wtedy skroc poprzednie dobranie)
  					
						  o203 if [#<x_start>  eq [#<srednica_mniejsza> + #<ostatnia_warstwa> - #<dobieranie>]]
								#<x_start> = #<srednica_mniejsza>
    
							o203 elseif [#<x_start>  lt [#<srednica_mniejsza>+#<ostatnia_warstwa>] ]
								#<x_start>  = [#<srednica_mniejsza> + #<ostatnia_warstwa>]
							o203 endif
					
					
					
					g0 z[ [#<z_pocz> - #<dl_stozka>] + [[#<srednica_wieksza> - #<x_start>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ]
					
					g1 x#<srednica_wieksza> F#<posuw>
					g1 x#<x_start> z[#<z_pocz> - #<dl_stozka>] F#<posuw>
					g0 x[#<srednica_wieksza> + 2]
					
					o202 endwhile
					
					
			o105 endif
			
			o106 if [#<sr_koncowa> gt #<sr_pocz>]  (SREDNICA PRAWA < LEWA)
			
					o204 while [#<x_start> gt #<srednica_mniejsza>]
									#<x_start> = [#<x_start> - #<dobieranie>]
									
										(o209 if [#<x_start> lt #<srednica_mniejsza>])
										(	#<x_start> = #<srednica_mniejsza>)
										(o209 endif)

  (jesli ostatnie dobranie wychodzi mniejsze niz zadana grubosc ostatniej warstwy wtedy skroc poprzednie dobranie)
					
							o209 if [#<x_start>  eq [#<srednica_mniejsza> + #<ostatnia_warstwa> - #<dobieranie>]]
								#<x_start> = #<srednica_mniejsza>
    
							o209 elseif [#<x_start>  lt [#<srednica_mniejsza>+#<ostatnia_warstwa>] ]
								#<x_start>  = [#<srednica_mniejsza> + #<ostatnia_warstwa>]
							o209 endif
					
					g0 z[#<z_pocz> + 1]
					g0 x#<x_start>
					g1 z#<z_pocz> F#<posuw>
					g1 x#<srednica_wieksza> z[ #<z_pocz> - [[#<srednica_wieksza> - #<x_start>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ]
					g0 x[#<srednica_wieksza> + 2]
					
					(g0 z[ #<z_pocz> - [[#<srednica_wieksza> - #<x_start>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ])
					
					(g1 x#<srednica_wieksza> F#<posuw>)
					(g1 x#<x_start> z#<z_pocz> F#<posuw>)
					(g0 x[#<srednica_wieksza> + 2])
					
					o204 endwhile
			
			o106 endif	
					

	o101 else  (ZEWNETRZNY Z KOREKTĄ)
	
		(---------- korekta ----------)
			#<srednica_mniejsza> = [#<srednica_mniejsza> - #<wielkosc_korekty>]
			#<x_start> = #<srednica_mniejsza>
			
			
			
					o13 if [#<stala_pr_skrawania> eq 1]
					G96 s#<pr_skrawania> D#<obroty_max>
					o13 endif
			
				g0 x[#<srednica_wieksza> + 2]
				g0 z[#<z_pocz> + 1]	
			
			
					o107  if [#<sr_pocz> gt #<sr_koncowa>]
							
					g0 z[ [#<z_pocz> - #<dl_stozka>] + [[#<srednica_wieksza> - #<x_start>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ]
				
					g1 x[#<srednica_wieksza> - #<wielkosc_korekty>] F#<posuw>
					g1 x#<srednica_mniejsza> z[#<z_pocz> - #<dl_stozka>] F#<posuw>
					g0 x[#<srednica_wieksza> + 2]
					
					o107 endif
			
	
	
					o108 if [#<sr_koncowa> gt #<sr_pocz>]
					
					g0 z[#<z_pocz> + 2]
					g0 x#<srednica_mniejsza>
					g1 z#<z_pocz> F#<posuw>
					g1 x[#<srednica_wieksza> - #<wielkosc_korekty>] z[#<z_pocz> - #<dl_stozka>]
					
					
					(g1 x[#<srednica_wieksza>] z[ #<z_pocz> - [[#<srednica_wieksza> - #<x_start> + #<wielkosc_korekty>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ] )
					g0 x[#<srednica_wieksza> + 2]
					
					(g0 z[ #<z_pocz> - [[#<srednica_wieksza> - #<x_start> + #<wielkosc_korekty>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ])
					
					(g1 x[#<srednica_wieksza>] F#<posuw>)
					(g1 x#<srednica_mniejsza> z#<z_pocz> F#<posuw>)
					(g0 x[#<srednica_wieksza> + 2])
					
					o108 endif	
					
				
		
	o101 endif
		
o100 else  (WEWNETRZNY)

(wewnetrzny)

(stozek malejacy)
	

	o201 if [#<korekta> eq 0]  (WEWNETRZNY BEZ KOREKTY)
	
						o111 if [#<stala_pr_skrawania> eq 1]
						G96 s#<pr_skrawania> D#<obroty_max>
						o111 endif
		
			( jezeli srednica koncowa wieksza niz otwor to zbieram naddatek)
				
			(zaleznie od kierunku pochylenia wieksza bedzie srednica poczatkowa lub koncowa - musimy sie zabezpieczyc)
			
			
			
						o112 if [#<sr_materialu> lt #<srednica_mniejsza>]  (ZBIERANIE NADDATKU MATERIAŁU)
						 
							#<akt_poz> = #<sr_materialu>
							#<x_koniec> = #<srednica_mniejsza>
							
							o300 while [#<akt_poz> lt #<x_koniec>]
									#<akt_poz> = [#<akt_poz> + #<dobieranie>]
									
										o301 if [#<akt_poz> gt #<x_koniec>]
											#<akt_poz> = #<x_koniec>
										o301 endif
									
									
									
								g0 z[#<z_pocz> + 1]
								g0 x#<akt_poz>
								g1 z[#<z_pocz> - #<dl_stozka>] F#<posuw>
								g1 x[#<akt_poz> - 2] F#<posuw>
								g0 z[#<z_pocz> + 1]
								
							o300 endwhile
			
				
						o112 endif



			#<x_start> = #<srednica_mniejsza>
		
			g0 x[#<srednica_mniejsza> - 2]
			g0 z[#<z_pocz> + 1]	
				
					
			o205  if [#<sr_koncowa> gt #<sr_pocz>]  (SREDNICA PRAWA < LEWA)
			

					o210 while [#<x_start> lt #<srednica_wieksza>]
									#<x_start> = [#<x_start> + #<dobieranie>]
									
									(	o211 if [#<x_start> gt #<srednica_wieksza>])
									(		#<x_start> = #<srednica_wieksza>)
									(	o211 endif)
					
 (jesli ostatnie dobranie wychodzi mniejsze niz zadana grubosc ostatniej warstwy wtedy skroc poprzednie dobranie)
											
					
						o211 if [#<x_start> eq [#<srednica_wieksza> - #<ostatnia_warstwa> + #<dobieranie>]]
							#<x_start> = #<srednica_wieksza>
    
						o211 elseif [#<x_start>  gt [#<srednica_wieksza>-#<ostatnia_warstwa>] ]
							#<x_start> = [#<srednica_wieksza> - #<ostatnia_warstwa>]
						o211 endif
					
					
					
					
					g0 z[ [#<z_pocz> - #<dl_stozka>] + [[#<x_start>-#<srednica_mniejsza>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ]
					
					g1 x#<srednica_mniejsza> F#<posuw>
					
					g1 x#<x_start> z[#<z_pocz> - #<dl_stozka>] F#<posuw>
					g0 x[#<srednica_mniejsza> - 2]
					
					o210 endwhile
									
					
					
					
							
					
			o205 endif
			
			o206 if [#<sr_pocz> gt #<sr_koncowa>]  (SREDNICA PRAWA > LEWA)
			
			
			
					o304 while [#<x_start> lt #<srednica_wieksza>]
									#<x_start> = [#<x_start> + #<dobieranie>]
									
										(o302 if [#<x_start> gt #<srednica_wieksza>])
										(	#<x_start> = #<srednica_wieksza>)
										(o302 endif)
										
(jesli ostatnie dobranie wychodzi mniejsze niz zadana grubosc ostatniej warstwy wtedy skroc poprzednie dobranie)
											
					
						o302 if [#<x_start> eq [#<srednica_wieksza> - #<ostatnia_warstwa> + #<dobieranie>]]
							#<x_start> = #<srednica_wieksza>
    
						o302 elseif [#<x_start>  gt [#<srednica_wieksza>-#<ostatnia_warstwa>] ]
							#<x_start> = [#<srednica_wieksza> - #<ostatnia_warstwa>]
						o302 endif					
					
					
					g0 z[#<z_pocz> + 1]
					g0 x#<x_start>
					
					
					g1 z#<z_pocz> F#<posuw>
					
					g1 x#<srednica_mniejsza> z[[#<z_pocz> - #<dl_stozka>] + [[#<srednica_wieksza> - #<x_start>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ]
				
					
					g0 x[#<srednica_mniejsza> - 2]
					
					
					o304 endwhile
			
		
			
			o206 endif	
					

	o201 else   (WEWNETRZNY Z KOREKTĄ)
	
		(---------- korekta ----------)
			#<srednica_mniejsza> = [#<srednica_mniejsza> - #<wielkosc_korekty>]
			#<x_start> = #<srednica_mniejsza>
			
			
					o113 if [#<stala_pr_skrawania> eq 1]
					G96 s#<pr_skrawania> D#<obroty_max>
					o113 endif
			
				g0 x[#<srednica_mniejsza> - 2]
			
				g0 z[#<z_pocz> + 2]	
			
		
					o207  if [#<sr_pocz> gt #<sr_koncowa>]
					
					g0 x[#<srednica_wieksza> + #<wielkosc_korekty>] 	
					g1 z[ [#<z_pocz> - #<dl_stozka>] + [[#<srednica_wieksza> - #<x_start>] * #<dl_stozka> / [#<srednica_wieksza> - #<srednica_mniejsza>]] ] F#<posuw>
				
					
					g1 x[#<srednica_mniejsza> + 2*#<wielkosc_korekty>] z[#<z_pocz> - #<dl_stozka>] F#<posuw>
					g0 x[#<srednica_mniejsza> - 2]
					
					o207 endif
			
	
	
					o208 if [#<sr_koncowa> gt #<sr_pocz>]
					
					(---------- przystozku wewnetrznym nie da sie dojechac nozem i wytoczyc stozka rosnacego w lewo -----------)
										
						(------opcja tymczasowo wyłączona----)
						
						(msg, stożek rosnący wewnetrzny, nie wjedziesz nożem)
					
						
					
					g0 z[#<z_pocz> + 2]
					g0 x#<srednica_mniejsza>
					g1 z#<z_pocz> F#<posuw>
					g1 x[#<srednica_wieksza> - #<wielkosc_korekty>] z[#<z_pocz> - #<dl_stozka>]
					
					
					
					o208 endif	
					
				
		
	o201 endif


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

o<stozek2> endsub 

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 

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

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

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-----)

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 

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

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