def __init__(self, *args):
PluginBase.__init__(self, BrickletOLED64x48, *args)
self.setupUi(self)
self.oled = self.device
self.scribble_widget = ScribbleWidget(64,
48,
7,
QColor(Qt.white),
QColor(Qt.black),
enable_grid=False)
self.image_button_layout.insertWidget(0, self.scribble_widget)
self.contrast_syncer = SliderSpinSyncer(
self.contrast_slider,
self.contrast_spin,
lambda value: self.new_configuration(),
spin_signal='valueChanged')
self.char_syncer = SliderSpinSyncer(self.char_slider,
self.char_spin,
self.char_slider_changed,
spin_signal='valueChanged')
self.draw_button.clicked.connect(self.draw_clicked)
self.clear_button.clicked.connect(self.clear_clicked)
self.send_button.clicked.connect(self.send_clicked)
self.clear_display_button.clicked.connect(self.clear_display_clicked)
self.invert_checkbox.stateChanged.connect(self.new_configuration)
self.current_char_value = -1
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletLCD128x64, *args)
self.setupUi(self)
self.lcd = self.device
self.scribble_area = ScribbleArea(128, 64)
self.image_button_layout.insertWidget(0, self.scribble_area)
self.contrast_syncer = SliderSpinSyncer(
self.contrast_slider, self.contrast_spin,
lambda value: self.new_configuration())
self.backlight_syncer = SliderSpinSyncer(
self.backlight_slider, self.backlight_spin,
lambda value: self.new_configuration())
self.char_syncer = SliderSpinSyncer(self.char_slider, self.char_spin,
self.char_slider_changed)
self.draw_button.clicked.connect(self.draw_clicked)
self.clear_button.clicked.connect(self.clear_clicked)
self.send_button.clicked.connect(self.send_clicked)
self.clear_display_button.clicked.connect(self.clear_display_clicked)
self.invert_checkbox.stateChanged.connect(self.new_configuration)
self.current_char_value = -1
self.write_line_response_expected = False
self.cbe_touch_position = CallbackEmulator(
self.lcd.get_touch_position, self.scribble_area.touch_position,
self.increase_error_count)
self.cbe_touch_gesture = CallbackEmulator(
self.lcd.get_touch_gesture, self.scribble_area.touch_gesture,
self.increase_error_count)
def __init__(self, *args):
PluginBase.__init__(self, BrickletIndustrialAnalogOut, *args)
self.setupUi(self)
self.ao = self.device
self.voltage_syncer = SliderSpinSyncer(self.slider_voltage,
self.spin_voltage,
self.voltage_changed)
self.current_syncer = SliderSpinSyncer(self.slider_current,
self.spin_current,
self.current_changed)
self.radio_voltage.clicked.connect(self.radio_clicked)
self.radio_current.clicked.connect(self.radio_clicked)
self.box_voltage_range.currentIndexChanged.connect(self.config_changed)
self.box_current_range.currentIndexChanged.connect(self.config_changed)
self.checkbox_enable.clicked.connect(self.enable_changed)
self.last_voltage = 0
self.last_current = 4000
self.last_voltage_range = 0
self.last_current_range = 1
self.new_voltage(self.last_voltage)
self.new_current(self.last_current)
self.mode_voltage()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletOLED128x64V2, *args)
self.setupUi(self)
self.oled = self.device
self.scribble_widget = ScribbleWidget(128,
64,
5,
QColor(Qt.white),
QColor(Qt.black),
enable_grid=False)
self.image_button_layout.insertWidget(0, self.scribble_widget)
self.contrast_syncer = SliderSpinSyncer(
self.contrast_slider, self.contrast_spin,
lambda value: self.new_configuration())
self.char_syncer = SliderSpinSyncer(self.char_slider, self.char_spin,
self.char_slider_changed)
self.draw_button.clicked.connect(self.draw_clicked)
self.clear_button.clicked.connect(self.clear_clicked)
self.send_button.clicked.connect(self.send_clicked)
self.clear_display_button.clicked.connect(self.clear_display_clicked)
self.invert_checkbox.stateChanged.connect(self.new_configuration)
self.current_char_value = -1
self.write_line_response_expected = None
def __init__(self, *args):
TNGPluginBase.__init__(self, TNGAO4U4IBindings, *args)
self.setupUi(self)
self.ao_4u_4i = self.device
self.voltages = [
SliderSpinSyncer(self.slider_voltage_ch0, self.spin_voltage_ch0,
self.value_changed),
SliderSpinSyncer(self.slider_voltage_ch1, self.spin_voltage_ch1,
self.value_changed),
SliderSpinSyncer(self.slider_voltage_ch2, self.spin_voltage_ch2,
self.value_changed),
SliderSpinSyncer(self.slider_voltage_ch3, self.spin_voltage_ch3,
self.value_changed)
]
self.currents = [
SliderSpinSyncer(self.slider_current_ch0, self.spin_current_ch0,
self.value_changed),
SliderSpinSyncer(self.slider_current_ch1, self.spin_current_ch1,
self.value_changed),
SliderSpinSyncer(self.slider_current_ch2, self.spin_current_ch2,
self.value_changed),
SliderSpinSyncer(self.slider_current_ch3, self.spin_current_ch3,
self.value_changed)
]
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletPiezoSpeakerV2, *args)
self.setupUi(self)
self.ps = self.device
self.qtcb_beep_finished.connect(self.cb_beep)
self.ps.register_callback(self.ps.CALLBACK_BEEP_FINISHED,
self.qtcb_beep_finished.emit)
self.qtcb_alarm_finished.connect(self.cb_alarm)
self.ps.register_callback(self.ps.CALLBACK_ALARM_FINISHED,
self.qtcb_alarm_finished.emit)
self.frequency_syncer = SliderSpinSyncer(self.frequency_slider,
self.frequency_spinbox,
self.frequency_changed,
spin_signal='valueChanged')
self.volume_syncer = SliderSpinSyncer(self.volume_slider,
self.volume_spinbox,
self.volume_changed,
spin_signal='valueChanged')
self.beep_duration_syncer = SliderSpinSyncer(
self.beep_duration_slider,
self.beep_duration_spinbox,
self.beep_duration_changed,
spin_signal='valueChanged')
self.alarm_duration_syncer = SliderSpinSyncer(
self.alarm_duration_slider,
self.alarm_duration_spinbox,
self.alarm_duration_changed,
spin_signal='valueChanged')
self.alarm_start_frequency_syncer = SliderSpinSyncer(
self.alarm_start_frequency_slider,
self.alarm_start_frequency_spinbox,
self.alarm_start_frequency_changed,
spin_signal='valueChanged')
self.alarm_end_frequency_syncer = SliderSpinSyncer(
self.alarm_end_frequency_slider,
self.alarm_end_frequency_spinbox,
self.alarm_end_frequency_changed,
spin_signal='valueChanged')
self.alarm_step_size_syncer = SliderSpinSyncer(
self.alarm_step_size_slider,
self.alarm_step_size_spinbox,
self.alarm_step_size_changed,
spin_signal='valueChanged')
self.alarm_step_delay_syncer = SliderSpinSyncer(
self.alarm_step_delay_slider,
self.alarm_step_delay_spinbox,
self.alarm_step_delay_changed,
spin_signal='valueChanged')
self.beep_button.clicked.connect(self.beep_clicked)
self.alarm_button.clicked.connect(self.alarm_clicked)
self.new_value_timer = QTimer(self)
self.new_value_timer.timeout.connect(self.new_value_update)
self.last_frequency = self.frequency_spinbox.value()
self.last_volume = self.volume_spinbox.value()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletPerformanceDC, *args)
self.setupUi(self)
self.dc = self.device
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_stop_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio0_stop_falling_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio0_brake_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio0_brake_falling_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio1_stop_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(1))
self.gpio1_stop_falling_check.stateChanged.connect(
lambda: self.gpio_action_changed(1))
self.gpio1_brake_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(1))
self.gpio1_brake_falling_check.stateChanged.connect(
lambda: 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.dc.get_power_statistics, None,
self.get_power_statistics_async, self.increase_error_count)
self.cbe_current_velocity = CallbackEmulator(
self.dc.get_current_velocity, None,
self.get_current_velocity_async, self.increase_error_count)
self.cbe_gpio_state = CallbackEmulator(self.dc.get_gpio_state, None,
self.get_gpio_state_async,
self.increase_error_count)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletLCD128x64, *args)
self.setupUi(self)
self.lcd = self.device
self.scribble_widget = TouchScribbleWidget(128,
64,
5,
QColor(Qt.black),
QColor(Qt.white),
enable_grid=False)
self.image_button_layout.insertWidget(0, self.scribble_widget)
self.contrast_syncer = SliderSpinSyncer(
self.contrast_slider,
self.contrast_spin,
lambda value: self.new_configuration(),
spin_signal='valueChanged')
self.backlight_syncer = SliderSpinSyncer(
self.backlight_slider,
self.backlight_spin,
lambda value: self.new_configuration(),
spin_signal='valueChanged')
self.char_syncer = SliderSpinSyncer(self.char_slider,
self.char_spin,
self.char_slider_changed,
spin_signal='valueChanged')
self.draw_button.clicked.connect(self.draw_clicked)
self.clear_button.clicked.connect(self.clear_clicked)
self.send_button.clicked.connect(self.send_clicked)
self.clear_display_button.clicked.connect(self.clear_display_clicked)
self.invert_checkbox.stateChanged.connect(self.new_configuration)
self.current_char_value = -1
self.write_line_response_expected = None
self.cbe_touch_position = CallbackEmulator(
self, self.lcd.get_touch_position, None,
self.scribble_widget.touch_position, self.increase_error_count)
self.cbe_touch_gesture = CallbackEmulator(
self, self.lcd.get_touch_gesture, None,
self.scribble_widget.touch_gesture, self.increase_error_count)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIndustrialAnalogOutV2, *args)
self.setupUi(self)
self.ao = self.device
self.voltage_syncer = SliderSpinSyncer(self.slider_voltage,
self.spin_voltage,
self.voltage_changed)
self.current_syncer = SliderSpinSyncer(self.slider_current,
self.spin_current,
self.current_changed)
self.radio_voltage.clicked.connect(self.radio_clicked)
self.radio_current.clicked.connect(self.radio_clicked)
self.box_voltage_range.currentIndexChanged.connect(self.config_changed)
self.box_current_range.currentIndexChanged.connect(self.config_changed)
self.checkbox_enable.clicked.connect(self.enable_changed)
self.cbox_osl_lc.currentIndexChanged.connect(self.cbox_osl_lc_changed)
self.cbox_osl_lsc.currentIndexChanged.connect(
self.cbox_osl_lsc_changed)
self.sbox_osl_min.valueChanged.connect(self.sbox_osl_min_changed)
self.sbox_osl_max.valueChanged.connect(self.sbox_osl_max_changed)
self.ui_grp_show_ch_status = [
self.cbox_osl_lsc, self.sbox_osl_min, self.sbox_osl_max
]
self.box_voltage_range.setCurrentIndex(1)
self.box_current_range.setCurrentIndex(0)
self.new_voltage(0)
self.new_current(0)
self.mode_voltage()
def __init__(self, *args):
PluginBase.__init__(self, BrickletOLED128x64, *args)
self.setupUi(self)
self.oled = self.device
self.scribble_area = ScribbleArea(128, 64)
self.image_button_layout.insertWidget(0, self.scribble_area)
self.contrast_syncer = SliderSpinSyncer(
self.contrast_slider, self.contrast_spin,
lambda value: self.new_configuration())
self.char_syncer = SliderSpinSyncer(self.char_slider, self.char_spin,
self.char_slider_changed)
self.draw_button.clicked.connect(self.draw_clicked)
self.clear_button.clicked.connect(self.clear_clicked)
self.send_button.clicked.connect(self.send_clicked)
self.clear_display_button.clicked.connect(self.clear_display_clicked)
self.invert_checkbox.stateChanged.connect(self.new_configuration)
self.current_char_value = -1
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletRGBLEDV2, *args)
self.rgb_led = self.device
self.changing = False
self.set_rgb_value_response_expected = None
self.setupUi(self)
self.r_syncer = SliderSpinSyncer(self.slider_r,
self.spin_r,
self.rgb_changed,
spin_signal='valueChanged')
self.g_syncer = SliderSpinSyncer(self.slider_g,
self.spin_g,
self.rgb_changed,
spin_signal='valueChanged')
self.b_syncer = SliderSpinSyncer(self.slider_b,
self.spin_b,
self.rgb_changed,
spin_signal='valueChanged')
self.h_syncer = SliderSpinSyncer(self.slider_h,
self.spin_h,
self.hsl_changed,
spin_signal='valueChanged')
self.s_syncer = SliderSpinSyncer(self.slider_s,
self.spin_s,
self.hsl_changed,
spin_signal='valueChanged')
self.l_syncer = SliderSpinSyncer(self.slider_l,
self.spin_l,
self.hsl_changed,
spin_signal='valueChanged')
def set_color(r, g, b):
self.changing = True
self.spin_r.setValue(r)
self.spin_g.setValue(g)
self.spin_b.setValue(b)
self.changing = False
self.rgb_changed()
for color, button in zip(
[(0, 0, 0), (255, 255, 255), (255, 0, 0), (255, 255, 0),
(0, 255, 0), (0, 255, 255), (0, 0, 255), (255, 0, 255)], [
self.button_black, self.button_white, self.button_red,
self.button_yellow, self.button_green, self.button_cyan,
self.button_blue, self.button_magenta
]):
button.clicked.connect(lambda clicked, c=color: set_color(*c))
pixmap = QPixmap(16, 16)
QPainter(pixmap).fillRect(0, 0, 16, 16, QColor(*color))
button.setIcon(QIcon(pixmap))
button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletRGBLEDButton, *args)
self.rgb_led_button = self.device
self.changing = False
self.setupUi(self)
self.qtcb_button_state_changed.connect(self.cb_button_state_changed)
self.rgb_led_button.register_callback(
self.rgb_led_button.CALLBACK_BUTTON_STATE_CHANGED,
self.qtcb_button_state_changed.emit)
self.r_syncer = SliderSpinSyncer(self.slider_r,
self.spin_r,
self.rgb_changed,
spin_signal='valueChanged')
self.g_syncer = SliderSpinSyncer(self.slider_g,
self.spin_g,
self.rgb_changed,
spin_signal='valueChanged')
self.b_syncer = SliderSpinSyncer(self.slider_b,
self.spin_b,
self.rgb_changed,
spin_signal='valueChanged')
self.h_syncer = SliderSpinSyncer(self.slider_h,
self.spin_h,
self.hsl_changed,
spin_signal='valueChanged')
self.s_syncer = SliderSpinSyncer(self.slider_s,
self.spin_s,
self.hsl_changed,
spin_signal='valueChanged')
self.l_syncer = SliderSpinSyncer(self.slider_l,
self.spin_l,
self.hsl_changed,
spin_signal='valueChanged')
def set_color(r, g, b):
self.changing = True
self.spin_r.setValue(r)
self.spin_g.setValue(g)
self.spin_b.setValue(b)
self.changing = False
self.rgb_changed()
self.button_black.clicked.connect(lambda: set_color(0, 0, 0))
self.button_white.clicked.connect(lambda: set_color(255, 255, 255))
self.button_red.clicked.connect(lambda: set_color(255, 0, 0))
self.button_yellow.clicked.connect(lambda: set_color(255, 255, 0))
self.button_green.clicked.connect(lambda: set_color(0, 255, 0))
self.button_cyan.clicked.connect(lambda: set_color(0, 255, 255))
self.button_blue.clicked.connect(lambda: set_color(0, 0, 255))
self.button_magenta.clicked.connect(lambda: set_color(255, 0, 255))
def __init__(self, *args):
PluginBase.__init__(self, BrickletRGBLED, *args)
self.rgb_led = self.device
self.changing = False
self.setupUi(self)
self.r_syncer = SliderSpinSyncer(self.slider_r,
self.spin_r,
self.rgb_changed,
spin_signal='valueChanged')
self.g_syncer = SliderSpinSyncer(self.slider_g,
self.spin_g,
self.rgb_changed,
spin_signal='valueChanged')
self.b_syncer = SliderSpinSyncer(self.slider_b,
self.spin_b,
self.rgb_changed,
spin_signal='valueChanged')
self.h_syncer = SliderSpinSyncer(self.slider_h,
self.spin_h,
self.hsl_changed,
spin_signal='valueChanged')
self.s_syncer = SliderSpinSyncer(self.slider_s,
self.spin_s,
self.hsl_changed,
spin_signal='valueChanged')
self.l_syncer = SliderSpinSyncer(self.slider_l,
self.spin_l,
self.hsl_changed,
spin_signal='valueChanged')
def set_color(r, g, b):
self.changing = True
self.spin_r.setValue(r)
self.spin_g.setValue(g)
self.spin_b.setValue(b)
self.changing = False
self.rgb_changed()
self.button_black.clicked.connect(lambda: set_color(0, 0, 0))
self.button_white.clicked.connect(lambda: set_color(255, 255, 255))
self.button_red.clicked.connect(lambda: set_color(255, 0, 0))
self.button_yellow.clicked.connect(lambda: set_color(255, 255, 0))
self.button_green.clicked.connect(lambda: set_color(0, 255, 0))
self.button_cyan.clicked.connect(lambda: set_color(0, 255, 255))
self.button_blue.clicked.connect(lambda: set_color(0, 0, 255))
self.button_magenta.clicked.connect(lambda: set_color(255, 0, 255))
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 __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])])
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
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])])
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 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)
class PerformanceDC(COMCUPluginBase, Ui_PerformanceDC):
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletPerformanceDC, *args)
self.setupUi(self)
self.dc = self.device
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_stop_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio0_stop_falling_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio0_brake_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio0_brake_falling_check.stateChanged.connect(
lambda: self.gpio_action_changed(0))
self.gpio1_stop_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(1))
self.gpio1_stop_falling_check.stateChanged.connect(
lambda: self.gpio_action_changed(1))
self.gpio1_brake_rising_check.stateChanged.connect(
lambda: self.gpio_action_changed(1))
self.gpio1_brake_falling_check.stateChanged.connect(
lambda: 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.dc.get_power_statistics, None,
self.get_power_statistics_async, self.increase_error_count)
self.cbe_current_velocity = CallbackEmulator(
self.dc.get_current_velocity, None,
self.get_current_velocity_async, self.increase_error_count)
self.cbe_gpio_state = CallbackEmulator(self.dc.get_gpio_state, None,
self.get_gpio_state_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)
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)
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 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:
self.gpio0_stop_rising_check.setChecked(
(action & self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE) != 0)
self.gpio0_stop_falling_check.setChecked(
(action & self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE) != 0)
self.gpio0_brake_rising_check.setChecked(
(action & self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE) != 0)
self.gpio0_brake_falling_check.setChecked(
(action & self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE) != 0)
elif channel == 1:
self.gpio1_stop_rising_check.setChecked(
(action & self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE) != 0)
self.gpio1_stop_falling_check.setChecked(
(action & self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE) != 0)
self.gpio1_brake_rising_check.setChecked(
(action & self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE) != 0)
self.gpio1_brake_falling_check.setChecked(
(action & self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE) != 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):
action = 0
if channel == 0:
if self.gpio0_stop_rising_check.isChecked():
action = action | self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE
if self.gpio0_stop_falling_check.isChecked():
action = action | self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE
if self.gpio0_brake_rising_check.isChecked():
action = action | self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE
if self.gpio0_brake_falling_check.isChecked():
action = action | self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE
elif channel == 1:
if self.gpio1_stop_rising_check.isChecked():
action = action | self.dc.GPIO_ACTION_NORMAL_STOP_RISING_EDGE
if self.gpio1_stop_falling_check.isChecked():
action = action | self.dc.GPIO_ACTION_NORMAL_STOP_FALLING_EDGE
if self.gpio1_brake_rising_check.isChecked():
action = action | self.dc.GPIO_ACTION_FULL_BRAKE_RISING_EDGE
if self.gpio1_brake_falling_check.isChecked():
action = action | self.dc.GPIO_ACTION_FULL_BRAKE_FALLING_EDGE
# TODO: Retain callback configuration
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)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletMotionDetectorV2, *args)
self.motion_detector_v2 = self.device
self.changing = False
self.setupUi(self)
self.qtcb_motion_detected.connect(self.cb_motion_detected)
self.motion_detector_v2.register_callback(
self.motion_detector_v2.CALLBACK_MOTION_DETECTED,
self.qtcb_motion_detected.emit)
self.qtcb_detection_cylce_ended.connect(self.cb_detection_cycle_ended)
self.motion_detector_v2.register_callback(
self.motion_detector_v2.CALLBACK_DETECTION_CYCLE_ENDED,
self.qtcb_detection_cylce_ended.emit)
self.left_syncer = SliderSpinSyncer(self.slider_left,
self.spin_left,
self.indicator_changed,
spin_signal='valueChanged')
self.right_syncer = SliderSpinSyncer(self.slider_right,
self.spin_right,
self.indicator_changed,
spin_signal='valueChanged')
self.bottom_syncer = SliderSpinSyncer(self.slider_bottom,
self.spin_bottom,
self.indicator_changed,
spin_signal='valueChanged')
self.all_syncer = SliderSpinSyncer(self.slider_all,
self.spin_all,
self.all_changed,
spin_signal='valueChanged')
self.sensitivity_syncer = SliderSpinSyncer(self.slider_sensitivity,
self.spin_sensitivity,
self.sensitivity_changed,
spin_signal='valueChanged')
def set_indicator(l, r, b):
self.changing = True
self.spin_left.setValue(l)
self.spin_right.setValue(r)
self.spin_bottom.setValue(b)
self.changing = False
self.indicator_changed()
self.button_off.clicked.connect(lambda: set_indicator(0, 0, 0))
self.button_on.clicked.connect(lambda: set_indicator(255, 255, 255))
self.button_left.clicked.connect(lambda: set_indicator(255, 0, 0))
self.button_right.clicked.connect(lambda: set_indicator(0, 255, 0))
self.button_bottom.clicked.connect(lambda: set_indicator(0, 0, 255))
self.indicator_update = False
self.indicator_value = [0, 0, 0]
self.sensitivity_update = False
self.sensitivity_value = 50
self.update_timer = QTimer()
self.update_timer.timeout.connect(self.update)
self.update_timer.setInterval(50)
self.update_timer.start()
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 __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletServoV2, *args)
self.setupUi(self)
self.servo = self.device
self.cbe_status = CallbackEmulator(self,
self.servo.get_status,
None,
self.cb_status,
self.increase_error_count)
self.position_list = []
self.velocity_list = []
self.current_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]*10
self.up_pos = [0]*10
self.up_vel = [0]*10
self.up_acc = [0]*10
self.alive = True
for i in range(1, 11):
label = QLabel()
label.setText('Off')
self.enable_list.append(label)
self.status_grid.addWidget(label, i, 1)
for i in range(1, 11):
pk = PositionKnob()
self.position_list.append(pk)
self.status_grid.addWidget(pk, i, 2)
for i in range(1, 11):
cb = ColorBar(Qt.Vertical)
self.velocity_list.append(cb)
self.status_grid.addWidget(cb, i, 3)
for i in range(1, 11):
cb = ColorBar(Qt.Vertical)
self.current_list.append(cb)
self.status_grid.addWidget(cb, i, 4)
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.motion_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.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)
def __init__(self, *args):
PluginBase.__init__(self, BrickStepper, *args)
self.setupUi(self)
self.stepper = self.device
self.endis_all(False)
self.update_timer = QTimer()
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.decay_syncer = SliderSpinSyncer(self.decay_slider,
# self.decay_spin,
# self.decay_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.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.firmware_version >= (1, 1, 4):
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.stepper.reset())
self.set_actions(reset)
class PerformanceStepper(COMCUPluginBase, Ui_PerformanceStepper):
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletPerformanceStepper, *args)
self.setupUi(self)
self.ps = self.device
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.update_counter = 0
# Init register access elements
self.parent_items = {}
for register_name in registers.keys():
self.parent_items[register_name] = QTreeWidgetItem([register_name])
for pi in self.parent_items.values():
self.tree_widget.addTopLevelItem(pi)
self.child_items = []
for name, rows in registers.items():
for row in rows:
child = QTreeWidgetItem([row[0], hex(row[1]), row[2], '0', ''])
self.child_items.append(child)
self.parent_items[name].addChild(child)
for pi in self.parent_items.values():
pi.setExpanded(True)
self.tree_widget.itemClicked.connect(self.register_item_clicked)
self.button_read_registers.clicked.connect(self.read_registers_clicked)
self.button_write_register.clicked.connect(self.write_register_clicked)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.maximum_motor_current_spinbox.valueChanged.connect(
self.maximum_motor_current_changed)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
# Motion Configuration
self.velocity_start_syncer = SliderSpinSyncer(
self.velocity_start_slider, self.velocity_start_spinbox,
self.motion_changed)
self.velocity_stop_syncer = SliderSpinSyncer(
self.velocity_stop_slider, self.velocity_stop_spinbox,
self.motion_changed)
self.velocity_1_syncer = SliderSpinSyncer(self.velocity_1_slider,
self.velocity_1_spinbox,
self.motion_changed)
self.velocity_max_syncer = SliderSpinSyncer(self.velocity_max_slider,
self.velocity_max_spinbox,
self.motion_changed)
self.acceleration_1_syncer = SliderSpinSyncer(
self.acceleration_1_slider, self.acceleration_1_spinbox,
self.motion_changed)
self.acceleration_max_syncer = SliderSpinSyncer(
self.acceleration_max_slider, self.acceleration_max_spinbox,
self.motion_changed)
self.deceleration_max_syncer = SliderSpinSyncer(
self.deceleration_max_slider, self.deceleration_max_spinbox,
self.motion_changed)
self.deceleration_1_syncer = SliderSpinSyncer(
self.deceleration_1_slider, self.deceleration_1_spinbox,
self.motion_changed)
self.ramp_zero_wait_syncer = SliderSpinSyncer(
self.ramp_zero_wait_slider, self.ramp_zero_wait_spinbox,
self.motion_changed)
# 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.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.high_velocity_fullstep_checkbox.stateChanged.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.offset_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.enable_autogradient_checkbox.stateChanged.connect(
self.stealth_configuration_changed)
self.freewheel_mode_combo.currentIndexChanged.connect(
self.stealth_configuration_changed)
self.regulation_loop_gradient_spin.valueChanged.connect(
self.stealth_configuration_changed)
self.amplitude_limit_spin.valueChanged.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)
# Short Configuration
self.disable_short_to_voltage_protection_checkbox.stateChanged.connect(
self.short_configuration_changed)
self.disable_short_to_ground_protection_checkbox.stateChanged.connect(
self.short_configuration_changed)
self.short_to_voltage_level_spin.valueChanged.connect(
self.short_configuration_changed)
self.short_to_ground_level_spin.valueChanged.connect(
self.short_configuration_changed)
self.spike_filter_bandwidth_combo.currentIndexChanged.connect(
self.short_configuration_changed)
self.short_detection_delay_checkbox.stateChanged.connect(
self.short_configuration_changed)
self.filter_time_combo.currentIndexChanged.connect(
self.short_configuration_changed)
def motion_changed(self, _):
ramping_mode = self.ramping_mode_combobox.currentIndex()
velocity_start = self.velocity_start_slider.value()
acceleration_1 = self.acceleration_1_slider.value()
velocity_1 = self.velocity_1_slider.value()
acceleration_max = self.acceleration_max_slider.value()
velocity_max = self.velocity_max_slider.value()
deceleration_max = self.deceleration_max_slider.value()
deceleration_1 = self.deceleration_1_slider.value()
velocity_stop = self.velocity_stop_slider.value()
ramp_zero_wait = self.ramp_zero_wait_slider.value()
motion_configuration = (ramping_mode, velocity_start, acceleration_1,
velocity_1, acceleration_max, velocity_max,
deceleration_max, deceleration_1,
velocity_stop, ramp_zero_wait)
self.ps.set_motion_configuration(*motion_configuration)
def register_item_clicked(self, item, column):
try:
reg = int(item.text(1), 16)
value = int(item.text(3))
self.spinbox_write_register.setValue(reg)
self.spinbox_write_value.setValue(value)
except:
pass
def read_registers_clicked(self):
for child in self.child_items:
reg = int(child.text(1), 0)
ret = self.ps.read_register(reg)
child.setText(3, str(ret.value))
def write_register_clicked(self):
reg = self.spinbox_write_register.value()
value = self.spinbox_write_value.value()
ret = self.ps.write_register(reg, value)
def start(self):
async_call(self.ps.get_motion_configuration, None,
self.get_motion_configuration_async,
self.increase_error_count)
async_call(self.ps.get_step_configuration, None,
self.get_step_configuration_async,
self.increase_error_count)
async_call(self.ps.get_motor_current, None,
self.get_motor_current_async, self.increase_error_count)
async_call(self.ps.get_enabled, None, self.get_enabled_async,
self.increase_error_count)
async_call(self.ps.get_step_configuration, None,
self.get_step_configuration_async,
self.increase_error_count)
async_call(self.ps.get_basic_configuration, None,
self.get_basic_configuration_async,
self.increase_error_count)
async_call(self.ps.get_spreadcycle_configuration, None,
self.get_spreadcycle_configuration_async,
self.increase_error_count)
async_call(self.ps.get_stealth_configuration, None,
self.get_stealth_configuration_async,
self.increase_error_count)
async_call(self.ps.get_coolstep_configuration, None,
self.get_coolstep_configuration_async,
self.increase_error_count)
async_call(self.ps.get_short_configuration, None,
self.get_short_configuration_async,
self.increase_error_count)
self.update_timer.start(100)
def stop(self):
self.update_timer.stop()
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletPerformanceStepper.DEVICE_IDENTIFIER
def update_data(self):
async_call(self.ps.get_remaining_steps, None,
self.get_remaining_steps_async, self.increase_error_count)
async_call(self.ps.get_current_position, None,
self.get_current_position_async, self.increase_error_count)
async_call(self.ps.get_current_velocity, None,
self.get_current_velocity_async, self.increase_error_count)
self.update_counter += 1
if self.update_counter % 10 == 0:
async_call(self.ps.get_input_voltage, None,
self.get_input_voltage_async, self.increase_error_count)
async_call(self.ps.get_driver_status, None,
self.get_driver_status_async, self.increase_error_count)
async_call(self.ps.get_temperature, None,
self.get_temperature_async, self.increase_error_count)
def to_button_clicked(self):
drive_to = self.to_spin.value()
try:
self.ps.set_target_position(drive_to)
except ip_connection.Error:
return
def steps_button_clicked(self):
drive_steps = self.steps_spin.value()
try:
self.ps.set_steps(drive_steps)
except ip_connection.Error:
return
def enable_state_changed(self, state):
self.ps.set_enabled(state == Qt.Checked)
def maximum_motor_current_changed(self, value):
try:
self.ps.set_motor_current(value)
except ip_connection.Error:
return
def step_configuration_changed(self, _):
step_resolution = self.step_resolution_dropbox.currentIndex()
interpolation = self.interpolate_checkbox.isChecked()
try:
self.ps.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.ps.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()
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()
high_velocity_fullstep = self.high_velocity_fullstep_checkbox.isChecked(
)
fast_decay_without_comparator = self.fast_decay_without_comparator_checkbox.isChecked(
)
try:
self.ps.set_spreadcycle_configuration(
slow_decay_duration, high_velocity_fullstep,
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()
offset = self.offset_spin.value()
gradient = self.gradient_spin.value()
enable_autoscale = self.enable_autoscale_checkbox.isChecked()
enable_autogradient = self.enable_autogradient_checkbox.isChecked()
freewheel_mode = self.freewheel_mode_combo.currentIndex()
regulation_loop_gradient = self.regulation_loop_gradient_spin.value()
amplitude_limit = self.amplitude_limit_spin.value()
try:
self.ps.set_stealth_configuration(enable_stealth, offset, gradient,
enable_autoscale,
enable_autogradient,
freewheel_mode,
regulation_loop_gradient,
amplitude_limit)
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.ps.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 short_configuration_changed(self, _):
disable_short_to_voltage_protection = self.disable_short_to_voltage_protection_checkbox.isChecked(
)
disable_short_to_ground_protection = self.disable_short_to_ground_protection_checkbox.isChecked(
)
short_to_voltage_level = self.short_to_voltage_level_spin.value()
short_to_ground_level = self.short_to_ground_level_spin.value()
spike_filter_bandwidth = self.spike_filter_bandwidth_combo.currentIndex(
)
short_detection_delay = self.short_detection_delay_checkbox.isChecked()
filter_time = self.filter_time_combo.currentIndex()
try:
self.ps.set_short_configuration(
disable_short_to_voltage_protection,
disable_short_to_ground_protection, short_to_voltage_level,
short_to_ground_level, spike_filter_bandwidth,
short_detection_delay, filter_time)
except ip_connection.Error:
return
def get_remaining_steps_async(self, remaining_steps):
self.remaining_steps_label.setText(str(remaining_steps))
def get_current_position_async(self, current_position):
self.position_label.setText(str(current_position))
def get_current_velocity_async(self, current_velocity):
self.velocity_label.setText(str(current_velocity))
def get_input_voltage_async(self, input_voltage):
self.input_voltage_label.setText('{0:.1f}V'.format(input_voltage /
1000))
def get_temperature_async(self, temperature):
self.status_temperature.setText('{0:.1f}°C'.format(temperature / 10))
def get_driver_status_async(self, driver_status):
if driver_status.open_load == 0:
self.status_open_load.setText('No')
elif driver_status.open_load == 1:
self.status_open_load.setText('Phase A')
elif driver_status.open_load == 2:
self.status_open_load.setText('Phase B')
elif driver_status.open_load == 3:
self.status_open_load.setText('Phase A and B')
else:
self.status_open_load.setText('Unknown')
if driver_status.short_to_ground == 0:
self.status_short_to_ground.setText('No')
elif driver_status.short_to_ground == 1:
self.status_short_to_ground.setText('Phase A')
elif driver_status.short_to_ground == 2:
self.status_short_to_ground.setText('Phase B')
elif driver_status.short_to_ground == 3:
self.status_short_to_ground.setText('Phase A and B')
else:
self.status_short_to_ground.setText('Unknown')
if driver_status.over_temperature == 0:
self.status_over_temperature.setText('No')
elif driver_status.over_temperature == 1:
self.status_over_temperature.setText(
'<font color=yellow>Warning</font>')
elif driver_status.over_temperature == 2:
self.status_over_temperature.setText(
'<font color=red>Limit</font>')
if driver_status.motor_stalled:
self.status_motor_stalled.setText('Yes')
else:
self.status_motor_stalled.setText('No')
self.status_actual_motor_current.setText(
str(driver_status.actual_motor_current))
if driver_status.full_step_active:
self.status_full_step_active.setText('Yes')
else:
self.status_full_step_active.setText('No')
self.status_stallguard_result.setText(
str(driver_status.stallguard_result))
self.status_stealth_voltage_amplitude.setText(
str(driver_status.stealth_voltage_amplitude))
def get_enabled_async(self, enabled):
old_state = self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(enabled)
self.enable_checkbox.blockSignals(old_state)
def get_motor_current_async(self, value):
old_state = self.maximum_motor_current_spinbox.blockSignals(True)
self.maximum_motor_current_spinbox.setValue(value)
self.maximum_motor_current_spinbox.blockSignals(old_state)
def get_step_configuration_async(self, conf):
old_state = self.step_resolution_dropbox.blockSignals(True)
self.step_resolution_dropbox.setCurrentIndex(conf.step_resolution)
self.step_resolution_dropbox.blockSignals(old_state)
old_state = self.interpolate_checkbox.blockSignals(True)
self.interpolate_checkbox.setChecked(conf.interpolation)
self.interpolate_checkbox.blockSignals(old_state)
def get_motion_configuration_async(self, conf):
self.velocity_start_syncer.set_value(conf.velocity_start)
self.acceleration_1_syncer.set_value(conf.acceleration_1)
self.velocity_1_syncer.set_value(conf.velocity_1)
self.acceleration_max_syncer.set_value(conf.acceleration_max)
self.velocity_max_syncer.set_value(conf.velocity_max)
self.deceleration_max_syncer.set_value(conf.deceleration_max)
self.deceleration_1_syncer.set_value(conf.deceleration_1)
self.velocity_stop_syncer.set_value(conf.velocity_stop)
self.ramp_zero_wait_syncer.set_value(conf.ramp_zero_wait)
self.ramping_mode_combobox.setCurrentIndex(conf.ramping_mode)
def get_basic_configuration_async(self, conf):
old_state = self.standstill_current_spin.blockSignals(True)
self.standstill_current_spin.setValue(conf.standstill_current)
self.standstill_current_spin.blockSignals(old_state)
old_state = self.motor_run_current_spin.blockSignals(True)
self.motor_run_current_spin.setValue(conf.motor_run_current)
self.motor_run_current_spin.blockSignals(old_state)
old_state = self.standstill_delay_time_spin.blockSignals(True)
self.standstill_delay_time_spin.setValue(conf.standstill_delay_time)
self.standstill_delay_time_spin.blockSignals(old_state)
old_state = self.power_down_time_spin.blockSignals(True)
self.power_down_time_spin.setValue(conf.power_down_time)
self.power_down_time_spin.blockSignals(old_state)
old_state = self.stealth_threshold_spin.blockSignals(True)
self.stealth_threshold_spin.setValue(conf.stealth_threshold)
self.stealth_threshold_spin.blockSignals(old_state)
old_state = self.coolstep_threashold_spin.blockSignals(True)
self.coolstep_threashold_spin.setValue(conf.coolstep_threshold)
self.coolstep_threashold_spin.blockSignals(old_state)
old_state = self.classic_threshold_spin.blockSignals(True)
self.classic_threshold_spin.setValue(conf.classic_threshold)
self.classic_threshold_spin.blockSignals(old_state)
old_state = 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(old_state)
def get_spreadcycle_configuration_async(self, conf):
old_state = self.slow_decay_duration_spin.blockSignals(True)
self.slow_decay_duration_spin.setValue(conf.slow_decay_duration)
self.slow_decay_duration_spin.blockSignals(old_state)
old_state = self.fast_decay_duration_spin.blockSignals(True)
self.fast_decay_duration_spin.setValue(conf.fast_decay_duration)
self.fast_decay_duration_spin.blockSignals(old_state)
old_state = self.hysteresis_start_value_spin.blockSignals(True)
self.hysteresis_start_value_spin.setValue(conf.hysteresis_start_value)
self.hysteresis_start_value_spin.blockSignals(old_state)
old_state = self.hysteresis_end_value_spin.blockSignals(True)
self.hysteresis_end_value_spin.setValue(conf.hysteresis_end_value)
self.hysteresis_end_value_spin.blockSignals(old_state)
old_state = self.sine_wave_offset_spin.blockSignals(True)
self.sine_wave_offset_spin.setValue(conf.sine_wave_offset)
self.sine_wave_offset_spin.blockSignals(old_state)
old_state = self.chopper_mode_combo.blockSignals(True)
self.chopper_mode_combo.setCurrentIndex(conf.chopper_mode)
self.chopper_mode_combo.blockSignals(old_state)
old_state = self.standstill_current_spin.blockSignals(True)
self.comparator_blank_time_combo.setCurrentIndex(
conf.comparator_blank_time)
self.standstill_current_spin.blockSignals(old_state)
old_state = self.high_velocity_fullstep_checkbox.blockSignals(True)
self.high_velocity_fullstep_checkbox.setChecked(
conf.high_velocity_fullstep)
self.high_velocity_fullstep_checkbox.blockSignals(old_state)
old_state = 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(old_state)
def get_stealth_configuration_async(self, conf):
old_state = self.enable_stealth_checkbox.blockSignals(True)
self.enable_stealth_checkbox.setChecked(conf.enable_stealth)
self.enable_stealth_checkbox.blockSignals(old_state)
old_state = self.offset_spin.blockSignals(True)
self.offset_spin.setValue(conf.offset)
self.offset_spin.blockSignals(old_state)
old_state = self.gradient_spin.blockSignals(True)
self.gradient_spin.setValue(conf.gradient)
self.gradient_spin.blockSignals(old_state)
old_state = self.enable_autoscale_checkbox.blockSignals(True)
self.enable_autoscale_checkbox.setChecked(conf.enable_autoscale)
self.enable_autoscale_checkbox.blockSignals(old_state)
old_state = self.enable_autogradient_checkbox.blockSignals(True)
self.enable_autogradient_checkbox.setChecked(conf.enable_autogradient)
self.enable_autogradient_checkbox.blockSignals(old_state)
old_state = self.freewheel_mode_combo.blockSignals(True)
self.freewheel_mode_combo.setCurrentIndex(conf.freewheel_mode)
self.freewheel_mode_combo.blockSignals(old_state)
old_state = self.regulation_loop_gradient_spin.blockSignals(True)
self.regulation_loop_gradient_spin.setValue(
conf.regulation_loop_gradient)
self.regulation_loop_gradient_spin.blockSignals(old_state)
old_state = self.amplitude_limit_spin.blockSignals(True)
self.amplitude_limit_spin.setValue(conf.amplitude_limit)
self.amplitude_limit_spin.blockSignals(old_state)
def get_coolstep_configuration_async(self, conf):
old_state = self.minimum_stallguard_value_spin.blockSignals(True)
self.minimum_stallguard_value_spin.setValue(
conf.minimum_stallguard_value)
self.minimum_stallguard_value_spin.blockSignals(old_state)
old_state = self.maximum_stallguard_value_spin.blockSignals(True)
self.maximum_stallguard_value_spin.setValue(
conf.maximum_stallguard_value)
self.maximum_stallguard_value_spin.blockSignals(old_state)
old_state = 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(old_state)
old_state = 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(old_state)
old_state = self.minimum_current_combo.blockSignals(True)
self.minimum_current_combo.setCurrentIndex(conf.minimum_current)
self.minimum_current_combo.blockSignals(old_state)
old_state = self.stallguard_threshold_value_spin.blockSignals(True)
self.stallguard_threshold_value_spin.setValue(
conf.stallguard_threshold_value)
self.stallguard_threshold_value_spin.blockSignals(old_state)
old_state = self.stallguard_mode_combo.blockSignals(True)
self.stallguard_mode_combo.setCurrentIndex(conf.stallguard_mode)
self.stallguard_mode_combo.blockSignals(old_state)
def get_short_configuration_async(self, conf):
old_state = self.disable_short_to_voltage_protection_checkbox.blockSignals(
True)
self.disable_short_to_voltage_protection_checkbox.setChecked(
conf.disable_short_to_voltage_protection)
self.disable_short_to_voltage_protection_checkbox.blockSignals(
old_state)
old_state = 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(
old_state)
old_state = self.short_to_voltage_level_spin.blockSignals(True)
self.short_to_voltage_level_spin.setValue(conf.short_to_voltage_level)
self.short_to_voltage_level_spin.blockSignals(old_state)
old_state = self.short_to_ground_level_spin.blockSignals(True)
self.short_to_ground_level_spin.setValue(conf.short_to_ground_level)
self.short_to_ground_level_spin.blockSignals(old_state)
old_state = self.spike_filter_bandwidth_combo.blockSignals(True)
self.spike_filter_bandwidth_combo.setCurrentIndex(
conf.spike_filter_bandwidth)
self.spike_filter_bandwidth_combo.blockSignals(old_state)
old_state = self.short_detection_delay_checkbox.blockSignals(True)
self.short_detection_delay_checkbox.setChecked(
conf.short_detection_delay)
self.short_detection_delay_checkbox.blockSignals(old_state)
old_state = self.filter_time_combo.blockSignals(True)
self.filter_time_combo.setCurrentIndex(conf.filter_time)
self.filter_time_combo.blockSignals(old_state)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletPerformanceStepper, *args)
self.setupUi(self)
self.ps = self.device
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.update_counter = 0
# Init register access elements
self.parent_items = {}
for register_name in registers.keys():
self.parent_items[register_name] = QTreeWidgetItem([register_name])
for pi in self.parent_items.values():
self.tree_widget.addTopLevelItem(pi)
self.child_items = []
for name, rows in registers.items():
for row in rows:
child = QTreeWidgetItem([row[0], hex(row[1]), row[2], '0', ''])
self.child_items.append(child)
self.parent_items[name].addChild(child)
for pi in self.parent_items.values():
pi.setExpanded(True)
self.tree_widget.itemClicked.connect(self.register_item_clicked)
self.button_read_registers.clicked.connect(self.read_registers_clicked)
self.button_write_register.clicked.connect(self.write_register_clicked)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.maximum_motor_current_spinbox.valueChanged.connect(
self.maximum_motor_current_changed)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
# Motion Configuration
self.velocity_start_syncer = SliderSpinSyncer(
self.velocity_start_slider, self.velocity_start_spinbox,
self.motion_changed)
self.velocity_stop_syncer = SliderSpinSyncer(
self.velocity_stop_slider, self.velocity_stop_spinbox,
self.motion_changed)
self.velocity_1_syncer = SliderSpinSyncer(self.velocity_1_slider,
self.velocity_1_spinbox,
self.motion_changed)
self.velocity_max_syncer = SliderSpinSyncer(self.velocity_max_slider,
self.velocity_max_spinbox,
self.motion_changed)
self.acceleration_1_syncer = SliderSpinSyncer(
self.acceleration_1_slider, self.acceleration_1_spinbox,
self.motion_changed)
self.acceleration_max_syncer = SliderSpinSyncer(
self.acceleration_max_slider, self.acceleration_max_spinbox,
self.motion_changed)
self.deceleration_max_syncer = SliderSpinSyncer(
self.deceleration_max_slider, self.deceleration_max_spinbox,
self.motion_changed)
self.deceleration_1_syncer = SliderSpinSyncer(
self.deceleration_1_slider, self.deceleration_1_spinbox,
self.motion_changed)
self.ramp_zero_wait_syncer = SliderSpinSyncer(
self.ramp_zero_wait_slider, self.ramp_zero_wait_spinbox,
self.motion_changed)
# 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.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.high_velocity_fullstep_checkbox.stateChanged.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.offset_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.enable_autogradient_checkbox.stateChanged.connect(
self.stealth_configuration_changed)
self.freewheel_mode_combo.currentIndexChanged.connect(
self.stealth_configuration_changed)
self.regulation_loop_gradient_spin.valueChanged.connect(
self.stealth_configuration_changed)
self.amplitude_limit_spin.valueChanged.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)
# Short Configuration
self.disable_short_to_voltage_protection_checkbox.stateChanged.connect(
self.short_configuration_changed)
self.disable_short_to_ground_protection_checkbox.stateChanged.connect(
self.short_configuration_changed)
self.short_to_voltage_level_spin.valueChanged.connect(
self.short_configuration_changed)
self.short_to_ground_level_spin.valueChanged.connect(
self.short_configuration_changed)
self.spike_filter_bandwidth_combo.currentIndexChanged.connect(
self.short_configuration_changed)
self.short_detection_delay_checkbox.stateChanged.connect(
self.short_configuration_changed)
self.filter_time_combo.currentIndexChanged.connect(
self.short_configuration_changed)
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 __init__(self, *args):
PluginBase.__init__(self, BrickDC, *args)
self.setupUi(self)
self.dc = self.device
self.encoder_hide_all()
self.update_timer = QTimer()
self.update_timer.timeout.connect(self.update_data)
self.speedometer = SpeedoMeter()
self.vertical_layout_right.insertWidget(4, self.speedometer)
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, self.update_velocity,
self.increase_error_count)
if self.firmware_version >= (1, 1, 3):
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.dc.reset())
self.set_actions(reset)
def __init__(self, *args):
PluginBase.__init__(self, BrickServo, *args)
self.setupUi(self)
self.servo = self.device
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.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):
QThread.__init__(self, 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.firmware_version >= (1, 1, 3):
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.servo.reset())
self.set_actions(reset)
def __init__(self, *args):
PluginBase.__init__(self, BrickStepper, *args)
self.setupUi(self)
self.stepper = self.device
self.endis_all(False)
self.update_timer = QTimer()
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.firmware_version >= (2, 3, 1):
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
if self.firmware_version >= (1, 1, 4):
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.stepper.reset())
self.set_actions([(0, None, [reset])])