stepconf.py

来自「CNC 的开放码,EMC2 V2.2.8版」· Python 代码 · 共 1,576 行 · 第 1/4 页

    def on_xaxis_prepare(self, *args): self.axis_prepare('x')
    def on_yaxis_prepare(self, *args): self.axis_prepare('y')
    def on_zaxis_prepare(self, *args): self.axis_prepare('z')
    def on_aaxis_prepare(self, *args): self.axis_prepare('a')

    def on_xaxis_back(self, *args): self.axis_done('x')
    def on_yaxis_back(self, *args): self.axis_done('y')
    def on_zaxis_back(self, *args):
	self.axis_done('z')
	if self.data.axes == 2:
	    self.widgets.druid1.set_page(self.widgets.xaxis)
	    return True
    def on_aaxis_back(self, *args): self.axis_done('a')

    def on_xaxistest_clicked(self, *args): self.test_axis('x')
    def on_yaxistest_clicked(self, *args): self.test_axis('y')
    def on_zaxistest_clicked(self, *args): self.test_axis('z')
    def on_aaxistest_clicked(self, *args): self.test_axis('a')

    def on_spindle_prepare(self, *args):
	self.widgets['spindlecarrier'].set_text("%s" % self.data.spindlecarrier)
	self.widgets['spindlespeed1'].set_text("%s" % self.data.spindlespeed1)
	self.widgets['spindlespeed2'].set_text("%s" % self.data.spindlespeed2)
	self.widgets['spindlepwm1'].set_text("%s" % self.data.spindlepwm1)
	self.widgets['spindlepwm2'].set_text("%s" % self.data.spindlepwm2)
	self.widgets['spindlecpr'].set_text("%s" % self.data.spindlecpr)

	data = self.data
	if PHA in (data.pin10, data.pin11, data.pin12, data.pin13, data.pin15):
	    self.widgets.spindlecpr.set_sensitive(1)
	else:
	    self.widgets.spindlecpr.set_sensitive(0)

    def on_spindle_next(self, *args):
	self.data.spindlecarrier = float(self.widgets.spindlecarrier.get_text())
	self.data.spindlespeed1 = float(self.widgets.spindlespeed1.get_text())
	self.data.spindlespeed2 = float(self.widgets.spindlespeed2.get_text())
	self.data.spindlepwm1 = float(self.widgets.spindlepwm1.get_text())
	self.data.spindlepwm2 = float(self.widgets.spindlepwm2.get_text())
	self.data.spindlecpr = float(self.widgets.spindlecpr.get_text())

    def on_spindle_back(self, *args):
	self.on_spindle_next()
	if self.data.axes != 1:
	    self.widgets.druid1.set_page(self.widgets.zaxis)
	else:
	    self.widgets.druid1.set_page(self.widgets.aaxis)
	return True

    def on_complete_back(self, *args):
	if self.has_spindle_speed_control():
	    self.widgets.druid1.set_page(self.widgets.spindle)
	elif self.data.axes != 1:
	    self.widgets.druid1.set_page(self.widgets.zaxis)
	else:
	    self.widgets.druid1.set_page(self.widgets.aaxis)
	return True

    def on_xaxis_next(self, *args):
	self.axis_done('x')
	if self.data.axes == 2:
	    self.widgets.druid1.set_page(self.widgets.zaxis)
	    return True

    def on_yaxis_next(self, *args): self.axis_done('y')
    def on_zaxis_next(self, *args):
	self.axis_done('z')
	if self.data.axes != 1:
	    if self.has_spindle_speed_control():
		self.widgets.druid1.set_page(self.widgets.spindle)
	    else:
		self.widgets.druid1.set_page(self.widgets.complete)
	    return True
    def on_aaxis_next(self, *args):
	self.axis_done('a')
	if self.has_spindle_speed_control():
	    self.widgets.druid1.set_page(self.widgets.spindle)
	else:
	    self.widgets.druid1.set_page(self.widgets.complete)
	return True

    def has_spindle_speed_control(self):
	d = self.data
	return PWM in (d.pin1, d.pin2, d.pin3, d.pin4, d.pin5, d.pin6, d.pin7,
	    d.pin8, d.pin9, d.pin14, d.pin16) or \
		PPR in (d.pin10, d.pin11, d.pin12, d.pin13, d.pin15) or \
		PHA in (d.pin10, d.pin11, d.pin12, d.pin13, d.pin15) \

    def update_pps(self, axis):
	w = self.widgets
	d = self.data
	def get(n): return float(w[axis + n].get_text())

	try:
	    pitch = get("leadscrew")
	    if d.units == 1 or axis == 'a': pitch = 1./pitch
	    pps = (pitch * get("steprev") * get("microstep") *
		(get("pulleynum") / get("pulleyden")) * get("maxvel"))
            if pps == 0: raise ValueError
            pps = abs(pps)
	    acctime = get("maxvel") / get("maxacc")
	    accdist = acctime * .5 * get("maxvel")
	    w[axis + "acctime"].set_text("%.4f" % acctime)
	    w[axis + "accdist"].set_text("%.4f" % accdist)
	    w[axis + "hz"].set_text("%.1f" % pps)
	    scale = self.data[axis + "scale"] = (1.0 * pitch * get("steprev")
		* get("microstep") * (get("pulleynum") / get("pulleyden")))
            w[axis + "scale"].set_text("%.1f" % scale)
            self.widgets.druid1.set_buttons_sensitive(1,1,1,1)
            w[axis + "axistest"].set_sensitive(1)
	except (ValueError, ZeroDivisionError): # Some entries not numbers or not valid
	    w[axis + "acctime"].set_text("")
	    w[axis + "accdist"].set_text("")
	    w[axis + "hz"].set_text("")
            w[axis + "scale"].set_text("")
            self.widgets.druid1.set_buttons_sensitive(1,0,1,1)
            w[axis + "axistest"].set_sensitive(0)

    def on_xsteprev_changed(self, *args): self.update_pps('x')
    def on_ysteprev_changed(self, *args): self.update_pps('y')
    def on_zsteprev_changed(self, *args): self.update_pps('z')
    def on_asteprev_changed(self, *args): self.update_pps('a')

    def on_xmicrostep_changed(self, *args): self.update_pps('x')
    def on_ymicrostep_changed(self, *args): self.update_pps('y')
    def on_zmicrostep_changed(self, *args): self.update_pps('z')
    def on_amicrostep_changed(self, *args): self.update_pps('a')

    def on_xpulleynum_changed(self, *args): self.update_pps('x')
    def on_ypulleynum_changed(self, *args): self.update_pps('y')
    def on_zpulleynum_changed(self, *args): self.update_pps('z')
    def on_apulleynum_changed(self, *args): self.update_pps('a')

    def on_xpulleyden_changed(self, *args): self.update_pps('x')
    def on_ypulleyden_changed(self, *args): self.update_pps('y')
    def on_zpulleyden_changed(self, *args): self.update_pps('z')
    def on_apulleyden_changed(self, *args): self.update_pps('a')

    def on_xleadscrew_changed(self, *args): self.update_pps('x')
    def on_yleadscrew_changed(self, *args): self.update_pps('y')
    def on_zleadscrew_changed(self, *args): self.update_pps('z')
    def on_aleadscrew_changed(self, *args): self.update_pps('a')

    def on_xmaxvel_changed(self, *args): self.update_pps('x')
    def on_ymaxvel_changed(self, *args): self.update_pps('y')
    def on_zmaxvel_changed(self, *args): self.update_pps('z')
    def on_amaxvel_changed(self, *args): self.update_pps('a')

    def on_xmaxacc_changed(self, *args): self.update_pps('x')
    def on_ymaxacc_changed(self, *args): self.update_pps('y')
    def on_zmaxacc_changed(self, *args): self.update_pps('z')
    def on_amaxacc_changed(self, *args): self.update_pps('a')

    def on_complete_finish(self, *args):
	self.data.save()
	gtk.main_quit()

    def on_calculate_ideal_period(self, *args):
        steptime = self.widgets.steptime.get_value()
        stepspace = self.widgets.stepspace.get_value()
        latency = self.widgets.latency.get_value()
        minperiod = int(latency + steptime + stepspace + 5000)
        maxhz = int(1e9 / minperiod)

        self.widgets.baseperiod.set_text("%s ns" % minperiod)
        self.widgets.maxsteprate.set_text("%s Hz" % maxhz)

    def update_axis_params(self, *args):
	axis = self.axis_under_test
	if axis is None: return
	halrun = self.halrun
	halrun.write("""
	    setp stepgen.0.maxaccel %(accel)f
	    setp stepgen.0.maxvel %(vel)f
	    setp steptest.0.jog-minus %(jogminus)s
	    setp steptest.0.jog-plus %(jogplus)s
	    setp steptest.0.run %(run)s
	    setp steptest.0.amplitude %(amplitude)f
	    setp steptest.0.maxvel %(vel)f
	    setp steptest.0.dir %(dir)s
	""" % {
	    'jogminus': self.jogminus,
	    'jogplus': self.jogplus,
	    'run': self.widgets.run.get_active(),
	    'amplitude': self.widgets.testamplitude.get_value(),
	    'accel': self.widgets.testacc.get_value(),
	    'vel': self.widgets.testvel.get_value(),
	    'dir': self.widgets.testdir.get_active(),
	})
	halrun.flush()

    def on_jogminus_pressed(self, w):
	self.jogminus = 1
	self.update_axis_params()
    def on_jogminus_released(self, w):
	self.jogminus = 0
	self.update_axis_params()

    def on_jogplus_pressed(self, w):
	self.jogplus = 1
	self.update_axis_params()
    def on_jogplus_released(self, w):
	self.jogplus = 0
	self.update_axis_params()

    def test_axis(self, axis):
	data = self.data
	widgets = self.widgets

	vel = float(widgets[axis + "maxvel"].get_text())
	acc = float(widgets[axis + "maxacc"].get_text())

        scale = data[axis + "scale"]
        maxvel = 1.5 * vel
        period = int(1e9 / maxvel / scale)

        steptime = self.widgets.steptime.get_value()
        stepspace = self.widgets.stepspace.get_value()
        latency = self.widgets.latency.get_value()
        minperiod = int(latency + steptime + stepspace + 5000)

        if period < minperiod:
            period = minperiod
            maxvel = 1e9 / minperiod / abs(scale)
        if period > 100000:
            period = 100000

	self.halrun = halrun = os.popen("halrun -sf > /dev/null", "w")

	axnum = "xyza".index(axis)
	step = XSTEP + 2 * axnum
	dir = XDIR + 2 * axnum

	halrun.write("""
	    loadrt steptest
	    loadrt stepgen step_type=0
	    loadrt probe_parport
	    loadrt hal_parport cfg=%(ioaddr)s
	    loadrt threads period1=%(period)d name1=fast fp1=0 period2=1000000 name2=slow\n

	    addf stepgen.make-pulses fast
	    addf parport.0.write fast
	    addf parport.0.reset fast

	    addf stepgen.capture-position slow
	    addf steptest.0 slow
	    addf stepgen.update-freq slow

	    net step stepgen.0.step => parport.0.pin-%(steppin)02d-out
	    net dir stepgen.0.dir => parport.0.pin-%(dirpin)02d-out
	    net cmd steptest.0.position-cmd => stepgen.0.position-cmd
	    net fb stepgen.0.position-fb => steptest.0.position-fb

	    setp parport.0.pin-%(steppin)02d-out-reset 1
	    setp parport.0.reset-time %(resettime)d
	    setp stepgen.0.stepspace 0
	    setp stepgen.0.steplen 1
	    setp stepgen.0.dirhold %(dirhold)d
	    setp stepgen.0.dirsetup %(dirsetup)d
	    setp stepgen.0.position-scale %(scale)f
	    setp steptest.0.epsilon %(onestep)f

	    setp stepgen.0.enable 1
	""" % {
	    'period': period,
	    'ioaddr': data.ioaddr,
	    'steppin': data.find_output(step),
	    'dirpin': data.find_output(dir),
	    'dirhold': data.dirhold + data.latency,
	    'dirsetup': data.dirsetup + data.latency,
	    'onestep': abs(1. / data[axis + "scale"]),
	    'scale': data[axis + "scale"],
	    'resettime': data['steptime']
	})
	amp = data.find_output(AMP)
	if amp:
	    halrun.write("setp parport.0.pin-%(enablepin)02d-out 1\n"
		% {'enablepin': amp})

	estop = data.find_output(ESTOP)
	if estop:
	    halrun.write("setp parport.0.pin-%(estoppin)02d-out 1\n"
		% {'estoppin': estop})

        for pin in 1,2,3,4,5,6,7,8,9,14,16,17:
            inv = getattr(data, "pin%dinv" % pin)
            if inv:
                halrun.write("setp parport.0.pin-%(pin)02d-out-invert 1\n"
                    % {'pin': pin}) 

	widgets.dialog1.set_title(_("%s Axis Test") % axis.upper())

	if axis == "a":
	    widgets.testvelunit.set_text(_("deg / s"))
	    widgets.testaccunit.set_text(_("deg / s虏"))
	    widgets.testampunit.set_text(_("deg"))
	    widgets.testvel.set_increments(1,5)
	    widgets.testacc.set_increments(1,5)
	    widgets.testamplitude.set_increments(1,5)
	    widgets.testvel.set_range(0, maxvel)
	    widgets.testacc.set_range(1, 360000)
	    widgets.testamplitude.set_range(0, 1440)
	    widgets.testvel.set_digits(1)
	    widgets.testacc.set_digits(1)
	    widgets.testamplitude.set_digits(1)
            widgets.testamplitude.set_value(10)
	elif data.units:
	    widgets.testvelunit.set_text(_("mm / s"))
	    widgets.testaccunit.set_text(_("mm / s虏"))
	    widgets.testampunit.set_text(_("mm"))
	    widgets.testvel.set_increments(1,5)
	    widgets.testacc.set_increments(1,5)
	    widgets.testamplitude.set_increments(1,5)
	    widgets.testvel.set_range(0, maxvel)
	    widgets.testacc.set_range(1, 100000)
	    widgets.testamplitude.set_range(0, 1000)
	    widgets.testvel.set_digits(2)
	    widgets.testacc.set_digits(2)
	    widgets.testamplitude.set_digits(2)
            widgets.testamplitude.set_value(.5)
	else:
	    widgets.testvelunit.set_text(_("in / s"))
	    widgets.testaccunit.set_text(_("in / s虏"))
	    widgets.testampunit.set_text(_("in"))
	    widgets.testvel.set_increments(.1,5)
	    widgets.testacc.set_increments(1,5)
	    widgets.testamplitude.set_increments(.1,5)
	    widgets.testvel.set_range(0, maxvel)
	    widgets.testacc.set_range(1, 3600)
	    widgets.testamplitude.set_range(0, 36)
	    widgets.testvel.set_digits(1)
	    widgets.testacc.set_digits(1)
	    widgets.testamplitude.set_digits(1)
            widgets.testamplitude.set_value(15)

	self.jogplus = self.jogminus = 0
	self.widgets.testdir.set_active(0)
	self.widgets.run.set_active(0)
	self.widgets.testacc.set_value(acc)
	self.widgets.testvel.set_value(vel)
	self.axis_under_test = axis
	self.update_axis_params()

	halrun.write("start\n"); halrun.flush()
	widgets.dialog1.show_all()
	result = widgets.dialog1.run()
	widgets.dialog1.hide()
	
	if amp:
	    halrun.write("""setp parport.0.pin-%02d-out 0\n""" % amp)
	if estop:
	    halrun.write("""setp parport.0.pin-%02d-out 0\n""" % estop)

	time.sleep(.001)

	halrun.close()	

	if result == gtk.RESPONSE_OK:
	    widgets[axis+"maxacc"].set_text("%s" % widgets.testacc.get_value())
	    widgets[axis+"maxvel"].set_text("%s" % widgets.testvel.get_value())
	self.axis_under_test = None

    def run(self, filename=None):
	if filename is not None:
	    self.data.load(filename, self)
	    self.widgets.druid1.set_page(self.widgets.basicinfo)
	gtk.main()

def makedirs(d):
    try:
	os.makedirs(d)
    except os.error, detail:
	if detail.errno != errno.EEXIST: raise
makedirs(os.path.expanduser("~/emc2/configs"))

opts, args = getopt.getopt(sys.argv[1:], "fr")
mode = 0
force = 0
for k, v in opts:
    if k == "-r": mode = 1
    if k == "-f": force = 1

if mode:
    filename = args[0]
    data = Data()
    data.load(filename, None, force)
    data.save()
elif args:
    app = App()
    app.run(args[0])
else:
    app = App()
    app.run()