class Servo(PluginBase, Ui_Servo):
qtcb_under_voltage = pyqtSignal(int)
def __init__(self, *args):
PluginBase.__init__(self, BrickServo, *args)
self.setupUi(self)
self.servo = self.device
# the firmware version of a Brick can (under common circumstances) not
# change during the lifetime of a Brick plugin. therefore, it's okay to
# make final decisions based on it here
self.has_status_led = self.firmware_version >= (2, 3, 1)
self.position_list = []
self.velocity_list = []
self.acceleration_list = []
self.enable_list = []
self.up_cur = 0
self.up_siv = 0
self.up_eiv = 0
self.up_opv = 0
self.up_mv = 0
self.up_ena = [0] * 7
self.up_pos = [0] * 7
self.up_vel = [0] * 7
self.up_acc = [0] * 7
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_apply)
self.update_timer.setInterval(50)
self.alive = True
for i in range(1, 8):
label = QLabel()
label.setText('Off')
self.enable_list.append(label)
self.status_grid.addWidget(label, i, 1)
for i in range(1, 8):
pk = PositionKnob()
self.position_list.append(pk)
self.status_grid.addWidget(pk, i, 2)
for i in range(1, 8):
cb = ColorBar(Qt.Vertical)
self.velocity_list.append(cb)
self.status_grid.addWidget(cb, i, 3)
for i in range(1, 8):
cb = ColorBar(Qt.Vertical)
self.acceleration_list.append(cb)
self.status_grid.addWidget(cb, i, 4)
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.test_button.clicked.connect(self.test_button_clicked)
self.output_voltage_button.clicked.connect(
self.output_voltage_button_clicked)
self.servo_dropbox.currentIndexChanged.connect(
lambda x: self.update_servo_specific())
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.position_syncer = SliderSpinSyncer(self.position_slider,
self.position_spin,
self.position_changed)
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.period_syncer = SliderSpinSyncer(self.period_slider,
self.period_spin,
self.period_changed)
self.pulse_width_min_spin.editingFinished.connect(
self.pulse_width_spin_finished)
self.pulse_width_max_spin.editingFinished.connect(
self.pulse_width_spin_finished)
self.degree_min_spin.editingFinished.connect(self.degree_spin_finished)
self.degree_max_spin.editingFinished.connect(self.degree_spin_finished)
self.minimum_voltage_button.clicked.connect(
self.minimum_voltage_button_clicked)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.servo.register_callback(self.servo.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
class WorkerThread(QThread):
def __init__(self, parent=None, func=None):
super().__init__(parent)
self.func = func
def run(self):
self.func()
self.test_event = Event()
self.test_thread_object = WorkerThread(self, self.test_thread)
self.update_event = Event()
self.update_thread_object = WorkerThread(self, self.update_thread)
self.update_thread_first_time = False
self.update_done_event = Event()
self.update_done_event.set()
if self.has_status_led:
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(
lambda checked: self.servo.enable_status_led()
if checked else self.servo.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
else:
self.status_led_action = None
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.servo.reset())
self.set_actions([(0, None, [reset])])
def start(self):
if self.has_status_led:
async_call(self.servo.is_status_led_enabled, None,
self.status_led_action.setChecked,
self.increase_error_count)
self.alive = True
self.test_event.clear()
self.update_done_event.set()
self.update_event.set()
if not self.test_thread_object.isRunning():
self.test_thread_object.start()
if not self.update_thread_object.isRunning():
self.update_thread_object.start()
self.update_servo_specific()
self.update_timer.start()
def stop(self):
if self.test_button.text().replace('&', '') == "Stop Test":
self.test_button_clicked()
self.update_timer.stop()
self.update_event.clear()
self.alive = False
self.update_done_event.wait()
def destroy(self):
self.test_event.set()
self.update_event.set()
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickServo.DEVICE_IDENTIFIER
def get_period_async(self, period):
self.period_spin.setValue(period)
self.period_slider.setValue(period)
def is_enabled_async(self, enabled):
self.enable_checkbox.setChecked(enabled)
def get_position_async(self, position):
self.position_spin.setValue(position)
self.position_slider.setValue(position)
def get_velocity_async(self, velocity):
self.velocity_spin.setValue(velocity)
self.velocity_slider.setValue(velocity)
def get_acceleration_async(self, acceleration):
self.acceleration_spin.setValue(acceleration)
self.acceleration_slider.setValue(acceleration)
def get_degree_async(self, servo, degree_min, degree_max):
self.degree_min_spin.setValue(degree_min)
self.degree_max_spin.setValue(degree_max)
self.position_slider.setMinimum(degree_min)
self.position_slider.setMaximum(degree_max)
self.position_spin.setMinimum(degree_min)
self.position_spin.setMaximum(degree_max)
self.position_list[servo].set_total_angle(
(degree_max - degree_min) / 100)
self.position_list[servo].set_range(degree_min / 100, degree_max / 100)
def get_pulse_width_async(self, pulse_width_min, pulse_width_max):
self.pulse_width_min_spin.setValue(pulse_width_min)
self.pulse_width_max_spin.setValue(pulse_width_max)
def update_servo_specific(self):
servo = self.selected_servo()
if servo == 255:
self.enable_checkbox.setChecked(False)
return
async_call(self.servo.get_position, servo, self.get_position_async,
self.increase_error_count)
async_call(self.servo.get_velocity, servo, self.get_velocity_async,
self.increase_error_count)
async_call(self.servo.get_acceleration, servo,
self.get_acceleration_async, self.increase_error_count)
async_call(self.servo.get_period, servo, self.get_period_async,
self.increase_error_count)
async_call(self.servo.is_enabled, servo, self.is_enabled_async,
self.increase_error_count)
async_call(self.servo.get_degree,
servo,
self.get_degree_async,
self.increase_error_count,
pass_arguments_to_result_callback=True,
expand_result_tuple_for_callback=True)
async_call(self.servo.get_pulse_width,
servo,
self.get_pulse_width_async,
self.increase_error_count,
expand_result_tuple_for_callback=True)
def servo_current_update(self, value):
self.current_label.setText(str(value) + "mA")
def stack_input_voltage_update(self, sv):
sv_str = "%gV" % round(sv / 1000.0, 1)
self.stack_voltage_label.setText(sv_str)
def external_input_voltage_update(self, ev):
ev_str = "%gV" % round(ev / 1000.0, 1)
self.external_voltage_label.setText(ev_str)
def output_voltage_update(self, ov):
ov_str = "%gV" % round(ov / 1000.0, 1)
self.output_voltage_label.setText(ov_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv / 1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def position_update(self, servo, position):
self.position_list[servo].set_value(position / 100)
def velocity_update(self, servo, velocity):
self.velocity_list[servo].set_height(velocity * 100 // 0xFFFF)
def acceleration_update(self, servo, acceleration):
self.acceleration_list[servo].set_height(acceleration * 100 // 0xFFFF)
def deactivate_servo(self, servo):
if self.enable_list[servo].text().replace('&', '') != 'Off':
self.velocity_list[servo].grey()
self.acceleration_list[servo].grey()
def activate_servo(self, servo):
if self.enable_list[servo].text().replace('&', '') != 'On':
self.velocity_list[servo].color()
self.acceleration_list[servo].color()
def selected_servo(self):
try:
return int(self.servo_dropbox.currentText()[-1:])
except:
return 255
def enable_state_changed(self, state):
servo = self.selected_servo()
try:
if state == Qt.Checked:
self.servo.enable(servo)
elif state == Qt.Unchecked:
self.servo.disable(servo)
except ip_connection.Error:
return
def update_apply(self):
if not self.update_thread_first_time:
return
self.servo_current_update(self.up_cur)
self.stack_input_voltage_update(self.up_siv)
self.external_input_voltage_update(self.up_eiv)
self.output_voltage_update(self.up_opv)
self.minimum_voltage_update(self.up_mv)
for i in range(7):
if self.up_ena[i]:
self.activate_servo(i)
self.position_update(i, self.up_pos[i])
self.velocity_update(i, self.up_vel[i])
self.acceleration_update(i, self.up_acc[i])
self.enable_list[i].setText('On')
else:
self.deactivate_servo(i)
self.enable_list[i].setText('Off')
def update_thread(self):
while self.alive:
time.sleep(0.1)
try:
servo = self.selected_servo()
if servo == 255:
self.up_cur = self.servo.get_overall_current()
else:
self.up_cur = self.servo.get_servo_current(servo)
self.up_siv = self.servo.get_stack_input_voltage()
self.up_eiv = self.servo.get_external_input_voltage()
self.up_opv = self.servo.get_output_voltage()
self.up_mv = self.servo.get_minimum_voltage()
for i in range(7):
self.up_ena[i] = self.servo.is_enabled(i)
if self.up_ena[i]:
self.activate_servo(i)
self.up_pos[i] = self.servo.get_current_position(i)
self.up_vel[i] = self.servo.get_current_velocity(i)
self.up_acc[i] = self.servo.get_acceleration(i)
self.update_done_event.set()
self.update_event.wait()
self.update_done_event.clear()
except ip_connection.Error:
pass
self.update_thread_first_time = True
self.update_done_event.set()
def test_thread(self):
def test(num, ena, acc, vel, pos):
if not self.alive:
return
try:
if ena:
self.servo.enable(num)
else:
self.servo.disable(num)
self.servo.set_acceleration(num, acc)
self.servo.set_velocity(num, vel)
self.servo.set_position(num, pos)
except ip_connection.Error:
return
def random_test():
for i in range(7):
test(i, random.randrange(0, 2), random.randrange(0, 65536),
random.randrange(0, 65536), random.randrange(-9000, 9001))
while self.alive:
self.test_event.wait()
if not self.alive:
return
# Full Speed left for 2 seconds
for i in range(7):
test(i, True, 65535, 65535, 9000)
time.sleep(2)
self.test_event.wait()
if not self.alive:
return
# Full Speed right for 2 seconds
for i in range(7):
test(i, True, 65535, 65535, -9000)
time.sleep(2)
self.test_event.wait()
if not self.alive:
return
# Test different speeds
for i in range(19):
for j in range(7):
test(j, True, 65535, 65535 * i / 18, -9000 + i * 1000)
time.sleep(0.1)
self.test_event.wait()
if not self.alive:
return
time.sleep(1)
self.test_event.wait()
if not self.alive:
return
# Test acceleration
for i in range(7):
test(i, True, 100, 65535, -9000)
time.sleep(3)
self.test_event.wait()
if not self.alive:
return
# Random for 3 seconds
random_test()
time.sleep(3)
def test_button_clicked(self):
if self.test_button.text().replace('&', '') == "Start Test":
self.test_button.setText("Stop Test")
self.test_event.set()
else:
self.test_button.setText("Start Test")
self.test_event.clear()
def output_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setWindowTitle('Servo Brick')
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(2000)
qid.setIntMaximum(9000)
qid.setIntStep(100)
async_call(self.servo.get_output_voltage, None, qid.setIntValue,
self.increase_error_count)
qid.intValueSelected.connect(self.output_voltage_selected)
qid.setLabelText("Choose Output Voltage in mV:")
qid.open()
def output_voltage_selected(self, value):
try:
self.servo.set_output_voltage(value)
except ip_connection.Error:
return
def position_changed(self, value):
try:
self.servo.set_position(self.selected_servo(), value)
except ip_connection.Error:
return
def velocity_changed(self, value):
try:
self.servo.set_velocity(self.selected_servo(), value)
except ip_connection.Error:
return
def acceleration_changed(self, value):
try:
self.servo.set_acceleration(self.selected_servo(), value)
except ip_connection.Error:
return
def period_changed(self, value):
try:
self.servo.set_period(self.selected_servo(), value)
except ip_connection.Error:
return
def pulse_width_spin_finished(self):
try:
self.servo.set_pulse_width(self.selected_servo(),
self.pulse_width_min_spin.value(),
self.pulse_width_max_spin.value())
except ip_connection.Error:
return
def degree_spin_finished(self):
degree_min = self.degree_min_spin.value()
degree_max = self.degree_max_spin.value()
servo = self.selected_servo()
self.position_slider.setMinimum(degree_min)
self.position_slider.setMaximum(degree_max)
self.position_spin.setMinimum(degree_min)
self.position_spin.setMaximum(degree_max)
if servo == 255:
for i in range(7):
self.position_list[i].set_total_angle(
(degree_max - degree_min) / 100)
self.position_list[i].set_range(degree_min / 100,
degree_max / 100)
else:
self.position_list[servo].set_total_angle(
(degree_max - degree_min) / 100)
self.position_list[servo].set_range(degree_min / 100,
degree_max / 100)
try:
self.servo.set_degree(servo, degree_min, degree_max)
except ip_connection.Error:
return
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov / 1000.0, 1)
if not self.qem.isVisible():
self.qem.showMessage(
"Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str, "Servo_UnterVoltage")
def minimum_voltage_selected(self, value):
try:
self.servo.set_minimum_voltage(value)
except ip_connection.Error:
return
def minimum_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setWindowTitle('Servo Brick')
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(5000)
qid.setIntMaximum(0xFFFF)
qid.setIntStep(100)
async_call(self.servo.get_minimum_voltage, None, qid.setIntValue,
self.increase_error_count)
qid.intValueSelected.connect(self.minimum_voltage_selected)
qid.setLabelText("Choose Minimum Servo Voltage in mV:")
qid.open()
class DC(PluginBase, Ui_DC):
qtcb_velocity_reached = pyqtSignal(int)
qtcb_under_voltage = pyqtSignal(int)
qtcb_emergency_shutdown = pyqtSignal()
def __init__(self, *args):
PluginBase.__init__(self, BrickDC, *args)
self.setupUi(self)
self.dc = self.device
# the firmware version of a Brick can (under common circumstances) not
# change during the lifetime of a Brick plugin. therefore, it's okay to
# make final decisions based on it here
self.has_status_led = self.firmware_version >= (2, 3, 1)
self.encoder_hide_all()
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.frequency_syncer = SliderSpinSyncer(self.frequency_slider,
self.frequency_spin,
self.frequency_changed)
self.radio_mode_brake.toggled.connect(self.brake_value_changed)
self.radio_mode_coast.toggled.connect(self.coast_value_changed)
self.minimum_voltage_button.clicked.connect(
self.minimum_voltage_button_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.emergency_signal = None
self.under_signal = None
self.current_velocity_signal = None
self.velocity_reached_signal = None
self.qem = QErrorMessage(self)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.dc.register_callback(self.dc.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
self.qtcb_emergency_shutdown.connect(self.cb_emergency_shutdown)
self.dc.register_callback(self.dc.CALLBACK_EMERGENCY_SHUTDOWN,
self.qtcb_emergency_shutdown.emit)
self.qtcb_velocity_reached.connect(self.update_velocity)
self.dc.register_callback(self.dc.CALLBACK_VELOCITY_REACHED,
self.qtcb_velocity_reached.emit)
self.cbe_current_velocity = CallbackEmulator(
self.dc.get_current_velocity, None, self.update_velocity,
self.increase_error_count)
if self.has_status_led:
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(
lambda checked: self.dc.enable_status_led()
if checked else self.dc.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
else:
self.status_led_action = None
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.dc.reset())
self.set_actions([(0, None, [reset])])
def start(self):
if self.has_status_led:
async_call(self.dc.is_status_led_enabled, None,
self.status_led_action.setChecked,
self.increase_error_count)
self.update_timer.start(1000)
self.cbe_current_velocity.set_period(100)
self.update_start()
self.update_data()
def stop(self):
self.update_timer.stop()
self.cbe_current_velocity.set_period(0)
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickDC.DEVICE_IDENTIFIER
def cb_emergency_shutdown(self):
if not self.qem.isVisible():
self.qem.setWindowTitle("Emergency Shutdown")
self.qem.showMessage(
"Emergency Shutdown: Short-Circuit or Over-Temperature")
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov / 1000.0, 1)
if not self.qem.isVisible():
self.qem.setWindowTitle("Under Voltage")
self.qem.showMessage(
"Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str, "DC_UnderVoltage")
def encoder_hide_all(self):
self.enable_encoder_checkbox.hide()
self.encoder_hide()
def encoder_hide(self):
self.p_label.hide()
self.p_spinbox.hide()
self.i_label.hide()
self.i_spinbox.hide()
self.d_label.hide()
self.d_spinbox.hide()
self.st_label.hide()
self.st_spinbox.hide()
self.cpr_label.hide()
self.cpr_spinbox.hide()
self.encoder_spacer.hide()
def encoder_show(self):
self.p_label.show()
self.p_spinbox.show()
self.i_label.show()
self.i_spinbox.show()
self.d_label.show()
self.d_spinbox.show()
self.st_label.show()
self.st_spinbox.show()
self.cpr_label.show()
self.cpr_spinbox.show()
self.encoder_spacer.show()
def enable_encoder_state_changed(self, state):
try:
if state == Qt.Checked:
self.dc.enable_encoder()
self.update_encoder()
elif state == Qt.Unchecked:
self.dc.disable_encoder()
except ip_connection.Error:
return
def enable_state_changed(self, state):
try:
if state == Qt.Checked:
self.dc.enable()
elif state == Qt.Unchecked:
self.dc.disable()
except ip_connection.Error:
return
def brake_value_changed(self, checked):
if checked:
try:
self.dc.set_drive_mode(0)
except ip_connection.Error:
return
def coast_value_changed(self, checked):
if checked:
try:
self.dc.set_drive_mode(1)
except ip_connection.Error:
return
def full_brake_clicked(self):
try:
self.dc.full_brake()
except ip_connection.Error:
return
def minimum_voltage_selected(self, value):
try:
self.dc.set_minimum_voltage(value)
except ip_connection.Error:
return
def minimum_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(5000)
qid.setIntMaximum(0xFFFF)
qid.setIntStep(100)
async_call(self.dc.get_minimum_voltage, None, qid.setIntValue,
self.increase_error_count)
qid.intValueSelected.connect(self.minimum_voltage_selected)
qid.setLabelText("Choose minimum motor voltage in mV.")
qid.open()
def stack_input_voltage_update(self, sv):
sv_str = "%gV" % round(sv / 1000.0, 1)
self.stack_voltage_label.setText(sv_str)
def external_input_voltage_update(self, ev):
ev_str = "%gV" % round(ev / 1000.0, 1)
self.external_voltage_label.setText(ev_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv / 1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def drive_mode_update(self, dm):
if dm == 0:
self.radio_mode_brake.setChecked(True)
self.radio_mode_coast.setChecked(False)
else:
self.radio_mode_brake.setChecked(False)
self.radio_mode_coast.setChecked(True)
def current_consumption_update(self, cc):
if cc >= 1000:
cc_str = "%gA" % round(cc / 1000.0, 1)
else:
cc_str = "%gmA" % cc
self.current_label.setText(cc_str)
def update_velocity(self, velocity):
self.speedometer.set_velocity(velocity)
self.current_velocity_label.setText('{0} ({1}%)'.format(
velocity, round(abs(velocity) * 100 / 32768.0, 1)))
def get_velocity_async(self, velocity):
self.velocity_syncer.set_value(velocity)
self.update_velocity(velocity)
def get_acceleration_async(self, acceleration):
self.acceleration_syncer.set_value(acceleration)
def get_pwm_frequency_async(self, frequency):
self.frequency_syncer.set_value(frequency)
def is_enabled_async(self, enabled):
self.enable_checkbox.setChecked(enabled)
def is_encoder_enabled_async(self, enabled):
self.enable_encoder_checkbox.setChecked(enabled)
def get_encoder_config_async(self, cpr):
self.cpr_spinbox.setValue(cpr)
def get_encoder_pid_config_async(self, pid_config):
self.p_spinbox.setValue(pid_config.p)
self.i_spinbox.setValue(pid_config.i)
self.d_spinbox.setValue(pid_config.d)
self.st_spinbox.setValue(pid_config.sample_time)
def update_encoder(self):
async_call(self.dc.get_encoder_config, None,
self.get_encoder_config_async, self.increase_error_count)
async_call(self.dc.get_encoder_pid_config, None,
self.get_encoder_pid_config_async,
self.increase_error_count)
async_call(self.dc.is_encoder_enabled, None,
self.is_encoder_enabled_async, self.increase_error_count)
def update_start(self):
async_call(self.dc.get_drive_mode, None, self.drive_mode_update,
self.increase_error_count)
async_call(self.dc.get_velocity, None, self.get_velocity_async,
self.increase_error_count)
async_call(self.dc.get_acceleration, None, self.get_acceleration_async,
self.increase_error_count)
async_call(self.dc.get_pwm_frequency, None,
self.get_pwm_frequency_async, self.increase_error_count)
async_call(self.dc.is_enabled, None, self.is_enabled_async,
self.increase_error_count)
def update_data(self):
async_call(self.dc.get_stack_input_voltage, None,
self.stack_input_voltage_update, self.increase_error_count)
async_call(self.dc.get_external_input_voltage, None,
self.external_input_voltage_update,
self.increase_error_count)
async_call(self.dc.get_minimum_voltage, None,
self.minimum_voltage_update, self.increase_error_count)
async_call(self.dc.get_current_consumption, None,
self.current_consumption_update, self.increase_error_count)
def acceleration_changed(self, value):
try:
self.dc.set_acceleration(value)
except ip_connection.Error:
return
def velocity_changed(self, value):
try:
self.dc.set_velocity(value)
except ip_connection.Error:
return
def frequency_changed(self, value):
try:
self.dc.set_pwm_frequency(value)
except ip_connection.Error:
return
class DCV2(COMCUPluginBase, Ui_DCV2):
qtcb_emergency_shutdown = pyqtSignal()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletDCV2, *args)
self.setupUi(self)
self.dc = self.device
self.qem = QErrorMessage(self)
self.qtcb_emergency_shutdown.connect(self.cb_emergency_shutdown)
self.dc.register_callback(self.dc.CALLBACK_EMERGENCY_SHUTDOWN,
self.qtcb_emergency_shutdown.emit)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.radio_mode_brake.toggled.connect(self.brake_value_changed)
self.radio_mode_coast.toggled.connect(self.coast_value_changed)
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.motion_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.motion_changed)
self.frequency_syncer = SliderSpinSyncer(self.frequency_slider,
self.frequency_spin,
self.frequency_changed)
self.cbe_power_statistics = CallbackEmulator(
self, self.dc.get_power_statistics, None,
self.get_power_statistics_async, self.increase_error_count)
self.cbe_current_velocity = CallbackEmulator(
self, self.dc.get_current_velocity, None,
self.get_current_velocity_async, self.increase_error_count)
def start(self):
async_call(self.dc.get_drive_mode, None, self.get_drive_mode_async,
self.increase_error_count)
async_call(self.dc.get_velocity, None, self.get_velocity_async,
self.increase_error_count)
async_call(self.dc.get_motion, None, self.get_motion_async,
self.increase_error_count)
async_call(self.dc.get_pwm_frequency, None,
self.get_pwm_frequency_async, self.increase_error_count)
async_call(self.dc.get_enabled, None, self.get_enabled_async,
self.increase_error_count)
self.cbe_power_statistics.set_period(100)
self.cbe_current_velocity.set_period(50)
def stop(self):
self.cbe_power_statistics.set_period(0)
self.cbe_current_velocity.set_period(0)
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletDCV2.DEVICE_IDENTIFIER
def cb_emergency_shutdown(self):
# Refresh enabled checkbox in case of emergency shutdown
async_call(self.dc.get_enabled, None, self.get_enabled_async,
self.increase_error_count)
if not self.qem.isVisible():
self.qem.setWindowTitle("Emergency Shutdown")
self.qem.showMessage(
"Emergency Shutdown: Short-Circuit or Over-Temperature or Under-Voltage"
)
def brake_value_changed(self, checked):
if checked:
try:
self.dc.set_drive_mode(0)
except ip_connection.Error:
return
def coast_value_changed(self, checked):
if checked:
try:
self.dc.set_drive_mode(1)
except ip_connection.Error:
return
def full_brake_clicked(self):
try:
self.dc.full_brake()
self.velocity_syncer.set_value(0)
except ip_connection.Error:
return
def get_drive_mode_async(self, dm):
if dm == 0:
self.radio_mode_brake.setChecked(True)
self.radio_mode_coast.setChecked(False)
else:
self.radio_mode_brake.setChecked(False)
self.radio_mode_coast.setChecked(True)
def get_power_statistics_async(self, ps):
if ps.current >= 1000:
current_str = "{0}A".format(round(ps.current / 1000.0, 1))
else:
current_str = "{0}mA".format(ps.current)
if ps.voltage >= 1000:
voltage_str = "{0}V".format(round(ps.voltage / 1000.0, 1))
else:
voltage_str = "{0}mV".format(ps.voltage)
self.current_label.setText(current_str)
self.input_voltage_label.setText(voltage_str)
def get_current_velocity_async(self, velocity):
self.speedometer.set_velocity(velocity)
self.current_velocity_label.setText('{0} ({1}%)'.format(
velocity, round(abs(velocity) * 100 / 32768.0, 1)))
def get_velocity_async(self, velocity):
self.velocity_syncer.set_value(velocity)
def get_motion_async(self, motion):
self.acceleration_syncer.set_value(motion.acceleration)
self.deceleration_syncer.set_value(motion.deceleration)
def get_pwm_frequency_async(self, frequency):
self.frequency_syncer.set_value(frequency)
def get_enabled_async(self, enabled):
self.enable_checkbox.setChecked(enabled)
def enable_state_changed(self, state):
try:
self.dc.set_enabled(state == Qt.Checked)
except ip_connection.Error:
return
def motion_changed(self, _):
acceleration = self.acceleration_spin.value()
deceleration = self.deceleration_spin.value()
try:
self.dc.set_motion(acceleration, deceleration)
except ip_connection.Error:
return
def velocity_changed(self, value):
try:
self.dc.set_velocity(value)
except ip_connection.Error:
return
def frequency_changed(self, value):
try:
self.dc.set_pwm_frequency(value)
except ip_connection.Error:
return
class SilentStepper(PluginBase, Ui_SilentStepper):
qtcb_position_reached = pyqtSignal(int)
qtcb_under_voltage = pyqtSignal(int)
def __init__(self, *args):
PluginBase.__init__(self, BrickSilentStepper, *args)
self.setupUi(self)
self.silent_stepper = self.device
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.speedometer = SpeedoMeter()
self.vertical_layout_right.insertWidget(5, self.speedometer)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
# Step Configuration
self.step_resolution_dropbox.currentIndexChanged.connect(self.step_configuration_changed)
self.interpolate_checkbox.stateChanged.connect(self.step_configuration_changed)
# Basic Configuration
self.standstill_current_spin.valueChanged.connect(self.basic_configuration_changed)
self.motor_run_current_spin.valueChanged.connect(self.basic_configuration_changed)
self.standstill_delay_time_spin.valueChanged.connect(self.basic_configuration_changed)
self.power_down_time_spin.valueChanged.connect(self.basic_configuration_changed)
self.stealth_threshold_spin.valueChanged.connect(self.basic_configuration_changed)
self.coolstep_threashold_spin.valueChanged.connect(self.basic_configuration_changed)
self.classic_threshold_spin.valueChanged.connect(self.basic_configuration_changed)
self.high_velocity_chopper_mode_checkbox.stateChanged.connect(self.basic_configuration_changed)
# Spreadcycle Configuration
self.slow_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.enable_random_slow_decay_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed)
self.fast_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.hysteresis_start_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.hysteresis_end_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.sine_wave_offset_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.chopper_mode_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed)
self.comparator_blank_time_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed)
self.fast_decay_without_comparator_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed)
# Stealth Configuration
self.enable_stealth_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.amplitude_spin.valueChanged.connect(self.stealth_configuration_changed)
self.gradient_spin.valueChanged.connect(self.stealth_configuration_changed)
self.enable_autoscale_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.force_symmetric_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.freewheel_mode_combo.currentIndexChanged.connect(self.stealth_configuration_changed)
# Coolstep Configuration
self.minimum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.maximum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.current_up_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.current_down_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.minimum_current_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.stallguard_threshold_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.stallguard_mode_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
# Misc Configuration
self.disable_short_to_ground_protection_checkbox.stateChanged.connect(self.misc_configuration_changed)
self.synchronize_phase_frequency_spin.valueChanged.connect(self.misc_configuration_changed)
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(lambda checked: self.silent_stepper.enable_status_led() if checked else self.silent_stepper.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.silent_stepper.reset())
self.set_actions([(0, None, [reset])])
def start(self):
async_call(self.silent_stepper.is_status_led_enabled, None, self.status_led_action.setChecked, self.increase_error_count)
self.update_timer.start(100)
self.update_start()
def stop(self):
self.update_timer.stop()
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickSilentStepper.DEVICE_IDENTIFIER
def cb_position_reached(self, position):
self.position_update(position)
self.endis_all(True)
def disable_list(self, button_list):
for button in button_list:
button.setEnabled(False)
def endis_all(self, value):
self.forward_button.setEnabled(value)
self.stop_button.setEnabled(value)
self.backward_button.setEnabled(value)
self.to_button.setEnabled(value)
self.steps_button.setEnabled(value)
self.full_brake_button.setEnabled(value)
def step_configuration_changed(self, _):
step_resolution = self.step_resolution_dropbox.currentIndex()
interpolation = self.interpolate_checkbox.isChecked()
try:
self.silent_stepper.set_step_configuration(step_resolution, interpolation)
except ip_connection.Error:
return
def basic_configuration_changed(self, _):
standstill_current = self.standstill_current_spin.value()
motor_run_current = self.motor_run_current_spin.value()
standstill_delay_time = self.standstill_delay_time_spin.value()
power_down_time = self.power_down_time_spin.value()
stealth_threshold = self.stealth_threshold_spin.value()
coolstep_threshold = self.coolstep_threashold_spin.value()
classic_threshold = self.classic_threshold_spin.value()
high_velocity_chopper_mode = self.high_velocity_chopper_mode_checkbox.isChecked()
try:
self.silent_stepper.set_basic_configuration(standstill_current, motor_run_current, standstill_delay_time, power_down_time, stealth_threshold, coolstep_threshold, classic_threshold, high_velocity_chopper_mode)
except ip_connection.Error:
return
def spreadcycle_configuration_changed(self, _):
slow_decay_duration = self.slow_decay_duration_spin.value()
enable_random_slow_decay = self.enable_random_slow_decay_checkbox.isChecked()
fast_decay_duration = self.fast_decay_duration_spin.value()
hysteresis_start_value = self.hysteresis_start_value_spin.value()
hysteresis_end_value = self.hysteresis_end_value_spin.value()
sine_wave_offset = self.sine_wave_offset_spin.value()
chopper_mode = self.chopper_mode_combo.currentIndex()
comparator_blank_time = self.comparator_blank_time_combo.currentIndex()
fast_decay_without_comparator = self.fast_decay_without_comparator_checkbox.isChecked()
try:
self.silent_stepper.set_spreadcycle_configuration(slow_decay_duration, enable_random_slow_decay, fast_decay_duration, hysteresis_start_value, hysteresis_end_value, sine_wave_offset, chopper_mode, comparator_blank_time, fast_decay_without_comparator)
except ip_connection.Error:
return
def stealth_configuration_changed(self, _):
enable_stealth = self.enable_stealth_checkbox.isChecked()
amplitude = self.amplitude_spin.value()
gradient = self.gradient_spin.value()
enable_autoscale = self.enable_autoscale_checkbox.isChecked()
force_symmetric = self.force_symmetric_checkbox.isChecked()
freewheel_mode = self.freewheel_mode_combo.currentIndex()
try:
self.silent_stepper.set_stealth_configuration(enable_stealth, amplitude, gradient, enable_autoscale, force_symmetric, freewheel_mode)
except ip_connection.Error:
return
def coolstep_configuration_changed(self, _):
minimum_stallguard_value = self.minimum_stallguard_value_spin.value()
maximum_stallguard_value = self.maximum_stallguard_value_spin.value()
current_up_step_width = self.current_up_step_width_combo.currentIndex()
current_down_step_width = self.current_down_step_width_combo.currentIndex()
minimum_current = self.minimum_current_combo.currentIndex()
stallguard_threshold_value = self.stallguard_threshold_value_spin.value()
stallguard_mode = self.stallguard_mode_combo.currentIndex()
try:
self.silent_stepper.set_coolstep_configuration(minimum_stallguard_value, maximum_stallguard_value, current_up_step_width, current_down_step_width, minimum_current, stallguard_threshold_value, stallguard_mode)
except ip_connection.Error:
return
def misc_configuration_changed(self, _):
disable_short_to_ground_protection = self.disable_short_to_ground_protection_checkbox.isChecked()
synchronize_phase_frequency = self.synchronize_phase_frequency_spin.value()
try:
self.silent_stepper.set_misc_configuration(disable_short_to_ground_protection, synchronize_phase_frequency)
except ip_connection.Error:
return
def forward_clicked(self):
try:
self.silent_stepper.drive_forward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def backward_clicked(self):
try:
self.silent_stepper.drive_backward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def stop_clicked(self):
try:
self.silent_stepper.stop()
except ip_connection.Error:
return
self.endis_all(True)
def full_brake_clicked(self):
try:
self.silent_stepper.full_brake()
except ip_connection.Error:
return
self.endis_all(True)
def to_button_clicked(self):
drive_to = self.to_spin.value()
try:
self.silent_stepper.set_target_position(drive_to)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def steps_button_clicked(self):
drive_steps = self.steps_spin.value()
try:
self.silent_stepper.set_steps(drive_steps)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def motor_current_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(360)
qid.setIntMaximum(1640)
qid.setIntStep(100)
async_call(self.silent_stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.motor_current_selected)
qid.setLabelText("Choose motor current in mA.")
qid.open()
def minimum_motor_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(40000)
qid.setIntStep(100)
async_call(self.silent_stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.minimum_motor_voltage_selected)
qid.setLabelText("Choose minimum motor voltage in mV.")
qid.open()
def motor_current_selected(self, value):
try:
self.silent_stepper.set_motor_current(value)
except ip_connection.Error:
return
def minimum_motor_voltage_selected(self, value):
try:
self.silent_stepper.set_minimum_voltage(value)
except ip_connection.Error:
return
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov/1000.0, 1)
if not self.qem.isVisible():
self.qem.showMessage("Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str,
"SilentStepper_UnderVoltage")
def enable_state_changed(self, state):
try:
if state == Qt.Checked:
self.endis_all(True)
self.silent_stepper.enable()
elif state == Qt.Unchecked:
self.endis_all(False)
self.silent_stepper.disable()
except ip_connection.Error:
return
def stack_input_voltage_update(self, sv):
sv_str = "%gV" % round(sv/1000.0, 1)
self.stack_voltage_label.setText(sv_str)
def external_input_voltage_update(self, ev):
ev_str = "%gV" % round(ev/1000.0, 1)
self.external_voltage_label.setText(ev_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv/1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def maximum_current_update(self, cur):
cur_str = "%gA" % round(cur/1000.0, 1)
self.maximum_current_label.setText(cur_str)
def position_update(self, pos):
pos_str = "%d" % pos
self.position_label.setText(pos_str)
def remaining_steps_update(self, ste):
ste_str = "%d" % ste
self.remaining_steps_label.setText(ste_str)
def driver_status_update(self, update):
if update.open_load == 0:
self.status_open_load.setText('No')
elif update.open_load == 1:
self.status_open_load.setText('Phase A')
elif update.open_load == 2:
self.status_open_load.setText('Phase B')
elif update.open_load == 3:
self.status_open_load.setText('Phase A and B')
else:
self.status_open_load.setText('Unknown')
if update.short_to_ground == 0:
self.status_short_to_ground.setText('No')
elif update.short_to_ground == 1:
self.status_short_to_ground.setText('Phase A')
elif update.short_to_ground == 2:
self.status_short_to_ground.setText('Phase B')
elif update.short_to_ground == 3:
self.status_short_to_ground.setText('Phase A and B')
else:
self.status_short_to_ground.setText('Unknown')
if update.over_temperature == 0:
self.status_over_temperature.setText('No')
elif update.over_temperature == 1:
self.status_over_temperature.setText('<font color=yellow>Warning</font>')
elif update.over_temperature == 2:
self.status_over_temperature.setText('<font color=red>Limit</font>')
if update.motor_stalled:
self.status_motor_stalled.setText('Yes')
else:
self.status_motor_stalled.setText('No')
self.status_actual_motor_current.setText(str(update.actual_motor_current))
if update.full_step_active:
self.status_full_step_active.setText('Yes')
else:
self.status_full_step_active.setText('No')
self.status_stallguard_result.setText(str(update.stallguard_result))
self.status_stealth_voltage_amplitude.setText(str(update.stealth_voltage_amplitude))
def get_max_velocity_async(self, velocity):
if not self.velocity_slider.isSliderDown():
if velocity != self.velocity_slider.sliderPosition():
self.velocity_slider.setSliderPosition(velocity)
self.velocity_spin.setValue(velocity)
def get_speed_ramping_async(self, ramp):
acc, dec = ramp
if not self.acceleration_slider.isSliderDown() and \
not self.deceleration_slider.isSliderDown():
if acc != self.acceleration_slider.sliderPosition():
self.acceleration_slider.setSliderPosition(acc)
self.acceleration_spin.setValue(acc)
if dec != self.deceleration_slider.sliderPosition():
self.deceleration_slider.setSliderPosition(dec)
self.deceleration_spin.setValue(dec)
def is_enabled_async(self, enabled):
if enabled:
if not self.enable_checkbox.isChecked():
self.endis_all(True)
self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(True)
self.enable_checkbox.blockSignals(False)
else:
if self.enable_checkbox.isChecked():
self.endis_all(False)
self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(False)
self.enable_checkbox.blockSignals(False)
def get_step_configuration_async(self, conf):
self.step_resolution_dropbox.blockSignals(True)
self.step_resolution_dropbox.setCurrentIndex(conf.step_resolution)
self.step_resolution_dropbox.blockSignals(False)
self.interpolate_checkbox.blockSignals(True)
self.interpolate_checkbox.setChecked(conf.interpolation)
self.interpolate_checkbox.blockSignals(False)
def get_basic_configuration_async(self, conf):
self.standstill_current_spin.blockSignals(True)
self.standstill_current_spin.setValue(conf.standstill_current)
self.standstill_current_spin.blockSignals(False)
self.motor_run_current_spin.blockSignals(True)
self.motor_run_current_spin.setValue(conf.motor_run_current)
self.motor_run_current_spin.blockSignals(False)
self.standstill_delay_time_spin.blockSignals(True)
self.standstill_delay_time_spin.setValue(conf.standstill_delay_time)
self.standstill_delay_time_spin.blockSignals(False)
self.power_down_time_spin.blockSignals(True)
self.power_down_time_spin.setValue(conf.power_down_time)
self.power_down_time_spin.blockSignals(False)
self.stealth_threshold_spin.blockSignals(True)
self.stealth_threshold_spin.setValue(conf.stealth_threshold)
self.stealth_threshold_spin.blockSignals(False)
self.coolstep_threashold_spin.blockSignals(True)
self.coolstep_threashold_spin.setValue(conf.coolstep_threshold)
self.coolstep_threashold_spin.blockSignals(False)
self.classic_threshold_spin.blockSignals(True)
self.classic_threshold_spin.setValue(conf.classic_threshold)
self.classic_threshold_spin.blockSignals(False)
self.high_velocity_chopper_mode_checkbox.blockSignals(True)
self.high_velocity_chopper_mode_checkbox.setChecked(conf.high_velocity_chopper_mode)
self.high_velocity_chopper_mode_checkbox.blockSignals(False)
def get_spreadcycle_configuration_async(self, conf):
self.slow_decay_duration_spin.blockSignals(True)
self.slow_decay_duration_spin.setValue(conf.slow_decay_duration)
self.slow_decay_duration_spin.blockSignals(False)
self.enable_random_slow_decay_checkbox.blockSignals(True)
self.enable_random_slow_decay_checkbox.setChecked(conf.enable_random_slow_decay)
self.enable_random_slow_decay_checkbox.blockSignals(False)
self.fast_decay_duration_spin.blockSignals(True)
self.fast_decay_duration_spin.setValue(conf.fast_decay_duration)
self.fast_decay_duration_spin.blockSignals(False)
self.hysteresis_start_value_spin.blockSignals(True)
self.hysteresis_start_value_spin.setValue(conf.hysteresis_start_value)
self.hysteresis_start_value_spin.blockSignals(False)
self.hysteresis_end_value_spin.blockSignals(True)
self.hysteresis_end_value_spin.setValue(conf.hysteresis_end_value)
self.hysteresis_end_value_spin.blockSignals(False)
self.sine_wave_offset_spin.blockSignals(True)
self.sine_wave_offset_spin.setValue(conf.sine_wave_offset)
self.sine_wave_offset_spin.blockSignals(False)
self.chopper_mode_combo.blockSignals(True)
self.chopper_mode_combo.setCurrentIndex(conf.chopper_mode)
self.chopper_mode_combo.blockSignals(False)
self.standstill_current_spin.blockSignals(True)
self.comparator_blank_time_combo.setCurrentIndex(conf.comparator_blank_time)
self.standstill_current_spin.blockSignals(False)
self.fast_decay_without_comparator_checkbox.blockSignals(True)
self.fast_decay_without_comparator_checkbox.setChecked(conf.fast_decay_without_comparator)
self.fast_decay_without_comparator_checkbox.blockSignals(False)
def get_stealth_configuration_async(self, conf):
self.enable_stealth_checkbox.blockSignals(True)
self.enable_stealth_checkbox.setChecked(conf.enable_stealth)
self.enable_stealth_checkbox.blockSignals(False)
self.amplitude_spin.blockSignals(True)
self.amplitude_spin.setValue(conf.amplitude)
self.amplitude_spin.blockSignals(False)
self.gradient_spin.blockSignals(True)
self.gradient_spin.setValue(conf.gradient)
self.gradient_spin.blockSignals(False)
self.enable_autoscale_checkbox.blockSignals(True)
self.enable_autoscale_checkbox.setChecked(conf.enable_autoscale)
self.enable_autoscale_checkbox.blockSignals(False)
self.force_symmetric_checkbox.blockSignals(True)
self.force_symmetric_checkbox.setChecked(conf.force_symmetric)
self.force_symmetric_checkbox.blockSignals(False)
self.freewheel_mode_combo.blockSignals(True)
self.freewheel_mode_combo.setCurrentIndex(conf.freewheel_mode)
self.freewheel_mode_combo.blockSignals(False)
def get_coolstep_configuration_async(self, conf):
self.minimum_stallguard_value_spin.blockSignals(True)
self.minimum_stallguard_value_spin.setValue(conf.minimum_stallguard_value)
self.minimum_stallguard_value_spin.blockSignals(False)
self.maximum_stallguard_value_spin.blockSignals(True)
self.maximum_stallguard_value_spin.setValue(conf.maximum_stallguard_value)
self.maximum_stallguard_value_spin.blockSignals(False)
self.current_up_step_width_combo.blockSignals(True)
self.current_up_step_width_combo.setCurrentIndex(conf.current_up_step_width)
self.current_up_step_width_combo.blockSignals(False)
self.current_down_step_width_combo.blockSignals(True)
self.current_down_step_width_combo.setCurrentIndex(conf.current_down_step_width)
self.current_down_step_width_combo.blockSignals(False)
self.minimum_current_combo.blockSignals(True)
self.minimum_current_combo.setCurrentIndex(conf.minimum_current)
self.minimum_current_combo.blockSignals(False)
self.stallguard_threshold_value_spin.blockSignals(True)
self.stallguard_threshold_value_spin.setValue(conf.stallguard_threshold_value)
self.stallguard_threshold_value_spin.blockSignals(False)
self.stallguard_mode_combo.blockSignals(True)
self.stallguard_mode_combo.setCurrentIndex(conf.stallguard_mode)
self.stallguard_mode_combo.blockSignals(False)
def get_misc_configuration_async(self, conf):
self.disable_short_to_ground_protection_checkbox.blockSignals(True)
self.disable_short_to_ground_protection_checkbox.setChecked(conf.disable_short_to_ground_protection)
self.disable_short_to_ground_protection_checkbox.blockSignals(False)
self.synchronize_phase_frequency_spin.blockSignals(True)
self.synchronize_phase_frequency_spin.setValue(conf.synchronize_phase_frequency)
self.synchronize_phase_frequency_spin.blockSignals(False)
def update_start(self):
async_call(self.silent_stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count)
async_call(self.silent_stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count)
async_call(self.silent_stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count)
async_call(self.silent_stepper.get_step_configuration, None, self.get_step_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_basic_configuration, None, self.get_basic_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_spreadcycle_configuration, None, self.get_spreadcycle_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_stealth_configuration, None, self.get_stealth_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_coolstep_configuration, None, self.get_coolstep_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_misc_configuration, None, self.get_misc_configuration_async, self.increase_error_count)
def update_data(self):
async_call(self.silent_stepper.get_remaining_steps, None, self.remaining_steps_update, self.increase_error_count)
async_call(self.silent_stepper.get_current_position, None, self.position_update, self.increase_error_count)
async_call(self.silent_stepper.get_current_velocity, None, self.speedometer.set_velocity, self.increase_error_count)
self.update_counter += 1
if self.update_counter % 10 == 0:
async_call(self.silent_stepper.get_motor_current, None, self.maximum_current_update, self.increase_error_count)
async_call(self.silent_stepper.get_stack_input_voltage, None, self.stack_input_voltage_update, self.increase_error_count)
async_call(self.silent_stepper.get_external_input_voltage, None, self.external_input_voltage_update, self.increase_error_count)
async_call(self.silent_stepper.get_minimum_voltage, None, self.minimum_voltage_update, self.increase_error_count)
async_call(self.silent_stepper.get_driver_status, None, self.driver_status_update, self.increase_error_count)
def velocity_changed(self, value):
try:
self.silent_stepper.set_max_velocity(value)
except ip_connection.Error:
return
def acceleration_changed(self, value):
dec = self.deceleration_spin.value()
try:
self.silent_stepper.set_speed_ramping(value, dec)
except ip_connection.Error:
return
def deceleration_changed(self, value):
acc = self.acceleration_slider.value()
try:
self.silent_stepper.set_speed_ramping(acc, value)
except ip_connection.Error:
return
class SilentStepperV2(COMCUPluginBase, Ui_SilentStepperV2):
qtcb_position_reached = pyqtSignal(int)
qtcb_under_voltage = pyqtSignal(int)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletSilentStepperV2, *args)
self.setupUi(self)
self.silent_stepper_v2 = self.device
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.speedometer = SpeedoMeter()
self.vertical_layout_right.insertWidget(5, self.speedometer)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(
self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(
self.minimum_motor_voltage_button_clicked)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.silent_stepper_v2.register_callback(
self.silent_stepper_v2.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.silent_stepper_v2.register_callback(
self.silent_stepper_v2.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
# Step Configuration
self.step_resolution_dropbox.currentIndexChanged.connect(
self.step_configuration_changed)
self.interpolate_checkbox.stateChanged.connect(
self.step_configuration_changed)
# Basic Configuration
self.standstill_current_spin.valueChanged.connect(
self.basic_configuration_changed)
self.motor_run_current_spin.valueChanged.connect(
self.basic_configuration_changed)
self.standstill_delay_time_spin.valueChanged.connect(
self.basic_configuration_changed)
self.power_down_time_spin.valueChanged.connect(
self.basic_configuration_changed)
self.stealth_threshold_spin.valueChanged.connect(
self.basic_configuration_changed)
self.coolstep_threashold_spin.valueChanged.connect(
self.basic_configuration_changed)
self.classic_threshold_spin.valueChanged.connect(
self.basic_configuration_changed)
self.high_velocity_chopper_mode_checkbox.stateChanged.connect(
self.basic_configuration_changed)
# Spreadcycle Configuration
self.slow_decay_duration_spin.valueChanged.connect(
self.spreadcycle_configuration_changed)
self.enable_random_slow_decay_checkbox.stateChanged.connect(
self.spreadcycle_configuration_changed)
self.fast_decay_duration_spin.valueChanged.connect(
self.spreadcycle_configuration_changed)
self.hysteresis_start_value_spin.valueChanged.connect(
self.spreadcycle_configuration_changed)
self.hysteresis_end_value_spin.valueChanged.connect(
self.spreadcycle_configuration_changed)
self.sine_wave_offset_spin.valueChanged.connect(
self.spreadcycle_configuration_changed)
self.chopper_mode_combo.currentIndexChanged.connect(
self.spreadcycle_configuration_changed)
self.comparator_blank_time_combo.currentIndexChanged.connect(
self.spreadcycle_configuration_changed)
self.fast_decay_without_comparator_checkbox.stateChanged.connect(
self.spreadcycle_configuration_changed)
# Stealth Configuration
self.enable_stealth_checkbox.stateChanged.connect(
self.stealth_configuration_changed)
self.amplitude_spin.valueChanged.connect(
self.stealth_configuration_changed)
self.gradient_spin.valueChanged.connect(
self.stealth_configuration_changed)
self.enable_autoscale_checkbox.stateChanged.connect(
self.stealth_configuration_changed)
self.force_symmetric_checkbox.stateChanged.connect(
self.stealth_configuration_changed)
self.freewheel_mode_combo.currentIndexChanged.connect(
self.stealth_configuration_changed)
# Coolstep Configuration
self.minimum_stallguard_value_spin.valueChanged.connect(
self.coolstep_configuration_changed)
self.maximum_stallguard_value_spin.valueChanged.connect(
self.coolstep_configuration_changed)
self.current_up_step_width_combo.currentIndexChanged.connect(
self.coolstep_configuration_changed)
self.current_down_step_width_combo.currentIndexChanged.connect(
self.coolstep_configuration_changed)
self.minimum_current_combo.currentIndexChanged.connect(
self.coolstep_configuration_changed)
self.stallguard_threshold_value_spin.valueChanged.connect(
self.coolstep_configuration_changed)
self.stallguard_mode_combo.currentIndexChanged.connect(
self.coolstep_configuration_changed)
# Misc Configuration
self.disable_short_to_ground_protection_checkbox.stateChanged.connect(
self.misc_configuration_changed)
self.synchronize_phase_frequency_spin.valueChanged.connect(
self.misc_configuration_changed)
self.gpio0_rising_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(0))
self.gpio0_falling_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(0))
self.gpio1_rising_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(1))
self.gpio1_falling_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(1))
self.gpio0_debounce_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(0))
self.gpio0_stop_deceleration_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(0))
self.gpio1_debounce_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(1))
self.gpio1_stop_deceleration_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(1))
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
def start(self):
self.update_timer.start(100)
self.update_start()
def stop(self):
self.update_timer.stop()
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletSilentStepperV2.DEVICE_IDENTIFIER
def cb_position_reached(self, position):
self.position_update(position)
self.endis_all(True)
def disable_list(self, button_list):
for button in button_list:
button.setEnabled(False)
def endis_all(self, value):
self.forward_button.setEnabled(value)
self.stop_button.setEnabled(value)
self.backward_button.setEnabled(value)
self.to_button.setEnabled(value)
self.steps_button.setEnabled(value)
self.full_brake_button.setEnabled(value)
def step_configuration_changed(self, _):
step_resolution = self.step_resolution_dropbox.currentIndex()
interpolation = self.interpolate_checkbox.isChecked()
try:
self.silent_stepper_v2.set_step_configuration(
step_resolution, interpolation)
except ip_connection.Error:
return
def basic_configuration_changed(self, _):
standstill_current = self.standstill_current_spin.value()
motor_run_current = self.motor_run_current_spin.value()
standstill_delay_time = self.standstill_delay_time_spin.value()
power_down_time = self.power_down_time_spin.value()
stealth_threshold = self.stealth_threshold_spin.value()
coolstep_threshold = self.coolstep_threashold_spin.value()
classic_threshold = self.classic_threshold_spin.value()
high_velocity_chopper_mode = self.high_velocity_chopper_mode_checkbox.isChecked(
)
try:
self.silent_stepper_v2.set_basic_configuration(
standstill_current, motor_run_current, standstill_delay_time,
power_down_time, stealth_threshold, coolstep_threshold,
classic_threshold, high_velocity_chopper_mode)
except ip_connection.Error:
return
def spreadcycle_configuration_changed(self, _):
slow_decay_duration = self.slow_decay_duration_spin.value()
enable_random_slow_decay = self.enable_random_slow_decay_checkbox.isChecked(
)
fast_decay_duration = self.fast_decay_duration_spin.value()
hysteresis_start_value = self.hysteresis_start_value_spin.value()
hysteresis_end_value = self.hysteresis_end_value_spin.value()
sine_wave_offset = self.sine_wave_offset_spin.value()
chopper_mode = self.chopper_mode_combo.currentIndex()
comparator_blank_time = self.comparator_blank_time_combo.currentIndex()
fast_decay_without_comparator = self.fast_decay_without_comparator_checkbox.isChecked(
)
try:
self.silent_stepper_v2.set_spreadcycle_configuration(
slow_decay_duration, enable_random_slow_decay,
fast_decay_duration, hysteresis_start_value,
hysteresis_end_value, sine_wave_offset, chopper_mode,
comparator_blank_time, fast_decay_without_comparator)
except ip_connection.Error:
return
def stealth_configuration_changed(self, _):
enable_stealth = self.enable_stealth_checkbox.isChecked()
amplitude = self.amplitude_spin.value()
gradient = self.gradient_spin.value()
enable_autoscale = self.enable_autoscale_checkbox.isChecked()
force_symmetric = self.force_symmetric_checkbox.isChecked()
freewheel_mode = self.freewheel_mode_combo.currentIndex()
try:
self.silent_stepper_v2.set_stealth_configuration(
enable_stealth, amplitude, gradient, enable_autoscale,
force_symmetric, freewheel_mode)
except ip_connection.Error:
return
def coolstep_configuration_changed(self, _):
minimum_stallguard_value = self.minimum_stallguard_value_spin.value()
maximum_stallguard_value = self.maximum_stallguard_value_spin.value()
current_up_step_width = self.current_up_step_width_combo.currentIndex()
current_down_step_width = self.current_down_step_width_combo.currentIndex(
)
minimum_current = self.minimum_current_combo.currentIndex()
stallguard_threshold_value = self.stallguard_threshold_value_spin.value(
)
stallguard_mode = self.stallguard_mode_combo.currentIndex()
try:
self.silent_stepper_v2.set_coolstep_configuration(
minimum_stallguard_value, maximum_stallguard_value,
current_up_step_width, current_down_step_width,
minimum_current, stallguard_threshold_value, stallguard_mode)
except ip_connection.Error:
return
def misc_configuration_changed(self, _):
disable_short_to_ground_protection = self.disable_short_to_ground_protection_checkbox.isChecked(
)
synchronize_phase_frequency = self.synchronize_phase_frequency_spin.value(
)
try:
self.silent_stepper_v2.set_misc_configuration(
disable_short_to_ground_protection,
synchronize_phase_frequency)
except ip_connection.Error:
return
def forward_clicked(self):
try:
self.silent_stepper_v2.drive_forward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def backward_clicked(self):
try:
self.silent_stepper_v2.drive_backward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def stop_clicked(self):
try:
self.silent_stepper_v2.stop()
except ip_connection.Error:
return
self.endis_all(True)
def full_brake_clicked(self):
try:
self.silent_stepper_v2.full_brake()
except ip_connection.Error:
return
self.endis_all(True)
def to_button_clicked(self):
drive_to = self.to_spin.value()
try:
self.silent_stepper_v2.set_target_position(drive_to)
except ip_connection.Error:
return
self.disable_list([
self.to_button, self.steps_button, self.forward_button,
self.backward_button
])
def steps_button_clicked(self):
drive_steps = self.steps_spin.value()
try:
self.silent_stepper_v2.set_steps(drive_steps)
except ip_connection.Error:
return
self.disable_list([
self.to_button, self.steps_button, self.forward_button,
self.backward_button
])
def motor_current_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(360)
qid.setIntMaximum(1640)
qid.setIntStep(100)
async_call(self.silent_stepper_v2.get_motor_current, None,
qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.motor_current_selected)
qid.setLabelText("Choose motor current in mA.")
qid.open()
def minimum_motor_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(40000)
qid.setIntStep(100)
async_call(self.silent_stepper_v2.get_minimum_voltage, None,
qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.minimum_motor_voltage_selected)
qid.setLabelText("Choose minimum motor voltage in mV.")
qid.open()
def motor_current_selected(self, value):
try:
self.silent_stepper_v2.set_motor_current(value)
except ip_connection.Error:
return
def minimum_motor_voltage_selected(self, value):
try:
self.silent_stepper_v2.set_minimum_voltage(value)
except ip_connection.Error:
return
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov / 1000.0, 1)
if not self.qem.isVisible():
self.qem.showMessage(
"Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str,
"SilentStepperV2_UnderVoltage")
def enable_state_changed(self, state):
try:
if state == Qt.Checked:
self.endis_all(True)
self.silent_stepper_v2.set_enabled(True)
elif state == Qt.Unchecked:
self.endis_all(False)
self.silent_stepper_v2.set_enabled(False)
except ip_connection.Error:
return
def input_voltage_update(self, sv):
sv_str = "%gV" % round(sv / 1000.0, 1)
self.input_voltage_label.setText(sv_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv / 1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def maximum_current_update(self, cur):
cur_str = "%gA" % round(cur / 1000.0, 1)
self.maximum_current_label.setText(cur_str)
def position_update(self, pos):
pos_str = "%d" % pos
self.position_label.setText(pos_str)
def remaining_steps_update(self, ste):
ste_str = "%d" % ste
self.remaining_steps_label.setText(ste_str)
def driver_status_update(self, update):
if update.open_load == 0:
self.status_open_load.setText('No')
elif update.open_load == 1:
self.status_open_load.setText('Phase A')
elif update.open_load == 2:
self.status_open_load.setText('Phase B')
elif update.open_load == 3:
self.status_open_load.setText('Phase A and B')
else:
self.status_open_load.setText('Unknown')
if update.short_to_ground == 0:
self.status_short_to_ground.setText('No')
elif update.short_to_ground == 1:
self.status_short_to_ground.setText('Phase A')
elif update.short_to_ground == 2:
self.status_short_to_ground.setText('Phase B')
elif update.short_to_ground == 3:
self.status_short_to_ground.setText('Phase A and B')
else:
self.status_short_to_ground.setText('Unknown')
if update.over_temperature == 0:
self.status_over_temperature.setText('No')
elif update.over_temperature == 1:
self.status_over_temperature.setText(
'<font color=yellow>Warning</font>')
elif update.over_temperature == 2:
self.status_over_temperature.setText(
'<font color=red>Limit</font>')
if update.motor_stalled:
self.status_motor_stalled.setText('Yes')
else:
self.status_motor_stalled.setText('No')
self.status_actual_motor_current.setText(
str(update.actual_motor_current))
if update.full_step_active:
self.status_full_step_active.setText('Yes')
else:
self.status_full_step_active.setText('No')
self.status_stallguard_result.setText(str(update.stallguard_result))
self.status_stealth_voltage_amplitude.setText(
str(update.stealth_voltage_amplitude))
def get_max_velocity_async(self, velocity):
if not self.velocity_slider.isSliderDown():
if velocity != self.velocity_slider.sliderPosition():
self.velocity_slider.setSliderPosition(velocity)
self.velocity_spin.setValue(velocity)
def get_speed_ramping_async(self, ramp):
acc, dec = ramp
if not self.acceleration_slider.isSliderDown() and \
not self.deceleration_slider.isSliderDown():
if acc != self.acceleration_slider.sliderPosition():
self.acceleration_slider.setSliderPosition(acc)
self.acceleration_spin.setValue(acc)
if dec != self.deceleration_slider.sliderPosition():
self.deceleration_slider.setSliderPosition(dec)
self.deceleration_spin.setValue(dec)
def get_enabled_async(self, enabled):
if enabled:
if not self.enable_checkbox.isChecked():
self.endis_all(True)
self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(True)
self.enable_checkbox.blockSignals(False)
else:
if self.enable_checkbox.isChecked():
self.endis_all(False)
self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(False)
self.enable_checkbox.blockSignals(False)
def get_step_configuration_async(self, conf):
self.step_resolution_dropbox.blockSignals(True)
self.step_resolution_dropbox.setCurrentIndex(conf.step_resolution)
self.step_resolution_dropbox.blockSignals(False)
self.interpolate_checkbox.blockSignals(True)
self.interpolate_checkbox.setChecked(conf.interpolation)
self.interpolate_checkbox.blockSignals(False)
def get_basic_configuration_async(self, conf):
self.standstill_current_spin.blockSignals(True)
self.standstill_current_spin.setValue(conf.standstill_current)
self.standstill_current_spin.blockSignals(False)
self.motor_run_current_spin.blockSignals(True)
self.motor_run_current_spin.setValue(conf.motor_run_current)
self.motor_run_current_spin.blockSignals(False)
self.standstill_delay_time_spin.blockSignals(True)
self.standstill_delay_time_spin.setValue(conf.standstill_delay_time)
self.standstill_delay_time_spin.blockSignals(False)
self.power_down_time_spin.blockSignals(True)
self.power_down_time_spin.setValue(conf.power_down_time)
self.power_down_time_spin.blockSignals(False)
self.stealth_threshold_spin.blockSignals(True)
self.stealth_threshold_spin.setValue(conf.stealth_threshold)
self.stealth_threshold_spin.blockSignals(False)
self.coolstep_threashold_spin.blockSignals(True)
self.coolstep_threashold_spin.setValue(conf.coolstep_threshold)
self.coolstep_threashold_spin.blockSignals(False)
self.classic_threshold_spin.blockSignals(True)
self.classic_threshold_spin.setValue(conf.classic_threshold)
self.classic_threshold_spin.blockSignals(False)
self.high_velocity_chopper_mode_checkbox.blockSignals(True)
self.high_velocity_chopper_mode_checkbox.setChecked(
conf.high_velocity_chopper_mode)
self.high_velocity_chopper_mode_checkbox.blockSignals(False)
def get_spreadcycle_configuration_async(self, conf):
self.slow_decay_duration_spin.blockSignals(True)
self.slow_decay_duration_spin.setValue(conf.slow_decay_duration)
self.slow_decay_duration_spin.blockSignals(False)
self.enable_random_slow_decay_checkbox.blockSignals(True)
self.enable_random_slow_decay_checkbox.setChecked(
conf.enable_random_slow_decay)
self.enable_random_slow_decay_checkbox.blockSignals(False)
self.fast_decay_duration_spin.blockSignals(True)
self.fast_decay_duration_spin.setValue(conf.fast_decay_duration)
self.fast_decay_duration_spin.blockSignals(False)
self.hysteresis_start_value_spin.blockSignals(True)
self.hysteresis_start_value_spin.setValue(conf.hysteresis_start_value)
self.hysteresis_start_value_spin.blockSignals(False)
self.hysteresis_end_value_spin.blockSignals(True)
self.hysteresis_end_value_spin.setValue(conf.hysteresis_end_value)
self.hysteresis_end_value_spin.blockSignals(False)
self.sine_wave_offset_spin.blockSignals(True)
self.sine_wave_offset_spin.setValue(conf.sine_wave_offset)
self.sine_wave_offset_spin.blockSignals(False)
self.chopper_mode_combo.blockSignals(True)
self.chopper_mode_combo.setCurrentIndex(conf.chopper_mode)
self.chopper_mode_combo.blockSignals(False)
self.standstill_current_spin.blockSignals(True)
self.comparator_blank_time_combo.setCurrentIndex(
conf.comparator_blank_time)
self.standstill_current_spin.blockSignals(False)
self.fast_decay_without_comparator_checkbox.blockSignals(True)
self.fast_decay_without_comparator_checkbox.setChecked(
conf.fast_decay_without_comparator)
self.fast_decay_without_comparator_checkbox.blockSignals(False)
def get_stealth_configuration_async(self, conf):
self.enable_stealth_checkbox.blockSignals(True)
self.enable_stealth_checkbox.setChecked(conf.enable_stealth)
self.enable_stealth_checkbox.blockSignals(False)
self.amplitude_spin.blockSignals(True)
self.amplitude_spin.setValue(conf.amplitude)
self.amplitude_spin.blockSignals(False)
self.gradient_spin.blockSignals(True)
self.gradient_spin.setValue(conf.gradient)
self.gradient_spin.blockSignals(False)
self.enable_autoscale_checkbox.blockSignals(True)
self.enable_autoscale_checkbox.setChecked(conf.enable_autoscale)
self.enable_autoscale_checkbox.blockSignals(False)
self.force_symmetric_checkbox.blockSignals(True)
self.force_symmetric_checkbox.setChecked(conf.force_symmetric)
self.force_symmetric_checkbox.blockSignals(False)
self.freewheel_mode_combo.blockSignals(True)
self.freewheel_mode_combo.setCurrentIndex(conf.freewheel_mode)
self.freewheel_mode_combo.blockSignals(False)
def get_coolstep_configuration_async(self, conf):
self.minimum_stallguard_value_spin.blockSignals(True)
self.minimum_stallguard_value_spin.setValue(
conf.minimum_stallguard_value)
self.minimum_stallguard_value_spin.blockSignals(False)
self.maximum_stallguard_value_spin.blockSignals(True)
self.maximum_stallguard_value_spin.setValue(
conf.maximum_stallguard_value)
self.maximum_stallguard_value_spin.blockSignals(False)
self.current_up_step_width_combo.blockSignals(True)
self.current_up_step_width_combo.setCurrentIndex(
conf.current_up_step_width)
self.current_up_step_width_combo.blockSignals(False)
self.current_down_step_width_combo.blockSignals(True)
self.current_down_step_width_combo.setCurrentIndex(
conf.current_down_step_width)
self.current_down_step_width_combo.blockSignals(False)
self.minimum_current_combo.blockSignals(True)
self.minimum_current_combo.setCurrentIndex(conf.minimum_current)
self.minimum_current_combo.blockSignals(False)
self.stallguard_threshold_value_spin.blockSignals(True)
self.stallguard_threshold_value_spin.setValue(
conf.stallguard_threshold_value)
self.stallguard_threshold_value_spin.blockSignals(False)
self.stallguard_mode_combo.blockSignals(True)
self.stallguard_mode_combo.setCurrentIndex(conf.stallguard_mode)
self.stallguard_mode_combo.blockSignals(False)
def get_misc_configuration_async(self, conf):
self.disable_short_to_ground_protection_checkbox.blockSignals(True)
self.disable_short_to_ground_protection_checkbox.setChecked(
conf.disable_short_to_ground_protection)
self.disable_short_to_ground_protection_checkbox.blockSignals(False)
self.synchronize_phase_frequency_spin.blockSignals(True)
self.synchronize_phase_frequency_spin.setValue(
conf.synchronize_phase_frequency)
self.synchronize_phase_frequency_spin.blockSignals(False)
def update_start(self):
async_call(self.silent_stepper_v2.get_max_velocity, None,
self.get_max_velocity_async, self.increase_error_count)
async_call(self.silent_stepper_v2.get_speed_ramping, None,
self.get_speed_ramping_async, self.increase_error_count)
async_call(self.silent_stepper_v2.get_enabled, None,
self.get_enabled_async, self.increase_error_count)
async_call(self.silent_stepper_v2.get_step_configuration, None,
self.get_step_configuration_async,
self.increase_error_count)
async_call(self.silent_stepper_v2.get_basic_configuration, None,
self.get_basic_configuration_async,
self.increase_error_count)
async_call(self.silent_stepper_v2.get_spreadcycle_configuration, None,
self.get_spreadcycle_configuration_async,
self.increase_error_count)
async_call(self.silent_stepper_v2.get_stealth_configuration, None,
self.get_stealth_configuration_async,
self.increase_error_count)
async_call(self.silent_stepper_v2.get_coolstep_configuration, None,
self.get_coolstep_configuration_async,
self.increase_error_count)
async_call(self.silent_stepper_v2.get_misc_configuration, None,
self.get_misc_configuration_async,
self.increase_error_count)
def update_data(self):
async_call(self.silent_stepper_v2.get_remaining_steps, None,
self.remaining_steps_update, self.increase_error_count)
async_call(self.silent_stepper_v2.get_current_position, None,
self.position_update, self.increase_error_count)
async_call(self.silent_stepper_v2.get_current_velocity, None,
self.speedometer.set_velocity, self.increase_error_count)
async_call(self.silent_stepper_v2.get_gpio_state, None,
self.gpio_state_update, self.increase_error_count)
self.update_counter += 1
if self.update_counter % 10 == 0:
async_call(self.silent_stepper_v2.get_motor_current, None,
self.maximum_current_update, self.increase_error_count)
async_call(self.silent_stepper_v2.get_input_voltage, None,
self.input_voltage_update, self.increase_error_count)
async_call(self.silent_stepper_v2.get_minimum_voltage, None,
self.minimum_voltage_update, self.increase_error_count)
async_call(self.silent_stepper_v2.get_driver_status, None,
self.driver_status_update, self.increase_error_count)
def velocity_changed(self, value):
try:
self.silent_stepper_v2.set_max_velocity(value)
except ip_connection.Error:
return
def acceleration_changed(self, value):
dec = self.deceleration_spin.value()
try:
self.silent_stepper_v2.set_speed_ramping(value, dec)
except ip_connection.Error:
return
def deceleration_changed(self, value):
acc = self.acceleration_slider.value()
try:
self.silent_stepper_v2.set_speed_ramping(acc, value)
except ip_connection.Error:
return
def gpio_action_changed(self, channel):
action = 0
if channel == 0:
rising = self.gpio0_rising_combo.currentIndex()
falling = self.gpio0_falling_combo.currentIndex()
elif channel == 1:
rising = self.gpio1_rising_combo.currentIndex()
falling = self.gpio1_falling_combo.currentIndex()
else:
return # unreachable
if rising == 1:
action = action | self.silent_stepper_v2.GPIO_ACTION_NORMAL_STOP_RISING_EDGE
if falling == 1:
action = action | self.silent_stepper_v2.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE
if rising == 2:
action = action | self.silent_stepper_v2.GPIO_ACTION_FULL_BRAKE_RISING_EDGE
if falling == 2:
action = action | self.silent_stepper_v2.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE
# TODO: Retain callback configuration
self.silent_stepper_v2.set_gpio_action(channel, action)
def gpio_configuration_changed(self, channel):
if channel == 0:
debounce = self.gpio0_debounce_spin.value()
stop_deceleration = self.gpio0_stop_deceleration_spin.value()
elif channel == 1:
debounce = self.gpio1_debounce_spin.value()
stop_deceleration = self.gpio1_stop_deceleration_spin.value()
self.silent_stepper_v2.set_gpio_configuration(channel, debounce,
stop_deceleration)
def gpio_state_update(self, state):
if state[0]:
self.gpio0_state_label.setText('High')
else:
self.gpio0_state_label.setText('Low')
if state[1]:
self.gpio1_state_label.setText('High')
else:
self.gpio1_state_label.setText('Low')
class Stepper(PluginBase, Ui_Stepper):
qtcb_position_reached = pyqtSignal(int)
qtcb_under_voltage = pyqtSignal(int)
def __init__(self, *args):
PluginBase.__init__(self, BrickStepper, *args)
self.setupUi(self)
self.stepper = self.device
# the firmware version of a Brick can (under common circumstances) not
# change during the lifetime of a Brick plugin. therefore, it's okay to
# make final decisions based on it here
self.has_status_led = self.firmware_version >= (2, 3, 1)
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.decay_widget.hide()
self.setting_sync_rect_checkbox = False
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.decay_syncer = SliderSpinSyncer(self.decay_slider,
self.decay_spin,
self.decay_changed)
self.enable_checkbox.toggled.connect(self.enable_toggled)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked)
self.sync_rect_checkbox.toggled.connect(self.sync_rect_toggled)
self.mode_dropbox.currentIndexChanged.connect(self.mode_changed)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.stepper.register_callback(self.stepper.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.stepper.register_callback(self.stepper.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
if self.has_status_led:
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(lambda checked: self.stepper.enable_status_led() if checked else self.stepper.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
else:
self.status_led_action = None
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.stepper.reset())
self.set_actions([(0, None, [reset])])
def start(self):
if self.has_status_led:
async_call(self.stepper.is_status_led_enabled, None, self.status_led_action.setChecked, self.increase_error_count)
self.update_timer.start(100)
self.update_start()
def stop(self):
self.update_timer.stop()
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickStepper.DEVICE_IDENTIFIER
def cb_position_reached(self, position):
self.position_update(position)
self.endis_all(True)
def disable_list(self, button_list):
for button in button_list:
button.setEnabled(False)
def endis_all(self, value):
self.forward_button.setEnabled(value)
self.stop_button.setEnabled(value)
self.backward_button.setEnabled(value)
self.to_button.setEnabled(value)
self.steps_button.setEnabled(value)
self.full_brake_button.setEnabled(value)
def mode_changed(self, index):
try:
self.stepper.set_step_mode(1 << index)
self.mod = 1 << index
except ip_connection.Error:
return
def forward_clicked(self):
try:
self.stepper.drive_forward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def backward_clicked(self):
try:
self.stepper.drive_backward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def stop_clicked(self):
try:
self.stepper.stop()
except ip_connection.Error:
return
self.endis_all(True)
def full_brake_clicked(self):
try:
self.stepper.full_brake()
except ip_connection.Error:
return
self.endis_all(True)
def to_button_clicked(self):
drive_to = self.to_spin.value()
try:
self.stepper.set_target_position(drive_to)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def steps_button_clicked(self):
drive_steps = self.steps_spin.value()
try:
self.stepper.set_steps(drive_steps)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def motor_current_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(2500)
qid.setIntStep(100)
async_call(self.stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.motor_current_selected)
qid.setLabelText("Choose motor current in mA.")
qid.open()
def minimum_motor_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(40000)
qid.setIntStep(100)
async_call(self.stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.minimum_motor_voltage_selected)
qid.setLabelText("Choose minimum motor voltage in mV.")
qid.open()
def motor_current_selected(self, value):
try:
self.stepper.set_motor_current(value)
except ip_connection.Error:
return
def minimum_motor_voltage_selected(self, value):
try:
self.stepper.set_minimum_voltage(value)
except ip_connection.Error:
return
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov/1000.0, 1)
if not self.qem.isVisible():
self.qem.showMessage("Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str,
"Stepper_UnderVoltage")
def enable_toggled(self, checked):
try:
if checked:
if not self.stepper.is_enabled():
self.endis_all(True)
self.stepper.enable()
else:
if self.stepper.is_enabled():
self.endis_all(False)
self.stepper.disable()
except ip_connection.Error:
return
def sync_rect_toggled(self, checked):
if not self.setting_sync_rect_checkbox and checked:
rc = QMessageBox.warning(get_main_window(), 'Synchronous Rectification',
'If you want to use high speeds (> 10000 steps/s) for a large stepper motor with a ' +
'large inductivity we strongly suggest that you do not enable synchronous rectification. ' +
'Otherwise the Brick may not be able to cope with the load and overheat.',
QMessageBox.Ok | QMessageBox.Cancel)
if rc != QMessageBox.Ok:
self.sync_rect_checkbox.setChecked(False)
return
try:
self.stepper.set_sync_rect(checked)
except ip_connection.Error:
return
self.decay_widget.setVisible(checked)
def stack_input_voltage_update(self, sv):
sv_str = "%gV" % round(sv/1000.0, 1)
self.stack_voltage_label.setText(sv_str)
def external_input_voltage_update(self, ev):
ev_str = "%gV" % round(ev/1000.0, 1)
self.external_voltage_label.setText(ev_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv/1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def maximum_current_update(self, cur):
cur_str = "%gA" % round(cur/1000.0, 1)
self.maximum_current_label.setText(cur_str)
def position_update(self, pos):
pos_str = "%d" % pos
self.position_label.setText(pos_str)
def remaining_steps_update(self, ste):
ste_str = "%d" % ste
self.remaining_steps_label.setText(ste_str)
def current_velocity_update(self, velocity):
velocity_str = "%d" % velocity
self.current_velocity_label.setText(velocity_str)
self.speedometer.set_velocity(velocity)
def mode_update(self, mod):
if mod == 8:
index = 3
elif mod == 4:
index = 2
elif mod == 2:
index = 1
else:
index = 0
self.mode_dropbox.setCurrentIndex(index)
def get_max_velocity_async(self, velocity):
if not self.velocity_slider.isSliderDown():
if velocity != self.velocity_slider.sliderPosition():
self.velocity_slider.setSliderPosition(velocity)
self.velocity_spin.setValue(velocity)
def get_speed_ramping_async(self, ramp):
acc, dec = ramp
if not self.acceleration_slider.isSliderDown() and \
not self.deceleration_slider.isSliderDown():
if acc != self.acceleration_slider.sliderPosition():
self.acceleration_slider.setSliderPosition(acc)
self.acceleration_spin.setValue(acc)
if dec != self.deceleration_slider.sliderPosition():
self.deceleration_slider.setSliderPosition(dec)
self.deceleration_spin.setValue(dec)
def get_decay_async(self, decay):
if not self.decay_slider.isSliderDown():
if decay != self.decay_slider.sliderPosition():
self.decay_slider.setSliderPosition(decay)
self.decay_spin.setValue(decay)
def is_enabled_async(self, enabled):
if enabled:
if not self.enable_checkbox.isChecked():
self.endis_all(True)
self.enable_checkbox.setChecked(True)
else:
if self.enable_checkbox.isChecked():
self.endis_all(False)
self.enable_checkbox.setChecked(False)
def is_sync_rect_async(self, sync_rect):
self.setting_sync_rect_checkbox = True
self.sync_rect_checkbox.setChecked(sync_rect)
self.setting_sync_rect_checkbox = False
def update_start(self):
async_call(self.stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count)
async_call(self.stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count)
async_call(self.stepper.get_decay, None, self.get_decay_async, self.increase_error_count)
async_call(self.stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count)
async_call(self.stepper.is_sync_rect, None, self.is_sync_rect_async, self.increase_error_count)
def update_data(self):
async_call(self.stepper.get_remaining_steps, None, self.remaining_steps_update, self.increase_error_count)
async_call(self.stepper.get_current_position, None, self.position_update, self.increase_error_count)
async_call(self.stepper.get_current_velocity, None, self.current_velocity_update, self.increase_error_count)
self.update_counter += 1
if self.update_counter % 10 == 0:
async_call(self.stepper.get_motor_current, None, self.maximum_current_update, self.increase_error_count)
async_call(self.stepper.get_stack_input_voltage, None, self.stack_input_voltage_update, self.increase_error_count)
async_call(self.stepper.get_external_input_voltage, None, self.external_input_voltage_update, self.increase_error_count)
async_call(self.stepper.get_minimum_voltage, None, self.minimum_voltage_update, self.increase_error_count)
async_call(self.stepper.get_step_mode, None, self.mode_update, self.increase_error_count)
def velocity_changed(self, value):
try:
self.stepper.set_max_velocity(value)
except ip_connection.Error:
return
def acceleration_changed(self, value):
dec = self.deceleration_spin.value()
try:
self.stepper.set_speed_ramping(value, dec)
except ip_connection.Error:
return
def deceleration_changed(self, value):
acc = self.acceleration_slider.value()
try:
self.stepper.set_speed_ramping(acc, value)
except ip_connection.Error:
return
def decay_changed(self, value):
try:
self.stepper.set_decay(value)
except ip_connection.Error:
return
class PerformanceDC(COMCUPluginBase, Ui_PerformanceDC):
qtcb_emergency_shutdown = pyqtSignal()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletPerformanceDC, *args)
self.setupUi(self)
self.dc = self.device
self.qem = QErrorMessage(self)
self.qtcb_emergency_shutdown.connect(self.cb_emergency_shutdown)
self.dc.register_callback(self.dc.CALLBACK_EMERGENCY_SHUTDOWN,
self.qtcb_emergency_shutdown.emit)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.radio_mode_brake.toggled.connect(self.brake_value_changed)
self.radio_mode_coast.toggled.connect(self.coast_value_changed)
self.gpio0_rising_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(0))
self.gpio0_falling_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(0))
self.gpio1_rising_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(1))
self.gpio1_falling_combo.currentIndexChanged.connect(
lambda x: self.gpio_action_changed(1))
self.gpio0_debounce_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(0))
self.gpio0_stop_deceleration_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(0))
self.gpio1_debounce_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(1))
self.gpio1_stop_deceleration_spin.valueChanged.connect(
lambda: self.gpio_configuration_changed(1))
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.motion_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.motion_changed)
self.frequency_syncer = SliderSpinSyncer(self.frequency_slider,
self.frequency_spin,
self.frequency_changed)
self.cbe_power_statistics = CallbackEmulator(
self, self.dc.get_power_statistics, None,
self.get_power_statistics_async, self.increase_error_count)
self.cbe_current_velocity = CallbackEmulator(
self, self.dc.get_current_velocity, None,
self.get_current_velocity_async, self.increase_error_count)
self.cbe_gpio_state = CallbackEmulator(self, self.dc.get_gpio_state,
None, self.get_gpio_state_async,
self.increase_error_count)
self.error_led_off_action = QAction('Off', self)
self.error_led_off_action.triggered.connect(
lambda: self.dc.set_error_led_config(BrickletPerformanceDC.
ERROR_LED_CONFIG_OFF))
self.error_led_on_action = QAction('On', self)
self.error_led_on_action.triggered.connect(
lambda: self.dc.set_error_led_config(BrickletPerformanceDC.
ERROR_LED_CONFIG_ON))
self.error_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.error_led_show_heartbeat_action.triggered.connect(
lambda: self.dc.set_error_led_config(
BrickletPerformanceDC.ERROR_LED_CONFIG_SHOW_HEARTBEAT))
self.error_led_show_error_action = QAction('Show Error', self)
self.error_led_show_error_action.triggered.connect(
lambda: self.dc.set_error_led_config(BrickletPerformanceDC.
ERROR_LED_CONFIG_SHOW_ERROR))
self.extra_configs += [(1, 'Error LED:', [
self.error_led_off_action, self.error_led_on_action,
self.error_led_show_heartbeat_action,
self.error_led_show_error_action
])]
self.cw_led_off_action = QAction('Off', self)
self.cw_led_off_action.triggered.connect(
lambda: self.dc.set_cw_led_config(BrickletPerformanceDC.
CW_LED_CONFIG_OFF))
self.cw_led_on_action = QAction('On', self)
self.cw_led_on_action.triggered.connect(
lambda: self.dc.set_cw_led_config(BrickletPerformanceDC.
CW_LED_CONFIG_ON))
self.cw_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.cw_led_show_heartbeat_action.triggered.connect(
lambda: self.dc.set_cw_led_config(BrickletPerformanceDC.
CW_LED_CONFIG_SHOW_HEARTBEAT))
self.cw_led_show_cw_as_forward_action = QAction(
'Show CW As Forward', self)
self.cw_led_show_cw_as_forward_action.triggered.connect(
lambda: self.dc.set_cw_led_config(
BrickletPerformanceDC.CW_LED_CONFIG_SHOW_CW_AS_FORWARD))
self.cw_led_show_cw_as_backward_action = QAction(
'Show CW As Backward', self)
self.cw_led_show_cw_as_backward_action.triggered.connect(
lambda: self.dc.set_cw_led_config(
BrickletPerformanceDC.CW_LED_CONFIG_SHOW_CW_AS_BACKWARD))
self.extra_configs += [(2, 'CW LED:', [
self.cw_led_off_action, self.cw_led_on_action,
self.cw_led_show_heartbeat_action,
self.cw_led_show_cw_as_forward_action,
self.cw_led_show_cw_as_backward_action
])]
self.ccw_led_off_action = QAction('Off', self)
self.ccw_led_off_action.triggered.connect(
lambda: self.dc.set_ccw_led_config(BrickletPerformanceDC.
CCW_LED_CONFIG_OFF))
self.ccw_led_on_action = QAction('On', self)
self.ccw_led_on_action.triggered.connect(
lambda: self.dc.set_ccw_led_config(BrickletPerformanceDC.
CCW_LED_CONFIG_ON))
self.ccw_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.ccw_led_show_heartbeat_action.triggered.connect(
lambda: self.dc.set_ccw_led_config(BrickletPerformanceDC.
CCW_LED_CONFIG_SHOW_HEARTBEAT))
self.ccw_led_show_ccw_as_forward_action = QAction(
'Show CCW As Forward', self)
self.ccw_led_show_ccw_as_forward_action.triggered.connect(
lambda: self.dc.set_ccw_led_config(
BrickletPerformanceDC.CCW_LED_CONFIG_SHOW_CCW_AS_FORWARD))
self.ccw_led_show_ccw_as_backward_action = QAction(
'Show CCW As Backward', self)
self.ccw_led_show_ccw_as_backward_action.triggered.connect(
lambda: self.dc.set_ccw_led_config(
BrickletPerformanceDC.CCW_LED_CONFIG_SHOW_CCW_AS_BACKWARD))
self.extra_configs += [(2, 'CCW LED:', [
self.ccw_led_off_action, self.ccw_led_on_action,
self.ccw_led_show_heartbeat_action,
self.ccw_led_show_ccw_as_forward_action,
self.ccw_led_show_ccw_as_backward_action
])]
self.gpio0_led_off_action = QAction('Off', self)
self.gpio0_led_off_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
0, BrickletPerformanceDC.GPIO_LED_CONFIG_OFF))
self.gpio0_led_on_action = QAction('On', self)
self.gpio0_led_on_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
0, BrickletPerformanceDC.GPIO_LED_CONFIG_ON))
self.gpio0_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.gpio0_led_show_heartbeat_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
0, BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_HEARTBEAT))
self.gpio0_led_show_show_gpio_active_high_action = QAction(
'Show GPIO Active High', self)
self.gpio0_led_show_show_gpio_active_high_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
0, BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_HIGH
))
self.gpio0_led_show_show_gpio_active_low_action = QAction(
'Show GPIO Active Low', self)
self.gpio0_led_show_show_gpio_active_low_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
0, BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_LOW))
self.extra_configs += [(3, 'GPIO0 LED:', [
self.gpio0_led_off_action, self.gpio0_led_on_action,
self.gpio0_led_show_heartbeat_action,
self.gpio0_led_show_show_gpio_active_high_action,
self.gpio0_led_show_show_gpio_active_low_action
])]
self.gpio1_led_off_action = QAction('Off', self)
self.gpio1_led_off_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
1, BrickletPerformanceDC.GPIO_LED_CONFIG_OFF))
self.gpio1_led_on_action = QAction('On', self)
self.gpio1_led_on_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
1, BrickletPerformanceDC.GPIO_LED_CONFIG_ON))
self.gpio1_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.gpio1_led_show_heartbeat_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
1, BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_HEARTBEAT))
self.gpio1_led_show_show_gpio_active_high_action = QAction(
'Show GPIO Active High', self)
self.gpio1_led_show_show_gpio_active_high_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
1, BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_HIGH
))
self.gpio1_led_show_show_gpio_active_low_action = QAction(
'Show GPIO Active Low', self)
self.gpio1_led_show_show_gpio_active_low_action.triggered.connect(
lambda: self.dc.set_gpio_led_config(
1, BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_LOW))
self.extra_configs += [(3, 'GPIO1 LED:', [
self.gpio1_led_off_action, self.gpio1_led_on_action,
self.gpio1_led_show_heartbeat_action,
self.gpio1_led_show_show_gpio_active_high_action,
self.gpio1_led_show_show_gpio_active_low_action
])]
def start(self):
async_call(self.dc.get_drive_mode, None, self.get_drive_mode_async,
self.increase_error_count)
async_call(self.dc.get_velocity, None, self.get_velocity_async,
self.increase_error_count)
async_call(self.dc.get_motion, None, self.get_motion_async,
self.increase_error_count)
async_call(self.dc.get_pwm_frequency, None,
self.get_pwm_frequency_async, self.increase_error_count)
async_call(self.dc.get_enabled, None, self.get_enabled_async,
self.increase_error_count)
async_call(self.dc.get_gpio_configuration, 0,
lambda x: self.get_gpio_configuration_async(0, x),
self.increase_error_count)
async_call(self.dc.get_gpio_configuration, 1,
lambda x: self.get_gpio_configuration_async(1, x),
self.increase_error_count)
async_call(self.dc.get_gpio_action, 0,
lambda x: self.get_gpio_action_async(0, x),
self.increase_error_count)
async_call(self.dc.get_gpio_action, 1,
lambda x: self.get_gpio_action_async(1, x),
self.increase_error_count)
async_call(self.dc.get_error_led_config, None,
self.get_error_led_config_async, self.increase_error_count)
async_call(self.dc.get_cw_led_config, None,
self.get_cw_led_config_async, self.increase_error_count)
async_call(self.dc.get_ccw_led_config, None,
self.get_ccw_led_config_async, self.increase_error_count)
async_call(self.dc.get_gpio_led_config, 0,
self.get_gpio0_led_config_async, self.increase_error_count)
async_call(self.dc.get_gpio_led_config, 1,
self.get_gpio1_led_config_async, self.increase_error_count)
self.cbe_gpio_state.set_period(200)
self.cbe_power_statistics.set_period(100)
self.cbe_current_velocity.set_period(50)
def stop(self):
self.cbe_gpio_state.set_period(0)
self.cbe_power_statistics.set_period(0)
self.cbe_current_velocity.set_period(0)
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletPerformanceDC.DEVICE_IDENTIFIER
def get_error_led_config_async(self, config):
if config == BrickletPerformanceDC.ERROR_LED_CONFIG_OFF:
self.error_led_off_action.trigger()
elif config == BrickletPerformanceDC.ERROR_LED_CONFIG_ON:
self.error_led_on_action.trigger()
elif config == BrickletPerformanceDC.ERROR_LED_CONFIG_SHOW_HEARTBEAT:
self.error_led_show_heartbeat_action.trigger()
elif config == BrickletPerformanceDC.ERROR_LED_CONFIG_SHOW_ERROR:
self.error_led_show_error_action.trigger()
def get_cw_led_config_async(self, config):
if config == BrickletPerformanceDC.CW_LED_CONFIG_OFF:
self.cw_led_off_action.trigger()
elif config == BrickletPerformanceDC.CW_LED_CONFIG_ON:
self.cw_led_on_action.trigger()
elif config == BrickletPerformanceDC.CW_LED_CONFIG_SHOW_HEARTBEAT:
self.cw_led_show_heartbeat_action.trigger()
elif config == BrickletPerformanceDC.CW_LED_CONFIG_SHOW_CW_AS_FORWARD:
self.cw_led_show_cw_as_forward_action.trigger()
elif config == BrickletPerformanceDC.CW_LED_CONFIG_SHOW_CW_AS_BACKWARD:
self.cw_led_show_cw_as_backward_action.trigger()
def get_ccw_led_config_async(self, config):
if config == BrickletPerformanceDC.CCW_LED_CONFIG_OFF:
self.ccw_led_off_action.trigger()
elif config == BrickletPerformanceDC.CCW_LED_CONFIG_ON:
self.ccw_led_on_action.trigger()
elif config == BrickletPerformanceDC.CCW_LED_CONFIG_SHOW_HEARTBEAT:
self.ccw_led_show_heartbeat_action.trigger()
elif config == BrickletPerformanceDC.CCW_LED_CONFIG_SHOW_CCW_AS_FORWARD:
self.ccw_led_show_ccw_as_forward_action.trigger()
elif config == BrickletPerformanceDC.CCW_LED_CONFIG_SHOW_CCW_AS_BACKWARD:
self.ccw_led_show_ccw_as_backward_action.trigger()
def get_gpio0_led_config_async(self, config):
if config == BrickletPerformanceDC.GPIO_LED_CONFIG_OFF:
self.gpio0_led_off_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_ON:
self.gpio0_led_on_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_HEARTBEAT:
self.gpio0_led_show_heartbeat_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_HIGH:
self.gpio0_led_show_show_gpio_active_high_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_LOW:
self.gpio0_led_show_show_gpio_active_low_action.trigger()
def get_gpio1_led_config_async(self, config):
if config == BrickletPerformanceDC.GPIO_LED_CONFIG_OFF:
self.gpio1_led_off_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_ON:
self.gpio1_led_on_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_HEARTBEAT:
self.gpio1_led_show_heartbeat_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_HIGH:
self.gpio1_led_show_show_gpio_active_high_action.trigger()
elif config == BrickletPerformanceDC.GPIO_LED_CONFIG_SHOW_GPIO_ACTIVE_LOW:
self.gpio1_led_show_show_gpio_active_low_action.trigger()
def cb_emergency_shutdown(self):
# Refresh enabled checkbox in case of emergency shutdown
async_call(self.dc.get_enabled, None, self.get_enabled_async,
self.increase_error_count)
if not self.qem.isVisible():
self.qem.setWindowTitle("Emergency Shutdown")
self.qem.showMessage(
"Emergency Shutdown: Short-Circuit or Over-Temperature or Under-Voltage"
)
def brake_value_changed(self, checked):
if checked:
try:
self.dc.set_drive_mode(0)
except ip_connection.Error:
return
def coast_value_changed(self, checked):
if checked:
try:
self.dc.set_drive_mode(1)
except ip_connection.Error:
return
def full_brake_clicked(self):
try:
self.dc.full_brake()
self.velocity_syncer.set_value(0)
except ip_connection.Error:
return
def get_drive_mode_async(self, dm):
if dm == 0:
self.radio_mode_brake.setChecked(True)
self.radio_mode_coast.setChecked(False)
else:
self.radio_mode_brake.setChecked(False)
self.radio_mode_coast.setChecked(True)
def get_power_statistics_async(self, ps):
if ps.current >= 1000:
current_str = "{0}A".format(round(ps.current / 1000.0, 1))
else:
current_str = "{0}mA".format(ps.current)
if ps.voltage >= 1000:
voltage_str = "{0}V".format(round(ps.voltage / 1000.0, 1))
else:
voltage_str = "{0}mV".format(ps.voltage)
temperature_str = "{0}°C".format(round(ps.temperature / 10.0, 1))
self.current_label.setText(current_str)
self.input_voltage_label.setText(voltage_str)
self.temperature_label.setText(temperature_str)
def get_current_velocity_async(self, velocity):
self.speedometer.set_velocity(velocity)
self.current_velocity_label.setText('{0} ({1}%)'.format(
velocity, round(abs(velocity) * 100 / 32768.0, 1)))
def get_velocity_async(self, velocity):
self.velocity_syncer.set_value(velocity)
def get_motion_async(self, motion):
self.acceleration_syncer.set_value(motion.acceleration)
self.deceleration_syncer.set_value(motion.deceleration)
def get_pwm_frequency_async(self, frequency):
self.frequency_syncer.set_value(frequency)
def get_enabled_async(self, enabled):
self.enable_checkbox.setChecked(enabled)
def get_gpio_configuration_async(self, channel, conf):
if channel == 0:
self.gpio0_debounce_spin.setValue(conf.debounce)
self.gpio0_stop_deceleration_spin.setValue(conf.stop_deceleration)
elif channel == 1:
self.gpio1_debounce_spin.setValue(conf.debounce)
self.gpio1_stop_deceleration_spin.setValue(conf.stop_deceleration)
def get_gpio_action_async(self, channel, action):
if channel == 0:
if action & self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE: # full brake has higher priority
self.gpio0_rising_combo.setCurrentIndex(2)
elif action & self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE:
self.gpio0_rising_combo.setCurrentIndex(1)
else:
self.gpio0_rising_combo.setCurrentIndex(0)
if action & self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE: # full brake has higher priority
self.gpio0_falling_combo.setCurrentIndex(2)
elif action & self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE:
self.gpio0_falling_combo.setCurrentIndex(1)
else:
self.gpio0_falling_combo.setCurrentIndex(0)
elif channel == 1:
if action & self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE: # full brake has higher priority
self.gpio1_rising_combo.setCurrentIndex(2)
elif action & self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE:
self.gpio1_rising_combo.setCurrentIndex(1)
else:
self.gpio1_rising_combo.setCurrentIndex(0)
if action & self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE: # full brake has higher priority
self.gpio1_falling_combo.setCurrentIndex(2)
elif action & self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE:
self.gpio1_falling_combo.setCurrentIndex(1)
else:
self.gpio1_falling_combo.setCurrentIndex(0)
def get_gpio_state_async(self, state):
if state[0]:
self.gpio0_state_label.setText('High')
else:
self.gpio0_state_label.setText('Low')
if state[1]:
self.gpio1_state_label.setText('High')
else:
self.gpio1_state_label.setText('Low')
def enable_state_changed(self, state):
try:
self.dc.set_enabled(state == Qt.Checked)
except ip_connection.Error:
return
def motion_changed(self, _):
acceleration = self.acceleration_spin.value()
deceleration = self.deceleration_spin.value()
try:
self.dc.set_motion(acceleration, deceleration)
except ip_connection.Error:
return
def velocity_changed(self, value):
try:
self.dc.set_velocity(value)
except ip_connection.Error:
return
def frequency_changed(self, value):
try:
self.dc.set_pwm_frequency(value)
except ip_connection.Error:
return
def gpio_action_changed(self, channel):
async_call(self.dc.get_gpio_action, channel,
lambda x: self.gpio_action_changed_step2(channel, x),
self.increase_error_count)
def gpio_action_changed_step2(self, channel, action):
action &= self.dc.GPIO_ACTION_CALLBACK_RISING_EDGE | self.dc.GPIO_ACTION_CALLBACK_FALLING_EDGE
if channel == 0:
rising = self.gpio0_rising_combo.currentIndex()
falling = self.gpio0_falling_combo.currentIndex()
elif channel == 1:
rising = self.gpio1_rising_combo.currentIndex()
falling = self.gpio1_falling_combo.currentIndex()
else:
return # unreachable
if rising == 1: action |= self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE
if falling == 1: action |= self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE
if rising == 2: action |= self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE
if falling == 2: action |= self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE
self.dc.set_gpio_action(channel, action)
def gpio_configuration_changed(self, channel):
if channel == 0:
debounce = self.gpio0_debounce_spin.value()
stop_deceleration = self.gpio0_stop_deceleration_spin.value()
elif channel == 1:
debounce = self.gpio1_debounce_spin.value()
stop_deceleration = self.gpio1_stop_deceleration_spin.value()
self.dc.set_gpio_configuration(channel, debounce, stop_deceleration)
