def main():
"""
Program entry point. Setting up HAL pins and construct the Extruder instance.
"""
c = hal.component("rs-extruder")
c.newpin("connection", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("online", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("estop", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("enable", hal.HAL_BIT, hal.HAL_IN)
c.newpin("running", hal.HAL_BIT, hal.HAL_IN)
c.newparam("steps_per_mm_cube", hal.HAL_FLOAT, hal.HAL_RW)
c['steps_per_mm_cube'] = 4.0 # Some random default. Don't rely on this.
c.newpin("fault.communication", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("heater1.pv", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("heater1.sv", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("heater1.set-sv", hal.HAL_S32, hal.HAL_IN)
c.newpin("heater1.on", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("motor1.pv", hal.HAL_U32, hal.HAL_OUT)
c.newpin("motor1.sv", hal.HAL_U32, hal.HAL_OUT)
c.newpin("motor1.speed", hal.HAL_S32, hal.HAL_IN)
c.newpin("motor1.speed.trigger", hal.HAL_BIT, hal.HAL_IN)
c.newpin("motor1.spindle", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("motor1.spindle.on", hal.HAL_BIT, hal.HAL_IN)
c.newpin("mapp.mcode", hal.HAL_S32, hal.HAL_IN)
c.newpin("mapp.p", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("mapp.q", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("mapp.seqid", hal.HAL_S32, hal.HAL_IN)
c.newpin("mapp.done", hal.HAL_S32, hal.HAL_OUT)
c.ready()
extruder = Extruder(c)
try:
while True:
try:
extruder.execute()
except IOError:
pass
except OSError:
pass
except serial.serialutil.SerialException:
pass
finally:
c['connection'] = 0
c['fault.communication'] = 1
c['estop'] = 1
c['online'] = 0
time.sleep(0.05)
c['estop'] = 0
c['mapp.done'] = c['mapp.seqid']
time.sleep(0.05)
except KeyboardInterrupt:
raise SystemExit
def run(self) :
import hal, time
h = hal.component("compensation")
h.newpin("out", hal.HAL_FLOAT, hal.HAL_OUT)
h.newpin("enable", hal.HAL_BIT, hal.HAL_IN)
h.newpin("x-map", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("y-map", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("reset", hal.HAL_BIT, hal.HAL_IN)
h.newpin("error", hal.HAL_BIT, hal.HAL_OUT)
# ok, lets we are ready, lets go
h.ready()
last_reset = h["reset"]
try:
while 1:
try:
time.sleep(work_thread)
if h["enable"] :
x=h['x-map']
y=h['y-map']
h["out"]=self.get_comp(x,y)
else :
h["out"]=0
if h["reset"] and not last_reset:
self.reset()
last_reset = h["reset"]
except KeyboardInterrupt :
raise SystemExit
except :
h["error"] = False
else :
h["error"] = True
except KeyboardInterrupt:
raise SystemExit
def __init__(self, halName="cnccontrol"):
CNCControl.__init__(self, verbose=True)
self.tk = Timekeeping()
self.h = hal.component(halName)
self.__createHalPins()
self.h.ready()
self.foBalance = ValueBalance(self.h, self.tk,
scalePin="feed-override.scale",
incPin="feed-override.inc",
decPin="feed-override.dec",
feedbackPin="feed-override.value")
self.incJogPlus = {}
self.incJogMinus = {}
for ax in ALL_AXES:
self.incJogPlus[ax] = BitPoke(self.h, self.tk,
"jog.%s.inc-plus" % ax)
self.incJogMinus[ax] = BitPoke(self.h, self.tk,
"jog.%s.inc-minus" % ax)
self.programStop = BitPoke(self.h, self.tk,
"program.stop", cycleMsec=100)
self.spindleStart = BitPoke(self.h, self.tk, "spindle.start")
self.spindleStop = BitPoke(self.h, self.tk, "spindle.stop")
def __init__(self, iocard, component_name, injected_component=None):
self.iocard = iocard
self._handles = []
if injected_component is None:
self.component = hal.component(component_name)
else:
self.component = injected_component
def __init__(self):
print "UserFuncs.__init__()"
myhal = hal.component("myhal")
myhal.newpin("bit", hal.HAL_BIT, hal.HAL_OUT)
myhal.newpin("float", hal.HAL_FLOAT, hal.HAL_OUT)
myhal.newpin("int", hal.HAL_S32, hal.HAL_OUT)
myhal.ready()
self.myhal = myhal #FIXME
self.components["myhal"] = myhal
def setup_pins():
global H
H = hal.component("hal_racktoolchange")
H.newpin("toolnumber", hal.HAL_S32, hal.HAL_IN)
H.newpin("change", hal.HAL_BIT, hal.HAL_IN)
H.newpin("changed", hal.HAL_BIT, hal.HAL_OUT)
H.newpin("spindle_stopped", hal.HAL_BIT, hal.HAL_IN)
H.newpin("tool_secure", hal.HAL_BIT, hal.HAL_IN)
H.newpin("tool_released", hal.HAL_BIT, hal.HAL_IN)
H.newpin("drawbar", hal.HAL_BIT, hal.HAL_OUT)
H.newpin("blow", hal.HAL_BIT, hal.HAL_OUT)
return H
def __init__(self, number=0):
# self.command = emc.command()
# self.status = emc.stat()
self.initGui()
name = "graph"
name += "-%s" % (number)
self.h = hal.component(name)
panel = gladevcp.makepins.GladePanel(self.h, "graph.glade", self.builder, None)
self.h.ready()
def __init__(self) :
# logging.info("koppi-cnc-info.py init")
self.h = hal.component("koppi-cnc-info")
# logging.info("koppi-cnc-info.py ok")
for i in range(0,3):
self.h.newpin("motor-supply-%d" % (i), hal.HAL_FLOAT, hal.HAL_OUT)
self.h.newpin("max-current-%d" % (i), hal.HAL_FLOAT, hal.HAL_OUT)
self.h.newpin("temp-%i" % (i), hal.HAL_S32, hal.HAL_OUT)
self.h.newpin("fan1-rpm", hal.HAL_S32, hal.HAL_OUT)
self.h.newpin("temp1", hal.HAL_FLOAT, hal.HAL_OUT)
self.h.newpin("link-up", hal.HAL_BIT, hal.HAL_IN)
self.h.ready()
def runHal():
#set up hal component
extruder_hal = hal.component("extruder");
extruder_hal.newpin("temp_cmd",hal.HAL_FLOAT,hal.HAL_IN);
extruder_hal.newpin("temp_current",hal.HAL_FLOAT,hal.HAL_OUT);
extruder_hal.newpin("heater_duty_out",hal.HAL_FLOAT,hal.HAL_OUT);
extruder_hal.newpin("motor_duty_out",hal.HAL_FLOAT,hal.HAL_OUT);
extruder_hal.newpin("heater_ok",hal.HAL_BIT,hal.HAL_OUT);
extruder_hal.newpin("heater_enable",hal.HAL_BIT,hal.HAL_IN);
extruder_hal.newpin("motor_enable",hal.HAL_BIT,hal.HAL_IN);
extruder_hal.ready();
#extruder_hal.newpin("fault",hal.HAL_BIT,hal.HAL_OUT);
#default values of gains stored in firmware are probably fine,
#and can be set manually if required
#ex.newpin("igain",hal.HAL_FLOAT,hal.HAL_IN);
#ex.newpin("pgain",hal.HAL_FLOAT,hal.HAL_IN);
#ex.newpin("dgain",hal.HAL_FLOAT,hal.HAL_IN);
#ex.newpin("ff0gain",hal.HAL_FLOAT,hal.HAL_IN);
#ex.newpin("ff1gain",hal.HAL_FLOAT,hal.HAL_IN);
#connect serial port
extruder = Extruder();
try:
while 1:
#copy extruder status via serial interface
#extruder.
newVals = {};
extruder.open();
newVals["ht"] = extruder_hal["temp_cmd"];
newVals["hge"] = float(extruder_hal["heater_enable"]);
newVals["mge"] = float(extruder_hal["motor_enable"]);
extruder.save(newVals);
r = extruder.read();
extruder_hal["temp_current"] = r["hv"];
extruder_hal["heater_duty_out"] = r["hout"];
extruder_hal["motor_duty_out"] = r["mout"];
if r["he"] > 0:
extruder_hal["heater_ok"] = True;
else:
extruder_hal["heater_ok"] = False;
extruder.close();
time.sleep(HAL_POLL_INTERVAL);
except Exception:
exception("Uh, i got an exception");
raise SystemExit;
def __init__(self):
self.hal = hal.component("pendant-menu")
self.hal.newpin("axis-select", hal.HAL_S32, hal.HAL_IN)
self.hal.newpin("multiplier-select", hal.HAL_S32, hal.HAL_IN)
self.hal.newpin("menu1", hal.HAL_BIT, hal.HAL_IN)
self.hal.newpin("menu2", hal.HAL_BIT, hal.HAL_IN)
self.hal.newpin("menu3", hal.HAL_BIT, hal.HAL_IN)
self.hal.newpin("menu4", hal.HAL_BIT, hal.HAL_IN)
self.hal.newpin("enable", hal.HAL_BIT, hal.HAL_IN)
self.hal.newpin("spindle-speed", hal.HAL_FLOAT, hal.HAL_IN)
self.hal.newpin("page", hal.HAL_U32, hal.HAL_OUT)
self.hal.newpin("tool-change", hal.HAL_BIT, hal.HAL_IN)
self.hal.newpin("tool-changed",hal.HAL_BIT, hal.HAL_OUT)
self.hal.newpin("tool-prep-number", hal.HAL_S32, hal.HAL_IN)
self.hal.newpin("jog-wheel", hal.HAL_S32, hal.HAL_IN)
self.hal.ready()
self.stat = emc.stat()
self.cmd = emc.command()
self.loadToolTable()
def create_vcp(master, comp = None, compname="pyvcp"):
"""
create a pyVCP panel
master = Tkinter root window or other master container
comp = HAL component
compname = name of HAL component which is created if comp=None
"""
global pyvcp0, pycomp
pyvcp0 = master
if comp is None:
try:
comp = hal.component(compname)
except:
print "Error: Multiple components with the same name."
sys.exit(0)
pycomp = comp
read_file()
updater()
return comp
def __init__(self):
# create store for all programs on the 'hmi'
self.programs = []
#
# create 1 default program so there is never an empty list
# self.programs.append(motionProgram())
# plus other things we might need to keep
# track here....
self.currentIndex = 0
self.language = ""
self.halComp = hal.component("persistent")
self.halComp.newpin("axis.0.gain", hal.HAL_FLOAT, hal.HAL_IO)
self.halComp.newpin("axis.0.offset", hal.HAL_FLOAT, hal.HAL_IO)
self.halComp.newpin("axis.1.gain", hal.HAL_FLOAT, hal.HAL_IO)
self.halComp.newpin("axis.1.offset", hal.HAL_FLOAT, hal.HAL_IO)
self.halComp.ready()
def __init__(self):
self.builder = gtk.Builder()
self.builder.add_from_file(glade_file)
self.builder.connect_signals(self)
self.connect_signals()
self.halcomp = hal.component("cutmat")
panel = gladevcp.makepins.GladePanel( self.halcomp, glade_file, self.builder, None)
self.window = self.builder.get_object("window1")
self.linuxcnc_ini = linuxcnc.ini(LINUXCNC_INI)
self.window.show()
self.window.connect("key-press-event", self.on_key_down)
self.window.connect("delete-event", self.on_window_destroy)
# init cfg
self.c = linuxcnc.command()
self.err = linuxcnc.error_channel()
# post gui
print "Cutmat: loading postgui hal file"
postgui_halfile = self.linuxcnc_ini.find("HAL", "POSTGUI_HALFILE")
print postgui_halfile
p = subprocess.Popen(['halcmd', '-i', LINUXCNC_INI, "-f", postgui_halfile], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
print out, err
def __init__(self):
sys.excepthook = self.excepthook
INIPATH = None
INITITLE = INFO.TITLE
INIICON = INFO.ICON
usage = "usage: %prog [options] myfile.ui"
parser = OptionParser(usage=usage)
parser.disable_interspersed_args()
parser.add_options(options)
# remove [-ini filepath] that linuxcnc adds if being launched as a screen
# keep a reference of that path
for i in range(len(sys.argv)):
if sys.argv[i] == '-ini':
# delete -ini
del sys.argv[i]
# pop out the ini path
INIPATH = sys.argv.pop(i)
break
(opts, args) = parser.parse_args()
# so web engine can load local images
sys.argv.append("--disable-web-security")
# initialize QApp so we can pop up dialogs now.
self.app = MyApplication(sys.argv)
# we import here so that the QApp is initialized before
# the Notify library is loaded because it uses DBusQtMainLoop
# DBusQtMainLoop must be initialized after to work properly
from qtvcp import qt_makepins, qt_makegui
# ToDo: pass specific log levels as an argument, or use an INI setting
if opts.debug:
# Log level defaults to INFO, so set lower if in debug mode
logger.setGlobalLevel(logger.DEBUG)
if opts.verbose:
# Log level defaults to INFO, so set lowest if in verbose mode
logger.setGlobalLevel(logger.VERBOSE)
LOG.verbose('VERBOSE DEBUGGING ON')
# a specific path has been set to load from or...
# no path set but -ini is present: default qtvcp screen...or
# oops error
if args:
basepath = args[0]
elif INIPATH:
basepath = "qt_cnc"
else:
print(parser.print_help())
sys.exit(0)
# set paths using basename
error = PATH.set_paths(basepath, bool(INIPATH))
if error:
sys.exit(0)
# keep track of python version during this transition
ver = 'Python 3'
#################
# Screen specific
#################
if INIPATH:
LOG.info(
'green<Building A Linuxcnc Main Screen with {}>'.format(ver))
import linuxcnc
# pull info from the INI file
self.inifile = linuxcnc.ini(INIPATH)
self.inipath = INIPATH
# if no handler file specified, use stock test one
if not opts.usermod:
LOG.info('No handler file specified on command line')
target = os.path.join(PATH.CONFIGPATH,
'%s_handler.py' % PATH.BASENAME)
source = os.path.join(PATH.SCREENDIR,
'tester/tester_handler.py')
if PATH.HANDLER is None:
message = ("""
Qtvcp encountered an error; No handler file was found.
Would you like to copy a basic handler file into your config folder?
This handler file will allow display of your screen and basic keyboard jogging.
The new handlerfile's path will be:
%s
Pressing cancel will close linuxcnc.""" % target)
rtn = QtWidgets.QMessageBox.critical(
None, "QTVCP Error", message, QtWidgets.QMessageBox.Ok
| QtWidgets.QMessageBox.Cancel)
if rtn == QtWidgets.QMessageBox.Ok:
try:
shutil.copy(source, target)
except IOError as e:
LOG.critical("Unable to copy handler file. %s" % e)
sys.exit(0)
except:
LOG.critical(
"Unexpected error copying handler file:",
sys.exc_info())
sys.exit(0)
opts.usermod = PATH.HANDLER = target
else:
LOG.critical(
'No handler file found or specified. User requested stopping'
)
else:
opts.usermod = PATH.HANDLER
# specify the HAL component name if missing
if opts.component is None:
LOG.info(
'No HAL component base name specified on command line using: {}'
.format(PATH.BASENAME))
opts.component = PATH.BASENAME
#################
# VCP specific
#################
else:
LOG.info('green<Building A VCP Panel with {}>'.format(ver))
# if no handler file specified, use stock test one
if not opts.usermod:
LOG.info('No handler file specified - using {}'.format(
PATH.HANDLER))
opts.usermod = PATH.HANDLER
# specify the HAL component name if missing
if opts.component is None:
LOG.info(
'No HAL component base name specified - using: {}'.format(
PATH.BASENAME))
opts.component = PATH.BASENAME
############################
# International translation
############################
if PATH.LOCALEDIR is not None:
translator = QtCore.QTranslator()
translator.load(PATH.LOCALEDIR)
self.app.installTranslator(translator)
#QtCore.QCoreApplication.installTranslator(translator)
#print(self.app.translate("MainWindow", 'Machine Log'))
##############
# Build ui
##############
#if there was no component name specified use the xml file name
if opts.component is None:
opts.component = PATH.BASENAME
# initialize HAL
try:
self.halcomp = hal.component(opts.component)
self.hal = Qhal(self.halcomp, hal)
except:
LOG.critical(
"Asking for a HAL component using a name that already exists?")
raise Exception(
'"Asking for a HAL component using a name that already exists?'
)
# initialize the window
window = qt_makegui.VCPWindow(self.hal, PATH)
# give reference to user command line options
if opts.useropts:
window.USEROPTIONS_ = opts.useropts
else:
window.USEROPTIONS_ = None
# load optional user handler file
if opts.usermod:
LOG.debug('Loading the handler file')
window.load_extension(opts.usermod)
try:
window.web_view = QWebView()
except:
window.web_view = None
# do any class patching now
if "class_patch__" in dir(window.handler_instance):
window.handler_instance.class_patch__()
# add filter to catch keyboard events
LOG.debug('Adding the key events filter')
myFilter = qt_makegui.MyEventFilter(window)
self.app.installEventFilter(myFilter)
# actually build the widgets
window.instance()
# title
if INIPATH:
if (INITITLE == ""):
INITITLE = 'QTvcp-Screen-%s' % opts.component
title = INITITLE
else:
title = 'QTvcp-Panel-%s' % opts.component
window.setWindowTitle(title)
# make QT widget HAL pins
self.panel = qt_makepins.QTPanel(self.hal, PATH, window, opts.debug)
# call handler file's initialized function
if opts.usermod:
if "initialized__" in dir(window.handler_instance):
LOG.debug(
'''Calling the handler file's initialized__ function''')
window.handler_instance.initialized__()
# add any external handler override user commands
if INFO.USER_COMMAND_FILE is None:
INFO.USER_COMMAND_FILE = os.path.join(
PATH.CONFIGPATH, '.{}rc'.format(PATH.BASEPATH))
INFO.USER_COMMAND_FILE = INFO.USER_COMMAND_FILE.replace(
'CONFIGFOLDER', PATH.CONFIGPATH)
INFO.USER_COMMAND_FILE = INFO.USER_COMMAND_FILE.replace(
'WORKINGFOLDER', PATH.WORKINGDIR)
window.handler_instance.call_user_command_(window.handler_instance,
INFO.USER_COMMAND_FILE)
# All Widgets should be added now - synch them to linuxcnc
STATUS.forced_update()
# call a HAL file after widgets built
if opts.halfile:
if opts.halfile[-4:] == ".tcl":
cmd = ["haltcl", opts.halfile]
else:
cmd = ["halcmd", "-f", opts.halfile]
res = subprocess.call(cmd, stdout=sys.stdout, stderr=sys.stderr)
if res:
print >> sys.stderr, "'%s' exited with %d" % (' '.join(cmd),
res)
self.shutdown()
# User components are set up so report that we are ready
LOG.debug('Set HAL ready')
self.halcomp.ready()
# embed us into an X11 window (such as AXIS)
if opts.parent:
window = xembed.reparent_qt_to_x11(window, opts.parent)
forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
LOG.critical('Forwarding events to AXIS is not well tested yet')
if forward:
xembed.XEmbedFowarding(window, forward)
# push the window id for embedment into an external program
if opts.push_XID:
wid = int(window.winId())
print(wid, file=sys.stdout)
sys.stdout.flush()
# for window resize and or position options
if "+" in opts.geometry:
LOG.debug('-g option: moving window')
try:
j = opts.geometry.partition("+")
pos = j[2].partition("+")
window.move(int(pos[0]), int(pos[2]))
except Exception as e:
LOG.critical("With -g window position data:\n {}".format(e))
parser.print_help()
self.shutdown()
if "x" in opts.geometry:
LOG.debug('-g option: resizing')
try:
if "+" in opts.geometry:
j = opts.geometry.partition("+")
t = j[0].partition("x")
else:
t = opts.geometry.partition("x")
window.resize(int(t[0]), int(t[2]))
except Exception as e:
LOG.critical("With -g window resize data:\n {}".format(e))
parser.print_help()
self.shutdown()
# always on top
if opts.always_top:
window.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
# theme (styles in QT speak) specify a qss file
if opts.theme:
window.apply_styles(opts.theme)
# apply qss file or default theme
else:
window.apply_styles()
LOG.debug('Show window')
# maximize
if opts.maximum:
window.showMaximized()
# fullscreen
elif opts.fullscreen:
window.showFullScreen()
else:
self.panel.set_preference_geometry()
window.show()
if INIPATH:
self.postgui()
self.postgui_cmd()
if (INIICON == ""):
window.setWindowIcon(
QtGui.QIcon(os.path.join(PATH.IMAGEDIR,
'linuxcncicon.png')))
else:
window.setWindowIcon(
QtGui.QIcon(os.path.join(PATH.CONFIGPATH, INIICON)))
else:
window.setWindowIcon(
QtGui.QIcon(os.path.join(PATH.IMAGEDIR,
'linuxcnc-wizard.gif')))
# catch control c and terminate signals
signal.signal(signal.SIGTERM, self.shutdown)
signal.signal(signal.SIGINT, self.shutdown)
if opts.usermod and "before_loop__" in dir(window.handler_instance):
LOG.debug('''Calling the handler file's before_loop__ function''')
window.handler_instance.before_loop__()
LOG.info('Preference path: {}'.format(PATH.PREFS_FILENAME))
# start loop
self.app.exec_()
# now shut it all down
self.shutdown()
def __init__(self, gui, emc_control, mdi_control, emc):
self.gui = gui
self.emc_control = emc_control
self.emc = emc
self.emc_stat = self.emc.stat()
self.mdi_control = mdi_control
self.c = hal.component("touchy")
self.c.newpin("status-indicator", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.active", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.x", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.y", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.z", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.a", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.b", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.c", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.u", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.v", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.w", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.increment", hal.HAL_FLOAT, hal.HAL_OUT)
self.c.newpin("jog.continuous.x.positive", hal.HAL_BIT, hal.HAL_IN)
self.xp = 0
self.c.newpin("jog.continuous.x.negative", hal.HAL_BIT, hal.HAL_IN)
self.xn = 0
self.c.newpin("jog.continuous.y.positive", hal.HAL_BIT, hal.HAL_IN)
self.yp = 0
self.c.newpin("jog.continuous.y.negative", hal.HAL_BIT, hal.HAL_IN)
self.yn = 0
self.c.newpin("jog.continuous.z.positive", hal.HAL_BIT, hal.HAL_IN)
self.zp = 0
self.c.newpin("jog.continuous.z.negative", hal.HAL_BIT, hal.HAL_IN)
self.zn = 0
self.c.newpin("jog.continuous.a.positive", hal.HAL_BIT, hal.HAL_IN)
self.ap = 0
self.c.newpin("jog.continuous.a.negative", hal.HAL_BIT, hal.HAL_IN)
self.an = 0
self.c.newpin("jog.continuous.b.positive", hal.HAL_BIT, hal.HAL_IN)
self.bp = 0
self.c.newpin("jog.continuous.b.negative", hal.HAL_BIT, hal.HAL_IN)
self.bn = 0
self.c.newpin("jog.continuous.c.positive", hal.HAL_BIT, hal.HAL_IN)
self.cp = 0
self.c.newpin("jog.continuous.c.negative", hal.HAL_BIT, hal.HAL_IN)
self.cn = 0
self.c.newpin("jog.continuous.u.positive", hal.HAL_BIT, hal.HAL_IN)
self.up = 0
self.c.newpin("jog.continuous.u.negative", hal.HAL_BIT, hal.HAL_IN)
self.un = 0
self.c.newpin("jog.continuous.v.positive", hal.HAL_BIT, hal.HAL_IN)
self.vp = 0
self.c.newpin("jog.continuous.v.negative", hal.HAL_BIT, hal.HAL_IN)
self.vn = 0
self.c.newpin("jog.continuous.w.positive", hal.HAL_BIT, hal.HAL_IN)
self.wp = 0
self.c.newpin("jog.continuous.w.negative", hal.HAL_BIT, hal.HAL_IN)
self.wn = 0
self.xp_sw = 0
self.xn_sw = 0
self.yp_sw = 0
self.yn_sw = 0
self.zp_sw = 0
self.zn_sw = 0
self.ap_sw = 0
self.an_sw = 0
self.bp_sw = 0
self.bn_sw = 0
self.cp_sw = 0
self.cn_sw = 0
self.up_sw = 0
self.un_sw = 0
self.vp_sw = 0
self.vn_sw = 0
self.wp_sw = 0
self.wn_sw = 0
self.sw_button_presented = 0
self.c.newpin("joint-for-x", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-y", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-z", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-a", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-b", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-c", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-u", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-v", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("joint-for-w", hal.HAL_U32, hal.HAL_IN)
self.c.newpin("quill-up", hal.HAL_BIT, hal.HAL_IN)
self.quillup = 0
self.c.newpin("cycle-start", hal.HAL_BIT, hal.HAL_IN)
self.cyclestart = 0
self.c.newpin("abort", hal.HAL_BIT, hal.HAL_IN)
self.abort = 0
self.c.newpin("single-block", hal.HAL_BIT, hal.HAL_IN)
self.singleblock = 0
self.c.newpin("wheel-counts", hal.HAL_S32, hal.HAL_IN)
self.counts = 0
self.jog_velocity = 1
if self.gui.injector == 1:
# let injector call hal ready
pass
else:
self.c.ready()
self.active = 0
self.jogaxis(0)
#!/usr/bin/python
import hal
import time
import logging
import logging.config
import uuid
import os
h = hal.component("spindle_logging")
h.newpin("speed_in", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("speed_measured", hal.HAL_FLOAT, hal.HAL_IN)
h.ready()
def ConfigureLogger(name, file):
logger = logging.getLogger(name)
formatter = logging.Formatter("%(message)s")
fileHandler = logging.FileHandler(file, mode='a')
fileHandler.setFormatter(formatter)
streamFormatter = logging.Formatter("%(name)s %(message)s")
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(streamFormatter)
logger.setLevel(logging.INFO)
logger.addHandler(fileHandler)
logger.addHandler(streamHandler)
commandedName = "CommandedSpindle"
measuredName = "MeasuredSpindle"
uid = uuid.uuid4()
if (len(pinRaw) != 2):
print(("wrong input"))
sys.exit(1)
pin = Pin()
pin.pin = int(pinRaw[0])
if ((pin.pin > 5) or (pin.pin < 0)):
print(("Pin not available"))
sys.exit(1)
checkAdcInput(pin)
if (pinRaw[1] != "none"):
pin.r2temp = R2Temp(pinRaw[1])
pin.filterSize = filterSize
pins.append(pin)
# Initialize HAL
h = hal.component(args.name)
for pin in pins:
pin.halRawPin = h.newpin(
getHalName(pin) + ".raw", hal.HAL_FLOAT, hal.HAL_OUT)
if (pin.r2temp is not None):
pin.halValuePin = h.newpin(
getHalName(pin) + ".value", hal.HAL_FLOAT, hal.HAL_OUT)
halErrorPin = h.newpin("error", hal.HAL_BIT, hal.HAL_OUT)
halNoErrorPin = h.newpin("no-error", hal.HAL_BIT, hal.HAL_OUT)
halWatchdogPin = h.newpin("watchdog", hal.HAL_BIT, hal.HAL_OUT)
h.ready()
halErrorPin.value = error
halNoErrorPin.value = not error
halWatchdogPin.value = watchdog
import time
import sys
import os
# this is how long we wait for linuxcnc to do our bidding
timeout = 1.0
#
# set up pins
# shell out to halcmd to net our pins to where they need to go
#
h = hal.component("python-ui")
h.ready()
#
# connect to LinuxCNC
#
c = linuxcnc.command()
s = linuxcnc.stat()
e = linuxcnc.error_channel()
l = linuxcnc_util.LinuxCNC(command=c, status=s, error=e)
c.state(linuxcnc.STATE_ESTOP_RESET)
c.state(linuxcnc.STATE_ON)
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from vismach import *
import hal
c = hal.component("pumagui")
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint5", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint6", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("grip", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
###################
# this stuff is the actual definition of the machine
# ideally it would be in a separate file from the code above
#
# gripper fingers
#!/usr/bin/python
from pymodbus.client.sync import ModbusSerialClient as ModbusClient
from pymodbus.register_read_message import ReadInputRegistersResponse
from pprint import pprint
import time
import linuxcnc, hal
updateRate = 0.050 ##Second
plc = hal.component("plc01")
plc.newpin("in.x0", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x1", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x2", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x3", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x4", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x5", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x6", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x7", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x10", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x11", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x12", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x13", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x14", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x15", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x16", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("in.x17", hal.HAL_BIT, hal.HAL_OUT)
plc.newpin("out.y0", hal.HAL_BIT, hal.HAL_IN)
plc.newpin("out.y1", hal.HAL_BIT, hal.HAL_IN)
plc.newpin("out.y2", hal.HAL_BIT, hal.HAL_IN)
plc.newpin("out.y3", hal.HAL_BIT, hal.HAL_IN)
try:
# try loading as a gtk.builder project
dbg("**** GLADE VCP INFO: Not a builder project, trying to load as a lib glade project")
builder = gtk.glade.XML(xmlname)
builder = GladeBuilder(builder)
except Exception,e:
print >> sys.stderr, "**** GLADE VCP ERROR: With xml file: %s : %s" % (xmlname,e)
sys.exit(0)
window = builder.get_object("window1")
window.set_title(opts.component)
try:
halcomp = hal.component(opts.component)
except:
print >> sys.stderr, "*** GLADE VCP ERROR: Asking for a HAL component using a name that already exists."
sys.exit(0)
panel = gladevcp.makepins.GladePanel( halcomp, xmlname, builder, None)
# at this point, any glade HL widgets and their pins are set up.
handlers = load_handlers(opts.usermod,halcomp,builder,opts.useropts)
builder.connect_signals(handlers)
# This option puts the gladevcp panel into a plug and pushed the plug's
# X window id number to standard output - so it can be reparented exterally
# it also forwards events to qtvcp
if opts.push_XID:
#!/usr/bin/python
import serial
import hal
import sys
import time
PORT = "/dev/ttyACM0"
ser = serial.Serial(PORT, 115200, timeout=0)
#Now we create the HAL component and its pins
## HAL_IN arduino can read from linuxCNC
## HAL_OUT arduino can write to linuxCNC
#
c = hal.component("arduino")
c.newpin("spindle_rev", hal.HAL_BIT, hal.HAL_IN)
c.newpin("vacuum_pump", hal.HAL_BIT, hal.HAL_IN)
c.newpin("servo_tool", hal.HAL_BIT, hal.HAL_IN)
c.newpin("probe_3d", hal.HAL_BIT, hal.HAL_IN)
#c.newpin("temperature",hal.HAL_FLOAT,hal.HAL_OUT)
time.sleep(1)
c.ready()
spindle_rev = c['spindle_rev']
vacuum_pump = c['vacuum_pump']
servo_tool = c['servo_tool']
probe_3d = c['probe_3d']
spindle_rev_old = 'False'
vacuum_pump_old = 'False'
servo_tool_old = 'False'
from vismach import *
import hal
import math
import sys
# give endpoint Z values and radii
# resulting cylinder is on the Z axis
class HalToolCylinder(CylinderZ):
def __init__(self, comp, *args):
CylinderZ.__init__(self, *args)
self.comp = comp
def coords(self):
return (45, self.comp["tool-radius"], -self.comp["tool-length"], self.comp["tool-radius"])
c = hal.component("max5gui")
# table
c.newpin("table", hal.HAL_FLOAT, hal.HAL_IN)
# saddle
c.newpin("saddle", hal.HAL_FLOAT, hal.HAL_IN)
# head vertical slide
c.newpin("head", hal.HAL_FLOAT, hal.HAL_IN)
# head tilt
c.newpin("tilt", hal.HAL_FLOAT, hal.HAL_IN)
# rotary table
c.newpin("rotate", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-length", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-radius", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
else:
message = _("Remove the tool and click continue when ready")
app.wm_withdraw()
app.update()
poll_hal_in_background()
try:
r = app.tk.call("nf_dialog", ".tool_change",
_("Tool change"), message, "info", 0, _("Continue"))
finally:
stop_polling_hal_in_background()
if isinstance(r, str): r = int(r)
if r == 0:
h.changed = True
app.update()
h = hal.component("hal_manualtoolchange")
h.newpin("number", hal.HAL_S32, hal.HAL_IN)
h.newpin("change", hal.HAL_BIT, hal.HAL_IN)
h.newpin("changed", hal.HAL_BIT, hal.HAL_OUT)
h.ready()
import Tkinter, nf, rs274.options
app = Tkinter.Tk(className="AxisToolChanger")
app.wm_geometry("-60-60")
app.wm_title(_("AXIS Manual Toolchanger"))
rs274.options.install(app)
nf.start(app); nf.makecommand(app, "_", _)
app.wm_protocol("WM_DELETE_WINDOW", app.wm_withdraw)
lab = Tkinter.Message(app, aspect=500, text = _("\
This window is part of the AXIS manual toolchanger. It is safe to close \
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# graphic model of a Unimate Puma 560
# according to the dimensions from: http://www.juve.ro/blog/puma/
# the obj files can be downloaded there, and may be included in emc2 later
# link description
# link1 - stationary base
# link2 .. link7 - the 6 moving parts of the robot, numbered form base to end effector
from vismach import *
import hal
c = hal.component("puma560gui")
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint5", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint6", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("grip", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
# add a XYZ cross for debug
#floor = Collection([
# Box(-100,-100,-0.1,100,100,0),
# Box(-10,-0.1,-10,10,0,10),
# Box(-0.1,-10,-10,0,10,10),
## Color([0,1,0,1],[Box(-10,-10,9.9,10,10,10)]),
import sys
# give endpoint Z values and radii
# resulting cylinder is on the Z axis
class HalToolCylinder(CylinderZ):
def __init__(self, comp, *args):
CylinderZ.__init__(self, *args)
self.comp = comp
def coords(self):
return (0, self.comp["tool-radius"], self.comp["tool-length"],
self.comp["tool-radius"])
c = hal.component("mahogui")
# table
c.newpin("table", hal.HAL_FLOAT, hal.HAL_IN)
# full width ways that table rides one
# this assembly moves up and down for Y
c.newpin("tableway", hal.HAL_FLOAT, hal.HAL_IN)
# head vertical slide
c.newpin("head", hal.HAL_FLOAT, hal.HAL_IN)
# head tilt
c.newpin("arotate", hal.HAL_FLOAT, hal.HAL_IN)
# rotary table
c.newpin("brotate", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-length", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-radius", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
def __init__(self):
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
try:
if debug(): print "py: CustomTask()"
emctask.Task.__init__(self)
self.inifile = emc.ini(emctask.ini_filename())
self.tcpins = int(self.inifile.find("TOOL", "TASK_TOOLCHANGE_PINS") or 0)
self.startchange_pins = int(self.inifile.find("TOOL", "TASK_START_CHANGE_PINS") or 0)
self.fault_pins = int(self.inifile.find("TOOL", "TASK_TOOLCHANGE_FAULT_PINS") or 0)
h = hal.component("iocontrol.0")
h.newpin("coolant-flood", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("coolant-mist", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("lube-level", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("lube", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("emc-enable-in", hal.HAL_BIT, hal.HAL_IN)
h.newpin("user-enable-out", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("user-request-enable", hal.HAL_BIT, hal.HAL_OUT)
if self.tcpins:
h.newpin("tool-change", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("tool-changed", hal.HAL_BIT, hal.HAL_IN)
h.newpin("tool-number", hal.HAL_S32, hal.HAL_OUT)
h.newpin("tool-prep-number", hal.HAL_S32, hal.HAL_OUT)
h.newpin("tool-prep-pocket", hal.HAL_S32, hal.HAL_OUT)
h.newpin("tool-prepare", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("tool-prepared", hal.HAL_BIT, hal.HAL_IN)
if self.startchange_pins:
h.newpin("start-change", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("start-change-ack", hal.HAL_BIT, hal.HAL_IN)
if self.fault_pins:
h.newpin("emc-abort", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("emc-abort-ack", hal.HAL_BIT, hal.HAL_IN)
h.newpin("emc-reason", hal.HAL_S32, hal.HAL_OUT)
h.newpin("toolchanger-fault", hal.HAL_BIT, hal.HAL_IN)
h.newpin("toolchanger-fault-ack", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("toolchanger-reason", hal.HAL_S32, hal.HAL_IN)
h.newpin("toolchanger-faulted", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("toolchanger-clear-fault", hal.HAL_BIT, hal.HAL_IN)
h.ready()
self.components = dict()
self.components["iocontrol.0"] = h
self.hal = h
self.hal_init_pins()
self.io = emctask.emcstat.io
self.io.aux.estop = 1
self._callback = None
self._check = None
tt = self.io.tool.toolTable
for p in range(0,len(tt)):
tt[p].zero()
UserFuncs.__init__(self)
self.enqueue = EnqueueCall(self)
except Exception,e:
print "__init__"
print_exc_plus()
self.io.status = emctask.RCS_STATUS.RCS_ERROR
#!/usr/bin/env python
from vismach import *
import hal
c = hal.component("dargon-gui2")
c.newpin("joint-x", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint-y", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint-z", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
###################
tooltip = Capture()
tool = Collection([
tooltip,
#Color([0.5,0.5,0.5,0],
CylinderZ(0, 0.3, 10, 5),
CylinderZ(10, 5, 30, 5)
])
#tool = Translate([tool],0,0,-15)
zzz = Collection([tool, Color([0, 1, 0, 0], [Box(15, -5, 20, -15, -25, 520)])])
zzz = Translate([zzz], 0, 0, 400)
zzz = HalTranslate([zzz], c, "joint-z", 0, 0, -1)
zzz = HalTranslate([zzz], c, "joint-x", 1, 0, 0)
xxx = Collection(
[zzz, Color([0, 0, 1, 0], [Box(555, -25, 420, -45, -40, 440)])])
if (args.output_pins != ""):
outputPinsRaw = args.output_pins.split(',')
for pinRaw in outputPinsRaw:
pins.append(parseInputPin(pinRaw, MCP23017.DIR_OUT))
if (args.input_pins != ""):
inputPinsRaw = args.input_pins.split(',')
for pinRaw in inputPinsRaw:
pins.append(parseInputPin(pinRaw, MCP23017.DIR_IN))
if (len(pins) == 0):
print(("No pins specified"))
sys.exit(1)
# Initialize HAL
h = hal.component(args.name)
for pin in pins:
if (pin.direction == MCP23017.DIR_IN):
pin.halPin = h.newpin(getHalName(pin), hal.HAL_BIT, hal.HAL_OUT)
else:
pin.halPin = h.newpin(getHalName(pin), hal.HAL_BIT, hal.HAL_IN)
pin.halPullupPin = h.newpin(getHalName(pin) + ".pullup", hal.HAL_BIT, hal.HAL_IN)
pin.halInvertedPin = h.newpin(getHalName(pin) + ".invert", hal.HAL_BIT, hal.HAL_IN)
halErrorPin = h.newpin("error", hal.HAL_BIT, hal.HAL_OUT)
halNoErrorPin = h.newpin("no-error", hal.HAL_BIT, hal.HAL_OUT)
halWatchdogPin = h.newpin("watchdog", hal.HAL_BIT, hal.HAL_OUT)
h.ready()
halErrorPin.value = error
halNoErrorPin.value = not error
halWatchdogPin.value = watchdog
print(setting)
exec(setting)
# give endpoint Z values and radii
# resulting cylinder is on the Z axis
class HalToolCylinder(CylinderZ):
def __init__(self, comp, *args):
CylinderZ.__init__(self, *args)
self.comp = comp
def coords(self):
r = 20 # default if hal pin not set
if (c.tool_diam > 0): r=c.tool_diam/2
return -self.comp.tool_length, r, 0, r
c = hal.component("5axisgui")
c.newpin("jx", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("jy", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("jz", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("jb", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("jc", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool_length", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool_diam", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("pivot_len", hal.HAL_FLOAT, hal.HAL_OUT)
c["pivot_len"] = pivot_len
c.ready()
tooltip = Capture()
tool = Collection([HalTranslate([tooltip], c, "tool_length", 0,0,-1),
HalToolCylinder(c),
CylinderZ(pivot_len-(zb+za), 100, 0.0, 50),
#!/usr/bin/env python
import hal
h = hal.component("circle")
h.newpin("center", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("radius", hal.HAL_FLOAT, hal.HAL_IN)
h.ready()
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from vismach import *
import hal
import lineardeltakins
import sys
EFFECTOR_OFFSET = CARRIAGE_OFFSET = 30
MIN_JOINT = -236
MAX_JOINT = 300
for setting in sys.argv[1:]:
exec setting
c = hal.component("rostock")
c.newpin("joint0", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("R", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("L", hal.HAL_FLOAT, hal.HAL_IN)
c['R'], c['L'] = lineardeltakins.get_geometry()
c.ready()
class DeltaTranslate(Collection):
def __init__(self, parts, comp):
self.comp = comp
self.parts = parts
self.x = self.y = self.z = 0
else:
message = _("Remove the tool and click continue when ready")
app.wm_withdraw()
app.update()
poll_hal_in_background()
try:
r = app.tk.call("nf_dialog", ".tool_change",
_("Tool change"), message, "info", 0, _("Continue"))
finally:
stop_polling_hal_in_background()
if isinstance(r, str): r = int(r)
if r == 0:
h.changed = True
app.update()
h = hal.component("hal_manualtoolchange")
h.newpin("number", hal.HAL_S32, hal.HAL_IN)
h.newpin("change", hal.HAL_BIT, hal.HAL_IN)
h.newpin("change_button", hal.HAL_BIT, hal.HAL_IN)
h.newpin("changed", hal.HAL_BIT, hal.HAL_OUT)
h.ready()
import Tkinter, nf, rs274.options
app = Tkinter.Tk(className="AxisToolChanger")
app.wm_geometry("-60-60")
app.wm_title(_("AXIS Manual Toolchanger"))
rs274.options.install(app)
nf.start(app); nf.makecommand(app, "_", _)
app.wm_protocol("WM_DELETE_WINDOW", app.wm_withdraw)
lab = Tkinter.Message(app, aspect=500, text = _("\
#!/usr/bin/env python
import subprocess
import hal
def cmd(arg):
subprocess.call(arg, shell=True)
h = hal.component("linktest")
h.newpin("in", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("inout", hal.HAL_FLOAT, hal.HAL_IO)
h.ready()
# set pin values before linking
h['in'] = 42
h['inout'] = 43
assert h['in'] == 42
assert h['inout'] == 43
# make sure halcmd setp works as expected
cmd("halcmd setp linktest.in 4712")
cmd("halcmd setp linktest.inout 4713")
assert h['in'] == 4712
assert h['inout'] == 4713
# create virgin signals
cmd("halcmd newsig insig float")
cmd("halcmd newsig inoutsig float")
# link to them
cmd("halcmd net insig linktest.in")
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#**************************************************************************
#--------------------------------------------------------------------------
# Visualization model of the Hermle mill, as modified to 5-axis
# with rotary axes B and C added, with moving spindle head
# and rotary axis offsets
#--------------------------------------------------------------------------
from vismach import *
import hal
import math
import sys
c = hal.component("xyzbc-trt-gui")
# table-x
c.newpin("table-x", hal.HAL_FLOAT, hal.HAL_IN)
# saddle-y
c.newpin("saddle-y", hal.HAL_FLOAT, hal.HAL_IN)
# head vertical slide
c.newpin("spindle-z", hal.HAL_FLOAT, hal.HAL_IN)
# table-x tilt-b
c.newpin("tilt-b", hal.HAL_FLOAT, hal.HAL_IN)
# rotary table-x
c.newpin("rotate-c", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("z-offset", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("x-offset", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-offset", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
print "heater: Starting Heater port=", port, " name=", component_name
# open the serial port to the platform
ser = serial.Serial()
ser.port = port
ser.baudrate = 19200
ser.timeout = 0
ser.xonxoff = False
print "heater: Opening port"
ser.open()
if not ser.isOpen():
print "heater: Failed to open serial port"
sys.exit()
# create hal pins
c = hal.component(component_name)
c.newpin("run", hal.HAL_BIT, hal.HAL_IN)
c.newpin("running", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("ready", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("set-temp", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("temp", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("actual-set-temp", hal.HAL_FLOAT, hal.HAL_OUT)
# last values of the input or input/output pins
last_run = 0
last_set_temp = 0
last_poll_time = 0
WAIT_FOR_STX = 1
WAIT_FOR_MSG = 2
WAIT_FOR_CHKSUM = 3
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from vismach import *
import hal
import math
import sys
import time
c = hal.component("art_scaragui")
c.newpin("joint0", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint5", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("D1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("D2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("D3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("D4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("D5", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("D6", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("J3MIN", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("J3MAX", hal.HAL_FLOAT, hal.HAL_IN)
# Copyright 2007 Ben Lipkowitz
# You may distribute this software under the GNU GPL v2 or later
#
# see configs/tracking-test.hal
from vismach import *
import hal
import sys
for setting in sys.argv[1:]:
exec(setting)
#compname must be the same as given in 'loadusr -W' or the comp
#will never be ready
compname = "tracking-test"
c = hal.component(compname)
#declare hal pins here
c.newpin("joint0", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint5", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("axis0", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("axis1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("axis2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("axis3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("axis4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("axis5", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
def __init__(self,
vfd_names=[['mitsub_vfd', '00']],
baudrate=9600,
port='/dev/ttyUSB0'):
try:
self.ser = serial.Serial(port,
baudrate,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_TWO,
bytesize=serial.EIGHTBITS)
self.ser.open()
self.ser.isOpen()
except Exception as e:
try:
self.ser.close()
self.ser.open()
except:
print(
"ERROR : mitsub_vfd - No serial interface found at %s\nError: %s"
% (port, e))
pass
#raise SystemExit
print("Mitsubishi VFD serial computer link has loaded")
print(
"Port: %s,\nbaudrate: %d\n8 data bits, no parity, 2 stop bits\n" %
(port, baudrate))
self.h = []
self.comp_names = vfd_names
for index, name in enumerate(self.comp_names):
#print index,' NAME:',name[0],' SLAVE:',name[1]
c = hal.component(name[0])
c.newpin("fwd", hal.HAL_BIT, hal.HAL_IN)
c.newpin("run", hal.HAL_BIT, hal.HAL_IN)
c.newpin("up-to-speed", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("alarm", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("debug", hal.HAL_BIT, hal.HAL_IN)
c.newpin("monitor", hal.HAL_BIT, hal.HAL_IN)
c.newpin("motor-cmd", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("motor-fb", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("motor-amps", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("motor-volts", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("motor-power", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("motor-user", hal.HAL_FLOAT, hal.HAL_OUT)
c.newpin("scale-cmd", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("scale-fb", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("scale-amps", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("scale-volts", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("scale-power", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("scale-user", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("estop", hal.HAL_BIT, hal.HAL_IN)
c.newpin("stat-bit-0", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-1", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-2", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-3", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-4", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-5", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-6", hal.HAL_BIT, hal.HAL_OUT)
c.newpin("stat-bit-7", hal.HAL_BIT, hal.HAL_OUT)
# set reasonable defaults
c['scale-cmd'] = 1
c['scale-fb'] = 1
c['scale-amps'] = 1
c['scale-volts'] = 1
c['scale-power'] = 1
c['scale-user'] = 1
c['fwd'] = 1
# flags for each device
self['last_run%d' % index] = c['run']
self['last_fwd%d' % index] = c['fwd']
self['last_cmd%d' % index] = c['motor-cmd']
self['last_monitor%d' % index] = c['monitor']
self['last_estop%d' % index] = c['estop']
#add device to component reference variable
self.h.append(c)
print("Mitsubishi %s VFD: slave# %s added\n" % (name[0], name[1]))
# only issue ready when all the components are ready
for i in self.h:
i.ready()
self.set_special_monitor()
# G91 G1 F50 Z0.01
# repeat at a slower speed to get a more accurate reading
# G90 G38.2 Z2.240 F1
# Now back off so that operator can remove the probe
# G0 Z0.5 G91
# TODO does this leave us in incremental mode? That would be bad.
# For all of these commands, we know to execute the next one once machine.in-position is true
# Inputs: start, in-position
# Outputs: 5 unique mdi commands
import hal, time
h = hal.component("probe-touchoff")
h.newpin("start", hal.HAL_BIT, hal.HAL_IN)
h.newpin("in-position", hal.HAL_BIT, hal.HAL_IN)
h.newpin("mdi-g54z0", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-g38fast", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-backoff-tiny", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-g38slow", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-backoff-final", hal.HAL_BIT, hal.HAL_OUT)
h.ready()
# MDI_DURATION=1
MDI_DURATION=0.1
SHORT_SLEEP=0.1
# Periodically, usually in response to a timer, all HAL_OUT pins should be "driven" by assigning
# them a new value. This should be done whether or not the value is different than the last one
def __init__(self):
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
try:
if debug(): print "py: CustomTask()"
emctask.Task.__init__(self)
self.inifile = emc.ini(emctask.ini_filename())
self.tcpins = int(self.inifile.find("TOOL", "TASK_TOOLCHANGE_PINS") or 0)
self.startchange_pins = int(self.inifile.find("TOOL", "TASK_START_CHANGE_PINS") or 0)
self.fault_pins = int(self.inifile.find("TOOL", "TASK_TOOLCHANGE_FAULT_PINS") or 0)
h = hal.component("iocontrol.0")
h.newpin("coolant-flood", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("coolant-mist", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("lube-level", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("lube", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("emc-enable-in", hal.HAL_BIT, hal.HAL_IN)
h.newpin("user-enable-out", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("user-request-enable", hal.HAL_BIT, hal.HAL_OUT)
if self.tcpins:
h.newpin("tool-change", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("tool-changed", hal.HAL_BIT, hal.HAL_IN)
h.newpin("tool-number", hal.HAL_S32, hal.HAL_OUT)
h.newpin("tool-prep-number", hal.HAL_S32, hal.HAL_OUT)
h.newpin("tool-prep-pocket", hal.HAL_S32, hal.HAL_OUT)
h.newpin("tool-prepare", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("tool-prepared", hal.HAL_BIT, hal.HAL_IN)
if self.startchange_pins:
h.newpin("start-change", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("start-change-ack", hal.HAL_BIT, hal.HAL_IN)
if self.fault_pins:
h.newpin("emc-abort", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("emc-abort-ack", hal.HAL_BIT, hal.HAL_IN)
h.newpin("emc-reason", hal.HAL_S32, hal.HAL_OUT)
h.newpin("toolchanger-fault", hal.HAL_BIT, hal.HAL_IN)
h.newpin("toolchanger-fault-ack", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("toolchanger-reason", hal.HAL_S32, hal.HAL_IN)
h.newpin("toolchanger-faulted", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("toolchanger-clear-fault", hal.HAL_BIT, hal.HAL_IN)
h.ready()
self.components = dict()
self.components["iocontrol.0"] = h
self.hal = h
self.hal_init_pins()
self.io = emctask.emcstat.io
self.io.aux.estop = 1
self._callback = None
self._check = None
tt = self.io.tool.toolTable
for p in range(0,len(tt)):
tt[p].zero()
UserFuncs.__init__(self)
self.enqueue = EnqueueCall(self)
except Exception,e:
print "__init__"
print_exc_plus()
self.io.status = emctask.RCS_STATUS.RCS_ERROR
#!/usr/bin/python
import serial
import time
import struct
import hal
comm = serial.Serial()
comm.port = "/dev/ttyACM0"
comm.baudrate = 115200
comm.timeout = 1
comm.dtr = True
comm.open()
h = hal.component("ctrlpanel")
h.newpin("mpgXcount", hal.HAL_S32, hal.HAL_OUT)
h.newpin("mpgYcount", hal.HAL_S32, hal.HAL_OUT)
h.newpin("mpgZcount", hal.HAL_S32, hal.HAL_OUT)
# buttons
h.newpin("power", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("home", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("zeroAll", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("zeroX", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("zeroY", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("zeroZ", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("start", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("stop", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("laser", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("feedPlus", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("feedMin", hal.HAL_BIT, hal.HAL_OUT)
if opts.instance != -1:
print >> sys.stderr, "*** GLADE VCP ERROR: the -I option is deprecated, either use:"
print >> sys.stderr, "-s <uuid> for zeroconf lookup, or"
print >> sys.stderr, "-C <halrcmd_uri> -M <halrcomp_uri> for explicit URI's "
sys.exit(0)
if opts.svc_uuid and (opts.halrcmd_uri or opts.halrcomp_uri):
print >> sys.stderr, "*** GLADE VCP ERROR: use either -s<uuid> or -C/-M, but not both"
sys.exit(0)
if not (opts.svc_uuid or opts.use_mki or opts.halrcmd_uri
or opts.halrcomp_uri): # local
try:
import hal
halcomp = hal.component(opts.component)
except:
print >> sys.stderr, "*** GLADE VCP ERROR: Asking for a HAL component using a name that already exists."
sys.exit(0)
panel = gladevcp.makepins.GladePanel(halcomp, xmlname, builder, None)
else:
if opts.rcdebug:
print "remote uuid=%s halrcmd=%s halrcomp=%s" % (
opts.svc_uuid, opts.halrcmd_uri, opts.halrcomp_uri)
if opts.use_mki:
mki = ConfigParser.ConfigParser()
mki.read(os.getenv("MACHINEKIT_INI"))
uuid = mki.get("MACHINEKIT", "MKUUID")
else:
uuid = opts.svc_uuid
#!/usr/bin/env python3
import hal
import time
c = hal.component("stream_writer")
writer = hal.stream(c, hal.streamer_base, 10, "bfsu")
for i in range(9):
assert writer.writable
writer.write((i % 2, i, i, i))
assert not writer.writable
assert writer.num_overruns == 0
try:
writer.write((1,1,1,1))
except:
pass
else:
assert False, "failed to get exception on full stream"
assert writer.num_overruns == 1
c.ready()
try:
while 1: time.sleep(1)
except KeyboardInterrupt: pass
return
time.sleep(0.1)
raise RuntimeError("hal pin %s didn't get to %s after %.3f seconds" % (name, value, timeout))
# After doing something that should change the stat buffer, wait this
# long before polling to let the change propagate through.
# FIXME: this is bogus
stat_poll_wait = 0.100
c = linuxcnc.command()
s = linuxcnc.stat()
e = linuxcnc.error_channel()
h = hal.component("test-ui")
h.newpin("tool-change", hal.HAL_BIT, hal.HAL_IN)
h.newpin("tool-changed", hal.HAL_BIT, hal.HAL_OUT)
h["tool-changed"] = False
h.newpin("tool-prepare", hal.HAL_BIT, hal.HAL_IN)
h.newpin("tool-prepared", hal.HAL_BIT, hal.HAL_OUT)
h["tool-prepared"] = False
h.newpin("tool-number", hal.HAL_S32, hal.HAL_IN)
h.newpin("tool-prep-number", hal.HAL_S32, hal.HAL_IN)
h.newpin("tool-prep-pocket", hal.HAL_S32, hal.HAL_IN)
h.ready()
def __init__(self):
sys.excepthook = self.excepthook
INIPATH = None
usage = "usage: %prog [options] myfile.ui"
parser = OptionParser(usage=usage)
parser.disable_interspersed_args()
parser.add_options(options)
# remove [-ini filepath] that linuxcnc adds if being launched as a screen
# keep a reference of that path
for i in range(len(sys.argv)):
if sys.argv[i] =='-ini':
# delete -ini
del sys.argv[i]
# pop out the ini path
INIPATH = sys.argv.pop(i)
break
(opts, args) = parser.parse_args()
# initialize QApp so we can pop up dialogs now.
self.app = QtWidgets.QApplication(sys.argv)
# we import here so that the QApp is initialized before
# the Notify library is loaded because it uses DBusQtMainLoop
# DBusQtMainLoop must be initialized after to work properly
from qtvcp import qt_makepins, qt_makegui
# ToDo: pass specific log levels as an argument, or use an INI setting
if not opts.debug:
# Log level defaults to DEBUG, so set higher if not debug
logger.setGlobalLevel(logger.ERROR)
# a specific path has been set to load from or...
# no path set but -ini is present: default qtvcp screen...or
# oops error
if args:
basepath=args[0]
elif INIPATH:
basepath = "qt_cnc"
else:
log.error('Error in path')
sys.exit()
# set paths using basename
PATH = Paths(basepath, bool(INIPATH))
#################
# Screen specific
#################
if INIPATH:
log.debug('Building A Linuxcnc Main Screen')
import linuxcnc
# internationalization and localization
import locale, gettext
# pull info from the INI file
self.inifile = linuxcnc.ini(INIPATH)
self.inipath = INIPATH
# screens require more path info
PATH.add_screen_paths()
# International translation
locale.setlocale(locale.LC_ALL, '')
locale.bindtextdomain(PATH.DOMAIN, PATH.LOCALEDIR)
gettext.install(PATH.DOMAIN, localedir=PATH.LOCALEDIR, unicode=True)
gettext.bindtextdomain(PATH.DOMAIN, PATH.LOCALEDIR)
# if no handler file specified, use stock test one
if not opts.usermod:
log.info('No handler file specified on command line')
target = os.path.join(PATH.CONFIGPATH, '%s_handler.py' % PATH.BASENAME)
source = os.path.join(PATH.SCREENDIR, 'tester/tester_handler.py')
if PATH.HANDLER is None:
message = ("""
Qtvcp encountered an error; No handler file was found.
Would you like to copy a basic handler file into your config folder?
This handker file will allow display of your screen and basic keyboard jogging.
The new handlerfile's path will be:
%s
Pressing cancel will close linuxcnc.""" % target)
rtn = QtWidgets.QMessageBox.critical(None, "QTVCP Error", message,QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
if rtn == QtWidgets.QMessageBox.Ok:
try:
shutil.copy(source, target)
except IOError as e:
log.critical("Unable to copy handler file. %s" % e)
sys.exit(0)
except:
log.critical("Unexpected error copying handler file:", sys.exc_info())
sys.exit(0)
opts.usermod = PATH.HANDLER = target
else:
log.critical('No handler file found or specified. User requested stopping')
else:
opts.usermod = PATH.HANDLER
# specify the HAL component name if missing
if opts.component is None:
log.info('No HAL component base name specified on command line using: {}'.format(PATH.BASENAME))
opts.component = PATH.BASENAME
#################
# VCP specific
#################
else:
log.debug('Building A VCP Panel')
# if no handler file specified, use stock test one
if not opts.usermod:
log.info('No handler file specified - using {}'.format(PATH.HANDLER))
opts.usermod = PATH.HANDLER
# specify the HAL component name if missing
if opts.component is None:
log.info('No HAL component base name specified - using: {}'.format(PATH.BASENAME))
opts.component = PATH.BASENAME
##############
# Build ui
##############
#if there was no component name specified use the xml file name
if opts.component is None:
opts.component = PATH.BASENAME
# initialize HAL
try:
self.halcomp = hal.component(opts.component)
self.hal = QComponent(self.halcomp)
except:
log.critical("Asking for a HAL component using a name that already exists?")
sys.exit(0)
# initialize the window
window = qt_makegui.MyWindow(self.hal, PATH)
# load optional user handler file
if opts.usermod:
log.debug('Loading the handler file')
window.load_extension(opts.usermod)
# do any class patching now
if "class_patch__" in dir(window.handler_instance):
window.handler_instance.class_patch__()
# add filter to catch keyboard events
log.debug('Adding the key events filter')
myFilter = qt_makegui.MyEventFilter(window)
self.app.installEventFilter(myFilter)
# actually build the widgets
window.instance()
# make QT widget HAL pins
self.panel = qt_makepins.QTPanel(self.hal, PATH, window, opts.debug)
# call handler file's initialized function
if opts.usermod:
if "initialized__" in dir(window.handler_instance):
log.debug('''Calling the handler file's initialized__ function''')
window.handler_instance.initialized__()
# All Widgets should be added now - synch them to linuxcnc
STATUS.forced_update()
# User components are set up so report that we are ready
log.debug('Set HAL ready')
self.halcomp.ready()
# embed us into an X11 window (such as AXIS)
if opts.parent:
window = xembed.reparent_qt_to_x11(window, opts.parent)
forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
log.critical('Forwarding events to AXIS is not well tested yet')
if forward:
xembed.XEmbedFowarding(window, forward)
# push the window id for embedment into an external program
if opts.push_XID:
wid = int(window.winId())
print >> sys.stdout,wid
sys.stdout.flush()
# for window resize and or position options
if "+" in opts.geometry:
log.debug('-g option: moving window')
try:
j = opts.geometry.partition("+")
pos = j[2].partition("+")
window.move( int(pos[0]), int(pos[2]) )
except:
log.critical("With window position data")
parser.print_usage()
sys.exit(1)
if "x" in opts.geometry:
log.debug('-g option: resizing')
try:
if "+" in opts.geometry:
j = opts.geometry.partition("+")
t = j[0].partition("x")
else:
t = window_geometry.partition("x")
window.resize( int(t[0]), int(t[2]) )
except:
log.critical("With window resize data")
parser.print_usage()
sys.exit(1)
# always on top
if opts.always_top:
window.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
# theme (styles in QT speak) specify a qss file
if opts.theme:
window.apply_styles(opts.theme)
# appy qss file or default theme
else:
window.apply_styles()
# title
if INIPATH:
title = 'QTvcp-Screen-%s'% opts.component
else:
title = 'QTvcp-Panel-%s'% opts.component
window.setWindowTitle(title)
log.debug('Show window')
# maximize
if opts.maximum:
window.showMaximized()
# fullscreen
elif opts.fullscreen:
window.showFullScreen()
else:
self.panel.set_preference_geometry()
window.show()
if INIPATH:
self.postgui()
# catch control c and terminate signals
signal.signal(signal.SIGTERM, self.shutdown)
signal.signal(signal.SIGINT, self.shutdown)
if opts.usermod and "before_loop__" in dir(window.handler_instance):
log.debug('''Calling the handler file's before_loop__ function''')
window.handler_instance.before_loop__()
# start loop
self.app.exec_()
# now shut it all down
self.shutdown()
#!/usr/bin/python
import hal, time
h = hal.component("passthrough")
h.newpin("in", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("out", hal.HAL_FLOAT, hal.HAL_OUT)
h.ready()
try:
while 0:
time.sleep(1)
h['out'] = h['in']
except KeyboardInterrupt:
raise SystemExit
def calculate_levels(data, chunk,sample_rate):
# data = unpack("%dh" % (len(data)), data)
data = np.fromstring(data, dtype='int16')
# data = np.array(data, dtype='h')
fourier = np.fft.rfft(data)
fourier = np.delete(fourier, len(fourier)-1)
power = np.log10(np.abs(fourier)+0.000001)**2
# print (power)
power = np.reshape(power, (rows, chunk/rows/2))
matrix = np.average(power, axis=1)/4
return matrix
logging.debug("init")
h = hal.component("alsa-fft")
h.newpin("min", hal.HAL_FLOAT, hal.HAL_OUT)
h.newpin("max", hal.HAL_FLOAT, hal.HAL_OUT)
for i in range(0, rows):
h.newpin("fft-%d" % (i), hal.HAL_FLOAT, hal.HAL_OUT)
h.ready()
logging.debug("ready")
sample_rate = 44100
chunk = 1024 # Use a multiple of [rows]
logging.debug("aa.PCM begin")
audio = aa.PCM(type=aa.PCM_CAPTURE, mode=aa.PCM_NORMAL)
audio.setchannels(1)
audio.setrate(sample_rate)
audio.setformat(aa.PCM_FORMAT_S16_LE)
def __init__(self, gui, emc_control, mdi_control, emc):
self.gui = gui
self.emc_control = emc_control
self.emc = emc
self.emc_stat = self.emc.stat()
self.mdi_control = mdi_control
self.c = hal.component("touchy")
self.c.newpin("status-indicator", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.active", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.x", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.y", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.z", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.a", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.b", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.c", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.u", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.v", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.w", hal.HAL_BIT, hal.HAL_OUT)
self.c.newpin("jog.wheel.increment", hal.HAL_FLOAT, hal.HAL_OUT)
self.c.newpin("jog.continuous.x.positive", hal.HAL_BIT, hal.HAL_IN)
self.xp = 0
self.c.newpin("jog.continuous.x.negative", hal.HAL_BIT, hal.HAL_IN)
self.xn = 0
self.c.newpin("jog.continuous.y.positive", hal.HAL_BIT, hal.HAL_IN)
self.yp = 0
self.c.newpin("jog.continuous.y.negative", hal.HAL_BIT, hal.HAL_IN)
self.yn = 0
self.c.newpin("jog.continuous.z.positive", hal.HAL_BIT, hal.HAL_IN)
self.zp = 0
self.c.newpin("jog.continuous.z.negative", hal.HAL_BIT, hal.HAL_IN)
self.zn = 0
self.c.newpin("jog.continuous.a.positive", hal.HAL_BIT, hal.HAL_IN)
self.ap = 0
self.c.newpin("jog.continuous.a.negative", hal.HAL_BIT, hal.HAL_IN)
self.an = 0
self.c.newpin("jog.continuous.b.positive", hal.HAL_BIT, hal.HAL_IN)
self.bp = 0
self.c.newpin("jog.continuous.b.negative", hal.HAL_BIT, hal.HAL_IN)
self.bn = 0
self.c.newpin("jog.continuous.c.positive", hal.HAL_BIT, hal.HAL_IN)
self.cp = 0
self.c.newpin("jog.continuous.c.negative", hal.HAL_BIT, hal.HAL_IN)
self.cn = 0
self.c.newpin("jog.continuous.u.positive", hal.HAL_BIT, hal.HAL_IN)
self.up = 0
self.c.newpin("jog.continuous.u.negative", hal.HAL_BIT, hal.HAL_IN)
self.un = 0
self.c.newpin("jog.continuous.v.positive", hal.HAL_BIT, hal.HAL_IN)
self.vp = 0
self.c.newpin("jog.continuous.v.negative", hal.HAL_BIT, hal.HAL_IN)
self.vn = 0
self.c.newpin("jog.continuous.w.positive", hal.HAL_BIT, hal.HAL_IN)
self.wp = 0
self.c.newpin("jog.continuous.w.negative", hal.HAL_BIT, hal.HAL_IN)
self.wn = 0
self.c.newpin("quill-up", hal.HAL_BIT, hal.HAL_IN)
self.quillup = 0
self.c.newpin("cycle-start", hal.HAL_BIT, hal.HAL_IN)
self.cyclestart = 0
self.c.newpin("abort", hal.HAL_BIT, hal.HAL_IN)
self.abort = 0
self.c.newpin("single-block", hal.HAL_BIT, hal.HAL_IN)
self.singleblock = 0
self.c.newpin("wheel-counts", hal.HAL_S32, hal.HAL_IN)
self.counts = 0
self.jog_velocity = 1
self.c.ready()
self.active = 0
self.jogaxis(0)
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from vismach import *
import hal
import math
import sys
c = hal.component("scaragui")
c.newpin("joint0", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint1", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint2", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint3", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint4", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("joint5", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
# parameters that define the geometry see scarakins.c for definitions these
# numbers match the defaults there, and will need to be changed or specified on
# the commandline if you are not using the defaults.
d1 = 490.0
d2 = 340.0
d3 = 50.0
#!/usr/bin/env python
from PowermaxSerialFuncs import *
import hal
import sys
try:
h = hal.component("powermax")
h.newpin("minCurr", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("maxCurr", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("minPres", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("maxPres", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("runTime", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("fltCode", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("presFB", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("currFB", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("presSP", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("currSP", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("machON", hal.HAL_BIT, hal.HAL_IN)
h.newpin("modeNorSP", hal.HAL_BIT, hal.HAL_IN)
h.newpin("modeCpaSP", hal.HAL_BIT, hal.HAL_IN)
h.newpin("modeGouSP", hal.HAL_BIT, hal.HAL_IN)
h.newpin("modeNorFB", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("modeCpaFB", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("modeGouFB", hal.HAL_BIT, hal.HAL_OUT)
h.ready()
#print "PYTHON SERIAL: Finished creating HAL pins"
except:
raise
def run(self) :
import hal, time
self.h = hal.component("compensation")
self.h.newpin("enable-in", hal.HAL_BIT, hal.HAL_IN)
self.h.newpin("enable-out", hal.HAL_BIT, hal.HAL_OUT)
self.h.newpin("scale", hal.HAL_FLOAT, hal.HAL_IN)
self.h.newpin("counts", hal.HAL_S32, hal.HAL_OUT)
self.h.newpin("clear", hal.HAL_BIT, hal.HAL_IN)
self.h.newpin("x-pos", hal.HAL_FLOAT, hal.HAL_IN)
self.h.newpin("y-pos", hal.HAL_FLOAT, hal.HAL_IN)
self.h.newpin("z-pos", hal.HAL_FLOAT, hal.HAL_IN)
self.h.newpin("fade-height", hal.HAL_FLOAT, hal.HAL_IN)
self.h.ready()
s = linuxcnc.stat()
currentState = States.START
prevState = States.STOP
try:
while True:
time.sleep(update)
# get linuxcnc task_state status for machine on / off transitions
s.poll()
if currentState == States.START :
if currentState != prevState :
print("\nCompensation entering START state")
prevState = currentState
# do start-up tasks
print(" %s last modified: %s" % (self.filename, time.ctime(os.path.getmtime(self.filename))))
prevMapTime = 0
self.h["counts"] = 0
# transition to IDLE state
currentState = States.IDLE
elif currentState == States.IDLE :
if currentState != prevState :
print("\nCompensation entering IDLE state")
prevState = currentState
# stay in IDLE state until compensation is enabled
if self.h["enable-in"] :
currentState = States.LOADMAP
elif currentState == States.LOADMAP :
if currentState != prevState :
print("\nCompensation entering LOADMAP state")
prevState = currentState
mapTime = os.path.getmtime(self.filename)
if mapTime != prevMapTime:
self.loadMap()
print(" Compensation map loaded")
prevMapTime = mapTime
# transition to RUNNING state
currentState = States.RUNNING
elif currentState == States.RUNNING :
if currentState != prevState :
print("\nCompensation entering RUNNING state")
prevState = currentState
if self.h["enable-in"] :
# enable external offsets
self.h["enable-out"] = 1
fadeHeight = self.h["fade-height"]
zPos = self.h["z-pos"]
if fadeHeight == 0 :
compScale = 1
elif zPos < fadeHeight:
compScale = (fadeHeight - zPos)/fadeHeight
if compScale > 1 :
compScale = 1
else :
compScale = 0
if s.task_state == linuxcnc.STATE_ON :
# get the compensation if machine power is on, else set to 0
# otherwise we loose compensation eoffset if machine power is cycled
# when copensation is enable
compensation = self.compensate()
self.h["counts"] = compensation * compScale
self.h["scale"] = self.scale
else :
self.h["counts"] = 0
else :
# transition to RESET state
currentState = States.RESET
elif currentState == States.RESET :
if currentState != prevState :
print("\nCompensation entering RESET state")
prevState = currentState
# reset the eoffsets counts register so we don't accumulate
self.h["counts"] = 0
# toggle the clear output
self.h["clear"] = 1;
time.sleep(0.1)
self.h["clear"] = 0;
# disable external offsets
self.h["enable-out"] = 0
# transition to IDLE state
currentState = States.IDLE
except KeyboardInterrupt:
raise SystemExit
def name(self, name):
self._name = name
self.h = hal.component(name)
while ((time.time() - start) < timeout):
if h[pin_name]:
print "halui reports mode", pin_name
return
time.sleep(0.1)
print "timeout waiting for halui to report mode", pin_name
sys.exit(1)
#
# set up pins
# shell out to halcmd to make nets to halui and motion
#
h = hal.component("python-ui")
h.newpin("mdi-0", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-1", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-2", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("mdi-3", hal.HAL_BIT, hal.HAL_OUT)
h.newpin("joint-0-position", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("joint-1-position", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("joint-2-position", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("is-manual", hal.HAL_BIT, hal.HAL_IN)
h.newpin("is-auto", hal.HAL_BIT, hal.HAL_IN)
h.newpin("is-mdi", hal.HAL_BIT, hal.HAL_IN)
h.ready() # mark the component as 'ready'
# distance from spindle nose to tool-length = 0 point
tool_length_offset = 4.0
# give endpoint Z values and radii
# resulting cylinder is on the Z axis
class HalToolCylinder(CylinderZ):
def __init__(self, comp, *args):
CylinderZ.__init__(self, *args)
self.comp = comp
def coords(self):
return (0, self.comp["tool-radius"],
-tool_length_offset-self.comp["tool-length"], self.comp["tool-radius"])
c = hal.component("hbmgui")
# HAL pins
c.newpin("table", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("saddle", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("head", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("quill", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-length", hal.HAL_FLOAT, hal.HAL_IN)
c.newpin("tool-radius", hal.HAL_FLOAT, hal.HAL_IN)
c.ready()
tool_radius=0.5
for setting in sys.argv[1:]: exec setting
# the approach here is a little different than in previous vismach models
TIME_INCR = 0.1
TIMEOUT = 10.0
#
# connect to LinuxCNC
#
c = linuxcnc.command()
s = linuxcnc.stat()
e = linuxcnc.error_channel()
l = linuxcnc_util.LinuxCNC(command=c, status=s, error=e)
#
# Create and connect test feedback comp
#
h = hal.component("test-ui")
h.newpin("Xpos", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("Ypos", hal.HAL_FLOAT, hal.HAL_IN)
h.ready()
os.system("halcmd source ./postgui.hal")
#
# Come out of E-stop, turn the machine on, home
#
c.state(linuxcnc.STATE_ESTOP_RESET)
c.state(linuxcnc.STATE_ON)
c.home(0)
c.home(1)
c.home(2)
l.wait_for_home([1, 1, 1, 0, 0, 0, 0, 0, 0])
def __init__(self):
self.lcnc = linuxCNC()
gtk.settings_get_default().set_property(
'gtk-theme-name', self.lcnc.iniFile.find('PLASMAC', 'THEME'))
self.gui = "./test/plasmac_test.glade"
self.B = gtk.Builder()
self.B.add_from_file(self.gui)
self.B.connect_signals(self)
self.W = self.B.get_object("window1")
self.halcomp = hal.component('plasmactest')
self.panel = gladevcp.makepins.GladePanel(self.halcomp, self.gui,
self.B, None)
self.halcomp.ready()
if not hal.pin_has_writer('plasmac.arc-ok-in'):
sp.Popen([
'halcmd net p_test:arc-ok-in plasmactest.arcOk plasmac.arc-ok-in'
],
shell=True)
if not hal.pin_has_writer('plasmac.arc-voltage-in'):
sp.Popen([
'halcmd net p_test:arc-voltage-in plasmactest.arcVoltage plasmac.arc-voltage-in'
],
shell=True)
if not hal.pin_has_writer('debounce.0.0.in'):
sp.Popen([
'halcmd net p_test:float-switch plasmactest.floatSwitch debounce.0.0.in'
],
shell=True)
if not hal.pin_has_writer('debounce.0.1.in'):
sp.Popen([
'halcmd net p_test:breakaway-switch plasmactest.breakawaySwitch debounce.0.1.in'
],
shell=True)
if not hal.pin_has_writer('debounce.0.2.in'):
sp.Popen([
'halcmd net p_test:ohmic-probe plasmactest.ohmicProbe debounce.0.2.in'
],
shell=True)
if not hal.pin_has_writer('plasmac.move-down'):
sp.Popen([
'halcmd net p_test:move-down plasmactest.moveDown plasmac.move-down'
],
shell=True)
if not hal.pin_has_writer('plasmac.move-up'):
sp.Popen([
'halcmd net p_test:move-up plasmactest.moveUp plasmac.move-up'
],
shell=True)
self.W.connect('delete_event', self.ignore)
self.W.set_type_hint(gdk.WINDOW_TYPE_HINT_MENU)
self.W.set_keep_above(True)
self.W.show_all()
mode = self.lcnc.iniFile.find('PLASMAC', 'MODE') or '0'
if mode not in '012':
mode = 0
self.B.get_object('mode' + mode).set_active(1)
functions = {
'0': self.on_mode0_toggled(0),
'1': self.on_mode1_toggled(0),
'2': self.on_mode2_toggled(0),
}
if mode in functions:
functions[mode]
#!/usr/bin/env linuxcnc-python
import hal
import time
c = hal.component("stream_reader")
reader = hal.stream(c, hal.streamer_base, "bfsu")
for i in range(9):
assert reader.readable
assert reader.read() == ((i % 2, i, i, i))
assert reader.num_underruns == 0
assert reader.sampleno == i+1
assert reader.read() is None
assert reader.num_underruns == 1
c.ready()
print("pass")
try:
while 1: time.sleep(1)
except KeyboardInterrupt: pass
#!/usr/bin/python
import hal
import time
c = hal.component("stream_reader")
reader = hal.stream(c, hal.streamer_base, "bfsu")
for i in range(9):
assert reader.readable
assert reader.read() == ((i % 2, i, i, i))
assert reader.num_underruns == 0
assert reader.sampleno == i+1
assert reader.read() is None
assert reader.num_underruns == 1
c.ready()
print "pass"
try:
while 1: time.sleep(1)
except KeyboardInterrupt: pass
#!/usr/bin/python
from Adafruit_I2C import Adafruit_I2C
import hal
import time
i2c = Adafruit_I2C(0x60)
h = hal.component("spindle_voltage")
h.newpin("speed_in", hal.HAL_FLOAT, hal.HAL_IN)
h.ready()
x0 = 200.0
y0 = 764.15
x1 = 2080.0
y1 = 10000.0
lastSpeed = 0
try:
while True:
if h['speed_in'] != lastSpeed:
speed = h['speed_in']
value = x0 + (x1 - x0) * (speed - y0) / (y1 - y0)
i = int(min(max(value, 0), 4095))
lo = i & 15 << 4
hi = i >> 4
