def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.useropts = useropts
# use the module basename for the ini file:
self.ini_filename = __name__ + '.save'
# choose widgets and attributes to be retained here:
# this descriptor will not retain any attrbuts,
# but the state of all widgets (HAL widgets and Gtk widgets
# (subject to widget types supported by gladevcp.persistence.accessors())
#self.defaults = { IniFile.vars: dict(),
# IniFile.widgets : widget_defaults(<widgetlist>)
# }
# this descriptor will retain the listed attributes, and only
# HAL widgets state:
self.defaults = { IniFile.vars: { 'afloat' : 1.67, 'anint' : 42, 'abool' : True, 'astring': 'sometext' },
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = False))
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
# it is OK to use self.panel.widgets (all widgets) here because only
# widgets whose state was saved as per descriptor will be restored
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
# TODO: add a signal to check if the relay for spindle-pump is ON
halcomp.newpin("spindle.fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.pump", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp = halcomp
self.builder = builder
self.nhits = 0
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
class HandlerClass:
def on_destroy(self, obj, data=None):
print 'Destroy?'
self.ini.save_state(self)
def on_restore_defaults(self, button, data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = 'savestate.sav'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
def spin_handler(self, obj, data=None):
data = obj.get_text()
if data[-3:] == 'tpi':
obj.set_value(25.4 / float(data[:-3]))
obj.set_position(-1)
elif data[-2:] == 'in':
obj.set_value(25.4 * float(data[:-2]))
obj.set_position(-1)
elif data[-2:] == 'mm':
obj.set_value(float(data[:-2]) / 25.4)
obj.set_position(-1)
elif data[-5:] == 'pitch':
obj.set_value(25.4 / float(data[:-5]))
obj.set_position(-1)
elif data[-2:] in ['/2', '/4', '/8']:
v = data[:-2].split()
if len(v) == 2:
obj.set_value(float(v[0]) + float(v[1]) / float(data[-1:]))
obj.set_position(-1)
elif len(v) == 1:
obj.set_value(float(v[0]) / float(data[-1:]))
obj.set_position(-1)
elif data[-3:] in ['/16', '/32', '/64']:
v = data[:-3].split()
if len(v) == 2:
obj.set_value(float(v[0]) + float(v[1]) / float(data[-2:]))
obj.set_position(-1)
elif len(v) == 1:
obj.set_value(float(v[0]) / float(data[-2:]))
obj.set_position(-1)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = 'savestate.sav'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
# A pin to use a physical switch to start the cycle
self.cycle_start = hal_glib.GPin(
halcomp.newpin('cycle-start', hal.HAL_BIT, hal.HAL_IN))
self.cycle_start.connect('value-changed', self.cycle_pin)
# This catches the signal from Touchy to say that the tab is exposed
t = self.builder.get_object('eventbox1')
t.connect('map-event', self.on_map_event)
t.add_events(gtk.gdk.STRUCTURE_MASK)
self.cmd = linuxcnc.command()
# This conects the expose event to re-draw and scale the SVG frames
t = self.builder.get_object('tabs1')
t.connect_after("expose_event", self.on_expose)
t.connect("destroy", gtk.main_quit)
t.add_events(gtk.gdk.STRUCTURE_MASK)
self.svg = rsvg.Handle(file='LatheMacro.svg', )
self.active = True
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + '.save')
# the dict driving the ini file persistence feature
# a signature checks variable names,types,sections
#
# to see the mechanism at work, do this:
# - run the application, change some values, and exit
# - edit the complex.save file and change a variable name in the widgets or vars section
# for example, rename 'a' to 'z'
# and remove one of the widgets in the widgets section
# - then re-run the application
# during startup, you get a message saying
# "key 'a' in section 'vars' : missing"
# "key 'hal_radiobutton1' in section 'widgets' : missing"
#
# to see how the protection of ini file versus a changed program works,
# change the defaults dict below, for instance remove the 'c' : "a string variable
# then re-run - the signature check at startup should fail, you should get:
# "signature mismatch in ./complex.save - resetting to default"
# and a default ini file is generated
self.defaults = { # these will be saved/restored as method attributes
IniFile.vars: { 'nhits' : 0, 'lifetime_ticks': 0, 'a': 1.67, 'd': True, 'c' : "a string"},
# we're interested restoring state to output HAL widgets only
# NB: this does NOT restore state pf plain gtk objects - set hal_only to False to do this
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(), hal_only=True,output_only = True)),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
# at this point it is ok to refer to restored attributes like self.nhits and self.lifetime_ticks:
self.builder.get_object('hal_button1').set_label("past hits: %d" %
self.nhits)
self.builder.get_object('message').hal_pin.set(self.lifetime_ticks)
self._hal_setup(halcomp, builder)
# demonstrate a slow background timer - granularity is one second
# for a faster timer, use this:
# GLib.timeout_add(5000, self._on_timer_tick)
GLib.timeout_add_seconds(1, self._on_timer_tick)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + '.ini')
self.defaults = {
IniFile.vars: {},
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=True,
output_only=True)),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.c = linuxcnc.command()
self.e = linuxcnc.error_channel()
self.s = linuxcnc.stat()
self.state = hal_glib.GPin(
halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.state.connect('value-changed', self._on_state_changed)
self.motion_type = hal_glib.GPin(
halcomp.newpin('motion_type', hal.HAL_S32, hal.HAL_IN))
self.motion_type.connect('value-changed', self._on_motion_type_changed)
class HandlerClass:
def _on_state_changed(self, hal_pin, data=None):
state = hal_pin.get()
self.builder.get_object("state").set_text(states[state])
def _on_motion_type_changed(self, hal_pin, data=None):
self.builder.get_object("motion_type_label").set_text(
motions[hal_pin.get()])
def on_in_position_changed(self, hal_led, data=None):
if self.state.get() and hal_led.hal_pin.get():
self.s.poll()
posfmt = " ".join(["%-8.4f"] * self.s.axes)
posn = posfmt % self.s.position[:self.s.axes]
print "new_position: ", posn, "motion type=", motions[
self.motion_type.get()]
def on_unix_signal(self, signum, stack_frame):
print "on_unix_signal(): signal %d received, saving state" % (signum)
self.ini.save_state(self)
gtk.main_quit()
self.halcomp.exit()
def on_destroy(self, obj, data=None):
print "on_destroy() - saving state"
self.ini.save_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + '.ini')
self.defaults = {
IniFile.vars: {},
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=True,
output_only=True)),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.c = linuxcnc.command()
self.e = linuxcnc.error_channel()
self.s = linuxcnc.stat()
self.state = hal_glib.GPin(
halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.state.connect('value-changed', self._on_state_changed)
self.motion_type = hal_glib.GPin(
halcomp.newpin('motion_type', hal.HAL_S32, hal.HAL_IN))
self.motion_type.connect('value-changed', self._on_motion_type_changed)
class HandlerClass:
def on_button_press(self,widget,data=None):
print "on_button_press"
self.anint += 1
# show retained attributes as inifile and current values
print "attr\tini\tcurrent"
for k in self.defaults[IniFile.vars].keys():
print "%s\t%s\t%s" % (k,self.defaults[IniFile.vars][k],getattr(self,k,None))
def on_destroy(self,obj,data=None):
'''
save state on application exit
'''
print "on_destroy() - saving state"
self.ini.save_state(self)
def on_restore_defaults(self,button,data=None):
'''
example callback for 'Reset to defaults' button (unused)
'''
print "on_restore_defaults() - setting default state"
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.useropts = useropts
# use the module basename for the ini file:
self.ini_filename = __name__ + '.save'
# choose widgets and attributes to be retained here:
# this descriptor will not retain any attrbuts,
# but the state of all widgets (HAL widgets and Gtk widgets
# (subject to widget types supported by gladevcp.persistence.accessors())
#self.defaults = { IniFile.vars: dict(),
# IniFile.widgets : widget_defaults(<widgetlist>)
# }
# this descriptor will retain the listed attributes, and only
# HAL widgets state:
self.defaults = { IniFile.vars: { 'afloat' : 1.67, 'anint' : 42, 'abool' : True, 'astring': 'sometext' },
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = False))
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
# it is OK to use self.panel.widgets (all widgets) here because only
# widgets whose state was saved as per descriptor will be restored
self.ini.restore_state(self)
class HandlerClass:
def on_button_press(self,widget,data=None):
print("on_button_press")
self.anint += 1
# show retained attributes as inifile and current values
print("attr\tini\tcurrent")
for k in list(self.defaults[IniFile.vars].keys()):
print("%s\t%s\t%s" % (k,self.defaults[IniFile.vars][k],getattr(self,k,None)))
def on_destroy(self,obj,data=None):
'''
save state on application exit
'''
print("on_destroy() - saving state")
self.ini.save_state(self)
def on_restore_defaults(self,button,data=None):
'''
example callback for 'Reset to defaults' button (unused)
'''
print("on_restore_defaults() - setting default state")
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.useropts = useropts
# use the module basename for the ini file:
self.ini_filename = __name__ + '.save'
# choose widgets and attributes to be retained here:
# this descriptor will not retain any attrbuts,
# but the state of all widgets (HAL widgets and Gtk widgets
# (subject to widget types supported by gladevcp.persistence.accessors())
#self.defaults = { IniFile.vars: dict(),
# IniFile.widgets : widget_defaults(<widgetlist>)
# }
# this descriptor will retain the listed attributes, and only
# HAL widgets state:
self.defaults = { IniFile.vars: { 'afloat' : 1.67, 'anint' : 42, 'abool' : True, 'astring': 'sometext' },
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = False))
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
# it is OK to use self.panel.widgets (all widgets) here because only
# widgets whose state was saved as per descriptor will be restored
self.ini.restore_state(self)
def __init__(self, halcomp,builder,useropts,compname):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = __name__ + '.save'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
class HandlerClass:
def _on_state_changed(self,hal_pin,data=None):
state = hal_pin.get()
self.builder.get_object("state").set_text(states[state])
def _on_motion_type_changed(self,hal_pin,data=None):
self.builder.get_object("motion_type_label").set_text(motions[hal_pin.get()])
def on_in_position_changed(self,hal_led,data=None):
if self.state.get() and hal_led.hal_pin.get():
self.s.poll()
posfmt = " ".join(["%-8.4f"] * self.s.axes)
posn = posfmt % self.s.position[:self.s.axes]
print "new_position: ", posn, "motion type=",motions[self.motion_type.get()]
def on_unix_signal(self,signum,stack_frame):
print "on_unix_signal(): signal %d received, saving state" % (signum)
self.ini.save_state(self)
gtk.main_quit()
self.halcomp.exit()
def on_destroy(self,obj,data=None):
print "on_destroy() - saving state"
self.ini.save_state(self)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
(directory,filename) = os.path.split(__file__)
(basename,extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory,basename + '.ini')
self.defaults = { IniFile.vars: { },
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(),
hal_only=True,output_only = True)),
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
self.ini.restore_state(self)
self.c = linuxcnc.command()
self.e = linuxcnc.error_channel()
self.s = linuxcnc.stat()
self.state = hal_glib.GPin(halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.state.connect('value-changed', self._on_state_changed)
self.motion_type = hal_glib.GPin(halcomp.newpin('motion_type', hal.HAL_S32, hal.HAL_IN))
self.motion_type.connect('value-changed', self._on_motion_type_changed)
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
# TODO: add a signal to check if the relay for spindle-pump is ON
halcomp.newpin("spindle.fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.pump", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp = halcomp
self.builder = builder
self.nhits = 0
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = 'savestate.sav'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
"""
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
"""
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + ".ini")
# the dict driving the ini file persistence feature
# a signature checks variable names,types,sections
#
# to see the mechanism at work, do this:
# - run the application, change some values, and exit
# - edit the complex.ini file and change a variable name in the widgets or vars section
# for example, rename 'a' to 'z'
# and remove one of the widgets in the widgets section
# - then re-run the application
# during startup, you get a message saying
# "key 'a' in section 'vars' : missing"
# "key 'hal_radiobutton1' in section 'widgets' : missing"
#
# to see how the protection of ini file versus a changed program works,
# change the defaults dict below, for instance remove the 'c' : "a string variable
# then re-run - the signature check at startup should fail, you should get:
# "signature mismatch in ./complex.ini - resetting to default"
# and a default ini file is generated
self.defaults = { # these will be saved/restored as method attributes
IniFile.vars: {"nhits": 0, "lifetime_ticks": 0, "a": 1.67, "d": True, "c": "a string"},
# we're interested restoring state to output HAL widgets only
# NB: this does NOT restore state pf plain gtk objects - set hal_only to False to do this
IniFile.widgets: widget_defaults(
select_widgets(self.builder.get_objects(), hal_only=True, output_only=True)
),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
# at this point it is ok to refer to restored attributes like self.nhits and self.lifetime_ticks:
self.builder.get_object("hal_button1").set_label("past hits: %d" % self.nhits)
self.builder.get_object("message").hal_pin.set(self.lifetime_ticks)
self._hal_setup(halcomp, builder)
# demonstrate a slow background timer - granularity is one second
# for a faster timer, use this:
# glib.timeout_add(5000, self._on_timer_tick)
glib.timeout_add_seconds(1, self._on_timer_tick)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.useropts = useropts
# use the module basename for the ini file:
self.ini_filename = __name__ + '.save'
# choose widgets and attributes to be retained here:
# this descriptor will not retain any attrbuts,
# but the state of all widgets (HAL widgets and Gtk widgets
# (subject to widget types supported by gladevcp.persistence.accessors())
#self.defaults = { IniFile.vars: dict(),
# IniFile.widgets : widget_defaults(<widgetlist>)
# }
# this descriptor will retain the listed attributes, and only
# HAL widgets state:
self.defaults = { IniFile.vars: { 'afloat' : 1.67, 'anint' : 42, 'abool' : True, 'astring': 'sometext' },
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = False))
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
# it is OK to use self.panel.widgets (all widgets) here because only
# widgets whose state was saved as per descriptor will be restored
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + '.ini')
self.defaults = { # these will be saved/restored as method attributes
IniFile.vars: { 'probe_feed' : 1, 'probe_max': 2, 'plate_thickness': 3, 'z_retract': 4},
# we're interested restoring state to output HAL widgets only
# NB: this does NOT restore state pf plain gtk objects - set hal_only to False to do this
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True)),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
''' self._hal_setup(halcomp,builder) '''
self.change_text = builder.get_object("change-text")
self.halcomp.newpin("number", hal.HAL_FLOAT, hal.HAL_IN)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
def __init__(self,halcomp,builder,useropts):
self.builder = builder
self.halcomp = halcomp
self.defaults = { IniFile.vars : {"laser_milliseconds" : 166}}
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.laser_hertz_value = hal_glib.GPin(halcomp.newpin("laser_hertz_value", hal.HAL_U32, hal.HAL_OUT))
self.lbl_duration_value = self.builder.get_object("lbl_duration_value")
# sets what got loaded in from the ini_file
self.calc_and_set_milliseconds(self.laser_milliseconds)
# self.btn1 = self.builder.get_object("period_50")
# self.btn1.connect("pressed", self.on_btn_pressed, 50)
self.btn1 = self.builder.get_object("period_50")
self.btn1.connect("pressed", self.on_btn_pressed, 50)
self.btn1 = self.builder.get_object("period_100")
self.btn1.connect("pressed", self.on_btn_pressed, 100)
self.btn1 = self.builder.get_object("period_200")
self.btn1.connect("pressed", self.on_btn_pressed, 200)
self.btn1 = self.builder.get_object("period_500")
self.btn1.connect("pressed", self.on_btn_pressed, 500)
self.btn1 = self.builder.get_object("period_700")
self.btn1.connect("pressed", self.on_btn_pressed, 700)
self.btn1 = self.builder.get_object("period_900")
self.btn1.connect("pressed", self.on_btn_pressed, 900)
self.box = self.builder.get_object("tbl_marius") # arbitrary object to test for ending
self.box.connect("destroy", self._on_destroy)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
(directory,filename) = os.path.split(__file__)
(basename,extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory,basename + '.ini')
self.defaults = { IniFile.vars: { },
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(),
hal_only=True,output_only = True)),
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
self.ini.restore_state(self)
self.c = linuxcnc.command()
self.e = linuxcnc.error_channel()
self.s = linuxcnc.stat()
self.state = hal_glib.GPin(halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.state.connect('value-changed', self._on_state_changed)
self.motion_type = hal_glib.GPin(halcomp.newpin('motion_type', hal.HAL_S32, hal.HAL_IN))
self.motion_type.connect('value-changed', self._on_motion_type_changed)
class HandlerClass:
'''
class with gladevcp callback handlers
'''
def _query_emc_status(self, data=None):
(task_mode, task_state, exec_state, interp_state) = self.e.emc_status()
self.builder.get_object('task_mode').set_label("Task mode: " +
task_mode)
self.builder.get_object('task_state').set_label("Task state: " +
task_state)
self.builder.get_object('exec_state').set_label("Exec state: " +
exec_state)
self.builder.get_object('interp_state').set_label("Interp state: " +
interp_state)
# 為了左右邊的 mdi command 訊號可以同步
# if(self.e.spindle_speed() > 0):
# self.builder.get_object('do1').set_active(True) # M3, SPINDLE.FWD
# self.builder.get_object('do2').set_active(False) # M4, SPINDLE.REV
# elif(self.e.spindle_speed() < 0):
# self.builder.get_object('do1').set_active(False) # M3, SPINDLE.FWD
# self.builder.get_object('do2').set_active(True) # M4, SPINDLE.REV
# else:
# self.builder.get_object('do1').set_active(False)
# self.builder.get_object('do2').set_active(False)
# print self.e.active_modes()
# looping: if (task_mode == "MANUAL") and (task_state == "ON") and (exec_state == "DONE") and (interp_state == "IDLE"):
# looping: # print ("task_mode: manual...")
# looping: # print ("about to cycle-start...")
# looping: # if self.emcstat.interp_state == self.emc.INTERP_IDLE:
# looping: self.e.c.mode(linuxcnc.MODE_AUTO)
# looping: self.e.c.wait_complete() # linuxcnc.command
# looping: self.e.c.auto(linuxcnc.AUTO_RUN, 0)
return True
# def on_button_press(self,widget,data=None):
# '''
# a callback method
# parameters are:
# the generating object instance, likte a GtkButton instance
# user data passed if any - this is currently unused but
# the convention should be retained just in case
# '''
# print "on_button_press called"
# self.nhits += 1
# self.builder.get_object('hits').set_label("Hits: %d" % (self.nhits))
def on_destroy(self, obj, data=None):
self.ini.save_state(self)
# def on_do7_toggled(self, widget, data=None):
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
# label = gtk.Label("Click OK to TOOL-RELEASE")
# dialog = gtk.Dialog("TOOL-RELEASE",
# None,
# gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
# (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
# gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
# dialog.vbox.pack_start(label)
# label.show()
#
# response = dialog.run()
# if response == gtk.RESPONSE_ACCEPT:
# print 'on_do7_toggled'
# dialog.destroy()
# if widget.get_active() == True:
# self.e.mdi_command('M64 P8', True) # release tool
# else:
# self.e.mdi_command('M65 P8', True) # clamp tool
# else:
# dialog.destroy()
#
# def on_do1_toggled(self, widget, data=None):
# # print 'debug: on_do1_toggled'
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
# if widget.get_active() == True:
# self.e.mdi_command('M3', True)
# else:
# if(self.e.spindle_speed() != 0):
# self.e.mdi_command('M5', True)
#
# def on_do2_toggled(self, widget, data=None):
# # print 'debug: on_do2_toggled'
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
# if widget.get_active() == True:
# self.e.mdi_command('M4', True)
# else:
# if(self.e.spindle_speed() != 0):
# self.e.mdi_command('M5', True)
#
#
# def on_spindle_brake_toggled(self, widget, data=None):
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
#
# if (self.halcomp['spindle.brake'] == 0):
# self.halcomp['spindle.brake'] = 1
## self.e.mdi_command('M64 P9', True)
# else:
# self.halcomp['spindle.brake'] = 0
## self.e.mdi_command('M65 P9', True)
def on_restore_defaults(self, button, data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def set_theme_font(self):
# set ui theme
config = ConfigParser.ConfigParser()
fn = os.path.expanduser(".touchy_preferences")
config.read(fn)
o = config.get("DEFAULT", 'control_font')
l = config.get("DEFAULT", 'listing_font')
control_font = pango.FontDescription(o)
#control_font = pango.FontDescription("San 24")
# # set spin button font
# for i in ["btn_scan_barcode"]:
# w = self.builder.get_object(i)
# if w:
# w = w.child
# w.modify_font(control_font)
'''set label font'''
self.listing_font = pango.FontDescription(l)
for i in [
"task_mode", "task_state", "exec_state", "interp_state",
"label3", "j4-enc_pos-label", "label6", "current-tool",
"label7", "prepared-tool", "label8", "label9", "label10",
"label11", "label12", "label13", "label14", "label15",
"label16", "label17", "label18", "label19", "label20"
]:
w = self.builder.get_object(i)
if w:
w.modify_font(self.listing_font)
for i in [
"prepared-tool", "current-tool", "j4-enc_pos-label",
"analog_07"
]:
w = self.builder.get_object(i)
if w:
w.modify_font(control_font)
theme_name = config.get("DEFAULT", 'gtk_theme')
settings = gtk.settings_get_default()
settings.set_string_property("gtk-theme-name", theme_name, "")
def _on_update_status(self):
evts = self.zmq_poller.poll(0)
if evts:
msg = self.zmq_server.recv()
'''TODO: 偵測訊息內容'''
if msg:
pass
self.zmq_server.send("message from vbc.py")
return True
def _delayed_sys_init_(self):
self.builder.get_object("task_mode").hide()
self.builder.get_object("task_state").hide()
self.builder.get_object("exec_state").hide()
self.builder.get_object("interp_state").hide()
return False
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
# TODO: add a signal to check if the relay for spindle-pump is ON
halcomp.newpin("spindle.fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.pump", hal.HAL_BIT, hal.HAL_OUT)
halcomp.newpin("spindle.brake", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp = halcomp
self.builder = builder
self.nhits = 0
self.set_theme_font()
self.context = zmq.Context()
self.zmq_server = self.context.socket(zmq.PAIR)
self.zmq_server.bind('tcp://127.0.0.1:5556')
self.zmq_poller = zmq.Poller()
self.zmq_poller.register(self.zmq_server, zmq.POLLIN)
self.zmq_context = zmq.Context()
self.zmq_socket = self.zmq_context.socket(zmq.PUSH)
self.zmq_socket.connect('tcp://127.0.0.1:5555')
self.ini_filename = __name__ + '.ini'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
# program startup
self.timer_id = glib.timeout_add(100, self._delayed_sys_init_)
glib.timeout_add_seconds(1, self._query_emc_status)
glib.timeout_add(100, self._on_update_status)
class LaserClass:
def __init__(self,halcomp,builder,useropts):
self.builder = builder
self.halcomp = halcomp
self.defaults = { IniFile.vars : {"laser_power_val" : 90.0 ,
"laser_power_min" : 1.0 ,
"laser_power_max" : 100.0,
"laser_power_incr" : 1.0,
"spin_oneshot_time" : 1.0}}
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.lbl_program_name = self.builder.get_object("lbl_program_name")
self.laser_on_cont = hal_glib.GPin(halcomp.newpin("laser_on_cont", hal.HAL_BIT, hal.HAL_OUT))
self.laser_pulse = hal_glib.GPin(halcomp.newpin("laser_on_pulse", hal.HAL_BIT, hal.HAL_OUT))
self.laser_pulse_width = hal_glib.GPin(halcomp.newpin("laser_pulse_width", hal.HAL_FLOAT, hal.HAL_OUT))
self.box = self.builder.get_object("hbox1") # arbitrary object to test for ending
self.box.connect("destroy", self._on_destroy)
self.btn_chiller_pressed = self.builder.get_object("btn_chiller")
self.btn_chiller_pressed.connect("pressed", self.on_btn_chiller_pressed)
self.btn_squealer_pressed = self.builder.get_object("squeal_button")
self.btn_squealer_pressed.connect("pressed", self.on_btn_squealer_pressed)
self.mbtn_laser_pressed = self.builder.get_object("mbtn-laser_start")
self.mbtn_laser_pressed.connect("pressed", self.on_mbtn_laser_pressed)
self.mbtn_laser_released = self.builder.get_object("mbtn-laser_start")
self.mbtn_laser_released.connect("released", self.on_mbtn_laser_released)
self.adj_spin_oneshot = self.builder.get_object("spin_adjust")
self.adj_spin_oneshot.connect("value_changed", self.on_adj_spin_oneshot_value_changed)
self.adj_spin_oneshot.set_value(self.spin_oneshot_time)
self.adj_laser_power = self.builder.get_object("slide_adjust")
self.adj_laser_power.connect("value_changed", self.on_adj_laser_power_value_changed)
self.adj_laser_power.upper = self.laser_power_max
self.adj_laser_power.lower = self.laser_power_min
self.adj_laser_power.set_value(self.laser_power_val)
if os.getenv('INI_FILE_NAME'):
ini_file = os.getenv('INI_FILE_NAME')
else:
self.lbl_program_name.set_label("INI_FILE_NAME not set?")
if os.path.isfile(ini_file):
config = ConfigParser.ConfigParser()
config.read(ini_file)
if config.has_option('DISPLAY','PROGRAM_PREFIX') and config.has_option('DISPLAY','PROGRAM_DEFAULT'):
prefix = config.get('DISPLAY','PROGRAM_PREFIX')
prog = config.get('DISPLAY','PROGRAM_DEFAULT')
self.target_path = os.path.join(prefix, prog)
else:
self.lbl_program_name.set_label("ncfile not found")
glib.timeout_add_seconds(1, self.on_timer_tick)
def human_readable_file_date(self, f):
seconds = int(float(time.time()) - float(os.path.getmtime(f)))
value = ''
if seconds < 10:
value = 'NEW'
elif seconds < 60:
value = '%d sec' % seconds
elif seconds < (60 * 2):
value = '%d min' % (seconds / 60)
elif seconds < (2 * 60 * 60):
value = '%d mins' % (seconds / 60)
elif seconds > (60 * 60 * 60):
value = '%dh' % (seconds / (60 * 60 * 60))
else:
value = 'age?'
return (value)
# chows the thing.ngc file and finds the numth occurance of
# of a comment in the form "^(text)"
def extract_headline(self, file_name, num):
f = open(file_name, "r")
tag = self.human_readable_file_date(file_name)
count = 0
for line in f.read().splitlines():
if re.match("^\(.*", line):
if count == (num - 1):
line = re.sub('[\(\))]', '', line)
return('%s (%s)' % (line, tag))
count += 1
def on_btn_squealer_pressed(self, pin, data = None):
print "poked squealer button"
def on_timer_tick(self,userdata=None):
if os.path.isfile(self.target_path):
r = self.extract_headline(self.target_path, 1)
if r:
self.lbl_program_name.set_label(r)
return True # True restarts the timer
def _on_destroy(self, obj, data = None):
self.ini.save_state(self)
def on_btn_chiller_pressed(self, pin, data = None):
print self.halcomp["chiller.is-on"]
def on_mbtn_laser_pressed(self, pin, data = None):
# for milli seconds
self.halcomp["laser_pulse_width"] = self.halcomp["spin_oneshot_time-s"] / float(1000)
# for seconds
# self.halcomp["laser_pulse_width"] = self.halcomp["spin_oneshot_time-s"] / float(1)
if self.halcomp["chkbtn_oneshot"]:
self.halcomp["laser_on_cont"] = 0
self.halcomp["laser_on_pulse"] = 1
else:
self.halcomp["laser_on_cont"] = 1
self.halcomp["laser_on_pulse"] = 0
def on_mbtn_laser_released(self, pin, data = None):
self.halcomp["laser_on_cont"] = 0
self.halcomp["laser_on_pulse"] = 0
def on_adj_laser_power_value_changed(self, pin, data = None):
self.laser_power_val = pin.get_value()
def on_adj_spin_oneshot_value_changed(self, pin, data = None):
self.spin_oneshot_time = pin.get_value()
def on_unix_signal(self,signum,stack_frame):
print "on_unix_signal(): signal %d received, saving state" % (signum)
self.ini.save_state(self)
class HandlerClass:
'''
class with gladevcp callback handlers
'''
def _query_emc_status(self,data=None):
(task_mode, task_state, exec_state, interp_state) = self.e.emc_status()
self.builder.get_object('task_mode').set_label("Task mode: " + task_mode)
self.builder.get_object('task_state').set_label("Task state: " + task_state)
self.builder.get_object('exec_state').set_label("Exec state: " + exec_state)
self.builder.get_object('interp_state').set_label("Interp state: " + interp_state)
# looping: if (task_mode == "MANUAL") and (task_state == "ON") and (exec_state == "DONE") and (interp_state == "IDLE"):
# looping: # print ("task_mode: manual...")
# looping: # print ("about to cycle-start...")
# looping: # if self.emcstat.interp_state == self.emc.INTERP_IDLE:
# looping: self.e.c.mode(linuxcnc.MODE_AUTO)
# looping: self.e.c.wait_complete() # linuxcnc.command
# looping: self.e.c.auto(linuxcnc.AUTO_RUN, 0)
return True
def on_button_press(self,widget,data=None):
'''
a callback method
parameters are:
the generating object instance, likte a GtkButton instance
user data passed if any - this is currently unused but
the convention should be retained just in case
'''
print "on_button_press called"
self.nhits += 1
self.builder.get_object('hits').set_label("Hits: %d" % (self.nhits))
def on_destroy(self,obj,data=None):
self.ini.save_state(self)
def on_restore_defaults(self,button,data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
# TODO: add a signal to check if the relay for spindle-pump is ON
halcomp.newpin("spindle.fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.pump", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp = halcomp
self.builder = builder
self.nhits = 0
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
class HandlerClass:
def set_theme(self):
theme = gtk.settings_get_default().get_property('gtk-theme-name')
if os.path.exists(self.prefFile):
try:
with open(self.prefFile, 'r') as f_in:
for line in f_in:
if 'gtk_theme' in line and not 'Follow System Theme' in line:
(item, theme) = line.strip().replace(" ", "").split('=')
except:
print('*** configuration file, {} is invalid ***'.format(self.prefFile))
gtk.settings_get_default().set_property('gtk-theme-name', theme)
def pierce_count_changed(self,halpin):
if hal.get_value('plasmac_stats.state') >= self.TORCH_ON:
self.PIERCE_COUNT += 1
self.pierce_count += 1
self.builder.get_object('pierce-countT').set_label('{:d}'.format(self.PIERCE_COUNT))
self.builder.get_object('pierce-count').set_label('{:d}'.format(self.pierce_count))
def cut_length_changed(self,halpin):
if halpin.get():
self.thisCutLength = halpin.get()
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-lengthT').set_label('{:.2f} M'.format((self.CUT_LENGTH + self.thisCutLength) * 0.001))
self.builder.get_object('cut-length').set_label('{:.2f} M'.format((self.cut_length + self.thisCutLength) * 0.001))
else:
self.builder.get_object('cut-lengthT').set_label('{:.2f}\"'.format(self.CUT_LENGTH + self.thisCutLength))
self.builder.get_object('cut-length').set_label('{:.2f}\"'.format(self.cut_length + self.thisCutLength))
else:
self.CUT_LENGTH += self.thisCutLength
self.cut_length += self.thisCutLength
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-lengthT').set_label('{:.2f} M'.format(self.CUT_LENGTH * 0.001))
else:
self.builder.get_object('cut-lengthT').set_label('{:.2f}\"'.format(self.CUT_LENGTH))
self.thisCutLength = 0
def cut_time_changed(self,halpin):
if halpin.get():
self.thisCutTime = halpin.get()
self.display_time('cut-timeT', self.CUT_TIME + self.thisCutTime)
self.display_time('cut-time', self.cut_time + self.thisCutTime)
else:
self.CUT_TIME += self.thisCutTime
self.cut_time += self.thisCutTime
self.display_time('cut-timeT', self.CUT_TIME)
thisCutTime = 0
def torch_on_changed(self,halpin):
if halpin.get() and not self.torchOn:
self.torchStart = time.time()
elif not halpin.get() and self.torchOn:
self.TORCH_TIME += (time.time() - self.torchStart)
self.torch_time += (time.time() - self.torchStart)
self.display_time('torch-timeT', self.TORCH_TIME)
self.torchOn = halpin.get()
def prog_run_changed(self,halpin):
if halpin.get() and not self.progRun:
self.clear_job_values()
self.runStart = time.time()
self.progRun = True
def prog_idle_changed(self,halpin):
if halpin.get() and self.progRun:
self.RUN_TIME += (time.time() - self.runStart)
self.display_time('run-timeT', self.RUN_TIME)
self.progRun = False
def motion_type_changed(self,halpin):
if halpin.get() == 1 and self.oldMotionType != 1:
self.rapidStart = time.time()
self.rapidOn = True
elif halpin.get() != 1 and self.oldMotionType == 1:
self.RAPID_TIME += (time.time() - self.rapidStart)
self.rapid_time += (time.time() - self.rapidStart)
self.display_time('rapid-timeT', self.RAPID_TIME)
self.rapidOn = False
self.oldMotionType = halpin.get()
def state_changed(self,halpin):
if halpin.get() == self.PROBE_HEIGHT and self.oldState == self.IDLE:
self.probeStart = time.time()
self.probeOn = True
elif (halpin.get() > self.ZERO_HEIGHT or halpin.get() == self.IDLE) and self.probeOn:
self.PROBE_TIME += (time.time() - self.probeStart)
self.probe_time += (time.time() - self.probeStart)
self.display_time('probe-timeT', self.PROBE_TIME)
self.probeOn = False
self.oldState = halpin.get()
def pierce_reset(self,halbutton):
self.PIERCE_COUNT = 0
self.builder.get_object('pierce-countT').set_label('{:d}'.format(self.PIERCE_COUNT))
def cut_length_reset(self,halbutton):
self.CUT_LENGTH = 0.0
self.builder.get_object('cut-lengthT').set_label('{:.2f}'.format(self.CUT_LENGTH))
def cut_time_reset(self,halbutton):
self.CUT_TIME = 0.0
self.display_time('cut-timeT', self.CUT_TIME)
def torch_time_reset(self,halbutton):
self.TORCH_TIME = 0.0
self.display_time('torch-timeT', self.TORCH_TIME)
def run_time_reset(self,halbutton):
self.RUN_TIME = 0.0
self.display_time('run-timeT', self.RUN_TIME)
def rapid_time_reset(self,halbutton):
self.RAPID_TIME = 0.0
self.display_time('rapid-timeT', self.RAPID_TIME)
def probe_time_reset(self,halbutton):
self.PROBE_TIME = 0.0
self.display_time('probe-timeT', self.PROBE_TIME)
def clear_job_values(self):
self.pierce_count = 0
self.builder.get_object('pierce-count').set_label('{:d}'.format(self.pierce_count))
self.cut_length = 0
self.builder.get_object('cut-length').set_label('{:.2f}'.format(self.cut_length))
self.cut_time = 0
self.display_time('cut-time', self.cut_time)
self.torch_time = 0
self.display_time('torch-time', self.torch_time)
self.display_time('run-time', 0)
self.rapid_time = 0
self.display_time('rapid-time', self.rapid_time)
self.probe_time = 0
self.display_time('probe-time', self.probe_time)
self.torchOn = False
self.progRun = False
self.rapidOn = False
self.probeOn = False
def all_reset(self,halbutton):
self.pierce_reset(0)
self.cut_length_reset(0)
self.cut_time_reset(0)
self.torch_time_reset(0)
self.run_time_reset(0)
self.rapid_time_reset(0)
self.probe_time_reset(0)
def display_time(self,widget,time):
m, s = divmod(time, 60)
h, m = divmod(m, 60)
self.builder.get_object(widget).set_label('{:.0f}:{:02.0f}:{:02.0f}'.format(h,m,s))
def on_stats_box_destroy(self, obj, data = None):
self.ini.save_state(self)
def on_unix_signal(self,signum,stack_frame):
self.ini.save_state(self)
def periodic(self):
if self.torchOn:
self.display_time('torch-timeT', self.TORCH_TIME + (time.time() - self.torchStart))
self.display_time('torch-time', self.torch_time + (time.time() - self.torchStart))
if self.progRun:
self.display_time('run-timeT', self.RUN_TIME + (time.time() - self.runStart))
self.display_time('run-time', time.time() - self.runStart)
if self.rapidOn:
self.display_time('rapid-timeT', self.RAPID_TIME + (time.time() - self.rapidStart))
self.display_time('rapid-time', self.rapid_time + (time.time() - self.rapidStart))
if self.probeOn:
self.display_time('probe-timeT', self.PROBE_TIME + (time.time() - self.probeStart))
self.display_time('probe-time', self.probe_time + (time.time() - self.probeStart))
return True
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.prefFile = self.i.find('LBV', 'MACHINE') + '.pref'
self.set_theme()
self.pierceCount = hal_glib.GPin(halcomp.newpin('pierce-count', hal.HAL_S32, hal.HAL_IN))
self.pierceCount.connect('value-changed', self.pierce_count_changed)
self.cutLength = hal_glib.GPin(halcomp.newpin('cut-length', hal.HAL_FLOAT, hal.HAL_IN))
self.cutLength.connect('value-changed', self.cut_length_changed)
self.cutTime = hal_glib.GPin(halcomp.newpin('cut-time', hal.HAL_FLOAT, hal.HAL_IN))
self.cutTime.connect('value-changed', self.cut_time_changed)
self.torchOn = hal_glib.GPin(halcomp.newpin('torch-on', hal.HAL_BIT, hal.HAL_IN))
self.torchOn.connect('value-changed', self.torch_on_changed)
self.progRun = hal_glib.GPin(halcomp.newpin('program-is-running', hal.HAL_BIT, hal.HAL_IN))
self.progRun.connect('value-changed', self.prog_run_changed)
self.progIdle = hal_glib.GPin(halcomp.newpin('program-is-idle', hal.HAL_BIT, hal.HAL_IN))
self.progIdle.connect('value-changed', self.prog_idle_changed)
self.statePin = hal_glib.GPin(halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.statePin.connect('value-changed', self.state_changed)
self.rapidTime = hal_glib.GPin(halcomp.newpin('motion-type', hal.HAL_S32, hal.HAL_IN))
self.rapidTime.connect('value-changed', self.motion_type_changed)
self.pierceReset = self.builder.get_object('pierce-count-reset')
self.pierceReset.connect('pressed', self.pierce_reset)
self.cutLengthReset = self.builder.get_object('cut-length-reset')
self.cutLengthReset.connect('pressed', self.cut_length_reset)
self.cutTimeReset = self.builder.get_object('cut-time-reset')
self.cutTimeReset.connect('pressed', self.cut_time_reset)
self.torchTimeReset = self.builder.get_object('torch-time-reset')
self.torchTimeReset.connect('pressed', self.torch_time_reset)
self.runTimeReset = self.builder.get_object('run-time-reset')
self.runTimeReset.connect('pressed', self.run_time_reset)
self.rapidTimeReset = self.builder.get_object('rapid-time-reset')
self.rapidTimeReset.connect('pressed', self.rapid_time_reset)
self.probeTimeReset = self.builder.get_object('probe-time-reset')
self.probeTimeReset.connect('pressed', self.probe_time_reset)
self.allReset = self.builder.get_object('all-reset')
self.allReset.connect('pressed', self.all_reset)
# plasmac states
self.IDLE = 0
self.PROBE_HEIGHT = 1
self.PROBE_DOWN = 2
self.PROBE_UP = 3
self.ZERO_HEIGHT = 4
self.PIERCE_HEIGHT = 5
self.TORCH_ON = 6
self.ARC_OK = 7
self.PIERCE_DELAY = 8
self.PUDDLE_JUMP = 9
self.CUT_HEGHT = 10
self.CUTTING = 11
self.SAFE_HEIGHT = 12
self.MAX_HEIGHT = 13
self.FINISH = 14
self.TORCH_PULSE = 15
self.PAUSED_MOTION = 16
self.OHMIC_TEST = 17
self.PROBE_TEST = 18
self.oldState = 0
self.oldMotionType = 0
self.pierce_count = 0
self.cut_length = 0
self.thisCutLength = 0
self.cut_time = 0.0
self.thisCutTime = 0.0
self.torch_time = 0.0
self.torchOn = False
self.progRun = False
self.rapid_time = 0.0
self.rapidOn = False
self.probe_time = 0.0
self.probeOn = False
self.defaults = {IniFile.vars:{"PIERCE_COUNT" : 0,
"CUT_LENGTH" : 0.0,
"CUT_TIME" : 0.0,
"TORCH_TIME" : 0.0,
"RUN_TIME" : 0.0,
"RAPID_TIME" : 0.0,
"PROBE_TIME" : 0.0,
},
}
get_ini_info = getiniinfo.GetIniInfo()
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.builder.get_object('pierce-countT').set_label('{:d}'.format(self.PIERCE_COUNT))
self.builder.get_object('pierce-count').set_label('{:d}'.format(0))
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-lengthT').set_label('{:0.2f} M'.format(self.CUT_LENGTH * 0.001))
self.builder.get_object('cut-length').set_label('{:0.2f} M'.format(0))
else:
self.builder.get_object('cut-lengthT').set_label('{:0.2f}\"'.format(self.CUT_LENGTH))
self.builder.get_object('cut-length').set_label('{:0.2f}\"'.format(0))
self.display_time('cut-timeT', self.CUT_TIME)
self.display_time('torch-timeT', self.TORCH_TIME)
self.display_time('run-timeT', self.RUN_TIME)
self.display_time('rapid-timeT', self.RAPID_TIME)
self.display_time('probe-timeT', self.PROBE_TIME)
gobject.timeout_add(100, self.periodic)
class HandlerClass:
def on_manual_mode(self,widget,data=None):
if self.e.ensure_mode(linuxcnc.MODE_MANUAL):
print "switched to manual mode"
else:
print "cant switch to manual in this state"
def on_mdi_mode(self,widget,data=None):
if self.e.ensure_mode(linuxcnc.MODE_MDI):
print "switched to MDI mode"
else:
print "cant switch to MDI in this state"
def _query_emc_status(self,data=None):
(task_mode, task_state, exec_state, interp_state) = self.e.emc_status()
self.builder.get_object('task_mode').set_label("Task mode: " + task_mode)
self.builder.get_object('task_state').set_label("Task state: " + task_state)
self.builder.get_object('exec_state').set_label("Exec state: " + exec_state)
self.builder.get_object('interp_state').set_label("Interp state: " + interp_state)
return True
def on_probe(self,widget,data=None):
label = widget.get_label()
axis = ord(label[0].lower()) - ord('x')
direction = 1.0
if label[1] == '-':
direction = -1.0
self.e.s.poll()
self.start_feed = self.e.s.settings[1]
# determine system we are touching off - 1...g54 etc
self.current_system = self.e.get_current_system()
# remember current abs or rel mode - g91
self.start_relative = (910 in self.e.active_codes())
self.previous_mode = self.e.s.task_mode
if self.e.s.task_state != linuxcnc.STATE_ON:
print "machine not turned on"
return
if not self.e.s.homed[axis]:
print "%s axis not homed" %(chr(axis + ord('X')))
return
if self.e.running(do_poll=False):
print "cant do that now - intepreter running"
return
self.e.ensure_mode(linuxcnc.MODE_MDI)
self.e.mdi_command("#<_Probe_System> = %d " % (self.current_system ),wait=False)
self.e.mdi_command("#<_Probe_Axis> = %d " % (axis),wait=False)
self.e.mdi_command("#<_Probe_Speed> = %s " % (self.builder.get_object('probe_feed').get_value()),wait=False)
self.e.mdi_command("#<_Probe_Diameter> = %s " % (self.builder.get_object('probe_diameter').get_value() ),wait=False)
self.e.mdi_command("#<_Probe_Distance> = %s " % (self.builder.get_object('probe_travel').get_value() * direction),wait=False)
self.e.mdi_command("#<_Probe_Retract> = %s " % (self.builder.get_object('retract').get_value() * direction * -1.0),wait=False)
self.e.mdi_command("O<probe> call",wait=False)
self.e.mdi_command('F%f' % (self.start_feed),wait=False)
self.e.mdi_command('G91' if self.start_relative else 'G90',wait=False)
# self.e.ensure_mode(self.previous_mode)
def on_destroy(self,obj,data=None):
self.ini.save_state(self)
def on_restore_defaults(self,button,data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
class HandlerClass:
'''
class with gladevcp callback handlers
'''
def on_button_press(self,halwidget,data=None):
'''
a callback method
parameters are:
the generating object instance, like a GtkButton instance
user data passed if any - this is currently unused but
the convention should be retained just in case
'''
print "on_button_press()"
self.nhits += 1
halwidget.set_label("hits: %d" % self.nhits)
def on_toggle_button(self,hal_button,data=None):
'''
standard button-pressed callback. Parameter is the widget object instance.
'''
print "on_toggle_button() HAL pin value: %s" %(str(hal_button.hal_pin.get()))
def _on_example_trigger_change(self,hal_pin,data=None):
'''
executed when the 'example-trigger' hal pin value changes
note that this callback will not be exposed as potential callback
handler through gladevcp since the name begins with an underscore (_) .
Parameter is the HAL pin instance.
'''
print "_on_example_trigger_change() - HAL pin value: %s" % (hal_pin.get())
def on_led_pin_changed(self,hal_led,data=None):
'''
this is an example of a hal-pin-changed signal handler as set in glade.
The purpose of this callback is to deliver an optional notification to your code beyond
just reacting to the changed HAL pin.
the on_led_pin_changed signal is set in the complex.ui hal_led1 signals section
'''
print "on_led_pin_changed() - HAL pin value:",hal_led.hal_pin.get()
def _on_timer_tick(self,userdata=None):
'''
the full glib functionality is available if needed.
here's a timer function which will be called periodically
returning True restarts the timer
returning False makes it a one-shot
'''
self.lifetime_ticks += 1
self.builder.get_object('message').hal_pin.set(self.lifetime_ticks)
return True
def on_unix_signal(self,signum,stack_frame):
print "on_unix_signal(): signal %d received, saving state" % (signum)
self.ini.save_state(self)
gtk.main_quit()
self.halcomp.exit()
def on_destroy(self,obj,data=None):
'''
gladevcp_demo.ui has a destroy callback set in the window1 Gobject
note the widget tree is not safely accessible here any more
'''
print "on_destroy() - saving state)"
self.ini.save_state(self)
def on_restore_defaults(self,button,data=None):
self.ini.create_default_ini()
self.ini.restore_state(self)
self.builder.get_object('hal_button1').set_label("past hits: %d" % self.nhits)
def on_save_settings(self,button,data=None):
print "on_save_settings() - saving state"
self.ini.save_state(self)
def _hal_setup(self,halcomp, builder):
'''
hal related initialisation
'''
# the toplevel window is always named 'window1'. Do not change.
# widgets may be accessed through builder.get_object() and
# builder.get_objects()
self.window1 = self.builder.get_object("window1")
self.led1 = self.builder.get_object("hal_led1")
# standard hal pins not associated with any widget
self.halcomp.newpin("example-out", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp.newpin("example-in", hal.HAL_S32, hal.HAL_IN)
# hal pins with change callback. Also unrelated to any HAL widget.
# When the pin's value changes the callback is executed.
self.example_trigger = hal_glib.GPin(halcomp.newpin('example-trigger', hal.HAL_BIT, hal.HAL_IN))
self.example_trigger.connect('value-changed', self._on_example_trigger_change)
def __init__(self, halcomp,builder,useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
self.halcomp = halcomp
self.builder = builder
(directory,filename) = os.path.split(__file__)
(basename,extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory,basename + '.save')
# the dict driving the ini file persistence feature
# a signature checks variable names,types,sections
#
# to see the mechanism at work, do this:
# - run the application, change some values, and exit
# - edit the complex.save file and change a variable name in the widgets or vars section
# for example, rename 'a' to 'z'
# and remove one of the widgets in the widgets section
# - then re-run the application
# during startup, you get a message saying
# "key 'a' in section 'vars' : missing"
# "key 'hal_radiobutton1' in section 'widgets' : missing"
#
# to see how the protection of ini file versus a changed program works,
# change the defaults dict below, for instance remove the 'c' : "a string variable
# then re-run - the signature check at startup should fail, you should get:
# "signature mismatch in ./complex.save - resetting to default"
# and a default ini file is generated
self.defaults = { # these will be saved/restored as method attributes
IniFile.vars: { 'nhits' : 0, 'lifetime_ticks': 0, 'a': 1.67, 'd': True, 'c' : "a string"},
# we're interested restoring state to output HAL widgets only
# NB: this does NOT restore state pf plain gtk objects - set hal_only to False to do this
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(), hal_only=True,output_only = True)),
}
self.ini = IniFile(self.ini_filename,self.defaults, self.builder)
self.ini.restore_state(self)
# at this point it is ok to refer to restored attributes like self.nhits and self.lifetime_ticks:
self.builder.get_object('hal_button1').set_label("past hits: %d" % self.nhits)
self.builder.get_object('message').hal_pin.set(self.lifetime_ticks)
self._hal_setup(halcomp,builder)
# demonstrate a slow background timer - granularity is one second
# for a faster timer, use this:
# glib.timeout_add(5000, self._on_timer_tick)
glib.timeout_add_seconds(1, self._on_timer_tick)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.i = labvcnc.ini(os.environ['INI_FILE_NAME'])
self.prefFile = self.i.find('LBV', 'MACHINE') + '.pref'
self.set_theme()
self.pierceCount = hal_glib.GPin(halcomp.newpin('pierce-count', hal.HAL_S32, hal.HAL_IN))
self.pierceCount.connect('value-changed', self.pierce_count_changed)
self.cutLength = hal_glib.GPin(halcomp.newpin('cut-length', hal.HAL_FLOAT, hal.HAL_IN))
self.cutLength.connect('value-changed', self.cut_length_changed)
self.cutTime = hal_glib.GPin(halcomp.newpin('cut-time', hal.HAL_FLOAT, hal.HAL_IN))
self.cutTime.connect('value-changed', self.cut_time_changed)
self.torchOn = hal_glib.GPin(halcomp.newpin('torch-on', hal.HAL_BIT, hal.HAL_IN))
self.torchOn.connect('value-changed', self.torch_on_changed)
self.progRun = hal_glib.GPin(halcomp.newpin('program-is-running', hal.HAL_BIT, hal.HAL_IN))
self.progRun.connect('value-changed', self.prog_run_changed)
self.progIdle = hal_glib.GPin(halcomp.newpin('program-is-idle', hal.HAL_BIT, hal.HAL_IN))
self.progIdle.connect('value-changed', self.prog_idle_changed)
self.statePin = hal_glib.GPin(halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.statePin.connect('value-changed', self.state_changed)
self.rapidTime = hal_glib.GPin(halcomp.newpin('motion-type', hal.HAL_S32, hal.HAL_IN))
self.rapidTime.connect('value-changed', self.motion_type_changed)
self.pierceReset = self.builder.get_object('pierce-count-reset')
self.pierceReset.connect('pressed', self.pierce_reset)
self.cutLengthReset = self.builder.get_object('cut-length-reset')
self.cutLengthReset.connect('pressed', self.cut_length_reset)
self.cutTimeReset = self.builder.get_object('cut-time-reset')
self.cutTimeReset.connect('pressed', self.cut_time_reset)
self.torchTimeReset = self.builder.get_object('torch-time-reset')
self.torchTimeReset.connect('pressed', self.torch_time_reset)
self.runTimeReset = self.builder.get_object('run-time-reset')
self.runTimeReset.connect('pressed', self.run_time_reset)
self.rapidTimeReset = self.builder.get_object('rapid-time-reset')
self.rapidTimeReset.connect('pressed', self.rapid_time_reset)
self.probeTimeReset = self.builder.get_object('probe-time-reset')
self.probeTimeReset.connect('pressed', self.probe_time_reset)
self.allReset = self.builder.get_object('all-reset')
self.allReset.connect('pressed', self.all_reset)
# plasmac states
self.IDLE = 0
self.PROBE_HEIGHT = 1
self.PROBE_DOWN = 2
self.PROBE_UP = 3
self.ZERO_HEIGHT = 4
self.PIERCE_HEIGHT = 5
self.TORCH_ON = 6
self.ARC_OK = 7
self.PIERCE_DELAY = 8
self.PUDDLE_JUMP = 9
self.CUT_HEGHT = 10
self.CUTTING = 11
self.SAFE_HEIGHT = 12
self.MAX_HEIGHT = 13
self.FINISH = 14
self.TORCH_PULSE = 15
self.PAUSED_MOTION = 16
self.OHMIC_TEST = 17
self.PROBE_TEST = 18
self.oldState = 0
self.oldMotionType = 0
self.pierce_count = 0
self.cut_length = 0
self.thisCutLength = 0
self.cut_time = 0.0
self.thisCutTime = 0.0
self.torch_time = 0.0
self.torchOn = False
self.progRun = False
self.rapid_time = 0.0
self.rapidOn = False
self.probe_time = 0.0
self.probeOn = False
self.defaults = {IniFile.vars:{"PIERCE_COUNT" : 0,
"CUT_LENGTH" : 0.0,
"CUT_TIME" : 0.0,
"TORCH_TIME" : 0.0,
"RUN_TIME" : 0.0,
"RAPID_TIME" : 0.0,
"PROBE_TIME" : 0.0,
},
}
get_ini_info = getiniinfo.GetIniInfo()
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.builder.get_object('pierce-countT').set_label('{:d}'.format(self.PIERCE_COUNT))
self.builder.get_object('pierce-count').set_label('{:d}'.format(0))
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-lengthT').set_label('{:0.2f} M'.format(self.CUT_LENGTH * 0.001))
self.builder.get_object('cut-length').set_label('{:0.2f} M'.format(0))
else:
self.builder.get_object('cut-lengthT').set_label('{:0.2f}\"'.format(self.CUT_LENGTH))
self.builder.get_object('cut-length').set_label('{:0.2f}\"'.format(0))
self.display_time('cut-timeT', self.CUT_TIME)
self.display_time('torch-timeT', self.TORCH_TIME)
self.display_time('run-timeT', self.RUN_TIME)
self.display_time('rapid-timeT', self.RAPID_TIME)
self.display_time('probe-timeT', self.PROBE_TIME)
gobject.timeout_add(100, self.periodic)
class PWMClass:
def __init__(self,halcomp,builder,useropts):
self.builder = builder
self.halcomp = halcomp
self.defaults = { IniFile.vars : {"laser_milliseconds" : 166}}
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.laser_hertz_value = hal_glib.GPin(halcomp.newpin("laser_hertz_value", hal.HAL_U32, hal.HAL_OUT))
self.lbl_duration_value = self.builder.get_object("lbl_duration_value")
# sets what got loaded in from the ini_file
self.calc_and_set_milliseconds(self.laser_milliseconds)
# self.btn1 = self.builder.get_object("period_50")
# self.btn1.connect("pressed", self.on_btn_pressed, 50)
self.btn1 = self.builder.get_object("period_50")
self.btn1.connect("pressed", self.on_btn_pressed, 50)
self.btn1 = self.builder.get_object("period_100")
self.btn1.connect("pressed", self.on_btn_pressed, 100)
self.btn1 = self.builder.get_object("period_200")
self.btn1.connect("pressed", self.on_btn_pressed, 200)
self.btn1 = self.builder.get_object("period_500")
self.btn1.connect("pressed", self.on_btn_pressed, 500)
self.btn1 = self.builder.get_object("period_700")
self.btn1.connect("pressed", self.on_btn_pressed, 700)
self.btn1 = self.builder.get_object("period_900")
self.btn1.connect("pressed", self.on_btn_pressed, 900)
self.box = self.builder.get_object("tbl_marius") # arbitrary object to test for ending
self.box.connect("destroy", self._on_destroy)
def calc_and_set_milliseconds(self, value):
self.laser_milliseconds = value
if (self.laser_milliseconds < 20):
self.laser_milliseconds = 20
if (self.laser_milliseconds > 990):
self.laser_milliseconds = 990
self.halcomp["laser_hertz_value"] = (1000000 / self.laser_milliseconds)
self.lbl_duration_value.set_label("%d" % self.laser_milliseconds)
os.system("halcmd setp hm2_5i20.0.pwmgen.pwm_frequency %d" % self.halcomp["laser_hertz_value"])
def on_btn_pressed(self, pin, value):
self.calc_and_set_milliseconds(value)
def on_unix_signal(self,signum,stack_frame):
print "on_unix_signal(): signal %d received, saving state" % (signum)
self.ini.save_state(self)
def _on_destroy(self, obj, data = None):
self.ini.save_state(self)
def __init__(self,halcomp,builder,useropts):
self.builder = builder
self.halcomp = halcomp
self.defaults = { IniFile.vars : {"laser_power_val" : 90.0 ,
"laser_power_min" : 1.0 ,
"laser_power_max" : 100.0,
"laser_power_incr" : 1.0,
"spin_oneshot_time" : 1.0}}
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.lbl_program_name = self.builder.get_object("lbl_program_name")
self.laser_on_cont = hal_glib.GPin(halcomp.newpin("laser_on_cont", hal.HAL_BIT, hal.HAL_OUT))
self.laser_pulse = hal_glib.GPin(halcomp.newpin("laser_on_pulse", hal.HAL_BIT, hal.HAL_OUT))
self.laser_pulse_width = hal_glib.GPin(halcomp.newpin("laser_pulse_width", hal.HAL_FLOAT, hal.HAL_OUT))
self.box = self.builder.get_object("hbox1") # arbitrary object to test for ending
self.box.connect("destroy", self._on_destroy)
self.btn_chiller_pressed = self.builder.get_object("btn_chiller")
self.btn_chiller_pressed.connect("pressed", self.on_btn_chiller_pressed)
self.btn_squealer_pressed = self.builder.get_object("squeal_button")
self.btn_squealer_pressed.connect("pressed", self.on_btn_squealer_pressed)
self.mbtn_laser_pressed = self.builder.get_object("mbtn-laser_start")
self.mbtn_laser_pressed.connect("pressed", self.on_mbtn_laser_pressed)
self.mbtn_laser_released = self.builder.get_object("mbtn-laser_start")
self.mbtn_laser_released.connect("released", self.on_mbtn_laser_released)
self.adj_spin_oneshot = self.builder.get_object("spin_adjust")
self.adj_spin_oneshot.connect("value_changed", self.on_adj_spin_oneshot_value_changed)
self.adj_spin_oneshot.set_value(self.spin_oneshot_time)
self.adj_laser_power = self.builder.get_object("slide_adjust")
self.adj_laser_power.connect("value_changed", self.on_adj_laser_power_value_changed)
self.adj_laser_power.upper = self.laser_power_max
self.adj_laser_power.lower = self.laser_power_min
self.adj_laser_power.set_value(self.laser_power_val)
if os.getenv('INI_FILE_NAME'):
ini_file = os.getenv('INI_FILE_NAME')
else:
self.lbl_program_name.set_label("INI_FILE_NAME not set?")
if os.path.isfile(ini_file):
config = ConfigParser.ConfigParser()
config.read(ini_file)
if config.has_option('DISPLAY','PROGRAM_PREFIX') and config.has_option('DISPLAY','PROGRAM_DEFAULT'):
prefix = config.get('DISPLAY','PROGRAM_PREFIX')
prog = config.get('DISPLAY','PROGRAM_DEFAULT')
self.target_path = os.path.join(prefix, prog)
else:
self.lbl_program_name.set_label("ncfile not found")
glib.timeout_add_seconds(1, self.on_timer_tick)
class PlasmaClass:
def __init__(self,halcomp,builder,useropts):
self.builder = builder
self.halcomp = halcomp
self.defaults = { IniFile.vars : { "thcspeedval" : 15.0 ,
"thcspeedmax" : 20.0 ,
"thcspeedmin" : 1.0 ,
"thcspeedincr" : 1.0 ,
"cutgapval" : 4.0 ,
"cutgapmax" : 10.0 ,
"cutgapmin" : 0.1 ,
"cutgapincr" : 0.1 ,
"g0gapval" : 45.0 ,
"g0gapmax" : 55.0 ,
"g0gapmin" : 0.5 ,
"g0gapincr" : 0.5 ,
"pierceutostart" : True ,
"piercegapval" : 5.0 ,
"piercegapmax" : 12.0 ,
"piercegapmin" : 2.0 ,
"piercegapincr" : 0.5 ,
"piercedelayval" : 0.5 ,
"piercedelaymax" : 10.0 ,
"piercedelaymin" : 0.01 ,
"piercedelayincr" : 0.01 ,
"enableheightlock" : False,
"chlthresholdval" : 60.0 ,
"chlthresholdmax" : 100.0,
"chlthresholdmin" : 10.0 ,
"chlthresholdincr" : 10.0 ,
"thctargetvoltval" : 100.0,
"thctargetvoltmax" : 255.0,
"thctargetvoltmin" : 55.0 ,
"thctargetvoltincr" : 5.0 ,
},
IniFile.widgets: widget_defaults(select_widgets([self.builder.get_object("hal-btn-THC"),
], hal_only=True, output_only = True)),
}
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
# lets make our pins
self.THC_speed = hal_glib.GPin(halcomp.newpin("THC-Speed", hal.HAL_FLOAT, hal.HAL_OUT))
self.cut_gap = hal_glib.GPin(halcomp.newpin("Cut-Gap", hal.HAL_FLOAT, hal.HAL_OUT))
self.g0_gap = hal_glib.GPin(halcomp.newpin("G0-Gap", hal.HAL_FLOAT, hal.HAL_OUT))
self.pierce_deley = hal_glib.GPin(halcomp.newpin("Pierce-Delay", hal.HAL_FLOAT, hal.HAL_OUT))
self.pierce_gap = hal_glib.GPin(halcomp.newpin("Pierce-Gap", hal.HAL_FLOAT, hal.HAL_OUT))
self.target_voltage = hal_glib.GPin(halcomp.newpin("Target-Voltage", hal.HAL_FLOAT, hal.HAL_OUT))
# get all widgets and connect them
self.lbl_prog_volt = self.builder.get_object("lbl_prog_volt")
self.lbl_cut_speed = self.builder.get_object("lbl_cut_speed")
self.lbl_cut_gap = self.builder.get_object("lbl_cut_gap")
self.lbl_g0_gap = self.builder.get_object("lbl_g0_gap")
self.lbl_pierce_gap = self.builder.get_object("lbl_pierce_gap")
self.lbl_pierce_delay = self.builder.get_object("lbl_pierce_delay")
self.btn_THC_speed_minus = self.builder.get_object("btn_THC_speed_minus")
self.btn_THC_speed_minus.connect("pressed", self.on_btn_THC_speed_pressed, -1)
self.btn_THC_speed_plus = self.builder.get_object("btn_THC_speed_plus")
self.btn_THC_speed_plus.connect("pressed", self.on_btn_THC_speed_pressed, 1)
self.adj_THC_speed = self.builder.get_object("adj_THC_speed")
self.adj_THC_speed.connect("value_changed", self.on_adj_THC_speed_value_changed)
self.adj_THC_speed.upper = self.thcspeedmax
self.adj_THC_speed.lower = self.thcspeedmin
self.adj_THC_speed.set_value(self.thcspeedval)
self.tbl_cutting = self.builder.get_object("tbl_cutting")
self.tbl_cutting.connect("destroy", self._on_destroy)
self.btn_cut_gap_minus = self.builder.get_object("btn_cut_gap_minus")
self.btn_cut_gap_minus.connect("pressed", self.on_btn_cut_gap_pressed, -1)
self.btn_cut_gap_plus = self.builder.get_object("btn_cut_gap_plus")
self.btn_cut_gap_plus.connect("pressed", self.on_btn_cut_gap_pressed, 1)
self.adj_cut_gap = self.builder.get_object("adj_cut_gap")
self.adj_cut_gap.connect("value_changed", self.on_adj_cut_gap_value_changed)
self.adj_cut_gap.upper = self.cutgapmax
self.adj_cut_gap.lower = self.cutgapmin
self.adj_cut_gap.set_value(self.cutgapval)
self.btn_g0_minus = self.builder.get_object("btn_g0_minus")
self.btn_g0_minus.connect("pressed", self.on_btn_g0_pressed, -1)
self.btn_g0_plus = self.builder.get_object("btn_g0_plus")
self.btn_g0_plus.connect("pressed", self.on_btn_g0_pressed, 1)
self.adj_G0_gap = self.builder.get_object("adj_G0_gap")
self.adj_G0_gap.connect("value_changed", self.on_adj_G0_gap_value_changed)
self.adj_G0_gap.upper = self.g0gapmax
self.adj_G0_gap.lower = self.g0gapmin
self.adj_G0_gap.set_value(self.g0gapval)
self.Piercing_autostart = self.builder.get_object("Piercing-autostart")
self.Piercing_autostart.connect("toggled", self.on_Piercing_autostart_toggled)
self.Piercing_autostart.set_active(self.pierceutostart)
self.btn_pierce_gap_minus = self.builder.get_object("btn_pierce_gap_minus")
self.btn_pierce_gap_minus.connect("pressed", self.on_btn_pierce_gap_pressed, -1)
self.btn_pierce_gap_plus = self.builder.get_object("btn_pierce_gap_plus")
self.btn_pierce_gap_plus.connect("pressed", self.on_btn_pierce_gap_pressed, 1)
self.adj_pierce_gap = self.builder.get_object("adj_pierce_gap")
self.adj_pierce_gap.connect("value_changed", self.on_adj_pierce_gap_value_changed)
self.adj_pierce_gap.upper = self.piercegapmax
self.adj_pierce_gap.lower = self.piercegapmin
self.adj_pierce_gap.set_value(self.piercegapval)
self.btn_pierce_delay_minus = self.builder.get_object("btn_pierce_delay_minus")
self.btn_pierce_delay_minus.connect("pressed", self.on_btn_pierce_delay_pressed, -1)
self.btn_pierce_delay_plus = self.builder.get_object("btn_pierce_delay_plus")
self.btn_pierce_delay_plus.connect("pressed", self.on_btn_pierce_delay_pressed, 1)
self.adj_pierce_delay = self.builder.get_object("adj_pierce_delay")
self.adj_pierce_delay.connect("value_changed", self.on_adj_pierce_delay_value_changed)
self.adj_pierce_delay.upper = self.piercedelaymax
self.adj_pierce_delay.lower = self.piercedelaymin
self.adj_pierce_delay.set_value(self.piercedelayval)
self.enable_HeightLock = self.builder.get_object("enable-HeightLock")
self.enable_HeightLock.connect("toggled", self.on_enable_HeightLock_toggled)
self.enable_HeightLock.set_active(self.enableheightlock)
self.adj_CHL_threshold = self.builder.get_object("adj_CHL_threshold")
self.adj_CHL_threshold.connect("value_changed", self.on_adj_CHL_threshold_value_changed)
self.adj_CHL_threshold.upper = self.chlthresholdmax
self.adj_CHL_threshold.lower = self.chlthresholdmin
self.adj_CHL_threshold.set_value(self.chlthresholdval)
self.btn_THC_target_minus = self.builder.get_object("btn_THC_target_minus")
self.btn_THC_target_minus.connect("pressed", self.on_btn_THC_target_pressed, -1)
self.btn_THC_target_plus = self.builder.get_object("btn_THC_target_plus")
self.btn_THC_target_plus.connect("pressed", self.on_btn_THC_target_pressed, 1)
self.adj_THC_Voltage = self.builder.get_object("adj_THC_Voltage")
self.adj_THC_Voltage.connect("value_changed", self.on_adj_THC_Voltage_value_changed)
self.adj_THC_Voltage.upper = self.thctargetvoltmax
self.adj_THC_Voltage.lower = self.thctargetvoltmin
self.adj_THC_Voltage.set_value(self.thctargetvoltval)
def _on_destroy(self, obj, data = None):
self.ini.save_state(self)
# What to do on button pres events?
def on_btn_THC_speed_pressed(self, widget, dir):
increment = self.thcspeedincr * dir
self.thcspeedval = self.adj_THC_speed.get_value() + increment
self.adj_THC_speed.set_value(self.thcspeedval)
def on_btn_cut_gap_pressed(self, widget, dir):
increment = self.cutgapincr * dir
self.cutgapval = self.adj_cut_gap.get_value() + increment
self.adj_cut_gap.set_value(self.cutgapval)
def on_btn_g0_pressed(self, widget, dir):
increment = self.g0gapincr * dir
self.g0gapval = self.adj_G0_gap.get_value() + increment
self.adj_G0_gap.set_value(self.g0gapval)
def on_btn_pierce_gap_pressed(self, widget, dir):
increment = self.piercegapincr * dir
self.piercegapval = self.adj_pierce_gap.get_value() + increment
self.adj_pierce_gap.set_value(self.piercegapval)
def on_btn_pierce_delay_pressed(self, widget, dir):
increment = self.piercedelayincr * dir
self.piercedelayval = self.adj_pierce_delay.get_value() + increment
self.adj_pierce_delay.set_value(self.piercedelayval)
def on_btn_THC_target_pressed(self, widget, dir):
increment = self.thctargetvoltincr * dir
self.thctargetvoltval = self.adj_THC_Voltage.get_value() + increment
self.adj_THC_Voltage.set_value(self.thctargetvoltval)
# and the behavior of the adjustments to control max and min values
def on_adj_THC_speed_value_changed(self, widget, data=None):
if widget.get_value() >= widget.upper:
self.btn_THC_speed_plus.set_sensitive(False)
elif widget.get_value() <= widget.lower:
self.btn_THC_speed_minus.set_sensitive(False)
else:
self.btn_THC_speed_plus.set_sensitive(True)
self.btn_THC_speed_minus.set_sensitive(True)
self.halcomp["THC-Speed"] = widget.get_value()
self.lbl_cut_speed.set_label("%.1f"%(widget.get_value()))
def on_adj_cut_gap_value_changed(self, widget, data=None):
if widget.get_value() >= widget.upper:
self.btn_cut_gap_plus.set_sensitive(False)
elif widget.get_value() <= widget.lower:
self.btn_cut_gap_minus.set_sensitive(False)
else:
self.btn_cut_gap_plus.set_sensitive(True)
self.btn_cut_gap_minus.set_sensitive(True)
self.halcomp["Cut-Gap"] = widget.get_value()
self.lbl_cut_gap.set_label("%.3f"%(widget.get_value()))
def on_adj_G0_gap_value_changed(self, widget, data=None):
if widget.get_value() >= widget.upper:
self.btn_g0_plus.set_sensitive(False)
elif widget.get_value() <= widget.lower:
self.btn_g0_minus.set_sensitive(False)
else:
self.btn_g0_plus.set_sensitive(True)
self.btn_g0_minus.set_sensitive(True)
self.halcomp["G0-Gap"] = widget.get_value()
self.lbl_g0_gap.set_label("%.3f"%(widget.get_value()))
def on_adj_pierce_gap_value_changed(self, widget, data=None):
if widget.get_value() >= widget.upper:
self.btn_pierce_gap_plus.set_sensitive(False)
elif widget.get_value() <= widget.lower:
self.btn_pierce_gap_minus.set_sensitive(False)
else:
self.btn_pierce_gap_plus.set_sensitive(True)
self.btn_pierce_gap_minus.set_sensitive(True)
self.halcomp["Pierce-Gap"] = widget.get_value()
self.lbl_pierce_gap.set_label("%.3f"%(widget.get_value()))
def on_adj_pierce_delay_value_changed(self, widget, data=None):
if widget.get_value() >= widget.upper:
self.btn_pierce_delay_plus.set_sensitive(False)
elif widget.get_value() <= widget.lower:
self.btn_pierce_delay_minus.set_sensitive(False)
else:
self.btn_pierce_delay_plus.set_sensitive(True)
self.btn_pierce_delay_minus.set_sensitive(True)
self.halcomp["Pierce-Delay"] = widget.get_value()
self.lbl_pierce_delay.set_label("%.2f"%(widget.get_value()))
def on_adj_CHL_threshold_value_changed(self, widget, data=None):
self.chlthresholdval = widget.get_value()
def on_adj_THC_Voltage_value_changed(self, widget, data=None):
if widget.get_value() >= widget.upper:
self.btn_THC_target_plus.set_sensitive(False)
elif widget.get_value() <= widget.lower:
self.btn_THC_target_minus.set_sensitive(False)
else:
self.btn_THC_target_plus.set_sensitive(True)
self.btn_THC_target_minus.set_sensitive(True)
self.halcomp["Target-Voltage"] = widget.get_value()
self.lbl_prog_volt.set_label("%d"%(widget.get_value()))
def on_Piercing_autostart_toggled(self, widget, data=None):
self.pierceutostart = widget.get_active()
def on_enable_HeightLock_toggled(self, widget, data=None):
self.enableheightlock = widget.get_active()
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.i = linuxcnc.ini(os.environ['INI_FILE_NAME'])
self.prefFile = self.i.find('EMC', 'MACHINE') + '.pref'
self.set_theme()
self.statePin = hal_glib.GPin(halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.statePin.connect('value-changed', self.state_changed)
self.pierceCount = hal_glib.GPin(halcomp.newpin('pierce-count', hal.HAL_S32, hal.HAL_IN))
self.pierceCount.connect('value-changed', self.pierce_count_changed)
self.rapidTime = hal_glib.GPin(halcomp.newpin('motion-type', hal.HAL_S32, hal.HAL_IN))
self.rapidTime.connect('value-changed', self.motion_type_changed)
self.pierceReset = self.builder.get_object('pierce-count-reset')
self.pierceReset.connect('pressed', self.pierce_reset)
self.cutDistanceReset = self.builder.get_object('cut-distance-reset')
self.cutDistanceReset.connect('pressed', self.cut_distance_reset)
self.cutTimeReset = self.builder.get_object('cut-time-reset')
self.cutTimeReset.connect('pressed', self.cut_time_reset)
self.rapidTimeReset = self.builder.get_object('rapid-time-reset')
self.rapidTimeReset.connect('pressed', self.rapid_time_reset)
self.probeTimeReset = self.builder.get_object('probe-time-reset')
self.probeTimeReset.connect('pressed', self.probe_time_reset)
self.allReset = self.builder.get_object('all-reset')
self.allReset.connect('pressed', self.all_reset)
# plasmac states
self.IDLE = 0
self.PROBE_HEIGHT = 1
self.PROBE_DOWN = 2
self.PROBE_UP = 3
self.ZERO_HEIGHT = 4
self.PIERCE_HEIGHT = 5
self.TORCH_ON = 6
self.ARC_OK = 7
self.PIERCE_DELAY = 8
self.PUDDLE_JUMP = 9
self.CUT_HEGHT = 10
self.CUTTING = 11
self.SAFE_HEIGHT = 12
self.MAX_HEIGHT = 13
self.FINISH = 14
self.TORCH_PULSE = 15
self.PAUSED_MOTION = 16
self.OHMIC_TEST = 17
self.PROBE_TEST = 18
self.oldState = 0
self.oldMotionType = 0
self.defaults = {IniFile.vars:{"PIERCE_COUNT" : 0,
"CUT_TIME" : 0.0,
"CUT_DISTANCE" : 0.0,
"RAPID_TIME" : 0.0,
"PROBE_TIME" : 0.0,
},
}
get_ini_info = getiniinfo.GetIniInfo()
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.builder.get_object('pierce-count').set_label('%d' %(self.PIERCE_COUNT))
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-distance').set_label('%0.2f M' %(self.CUT_DISTANCE * 0.001))
else:
self.builder.get_object('cut-distance').set_label('%0.2f\"' %(self.CUT_DISTANCE))
self.display_time('cut-time', self.CUT_TIME)
self.display_time('rapid-time', self.RAPID_TIME)
self.display_time('probe-time', self.PROBE_TIME)
class HandlerClass:
def set_theme(self):
theme = gtk.settings_get_default().get_property('gtk-theme-name')
if os.path.exists(self.prefFile):
try:
with open(self.prefFile, 'r') as f_in:
for line in f_in:
if 'gtk_theme' in line and not 'Follow System Theme' in line:
(item, theme) = line.strip().replace(" ", "").split('=')
except:
print '*** configuration file,', self.prefFile, 'is invalid ***'
gtk.settings_get_default().set_property('gtk-theme-name', theme)
def state_changed(self,halpin):
if hal.get_value('plasmac.torch-enable') == 1:
if halpin.get() != self.CUTTING and self.oldState == self.CUTTING:
self.CUT_DISTANCE = self.CUT_DISTANCE + hal.get_value('plasmac.cut-length')
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-distance').set_label('%0.2f M' %(self.CUT_DISTANCE * 0.001))
else:
self.builder.get_object('cut-distance').set_label('%0.2f\"' %(self.CUT_DISTANCE))
self.CUT_TIME = self.CUT_TIME + hal.get_value('plasmac.cut-time')
self.display_time('cut-time', self.CUT_TIME)
elif halpin.get() == self.PROBE_HEIGHT and self.oldState == self.IDLE:
self.probeStart = time.time()
elif halpin.get() > self.ZERO_HEIGHT and (self.oldState >= self.PROBE_HEIGHT and self.oldState <= self.PROBE_UP):
self.PROBE_TIME = self.PROBE_TIME + (time.time() - self.probeStart)
self.display_time('probe-time', self.PROBE_TIME)
self.oldState = halpin.get()
def pierce_count_changed(self,halpin):
if hal.get_value('plasmac_stats.state') >= self.TORCH_ON:
self.PIERCE_COUNT += 1
self.builder.get_object('pierce-count').set_label('%d' %(self.PIERCE_COUNT))
def motion_type_changed(self,halpin):
if hal.get_value('plasmac.torch-enable') == 1:
if halpin.get() == 1 and self.oldMotionType != 1:
self.rapidStart = time.time()
elif halpin.get() != 1 and self.oldMotionType == 1:
self.RAPID_TIME = self.RAPID_TIME + (time.time() - self.rapidStart)
self.display_time('rapid-time', self.RAPID_TIME)
self.oldMotionType = halpin.get()
def pierce_reset(self,halbutton):
self.PIERCE_COUNT = 0
self.builder.get_object('pierce-count').set_label('%d' %(self.PIERCE_COUNT))
def cut_distance_reset(self,halbutton):
self.CUT_DISTANCE = 0.0
self.builder.get_object('cut-distance').set_label('%0.2f' %(self.CUT_DISTANCE))
def cut_time_reset(self,halbutton):
self.CUT_TIME = 0.0
self.display_time('cut-time', self.CUT_TIME)
def rapid_time_reset(self,halbutton):
self.RAPID_TIME = 0.0
self.display_time('rapid-time', self.RAPID_TIME)
def probe_time_reset(self,halbutton):
self.PROBE_TIME = 0.0
self.display_time('probe-time', self.PROBE_TIME)
def all_reset(self,halbutton):
self.pierce_reset(0)
self.cut_distance_reset(0)
self.cut_time_reset(0)
self.rapid_time_reset(0)
self.probe_time_reset(0)
def display_time(self,widget,time):
m, s = divmod(time, 60)
h, m = divmod(m, 60)
self.builder.get_object(widget).set_label('%d:%02d:%02d' %(h,m,s))
def on_stats_box_destroy(self, obj, data = None):
self.ini.save_state(self)
def __init__(self, halcomp,builder,useropts):
self.halcomp = halcomp
self.builder = builder
self.i = linuxcnc.ini(os.environ['INI_FILE_NAME'])
self.prefFile = self.i.find('EMC', 'MACHINE') + '.pref'
self.set_theme()
self.statePin = hal_glib.GPin(halcomp.newpin('state', hal.HAL_S32, hal.HAL_IN))
self.statePin.connect('value-changed', self.state_changed)
self.pierceCount = hal_glib.GPin(halcomp.newpin('pierce-count', hal.HAL_S32, hal.HAL_IN))
self.pierceCount.connect('value-changed', self.pierce_count_changed)
self.rapidTime = hal_glib.GPin(halcomp.newpin('motion-type', hal.HAL_S32, hal.HAL_IN))
self.rapidTime.connect('value-changed', self.motion_type_changed)
self.pierceReset = self.builder.get_object('pierce-count-reset')
self.pierceReset.connect('pressed', self.pierce_reset)
self.cutDistanceReset = self.builder.get_object('cut-distance-reset')
self.cutDistanceReset.connect('pressed', self.cut_distance_reset)
self.cutTimeReset = self.builder.get_object('cut-time-reset')
self.cutTimeReset.connect('pressed', self.cut_time_reset)
self.rapidTimeReset = self.builder.get_object('rapid-time-reset')
self.rapidTimeReset.connect('pressed', self.rapid_time_reset)
self.probeTimeReset = self.builder.get_object('probe-time-reset')
self.probeTimeReset.connect('pressed', self.probe_time_reset)
self.allReset = self.builder.get_object('all-reset')
self.allReset.connect('pressed', self.all_reset)
# plasmac states
self.IDLE = 0
self.PROBE_HEIGHT = 1
self.PROBE_DOWN = 2
self.PROBE_UP = 3
self.ZERO_HEIGHT = 4
self.PIERCE_HEIGHT = 5
self.TORCH_ON = 6
self.ARC_OK = 7
self.PIERCE_DELAY = 8
self.PUDDLE_JUMP = 9
self.CUT_HEGHT = 10
self.CUTTING = 11
self.SAFE_HEIGHT = 12
self.MAX_HEIGHT = 13
self.FINISH = 14
self.TORCH_PULSE = 15
self.PAUSED_MOTION = 16
self.OHMIC_TEST = 17
self.PROBE_TEST = 18
self.oldState = 0
self.oldMotionType = 0
self.defaults = {IniFile.vars:{"PIERCE_COUNT" : 0,
"CUT_TIME" : 0.0,
"CUT_DISTANCE" : 0.0,
"RAPID_TIME" : 0.0,
"PROBE_TIME" : 0.0,
},
}
get_ini_info = getiniinfo.GetIniInfo()
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.builder.get_object('pierce-count').set_label('%d' %(self.PIERCE_COUNT))
if hal.get_value('halui.machine.units-per-mm') == 1:
self.builder.get_object('cut-distance').set_label('%0.2f M' %(self.CUT_DISTANCE * 0.001))
else:
self.builder.get_object('cut-distance').set_label('%0.2f\"' %(self.CUT_DISTANCE))
self.display_time('cut-time', self.CUT_TIME)
self.display_time('rapid-time', self.RAPID_TIME)
self.display_time('probe-time', self.PROBE_TIME)
class HandlerClass:
def on_tool_change_set_xyz_clicked(self, widget, data=None):
s = linuxcnc.stat() # create a connection to the status channel
s.poll() # get current values
self.builder.get_object('tool_change_pos_x').set_value(
s.actual_position[0])
self.builder.get_object('tool_change_pos_y').set_value(
s.actual_position[1])
self.builder.get_object('tool_change_pos_z').set_value(
s.actual_position[2])
def on_tool_probe_set_xyz_clicked(self, widget, data=None):
s = linuxcnc.stat() # create a connection to the status channel
s.poll() # get current values
self.builder.get_object('tool_probe_pos_x').set_value(
s.actual_position[0])
self.builder.get_object('tool_probe_pos_y').set_value(
s.actual_position[1])
self.builder.get_object('tool_probe_pos_z').set_value(
s.actual_position[2])
def on_probe_touchoff_pressed(self, widget, data=None):
print "Probe touch off pressed"
def on_led_change(self, hal_led, data=None):
'''
the gladevcp.change led had a transition
'''
if hal_led.hal_pin.get():
if self.halcomp["number"] > 0.0:
self.change_text.set_label("Insert tool number %d" %
(int(self.halcomp["number"])))
else:
self.change_text.set_label("Remove tool")
else:
self.change_text.set_label("")
def on_unix_signal(self, signum, stack_frame):
print "on_unix_signal(): signal %d received, saving state" % (signum)
self.ini.save_state(self)
gtk.main_quit()
self.halcomp.exit()
def on_destroy(self, obj, data=None):
'''
gladevcp_demo.ui has a destroy callback set in the window1 Gobject
note the widget tree is not safely accessible here any more
'''
print "on_destroy() - saving state)"
self.ini.save_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + '.ini')
self.defaults = { # these will be saved/restored as method attributes
IniFile.vars: { 'probe_feed' : 1, 'probe_max': 2, 'plate_thickness': 3, 'z_retract': 4},
# we're interested restoring state to output HAL widgets only
# NB: this does NOT restore state pf plain gtk objects - set hal_only to False to do this
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True)),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
''' self._hal_setup(halcomp,builder) '''
self.change_text = builder.get_object("change-text")
self.halcomp.newpin("number", hal.HAL_FLOAT, hal.HAL_IN)
class HandlerClass:
'''
class with gladevcp callback handlers
'''
def _query_emc_status(self,data=None):
(task_mode, task_state, exec_state, interp_state) = self.e.emc_status()
self.builder.get_object('task_mode').set_label("Task mode: " + task_mode)
self.builder.get_object('task_state').set_label("Task state: " + task_state)
self.builder.get_object('exec_state').set_label("Exec state: " + exec_state)
self.builder.get_object('interp_state').set_label("Interp state: " + interp_state)
# 為了左右邊的 mdi command 訊號可以同步
if(self.e.spindle_speed() > 0):
self.builder.get_object('do1').set_active(True) # M3, SPINDLE.FWD
self.builder.get_object('do2').set_active(False) # M4, SPINDLE.REV
elif(self.e.spindle_speed() < 0):
self.builder.get_object('do1').set_active(False) # M3, SPINDLE.FWD
self.builder.get_object('do2').set_active(True) # M4, SPINDLE.REV
else:
self.builder.get_object('do1').set_active(False)
self.builder.get_object('do2').set_active(False)
# print self.e.active_modes()
# looping: if (task_mode == "MANUAL") and (task_state == "ON") and (exec_state == "DONE") and (interp_state == "IDLE"):
# looping: # print ("task_mode: manual...")
# looping: # print ("about to cycle-start...")
# looping: # if self.emcstat.interp_state == self.emc.INTERP_IDLE:
# looping: self.e.c.mode(linuxcnc.MODE_AUTO)
# looping: self.e.c.wait_complete() # linuxcnc.command
# looping: self.e.c.auto(linuxcnc.AUTO_RUN, 0)
return True
def on_button_press(self,widget,data=None):
'''
a callback method
parameters are:
the generating object instance, likte a GtkButton instance
user data passed if any - this is currently unused but
the convention should be retained just in case
'''
print "on_button_press called"
self.nhits += 1
self.builder.get_object('hits').set_label("Hits: %d" % (self.nhits))
def on_destroy(self,obj,data=None):
self.ini.save_state(self)
def on_do7_toggled(self, widget, data=None):
if (not self.e.manual_ok(do_poll=True)):
# bypass issuing MDI when program is running
return
label = gtk.Label("Click OK to TOOL-RELEASE")
dialog = gtk.Dialog("TOOL-RELEASE",
None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
dialog.vbox.pack_start(label)
label.show()
response = dialog.run()
if response == gtk.RESPONSE_ACCEPT:
print 'on_do7_toggled'
dialog.destroy()
if widget.get_active() == True:
self.e.mdi_command('M64 P7', True) # release tool
else:
self.e.mdi_command('M65 P7', True) # clamp tool
else:
dialog.destroy()
def on_do1_toggled(self, widget, data=None):
# print 'debug: on_do1_toggled'
if (not self.e.manual_ok(do_poll=True)):
# bypass issuing MDI when program is running
return
if widget.get_active() == True:
self.e.mdi_command('M3', True)
else:
if(self.e.spindle_speed() != 0):
self.e.mdi_command('M5', True)
def on_do2_toggled(self, widget, data=None):
# print 'debug: on_do2_toggled'
if (not self.e.manual_ok(do_poll=True)):
# bypass issuing MDI when program is running
return
if widget.get_active() == True:
self.e.mdi_command('M4', True)
else:
if(self.e.spindle_speed() != 0):
self.e.mdi_command('M5', True)
def on_restore_defaults(self,button,data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
# TODO: add a signal to check if the relay for spindle-pump is ON
halcomp.newpin("spindle.fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.pump", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp = halcomp
self.builder = builder
self.nhits = 0
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
class HandlerClass:
'''
class with gladevcp callback handlers
'''
def on_button_press(self, halwidget, data=None):
'''
a callback method
parameters are:
the generating object instance, like a GtkButton instance
user data passed if any - this is currently unused but
the convention should be retained just in case
'''
print("on_button_press()")
self.nhits += 1
halwidget.set_label("hits: %d" % self.nhits)
def on_toggle_button(self, hal_button, data=None):
'''
standard button-pressed callback. Parameter is the widget object instance.
'''
print("on_toggle_button() HAL pin value: %s" %
(str(hal_button.hal_pin.get())))
def _on_example_trigger_change(self, hal_pin, data=None):
'''
executed when the 'example-trigger' hal pin value changes
note that this callback will not be exposed as potential callback
handler through gladevcp since the name begins with an underscore (_) .
Parameter is the HAL pin instance.
'''
print("_on_example_trigger_change() - HAL pin value: %s" %
(hal_pin.get()))
def on_led_pin_changed(self, hal_led, data=None):
'''
this is an example of a hal-pin-changed signal handler as set in glade.
The purpose of this callback is to deliver an optional notification to your code beyond
just reacting to the changed HAL pin.
the on_led_pin_changed signal is set in the complex.ui hal_led1 signals section
'''
print("on_led_pin_changed() - HAL pin value:", hal_led.hal_pin.get())
def _on_timer_tick(self, userdata=None):
'''
the full glib functionality is available if needed.
here's a timer function which will be called periodically
returning True restarts the timer
returning False makes it a one-shot
'''
self.lifetime_ticks += 1
self.builder.get_object('message').hal_pin.set(self.lifetime_ticks)
return True
def on_unix_signal(self, signum, stack_frame):
print("on_unix_signal(): signal %d received, saving state" % (signum))
self.ini.save_state(self)
gtk.main_quit()
self.halcomp.exit()
def on_destroy(self, obj, data=None):
'''
gladevcp_demo.ui has a destroy callback set in the window1 Gobject
note the widget tree is not safely accessible here any more
'''
print("on_destroy() - saving state)")
self.ini.save_state(self)
def on_restore_defaults(self, button, data=None):
self.ini.create_default_ini()
self.ini.restore_state(self)
self.builder.get_object('hal_button1').set_label("past hits: %d" %
self.nhits)
def on_save_settings(self, button, data=None):
print("on_save_settings() - saving state")
self.ini.save_state(self)
def _hal_setup(self, halcomp, builder):
'''
hal related initialisation
'''
# the toplevel window is always named 'window1'. Do not change.
# widgets may be accessed through builder.get_object() and
# builder.get_objects()
self.window1 = self.builder.get_object("window1")
self.led1 = self.builder.get_object("hal_led1")
# standard hal pins not associated with any widget
self.halcomp.newpin("example-out", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp.newpin("example-in", hal.HAL_S32, hal.HAL_IN)
# hal pins with change callback. Also unrelated to any HAL widget.
# When the pin's value changes the callback is executed.
self.example_trigger = hal_glib.GPin(
halcomp.newpin('example-trigger', hal.HAL_BIT, hal.HAL_IN))
self.example_trigger.connect('value-changed',
self._on_example_trigger_change)
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
self.halcomp = halcomp
self.builder = builder
(directory, filename) = os.path.split(__file__)
(basename, extension) = os.path.splitext(filename)
self.ini_filename = os.path.join(directory, basename + '.save')
# the dict driving the ini file persistence feature
# a signature checks variable names,types,sections
#
# to see the mechanism at work, do this:
# - run the application, change some values, and exit
# - edit the complex.save file and change a variable name in the widgets or vars section
# for example, rename 'a' to 'z'
# and remove one of the widgets in the widgets section
# - then re-run the application
# during startup, you get a message saying
# "key 'a' in section 'vars' : missing"
# "key 'hal_radiobutton1' in section 'widgets' : missing"
#
# to see how the protection of ini file versus a changed program works,
# change the defaults dict below, for instance remove the 'c' : "a string variable
# then re-run - the signature check at startup should fail, you should get:
# "signature mismatch in ./complex.save - resetting to default"
# and a default ini file is generated
self.defaults = { # these will be saved/restored as method attributes
IniFile.vars: { 'nhits' : 0, 'lifetime_ticks': 0, 'a': 1.67, 'd': True, 'c' : "a string"},
# we're interested restoring state to output HAL widgets only
# NB: this does NOT restore state pf plain gtk objects - set hal_only to False to do this
IniFile.widgets: widget_defaults(select_widgets(self.builder.get_objects(), hal_only=True,output_only = True)),
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
# at this point it is ok to refer to restored attributes like self.nhits and self.lifetime_ticks:
self.builder.get_object('hal_button1').set_label("past hits: %d" %
self.nhits)
self.builder.get_object('message').hal_pin.set(self.lifetime_ticks)
self._hal_setup(halcomp, builder)
# demonstrate a slow background timer - granularity is one second
# for a faster timer, use this:
# GLib.timeout_add(5000, self._on_timer_tick)
GLib.timeout_add_seconds(1, self._on_timer_tick)
class HandlerClass:
active = False
tab_num = 0
firstpress = 0
def on_expose(self, nb, data=None):
tab_num = nb.get_current_page()
tab = nb.get_nth_page(tab_num)
cr = tab.window.cairo_create()
cr.set_operator(cairo.OPERATOR_OVER)
x, y, w, h = tab.allocation
sx, sy, sw, sh = self.svg.get_dimension_data()
cr.translate(0, y)
cr.scale(1.0 * w / sw, 1.0 * h / sh)
self.svg.render_cairo(cr=cr, id='#layer%i' % tab_num)
# This catches our messages from another program
def event(self, w, event):
print event.message_type, event.data
if event.message_type == 'Gladevcp':
if event.data[:7] == 'Visible':
self.active = True
else:
self.active = False
# We connect to client-events from the new toplevel widget
def on_map_event(self, widget, data=None):
top = widget.get_toplevel()
print "map event"
top.connect('client-event', self.event)
def on_destroy(self, obj, data=None):
self.ini.save_state(self)
def on_restore_defaults(self, button, data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = 'savestate.sav'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
# A pin to use a physical switch to start the cycle
self.cycle_start = hal_glib.GPin(
halcomp.newpin('cycle-start', hal.HAL_BIT, hal.HAL_IN))
self.cycle_start.connect('value-changed', self.cycle_pin)
# This catches the signal from Touchy to say that the tab is exposed
t = self.builder.get_object('eventbox1')
t.connect('map-event', self.on_map_event)
t.add_events(gtk.gdk.STRUCTURE_MASK)
self.cmd = linuxcnc.command()
# This conects the expose event to re-draw and scale the SVG frames
t = self.builder.get_object('tabs1')
t.connect_after("expose_event", self.on_expose)
t.connect("destroy", gtk.main_quit)
t.add_events(gtk.gdk.STRUCTURE_MASK)
self.svg = rsvg.Handle(file='LatheMacro.svg', )
def show_keyb(self, obj, data=None):
self.active_ctrl = obj
self.keyb = self.builder.get_object('keyboard')
self.entry = self.builder.get_object('entry1')
self.entry.modify_font(pango.FontDescription("courier 42"))
#set text to previous value
self.entry.set_text(self.active_ctrl.get_text())
self.entry.select_region(0, -1)
#clear text
#self.entry.set_text("")
self.firstpress = 1
resp = self.keyb.run()
def keyb_prev_click(self, obj, data=None):
pos = self.entry.get_position()
self.entry.set_text(self.active_ctrl.get_text())
self.entry.set_position(pos)
def keyb_number_click(self, obj, data=None):
dataval = obj.get_label()
entryval = self.entry.get_text()
#do some sanity checking
if '.' in dataval:
if self.firstpress == 0:
tarr = entryval.split('/')
pos = self.entry.get_position()
if len(tarr[0]) >= pos:
#cursor is in the numerator
if '.' in tarr[0]:
return
elif len(tarr) > 1:
if '.' in tarr[1]:
return
if '/' in dataval and '/' in entryval:
return #only one divisor
self.firstpress = 0
#otherwise send the value to the entry box
event = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
data = obj.get_label()
virtkey = int(gtk.gdk.unicode_to_keyval(ord(data[0])))
event.keyval = virtkey
self.entry.emit('key_press_event', event)
def process_entry(self):
self.firstpress = 0
data = self.entry.get_text()
darr = data.split('/')
if len(darr) == 1:
#is a single number
return darr[0]
else:
if float(darr[1]) == 0:
return darr[
0] #not really correct for divide by 0 but this should be fine
else:
value = float(darr[0]) / float(darr[1])
return "%.5f" % value
def keyb_pm_click(self, obj, data=None):
data = self.process_entry()
if data[0] == '-':
data = data[1:]
else:
data = '-' + data
self.entry.set_text(data)
self.entry.set_position(-1)
def keyb_convert_click(self, obj, data=None):
v = float(self.process_entry())
op = obj.get_label()
if op == 'in->mm':
v = v * 25.4
elif op == 'mm->in':
v = v / 25.4
elif op == 'tpi->pitch':
v = 25.4 / v
elif op == 'pitch->tpi':
v = 25.4 / v
self.entry.set_text('%6.4f' % v)
self.entry.set_position(-1)
def keyb_del_click(self, obj, data=None):
data = self.entry.get_text()
pos = self.entry.get_position()
data = data[:(pos - 1)] + data[pos:]
self.entry.set_text(data)
self.entry.set_position(pos - 1)
def keyb_clear_click(self, obj, data=None):
self.entry.set_text("0")
self.entry.select_region(0, -1)
def keyb_cancel_click(self, obj, data=None):
self.keyb.hide()
def keyb_ok_click(self, obj, data=None):
if self.entry.get_text() != '':
self.active_ctrl.set_value(float(self.process_entry()))
self.keyb.hide()
def set_alpha(self, obj, data=None):
cr = obj.window.cairo_create()
cr.set_source_rgba(1.0, 1.0, 1.0, 0.0)
def cycle_pin(self, pin, data=None):
if pin.get() == 0:
return
print 'cycle pin'
if self.active:
nb = self.builder.get_object('tabs1')
print 'current tab', nb.get_current_page()
tab = nb.get_nth_page(nb.get_current_page())
for c in tab.get_children():
if c.name.partition('.')[2] == 'action':
self.cmd.abort()
self.cmd.mode(linuxcnc.MODE_MDI)
self.cmd.wait_complete()
c.emit('clicked')
def gash(self, obj, data=None):
print 'event', data
class HandlerClass:
def on_manual_mode(self, widget, data=None):
if self.e.ensure_mode(linuxcnc.MODE_MANUAL):
print "switched to manual mode"
else:
print "cant switch to manual in this state"
def on_mdi_mode(self, widget, data=None):
if self.e.ensure_mode(linuxcnc.MODE_MDI):
print "switched to MDI mode"
else:
print "cant switch to MDI in this state"
def _query_emc_status(self, data=None):
(task_mode, task_state, exec_state, interp_state) = self.e.emc_status()
self.builder.get_object('task_mode').set_label("Task mode: " +
task_mode)
self.builder.get_object('task_state').set_label("Task state: " +
task_state)
self.builder.get_object('exec_state').set_label("Exec state: " +
exec_state)
self.builder.get_object('interp_state').set_label("Interp state: " +
interp_state)
return True
def on_probe(self, widget, data=None):
label = widget.get_label()
axis = ord(label[0].lower()) - ord('x')
direction = 1.0
if label[1] == '-':
direction = -1.0
self.e.s.poll()
self.start_feed = self.e.s.settings[1]
# determine system we are touching off - 1...g54 etc
self.current_system = self.e.get_current_system()
# remember current abs or rel mode - g91
self.start_relative = (910 in self.e.active_codes())
self.previous_mode = self.e.s.task_mode
if self.e.s.task_state != linuxcnc.STATE_ON:
print "machine not turned on"
return
if not self.e.s.homed[axis]:
print "%s axis not homed" % (chr(axis + ord('X')))
return
if self.e.running(do_poll=False):
print "cant do that now - intepreter running"
return
self.e.ensure_mode(linuxcnc.MODE_MDI)
self.e.mdi_command("#<_Probe_System> = %d " % (self.current_system),
wait=False)
self.e.mdi_command("#<_Probe_Axis> = %d " % (axis), wait=False)
self.e.mdi_command("#<_Probe_Speed> = %s " %
(self.builder.get_object('probe_feed').get_value()),
wait=False)
self.e.mdi_command(
"#<_Probe_Diameter> = %s " %
(self.builder.get_object('probe_diameter').get_value()),
wait=False)
self.e.mdi_command(
"#<_Probe_Distance> = %s " %
(self.builder.get_object('probe_travel').get_value() * direction),
wait=False)
self.e.mdi_command("#<_Probe_Retract> = %s " %
(self.builder.get_object('retract').get_value() *
direction * -1.0),
wait=False)
self.e.mdi_command("O<probe> call", wait=False)
self.e.mdi_command('F%f' % (self.start_feed), wait=False)
self.e.mdi_command('G91' if self.start_relative else 'G90', wait=False)
# self.e.ensure_mode(self.previous_mode)
def on_destroy(self, obj, data=None):
self.ini.save_state(self)
def on_restore_defaults(self, button, data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = __name__ + '.ini'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
glib.timeout_add_seconds(1, self._query_emc_status)
class HandlerClass:
active = False
tab_num = 0
def on_expose(self, nb, data=None):
tab_num = nb.get_current_page()
tab = nb.get_nth_page(tab_num)
cr = tab.window.cairo_create()
cr.set_operator(cairo.OPERATOR_OVER)
x, y, w, h = tab.allocation
sx, sy, sw, sh = self.svg.get_dimension_data()
cr.translate(0, y)
cr.scale(1.0 * w / sw, 1.0 * h / sh)
self.svg.render_cairo(cr=cr, id='#layer%i' % tab_num)
# This catches our messages from another program
def event(self, w, event):
print event.message_type, event.data
if event.message_type == 'Gladevcp':
if event.data[:7] == 'Visible':
self.active = True
else:
self.active = False
# We connect to client-events from the new toplevel widget
def on_map_event(self, widget, data=None):
top = widget.get_toplevel()
print "map event"
top.connect('client-event', self.event)
def on_destroy(self, obj, data=None):
self.ini.save_state(self)
def on_restore_defaults(self, button, data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def __init__(self, halcomp, builder, useropts):
self.halcomp = halcomp
self.builder = builder
self.ini_filename = 'savestate.sav'
self.defaults = {
IniFile.vars:
dict(),
IniFile.widgets:
widget_defaults(
select_widgets(self.builder.get_objects(),
hal_only=False,
output_only=True))
}
self.ini = IniFile(self.ini_filename, self.defaults, self.builder)
self.ini.restore_state(self)
# A pin to use a physical switch to start the cycle
self.cycle_start = hal_glib.GPin(
halcomp.newpin('cycle-start', hal.HAL_BIT, hal.HAL_IN))
self.cycle_start.connect('value-changed', self.cycle_pin)
# This catches the signal from Touchy to say that the tab is exposed
t = self.builder.get_object('eventbox1')
t.connect('map-event', self.on_map_event)
t.add_events(gtk.gdk.STRUCTURE_MASK)
self.cmd = linuxcnc.command()
# This conects the expose event to re-draw and scale the SVG frames
t = self.builder.get_object('tabs1')
t.connect_after("expose_event", self.on_expose)
t.connect("destroy", gtk.main_quit)
t.add_events(gtk.gdk.STRUCTURE_MASK)
self.svg = rsvg.Handle(file='LatheMacro.svg', )
self.active = True
def show_keyb(self, obj, data=None):
self.active_ctrl = obj
self.keyb = self.builder.get_object('keyboard')
self.entry = self.builder.get_object('entry1')
self.entry.modify_font(pango.FontDescription("courier 42"))
resp = self.keyb.run()
def keyb_prev_click(self, obj, data=None):
self.entry.set_text(self.active_ctrl.get_text())
def keyb_number_click(self, obj, data=None):
data = self.entry.get_text()
data = data + obj.get_label()
if data[-2:] in ['/2', '/4', '/8']:
v = data[:-2].split('.')
if len(v) == 2:
data = '%6.3f' % (float(v[0]) + float(v[1]) / float(data[-1:]))
elif len(v) == 1:
data = '%6.3f' % (float(v[0]) / float(data[-1:]))
elif data[-3:] in ['/16', '/32', '/64']:
v = data[:-3].split('.')
if len(v) == 2:
data = '%6.3f' % (float(v[0]) + float(v[1]) / float(data[-2:]))
elif len(v) == 1:
data = '%6.3f' % (float(v[0]) / float(data[-2:]))
self.entry.set_text(data)
def keyb_pm_click(self, obj, data=None):
data = self.entry.get_text()
if data[0] == '-':
data = data[1:]
else:
data = '-' + data
self.entry.set_text(data)
def keyb_convert_click(self, obj, data=None):
v = float(self.entry.get_text())
op = obj.get_label()
if op == 'in->mm':
v = v * 25.4
elif op == 'mm->in':
v = v / 25.4
elif op == 'tpi->pitch':
v = 25.4 / v
elif op == 'pitch->tpi':
v = 25.4 / v
self.entry.set_text('%6.4f' % v)
def keyb_del_click(self, obj, data=None):
data = self.entry.get_text()
data = data[:-1]
self.entry.set_text(data)
def keyb_clear_click(self, obj, data=None):
self.entry.set_text('')
def keyb_cancel_click(self, obj, data=None):
self.keyb.hide()
def keyb_ok_click(self, obj, data=None):
if self.entry.get_text() != '':
self.active_ctrl.set_value(float(self.entry.get_text()))
self.keyb.hide()
def set_alpha(self, obj, data=None):
cr = obj.window.cairo_create()
cr.set_source_rgba(1.0, 1.0, 1.0, 0.0)
def cycle_pin(self, pin, data=None):
if pin.get() == 0:
return
print 'cycle pin'
if self.active:
nb = self.builder.get_object('tabs1')
print 'current tab', nb.get_current_page()
tab = nb.get_nth_page(nb.get_current_page())
for c in tab.get_children():
if c.name.partition('.')[2] == 'action':
self.cmd.abort()
self.cmd.mode(linuxcnc.MODE_MDI)
self.cmd.wait_complete()
c.emit('clicked')
def gash(self, obj, data=None):
print 'event', data
def __init__(self,halcomp,builder,useropts):
self.builder = builder
self.halcomp = halcomp
self.defaults = { IniFile.vars : { "thcspeedval" : 15.0 ,
"thcspeedmax" : 20.0 ,
"thcspeedmin" : 1.0 ,
"thcspeedincr" : 1.0 ,
"cutgapval" : 4.0 ,
"cutgapmax" : 10.0 ,
"cutgapmin" : 0.1 ,
"cutgapincr" : 0.1 ,
"g0gapval" : 45.0 ,
"g0gapmax" : 55.0 ,
"g0gapmin" : 0.5 ,
"g0gapincr" : 0.5 ,
"pierceutostart" : True ,
"piercegapval" : 5.0 ,
"piercegapmax" : 12.0 ,
"piercegapmin" : 2.0 ,
"piercegapincr" : 0.5 ,
"piercedelayval" : 0.5 ,
"piercedelaymax" : 10.0 ,
"piercedelaymin" : 0.01 ,
"piercedelayincr" : 0.01 ,
"enableheightlock" : False,
"chlthresholdval" : 60.0 ,
"chlthresholdmax" : 100.0,
"chlthresholdmin" : 10.0 ,
"chlthresholdincr" : 10.0 ,
"thctargetvoltval" : 100.0,
"thctargetvoltmax" : 255.0,
"thctargetvoltmin" : 55.0 ,
"thctargetvoltincr" : 5.0 ,
},
IniFile.widgets: widget_defaults(select_widgets([self.builder.get_object("hal-btn-THC"),
], hal_only=True, output_only = True)),
}
self.ini_filename = __name__ + ".var"
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
# lets make our pins
self.THC_speed = hal_glib.GPin(halcomp.newpin("THC-Speed", hal.HAL_FLOAT, hal.HAL_OUT))
self.cut_gap = hal_glib.GPin(halcomp.newpin("Cut-Gap", hal.HAL_FLOAT, hal.HAL_OUT))
self.g0_gap = hal_glib.GPin(halcomp.newpin("G0-Gap", hal.HAL_FLOAT, hal.HAL_OUT))
self.pierce_deley = hal_glib.GPin(halcomp.newpin("Pierce-Delay", hal.HAL_FLOAT, hal.HAL_OUT))
self.pierce_gap = hal_glib.GPin(halcomp.newpin("Pierce-Gap", hal.HAL_FLOAT, hal.HAL_OUT))
self.target_voltage = hal_glib.GPin(halcomp.newpin("Target-Voltage", hal.HAL_FLOAT, hal.HAL_OUT))
# get all widgets and connect them
self.lbl_prog_volt = self.builder.get_object("lbl_prog_volt")
self.lbl_cut_speed = self.builder.get_object("lbl_cut_speed")
self.lbl_cut_gap = self.builder.get_object("lbl_cut_gap")
self.lbl_g0_gap = self.builder.get_object("lbl_g0_gap")
self.lbl_pierce_gap = self.builder.get_object("lbl_pierce_gap")
self.lbl_pierce_delay = self.builder.get_object("lbl_pierce_delay")
self.btn_THC_speed_minus = self.builder.get_object("btn_THC_speed_minus")
self.btn_THC_speed_minus.connect("pressed", self.on_btn_THC_speed_pressed, -1)
self.btn_THC_speed_plus = self.builder.get_object("btn_THC_speed_plus")
self.btn_THC_speed_plus.connect("pressed", self.on_btn_THC_speed_pressed, 1)
self.adj_THC_speed = self.builder.get_object("adj_THC_speed")
self.adj_THC_speed.connect("value_changed", self.on_adj_THC_speed_value_changed)
self.adj_THC_speed.upper = self.thcspeedmax
self.adj_THC_speed.lower = self.thcspeedmin
self.adj_THC_speed.set_value(self.thcspeedval)
self.tbl_cutting = self.builder.get_object("tbl_cutting")
self.tbl_cutting.connect("destroy", self._on_destroy)
self.btn_cut_gap_minus = self.builder.get_object("btn_cut_gap_minus")
self.btn_cut_gap_minus.connect("pressed", self.on_btn_cut_gap_pressed, -1)
self.btn_cut_gap_plus = self.builder.get_object("btn_cut_gap_plus")
self.btn_cut_gap_plus.connect("pressed", self.on_btn_cut_gap_pressed, 1)
self.adj_cut_gap = self.builder.get_object("adj_cut_gap")
self.adj_cut_gap.connect("value_changed", self.on_adj_cut_gap_value_changed)
self.adj_cut_gap.upper = self.cutgapmax
self.adj_cut_gap.lower = self.cutgapmin
self.adj_cut_gap.set_value(self.cutgapval)
self.btn_g0_minus = self.builder.get_object("btn_g0_minus")
self.btn_g0_minus.connect("pressed", self.on_btn_g0_pressed, -1)
self.btn_g0_plus = self.builder.get_object("btn_g0_plus")
self.btn_g0_plus.connect("pressed", self.on_btn_g0_pressed, 1)
self.adj_G0_gap = self.builder.get_object("adj_G0_gap")
self.adj_G0_gap.connect("value_changed", self.on_adj_G0_gap_value_changed)
self.adj_G0_gap.upper = self.g0gapmax
self.adj_G0_gap.lower = self.g0gapmin
self.adj_G0_gap.set_value(self.g0gapval)
self.Piercing_autostart = self.builder.get_object("Piercing-autostart")
self.Piercing_autostart.connect("toggled", self.on_Piercing_autostart_toggled)
self.Piercing_autostart.set_active(self.pierceutostart)
self.btn_pierce_gap_minus = self.builder.get_object("btn_pierce_gap_minus")
self.btn_pierce_gap_minus.connect("pressed", self.on_btn_pierce_gap_pressed, -1)
self.btn_pierce_gap_plus = self.builder.get_object("btn_pierce_gap_plus")
self.btn_pierce_gap_plus.connect("pressed", self.on_btn_pierce_gap_pressed, 1)
self.adj_pierce_gap = self.builder.get_object("adj_pierce_gap")
self.adj_pierce_gap.connect("value_changed", self.on_adj_pierce_gap_value_changed)
self.adj_pierce_gap.upper = self.piercegapmax
self.adj_pierce_gap.lower = self.piercegapmin
self.adj_pierce_gap.set_value(self.piercegapval)
self.btn_pierce_delay_minus = self.builder.get_object("btn_pierce_delay_minus")
self.btn_pierce_delay_minus.connect("pressed", self.on_btn_pierce_delay_pressed, -1)
self.btn_pierce_delay_plus = self.builder.get_object("btn_pierce_delay_plus")
self.btn_pierce_delay_plus.connect("pressed", self.on_btn_pierce_delay_pressed, 1)
self.adj_pierce_delay = self.builder.get_object("adj_pierce_delay")
self.adj_pierce_delay.connect("value_changed", self.on_adj_pierce_delay_value_changed)
self.adj_pierce_delay.upper = self.piercedelaymax
self.adj_pierce_delay.lower = self.piercedelaymin
self.adj_pierce_delay.set_value(self.piercedelayval)
self.enable_HeightLock = self.builder.get_object("enable-HeightLock")
self.enable_HeightLock.connect("toggled", self.on_enable_HeightLock_toggled)
self.enable_HeightLock.set_active(self.enableheightlock)
self.adj_CHL_threshold = self.builder.get_object("adj_CHL_threshold")
self.adj_CHL_threshold.connect("value_changed", self.on_adj_CHL_threshold_value_changed)
self.adj_CHL_threshold.upper = self.chlthresholdmax
self.adj_CHL_threshold.lower = self.chlthresholdmin
self.adj_CHL_threshold.set_value(self.chlthresholdval)
self.btn_THC_target_minus = self.builder.get_object("btn_THC_target_minus")
self.btn_THC_target_minus.connect("pressed", self.on_btn_THC_target_pressed, -1)
self.btn_THC_target_plus = self.builder.get_object("btn_THC_target_plus")
self.btn_THC_target_plus.connect("pressed", self.on_btn_THC_target_pressed, 1)
self.adj_THC_Voltage = self.builder.get_object("adj_THC_Voltage")
self.adj_THC_Voltage.connect("value_changed", self.on_adj_THC_Voltage_value_changed)
self.adj_THC_Voltage.upper = self.thctargetvoltmax
self.adj_THC_Voltage.lower = self.thctargetvoltmin
self.adj_THC_Voltage.set_value(self.thctargetvoltval)
class HandlerClass:
'''
class with gladevcp callback handlers
'''
def _query_emc_status(self,data=None):
(task_mode, task_state, exec_state, interp_state) = self.e.emc_status()
self.builder.get_object('task_mode').set_label("Task mode: " + task_mode)
self.builder.get_object('task_state').set_label("Task state: " + task_state)
self.builder.get_object('exec_state').set_label("Exec state: " + exec_state)
self.builder.get_object('interp_state').set_label("Interp state: " + interp_state)
# 為了左右邊的 mdi command 訊號可以同步
# if(self.e.spindle_speed() > 0):
# self.builder.get_object('do1').set_active(True) # M3, SPINDLE.FWD
# self.builder.get_object('do2').set_active(False) # M4, SPINDLE.REV
# elif(self.e.spindle_speed() < 0):
# self.builder.get_object('do1').set_active(False) # M3, SPINDLE.FWD
# self.builder.get_object('do2').set_active(True) # M4, SPINDLE.REV
# else:
# self.builder.get_object('do1').set_active(False)
# self.builder.get_object('do2').set_active(False)
# print self.e.active_modes()
# looping: if (task_mode == "MANUAL") and (task_state == "ON") and (exec_state == "DONE") and (interp_state == "IDLE"):
# looping: # print ("task_mode: manual...")
# looping: # print ("about to cycle-start...")
# looping: # if self.emcstat.interp_state == self.emc.INTERP_IDLE:
# looping: self.e.c.mode(linuxcnc.MODE_AUTO)
# looping: self.e.c.wait_complete() # linuxcnc.command
# looping: self.e.c.auto(linuxcnc.AUTO_RUN, 0)
return True
# def on_button_press(self,widget,data=None):
# '''
# a callback method
# parameters are:
# the generating object instance, likte a GtkButton instance
# user data passed if any - this is currently unused but
# the convention should be retained just in case
# '''
# print "on_button_press called"
# self.nhits += 1
# self.builder.get_object('hits').set_label("Hits: %d" % (self.nhits))
def on_destroy(self,obj,data=None):
self.ini.save_state(self)
# def on_do7_toggled(self, widget, data=None):
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
# label = gtk.Label("Click OK to TOOL-RELEASE")
# dialog = gtk.Dialog("TOOL-RELEASE",
# None,
# gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
# (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
# gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
# dialog.vbox.pack_start(label)
# label.show()
#
# response = dialog.run()
# if response == gtk.RESPONSE_ACCEPT:
# print 'on_do7_toggled'
# dialog.destroy()
# if widget.get_active() == True:
# self.e.mdi_command('M64 P8', True) # release tool
# else:
# self.e.mdi_command('M65 P8', True) # clamp tool
# else:
# dialog.destroy()
#
# def on_do1_toggled(self, widget, data=None):
# # print 'debug: on_do1_toggled'
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
# if widget.get_active() == True:
# self.e.mdi_command('M3', True)
# else:
# if(self.e.spindle_speed() != 0):
# self.e.mdi_command('M5', True)
#
# def on_do2_toggled(self, widget, data=None):
# # print 'debug: on_do2_toggled'
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
# if widget.get_active() == True:
# self.e.mdi_command('M4', True)
# else:
# if(self.e.spindle_speed() != 0):
# self.e.mdi_command('M5', True)
#
#
# def on_spindle_brake_toggled(self, widget, data=None):
# if (not self.e.manual_ok(do_poll=True)):
# # bypass issuing MDI when program is running
# return
#
# if (self.halcomp['spindle.brake'] == 0):
# self.halcomp['spindle.brake'] = 1
## self.e.mdi_command('M64 P9', True)
# else:
# self.halcomp['spindle.brake'] = 0
## self.e.mdi_command('M65 P9', True)
def on_restore_defaults(self,button,data=None):
'''
example callback for 'Reset to defaults' button
currently unused
'''
self.ini.create_default_ini()
self.ini.restore_state(self)
def set_theme_font(self):
# set ui theme
config = ConfigParser.ConfigParser()
fn = os.path.expanduser(".touchy_preferences")
config.read(fn)
o = config.get("DEFAULT", 'control_font')
l = config.get("DEFAULT", 'listing_font')
control_font = pango.FontDescription(o)
#control_font = pango.FontDescription("San 24")
# # set spin button font
# for i in ["btn_scan_barcode"]:
# w = self.builder.get_object(i)
# if w:
# w = w.child
# w.modify_font(control_font)
'''set label font'''
self.listing_font = pango.FontDescription(l)
for i in ["task_mode","task_state","exec_state","interp_state",
"label3","j4-enc_pos-label",
"label6","current-tool","label7","prepared-tool","label8",
"label9","label10","label11","label12","label13","label14","label15",
"label16","label17","label18","label19","label20"]:
w = self.builder.get_object(i)
if w:
w.modify_font(self.listing_font)
for i in ["prepared-tool","current-tool","j4-enc_pos-label","analog_07"]:
w = self.builder.get_object(i)
if w:
w.modify_font(control_font)
theme_name = config.get("DEFAULT", 'gtk_theme')
settings = gtk.settings_get_default()
settings.set_string_property("gtk-theme-name", theme_name, "")
def _on_update_status(self):
evts = self.zmq_poller.poll(0)
if evts:
msg = self.zmq_server.recv()
'''TODO: 偵測訊息內容'''
if msg:
pass
self.zmq_server.send("message from vbc.py")
return True
def _delayed_sys_init_(self):
self.builder.get_object("task_mode").hide()
self.builder.get_object("task_state").hide()
self.builder.get_object("exec_state").hide()
self.builder.get_object("interp_state").hide()
return False
def __init__(self, halcomp, builder, useropts):
'''
Handler classes are instantiated in the following state:
- the widget tree is created, but not yet realized (no toplevel window.show() executed yet)
- the halcomp HAL component is set up and the widhget tree's HAL pins have already been added to it
- it is safe to add more hal pins because halcomp.ready() has not yet been called at this point.
after all handlers are instantiated in command line and get_handlers() order, callbacks will be
connected with connect_signals()/signal_autoconnect()
The builder may be either of libglade or GtkBuilder type depending on the glade file format.
'''
# TODO: add a signal to check if the relay for spindle-pump is ON
halcomp.newpin("spindle.fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-fwd", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.jog-rev", hal.HAL_BIT, hal.HAL_IN)
halcomp.newpin("spindle.pump", hal.HAL_BIT, hal.HAL_OUT)
halcomp.newpin("spindle.brake", hal.HAL_BIT, hal.HAL_OUT)
self.halcomp = halcomp
self.builder = builder
self.nhits = 0
self.set_theme_font()
self.context = zmq.Context()
self.zmq_server = self.context.socket(zmq.PAIR)
self.zmq_server.bind('tcp://127.0.0.1:5556')
self.zmq_poller = zmq.Poller()
self.zmq_poller.register(self.zmq_server, zmq.POLLIN)
self.zmq_context = zmq.Context()
self.zmq_socket = self.zmq_context.socket(zmq.PUSH)
self.zmq_socket.connect('tcp://127.0.0.1:5555')
self.ini_filename = __name__ + '.ini'
self.defaults = { IniFile.vars: dict(),
IniFile.widgets : widget_defaults(select_widgets(self.builder.get_objects(), hal_only=False,output_only = True))
}
self.ini = IniFile(self.ini_filename,self.defaults,self.builder)
self.ini.restore_state(self)
self.e = EmcInterface()
# program startup
self.timer_id = glib.timeout_add(100, self._delayed_sys_init_)
glib.timeout_add_seconds(1, self._query_emc_status)
glib.timeout_add(100, self._on_update_status)
