Oswajanie gada

Dyskusje dotyczące działania obsługi programu LinuxCNC
Awatar użytkownika

Autor tematu
MlKl
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 7
Posty: 3706
Rejestracja: 15 sie 2010, 13:44
Lokalizacja: Błonie
Kontakt:

Oswajanie gada

#1

Post napisał: MlKl » 08 sty 2012, 14:15

Kamar podesłał mi skrypt, napisany w języku Python, który można wessać do EMC jak plik .ngc, umożliwia on wpisanie danych do procedury w wyskakującej tabelce, zamiast wprost w pliku. Zatwierdzenie powoduje wygenerowanie takiego pliku wprost do programu. Słowem - to się zachowuje jak wbudowany element EMC.

Pythona nie znałem dotychczas - skrypt Kamara był niedokończony, i działał tylko częściowo. W związku z powyższym wziąłem na tapetę troszkę prostszy w budowie, jednoprocedurowy, znaleziony w plikach przykładowych. Tak powstał plik czop.py

Wykorzystałem w nim wcześniej napisaną procedurę czop.ngc

Aby skorzystać, należy pobrać załącznik, zmienić mu rozszerzenie pliku na .py i wciągnąć to do EMC. Można też zassać z mojego serwera - linki niżej.

Powodzenia :)

czop.py


czop.ngc

Widoczne wyżej linki trzeba zapisywać przez "Zapisz jako" bo inaczej otwierają się w tekście.


Kod: Zaznacz cały

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# ------------------------------ 
#         CZOP WAŁU Z FAZAMI
# ------------------------------ 
# 
# Z. Maciej "Miki" Bajkowski <[email protected]> 
# Time-stamp: <2012-01-08 13:55> 
import sys, os
BASE = os.environ['EMC2_HOME'] 
sys.path.insert(0, os.path.join(BASE, "lib", "python")) 

import math

def _(s): return s

def ui(): 
    import Tkinter
    import pickle
    import nf
    import rs274.options
    import os

    app = Tkinter.Tk() 
    rs274.options.install(app) 
    app.tk.call("source", os.path.join(BASE, "share", "axis", "tcl", "combobox.tcl")) 

    app.wm_title(_("Czop wału")) 
    app.wm_iconname(_("Czop wału")) 

    prev = Tkinter.Canvas(app, width=100, height=200) 
    f = Tkinter.Frame(app) 
    b = Tkinter.Frame(app) 
    prev.grid(row=0, column=0, sticky="nw") 
    f.grid(row=0, column=1, sticky="nw") 
    b.grid(row=1, column=0, columnspan=2, sticky="ne") 

    validate_float    = "expr {[regexp {^-?([0-9]+(\.[0-9]*)?|\.[0-9]+|)$} %P]}" 
    validate_int      = "expr {[regexp {^-?([0-9]+|)$} %P]}" 
    validate_posfloat = "expr {[regexp {^?([0-9]+(\.[0-9]*)?|\.[0-9]+|)$} %P]}" 
    validate_posint   = "expr {[regexp {^([0-9]+|)$} %P]}" 
    def posfloatentry(f, v): 
        var = Tkinter.DoubleVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_posfloat, validate="all", width=10) 
        return w, var

    def floatentry(f, v): 
        var = Tkinter.DoubleVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_float, validate="all", width=10) 
        return w, var

    def posintentry(f, v): 
        var = Tkinter.IntVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_posint, validate="all", width=10) 
        return w, var


    def intentry(f, v): 
        var = Tkinter.IntVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_int, validate="all", width=10) 
        return w, var

    def checkbutton(k, v): 
        var = Tkinter.BooleanVar(f) 
        var.set(v) 
        g = Tkinter.Frame(f) 
        w = Tkinter.Checkbutton(g, variable=var, text="Yes") 
        w.pack(side="left") 
        return g, var 

    def intscale(k, v, min=1, max = 100): 
        var = Tkinter.IntVar(f) 
        var.set(v) 
        g = Tkinter.Frame(f, borderwidth=0) 
        w = Tkinter.Scale(g, orient="h", variable=var, from_=min, to=max, showvalue=False) 
        l = Tkinter.Label(g, textvariable=var, width=3) 
        l.pack(side="left") 
        w.pack(side="left", fill="x", expand=1) 
        return g, var

    def optionmenu(k, v, *options): 
        options = list(options) 
        def trace(*args): 
            try: 
                var.set(options.index(svar.get())) 
            except ValueError: 
                pass

        try: 
            opt = options[v] 
        except (TypeError, IndexError): 
            v = 0
            opt = options[0] 

        var = Tkinter.IntVar(f)    
        var.set(v) 
        svar = Tkinter.StringVar(f) 
        svar.set(options[v]) 
        svar.trace("w", trace) 
        wp = f._w.rstrip(".") + ".c" + svar._name
        f.tk.call("combobox::combobox", wp, "-editable", 0, "-width",
                max(len(opt) for opt in options)+3, "-textvariable", svar._name,
                "-background", "white") 
        f.tk.call(wp, "list", "insert", "end", *options) 
        w = nf.makewidget(f, Tkinter.Widget, wp) 
        return w, var

    rc = os.path.expanduser("~/.emc_czop") 
# Poniżej deklarujemy wszystkie zmienne - ważna jest kolejność.
    constructors = [ 
        ("cz", floatentry),
	("dc", floatentry),
	("sw", floatentry),
	("fps", floatentry),
	("fpg", floatentry),
	("fds", floatentry),
	("fdg", floatentry),
	("units", lambda f, v: optionmenu(f, v, _("G21 (mm)"), _("G20 (cal)"))),
        ("cx", floatentry),
        ("pos", floatentry),
        ("obr", floatentry) 
    ] 

    defaults = dict( 
	dc = 0,
	sw = 0,
	fps = 0,
	fpg = 0,
	fds = 0,
	fdg = 0,
	cx = 0,
	cz = 0,
	pos = 1000,
	obr= 1000
    ) 

    texts = dict( 
        cz=_("Średnica czopa"),
	dc=_("Długość czopa"),
	sw=_("Średnica wału"),
	fps=_("Szerokść fazy czopa (0=brak tej fazy)"),
	fpg=_("Wysokość fazy czopa"),
	fds=_("Szerokość fazy reszty wału (0=brak tej fazy)"),
	fdg=_("Wysokość fazy reszty wału"),
	units=_("Jednostki"),
	cx=_("Przybranie materiału"),
	pos=_("Posuw"),
	obr=_("Obroty wrzeciona") 
    ) 

    try: 
        defaults.update(pickle.load(open(rc, "rb"))) 
    except (IOError, pickle.PickleError): pass

    vars = {} 
    widgets = {} 
    for j, (k, con) in enumerate(constructors): 
        v = defaults[k] 
        text = texts.get(k, k.replace("_", " ")) 
        lab = Tkinter.Label(f, text=text) 
        widgets[k], vars[k] = con(f, v) 
        lab.grid(row=j, column=0, sticky="w") 
        widgets[k].grid(row=j, column=1, sticky="ew") 



    status = Tkinter.IntVar() 
    bb = Tkinter.Button(b, text=_("OK"), command=lambda:status.set(1), width=8, default="active") 
    bb.pack(side="left", padx=4, pady=4) 
    bc = Tkinter.Button(b, text=_("Cancel"), command=lambda:status.set(-1), width=8, default="normal") 
    bc.pack(side="left", padx=4, pady=4) 
    
    app.bind("<Escape>", lambda evt: bc.invoke()) 
    app.bind("<Return>", lambda evt: bb.invoke()) 
    app.wm_protocol("WM_DELETE_WINDOW", lambda: bc.invoke()) 
    app.wm_resizable(0,0) 

    app.wait_visibility() 
    app.tk.call("after", "idle", ("after", "idle", "focus [tk_focusNext .]")) 
    #app.tk_focusNext().focus() 
    app.wait_variable(status) 

    if status.get() == -1: 
	raise SystemExit(1) 

    for k, v in vars.items(): 
        defaults[k] = v.get() 

    app.destroy() 

    pickle.dump(defaults, open(rc, "wb")) 

    return defaults

unitcodes = ['G21', 'G20'] 
u = ui() 
print unitcodes[u['units']] 


#definiwanie zmiennych - tu wpisujemy wszystkie wcześniej zadeklarowane zmienne.
cx = u['cx'] 
cz = u['cz'] 
dc = u['dc'] 
sw = u['sw'] 
fps = u['fps'] 
fpg = u['fpg'] 
fds = u['fds'] 
fdg = u['fdg'] 
pos = u['pos'] 
obr = u['obr'] 
#niżej wstawiamy kod .z ngc podstawiając pod potrzebne zmienne dane z tabelki w kolejności jak wpisane w nią
print """ 
            
(---------------------)            
(------ C Z O P ------) 
(---------------------) 

#<srednica_czopu> = % 4.2f
#<dlugosc_czopu> = % 4.2f
#<srednica_walka> = % 4.2f   
#<szerokosc_fazki_czopu> = % 4.2f       (ustawienie zerowej szerokosci wylacza wykonywanie fazki) 
#<glebokosc_fazki_czopu> = % 4.2f
#<szerokosc_fazki_walka> = % 4.2f      (ustawienie zerowej szerokosci wylacza wykonywanie fazki) 
#<glebokosc_fazki_walka> = % 4.2f
#<przybranie_materialu> = % 4.2f (tyle zbieramy ze srednicy na jeden raz, roznica srednic musi byc przez to podzielna) 
#<szybkosc_posuwu> = % 4.2f            (Szybkosc posuwu w trakcie toczenia) 
#<obroty_wrzeciona> = % 4.2f
(----------------------) 
(----koniec ustawień---) 

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



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) 

    """ % ( cz, dc, sw, fps, fpg, fds, fdg, cx, pos, obr) # tu trzeba również wpisać wszystkie zadeklarowane wcześniej zmienne w kolejności deklarowania. 

print "M30" 
print "%"
Obrazek

I kolejny plik: Półkula.

Obrazek

Kod: Zaznacz cały

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# ------------------------------ 
#         Półkula
# ------------------------------ 
# 
# Z. Maciej "Miki" Bajkowski <[email protected]> 
# Time-stamp: <2012-01-08 13:55> 
import sys, os
BASE = os.environ['EMC2_HOME'] 
sys.path.insert(0, os.path.join(BASE, "lib", "python")) 

import math

def _(s): return s

def ui(): 
    import Tkinter
    import pickle
    import nf
    import rs274.options
    import os

    app = Tkinter.Tk() 
    rs274.options.install(app) 
    app.tk.call("source", os.path.join(BASE, "share", "axis", "tcl", "combobox.tcl")) 

    app.wm_title(_("Półkula")) 
    app.wm_iconname(_("Półkula")) 

    prev = Tkinter.Canvas(app, width=100, height=200) 
    f = Tkinter.Frame(app) 
    b = Tkinter.Frame(app) 
    prev.grid(row=0, column=0, sticky="nw") 
    f.grid(row=0, column=1, sticky="nw") 
    b.grid(row=1, column=0, columnspan=2, sticky="ne") 

    validate_float    = "expr {[regexp {^-?([0-9]+(\.[0-9]*)?|\.[0-9]+|)$} %P]}" 
    validate_int      = "expr {[regexp {^-?([0-9]+|)$} %P]}" 
    validate_posfloat = "expr {[regexp {^?([0-9]+(\.[0-9]*)?|\.[0-9]+|)$} %P]}" 
    validate_posint   = "expr {[regexp {^([0-9]+|)$} %P]}" 
    def posfloatentry(f, v): 
        var = Tkinter.DoubleVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_posfloat, validate="all", width=10) 
        return w, var

    def floatentry(f, v): 
        var = Tkinter.DoubleVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_float, validate="all", width=10) 
        return w, var

    def posintentry(f, v): 
        var = Tkinter.IntVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_posint, validate="all", width=10) 
        return w, var


    def intentry(f, v): 
        var = Tkinter.IntVar(f) 
        var.set(v) 
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_int, validate="all", width=10) 
        return w, var

    def checkbutton(k, v): 
        var = Tkinter.BooleanVar(f) 
        var.set(v) 
        g = Tkinter.Frame(f) 
        w = Tkinter.Checkbutton(g, variable=var, text="Yes") 
        w.pack(side="left") 
        return g, var 

    def intscale(k, v, min=1, max = 100): 
        var = Tkinter.IntVar(f) 
        var.set(v) 
        g = Tkinter.Frame(f, borderwidth=0) 
        w = Tkinter.Scale(g, orient="h", variable=var, from_=min, to=max, showvalue=False) 
        l = Tkinter.Label(g, textvariable=var, width=3) 
        l.pack(side="left") 
        w.pack(side="left", fill="x", expand=1) 
        return g, var

    def optionmenu(k, v, *options): 
        options = list(options) 
        def trace(*args): 
            try: 
                var.set(options.index(svar.get())) 
            except ValueError: 
                pass

        try: 
            opt = options[v] 
        except (TypeError, IndexError): 
            v = 0
            opt = options[0] 

        var = Tkinter.IntVar(f)    
        var.set(v) 
        svar = Tkinter.StringVar(f) 
        svar.set(options[v]) 
        svar.trace("w", trace) 
        wp = f._w.rstrip(".") + ".c" + svar._name
        f.tk.call("combobox::combobox", wp, "-editable", 0, "-width",
                max(len(opt) for opt in options)+3, "-textvariable", svar._name,
                "-background", "white") 
        f.tk.call(wp, "list", "insert", "end", *options) 
        w = nf.makewidget(f, Tkinter.Widget, wp) 
        return w, var

    rc = os.path.expanduser("~/.emc_czop") 
# Poniżej deklarujemy wszystkie zmienne - ważna jest kolejność.
    constructors = [ 
        ("cz", floatentry),
	("units", lambda f, v: optionmenu(f, v, _("G21 (mm)"), _("G20 (cal)"))),
        ("cx", floatentry),
        ("pos", floatentry),
        ("obr", floatentry) 
    ] 

    defaults = dict( 
	cx = 0,
	cz = 0,
	pos = 1000,
	obr= 1000
    ) 

    texts = dict( 
        cz=_("Promień półkuli"),
	units=_("Jednostki"),
	cx=_("Przybranie materiału"),
	pos=_("Posuw"),
	obr=_("Obroty wrzeciona") 
    ) 

    try: 
        defaults.update(pickle.load(open(rc, "rb"))) 
    except (IOError, pickle.PickleError): pass

    vars = {} 
    widgets = {} 
    for j, (k, con) in enumerate(constructors): 
        v = defaults[k] 
        text = texts.get(k, k.replace("_", " ")) 
        lab = Tkinter.Label(f, text=text) 
        widgets[k], vars[k] = con(f, v) 
        lab.grid(row=j, column=0, sticky="w") 
        widgets[k].grid(row=j, column=1, sticky="ew") 



    status = Tkinter.IntVar() 
    bb = Tkinter.Button(b, text=_("OK"), command=lambda:status.set(1), width=8, default="active") 
    bb.pack(side="left", padx=4, pady=4) 
    bc = Tkinter.Button(b, text=_("Cancel"), command=lambda:status.set(-1), width=8, default="normal") 
    bc.pack(side="left", padx=4, pady=4) 
    
    app.bind("<Escape>", lambda evt: bc.invoke()) 
    app.bind("<Return>", lambda evt: bb.invoke()) 
    app.wm_protocol("WM_DELETE_WINDOW", lambda: bc.invoke()) 
    app.wm_resizable(0,0) 

    app.wait_visibility() 
    app.tk.call("after", "idle", ("after", "idle", "focus [tk_focusNext .]")) 
    #app.tk_focusNext().focus() 
    app.wait_variable(status) 

    if status.get() == -1: 
	raise SystemExit(1) 

    for k, v in vars.items(): 
        defaults[k] = v.get() 

    app.destroy() 

    pickle.dump(defaults, open(rc, "wb")) 

    return defaults

unitcodes = ['G21', 'G20'] 
u = ui() 
print unitcodes[u['units']] 


#definiwanie zmiennych - tu wpisujemy wszystkie wcześniej zadeklarowane zmienne.
cx = u['cx'] 
cz = u['cz'] 
pos = u['pos'] 
obr = u['obr'] 
#niżej wstawiamy kod .z ngc podstawiając pod potrzebne zmienne dane z tabelki w kolejności jak wpisane w nią
print """ 
            
( ------------------------------ ) 
( Półkula na końcu walca ) 
( ------------------------------ ) 
( Miki ) 
( Time-stamp: <2012-01-07 02:39> ) 

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

#<promien_kulki> =  % 4.2f
#<przybranie>    =  % 4.2f
#<posuw> = % 4.2f
#<obroty> = % 4.2f
( ------------------------------ ) 
( ------------------------------ ) 



#<walec> = 0

g18 (g7) 
M3 S#<obroty> 

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>]  f#<posuw> 

g0
x [[#<promien_kulki>]+1] 
z1

o100 endwhile ( koniec toczenia ) 


g0 x[#<promien_kulki>+1] 
z0 x[#<promien_kulki>*2+10] 



    """ % ( cz, cx, pos, obr) #  , sw, fps, fpg, fds, fdg, cx, pos, obr tu trzeba również wpisać wszystkie zadeklarowane wcześniej zmienne w kolejności deklarowania. 

print "M30" 
print "%"
Załączniki
czop.txt
(8.7 KiB) Pobrany 392 razy
Ostatnio zmieniony 09 sty 2012, 14:35 przez MlKl, łącznie zmieniany 1 raz.



Tagi:


kamar
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 4
Posty: 16275
Rejestracja: 18 wrz 2010, 06:17
Lokalizacja: Kozienice
Kontakt:

#2

Post napisał: kamar » 09 sty 2012, 00:38

:) Trochę to nie oto mi biegało :) Moja idea jest taka, coby zbudować jeden program zawierający wszystkie procedurki. Pisanie gada na pojedyńcze operacje i wczytywanie do emca za każdym razem to nie dla mnie.
Optymalnie po włączeniu kompa emc ma odpalać się automatycznie z wczytanym np. tokarka.py, zawierającym dostępne procedurki, zbazowany, z włączoną maszyną. Jednym słowem - gotowy do pracy :) Ale pisz, później się poskłada do kupy :)

PS. I ciągle naddatek jest wielokrotnością przybierania :)
Jest to dość ważne bo umożliwia jechanie grubo a ostatnie przejście wykańczająco.
np. 25mm jedziesz z przybraniem 6mm a ostatnie masz 1mm.
W każdą pętlę wstawiasz coś podobnego :

( jezeli nizej limitu to jade max )

o110 if [#<akt_glebokosc> LT #<glebokosc>]
#<akt_glebokosc> = #<glebokosc>
o110 endif

Awatar użytkownika

Autor tematu
MlKl
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 7
Posty: 3706
Rejestracja: 15 sie 2010, 13:44
Lokalizacja: Błonie
Kontakt:

#3

Post napisał: MlKl » 09 sty 2012, 06:23

Kamar - Jak dzieciaka poślesz do szkoły, to mu spuszczasz w...dol, jak na drugi dzień jeszcze magistrem nie zostanie? :)

Weź pod uwagę, że ja G coda pierwszy raz powąchałem trzy dni temu, Pythona - wczoraj. Na CNC realnie nie toczyłem nigdy. Słowem - to są przykłady działających procedur do twórczego rozwijania i uzupełniania. Idea GNU GPL polega na pracy zbiorowej - wszyscy dokładają swoje cegiełki do wspólnego dzieła, i wszyscy korzystają z całości. W dziedzinie pisania procedur pod EMC byłeś tu pierszy, ja chyba jestem drugi. A przynajmniej nie spotkałem tutaj więcej chętnych do dzielenia się swymi pomysłami w tej dziedzinie.

Twój kod jest fajny, i być może będę go rozwijał, ale równie dobrze może być tak, że dopiszę procedurę automatycznie robiącą listę wszystkich pojedynczych procedur zapisanych w osobnych plikach - takich jak moje. Taka filozofia mi bardziej odpowiada, bo to jest łatwiej skalowalne - każdy sobie może w katalog wrzucić dowolnie wybrany zestaw procedur, każdą procedurę łatwo poprawić, żaden problem dodać nową wedle ustalonego szablonu. Z punktu widzenia użytkownika będzie to wyglądać dokładnie tak samo - wczytuje się tylko pierwszy plik, on tworzy i wyświetla listę wyboru procedur, po zatwierdzeniu procedury wciąga se odpowiedni kolejny - ten wyświetla tabelkę, którą wypełniasz, i gotowy G code trafia do EMC. Żeby to zrobić, muszę poznać Pythona lepiej. W jeden dzień jeszcze nikt nie został programistą przez duże P w żadnym języku programowania.

EMC mi się podoba, jest warte spopularyzowania. Ponieważ nie było dotąd żadnego przyzwoitego tutoriala do niego po polsku - piszę takowy w tamtym w wątku , edytuję wciąż pierwszy wpis, i za miesiąc każde dziecko będzie mogło se odpalić EMC, i toczyć - tutek jest pod tokarki, bo to mnie w tej chwili interesuje. Jak ktoś zechce go rozszerzać o inne zastosowania - frezarka, plazma, ploter, cokolwiek innego - będzie fajnie.

A w tej chwili chodzi mi po głowie stworzenie domowego centrum obróbki CNC. Mam żeliwną płytę 150x60x3cm, szlifowaną do mikrona, w tej chwili na tym stoi tylko moja tokarynka. Ale mogę dać podparte wałki na całej długości, dorobić konstrukcję z szynami metr wyżej, i na nich powiesić oś Z. Toto się da rozbudowywać, np jako konik może być dodatkowe wrzeciono ruchome poprzecznie do stołu. Blat roboczy dla frezarki można wtedy zakładać na suport i podstawę tego wrzeciona, może mieć chyba coś ok metr na metr, zakładając, że ma te 50 cm swobody na boki, a wrzeciono z osi Z również. Ino kto toto będzie dźwigał w razie czego...
Ostatnio zmieniony 09 sty 2012, 07:12 przez MlKl, łącznie zmieniany 1 raz.


kamar
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 4
Posty: 16275
Rejestracja: 18 wrz 2010, 06:17
Lokalizacja: Kozienice
Kontakt:

#4

Post napisał: kamar » 09 sty 2012, 06:44

Sorry, jeżeli odebrałeś to jako przytyk ! Chodziło mi raczej o pokazanie kierunku. To co mi jest niezbędnie potrzebne, to mam w takiej czy innej postaci napisane. Parę lat już toczymy i moje lenistwo wie co by chciało ale z czasem krucho. Co mamy to się podzielimy (sekwencje startową jak wyżej), ale nowe rzeczy to piszemy z nożem na gardle :)

Awatar użytkownika

Autor tematu
MlKl
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 7
Posty: 3706
Rejestracja: 15 sie 2010, 13:44
Lokalizacja: Błonie
Kontakt:

#5

Post napisał: MlKl » 09 sty 2012, 06:59

Komunikacja przez neta ma swoją specyfikę - nie odbieramy bodźców niewerbalnych, które w komunikacji face to face stanowią większość przekazu wbrew pozorom. Nie potraktowałem twojego wpisu jako przytyk - po prostu tłumaczę, jak się rzecz ma z mojej strony.

Jak ktoś już dobrze zna temat, pewne kwestie są dla niego taką oczywistością, że nie przychodzi mu do głowy, iż komuś je trzeba tłumaczyć. Tak jak z tym zerowaniem osi na materiale - mając tylko program z wizualizacją, nie jest to wcale takie łatwe do odgadnięcia. Wskazałeś mi kierunek, na dziś mam już gotowe: toczenie stożka od prawej do lewej, zataczanie półkuli również od prawej do lewej, i toczenie czopa na wale z fazkami. Do stożka jeszcze muszę gada dorobić. No i te twoje dopasowanie ostatniego przebiegu. Ale chyba profesjonalnie, to by trzeba opracować procedurę, która umożliwi zdefiniowanie obróbki wykańczającej z doprecyzowaniem grubości zbierania ostatnich warstw i szybkości roboczej dla tych przebiegów. Ale tu właśnie bym potrzebował wskazówek fachowca, bo sam o toczeniu mam pojęcie dość niewielkie, jak mi coś wyjdzie niezbyt gładkie, to se doszlifuję papierem i tyle.


kamar
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 4
Posty: 16275
Rejestracja: 18 wrz 2010, 06:17
Lokalizacja: Kozienice
Kontakt:

#6

Post napisał: kamar » 09 sty 2012, 10:46

MlKl pisze: Ale chyba profesjonalnie, to by trzeba opracować procedurę, która umożliwi zdefiniowanie obróbki wykańczającej z doprecyzowaniem grubości zbierania ostatnich warstw i szybkości roboczej dla tych przebiegów.
Teoretycznie tak ale praktycznie mało potrzebne. Jeżeli masz zrobić tylko na dwa przejścia to pójdzie na tych samych parametrach a jak jest skurówa na wiele przejść to ryzykiem będzie ustawienie wykańczającego od razu. Lepiej ustawić wyżej, zmierzyć i puścić jeszcze raz.

[ Dodano: 2012-01-09, 11:27 ]
Coś mi się zdaje że z tego to tylko g-kody zostaną :) NGCGUI załatwi to najlepiej :)
I gady nie będą sie plenić.

Awatar użytkownika

Autor tematu
MlKl
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 7
Posty: 3706
Rejestracja: 15 sie 2010, 13:44
Lokalizacja: Błonie
Kontakt:

#7

Post napisał: MlKl » 09 sty 2012, 13:36

Oki. Mam już gotową procedurę importu tych pojedynczych procedur - czyli działa tak, jak twoja tokarka.py

Jest plik toczenie.py w którym trzeba tylko edytować pozycje listy rozwijanej, i dowolna ilość plików jak stozek.py otwieranych przez wybór z listy. Łatwiej przygotowywać kolejne pliki z jedną procedurą, niż rozbudowywać w nieskończoność jeden wielki.

Jak dokończę stozek.py i wsadzę we wszystkie tę implementację ostatniego przejazdu noża, spakuję i wrzucę na serwer.

Obrazek

Tego NGCGUIcośtam na razie nie odpaliłem, choć se zainstalowałem testowe EMC - nie chce bydlę ruszyć. Generalnie - każda metoda uproszczenia sobie życia jest dobra. Najlepiej by było powiedzieć tokarce "Wytocz mi kulkę" :)

Awatar użytkownika

jarenio
Specjalista poziom 3 (min. 600)
Specjalista poziom 3 (min. 600)
Posty w temacie: 2
Posty: 672
Rejestracja: 06 paź 2008, 22:48
Lokalizacja: TJE/KR
Kontakt:

#8

Post napisał: jarenio » 09 sty 2012, 15:55

NGCGUI to chyba najlepsze rozwiązanie, bo wszytko załatwiasz pisząc odpowiedni gcode ze zmiennymi, a zrobienie kolejnego okna sprowadza się do dopisania jednej linijki w pliku ini.
Pozdrawiam; Jarek

Awatar użytkownika

Autor tematu
MlKl
Lider FORUM (min. 2000)
Lider FORUM (min. 2000)
Posty w temacie: 7
Posty: 3706
Rejestracja: 15 sie 2010, 13:44
Lokalizacja: Błonie
Kontakt:

#9

Post napisał: MlKl » 11 sty 2012, 08:43

NCGGUI przede wszystkim pozwala na zaprogramowanie całego detalu, o ile mamy gotowe procedury na wszystkie kolejne operacje. Ale dobre jest wrogiem lepszego - o ile hobbysta-maniak chętnie łapie nowinki, o tyle ktoś zajmujący się produkcją może z wprowadzaniem ich czekać aż do wyjścia stabilnej wersji i pozytywnej opinii użytkowników.

Awatar użytkownika

jarenio
Specjalista poziom 3 (min. 600)
Specjalista poziom 3 (min. 600)
Posty w temacie: 2
Posty: 672
Rejestracja: 06 paź 2008, 22:48
Lokalizacja: TJE/KR
Kontakt:

#10

Post napisał: jarenio » 11 sty 2012, 15:31

chodzi Ci o zaprzęgnięcie NGCGUI do stabilnego EMC2 ??
bo jak tak, to nie ma z tym problemu....
co by nie było, to większość użytkowników EMC2 raczej umie korzystać z PCta na poziomie powyżej pasjansa i NK ;)
Pozdrawiam; Jarek

ODPOWIEDZ Poprzedni tematNastępny temat

Wróć do „LinuxCNC (dawniej EMC2)”