Pomysłowo skonfigurowany Emc.

MlKl · Post napisał: **MlKl** » 20 sty 2012, 21:38

IMHO nie ma takiej potrzeby. Plik auto.ngc zawiera wszystkie zmienne dla danej procedury wraz z opisami i jej wywołanie.

Nie potrzeba oglądać fizycznie g-codu, podawanego na maszynę - operator ma redagować wyłącznie wartości zmiennych.

Słowem - warto by stworzyć osobną formatkę, która wczyta kod z auto.ngc w postaci jednego formularza zawierającego podformularze wszystkich znalezionych w auto.ngc procedur, i najlepiej od razu wizualizację całego procesu.

Kod: Zaznacz cały

(ngcgui: FEATURE 120118:18.37.11) 
(ngcgui: files: </home/miki/emc2/nc_files/start.ngc /home/miki/emc2/nc_files/polkula.ngc /home/miki/emc2/nc_files/end.ngc>) 
(ngcgui: feature line added) #<_feature:> = 0
(ngcgui: preamble file: /home/miki/emc2/nc_files/start.ngc) 
g18 (xz plane) 
g21 (mm) 
g40 (cancel cutter radius compensation) 
g49 (cancel tool lengthoffset) 
g90 (absolute distance mode) 
g94 (units/min feedrate) 
g54 (Coordinate system 1 default) 
#<tol>  = 0.001
g64 p#<tol> (path control stop) 
( ------------------------------ ) 
( start ) 
( ------------------------------ ) 
( Miki ) 
( Time-stamp: <2012-01-06 20:39> ) 
(ngcgui: call subroutine file: /home/miki/emc2/nc_files/polkula.ngc) 
(ngcgui: positional parameters:) 
(         #1 = promien_walca =           30) 
(         #2 = promien_na_plasko =           20) 
(         #3 = promien_kulki =           15) 
(         #4 =   przybranie =            3) 
(         #5 = przesuniecie_z =            0) 
(         #6 =      coolant =            8) 
(         #7 =     predkosc =          400) 
o<polkula> call [30][20][15][3][0][8][400] 
(ngcgui: postamble file: /home/miki/emc2/nc_files/end.ngc) 
(not_a_subfile) 

( ------------------------------ ) 
( end ) 
( ------------------------------ ) 
( Miki ) 

( Time-stamp: <2012-01-06 20:39> ) 

g28






(ngcgui: m2 line added) m2 (g54 activated)

Przeanalizujmy: Użyłem trzech plików w jednej operacji - Wstęp, czyli u mnie start.ngc, Procedura - u mnie polkula.ngc i Zakończenie - u mnie end.ngc. Jakbym zbudował operacje wieloprocedurową, to by było Wstęp, Procedura1, Procedura2, Procedura3 i Zakończenie.

Wstęp i zakończenie wpisują się do auto.ngc tak, jak są zapisane w plikach.

Wywołanie procedury/procedur zasadniczych wygląda tak:

Kod: Zaznacz cały

(ngcgui: call subroutine file: /home/miki/emc2/nc_files/polkula.ngc) 
(ngcgui: positional parameters:) 
(         #1 = promien_walca =           30) 
(         #2 = promien_na_plasko =           20) 
(         #3 = promien_kulki =           15) 
(         #4 =   przybranie =            3) 
(         #5 = przesuniecie_z =            0) 
(         #6 =      coolant =            8) 
(         #7 =     predkosc =          400) 
o<polkula> call [30][20][15][3][0][8][400]

Z czego istotna jest tylko jedna linijka -

Kod: Zaznacz cały

o<polkula> call [30][20][15][3][0][8][400]

Edytując ręcznie ten kod wystarczy patrzeć na nazwy zmiennych w komentarzach wyżej, żeby wiedzieć który parametr trzeba zmienić. Dla formatki trzeba albo napisać procedurę wciągającą tekstowe opisy zmiennych z plików procedur, albo zmienić sposób zapisu pliku auto.ngc, żeby się w nim również zapisywały przy tworzeniu.

markcomp77 · Post napisał: **markcomp77** » 20 sty 2012, 23:51

MlKl pisze:Edytując ręcznie ten kod wystarczy patrzeć na nazwy zmiennych w komentarzach wyżej, żeby wiedzieć który parametr trzeba zmienić.

program te zmienne też może odnaleźć....
jednak -- ja myślałem o grupowaniu modyfikowalnych zestawów procedur...
z możliwością grupowania utworzonych wcześniej grup

dlatego zależało mi na generowaniu kodu dopiero na samym końcu...
coś jak praca na makrach... opis projektu ma być jak najkrótszy, dopiero po wciśnięciu "Przekaż" ma się rozwinąć do pełnego gcodu... wcześniej niech będzie możliwie krótkim opisem (czytelnym dla człowieka analizującego działanie programu - tak jak kod opisu tekstu -- TeX - LaTeX - LyX)

i ważne jest aby obiekt złożony dawał się modyfikować -- przez przynależny mu kod formularza ekranowego (to co teraz jest w zakładce)... to też może udać się zrobić jakoś automatycznie - bez tworzenia specyficznego kodu dla każdej z procedur obróbkowych z osobna

MlKl · Post napisał: **MlKl** » 21 sty 2012, 01:04

Toć właśnie genialne jest tworzenie procedur bez ograniczeń żadnymi ramkami. Potrzebujesz zmiennej, pobieranej z okienka - dodajesz linijkę z kolejnym #n i masz dodatkowe pole do wypełnienia w formatce.

Każdy stworzony plik g-codu w formacie NGCGUI jest tym plikiem INI o którym mówisz. W wynikowym pliku auto.ngc brak tylko komentarzy, które są opisami pól formatki, żeby wciągać go do ponownej edycji bez żadnego problemu - ino trzeba napisać do tego formatkę.

Albo przepisać to, co jest, żeby można się poruszać było w tył w trakcie edycji i móc obejrzeć w dowolnym momencie wizualizację i znowu wrócić do edycji.

[ Dodano: 2012-01-22, 02:06 ]
Jakby kto pytał, to polonizacja wersji z gita działa, jak się wrzuci plik zatytułowany emc2.mo zamiast linuxcnc.mo, albo obok niego.

Czyli romans do micgesa - rzecz do poprawki.

kamar · Post napisał: **kamar** » 22 sty 2012, 17:16

MlKl pisze: Albo przepisać to, co jest, żeby można się poruszać było w tył w trakcie edycji i móc obejrzeć w dowolnym momencie wizualizację i znowu wrócić do edycji. .

Dla mnie NGCGUI to raczej narzędzie umożliwiające obsługę maszyny bez głębszej znajomości pisania g-kodów ( pętli, subów, calli itp) I raczej nie ma co tego komplikować. Średnio kumaty tokarz czy frezer ma przycisk do określonej procedurki , podaje parametry i wykonuje.
Można z niego robić cam-a ale nie bezpośrednio na maszynie.
I dlatego bardziej skupiamy się na samym wprowadzaniu parametrów tzn. jakieś ptaszkowania czy rozwijane listy, żeby więcej tego zmieścić i łatwiej wybierać.

MlKl · Post napisał: **MlKl** » 22 sty 2012, 17:26

To jest zadanie dla zespołu, piszącego LinuxCNC. Możemy to sugerować - przynajmniej ja na etapie, na jakim jestem, nie podejmuję się ingerencji w kod źródłowy NGCGUI. Może za jakiś miesiąc zmienię zdanie

A na dziś jakimś rozwiązaniem byłoby stworzenie kilku wariantów pliku .ini z pogrupowaniem odpowiednio dobranych przycisków - a procedurę własną i tak z każdej konfiguracji można poskładać dowolnie.

Czyli jak chcesz frezować koła zębate, to wczytujesz zebatka.ini, a na kieszenie kieszen.ini etc.

kamar · Post napisał: **kamar** » 22 sty 2012, 17:40

MlKl pisze: byłoby stworzenie kilku wariantów pliku .ini z pogrupowaniem odpowiednio dobranych przycisków - a procedurę własną i tak z każdej konfiguracji można poskładać dowolnie.

Niby proste ale w teorii

Żeby zmienić plik .ini musisz zamknąć emca, zeby zamknąć emca i nie stracić offsetów, musisz zbazować maszyne

MlKl · Post napisał: **MlKl** » 22 sty 2012, 18:19

Zakładki taper-od, od i in to tylko graficzne wywołanie pierwszej procedury cyklu. Jak tworzysz złożoną procedurę, i tak musisz wybierać z plików .ngc

Słowem - na dziś już masz możliwość wykonania dowolnie złożonej procedury, do twórców LinuxCNC zaś sugestia, żeby poszli w kierunku wyboru plików z list rozwijanych na każdym poziomie - i będzie git.

kamar · Post napisał: **kamar** » 19 lut 2012, 21:19

Procedurka na kieszeń prostokątną.

Kod: Zaznacz cały

( ------------------------------ ) 
(         KIESZEŃ PROSTOKĄTNA    ) 
( ------------------------------ ) 
( Kamar                          ) 
( Time-stamp: <2012-02-19 14:26> ) 
( ------------------------------ ) 

(info: Frezowanie kieszeni prostokątnej ) 

o<kieszen> sub

#<frez> = #1   (=8 frez) 
#<x_pocz> = #2 (=20 X początkowy) 
#<x_kon> = #3  (=10 X końcowy ) 
#<y_pocz> = #4 (=10 Y początkowy) 
#<y_kon> = #5 (=190  Y końcowy ) 
#<glebokosc> = #6  (=-10 głębokość  ) 
#<glebokosc_poczatkowa> = #7 (=0 głębokość poczatkowa ) 
#<skok> = #8 (=2 skok) 
#<predkosc_bok> = #9 (=60 prędkość bok) 
#<predkosc_dol> = #10 (=40 prędkość dół) 
#<pokrycie> = #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> + #<skok>] 
     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

o<kieszen> endsub

syntetyczny · Post napisał: **syntetyczny** » 26 lut 2012, 00:32

kamar, Kurdwa, bije kolega na głowę takim skrypciorami, szacun.... W takim razie muszę ogarnąć pisanie skryptów w EMC2, bo widzę, że to bardzo potężne narzędzie..

kamar · Post napisał: **kamar** » 11 mar 2012, 16:27

syntetyczny pisze:kamar bije kolega na głowę takim skrypciorami,

Kolega nie przesadza, toż to proste jak drut (skoro ja potrafię

) Ten u góry akurat to dość byle jaki, działa tylko w dodatnią strone. Taki był potrzebny na szybko, z czasem się poprawi

[ Dodano: 2012-03-11, 16:26 ]
Na prośbę jednego z kolegów - procedurka na baryłki pod GUI

Kod: Zaznacz cały

( ------------------------------ ) 
(         B A R Y L K I          ) 
( ------------------------------ ) 
( Kamar                          ) 
( Time-stamp: <2012-01-19 15:10> ) 

(info: Toczenie baryłek ) 

o<barylki> sub 

#<srednica> = #1 (=50 średnica) 
#<dlugosc_barylki> = #2 (=29 długość baryłki) 
#<promien> = #3 (=100 promień) 
#<odstep> = #4 (=0 odstep) 
#<liczba_barylek> = #5 (=1 liczba baryłek) 

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

g18
M3 S1 m8

g0 z0.1

 x#<srednica> 


#<nr_barylki> = 0
o100 while [#<nr_barylki> lt #<liczba_barylek>] 

  #<poczatek_aktualnej> = [[-1 * #<dlugosc_barylki> * #<nr_barylki>] - [#<odstep> * #<nr_barylki>]] 
  g3 x#<srednica> z[#<poczatek_aktualnej> - #<dlugosc_barylki>] r#<promien> f40
  g1 z[#<poczatek_aktualnej> - #<dlugosc_barylki> - #<odstep>] 
  #<nr_barylki> = [#<nr_barylki> + 1] 
	
o100 endwhile

g0 x[#<srednica> +20] m5
z0

o<barylki> endsub

Pomysłowo skonfigurowany Emc.

Szyna liniowa HIWIN MGNR12 0069 mm

Dalmierz laserowy MC2 40 2D

Pomysłowo skonfigurowany Emc.

Szyna liniowa HIWIN MGNR12 0069 mm

Dalmierz laserowy MC2 40 2D

Zaloguj się • Zarejestruj się

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