def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletRGBLEDMatrix, *args)
self.setupUi(self)
self.rgb_led_matrix = self.device
self.color_button = QColorButton()
self.below_scribble_layout.insertWidget(2, self.color_button)
self.scribble_widget = ScribbleWidget(8, 8, 35,
self.color_button.color(),
QColor(Qt.black))
def set_state_scribble():
self.state = self.STATE_COLOR_SCRIBBLE
self.scribble_widget.scribbling_started.connect(set_state_scribble)
self.scribble_layout.insertWidget(1, self.scribble_widget)
self.qtcb_frame_started.connect(self.cb_frame_started)
self.color_button.colorChanged.connect(self.color_changed)
self.button_clear_drawing.clicked.connect(
self.scribble_widget.clear_image)
self.button_drawing.clicked.connect(self.drawing_clicked)
self.button_color.clicked.connect(self.color_clicked)
self.button_gradient.clicked.connect(self.gradient_clicked)
self.button_dot.clicked.connect(self.dot_clicked)
self.box_frame_duration.valueChanged.connect(
self.frame_duration_changed)
self.state = self.STATE_IDLE
self.gradient_counter = 0
self.dot_counter = 0
self.dot_direction = 1
self.voltage = 0
self.cbe_supply_voltage = CallbackEmulator(
self, self.rgb_led_matrix.get_supply_voltage, None,
self.cb_supply_voltage, self.increase_error_count)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletEnergyMonitor, *args)
self.setupUi(self)
self.energy_monitor = self.device
self.cbe_get_energy_data = CallbackEmulator(self,
self.energy_monitor.get_energy_data,
None,
self.cb_energy_data,
self.increase_error_count)
self.cbe_get_transformer_status = CallbackEmulator(self,
self.energy_monitor.get_transformer_status,
None,
self.cb_transformer_status,
self.increase_error_count)
plots_waveform_v = [('Waveform V', Qt.red, None, None)]
self.plot_widget_waveform_v = PlotWidget('Voltage [V]', plots_waveform_v, clear_button=None, x_diff=768*ENERGY_MONITOR_MS_PER_TICK, x_scale_title_text='Time [ms]', key=None, x_scale_visible=False)
plots_waveform_a = [('Waveform A', Qt.red, None, None)]
self.plot_widget_waveform_a = PlotWidget('Current [A]', plots_waveform_a, clear_button=None, x_diff=768*ENERGY_MONITOR_MS_PER_TICK, x_scale_title_text='Time [ms]', key=None)
self.plot_widget_waveform_v.add_y_scale_sibling(self.plot_widget_waveform_a)
self.plot_widget_waveform_a.add_y_scale_sibling(self.plot_widget_waveform_v)
# try to make the actual curve area equal in height by fiddling with the
# minimum-height and the stretch factors
self.plot_widget_waveform_v.setMinimumHeight(194)
self.plot_widget_waveform_a.setMinimumHeight(250)
self.layout_graph.insertWidget(0, self.plot_widget_waveform_v, 86)
self.layout_graph.addWidget(self.plot_widget_waveform_a, 100)
self.x_data = [x * ENERGY_MONITOR_MS_PER_TICK for x in list(range(768))]
self.button_energy.clicked.connect(self.button_energy_clicked)
self.button_transformer_settings.clicked.connect(self.button_transformer_settings_clicked)
self.voltage_connected = True
self.current_connected = True
self.running = False
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickHATZero, *args)
self.setupUi(self)
self.hat_zero = self.device
self.cbe_voltage = CallbackEmulator(self.hat_zero.get_usb_voltage,
None, self.cb_usb_voltage,
self.increase_error_count)
self.ports = [self.port_a, self.port_b, self.port_c, self.port_d]
for port in self.ports:
port.setProperty('_bricklet_uid', None)
port.setEnabled(False)
port.clicked.connect(self.port_clicked)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_bricklets)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletTemperatureIRV2, *args)
self.tir = self.device
self.cbe_ambient_temperature = CallbackEmulator(
self.tir.get_ambient_temperature, self.cb_ambient_temperature,
self.increase_error_count)
self.cbe_object_temperature = CallbackEmulator(
self.tir.get_object_temperature, self.cb_object_temperature,
self.increase_error_count)
self.current_ambient = None # float, °C
self.current_object = None # float, °C
plots = [('Ambient', Qt.blue, lambda: self.current_ambient,
u'{} °C'.format),
('Object', Qt.red, lambda: self.current_object,
u'{} °C'.format)]
self.plot_widget = PlotWidget(u'Temperature [°C]', plots)
self.spin_emissivity = QSpinBox()
self.spin_emissivity.setMinimum(6553)
self.spin_emissivity.setMaximum(65535)
self.spin_emissivity.setValue(65535)
self.spin_emissivity.editingFinished.connect(
self.spin_emissivity_finished)
hlayout = QHBoxLayout()
hlayout.addWidget(QLabel('Emissivity:'))
hlayout.addWidget(self.spin_emissivity)
hlayout.addStretch()
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addWidget(line)
layout.addLayout(hlayout)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletOneWire, *args)
self.setupUi(self)
self.one_wire = self.device
self.button_reset.clicked.connect(self.button_reset_clicked)
self.button_search.clicked.connect(self.button_search_clicked)
self.button_read_byte.clicked.connect(self.button_read_byte_clicked)
self.button_write_byte.clicked.connect(self.button_write_byte_clicked)
self.button_write_command.clicked.connect(
self.button_write_command_clicked)
self.start_time = time.time()
self.ids = [0]
self.write_data = 0
self.write_command = 0
self.write_command_id = 0
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletSolidStateRelayV2, *args)
self.setupUi(self)
self.ssr = self.device
self.state_combobox.setItemData(0, True)
self.state_combobox.setItemData(1, False)
self.monoflop = Monoflop(self.ssr, None, self.state_combobox,
self.cb_state_change_by_monoflop,
self.time_spinbox, None, self)
self.ssr_button.clicked.connect(self.ssr_clicked)
self.go_button.clicked.connect(self.go_clicked)
self.a_pixmap = load_masked_pixmap(
'plugin_system/plugins/solid_state_relay/relay_a.bmp')
self.b_pixmap = load_masked_pixmap(
'plugin_system/plugins/solid_state_relay/relay_b.bmp')
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletAirQuality, *args)
self.air_quality = self.device
self.cbe_air_quality = CallbackEmulator(self.air_quality.get_all_values,
self.cb_get_all_values,
self.increase_error_count)
self.current_iaq_index = None # float
self.current_temperature = None # float, °C
self.current_humidity = None # float, %RH
self.current_air_pressure = None # float, mbar
self.current_iaq_index_accuracy = None
self.iaq_accuracy_label = QLabel("(Accuracy: TBD)")
plots_iaq_index = [(u'IAQ Index', Qt.red, lambda: self.current_iaq_index, u'{}'.format)]
self.plot_widget_iaq_index = PlotWidget(u'IAQ Index', plots_iaq_index, extra_key_widgets=(self.iaq_accuracy_label, ))
plots_temperature = [(u'Temperature', Qt.red, lambda: self.current_temperature, u'{} °C'.format)]
self.plot_widget_temperature = PlotWidget(u'Temperature [°C]', plots_temperature)
plots_humidity = [(u'Relative Humidity', Qt.red, lambda: self.current_humidity, u'{} %RH'.format)]
self.plot_widget_humidity = PlotWidget(u'Relative Humidity [%RH]', plots_humidity)
plots_air_pressure = [(u'Air Pressure', Qt.red, lambda: self.current_air_pressure, u'{} mbar (QFE)'.format)]
self.plot_widget_air_pressure = PlotWidget(u'Air Pressure [mbar]', plots_air_pressure)
layout_plot1 = QHBoxLayout()
layout_plot1.addWidget(self.plot_widget_iaq_index)
layout_plot1.addWidget(self.plot_widget_temperature)
layout_plot2 = QHBoxLayout()
layout_plot2.addWidget(self.plot_widget_humidity)
layout_plot2.addWidget(self.plot_widget_air_pressure)
layout_main = QVBoxLayout(self)
layout_main.addLayout(layout_plot1)
layout_main.addLayout(layout_plot2)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletEPaper296x128, *args)
self.setupUi(self)
self.epaper = self.device
self.scribble_widget = ScribbleWidget(WIDTH, HEIGHT, 2, QColor(Qt.white), QColor(Qt.black), enable_grid=False)
self.image_button_layout.insertWidget(0, self.scribble_widget)
self.draw_button.clicked.connect(self.draw_clicked)
self.send_button.clicked.connect(self.send_clicked)
self.fill_black_button.clicked.connect(lambda: self.fill_clicked(0))
self.fill_white_button.clicked.connect(lambda: self.fill_clicked(1))
self.fill_red_button.clicked.connect(lambda: self.fill_clicked(2))
self.color_radio_black.toggled.connect(self.radio_toggled)
self.color_radio_white.toggled.connect(self.radio_toggled)
self.color_radio_red.toggled.connect(self.radio_toggled)
self.display_type = self.epaper.DISPLAY_TYPE_BLACK_WHITE_RED
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):
COMCUPluginBase.__init__(self, BrickletEVSE, *args)
self.setupUi(self)
self.evse = self.device
self.cbe_state = CallbackEmulator(self,
self.evse.get_state,
None,
self.state_cb,
self.increase_error_count)
self.cbe_low_level_state = CallbackEmulator(self,
self.evse.get_low_level_state,
None,
self.low_level_state_cb,
self.increase_error_count)
self.cbe_max_charging_current = CallbackEmulator(self,
self.evse.get_max_charging_current,
None,
self.max_charging_current_cb,
self.increase_error_count)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletOLED128x64V2, *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
self.write_line_response_expected = False
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIndustrialDualACRelay, *args)
self.setupUi(self)
self.idr = self.device
self.value0_combobox.setItemData(0, True)
self.value0_combobox.setItemData(1, False)
self.value1_combobox.setItemData(0, True)
self.value1_combobox.setItemData(1, False)
self.monoflop = Monoflop(self.idr, [0, 1],
[self.value0_combobox, self.value1_combobox],
self.cb_value_change_by_monoflop,
[self.time0_spinbox, self.time1_spinbox],
None, self)
self.ch0_button.clicked.connect(self.ch0_clicked)
self.ch1_button.clicked.connect(self.ch1_clicked)
self.go0_button.clicked.connect(self.go0_clicked)
self.go1_button.clicked.connect(self.go1_clicked)
self.combobox_led0.currentIndexChanged.connect(
self.combobox_led0_changed)
self.combobox_led1.currentIndexChanged.connect(
self.combobox_led1_changed)
self.a0_pixmap = load_masked_pixmap(
'plugin_system/plugins/industrial_dual_ac_relay/relay_close.bmp')
self.a1_pixmap = load_masked_pixmap(
'plugin_system/plugins/industrial_dual_ac_relay/relay_close.bmp')
self.b0_pixmap = load_masked_pixmap(
'plugin_system/plugins/industrial_dual_ac_relay/relay_open.bmp')
self.b1_pixmap = load_masked_pixmap(
'plugin_system/plugins/industrial_dual_ac_relay/relay_open.bmp')
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletDualButtonV2, *args)
self.setupUi(self)
self.button = self.device
self.cbe_button_state = CallbackEmulator(
self,
self.button.get_button_state,
None,
self.cb_button_state,
self.increase_error_count,
expand_result_tuple_for_callback=True)
self.cbe_led_state = CallbackEmulator(
self,
self.button.get_led_state,
None,
self.cb_led_state,
self.increase_error_count,
expand_result_tuple_for_callback=True)
self.led_r = BrickletDualButtonV2.LED_STATE_OFF
self.led_l = BrickletDualButtonV2.LED_STATE_OFF
self.button_r = BrickletDualButtonV2.BUTTON_STATE_RELEASED
self.button_l = BrickletDualButtonV2.BUTTON_STATE_RELEASED
self.button_led_on_button_r.clicked.connect(self.on_button_r_clicked)
self.button_led_on_button_l.clicked.connect(self.on_button_l_clicked)
self.button_led_off_button_r.clicked.connect(self.off_button_r_clicked)
self.button_led_off_button_l.clicked.connect(self.off_button_l_clicked)
self.button_toggle_button_r.clicked.connect(
self.toggle_button_r_clicked)
self.button_toggle_button_l.clicked.connect(
self.toggle_button_l_clicked)
self.count = 0
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickHAT, *args)
self.setupUi(self)
self.hat = self.device
self.cbe_voltages = CallbackEmulator(self, self.hat.get_voltages, None,
self.cb_voltages,
self.increase_error_count)
self.button_sleep.clicked.connect(self.button_sleep_clicked)
self.bricklet_power_checkbox.stateChanged.connect(
self.bricklet_power_changed)
self.ports = [
self.port_a, self.port_b, self.port_c, self.port_d, self.port_e,
self.port_f, self.port_g, self.port_h
]
for port in self.ports:
port.setProperty('_bricklet_uid', None)
port.setEnabled(False)
port.clicked.connect(self.port_clicked)
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):
COMCUPluginBase.__init__(self, BrickletIndustrialCounter, *args)
self.setupUi(self)
self.counter = self.device
self.cbe_signal = CallbackEmulator(self.counter.get_all_signal_data,
None, self.cb_all_signal_data,
self.increase_error_count)
self.cbe_counter = CallbackEmulator(self.counter.get_all_counter, None,
self.cb_all_counter,
self.increase_error_count)
def get_combo_lambda(channel):
return lambda: self.combo_index_changed(channel)
def get_checkstate_lambda(channel):
return lambda x: self.checkstate_changed(channel, x)
g = self.main_grid
pos = 2
self.checkboxess_active = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
for channel, checkbox in enumerate(self.checkboxess_active):
checkbox.stateChanged.connect(get_checkstate_lambda(channel))
pos += 1
self.combos_count_edge = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
for channel, combo in enumerate(self.combos_count_edge):
combo.addItem('Rising')
combo.addItem('Falling')
combo.addItem('Both')
combo.currentIndexChanged.connect(get_combo_lambda(channel))
pos += 1
self.combos_count_direction = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
for channel, combo in enumerate(self.combos_count_direction):
combo.addItem('Up')
combo.addItem('Down')
combo.currentIndexChanged.connect(get_combo_lambda(channel))
self.combos_count_direction[0].addItem('Ext Up (Ch 2)')
self.combos_count_direction[0].addItem('Ext Down (Ch 2)')
self.combos_count_direction[3].addItem('Ext Up (Ch 1)')
self.combos_count_direction[3].addItem('Ext Down (Ch 1)')
pos += 1
self.combos_duty_cycle_prescaler = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
for channel, combo in enumerate(self.combos_duty_cycle_prescaler):
combo.addItem('1')
combo.addItem('2')
combo.addItem('4')
combo.addItem('8')
combo.addItem('16')
combo.addItem('32')
combo.addItem('64')
combo.addItem('128')
combo.addItem('256')
combo.addItem('512')
combo.addItem('1024')
combo.addItem('2048')
combo.addItem('4096')
combo.addItem('8192')
combo.addItem('16384')
combo.addItem('32768')
combo.currentIndexChanged.connect(get_combo_lambda(channel))
pos += 1
self.combos_frequency_integration = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
for channel, combo in enumerate(self.combos_frequency_integration):
combo.addItem('128ms')
combo.addItem('256ms')
combo.addItem('512ms')
combo.addItem('1024ms')
combo.addItem('2048ms')
combo.addItem('4096ms')
combo.addItem('8192ms')
combo.addItem('16384ms')
combo.addItem('32768ms')
combo.currentIndexChanged.connect(get_combo_lambda(channel))
pos += 3
self.labels_counter = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
pos += 1
self.labels_duty_cycle = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
pos += 1
self.labels_period = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
pos += 1
self.labels_frequency = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
pos += 1
self.labels_value = [
g.itemAtPosition(pos, 1).widget(),
g.itemAtPosition(pos, 2).widget(),
g.itemAtPosition(pos, 3).widget(),
g.itemAtPosition(pos, 4).widget()
]
self.cbox_cs0_cfg.currentIndexChanged.connect(
self.cbox_cs0_cfg_changed)
self.cbox_cs1_cfg.currentIndexChanged.connect(
self.cbox_cs1_cfg_changed)
self.cbox_cs2_cfg.currentIndexChanged.connect(
self.cbox_cs2_cfg_changed)
self.cbox_cs3_cfg.currentIndexChanged.connect(
self.cbox_cs3_cfg_changed)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletGPSV2, *args)
self.setupUi(self)
self.gps = self.device
self.cbe_universal = CallbackEmulator(self, self.get_universal, None,
self.cb_universal,
self.increase_error_count)
self.cbe_universal_gps = CallbackEmulator(self, self.get_universal_gps,
None, self.cb_universal_gps,
self.increase_error_count)
self.cbe_universal_glo = CallbackEmulator(self, self.get_universal_glo,
None, self.cb_universal_glo,
self.increase_error_count)
self.qtcb_pps.connect(self.cb_pps)
self.gps.register_callback(self.gps.CALLBACK_PULSE_PER_SECOND,
self.qtcb_pps.emit)
self.format_combobox.currentIndexChanged.connect(self.format_changed)
self.show_pos.clicked.connect(self.show_pos_clicked)
self.hot_start.clicked.connect(lambda: self.restart_clicked(0))
self.warm_start.clicked.connect(lambda: self.restart_clicked(1))
self.cold_start.clicked.connect(lambda: self.restart_clicked(2))
self.factory_reset.clicked.connect(lambda: self.restart_clicked(3))
self.had_fix = False
self.last_lat = 0
self.last_ns = 'U'
self.last_long = 0
self.last_ew = 'U'
self.gps_counter = 0
self.glo_counter = 0
self.gps_model = QStandardItemModel(32, 3, self)
self.gps_table.setModel(self.gps_model)
self.gps_model.setHorizontalHeaderItem(0,
QStandardItem('Elevation (°)'))
self.gps_model.setHorizontalHeaderItem(1, QStandardItem('Azimuth (°)'))
self.gps_model.setHorizontalHeaderItem(2, QStandardItem('SNR (dB)'))
for i in range(32):
self.gps_model.setVerticalHeaderItem(
i, QStandardItem('Sat ' + str(i + 1)))
self.gps_table.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.glo_model = QStandardItemModel(32, 3, self)
self.glo_table.setModel(self.glo_model)
self.glo_model.setHorizontalHeaderItem(0,
QStandardItem('Elevation (°)'))
self.glo_model.setHorizontalHeaderItem(1, QStandardItem('Azimuth (°)'))
self.glo_model.setHorizontalHeaderItem(2, QStandardItem('SNR (dB)'))
for i in range(32):
self.glo_model.setVerticalHeaderItem(
i, QStandardItem('Sat ' + str(i + 1 + 64)))
self.glo_table.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.fix_led_off_action = QAction('Off', self)
self.fix_led_off_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_OFF))
self.fix_led_on_action = QAction('On', self)
self.fix_led_on_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.FIX_LED_CONFIG_ON
))
self.fix_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.fix_led_show_heartbeat_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_HEARTBEAT))
self.fix_led_show_fix_action = QAction('Show Fix', self)
self.fix_led_show_fix_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_FIX))
self.fix_led_show_pps_action = QAction('Show PPS', self)
self.fix_led_show_pps_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_PPS))
self.extra_configs += [(1, 'Fix LED:', [
self.fix_led_off_action, self.fix_led_on_action,
self.fix_led_show_heartbeat_action, self.fix_led_show_fix_action,
self.fix_led_show_pps_action
])]
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIO4V2, *args)
self.setupUi(self)
self.io = self.device
self.on_focus = False
self.ch_current_config = {0: None, 1: None, 2: None, 3: None}
self.async_data_store = {
'all_ch_status_update': {
'ch_values': None,
'ch_config': None,
'monoflop': {
0: {
'running': False,
'start_time_remaining': 500
},
1: {
'running': False,
'start_time_remaining': 500
},
2: {
'running': False,
'start_time_remaining': 500
},
3: {
'running': False,
'start_time_remaining': 500
}
}
},
'update_current_channel_info': {
'value': None,
'config': None,
},
'iv_cb': {
'direction': {
0: None,
1: None,
2: None,
3: None
},
'values': None
}
}
self.gui_grp_cfg_ch_in = [self.lbl_cfg_ch_in_v, self.cbox_cfg_ch_in_v]
self.gui_grp_cfg_ch_out = [
self.lbl_cfg_ch_out_v, self.cbox_cfg_ch_out_v, self.lbl_monoflop,
self.cbox_monoflop_v, self.sbox_monoflop_t, self.btn_monoflop_go
]
self.gui_grp_monoflop = [
self.cbox_monoflop_v, self.sbox_monoflop_t, self.btn_monoflop_go
]
self.lbl_st_ch_v = [
self.lbl_st_ch0_v, self.lbl_st_ch1_v, self.lbl_st_ch2_v,
self.lbl_st_ch3_v
]
self.lbl_st_ch_d = [
self.lbl_st_ch0_d, self.lbl_st_ch1_d, self.lbl_st_ch2_d,
self.lbl_st_ch3_d
]
self.lbl_st_ch_cfg = [
self.lbl_st_ch0_cfg, self.lbl_st_ch1_cfg, self.lbl_st_ch2_cfg,
self.lbl_st_ch3_cfg
]
self.lbl_st_ch_monoflop_t = [
self.lbl_st_ch0_monoflop_t, self.lbl_st_ch1_monoflop_t,
self.lbl_st_ch2_monoflop_t, self.lbl_st_ch3_monoflop_t
]
self.ch_status_update_timer = QTimer()
self.ch_status_update_timer.timeout.connect(
self.ch_status_update_timeout)
self.iv_cb_timer = QTimer()
self.iv_cb_timer.timeout.connect(self.iv_cb_timeout)
self.btn_monoflop_go.clicked.connect(self.btn_monoflop_go_clicked)
self.btn_cfg_ch_apply.clicked.connect(self.btn_cfg_ch_apply_clicked)
self.cbox_cfg_ch.currentIndexChanged.connect(self.cbox_cfg_ch_changed)
self.cbox_cfg_ch_dir.currentIndexChanged.connect(
self.cbox_cfg_ch_dir_changed)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletAccelerometerV2, *args)
self.accelerometer = self.device
self.cbe_acceleration = CallbackEmulator(
self.accelerometer.get_acceleration, self.cb_acceleration,
self.increase_error_count)
self.current_acceleration = [None, None, None] # float, g
self.pitch_label = PitchLabel()
self.roll_label = RollLabel()
plots = [('X', Qt.red, lambda: self.current_acceleration[0],
'{:.3f} g'.format),
('Y', Qt.darkGreen, lambda: self.current_acceleration[1],
'{:.3f} g'.format),
('Z', Qt.blue, lambda: self.current_acceleration[2],
'{:.3f} g'.format)]
self.plot_widget = PlotWidget(
'Acceleration [g]',
plots,
extra_key_widgets=[self.pitch_label, self.roll_label],
curve_motion_granularity=20,
update_interval=0.05)
self.fs_label = QLabel('Full Scale:')
self.fs_combo = QComboBox()
self.fs_combo.addItem("2 g")
self.fs_combo.addItem("4 g")
self.fs_combo.addItem("8 g")
self.fs_combo.currentIndexChanged.connect(self.new_config)
self.dr_label = QLabel('Data Rate:')
self.dr_combo = QComboBox()
self.dr_combo.addItem("0.781 Hz")
self.dr_combo.addItem("1.563 Hz")
self.dr_combo.addItem("3.125 Hz")
self.dr_combo.addItem("6.2512 Hz")
self.dr_combo.addItem("12.5 Hz")
self.dr_combo.addItem("25 Hz")
self.dr_combo.addItem("50 Hz")
self.dr_combo.addItem("100 Hz")
self.dr_combo.addItem("200 Hz")
self.dr_combo.addItem("400 Hz")
self.dr_combo.addItem("800 Hz")
self.dr_combo.addItem("1600 Hz")
self.dr_combo.addItem("3200 Hz")
self.dr_combo.addItem("6400 Hz")
self.dr_combo.addItem("12800 Hz")
self.dr_combo.addItem("25600 Hz")
self.dr_combo.currentIndexChanged.connect(self.new_config)
# self.fb_label = QLabel('Filter Bandwidth:')
# self.fb_combo = QComboBox()
# self.fb_combo.addItem("800 Hz")
# self.fb_combo.addItem("400 Hz")
# self.fb_combo.addItem("200 Hz")
# self.fb_combo.addItem("50 Hz")
# self.fb_combo.currentIndexChanged.connect(self.new_config)
# self.enable_led = QCheckBox("Enable LED")
# self.enable_led.stateChanged.connect(self.enable_led_changed)
hlayout = QHBoxLayout()
hlayout.addStretch()
hlayout.addWidget(self.fs_label)
hlayout.addWidget(self.fs_combo)
hlayout.addStretch()
hlayout.addWidget(self.dr_label)
hlayout.addWidget(self.dr_combo)
hlayout.addStretch()
# hlayout.addWidget(self.fb_label)
# hlayout.addWidget(self.fb_combo)
# hlayout.addStretch()
# hlayout.addWidget(self.enable_led)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addWidget(line)
layout.addLayout(hlayout)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletThermalImaging, *args)
self.setupUi(self)
self.thermal_imaging = self.device
self.previous_image_transfer_config = None
self.agc_roi_from = QPoint(0, 0)
self.agc_roi_to = QPoint(79, 59)
self.spotmeter_roi_from = QPoint(0, 0)
self.spotmeter_roi_to = QPoint(79, 59)
self.thermal_image = ThermalImage(80, 60, self, self)
self.thermal_image.agc_roi_changed.connect(self.update_agc_roi)
self.thermal_image.spotmeter_roi_changed.connect(
self.update_spotmeter_roi)
self.thermal_image_layout.insertWidget(0, self.thermal_image)
self.thermal_image_bar = ThermalImageBar(80, 20, self.thermal_image,
self, self)
self.thermal_image_layout.insertWidget(2, self.thermal_image_bar)
self.combo_scale_factor.currentIndexChanged.connect(
lambda: self.thermal_image.scale_factor_changed(
int(1 + 4 * float(self.combo_scale_factor.currentText()[:-1]))
))
self.agc_roi_button.clicked.connect(self.cb_roi_button)
self.spotmeter_roi_button.clicked.connect(self.cb_roi_button)
self.image_combo.setItemData(
0,
BrickletThermalImaging.IMAGE_TRANSFER_CALLBACK_HIGH_CONTRAST_IMAGE)
self.image_combo.setItemData(
1,
BrickletThermalImaging.IMAGE_TRANSFER_CALLBACK_TEMPERATURE_IMAGE)
self.agc_clip_limit_high_spin.editingFinished.connect(
self.update_agc_data)
self.agc_clip_limit_low_spin.editingFinished.connect(
self.update_agc_data)
self.agc_dampening_factor_spin.editingFinished.connect(
self.update_agc_data)
self.agc_empty_counts_spin.editingFinished.connect(
self.update_agc_data)
self.color_palette_box.currentIndexChanged.connect(
self.color_palette_changed)
self.resolution_box.currentIndexChanged.connect(self.update_resolution)
self.image_combo.currentIndexChanged.connect(self.update_image_combo)
self.qtcb_high_contrast_image.connect(self.cb_high_contrast_image)
self.qtcb_temperature_image.connect(self.cb_temperature_image)
self.valid_resolution = self.resolution_box.currentIndex()
self.thermal_image_wrapper = None
self.button_detach_image.clicked.connect(self.detach_image_clicked)
self.update_agc_roi_label()
self.fps_average_length = 10
self.last_ten_image_times = []
self.qtcb_high_contrast_image.connect(self.update_fps)
self.qtcb_temperature_image.connect(self.update_fps)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletLEDStripV2, *args)
self.setupUi(self)
self.led_strip = self.device
self.frame_read_callback_was_enabled = None
self.qtcb_frame_started.connect(self.cb_frame_started)
self.button_color.clicked.connect(self.color_clicked)
self.button_black.clicked.connect(self.black_clicked)
self.button_gradient.clicked.connect(self.gradient_clicked)
self.button_dot.clicked.connect(self.dot_clicked)
self.box_frame_duration.valueChanged.connect(
self.frame_duration_changed)
self.gradient_intensity.valueChanged.connect(
self.gradient_intensity_changed)
self.chip_type_combobox.addItem(
'WS2801', (BrickletLEDStripV2.CHIP_TYPE_WS2801, 3))
self.chip_type_combobox.addItem(
'WS2811', (BrickletLEDStripV2.CHIP_TYPE_WS2811, 3))
self.chip_type_combobox.addItem(
'WS2812 / SK6812 / NeoPixel RGB (GRB)',
(BrickletLEDStripV2.CHIP_TYPE_WS2812, 3))
self.box_clock_frequency.editingFinished.connect(
self.clock_frequency_changed)
self.chip_type_combobox.currentIndexChanged.connect(
self.chip_type_changed)
self.chip_type_combobox.addItem(
'SK6812RGBW / NeoPixel RGBW (GRBW)',
(BrickletLEDStripV2.CHIP_TYPE_WS2812, 4))
self.chip_type_combobox.addItem(
'LPD8806', (BrickletLEDStripV2.CHIP_TYPE_LPD8806, 3))
self.chip_type_combobox.addItem(
'APA102 / DotStar (bBGR)',
(BrickletLEDStripV2.CHIP_TYPE_APA102, 4))
self.channel_mapping_combobox.currentIndexChanged.connect(
self.channel_mapping_changed)
self.state = self.STATE_IDLE
self.gradient_counter = 0
self.dot_counter = 0
self.dot_direction = 1
self.voltage = 0
self.frame_started_callback_was_enabled = None
self.voltage_timer = QTimer(self)
self.voltage_timer.timeout.connect(self.update_voltage)
self.voltage_timer.setInterval(1000)
self.chip_type_changed(0, ui_only=True)
self.button_gradient.setEnabled(False)
self.box_num_led.valueChanged.connect(self.box_num_led_changed)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletRS232V2, *args)
self.setupUi(self)
self.text.setReadOnly(True)
self.rs232 = self.device
self.read_callback_was_enabled = None
self.qtcb_read.connect(self.cb_read)
self.rs232.register_callback(self.rs232.CALLBACK_READ,
self.qtcb_read.emit)
self.qtcb_error_count.connect(self.cb_error_count)
self.rs232.register_callback(self.rs232.CALLBACK_ERROR_COUNT,
self.qtcb_error_count.emit)
self.input_combobox.addItem("")
self.input_combobox.lineEdit().setMaxLength(65533)
self.input_combobox.lineEdit().returnPressed.connect(
self.input_changed)
self.line_ending_lineedit.setValidator(HexValidator())
self.line_ending_combobox.currentIndexChanged.connect(
self.line_ending_changed)
self.line_ending_lineedit.editingFinished.connect(
self.line_ending_changed)
self.baudrate_spinbox.valueChanged.connect(self.configuration_changed)
self.parity_combobox.currentIndexChanged.connect(
self.configuration_changed)
self.stopbits_spinbox.valueChanged.connect(self.configuration_changed)
self.wordlength_spinbox.valueChanged.connect(
self.configuration_changed)
self.flowcontrol_combobox.currentIndexChanged.connect(
self.configuration_changed)
self.text_type_combobox.currentIndexChanged.connect(
self.text_type_changed)
self.hextext = QHexeditWidget(self.text.font())
self.hextext.hide()
self.layout().insertWidget(2, self.hextext)
self.button_clear_text.clicked.connect(
lambda: self.text.setPlainText(""))
self.button_clear_text.clicked.connect(self.hextext.clear)
self.save_button.clicked.connect(self.save_clicked)
self.error_stream_oos = 0
self.last_char = ''
if self.baudrate_spinbox.value() > BAUDRATE_MAX_RS232:
self.label_note_baud.show()
else:
self.label_note_baud.hide()
if self.flowcontrol_combobox.currentIndex() == CBOX_IDX_FC_HW:
self.label_note_fc_hw.show()
else:
self.label_note_fc_hw.hide()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletDMX, *args)
self.setupUi(self)
self.dmx = self.device
self.wait_for_first_read = True
self.dmx_overview = DMXOverview(self)
self.layout_dmx_overview.insertWidget(1, self.dmx_overview)
self.qtcb_frame_started.connect(self.cb_frame_started)
self.qtcb_frame.connect(self.cb_frame)
self.mode_combobox.currentIndexChanged.connect(self.mode_changed)
self.frame_duration_spinbox.valueChanged.connect(
self.frame_duration_changed)
self.address_spinboxes = []
self.address_slider = []
for i in range(512):
spinbox = QSpinBox()
spinbox.setMinimum(0)
spinbox.setMaximum(255)
slider = QSlider(Qt.Horizontal)
slider.setMinimum(0)
slider.setMaximum(255)
spinbox.valueChanged.connect(slider.setValue)
slider.valueChanged.connect(spinbox.setValue)
def get_frame_value_changed_func(i):
return lambda x: self.frame_value_changed(i, x)
slider.valueChanged.connect(get_frame_value_changed_func(i))
self.address_table.setCellWidget(i, 0, spinbox)
self.address_table.setCellWidget(i, 1, slider)
self.address_spinboxes.append(spinbox)
self.address_slider.append(slider)
self.address_table.horizontalHeader().setStretchLastSection(True)
self.address_table.show()
self.current_frame = [0] * 512
self.com_led_off_action = QAction('Off', self)
self.com_led_off_action.triggered.connect(
lambda: self.dmx.set_communication_led_config(
BrickletDMX.COMMUNICATION_LED_CONFIG_OFF))
self.com_led_on_action = QAction('On', self)
self.com_led_on_action.triggered.connect(
lambda: self.dmx.set_communication_led_config(
BrickletDMX.COMMUNICATION_LED_CONFIG_ON))
self.com_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.com_led_show_heartbeat_action.triggered.connect(
lambda: self.dmx.set_communication_led_config(
BrickletDMX.COMMUNICATION_LED_CONFIG_SHOW_HEARTBEAT))
self.com_led_show_communication_action = QAction('Show Com', self)
self.com_led_show_communication_action.triggered.connect(
lambda: self.dmx.set_communication_led_config(
BrickletDMX.COMMUNICATION_LED_CONFIG_SHOW_COMMUNICATION))
self.extra_configs += [(1, 'Com LED:', [
self.com_led_off_action, self.com_led_on_action,
self.com_led_show_heartbeat_action,
self.com_led_show_communication_action
])]
self.error_led_off_action = QAction('Off', self)
self.error_led_off_action.triggered.connect(
lambda: self.dmx.set_error_led_config(BrickletDMX.
ERROR_LED_CONFIG_OFF))
self.error_led_on_action = QAction('On', self)
self.error_led_on_action.triggered.connect(
lambda: self.dmx.set_error_led_config(BrickletDMX.
ERROR_LED_CONFIG_ON))
self.error_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.error_led_show_heartbeat_action.triggered.connect(
lambda: self.dmx.set_error_led_config(
BrickletDMX.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.dmx.set_error_led_config(BrickletDMX.
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
])]
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIndustrialQuadRelayV2, *args)
self.setupUi(self)
self.iqr = self.device
self.open_pixmap = load_masked_pixmap(
'plugin_system/plugins/industrial_quad_relay/relay_open.bmp')
self.close_pixmap = load_masked_pixmap(
'plugin_system/plugins/industrial_quad_relay/relay_close.bmp')
self.relay_buttons = [self.b0, self.b1, self.b2, self.b3]
self.relay_button_icons = [
self.b0_icon, self.b1_icon, self.b2_icon, self.b3_icon
]
self.relay_button_labels = [
self.b0_label, self.b1_label, self.b2_label, self.b3_label
]
for icon in self.relay_button_icons:
icon.setPixmap(self.open_pixmap)
icon.show()
for i in range(len(self.relay_buttons)):
self.relay_buttons[i].clicked.connect(
functools.partial(self.relay_button_clicked, i))
self.monoflop_values = []
self.monoflop_times = []
for i in range(4):
self.monoflop_channel.setItemData(i, i)
monoflop_value = QComboBox()
monoflop_value.addItem('On', True)
monoflop_value.addItem('Off', False)
self.monoflop_values.append(monoflop_value)
self.monoflop_value_stack.addWidget(monoflop_value)
monoflop_time = QSpinBox()
monoflop_time.setRange(1, (1 << 31) - 1)
monoflop_time.setValue(1000)
self.monoflop_times.append(monoflop_time)
self.monoflop_time_stack.addWidget(monoflop_time)
self.monoflop = Monoflop(self.iqr, [0, 1, 2, 3], self.monoflop_values,
self.cb_value_change_by_monoflop,
self.monoflop_times, None, self)
self.monoflop_channel.currentIndexChanged.connect(
self.monoflop_channel_changed)
self.monoflop_go.clicked.connect(self.monoflop_go_clicked)
self.cbox_cs0_cfg.currentIndexChanged.connect(
self.cbox_cs0_cfg_changed)
self.cbox_cs1_cfg.currentIndexChanged.connect(
self.cbox_cs1_cfg_changed)
self.cbox_cs2_cfg.currentIndexChanged.connect(
self.cbox_cs2_cfg_changed)
self.cbox_cs3_cfg.currentIndexChanged.connect(
self.cbox_cs3_cfg_changed)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIMUV3, *args)
self.setupUi(self)
self.imu = self.device
self.cbe_all_data = CallbackEmulator(self, self.imu.get_all_data, None,
self.cb_all_data,
self.increase_error_count)
self.imu_gl = IMUV33DWidget(self)
self.imu_gl.setFixedSize(200, 200)
self.imu_gl_wrapper = None
self.state = None
self.data_plot_widget = []
self.sensor_data = [CurveValueWrapper() for i in range(23)]
self.data_labels = [
self.label_acceleration_x, self.label_acceleration_y,
self.label_acceleration_z, self.label_magnetic_field_x,
self.label_magnetic_field_y, self.label_magnetic_field_z,
self.label_angular_velocity_x, self.label_angular_velocity_y,
self.label_angular_velocity_z, self.label_euler_angle_heading,
self.label_euler_angle_roll, self.label_euler_angle_pitch,
self.label_quaternion_w, self.label_quaternion_x,
self.label_quaternion_y, self.label_quaternion_z,
self.label_linear_acceleration_x, self.label_linear_acceleration_y,
self.label_linear_acceleration_z, self.label_gravity_vector_x,
self.label_gravity_vector_y, self.label_gravity_vector_z,
self.label_temperature
]
self.data_rows = [
[
self.label_acceleration_11, self.label_acceleration_21,
self.label_acceleration_22, self.label_acceleration_23,
self.label_acceleration_41, self.label_acceleration_42,
self.label_acceleration_43, self.label_acceleration_x,
self.label_acceleration_y, self.label_acceleration_z
],
[
self.label_magnetic_field_11, self.label_magnetic_field_21,
self.label_magnetic_field_22, self.label_magnetic_field_23,
self.label_magnetic_field_41, self.label_magnetic_field_42,
self.label_magnetic_field_43, self.label_magnetic_field_x,
self.label_magnetic_field_y, self.label_magnetic_field_z
],
[
self.label_angular_velocity_11, self.label_angular_velocity_21,
self.label_angular_velocity_22, self.label_angular_velocity_23,
self.label_angular_velocity_41, self.label_angular_velocity_42,
self.label_angular_velocity_43, self.label_angular_velocity_x,
self.label_angular_velocity_y, self.label_angular_velocity_z
],
[
self.label_euler_angle_11, self.label_euler_angle_21,
self.label_euler_angle_22, self.label_euler_angle_23,
self.label_euler_angle_41, self.label_euler_angle_42,
self.label_euler_angle_43, self.label_euler_angle_roll,
self.label_euler_angle_pitch, self.label_euler_angle_heading
],
[
self.label_quaternion_11, self.label_quaternion_21,
self.label_quaternion_22, self.label_quaternion_23,
self.label_quaternion_24, self.label_quaternion_41,
self.label_quaternion_42, self.label_quaternion_43,
self.label_quaternion_44, self.label_quaternion_w,
self.label_quaternion_x, self.label_quaternion_y,
self.label_quaternion_z
],
[
self.label_linear_acceleration_11,
self.label_linear_acceleration_21,
self.label_linear_acceleration_22,
self.label_linear_acceleration_23,
self.label_linear_acceleration_41,
self.label_linear_acceleration_42,
self.label_linear_acceleration_43,
self.label_linear_acceleration_x,
self.label_linear_acceleration_y,
self.label_linear_acceleration_z
],
[
self.label_gravity_vector_11, self.label_gravity_vector_21,
self.label_gravity_vector_22, self.label_gravity_vector_23,
self.label_gravity_vector_41, self.label_gravity_vector_42,
self.label_gravity_vector_43, self.label_gravity_vector_x,
self.label_gravity_vector_y, self.label_gravity_vector_z
],
[
self.label_temperature_11, self.label_temperature_21,
self.label_temperature_41, self.label_temperature
]
]
even_color = QColor(240, 240, 240)
odd_color = QColor(255, 255, 255)
self.data_color = [(Qt.red, even_color), (Qt.darkGreen, even_color),
(Qt.blue, even_color), (Qt.red, odd_color),
(Qt.darkGreen, odd_color), (Qt.blue, odd_color),
(Qt.red, even_color), (Qt.darkGreen, even_color),
(Qt.blue, even_color), (Qt.red, odd_color),
(Qt.darkGreen, odd_color), (Qt.blue, odd_color),
(Qt.magenta, even_color), (Qt.red, even_color),
(Qt.darkGreen, even_color), (Qt.blue, even_color),
(Qt.red, odd_color), (Qt.darkGreen, odd_color),
(Qt.blue, odd_color), (Qt.red, even_color),
(Qt.darkGreen, even_color), (Qt.blue, even_color),
(Qt.magenta, odd_color)]
even_palette = QPalette()
even_palette.setColor(QPalette.Window, even_color)
odd_palette = QPalette()
odd_palette.setColor(QPalette.Window, odd_color)
for i, row in enumerate(self.data_rows):
for label in row:
if i % 2:
label.setPalette(odd_palette)
else:
label.setPalette(even_palette)
label.setAutoFillBackground(True)
self.plot_timer = QTimer(self)
self.plot_timer.start(100)
for i in range(23):
self.data_plot_widget.append(
PlotWidget(
"",
[("", self.data_color[i][0], self.sensor_data[i], str)],
clear_button=self.clear_graphs,
x_scale_visible=False,
y_scale_visible=False,
curve_outer_border_visible=False,
curve_motion='smooth',
canvas_color=self.data_color[i][1],
external_timer=self.plot_timer,
curve_start='right',
key=None,
y_resolution=0.01))
for w in self.data_plot_widget:
w.setMinimumHeight(15)
w.setMaximumHeight(25)
for i in range(23):
self.data_grid.addWidget(self.data_plot_widget[i], i, 4)
self.data_grid.setColumnMinimumWidth(2, 75)
self.gl_layout = QVBoxLayout()
self.gl_layout.addWidget(self.imu_gl)
self.layout_bottom.addLayout(self.gl_layout)
self.save_orientation.clicked.connect(self.save_orientation_clicked)
self.button_detach_3d_view.clicked.connect(self.detach_3d_view_clicked)
self.button_calibration.clicked.connect(self.calibration_clicked)
self.calibration_color = [
Qt.red, QColor(0xFF, 0xA0, 0x00), Qt.yellow, Qt.darkGreen
]
self.calibration = None
self.alive = True
self.callback_counter = 0
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIO16V2, *args)
self.setupUi(self)
self.io = self.device
self.io.set_response_expected(self.io.FUNCTION_SET_CONFIGURATION, True)
self.cbe_value = CallbackEmulator(self.io.get_value, None,
self.cb_value,
self.increase_error_count)
self.config_direction = [None] * 16
self.config_value = [None] * 16
self.lbl_st_ch_v = [
self.lbl_st_ch0_v, self.lbl_st_ch1_v, self.lbl_st_ch2_v,
self.lbl_st_ch3_v, self.lbl_st_ch4_v, self.lbl_st_ch5_v,
self.lbl_st_ch6_v, self.lbl_st_ch7_v, self.lbl_st_ch8_v,
self.lbl_st_ch9_v, self.lbl_st_ch10_v, self.lbl_st_ch11_v,
self.lbl_st_ch12_v, self.lbl_st_ch13_v, self.lbl_st_ch14_v,
self.lbl_st_ch15_v
]
self.lbl_st_ch_d = [
self.lbl_st_ch0_d, self.lbl_st_ch1_d, self.lbl_st_ch2_d,
self.lbl_st_ch3_d, self.lbl_st_ch4_d, self.lbl_st_ch5_d,
self.lbl_st_ch6_d, self.lbl_st_ch7_d, self.lbl_st_ch8_d,
self.lbl_st_ch9_d, self.lbl_st_ch10_d, self.lbl_st_ch11_d,
self.lbl_st_ch12_d, self.lbl_st_ch13_d, self.lbl_st_ch14_d,
self.lbl_st_ch15_d
]
self.lbl_st_ch_cfg = [
self.lbl_st_ch0_cfg, self.lbl_st_ch1_cfg, self.lbl_st_ch2_cfg,
self.lbl_st_ch3_cfg, self.lbl_st_ch4_cfg, self.lbl_st_ch5_cfg,
self.lbl_st_ch6_cfg, self.lbl_st_ch7_cfg, self.lbl_st_ch8_cfg,
self.lbl_st_ch9_cfg, self.lbl_st_ch10_cfg, self.lbl_st_ch11_cfg,
self.lbl_st_ch12_cfg, self.lbl_st_ch13_cfg, self.lbl_st_ch14_cfg,
self.lbl_st_ch15_cfg
]
self.lbl_st_ch_monoflop_t = [
self.lbl_st_ch0_monoflop_t, self.lbl_st_ch1_monoflop_t,
self.lbl_st_ch2_monoflop_t, self.lbl_st_ch3_monoflop_t,
self.lbl_st_ch4_monoflop_t, self.lbl_st_ch5_monoflop_t,
self.lbl_st_ch6_monoflop_t, self.lbl_st_ch7_monoflop_t,
self.lbl_st_ch8_monoflop_t, self.lbl_st_ch9_monoflop_t,
self.lbl_st_ch10_monoflop_t, self.lbl_st_ch11_monoflop_t,
self.lbl_st_ch12_monoflop_t, self.lbl_st_ch13_monoflop_t,
self.lbl_st_ch14_monoflop_t, self.lbl_st_ch15_monoflop_t
]
self.cbox_cfg_ch_dir.setItemData(0, self.io.DIRECTION_IN)
self.cbox_cfg_ch_dir.setItemData(1, self.io.DIRECTION_OUT)
self.cbox_cfg_ch_v.setItemData(0, True)
self.cbox_cfg_ch_v.setItemData(1, False)
self.btn_monoflop_go.clicked.connect(self.btn_monoflop_go_clicked)
self.btn_cfg_ch_save.clicked.connect(self.btn_cfg_ch_save_clicked)
self.cbox_cfg_ch.currentIndexChanged.connect(self.cbox_cfg_ch_changed)
self.cbox_cfg_ch_dir.currentIndexChanged.connect(
self.cbox_cfg_ch_dir_changed)
self.monoflop_values = []
self.monoflop_times = []
for i in range(16):
monoflop_value = QComboBox()
monoflop_value.addItem('High', 1)
monoflop_value.addItem('Low', 0)
self.monoflop_values.append(monoflop_value)
self.monoflop_value_stack.addWidget(monoflop_value)
monoflop_time = QDoubleSpinBox()
self.monoflop_times.append(monoflop_time)
self.monoflop_time_stack.addWidget(monoflop_time)
self.monoflop = Monoflop(
self.io,
list(range(16)),
self.monoflop_values,
self.cb_value_change_by_monoflop,
self.monoflop_times,
self.lbl_st_ch_monoflop_t,
self,
handle_get_monoflop_invalid_parameter_as_abort=True)
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIndustrialDual020mAV2, *args)
self.dual020 = self.device
self.str_connected = 'Channel {0} is <font color="green">connected</font>'
self.str_not_connected = 'Channel {0} is <font color="red">not connected</font>'
self.cbe_current0 = CallbackEmulator(
functools.partial(self.dual020.get_current, CH_0),
functools.partial(self.cb_current, CH_0),
self.increase_error_count)
self.cbe_current1 = CallbackEmulator(
functools.partial(self.dual020.get_current, CH_1),
functools.partial(self.cb_current, CH_1),
self.increase_error_count)
self.connected_labels = [
FixedSizeLabel(self.str_not_connected.format(CH_0)),
FixedSizeLabel(self.str_not_connected.format(CH_1))
]
self.current_current = [None, None] # float, mA
plots = [('Channel 0', Qt.red, lambda: self.current_current[CH_0],
lambda value: '{:.03f} mA'.format(round(value, 3))),
('Channel 1', Qt.blue, lambda: self.current_current[CH_1],
lambda value: '{:.03f} mA'.format(round(value, 3)))]
self.plot_widget = PlotWidget('Current [mA]',
plots,
extra_key_widgets=self.connected_labels)
h_sp = QSizePolicy()
h_sp.setHorizontalPolicy(QSizePolicy.Expanding)
self.sample_rate_label = QLabel('Sample Rate:')
self.sample_rate_combo = QComboBox()
self.sample_rate_combo.addItem('240 Hz')
self.sample_rate_combo.addItem('60 Hz')
self.sample_rate_combo.addItem('15 Hz')
self.sample_rate_combo.addItem('4 Hz')
self.sample_rate_combo.currentIndexChanged.connect(
self.sample_rate_combo_index_changed)
self.sample_rate_combo.setSizePolicy(h_sp)
self.gain_label = QLabel('Gain:')
self.gain_combo = QComboBox()
self.gain_combo.addItem('x1')
self.gain_combo.addItem('x2')
self.gain_combo.addItem('x4')
self.gain_combo.addItem('x8')
self.gain_combo.currentIndexChanged.connect(
self.gain_combo_index_changed)
self.gain_combo.setSizePolicy(h_sp)
self.led_config_ch0_label = QLabel('Channel 0')
self.led_config_ch1_label = QLabel('Channel 1')
self.led_config_label = QLabel('LED Config:')
self.led_status_config_label = QLabel('LED Status Config:')
self.led_status_config_ch0_min_label = QLabel('Min:')
self.led_status_config_ch0_max_label = QLabel('Max:')
self.led_status_config_ch1_min_label = QLabel('Min:')
self.led_status_config_ch1_max_label = QLabel('Max:')
self.led_config_ch0_combo = QComboBox()
self.led_config_ch0_combo.addItem('Off')
self.led_config_ch0_combo.addItem('On')
self.led_config_ch0_combo.addItem('Show Heartbeat')
self.led_config_ch0_combo.addItem('Show Channel Status')
self.led_config_ch0_combo.setSizePolicy(h_sp)
self.led_config_ch0_combo.currentIndexChanged.connect(
self.led_config_ch0_combo_changed)
self.led_config_ch1_combo = QComboBox()
self.led_config_ch1_combo.addItem('Off')
self.led_config_ch1_combo.addItem('On')
self.led_config_ch1_combo.addItem('Show Heartbeat')
self.led_config_ch1_combo.addItem('Show Channel Status')
self.led_config_ch1_combo.setSizePolicy(h_sp)
self.led_config_ch1_combo.currentIndexChanged.connect(
self.led_config_ch1_combo_changed)
self.led_status_config_ch0_combo = QComboBox()
self.led_status_config_ch0_combo.addItem('Threshold')
self.led_status_config_ch0_combo.addItem('Intensity')
self.led_status_config_ch0_combo.setSizePolicy(h_sp)
self.led_status_config_ch0_combo.currentIndexChanged.connect(
self.led_status_config_ch0_combo_changed)
self.led_status_config_ch1_combo = QComboBox()
self.led_status_config_ch1_combo.addItem('Threshold')
self.led_status_config_ch1_combo.addItem('Intensity')
self.led_status_config_ch1_combo.setSizePolicy(h_sp)
self.led_status_config_ch1_combo.currentIndexChanged.connect(
self.led_status_config_ch1_combo_changed)
self.led_status_config_ch0_min_sbox = QDoubleSpinBox()
self.led_status_config_ch0_max_sbox = QDoubleSpinBox()
self.led_status_config_ch1_min_sbox = QDoubleSpinBox()
self.led_status_config_ch1_max_sbox = QDoubleSpinBox()
self.led_status_config_ch0_min_sbox.setValue(0)
self.led_status_config_ch0_min_sbox.setMinimum(0)
self.led_status_config_ch0_min_sbox.setSingleStep(0.5)
self.led_status_config_ch0_min_sbox.setDecimals(3)
self.led_status_config_ch0_min_sbox.setSuffix(' mA')
self.led_status_config_ch0_min_sbox.setMaximum(22.5)
self.led_status_config_ch0_min_sbox.valueChanged.connect(
self.led_status_config_ch0_min_sbox_changed)
self.led_status_config_ch0_max_sbox.setValue(0)
self.led_status_config_ch0_max_sbox.setMinimum(0)
self.led_status_config_ch0_max_sbox.setSingleStep(0.5)
self.led_status_config_ch0_max_sbox.setDecimals(3)
self.led_status_config_ch0_max_sbox.setSuffix(' mA')
self.led_status_config_ch0_max_sbox.setMaximum(22.5)
self.led_status_config_ch0_max_sbox.valueChanged.connect(
self.led_status_config_ch0_max_sbox_changed)
self.led_status_config_ch1_min_sbox.setValue(0)
self.led_status_config_ch1_min_sbox.setMinimum(0)
self.led_status_config_ch1_min_sbox.setSingleStep(0.5)
self.led_status_config_ch1_min_sbox.setDecimals(3)
self.led_status_config_ch1_min_sbox.setSuffix(' mA')
self.led_status_config_ch1_min_sbox.setMaximum(22.5)
self.led_status_config_ch1_min_sbox.valueChanged.connect(
self.led_status_config_ch1_min_sbox_changed)
self.led_status_config_ch1_max_sbox.setValue(0)
self.led_status_config_ch1_max_sbox.setMinimum(0)
self.led_status_config_ch1_max_sbox.setSingleStep(0.5)
self.led_status_config_ch1_max_sbox.setDecimals(3)
self.led_status_config_ch1_max_sbox.setSuffix(' mA')
self.led_status_config_ch1_max_sbox.setMaximum(22.5)
self.led_status_config_ch1_max_sbox.valueChanged.connect(
self.led_status_config_ch1_max_sbox_changed)
hlayout = QHBoxLayout()
self.led_status_config_ch0_min_sbox.setSizePolicy(h_sp)
self.led_status_config_ch0_max_sbox.setSizePolicy(h_sp)
hlayout.addWidget(self.led_status_config_ch0_min_label)
hlayout.addWidget(self.led_status_config_ch0_min_sbox)
hlayout.addWidget(self.led_status_config_ch0_max_label)
hlayout.addWidget(self.led_status_config_ch0_max_sbox)
hlayout1 = QHBoxLayout()
self.led_status_config_ch1_min_sbox.setSizePolicy(h_sp)
self.led_status_config_ch1_max_sbox.setSizePolicy(h_sp)
hlayout1.addWidget(self.led_status_config_ch1_min_label)
hlayout1.addWidget(self.led_status_config_ch1_min_sbox)
hlayout1.addWidget(self.led_status_config_ch1_max_label)
hlayout1.addWidget(self.led_status_config_ch1_max_sbox)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
line1 = QFrame()
line1.setFrameShape(QFrame.HLine)
line1.setFrameShadow(QFrame.Sunken)
line2 = QFrame()
line2.setFrameShape(QFrame.HLine)
line2.setFrameShadow(QFrame.Sunken)
glayout = QGridLayout()
glayout.addWidget(line, 0, 0, 1, 3) # line-1
glayout.addWidget(self.sample_rate_label, 1, 0, 1, 1)
glayout.addWidget(self.sample_rate_combo, 1, 1, 1, 2)
glayout.addWidget(self.gain_label, 2, 0, 1, 1)
glayout.addWidget(self.gain_combo, 2, 1, 1, 2)
glayout.addWidget(line1, 3, 0, 1, 3) # line-2
glayout.addWidget(self.led_config_ch0_label, 4, 1, 1, 1)
glayout.addWidget(self.led_config_ch1_label, 4, 2, 1, 1)
glayout.addWidget(line2, 5, 0, 1, 3) # line-3
glayout.addWidget(self.led_config_label, 6, 0, 1, 1)
glayout.addWidget(self.led_config_ch0_combo, 6, 1, 1, 1)
glayout.addWidget(self.led_config_ch1_combo, 6, 2, 1, 1)
glayout.addWidget(self.led_status_config_label, 7, 0, 1, 1)
glayout.addWidget(self.led_status_config_ch0_combo, 7, 1, 1, 1)
glayout.addWidget(self.led_status_config_ch1_combo, 7, 2, 1, 1)
glayout.addLayout(hlayout, 8, 1, 1, 1)
glayout.addLayout(hlayout1, 8, 2, 1, 1)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
layout.addLayout(glayout)
self.ui_group_ch_status_ch0 = [
self.led_status_config_ch0_combo,
self.led_status_config_ch0_min_sbox,
self.led_status_config_ch0_max_sbox
]
self.ui_group_ch_status_ch1 = [
self.led_status_config_ch1_combo,
self.led_status_config_ch1_min_sbox,
self.led_status_config_ch1_max_sbox
]
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletIndustrialDualAnalogInV2, *args)
self.analog_in = self.device
self.cbe_voltage0 = CallbackEmulator(functools.partial(self.analog_in.get_voltage, 0),
functools.partial(self.cb_voltage, 0),
self.increase_error_count)
self.cbe_voltage1 = CallbackEmulator(functools.partial(self.analog_in.get_voltage, 1),
functools.partial(self.cb_voltage, 1),
self.increase_error_count)
self.calibration = None
self.sample_rate_label = QLabel('Sample Rate:')
self.sample_rate_combo = QComboBox()
self.sample_rate_combo.addItem('976 Hz')
self.sample_rate_combo.addItem('488 Hz')
self.sample_rate_combo.addItem('244 Hz')
self.sample_rate_combo.addItem('122 Hz')
self.sample_rate_combo.addItem('61 Hz')
self.sample_rate_combo.addItem('4 Hz')
self.sample_rate_combo.addItem('2 Hz')
self.sample_rate_combo.addItem('1 Hz')
self.current_voltage = [None, None] # float, V
self.calibration_button = QPushButton('Calibration...')
self.sample_rate_combo.currentIndexChanged.connect(self.sample_rate_combo_index_changed)
self.calibration_button.clicked.connect(self.calibration_button_clicked)
plots = [('Channel 0', Qt.red, lambda: self.current_voltage[0], format_voltage),
('Channel 1', Qt.blue, lambda: self.current_voltage[1], format_voltage)]
self.plot_widget = PlotWidget('Voltage [V]', plots)
# Define lines
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
line1 = QFrame()
line1.setFrameShape(QFrame.HLine)
line1.setFrameShadow(QFrame.Sunken)
line2 = QFrame()
line2.setFrameShape(QFrame.HLine)
line2.setFrameShadow(QFrame.Sunken)
# Define channel LED status config widgets
self.led_config_ch0_label = QLabel('Channel 0')
self.led_config_ch1_label = QLabel('Channel 1')
self.led_config_label = QLabel('LED Config:')
self.led_status_config_label = QLabel('LED Status Config:')
self.led_status_config_ch0_min_label = QLabel('Min:')
self.led_status_config_ch0_max_label = QLabel('Max:')
self.led_status_config_ch1_min_label = QLabel('Min:')
self.led_status_config_ch1_max_label = QLabel('Max:')
self.led_config_ch0_combo = QComboBox()
self.led_config_ch0_combo.addItem('Off')
self.led_config_ch0_combo.addItem('On')
self.led_config_ch0_combo.addItem('Show Heartbeat')
self.led_config_ch0_combo.addItem('Show Channel Status')
self.led_config_ch0_combo.currentIndexChanged.connect(self.led_config_ch0_combo_changed)
self.led_config_ch1_combo = QComboBox()
self.led_config_ch1_combo.addItem('Off')
self.led_config_ch1_combo.addItem('On')
self.led_config_ch1_combo.addItem('Show Heartbeat')
self.led_config_ch1_combo.addItem('Show Channel Status')
self.led_config_ch1_combo.currentIndexChanged.connect(self.led_config_ch1_combo_changed)
self.led_status_config_ch0_combo = QComboBox()
self.led_status_config_ch0_combo.addItem('Threshold')
self.led_status_config_ch0_combo.addItem('Intensity')
self.led_status_config_ch0_combo.currentIndexChanged.connect(self.led_status_config_ch0_combo_changed)
self.led_status_config_ch1_combo = QComboBox()
self.led_status_config_ch1_combo.addItem('Threshold')
self.led_status_config_ch1_combo.addItem('Intensity')
self.led_status_config_ch1_combo.currentIndexChanged.connect(self.led_status_config_ch1_combo_changed)
self.led_status_config_ch0_min_sbox = QSpinBox()
self.led_status_config_ch0_min_sbox.setMinimum(-35000)
self.led_status_config_ch0_min_sbox.setMaximum(35000)
self.led_status_config_ch0_min_sbox.setValue(0)
self.led_status_config_ch0_min_sbox.setSingleStep(1)
self.led_status_config_ch0_min_sbox.setSuffix(' mV')
self.led_status_config_ch0_min_sbox.valueChanged.connect(self.led_status_config_ch0_min_sbox_changed)
self.led_status_config_ch0_max_sbox = QSpinBox()
self.led_status_config_ch0_max_sbox.setMinimum(-35000)
self.led_status_config_ch0_max_sbox.setMaximum(35000)
self.led_status_config_ch0_max_sbox.setValue(0)
self.led_status_config_ch0_max_sbox.setSingleStep(1)
self.led_status_config_ch0_max_sbox.setSuffix(' mV')
self.led_status_config_ch0_max_sbox.valueChanged.connect(self.led_status_config_ch0_max_sbox_changed)
self.led_status_config_ch1_min_sbox = QSpinBox()
self.led_status_config_ch1_min_sbox.setMinimum(-35000)
self.led_status_config_ch1_min_sbox.setMaximum(35000)
self.led_status_config_ch1_min_sbox.setValue(0)
self.led_status_config_ch1_min_sbox.setSingleStep(1)
self.led_status_config_ch1_min_sbox.setSuffix(' mV')
self.led_status_config_ch1_min_sbox.valueChanged.connect(self.led_status_config_ch1_min_sbox_changed)
self.led_status_config_ch1_max_sbox = QSpinBox()
self.led_status_config_ch1_max_sbox.setMinimum(-35000)
self.led_status_config_ch1_max_sbox.setMaximum(35000)
self.led_status_config_ch1_max_sbox.setValue(0)
self.led_status_config_ch1_max_sbox.setSingleStep(1)
self.led_status_config_ch1_max_sbox.setSuffix(' mV')
self.led_status_config_ch1_max_sbox.valueChanged.connect(self.led_status_config_ch1_max_sbox_changed)
# Define size policies
h_sp = QSizePolicy()
h_sp.setHorizontalPolicy(QSizePolicy.Expanding)
# Set size policies
self.sample_rate_combo.setSizePolicy(h_sp)
self.led_config_ch0_combo.setSizePolicy(h_sp)
self.led_config_ch1_combo.setSizePolicy(h_sp)
self.led_status_config_ch0_combo.setSizePolicy(h_sp)
self.led_status_config_ch1_combo.setSizePolicy(h_sp)
self.led_status_config_ch0_min_sbox.setSizePolicy(h_sp)
self.led_status_config_ch0_max_sbox.setSizePolicy(h_sp)
self.led_status_config_ch1_min_sbox.setSizePolicy(h_sp)
self.led_status_config_ch1_max_sbox.setSizePolicy(h_sp)
# Define layouts
hlayout = QHBoxLayout()
vlayout = QVBoxLayout()
glayout = QGridLayout()
layout = QVBoxLayout(self)
hlayout_ch0_min_max = QHBoxLayout()
hlayout_ch1_min_max = QHBoxLayout()
# Populate layouts
vlayout.addWidget(self.calibration_button)
hlayout.addWidget(self.sample_rate_label)
hlayout.addWidget(self.sample_rate_combo)
vlayout.addLayout(hlayout)
vlayout.addWidget(line1)
hlayout_ch0_min_max.addWidget(self.led_status_config_ch0_min_label)
hlayout_ch0_min_max.addWidget(self.led_status_config_ch0_min_sbox)
hlayout_ch0_min_max.addWidget(self.led_status_config_ch0_max_label)
hlayout_ch0_min_max.addWidget(self.led_status_config_ch0_max_sbox)
hlayout_ch1_min_max.addWidget(self.led_status_config_ch1_min_label)
hlayout_ch1_min_max.addWidget(self.led_status_config_ch1_min_sbox)
hlayout_ch1_min_max.addWidget(self.led_status_config_ch1_max_label)
hlayout_ch1_min_max.addWidget(self.led_status_config_ch1_max_sbox)
glayout.addWidget(self.led_config_ch0_label, 0, 1, 1, 1) # R, C, RS, CS
glayout.addWidget(self.led_config_ch1_label, 0, 2, 1, 1)
glayout.addWidget(line2, 1, 0, 1, 3)
glayout.addWidget(self.led_config_label, 2, 0, 1, 1)
glayout.addWidget(self.led_config_ch0_combo, 2, 1, 1, 1)
glayout.addWidget(self.led_config_ch1_combo, 2, 2, 1, 1)
glayout.addWidget(self.led_status_config_label, 3, 0, 1, 1)
glayout.addWidget(self.led_status_config_ch0_combo, 3, 1, 1, 1)
glayout.addWidget(self.led_status_config_ch1_combo, 3, 2, 1, 1)
glayout.addLayout(hlayout_ch0_min_max, 4, 1, 1, 1)
glayout.addLayout(hlayout_ch1_min_max, 4, 2, 1, 1)
layout.addWidget(self.plot_widget)
layout.addWidget(line)
layout.addLayout(vlayout)
layout.addLayout(glayout)
self.ui_group_ch_status_ch0 = [self.led_status_config_ch0_combo,
self.led_status_config_ch0_min_sbox,
self.led_status_config_ch0_max_sbox]
self.ui_group_ch_status_ch1 = [self.led_status_config_ch1_combo,
self.led_status_config_ch1_min_sbox,
self.led_status_config_ch1_max_sbox]
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):
COMCUPluginBase.__init__(self, BrickletIO4V2, *args)
self.setupUi(self)
self.io = self.device
self.has_monoflop_abort_by_set_configuration = None
self.io.set_response_expected(self.io.FUNCTION_SET_CONFIGURATION, True)
self.cbe_value = CallbackEmulator(self.io.get_value, None,
self.cb_value,
self.increase_error_count)
self.config_direction = [None] * 4
self.config_value = [None] * 4
self.lbl_st_ch_v = [
self.lbl_st_ch0_v, self.lbl_st_ch1_v, self.lbl_st_ch2_v,
self.lbl_st_ch3_v
]
self.lbl_st_ch_d = [
self.lbl_st_ch0_d, self.lbl_st_ch1_d, self.lbl_st_ch2_d,
self.lbl_st_ch3_d
]
self.lbl_st_ch_cfg = [
self.lbl_st_ch0_cfg, self.lbl_st_ch1_cfg, self.lbl_st_ch2_cfg,
self.lbl_st_ch3_cfg
]
self.lbl_st_ch_monoflop_t = [
self.lbl_st_ch0_monoflop_t, self.lbl_st_ch1_monoflop_t,
self.lbl_st_ch2_monoflop_t, self.lbl_st_ch3_monoflop_t
]
self.cbox_cfg_ch_dir.setItemData(0, self.io.DIRECTION_IN)
self.cbox_cfg_ch_dir.setItemData(1, self.io.DIRECTION_OUT)
self.cbox_cfg_ch_v.setItemData(0, True)
self.cbox_cfg_ch_v.setItemData(1, False)
self.btn_monoflop_go.clicked.connect(self.btn_monoflop_go_clicked)
self.btn_cfg_ch_save.clicked.connect(self.btn_cfg_ch_save_clicked)
self.cbox_cfg_ch.currentIndexChanged.connect(self.cbox_cfg_ch_changed)
self.cbox_cfg_ch_dir.currentIndexChanged.connect(
self.cbox_cfg_ch_dir_changed)
self.monoflop_values = []
self.monoflop_times = []
for i in range(4):
monoflop_value = QComboBox()
monoflop_value.addItem('High', 1)
monoflop_value.addItem('Low', 0)
self.monoflop_values.append(monoflop_value)
self.monoflop_value_stack.addWidget(monoflop_value)
monoflop_time = QSpinBox()
monoflop_time.setRange(1, (1 << 31) - 1)
monoflop_time.setValue(1000)
self.monoflop_times.append(monoflop_time)
self.monoflop_time_stack.addWidget(monoflop_time)
self.monoflop = Monoflop(
self.io, [0, 1, 2, 3],
self.monoflop_values,
self.cb_value_change_by_monoflop,
self.monoflop_times,
self.lbl_st_ch_monoflop_t,
self,
handle_get_monoflop_invalid_parameter_as_abort=True)
