コード例 #1
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletLine, *args)

        self.line = self.device

        self.cbe_reflectivity = CallbackEmulator(self.line.get_reflectivity,
                                                 self.cb_reflectivity,
                                                 self.increase_error_count)

        self.reflectivity_label = ReflectivityLabel()
        self.rf = ReflectivityFrame()

        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Reflectivity', plot_list)

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.reflectivity_label)
        layout_h.addStretch()

        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.rf)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addWidget(self.plot_widget)
コード例 #2
0
ファイル: dual_relay.py プロジェクト: fk0815/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletDualRelay, *args)

        self.setupUi(self)

        self.dr = self.device

        self.state1_combobox.setItemData(0, True)
        self.state1_combobox.setItemData(1, False)

        self.state2_combobox.setItemData(0, True)
        self.state2_combobox.setItemData(1, False)

        self.monoflop = Monoflop(self.dr, [1, 2],
                                 [self.state1_combobox, self.state2_combobox],
                                 self.cb_state_change_by_monoflop,
                                 [self.time1_spinbox, self.time2_spinbox],
                                 None, self)

        self.dr1_button.clicked.connect(self.dr1_clicked)
        self.dr2_button.clicked.connect(self.dr2_clicked)

        self.go1_button.clicked.connect(self.go1_clicked)
        self.go2_button.clicked.connect(self.go2_clicked)

        self.a1_pixmap = load_masked_pixmap(
            'plugin_system/plugins/dual_relay/relay_a1.bmp')
        self.a2_pixmap = load_masked_pixmap(
            'plugin_system/plugins/dual_relay/relay_a2.bmp')
        self.b1_pixmap = load_masked_pixmap(
            'plugin_system/plugins/dual_relay/relay_b1.bmp')
        self.b2_pixmap = load_masked_pixmap(
            'plugin_system/plugins/dual_relay/relay_b2.bmp')
コード例 #3
0
ファイル: rgb_led.py プロジェクト: Tinkerforge/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletRGBLED, *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)
コード例 #4
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAmbientLight, *args)

        self.al = self.device

        self.cbe_illuminance = CallbackEmulator(self.al.get_illuminance,
                                                self.cb_illuminance,
                                                self.increase_error_count)

        self.illuminance_label = IlluminanceLabel('Illuminance: ')
        self.alf = AmbientLightFrame()

        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Illuminance [lx]', plot_list)

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.illuminance_label)
        layout_h.addWidget(self.alf)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #5
0
ファイル: dual_button.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletDualButton, *args)

        self.setupUi(self)

        self.button = self.device

        self.qtcb_state_changed.connect(self.cb_state_changed)
        self.button.register_callback(self.button.CALLBACK_STATE_CHANGED,
                                      self.qtcb_state_changed.emit)

        self.led_r = DualButton.OFF
        self.led_l = DualButton.OFF
        self.button_r = DualButton.RELEASED
        self.button_l = DualButton.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
コード例 #6
0
ファイル: tilt.py プロジェクト: makerpc/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletTilt, *args)

        self.tilt = self.device

        self.cbe_tilt_state = CallbackEmulator(self.tilt.get_tilt_state,
                                               self.cb_tilt_state,
                                               self.increase_error_count)

        self.label = QLabel("Closed")
        self.closed_pixmap = load_masked_pixmap('plugin_system/plugins/tilt/tilt_closed.bmp')
        self.open_pixmap = load_masked_pixmap('plugin_system/plugins/tilt/tilt_open.bmp')
        self.closed_vibrationg_pixmap = load_masked_pixmap('plugin_system/plugins/tilt/tilt_closed_vibrating.bmp')
        
        self.image_label = QLabel("")
        self.image_label.setPixmap(self.closed_pixmap)
        
        layout = QVBoxLayout(self)
        layout.addStretch()
        
        h_layout1 = QHBoxLayout()
        h_layout1.addStretch()
        h_layout1.addWidget(self.label)
        h_layout1.addStretch()
        
        h_layout2 = QHBoxLayout()
        h_layout2.addStretch()
        h_layout2.addWidget(self.image_label)
        h_layout2.addStretch()
        
        layout.addLayout(h_layout1)
        layout.addLayout(h_layout2)
        layout.addStretch()
コード例 #7
0
ファイル: tilt.py プロジェクト: karstenerhardt/brickv
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Tilt Bricklet', version)

        self.tilt = BrickletTilt(uid, ipcon)
        
        self.qtcb_tilt_state.connect(self.cb_tilt_state)
        self.tilt.register_callback(self.tilt.CALLBACK_TILT_STATE,
                                    self.qtcb_tilt_state.emit)
        
        self.label = QLabel("Closed")
        self.closed_pixmap = bmp_to_pixmap('plugin_system/plugins/tilt/tilt_closed.bmp')
        self.open_pixmap = bmp_to_pixmap('plugin_system/plugins/tilt/tilt_open.bmp')
        self.closed_vibrationg_pixmap = bmp_to_pixmap('plugin_system/plugins/tilt/tilt_closed_vibrating.bmp')
        
        self.image_label = QLabel("")
        self.image_label.setPixmap(self.closed_pixmap)
        
        layout = QVBoxLayout(self)
        layout.addStretch()
        
        h_layout1 = QHBoxLayout()
        h_layout1.addStretch()
        h_layout1.addWidget(self.label)
        h_layout1.addStretch()
        
        h_layout2 = QHBoxLayout()
        h_layout2.addStretch()
        h_layout2.addWidget(self.image_label)
        h_layout2.addStretch()
        
        layout.addLayout(h_layout1)
        layout.addLayout(h_layout2)
        layout.addStretch()
コード例 #8
0
ファイル: heart_rate.py プロジェクト: fischero19/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletHeartRate, *args)

        self.hr = self.device

        self.cbe_heart_rate = CallbackEmulator(self.hr.get_heart_rate,
                                               self.cb_heart_rate,
                                               self.increase_error_count)

        # FIXME: add beat state getter to Heart Rate Bricklet API
        self.qtcb_beat_state_changed.connect(self.cb_beat_state_changed)
        self.hr.register_callback(self.hr.CALLBACK_BEAT_STATE_CHANGED,
                                  self.qtcb_beat_state_changed.emit)

        self.heart_white_bitmap = load_masked_pixmap('plugin_system/plugins/heart_rate/heart_white_small.bmp')
        self.heart_red_bitmap = load_masked_pixmap('plugin_system/plugins/heart_rate/heart_red_small.bmp')
        self.heart_icon = QLabel()
        self.heart_icon.setPixmap(self.heart_white_bitmap)

        self.current_heart_rate = None

        plots = [('Heart Rate', Qt.red, lambda: self.current_heart_rate, '{} BPM'.format)]
        self.plot_widget = PlotWidget('Heart Rate [BPM]', plots, extra_key_widgets=[self.heart_icon])

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
コード例 #9
0
    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()
コード例 #10
0
ファイル: distance_us.py プロジェクト: fischero19/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletDistanceUS, *args)

        self.dist = self.device

        self.cbe_distance = CallbackEmulator(self.dist.get_distance_value,
                                             self.cb_distance,
                                             self.increase_error_count)

        self.current_distance = None

        plots = [('Distance Value', Qt.red, lambda: self.current_distance, str)]
        self.plot_widget = PlotWidget('Distance Value', plots)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(0)
        self.spin_average.setMaximum(100)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(20)
        self.spin_average.editingFinished.connect(self.spin_average_finished)

        hlayout = QHBoxLayout()
        hlayout.addWidget(QLabel('Moving Average Length:'))
        hlayout.addWidget(self.spin_average)
        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)
コード例 #11
0
ファイル: tilt.py プロジェクト: fscherwi/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletTilt, *args)

        self.tilt = self.device

        self.cbe_tilt_state = CallbackEmulator(self.tilt.get_tilt_state,
                                               self.cb_tilt_state,
                                               self.increase_error_count)

        self.label = QLabel("Closed")
        self.closed_pixmap = load_masked_pixmap('plugin_system/plugins/tilt/tilt_closed.bmp')
        self.open_pixmap = load_masked_pixmap('plugin_system/plugins/tilt/tilt_open.bmp')
        self.closed_vibrationg_pixmap = load_masked_pixmap('plugin_system/plugins/tilt/tilt_closed_vibrating.bmp')
        
        self.image_label = QLabel("")
        self.image_label.setPixmap(self.closed_pixmap)
        
        layout = QVBoxLayout(self)
        layout.addStretch()
        
        h_layout1 = QHBoxLayout()
        h_layout1.addStretch()
        h_layout1.addWidget(self.label)
        h_layout1.addStretch()
        
        h_layout2 = QHBoxLayout()
        h_layout2.addStretch()
        h_layout2.addWidget(self.image_label)
        h_layout2.addStretch()
        
        layout.addLayout(h_layout1)
        layout.addLayout(h_layout2)
        layout.addStretch()
コード例 #12
0
ファイル: distance_us.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletDistanceUS, *args)

        self.dist = self.device

        self.cbe_distance = CallbackEmulator(self.dist.get_distance_value,
                                             self.cb_distance,
                                             self.increase_error_count)

        self.current_distance = None

        plots = [('Distance Value', Qt.red, lambda: self.current_distance, str)
                 ]
        self.plot_widget = PlotWidget('Distance Value', plots)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(0)
        self.spin_average.setMaximum(100)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(20)
        self.spin_average.editingFinished.connect(self.spin_average_finished)

        hlayout = QHBoxLayout()
        hlayout.addWidget(QLabel('Moving Average Length:'))
        hlayout.addWidget(self.spin_average)
        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)
コード例 #13
0
ファイル: analog_in_v2.py プロジェクト: fischero19/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAnalogInV2, *args)

        self.ai = self.device

        self.cbe_voltage = CallbackEmulator(self.ai.get_voltage,
                                            self.cb_voltage,
                                            self.increase_error_count)

        self.current_voltage = None # float, V

        plots = [('Voltage', Qt.red, lambda: self.current_voltage, format_voltage)]
        self.plot_widget = PlotWidget('Voltage [V]', plots)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(1)
        self.spin_average.setMaximum(50)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(50)
        self.spin_average.editingFinished.connect(self.spin_average_finished)

        layout_h1 = QHBoxLayout()
        layout_h1.addWidget(QLabel('Moving Average Length:'))
        layout_h1.addWidget(self.spin_average)
        layout_h1.addStretch()

        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(line)
        layout.addLayout(layout_h1)
コード例 #14
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletIndustrialAnalogOut, *args)
        
        self.setupUi(self)

        self.ao = self.device
        
        self.spin_voltage.editingFinished.connect(self.voltage_spin_finished)
        self.slider_voltage.sliderReleased.connect(self.voltage_slider_released)
        self.slider_voltage.valueChanged.connect(self.voltage_slider_changed)
        self.spin_current.editingFinished.connect(self.current_spin_finished)
        self.slider_current.sliderReleased.connect(self.current_slider_released)
        self.slider_current.valueChanged.connect(self.current_slider_changed)
        
        self.radio_voltage.released.connect(self.radio_released)
        self.radio_current.released.connect(self.radio_released)
        
        self.box_voltage_range.activated.connect(self.config_changed)
        self.box_current_range.activated.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.ui_voltage = [self.label_voltage, self.label_mv, self.label_voltage_range, self.slider_voltage, self.spin_voltage, self.box_voltage_range]
        self.ui_current = [self.label_current, self.label_ua, self.label_current_range, self.slider_current, self.spin_current, self.box_current_range]
        self.new_voltage(self.last_voltage)
        self.new_current(self.last_current)
        self.mode_voltage()
コード例 #15
0
ファイル: co2.py プロジェクト: fscherwi/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletCO2, *args)

        self.co2 = self.device

        self.cbe_co2_concentration = CallbackEmulator(
            self.co2.get_co2_concentration, self.cb_co2_concentration,
            self.increase_error_count)

        self.co2_concentration_label = CO2ConcentrationLabel(
            'CO2 Concentration: ')

        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('CO2 Concentration [ppm]', plot_list)

        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.co2_concentration_label)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h2)
        layout.addWidget(self.plot_widget)
コード例 #16
0
ファイル: voltage_current.py プロジェクト: Tinkerforge/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletVoltageCurrent, *args)

        self.setupUi(self)

        self.vc = self.device

        self.cbe_current = CallbackEmulator(self.vc.get_current, self.cb_current, self.increase_error_count)
        self.cbe_voltage = CallbackEmulator(self.vc.get_voltage, self.cb_voltage, self.increase_error_count)
        self.cbe_power = CallbackEmulator(self.vc.get_power, self.cb_power, self.increase_error_count)

        self.current_voltage = None  # float, V
        self.current_current = None  # float, A
        self.current_power = None  # float, W

        plots_voltage = [("Voltage", Qt.red, lambda: self.current_voltage, format_voltage)]
        plots_current = [("Current", Qt.blue, lambda: self.current_current, format_current)]
        plots_power = [("Power", Qt.darkGreen, lambda: self.current_power, format_power)]
        self.plot_widget_voltage = PlotWidget("Voltage [V]", plots_voltage, self.button_clear_graphs)
        self.plot_widget_current = PlotWidget("Current [A]", plots_current, self.button_clear_graphs)
        self.plot_widget_power = PlotWidget("Power [W]", plots_power, self.button_clear_graphs)

        self.save_cal_button.clicked.connect(self.save_cal_clicked)
        self.save_conf_button.clicked.connect(self.save_conf_clicked)

        hlayout = QHBoxLayout()
        hlayout.addWidget(self.plot_widget_voltage)
        hlayout.addWidget(self.plot_widget_current)
        hlayout.addWidget(self.plot_widget_power)

        self.main_layout.insertLayout(0, hlayout)
コード例 #17
0
ファイル: comcu_plugin_base.py プロジェクト: jose1711/brickv
    def __init__(self, device_class, ipcon, device_info, override_base_name=None):
        PluginBase.__init__(self, device_class, ipcon, device_info, override_base_name)

        self.start_called = False
        self.has_comcu = True
        self.cbe_bootloader_mode = CallbackEmulator(self.device.get_bootloader_mode,
                                                    self.cb_bootloader_mode,
                                                    self.increase_error_count)

        self.status_led_off_action = QAction('Off', self)
        self.status_led_off_action.triggered.connect(lambda: self.device.set_status_led_config(device_class.STATUS_LED_CONFIG_OFF))
        self.status_led_on_action = QAction('On', self)
        self.status_led_on_action.triggered.connect(lambda: self.device.set_status_led_config(device_class.STATUS_LED_CONFIG_ON))
        self.status_led_show_heartbeat_action = QAction('Show Heartbeat', self)
        self.status_led_show_heartbeat_action.triggered.connect(lambda: self.device.set_status_led_config(device_class.STATUS_LED_CONFIG_SHOW_HEARTBEAT))
        self.status_led_show_status_action = QAction('Show Status', self)
        self.status_led_show_status_action.triggered.connect(lambda: self.device.set_status_led_config(device_class.STATUS_LED_CONFIG_SHOW_STATUS))

        self.extra_configs = [(0, 'Status LED:', [self.status_led_off_action,
                                                  self.status_led_on_action,
                                                  self.status_led_show_heartbeat_action,
                                                  self.status_led_show_status_action])]

        self.reset_action = QAction('Reset', self)
        self.reset_action.triggered.connect(self.remove_and_reset)

        self.extra_actions = [(0, None, [self.reset_action])]
コード例 #18
0
ファイル: heart_rate.py プロジェクト: makerpc/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletHeartRate, *args)
        
        self.hr = self.device

        self.cbe_heart_rate = CallbackEmulator(self.hr.get_heart_rate,
                                               self.cb_heart_rate,
                                               self.increase_error_count)

        # FIXME: add beat state getter to Heart Rate Bricklet API
        self.qtcb_beat_state_changed.connect(self.cb_beat_state_changed)
        self.hr.register_callback(self.hr.CALLBACK_BEAT_STATE_CHANGED,
                                  self.qtcb_beat_state_changed.emit) 
        
        self.heart_rate_label = HeartRateLabel()
        self.heart_white_bitmap = load_masked_pixmap('plugin_system/plugins/heart_rate/heart_white_small.bmp')
        self.heart_red_bitmap = load_masked_pixmap('plugin_system/plugins/heart_rate/heart_red_small.bmp')
        self.heart_icon = QLabel()
        self.heart_icon.setPixmap(self.heart_white_bitmap)
        
        self.current_value = None
        
        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Heart Rate [BPM]', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.heart_rate_label)
        layout_h.addWidget(self.heart_icon)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #19
0
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Ambient Light Bricklet', version)
        
        self.al = BrickletAmbientLight(uid, ipcon)
        
        self.qtcb_illuminance.connect(self.cb_illuminance)
        self.al.register_callback(self.al.CALLBACK_ILLUMINANCE,
                                  self.qtcb_illuminance.emit) 
        
        self.illuminance_label = IlluminanceLabel('Illuminance: ')
        self.alf = AmbientLightFrame()
        
        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Illuminance [lx]', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.illuminance_label)
        layout_h.addWidget(self.alf)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #20
0
ファイル: analog_out_v2.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAnalogOutV2, *args)

        self.ao = self.device

        self.input_voltage_label = VoltageLabel()

        self.output_voltage_label = QLabel('Output Voltage [mV]:')
        self.output_voltage_box = QSpinBox()
        self.output_voltage_box.setMinimum(0)
        self.output_voltage_box.setMaximum(12000)
        self.output_voltage_box.setSingleStep(1)

        layout_h1 = QHBoxLayout()
        layout_h1.addStretch()
        layout_h1.addWidget(self.output_voltage_label)
        layout_h1.addWidget(self.output_voltage_box)
        layout_h1.addStretch()

        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.input_voltage_label)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h2)
        layout.addLayout(layout_h1)
        layout.addStretch()

        self.output_voltage_box.editingFinished.connect(self.voltage_finished)

        self.cbe_input_voltage = CallbackEmulator(self.ao.get_input_voltage,
                                                  self.cb_get_input_voltage,
                                                  self.increase_error_count)
コード例 #21
0
ファイル: ozone.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletOzone, *args)

        self.ozone = self.device

        self.cbe_ozone_concentration = CallbackEmulator(
            self.ozone.get_ozone_concentration, self.cb_ozone_concentration,
            self.increase_error_count)

        self.current_ozone_concentration = None

        plots = [('Ozone Concentration', Qt.red,
                  lambda: self.current_ozone_concentration, '{} ppb'.format)]
        self.plot_widget = PlotWidget('Ozone Concentration [ppb]', plots)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(1)
        self.spin_average.setMaximum(50)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(50)
        self.spin_average.editingFinished.connect(self.spin_average_finished)

        hlayout = QHBoxLayout()
        hlayout.addWidget(QLabel('Moving Average Length:'))
        hlayout.addWidget(self.spin_average)
        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)
コード例 #22
0
ファイル: dual_relay.py プロジェクト: Tinkerforge/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletDualRelay, *args)

        self.setupUi(self)

        self.dr = self.device

        self.state1_combobox.setItemData(0, True)
        self.state1_combobox.setItemData(1, False)

        self.state2_combobox.setItemData(0, True)
        self.state2_combobox.setItemData(1, False)

        self.monoflop = Monoflop(self.dr,
                                 [1, 2],
                                 [self.state1_combobox, self.state2_combobox],
                                 self.cb_state_change_by_monoflop,
                                 [self.time1_spinbox, self.time2_spinbox],
                                 None,
                                 self)

        self.dr1_button.clicked.connect(self.dr1_clicked)
        self.dr2_button.clicked.connect(self.dr2_clicked)

        self.go1_button.clicked.connect(self.go1_clicked)
        self.go2_button.clicked.connect(self.go2_clicked)

        self.a1_pixmap = load_masked_pixmap('plugin_system/plugins/dual_relay/relay_a1.bmp')
        self.a2_pixmap = load_masked_pixmap('plugin_system/plugins/dual_relay/relay_a2.bmp')
        self.b1_pixmap = load_masked_pixmap('plugin_system/plugins/dual_relay/relay_b1.bmp')
        self.b2_pixmap = load_masked_pixmap('plugin_system/plugins/dual_relay/relay_b2.bmp')
コード例 #23
0
ファイル: rs232.py プロジェクト: makerpc/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletRS232, *args)

        self.setupUi(self)
        self.text.setReadOnly(True)
        
        self.rs232 = self.device
        
        #self.cbe_read = CallbackEmulator(self.rs232.read,
        #                                 self.cb_read,
        #                                 self.increase_error_count)
        
        self.input_combobox.addItem("")
        
        self.input_combobox.lineEdit().returnPressed.connect(self.input_changed)
        
        self.baudrate_combobox.activated.connect(self.configuration_changed)
        self.parity_combobox.activated.connect(self.configuration_changed)
        self.stopbits_spinbox.editingFinished.connect(self.configuration_changed)
        self.wordlength_spinbox.editingFinished.connect(self.configuration_changed)
        self.hardware_flowcontrol_combobox.activated.connect(self.configuration_changed)
        self.software_flowcontrol_combobox.activated.connect(self.configuration_changed)
        
        self.save_button.pressed.connect(self.save_pressed)
        self.timer = None
コード例 #24
0
ファイル: sound_intensity.py プロジェクト: fscherwi/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletSoundIntensity, *args)

        self.si = self.device

        self.cbe_intensity = CallbackEmulator(self.si.get_intensity,
                                              self.cb_intensity,
                                              self.increase_error_count)

        self.intensity_label = IntensityLabel()
        self.current_value = None
        self.thermo = TuningThermo()

        #plot_list = [['', Qt.red, self.get_current_value]]
        #self.plot_widget = PlotWidget('Intensity Value', plot_list)

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.intensity_label)
        layout_h.addStretch()

        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.thermo)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addStretch()
コード例 #25
0
ファイル: analog_out_v2.py プロジェクト: fischero19/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAnalogOutV2, *args)
        
        self.ao = self.device
        
        self.input_voltage_label = VoltageLabel()
        
        self.output_voltage_label = QLabel('Output Voltage [mV]: ')
        self.output_voltage_box = QSpinBox()
        self.output_voltage_box.setMinimum(0)
        self.output_voltage_box.setMaximum(12000)
        self.output_voltage_box.setSingleStep(1)
        
        layout_h1 = QHBoxLayout()
        layout_h1.addStretch()
        layout_h1.addWidget(self.output_voltage_label)
        layout_h1.addWidget(self.output_voltage_box)
        layout_h1.addStretch()
        
        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.input_voltage_label)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h2)
        layout.addLayout(layout_h1)
        layout.addStretch()
        
        self.output_voltage_box.editingFinished.connect(self.voltage_finished)
        
        self.cbe_input_voltage = CallbackEmulator(self.ao.get_input_voltage,
                                                  self.cb_get_input_voltage,
                                                  self.increase_error_count)
コード例 #26
0
ファイル: current12.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletCurrent12, *args)

        self.cur = self.device

        self.cbe_current = CallbackEmulator(self.cur.get_current,
                                            self.cb_current,
                                            self.increase_error_count)

        self.qtcb_over.connect(self.cb_over)
        self.cur.register_callback(self.cur.CALLBACK_OVER_CURRENT,
                                   self.qtcb_over.emit)

        self.over_label = QLabel('Over Current: No')
        self.calibrate_button = QPushButton('Calibrate Zero')
        self.calibrate_button.clicked.connect(self.calibrate_clicked)

        self.current_current = None  # float, A

        plots = [('Current', Qt.red, lambda: self.current_current,
                  format_current)]
        self.plot_widget = PlotWidget('Current [A]',
                                      plots,
                                      extra_key_widgets=[self.over_label])

        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(line)
        layout.addWidget(self.calibrate_button)
コード例 #27
0
ファイル: ambient_light.py プロジェクト: makerpc/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAmbientLight, *args)

        self.al = self.device

        self.cbe_illuminance = CallbackEmulator(self.al.get_illuminance,
                                                self.cb_illuminance,
                                                self.increase_error_count)

        self.illuminance_label = IlluminanceLabel('Illuminance: ')
        self.alf = AmbientLightFrame()

        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Illuminance [lx]', plot_list)

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.illuminance_label)
        layout_h.addWidget(self.alf)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #28
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletSolidStateRelay, *args)

        self.setupUi(self)

        self.ssr = self.device

        self.qtcb_monoflop.connect(self.cb_monoflop)
        self.ssr.register_callback(self.ssr.CALLBACK_MONOFLOP_DONE,
                                   self.qtcb_monoflop.emit)

        self.ssr_button.clicked.connect(self.ssr_clicked)
        self.go_button.clicked.connect(self.go_clicked)

        self.monoflop = False
        self.timebefore = 500

        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')

        self.update_timer = QTimer()
        self.update_timer.timeout.connect(self.update)
        self.update_timer.setInterval(50)
コード例 #29
0
ファイル: rotary_poti.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletRotaryPoti, *args)

        self.rp = self.device

        self.cbe_position = CallbackEmulator(self.rp.get_position,
                                             self.cb_position,
                                             self.increase_error_count)

        self.position_knob = KnobWidget(self)
        self.position_knob.setFocusPolicy(Qt.NoFocus)
        self.position_knob.set_total_angle(300)
        self.position_knob.set_range(-150, 150)
        self.position_knob.set_scale(30, 3)
        self.position_knob.set_knob_radius(25)

        self.current_position = None

        plots = [('Position', Qt.red, lambda: self.current_position, str)]
        self.plot_widget = PlotWidget('Position',
                                      plots,
                                      curve_motion_granularity=40,
                                      update_interval=0.025)

        layout = QHBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(self.position_knob)
コード例 #30
0
    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()
コード例 #31
0
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Sound Intensity Bricklet', version)

        self.si = BrickletSoundIntensity(uid, ipcon)
        
        self.qtcb_intensity.connect(self.cb_intensity)
        self.si.register_callback(self.si.CALLBACK_INTENSITY,
                                  self.qtcb_intensity.emit) 
        
        self.intensity_label = IntensityLabel()
        self.current_value = None
        self.thermo = TuningThermo()
        
#        plot_list = [['', Qt.red, self.get_current_value]]
#        self.plot_widget = PlotWidget('Intensity', plot_list)
        
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.intensity_label)
        layout_h.addStretch()
        
        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.thermo)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addStretch()
コード例 #32
0
ファイル: master.py プロジェクト: fscherwi/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickMaster, *args)

        self.setupUi(self)

        self.master = self.device
        
        self.update_timer = QTimer()
        self.update_timer.timeout.connect(self.update_data)

        self.extension_type = None

        self.extensions = []
        self.num_extensions = 0

        self.extension_label.setText("None Present")
        self.tab_widget.removeTab(0)
        self.tab_widget.hide()

        if self.firmware_version >= (1, 1, 0):
            self.check_extensions = True
            self.extension_type_button.clicked.connect(self.extension_clicked)
        else:
            self.check_extensions = False
            self.extension_type_button.setEnabled(False)

        if self.firmware_version >= (1, 2, 1):
            reset = QAction('Reset', self)
            reset.triggered.connect(lambda: self.master.reset())
            self.set_actions(reset)

        self.extension_type_preset = [None, False, False, False, False, False]
        self.update_extensions_in_device_info()
コード例 #33
0
ファイル: led_strip.py プロジェクト: karstenerhardt/brickv
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'LED Strip Bricklet', version)
        
        self.setupUi(self)
        
        self.has_clock_frequency = version >= (2, 0, 1)

        self.led_strip = BrickletLEDStrip(uid, ipcon)
        
        self.qtcb_frame_rendered.connect(self.cb_frame_rendered)
        
        self.button_gradient.pressed.connect(self.gradient_pressed)
        self.button_color.pressed.connect(self.color_pressed)
        self.box_frame_duration.valueChanged.connect(self.frame_duration_changed)
        if self.has_clock_frequency:
            self.box_clock_frequency.valueChanged.connect(self.clock_frequency_changed)
        else:
            self.box_clock_frequency.setValue(20000000)
            self.box_clock_frequency.setEnabled(False)
        
        self.state = self.STATE_IDLE
        
        self.gradient_counter = 0
        
        self.voltage = 0
        
        self.voltage_timer = QTimer()
        self.voltage_timer.timeout.connect(self.update_voltage)
        self.voltage_timer.setInterval(1000)
コード例 #34
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletLoadCell, *args)

        self.lc = self.device

        self.cbe_weight = CallbackEmulator(self.lc.get_weight, self.cb_weight,
                                           self.increase_error_count)

        self.weight_label = WeightLabel()

        self.gain = 0  # 128x
        self.current_value = None
        self.calibration = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Weight [g]', plot_list)

        self.button_calibration = QPushButton("Calibration")
        self.button_calibration.clicked.connect(
            self.button_calibration_clicked)

        self.button_tare = QPushButton("Tare")
        self.button_tare.clicked.connect(self.button_tare_clicked)

        self.enable_led = QCheckBox("LED On")
        self.enable_led.stateChanged.connect(self.enable_led_changed)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(0)
        self.spin_average.setMaximum(40)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(5)
        self.spin_average.editingFinished.connect(self.spin_average_finished)
        self.label_average = QLabel('Length of moving average:')

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.weight_label)
        layout_h.addStretch()

        self.rate_label = QLabel('Rate: ')
        self.rate_combo = QComboBox()
        self.rate_combo.addItem("10Hz")
        self.rate_combo.addItem("80Hz")
        self.rate_combo.currentIndexChanged.connect(self.new_config)

        layout_avg = QHBoxLayout()
        layout_avg.addWidget(self.label_average)
        layout_avg.addWidget(self.spin_average)
        layout_avg.addWidget(self.rate_label)
        layout_avg.addWidget(self.rate_combo)
        layout_avg.addStretch()
        layout_avg.addWidget(self.button_calibration)
        layout_avg.addWidget(self.button_tare)
        layout_avg.addWidget(self.enable_led)

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
        layout.addLayout(layout_avg)
コード例 #35
0
ファイル: current12.py プロジェクト: fischero19/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletCurrent12, *args)

        self.cur = self.device

        self.cbe_current = CallbackEmulator(self.cur.get_current,
                                            self.cb_current,
                                            self.increase_error_count)

        self.qtcb_over.connect(self.cb_over)
        self.cur.register_callback(self.cur.CALLBACK_OVER_CURRENT,
                                   self.qtcb_over.emit)

        self.over_label = QLabel('Over Current: No')
        self.calibrate_button = QPushButton('Calibrate Zero')
        self.calibrate_button.clicked.connect(self.calibrate_clicked)

        self.current_current = None # float, A

        plots = [('Current', Qt.red, lambda: self.current_current, format_current)]
        self.plot_widget = PlotWidget('Current [A]', plots, extra_key_widgets=[self.over_label])

        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(line)
        layout.addWidget(self.calibrate_button)
コード例 #36
0
ファイル: gps.py プロジェクト: Tinkerforge/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletGPS, *args)

        self.setupUi(self)

        self.gps = self.device

        self.cbe_universal = CallbackEmulator(self.get_universal,
                                              None,
                                              self.cb_universal,
                                              self.increase_error_count,
                                              expand_result_tuple_for_callback=True)

        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.last_pdop = 0
        self.last_hdop = 0
        self.last_vdop = 0
        self.last_epe = 0
コード例 #37
0
ファイル: heart_rate.py プロジェクト: karstenerhardt/brickv
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Heart Rate Bricklet', version)
        
        self.hr = BrickletHeartRate(uid, ipcon)
        
        self.qtcb_heart_rate.connect(self.cb_heart_rate)
        self.hr.register_callback(self.hr.CALLBACK_HEART_RATE,
                                  self.qtcb_heart_rate.emit) 
        self.qtcb_beat_state_changed.connect(self.cb_beat_state_changed)
        self.hr.register_callback(self.hr.CALLBACK_BEAT_STATE_CHANGED,
                                  self.qtcb_beat_state_changed.emit) 
        
        self.heart_rate_label = HeartRateLabel()
        self.heart_white_bitmap = bmp_to_pixmap('plugin_system/plugins/heart_rate/heart_white_small.bmp')
        self.heart_red_bitmap = bmp_to_pixmap('plugin_system/plugins/heart_rate/heart_red_small.bmp')
        self.heart_icon = QLabel()
        self.heart_icon.setPixmap(self.heart_white_bitmap)
        
        self.current_value = None
        
        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Heart Rate [BPM]', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.heart_rate_label)
        layout_h.addWidget(self.heart_icon)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #38
0
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Industrial Digital In 4 Bricklet', version)
        
        self.setupUi(self)
        
        self.idi4 = BrickletIndustrialDigitalIn4(uid, ipcon)
        
        self.gnd_pixmap = bmp_to_pixmap('plugin_system/plugins/industrial_digital_in_4/dio_gnd.bmp')
        self.vcc_pixmap = bmp_to_pixmap('plugin_system/plugins/industrial_digital_in_4/dio_vcc.bmp')
        
        self.pin_buttons = [self.b0, self.b1, self.b2, self.b3, self.b4, self.b5, self.b6, self.b7, self.b8, self.b9, self.b10, self.b11, self.b12, self.b13, self.b14, self.b15]
        self.pin_button_icons = [self.b0_icon, self.b1_icon, self.b2_icon, self.b3_icon, self.b4_icon, self.b5_icon, self.b6_icon, self.b7_icon, self.b8_icon, self.b9_icon, self.b10_icon, self.b11_icon, self.b12_icon, self.b13_icon, self.b14_icon, self.b15_icon]
        self.pin_button_labels = [self.b0_label, self.b1_label, self.b2_label, self.b3_label, self.b4_label, self.b5_label, self.b6_label, self.b7_label, self.b8_label, self.b9_label, self.b10_label, self.b11_label, self.b12_label, self.b13_label, self.b14_label, self.b15_label]
        self.groups = [self.group0, self.group1, self.group2, self.group3]

        self.lines = [[self.line0, self.line0a, self.line0b, self.line0c],
                      [self.line1, self.line1a, self.line1b, self.line1c],
                      [self.line2, self.line2a, self.line2b, self.line2c],
                      [self.line3, self.line3a, self.line3b, self.line3c]]
        for lines in self.lines:
            for line in lines:
                line.setVisible(False)
        
        self.available_ports = 0
        async_call(self.idi4.get_available_for_group, None, self.get_available_for_group_aysnc, self.increase_error_count)
        
        self.qtcb_interrupt.connect(self.cb_interrupt)
        self.idi4.register_callback(self.idi4.CALLBACK_INTERRUPT,
                                    self.qtcb_interrupt.emit)
        
        self.set_group.pressed.connect(self.set_group_pressed)
        
        self.debounce_go.pressed.connect(self.debounce_go_pressed)
        
        self.reconfigure_everything()
コード例 #39
0
ファイル: uv_light.py プロジェクト: fscherwi/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletUVLight, *args)

        self.uv_light = self.device

        self.cbe_uv_light = CallbackEmulator(self.uv_light.get_uv_light,
                                             self.cb_uv_light,
                                             self.increase_error_count)

        self.uv_label = UVLabel(u'UV Light: ')
        self.index_label = IndexLabel(u'UV Index: ')

        self.current_uv_light = None
        
        plot_list = [['', Qt.red, self.get_current_uv_light]]
        self.plot_widget_uv = PlotWidget(u'UV Light [µW/cm²]', plot_list)
        
        layout_h1 = QHBoxLayout()
        layout_h1.addStretch()
        layout_h1.addWidget(self.uv_label)
        layout_h1.addStretch()
        
        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.index_label)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h1)
        layout.addLayout(layout_h2)
        layout.addWidget(self.plot_widget_uv)
コード例 #40
0
ファイル: linear_poti.py プロジェクト: karstenerhardt/brickv
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Linear Poti Bricklet', version)
        
        self.lp = BrickletLinearPoti(uid, ipcon)
        
        self.qtcb_position.connect(self.cb_position)
        self.lp.register_callback(self.lp.CALLBACK_POSITION,
                                  self.qtcb_position.emit) 
        
        self.slider = QSlider(Qt.Horizontal)
        self.slider.setRange(0, 100)
        
        self.position_label = PositionLabel('Position: ')
        
        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Position', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.position_label)
        layout_h.addWidget(self.slider)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #41
0
ファイル: unknown.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, None, *args, override_base_name='Unknown')
        
        # All new released Bricklets will have a comcu
        self.has_comcu = True

        info = args[1]

        layout = QVBoxLayout()
        layout.addStretch()
        label = QLabel("""The {6} with

   * Device Identifier: {0}
   * UID: {1}
   * Position: {2}
   * FW Version: {3}.{4}.{5}

is not yet supported.

Please update Brick Viewer!""".format(info.device_identifier,
                                      info.uid,
                                      info.position.upper(),
                                      info.firmware_version_installed[0],
                                      info.firmware_version_installed[1],
                                      info.firmware_version_installed[2],
                                      'Brick' if str(info.device_identifier).startswith('1') else 'Bricklet'))

        #label.setAlignment(Qt.AlignHCenter)
        layout.addWidget(label)
        layout.addStretch()

        hbox = QHBoxLayout(self)
        hbox.addStretch()
        hbox.addLayout(layout)
        hbox.addStretch()
コード例 #42
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletHeartRate, *args)

        self.hr = self.device

        self.cbe_heart_rate = CallbackEmulator(self.hr.get_heart_rate,
                                               self.cb_heart_rate,
                                               self.increase_error_count)

        # FIXME: add beat state getter to Heart Rate Bricklet API
        self.qtcb_beat_state_changed.connect(self.cb_beat_state_changed)
        self.hr.register_callback(self.hr.CALLBACK_BEAT_STATE_CHANGED,
                                  self.qtcb_beat_state_changed.emit)

        self.heart_white_bitmap = load_masked_pixmap('plugin_system/plugins/heart_rate/heart_white_small.bmp')
        self.heart_red_bitmap = load_masked_pixmap('plugin_system/plugins/heart_rate/heart_red_small.bmp')
        self.heart_icon = QLabel()
        self.heart_icon.setPixmap(self.heart_white_bitmap)

        self.current_heart_rate = None

        plots = [('Heart Rate', Qt.red, lambda: self.current_heart_rate, '{} BPM'.format)]
        self.plot_widget = PlotWidget('Heart Rate [BPM]', plots, extra_key_widgets=[self.heart_icon])

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
コード例 #43
0
ファイル: linear_poti.py プロジェクト: fscherwi/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletLinearPoti, *args)
        
        self.lp = self.device

        self.cbe_position = CallbackEmulator(self.lp.get_position,
                                             self.cb_position,
                                             self.increase_error_count)

        self.slider = QSlider(Qt.Horizontal)
        self.slider.setRange(0, 100)
        
        self.position_label = PositionLabel('Position: ')
        
        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Position', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.position_label)
        layout_h.addWidget(self.slider)
        layout_h.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
コード例 #44
0
ファイル: line.py プロジェクト: makerpc/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletLine, *args)

        self.line = self.device

        self.cbe_reflectivity = CallbackEmulator(self.line.get_reflectivity,
                                                 self.cb_reflectivity,
                                                 self.increase_error_count)

        self.reflectivity_label = ReflectivityLabel()
        self.rf = ReflectivityFrame()

        self.current_value = None

        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Reflectivity', plot_list)

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.reflectivity_label)
        layout_h.addStretch()

        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.rf)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addWidget(self.plot_widget)
コード例 #45
0
    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())
        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
コード例 #46
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletIndustrialDigitalIn4, *args)

        self.setupUi(self)
        
        self.idi4 = self.device
        
        self.gnd_pixmap = load_masked_pixmap('plugin_system/plugins/industrial_digital_in_4/dio_gnd.bmp')
        self.vcc_pixmap = load_masked_pixmap('plugin_system/plugins/industrial_digital_in_4/dio_vcc.bmp')
        
        self.pin_buttons = [self.b0, self.b1, self.b2, self.b3, self.b4, self.b5, self.b6, self.b7, self.b8, self.b9, self.b10, self.b11, self.b12, self.b13, self.b14, self.b15]
        self.pin_button_icons = [self.b0_icon, self.b1_icon, self.b2_icon, self.b3_icon, self.b4_icon, self.b5_icon, self.b6_icon, self.b7_icon, self.b8_icon, self.b9_icon, self.b10_icon, self.b11_icon, self.b12_icon, self.b13_icon, self.b14_icon, self.b15_icon]
        self.pin_button_labels = [self.b0_label, self.b1_label, self.b2_label, self.b3_label, self.b4_label, self.b5_label, self.b6_label, self.b7_label, self.b8_label, self.b9_label, self.b10_label, self.b11_label, self.b12_label, self.b13_label, self.b14_label, self.b15_label]
        self.groups = [self.group0, self.group1, self.group2, self.group3]

        self.lines = [[self.line0, self.line0a, self.line0b, self.line0c],
                      [self.line1, self.line1a, self.line1b, self.line1c],
                      [self.line2, self.line2a, self.line2b, self.line2c],
                      [self.line3, self.line3a, self.line3b, self.line3c]]
        for lines in self.lines:
            for line in lines:
                line.setVisible(False)
        
        self.available_ports = 0
        async_call(self.idi4.get_available_for_group, None, self.get_available_for_group_aysnc, self.increase_error_count)

        self.cbe_value = CallbackEmulator(self.idi4.get_value,
                                          self.cb_value,
                                          self.increase_error_count)
        
        self.set_group.clicked.connect(self.set_group_clicked)
        
        self.debounce_go.clicked.connect(self.debounce_go_clicked)
        
        self.reconfigure_everything()
コード例 #47
0
ファイル: load_cell.py プロジェクト: Loremipsum1988/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletLoadCell, *args)
        
        self.lc = self.device

        self.cbe_weight = CallbackEmulator(self.lc.get_weight,
                                           self.cb_weight,
                                           self.increase_error_count)

        self.weight_label = WeightLabel()
        
        self.gain = 0 # 128x
        self.current_value = None
        self.calibration = None
        
        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Weight [g]', plot_list)

        self.button_calibration = QPushButton("Calibration")
        self.button_calibration.clicked.connect(self.button_calibration_clicked)

        self.button_tare = QPushButton("Tare")
        self.button_tare.clicked.connect(self.button_tare_clicked)
        
        self.enable_led = QCheckBox("LED On")
        self.enable_led.stateChanged.connect(self.enable_led_changed)
        
        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(0)
        self.spin_average.setMaximum(40)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(5)
        self.spin_average.editingFinished.connect(self.spin_average_finished)
        self.label_average = QLabel('Length of moving average:')

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.weight_label)
        layout_h.addStretch()
        
        self.rate_label = QLabel('Rate: ')
        self.rate_combo = QComboBox()
        self.rate_combo.addItem("10Hz")
        self.rate_combo.addItem("80Hz")
        self.rate_combo.currentIndexChanged.connect(self.new_config)
        
        layout_avg = QHBoxLayout()
        layout_avg.addWidget(self.label_average)
        layout_avg.addWidget(self.spin_average)
        layout_avg.addWidget(self.rate_label)
        layout_avg.addWidget(self.rate_combo)
        layout_avg.addStretch()
        layout_avg.addWidget(self.button_calibration)
        layout_avg.addWidget(self.button_tare)
        layout_avg.addWidget(self.enable_led)

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addWidget(self.plot_widget)
        layout.addLayout(layout_avg)
コード例 #48
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAnalogInV2, *args)

        self.ai = self.device

        self.cbe_voltage = CallbackEmulator(self.ai.get_voltage,
                                            self.cb_voltage,
                                            self.increase_error_count)

        self.current_voltage = None  # float, V

        plots = [('Voltage', Qt.red, lambda: self.current_voltage,
                  format_voltage)]
        self.plot_widget = PlotWidget('Voltage [V]', plots)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(1)
        self.spin_average.setMaximum(50)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(50)
        self.spin_average.editingFinished.connect(self.spin_average_finished)

        layout_h1 = QHBoxLayout()
        layout_h1.addWidget(QLabel('Moving Average Length:'))
        layout_h1.addWidget(self.spin_average)
        layout_h1.addStretch()

        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(line)
        layout.addLayout(layout_h1)
コード例 #49
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickMaster, *args)

        self.setupUi(self)

        self.master = self.device

        self.update_timer = QTimer()
        self.update_timer.timeout.connect(self.update_data)

        self.extension_type = None

        self.extensions = []
        self.num_extensions = 0

        self.extension_label.setText("None Present")
        self.tab_widget.removeTab(0)
        self.tab_widget.hide()

        if self.firmware_version >= (1, 1, 0):
            self.check_extensions = True
            self.extension_type_button.clicked.connect(self.extension_clicked)
        else:
            self.check_extensions = False
            self.extension_type_button.setEnabled(False)

        if self.firmware_version >= (1, 2, 1):
            reset = QAction('Reset', self)
            reset.triggered.connect(lambda: self.master.reset())
            self.set_actions(reset)

        self.extension_type_preset = [None, False, False, False, False, False]
        self.update_extensions_in_device_info()
コード例 #50
0
ファイル: line.py プロジェクト: karstenerhardt/brickv
    def __init__(self, ipcon, uid, version):
        PluginBase.__init__(self, ipcon, uid, 'Line Bricklet', version)

        self.line = BrickletLine(uid, ipcon)
        
        self.qtcb_reflectivity.connect(self.cb_reflectivity)
        self.line.register_callback(self.line.CALLBACK_REFLECTIVITY,
                                    self.qtcb_reflectivity.emit) 
        
        self.reflectivity_label = ReflectivityLabel()
        self.rf = ReflectivityFrame()
        
        self.current_value = None
        
        plot_list = [['', Qt.red, self.get_current_value]]
        self.plot_widget = PlotWidget('Reflectivity', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.reflectivity_label)
        layout_h.addStretch()
        
        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.rf)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addWidget(self.plot_widget)
コード例 #51
0
ファイル: gps.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletGPS, *args)

        self.setupUi(self)

        self.gps = self.device

        self.cbe_universal = CallbackEmulator(self.get_universal,
                                              self.cb_universal,
                                              self.increase_error_count)

        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.last_pdop = 0
        self.last_hdop = 0
        self.last_vdop = 0
        self.last_epe = 0
コード例 #52
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletSoundIntensity, *args)

        self.si = self.device

        self.cbe_intensity = CallbackEmulator(self.si.get_intensity,
                                              self.cb_intensity,
                                              self.increase_error_count)

        self.intensity_label = IntensityLabel()
        self.current_value = None
        self.thermo = TuningThermo()

        #plot_list = [['', Qt.red, self.get_current_value]]
        #self.plot_widget = PlotWidget('Intensity Value', plot_list)

        layout_h = QHBoxLayout()
        layout_h.addStretch()
        layout_h.addWidget(self.intensity_label)
        layout_h.addStretch()

        layout_h2 = QHBoxLayout()
        layout_h2.addStretch()
        layout_h2.addWidget(self.thermo)
        layout_h2.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addStretch()
コード例 #53
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletIndustrialDual020mA, *args)

        self.dual020 = self.device
        
        self.str_connected = 'Sensor {0} is currently <font color="green">connected</font>'
        self.str_not_connected = 'Sensor {0} is currently <font color="red">not connected</font>'

        self.cbe_current0 = CallbackEmulator(functools.partial(self.dual020.get_current, 0),
                                             functools.partial(self.cb_current, 0),
                                             self.increase_error_count)
        self.cbe_current1 = CallbackEmulator(functools.partial(self.dual020.get_current, 1),
                                             functools.partial(self.cb_current, 1),
                                             self.increase_error_count)

        self.current_label = [CurrentLabel(), CurrentLabel()]
        
        self.sample_rate_label1 = QLabel('Sample Rate:')
        self.sample_rate_combo = QComboBox()
        self.sample_rate_combo.addItem('240')
        self.sample_rate_combo.addItem('60')
        self.sample_rate_combo.addItem('15')
        self.sample_rate_combo.addItem('4')
        self.sample_rate_label2 = QLabel('Samples per second')
        
        self.connected_label = [QLabel(self.str_not_connected.format(0)),
                                QLabel(self.str_not_connected.format(1))]
        
        self.current_value = [None, None]
        
        self.sample_rate_combo.currentIndexChanged.connect(self.sample_rate_combo_index_changed)
        
        plot_list = [['Sensor 0', Qt.red, self.get_current_value0],
                     ['Sensor 1', Qt.blue, self.get_current_value1]]
        self.plot_widget = PlotWidget('Current [mA]', plot_list)
        
        layout_h = QHBoxLayout()
        layout_h.addWidget(QLabel("Sensor 0: "))
        layout_h.addWidget(self.current_label[0])
        layout_h.addStretch()
        layout_h.addWidget(self.connected_label[0])
        
        layout_h2 = QHBoxLayout()
        layout_h2.addWidget(QLabel("Sensor 1: "))
        layout_h2.addWidget(self.current_label[1])
        layout_h2.addStretch()
        layout_h2.addWidget(self.connected_label[1])
        
        layout_h3 = QHBoxLayout()
        layout_h3.addWidget(self.sample_rate_label1)
        layout_h3.addWidget(self.sample_rate_combo)
        layout_h3.addWidget(self.sample_rate_label2)
        layout_h3.addStretch()

        layout = QVBoxLayout(self)
        layout.addLayout(layout_h)
        layout.addLayout(layout_h2)
        layout.addWidget(self.plot_widget)
        layout.addLayout(layout_h3)
コード例 #54
0
ファイル: load_cell.py プロジェクト: jose1711/brickv
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletLoadCell, *args)

        self.lc = self.device

        self.cbe_weight = CallbackEmulator(self.lc.get_weight, self.cb_weight,
                                           self.increase_error_count)

        self.gain = 0  # 128x
        self.current_weight = None  # int, g
        self.calibration = None

        plots = [('Weight', Qt.red, lambda: self.current_weight, format_weight)
                 ]
        self.plot_widget = PlotWidget('Weight [g]', plots)

        self.button_calibration = QPushButton("Calibration...")
        self.button_calibration.clicked.connect(
            self.button_calibration_clicked)

        self.button_tare = QPushButton("Tare")
        self.button_tare.clicked.connect(self.button_tare_clicked)

        self.enable_led = QCheckBox("Enable LED")
        self.enable_led.stateChanged.connect(self.enable_led_changed)

        self.spin_average = QSpinBox()
        self.spin_average.setMinimum(0)
        self.spin_average.setMaximum(40)
        self.spin_average.setSingleStep(1)
        self.spin_average.setValue(5)
        self.spin_average.editingFinished.connect(self.spin_average_finished)
        self.label_average = QLabel('Moving Average Length:')

        self.rate_label = QLabel('Rate:')
        self.rate_combo = QComboBox()
        self.rate_combo.addItem("10 Hz")
        self.rate_combo.addItem("80 Hz")
        self.rate_combo.currentIndexChanged.connect(self.new_config)

        hlayout = QHBoxLayout()
        hlayout.addWidget(self.label_average)
        hlayout.addWidget(self.spin_average)
        hlayout.addWidget(self.rate_label)
        hlayout.addWidget(self.rate_combo)
        hlayout.addStretch()
        hlayout.addWidget(self.button_calibration)
        hlayout.addWidget(self.button_tare)
        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)
コード例 #55
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletPTC, *args)

        self.ptc = self.device

        self.str_connected = 'Sensor is <font color="green">connected</font>'
        self.str_not_connected = 'Sensor is <font color="red">not connected</font>'

        self.cbe_temperature = CallbackEmulator(self.ptc.get_temperature,
                                                self.cb_temperature,
                                                self.increase_error_count)

        #self.cbe_resistance = CallbackEmulator(self.ptc.get_resistance,
        #                                       self.cb_resistance,
        #                                       self.increase_error_count)

        #self.resistance_label = ResistanceLabel()

        self.wire_label = QLabel('Wire Type:')
        self.wire_combo = QComboBox()
        self.wire_combo.addItem('2-Wire')
        self.wire_combo.addItem('3-Wire')
        self.wire_combo.addItem('4-Wire')

        self.noise_label = QLabel('Noise Rejection Filter:')
        self.noise_combo = QComboBox()
        self.noise_combo.addItem('50 Hz')
        self.noise_combo.addItem('60 Hz')

        self.connected_label = QLabel(self.str_connected)

        self.current_temperature = None # float, °C

        self.wire_combo.currentIndexChanged.connect(self.wire_combo_index_changed)
        self.noise_combo.currentIndexChanged.connect(self.noise_combo_index_changed)

        plots = [('Temperature', Qt.red, lambda: self.current_temperature, u'{} °C'.format)]
        self.plot_widget = PlotWidget(u'Temperature [°C]', plots, extra_key_widgets=[self.connected_label])

        hlayout = QHBoxLayout()
        hlayout.addWidget(self.wire_label)
        hlayout.addWidget(self.wire_combo)
        hlayout.addStretch()
        hlayout.addWidget(self.noise_label)
        hlayout.addWidget(self.noise_combo)

        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)
        layout.addWidget(line)
        layout.addLayout(hlayout)

        self.connected_timer = QTimer()
        self.connected_timer.timeout.connect(self.update_connected)
        self.connected_timer.setInterval(1000)
コード例 #56
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletAnalogIn, *args)

        self.ai = self.device

        self.cbe_voltage = CallbackEmulator(self.ai.get_voltage,
                                            self.cb_voltage,
                                            self.increase_error_count)

        self.current_voltage = None  # float, V

        plots = [('Voltage', Qt.red, lambda: self.current_voltage,
                  format_voltage)]
        self.plot_widget = PlotWidget('Voltage [V]', plots)

        layout = QVBoxLayout(self)
        layout.addWidget(self.plot_widget)

        if self.firmware_version >= (2, 0, 1):
            self.combo_range = QComboBox()
            self.combo_range.addItem('Automatic',
                                     BrickletAnalogIn.RANGE_AUTOMATIC)
            if self.firmware_version >= (2, 0, 3):
                self.combo_range.addItem('0 - 3.30 V',
                                         BrickletAnalogIn.RANGE_UP_TO_3V)
            self.combo_range.addItem('0 - 6.05 V',
                                     BrickletAnalogIn.RANGE_UP_TO_6V)
            self.combo_range.addItem('0 - 10.32 V',
                                     BrickletAnalogIn.RANGE_UP_TO_10V)
            self.combo_range.addItem('0 - 36.30 V',
                                     BrickletAnalogIn.RANGE_UP_TO_36V)
            self.combo_range.addItem('0 - 45.00 V',
                                     BrickletAnalogIn.RANGE_UP_TO_45V)
            self.combo_range.currentIndexChanged.connect(self.range_changed)

            hlayout = QHBoxLayout()
            hlayout.addWidget(QLabel('Range:'))
            hlayout.addWidget(self.combo_range)
            hlayout.addStretch()

            if self.firmware_version >= (2, 0, 3):
                self.spin_average = QSpinBox()
                self.spin_average.setMinimum(0)
                self.spin_average.setMaximum(255)
                self.spin_average.setSingleStep(1)
                self.spin_average.setValue(50)
                self.spin_average.editingFinished.connect(
                    self.spin_average_finished)

                hlayout.addWidget(QLabel('Average Length:'))
                hlayout.addWidget(self.spin_average)

            line = QFrame()
            line.setFrameShape(QFrame.HLine)
            line.setFrameShadow(QFrame.Sunken)

            layout.addWidget(line)
            layout.addLayout(hlayout)
コード例 #57
0
    def __init__(self, *args):
        PluginBase.__init__(self, BrickletRS232, *args)

        self.setupUi(self)

        # the firmware version of a EEPROM Bricklet can (under common circumstances)
        # not change during the lifetime of an EEPROM Bricklet plugin. therefore,
        # it's okay to make final decisions based on it here
        self.has_error_callback = self.firmware_version >= (2, 0, 1)

        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)

        if self.has_error_callback:
            self.label_no_error_support.hide()
            self.qtcb_error.connect(self.cb_error)
            self.rs232.register_callback(self.rs232.CALLBACK_ERROR,
                                         self.qtcb_error.emit)
        else:
            self.widget_errors.hide()

        self.input_combobox.addItem("")
        self.input_combobox.lineEdit().setMaxLength(58)
        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_combobox.currentIndexChanged.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_overrun = 0
        self.error_parity = 0
        self.error_framing = 0

        self.last_char = ''
コード例 #58
0
    def __init__(self, *args):
        PluginBase.__init__(self, None, *args, override_base_name='Error')

        layout = QVBoxLayout(self)
        layout.addStretch()
        label = QLabel("An error occured while the tab for this Brick or Bricklet was created.")
        label.setAlignment(Qt.AlignHCenter)
        layout.addWidget(label)
        layout.addStretch()