Пример #1
0
def setup_stepper_multiplexer(stepgenIndex, sections, selSignal, thread):
    num = len(sections)
    sigBase = 'stepgen-%i' % stepgenIndex

    unsignedSignals = [['dirsetup', 'DIRSETUP'],
                       ['dirhold', 'DIRHOLD'],
                       ['steplen', 'STEPLEN'],
                       ['stepspace', 'STEPSPACE']]

    floatSignals = [['scale', 'SCALE'],
                    ['max-vel', 'STEPGEN_MAX_VEL'],
                    ['max-acc', 'STEPGEN_MAX_ACC']]

    for item in unsignedSignals:
        signal = hal.Signal('%s-%s' % (sigBase, item[0]), hal.HAL_U32)
        mux = rt.newinst('muxn_u32', 'mux%i.%s' % (num, signal.name), pincount=num)
        hal.addf(mux.name, thread)
        for n, section in enumerate(sections):
            mux.pin('in%i' % n).set(c.find(section, item[1]))
        mux.pin('sel').link(selSignal)
        mux.pin('out').link(signal)

    for item in floatSignals:
        signal = hal.Signal('%s-%s' % (sigBase, item[0]), hal.HAL_FLOAT)
        mux = rt.newinst('muxn', 'mux%i.%s' % (num, signal.name), pincount=num)
        hal.addf(mux.name, thread)
        for n, section in enumerate(sections):
            mux.pin('in%i' % n).set(c.find(section, item[1]))
        mux.pin('sel').link(selSignal)
        mux.pin('out').link(signal)
Пример #2
0
def setup_motion(kinematics='trivkins'):
    rt.loadrt(kinematics)
    rt.loadrt('tp')

    # motion controller, get name and thread periods from ini file
    rt.loadrt(c.find('EMCMOT', 'EMCMOT'),
              servo_period_nsec=c.find('EMCMOT', 'SERVO_PERIOD'),
              num_joints=c.find('TRAJ', 'AXES'),
              num_aio=51,
              num_dio=21)
Пример #3
0
def setup_system_fan(replicape):
    en = config.find('FDM', 'SYSTEM_FAN', 0)
    if int(en) == 0:
        return

    fan_sig = hal.newsig('fan-output', hal.HAL_FLOAT)
    replicape.get_fan_pwm_pin(3).link(fan_sig)
    fan_sig.set(1.0)
Пример #4
0
def setup_system_fan(replicape):
    en = config.find('FDM','SYSTEM_FAN', 0)
    if int(en) == 0:
        return

    fan_sig = hal.newsig('fan-output', hal.HAL_FLOAT)
    replicape.get_fan_pwm_pin(3).link(fan_sig)
    fan_sig.set(1.0)
Пример #5
0
def setup_motion(kinematics='trivkins'):
    rt.loadrt(kinematics)
    rt.loadrt('tp')
    rt.loadrt('hostmot2')

    #    rt.newinst(c.find('HOSTMOT2', 'DRIVER'),
    #        c.find('HOSTMOT2', 'DEVNAME'),
    #        c.find('HOSTMOT2', 'CONFIG'))
    os.system(
        'halcmd newinst hm2_soc_ol hm2-socfpga0 -- config="firmware=socfpga/dtbo/DE0_Nano_SoC_Cramps.3x24.dtbo num_pwmgens=6 num_stepgens=8 enable_adc=1" debug=1'
    )

    # motion controller, get name and thread periods from ini file
    rt.loadrt(c.find('EMCMOT', 'EMCMOT'),
              servo_period_nsec=c.find('EMCMOT', 'SERVO_PERIOD'),
              num_joints=c.find('TRAJ', 'AXES'),
              num_aio=51,
              num_dio=21)
Пример #6
0
def setup_servo_toggle(servoIndex, section, pwm, selectSignal, thread=None):
    servo = '%s.%02i' % ('rc_servo', servoIndex)
    mux2 = rt.newinst('mux2', '%s-mux2' % servo)
    hal.addf(mux2.name, thread)
    pwmout = hal.newsig('%s-pwm-out' % servo, hal.HAL_FLOAT)
    mux2.pin('out').link(pwmout)
    hal.Pin('%s.value' % pwm).link(pwmout)
    enable = hal.Signal('emcmot-0-enable', hal.HAL_BIT)
    hal.Pin('%s.enable' % pwm).link(enable)

    sigBase = 'rc-servo-%i' % servoIndex
    smin = hal.newsig('%s-min' % sigBase, hal.HAL_FLOAT)
    smax = hal.newsig('%s-max' % sigBase, hal.HAL_FLOAT)

    hal.Pin('%s-mux2.in1' % servo).link(smin)
    hal.Pin('%s-mux2.in0' % servo).link(smax)
    smin.set(c.find(section, 'SERVO_MIN', 0.1))
    smax.set(c.find(section, 'SERVO_MAX', 0.2))
    mux2.pin('sel').link('%s' % selectSignal)
Пример #7
0
def configure_stepgen():
    # stepgen config
    hal.Pin('hpg.stepgen.00.steppin').set(812)
    hal.Pin('hpg.stepgen.00.dirpin').set(811)
    hal.Pin('hpg.stepgen.00.control-type').set(1)  # velocity mode
    hal.Pin('hpg.stepgen.00.position-scale').set(c.find('STEPPER', 'SCALE'))
    hal.Pin('hpg.stepgen.00.dirsetup').set(c.find('STEPPER', 'DIRSETUP'))
    hal.Pin('hpg.stepgen.00.dirhold').set(c.find('STEPPER', 'DIRHOLD'))
    hal.Pin('hpg.stepgen.00.steplen').set(c.find('STEPPER', 'STEPLEN'))
    hal.Pin('hpg.stepgen.00.stepspace').set(c.find('STEPPER', 'STEPSPACE'))
    hal.Pin('hpg.stepgen.00.velocity-cmd').link(
        hal.Signal('motor-vel', hal.HAL_FLOAT))
    hal.Pin('hpg.stepgen.00.enable').link(
        hal.Signal('motor-enable', hal.HAL_BIT))

    # machine power
    hal.Pin('bb_gpio.p9.out-26').link(hal.Signal('motor-enable', hal.HAL_BIT))
    hal.Pin('bb_gpio.p8.out-07').link(hal.Signal('motor-enable', hal.HAL_BIT))
    hal.Pin('bb_gpio.p8.out-07.invert').set(True)
Пример #8
0
    def __init__(self):
        self.gpio = rtapi.loadrt('hal_bb_gpio', 
            output_pins='', 
            input_pins='810,809,924,818,923,925,916,918,911,913')

        self.dac = hal.loadusr(USR_HAL_PATH + 'hal_replicape_dac',
            name='replicape_dac',
            wait_name='replicape_dac')

        self.hwconfig = hal.loadusr(USR_HAL_PATH + 'hal_replicape_A4_hwconfig',
            name='replicape_hwconfig',
            wait_name='replicape_hwconfig')

        for i in xrange(5):
            # Default: microstepping=1/32, fast decay
            self.hwconfig.pin('stepper.%i.microstepping' % i).set(config.find('FDM','STEPPER_%i_MICROSTEPPING' % i, 5))
            self.hwconfig.pin('stepper.%i.decay' % i).set(config.find('FDM','STEPPER_%i_DECAY' % i, 0))

        super(ReplicapeA4A, self).__init__()
Пример #9
0
def setup_axis(replicape, command, feedback, nr):
    section = 'AXIS_%d' % nr
    port_str = config.find(section, 'PORT', str(nr))
    ports = re.split('\s*,\s*', port_str)

    replicape.get_pru_pin('%s.position-fb' % replicape.get_stepgen(ports[0])).link(feedback)
    for port in ports:
        sg = replicape.get_stepgen(port)
        replicape.get_pru_pin('%s.position-cmd' % (sg)).link(command)
        replicape.get_pru_pin('%s.position-scale' % (sg)) \
            .set(float(
                config.find(section, 'SCALE_PORT_%s' % port, config.find(section, 'SCALE', 'SCALE must be defined'))
            ))
        replicape.get_pru_pin('%s.enable' % (sg)).link('main-enable')
        replicape.set_motor_current(
            replicape.get_motor_port(port),
            float(
                config.find(section, 'CURRENT_PORT_%s' % port, config.find(section, 'CURRENT', DEFAULT_CURRENT))
            ))
Пример #10
0
def setup_axis(replicape, command, feedback, nr):
    section = 'AXIS_%d' % nr
    port_str = config.find(section, 'PORT', str(nr))
    ports = re.split('\s*,\s*', port_str)

    replicape.get_pru_pin('%s.position-fb' % replicape.get_stepgen(ports[0])).link(feedback)
    for port in ports:
        sg = replicape.get_stepgen(port)
        replicape.get_pru_pin('%s.position-cmd' % (sg)).link(command)
        replicape.get_pru_pin('%s.position-scale' % (sg)) \
            .set(float(
                config.find(section, 'SCALE_PORT_%s' % port, config.find(section, 'SCALE', 'SCALE must be defined'))
            ))
        replicape.get_pru_pin('%s.enable' % (sg)).link('main-enable')
        replicape.set_motor_current(
            replicape.get_motor_port(port),
            float(
                config.find(section, 'CURRENT_PORT_%s' % port, config.find(section, 'CURRENT', DEFAULT_CURRENT))
            ))
Пример #11
0
def setup_extruder(replicape, extruder, nr):
    section = 'EXTRUDER_%d' % nr
    port_str = str(config.find(section, 'PORT', str(nr + 3)))  # Extruder starts at port 3, after XYZ
    ports = re.split('\s*,\s*', port_str)

    for port in ports:
        sg = replicape.get_stepgen(port)
        replicape.get_pru_pin('%s.control-type' % (sg)).set(1)
        replicape.get_pru_pin('%s.velocity-cmd' % (sg)).link(extruder.extrude_vel_sig)
        replicape.get_pru_pin('%s.position-scale' % (sg)) \
            .set(float(
                config.find(section, 'SCALE_PORT_%s' % port, config.find(section, 'SCALE', 'SCALE must be defined'))
            ))
        replicape.get_pru_pin('%s.enable' % (sg)).link('main-enable')
        replicape.set_motor_current(
            replicape.get_motor_port(port),
            float(
                config.find(section, 'CURRENT_PORT_%s' % port, config.find(section, 'CURRENT', DEFAULT_CURRENT))
            ))
Пример #12
0
def setup_extruder(replicape, extruder, nr):
    section = 'EXTRUDER_%d' % nr
    port_str = str(config.find(section, 'PORT', str(nr + 3)))  # Extruder starts at port 3, after XYZ
    ports = re.split('\s*,\s*', port_str)

    for port in ports:
        sg = replicape.get_stepgen(port)
        replicape.get_pru_pin('%s.control-type' % (sg)).set(1)
        replicape.get_pru_pin('%s.velocity-cmd' % (sg)).link(extruder.extrude_vel_sig)
        replicape.get_pru_pin('%s.position-scale' % (sg)) \
            .set(float(
                config.find(section, 'SCALE_PORT_%s' % port, config.find(section, 'SCALE', 'SCALE must be defined'))
            ))
        replicape.get_pru_pin('%s.enable' % (sg)).link('main-enable')
        replicape.set_motor_current(
            replicape.get_motor_port(port),
            float(
                config.find(section, 'CURRENT_PORT_%s' % port, config.find(section, 'CURRENT', DEFAULT_CURRENT))
            ))
Пример #13
0
    def __init__(self):
        self.gpio = rtapi.loadrt('hal_bb_gpio', 
            output_pins='', 
            input_pins='810,809,924,818,923,925,916,918,911,913')

        self.dac = hal.loadusr(USR_HAL_PATH + 'hal_replicape_dac',
            name='replicape_dac',
            wait_name='replicape_dac')

        self.hwconfig = hal.loadusr(USR_HAL_PATH + 'hal_replicape_A4_hwconfig',
            name='replicape_hwconfig',
            wait_name='replicape_hwconfig')

        for i in xrange(5):
            # Default: microstepping=1/32, fast decay
            self.hwconfig.pin('stepper.%i.microstepping' % i).set(config.find('FDM','STEPPER_%i_MICROSTEPPING' % i, 5))
            self.hwconfig.pin('stepper.%i.decay' % i).set(config.find('FDM','STEPPER_%i_DECAY' % i, 0))

        super(ReplicapeA4A, self).__init__()
Пример #14
0
def setup_stepper(stepgenIndex,
                  section,
                  axisIndex=None,
                  stepgenType='hpg.stepgen',
                  gantry=False,
                  gantryJoint=0,
                  velocitySignal=None,
                  thread=None):
    stepgen = '%s.%01i' % (stepgenType, stepgenIndex)
    if axisIndex is not None:
        axis = 'axis.%i' % axisIndex
    hasMotionAxis = (axisIndex is not None) and (not gantry
                                                 or gantryJoint == 0)
    velocityControlled = velocitySignal is not None

    # axis enable chain
    enableIndex = axisIndex
    if axisIndex is None:
        enableIndex = 0  # use motor enable signal
    enable = hal.Signal('emcmot-%i-enable' % enableIndex, hal.HAL_BIT)
    if hasMotionAxis:
        enable.link('%s.amp-enable-out' % axis)
    enable.link('%s.enable' % stepgen)

    # expose timing parameters so we can multiplex them later
    sigBase = 'stepgen.%i' % stepgenIndex

    assign_param(sigBase, "position-scale", c.find(section, 'SCALE'))
    assign_param(sigBase, "maxaccel", c.find(section, 'STEPGEN_MAXACC'))
    #assign_param(sigBase,"maxvel",c.find("ABP", 'STEPGEN_MAXVEL'))

    # position command and feedback
    limitHome = hal.newsig('limit-%i-home' % axisIndex, hal.HAL_BIT)
    limitMin = hal.newsig('limit-%i-min' % axisIndex, hal.HAL_BIT)
    limitMax = hal.newsig('limit-%i-max' % axisIndex, hal.HAL_BIT)
    limitHome.link('%s.home-sw-in' % axis)
    limitMin.link('%s.neg-lim-sw-in' % axis)
    limitMax.link('%s.pos-lim-sw-in' % axis)

    if velocityControlled:
        hal.net(velocitySignal, '%s.velocity-cmd' % stepgen)
Пример #15
0
def init_hardware():
    watchList = []

    # Python user-mode HAL module to read ADC value and generate a thermostat output for PWM
    defaultThermistor = 'semitec_103GT_2'
    hal.loadusr('hal_temp_atlas',
                name='temp',
                filter_size=20,
                channels='00:%s,01:%s,02:%s,03:%s' %
                (c.find('HBP', 'THERMISTOR', defaultThermistor),
                 c.find('EXTRUDER_0', 'THERMISTOR', defaultThermistor),
                 c.find('EXTRUDER_1', 'THERMISTOR', defaultThermistor),
                 c.find('EXTRUDER_2', 'THERMISTOR', defaultThermistor)),
                wait_name='temp')
    watchList.append(['temp', 0.1])

    base.usrcomp_status('temp', 'temp-hw', thread='servo-thread')
    base.usrcomp_watchdog(watchList,
                          'estop-reset',
                          thread='servo-thread',
                          errorSignal='watchdog-error')
Пример #16
0
def init_hardware():
    watchList = []

    # load low-level drivers
    rt.loadrt('hal_bb_gpio',
              output_pins='816,822,823,824,825,826,914,923,925',
              input_pins='807,808,809,810,817,911,913')
    prubin = '%s/%s' % (c.Config().EMC2_RTLIB_DIR, c.find('PRUCONF', 'PRUBIN'))
    rt.loadrt(c.find('PRUCONF', 'DRIVER'),
              pru=0,
              num_stepgens=6,
              num_pwmgens=6,
              prucode=prubin,
              halname='hpg')

    # Python user-mode HAL module to read ADC value and generate a thermostat output for PWM
    defaultThermistor = 'semitec_103GT_2'
    hal.loadusr('hal_temp_bbb',
                name='temp',
                interval=0.05,
                filter_size=1,
                cape_board='CRAMPS',
                channels='04:%s,05:%s,02:%s,03:%s' %
                (c.find('HBP', 'THERMISTOR', defaultThermistor),
                 c.find('EXTRUDER_0', 'THERMISTOR', defaultThermistor),
                 c.find('EXTRUDER_1', 'THERMISTOR', defaultThermistor),
                 c.find('EXTRUDER_2', 'THERMISTOR', defaultThermistor)),
                wait_name='temp')
    watchList.append(['temp', 0.1])

    base.usrcomp_status('temp', 'temp-hw', thread='servo-thread')
    base.usrcomp_watchdog(watchList,
                          'estop-reset',
                          thread='servo-thread',
                          errorSignal='watchdog-error')
Пример #17
0
def init_hardware():
    watchList = []

    # load low-level drivers
    rt.loadrt('hal_bb_gpio', output_pins='816,822,823,824,825,826,914,923,925', input_pins='807,808,809,810,817,911,913')
    prubin = '%s/%s' % (c.Config().EMC2_RTLIB_DIR, c.find('PRUCONF', 'PRUBIN'))
    rt.loadrt(c.find('PRUCONF', 'DRIVER'),
              pru=0, num_stepgens=6, num_pwmgens=6,
              prucode=prubin, halname='hpg')

    # Python user-mode HAL module to read ADC value and generate a thermostat output for PWM
    defaultThermistor = 'semitec_103GT_2'
    hal.loadusr('hal_temp_bbb',
                name='temp',
                interval=0.05,
                filter_size=1,
                cape_board='CRAMPS',
                channels='04:%s,05:%s,02:%s,03:%s'
                % (c.find('HBP', 'THERMISTOR', defaultThermistor),
                   c.find('EXTRUDER_0', 'THERMISTOR', defaultThermistor),
                   c.find('EXTRUDER_1', 'THERMISTOR', defaultThermistor),
                   c.find('EXTRUDER_2', 'THERMISTOR', defaultThermistor)),
                wait_name='temp')
    watchList.append(['temp', 0.1])

    base.usrcomp_status('temp', 'temp-hw', thread='servo-thread')
    base.usrcomp_watchdog(watchList, 'estop-reset', thread='servo-thread',
                          errorSignal='watchdog-error')
Пример #18
0
    def __init__(self):
        self.gpio = rtapi.loadrt('hal_bb_gpio', 
            output_pins='941', 
            input_pins='810,809,924,818,923,925,928,918,911,913')

        self.hwconfig = hal.loadusr(USR_HAL_PATH + 'hal_replicape_B3_hwconfig',
            name='replicape_hwconfig',
            wait_name='replicape_hwconfig')

        for i in xrange(5):
            # Default: spreadMode, microstepping=1/16
            self.hwconfig.pin('stepper.%i.mode' % i).set(config.find('FDM','STEPPER_%i_MODE' % i, 0x80))

        super(ReplicapeB3A, self).__init__()
Пример #19
0
    def __init__(self):
        self.gpio = rtapi.loadrt('hal_bb_gpio', 
            output_pins='941', 
            input_pins='810,809,924,818,923,925,928,918,911,913')

        self.hwconfig = hal.loadusr(USR_HAL_PATH + 'hal_replicape_B3_hwconfig',
            name='replicape_hwconfig',
            wait_name='replicape_hwconfig')

        for i in xrange(5):
            # Default: spreadMode, microstepping=1/16
            self.hwconfig.pin('stepper.%i.mode' % i).set(config.find('FDM','STEPPER_%i_MODE' % i, 0x80))

        super(ReplicapeB3A, self).__init__()
Пример #20
0
def setup_motion(kinematics='trivkins', tp='tp', num_aio=50, num_dio=21):
    rt.loadrt(kinematics)
    #    rt.loadrt(tp)

    # hostmot2 setup  get names and config from ini file
    hostmot2 = bool(c.find('HOSTMOT2', 'DRIVER'))
    if hostmot2:
        rt.loadrt('hostmot2')
        os.system(
            'halcmd newinst hm2_soc_ol hm2-socfpga0 already_programmed=1 -- config="num_pwmgens=1 num_stepgens=4"'
        )


#        rt.newinst(c.find('HOSTMOT2', 'DRIVER'),
#            c.find('HOSTMOT2', 'DEVNAME'),
#            "-- ",
#            c.find('HOSTMOT2', 'CONFIG'))

# motion controller, get name and thread periods from ini file
    rt.loadrt(c.find('EMCMOT', 'EMCMOT'),
              servo_period_nsec=c.find('EMCMOT', 'SERVO_PERIOD'),
              num_joints=c.find('TRAJ', 'AXES'),
              num_aio=num_aio,
              num_dio=num_dio)
Пример #21
0
def setup_limit_switches(replicape):
    limit_x_sig = hal.newsig('limit-x', hal.HAL_BIT)
    limit_x_sig.link('axis.0.home-sw-in')
    limit_x_pos = config.find('AXIS_0', 'HOME_SEARCH_VEL', 0)
    if limit_x_pos < 0:
        replicape.get_limit_pin('X', False).link(limit_x_sig)
        limit_x_sig.link('axis.0.neg-lim-sw-in')
    if limit_x_pos > 0:
        replicape.get_limit_pin('X', True).link(limit_x_sig)
        limit_x_sig.link('axis.0.pos-lim-sw-in')

    limit_y_sig = hal.newsig('limit-y', hal.HAL_BIT)
    limit_y_sig.link('axis.1.home-sw-in')
    limit_y_pos = config.find('AXIS_1', 'HOME_SEARCH_VEL', 0)
    if limit_y_pos < 0:
        replicape.get_limit_pin('Y', False).link(limit_y_sig)
        limit_y_sig.link('axis.1.neg-lim-sw-in')
    if limit_y_pos > 0:
        replicape.get_limit_pin('Y', True).link(limit_y_sig)
        limit_y_sig.link('axis.1.pos-lim-sw-in')

    limit_z_sig = hal.newsig('limit-z', hal.HAL_BIT)
    limit_z_sig.link('axis.2.home-sw-in')
    limit_z_pos = config.find('AXIS_2', 'HOME_SEARCH_VEL', 0)
    if limit_z_pos < 0:
        replicape.get_limit_pin('Z', False).link(limit_z_sig)
        limit_z_sig.link('axis.2.neg-lim-sw-in')
    if limit_z_pos > 0:
        replicape.get_limit_pin('Z', True).link(limit_z_sig)
        limit_z_sig.link('axis.2.pos-lim-sw-in')

    probe_pin = replicape.get_probe_pin();
    if probe_pin is not None:
        probe_sig = hal.newsig('limit-probe', hal.HAL_BIT)
        probe_sig.link(probe_pin)
        probe_sig.link('motion.probe-input')
Пример #22
0
def setup_limit_switches(replicape):
    limit_x_sig = hal.newsig('limit-x', hal.HAL_BIT)
    limit_x_sig.link('axis.0.home-sw-in')
    limit_x_pos = config.find('AXIS_0', 'HOME_SEARCH_VEL', 0)
    if limit_x_pos < 0:
        replicape.get_limit_pin('X', False).link(limit_x_sig)
        limit_x_sig.link('axis.0.neg-lim-sw-in')
    if limit_x_pos > 0:
        replicape.get_limit_pin('X', True).link(limit_x_sig)
        limit_x_sig.link('axis.0.pos-lim-sw-in')

    limit_y_sig = hal.newsig('limit-y', hal.HAL_BIT)
    limit_y_sig.link('axis.1.home-sw-in')
    limit_y_pos = config.find('AXIS_1', 'HOME_SEARCH_VEL', 0)
    if limit_y_pos < 0:
        replicape.get_limit_pin('Y', False).link(limit_y_sig)
        limit_y_sig.link('axis.1.neg-lim-sw-in')
    if limit_y_pos > 0:
        replicape.get_limit_pin('Y', True).link(limit_y_sig)
        limit_y_sig.link('axis.1.pos-lim-sw-in')

    limit_z_sig = hal.newsig('limit-z', hal.HAL_BIT)
    limit_z_sig.link('axis.2.home-sw-in')
    limit_z_pos = config.find('AXIS_2', 'HOME_SEARCH_VEL', 0)
    if limit_z_pos < 0:
        replicape.get_limit_pin('Z', False).link(limit_z_sig)
        limit_z_sig.link('axis.2.neg-lim-sw-in')
    if limit_z_pos > 0:
        replicape.get_limit_pin('Z', True).link(limit_z_sig)
        limit_z_sig.link('axis.2.pos-lim-sw-in')

    probe_pin = replicape.get_probe_pin();
    if probe_pin is not None:
        probe_sig = hal.newsig('limit-probe', hal.HAL_BIT)
        probe_sig.link(probe_pin)
        probe_sig.link('motion.probe-input')
Пример #23
0
    def __init__(self, replicape, enable_sig, estop_reset_sig):
        config_name = 'HBP'
        thermistor = config.find(config_name, 'THERMISTOR', '')
        if thermistor == '':
            raise ValueError('[%s] THERMISTOR must be defined' % (config_name))

        temp_hal = hal.loadusr(USR_HAL_PATH + 'hal_bbb_temp',
            name='ThermHbp',
            wait_name='ThermHbp',
            cape_board='Replicape',
            channel=replicape.get_hbp_adc_channel(),
            thermistor=thermistor)

        super(HbpTemperature, self).__init__(
            temp_hal, replicape.get_hbp_pwm_pin(), replicape.get_hbp_on_pin(), 
            enable_sig, estop_reset_sig,
            config_name, 'fdm-hbp', 'temp.hbp', 0)
Пример #24
0
def setup_linearDeltaKins(c):
    #    c.load_ini(os.environ['INI_FILE_NAME'])

    deltaCfRod = c.find('MACHINE', 'CF_ROD')
    deltaRadius = c.find('MACHINE', 'DELTA_R')
    deltaJoin0Offset = c.find('MACHINE', 'JOINT_0_OFFSET', 0)
    deltaJoin1Offset = c.find('MACHINE', 'JOINT_1_OFFSET', 0)
    deltaJoin2Offset = c.find('MACHINE', 'JOINT_2_OFFSET', 0)
    deltaJoin1AngleOffset = c.find('MACHINE', 'JOINT_1_ANGLE_OFFSET', 0)
    deltaJoin2AngleOffset = c.find('MACHINE', 'JOINT_2_ANGLE_OFFSET', 0)
    deltaJoin1RadiusOffset = c.find('MACHINE', 'JOINT_1_RADIUS_OFFSET', 0)
    deltaJoin2RadiusOffset = c.find('MACHINE', 'JOINT_2_RADIUS_OFFSET', 0)

    c.load_ini(os.environ['INI_FILE_NAME'])

    hal.Pin('lineardeltakins.L').set(deltaCfRod)
    hal.Pin('lineardeltakins.R').set(deltaRadius)
    hal.Pin('lineardeltakins.J0off').set(deltaJoin0Offset)
    hal.Pin('lineardeltakins.J1off').set(deltaJoin1Offset)
    hal.Pin('lineardeltakins.J2off').set(deltaJoin2Offset)
    hal.Pin('lineardeltakins.A1off').set(deltaJoin1AngleOffset)
    hal.Pin('lineardeltakins.A2off').set(deltaJoin2AngleOffset)
    hal.Pin('lineardeltakins.R1off').set(deltaJoin1RadiusOffset)
    hal.Pin('lineardeltakins.R2off').set(deltaJoin2RadiusOffset)
Пример #25
0
def setup_linearDeltaKins(c):
#    c.load_ini(os.environ['INI_FILE_NAME'])

    deltaCfRod = c.find('MACHINE', 'CF_ROD')
    deltaRadius = c.find('MACHINE', 'DELTA_R')
    deltaJoin0Offset = c.find('MACHINE', 'JOINT_0_OFFSET',0)
    deltaJoin1Offset = c.find('MACHINE', 'JOINT_1_OFFSET',0)
    deltaJoin2Offset = c.find('MACHINE', 'JOINT_2_OFFSET',0)
    deltaJoin1AngleOffset = c.find('MACHINE', 'JOINT_1_ANGLE_OFFSET',0)
    deltaJoin2AngleOffset = c.find('MACHINE', 'JOINT_2_ANGLE_OFFSET',0)
    deltaJoin1RadiusOffset = c.find('MACHINE', 'JOINT_1_RADIUS_OFFSET',0)
    deltaJoin2RadiusOffset = c.find('MACHINE', 'JOINT_2_RADIUS_OFFSET',0)

    c.load_ini(os.environ['INI_FILE_NAME'])

    hal.Pin('lineardeltakins.L').set(deltaCfRod)
    hal.Pin('lineardeltakins.R').set(deltaRadius)
    hal.Pin('lineardeltakins.J0off').set(deltaJoin0Offset)
    hal.Pin('lineardeltakins.J1off').set(deltaJoin1Offset)
    hal.Pin('lineardeltakins.J2off').set(deltaJoin2Offset)
    hal.Pin('lineardeltakins.A1off').set(deltaJoin1AngleOffset)
    hal.Pin('lineardeltakins.A2off').set(deltaJoin2AngleOffset)
    hal.Pin('lineardeltakins.R1off').set(deltaJoin1RadiusOffset)
    hal.Pin('lineardeltakins.R2off').set(deltaJoin2RadiusOffset)
Пример #26
0
    def __init__(self, replicape, index, enable_sig, estop_reset_sig):
        config_name = 'EXTRUDER_%s' % (index)
        thermistor = config.find(config_name, 'THERMISTOR', '')
        if thermistor == '':
            raise ValueError('[%s] THERMISTOR must be defined' % (config_name))

        temp_hal = hal.loadusr(USR_HAL_PATH + 'hal_bbb_temp',
            name='Therm%s' % (index),
            wait_name='Therm%s' % (index),
            cape_board='Replicape',
            channel=replicape.get_extruder_adc_channel(index),
            thermistor=thermistor)

        super(ExtruderTemperature, self).__init__(
            temp_hal, replicape.get_extruder_pwm_pin(index), replicape.get_extruder_on_pin(index), 
            enable_sig, estop_reset_sig,
            config_name, 'fdm-e%s' % (index), 'temp.e%s' % (index), 
            index + 2
        )
Пример #27
0
def check_version():
    global BOARD_REV
# we use a 4.14.18-ti-rt-r33 kernel and have enable_uboot_overlays=1
# in /boot/uEnv.txt
# u-boot overlays do not use the slots file, so we take the board
# version from the INI file
# is there any way to find not just the loaded cape name, but also
# its version (short of reading the cape eeprom)?
# we check in /sys/proc/cmdline for the REPLICAPE cape
#
#    with open('/sys/devices/platform/bone_capemgr/slots', 'r') as file:
#        content = file.read()
    content = subprocess.check_output(['cat','/proc/cmdline'])
    if re.search('capes=BB-BONE-REPLICAP', content) is None:
        raise RuntimeError('Replicape not found. Is the cape mounted?')

    content = config.find('FDM','BOARD_REV')
    if (content is not None) and (content in ['B3A', 'A4A']):
        BOARD_REV = content
    else:
        raise RuntimeError('BOARD_REV not set in ini file. Set to B3A or A4A!')
Пример #28
0
def setup_motion(kinematics='trivkins', tp='tp', num_aio=50, num_dio=21):
    rt.loadrt(kinematics)
    #    rt.loadrt(tp)

    # hostmot2 setup  get names and config from ini file
    hostmot2 = bool(c.find('HOSTMOT2', 'DRIVER'))
    if hostmot2:
        rt.loadrt('hostmot2')
        rt.newinst(c.find('HOSTMOT2', 'DRIVER'), c.find('HOSTMOT2', 'DEVNAME'),
                   "-- ", c.find('HOSTMOT2', 'CONFIG'))

    # motion controller, get name and thread periods from ini file
    rt.loadrt(c.find('EMCMOT', 'EMCMOT'),
              servo_period_nsec=c.find('EMCMOT', 'SERVO_PERIOD'),
              num_joints=c.find('TRAJ', 'AXES'),
              num_aio=num_aio,
              num_dio=num_dio,
              tp=tp,
              kins=kinematics)
Пример #29
0
def check_version():
    global BOARD_REV
# we use a 4.14.18-ti-rt-r33 kernel and have enable_uboot_overlays=1
# in /boot/uEnv.txt
# u-boot overlays do not use the slots file, so we take the board
# version from the INI file
# is there any way to find not just the loaded cape name, but also
# its version (short of reading the cape eeprom)?
# we check in /sys/proc/cmdline for the REPLICAPE cape
#
#    with open('/sys/devices/platform/bone_capemgr/slots', 'r') as file:
#        content = file.read()
    content = subprocess.check_output(['cat','/proc/cmdline'])
    if re.search('capes=BB-BONE-REPLICAP', content) is None:
        raise RuntimeError('Replicape not found. Is the cape mounted?')

    content = config.find('FDM','BOARD_REV')
    if (content is not None) and (content in ['B3A', 'A4A']):
        BOARD_REV = content
    else:
        raise RuntimeError('BOARD_REV not set in ini file. Set to B3A or A4A!')
Пример #30
0
def setup_fans(replicape):
    if NUM_FANS == 0:
    	return
    en = config.find('FDM','SYSTEM_FAN', 0)
    fan_out = [None] * NUM_FANS
    fan_scale = [None] * NUM_FANS
    fan_in = [None] * NUM_FANS
    #on-board pwm input is 0.0 to 1.0, M106 sends 0 to 255
    for i in xrange(NUM_FANS):
        fan_out[i] =  hal.newsig('fan-out-%d' % i, hal.HAL_FLOAT)
        replicape.get_fan_pwm_pin(i).link(fan_out[i])
        # the system fan is connected to the last fan pwm output
        if (int(en) > 0) and (i == NUM_FANS-1):
            fan_out[i].set(1.0)
        else:
            fan_in[i] = hal.newsig('fan-in-%d' % i, hal.HAL_FLOAT)
            fan_in[i].link('motion.analog-out-io-%d' % (FAN_IO_START + i))
            fan_scale[i] = rtapi.newinst('div2', 'fan%d.div2.scale-pwm' % i)
            hal.addf(fan_scale[i].name, SERVO_THREAD)
            fan_scale[i].pin('in0').link(fan_in[i])
            fan_scale[i].pin('in1').set(255.0)
            fan_scale[i].pin('out').link(fan_out[i])
Пример #31
0
 def _init_config(self, config):
     configs = [
         (self.filament_dia_sig,   ['FILAMENT_DIAMETER', 'FILAMENT_DIA'],    '3'),
         (self.extrude_scale_sig,  ['EXTRUDE_SCALE'],                        '1'),
         (self.accel_gain_sig,     ['ACCELERATION_GAIN'],                    '0.05'),
         (self.max_jog_vel_sig,    ['MAX_JOG_VELOCITY', 'MAX_VELOCITY'],     '40'),
         (self.retract_len_sig,    ['RETRACT_LENGTH', 'RETRACT_LEN'],        '3'),
         (self.retract_vel_sig,    ['RETRACT_VELOCITY', 'RETRACT_VEL'],      '60')
     ]
     for i in configs:
         (signal, config_names, config_default) = i
         v = None
         for config_name in config_names:
             v = config.find('EXTRUDER_%d' % self.nr, config_name)
             if v is not None:
                 break
         if v is None:
             v = config_default
         if v is None:
             raise ValueError('Config [EXTRUDER_%d] %s must be defined' % (self.nr, config_nammes[0]))
         float_v = float(v)
         signal.set(float_v)
Пример #32
0
def setup_fans(replicape):
    if NUM_FANS == 0:
        return
    en = config.find('FDM', 'SYSTEM_FAN', 0)
    fan_out = [None] * NUM_FANS
    fan_scale = [None] * NUM_FANS
    fan_in = [None] * NUM_FANS
    #on-board pwm input is 0.0 to 1.0, M106 sends 0 to 255
    for i in xrange(NUM_FANS):
        fan_out[i] = hal.newsig('fan-out-%d' % i, hal.HAL_FLOAT)
        replicape.get_fan_pwm_pin(i).link(fan_out[i])
        # the system fan is connected to the last fan pwm output
        if (int(en) > 0) and (i == NUM_FANS - 1):
            fan_out[i].set(1.0)
        else:
            fan_in[i] = hal.newsig('fan-in-%d' % i, hal.HAL_FLOAT)
            fan_in[i].link('motion.analog-out-io-%d' % (FAN_IO_START + i))
            fan_scale[i] = rtapi.newinst('div2', 'fan%d.div2.scale-pwm' % i)
            hal.addf(fan_scale[i].name, SERVO_THREAD)
            fan_scale[i].pin('in0').link(fan_in[i])
            fan_scale[i].pin('in1').set(255.0)
            fan_scale[i].pin('out').link(fan_out[i])
Пример #33
0
    def __init__(self):
        self.pru = rtapi.loadrt('hal_pru_generic', 
            pru=0, num_stepgens=5, num_pwmgens=0, halname='hpg',
            prucode='%s/rt-preempt/pru_generic.bin' % (config.Config().EMC2_RTLIB_DIR))
# 4.14.18-ti-rt-r33 kernel and rt-preempt
        hal.addf('hpg.capture-position', SERVO_THREAD)
        hal.addf('hpg.update', SERVO_THREAD)
        hal.addf('bb_gpio.read', SERVO_THREAD)
        hal.addf('bb_gpio.write', SERVO_THREAD)
        minvel = config.find('TRAJ','MIN_VELOCITY', 0.001)
        for i in xrange(5):
            self.get_pru_pin('stepgen.%02i.dirsetup' % i).set(200)
            self.get_pru_pin('stepgen.%02i.dirhold' % i).set(200)
            self.get_pru_pin('stepgen.%02i.steplen' % i).set(1000)
            self.get_pru_pin('stepgen.%02i.stepspace' % i).set(1000)
            self.get_pru_pin('stepgen.%02i.dirpin' % i).set(self.pru_dir_pin(i))
            self.get_pru_pin('stepgen.%02i.steppin' % i).set(self.pru_step_pin(i))
# setting to zero: pru_generic adapts to maximum velocity and acceleration
# see http://www.machinekit.io/docs/man/man9/hal_pru_generic/           
            self.get_pru_pin('stepgen.%02i.maxvel' % i).set(0)
            self.get_pru_pin('stepgen.%02i.maxaccel' % i).set(0)
            
# use new pru stepgen minvel pin to avoid pru hunting problem (without PID loop)
# see this discussion https://groups.google.com/forum/#!topic/machinekit/ATEwvfgoIb4
# except for extruder(s)
            if i < 3 :
                self.get_pru_pin('stepgen.%02i.minvel' % i).set(minvel)

        self.pwm = hal.loadusr(USR_HAL_PATH + 'hal_replicape_pwm',
            name='replicape_pwm',
            wait_name='replicape_pwm')

        self.watchdog_sigs = []
        for pin in self.get_watchdog_pins():
            s = hal.newsig('replicape.watchdog.%d' % len(self.watchdog_sigs), hal.HAL_BIT)
            pin.link(s)
            self.watchdog_sigs.append(s)
Пример #34
0
 def _init_config(self, config):
     configs = [
         (self.filament_dia_sig, ['FILAMENT_DIAMETER',
                                  'FILAMENT_DIA'], '3'),
         (self.extrude_scale_sig, ['EXTRUDE_SCALE'], '1'),
         (self.accel_gain_sig, ['ACCELERATION_GAIN'], '0.05'),
         (self.max_jog_vel_sig, ['MAX_JOG_VELOCITY', 'MAX_VELOCITY'], '40'),
         (self.retract_len_sig, ['RETRACT_LENGTH', 'RETRACT_LEN'], '3'),
         (self.retract_vel_sig, ['RETRACT_VELOCITY', 'RETRACT_VEL'], '60')
     ]
     for i in configs:
         (signal, config_names, config_default) = i
         v = None
         for config_name in config_names:
             v = config.find('EXTRUDER_%d' % self.nr, config_name)
             if v is not None:
                 break
         if v is None:
             v = config_default
         if v is None:
             raise ValueError('Config [EXTRUDER_%d] %s must be defined' %
                              (self.nr, config_names[0]))
         float_v = float(v)
         signal.set(float_v)
Пример #35
0
def setup_stepper(stepgenIndex,
                  section,
                  axisIndex=None,
                  stepgenType='hpg.stepgen',
                  gantry=False,
                  gantryJoint=0,
                  velocitySignal=None,
                  thread=None):
    stepgen = '%s.%02i' % (stepgenType, stepgenIndex)
    if axisIndex is not None:
        axis = 'axis.%i' % axisIndex
    hasMotionAxis = (axisIndex is not None) and (not gantry
                                                 or gantryJoint == 0)
    velocityControlled = velocitySignal is not None

    # axis enable chain
    enableIndex = axisIndex
    if axisIndex is None:
        enableIndex = 0  # use motor enable signal
    enable = hal.Signal('emcmot-%i-enable' % enableIndex, hal.HAL_BIT)
    if hasMotionAxis:
        enable.link('%s.amp-enable-out' % axis)
    enable.link('%s.enable' % stepgen)

    # expose timing parameters so we can multiplex them later
    sigBase = 'stepgen-%i' % stepgenIndex
    dirsetup = hal.newsig('%s-dirsetup' % sigBase, hal.HAL_U32)
    dirhold = hal.newsig('%s-dirhold' % sigBase, hal.HAL_U32)
    steplen = hal.newsig('%s-steplen' % sigBase, hal.HAL_U32)
    stepspace = hal.newsig('%s-stepspace' % sigBase, hal.HAL_U32)
    scale = hal.newsig('%s-scale' % sigBase, hal.HAL_FLOAT)
    maxVel = hal.newsig('%s-max-vel' % sigBase, hal.HAL_FLOAT)
    maxAcc = hal.newsig('%s-max-acc' % sigBase, hal.HAL_FLOAT)
    controlType = hal.newsig('%s-control-type' % sigBase, hal.HAL_BIT)

    hal.Pin('%s.dirsetup' % stepgen).link(dirsetup)
    hal.Pin('%s.dirhold' % stepgen).link(dirhold)
    dirsetup.set(c.find(section, 'DIRSETUP'))
    dirhold.set(c.find(section, 'DIRHOLD'))

    hal.Pin('%s.steplen' % stepgen).link(steplen)
    hal.Pin('%s.stepspace' % stepgen).link(stepspace)
    steplen.set(c.find(section, 'STEPLEN'))
    stepspace.set(c.find(section, 'STEPSPACE'))

    hal.Pin('%s.position-scale' % stepgen).link(scale)
    scale.set(c.find(section, 'SCALE'))

    hal.Pin('%s.maxvel' % stepgen).link(maxVel)
    hal.Pin('%s.maxaccel' % stepgen).link(maxAcc)
    maxVel.set(c.find(section, 'STEPGEN_MAX_VEL'))
    maxAcc.set(c.find(section, 'STEPGEN_MAX_ACC'))

    hal.Pin('%s.control-type' % stepgen).link(controlType)

    # position command and feedback
    if not velocityControlled:
        if hasMotionAxis:  # per axis fb and cmd
            posCmd = hal.newsig('emcmot-%i-pos-cmd' % axisIndex, hal.HAL_FLOAT)
            posCmd.link('%s.motor-pos-cmd' % axis)
            if not gantry:
                posCmd.link('%s.position-cmd' % stepgen)
            else:
                posCmd.link('gantry.%i.position-cmd' % axisIndex)

            posFb = hal.newsig('emcmot-%i-pos-fb' % axisIndex, hal.HAL_FLOAT)
            posFb.link('%s.motor-pos-fb' % axis)
            if not gantry:
                posFb.link('%s.position-fb' % stepgen)
            else:
                posFb.link('gantry.%i.position-fb' % axisIndex)

        if gantry:  # per joint fb and cmd
            posCmd = hal.newsig(
                'emcmot-%i-%i-pos-cmd' % (axisIndex, gantryJoint),
                hal.HAL_FLOAT)
            posCmd.link('gantry.%i.joint.%02i.pos-cmd' %
                        (axisIndex, gantryJoint))
            posCmd.link('%s.position-cmd' % stepgen)

            posFb = hal.newsig(
                'emcmot-%i-%i-pos-fb' % (axisIndex, gantryJoint),
                hal.HAL_FLOAT)
            posFb.link('%s.position-fb' % stepgen)
            posFb.link('gantry.%i.joint.%02i.pos-fb' %
                       (axisIndex, gantryJoint))
    else:  # velocity control
        hal.net(velocitySignal, '%s.velocity-cmd' % stepgen)
        controlType.set(1)  # enable velocity control

    # limits
    if hasMotionAxis:
        limitHome = hal.newsig('limit-%i-home' % axisIndex, hal.HAL_BIT)
        limitMin = hal.newsig('limit-%i-min' % axisIndex, hal.HAL_BIT)
        limitMax = hal.newsig('limit-%i-max' % axisIndex, hal.HAL_BIT)
        limitHome.link('%s.home-sw-in' % axis)
        limitMin.link('%s.neg-lim-sw-in' % axis)
        limitMax.link('%s.pos-lim-sw-in' % axis)

    if gantry:
        if gantryJoint == 0:
            axisHoming = hal.newsig('emcmot-%i-homing' % axisIndex,
                                    hal.HAL_BIT)
            axisHoming.link('%s.homing' % axis)

            hal.Pin('gantry.%i.search-vel' % axisIndex).set(
                c.find(section, 'HOME_SEARCH_VEL'))
            hal.Pin('gantry.%i.homing' % axisIndex).link(axisHoming)
            hal.Pin('gantry.%i.home' % axisIndex).link(limitHome)

            or2 = rt.newinst('or2', 'or2.limit-%i-min' % axisIndex)
            hal.addf(or2.name, thread)
            or2.pin('out').link(limitMin)

            or2 = rt.newinst('or2', 'or2.limit-%i-max' % axisIndex)
            hal.addf(or2.name, thread)
            or2.pin('out').link(limitMax)

        limitHome = hal.newsig('limit-%i-%i-home' % (axisIndex, gantryJoint),
                               hal.HAL_BIT)
        limitMin = hal.newsig('limit-%i-%i-min' % (axisIndex, gantryJoint),
                              hal.HAL_BIT)
        limitMax = hal.newsig('limit-%i-%i-max' % (axisIndex, gantryJoint),
                              hal.HAL_BIT)
        homeOffset = hal.Signal('home-offset-%i-%i' % (axisIndex, gantryJoint),
                                hal.HAL_FLOAT)
        limitHome.link('gantry.%i.joint.%02i.home' % (axisIndex, gantryJoint))
        limitMin.link('or2.limit-%i-min.in%i' % (axisIndex, gantryJoint))
        limitMax.link('or2.limit-%i-max.in%i' % (axisIndex, gantryJoint))
        homeOffset.link('gantry.%i.joint.%02i.home-offset' %
                        (axisIndex, gantryJoint))

        storage.setup_gantry_storage(axisIndex, gantryJoint)
Пример #36
0
def create_temperature_control(name,
                               section,
                               thread,
                               hardwareOkSignal=None,
                               coolingFan=None,
                               hotendFan=None):
    tempSet = hal.newsig('%s-temp-set' % name, hal.HAL_FLOAT)
    tempMeas = hal.newsig('%s-temp-meas' % name, hal.HAL_FLOAT)
    tempInRange = hal.newsig('%s-temp-in-range' % name, hal.HAL_BIT)
    tempPwm = hal.newsig('%s-temp-pwm' % name, hal.HAL_FLOAT)
    tempPwmMax = hal.newsig('%s-temp-pwm-max' % name, hal.HAL_FLOAT)
    tempLimitMin = hal.newsig('%s-temp-limit-min' % name, hal.HAL_FLOAT)
    tempLimitMax = hal.newsig('%s-temp-limit-max' % name, hal.HAL_FLOAT)
    tempStandby = hal.newsig('%s-temp-standby' % name, hal.HAL_FLOAT)
    tempInLimit = hal.newsig('%s-temp-in-limit' % name, hal.HAL_BIT)
    tempThermOk = hal.newsig('%s-temp-therm-ok' % name, hal.HAL_BIT)
    error = hal.newsig('%s-error' % name, hal.HAL_BIT)
    active = hal.newsig('%s-active' % name, hal.HAL_BIT)

    tempPidPgain = hal.newsig('%s-temp-pid-Pgain' % name, hal.HAL_FLOAT)
    tempPidIgain = hal.newsig('%s-temp-pid-Igain' % name, hal.HAL_FLOAT)
    tempPidDgain = hal.newsig('%s-temp-pid-Dgain' % name, hal.HAL_FLOAT)
    tempPidMaxerrorI = hal.newsig('%s-temp-pid-maxerrorI' % name,
                                  hal.HAL_FLOAT)
    tempPidOut = hal.newsig('%s-temp-pid-out' % name, hal.HAL_FLOAT)
    tempPidBias = hal.newsig('%s-temp-pid-bias' % name, hal.HAL_FLOAT)
    tempRangeMin = hal.newsig('%s-temp-range-min' % name, hal.HAL_FLOAT)
    tempRangeMax = hal.newsig('%s-temp-range-max' % name, hal.HAL_FLOAT)
    noErrorIn = hal.newsig('%s-no-error-in' % name, hal.HAL_BIT)
    errorIn = hal.newsig('%s-error-in' % name, hal.HAL_BIT)

    tempPidBiasOut = tempPidBias
    # coolingFan compensation
    if coolingFan:
        tempPidFanBias = hal.newsig('%s-temp-pid-fan-bias' % name,
                                    hal.HAL_FLOAT)
        tempPidBiasOut = hal.newsig('%s-temp-pid-bias-out' % name,
                                    hal.HAL_FLOAT)

        scale = rt.newinst('scale', 'scale.%s-temp-pid-fan-bias' % name)
        hal.addf(scale.name, thread)
        scale.pin('in').link('%s.pwm' % coolingFan)
        scale.pin('out').link(tempPidFanBias)
        scale.pin('gain').set(c.find(section, 'FAN_BIAS'))

        sum2 = rt.newinst('sum2', 'sum2.%s-temp-pid-bias' % name)
        hal.addf(sum2.name, thread)
        sum2.pin('in0').link(tempPidBias)
        sum2.pin('in1').link(tempPidFanBias)
        sum2.pin('out').link(tempPidBiasOut)

    # PID
    pid = rt.newinst('pid', 'pid.%s' % name)
    hal.addf('%s.do-pid-calcs' % pid.name, thread)
    pid.pin('enable').link('emcmot-0-enable')  # motor enable
    pid.pin('feedback').link(tempMeas)
    pid.pin('command').link(tempSet)
    pid.pin('output').link(tempPidOut)
    pid.pin('maxoutput').link(tempPwmMax)
    pid.pin('bias').link(tempPidBias)
    pid.pin('Pgain').link(tempPidPgain)
    pid.pin('Igain').link(tempPidIgain)
    pid.pin('Dgain').link(tempPidDgain)
    pid.pin('maxerrorI').link(tempPidMaxerrorI)

    # Limit heater PWM to positive values
    # PWM mimics hm2 implementation, which generates output for negative values
    limit1 = rt.newinst('limit1', 'limit.%s-temp-heaterl' % name)
    hal.addf(limit1.name, thread)
    limit1.pin('in').link(tempPidOut)
    limit1.pin('out').link(tempPwm)
    limit1.pin('min').set(0.0)
    limit1.pin('max').link(tempPwmMax)

    # Temperature checking
    sum2 = rt.newinst('sum2', 'sum2.%s-temp-range-pos' % name)
    hal.addf(sum2.name, thread)
    sum2.pin('in0').link(tempSet)
    sum2.pin('in1').set(c.find(section, 'TEMP_RANGE_POS_ERROR'))
    sum2.pin('out').link(tempRangeMax)

    sum2 = rt.newinst('sum2', 'sum2.%s-temp-range-neg' % name)
    hal.addf(sum2.name, thread)
    sum2.pin('in0').link(tempSet)
    sum2.pin('in1').set(c.find(section, 'TEMP_RANGE_NEG_ERROR'))
    sum2.pin('out').link(tempRangeMin)

    #the output of this component will say if measured temperature is in range of set value
    wcomp = rt.newinst('wcomp', 'wcomp.%s-temp-in-range' % name)
    hal.addf(wcomp.name, thread)
    wcomp.pin('min').link(tempRangeMin)
    wcomp.pin('max').link(tempRangeMax)
    wcomp.pin('in').link(tempMeas)
    wcomp.pin('out').link(tempInRange)

    # limit the output temperature to prevent damage when thermistor is broken/removed
    wcomp = rt.newinst('wcomp', 'wcomp.%s-temp-in-limit' % name)
    hal.addf(wcomp.name, thread)
    wcomp.pin('min').link(tempLimitMin)
    wcomp.pin('max').link(tempLimitMax)
    wcomp.pin('in').link(tempMeas)
    wcomp.pin('out').link(tempInLimit)

    # check the thermistor
    # net e0.temp.meas              => thermistor-check.e0.temp
    # net e0.temp.in-range          => not.e0-temp-range.in
    # net e0.temp.in-range_n        <= not.e0-temp-range.out
    # net e0.temp.in-range_n        => thermistor-check.e0.enable
    # net e0.heaterl                => thermistor-check.e0.pid
    # net e0.therm-ok               <= thermistor-check.e0.no-error

    # no error chain
    and3 = rt.newinst('andn', 'and3.%s-no-error-in' % name, pincount=3)
    hal.addf(and3.name, thread)
    and3.pin('in0').link(tempThermOk)
    and3.pin('in1').link(tempInLimit)
    if hardwareOkSignal:
        and3.pin('in2').link(hardwareOkSignal)
    else:
        and3.pin('in2').set(True)
    and3.pin('out').link(noErrorIn)

    tempThermOk.set(True)  # thermistor checking for now disabled

    notComp = rt.newinst('not', 'not.%s-error-in' % name)
    hal.addf(notComp.name, thread)
    notComp.pin('in').link(noErrorIn)
    notComp.pin('out').link(errorIn)

    safetyLatch = rt.newinst('safety_latch', 'safety-latch.%s-error' % name)
    hal.addf(safetyLatch.name, thread)
    safetyLatch.pin('error-in').link(errorIn)
    safetyLatch.pin('error-out').link(error)
    safetyLatch.pin('reset').link('estop-reset')
    safetyLatch.pin('threshold').set(500)  # 500ms error
    safetyLatch.pin('latching').set(True)

    # active chain
    comp = rt.newinst('comp', 'comp.%s-active' % name)
    hal.addf(comp.name, thread)
    comp.pin('in0').set(0.0001)
    comp.pin('hyst').set(0.0)
    comp.pin('in1').link(tempPwm)
    comp.pin('out').link(active)

    # Thermistor checking
    # setp thermistor-check.e0.wait 9.0
    # setp thermistor-check.e0.min-pid 1.5 # disable0.25
    # setp thermistor-check.e0.min-temp 1.5
    # net e0.pid.bias => thermistor-check.e0.bias

    # Hotend fan
    if hotendFan:
        comp = rt.newinst('comp', 'comp.%s-pwm-enable' % hotendFan)
        hal.addf(comp.name, thread)
        comp.pin('in0').set(c.find(section, 'HOTEND_FAN_THRESHOLD', 50.0))
        comp.pin('in1').link(tempMeas)
        comp.pin('hyst').set(c.find(section, 'HOTEND_FAN_HYST', 2.0))
        comp.pin('out').link('%s-pwm-enable' % hotendFan)

        hal.Signal('%s-pwm' % hotendFan).set(1.0)

    rcomps.create_temperature_rcomp(name)
    motion.setup_temperature_io(name)

    # init parameter signals
    tempLimitMin.set(c.find(section, 'TEMP_LIMIT_MIN'))
    tempLimitMax.set(c.find(section, 'TEMP_LIMIT_MAX'))
    tempStandby.set(c.find(section, 'TEMP_STANDBY'))
    tempPwmMax.set(c.find(section, 'PWM_MAX'))
    tempPidPgain.set(c.find(section, 'PID_PGAIN'))
    tempPidIgain.set(c.find(section, 'PID_IGAIN'))
    tempPidDgain.set(c.find(section, 'PID_DGAIN'))
    tempPidMaxerrorI.set(c.find(section, 'PID_MAXERRORI'))
    tempPidBias.set(c.find(section, 'PID_BIAS'))
Пример #37
0
# HAL file for BeagleBone + TCT paralell port cape with 5 steppers and 3D printer board
import os

from machinekit import rtapi as rt
from machinekit import hal
from machinekit import config as c

from config import base
from config import motion

# initialize the RTAPI command client
rt.init_RTAPI()
# loads the ini file passed by linuxcnc
c.load_ini(os.environ["INI_FILE_NAME"])

motion.setup_motion(kinematics=c.find("KINS", "KINEMATICS"))

# reading functions
hal.addf("motion-command-handler", "servo-thread")

# define gantry joints
base.init_gantry(axisIndex=1, joints=2, latching=True)

# Axis-of-motion Specific Configs (not the GUI)
# X [J0] Axis
base.setup_stepper(section="AXIS_0", axisIndex=0, stepgenIndex=0, stepgenType="sim")
# Y [J1] Axis
base.setup_stepper(section="AXIS_1", axisIndex=1, stepgenIndex=1, gantry=True, gantryJoint=0, stepgenType="sim")
# YY[J2] Axis
base.setup_stepper(section="AXIS_1", axisIndex=1, stepgenIndex=2, gantry=True, gantryJoint=1, stepgenType="sim")
# Z [J3] Axis
Пример #38
0
def velocity_extrusion(extruders, thread):
    ''' Velocity extrusion support '''
    # from motion/ui
    crossSection = hal.newsig('ve-cross-section', hal.HAL_FLOAT)
    crossSectionIn = hal.newsig('ve-cross-section-in', hal.HAL_FLOAT)
    lineWidth = hal.newsig('ve-line-width', hal.HAL_FLOAT)
    lineHeight = hal.newsig('ve-line-height', hal.HAL_FLOAT)
    filamentDia = hal.newsig('ve-filament-dia', hal.HAL_FLOAT)
    extrudeScale = hal.newsig('ve-extrude-scale', hal.HAL_FLOAT)
    extrudeAccelAdjGain = hal.newsig('ve-extrude-accel-adj-gain', hal.HAL_FLOAT)
    retractVel = hal.newsig('ve-retract-vel', hal.HAL_FLOAT)
    retractLen = hal.newsig('ve-retract-len', hal.HAL_FLOAT)
    maxVelocity = hal.newsig('ve-max-velocity', hal.HAL_FLOAT)
    # helper signals
    nozzleVel = hal.newsig('ve-nozzle-vel', hal.HAL_FLOAT)
    nozzleDischarge = hal.newsig('ve-nozzle-discharge', hal.HAL_FLOAT)
    filamentDiaSquared = hal.newsig('ve-filament-dia-squared', hal.HAL_FLOAT)
    filamentArea = hal.newsig('ve-filament-area', hal.HAL_FLOAT)
    extrudeRate = hal.newsig('ve-extrude-rate', hal.HAL_FLOAT)
    extrudeRateScaled = hal.newsig('ve-extrude-rate-scaled', hal.HAL_FLOAT)
    extrudeAccel = hal.newsig('ve-extrude-accel', hal.HAL_FLOAT)
    extrudeAccelAdj = hal.newsig('ve-extrude-accel-adj', hal.HAL_FLOAT)
    extrudeRateAdj = hal.newsig('ve-extrude-rate-adj', hal.HAL_FLOAT)
    extruderEn = hal.newsig('ve-extruder-en', hal.HAL_BIT)
    retractVelNeg = hal.newsig('ve-retract-vel-neg', hal.HAL_FLOAT)
    retractTime = hal.newsig('ve-retract-time', hal.HAL_FLOAT)
    retract = hal.newsig('ve-retract', hal.HAL_BIT)
    extrudeVel = hal.newsig('ve-extrude-vel', hal.HAL_FLOAT)
    baseVel = hal.newsig('ve-base-vel', hal.HAL_FLOAT)

    nozzleVel.link('motion.current-vel')

    mult2 = rt.newinst('mult2', 'mult2.ve-cross-section')
    hal.addf(mult2.name, thread)
    mult2.pin('in0').link(lineWidth)
    mult2.pin('in1').link(lineHeight)
    mult2.pin('out').link(crossSectionIn)

    outToIo = rt.newinst('out_to_io', 'out-to-io.ve-cross-section')
    hal.addf(outToIo.name, thread)
    outToIo.pin('in-float').link(crossSectionIn)
    outToIo.pin('out-float').link(crossSection)

    # multiply area with speed and we get discharge (mm^3 per second)
    mult2 = rt.newinst('mult2', 'mult2.ve-nozzle-discharge')
    hal.addf(mult2.name, thread)
    mult2.pin('in0').link(crossSection)
    mult2.pin('in1').link(nozzleVel)
    mult2.pin('out').link(nozzleDischarge)

    # calculate filament cross section area
    # PI divided by 4
    mult2 = rt.newinst('mult2', 'mult2.ve-filament-dia')
    hal.addf(mult2.name, thread)
    mult2.pin('in0').link(filamentDia)
    mult2.pin('in1').link(filamentDia)
    mult2.pin('out').link(filamentDiaSquared)

    mult2 = rt.newinst('mult2', 'mult2.ve-filament-area')
    hal.addf(mult2.name, thread)
    mult2.pin('in0').set(math.pi / 4)
    mult2.pin('in1').link(filamentDiaSquared)
    mult2.pin('out').link(filamentArea)

    # calculate extrude rate
    div2 = rt.newinst('div2', 'div2.ve-extrude-rate')
    hal.addf(div2.name, thread)
    div2.pin('in0').link(nozzleDischarge)
    div2.pin('in1').link(filamentArea)
    div2.pin('out').link(extrudeRate)

    # scale extrude rate
    mult2 = rt.newinst('mult2', 'mult2.ve-extrude-rate-scaled')
    hal.addf(mult2.name, thread)
    mult2.pin('in0').link(extrudeRate)
    mult2.pin('in1').link(extrudeScale)
    mult2.pin('out').link(extrudeRateScaled)

    # these are used for a small offset in velocity during acceleration (buildup pressure inside
    # the nozzle because of the current speed. Take the maximum accel you've specified in .ini
    # get acceleration into lincurve
    ddt = rt.newinst('ddt', 'ddt.ve-extruder-accel')
    hal.addf(ddt.name, thread)
    ddt.pin('in').link(extrudeRateScaled)
    ddt.pin('out').link(extrudeAccel)

    mult2 = rt.newinst('mult2', 'mult2.ve-extrude-accel-adj')
    hal.addf(mult2.name, thread)
    mult2.pin('in0').link(extrudeAccel)
    mult2.pin('in1').link(extrudeAccelAdjGain)
    mult2.pin('out').link(extrudeAccelAdj)

    # get adjusted speed for adding to current speed during acceleration
    sum2 = rt.newinst('sum2', 'sum2.ve-extrude-rate-adj')
    hal.addf(sum2.name, thread)
    sum2.pin('in0').link(extrudeRateScaled)
    sum2.pin('in1').link(extrudeAccelAdj)
    sum2.pin('out').link(extrudeRateAdj)

    # negative retract velocity
    neg = rt.newinst('neg', 'neg.ve-rectract-vel-neg')
    hal.addf(neg.name, thread)
    neg.pin('in').link(retractVel)
    neg.pin('out').link(retractVelNeg)

    # calculate retract time
    div2 = rt.newinst('div2', 'div2.ve-retract-time')
    hal.addf(div2.name, thread)
    div2.pin('in0').link(retractLen)
    div2.pin('in1').link(retractVel)
    div2.pin('out').link(retractTime)

    # We want the retract-charge to run for a fixed time:
    # when sel0 set to "1" meaning motion with extrusion" the on the rising edge
    # there will temporarily be also sel1 which is high, meaning a pre-charge because the
    # sel combination is 11
    # when sel1 set to "0" meaning decoupling motion with extrusion" then the falling edge
    # will trigger a 01 combination, meaning a retract

    # trigger a retract/unretract move when extruder is enable or disabled
    oneshot = rt.newinst('oneshot', 'oneshot.ve-retract')
    hal.addf(oneshot.name, thread)
    oneshot.pin('rising').set(True)
    oneshot.pin('falling').set(True)
    oneshot.pin('retriggerable').set(True)
    oneshot.pin('width').link(retractTime)
    oneshot.pin('in').link(extruderEn)
    oneshot.pin('out').link(retract)

    retract += 'motion.feed-hold'  # stop motion until retract/unretract finished

    # jogging needs to be inserted here
    velocity_jog(extruders, thread)

    # now the solution of Andy Pugh for automatically retracting/priming
    #00 = motion without extrusion, jog
    #01 = retract
    #10 = motion with extrusion
    #11 = unretract, pre-charge
    mux4 = rt.newinst('mux4', 'mux4.ve-extrude-vel')
    hal.addf(mux4.name, thread)
    mux4.pin('in0').link(baseVel)
    mux4.pin('in1').link(retractVelNeg)
    mux4.pin('in2').link(extrudeRateAdj)
    mux4.pin('in3').link(retractVel)
    mux4.pin('out').link(extrudeVel)
    mux4.pin('sel0').link(retract)
    mux4.pin('sel1').link(extruderEn)

    sections = [[retractLen, 'RETRACT_LEN'],
                [retractVel, 'RETRACT_VEL'],
                [filamentDia, 'FILAMENT_DIA'],
                [maxVelocity, 'MAX_VELOCITY'],
                [extrudeScale, 'EXTRUDE_SCALE']]

    for section in sections:
        ioMux = rt.newinst('io_muxn',
                           'io-mux%i.%s' % (extruders, section[0].name),
                           pincount=extruders)
        hal.addf(ioMux.name, thread)
        ioMux.pin('out').link(section[0])
        ioMux.pin('sel').link('extruder-sel')
        for n in range(0, extruders):
            signal = hal.newsig('%s-e%i' % (section[0].name, n), hal.HAL_FLOAT)
            ioMux.pin('in%i' % n).link(signal)
            signal.set(c.find('EXTRUDER_%i' % n, section[1]))

    extrudeAccelAdjGain.set(0.05)
    if baseVel.writers < 1:  # can only write when jogging not configured
        baseVel.set(0.0)

    rcomps.create_ve_params_rcomp()
    storage.setup_ve_storage(extruders=extruders)
    motion.setup_ve_io()
Пример #39
0
def setup_hardware(thread):
    # PWM
    #hal.Pin('hm2_5i25.0.pwmgen.00.pwm_frequency').set(20000)  # 100Hz
    #    os.system('halcmd setp hm2_5i25.0.pwmgen.00.pwm_frequency 20000')
    # HBP
    #    hal.Pin('hm2_5i25.0.pwmgen.00.enable').set(True)
    #    hal.Pin('hm2_5i25.0.pwmgen.00.value').link('hbp-temp-pwm')
    # Spindle
    spindlespeed = hal.newsig('spindle-speed', hal.HAL_FLOAT)
    spindleon = hal.newsig('spindle-on', hal.HAL_BIT)
    spindlespeeddiv = hal.newsig('spindle-speed-20', hal.HAL_FLOAT)
    spindlepwmspeed = hal.newsig('spindle-pwm-speed', hal.HAL_FLOAT)
    spindlepwmspeedlimited = hal.newsig('spindle-pwm-speed-limited',
                                        hal.HAL_FLOAT)

    #    spindlespeed.link('motion.spindle-speed-out-rps')
    spindlespeed.link('motion.spindle-speed-out')
    spindleon.link('motion.spindle-on')
    os.system('halcmd setp hm2_5i25.0.gpio.070.is_output true')
    #    halold.Param('hm2_5i25.0.gpio.070.is_output').set(true)
    #    os.system('halcmd setp hm2_5i25.0.gpio.071.invert_output true')
    hal.Pin('hm2_5i25.0.gpio.070.out').link(spindleon)

    ##    hal.Pin('hm2_5i25.0.pwmgen.02.enable').set(True)
    hal.Pin('hm2_5i25.0.pwmgen.00.enable').link(spindleon)

    div2 = rt.newinst('div2', 'div2.spindlespeed-divfac')
    hal.addf(div2.name, 'servo-thread')
    div2.pin('in0').link(spindlespeed)
    div2.pin('in1').set(c.find('SPINDLE', 'DIVFACTOR'))
    div2.pin('out').link(spindlespeeddiv)

    sum2 = rt.newinst('sum2', 'sum2.spindle-speed-add')
    hal.addf(sum2.name, 'servo-thread')
    sum2.pin('in0').set(c.find('SPINDLE', 'ADDFACTOR'))
    sum2.pin('in1').link(spindlespeeddiv)
    sum2.pin('out').link(spindlepwmspeed)

    #    limit1 = rt.newinst('limit1', 'limit1.spindle-pwm-speed-limited')
    #    hal.addf(limit1.name, thread)
    #    limit1.pin('in').link(spindlepwmspeed)
    #    limit1.pin('out').link(spindlepwmspeedlimited)
    #    limit1.pin('min').set(0.05)  # prevent users from setting 0 as jog velocity
    #    limit1.pin('max').set(c.find('SPINDLE', 'LIMIT'))

    #    hal.Pin('hm2_5i25.0.pwmgen.00.value').link(spindlepwmspeedlimited)
    hal.Pin('hm2_5i25.0.pwmgen.00.value').link(spindlepwmspeed)
    os.system('halcmd setp hm2_5i25.0.gpio.018.invert_output true')
    #    hal.Pin('hm2_5i25.0.gpio.018.invert_output').set(true)
    #    hal.Param('hm2_5i25.0.pwmgen.00.scale').set(c.find('SPINDLE', 'MAXRPM'))
    #    os.system('halcmd setp hm2_5i25.0.pwmgen.00.scale 12000')
    #    cmd = "halcmd setp hm2_5i25.0.pwmgen.00.scale %s "%(c.find('SPINDLE', 'MAXRPM'))
    #    os.system(cmd)
    os.system("halcmd setp hm2_5i25.0.pwmgen.00.scale %s " %
              (c.find('SPINDLE', 'MAXRPM')))

    # configure extruders
    #    for n in range(0, 1):
    #        hal.Pin('hm2_5i25.0.pwmgen.%02i.enable' % (n + 1)).set(True)
    #        hal.Pin('hm2_5i25.0.pwmgen.%02i.value' % (n + 1)).link('e%i-temp-pwm' % n)
    # configure fans
    #    for n in range(0, 2):
    #        hal.Pin('hm2_5i25.0.pwmgen.%02i.enable' % (n + 3)).link('f%i-pwm-enable' % n)
    #        hal.Pin('hm2_5i25.0.pwmgen.%02i.value' % (n + 3)).link('f%i-pwm' % n)
    #        hal.Signal('f%i-pwm-enable' % n).set(True)
    # configure exps
    #    for n in range(0, 1):
    #        hal.Pin('hm2_5i25.0.pwmgen.%02i.enable' % (n + 5)).link('exp%i-pwm-enable' % n)
    #        hal.Pin('hm2_5i25.0.pwmgen.%02i.value' % (n + 5)).link('exp%i-pwm' % n)
    #        hal.Signal('exp%i-pwm' % n).set(1.0)
    # configure leds
    # none

    # GPIO
    # Adjust as needed for your switch polarity
    hal.Pin('hm2_5i25.0.gpio.024.in_not').link('limit-0-home')  # X
    hal.Pin('hm2_5i25.0.gpio.025.in').link('limit-1-0-home')  # YL
    hal.Pin('hm2_5i25.0.gpio.026.in').link('limit-1-1-home')  # YR
    hal.Pin('hm2_5i25.0.gpio.027.in_not').link('limit-2-home')  # Z
    #    hal.Pin('hm2_5i25.0.gpio.036.in_not').link('limit-0-max')    # X
    #    hal.Pin('hm2_5i25.0.gpio.026.in_not').link('limit-1-home')   # Y
    #    hal.Pin('hm2_5i25.0.gpio.030.in_not').link('limit-0-home')   # X
    #    hal.Pin('hm2_5i25.0.gpio.071.in_not').link('limit-0-home')   # X
    #    hal.Pin('hm2_5i25.0.gpio.024.in').link('limit-2-0-home')  # ZLF
    #    hal.Pin('hm2_5i25.0.gpio.025.in').link('limit-2-1-home')  # ZRF
    #    hal.Pin('hm2_5i25.0.gpio.026.in').link('limit-2-2-home')  # ZLB
    #    hal.Pin('hm2_5i25.0.gpio.027.in').link('limit-2-3-home')  # ZRB
    #    hal.Pin('hm2_5i25.0.gpio.024.in_not').link('limit-2-0-home')  # ZLF
    #    hal.Pin('hm2_5i25.0.gpio.025.in_not').link('limit-2-1-home')  # ZRF
    #    hal.Pin('hm2_5i25.0.gpio.026.in_not').link('limit-2-2-home')  # ZLB
    #    hal.Pin('hm2_5i25.0.gpio.027.in_not').link('limit-2-3-home')  # ZRB

    #    hal.Pin('hm2_5i25.0.gpio.025.in').link('limit-0-max')    # X
    #    hal.Pin('hm2_5i25.0.gpio.026.in').link('limit-1-home')   # Y
    #    hal.Pin('hm2_5i25.0.gpio.028.in').link('limit-2-0-home')  # ZR
    #    hal.Pin('hm2_5i25.0.gpio.029.in').link('limit-2-1-home')  # ZL

    # probe ... 74CBTD3861

    hal.Pin('hm2_5i25.0.capsense.00.trigged').link('probe-signal')  #
    os.system('halcmd setp hm2_5i25.0.capsense.00.hysteresis 0x44444444')
    #    hm2_5i25.0.pin('capsense.00.hysteresis').set(c.find('PROBE', 'HYSTERESIS'))
    #    hm2_5i25.0.pin('capsense.00.hysteresis').set(0x44444444))
    #    hm2_5i25.0.pin('hysteresis').set(c.find('PROBE', 'HYSTERESIS'))
    #    hm2_5i25.0.pin('hysteresis').set(17476)
    #    hal.pin('hm2_5i25.0.capsense.00.hysteresis').set(1000))

    # ADC
    #    hal.Pin('hm2_5i25.0.nano_soc_adc.ch.0.out').link('temp.ch-00.input')
    #    hal.Pin('hm2_5i25.0.nano_soc_adc.ch.1.out').link('temp.ch-01.input')
    #    hal.Pin('hm2_5i25.0.nano_soc_adc.ch.2.out').link('temp.ch-02.input')
    #    hal.Pin('hm2_5i25.0.nano_soc_adc.ch.3.out').link('temp.ch-03.input')

    #    hal.Pin('temp.ch-00.value').link('hbp-temp-meas')
    #    hal.Pin('temp.ch-01.value').link('e0-temp-meas')
    #    hal.Pin('temp.ch-02.value').link('e1-temp-meas')
    #    hal.Pin('temp.ch-03.value').link('e2-temp-meas')

    # machine power
    os.system('halcmd setp hm2_5i25.0.gpio.033.is_output true')
    hal.Pin('hm2_5i25.0.gpio.033.out').link('emcmot-0-enable')

    # Monitor estop input from hardware
    hal.Pin('hm2_5i25.0.gpio.034.in_not').link('estop-in')
    # drive estop-sw
    os.system('halcmd setp hm2_5i25.0.gpio.035.is_output true')
    os.system('halcmd setp hm2_5i25.0.gpio.035.invert_output true')
    hal.Pin('hm2_5i25.0.gpio.035.out').link('estop-out')

    # Tie machine power signal to the Parport Cape LED
    # Feel free to tie any other signal you like to the LED
    os.system('halcmd setp hm2_5i25.0.gpio.031.is_output true')
    hal.Pin('hm2_5i25.0.gpio.031.out').link('emcmot-0-enable')

    # link emcmot.xx.enable to stepper driver enable signals
    os.system('halcmd setp hm2_5i25.0.gpio.032.is_output true')
    os.system('halcmd setp hm2_5i25.0.gpio.032.invert_output true')
    hal.Pin('hm2_5i25.0.gpio.032.out').link('emcmot-0-enable')
Пример #40
0
    def __init__(self, temp_hal, pwm_pin, on_pin, 
                 enable_sig, estop_reset_sig, 
                 config_name, comp_name, hal_name, motion_pin_number):
        self.temp_hal = temp_hal

        comp = hal.RemoteComponent(comp_name, timer=100)
        comp_limit_min_pin = comp.newpin('temp.limit.min', hal.HAL_FLOAT, hal.HAL_IN)
        comp_limit_max_pin = comp.newpin('temp.limit.max', hal.HAL_FLOAT, hal.HAL_IN)
        comp_standby_pin = comp.newpin('temp.standby', hal.HAL_FLOAT, hal.HAL_IN)
        comp_meas_pin = comp.newpin('temp.meas', hal.HAL_FLOAT, hal.HAL_IN)
        comp_set_pin = comp.newpin('temp.set', hal.HAL_FLOAT, hal.HAL_IO)
        comp_in_range_pin = comp.newpin('temp.in-range', hal.HAL_BIT, hal.HAL_IN)
        comp_active_pin = comp.newpin('active', hal.HAL_BIT, hal.HAL_IN)
        comp_error_pin = comp.newpin('error', hal.HAL_BIT, hal.HAL_IN)
        comp.ready()

        # -- General Signals --
        meas_sig = hal.newsig('%s.meas' % hal_name, hal.HAL_FLOAT)
        meas_sig.link(temp_hal.pin('value'))
        meas_sig.link(comp_meas_pin)
        meas_sig.link('motion.analog-in-%02d' % motion_pin_number)

        set_sig = hal.newsig('%s.set' % hal_name, hal.HAL_FLOAT)
        set_sig.link(comp_set_pin)
        set_sig.link('motion.analog-out-io-%02d' % motion_pin_number)

        limit_min_sig = hal.newsig('%s.limit.min' % hal_name, hal.HAL_FLOAT)
        limit_min_sig.link(comp_limit_min_pin)
        limit_min_sig.set(config.find(config_name, 'TEMP_LIMIT_MIN', 0.0))
        
        limit_max_sig = hal.newsig('%s.limit.max' % hal_name, hal.HAL_FLOAT)
        limit_max_sig.link(comp_limit_max_pin)
        limit_max_sig.set(config.find(config_name, 'TEMP_LIMIT_MAX', 30.0))

        standby_sig = hal.newsig('%s.standby' % hal_name, hal.HAL_FLOAT)
        standby_sig.link(comp_standby_pin)
        standby_sig.set(config.find(config_name, 'TEMP_STANDBY', 15.0))

        on_sig = hal.newsig('%s.on' % hal_name, hal.HAL_BIT)
        on_sig.link(on_pin)
        on_sig.link(comp_active_pin)

        error_sig = hal.newsig('%s.error' % hal_name, hal.HAL_BIT)
        self.error_sig = error_sig
        error_sig.link(comp_error_pin)

        self.temp_watchdog_sig = hal.newsig('%s.watchdog' % hal_name, hal.HAL_BIT)
        temp_hal.pin('watchdog').link(self.temp_watchdog_sig)

        # -- Measurement --

        # In-Range Signal
        in_range_sig = hal.newsig('%s.in-range' % hal_name, hal.HAL_BIT)
        in_range_sig.link(comp_in_range_pin)
        in_range_sig.link('motion.digital-in-%02d' % motion_pin_number)

        range_lb_sum = rtapi.newinst('sum2', '%s.range.lb.sum2' % hal_name)
        hal.addf(range_lb_sum.name, SERVO_THREAD)
        range_ub_sum = rtapi.newinst('sum2', '%s.range.ub.sum2' % hal_name)
        hal.addf(range_ub_sum.name, SERVO_THREAD)
        range_lb_sig = hal.newsig('%s.range.lb' % hal_name, hal.HAL_FLOAT)
        range_ub_sig = hal.newsig('%s.range.ub' % hal_name, hal.HAL_FLOAT)

        range_lb_sum.pin('in0').link(set_sig)
        range_lb_sum.pin('in1').set(float(config.find(config_name, 'TEMP_RANGE_NEG_ERROR', -1.0)))
        range_lb_sum.pin('out').link(range_lb_sig)
        range_ub_sum.pin('in0').link(set_sig)
        range_ub_sum.pin('in1').set(float(config.find(config_name, 'TEMP_RANGE_POS_ERROR', 1.0)))
        range_ub_sum.pin('out').link(range_ub_sig)

        range_wcomp = rtapi.newinst('wcomp', '%s.range.wcomp' % hal_name)
        hal.addf(range_wcomp.name, SERVO_THREAD)
        range_wcomp.pin('min').link(range_lb_sig)
        range_wcomp.pin('max').link(range_ub_sig)
        range_wcomp.pin('in').link(meas_sig)
        range_wcomp.pin('out').link(in_range_sig)

        # -- Output --
        pwm_raw_sig = hal.newsig('%s.pwm_raw' % hal_name, hal.HAL_FLOAT)
        pwm_sig = hal.newsig('%s.pwm' % hal_name, hal.HAL_FLOAT)
        pwm_max = float(config.find(config_name, 'PWM_MAX', 1.0))

        # PID
        pid = rtapi.newinst('at_pid', '%s.pid' % hal_name)
        hal.addf(pid.name + '.do-pid-calcs', SERVO_THREAD)
        pid.pin('enable').link(enable_sig)
        pid.pin('feedback').link(meas_sig)
        pid.pin('command').link(set_sig)
        pid.pin('output').link(pwm_raw_sig)
        pid.pin('maxoutput').set(pwm_max)
        pid.pin('Pgain').set(float(config.find(config_name, 'PID_PGAIN', 0)))
        pid.pin('Igain').set(float(config.find(config_name, 'PID_IGAIN', 0)))
        pid.pin('Dgain').set(float(config.find(config_name, 'PID_DGAIN', 0)))
        pid.pin('maxerrorI').set(float(config.find(config_name, 'PID_MAXERRORI', 1.0)))
        pid.pin('bias').set(float(config.find(config_name, 'PID_BIAS', 0.0)))

        # PWM Limit (PID can output negative values)
        pwm_limit = rtapi.newinst('limit1', '%s.limit1.pwm' % hal_name)
        hal.addf(pwm_limit.name, SERVO_THREAD)
        pwm_limit.pin('min').set(0.0)
        pwm_limit.pin('max').set(pwm_max)
        pwm_limit.pin('in').link(pwm_raw_sig)
        pwm_limit.pin('out').link(pwm_sig)

        pwm_pin.link(pwm_sig)

        # -- Safety Check --
        check_limit_ok_sig = hal.newsig('%s.check.limit-ok' % hal_name, hal.HAL_BIT)

        limit_wcomp = rtapi.newinst('wcomp', '%s.check.limit.wcomp' % hal_name)
        hal.addf(limit_wcomp.name, SERVO_THREAD)
        limit_wcomp.pin('min').link(limit_min_sig)
        limit_wcomp.pin('max').link(limit_max_sig)
        limit_wcomp.pin('in').link(meas_sig)
        limit_wcomp.pin('out').link(check_limit_ok_sig)

        out_range_sig = hal.newsig('%s.out-range' % hal_name, hal.HAL_BIT)
        out_range_not = rtapi.newinst('not', '%s.out-range.not' % hal_name)
        hal.addf(out_range_not.name, SERVO_THREAD)
        out_range_not.pin('in').link(in_range_sig)
        out_range_not.pin('out').link(out_range_sig)

        thermistor_check_enable_sig = hal.newsig('%s.check.therm.enable' % hal_name, hal.HAL_BIT)
        thermistor_check_enable_and = rtapi.newinst('and2', '%s.check.therm.enable.and2' % hal_name)
        hal.addf(thermistor_check_enable_and.name, SERVO_THREAD)
        thermistor_check_enable_and.pin('in0').link(enable_sig)
        thermistor_check_enable_and.pin('in1').link(out_range_sig)
        thermistor_check_enable_and.pin('out').link(thermistor_check_enable_sig)

        check_thermistor_ok_sig = hal.newsig('%s.check.therm-ok' % hal_name, hal.HAL_BIT)
        thermistor_check = rtapi.newinst('thermistor_check', '%s.check.therm-check' % hal_name)
        hal.addf(thermistor_check.name, SERVO_THREAD)
        thermistor_check.pin('enable').link(thermistor_check_enable_sig)
        thermistor_check.pin('pid').link(pwm_sig)
        thermistor_check.pin('temp').link(meas_sig)
        thermistor_check.pin('min-pid').set(float(config.find(config_name, 'CHECK_MIN_PID', 0.25)))
        thermistor_check.pin('min-temp').set(float(config.find(config_name, 'CHECK_MIN_TEMP', 2.0)))
        thermistor_check.pin('wait').set(float(config.find(config_name, 'CHECK_WAIT', 30.0)))
        thermistor_check.pin('no-error').link(check_thermistor_ok_sig)

        check_all_ok_sig = hal.newsig('%s.check.all-ok' % hal_name, hal.HAL_BIT)
        check_all_ok = rtapi.newinst('and2', '%s.check.all.and2' % hal_name)
        hal.addf(check_all_ok.name, SERVO_THREAD)
        check_all_ok.pin('in0').link(check_limit_ok_sig)
        check_all_ok.pin('in1').link(check_thermistor_ok_sig)
        check_all_ok.pin('out').link(check_all_ok_sig)

        check_error_sig = hal.newsig('%s.check.error' % hal_name, hal.HAL_BIT)
        check_error = rtapi.newinst('not', '%s.check.error.not' % hal_name)
        hal.addf(check_error.name, SERVO_THREAD)
        check_error.pin('in').link(check_all_ok_sig)
        check_error.pin('out').link(check_error_sig)

        error_latch = rtapi.newinst('flipflop', '%s.check.error.flipflop' % hal_name)
        hal.addf(error_latch.name, SERVO_THREAD)
        error_latch.pin('set').link(check_error_sig)
        error_latch.pin('reset').link(estop_reset_sig)
        error_latch.pin('out').link(error_sig)
Пример #41
0
                name='storage',
                file='storage.ini',
                autosave=True,
                wait_name='storage')


def readStorage():
    hal.Pin('storage.read-trigger').set(True)  # trigger read


rt.init_RTAPI()
c.load_ini('hardware.ini')

rt.loadrt('hal_bb_gpio', output_pins='915,917,838,840')
rt.loadrt('hal_arm335xQEP', encoders='eQEP0,eQEP2')
rt.loadrt(c.find('PRUCONF', 'DRIVER'),
          'prucode=' + c.find('PRUCONF', 'PRUBIN'),
          pru=0,
          num_pwmgens=7,
          halname='hpg')

# storage
setupStorage()

# pru pwmgens
hal.Pin('hpg.pwmgen.00.pwm_period').set(500000)
# motor left
hal.Pin('hpg.pwmgen.00.out.00.pin').set(911)
hal.Pin('hpg.pwmgen.00.out.01.pin').set(913)
# motor right
hal.Pin('hpg.pwmgen.00.out.02.pin').set(808)
Пример #42
0
# HAL file for BeagleBone + TCT paralell port cape with 5 steppers and 3D printer board
import os

from machinekit import rtapi as rt
from machinekit import hal
from machinekit import config as c

from config import base
from config import motion

# initialize the RTAPI command client
rt.init_RTAPI()
# loads the ini file passed by linuxcnc
c.load_ini(os.environ['INI_FILE_NAME'])

motion.setup_motion(kinematics=c.find('KINS','KINEMATICS'))

# reading functions
hal.addf('motion-command-handler', 'servo-thread')

# Axis-of-motion Specific Configs (not the GUI)
# X [0] Axis
base.setup_stepper(section='AXIS_0', axisIndex=0, stepgenIndex=0, stepgenType='sim')
# Y [1] Axis
base.setup_stepper(section='AXIS_1', axisIndex=1, stepgenIndex=1, stepgenType='sim')
# Z [2] Axis
base.setup_stepper(section='AXIS_2', axisIndex=2, stepgenIndex=2, stepgenType='sim')
# Z [2] Axis
base.setup_stepper(section='AXIS_3', axisIndex=3, stepgenIndex=3, stepgenType='sim')
# Z [2] Axis
base.setup_stepper(section='AXIS_4', axisIndex=4, stepgenIndex=4, stepgenType='sim')
Пример #43
0
# initialize the RTAPI command client
rt.init_RTAPI()
# loads the ini file passed by linuxcnc
c.load_ini(os.environ['INI_FILE_NAME'])

motion.setup_motion()
hardware.init_hardware()
storage.init_storage('storage.ini')

# reading functions
hardware.hardware_read()
hal.addf('motion-command-handler', 'servo-thread')
hal.addf('motion-controller', 'servo-thread')

numFans = c.find('FDM', 'NUM_FANS')
numExtruders = c.find('FDM', 'NUM_EXTRUDERS')
numLights = c.find('FDM', 'NUM_LIGHTS')
hasHbp = c.find('FDM', 'HAS_HBP')

# Axis-of-motion Specific Configs (not the GUI)
ve.velocity_extrusion(extruders=numExtruders, thread='servo-thread')
# X [0] Axis
base.setup_stepper(section='AXIS_0', axisIndex=0, stepgenIndex=0, thread='servo-thread')
# Y [1] Axis
base.setup_stepper(section='AXIS_1', axisIndex=1, stepgenIndex=1, thread='servo-thread')
# Z [2] Axis
base.setup_stepper(section='AXIS_2', axisIndex=2, stepgenIndex=2, thread='servo-thread')
# Extruder, velocity controlled
for i in range(0, numExtruders):
    base.setup_stepper(section='EXTRUDER_%i' % i, stepgenIndex=3,
Пример #44
0
def init_hardware():
    config.load_ini(os.environ['INI_FILE_NAME'])
    check_version()
# we need to make the gpio pins used by the pru visible to userspace (??) in /sys/class/gpio
    os.system('sudo ' + HARDWARE_PATH + 'set_pru_gpio.sh')
    rtapi.init_RTAPI()
    error_sigs = []
    watchdog_sigs = []

    global AXIS_TOTAL
    AXIS_TOTAL = int(config.find('TRAJ', 'AXES', '3'))
    if AXIS_TOTAL < 3:
        raise RuntimeError("AXES must be >= 3")

    global EXTRUDER_TOTAL
    EXTRUDER_TOTAL = int(config.find('FDM', 'EXTRUDERS', '1'))
    if EXTRUDER_TOTAL < 1:
        raise RuntimeError("EXTRUDERS must be >= 1")
        
    global NUM_FANS
    NUM_FANS = int(config.find('FDM','NUM_FANS', 4))
    system_fan = int(config.find('FDM','SYSTEM_FAN', 0))
    if (NUM_FANS < system_fan):
    	raise RuntimeError("NUM_FANS must be >= 1 if SYSTEM_FAN > 0")
    if (NUM_FANS > 4) or (NUM_FANS < 0 ):
        raise RuntimeError("NUM_FANS must be > 0 and < 5")

    rtapi.loadrt('tp')
    if config.find('MACHINE','DELTA_R') is not None:
        kinematics = 'lineardeltakins'
        rtapi.loadrt(kinematics)
        hal.Pin('lineardeltakins.L').set(config.find('MACHINE', 'CF_ROD'))
        hal.Pin('lineardeltakins.R').set(config.find('MACHINE', 'DELTA_R'))
    else:
        kinematics = 'trivkins'
        rtapi.loadrt(kinematics)
    
    rtapi.loadrt(config.find('EMCMOT', 'EMCMOT'), 
        servo_period_nsec=config.find('EMCMOT', 'SERVO_PERIOD'),
        num_joints=str(AXIS_TOTAL),
        num_aio=51,
        num_dio=21,
        kins = kinematics)

    hal.addf('motion-command-handler', SERVO_THREAD)
    hal.addf('motion-controller', SERVO_THREAD)

    estop_reset = hal.newsig('estop-reset', hal.HAL_BIT)
    (main_enable, main_enable_inv) = setup_enable_chain()

    if BOARD_REV == 'B3A':
        replicape = hardware.ReplicapeB3A()
    if BOARD_REV == 'A4A':
        replicape = hardware.ReplicapeA4A()
    watchdog_sigs.extend(replicape.get_watchdog_sigs())
    replicape.link_enable(main_enable, main_enable_inv)

    (joint_commands, joint_feedbacks) = setup_joints()
    for i in xrange(AXIS_TOTAL):
        setup_axis(replicape, joint_commands[i], joint_feedbacks[i], i)
    setup_limit_switches(replicape)

    extruder_sel_sig = hal.newsig('extruder-sel', hal.HAL_S32)
    setup_extruders(replicape, extruder_sel_sig)

    for i in xrange(EXTRUDER_TOTAL):
        t = ExtruderTemperature(replicape, i, main_enable, estop_reset)
        error_sigs.append(t.get_error_sig())
        watchdog_sigs.append(t.get_temp_watchdog_sig())

    if config.find('HBP', 'THERMISTOR'):
        t = HbpTemperature(replicape, main_enable, estop_reset)
        error_sigs.append(t.get_error_sig())
        watchdog_sigs.append(t.get_temp_watchdog_sig())

#    setup_system_fan(replicape)
    setup_fans(replicape)
    setup_estop(error_sigs, watchdog_sigs, estop_reset, SERVO_THREAD)
    connect_tool_changer()
ENC_A = io_map[20]
EN1 = io_map[21]
EN2 = io_map[22]
IN1 = io_map[23]
IN2 = io_map[24]

output_pins = [EN1, EN2]
input_pins = [IS1, IS2]

output_pins_joined = ','.join(str(x) for x in output_pins)
input_pins_joined = ','.join(str(x) for x in input_pins)

rt.loadrt('hal_bb_gpio',
          output_pins=output_pins_joined,
          input_pins=input_pins_joined)
rt.loadrt(c.find('PRUCONF', 'DRIVER'),
          'prucode={}/{}'.format(c.Config().EMC2_RTLIB_DIR,
                                 c.find('PRUCONF', 'PRUBIN')),
          pru=0,
          num_stepgens=0,
          num_pwmgens=2,
          num_encoders=1,
          halname='hpg')

hpg = hal.Component('hpg')
hpg.pin('pwmgen.00.out.00.pin').set(IN1)
hpg.pin('pwmgen.00.out.01.pin').set(IN2)

hpg.pin('encoder.00.chan.00.A-pin').set(pru0_input_pins[ENC_A])
hpg.pin('encoder.00.chan.00.B-pin').set(pru0_input_pins[ENC_B])
hpg.pin('encoder.00.chan.00.index-pin').set(17)  # ignore
Пример #46
0
def create_temperature_control(name, section, thread, hardwareOkSignal=None,
                               coolingFan=None, hotendFan=None):
    tempSet = hal.newsig('%s-temp-set' % name, hal.HAL_FLOAT)
    tempMeas = hal.newsig('%s-temp-meas' % name, hal.HAL_FLOAT)
    tempInRange = hal.newsig('%s-temp-in-range' % name, hal.HAL_BIT)
    tempPwm = hal.newsig('%s-temp-pwm' % name, hal.HAL_FLOAT)
    tempPwmMax = hal.newsig('%s-temp-pwm-max' % name, hal.HAL_FLOAT)
    tempLimitMin = hal.newsig('%s-temp-limit-min' % name, hal.HAL_FLOAT)
    tempLimitMax = hal.newsig('%s-temp-limit-max' % name, hal.HAL_FLOAT)
    tempStandby = hal.newsig('%s-temp-standby' % name, hal.HAL_FLOAT)
    tempInLimit = hal.newsig('%s-temp-in-limit' % name, hal.HAL_BIT)
    tempThermOk = hal.newsig('%s-temp-therm-ok' % name, hal.HAL_BIT)
    error = hal.newsig('%s-error' % name, hal.HAL_BIT)
    active = hal.newsig('%s-active' % name, hal.HAL_BIT)

    tempPidPgain = hal.newsig('%s-temp-pid-Pgain' % name, hal.HAL_FLOAT)
    tempPidIgain = hal.newsig('%s-temp-pid-Igain' % name, hal.HAL_FLOAT)
    tempPidDgain = hal.newsig('%s-temp-pid-Dgain' % name, hal.HAL_FLOAT)
    tempPidMaxerrorI = hal.newsig('%s-temp-pid-maxerrorI' % name, hal.HAL_FLOAT)
    tempPidOut = hal.newsig('%s-temp-pid-out' % name, hal.HAL_FLOAT)
    tempPidBias = hal.newsig('%s-temp-pid-bias' % name, hal.HAL_FLOAT)
    tempRangeMin = hal.newsig('%s-temp-range-min' % name, hal.HAL_FLOAT)
    tempRangeMax = hal.newsig('%s-temp-range-max' % name, hal.HAL_FLOAT)
    noErrorIn = hal.newsig('%s-no-error-in' % name, hal.HAL_BIT)
    errorIn = hal.newsig('%s-error-in' % name, hal.HAL_BIT)

    # reset set temperature when estop is cleared
    reset = rt.newinst('reset', 'reset.%s-temp-set' % name)
    hal.addf(reset.name, thread)
    reset.pin('reset-float').set(0.0)
    reset.pin('out-float').link(tempSet)
    reset.pin('rising').set(True)
    reset.pin('falling').set(False)
    reset.pin('trigger').link('estop-reset')

    tempPidBiasOut = tempPidBias
    # coolingFan compensation
    if coolingFan:
        tempPidFanBias = hal.newsig('%s-temp-pid-fan-bias' % name, hal.HAL_FLOAT)
        tempPidBiasOut = hal.newsig('%s-temp-pid-bias-out' % name, hal.HAL_FLOAT)

        scale = rt.newinst('scale', 'scale.%s-temp-pid-fan-bias' % name)
        hal.addf(scale.name, thread)
        scale.pin('in').link('%s.pwm' % coolingFan)
        scale.pin('out').link(tempPidFanBias)
        scale.pin('gain').set(c.find(section, 'FAN_BIAS'))

        sum2 = rt.newinst('sum2', 'sum2.%s-temp-pid-bias' % name)
        hal.addf(sum2.name, thread)
        sum2.pin('in0').link(tempPidBias)
        sum2.pin('in1').link(tempPidFanBias)
        sum2.pin('out').link(tempPidBiasOut)

    # PID
    pid = rt.newinst('pid', 'pid.%s' % name)
    hal.addf('%s.do-pid-calcs' % pid.name, thread)
    pid.pin('enable').link('emcmot-0-enable')  # motor enable
    pid.pin('feedback').link(tempMeas)
    pid.pin('command').link(tempSet)
    pid.pin('output').link(tempPidOut)
    pid.pin('maxoutput').link(tempPwmMax)
    pid.pin('bias').link(tempPidBias)
    pid.pin('Pgain').link(tempPidPgain)
    pid.pin('Igain').link(tempPidIgain)
    pid.pin('Dgain').link(tempPidDgain)
    pid.pin('maxerrorI').link(tempPidMaxerrorI)

    # Limit heater PWM to positive values
    # PWM mimics hm2 implementation, which generates output for negative values
    limit1 = rt.newinst('limit1', 'limit.%s-temp-heaterl' % name)
    hal.addf(limit1.name, thread)
    limit1.pin('in').link(tempPidOut)
    limit1.pin('out').link(tempPwm)
    limit1.pin('min').set(0.0)
    limit1.pin('max').link(tempPwmMax)

    # Temperature checking
    sum2 = rt.newinst('sum2', 'sum2.%s-temp-range-pos' % name)
    hal.addf(sum2.name, thread)
    sum2.pin('in0').link(tempSet)
    sum2.pin('in1').set(c.find(section, 'TEMP_RANGE_POS_ERROR'))
    sum2.pin('out').link(tempRangeMax)

    sum2 = rt.newinst('sum2', 'sum2.%s-temp-range-neg' % name)
    hal.addf(sum2.name, thread)
    sum2.pin('in0').link(tempSet)
    sum2.pin('in1').set(c.find(section, 'TEMP_RANGE_NEG_ERROR'))
    sum2.pin('out').link(tempRangeMin)

    #the output of this component will say if measured temperature is in range of set value
    wcomp = rt.newinst('wcomp', 'wcomp.%s-temp-in-range' % name)
    hal.addf(wcomp.name, thread)
    wcomp.pin('min').link(tempRangeMin)
    wcomp.pin('max').link(tempRangeMax)
    wcomp.pin('in').link(tempMeas)
    wcomp.pin('out').link(tempInRange)

    # limit the output temperature to prevent damage when thermistor is broken/removed
    wcomp = rt.newinst('wcomp', 'wcomp.%s-temp-in-limit' % name)
    hal.addf(wcomp.name, thread)
    wcomp.pin('min').link(tempLimitMin)
    wcomp.pin('max').link(tempLimitMax)
    wcomp.pin('in').link(tempMeas)
    wcomp.pin('out').link(tempInLimit)

    # check the thermistor
    # net e0.temp.meas              => thermistor-check.e0.temp
    # net e0.temp.in-range          => not.e0-temp-range.in
    # net e0.temp.in-range_n        <= not.e0-temp-range.out
    # net e0.temp.in-range_n        => thermistor-check.e0.enable
    # net e0.heaterl                => thermistor-check.e0.pid
    # net e0.therm-ok               <= thermistor-check.e0.no-error

    # no error chain
    and3 = rt.newinst('andn', 'and3.%s-no-error-in' % name, pincount=3)
    hal.addf(and3.name, thread)
    and3.pin('in0').link(tempThermOk)
    and3.pin('in1').link(tempInLimit)
    if hardwareOkSignal:
        and3.pin('in2').link(hardwareOkSignal)
    else:
        and3.pin('in2').set(True)
    and3.pin('out').link(noErrorIn)

    tempThermOk.set(True)  # thermistor checking for now disabled

    notComp = rt.newinst('not', 'not.%s-error-in' % name)
    hal.addf(notComp.name, thread)
    notComp.pin('in').link(noErrorIn)
    notComp.pin('out').link(errorIn)

    safetyLatch = rt.newinst('safety_latch', 'safety-latch.%s-error' % name)
    hal.addf(safetyLatch.name, thread)
    safetyLatch.pin('error-in').link(errorIn)
    safetyLatch.pin('error-out').link(error)
    safetyLatch.pin('reset').link('estop-reset')
    safetyLatch.pin('threshold').set(500)  # 500ms error
    safetyLatch.pin('latching').set(True)

    # active chain
    comp = rt.newinst('comp', 'comp.%s-active' % name)
    hal.addf(comp.name, thread)
    comp.pin('in0').set(0.0001)
    comp.pin('hyst').set(0.0)
    comp.pin('in1').link(tempPwm)
    comp.pin('out').link(active)

    # Thermistor checking
    # setp thermistor-check.e0.wait 9.0
    # setp thermistor-check.e0.min-pid 1.5 # disable0.25
    # setp thermistor-check.e0.min-temp 1.5
    # net e0.pid.bias => thermistor-check.e0.bias

    # Hotend fan
    if hotendFan:
        comp = rt.newinst('comp', 'comp.%s-pwm-enable' % hotendFan)
        hal.addf(comp.name, thread)
        comp.pin('in0').set(c.find(section, 'HOTEND_FAN_THRESHOLD', 50.0))
        comp.pin('in1').link(tempMeas)
        comp.pin('hyst').set(c.find(section, 'HOTEND_FAN_HYST', 2.0))
        comp.pin('out').link('%s-pwm-enable' % hotendFan)

        hal.Signal('%s-pwm' % hotendFan).set(1.0)

    rcomps.create_temperature_rcomp(name)
    motion.setup_temperature_io(name)

    # init parameter signals
    tempLimitMin.set(c.find(section, 'TEMP_LIMIT_MIN'))
    tempLimitMax.set(c.find(section, 'TEMP_LIMIT_MAX'))
    tempStandby.set(c.find(section, 'TEMP_STANDBY'))
    tempPwmMax.set(c.find(section, 'PWM_MAX'))
    tempPidPgain.set(c.find(section, 'PID_PGAIN'))
    tempPidIgain.set(c.find(section, 'PID_IGAIN'))
    tempPidDgain.set(c.find(section, 'PID_DGAIN'))
    tempPidMaxerrorI.set(c.find(section, 'PID_MAXERRORI'))
    tempPidBias.set(c.find(section, 'PID_BIAS'))
Пример #47
0
logging.debug("starting motion")
motion.setup_motion()
logging.debug("motion should be started")
hardware.init_hardware()
logging.debug("done init")
storage.init_storage('storage.ini')

# reading functions
hw = True
if hw:
    hardware.hardware_read()
hal.addf('motion-command-handler', 'servo-thread')
hal.addf('motion-controller', 'servo-thread')

numFans = c.find('FDM', 'NUM_FANS')
numExtruders = c.find('FDM', 'NUM_EXTRUDERS')
numLights = c.find('FDM', 'NUM_LIGHTS')
logging.debug("fans %i extruders %i lights %i" %
              (numFans, numExtruders, numLights))
#raw_input()
# Axis-of-motion Specific Configs (not the GUI)
ve.velocity_extrusion(extruders=numExtruders, thread='servo-thread')
# X [0] Axis
base.setup_stepper(section='AXIS_0',
                   stepgenType='hps',
                   axisIndex=0,
                   velocitySignal=None,
                   stepgenIndex=0,
                   thread='servo-thread')
# Y [1] Axis
Пример #48
0
def setup_joints():
    """
    Create joints commands and feedbacks signal for the system
    """
    commands = [None] * AXIS_TOTAL
    feedbacks = [None] * AXIS_TOTAL
    for i in xrange(AXIS_TOTAL):
        commands[i] = hal.newsig('machine.joint.%d.command' % i, hal.HAL_FLOAT)
        feedbacks[i] = hal.newsig('machine.joint.%d.feedback' % i, hal.HAL_FLOAT)

    core_xy = config.find('FDM','CORE_XY')
    if core_xy is not None and int(core_xy) > 0:
        sum_cmd_a = rtapi.newinst('sum2', 'corexy.sum2.cmd.a')
        sum_fb_x = rtapi.newinst('sum2', 'corexy.sum2.fb.x')
        sum_cmd_b = rtapi.newinst('sum2', 'corexy.sum2.cmd.b')
        sum_fb_y = rtapi.newinst('sum2', 'corexy.sum2.fb.y')
        hal.addf(sum_cmd_a.name, SERVO_THREAD)
        hal.addf(sum_cmd_b.name, SERVO_THREAD)
        hal.addf(sum_fb_x.name, SERVO_THREAD)
        hal.addf(sum_fb_y.name, SERVO_THREAD)

        sum_cmd_a.pin('gain0').set(1)
        sum_cmd_a.pin('gain1').set(1)
        sum_cmd_b.pin('gain0').set(1)
        sum_cmd_b.pin('gain1').set(-1)

        sum_fb_x.pin('gain0').set(0.5)
        sum_fb_x.pin('gain1').set(0.5)
        sum_fb_y.pin('gain0').set(0.5)
        sum_fb_y.pin('gain1').set(-0.5)

        corex_cmd = hal.newsig('machine.joint.corex.command', hal.HAL_FLOAT)
        corey_cmd = hal.newsig('machine.joint.corey.command', hal.HAL_FLOAT)

        corex_cmd.link('axis.0.motor-pos-cmd')
        corey_cmd.link('axis.1.motor-pos-cmd')

        sum_cmd_a.pin('in0').link(corex_cmd)
        sum_cmd_a.pin('in1').link(corey_cmd)
        sum_cmd_b.pin('in0').link(corex_cmd)
        sum_cmd_b.pin('in1').link(corey_cmd)
        sum_cmd_a.pin('out').link(commands[0])
        sum_cmd_b.pin('out').link(commands[1])

        sum_fb_x.pin('in0').link(feedbacks[0])
        sum_fb_x.pin('in1').link(feedbacks[1])
        sum_fb_y.pin('in0').link(feedbacks[0])
        sum_fb_y.pin('in1').link(feedbacks[1])
        sum_fb_x.pin('out').link('axis.0.motor-pos-fb')
        sum_fb_y.pin('out').link('axis.1.motor-pos-fb')
    else:
        commands[0].link('axis.0.motor-pos-cmd')
        feedbacks[0].link('axis.0.motor-pos-fb')
        commands[1].link('axis.1.motor-pos-cmd')
        feedbacks[1].link('axis.1.motor-pos-fb')

    for i in xrange(AXIS_TOTAL):
        if i >= 2:
            commands[i].link('axis.%d.motor-pos-cmd' % i)
            feedbacks[i].link('axis.%d.motor-pos-fb' % i)

    return (commands, feedbacks)
Пример #49
0
def init_hardware():
    check_version()

    rtapi.init_RTAPI()
    config.load_ini(os.environ['INI_FILE_NAME'])

    error_sigs = []
    watchdog_sigs = []

    global AXIS_TOTAL
    AXIS_TOTAL = int(config.find('TRAJ', 'AXES', '3'))
    if AXIS_TOTAL < 3:
        raise RuntimeError("AXES must be >= 3")

    global EXTRUDER_TOTAL
    EXTRUDER_TOTAL = int(config.find('FDM', 'EXTRUDERS', '1'))
    if EXTRUDER_TOTAL < 1:
        raise RuntimeError("EXTRUDERS must be >= 1")

    rtapi.loadrt('tp')
    rtapi.loadrt('trivkins')
    rtapi.loadrt(config.find('EMCMOT', 'EMCMOT'), 
        servo_period_nsec=config.find('EMCMOT', 'SERVO_PERIOD'),
        num_joints=str(AXIS_TOTAL),
        num_aio=51,
        num_dio=21)

    hal.addf('motion-command-handler', SERVO_THREAD)
    hal.addf('motion-controller', SERVO_THREAD)

    estop_reset = hal.newsig('estop-reset', hal.HAL_BIT)
    (main_enable, main_enable_inv) = setup_enable_chain()

    if BOARD_REV == 'B3A':
        replicape = hardware.ReplicapeB3A()
    if BOARD_REV == 'A4A':
        replicape = hardware.ReplicapeA4A()
    watchdog_sigs.extend(replicape.get_watchdog_sigs())
    replicape.link_enable(main_enable, main_enable_inv)

    (joint_commands, joint_feedbacks) = setup_joints()
    for i in xrange(AXIS_TOTAL):
        setup_axis(replicape, joint_commands[i], joint_feedbacks[i], i)
    setup_limit_switches(replicape)

    extruder_sel_sig = hal.newsig('extruder-sel', hal.HAL_S32)
    setup_extruders(replicape, extruder_sel_sig)

    for i in xrange(EXTRUDER_TOTAL):
        t = ExtruderTemperature(replicape, i, main_enable, estop_reset)
        error_sigs.append(t.get_error_sig())
        watchdog_sigs.append(t.get_temp_watchdog_sig())

    if config.find('HBP', 'THERMISTOR'):
        t = HbpTemperature(replicape, main_enable, estop_reset)
        error_sigs.append(t.get_error_sig())
        watchdog_sigs.append(t.get_temp_watchdog_sig())

    setup_system_fan(replicape)

    setup_estop(error_sigs, watchdog_sigs, estop_reset, SERVO_THREAD)
    connect_tool_changer()
Пример #50
0
# initialize the RTAPI command client
rt.init_RTAPI()
# loads the ini file passed by linuxcnc
c.load_ini(os.environ['INI_FILE_NAME'])

motion.setup_motion()
hardware.init_hardware()
storage.init_storage('storage.ini')

# reading functions
hardware.hardware_read()
hal.addf('motion-command-handler', 'servo-thread')
hal.addf('motion-controller', 'servo-thread')

numFans = c.find('FDM', 'NUM_FANS')
numExtruders = c.find('FDM', 'NUM_EXTRUDERS')
numLights = c.find('FDM', 'NUM_LIGHTS')

# Axis-of-motion Specific Configs (not the GUI)
ve.velocity_extrusion(extruders=numExtruders, thread='servo-thread')
# X [0] Axis
base.setup_stepper(section='AXIS_0', axisIndex=0, stepgenIndex=0, thread='servo-thread')
# Y [1] Axis
base.setup_stepper(section='AXIS_1', axisIndex=1, stepgenIndex=1, thread='servo-thread')
# Z [2] Axis
base.setup_stepper(section='AXIS_2', axisIndex=2, stepgenIndex=2, thread='servo-thread')
# Extruder, velocity controlled
for i in range(0, numExtruders):
    base.setup_stepper(section='EXTRUDER_%i' % i, stepgenIndex=3,
                       velocitySignal='ve-extrude-vel', thread='servo-thread')
Пример #51
0
def init_hardware():
    watchList = []

    # load low-level drivers
    rt.loadrt('hal_bb_gpio', output_pins='807,819,826,926', input_pins='941')
    prubin = '%s/%s' % (c.Config().EMC2_RTLIB_DIR, c.find('PRUCONF', 'PRUBIN'))
    rt.loadrt(c.find('PRUCONF', 'DRIVER'),
              pru=0,
              num_stepgens=5,
              num_pwmgens=0,
              prucode=prubin,
              halname='hpg')

    # Python user-mode HAL module to interface with an I2C gpio extender
    hal.loadusr('hal_gpio_mcp23017',
                name='i2c-gpio',
                bus_id=2,
                address=32,
                interval=0.05,
                delay=2.5,
                input_pins='A00,A01,A02,A03,A04,A05,A06,A07,B06,B07',
                output_pins='B00,B01,B02,B03,B04,B05',
                wait_name='i2c-gpio')
    watchList.append(['i2c-gpio', 0.1])

    # Python user-mode HAL module to interface with an I2C PWM generator
    hal.loadusr('hal_pwm_pca9685',
                name='i2c-pwm',
                bus_id=2,
                address=67,
                interval=0.1,
                delay=2.6,
                wait_name='i2c-pwm')
    watchList.append(['i2c-pwm', 0.2])

    # Python user-mode HAL module to interface with an I2C ADC and convert it to temperature
    defaultThermistor = 'semitec_103GT_2'
    hal.loadusr(
        'hal_temp_ads7828',
        name='i2c-temp',
        bus_id=2,
        address=72,
        interval=0.05,
        delay=2.7,
        filter_size=1,
        channels='00:%s,01:%s,02:%s,03:%s,04:%s,05:none,06:none,07:none' %
        (c.find('HBP', 'THERMISTOR', defaultThermistor),
         c.find('EXTRUDER_0', 'THERMISTOR', defaultThermistor),
         c.find('EXTRUDER_1', 'THERMISTOR', defaultThermistor),
         c.find('EXTRUDER_2', 'THERMISTOR', defaultThermistor),
         c.find('EXTRUDER_3', 'THERMISTOR', defaultThermistor)),
        wait_name='i2c-temp')
    watchList.append(['i2c-temp', 0.1])

    base.usrcomp_status('i2c-gpio', 'gpio-hw', thread='servo-thread')
    base.usrcomp_status('i2c-pwm', 'pwm-hw', thread='servo-thread')
    base.usrcomp_status('i2c-temp', 'temp-hw', thread='servo-thread')
    base.usrcomp_watchdog(watchList,
                          'estop-reset',
                          thread='servo-thread',
                          errorSignal='watchdog-error')
Пример #52
0
rt.init_RTAPI()
c.load_ini(os.environ['INI_FILE_NAME'])

motion.setup_motion()
storage.init_storage('storage.ini')

# Gantry component for Z Axis
base.init_gantry(axisIndex=2)

base.gantry_read(gantryAxis=2, thread='servo-thread')
hal.addf('motion-command-handler', 'servo-thread')

# setup axis feedback
limits = [
    [c.find('AXIS_0', 'MAX_LIMIT') - 0.2, c.find('AXIS_0', 'MAX_LIMIT')],
    [c.find('AXIS_1', 'MAX_LIMIT') - 0.2, c.find('AXIS_1', 'MAX_LIMIT')],
    [c.find('AXIS_2', 'MIN_LIMIT'), 0.0]
]

for n in range(c.find('TRAJ', 'AXES')):
    axisPos = hal.newsig('axis-%i-pos' % n, hal.HAL_FLOAT)
    hal.Pin('axis.%i.motor-pos-cmd' % n).link(axisPos)
    hal.Pin('axis.%i.motor-pos-fb' % n).link(axisPos)

    # fake limits
    limitHome = hal.newsig('limit-%i-home' % n, hal.HAL_BIT)
    hal.Pin('axis.%i.home-sw-in' % n).link(limitHome)
    wcomp = rt.newinst('wcomp', 'wcomp.axis-%i-home' % n)
    hal.addf(wcomp.name, 'servo-thread')
    wcomp.pin('in').link(axisPos)
Пример #53
0
def setupStorage():
    hal.loadusr('hal_storage', name='storage', file='storage.ini',
                autosave=True, wait_name='storage')


def readStorage():
    hal.Pin('storage.read-trigger').set(True)  # trigger read


rt.init_RTAPI()
c.load_ini('hardware.ini')

rt.loadrt('hal_bb_gpio', output_pins='915,917,838,840')
rt.loadrt('hal_arm335xQEP', encoders='eQEP0,eQEP2')
rt.loadrt(c.find('PRUCONF', 'DRIVER'), 'prucode=' + c.find('PRUCONF', 'PRUBIN'), pru=0, num_pwmgens=7, halname='hpg')

# storage
setupStorage()

# pru pwmgens
hal.Pin('hpg.pwmgen.00.pwm_period').set(500000)
# motor left
hal.Pin('hpg.pwmgen.00.out.00.pin').set(911)
hal.Pin('hpg.pwmgen.00.out.01.pin').set(913)
# motor right
hal.Pin('hpg.pwmgen.00.out.02.pin').set(808)
hal.Pin('hpg.pwmgen.00.out.03.pin').set(810)

baseThread = 'base_thread'
rt.newthread(baseThread, 1000000, fp=True)
Пример #54
0
# initialize the RTAPI command client
rt.init_RTAPI()
# loads the ini file passed by linuxcnc
c.load_ini(os.environ['INI_FILE_NAME'])

motion.setup_motion('lineardeltakins')
hardware.init_hardware()
storage.init_storage('storage.ini')

# reading functions
hardware.hardware_read()
hal.addf('motion-command-handler', 'servo-thread')
hal.addf('motion-controller', 'servo-thread')

numFans = c.find('FDM', 'NUM_FANS')
numExtruders = c.find('FDM', 'NUM_EXTRUDERS')
numLights = c.find('FDM', 'NUM_LIGHTS')
hasHbp = c.find('FDM', 'HAS_HBP')

# Axis-of-motion Specific Configs (not the GUI)
ve.velocity_extrusion(extruders=numExtruders, thread='servo-thread')
# X [0] Axis
base.setup_stepper(section='AXIS_0',
                   axisIndex=0,
                   stepgenIndex=0,
                   thread='servo-thread')
# Y [1] Axis
base.setup_stepper(section='AXIS_1',
                   axisIndex=1,
                   stepgenIndex=1,
Пример #55
0
# loads the ini file passed by linuxcnc
c.load_ini(os.environ['INI_FILE_NAME'])

motion.setup_motion()
hardware.init_hardware()
storage.init_storage('storage.ini')

# Gantry component for Z Axis
base.init_gantry(axisIndex=2)

# reading functions
hardware.hardware_read()
base.gantry_read(gantryAxis=2, thread='servo-thread')
hal.addf('motion-command-handler', 'servo-thread')

numFans = c.find('FDM', 'NUM_FANS')
numExtruders = c.find('FDM', 'NUM_EXTRUDERS')
numLights = c.find('FDM', 'NUM_LIGHTS')
withAbp = c.find('FDM', 'ABP', False)

# Axis-of-motion Specific Configs (not the GUI)
ve.velocity_extrusion(extruders=numExtruders, thread='servo-thread')
# X [0] Axis
base.setup_stepper(section='AXIS_0', axisIndex=0, stepgenIndex=0)
# Y [1] Axis
base.setup_stepper(section='AXIS_1', axisIndex=1, stepgenIndex=1)
# Z [2] Axis
base.setup_stepper(section='AXIS_2', axisIndex=2, stepgenIndex=2,
              thread='servo-thread', gantry=True, gantryJoint=0)
base.setup_stepper(section='AXIS_2', axisIndex=2, stepgenIndex=3,
            gantry=True, gantryJoint=1)
Пример #56
0
def setup_stepper(stepgenIndex, section, axisIndex=None,
                  stepgenType='hpg.stepgen', gantry=False,
                  gantryJoint=0, velocitySignal=None, thread=None):
    stepgen = '%s.%02i' % (stepgenType, stepgenIndex)
    if axisIndex is not None:
        axis = 'axis.%i' % axisIndex
    hasMotionAxis = (axisIndex is not None) and (not gantry or gantryJoint == 0)
    velocityControlled = velocitySignal is not None

    # axis enable chain
    enableIndex = axisIndex
    if axisIndex is None:
        enableIndex = 0  # use motor enable signal
    enable = hal.Signal('emcmot-%i-enable' % enableIndex, hal.HAL_BIT)
    if hasMotionAxis:
        enable.link('%s.amp-enable-out' % axis)
    enable.link('%s.enable' % stepgen)

    # expose timing parameters so we can multiplex them later
    sigBase = 'stepgen-%i' % stepgenIndex
    dirsetup = hal.newsig('%s-dirsetup' % sigBase, hal.HAL_U32)
    dirhold = hal.newsig('%s-dirhold' % sigBase, hal.HAL_U32)
    steplen = hal.newsig('%s-steplen' % sigBase, hal.HAL_U32)
    stepspace = hal.newsig('%s-stepspace' % sigBase, hal.HAL_U32)
    scale = hal.newsig('%s-scale' % sigBase, hal.HAL_FLOAT)
    maxVel = hal.newsig('%s-max-vel' % sigBase, hal.HAL_FLOAT)
    maxAcc = hal.newsig('%s-max-acc' % sigBase, hal.HAL_FLOAT)
    controlType = hal.newsig('%s-control-type' % sigBase, hal.HAL_BIT)

    hal.Pin('%s.dirsetup' % stepgen).link(dirsetup)
    hal.Pin('%s.dirhold' % stepgen).link(dirhold)
    dirsetup.set(c.find(section, 'DIRSETUP'))
    dirhold.set(c.find(section, 'DIRHOLD'))

    hal.Pin('%s.steplen' % stepgen).link(steplen)
    hal.Pin('%s.stepspace' % stepgen).link(stepspace)
    steplen.set(c.find(section, 'STEPLEN'))
    stepspace.set(c.find(section, 'STEPSPACE'))

    hal.Pin('%s.position-scale' % stepgen).link(scale)
    scale.set(c.find(section, 'SCALE'))

    hal.Pin('%s.maxvel' % stepgen).link(maxVel)
    hal.Pin('%s.maxaccel' % stepgen).link(maxAcc)
    maxVel.set(c.find(section, 'STEPGEN_MAX_VEL'))
    maxAcc.set(c.find(section, 'STEPGEN_MAX_ACC'))

    hal.Pin('%s.control-type' % stepgen).link(controlType)

    # position command and feedback
    if not velocityControlled:
        if hasMotionAxis:  # per axis fb and cmd
            posCmd = hal.newsig('emcmot-%i-pos-cmd' % axisIndex, hal.HAL_FLOAT)
            posCmd.link('%s.motor-pos-cmd' % axis)
            if not gantry:
                posCmd.link('%s.position-cmd' % stepgen)
            else:
                posCmd.link('gantry.%i.position-cmd' % axisIndex)

            posFb = hal.newsig('emcmot-%i-pos-fb' % axisIndex, hal.HAL_FLOAT)
            posFb.link('%s.motor-pos-fb' % axis)
            if not gantry:
                posFb.link('%s.position-fb' % stepgen)
            else:
                posFb.link('gantry.%i.position-fb' % axisIndex)

        if gantry:  # per joint fb and cmd
            posCmd = hal.newsig('emcmot-%i-%i-pos-cmd' % (axisIndex, gantryJoint), hal.HAL_FLOAT)
            posCmd.link('gantry.%i.joint.%02i.pos-cmd' % (axisIndex, gantryJoint))
            posCmd.link('%s.position-cmd' % stepgen)

            posFb = hal.newsig('emcmot-%i-%i-pos-fb' % (axisIndex, gantryJoint), hal.HAL_FLOAT)
            posFb.link('%s.position-fb' % stepgen)
            posFb.link('gantry.%i.joint.%02i.pos-fb' % (axisIndex, gantryJoint))
    else:  # velocity control
        hal.net(velocitySignal, '%s.velocity-cmd' % stepgen)
        controlType.set(1)  # enable velocity control

    # limits
    if hasMotionAxis:
        limitHome = hal.newsig('limit-%i-home' % axisIndex, hal.HAL_BIT)
        limitMin = hal.newsig('limit-%i-min' % axisIndex, hal.HAL_BIT)
        limitMax = hal.newsig('limit-%i-max' % axisIndex, hal.HAL_BIT)
        limitHome.link('%s.home-sw-in' % axis)
        limitMin.link('%s.neg-lim-sw-in' % axis)
        limitMax.link('%s.pos-lim-sw-in' % axis)

    if gantry:
        if gantryJoint == 0:
            axisHoming = hal.newsig('emcmot-%i-homing' % axisIndex, hal.HAL_BIT)
            axisHoming.link('%s.homing' % axis)

            hal.Pin('gantry.%i.search-vel' % axisIndex).set(c.find(section, 'HOME_SEARCH_VEL'))
            hal.Pin('gantry.%i.homing' % axisIndex).link(axisHoming)
            hal.Pin('gantry.%i.home' % axisIndex).link(limitHome)

            or2 = rt.newinst('or2', 'or2.limit-%i-min' % axisIndex)
            hal.addf(or2.name, thread)
            or2.pin('out').link(limitMin)

            or2 = rt.newinst('or2', 'or2.limit-%i-max' % axisIndex)
            hal.addf(or2.name, thread)
            or2.pin('out').link(limitMax)

        limitHome = hal.newsig('limit-%i-%i-home' % (axisIndex, gantryJoint),
                               hal.HAL_BIT)
        limitMin = hal.newsig('limit-%i-%i-min' % (axisIndex, gantryJoint),
                              hal.HAL_BIT)
        limitMax = hal.newsig('limit-%i-%i-max' % (axisIndex, gantryJoint),
                              hal.HAL_BIT)
        homeOffset = hal.Signal('home-offset-%i-%i' % (axisIndex, gantryJoint),
                                hal.HAL_FLOAT)
        limitHome.link('gantry.%i.joint.%02i.home' % (axisIndex, gantryJoint))
        limitMin.link('or2.limit-%i-min.in%i' % (axisIndex, gantryJoint))
        limitMax.link('or2.limit-%i-max.in%i' % (axisIndex, gantryJoint))
        homeOffset.link('gantry.%i.joint.%02i.home-offset' % (axisIndex, gantryJoint))

        storage.setup_gantry_storage(axisIndex, gantryJoint)
Пример #57
0
def setup_joints():
    """
    Create joints commands and feedbacks signal for the system
    """
    commands = [None] * AXIS_TOTAL
    feedbacks = [None] * AXIS_TOTAL
    for i in xrange(AXIS_TOTAL):
        commands[i] = hal.newsig('machine.joint.%d.command' % i, hal.HAL_FLOAT)
        feedbacks[i] = hal.newsig('machine.joint.%d.feedback' % i, hal.HAL_FLOAT)

    core_xy = config.find('FDM','CORE_XY')
    if core_xy is not None and int(core_xy) > 0:
        sum_cmd_a = rtapi.newinst('sum2', 'corexy.sum2.cmd.a')
        sum_fb_x = rtapi.newinst('sum2', 'corexy.sum2.fb.x')
        sum_cmd_b = rtapi.newinst('sum2', 'corexy.sum2.cmd.b')
        sum_fb_y = rtapi.newinst('sum2', 'corexy.sum2.fb.y')
        hal.addf(sum_cmd_a.name, SERVO_THREAD)
        hal.addf(sum_cmd_b.name, SERVO_THREAD)
        hal.addf(sum_fb_x.name, SERVO_THREAD)
        hal.addf(sum_fb_y.name, SERVO_THREAD)

        sum_cmd_a.pin('gain0').set(1)
        sum_cmd_a.pin('gain1').set(1)
        sum_cmd_b.pin('gain0').set(1)
        sum_cmd_b.pin('gain1').set(-1)

        sum_fb_x.pin('gain0').set(0.5)
        sum_fb_x.pin('gain1').set(0.5)
        sum_fb_y.pin('gain0').set(0.5)
        sum_fb_y.pin('gain1').set(-0.5)

        corex_cmd = hal.newsig('machine.joint.corex.command', hal.HAL_FLOAT)
        corey_cmd = hal.newsig('machine.joint.corey.command', hal.HAL_FLOAT)

        corex_cmd.link('axis.0.motor-pos-cmd')
        corey_cmd.link('axis.1.motor-pos-cmd')

        sum_cmd_a.pin('in0').link(corex_cmd)
        sum_cmd_a.pin('in1').link(corey_cmd)
        sum_cmd_b.pin('in0').link(corex_cmd)
        sum_cmd_b.pin('in1').link(corey_cmd)
        sum_cmd_a.pin('out').link(commands[0])
        sum_cmd_b.pin('out').link(commands[1])

        sum_fb_x.pin('in0').link(feedbacks[0])
        sum_fb_x.pin('in1').link(feedbacks[1])
        sum_fb_y.pin('in0').link(feedbacks[0])
        sum_fb_y.pin('in1').link(feedbacks[1])
        sum_fb_x.pin('out').link('axis.0.motor-pos-fb')
        sum_fb_y.pin('out').link('axis.1.motor-pos-fb')
    else:
        commands[0].link('axis.0.motor-pos-cmd')
        feedbacks[0].link('axis.0.motor-pos-fb')
        commands[1].link('axis.1.motor-pos-cmd')
        feedbacks[1].link('axis.1.motor-pos-fb')

    for i in xrange(AXIS_TOTAL):
        if i >= 2:
            commands[i].link('axis.%d.motor-pos-cmd' % i)
            feedbacks[i].link('axis.%d.motor-pos-fb' % i)

    return (commands, feedbacks)