Obsługa, Programowanie i Budowa Maszyn Numerycznych
IMPULS3 pisze:Dobrze mądre glowy
Czytając ten dział co i rusz takie wpisy spotykam. Nikt się nie urodził linuxowym, czy emcowym guru. Jednym nauka przychodzi łatwo, i są ciekawi "jak to działa" Przeciętny tokarz chce mieć łatwe w obsłudze i wydajne narzędzie do obsługi swojej tokarki, frezer - frezerki etc.Zanixi pisze:Panowie, problem mam, 2h już czytam i czytam i nie wiem jak się do tego zabrać. Niedługo będę przestawiać sobie tokarynke na cnc. Więc i coś w programowaniu takowej wypadało by się dokształcić.
Ogólnie, bladego pojęcia o tym nie mam. Nawet g-kodów nie znam.
Dlatego chciałbym się dowiedzieć kilku rzeczy w tym temacie, mam nadzieję że znajdzie się ktoś pomocny:)
Po pierwsze, jakiego linuxa/ubutnu czy jak kolwiek inaczej się to nazywa zainstalować sobie na laptopie? Nadmienię, że mam tu Windowsa którego chciałbym zostawić w bierzącym stanie. Na początek wystarczy mi coś co będzie symulować obróbkę (bo i maszyna nie gotowa).
Ubuntu 10.10? Jeżeli tak, to jak się do tego zabrać? Przerażają mnie trochę te linuxy
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 "%"
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 "%"
