Jedna uwaga - jeżeli nie lubiliście matematyki w szkole, to pora ją zacząć lubić. Bardzo pomaga
Oczywiście - nie potrzeba, przynajmniej w znakomitej większości zadań, znajomości matematyki wyższej - wystarczy ta na poziomie szkoły podstawowej. Można maszynie zapodawać ręcznie każdy kolejny punkt, do którego ma jechać - jak na manualu. Ale to jest zdecydowanie utrudnianie sobie życia... W necie nie znalazłem żadnego samouczka, czy poradnika, jak toto uruchomić i obsługiwać. Ponieważ jeszcze mam świeżo w pamięci, to co musiałem sam odkrywać, czy wyciskać z bardziej doświadczonych kolegów - piszę ten tekst, żeby następcy mieli łatwiej. Wdzięczny będę za wszelkie uwagi, propozycje rozszerzenia tekstu, czy wytknięte błędy, które oczywiście w takim wypadku poprawię.
Jeżeli uczysz się G-codu i LinuxCNC z tego poradnika, zaglądaj do niego i sprawdzaj, co się zmieniło - wciąż przybywają kolejne partie materiału, jeżeli czegoś nie wiesz, lub nie rozumiesz, zapytaj w tym wątku - odpowiem, o ile będzie trzeba, dodam również to do tego tutoriala.
Kolejna uwaga - ten tutorial jest tworzony na bazie wersji symulacyjnej LinuxCNC. Do testowania na realnej maszynie trzeba podchodzić z dużą uwagą, bo duża elastyczność konfiguracyjna programu, i mnogość rozwiązań technicznych samych maszyn powodują, iż kod tu prawidłowo zasymulowany, na maszynie spowoduje kolizję. Ale warto zacząć od nauki na symulatorze.
Kamar jest tutejszym popularyzatorem idei przerabiania maszyn manualnych na CNC, i obsługiwania ich właśnie przy pomocy LinuxCNC. Ma w tej dziedzinie duże doświadczenie, dlatego warto wierzyć w to, co na ten temat mówi.Kamar pisze:
...Wracając do symulatora Emca. Z nudów pobawiłem się trochę tokarkowym i stwierdzam kategorycznie że powinno się na nim poćwiczyć przed podejściem do realnej maszyny.
W dwie minuty napisałem wałek wieloczopowy z byle jakim gwintowaniem na G33 i poprawionym przyzwoicie na G76. Symulator ladnie reaguje na zmiany skoku czy obrotów wrzeciona. Można dojść do perfekcji nie wstając od biurka. (jak się zna zasady obróbki
Zaczynamy naukę. Nie masz jeszcze maszyny CNC? nie szkodzi, ja też jej nie mam... W tym wątku znajdziecie informacje, jak zainstalować LinuxCNC w wersji symulacyjnej. Powiem tylko, że da się to zrobić bez problemu na każdym współczesnym komputerze, który ma ok 5 gigabajtów wolnej przestrzeni dyskowej, jako jedyny system na dysku, jako drugi z możliwością wyboru przy starcie systemu, albo i bez żadnej ingerencji w istniejący system operacyjny.
LinuxCNC jest programem kompilowanym pod Linuxa, czyli swoją przygodę z LinuxCNC musisz zacząć od zaprzyjaźnienia się z tym systemem operacyjnym. LinuxCNC wymaga specjalnie skonfigurowanego jądra systemu, tzw jądro czasu rzeczywistego, określane symbolem RTAI. Twórcy LinuxCNC przygotowali taką instalkę systemu, opartą o nieco starszą stabilną wersję Ubuntu 10.04 "Lucid Lynx" oznaczoną jako LTS czyli "z przedłużonym wsparciem technicznym". Wystarczy ściągnąć ten obraz pliku, wypalić na płycie CD, i zainstalować system wraz z gotowym do pracy LinuxCNC. Płyta jest w wersji "Live", czyli można system uruchomić wprost z niej, ale lepiej zainstalować go na dysku, co pozwoli go w pełni spolonizować i aktualizować automatycznie przez internet.
Nie bój się Linuxa - jest intuicyjny, i łatwiejszy w instalacji od Windowsa. Możesz go postawić na osobnej maszynie, na komputerze, którego używasz na co dzień jako drugi system, albo na Virtualboxie - to taki program, który pozwala "zainstalować" na komputerze zupełnie inny system operacyjny jako program systemu macierzystego, i odpalić Linuxa równocześnie z podstawowym systemem - najprawdopodobniej używasz którejś z wersji WIndows. Oba systemy niczym ze sobą nie kolidują. Ja mam tak zrobione, mimo iż podstawowym systemem u mnie też jest Linux w innej wersji. Tutaj znajdziesz obrazkową instrukcję, jak zainstalować Ubuntu na maszynie realnej lub Virtualboxie.
Ok, zakładam, że już masz zainstalowany system Ubuntu z LinuxCNC na pokładzie. W belce na górze ekranu masz zakładkę "Programy", wybierasz z niej dział CNC, i sam program LinuxCNC.
Po uruchomieniu programu pojawia się okienko, w którym należy wybrać odpowiednią konfigurację programu. Jako, że jak napisałem wcześniej, nie dysponuję żadną maszynerią CNC, na razie moja zabawa ogranicza się do symulacji. Do dzieła więc
Działające symulacje znajdują się w katalogu "Sim". Szukamy nas interesującej w oknie, które pojawia się po odpaleniu LinuxCNC. Mnie interesuje symulacja tokarki, więc wybieram Lathe - jak na załączonym obrazku. Próby odpalania innych konfiguracji (spoza katalogu sim) skutkują komunikatem błędu z powodu braku komunikacji z urządzeniami na porcie LPT. Nie szkodzi - jak będziemy mieć realną maszynę, i tak będziemy musieli ją najpierw skonfigurować, i potem będziemy odpalać LinuxCNC z tym naszym configiem, przykładowe konfiguracje realnej maszyny CNC niech sobie spoczywają w pokoju. Nas interesują tylko wersje symulacyjne.
Na rysunku widzicie, jak w LinuxCNC trzeba skonfigurować tokarkę, żeby właściwie odczytywała polecenia g-codu. Tokarka używa osi X i Z, ta pierwsza, poprzeczna do osi toczenia, skonfigurowana jest tak, że ruch o pół mm po promieniu materiału na odczycie DRO widać jako milimetr zdjęty ze średnicy.
Warto przed odpaleniem symulacji trochę zmienić plik konfiguracyjny, żeby upodobnić jak najbardziej symulację do realnych warunków. Wchodzimy do katalogu /emc/configs i edytujemy plik - bodajże emc-lathe-sim.ini w stabilnej instalce, ja używam eksperymentalnego LinuxCNC 2.6 z repozytoriów, i konfiguracji z NGCGUI w pliku ngcgui-lathe.ini.
Zmieniamy tylko zakresy limitów dla osi - dla X (axis0) dajemy:
MIN_LIMIT = -100.0
MAX_LIMIT = 5.0
dla Y (axis2) :
MIN_LIMIT =-200.0
MAX_LIMIT = 5.0
Ograniczamy w ten sposób zakres ruchów suportu jak w prawdziwej niewielkiej tokarce. Nasz punkt bazowy będzie jak najbliżej konika, i z imakiem odsuniętym jak najdalej od osi toczenia. Te 5 mm na plusie w każdej z osi wynika z konieczności zachowania luzu na tzw bazowanie osi, w trakcie którego sterowniki minimalnie przesuwają suport w każdym kierunku.
Od tej chwili dysponujemy tokarką o długości toczenia 200 mm i max średnicy obrabianego przedmiotu 200 mm.
Przy ustawianiu limitów dla maszyny realnej robimy to w ten sposób, że zjeżdżamy suportem jak najbliżej konika - zachowując jednak te 5 mm luzu na bazowanie, i jak najdalej od osi toczenia - również z zachowaniem tego luzu. Warto sobie te pozycje w sposób trwały na maszynie oznaczyć. Będzie łatwiej przywrócić maszynę do użytku np po awarii zasilania. Zerujemy obie osie w tym miejscu, i jedziemy suportem przy użyciu klawisza strzałki do końca w lewo. Wartość wyświetloną w okienku DRO dla osi Z wpisujemy jako ujemny limit dla tej osi w configu, dokłądnie to samo robimy dla osi X.
Oczywiście - wtedy górna krawędź pola roboczego wyjdzie powyżej osi toczenia. Ale to żaden problem, nam chodzi nie o to, by maszyna nie wyjechała poza wirtualną oś, a jedynie o to, by nie wyjechała z ramek.
Skonfigurowana w ten sposób maszyna, jeżeli zostanie zbazowana w miejscu, które sobie oznaczyliśmy, nigdy nie wyjedzie poza granice swego zakresu. I o to w sumie chodzi
Należy pamiętać, że jest to limit dla suportu, a nie dla narzędzia. Czyli jak nasze narzędzie wystaje fizycznie poza granice, zapisane dla suportu, to LinuxCNC na to uwagi nie zwraca. Podobnie jest z granicami materiału - to my musimy myśleć, i tak programować ruch, żeby nie wjeżdżać nożem w uchwyt, albo w materiał na dojazdach.
Czerwona cienka linia na zrzucie ekranu to pole robocze. Jeżeli prawidłowo to ustawicie w realu, nie potrzeba nawet zakładać krańcówek na osiach - suport wam poza tę linię nie wyjedzie. Suport jest w miejscu bazowania w prawym dolnym rogu pola roboczego. Tam musi być zawsze, jak kończycie pracę i zamykacie program LinuxCNC. Służy do tego komenda G28, czyli polecenie zjazdu suportu w pozycję HOME na wszystkich osiach. Uchwyt tokarki, a w zasadzie punkt zbiegu jego szczęk mamy w lewym górnym rogu naszego pola roboczego - program go niestety nie wizualizuje. A fajnie by było, gdyby taka możliwość istniała, z animacją pokazującą, czy się akurat obraca, czy stoi... Ech, rozmarzyłem się
Moja przygoda z EMC zaczęła się od tego, że odpaliłem se LinuxCNC, zapuściłem symulację tokarki - i drapię się w pustostan między uszami, bo mi na ekranie tokarka graweruje ładne logo programu... Ale jak se pogrzebałem w tym, to już wkrótce się dowiedziałem, że ten typ tak ma na początku. Wszystkie dostępne konfiguracje startowe LinuxCNC używają tego samego, frezarkowego G-Codu, i to wprowadza w błąd początkującego użytkownika, który usiłuje się połapać, o co w tym chodzi. Trzeba to traktować jak okienko powitalne programu i tyle.
Można to zmienić, nakazując LinuxCNC wczytanie przy starcie dowolnego pliku .ngc. W pliku .ini wystarczy podać w sekcji [DISPLAY] coś w stylu:
Kod: Zaznacz cały
OPEN_FILE = /home/miki/emc2/moj.ngcNa razie jednak w LinuxCNC wczytamy plik z rozszerzeniem .ngc w którym wcześniej zapiszemy nasz program, jaki tokarka ma faktycznie wykonać. Tokarka to nie frezarka, która jedzie frezem wzdłuż linii rysunku - tu linia jest limitem, którego nóż nie ma prawa przekroczyć, a resztę trzeba zbierać warstwami.
Wszystkie symulacje tokarki, dostępne w katalogach po instalacji LinuxCNC są tu mało pomocne - widać, że je pisał ktoś, kto na co dzień nie ma styku z tokarką. Symulacje te pokazują tylko ostatni przebieg noża dla danego kształtu - a bardzo rzadko zdarza się wszak, byśmy coś wytoczyli jednym przebiegiem. Dlatego proponuję nie zawracać sobie głowy tymi gotowcami z LinuxCNC a zacząć naukę od kodów, które niżej zapodaję.
Kod: Zaznacz cały
( ------------------------------ )
( start )
( ------------------------------ )
( Miki )
( Time-stamp: <2012-01-06 20:39> )
(odpalamy LinuxCNC, startuje ze znanym nam logiem, grawerowanym przez tokarkę)
(możemy na nim zbazować nasze osie, albo wczytać ten plik i dopiero bazować)
(obserwując jak osie się bazują, i nóż zjeżdża w pozycję oczekiwania)
G0 z-200 f2000 (start posuwu szybkiego, odjazd w osi Z do połowy)
x-100 (odjazd w osi X do osi toczenia)
z0 x0 (szybki przejazd po skosie do bazy)
x-100 (i droga do tego samego miejsca z powrotem)
z-200 (ale w innej kolejności osi)
M30 (zatrzymanie maszyny)
Kod: Zaznacz cały
G0 z-100 f2000
x-100
z0 x0
x-100
z-100
M30
Kod: Zaznacz cały
(to jest komentarz (nie zwracaj na niego uwagi)) Komentarze są wygodne - i warto je pisać. Jak się wam namnoży procedurek na różne operacje, trudno po paru miesiącach, czy latach domyślić się, o co nam kiedyś chodziło. A jedną z zalet pracy na CNC jest możliwość wykonania raz zaprogramowanej operacji w dowolnym momencie, dowolną ilość razy. Jednak takie operacje czasem przychodzi modyfikować - i wtedy komentarze się przydają.
Inną metodą na wpisanie komentarza w kod jest użycie średnika ";" - tekst po średniku aż do końca linii jest również traktowany jako komentarz.
Zrzut pokazuje plik start.ngc
Nie ma go oczywiście w tym katalogu po instalacji - czyli - kopiujemy kod z okienka powyżej, zapisujemy go do pliku nazwanego start.ngc Plik ten wczytujemy, klikając ikonkę "Otwórz plik G-codu" z menu LinuxCNC, lub po prostu wciskając klawisz "O" i wczytujemy do swojego LinuxCNC.
Otwiera się nam katalog nc_files w którym domyślnie zapisują się pliki konfiguracyjne - można to jednak zmienić bez problemu. Wybieramy interesujący nas plik, i zatwierdzamy klkając "Wczytaj".
Następnie odbezpieczamy maszynę, klikając przełącznik awaryjny (pierwsza ikonka od lewej), lub po prostu wciskając klawisz "F1". Następna ikonka, albo klawisz "F2" włączają zasilanie maszyny. Od tej pory możemy na niej pracować. Uaktywniają się operacje w okienku "Ręczna kontrola". Żeby zacząć pracę należy wykonać bazowanie wszystkich osi. Naciskamy więc przycisk "Bazuj wszystkie", czekamy, aż nasz wirtualny nóż ustawi się w bazie, i klikamy ikonkę "Rozpocznij wykonywanie bieżącego pliku", lub naciskamy klawisz "R". Na ekranie zobaczymy, jak nóż jedzie tam, gdzie go chcemy mieć.
Nóż sobie pojeździł, mogliście obserwować, jak podążał po ekranie, widząc jednocześnie w oknie kodu w dole, jaką komendę aktualnie wykonuje. Zwróćcie uwagę, gdzie znajdują się kolorowe kreski, obrazujące punkt zero obu osi. W przypadku tokarki oznacza to ni mniej, ni więcej, jak to, że w tej chwili program uważa, że w uchwyt zapięliśmy materiał o wielkości pola roboczego x2 ( pole robocze obejmuje pół średnicy materiału). Dodatkowo - na tokarce w osi Z standardowo toczymy w kierunku od zera do ustawionego ujemnego limitu. Dlatego po przekonfigurowaniu naszej tokarki w sposób wyżej opisany, nie da się odpalić symulacji toczenia/grawerowania logo programu. Wygenerowany dla frezarki kod wychodzi poza pole robocze naszej maszyny.
Zapytacie, zaraz zaraz, to zawsze każdą operację musimy zaczynać i obliczać od tego najdalszego od uchwytu miejsca? Otóż nie. Do tego, by zaczynać dowolną operację w tym miejscu, gdzie chcemy, służą offsety.
Mamy nóż w pozycji pośrodku pola roboczego, i przy osi. Co zrobić, żeby z tego miejsca zacząć jakąś operację? Np roztaczanie otworu fi 10 na fi 20 w wałku, wystającym z uchwytu na 10 cm? Wiem, że tak się nie robi, ale może tam jest podtrzymka? Może wałek ma średnicę dziesięć cm i większą, i jest wystarczająco sztywny. LinuxCNC tym się zupełnie nie przejmuje, takimi detalami musimy się zajmować sami.
Wracamy zatem do efektów wykonania naszego pierwszego programu. Nóż mamy przy osi toczenia w połowie pola roboczego. W okienku "Ręczna kontrola" klikamy "Ustaw Offset", i zatwierdzamy automatycznie pojawiające się w wyskakującym okienku zero. Zmieniamy przyciskiem "Radio" aktywną oś, i to samo robimy dla drugiej.
Widzimy, że strzałki osi, dotąd widoczne w okolicy punktu bazowego, przeniosły się w miejsce, gdzie sobie zzerowaliśmy osie. LinuxCNC to sobie zapamiętał, i od tego miejsca będzie zaczynał każdą kolejną operację cyklu roboczego, jaką mu zlecimy. Możecie zamknąć LinuxCNC i ponownie otworzyć. Zwróćcie uwagę, gdzie pojawiło się logo programu, które ten usiłuje co odpalenie wytoczyć
Zwróćcie również uwagę, że choć LinuxCNC pamięta, gdzie ma zaczynać, to nijak nie pamięta, gdzie zostawił nóż. Bo po odpaleniu LinuxCNC nóż widnieje sobie radośnie w miejscu bazowym obu osi, a nie tam, gdzie go pozostawiliśmy. Dlatego obowiązkowo trzeba zjeżdżać do bazy nożem na zakończenie pracy przed wyłączeniem LinuxCNC.
Na tokarce sterowanej z LinuxCNC możemy pracować również jak na manualnej. Możemy pracować tokarką, jeżdżąc strzałkami klawiatury, parametry jazdy zmienia się określonymi klawiszami: C - jazda ciągła, U oraz I zmiana skokowa ( można ustawić np 1mm i 0,1 mm), klawiszami numerycznymi wybierasz prędkość G0 ( fabrycznie od 10% do 100% np "1"-10% ;" 4"-40%). Można pod pierwsze trzy klawisze numeryczne podstawić np 1%; 2% ; i 3 %. Daje to możliwość przetoczenia bez G1 trzymając strzałkę. Magik joysticka może się nawet pokusić o ręczne rzeźbienie w toczonym materiale
Gdy mamy do dyspozycji trzecią oś, manewrujemy nią klawiszami "Page Up" i "Page Down".
Kamar w jednym z wątków wrzucił kod do toczenia czopa na wałku. To często wykonywana operacja, a sam kod był tak czytelnie napisany i skomentowany, że był idealną podstawą do nauki programowania w G-code. W dalszej części tutoriala znajdziecie wyjaśnienie do czego która komenda g-codu służy. Na razie popatrzmy na kod Kamara:
Kod: Zaznacz cały
G0 z0.5 x61 ( dojazd w pobliże materiału)
M3 s1 ( włączenie obrotów)
#1=60
o100 while [#1 gt 40] ( wykonuj dopóki #1 większy od 40 )
#1=[#1-4] ( deklarowane zmniejszenie)
G0 x#1 (ustawienie noża na pozycji )
g1 z-80 f100 ( toczenie )
G0 x[#1+1] ( odjazd od materiału)
z0.5 ( powrót na początek i wykonywanie ponowne )
o100 endwhile ( koniec toczenia )
G0 z0.5
x36 ( wjazd do fazki na Fi 40)
g1 x40.5 z-2 ( toczenie fazki na fi 40)
g0 z-79.5 x56 ( dojazd do fazki na fi 60)
g1 x60.5 z-82 ( toczenie fazki na fi 60)
g0 z1 x100 ( odjazd po wykonaniu)
M30
%
[/center]Na fotce widać, co chcemy wytoczyć. Z surowego wałka o danej średnicy staczamy na danej długości materiał do średnicy czopa, krawędzie toczenia fazujemy, albo nie. Pobawiłem się kodem Kamara i tak powstało to, co widać poniżej:
Kod: Zaznacz cały
( ------------------------------ )
( czop )
( ------------------------------ )
( Miki )
(na podstawie kodu Kamara)
( Time-stamp: <2012-01-06 08:39> )
( ------------------------------ )
( USTAWIENIA )
( ------------------------------ )
(wszystkie wartosci w milimetrach)
#<srednica_walka> = 45
#<srednica_czopu>= 35
#<dlugosc_czopu> = 50
#<glebokosc_fazki_czopu> = 0.5
#<szerokosc_fazki_czopu> = 0.5 (ustawienie zerowej szerokosci wylacza wykonywanie fazki)
#<glebokosc_fazki_walka> = 0.5
#<szerokosc_fazki_walka> = 0.5 (ustawienie zerowej szerokosci wylacza wykonywanie fazki)
#<przybranie_materialu> = 5 (tyle zbieramy ze srednicy na jeden raz, roznica srednic musi byc przez to podzielna)
#<baza_x> = [#<srednica_walka> + 20] (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)
#<szybkosc_posuwu> = 100 (Szybkosc posuwu w trakcie toczenia)
#<obroty_wrzeciona> = 1000
(koniec ustawien)
G0 z0.5 x#<baza_x> (Gdzie by noz nie był, zjeżdżamy do bazy w osi x - odpowiednio daleko od materiału, w osi z pol mm od jego poczatku)
M3 s#<obroty_wrzeciona> (wlaczamy wrzeciono)
o100 while [#<srednica_walka> gt #<srednica_czopu>] ( wykonuj dopoki #<srednica_walka> wiekszy od #<srednica_czopu> )
#<srednica_walka>=[#<srednica_walka>-#<przybranie_materialu>] ( deklarowane zmniejszenie)
G0 x#<srednica_walka> (ustawienie noza na pozycji )
g1 z-#<dlugosc_czopu> f#<szybkosc_posuwu> ( toczenie )
G0 x[#<srednica_walka>+1] ( odjazd od materialu)
z0.5 ( powrot na poczatek i wykonywanie ponowne )
o100 endwhile ( koniec toczenia )
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>)
g1 x[#<srednica_czopu>+0.5] z-[#<szerokosc_fazki_czopu>] ( toczenie fazki na fi #<srednica_czopu>)
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>-0.5] x[#<srednica_walka_do_fazki> - #<glebokosc_fazki_walka>] ( dojazd do fazki na fi #<srednica_walka_do_fazki>)
g1 x[#<srednica_walka_do_fazki>+0.5] z-[#<dlugosc_czopu>+#<szerokosc_fazki_walka>] ( toczenie fazki na fi #<srednica_walka_do_fazki>)
o120 endif (koniec procedury fazowania pozostałej krawędzi wałka)
G0 z0.5
x#<baza_x> (zjazd do bazy)
M30
%
Jak widać, z kodu Kamara wywaliłem wszystkie parametry do deklarowanych na początku zmiennych. Zmienną w G-codzie deklaruje się przez nadanie jej wartości, nazwa jej się zawsze zaczyna od krzyżyka #.
Zmienna może się nazywać #1, #2, ale to jest niewygodne, bo czytając kod po paru dniach ciężko zgadnąć, o co autorowi chodziło. Dlatego lepiej używać zmiennych opisowych. Taki opis nie może zawierać spacji ani myślników - tylko litery bez polskich znaków diaktrycznych i podkreślniki. Opis zmiennej wstawiamy zawsze w nawiasie trójkątnym. Czyli wygląda to tak: #<nazwa_naszej_zmiennej>. W tej chwili jest pusta - nie nadaliśmy jej jeszcze wartości.
A więc nadajmy:
#<nazwa_naszej_zmiennej> = 20
Od tej pory możemy w dowolnej ilości miejsc naszego programu wpisać tę nazwę, program jej wszędzie nada wartość 20. Po co to robimy? A jak nam jutro zajdzie potrzeba nadać tej zmiennej wartość 10? Po prostu zmieniamy zadeklarowaną wartość zmiennej:
#<nazwa_naszej_zmiennej> = 10
i od tej pory nasz program wszędzie jej taką wartość nadaje. Żeby było milej - możemy edytować wczytany aktualnie do LinuxCNC plik, i przez kliknięcie przycisku "Odśwież" program nam od razu wczyta nowe wartości.
Jeżeli chcemy w programie operować na wartościach zmiennych, musimy używać nawiasów kwadratowych, żeby o tym poinformować interpreter.
Czyli: Chcemy powiększyć naszą zmienną o jeden:
Kod: Zaznacz cały
#<nazwa_naszej_zmiennej> = 10
#<nazwa_naszej_zmiennej> =[ #<nazwa_naszej_zmiennej> +1]
Kod: Zaznacz cały
#<nazwa_naszej_zmiennej> =[[ #<nazwa_naszej_zmiennej>]+[ #<nazwa_naszej_zmiennej>]]
Co robi ten program? Ten program wykonuje operację bardzo często spotykaną w toczeniu - zatacza koniec wałka, którego średnicę podajemy, zmniejszając jego średnicę na zadanej długości do również podanej w zadanych na początku zmiennych. Robi to warstwami, których grubość również deklarujemy, z szybkością posuwu - też ustawianą w parametrach.
Zapytacie - a gdzie te warstwy, napisałeś tylko jedną linijkę z kodem G1? Słuszne pytanie. Byłoby głupotą, gdyby trzeba było każdą warstwę do stoczenia zapisywać ręcznie w osobnym poleceniu. Dlatego dla takich operacji stosujemy pętlę. Informujemy zatem EMC, że za chwilę wprowadzimy procedurę pętli (lub warunku, ale o tem potem), czyli piszemy o[xxx] Iksy to unikalny w skali danego kodu numer procedury. Procedurę możemy również nazwać tak, jak to czynimy ze zmiennymi - czyli np "o#<petla_wykonujaca_toczenie_warstwami>".
Kod: Zaznacz cały
o100 while [#<srednica_walka> gt #<srednica_czopu>] ( wykonuj dopoki #<srednica_walka> wiekszy od #<srednica_czopu> )
#<srednica_walka>=[#<srednica_walka>-#<przybranie_materialu>] ( deklarowane zmniejszenie)
G0 x#<srednica_walka> (ustawienie noza na pozycji )
g1 z-#<dlugosc_czopu> f#<szybkosc_posuwu> ( toczenie )
G0 x[#<srednica_walka>+1] ( odjazd od materialu)
z0.5 ( powrot na poczatek i wykonywanie ponowne )
o100 endwhile ( koniec toczenia )
słowo "gt" jest operatorem logicznym - oznacza: "jest większe lub równe" od wartości podanej za nim. Jeżeli chcemy sprawdzać czy wartość podana jako pierwsza jest mniejsza lub równa wartości drugiej, używamy słowa "lt". Jest jeszcze operator oznaczający, że wartości mają być równe sobie - używany głównie w instrukcjach typu "if". Są to dwa następujące po sobie znaki równości "==".
Kod: Zaznacz cały
#<srednica_walka>=[#<srednica_walka>-#<przybranie_materialu>] ( deklarowane zmniejszenie)Kod: Zaznacz cały
o100 endwhile ( koniec toczenia )Kod: Zaznacz cały
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>)
g1 x[#<srednica_czopu>+0.5] z-[#<szerokosc_fazki_czopu>] ( toczenie fazki na fi #<srednica_czopu>)
o110 endif (koniec procedury fazowania krawędzi czopa)
Jeżeli podamy wysokość i szerokość fazki na którejś ze średnic, program nam tę fazkę również wykona. Założyłem, że ta fazka wyjdzie na raz - jeżeli wprowadzimy wartości, przekraczające możliwości naszej tokarki, będzie lipa - czyli na większe fazki trzeba by program jeszcze rozbudować.
Program nie jest "idiotoodporny" - wpisanie szerokości fazki, przy głębokości ustawionej na zero, spowoduje, że program spróbuje ją wykonać. Żeby tę możliwość usunąć, trzeba by wstawić kolejny warunek if. Zostawiam to waszej inwencji
Podprogramy i ich wywoływanie by ArturM
ArturM pisze:LinuxCNC nie obsługuje M98, podprogram się wywołuje tak jak podałem w przykładzie z kołem, czyli:
Kod:
(podprogram)
o100 sub
g1 x10 f20
o100 endsub
(i wywołanie)
o100 call
od wersji 2.3 podprogram może się 'normalnie' nazywać - więc można robić zapis typu:
Kod:
o<okrag> sub
(jakis tam kod)
o<okrag> endsub
o<kwadrat> sub
(jakiś inny kod)
o<kwadrat> endsub
(i potem można to wywoływac tak)
o<kwadrat> call
o<okrag> call
Kolejny "stopień wtajemniczenia" to podprogramy z podawaniem argumentu.
Jeżeli wywołanie zrobimy tak:
Kod:
o100 call [1] [2] [3]
to wtedy w podprogramie te argumenty mamy dostępne jako zmienne #1, #2, #3 itd.
No i tu dochodzimy pewnie do tych 'podprogramów na zagłębienie'. Bo programy do generowania gcodu z reguły generują taką sieczkę:
Kod:
(----------------------)
G1 Z-2. F30
M98 P3
G1 Z-4. F30
M98 P3
G1 Z-6. F30
M98 P3
G1 Z-8. F30
M98 P3
G1 Z-10. F30
M98 P3
G1 Z-12. F30
M98 P3
G1 Z-14. F30
M98 P3
G1 Z-16. F30
M98 P3
G1 Z-18. F30
M98 P3
G1 Z-20. F30
M98 P3
G1 Z-22. F30
M98 P3
G1 Z-24. F30
M98 P3
G0 Z2.
(..... ciach inne smieci ...)
O3
G2 X9.25 Y16. I-0.25 J0. F50
M99
no i jeżeli chcesz to zapisac do LinuxCNC to trzeba jakoś tak:
Kod:
o100 sub
G2 X9.25 Y16. I-0.25 J0. F50
o100 endsub
G1 Z-2. F30
o100 call
G1 Z-4. F30
o100 call
G1 Z-6. F30
o100 call
G1 Z-8. F30
o100 call
G1 Z-10. F30
o100 call
G1 Z-12. F30
o100 call
G1 Z-14. F30
o100 call
G1 Z-16. F30
o100 call
G1 Z-18. F30
o100 call
G1 Z-20. F30
o100 call
G1 Z-22. F30
o100 call
G1 Z-24. F30
o100 call
G0 Z2.
Dla mnie taki zapis jest totalnie bez sensu - bo jak zmienić skok? Jak zwiekszyć glębokość? Mam generowac od nowa? Mam dopisać/przeedytowac 20 linijek dla takiej głupotki? Tak to se można na Machu robića nie na porządnych programach
W 'porządnych programach' to się zapisuje tak:
Kod:
o100 sub
G2 X9.25 Y16. I-0.25 J0. F50
o100 endsub
#1 = 0
o200 while [#1 gt -24]
#1 = [#1 - 2]
g1 z#1 f30
o100 call
o200 endwhile
Czyli:
podprogram został jak jest a zagłębianie robimy w pętli.
Pętlę tworzą linie:
Kod:
oxxx while [warunek]
oxxx endwhile
Pętla wykonuje wszystko co jest zawarte pomiędzy 'while' a 'endwhile' dopóki warunek jest spełniony. Jeżeli warunek przestanie być spełniony to pętla przestaje się wykonywać.
Warunek to z reguły zapis w stylu '#1 gt -20' czy '#2 lt 20'
gt to 'greater than' (większe niż)
lt to 'less than' (mniejsze niż)
#numerek to zmienna - czyli takie 'pudełeczko' w którym możesz przechować jakąś wartość - to pudełeczko nazywa się zawsze tak samo (np. #1, #<skok>, itp), a to co jest 'w środku' może się zmieniać.
Czyli mamy taki zapis:
Kod:
#1 = 0
o200 while [#1 gt -24]
#1 = [#1 - 2]
g1 z#1
o100 call
o200 endwhile
Co znaczy:
- nadaj zmiennej #1 wartość 0
- dopóki wartość zmiennej #1 jest wieksza niż -24 wykonuj:
--- nadaj zmiennej #1 wartość #1 - 2 (czyli zmniejsz wartość #1 o 2)
--- zjedź Zetem na wysokość równą wartości zmiennej #1
--- wywołaj podprogram o100
- zamknięcie pętli (czyli 'powtarzaj')
Jak widzisz można tu łatwo sobie regulowac głębokość - wystarczy zmienić -24 na inna wartość. I tak samo skok - zamiast - 2 dajemy - 1 i już mamy zagłębianie o 1 a nie o 2.
Jeżeli program będzie wykorzystywany więcej niż raz to warto parametry wywalic na początek i nadac im znaczące nazwy, czyli np. tak:
Kod:
#<glebokosc> = -24
#<skok> = 2
o100 sub
G2 X9.25 Y16. I-0.25 J0. F50
o100 endsub
#1 = 0
o200 while [#1 gt #<glebokosc>]
#1 = [#1 - #<skok>]
g1 z#1 f30
o100 call
o200 endwhile
wtedy zmieniasz tylko 2 pierwsze linijki - no i jeżeli program jest bardziej skomplikowany to łatwiej się w tym połapać po pół roku
Resztę znajdziecie z w komentarzach do kodu - wszystko, co w nawiasach okrągłych, jest przez EMC ignorowane.
Czyli - kopiujemy kod z okienka, zapisujemy go do pliku nazwanego np czop.ngc i wczytujemy do swojego LinuxCNC. I już można się bawić zmienianiem parametrów i obserwacją, jak wirtualna (albo i realna) tokarka robi, co jej nakazaliśmy
I zakończona operacja toczenia. Białe kreski określają drogę przyszłego przebiegu noża w trakcie pracy, niebieskie to szybkie przejazdy do i od materiału. Na czerwono zaznacza się już wykonana operacja pracy w materiale. Możemy to wyczyścić, klikając ikonkę "Pędzel", albo kombinacją klawiszy "Ctrl K".
Jak ten kod wykonać na maszynie realnej? Kolejność jest taka: Uruchamiamy EMC, wczytujemy realną konfigurację naszej maszyny. Bazujemy osie, i mocujemy materiał w uchwycie.
Cytat pochodzi stąd. Dotyczy wprawdzie frezarki i Macha, ale idea jest chyba dokładnie ta sama w LinuxCNC.pit202 pisze:Punkt home X jest po to aby maszyna wiedziała gdzie jest , nie my , home nie jest dla nas, home mozna uzyc do wycofywania sie maszyny w punkt (0,0,0) po co ? otoz: u mnie w maszynie zrobilem tak ze homeZ mam gdy wrzeciono jest podniesione, HomeY mam gdy stol mam blisko siebie i homeX mam gdy stol jest po prawej, hmm, no ale co to daje ? daje to nam tyle ze po skonczonym programie ( na koncu programu ) mam napisane :
G53 Z0
G28
i co to robi ? otoz , G53 Z0 robi home Z , czyli podnosi mi os Z na góre, czyli frezem w nic nie wjade gdy bede robił G28 , ktore jest po to aby wycofac wszystkie osie do pozycji HOME, czyli stol podjezdza do mnie. taka wygoda
druga wazna funkcją HOME`ów jest to ze moze sie wkoncu nam przydac
sprawa ustawiania materialu naszego ZERA : zakladam ze maszyna jest dobrze ustawiona i operator wie gdzie jest +-XYZ , ustawiamy nasz material na stole ( mocujemy , lub nie) dojezdzamy frezem do materialu : przy wlaczonych obrotach az do uslyszenia dzwięku uderzania freza o meterial, lub przy wylaczonych obrotach jak najblizej materialu i wiemy ze nasz freza ma srednice 6mm, nasz punkt 0,0,0 jest w lewym dolnym rogu naszego materialu, to nasz frez znajduje sie w poz X-3 ( polowa srednicy freza ) to samo robimy dla osi Y , dla Z mozna inaczej , zjezdzamy w dol i klikamy przycisk ZEROZ, nasza os Z sie wyzeruje i na gorze ( TOP`ie ) materialu mamy juz punkt Z=0
Mocujemy wałek w uchwycie, tak, by wystawał na tyle, by można było zatoczyć czop o zadanych parametrach. Teraz trzeba poinformować jakoś nasze LinuxCNC, gdzie ten materiał się znajduje w przestrzeni. Jak to zrobić? Bardzo prosto. Używając strzałek na klawiaturze dojeżdżamy do czoła materiału, można je lekko splanować dla dokładności, i zerujemy oś Z. Robimy to przez naciśnięcie w panelu LinuxCNC "Ustaw offset" dla ozi Z oczywiście - trzeba zaznaczyć odpowiedni przycisk "radio". Wyskakuje okienko z wpisanym już zerem - zatwierdzamy w nim tę pozycję. Następnie zmieniamy oś na X, dojeżdżamy nożem do powierzchni wałka - również można nieco stoczyć i dopiero potem ją zmierzyć. Wynik pomiaru wpisujemy w naszym pliku czop.ngc jako średnicę wałka. Wciągamy plik do LinuxCNC klikając klawisz "O". Od tego momentu LinuxCNC wie z dokładnością do setnej milimetra, gdzie ma trafić nożem. Naciskamy R na klawiaturze, i możemy popatrzeć jak LinuxCNC robi za nas to, co na manualu wymaga kręcenia korbkami, pomiarów co chwilę etc
Na zrzucie ekranu widać, jak po zabazowaniu osi zjechałem nożem ręcznie w prawo i w dół. Po zzerowaniu tam osi wczytałem plik polkula.ngc, i nóż rozpoczął działanie w miejscu, gdzie ustawiłem zero.
Poniżej macie ten plik, powodujący zataczanie końca walca na półkulę:
Kod: Zaznacz cały
( ------------------------------ )
( Półkula na końcu walca )
( ------------------------------ )
( Miki )
( Time-stamp: <2012-01-07 02:39> )
( ------------------------------ )
( USTAWIENIA )
( ------------------------------ )
#<promien_kulki> = 10
#<przybranie> = 1
( ------------------------------ )
( ------------------------------ )
#<walec> = 0
g18
M3 S1000
g0 z1
o100 while [#<walec> lt [[#<promien_kulki>]]]
#<walec>=[[#<walec>]+[#<przybranie>]]
x[[#<promien_kulki>]-[#<walec>]]
z0
g3 x[[#<promien_kulki>]] z-[[#<walec>]] r[#<promien_kulki>] f400
g0
x [[#<promien_kulki>]+1]
z1
o100 endwhile ( koniec toczenia )
g0 x[#<promien_kulki>+1]
z0 x[#<promien_kulki>*2+10]
m30
%
Jak sobie wciągniecie ten przykład do LinuxCNC widać wyraźnie zbieranie materiału warstwa po warstwie, ruch roboczy występuje wyłącznie w materiale. Dojazdy planowane są tak, by nóż w materiał wchodził łagodnie i nie pod ostrym kątem. Wynika to z tego, że LinuxCNC łagodzi krzywe - czyli idzie po łuku na styku linii kąta.
I cos na frezarkę od kamara:
Kod: Zaznacz cały
( ------------------------------ )
( KIESZEŃ PROSTOKĄTNA )
( ------------------------------ )
( Kamar )
( Time-stamp: <2012-01-24 14:26> )
( ------------------------------ )
(info: Frezowanie kieszeni prostokątnej )
/o<kieszen> sub
#<frez> = 8 (#1 =8 frez)
#<x_pocz> = 10 (#2 =20 X początkowy)
#<x_kon> = 190 (#3 =10 X końcowy )
#<y_pocz> = 10 (#4 =10 Y początkowy)
#<y_kon> = 190 (#5 =190 Y końcowy )
#<glebokosc> = -10 (#6 =-10 głębokość )
#<glebokosc_poczatkowa> = 0 ( #7 =0 głębokość poczatkowa )
#<skok> =2 ( #8 =2 skok)
#<predkosc_bok> = 3000 ( #9 =60 prędkość bok)
#<predkosc_dol> = 1000 (#10 =40 prędkość dół)
#<pokrycie> = 1 (#11 =1 zachodzenie w mm )
( ------------------------------ )
( ------------------------------ )
#<przyrost>=[#<frez>-#<pokrycie>]
#<x_fak>=[#<x_kon>-[#<frez>/2]]
g17 g21 g61
/g0 x[#<x_pocz>+[#<frez>/2]] y[#<y_pocz>+[#<frez>/2]]
/g0 z2
m3 s1
m8
#<akt_glebokosc> = #<glebokosc_poczatkowa> ( aktualna glebokosc )
#<x_akt>=[#<x_pocz>+[#<frez>/2]]
o100 while [#<akt_glebokosc> GT #<glebokosc>]
#<akt_glebokosc> = [#<akt_glebokosc> - #<skok>] ( ustalenie glebokosci )
( jezeli nizej limitu to jade max )
o110 if [#<akt_glebokosc> lT #<glebokosc>]
#<akt_glebokosc> = #<glebokosc>
o110 endif
g0 x#<x_akt> y[#<y_kon>-[#<frez>/2]]
g0 z#<akt_glebokosc>
G1 Z#<akt_glebokosc> F#<predkosc_dol> ( dobieranie poczatkowe )
y[#<y_pocz>+[#<frez>/2]] f#<predkosc_bok>
o120 while [#<x_akt> lt #<x_fak>]
#<x_akt>=[#<x_akt>+[#<frez>-#<pokrycie>]]
( jezeli nizej limitu to jade max )
o111 if [#<x_akt> gT #<x_fak>]
#<x_akt> = #<x_fak>
o111 endif
#<dodaj>=[#<x_akt>+#<przyrost>]
x#<x_akt>
G1 y[#<y_kon>-[#<frez>/2]] f#<predkosc_bok>
o112 if [ #<dodaj> gT #<x_fak>]
#<dodaj> = #<x_fak>
o112 endif
x#<dodaj>
#<x_akt>=[#<x_akt>+#<przyrost>]
y[#<y_pocz>+[#<frez>/2]] f#<predkosc_bok>
o120 endwhile
g0 z10
#<x_akt>=[#<x_pocz>+[#<frez>/2]]
g0 x#<x_akt> y[#<y_kon>-[#<frez>/2]]
o100 endwhile
g0 z10
#<akt_glebokosc> = #<glebokosc_poczatkowa> ( aktualna glebokosc )
o130 while [#<akt_glebokosc> GT #<glebokosc>]
#<akt_glebokosc> = [#<akt_glebokosc> - #<skok>] ( ustalenie glebokosci )
( jezeli nizej limitu to jade max )
o131 if [#<akt_glebokosc> lT #<glebokosc>]
#<akt_glebokosc> = #<glebokosc>
o131 endif
g0 z[#<akt_glebokosc> +1]
G1 Z#<akt_glebokosc> F#<predkosc_dol> ( dobieranie poczatkowe )
g1 y[#<y_pocz>+[#<frez>/2]]
x[#<x_kon>-[#<frez>/2]]
y[#<y_kon>-[#<frez>/2]]
x[#<x_pocz>+[#<frez>/2]]
o130 endwhile
g0 z10
m30
/o<kieszen> endsubG0 to dojazdy i odjazdy od materiału. Można wskazać pozycję, do której nóż ma jechać, szybkość jest definiowana w ustawieniach LinuxCNC. Nóż zawsze stara się jechać najkrótszą drogą, dlatego warto go zawsze pozycjonować tak, by nie wjechał w szkodę. LinuxCNC nie ma żadnego pojęcia, jaki materiał mamy w uchwycie. Czyli sam z siebie go nie ominie w razie czego.
G1 to ruch roboczy, czyli w naszym przypadku - toczenie. Również odbywa się z punktu, w którym jest aktualnie nóż, do punktu wskazanego przez napisany przez nas kod. Musimy tutaj zapodać prędkość narzędzia - czyli oprócz pozycji na osi X i Y ( w przypadku wskazania tylko jednej osi ruch odbędzie się prostopadle lub równolegle, wskazanie pozycji na obu osiach skutkuje jazdą pod kątem), musimy jeszcze dodać parametr f wyrażany w milimetrach na minutę. Niestety, programiści nie wyposażyli nas w proste narzędzie do jazdy pod określonym do obrabianej powierzchni kątem. Trzeba z tym sobie radzić, używając w programowaniu ruchu funkcji trygonometrycznych.
G2 to ruch po okręgu w kierunku przeciwnym do ruchu wskazówek zegara. Odbywa się od punktu, w którym nóż się znajduje w chwili wydania polecenia, do punktu wskazanego jako końcowy na osiach X i Z. Dodatkowo trzeba podać promień R, po jakim ruch się ma odbywać, i oczywiście szybkość F.
G3 jest dokładnie taką samą funkcją jak G2, z tym, że ruch odbywa się zgodnie z ruchem wskazówek zegara. Dla obu tych funkcji trzeba wskazać płaszczyznę, na jakiej mają działać - w przypadku tokarki jest to płaszczyzna XZ, wybieramy ją przez użycie kodu G18. Domyślnie aktywną jest płaszczyzna XY, dla tokarki niedostępna.
G4 - postój czasowy, parametrem jest Pxx gdzie xx to ilość sekund.
Funkcja G7 przestawia standardowo skonfigurowaną oś X na działanie takie, jak na tokarkach manualnych, czyli nie mierzy zmniejszania promienia, tylko zbieranie ze średnicy. Czyli przesunięcie X o jeden fizycznie przesunie nóż o pół milimetra.
Funkcja G8 z kolei przestawia oś X ustawioną jak w manualnej na skalę liczoną w milimetrach od osi. Czyli nie musimy się specjalnie przejmować, jak jest skonfigurowana oś - możemy to sobie w każdej chwili przestawić jedną komendą G-codu. Kamar radzi jednak skonfigurować na stałe oś w EMC jak w manualu i nie mieszać, żeby uniknąć potem pomyłek.
G10 Definiowanie narzędzi w tabeli narzędzi
Składnia:
G10 L1 P[numer narzędzia] R[promień] X[offset] Y[offset] Z[offset] A[offset] B[offset] C[offset] U[offset] V[offset] W[offset] I[frontangle] J[backangle] Q[orientation]
G10 L1 zapisuje w tabeli narzędzi pozycje konkretnych narzędzi na imakach, do użycia przez program, albo ręcznie z zakładki MDI.
G18 Ustawia jako aktywną dla poleceń G2 i G3 płaszczyznę XZ - wymagane dla użycia tych poleceń na tokarce.
G20 - wymiarowanie w calach
G21 - wymiarowanie w milimetrach
G28 Polecenie zjazdu suportu/wrzeciona w pozycję HOME na wszystkich osiach.
G40 - koniec korekcji
G41 - korekcja toru narzędzia lewostronna (kompensacja promienia płytki, freza)
G42 - korekcja toru narzędzia prawostronna (kompensacja promienia płytki, freza)
G43 - włączenie kompensacji długości narzędzia (frezarka)
Ponieważ korekcja zmusza maszynę do szeregu bardzo dokładnych obliczeń, obowiązują pewne zasady jej stosowania. Jeśli nie będziemy się ich trzymać, komputer może po prostu zgłupieć, bo dostanie polecenia matematycznie sprzeczne.
Korekcję włączamy jedynie dla obróbki konturów. Nie ma ona zastosowania przy obróbce cyklami kieszeni prostokątnych, kołowych, rowków ani wierceń.
Pomiędzy włączeniem korekcji G41/G42 a jej odwołaniem G40 mają prawo pojawić się wyłącznie funkcje G00, G01, G02 lub G03. Zastosowanie jakichkolwiek innych funkcji może powodować nieprzewidziane zachowanie się maszyny - niekontrolowane ruchy.
Korekcję włączamy przy najeździe na pierwszy punkt konturu, a wyłączamy w linii wyjazdu z konturu.
Korekcję włączamy dla każdego narzędzia osobno. Odwołujemy najpóźniej przed wymianą narzędzia.
Funkcje włączania i odwołanie korekcji w zależności od systemu piszemy w osobnych liniach lub na końcu linii ruchu.
Pomiędzy włączeniem a odwołaniem korekcji musi następować co najmniej jedna linia ruchu.
W większości maszyn korekcja obowiązuje tylko w płaszczyźnie X-Y
G53 Ustawia współrzędne absolutne maszynowe, czyli kasuje nasze poustawiane limity, i ustawia maszynę w nadanym jej w configu systemie koordynat. Polecenie G53 G0 Z0 spowoduje ruch suportu w osi Z do ustawionego na tej osi punktu Home, niezależnie od tego, gdzie ów suport się w danym momencie znajduje.
G64 p0.05 (tolerancja łuku 0.05mm)
G64 (wyłączona kontrola tolerancji, zakręty ścinanne)
G61 (dokładna jazda od punktu do punktu)
G76 - gwintowanie parametryczne
składnia:
G76 P2 z-100 I-0.1 J0.1 K4.2 R1
gdzie:
P - skok gwintu
I - pierwsze przejście ( z minusem - gwint zewnętrzny , bez - gwint wewnętrzny)
J - pozostałe przejścia
K - głębokość
R - wyjazd
G33 - toczenie gwintu
G54 - G59 - przesunięcie układu współrzędnych
G80 - koniec cyklu wielokrotnego
G81 - cykl nawiercania
G82 - cykl wiercenia z przerwą czasową
G83 - cykl wiercenia z wyciąganiem (usuwaniem) wióra
G84 - cykl gwintowania synchronicznego
G90 - pozycjonowanie absolutne
G91 - pozycjonowanie przyrostowe
G94 - programowanie prędkości posuwu w [mm/min]
G95 - programowanie prędkości posuwu w [mm/obr]
G96 - włączenie trybu stałej prędkości skrawania [m/min] (tokarka)
G97 - włączenie trybu stałej prędkości obrotowej wrzeciona [obr/min] (tokarka)
Funkcje pomocnicze M
M00 - stop programu bezwarunkowy
M01 - stop programu warunkowy (zależnie od trybu pracy)
M02 - koniec programu
M03 - włączenie prawych obrotów wrzeciona
M04 - włączenie lewych obrotów wrzeciona
M05 - wyłączenie obrotów wrzeciona
M06 - zmiana narzędzia (polecenie "zmień")
M07 - włączenie chłodziwa przez narzędzie
M08 - włączenie chłodziwa wylewki zewnętrzne
M09 - wyłączenie chłodziwa
M10 (M36) - otwarcie szczęk (zależnie od producenta)
M11 (M37) - zamknięcie szczęk (zależnie od producenta)
M30 - koniec programu i "przewinięcie" do początku.
Ponadto w istnieją parametry do poszczególnych kodów z grupy G:
S - wybór prędkości obrotowej wrzeciona (symbol "S" oraz podana wartość, np. S1500)
F - wybór posuwu (analogicznie do "S")
X - położeni w osi "X" (po adresie występuje wartość bezwzględna lub względna, np. X200)
Y - położeni w osi "Y" (po adresie występuje wartość bezwzględna lub względna, np. Y200)
Z - położeni w osi "Z" (po adresie występuje wartość bezwzględna lub względna, np. Z200)
A - położeni w osi "A" (po adresie występuje wartość bezwzględna lub względna, np. A10)
B - położeni w osi "B" (po adresie występuje wartość bezwzględna lub względna, np. B10)
C - położeni w osi "C" (po adresie występuje wartość bezwzględna lub względna, np. C10)
LinuxCNC ma jeszcze jedną ciekawą umiejętność - potrafi wczytać nie tylko gotowe pliki .ngc. Wczytuje i uruchamia również pliki wykonywalne, napisane w języku programowania Python, a efekt ich działania w postaci wygenerowanego kodu .ngc wrzuca wprost na obrabiarkę. Zapytacie, po co takie skomplikowanie? Otóż jest to istotne ułatwienie, bo skrypt, napisany w Pythonie, potrafi nas zapytać, jakie parametry ma podstawić pod zmienne, które w wyświetlanych wyżej przykładach trzeba było za każdym razem edytować w pliku .ngc przed zaimportowaniem go do programu.
Czyli wczytujemy do LinuxCNC plik Pythona - ma rozszerzenie .py - i zamiast kodu w okienku programu widzimy wyskakujące okienko z formularzem, w który trzeba jedynie wpisać parametry. Po zatwierdzeniu wprowadzonych parametrów okienko znika, a w samym LinuxCNC pojawia się gotowy kod i jego wizualizacja - wystarczy sprawdzić, czy wszystko się zgadza, i nacisnąć "R".
Mało tego - można napisać skrypt, który umożliwi wybór spośród wszystkich pozostałych - czyli mamy wczytany tylko jeden plik, który wyświetla za każdym odświeżeniem listę wyboru gotowych procedur. Na tę chwilę mam taki skrypt, w którym ręcznie trzeba te pozostałe plik zdefiniować, ale kolejna wersja po prostu sobie sprawdzi, jakie pliki z rozszerzeniem .py są w katalogu, i je do tej listy wyboru sam podstawi.
W ten sposób możemy sobie skonfigurować naszego LinuxCNC jak nam się tylko zamarzy, i z palca G-cody pisać tylko w nieszablonowych przypadkach. A taki przypadek również bez trudu potem możemy dodać do naszej biblioteki gotowców.
Więcej o tym w tym wątku
EMC w wersji najnowszej z repozytoriów ma wbudowane rozszerzenie NGCGUI - więcej o tym w tym wątku
W skrócie - dzięki sprytemu formatowaniu komentarzy to, do czego było potrzeba wczesniej Pythona, robi się w plikach ngc, i w oknie samego LinuxCNC.
procedura toczenia półkuli, albo półokrągłego elementu od dowolnej średnicy w dowolnym punkcie osi Z - 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: Zaznacz cały
NGCGUI_SUBFILE = polkula.ngcKod: Zaznacz cały
; Author: Z. Maciej "Miki" Bajkowski
(info: Toczenie półkuli lub zaokrąglenia krawędzi wałka. )
o<polkula> sub
#<promien_walca> = #1 (=30 Promień walca)
#<promien_na_plasko> = #2 (=20 Promień części bez zaokrąglenia. 0 - toczymy półkulę)
#<promien_kulki> = #3 (=15 Promień zaokrąglenia)
#<przybranie> = #4 (=3 Przybranie materiału)
#<przesuniecie_z> = #5 (=0 Punkt początku operacji na osi Z)
#<Coolant> = #6 (=8 8 - Chłodziwo włączone, 9 - wyłączone)
#<predkosc> = #7 (=400 Prędkość skrawania)
#<promien> = #<promien_walca>
; Turn the OD
M3 M#<Coolant> ; spindle cw, coolant on/off
#<walec> = 0
#<promien_walca> = [#<promien_walca>-#<promien_na_plasko>]
g18 (g7)
M3 S1000
g0 z[#<przesuniecie_z>+1] x[[#<promien>]+1]
o100 while [#<walec> lt [#<promien_walca>]]
#<walec>=[[#<walec>]+[#<przybranie>]]
x[[#<promien_walca>]-[#<walec>]+[[#<promien_na_plasko>]]]
z[#<przesuniecie_z>]
g3 x[[#<promien>]] z-[[#<walec>]-[#<przesuniecie_z>]] r[#<promien_kulki>] f[#<predkosc>]
g0
x [[#<promien>]+1]
z[#<przesuniecie_z>+1]
o100 endwhile ( koniec toczenia )
o<polkula> endsub
