def is_present_async(present, extension_type, name): self.extension_type_preset[extension_type] = present if present: if self.device_info.extensions['ext0'] == None: ext = 'ext0' elif self.device_info.extensions['ext1'] == None: ext = 'ext1' else: return # This should never be the case self.device_info.extensions[ext] = infos.ExtensionInfo() self.device_info.extensions[ext].name = name self.device_info.extensions[ext].extension_type = extension_type self.device_info.extensions[ext].position = ext self.device_info.extensions[ext].master_info = self.device_info infos.update_info(self.uid) def get_wifi2_firmware_version_async(version, ext): self.device_info.extensions[ext].firmware_version_installed = version infos.update_info(self.uid) if extension_type == self.master.EXTENSION_TYPE_WIFI2: self.device_info.extensions[ext].url_part = 'wifi_v2' async_call(self.master.get_wifi2_firmware_version, None, lambda v: get_wifi2_firmware_version_async(v, ext), self.increase_error_count)
def reconfigure_everything_async1(self, group): for i in range(4): if group[i] == 'n': self.groups[i].setCurrentIndex(0) else: item = 'Port ' + group[i].upper() index = self.groups[i].findText(item, Qt.MatchStartsWith) if index == -1: self.groups[i].setCurrentIndex(0) else: self.groups[i].setCurrentIndex(index) self.monoflop_pin.clear() if group[0] == 'n' and group[1] == 'n' and group[2] == 'n' and group[3] == 'n': self.show_buttons(0) self.hide_buttons(1) self.hide_buttons(2) self.hide_buttons(3) self.monoflop_pin.addItem('Pin 0') self.monoflop_pin.addItem('Pin 1') self.monoflop_pin.addItem('Pin 2') self.monoflop_pin.addItem('Pin 3') else: for i in range(4): if group[i] == 'n': self.hide_buttons(i) else: for j in range(4): self.monoflop_pin.addItem('Pin ' + str(i*4+j)) self.show_buttons(i) self.monoflop_pin.setCurrentIndex(0) async_call(self.ido4.get_value, None, self.reconfigure_everything_async2, self.increase_error_count)
def apply_changes(self): config = self.configs[self.combo_config.currentIndex()] content = config.edit.toPlainText() self.action_in_progress = True self.update_ui_state() self.label_progress.setText('Uploading ' + config.absolute_name) def cb_open(red_file): def cb_write(error): red_file.release() self.action_in_progress = False self.update_ui_state() if error != None: QMessageBox.critical(get_main_window(), 'Apply Changes Error', u'Error while writing {0}: {1}'.format(config.display_name, error)) return config.set_content(content) red_file.write_async(content.encode('utf-8'), cb_write) def cb_open_error(error): self.action_in_progress = False self.update_ui_state() QMessageBox.critical(get_main_window(), 'Apply Changes Error', u'Error while opening {0}: {1}'.format(config.display_name, error)) async_call(REDFile(self.session).open, (config.absolute_name, REDFile.FLAG_WRITE_ONLY | REDFile.FLAG_CREATE | REDFile.FLAG_NON_BLOCKING | REDFile.FLAG_TRUNCATE, 0o644, 0, 0), cb_open, cb_open_error, report_exception=True)
def start(self): if self.session == None: return if self.image_version.string == None: # FIXME: this is should actually be sync to ensure that the image # version is known before it'll be used def read_image_version_async(red_file): return red_file.open('/etc/tf_image_version', REDFile.FLAG_READ_ONLY | REDFile.FLAG_NON_BLOCKING, 0, 0, 0).read(256).decode('utf-8').strip() def cb_success(image_version): if self.label_version != None: self.label_version.setText(image_version) m = re.match(r'(\d+)\.(\d+)\s+\((.+)\)', image_version) if m != None: try: self.image_version.string = image_version self.image_version.number = (int(m.group(1)), int(m.group(2))) self.image_version.flavor = m.group(3) except: pass self.label_discovering.hide() self.tab_widget.show() self.tab_widget_current_changed(self.tab_widget.currentIndex()) async_call(read_image_version_async, REDFile(self.session), cb_success, None) else: self.tab_widget_current_changed(self.tab_widget.currentIndex())
def start(self): async_call(self.analog_in.get_sample_rate, None, self.get_sample_rate_async, self.increase_error_count) self.cbe_voltage0.set_period(100) self.cbe_voltage1.set_period(100) self.plot_widget.stop = False
def start(self): async_call(self.rs2.get_remote_configuration, None, self.get_remote_configuration_async, self.increase_error_count) self.timer_get_remote_input.start()
def stop(self): self.cbe_error_count.set_period(0) if not self.read_callback_was_enabled: try: async_call(self.rs485.disable_read_callback, None, None, None) except: pass
def get_image_version_async(self): if self.session == None: return def read_image_version_async(red_file): return red_file.open('/etc/tf_image_version', REDFile.FLAG_READ_ONLY | REDFile.FLAG_NON_BLOCKING, 0, 0, 0).read(256).decode('utf-8').strip() def cb_success(image_version): if self.label_version != None: self.label_version.setText(image_version) m = re.match(r'(\d+)\.(\d+)\s+\((.+)\)', image_version) if m != None: try: self.image_version.number = (int(m.group(1)), int(m.group(2))) self.image_version.flavor = m.group(3) self.image_version.string = image_version # set this last, because it is used as validity check except: self.label_discovering.setText('Error: Could not parse Image Version: {0}'.format(image_version)) else: self.widget_discovering.hide() self.tab_widget.show() self.tab_widget_current_changed(self.tab_widget.currentIndex()) self.device_info.firmware_version_installed = self.image_version.number + (0, ) brickv.infos.update_info(self.device_info.uid) else: self.label_discovering.setText('Error: Could not parse Image Version: {0}'.format(image_version)) self.label_discovering.setText('Discovering Image Version...') self.widget_discovering.show() async_call(read_image_version_async, REDFile(self.session), cb_success, None)
def start(self): async_call(self.rtc.get_offset, None, self.get_offset_async, self.increase_error_count) if self.firmware_version >= (2, 0, 1): async_call(self.rtc.get_alarm, None, self.get_alarm_async, self.increase_error_count) self.cbe_date_time.set_period(50)
def start(self): async_call(self.hf.get_edge_count_config, None, self.get_edge_count_config_async, self.increase_error_count, expand_result_tuple_for_callback=True) self.cbe_edge_count.set_period(50) self.plot_widget.stop = False
def slot_brickd_refresh_clicked(self): self.brickd_button_refresh_enabled(False) def cb_open(red_file): def cb_read(red_file, result): red_file.release() if result and result.data is not None: self.brickd_conf = config_parser.parse(result.data.decode('utf-8')) self.update_brickd_widget_data() else: QtGui.QMessageBox.critical(get_main_window(), 'Settings | Brickd', 'Error reading brickd config file.') self.brickd_button_refresh_enabled(True) self.brickd_button_save_enabled(False) red_file.read_async(4096, lambda x: cb_read(red_file, x)) def cb_open_error(): self.brickd_button_refresh_enabled(True) QtGui.QMessageBox.critical(get_main_window(), 'Settings | Brickd', 'Error opening brickd config file.') async_call(self.brickd_conf_rfile.open, (BRICKD_CONF_PATH, REDFile.FLAG_READ_ONLY | REDFile.FLAG_NON_BLOCKING, 0, 0, 0), cb_open, cb_open_error)
def cb_state(self, state, idle): if state & (self.nfc.STATE_ERROR & ~self.nfc.STATE_IDLE): self.tag_type_changed(self.combo_box_tag_type.currentIndex()) if (state & 0xF) == self.nfc.STATE_REQUEST_TAG_ID: s = 'Could not find {0} tag'.format(self.combo_box_tag_type.currentText()) self.label_id.setText(s) elif (state & 0xF) == self.nfc.STATE_AUTHENTICATING_MIFARE_CLASSIC_PAGE: s = 'Error: Could not authenticate page {0}'.format(self.read_page_clicked_page_range) self.textedit_read_page.setPlainText(s) elif (state & 0xF) == self.nfc.STATE_WRITE_PAGE: self.write_page_was_clicked = False s = 'Error: Could not write page {0}'.format(self.write_page_clicked_page_range) self.textedit_read_page.setPlainText(s) elif (state & 0xF) == self.nfc.STATE_REQUEST_PAGE: s = 'Error: Could not read page {0}'.format(self.read_page_clicked_page_range) self.textedit_read_page.setPlainText(s) elif state & self.nfc.STATE_IDLE: if (state & 0xF) == self.nfc.STATE_REQUEST_TAG_ID: async_call(self.nfc.get_tag_id, None, self.get_tag_id_async, self.increase_error_count) elif (state & 0xF) == self.nfc.STATE_AUTHENTICATING_MIFARE_CLASSIC_PAGE: if self.write_page_was_clicked: self.write_page_was_clicked = False self.nfc.write_page(self.write_page_clicked_first_page, self.write_page_clicked_data) else: self.nfc.request_page(self.read_page_clicked_first_page) elif (state & 0xF) == self.nfc.STATE_REQUEST_PAGE: async_call(self.nfc.get_page, None, self.get_page_async, self.increase_error_count) elif (state & 0xF) == self.nfc.STATE_WRITE_PAGE: self.write_page_was_clicked = False s = 'Successfully wrote page {0}'.format(self.write_page_clicked_page_range) self.textedit_read_page.setPlainText(s)
def bl_clicked(self): if self.bl_button.text().replace('&', '') == 'Backlight On': async_call(self.lcd.backlight_on, None, None, self.increase_error_count) self.bl_button.setText('Backlight Off') else: async_call(self.lcd.backlight_off, None, None, self.increase_error_count) self.bl_button.setText('Backlight On')
def start(self): async_call(self.tir.get_emissivity, None, self.get_emissivity_async, self.increase_error_count) self.cbe_ambient_temperature.set_period(250) self.cbe_object_temperature.set_period(250) self.plot_widget.stop = False
def get_wifi_encryption_async(self, enc): encryption, key, key_index, eap_options, ca_certificate_length, client_certificate_length, private_key_length = enc if self.connection in (2, 3, 4, 5): encryption -= 2 eap_outer = eap_options & 0b00000011 eap_inner = (eap_options & 0b00000100) >> 2 key = key.replace('\0', '') self.wifi_eap_outer_auth.setCurrentIndex(eap_outer) self.wifi_eap_inner_auth.setCurrentIndex(eap_inner) self.wifi_encryption.setCurrentIndex(encryption) if key == '-' and self.parent.firmware_version >= (2, 0, 2): async_call(self.master.get_long_wifi_key, None, self.get_long_wifi_key_async, self.parent.increase_error_count) else: self.wifi_key.setText(key) self.wifi_key_index.setValue(key_index) self.wifi_connection.currentIndexChanged.connect(self.connection_changed) self.wifi_encryption.currentIndexChanged.connect(self.encryption_changed) self.wifi_save.clicked.connect(self.save_clicked) self.wifi_show_status.clicked.connect(self.show_status_clicked) self.wifi_ca_certificate_browse.clicked.connect(self.ca_certificate_browse_clicked) self.wifi_client_certificate_browse.clicked.connect(self.client_certificate_browse_clicked) self.wifi_private_key_browse.clicked.connect(self.private_key_browse_clicked) self.connection_changed(0) self.encryption_changed(0) self.wifi_encryption.setCurrentIndex(encryption) # ensure that the correct encryption is displayed
def start(self): async_call(self.p.get_sensor_type, None, self.get_sensor_type_async, self.increase_error_count) async_call(self.p.get_moving_average, None, self.get_moving_average_async, self.increase_error_count) self.cbe_pressure.set_period(100) self.plot_widget.stop = False
def start(self): if self.has_clock_frequency: async_call(self.led_strip.get_clock_frequency, None, self.cb_frequency, self.increase_error_count) async_call(self.led_strip.get_supply_voltage, None, self.cb_voltage, self.increase_error_count) self.voltage_timer.start() self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, self.qtcb_frame_rendered.emit)
def start(self): async_call(self.hf.get_counter_config, None, self.get_counter_config_async, self.increase_error_count) self.cbe_magnetic_flux_density.set_period(25) self.cbe_counter.set_period(100) self.plot_widget.stop = False
def read_async(session, name, content_callback, error_callback, max_read_length=1024*1024): def cb_open(red_file): def cb_read(result): red_file.release() if result.error != None: if error_callback != None: error_callback(TextFile.ERROR_KIND_READ, result.error) return try: content = result.data.decode('utf-8') except UnicodeDecodeError as e: if error_callback != None: error_callback(TextFile.ERROR_KIND_UTF8, e) return if content_callback != None: content_callback(content) red_file.read_async(max_read_length, cb_read) def cb_open_error(error): if error_callback != None: error_callback(TextFile.ERROR_KIND_OPEN, error) async_call(REDFile(session).open, (name, REDFile.FLAG_READ_ONLY | REDFile.FLAG_NON_BLOCKING, 0, 0, 0), cb_open, cb_open_error, report_exception=True)
def update(self): for pin in range(4): if self.monoflop_active[pin]: def get_lambda(pin): return lambda x: self.update_async(pin, x) async_call(self.io.get_monoflop, pin, get_lambda(pin), self.increase_error_count)
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()
def start(self): async_call(self.acc.get_configuration, None, self.get_configuration_async, self.increase_error_count) async_call(self.acc.get_moving_average, None, self.get_moving_average_async, self.increase_error_count) self.cbe_current.set_period(100) self.plot_widget.stop = False
def is_present_async(present, extension_type, name): self.extension_type_preset[extension_type] = present if present: if self.device_info.extensions['ext0'] == None: ext = 'ext0' elif self.device_info.extensions['ext1'] == None: ext = 'ext1' else: return # This should never be the case self.device_info.extensions[ext] = infos.ExtensionInfo() self.device_info.extensions[ext].name = name self.device_info.extensions[ext].extension_type = extension_type self.device_info.extensions[ext].position = ext self.device_info.extensions[ext].master_info = self.device_info if extension_type == self.master.EXTENSION_TYPE_WIFI2: self.device_info.extensions[ext].url_part = 'wifi_v2' # When WIFI2 extension firmware version is being requested the # extension might still not be done with booting and thus the # message won't be received by the extension. So we delay sending # the request which gives enough time to the extension to finish # booting. Note that this delay is only induced when there is a # WIFI2 extension present. self.wifi2_ext = ext self.label_no_extension.setText('Waiting for WIFI Extension 2.0 firmware version...') async_call(self.master.get_wifi2_firmware_version, None, self.get_wifi2_firmware_version_async, self.increase_error_count, delay=2.0) infos.update_info(self.uid)
def start(self): self.sound_pressure_level.register_callback(self.sound_pressure_level.CALLBACK_SPECTRUM, self.qtcb_spectrum.emit) async_call(self.sound_pressure_level.get_configuration, None, self.get_configuration_async, self.increase_error_count) async_call(self.sound_pressure_level.set_spectrum_callback_configuration, 1, None, self.increase_error_count) self.cbe_get_decibel.set_period(50)
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()
def btn_cal_calibrate_clicked(self): self.parent.barometer.set_calibration(int(self.air_pressure * 1000), int(self.sbox_cal_actual_air_pressure.value() * 1000)) async_call(self.parent.barometer.get_calibration, None, self.get_calibration_async, self.parent.increase_error_count)
def update(self): try: pin = int(self.monoflop_pin.currentText().replace('Pin ', '')) except ValueError: return async_call(self.iqr.get_monoflop, pin, lambda monoflop: self.update_async(pin, *monoflop), self.increase_error_count)
def refresh_config(self, index, done_callback): if index >= len(self.configs): self.action_in_progress = False self.update_ui_state() if done_callback != None: done_callback() return config = self.configs[index] if config == None: self.refresh_config(index + 1, done_callback) return self.action_in_progress = True self.update_ui_state() self.label_progress.setText('Downloading ' + config.absolute_name) def cb_open(red_file): def cb_read(result): red_file.release() self.action_in_progress = False self.update_ui_state() if result.error != None: if result.error.error_code != REDError.E_OPERATION_ABORTED and \ result.error.error_code != REDError.E_DOES_NOT_EXIST: self.log_error(u'Error while reading {0}: {1}'.format(config.display_name, error)) else: config.set_content('') else: try: content = result.data.decode('utf-8') except UnicodeDecodeError: # FIXME: maybe add a encoding guesser here or try some common encodings if UTF-8 fails self.log_error(u'Error: Config file {0} is not UTF-8 encoded'.format(config.display_name)) else: config.set_content(content) self.refresh_config(index + 1, done_callback) red_file.read_async(red_file.length, cb_read) def cb_open_error(error): if isinstance(error, REDError) and \ error.error_code != REDError.E_OPERATION_ABORTED and \ error.error_code != REDError.E_DOES_NOT_EXIST: self.log_error(u'Error while opening {0}: {1}'.format(config.display_name, error)) else: config.set_content('') self.refresh_config(index + 1, done_callback) async_call(REDFile(self.session).open, (config.absolute_name, REDFile.FLAG_READ_ONLY | REDFile.FLAG_NON_BLOCKING, 0, 0, 0), cb_open, cb_open_error, report_exception=True)
def radio_clicked(self): if self.radio_voltage.isChecked(): async_call(self.ao.get_voltage, None, self.new_voltage, self.increase_error_count) self.mode_voltage() else: async_call(self.ao.get_current, None, self.new_current, self.increase_error_count) self.mode_current()
def btn_cal_remove_clicked(self): self.parent.barometer.set_calibration(0, 0) async_call(self.parent.barometer.get_calibration, None, self.get_calibration_async, self.parent.increase_error_count)
def update_start(self): async_call(self.stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count) async_call(self.stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count) async_call(self.stepper.get_decay, None, self.get_decay_async, self.increase_error_count) async_call(self.stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count) async_call(self.stepper.is_sync_rect, None, self.is_sync_rect_async, self.increase_error_count)
def motor_current_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(0) qid.setIntMaximum(2500) qid.setIntStep(100) async_call(self.stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.motor_current_selected) qid.setLabelText("Choose motor current in mA.") # "<font color=red>Setting this too high can destroy your Motor.</font>") qid.open()
def show(self): QDialog.show(self) self.cbe_p.set_period(100) self.cbe_a.set_period(100) self.cbe_t.set_period(100) self.sbox_cal_actual_air_pressure.setValue(1013.250) async_call(self.parent.barometer.get_calibration, None, self.get_calibration_async, self.parent.increase_error_count)
def start(self): async_call(self.vc.get_configuration, None, self.get_configuration_async, self.increase_error_count) async_call(self.vc.get_calibration, None, self.get_calibration_async, self.increase_error_count) self.cbe_current.set_period(100) self.cbe_voltage.set_period(100) self.cbe_power.set_period(100) self.plot_widget_current.stop = False self.plot_widget_voltage.stop = False self.plot_widget_power.stop = False
def start(self): async_call(self.idr.get_value, None, self.get_value_async, self.increase_error_count) for channel in range(2): async_call(self.idr.get_channel_led_config, channel, self.get_channel_led_config_async, self.increase_error_count, pass_arguments_to_result_callback=True) self.monoflop.start()
def update_start(self): async_call(self.dc.get_drive_mode, None, self.drive_mode_update, self.increase_error_count) async_call(self.dc.get_velocity, None, self.get_velocity_async, self.increase_error_count) async_call(self.dc.get_acceleration, None, self.get_acceleration_async, self.increase_error_count) async_call(self.dc.get_pwm_frequency, None, self.get_pwm_frequency_async, self.increase_error_count) async_call(self.dc.is_enabled, None, self.is_enabled_async, self.increase_error_count)
def minimum_motor_voltage_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(0) qid.setIntMaximum(40000) qid.setIntStep(100) async_call(self.stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.minimum_motor_voltage_selected) qid.setLabelText("Choose minimum motor voltage in mV.") qid.open()
def show(self): QDialog.show(self) self.cbe_voltage.set_period(100) self.cbe_current.set_period(100) self.cbe_power.set_period(100) async_call(self.parent.vc.get_calibration, None, self.get_calibration_async, self.parent.increase_error_count)
def start(self): async_call(self.color.get_configuration, None, self.get_configuration_async, self.increase_error_count) async_call(self.color.get_light, None, self.get_light_async, self.increase_error_count) self.cbe_color.set_period(50) self.cbe_illuminance.set_period(100) self.cbe_color_temperature.set_period(100) self.plot_widget.stop = False self.plot_widget_illuminance.stop = False self.plot_widget_color_temperature.stop = False
def start(self): async_call(self.ao.get_voltage, None, self.new_voltage, self.increase_error_count) async_call(self.ao.get_current, None, self.new_current, self.increase_error_count) async_call(self.ao.get_enabled, None, self.get_enabled_async, self.increase_error_count) async_call(self.ao.get_configuration, None, self.get_configuration_async, self.increase_error_count) async_call(self.ao.get_out_led_config, None, self.get_out_led_config_async, self.increase_error_count)
def refresh_program_list(self): def refresh_async(): return get_lite_programs(self.session) def cb_success(programs): sorted_programs = {} for program in programs: first_upload = program.cast_custom_option_value( 'first_upload', int, 0) if first_upload in sorted_programs: sorted_programs[first_upload][program.identifier] = program else: sorted_programs[first_upload] = { program.identifier: program } for first_upload in sorted(sorted_programs.keys()): for identifier in sorted(sorted_programs[first_upload].keys()): program = sorted_programs[first_upload][identifier] language = program.cast_custom_option_value( 'language', unicode, '<unknown>') try: language = Constants.get_language_display_name( language) except: pass item = QTreeWidgetItem([ program.cast_custom_option_value( 'name', unicode, '<unknown>'), identifier, language ]) self.tree_programs.addTopLevelItem(item) item.setSelected(True) self.refresh_in_progress = False self.update_ui_state() self.tree_programs.setFocus() def cb_error(error): pass # FIXME: report error self.refresh_in_progress = True self.update_ui_state() self.tree_programs.invisibleRootItem().takeChildren() async_call(refresh_async, None, cb_success, cb_error, report_exception=True)
def render_leds(self, r, g, b, w): _, num_channels = self.chip_type_combobox.itemData( self.chip_type_combobox.currentIndex()) if num_channels == 4: values = [value for rgbw in zip(r, g, b, w) for value in rgbw] else: values = [value for rgb in zip(r, g, b) for value in rgb] async_call(self.led_strip.set_led_values, (0, values), None, self.increase_error_count)
def motor_current_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(360) qid.setIntMaximum(1640) qid.setIntStep(100) async_call(self.silent_stepper_v2.get_motor_current, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.motor_current_selected) qid.setLabelText("Choose motor current in mA.") qid.open()
def start(self): async_call(self.sound_pressure_level.get_configuration, None, self.get_configuration_async, self.increase_error_count) self.cbe_get_decibel.set_period(50) async_call( self.sound_pressure_level.set_spectrum_callback_configuration, (1, ), None, self.increase_error_count) self.sound_pressure_level.register_callback( self.sound_pressure_level.CALLBACK_SPECTRUM, self.qtcb_spectrum.emit)
def start(self): self.config_direction = [None] * 16 self.config_value = [None] * 16 for channel in range(16): async_call(self.io.get_configuration, channel, self.get_configuration_async, self.increase_error_count, pass_arguments_to_result_callback=True, expand_result_tuple_for_callback=True) self.cbe_value.set_period(50) self.monoflop.start()
def start(self): async_call(self.dist.get_moving_average_configuration, None, self.get_moving_average_configuration_async, self.increase_error_count) async_call(self.dist.get_sensor_type, None, self.get_sensor_type_async, self.increase_error_count) self.cbe_distance.set_period(10) self.cbe_analog_value.set_period(100) self.plot_widget.stop = False
def update(self): for port in ['a', 'b']: for pin in range(8): if self.monoflop_active[port][pin]: def get_lambda(port, pin): return lambda x: self.update_async(port, pin, x) async_call(self.io.get_port_monoflop, (port, pin), get_lambda(port, pin), self.increase_error_count)
def connect_clicked(self): if self.ipcon.get_connection_state( ) == IPConnection.CONNECTION_STATE_DISCONNECTED: self.last_host = self.combo_host.currentText() self.setDisabled(True) self.button_connect.setText("Connecting...") async_call(self.ipcon.connect, (self.last_host, self.spinbox_port.value()), None, self.connect_error) else: self.do_disconnect()
def cb_java_main_classes(result): script_instance = script_instance_ref[0] if script_instance != None: aborted = script_instance.abort else: aborted = False script_instance_ref[0] = None def done(): progress.cancel() self.combo_main_class.setEnabled(True) self.completeChanged.emit() if aborted: done() return okay, message = check_script_result(result, decode_stderr=True) if not okay: self.label_main_class_error.setText('<b>Error:</b> ' + Qt.escape(message)) self.label_main_class_error.setVisible(True) done() return def expand_async(data): try: main_classes = json.loads(zlib.decompress(buffer(data)).decode('utf-8')) if not isinstance(main_classes, dict): main_classes = {} except: main_classes = {} return main_classes def cb_expand_success(main_classes): self.combo_main_class.clear() for cls in sorted(main_classes.keys()): self.combo_main_class.addItem(cls, main_classes[cls]) self.combo_main_class_checker.set_current_text(program.cast_custom_option_value('java.main_class', unicode, '')) done() def cb_expand_error(): self.label_main_class_error.setText('<b>Error:</b> Internal async error') self.label_main_class_error.setVisible(True) done() async_call(expand_async, result.stdout, cb_expand_success, cb_expand_error)
def start(self): async_call(self.rtc.get_offset, None, self.get_offset_async, self.increase_error_count) if self.has_alarm: async_call(self.rtc.get_alarm, None, self.get_alarm_async, self.increase_error_count, expand_result_tuple_for_callback=True) self.cbe_date_time.set_period(50)
def cb_alarm(self, year, month, day, hour, minute, second, centisecond, weekday, interval): async_call(self.rtc.get_alarm, None, self.get_alarm_async, self.increase_error_count, expand_result_tuple_for_callback=True) self.list_alarms.addItem( '{0}-{1:02}-{2:02} T {3:02}:{4:02}:{5:02}.{6:02} {7}'.format( year, month, day, hour, minute, second, centisecond, WEEKDAY_BY_NUMBER[weekday]))
def start(self): # Use response expected for write_line function, to make sure that the # data queue can't fill up while you move the slider around. self.write_line_response_expected = self.oled.get_response_expected( self.oled.FUNCTION_WRITE_LINE) self.oled.set_response_expected(self.oled.FUNCTION_WRITE_LINE, True) async_call(self.oled.get_display_configuration, None, self.get_display_configuration_async, self.increase_error_count) async_call(self.oled.read_pixels, (0, 0, 127, 63), self.read_pixels_async, self.increase_error_count)
def output_voltage_button_clicked(self): qid = QInputDialog(self) qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(2000) qid.setIntMaximum(9000) qid.setIntStep(100) async_call(self.servo.get_output_voltage, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.output_voltage_selected) qid.setLabelText("Choose Output Voltage in mV.") # "<font color=red>Setting this too high can destroy your servo.</font>") qid.open()
def text_clicked(self): line = int(self.line_combo.currentText()) position = int(self.pos_combo.currentText()) text = self.text_edit.text() if self.has_custom_character: for i in range(8): text = text.replace('\\' + str(i), chr(i + 8)) async_call(self.lcd.write_line, (line, position, unicode_to_ks0066u(text)), None, self.increase_error_count)
def reconfigure_everything(self): for i in range(4): self.groups[i].clear() self.groups[i].addItem('Off') for j in range(4): if self.available_ports & (1 << j): item = 'Port ' + chr(ord('A') + j) self.groups[i].addItem(item) async_call(self.ido4.get_group, None, self.reconfigure_everything_async1, self.increase_error_count)
def start(self): async_call(self.re.get_count, False, self.cb_count, self.increase_error_count) if self.firmware_version >= (2, 0, 2): # firmware 2.0.2 fixed the is_pressed return value, it was inverted before async_call(self.re.is_pressed, None, self.encoder_knob.set_pressed, self.increase_error_count) self.cbe_count.set_period(25) self.plot_widget.stop = False
def cb_walk(result): okay, message = check_script_result(result, decode_stderr=True) if not okay: self.label_error.setText('<b>Error:</b> ' + html.escape(message)) self.label_error.setVisible(True) self.refresh_files_done() return self.label_error.setVisible(False) def expand_async(data): try: walk = json.loads( zlib.decompress(memoryview(data)).decode('utf-8')) except: walk = None if walk == None or not isinstance(walk, dict): available_files = [] available_directories = [] walk = None else: available_files, available_directories = expand_walk_to_lists( walk) return walk, available_files, available_directories def cb_expand_success(result): walk, available_files, available_directories = result self.available_files = available_files self.available_directories = available_directories if walk != None: expand_walk_to_model(walk, self.tree_files_model, self.folder_icon, self.file_icon) else: self.label_error.setText( '<b>Error:</b> Received invalid data') self.label_error.setVisible(True) self.tree_files.header().setSortIndicator(0, Qt.AscendingOrder) self.refresh_files_done() def cb_expand_error(): self.label_error.setText('<b>Error:</b> Internal async error') self.label_error.setVisible(True) self.refresh_files_done() async_call(expand_async, result.stdout, cb_expand_success, cb_expand_error)
def monoflop_pin_changed(self): try: pin = int(self.monoflop_pin.currentText().replace('Pin ', '')) except ValueError: return if self.monoflop_pending[pin]: async_call(self.iqr.get_monoflop, pin, self.monoflop_pin_changed_async, self.increase_error_count) self.monoflop_time.setEnabled(False) else: self.monoflop_time.setValue(self.monoflop_time_before[pin]) self.monoflop_time.setEnabled(True)
def minimum_voltage_button_clicked(self): qid = QInputDialog(self) qid.setWindowTitle('Servo Brick') qid.setInputMode(QInputDialog.IntInput) qid.setIntMinimum(5000) qid.setIntMaximum(0xFFFF) qid.setIntStep(100) async_call(self.servo.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count) qid.intValueSelected.connect(self.minimum_voltage_selected) qid.setLabelText("Choose Minimum Servo Voltage in mV:") qid.open()
def update_sensor(self): if self.combo_identifier_sensor.isEnabled(): try: identifier = int(self.combo_identifier_sensor.currentText()) except: return async_call(self.outdoor_weather.get_sensor_data, identifier, self.get_sensor_data_async, self.increase_error_count) else: self.label_temperature_sensor.setText('---') self.label_humidity_sensor.setText('---') self.label_last_change_sensor.setText('---')