Mirror
/
klipper-dgus
mirror of https://github.com/Desuuuu/klipper.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
klipper-dgus/klippy/extras/tmc2660.py

283 lines
12 KiB
Python
Raw Blame History

# TMC2660 configuration
#
# Copyright (C) 2018 Florian Heilmann <Florian.Heilmann@gmx.net>
#
# This file may be distributed under the terms of the GNU GPLv3 license.
import bus
CURRENT_MAX = 2.4
CURRENT_MIN = 0.1
REG_DRVCONF = 0xe << 16
REG_SGCSCONF = 0xc << 16
REG_SMARTEN = 0xa << 16
REG_CHOPCONF = 0x8 << 16
REG_DRVCTRL = 0x0 << 16
def get_bits(reg, field, value):
return ((value << reg[field][0]) & reg[field][1])
def read_field(bits, reg, field):
return (bits & reg[field][1]) >> reg[field][0]
def current_to_reg(current):
current_constrained = min(CURRENT_MAX, max(CURRENT_MIN, current))
return int((32 * 1000 * current_constrained - 1600)/3236) # Taken from RRF
DRVCTRL = {
"INTPOL" : (9, 0x00100),
"DEDGE" : (8, 0x00080),
"MRES" : (0, 0x0000F)
}
CHOPCONF = {
"TBL" : (15, 0x18000),
"CHM" : (14, 0x04000),
"RNDTF" : (13, 0x02000),
"HDEC" : (11, 0x01800),
"HEND" : (7, 0x00780),
"HSTRT" : (4, 0x00070),
"TOFF" : (0, 0x0000F)
}
SMARTEN = {
"SEIMIN" : (15, 0x08000),
"SEDN" : (14, 0x06000),
"SEMAX" : (8, 0x00F00),
"SEUP" : (5, 0x00060),
"SEMIN" : (0, 0x0000F)
}
SGCSCONF = {
"SFILT" : (16, 0x10000),
"SGT" : (8, 0x07800),
"CS" : (0, 0x0001F)
}
DRVCONF = {
"TST" : (16, 0x10000),
"SLPH" : (14, 0x0C000),
"SLPL" : (12, 0x03000),
"DISS2G" : (10, 0x00400),
"TS2G" : (8, 0x00300),
"SDOFF" : (7, 0x00080),
"VSENSE" : (6, 0x00040),
"RDSEL" : (4, 0x00030)
}
READRSP = {
"MSTEP" : (10, 0xFFC00),
"STST" : (7, 0x00080),
"OLB" : (6, 0x00040),
"OLA" : (5, 0x00020),
"S2GB" : (4, 0x00010),
"S2GA" : (3, 0x00008),
"OTPW" : (2, 0x00004),
"OT" : (1, 0x00002),
"SG" : (0, 0x00001)
}
class TMC2660:
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 add_config_cmd(self, val):
data = [(val >> 16) & 0xff, (val >> 8) & 0xff, val & 0xff]
self.spi.spi_send(data)
def get_microsteps(self):
return 256 >> self.driver_mres
def get_phase(self):
# Send DRVCTRL to get a response
reg_data = [(self.reg_drvctrl >> 16) & 0xff,
(self.reg_drvctrl >> 8) & 0xff, self.reg_drvctrl & 0xff]
params = self.spi.spi_transfer(reg_data)
pr = bytearray(params['response'])
steps = (((pr[0] << 16) | (pr[1] << 8) | pr[2])
& READRSP['MSTEP'][1]) >> READRSP['MSTEP'][0]
return steps >> self.driver_mres
def handle_printing(self, print_time):
self.set_current(print_time, self.current)
def handle_ready(self, print_time):
self.set_current(print_time, (float(self.idle_current_percentage)
* self.current / 100))
def set_current(self, print_time, current):
self.driver_cs = current_to_reg(current)
reg = self.reg_sgcsconf
reg &= ~(SGCSCONF["CS"][1])
reg |= get_bits(SGCSCONF, "CS", self.driver_cs)
reg_data = [(reg >> 16) & 0xff, (reg >> 8) & 0xff, reg & 0xff]
clock = self.spi.get_mcu().print_time_to_clock(print_time)
self.spi.spi_send(reg_data, minclock=clock, reqclock=clock)
cmd_SET_TMC_CURRENT_help = (
"Set the current of a TMC2660 driver (between %d and %d)" % (
CURRENT_MIN, CURRENT_MAX))
def cmd_SET_TMC_CURRENT(self, params):
gcode = self.printer.lookup_object('gcode')
if 'CURRENT' in params:
self.current = gcode.get_float(
'CURRENT', params, minval=CURRENT_MIN, maxval=CURRENT_MAX)
self.set_current(
self.printer.lookup_object('toolhead').get_last_move_time(),
self.current)
cmd_DUMP_TMC_help = "Read and display TMC stepper driver registers"
def cmd_DUMP_TMC(self, params):
self.printer.lookup_object('toolhead').get_last_move_time()
gcode = self.printer.lookup_object('gcode')
for reg_name , val in zip(["DRVCONF", "DRVCTRL", "CHOPCONF",
"SGCSCONF", "SMARTEN"],
[self.reg_drvconf, self.reg_drvctrl,
self.reg_chopconf, self.reg_sgcsconf,
self.reg_smarten]):
msg = "%-15s %08x" % (reg_name + " (cached):", val)
gcode.respond_info(msg)
# Send one register to get the return data
reg_data = [(self.reg_drvctrl >> 16) & 0xff,
(self.reg_drvctrl >> 8) & 0xff, self.reg_drvctrl & 0xff]
params = self.spi.spi_transfer(reg_data)
pr = bytearray(params['response'])
msg = "%-15s %08x" % (
"RESPONSE:", ((pr[0] << 16) | (pr[1] << 8) | pr[2]))
gcode.respond_info(msg)
def load_config_prefix(config):
return TMC2660(config)
Reference in New Issue View Git Blame Copy Permalink