def __init__(self, config):
printer = config.get_printer()
ppins = printer.lookup_object('pins')
ppins.register_chip('replicape', self)
revisions = {'B3': 'B3'}
config.getchoice('revision', revisions)
self.host_mcu = mcu.get_printer_mcu(printer, config.get('host_mcu'))
# Setup enable pin
enable_pin = config.get('enable_pin', '!P9_41')
self.mcu_pwm_enable = ppins.setup_pin('digital_out', enable_pin)
self.mcu_pwm_enable.setup_max_duration(0.)
self.mcu_pwm_start_value = self.mcu_pwm_shutdown_value = False
# Setup power pins
self.pins = {
"power_e": (pca9685_pwm, 5), "power_h": (pca9685_pwm, 3),
"power_hotbed": (pca9685_pwm, 4),
"power_fan0": (pca9685_pwm, 7), "power_fan1": (pca9685_pwm, 8),
"power_fan2": (pca9685_pwm, 9), "power_fan3": (pca9685_pwm, 10) }
self.servo_pins = {
"servo0": 3, "servo1": 2 }
# Setup stepper config
self.last_stepper_time = 0.
self.stepper_dacs = {}
shift_registers = [1, 0, 0, 1, 1]
for port, name in enumerate('xyzeh'):
prefix = 'stepper_%s_' % (name,)
sc = config.getchoice(
prefix + 'microstep_mode', ReplicapeStepConfig, 'disable')
if sc is None:
continue
sc |= shift_registers[port]
if config.getboolean(prefix + 'chopper_off_time_high', False):
sc |= 1<<3
if config.getboolean(prefix + 'chopper_hysteresis_high', False):
sc |= 1<<2
if config.getboolean(prefix + 'chopper_blank_time_high', True):
sc |= 1<<1
shift_registers[port] = sc
channel = port + 11
cur = config.getfloat(
prefix + 'current', above=0., maxval=REPLICAPE_MAX_CURRENT)
self.stepper_dacs[channel] = cur / REPLICAPE_MAX_CURRENT
self.pins[prefix + 'enable'] = (ReplicapeDACEnable, channel)
self.enabled_channels = {ch: False for cl, ch in self.pins.values()}
self.sr_disabled = list(reversed(shift_registers))
if [i for i in [0, 1, 2] if 11+i in self.stepper_dacs]:
# Enable xyz steppers
shift_registers[0] &= ~1
if [i for i in [3, 4] if 11+i in self.stepper_dacs]:
# Enable eh steppers
shift_registers[3] &= ~1
if (config.getboolean('standstill_power_down', False)
and self.stepper_dacs):
shift_registers[4] &= ~1
self.sr_enabled = list(reversed(shift_registers))
self.sr_spi = bus.MCU_SPI(self.host_mcu, REPLICAPE_SHIFT_REGISTER_BUS,
None, 0, 50000000, self.sr_disabled)
self.sr_spi.spi_send(self.sr_disabled)
def __init__(self, config):
printer = config.get_printer()
pins.get_printer_pins(printer).register_chip('replicape', self)
revisions = {'B3': 'B3'}
config.getchoice('revision', revisions)
self.host_mcu = mcu.get_printer_mcu(printer, config.get('host_mcu'))
# Setup enable pin
self.mcu_pwm_enable = pins.setup_pin(
printer, 'digital_out', config.get('enable_pin', '!P9_41'))
self.mcu_pwm_enable.setup_max_duration(0.)
self.mcu_pwm_start_value = self.mcu_pwm_shutdown_value = False
# Setup power pins
self.pins = {
"power_e": (pca9685_pwm, 5), "power_h": (pca9685_pwm, 3),
"power_hotbed": (pca9685_pwm, 4),
"power_fan0": (pca9685_pwm, 7), "power_fan1": (pca9685_pwm, 8),
"power_fan2": (pca9685_pwm, 9), "power_fan3": (pca9685_pwm, 10) }
# Setup stepper config
self.stepper_dacs = {}
shift_registers = [1, 0, 0, 1, 1]
for port, name in enumerate('xyzeh'):
prefix = 'stepper_%s_' % (name,)
sc = config.getchoice(
prefix + 'microstep_mode', ReplicapeStepConfig, 'disable')
if sc is None:
continue
sc |= shift_registers[port]
if config.getboolean(prefix + 'chopper_off_time_high', False):
sc |= 1<<3
if config.getboolean(prefix + 'chopper_hysteresis_high', False):
sc |= 1<<2
if config.getboolean(prefix + 'chopper_blank_time_high', True):
sc |= 1<<1
shift_registers[port] = sc
channel = port + 11
cur = config.getfloat(
prefix + 'current', above=0., maxval=REPLICAPE_MAX_CURRENT)
self.stepper_dacs[channel] = cur / REPLICAPE_MAX_CURRENT
self.pins[prefix + 'enable'] = (ReplicapeDACEnable, channel)
self.enabled_channels = {ch: False for cl, ch in self.pins.values()}
self.disable_stepper_cmd = "send_spi bus=%d dev=%d msg=%s" % (
REPLICAPE_SHIFT_REGISTER_BUS, REPLICAPE_SHIFT_REGISTER_DEVICE,
"".join(["%02x" % (x,) for x in reversed(shift_registers)]))
if [i for i in [0, 1, 2] if 11+i in self.stepper_dacs]:
# Enable xyz steppers
shift_registers[0] &= ~1
if [i for i in [3, 4] if 11+i in self.stepper_dacs]:
# Enable eh steppers
shift_registers[3] &= ~1
if (config.getboolean('standstill_power_down', False)
and self.stepper_dacs):
shift_registers[4] &= ~1
self.enable_stepper_cmd = "send_spi bus=%d dev=%d msg=%s" % (
REPLICAPE_SHIFT_REGISTER_BUS, REPLICAPE_SHIFT_REGISTER_DEVICE,
"".join(["%02x" % (x,) for x in reversed(shift_registers)]))
self.host_mcu.add_config_cmd(self.disable_stepper_cmd)
self.last_stepper_time = 0.
def MCU_I2C_from_config(config, default_addr=None, default_speed=100000):
# Load bus parameters
printer = config.get_printer()
i2c_mcu = mcu.get_printer_mcu(printer, config.get('i2c_mcu', 'mcu'))
speed = config.getint('i2c_speed', default_speed, minval=100000)
bus = config.get('i2c_bus', None)
if default_addr is None:
addr = config.getint('i2c_address', minval=0, maxval=127)
else:
addr = config.getint('i2c_address', default_addr, minval=0, maxval=127)
# Create MCU_I2C object
return MCU_I2C(i2c_mcu, bus, addr, speed)
def __init__(self, config):
self.printer = config.get_printer()
self.mcu_name = config.get_name().split()[-1]
if self.mcu_name == None:
self.mcu_name = 'mcu'
self._mcu = mcu.get_printer_mcu(self.printer, self.mcu_name)
self._mcu.register_config_callback(self._build_config)
gcode = self.printer.lookup_object("gcode")
gcode.register_mux_command("BOOTLOADER",
"MCU",
self.mcu_name,
self.cmd_BOOTLOADER,
desc='cmd_BOOTLOADER_help')
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name().split()[-1]
self.sensor_id = config.get("serial_no")
self.temp = self.min_temp = self.max_temp = 0.0
self._report_clock = 0
self.report_time = config.getfloat('ds18_report_time',
DS18_REPORT_TIME,
minval=DS18_MIN_REPORT_TIME)
self._mcu = mcu.get_printer_mcu(self.printer, config.get('sensor_mcu'))
self.oid = self._mcu.create_oid()
self._mcu.register_response(self._handle_ds18b20_response,
"ds18b20_result", self.oid)
self._mcu.register_config_callback(self._build_config)
def __init__(self, config):
printer = config.get_printer()
ppins = printer.lookup_object('pins')
ppins.register_chip('recore', self)
revisions = {'A1': 'A1'}
config.getchoice('revision', revisions)
self.host_mcu = mcu.get_printer_mcu(printer, config.get('host_mcu'))
# Setup enable pin
enable_pin = config.get('enable_pin', 'ar100:PG1')
self.mcu_power_enable = ppins.setup_pin('digital_out', enable_pin)
self.mcu_power_enable.setup_start_value(start_value=1., shutdown_value=0., is_static=False)
self.mcu_power_enable.setup_max_duration(0.)
self.mcu_power_start_value = self.mcu_power_shutdown_value = False
# Setup stepper config
self.last_stepper_time = 0.
def __init__(self, config):
printer = config.get_printer()
self.mcu = mcu.get_printer_mcu(printer, config.get('mcu', 'mcu'))
self.i2c_addr = config.getint('i2c_address')
scale = config.getfloat('scale', 1., above=0.)
wipers = [None]*4
for i in range(len(wipers)):
val = config.getfloat('wiper_%d' % (i,), None,
minval=0., maxval=scale)
if val is not None:
wipers[i] = int(val * 255. / scale + .5)
self.add_config_cmd(0x04, 0xff)
self.add_config_cmd(0x0a, 0xff)
for reg, val in zip(WiperRegisters, wipers):
if val is not None:
self.add_config_cmd(reg, val)
def __init__(self, printer, config):
pins.get_printer_pins(printer).register_chip('replicape', self)
revisions = {'B3': 'B3'}
config.getchoice('revision', revisions)
self.host_mcu = mcu.get_printer_mcu(printer, config.get('host_mcu'))
# Setup enable pin
self.mcu_enable = pins.setup_pin(printer, 'digital_out',
config.get('enable_pin', '!P9_41'))
self.mcu_enable.setup_max_duration(0.)
self.enabled_channels = {}
# Setup power pins
self.pins = {
"power_e": (pca9685_pwm, 5),
"power_h": (pca9685_pwm, 3),
"power_hotbed": (pca9685_pwm, 4),
"power_fan0": (pca9685_pwm, 7),
"power_fan1": (pca9685_pwm, 8),
"power_fan2": (pca9685_pwm, 9),
"power_fan3": (pca9685_pwm, 10)
}
# Setup stepper config
self.stepper_dacs = {}
shift_registers = [1] * 5
for port, name in enumerate('xyzeh'):
prefix = 'stepper_%s_' % (name, )
sc = config.getchoice(prefix + 'microstep_mode',
ReplicapeStepConfig, 'disable')
if sc is None:
continue
if config.getboolean(prefix + 'chopper_off_time_high', False):
sc |= 1 << 3
if config.getboolean(prefix + 'chopper_hysteresis_high', False):
sc |= 1 << 2
if config.getboolean(prefix + 'chopper_blank_time_high', True):
sc |= 1 << 1
shift_registers[port] = sc
channel = port + 11
cur = config.getfloat(prefix + 'current',
above=0.,
maxval=REPLICAPE_MAX_CURRENT)
self.stepper_dacs[channel] = cur / REPLICAPE_MAX_CURRENT
self.pins[prefix + 'enable'] = (ReplicapeDACEnable, channel)
shift_registers.reverse()
self.host_mcu.add_config_cmd(
"send_spi bus=%d dev=%d msg=%s" %
(REPLICAPE_SHIFT_REGISTER_BUS, REPLICAPE_SHIFT_REGISTER_DEVICE,
"".join(["%02x" % (x, ) for x in shift_registers])))
def __init__(self, config):
self._printer = config.get_printer()
self._name = config.get_name().split()[1]
self._chip_address = int(config.get('address'), 0)
self._bus = config.getint('bus', minval=0, default=0)
self._ppins = self._printer.lookup_object("pins")
self._ppins.register_chip("sx1509_" + self._name, self)
self._mcu = mcu.get_printer_mcu(self._printer, config.get('mcu', 'mcu'))
self._mcu.register_config_callback(self._build_config)
self._oid = self._mcu.create_oid()
self._i2c_write_cmd = self._i2c_modify_cmd = None
self._last_clock = 0
self._freq = 400000 # Fixed frequency for SX1509
# Set up registers default values
self.reg_dict = {REG_DIR : 0xFFFF, REG_DATA : 0, REG_PULLUP : 0, REG_PULLDOWN : 0,
REG_INPUT_DISABLE : 0, REG_ANALOG_DRIVER_ENABLE : 0}
self.reg_i_on_dict = {reg : 0 for reg in REG_I_ON}
def __init__(self, config):
printer = config.get_printer()
self.mcu = mcu.get_printer_mcu(printer, config.get('mcu', 'mcu'))
self.i2c_addr = config.getint('i2c_address')
scale = config.getfloat('scale', 1., above=0.)
wipers = [None] * 4
for i in range(len(wipers)):
val = config.getfloat('wiper_%d' % (i, ),
None,
minval=0.,
maxval=scale)
if val is not None:
wipers[i] = int(val * 255. / scale + .5)
self.add_config_cmd(0x04, 0xff)
self.add_config_cmd(0x0a, 0xff)
for reg, val in zip(WiperRegisters, wipers):
if val is not None:
self.add_config_cmd(reg, val)
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name()
self.reactor = self.printer.get_reactor()
self.gcode = self.printer.lookup_object('gcode')
self.configfile = self.printer.lookup_object('configfile')
self.toolhead = None
self.heaters = self.printer.load_object(config, 'heaters')
self.pause_resume = self.printer.load_object(config, 'pause_resume')
self.stepper_enable = self.printer.load_object(config, 'stepper_enable')
self.bed_mesh = None
self.probe = None
self.extruders = {}
self.mcu = mcu.get_printer_mcu(self.printer,
config.get('t5uid1_mcu', 'mcu'))
self.oid = self.mcu.create_oid()
self._version = self.printer.get_start_args().get('software_version')
self.printer.load_object(config, 'gcode_macro')
self._gcode_macro = T5UID1GCodeMacro(config)
firmware_cfg = config.getchoice('firmware', T5UID1_firmware_cfg)
self._firmware = config.get('firmware')
self._machine_name = config.get('machine_name', 'Generic 3D printer')
self._baud = config.getint('baud', 115200, minval=1200, maxval=921600)
self._update_interval = config.getint('update_interval', 2,
minval=1, maxval=10)
self._volume = config.getint('volume', DEFAULT_VOLUME,
minval=0, maxval=100)
self._brightness = config.getint('brightness', DEFAULT_BRIGHTNESS,
minval=0, maxval=100)
self._boot_sound = config.getint('boot_sound',
firmware_cfg['boot_sound'],
minval=-1, maxval=255)
self._notification_sound = config.getint('notification_sound',
firmware_cfg['notification_sound'], minval=-1, maxval=255)
def __init__(self, config):
printer = config.get_printer()
# Read config parameters
self.mcu = mcu.get_printer_mcu(printer, config.get('mcu', 'mcu'))
i2c_addr = config.getint('i2c_address')
scale = config.getfloat('scale', 1., above=0.)
wipers = [None] * 4
for i in range(len(wipers)):
val = config.getfloat('wiper_%d' % (i, ),
None,
minval=0.,
maxval=scale)
if val is not None:
wipers[i] = int(val * 255. / scale + .5)
# Setup i2c
self.oid = self.mcu.create_oid()
self.mcu.add_config_cmd("config_i2c oid=%d bus=0 rate=100000 addr=%d" %
(self.oid, i2c_addr))
# Configure registers
self.add_config_cmd(0x04, 0xff)
self.add_config_cmd(0x0a, 0xff)
for reg, val in zip(WiperRegisters, wipers):
if val is not None:
self.add_config_cmd(reg, val)
def __init__(self, config):
self.printer = config.get_printer()
self.name = config.get_name()
self.reactor = self.printer.get_reactor()
self.gcode = self.printer.lookup_object('gcode')
self.configfile = self.printer.lookup_object('configfile')
self.toolhead = None
self.heaters = self.printer.load_object(config, 'heaters')
self.pause_resume = self.printer.load_object(config, 'pause_resume')
self.stepper_enable = self.printer.load_object(config,
'stepper_enable')
self.bed_mesh = None
self.probe = None
self.extruders = {}
self.mcu = mcu.get_printer_mcu(self.printer,
config.get('t5uid1_mcu', 'mcu'))
self.oid = self.mcu.create_oid()
self._version = self.printer.get_start_args().get('software_version')
self.printer.load_object(config, 'gcode_macro')
self._gcode_macro = T5UID1GCodeMacro(config)
firmware_cfg = config.getchoice('firmware', T5UID1_firmware_cfg)
self._firmware = config.get('firmware')
self._machine_name = config.get('machine_name', 'Generic 3D printer')
self._baud = config.getint('baud', 115200, minval=1200, maxval=921600)
self._update_interval = config.getint('update_interval',
2,
minval=1,
maxval=10)
self._volume = config.getint('volume',
DEFAULT_VOLUME,
minval=0,
maxval=100)
self._brightness = config.getint('brightness',
DEFAULT_BRIGHTNESS,
minval=0,
maxval=100)
self._boot_sound = config.getint('boot_sound',
firmware_cfg['boot_sound'],
minval=-1,
maxval=255)
self._notification_sound = config.getint(
'notification_sound',
firmware_cfg['notification_sound'],
minval=-1,
maxval=255)
self._x_min_inset = config.getfloat('x_min_inset',
DEFAULT_INSET,
minval=0.0)
self._x_max_inset = config.getfloat('x_max_inset',
DEFAULT_INSET,
minval=0.0)
self._y_min_inset = config.getfloat('y_min_inset',
DEFAULT_INSET,
minval=0.0)
self._y_max_inset = config.getfloat('y_max_inset',
DEFAULT_INSET,
minval=0.0)
self._x_min = config.getfloat('x_min', None)
self._x_max = config.getfloat('x_max', None)
self._y_min = config.getfloat('y_min', None)
self._y_max = config.getfloat('y_max', None)
self._z_min = config.getfloat('z_min', None)
self._z_max = config.getfloat('z_max', None)
self._last_cmd_time = 0
self._gui_version = 0
self._os_version = 0
self._current_page = ""
self._variable_data = {}
self._status_data = {}
self._vars = {}
self._pages = {}
self._routines = {}
self._is_printing = False
self._print_progress = 0
self._print_start_time = -1
self._print_pause_time = -1
self._print_end_time = -1
self._boot_page = self._timeout_page = self._shutdown_page = None
self._t5uid1_ping_cmd = self._t5uid1_write_cmd = None
self._is_connected = False
self._original_M73 = None
self._original_M117 = None
global_context = {
'get_variable': self.get_variable,
'set_variable': self.set_variable,
'enable_control': self.enable_control,
'disable_control': self.disable_control,
'start_routine': self.start_routine,
'stop_routine': self.stop_routine,
'set_message': self.set_message,
'bitwise_and': bitwise_and,
'bitwise_or': bitwise_or
}
context_input = dict(global_context)
context_input.update({
'page_name': self.page_name,
'switch_page': self.switch_page,
'play_sound': self.play_sound,
'set_volume': self.set_volume,
'set_brightness': self.set_brightness,
'limit_extrude': self.limit_extrude,
'heater_min_temp': self.heater_min_temp,
'heater_max_temp': self.heater_max_temp,
'heater_min_extrude_temp': self.heater_min_extrude_temp,
'is_busy': self.is_busy
})
context_output = dict(global_context)
context_output.update({
'all_steppers_enabled': self.all_steppers_enabled,
'heater_min_temp': self.heater_min_temp,
'heater_max_temp': self.heater_max_temp,
'probed_matrix': self.probed_matrix,
'pid_param': self.pid_param,
'get_duration': get_duration
})
context_routine = dict(global_context)
context_routine.update({
'page_name': self.page_name,
'switch_page': self.switch_page,
'play_sound': self.play_sound,
'set_volume': self.set_volume,
'set_brightness': self.set_brightness,
'abort_page_switch': self.abort_page_switch,
'full_update': self.full_update,
'is_busy': self.is_busy,
'check_paused': self.check_paused
})
self._status_data.update({
'controls': firmware_cfg['controls'],
'constants': firmware_cfg['constants']
})
self._load_config(config, firmware_cfg['config_files'], context_input,
context_output, context_routine)
if self._boot_page is None:
raise self.printer.config_error("No boot page found")
if self._timeout_page is None:
self._timeout_page = self._boot_page
if self._shutdown_page is None:
self._shutdown_page = self._boot_page
self.mcu.register_config_callback(self._build_config)
self._update_timer = self.reactor.register_timer(self._send_update)
self._ping_timer = self.reactor.register_timer(self._do_ping)
self.gcode.register_command('DGUS_ABORT_PAGE_SWITCH',
self.cmd_DGUS_ABORT_PAGE_SWITCH)
self.gcode.register_command('DGUS_PLAY_SOUND',
self.cmd_DGUS_PLAY_SOUND)
self.gcode.register_command('DGUS_PRINT_START',
self.cmd_DGUS_PRINT_START)
self.gcode.register_command('DGUS_PRINT_END', self.cmd_DGUS_PRINT_END)
self.gcode.register_command('M300', self.cmd_M300)
self.printer.register_event_handler("klippy:ready", self._handle_ready)
self.printer.register_event_handler("klippy:shutdown",
self._handle_shutdown)
self.printer.register_event_handler("klippy:disconnect",
self._handle_disconnect)
def __init__(self, config):
printer = config.get_printer()
ppins = printer.lookup_object('pins')
ppins.register_chip('replicape', self)
revisions = {'B3': 'B3'}
config.getchoice('revision', revisions)
self.host_mcu = mcu.get_printer_mcu(printer, config.get('host_mcu'))
# Setup enable pin
enable_pin = config.get('enable_pin', '!P9_41')
self.mcu_pwm_enable = ppins.setup_pin('digital_out', enable_pin)
self.mcu_pwm_enable.setup_max_duration(0.)
self.mcu_pwm_start_value = self.mcu_pwm_shutdown_value = False
# Setup power pins
self.pins = {
"power_e": (pca9685_pwm, 5),
"power_h": (pca9685_pwm, 3),
"power_hotbed": (pca9685_pwm, 4),
"power_fan0": (pca9685_pwm, 7),
"power_fan1": (pca9685_pwm, 8),
"power_fan2": (pca9685_pwm, 9),
"power_fan3": (pca9685_pwm, 10)
}
self.servo_pins = {"servo0": 3, "servo1": 2}
# Setup stepper config
self.last_stepper_time = 0.
self.stepper_dacs = {}
shift_registers = [1, 0, 0, 1, 1]
for port, name in enumerate('xyzeh'):
prefix = 'stepper_%s_' % (name, )
sc = config.getchoice(prefix + 'microstep_mode',
ReplicapeStepConfig, 'disable')
if sc is None:
continue
sc |= shift_registers[port]
if config.getboolean(prefix + 'chopper_off_time_high', False):
sc |= 1 << 3
if config.getboolean(prefix + 'chopper_hysteresis_high', False):
sc |= 1 << 2
if config.getboolean(prefix + 'chopper_blank_time_high', True):
sc |= 1 << 1
shift_registers[port] = sc
channel = port + 11
cur = config.getfloat(prefix + 'current',
above=0.,
maxval=REPLICAPE_MAX_CURRENT)
self.stepper_dacs[channel] = cur / REPLICAPE_MAX_CURRENT
self.pins[prefix + 'enable'] = (ReplicapeDACEnable, channel)
self.enabled_channels = {ch: False for cl, ch in self.pins.values()}
self.sr_disabled = list(reversed(shift_registers))
if [i for i in [0, 1, 2] if 11 + i in self.stepper_dacs]:
# Enable xyz steppers
shift_registers[0] &= ~1
if [i for i in [3, 4] if 11 + i in self.stepper_dacs]:
# Enable eh steppers
shift_registers[3] &= ~1
if (config.getboolean('standstill_power_down', False)
and self.stepper_dacs):
shift_registers[4] &= ~1
self.sr_enabled = list(reversed(shift_registers))
sr_spi_bus = "spidev1.1"
if not self.host_mcu.is_fileoutput() and os.path.exists(
'/sys/devices/platform/ocp/481a0000.spi/spi_master/spi2'):
sr_spi_bus = "spidev2.1"
self.sr_spi = bus.MCU_SPI(self.host_mcu, sr_spi_bus, None, 0, 50000000)
self.sr_spi.setup_shutdown_msg(self.sr_disabled)
self.sr_spi.spi_send(self.sr_disabled)
def __init__(self, config):
#Printer object, top level object
self.printer = config.get_printer()
self.reactor = self.printer.get_reactor()
#gcode dispatch and gcode macro dispatch (self.gcode.run_script("M220 S%d" % (self.feedrate_splice * 100)))
self.gcode = self.printer.lookup_object('gcode')
# load printer objects
self.gcode_macro = self.printer.load_object(config, 'gcode_macro')
self.gcode_queue = []
self.mcu = mcu.get_printer_mcu(self.printer,
config.get('maxpro_mcu', 'mcu'))
self.oid = self.mcu.create_oid()
#update system info
self.softversion = self.printer.get_start_args().get(
'software_version')
#initialize the member variable
self._maxproui_write = None
# minimum delay between back to back messages
self.cmd_delay = config.get('cmd_delay', 0.01)
self._baud = config.getint('baud', 115200, minval=1200, maxval=921600)
self._is_connected = False
self.previous_state = 'standby'
self.extruder_current_temp = 0
self.extruder_target_temp = 0
self.bed_current_temp = 0
self.bed_target_temp = 0
self.fan_speed = 0
self.print_progress = 0
self.print_time = ""
self.toolhead = None
self.fan = None
self.bed = None
self.heater = None
self.display_status = self.load_object_internal(
config, "display_status")
self.sdcard = self.load_object_internal(config, "virtual_sdcard")
self.pause_resume = self.load_object_internal(config, "pause_resume")
# Print Stat Tracking
self.print_stats = self.load_object_internal(config, 'print_stats')
self.idle_timeout = self.load_object_internal(config, 'idle_timeout')
self.gcode_move = None
self.menu_table = []
self.menu_table_lookup = {}
self.selectedSDFile = ""
self.lastUserSelection = ""
self.lastPageNo = 0
self.specialMenuActive = False
self.requestStayOnPage = False
self.requestExeCmd = False
self.showLastPage = False
self.lastShownPageIdx = 0
# Load items from main config
self.load_menuitems(config)
#Callback registrations
#get called on mcu config phase
self.mcu.register_config_callback(self.build_config)
#get called on klippy state changes
#self.printer.register_event_handler("klippy:connect", self._handle_connect)
self.printer.register_event_handler("klippy:ready", self._handle_ready)
self.printer.register_event_handler("klippy:shutdown",
self._handle_shutdown)
self.printer.register_event_handler("klippy:disconnect",
self._handle_disconnect)
self.gcode.register_command("TFTCMD",
self.cmd_TFTCMD,
desc=self.cmd_TFTCMD_help)
def __init__(self, config):
printer = config.get_printer()
ppins = printer.lookup_object('pins')
ppins.register_chip('replicape', self)
revisions = {'B3': 'B3'}
config.getchoice('revision', revisions)
self.host_mcu = mcu.get_printer_mcu(printer, config.get('host_mcu'))
# Setup enable pin
enable_pin = config.get('enable_pin', '!P9_41')
self.mcu_pwm_enable = ppins.setup_pin('digital_out', enable_pin)
self.mcu_pwm_enable.setup_max_duration(0.)
self.mcu_pwm_start_value = self.mcu_pwm_shutdown_value = False
# Setup power pins
self.pins = {
"power_e": (pca9685_pwm, 5),
"power_h": (pca9685_pwm, 3),
"power_hotbed": (pca9685_pwm, 4),
"power_fan0": (pca9685_pwm, 7),
"power_fan1": (pca9685_pwm, 8),
"power_fan2": (pca9685_pwm, 9),
"power_fan3": (pca9685_pwm, 10)
}
# Setup stepper config
self.spi_send_cmd = None
self.last_stepper_time = 0.
self.stepper_dacs = {}
shift_registers = [1, 0, 0, 1, 1]
for port, name in enumerate('xyzeh'):
prefix = 'stepper_%s_' % (name, )
sc = config.getchoice(prefix + 'microstep_mode',
ReplicapeStepConfig, 'disable')
if sc is None:
continue
sc |= shift_registers[port]
if config.getboolean(prefix + 'chopper_off_time_high', False):
sc |= 1 << 3
if config.getboolean(prefix + 'chopper_hysteresis_high', False):
sc |= 1 << 2
if config.getboolean(prefix + 'chopper_blank_time_high', True):
sc |= 1 << 1
shift_registers[port] = sc
channel = port + 11
cur = config.getfloat(prefix + 'current',
above=0.,
maxval=REPLICAPE_MAX_CURRENT)
self.stepper_dacs[channel] = cur / REPLICAPE_MAX_CURRENT
self.pins[prefix + 'enable'] = (ReplicapeDACEnable, channel)
self.enabled_channels = {ch: False for cl, ch in self.pins.values()}
if config.getboolean('servo0_enable', False):
shift_registers[1] |= 1
if config.getboolean('servo1_enable', False):
shift_registers[2] |= 1
self.sr_disabled = tuple(reversed(shift_registers))
if [i for i in [0, 1, 2] if 11 + i in self.stepper_dacs]:
# Enable xyz steppers
shift_registers[0] &= ~1
if [i for i in [3, 4] if 11 + i in self.stepper_dacs]:
# Enable eh steppers
shift_registers[3] &= ~1
if (config.getboolean('standstill_power_down', False)
and self.stepper_dacs):
shift_registers[4] &= ~1
self.sr_enabled = tuple(reversed(shift_registers))
self.host_mcu.register_config_callback(self._build_config)
self.sr_oid = self.host_mcu.create_oid()
str_sr_disabled = "".join(["%02x" % (x, ) for x in self.sr_disabled])
self.host_mcu.add_config_cmd(
"config_spi_without_cs oid=%d bus=%d mode=0 rate=50000000"
" shutdown_msg=%s" %
(self.sr_oid, REPLICAPE_SHIFT_REGISTER_BUS, str_sr_disabled))
self.host_mcu.add_config_cmd("spi_send oid=%d data=%s" %
(self.sr_oid, str_sr_disabled),
is_init=True)
