def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[-1]
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
# Allow virtual endstop to be created
self.diag1_pin = config.get('diag1_pin', None)
ppins = self.printer.lookup_object("pins")
ppins.register_chip("tmc2130_" + self.name, self)
# Add DUMP_TMC, INIT_TMC command
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("SET_TMC_CURRENT",
"STEPPER",
self.name,
self.cmd_SET_TMC_CURRENT,
desc=self.cmd_SET_TMC_CURRENT_help)
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
gcode.register_mux_command("SET_TMC_FIELD",
"STEPPER",
self.name,
self.cmd_SET_TMC_FIELD,
desc=self.cmd_SET_TMC_FIELD_help)
gcode.register_mux_command("INIT_TMC",
"STEPPER",
self.name,
self.cmd_INIT_TMC,
desc=self.cmd_INIT_TMC_help)
# Setup basic register values
self.regs = collections.OrderedDict()
self.fields = FieldHelper(Fields, SignedFields, FieldFormatters,
self.regs)
vsense, irun, ihold, self.sense_resistor = get_config_current(config)
self.fields.set_field("vsense", vsense)
self.fields.set_field("IHOLD", ihold)
self.fields.set_field("IRUN", irun)
mres, en_pwm, thresh = get_config_stealthchop(config, TMC_FREQUENCY)
self.fields.set_field("MRES", mres)
self.fields.set_field("en_pwm_mode", en_pwm)
self.fields.set_field("TPWMTHRS", thresh)
# Allow other registers to be set from the config
set_config_field = self.fields.set_config_field
set_config_field(config, "toff", 4)
set_config_field(config, "hstrt", 0)
set_config_field(config, "hend", 7)
set_config_field(config, "TBL", 1)
set_config_field(config, "intpol", True, "interpolate")
set_config_field(config, "IHOLDDELAY", 8)
set_config_field(config, "TPOWERDOWN", 0)
set_config_field(config, "PWM_AMPL", 128)
set_config_field(config, "PWM_GRAD", 4)
set_config_field(config, "pwm_freq", 1)
set_config_field(config, "pwm_autoscale", True)
set_config_field(config, "sgt", 0)
self._init_registers()
def __init__(self, config):
self.printer = config.get_printer()
self.printer.register_event_handler("klippy:connect",
self._handle_connect)
self.spi = bus.MCU_SPI_from_config(config, 3)
self.current = config.getint('current', 150, minval=0, maxval=255)
self.microsteps = int(
math.ceil(
math.log(config.getint('microsteps', 16, minval=0, maxval=256))
/ math.log(2)))
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[1]
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
# Allow virtual endstop to be created
self.diag1_pin = config.get('diag1_pin', None)
ppins = self.printer.lookup_object("pins")
ppins.register_chip("tmc2130_" + self.name, self)
# Add DUMP_TMC command
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
# Get config for initial driver settings
self.fields = FieldHelper(Fields)
interpolate = config.getboolean('interpolate', True)
self.mres, en_pwm, sc_threshold = get_config_stealthchop(
config, TMC_FREQUENCY)
iholddelay = config.getint('driver_IHOLDDELAY', 8, minval=0, maxval=15)
tpowerdown = config.getint('driver_TPOWERDOWN',
0,
minval=0,
maxval=255)
blank_time_select = config.getint('driver_BLANK_TIME_SELECT',
1,
minval=0,
maxval=3)
toff = config.getint('driver_TOFF', 4, minval=1, maxval=15)
hend = config.getint('driver_HEND', 7, minval=0, maxval=15)
hstrt = config.getint('driver_HSTRT', 0, minval=0, maxval=7)
sgt = config.getint('driver_SGT', 0, minval=-64, maxval=63) & 0x7f
pwm_scale = config.getboolean('driver_PWM_AUTOSCALE', True)
pwm_freq = config.getint('driver_PWM_FREQ', 1, minval=0, maxval=3)
pwm_grad = config.getint('driver_PWM_GRAD', 4, minval=0, maxval=255)
pwm_ampl = config.getint('driver_PWM_AMPL', 128, minval=0, maxval=255)
vsense, irun, ihold = get_config_current(config)
# Configure registers
self.reg_GCONF = en_pwm << 2
self.set_register("GCONF", self.reg_GCONF)
self.set_register(
"CHOPCONF",
(toff | (hstrt << 4) | (hend << 7) | (blank_time_select << 15)
| (vsense << 17) | (self.mres << 24) | (interpolate << 28)))
self.set_register("IHOLD_IRUN",
ihold | (irun << 8) | (iholddelay << 16))
self.set_register("TPOWERDOWN", tpowerdown)
self.set_register("TPWMTHRS", sc_threshold)
self.set_register("COOLCONF", sgt << 16)
self.set_register("PWMCONF", (pwm_ampl | (pwm_grad << 8) |
(pwm_freq << 16) | (pwm_scale << 18)))
def __init__(self, config):
self.spi = bus.MCU_SPI_from_config(config,
0,
pin_option="enable_pin",
default_speed=25000000)
scale = config.getfloat('scale', 1., above=0.)
for i in range(6):
val = config.getfloat('channel_%d' % (i + 1, ),
None,
minval=0.,
maxval=scale)
if val is not None:
self.set_register(i, int(val * 256. / scale + .5))
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[-1]
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
self.gcode = self.printer.lookup_object("gcode")
#
self.gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
#
# Setup basic register values
self.regs = collections.OrderedDict()
self.fields = tmc2130.FieldHelper(fields, FieldFormatters, self.regs)
vsense, irun, ihold, self.sense_resistor = tmc2130.get_config_current(
config)
#self.fields.set_field("vsense", vsense)
self.fields.set_field("IHOLD", ihold)
self.fields.set_field("IRUN", irun)
mres, en_pwm, thresh = tmc2130.get_config_stealthchop(
config, TMC_FREQUENCY)
self.fields.set_field("MRES", mres)
self.fields.set_field("en_pwm_mode", en_pwm)
self.fields.set_field("TPWMTHRS", thresh)
#
#
# Allow other registers to be set from the config
set_config_field = self.fields.set_config_field
set_config_field(config, "toff", 3)
set_config_field(config, "hstrt", 4)
set_config_field(config, "hend", 1)
set_config_field(config, "TBL", 2)
set_config_field(config, "intpol", True, "interpolate")
set_config_field(config, "IHOLDDELAY", 6)
set_config_field(config, "TPOWERDOWN", 10)
set_config_field(config, "PWM_OFS", 128) #
set_config_field(config, "PWM_GRAD", 4) #
set_config_field(config, "pwm_freq", 1)
set_config_field(config, "pwm_autoscale", True)
sgt = config.getint('driver_SGT', 0, minval=-64, maxval=63) & 0x7f
self.fields.set_field("sgt", sgt)
set_config_field(config, "test_mode", 0)
set_config_field(config, "direct_mode", 0)
#
set_config_field(config, "multistep_filt", 1)
set_config_field(config, "chm", 0)
#
self._init_registers()
def __init__(self, config, chip_type, config_cmd=None, spi_mode=1):
self.printer = config.get_printer()
self.chip_type = chip_type
self._callback = None
self.min_sample_value = self.max_sample_value = 0
self._report_clock = 0
self.spi = bus.MCU_SPI_from_config(
config, spi_mode, pin_option="sensor_pin", default_speed=4000000)
if config_cmd is not None:
self.spi.spi_send(config_cmd)
self.mcu = mcu = self.spi.get_mcu()
# Reader chip configuration
self.oid = oid = mcu.create_oid()
mcu.register_msg(self._handle_spi_response, "thermocouple_result", oid)
mcu.register_config_callback(self._build_config)
def __init__(self, config):
self.printer = config.get_printer()
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
self.bow_1 = config.getint("max_bow_1", 90000)
self.bow_2 = config.getint("max_bow_2", 90000)
self.bow_3 = config.getint("max_bow_3", 90000)
self.bow_4 = config.getint("max_bow_4", 90000)
self.enc_res = config.getint("encoder_resolution", 4096)
self.enc_type = config.get("encoder_type", "abi")
steps = {'256': 0, '128': 1, '64': 2, '32': 3, '16': 4,
'8': 5, '4': 6, '2': 7, '1': 8}
if config.has_section("tmc2130 stepper_x"):
self.tmc_x = config.getsection("tmc2130 stepper_x")
elif self.config.has_section("tmc2208 stepper_x"):
self.tmc_x = config.getsection("tmc2208 stepper_x")
elif config.has_section("tmc2660 stepper_x"):
self.tmc_x = config.getsection("tmc2660 stepper_x")
else:
raise config.error("Drivers must be TMC for use of TMC4361")
if config.has_section("tmc2130 stepper_y"):
self.tmc_y = config.getsection("tmc2130 stepper_y")
elif config.has_section("tmc2208 stepper_y"):
self.tmc_y = config.getsection("tmc2208 stepper_y")
elif config.has_section("tmc2660 stepper_y"):
self.tmc_y = config.getsection("tmc2660 stepper_y")
else:
raise config.error("Drivers must be TMC for use of TMC4361")
self.tmc_y = None
#Ensure that x and y axis have 1/256 microstepping
if self.tmc_x.getchoice("microsteps", steps) != 0: #or self.tmc_y.getchoice("microsteps", steps) != 0:
raise self._config.error("Driver microstepping must be set to 256 for use of TMC4361")
self.set_register("REGW_RESET", 0x52535400)
self.set_register("REGW_FILTER_START", 0x00540022)
self.set_register("REGW_FILTER_ENCODER", 0x8440000D)
self.set_register("REGW_RAMPMODE", 0x00000006)
self.set_register("REGW_MS", 0x00000000)
self.set_register("REGW_BOW1", self.bow_1)
self.set_register("REGW_BOW2", self.bow_2)
self.set_register("REGW_BOW3", self.bow_3)
self.set_register("REGW_BOW4", self.bow_4)
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[1]
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
# Allow virtual endstop to be created
self.diag1_pin = config.get('diag1_pin', None)
ppins = self.printer.lookup_object("pins")
ppins.register_chip("tmc2130_" + self.name, self)
# Add DUMP_TMC command
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
# Get config for initial driver settings
run_current = config.getfloat('run_current', above=0., maxval=2.)
hold_current = config.getfloat('hold_current',
run_current,
above=0.,
maxval=2.)
sense_resistor = config.getfloat('sense_resistor', 0.110, above=0.)
steps = {
'256': 0,
'128': 1,
'64': 2,
'32': 3,
'16': 4,
'8': 5,
'4': 6,
'2': 7,
'1': 8
}
self.mres = config.getchoice('microsteps', steps)
interpolate = config.getboolean('interpolate', True)
sc_velocity = config.getfloat('stealthchop_threshold', 0., minval=0.)
sc_threshold = self.velocity_to_clock(config, sc_velocity)
iholddelay = config.getint('driver_IHOLDDELAY', 8, minval=0, maxval=15)
tpowerdown = config.getint('driver_TPOWERDOWN',
0,
minval=0,
maxval=255)
blank_time_select = config.getint('driver_BLANK_TIME_SELECT',
1,
minval=0,
maxval=3)
toff = config.getint('driver_TOFF', 4, minval=1, maxval=15)
hend = config.getint('driver_HEND', 7, minval=0, maxval=15)
hstrt = config.getint('driver_HSTRT', 0, minval=0, maxval=7)
sgt = config.getint('driver_SGT', 0, minval=-64, maxval=63) & 0x7f
pwm_scale = config.getboolean('driver_PWM_AUTOSCALE', True)
pwm_freq = config.getint('driver_PWM_FREQ', 1, minval=0, maxval=3)
pwm_grad = config.getint('driver_PWM_GRAD', 4, minval=0, maxval=255)
pwm_ampl = config.getint('driver_PWM_AMPL', 128, minval=0, maxval=255)
# calculate current
vsense = False
irun = self.current_bits(run_current, sense_resistor, vsense)
ihold = self.current_bits(hold_current, sense_resistor, vsense)
if irun < 16 and ihold < 16:
vsense = True
irun = self.current_bits(run_current, sense_resistor, vsense)
ihold = self.current_bits(hold_current, sense_resistor, vsense)
# Configure registers
self.reg_GCONF = (sc_velocity > 0.) << 2
self.set_register("GCONF", self.reg_GCONF)
self.set_register(
"CHOPCONF",
(toff | (hstrt << 4) | (hend << 7) | (blank_time_select << 15)
| (vsense << 17) | (self.mres << 24) | (interpolate << 28)))
self.set_register("IHOLD_IRUN",
ihold | (irun << 8) | (iholddelay << 16))
self.set_register("TPOWERDOWN", tpowerdown)
self.set_register("TPWMTHRS", max(0, min(0xfffff, sc_threshold)))
self.set_register("COOLCONF", sgt << 16)
self.set_register("PWMCONF", (pwm_ampl | (pwm_grad << 8) |
(pwm_freq << 16) | (pwm_scale << 18)))
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[1]
self.spi = bus.MCU_SPI_from_config(config, 0, default_speed=2000000)
# Add SET_CURRENT and DUMP_TMC commands
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("SET_TMC_CURRENT",
"STEPPER",
self.name,
self.cmd_SET_TMC_CURRENT,
desc=self.cmd_SET_TMC_CURRENT_help)
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
# Setup driver registers
# DRVCTRL
steps = {
'256': 0,
'128': 1,
'64': 2,
'32': 3,
'16': 4,
'8': 5,
'4': 6,
'2': 7,
'1': 8
}
self.driver_mres = config.getchoice('microsteps', steps)
self.driver_intpol = config.getboolean('interpolate', default=True)
self.current = config.getfloat('run_current',
minval=CURRENT_MIN,
maxval=CURRENT_MAX)
self.driver_dedge = config.getboolean('driver_DEDGE', default=False)
# CHOPCONF
btime = {'16': 0, '24': 1, '36': 2, '54': 3}
self.driver_tbl = config.getchoice('driver_TBL', btime, default='36')
chm = {'spreadcycle': 0, 'constant_toff': 1}
self.driver_chm = config.getchoice('driver_CHM',
chm,
default='spreadcycle')
self.driver_rndtf = config.getboolean('driver_RNDTF', False)
if self.driver_chm:
self.driver_hend = config.getint(
'driver_HEND', default=7, minval=-3, maxval=12) + 3
self.driver_hstrt = config.getint('driver_HSTRT',
default=5,
minval=0,
maxval=15)
self.driver_toff = config.getint('driver_TOFF',
default=7,
minval=0,
maxval=15)
# if chm is 1, HDEC1 is the MSB of HSTRT
self.driver_hdec = (config.getboolean('driver_HDEC', default=False)
| ((self.driver_hstrt & 0x8) >> 1))
else:
self.driver_hdec = config.getboolean('driver_HDEC', default=False)
self.driver_hend = config.getint(
'driver_HEND', default=3, minval=-3, maxval=12) + 3
self.driver_hstrt = config.getint(
'driver_HSTRT', default=4, minval=1, maxval=8) - 1
self.driver_toff = config.getint('driver_TOFF',
default=4,
minval=0,
maxval=15)
if self.driver_hstrt + self.driver_hend > 15:
raise config.error("driver_HEND + HSTRT must be <= 15")
# SMARTEN
csc = {'quarter': 1, 'half': 0}
self.driver_seimin = config.getchoice('driver_SEIMIN',
csc,
default='half')
cds = {'32': 0, '8': 1, '2': 2, '1': 3}
self.driver_sedn = config.getchoice('driver_SEDN', cds, default='32')
self.driver_semax = config.getint('driver_SEMAX',
default=0,
minval=0,
maxval=15)
cis = {'1': 0, '2': 1, '4': 2, '8': 3}
self.driver_seup = config.getchoice('driver_SEUP', cis, default='1')
self.driver_semin = config.getint('driver_SEMIN',
default=0,
minval=0,
maxval=15)
# SGSCONF
self.driver_sfilt = config.getboolean('driver_SFILT', default=True)
self.driver_sgt = config.getint(
'driver_sgt', default=-64, minval=-64, maxval=63) + 64
self.driver_cs = current_to_reg(self.current)
# DRVCONF
slph = {'min': 0, 'min_tc': 1, 'med_tc': 2, 'max': 3}
self.driver_slph = config.getchoice('driver_SLPH', slph, default='min')
slpl = {'min': 0, 'med': 2, 'max': 3}
self.driver_slpl = config.getchoice('driver_SLPL', slpl, default='min')
self.driver_diss2g = config.getboolean('driver_DISS2G', default=False)
ts2g = {'3.2': 0, '1.6': 1, '1.2': 2, '0.8': 3}
self.driver_ts2g = config.getchoice('driver_TS2G', ts2g, default='0.8')
# since we don't support SPI mode yet, this has to be False
self.driver_sdoff = False
vsense = {'low': 0, 'high': 1}
self.driver_vsense = config.getchoice('driver_VSENSE',
vsense,
default='high')
self.driver_rdsel = 0 # Microsteps (used by endstop phase)
# Build and send registers
self.reg_drvconf = REG_DRVCONF | \
get_bits(DRVCONF, "TST", 0) | \
get_bits(DRVCONF, "SLPH", self.driver_slph) | \
get_bits(DRVCONF, "SLPL", self.driver_slpl) | \
get_bits(DRVCONF, "DISS2G", self.driver_diss2g) | \
get_bits(DRVCONF, "TS2G", self.driver_ts2g) | \
get_bits(DRVCONF, "SDOFF", self.driver_sdoff) | \
get_bits(DRVCONF, "VSENSE", self.driver_vsense) | \
get_bits(DRVCONF, "RDSEL", self.driver_rdsel)
self.add_config_cmd(self.reg_drvconf)
self.reg_drvctrl = REG_DRVCTRL | \
get_bits(DRVCTRL, "INTPOL", self.driver_intpol) | \
get_bits(DRVCTRL, "DEDGE", self.driver_dedge) | \
get_bits(DRVCTRL, "MRES", self.driver_mres)
self.add_config_cmd(self.reg_drvctrl)
self.reg_chopconf = REG_CHOPCONF | \
get_bits(CHOPCONF, "TBL", self.driver_tbl) | \
get_bits(CHOPCONF, "CHM", self.driver_chm) | \
get_bits(CHOPCONF, "RNDTF", self.driver_rndtf) | \
get_bits(CHOPCONF, "HDEC", self.driver_hdec) | \
get_bits(CHOPCONF, "HEND", self.driver_hend) | \
get_bits(CHOPCONF, "HSTRT", self.driver_hstrt) | \
get_bits(CHOPCONF, "TOFF", self.driver_toff)
self.add_config_cmd(self.reg_chopconf)
self.reg_sgcsconf = REG_SGCSCONF | \
get_bits(SGCSCONF, "SFILT", self.driver_sfilt) | \
get_bits(SGCSCONF, "SGT", self.driver_sgt) | \
get_bits(SGCSCONF, "CS", self.driver_cs)
self.add_config_cmd(self.reg_sgcsconf)
self.reg_smarten = REG_SMARTEN | \
get_bits(SMARTEN, "SEIMIN", self.driver_seimin) | \
get_bits(SMARTEN, "SEDN", self.driver_sedn) | \
get_bits(SMARTEN, "SEMAX", self.driver_semax) | \
get_bits(SMARTEN, "SEUP", self.driver_seup) | \
get_bits(SMARTEN, "SEMIN", self.driver_semin)
self.add_config_cmd(self.reg_smarten)
# Idle timeout
self.idle_current_percentage = config.getint('idle_current_percent',
default=100,
minval=0,
maxval=100)
if self.idle_current_percentage < 100:
self.printer.register_event_handler("idle_timeout:printing",
self.handle_printing)
self.printer.register_event_handler("idle_timeout:ready",
self.handle_ready)
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[1]
self.spi = bus.MCU_SPI_from_config(config, 0, default_speed=4000000)
# Add SET_CURRENT and DUMP_TMC commands
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("SET_TMC_CURRENT",
"STEPPER",
self.name,
self.cmd_SET_TMC_CURRENT,
desc=self.cmd_SET_TMC_CURRENT_help)
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
gcode.register_mux_command("SET_TMC_FIELD",
"STEPPER",
self.name,
self.cmd_SET_TMC_FIELD,
desc=self.cmd_SET_TMC_FIELD_help)
gcode.register_mux_command("INIT_TMC",
"STEPPER",
self.name,
self.cmd_INIT_TMC,
desc=self.cmd_INIT_TMC_help)
# Setup driver registers
self.regs = collections.OrderedDict()
self.fields = tmc2130.FieldHelper(Fields, SignedFields,
FieldFormatters, self.regs)
set_config_field = self.fields.set_config_field
# DRVCTRL
steps = {
'256': 0,
'128': 1,
'64': 2,
'32': 3,
'16': 4,
'8': 5,
'4': 6,
'2': 7,
'1': 8
}
self.driver_mres = config.getchoice('microsteps', steps)
self.fields.set_field("MRES", self.driver_mres)
set_config_field(config, "DEDGE", 0)
set_config_field(config, "INTPOL", True, 'interpolate')
# CHOPCONF
set_config_field(config, "TBL", 2)
set_config_field(config, "RNDTF", 0)
set_config_field(config, "HDEC", 0)
set_config_field(config, "CHM", 0)
set_config_field(config, "HEND", 3)
set_config_field(config, "HSTRT", 3)
set_config_field(config, "TOFF", 4)
if not self.fields.get_field("CHM"):
if (self.fields.get_field("HSTRT") +
self.fields.get_field("HEND")) > 15:
raise config.error("driver_HEND + driver_HSTRT must be <= 15")
# SMARTEN
set_config_field(config, "SEIMIN", 0)
set_config_field(config, "SEDN", 0)
set_config_field(config, "SEMAX", 0)
set_config_field(config, "SEUP", 0)
set_config_field(config, "SEMIN", 0)
# SGSCONF
set_config_field(config, "SFILT", 1)
set_config_field(config, "SGT", 0)
self.current = config.getfloat('run_current', minval=0.1, maxval=2.4)
self.sense_resistor = config.getfloat('sense_resistor')
(self.driver_cs,
self.driver_vsense) = get_config_current(self.current,
self.sense_resistor)
self.fields.set_field("CS", self.driver_cs)
# DRVCONF
set_config_field(config, "SLPH", 0)
set_config_field(config, "SLPL", 0)
set_config_field(config, "DISS2G", 0)
set_config_field(config, "TS2G", 3)
self.fields.set_field("VSENSE", self.driver_vsense)
self.fields.set_field("RDSEL", 0) # needed for phase calculations
self.fields.set_field("SDOFF", 0) # only step/dir mode supported
# Init Registers
self._init_registers(self)
# Register ready/printing handlers
self.idle_current_percentage = config.getint('idle_current_percent',
default=100,
minval=0,
maxval=100)
if self.idle_current_percentage < 100:
self.printer.register_event_handler("idle_timeout:printing",
self.handle_printing)
self.printer.register_event_handler("idle_timeout:ready",
self.handle_ready)
def __init__(self, config, name_to_reg, fields):
self.printer = config.get_printer()
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
self.name_to_reg = name_to_reg
self.fields = fields
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[-1]
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=100000)
# Allow virtual endstop to be created
self.diag1_pin = config.get('diag1_pin', None)
ppins = self.printer.lookup_object("pins")
ppins.register_chip("tmc5160_" + self.name, self)
# Add DUMP_TMC, INIT_TMC command
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("SET_TMC_CURRENT",
"STEPPER",
self.name,
self.cmd_SET_TMC_CURRENT,
desc=self.cmd_SET_TMC_CURRENT_help)
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
gcode.register_mux_command("SET_TMC_FIELD",
"STEPPER",
self.name,
self.cmd_SET_TMC_FIELD,
desc=self.cmd_SET_TMC_FIELD_help)
gcode.register_mux_command("INIT_TMC",
"STEPPER",
self.name,
self.cmd_INIT_TMC,
desc=self.cmd_INIT_TMC_help)
# Setup basic register values
self.regs = collections.OrderedDict()
self.fields = tmc2130.FieldHelper(fields, SignedFields,
FieldFormatters, self.regs)
irun, ihold, self.sense_resistor = get_config_current(config)
msteps, en_pwm, thresh = \
tmc2130.get_config_stealthchop(config, TMC_FREQUENCY)
set_config_field = self.fields.set_config_field
# CHOPCONF
set_config_field(config, "toff", 3)
set_config_field(config, "hstrt", 5)
set_config_field(config, "hend", 2)
set_config_field(config, "fd3", 0)
set_config_field(config, "disfdcc", 0)
set_config_field(config, "chm", 0)
set_config_field(config, "tbl", 2)
set_config_field(config, "vhighfs", 0)
set_config_field(config, "vhighchm", 0)
set_config_field(config, "tpfd", 4)
self.fields.set_field("mres", msteps) # microsteps
set_config_field(config, "intpol", True, "interpolate")
set_config_field(config, "dedge", 0)
set_config_field(config, "diss2g", 0)
set_config_field(config, "diss2vs", 0)
# COOLCONF
set_config_field(config, "semin", 0) # page 52
set_config_field(config, "seup", 0)
set_config_field(config, "semax", 0)
set_config_field(config, "sedn", 0)
set_config_field(config, "seimin", 0)
set_config_field(config, "sgt", 0)
set_config_field(config, "sfilt", 0)
# GCONF
self.fields.set_field("en_pwm_mode", en_pwm)
# IHOLDIRUN
self.fields.set_field("IHOLD", ihold)
self.fields.set_field("IRUN", irun)
set_config_field(config, "IHOLDDELAY", 6)
# PWMCONF
set_config_field(config, "PWM_OFS", 30)
set_config_field(config, "PWM_GRAD", 0)
set_config_field(config, "pwm_freq", 1)
set_config_field(config, "pwm_autoscale", True)
set_config_field(config, "pwm_autograd", True)
set_config_field(config, "freewheel", 0)
set_config_field(config, "PWM_REG", 4)
set_config_field(config, "PWM_LIM", 12)
# TPWMTHRS
self.fields.set_field("TPWMTHRS", thresh)
# TPOWERDOWN
set_config_field(config, "TPOWERDOWN", 10)
self._init_registers()
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[-1]
self.spi = bus.MCU_SPI_from_config(config, 3, default_speed=4000000)
# Allow virtual endstop to be created
self.diag1_pin = config.get('diag1_pin', None)
ppins = self.printer.lookup_object("pins")
ppins.register_chip("tmc2130_" + self.name, self)
# Add DUMP_TMC command
gcode = self.printer.lookup_object("gcode")
step_dist = config.getsection(self.name).getfloat('step_distance')
gcode.register_mux_command("DUMP_TMC",
"STEPPER",
self.name,
self.cmd_DUMP_TMC,
desc=self.cmd_DUMP_TMC_help)
# Get config for initial driver settings
self.run_current = config.getfloat('run_current', above=0., maxval=2.)
self.hold_current = config.getfloat('hold_current',
self.run_current,
above=0.,
maxval=2.)
self.homing_current = config.getfloat('homing_current',
self.run_current,
above=0.,
maxval=2.)
self.sense_resistor = config.getfloat('sense_resistor',
0.110,
above=0.)
steps = {
'256': 0,
'128': 1,
'64': 2,
'32': 3,
'16': 4,
'8': 5,
'4': 6,
'2': 7,
'1': 8
}
self.mres = config.getchoice('microsteps', steps)
self.step_dist_256 = step_dist / (1 << self.mres)
interpolate = config.getboolean('interpolate', True)
sc_velocity = config.getfloat('stealthchop_threshold', None, minval=0.)
sc_threshold = self.velocity_to_clock(sc_velocity)
self.iholddelay = config.getint('driver_IHOLDDELAY',
8,
minval=0,
maxval=15)
tpowerdown = config.getint('driver_TPOWERDOWN',
0,
minval=0,
maxval=255)
blank_time_select = config.getint('driver_BLANK_TIME_SELECT',
1,
minval=0,
maxval=3)
toff = config.getint('driver_TOFF', 4, minval=1, maxval=15)
hend = config.getint('driver_HEND', 7, minval=0, maxval=15)
hstrt = config.getint('driver_HSTRT', 0, minval=0, maxval=7)
sgt = config.getint('driver_SGT', 0, minval=-64, maxval=63) & 0x7f
pwm_scale = config.getboolean('driver_PWM_AUTOSCALE', True)
pwm_freq = config.getint('driver_PWM_FREQ', 1, minval=0, maxval=3)
pwm_grad = config.getint('driver_PWM_GRAD', 4, minval=0, maxval=255)
pwm_ampl = config.getint('driver_PWM_AMPL', 128, minval=0, maxval=255)
# new CHOPCONF options
ch_modes = {'SpreadCycle': 0, 'ConstantOff': 1}
chopper_mode = config.getchoice('chopper_mode', ch_modes,
"SpreadCycle")
rndtf = config.getboolean('driver_RNDTF', False)
tfd = config.getint('driver_TFD', 0, minval=0, maxval=15)
offset = config.getint('driver_OFFSET', 0, minval=0, maxval=15)
disfdcc = config.getboolean('driver_DISFDCC', False)
vhighfs = config.getboolean('driver_VHIGHFS', False)
vhighchm = config.getboolean('driver_VHIGHCHM', False)
sync = config.getint('driver_SYNC', 0, minval=0, maxval=15)
dedge = config.getboolean('driver_DEDGE', False)
diss2g = config.getboolean('driver_DISS2G', False)
# new COOLCONF options
semin = config.getint('driver_SEMIN', 0, minval=0, maxval=15)
seup_choices = {'1': 0, '2': 1, '4': 2, '8': 3}
seup = config.getchoice('driver_SEUP', seup_choices, '1')
semax = config.getint('driver_SEMAX', 0, minval=0, maxval=15)
sedn_choices = {'32': 0, '8': 1, '2': 2, '1': 3}
sedn = config.getchoice('driver_SEDN', sedn_choices, '32')
seimin = config.getint('driver_SEIMIN', 0, minval=0, maxval=1)
sfilt = config.getboolean('driver_SFILT', False)
# other new driver options
tc_velocity = config.getint('coolstep_threshold', 0, minval=0)
self.tcoolthrs = self.velocity_to_clock(tc_velocity)
thigh_velocity = config.getint('thigh_threshold', 0, minval=0)
th_threshold = self.velocity_to_clock(thigh_velocity)
self.vsense = config.getboolean('driver_VSENSE', None)
# Configure registers
self.reg_GCONF = (sc_velocity is not None) << 2
if chopper_mode == 0:
# spreadcycle
cm_bits = (hstrt << 4) | (hend << 7)
else:
# constant off with fast decay
cm_bits = (((tfd & 0x07) << 4) | (offset << 7) |
((tfd & 0x08) << 11) | (disfdcc << 12))
self.reg_CHOP_CONF = (toff | cm_bits | (rndtf << 13) |
(chopper_mode << 14) | (blank_time_select << 15)
| (vhighfs << 18) | (vhighchm << 19) |
(sync << 20) | (self.mres << 24) |
(interpolate << 28) | (dedge << 29) |
(diss2g << 30))
self.reg_COOL_CONF = (semin | (seup << 5) | (semax << 8) | (sedn << 13)
| (seimin << 15) | (sgt << 16) | (sfilt << 24))
self.reg_PWM_CONF = (pwm_ampl | (pwm_grad << 8) | (pwm_freq << 16) |
(pwm_scale << 18))
self.set_register("GCONF", self.reg_GCONF)
self.set_current_regs(self.run_current, self.hold_current)
self.set_register("TPOWERDOWN", tpowerdown)
self.set_register("TPWMTHRS", max(0, min(0xfffff, sc_threshold)))
# TODO: need to use velocity to clock for toolthrs and high?
self.set_register("TCOOLTHRS", max(0, min(0xfffff, self.tcoolthrs)))
self.set_register("THIGH", max(0, min(0xfffff, th_threshold)))
self.set_register("COOLCONF", self.reg_COOL_CONF)
self.set_register("PWMCONF", self.reg_PWM_CONF)
self.extras = tmc2130_extra.TMC2130_EXTRA(config, self)
