Pisanie G-code pod LinuxCNC

MlKl · Post napisał: **MlKl** » 16 sty 2012, 10:54

Da się zrobić

Zanixi · Post napisał: **Zanixi** » 13 kwie 2012, 01:17

A ja mam pytanko

Wszystko ładnie, pięknie, napisałem sobie kod, na dosyć skomplikowany detal, tylko teraz potrzeba mi poustawiać off-sety dla różnych narzędzi (wytaczaka, przecinaka, zwyklego do toczenia, do rowków zewnętrznych, wewnętrznych) i nie wiem za co łapać

Pierwsze co chciałbym się dowiedzieć, to czy da się tu jakoś ustawić, by emc mi widział, że mój nóż to przecinak o np szerokości 3mm.

Dwa to te off sety nieszczęsne dla tych narzędzi, fajnie by było nie ustawiać każdego od nowa co rusz. Pewnie się tak da, i to jest proste, łatwe i przyjemne, ale ja nie mogę znaleźć

MlKl · Post napisał: **MlKl** » 13 kwie 2012, 09:15

A te narzędzia to jak montujesz do tokarki? Pojedynczo? Na zwykłym imaku? Ogólnie do tego celu używa się tabeli narzędzi, ino musi być jakiś ich magazyn, albo musi być możliwość ich bardzo powtarzalnego montowania.

tuxcnc · Post napisał: **tuxcnc** » 13 kwie 2012, 17:23

Zanixi pisze:Pierwsze co chciałbym się dowiedzieć, to czy da się tu jakoś ustawić, by emc mi widział, że mój nóż to przecinak o np szerokości 3mm.

Nie da się i to z powodów zasadniczych.
G-kod to opis ścieżki narzędzia a nie jego kształtu.

.

Zanixi · Post napisał: **Zanixi** » 13 kwie 2012, 23:56

A imakiem szybkozmiennym.

Ale na razie to mam inny problem, ten nieszczęsny max jitter wychodzi taki, że aż głowa boli, trochę myszką poruszać, w okienku pokazuje się z 80000, raz doszło do 5milionów

Da się coś z tym zrobić?

1GB ramu
Radeon 9000pro
AMD Athlon 2600+
bios jakiś phoenix.. Próbowałem tu znaleźć coś, co się da wyłączyć, ale bez skutku.

MlKl · Post napisał: **MlKl** » 14 kwie 2012, 00:55

To se możesz spokojnie pisać procedurki pod pomierzone narzędzia. I nie ma żadnych przeciwwskazań, by w procedurze, obojętne, czy pisanej z palca w pliku .ngc, czy tworzonej Pythonem, albo NGCGUI, wstawić sobie zmienną, w której będziesz wpisywał szerokość noża.

Akurat sobie taką procedurkę piszę, to będzie mocno rozbudowana procedura czop.ngc, którą już tutaj zamieszczałem.

W jednej procedurze będzie: planowanie czoła walca o zadaną długość, planowanie powierzchni walca na zadanej długości i na zadaną średnicę, toczenie na końcu owego splanowanego odcinka czopa, fazowanie czopa, fazowanie pełnej średnicy za czopem (ale już splanowanej w drugiej operacji, zataczanie podcięcia na styku czopa i pełnej średnicy na zadaną głębokość i szerokość, fazka na tym podcięciu w stronę czopa, i odcięcie gotowego elementu - również ze zfazowaniem krawędzi.

Akurat takich elementów robię najwięcej, i nie będę ich składał za każdym razem w pięciu kolejnych okienkach NGCGUI.

Na jitter to chyba najlepiej zmienić kompa - ja przeleciałem kilka, teraz mam takiego, co ma w teście 14000, w ustawieniach wpisałem mu 18000 i śmiga.

Kod: Zaznacz cały

( ------------------------------ ) 
( czop ) 
( ------------------------------ ) 
( Z. Maciej Miki Bajkowski) 
(---na podstawie kodu Kamara-----) 
( Time-stamp: <2012-04-14 00:39> ) 

(info: Czop ) 

o<czop> sub

( ------------------------------ ) 
( Zmienne do tabelki ) 
( ------------------------------ ) 

(wszystkie wartosci w milimetrach) 

#<srednica_walka> = #1 (=22 Średnica początkowa wałka) 
#<srednica_czopu> = #2 (=19 Średnica czopu) 
#<dlugosc_czopu> = #3 (=10 Długość czopu) 
#<glebokosc_fazki_czopu> = #4 (=0.5 Głębokość fazki czopu) 
#<szerokosc_fazki_czopu> = #5 (=0.5 Szerokość fazki czopu, zero wyłącza) 
#<glebokosc_fazki_walka> = #6 (=0.5 Głebokość fazki wałka) 
#<szerokosc_fazki_walka> = #7 (=0.5 Szerokość fazki wałka, zero wyłącza) 
#<przybranie_materialu> = #8 (=0.5  Przybranie) 
#<planowanie_czola> =#9 (=1 Planowanie, zero wyłącza) 
#<glebokosc_podciecia> =#10 (=0 Głębokość podciecia za gwintem) 
#<szerokoszc_podciecia>=#11 (=0 Szerokośc podcięcia za gwintem) 
#<szerokość_noza> =#12 (=2.5 Szerokość noża) 
#<poczatek_z>=#13 (=0 Początek na osi Z) 
#<szybkosc_posuwu> = #14 (=10 Posuw)       
#<obroty_wrzeciona> = #15 (=1000 Obroty) 

(koniec zmiennych) 


#<baza_x> = [#<srednica_walka> + 2]   (tu zjedzie w osi x noz po pracy, ustawic tyle, by mozna swobodnie zmierzyc, czy wyjac material) 
#<srednica_walka_do_fazki> = #<srednica_walka> (zmienna #<srednica_walka> zmniejsza sie w trakcie wykonywania programu, zapamietuje ja wiec w zmiennej do pozniejszego fazowania) 

(Planowanie czoła) 


M3 s#<obroty_wrzeciona> (wlaczamy wrzeciono) 


g0 z[#<poczatek_z> + 0.5] 
g0 x[#<srednica_walka> + 0.5] 
#<akt_pozycja> = #<poczatek_z> 

o50 while [#<akt_pozycja> gt -[#<planowanie_czola>]] 
  #<akt_pozycja> = [#<akt_pozycja> - #<przybranie_materialu>] 
  o52 if [#<akt_pozycja> lt -[#<planowanie_czola>]] 
    #<akt_pozycja> = -[#<planowanie_czola>] 
  o52 endif

  g0 z#<akt_pozycja> 

  g1 x0 f#<szybkosc_posuwu> 
  g0 z[#<akt_pozycja> + 0.5] 
  g0 x[#<srednica_walka> + 0.5] 

o50 endwhile


(Koniec planowania czoła) 

(Toczenie czopa) 

G0 z[0.5-[#<planowanie_czola>]] 

o100 while [#<srednica_walka> gt #<srednica_czopu>] ( wykonuj dopoki #<srednica_walka> wiekszy od #<srednica_czopu> ) 
#<srednica_walka>=[#<srednica_walka>-#<przybranie_materialu>] ( deklarowane zmniejszenie) 
 o102 if [#<srednica_walka> lt #<srednica_czopu>] 
    #<srednica_walka> = #<srednica_czopu> 
  o102 endif

G0 x#<srednica_walka> (ustawienie noza na pozycji ) 
z-[#<planowanie_czola>] 
g1 z[[-#<dlugosc_czopu>]-[#<planowanie_czola>]] f#<szybkosc_posuwu> ( toczenie ) 
G0 x[#<srednica_walka>+1] ( odjazd od materialu) 
z[0.5-[#<planowanie_czola>]] ( powrot na poczatek i wykonywanie ponowne ) 
o100 endwhile ( koniec toczenia czopa) 

o110 if [#<szerokosc_fazki_czopu> gt 0] (procedura wykonania fazki na wytoczonym czopie, wykonywana tylko, gdy zadeklarowana szerokość fazki jest większa od zera)       
    
x[#<srednica_czopu>-#<glebokosc_fazki_czopu>]             ( wjazd do fazki na fi #<srednica_czopu>) 
z[[#<poczatek_z>]-[#<planowanie_czola>]] 
g1 x[#<srednica_czopu>] z-[[#<szerokosc_fazki_czopu>]+[#<planowanie_czola>]]    ( toczenie fazki na fi #<srednica_czopu>) 
g0 x[[#<srednica_czopu>]+0.5] 
o110 endif (koniec procedury fazowania krawędzi czopa) 


o120 if [#<szerokosc_fazki_walka> gt 0]  (procedura wykonania fazki na pozostałej krawędzi wałka, wykonywana tylko, gdy zadeklarowana szerokość fazki jest większa od zera)   
    
g0 z-[[#<dlugosc_czopu>]+[#<planowanie_czola>]] x[#<srednica_walka_do_fazki> - #<glebokosc_fazki_walka>] ( dojazd do fazki na fi #<srednica_walka_do_fazki>) 
g1 x[#<srednica_walka_do_fazki>] z-[[#<dlugosc_czopu>+#<szerokosc_fazki_walka>]+[#<planowanie_czola>]] ( toczenie fazki na fi #<srednica_walka_do_fazki>) 
g0 x[[#<srednica_walka_do_fazki>]+0.5] 
o120 endif (koniec procedury fazowania pozostałej krawędzi wałka) 

G0 z0.5
x#<baza_x> (zjazd do bazy) 
M30

o<czop> endsub

Dla ciekawych - zaczęta i działająca procedura czop.ngc - na razie tylko planowanie czoła, toczenie czopa i fazowanie - napisane ciut lepiej, niż pierwsza wersja

Z grubsza rzecz biorąc, chodzi o wykonanie elementu jak na zdjęciu - Wymiary mogą się zmieniać, podcięcie może być, lub nie, podobnie gwint.

Technologicznie materiał wsadzony w uchwyt trzeba splanować po wierzchu na długości całego gotowego elementu, potem splanować (lub nie) czoło, wytoczyć czop, sfazować. Potem trzeba zrobić podcięcie, i odciąć, pewnie przydałoby się jeszcze dodać fazowanie od strony odcinanej i fazowanie podcięcia w kierunku gwintu.

Wyjdzie mocno skomplikowana tabelka do wypełnienia, ale efekt będzie widać od razu po wysłaniu, i można będzie łatwo edytować w dowolnym miejscu procedury.

edit

Procedurka się powoli rozrasta, w zasadzie powinienem ją chyba nazwać inaczej, bo z czopem ma coraz mniej wspólnego...

Przybyło planowanie powierzchni, w tabelce pojawiła się średnica surowego wałka, czyli to, cośmy fizycznie w uchwyt włożyli, i pojęcia "długość detalu" oraz "średnica detalu", użyłem również wcześniej wprowadzonej zmiennej "szerokość noża" do ustalenia długości planowania surowego wałka jako sumy długości detalu i szerokości noża - potem dodam procedurę odcinania detalu, i wtedy już nie będę się musiał troszczyć o powrót noża na średnicę powyżej surowego wałka.

Generalnie to jest proteza na ułomność interfejsu NGCGUI - w zamyśle twórców to powinno być łatwo składane z pojedynczych klocków. Niestety - na razie NGCGUI nie zapamiętuje i nie pozwala się swobodnie przemieszczać i edytować poszczególnych etapów, co czyni programowanie w nim mało użytecznym przy skomplikowanym, wieloetapowym detalu. Oczywiście to tylko moje marudzenie, bo ogólnie sama idea jest słuszna.

Kod: Zaznacz cały

( ------------------------------ ) 
( czop ) 
( ------------------------------ ) 
( Z. Maciej Miki Bajkowski) 
(---na podstawie kodu Kamara-----) 
( Time-stamp: <2012-04-14 00:39> ) 

(info: Czop ) 

o<czop> sub

( ------------------------------ ) 
( Zmienne do tabelki ) 
( ------------------------------ ) 

(wszystkie wartosci w milimetrach) 
#<srednica_surowego_walka> = #1 (=23 Średnica surowego wałka) 
#<dlugosc_detalu> = #2 (=15  Długość gotowego detalu) 
#<srednica_walka> = #3 (=22 Średnica gotowego detalu) 
#<srednica_czopu> = #4 (=19 Średnica czopu) 
#<dlugosc_czopu> = #5 (=10 Długość czopu) 
#<glebokosc_fazki_czopu> = #6 (=0.5 Głębokość fazki czopu) 
#<szerokosc_fazki_czopu> = #7 (=0.5 Szerokość fazki czopu, zero wyłącza) 
#<glebokosc_fazki_walka> = #8 (=0.5 Głebokość fazki wałka) 
#<szerokosc_fazki_walka> = #9 (=0.5 Szerokość fazki wałka, zero wyłącza) 

#<planowanie_czola> =#10 (=1 O ile mm splanować czoło, zero wyłącza) 
#<glebokosc_podciecia> =#11 (=0 Głębokość podciecia za gwintem) 
#<szerokoszc_podciecia>=#12 (=0 Szerokośc podcięcia za gwintem) 
#<szerokość_noza> =#13 (=2.5 Szerokość noża) 
#<poczatek_z>=#14 (=0 Początek na osi Z) 
#<szybkosc_posuwu> = #15 (=10 Posuw)       
#<obroty_wrzeciona> = #16 (=1000 Obroty) 
#<przybranie_materialu> = #17 (=0.5  Przybranie) 
(koniec zmiennych) 


#<baza_x> = [#<srednica_walka> + 2]   (tu zjedzie w osi x noz po pracy, ustawić tyle, by można swobodnie zmierzyć, czy wyjąć materiał) 
#<srednica_walka_do_fazki> = #<srednica_walka> (zmienna #<srednica_walka> zmniejsza się w trakcie wykonywania programu, zapamietuję ją więec w zmiennej do późniejszego fazowania) 


(Planowanie powierzchni) 

G0 X#<srednica_surowego_walka> Z#<poczatek_z> 
#<Current_Dia>=#<srednica_surowego_walka> 

o60 while [#<Current_Dia> gt #<srednica_walka>] 

o61   if [#<Current_Dia>-#<przybranie_materialu> gt #<srednica_walka>] 
         #<Current_Dia>=[#<Current_Dia>-#<przybranie_materialu>] 
o61   else
         #<Current_Dia>=#<srednica_walka> 
o61   endif

       X#<Current_Dia> 
       G1 Z-[#<dlugosc_detalu>+#<szerokość_noza>] F#<szybkosc_posuwu> 
       G0 X[#<Current_Dia>+0.5] 
       Z#<poczatek_z> 
o60 endwhile


(Koniec planowania powierzchni) 

(Planowanie czoła) 


M3 s#<obroty_wrzeciona> (wlaczamy wrzeciono) 


g0 z[#<poczatek_z> + 0.5] 
g0 x[#<srednica_walka> + 0.5] 
#<akt_pozycja> = #<poczatek_z> 

o50 while [#<akt_pozycja> gt -[#<planowanie_czola>]] 
  #<akt_pozycja> = [#<akt_pozycja> - #<przybranie_materialu>] 
  o52 if [#<akt_pozycja> lt -[#<planowanie_czola>]] 
    #<akt_pozycja> = -[#<planowanie_czola>] 
  o52 endif

  g0 z#<akt_pozycja> 

  g1 x0 f#<szybkosc_posuwu> 
  g0 z[#<akt_pozycja> + 0.5] 
  g0 x[#<srednica_walka> + 0.5] 

o50 endwhile


(Koniec planowania czoła) 


(Toczenie czopa) 

G0 z[0.5-[#<planowanie_czola>]] 

o100 while [#<srednica_walka> gt #<srednica_czopu>] ( wykonuj dopoki #<srednica_walka> wiekszy od #<srednica_czopu> ) 
#<srednica_walka>=[#<srednica_walka>-#<przybranie_materialu>] ( deklarowane zmniejszenie) 

 o102 if [#<srednica_walka> lt #<srednica_czopu>] 
    #<srednica_walka> = #<srednica_czopu> 
  o102 endif

G0 x#<srednica_walka> (ustawienie noza na pozycji ) 
z-[#<planowanie_czola>] 
g1 z[[-#<dlugosc_czopu>]-[#<planowanie_czola>]] f#<szybkosc_posuwu> ( toczenie ) 
G0 x[#<srednica_walka>+1] ( odjazd od materialu) 
z[0.5-[#<planowanie_czola>]] ( powrot na poczatek i wykonywanie ponowne ) 
o100 endwhile ( koniec toczenia czopa) 

o110 if [#<szerokosc_fazki_czopu> gt 0] (procedura wykonania fazki na wytoczonym czopie, wykonywana tylko, gdy zadeklarowana szerokość fazki jest większa od zera)       
    
x[#<srednica_czopu>-#<glebokosc_fazki_czopu>]             ( wjazd do fazki na fi #<srednica_czopu>) 
z[[#<poczatek_z>]-[#<planowanie_czola>]] 
g1 x[#<srednica_czopu>] z-[[#<szerokosc_fazki_czopu>]+[#<planowanie_czola>]]    ( toczenie fazki na fi #<srednica_czopu>) 
g0 x[[#<srednica_czopu>]+0.5] 
o110 endif (koniec procedury fazowania krawędzi czopa) 


o120 if [#<szerokosc_fazki_walka> gt 0]  (procedura wykonania fazki na pozostałej krawędzi wałka, wykonywana tylko, gdy zadeklarowana szerokość fazki jest większa od zera)   
    
g0 z-[[#<dlugosc_czopu>]+[#<planowanie_czola>]] x[#<srednica_walka_do_fazki> - #<glebokosc_fazki_walka>] ( dojazd do fazki na fi #<srednica_walka_do_fazki>) 
g1 x[#<srednica_walka_do_fazki>] z-[[#<dlugosc_czopu>+#<szerokosc_fazki_walka>]+[#<planowanie_czola>]] ( toczenie fazki na fi #<srednica_walka_do_fazki>) 
g0 x[[#<srednica_walka_do_fazki>]+0.5] 
o120 endif (koniec procedury fazowania pozostałej krawędzi wałka) 

G0 z0.5
x#<baza_x> (zjazd do bazy) 
M30

o<czop> endsub

blasterpl · Post napisał: **blasterpl** » 06 lis 2013, 08:34

MIKI pisze w swoim pierwszym poście: "oczywiście do wsadzenia w NGCGUI. Zapisujemy kod do pliku polkula.ngc, plik wsadzamy do /emc2/nc_files/examples/ngcgui_lib/lathe. W /emc2/configs/ngcgui/ngcgui_lathe.ini dodajemy linijkę:

Kod:
NGCGUI_SUBFILE = polkula.ngc "

A ja nie mogę wsadzić tego pliku do linuxcnc

bo mam zablokowana taka możliwość(symbol kłódki ma folderze),co robić

G3d · Post napisał: **G3d** » 06 lis 2013, 08:52

Widocznie musisz edytowac plik na sudo, albo poprostu jako admin.

blasterpl · Post napisał: **blasterpl** » 06 lis 2013, 09:00

Jestem zalogowany jako admin

MlKl · Post napisał: **MlKl** » 06 lis 2013, 13:37

nazwa uzytkownika może być dowolna - istotne są uprawnienia konta - w ubuntu z automatu pełne uprawnienia ma konto root. Można też nadać pełne uprawnienia dowolnemu innemu.

Ale najbezpieczniej odpalić menadżer plików przez sudo, np

Kod: Zaznacz cały

sudo thunar

i z tego poziomu pozmieniać uprawnienia do folderów i plików, które chcemy edytować ze zwykłych kont.

Pisanie G-code pod LinuxCNC

Wałek prowadzący aluminiowy drążony drylin® R AWMR-20 fi 20 - 500 mm

Czwórnik MC4 z kablem

Pisanie G-code pod LinuxCNC

Wałek prowadzący aluminiowy drążony drylin® R AWMR-20 fi 20 - 500 mm

Czwórnik MC4 z kablem

Zaloguj się • Zarejestruj się

Połącz się z kontem sieci społecznościowej