def main(): ser = SerialPort(sys.argv[1], Resolver(), timeout=0) ser.start() def thread_loop(): threading.Timer(2.0, thread_loop).start() ask_for_usage() time.sleep(0.5) ask_for_volume() def ask_for_volume(): # threading.Timer(0.7, ask_for_volume).start() ser.write(b'zad2') ser.write(str(show_mixer()).encode()) def ask_for_usage(): # threading.Timer(5.0, ask_for_usage).start() data = show_host_data() ser.write(b'C') ser.write(str(data['cpu']).encode()) ser.write(b'T') ser.write(str(data['temperature']).encode()) ser.write(b'M') ser.write(str(data['memory']).encode()) # ask_for_volume() # ask_for_usage() thread_loop()
def __init__(self, **kwargs): super(SDKApplication, self).__init__() with open('logconfig.yaml', 'r') as f: logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader)) self.applogger = logging.getLogger('app') self.port_rx_stream_queue = Queue.Queue() self.parsed_message_queue = Queue.Queue() self.active_info = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('app_id', None), ('app_ver', 0x03010a00), ('bundle_id', '12345678901234567890123456789012'), ]] ) if not self.active_info.get('app_id'): raise TypeError( '{}.__init__() must pass argument "app_id"!'.format(__class__)) encrypt_param = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('crc16_init', 0x3AA3), ('crc16_poly', 0x18005), ('crc32_init', 0x3AA3), ('crc32_poly', 0x104C11DB7), ('aes256_key', None), ]] ) if not encrypt_param.get('aes256_key'): raise TypeError( '{}.__init__() must pass argument "aes256_key"!'.format(__class__)) EncryptCodec.initEncryptCodec(encrypt_param) port_param = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('port', '/dev/ttyUSB0'), ('baudrate', 230400), ('read_bytes', 12), ('buffer_queue', self.port_rx_stream_queue), ]] ) self.port = SerialPort(**port_param) self.parser = ProtocolParser( self.port_rx_stream_queue, self.parsed_message_queue) self.sm = SessionManager(self.port.write) self.register_data_handle() self.port.open() self.parser.start()
def __init__(self, master): tk.Frame.__init__(self) master.geometry(set_size(master, 520, 450)) master.resizable(False, True) master.title("自动布线机 v1.0") self.machine = Machine() self.gcoder = Gcoder() self.serialPort = SerialPort() # Initialized when the connector opened
def __init__(self, **kwargs): super(SDKApplication, self).__init__() with open('logconfig.yaml', 'r') as f: logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader)) self.applogger = logging.getLogger('app') self.port_rx_stream_queue = Queue.Queue() self.parsed_message_queue = Queue.Queue() self.active_info = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('app_id', None), ('api_level', 0x02), ('app_ver', 0x01), ('bundle_id', '12345678901234567890123456789012'), ]] ) if not self.active_info.get('app_id'): raise TypeError( '{}.__init__() must pass argument "app_id"!'.format(__class__)) encrypt_param = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('crc16_init', 0x3AA3), ('crc16_poly', 0x18005), ('crc32_init', 0x3AA3), ('crc32_poly', 0x104C11DB7), ('aes256_key', None), ]] ) if not encrypt_param.get('aes256_key'): raise TypeError( '{}.__init__() must pass argument "aes256_key"!'.format(__class__)) EncryptCodec.initEncryptCodec(encrypt_param) port_param = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('port', '/dev/ttyUSB0'), ('baudrate', 230400), ('read_bytes', 12), ('buffer_queue', self.port_rx_stream_queue), ]] ) self.port = SerialPort(**port_param) self.parser = ProtocolParser( self.port_rx_stream_queue, self.parsed_message_queue) self.sm = SessionManager(self.port.write) self.register_data_handle() self.port.open() self.parser.start()
def on_start(self, event): from TwrLtcConfig import ConfigFrame from CSVLog import CSVLog configs = self.TwrLtcConfig() frame = ConfigFrame(self, configs) frame.ShowModal() if configs.get_valid_configs() == True: # User inputs have passed the basic test Let us proceed with # those values # No more error checkings on serial ports are required here # Let us not have any error checking here try: self.twr_data_acq = SerialPort(configs.get_twr_ser_port()) except IOError: wx.MessageBox("Could not open serial port %s for communicating with the tower " %configs.get_twr_ser_port()) return try: self.dmm_data_acq = SerialPort(configs.get_dmm_ser_port(), '9600', stopbits='2') except IOError: wx.MessageBox("Could not open serial port %s for communicating with the HP34001A " %configs.get_dmm_ser_port()) self.twr_data.acq.close_port() return self.logger = CSVLog(configs.get_log_file()) pro = ProcessCmd(configs.get_cmd_file()) # The commands will be processed and self.cmds_file = 'cmds_pro.twrcmd' pro.process(self.cmds_file) # stored in 'cmds_pro.txt' pass # differnt file name to process() to change this behaviour del pro self.logger.write_title(['Sample number', 'Command sent to DAC', \ 'Voltages read by DMM', 'Volatges read by TWRLTC']) self.save_btn.Enable() self.start_btn.Disable() acq_thread = DatAcqThread(self) acq_thread.start()
def __init__(self): tk.Tk.__init__(self) self.serial = SerialPort(self) self.geometry('1000x1200+0+0') self.title("AT-Tool") self.config = Config(self) self.pane = tk.PanedWindow(orient=tk.HORIZONTAL, sashwidth=5) self.pane.pack(fill=tk.BOTH, expand=1, padx=3, pady=3) self.serial_terminal = SerialTerminal(self.pane) self.command_list = CommandList(self.pane) self.pane.add(self.serial_terminal) self.pane.add(self.command_list)
def __init__(self, **kwargs): Thread.__init__(self) # Serial thread self.serialthread = SerialPort() # Controller Read/Write variables over serial self.controller = DistantIO() # Serial protocol self.protocol = Protocol() # Variable manager self.variable_manager = VariableManager(self) self.variable_manager.start() self.running = True; # Data logger self.logger = DataLogger()
def change_frequency_init(self): port_name = self.port_selection.currentText() frequency = self.frequency_selection.currentText() self.message.setText("Setting Up Port {}".format(port_name)) port = SerialPort(port_name) port.write_port("RadiosondeDAS") self.message.setText("Waiting for Response") while port.read_port() != "RadiosondeDAS": pass port.write_port(frequency) while port.read_port() != frequency: pass self.message.setText("Frequency Set: {}".format(frequency))
def setupSerial(self, comport="COM1", baud=115200, data=8, par="N", stop=1, xon=None, rts=None, **kwargs): if(comport in listSerialPorts()) : self.closeSerial() #try: #comport, baud, data, par, stop, xon, rts = [] self.handle = SerialPort("tkTerm", comport, baud, data, par, stop, xon, rts) # except Exception as e: # print("SERIAL PORT ERROR!", e) # try: # self.handle = serial.Serial(port=comport, baudrate=baud, # bytesize=data, parity=par, stopbits=stop, timeout=3.0, # rtscts=rts, xonxoff=xon, writeTimeout=3.0) # except Exception as se: # print("COM PORT ERROR!", se) self.master.title("tkTerm {}".format(comport)) print(self.handle) else: print("NOT AN ACTIVE SERIAL PORT")
class GeigerCOMService(IService, SerialPortHandler): def __init__(self): self.serialPort = None pass def start(self, config): self.serialPort = SerialPort(self, config.get('port_address'), Constants.SERIAL_MESSAGE_DELIMITER) self.serialPort.openPort() pass def stop(self): if(self.serialPort != None): self.serialPort.abortPort() pass def commit(self): pass def port_opened(self, SerialPort): """When the port is opened.""" print("Port linked!") pass def port_read(self, SerialPort, Data): """When str data has been recvd.""" #Data starting by "N =" characters if(Data.startswith(Constants.SERIAL_MESSAGE_HEAD)): hitsCount = int(Data[Constants.SERIAL_MESSAGE_HEAD:]) hits = HitEntity().set(int(time.time()), hitsCount) Globals.Application.transact(hits) pass def port_closed(self, SerialPort): """When the port is closed.""" print("Port closed") self.serialPort.openPort() pass def port_error(self, SerialPort, Error): """When error has been encountered.""" pass def port_abort(self, SerialPort): """When the port has been aborted.""" print("Port aborted") pass
def __init__(self): super().__init__() self.setupUi(self) # 状态栏配置 self.status_label = QtWidgets.QLabel() self.status_label.setText("Hello word!") self.statusbar.addWidget(self.status_label) # 串口配置 self.comboBox = MyCombox(self.centralwidget) x = 670 + 97 y = 20 + 10 self.comboBox.setGeometry(QtCore.QRect(x, y, 115, 33)) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.comboBox.sizePolicy().hasHeightForWidth()) self.comboBox.setSizePolicy(sizePolicy) self.comboBox.setMinimumSize(QtCore.QSize(0, 30)) self.comboBox.setObjectName("comboBox") self.comboBox.enter_event_signal.connect(self.onCombox_EnterSlot) self.serial_port = SerialPort() self.serial_port.searchPort() self.serial_list = list(self.serial_port.port.keys()) self.serial_list.sort() for item in self.serial_list: self.comboBox.addItem(item) self.comboBox_baudrate.addItem('1200') self.comboBox_baudrate.addItem('2400') self.comboBox_baudrate.addItem('4800') self.comboBox_baudrate.addItem('9600') self.comboBox_baudrate.addItem('19200') self.comboBox_baudrate.addItem('38400') self.comboBox_baudrate.addItem('57600') self.comboBox_baudrate.addItem('115200') self.comboBox_baudrate.setCurrentIndex(7) self.serial_port.baund_rate = QSerialPort.Baud115200 self.comboBox_baudrate.currentIndexChanged.connect( self.onCombox_baudrate_IncdeChangeSlot) self.comboBox_stopBit.addItem('1') self.comboBox_stopBit.addItem('1.5') self.comboBox_stopBit.addItem('2') self.comboBox_stopBit.setCurrentIndex(0) self.comboBox_stopBit.currentIndexChanged.connect( self.onCombox_stopBit_IncdeChangeSlot) self.comboBox_dataBit.addItem('5') self.comboBox_dataBit.addItem('6') self.comboBox_dataBit.addItem('7') self.comboBox_dataBit.addItem('8') self.comboBox_dataBit.setCurrentIndex(3) self.comboBox_dataBit.currentIndexChanged.connect( self.onCombox_dataBit_IncdeChangeSlot) self.comboBox_parity.addItem('无') self.comboBox_parity.addItem('奇校验') self.comboBox_parity.addItem('偶校验') self.comboBox_parity.setCurrentIndex(0) self.comboBox_parity.currentIndexChanged.connect( self.onCombox_parity_IncdeChangeSlot) # 摄像头显示进程配置 self.thread_camera = ThreadCamera() # 创建定时器,用于定时读取摄像头进程中的图像 self.timer = QTimer(self) self.timer.setInterval(16) self.timer.timeout.connect(self.slotTimerTimeout) # 开关按钮配置 self.pushButton_flag = True self.pushButton_switch.clicked.connect(self.onPushButton_ClickedSlot)
class Model(Thread): def __init__(self, **kwargs): Thread.__init__(self) # Serial thread self.serialthread = SerialPort() # Controller Read/Write variables over serial self.controller = DistantIO() # Serial protocol self.protocol = Protocol() # Variable manager self.variable_manager = VariableManager(self) self.variable_manager.start() self.running = True; # Data logger self.logger = DataLogger() def get_ports(self): return self.serialthread.get_ports() def connect_com(self,COM_port): # Start serial thread (can run without COM port connected) if not self.serialthread.isAlive(): self.serialthread.start() self.serialthread.connect(COM_port,115200) #Model update running in a thread def run(self): while self.running: if self.serialthread.char_available(): c = self.serialthread.get_char() if not c is None: self.protocol.process_rx(c) if self.protocol.available(): p = self.protocol.get() # Dump payload if controller is in heavy load ? pub.sendMessage('new_rx_payload',rxpayload=p)#USED ? if not p is None: self.controller.decode(p) def disconnect_com(self): self.serialthread.disconnect() def stop(self): self.running = False self.serialthread.stop() self.variable_manager.stop() if self.serialthread.isAlive(): self.serialthread.join(0.1) if self.serialthread.isAlive(): self.serialthread.join(1) if self.serialthread.isAlive(): print("--- Serial thread not properly joined.") if self.variable_manager.isAlive(): self.variable_manager.join(0.1) if self.variable_manager.isAlive(): self.variable_manager.join(1) self.stop_controller() def start_controller(self): #Get command for querying variable table MCU side cmd = self.controller.encode(cmd='table') #Feed command to serial protocol payload processor frame = self.protocol.process_tx(cmd) #Send command self.serialthread.write(frame) def stop_controller(self): #TODO : Tell MCU to stop sending all data pass def start_log(self): self.logger.start() def stop_log(self): self.logger.record_all() def read_var(self, varid): # Get command cmd = self.controller.encode(cmd='read',var_id=varid) # Feed command to serial protocol payload processor frame = self.protocol.process_tx(cmd) # Send command self.serialthread.write(frame) def write_var(self,varid,value): # Get command cmd = self.controller.encode(cmd='write',var_id=varid,value=value) if cmd == None: return # Feed command to serial protocol payload processor frame = self.protocol.process_tx(cmd) # Send command self.serialthread.write(frame) def stop_read_var(self,varid): # Get command cmd = self.controller.encode(cmd='stop',var_id=varid) if cmd == None: return # Feed command to serial protocol payload processor frame = self.protocol.process_tx(cmd) # Send command self.serialthread.write(frame) def stop_read_all_vars(): # Get command cmd = self.controller.encode(cmd='stopall') if cmd == None: return # Feed command to serial protocol payload processor frame = self.protocol.process_tx(cmd) # Send command self.serialthread.write(frame) def get_var_info(self,varid): return self.controller.get_var_info(varid)
def __init__(self, xmlserial, verbose=False): """ Class constructor @param portname: Name/path of the serial port @param speed: Serial baudrate in bps @param verbose: Print out SWAP traffic (True or False) """ # Response to the last AT command sent to the serial modem self._atresponse = "" # AT response received from modem self.__atresponse_received = None # "Packet received" callback function. To be defined by the parent object self._ccpacket_received = None ## Hardware version of the serial modem self.hwversion = None ## Firmware version of the serial modem self.fwversion = None try: # Open serial port if xmlserial.port.startswith("mqtt"): self._serport = MQTTPort(xmlserial, verbose) self._serport.setRxCallback(self._serialPacketReceived) self.devaddress = 1 self.syncword = 0xc0de self.hwversion = 1 self.fwversion = 1 self.freq_channel = 70 self._serport.start() else: self._serport = SerialPort(xmlserial.port, xmlserial.speed, verbose) self._serport.setRxCallback(self._serialPacketReceived) self._serport.start() # Retrieve modem settings # Switch to command mode if not self.goToCommandMode(): raise SwapException("Modem is unable to enter command mode") # Hardware version response = self.runAtCommand("ATHV?\n") if response is None: raise SwapException("Unable to retrieve Hardware Version from serial modem") self.hwversion = long(response, 16) # Firmware version response = self.runAtCommand("ATFV?\n") if response is None: raise SwapException("Unable to retrieve Firmware Version from serial modem") self.fwversion = long(response, 16) # Frequency channel response = self.runAtCommand("ATCH?\n") if response is None: raise SwapException("Unable to retrieve Frequency Channel from serial modem") ## Frequency channel of the serial gateway self.freq_channel = int(response, 16) # Synchronization word response = self.runAtCommand("ATSW?\n") if response is None: raise SwapException("Unable to retrieve Synchronization Word from serial modem") ## Synchronization word of the serial gateway self.syncword = int(response, 16) # Device address response = self.runAtCommand("ATDA?\n") if response is None: raise SwapException("Unable to retrieve Device Address from serial modem") ## Device address of the serial gateway self.devaddress = int(response, 16) except: raise
class MainWindow(QMainWindow, Ui_MainWindow): def __init__(self): super().__init__() self.setupUi(self) # 状态栏配置 self.status_label = QtWidgets.QLabel() self.status_label.setText("Hello word!") self.statusbar.addWidget(self.status_label) # 串口配置 self.comboBox = MyCombox(self.centralwidget) x = 670 + 97 y = 20 + 10 self.comboBox.setGeometry(QtCore.QRect(x, y, 115, 33)) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.comboBox.sizePolicy().hasHeightForWidth()) self.comboBox.setSizePolicy(sizePolicy) self.comboBox.setMinimumSize(QtCore.QSize(0, 30)) self.comboBox.setObjectName("comboBox") self.comboBox.enter_event_signal.connect(self.onCombox_EnterSlot) self.serial_port = SerialPort() self.serial_port.searchPort() self.serial_list = list(self.serial_port.port.keys()) self.serial_list.sort() for item in self.serial_list: self.comboBox.addItem(item) self.comboBox_baudrate.addItem('1200') self.comboBox_baudrate.addItem('2400') self.comboBox_baudrate.addItem('4800') self.comboBox_baudrate.addItem('9600') self.comboBox_baudrate.addItem('19200') self.comboBox_baudrate.addItem('38400') self.comboBox_baudrate.addItem('57600') self.comboBox_baudrate.addItem('115200') self.comboBox_baudrate.setCurrentIndex(7) self.serial_port.baund_rate = QSerialPort.Baud115200 self.comboBox_baudrate.currentIndexChanged.connect( self.onCombox_baudrate_IncdeChangeSlot) self.comboBox_stopBit.addItem('1') self.comboBox_stopBit.addItem('1.5') self.comboBox_stopBit.addItem('2') self.comboBox_stopBit.setCurrentIndex(0) self.comboBox_stopBit.currentIndexChanged.connect( self.onCombox_stopBit_IncdeChangeSlot) self.comboBox_dataBit.addItem('5') self.comboBox_dataBit.addItem('6') self.comboBox_dataBit.addItem('7') self.comboBox_dataBit.addItem('8') self.comboBox_dataBit.setCurrentIndex(3) self.comboBox_dataBit.currentIndexChanged.connect( self.onCombox_dataBit_IncdeChangeSlot) self.comboBox_parity.addItem('无') self.comboBox_parity.addItem('奇校验') self.comboBox_parity.addItem('偶校验') self.comboBox_parity.setCurrentIndex(0) self.comboBox_parity.currentIndexChanged.connect( self.onCombox_parity_IncdeChangeSlot) # 摄像头显示进程配置 self.thread_camera = ThreadCamera() # 创建定时器,用于定时读取摄像头进程中的图像 self.timer = QTimer(self) self.timer.setInterval(16) self.timer.timeout.connect(self.slotTimerTimeout) # 开关按钮配置 self.pushButton_flag = True self.pushButton_switch.clicked.connect(self.onPushButton_ClickedSlot) # 串口号选择 def onCombox_EnterSlot(self): if self.pushButton_flag: index = self.comboBox.currentIndex() text = self.comboBox.currentText() self.comboBox.clear() self.serial_port.searchPort() self.serial_list = list(self.serial_port.port.keys()) self.serial_list.sort() for item in self.serial_list: self.comboBox.addItem(item) self.comboBox.setCurrentIndex(index) if self.comboBox.currentText() != text: self.comboBox.setCurrentIndex(0) # 串口波特率选择 def onCombox_baudrate_IncdeChangeSlot(self): current_index = self.comboBox_baudrate.currentIndex() if current_index == 0: self.serial_port.baund_rate = QSerialPort.Baud1200 elif current_index == 1: self.serial_port.baund_rate = QSerialPort.Baud2400 elif current_index == 2: self.serial_port.baund_rate = QSerialPort.Baud4800 elif current_index == 3: self.serial_port.baund_rate = QSerialPort.Baud9600 elif current_index == 4: self.serial_port.baund_rate = QSerialPort.Baud19200 elif current_index == 5: self.serial_port.baund_rate = QSerialPort.Baud38400 elif current_index == 6: self.serial_port.baund_rate = QSerialPort.Baud57600 elif current_index == 7: self.serial_port.baund_rate = QSerialPort.Baud115200 # 串口停止位选择 def onCombox_stopBit_IncdeChangeSlot(self): current_index = self.comboBox_stopBit.currentIndex() if current_index == 0: self.serial_port.stop_bits = QSerialPort.OneStop elif current_index == 1: self.serial_port.stop_bits = QSerialPort.OneAndHalfStop elif current_index == 2: self.serial_port.stop_bits = QSerialPort.TwoStop # 串口数据位选择 def onCombox_dataBit_IncdeChangeSlot(self): current_index = self.comboBox_dataBit.currentIndex() if current_index == 0: self.serial_port.data_bits = QSerialPort.Data5 elif current_index == 1: self.serial_port.data_bits = QSerialPort.Data6 elif current_index == 2: self.serial_port.data_bits = QSerialPort.Data7 elif current_index == 3: self.serial_port.data_bits = QSerialPort.Data8 # 串口奇偶校验位选择 def onCombox_parity_IncdeChangeSlot(self): current_index = self.comboBox_parity.currentIndex() if current_index == 0: self.serial_port.parity = QSerialPort.NoParity elif current_index == 1: self.serial_port.parity = QSerialPort.OddParity elif current_index == 2: self.serial_port.parity = QSerialPort.EvenParity # 定时器到达时间间隔的槽函数 def slotTimerTimeout(self): if self.thread_camera.img_frame and (not self.thread_camera.end_flag): self.label_video.setPixmap( QPixmap.fromImage(self.thread_camera.img_frame)) else: self.label_video.clear() # 按钮按下动作 def onPushButton_ClickedSlot(self): if self.pushButton_flag: port_name = self.comboBox.currentText() if port_name != '': self.serial_port.setPort(self.serial_port.port[port_name]) self.serial_port.open(QSerialPort.ReadWrite) self.serial_port.setBaudRate(self.serial_port.baund_rate) self.serial_port.setStopBits(self.serial_port.stop_bits) self.serial_port.setDataBits(self.serial_port.data_bits) self.serial_port.setParity(self.serial_port.parity) self.pushButton_flag = False self.pushButton_switch.setStyleSheet( "border-image: url(:/on/on.png);") self.comboBox.setEnabled(False) self.comboBox_baudrate.setEnabled(False) self.comboBox_stopBit.setEnabled(False) self.comboBox_dataBit.setEnabled(False) self.comboBox_parity.setEnabled(False) self.thread_camera.end_flag = False self.thread_camera.start() self.timer.start() self.lineEdit_ip.setReadOnly(True) self.lineEdit_telephone.setReadOnly(True) else: QMessageBox.warning(None, "Warning!", "Cannot detect serial!") else: self.serial_port.close() self.pushButton_flag = True self.pushButton_switch.setStyleSheet( "border-image: url(:/off/off.png);") self.comboBox.setEnabled(True) self.comboBox_baudrate.setEnabled(True) self.comboBox_stopBit.setEnabled(True) self.comboBox_dataBit.setEnabled(True) self.comboBox_parity.setEnabled(True) self.timer.stop() self.thread_camera.end_flag = True self.label_video.clear() self.lineEdit_ip.setReadOnly(False) self.lineEdit_telephone.setReadOnly(False)
class Parser: __serialPort = None __parsedInput = None __serialReadSize = None # Name: Parameterized constructor # Description: Parser class parameterized constructor which takes in baud rate and timeout # values which are used to create a SerialPort object # Parameters: Takes in two ints which are the baud rate and timeout value needed in the # constructor of the SerialPort object # Return: None def __init__(self, baudRate, timeOut, readinSize): self.__serialReadSize = readinSize # SerialPort object created with baud rate and timeout values passed into the constructor self.__serialPort = SerialPort(baudRate, timeOut, readinSize) # Name: getSerialInput # Description: Parser class method which continually reads in from the serial port through # the SerialPort object and formats and concatenates the portions of the input, # removing artifacts added by PySerial and checking for a decimal point # Parameters: None # Return: Returns a list containing the value from the receiver as a string and char # indicating what type of value it is def getSerialInput(self): dotBool = False # for reading in an entire line at a time from the serial port if self.__serialReadSize == 1: # reads in an entire line from the serial port inputValue = str(self.__serialPort.serialRead()) # leading and trailing characters are parsed off the line and the outputList is built # from the parsed line outputList = [inputValue[2]] outputString = inputValue[3:-4] outputString = outputString.replace('\\', "") outputList.append(outputString) # for reading in data from the serial port one byte at a time if read.__serialReadSize == 0: # grabbing the first portion of the input, which enters in the format: b'1' # where 1 is the value coming in, the final values being: b'\', b'r', b'\', b'n' # which, along with the 'b', and ''' chars, are removed inputValue = str(self.__serialPort.serialRead()) inputValue.split("'") value = "" # while the first '\' char of the carriage return, \r\n, has not been encountered, the # the first char in the string is retained and outputList is built from each one while inputValue[2] != "\\": # skips errant, additional '.' chars if they are present in the input if inputValue[2] == '.': if not dotBool: dotBool = True value += inputValue[2] else: value += inputValue[2] inputValue = str(self.__serialPort.serialRead()) inputValue.split("'") # a list is built from the input, making the first char in the input the first # element in the list which is a control char which marks whether the input is a # voltage, with a 'v', or as a proximity reading, with any char from 'a' to 'n' # and the second element the input value itself if len(value) > 1: outputList = [str(value[0]), str(value[1:])] else: outputList = value inputValue = str(self.__serialPort.serialRead()) # method call to trimValue to trim excess trailing digits from the input which will # then be returned outputList = self.trimValue(outputList) # the serial port buffer is flushed self.__serialPort.flushSerialPort() return outputList # Name: trimValue # Description: Parser class method which takes in a list containing as the second element # a string which is to have trailing digits trimmed off depending whether the # string corresponds to a voltage or a proximity reading # Parameters: Takes in a list containing a control char marking the type of value which is # being recieved from the serial port, which is the second element in the list # Return: Returns the list that was taken in but with the string containing the value # trimmed down to the proper size for use in other classes in the ground unit def trimValue(self, outputList): index = 1 voltLimit = 6 proxLimit = 5 if outputList != None and len(outputList) > 1 and len( outputList[1]) > 0: listSize = len(outputList[1]) # if the first element in the list is not a valid control then return None if outputList[0] < 'a' or outputList[0] > 'z': return None # the input value is iterated through and there are non-numeric chars in the # string, return None while index < listSize: if outputList[1][index] >= 'a' and outputList[1][index] <= 'z': return None index += 1 # if the input value is a voltage, enforce a string size of 5 if outputList[0] == 'v' and listSize > 6: outputList[1] = outputList[1][:-(listSize - voltLimit)] # else if the input value is proximity, enforce a string size of 4 elif len(outputList) > 0 and outputList[0] >= 'a' and outputList[ 0] <= 'l' and listSize > 5: outputList[1] = outputList[1][:-(listSize - proxLimit)] return outputList # Name: parsePipeInput # Description: Parser class method which takes in a value and immediately returns it; provides for # further parsing if necessary in the future by way of keeping other parsing methods # intact # Parameters: Takes in a value which is forwarded # Return: Returns the value passed into the method def parsePipeInput(self, inputValue): return inputValue
def __init__(self, baudRate, timeOut, readinSize): self.__serialReadSize = readinSize # SerialPort object created with baud rate and timeout values passed into the constructor self.__serialPort = SerialPort(baudRate, timeOut, readinSize)
def __init__(self, portName): self.portName = portName self.serialLink = SerialPort(self.portName)
class CommandCenter: def __init__(self, portName): self.portName = portName self.serialLink = SerialPort(self.portName) #binaryCommand = self.__getWirelessBinaryCommand(command, sensorId) #self.__sendDataToSerialPort(binaryCommand) #return self.__getFormatedDataFromSerialPort(lengthOfPacket=19,format) def setStreamingTiming (self,interval,duration,delay, sensorId): commandData = [0.0] * 3 commandData[0] = interval commandData[1] = duration commandData[2] = delay data = self.__getWirelessBinaryCommand(Commands.SET_STREAMING_TIMING,sensorId,commandData=commandData,format=">III") self.__retryIfSetCommandFailed(data,"setStreamingTiming", sensorId=sensorId) def performOffsetOperation(self,sensorId): #we are trying to find offset here by getting gravity vector of device and gravity vector that we want it as northAndGravityVectors = self.__getNorthAndGravityVectorsInSensorFrame(sensorId) untaredOrientationAsQuaternion = self.__getUntaredOrientationAsQuaternion(sensorId,needToReturnSensorId=False) vectorAndQuaternionCalculator = VectorAndQuaternionCalculator() offsetAsQuaternion = vectorAndQuaternionCalculator.getOffsetOrientationAsQuaternion(northAndGravityVectors) #below two statements is to offset gd so that it is align with g taredData = vectorAndQuaternionCalculator.getMultiplicationOfQuaternion(untaredOrientationAsQuaternion,offsetAsQuaternion) self.__setTareOrientationAsSameAsSuppliedOrientationInQuaternionDomain(sensorId,tareData=taredData) return offsetAsQuaternion def getAngleBetweenThreeVectors(self, vectorOne,vectorTwo,vectorthree): vectorAndQuaternionCalculator = VectorAndQuaternionCalculator() return vectorAndQuaternionCalculator.calculateAngle(vectorOne,vectorTwo,vectorthree) def getDeviceVector(self,sensorId, suppliedVector, offsetAsQuaternion): taredOrientationAsQuaternion = self.__getTaredOrientationAsQuaternion(sensorId,needToReturnSensorId=False) #print "taredOrientationAsQuaternion" #print taredOrientationAsQuaternion vectorAndQuaternionCalculator = VectorAndQuaternionCalculator() vector = vectorAndQuaternionCalculator.getVectorOftheDeviceBasedOnSuppliedOrientation(suppliedVector,taredOrientationAsQuaternion,offsetAsQuaternion) return vector def calculateDeviceVector(self,sensorId,vector,offset): taredOrientationAsQuaternion = self.__getTaredOrientationAsQuaternion(sensorId) ## Apply the offset for the device quat = self.__quaternionMultiplication(taredOrientationAsQuaternion, offset) ## Calculate a vector for the device with its orientation vector = self.__quaternionVectorMultiplication(quat, vector) return vector def getThisData(self): numberOfByteAvaialbe = self.serialLink.getNumberOfByteAvailable() if numberOfByteAvaialbe>18: receivedData = self.serialLink.readData(numberOfByteAvaialbe) if (numberOfByteAvaialbe == 19): formatedData = self.__getFormatedData(receivedData,format=">ffff") return formatedData EmptyList = list() return EmptyList def getTaredOridntationAsQuaternionFromBuffer(self, sensorId): print (self.serialLink.getNumberOfByteAvailable()) def getSerialBuffer(self): print("the buffer is") print ("available number of Byte") print (self.serialLink.getNumberOfByteAvailable()) print repr(self.serialLink.readData(self.serialLink.getNumberOfByteAvailable())) print ("available number of Byte after read") print (self.serialLink.getNumberOfByteAvailable()) def closeSerialPort(self): self.serialLink.clostPort() def setStreamingSlot(self,sensorId, slot1, slot2 = chr(0xff),slot3 = chr(0xff), slot4= chr(0xff), slot5= chr(0xff), slot6= chr(0xff),slot7= chr(0xff),slot8= chr(0xff)): commandData = [0.0] * 8 commandData[0] = slot1 commandData[1] = slot2 commandData[2] = slot3 commandData[3] = slot4 commandData[4] = slot5 commandData[5] = slot6 commandData[6] = slot7 commandData[7] = slot8 data = self.__getWirelessBinaryCommand(Commands.SET_STREAMING_SLOTS,sensorId, commandData=commandData,format='cccccccc') self.__retryIfSetCommandFailed(data,"setStreamingSlots", sensorId=sensorId) def startStreaming(self, sensorId): binaryCommand = self.__getWirelessBinaryCommand(Commands.START_STREAMING, sensorId) self.__sendDataToSerialPort(binaryCommand) self.__retryIfSetCommandFailed(binaryCommand,"StartStreaming", sensorId=sensorId) def stopStreaming(self,sensorId): binaryCommand = self.__getWirelessBinaryCommand(Commands.STOP_STREAMING, sensorId) self.__sendDataToSerialPort(binaryCommand) self.__retryIfSetCommandFailed(binaryCommand,"StopStreaming", sensorId=sensorId) def getStreamingTiming(self,sensorId): binaryCommand = self.__getWirelessBinaryCommand(Commands.GET_STREAMING_TIMING, sensorId) self.__sendDataToSerialPort(binaryCommand) return self.__getFormatedDataFromSerialPort(lengthOfPacket=15,format="III") ######################################################################################################################## #Private function def __getTaredOrientationAsQuaternion(self, sensorId,needToReturnSensorId = True): command = Commands.getCommandAsChr(Commands.GET_TARED_ORIENTATION_AS_QUATERNION) format = Commands.getRetrunDataFormat(Commands.GET_TARED_ORIENTATION_AS_QUATERNION) lengthOfReturnData = Commands.getReturnDataLength(Commands.GET_TARED_ORIENTATION_AS_QUATERNION) binaryCommand = self.__getWirelessBinaryCommand(command, sensorId) receivedData = self.__getRawDataAndRetryIfGetCommandFailed(sensorId,binaryCommand,lengthOfReturnData) if needToReturnSensorId is True: return (self.__getFormatedData(receivedData,format)) else: return (self.__getFormatedDataWithoutSensorId(receivedData,format)) def __setTareOrientationAsSameAsSuppliedOrientationInQuaternionDomain(self, sensorId, tareData): command = Commands.getCommandAsChr(Commands.TARE_WITH_QUATERNION) dataFormat = Commands.getDataFormat(Commands.TARE_WITH_QUATERNION) binaryCommand = self.__getWirelessBinaryCommand(command, sensorId, tareData, dataFormat) self.__retryIfSetCommandFailed(binaryCommand,"tareWithQuaternion", sensorId=sensorId) def __getUntaredOrientationAsQuaternion(self, sensorId = 0,needToReturnSensorId = True): command = Commands.getCommandAsChr(Commands.GET_UNTARED_ORIENTATION_AS_QUATERNION) lengthOfReturnData = Commands.getReturnDataLength(Commands.GET_UNTARED_ORIENTATION_AS_QUATERNION) format = Commands.getRetrunDataFormat(Commands.GET_UNTARED_ORIENTATION_AS_QUATERNION) binaryCommand = self.__getWirelessBinaryCommand(command, sensorId) receivedData = self.__getRawDataAndRetryIfGetCommandFailed(sensorId,binaryCommand,lengthOfReturnData) if needToReturnSensorId is True: return (self.__getFormatedData(receivedData,format)) else: #Note: starting byte is sensorId followed by data, need to remove index 0 if you dont want to get sensorId as return data return (self.__getFormatedData(receivedData,format))[1:] def __getFormatedDataWithoutSensorId(self,data, format): actualData = data[3:len(data)] dataToBeReturned = list(struct.unpack(format, actualData)) return dataToBeReturned def __getNorthAndGravityVectorsInSensorFrame(self, sensorId): command = Commands.getCommandAsChr(Commands.GET_NORTH_AND_GRAVITY_VECTORS_IN_SENSOR_FRAME) lengthOfReturnData = Commands.getReturnDataLength(Commands.GET_NORTH_AND_GRAVITY_VECTORS_IN_SENSOR_FRAME) format = Commands.getRetrunDataFormat(Commands.GET_NORTH_AND_GRAVITY_VECTORS_IN_SENSOR_FRAME) binaryCommand = self.__getWirelessBinaryCommand(command, sensorId) receivedData = self.__getRawDataAndRetryIfGetCommandFailed(sensorId,binaryCommand,lengthOfReturnData) return (self.__getFormatedData(receivedData,format)) def __getRawDataAndRetryIfGetCommandFailed(self,sensorId,binaryCommand, returnDataLength): WIRELESS_HEADER_LENGTH = 3 SUCESSFULLY_SENT_BYTE = chr(0x00) TOTAL_PACKET_LENGTH = WIRELESS_HEADER_LENGTH + returnDataLength self.__sendDataToSerialPort(binaryCommand) receivedData = (self.serialLink.readData(TOTAL_PACKET_LENGTH)) while receivedData[0] != SUCESSFULLY_SENT_BYTE and receivedData[1] != sensorId and receivedData != returnDataLength: print "send to sensor Id" + str(sensorId) + "fail" self.serialLink.flushBuffer() self.__sendDataToSerialPort(binaryCommand) receivedData = (self.serialLink.readData(TOTAL_PACKET_LENGTH)) return receivedData def __getFormatedData(self, data, format): actualData = data[3:len(data)] sensorId = data[1] dataToBeReturned = list(struct.unpack(format, actualData)) dataToBeReturned.insert(0,ord(sensorId)) return dataToBeReturned def __getSensorId(self,data): return data[1] def __flushBuffer(self): self.serialLink.readData(self.serialLink.getNumberOfByteAvailable()) self.serialLink.flushBuffer() def __retryIfSetCommandFailed(self, data, nameOfCommand, sensorId): self.__sendDataToSerialPort(data) while self.__isCommandSuccessful(sensorId) == False: self.__flushBuffer() print ("going to send again") self.__sendDataToSerialPort(data) print (nameOfCommand + " command is successfully sent to sensor ID: " + str(sensorId)) def __isCommandSuccessful(self, sensorId): print(self.serialLink.getNumberOfByteAvailable()) numberOfbyte = self.serialLink.getNumberOfByteAvailable() print (numberOfbyte) receivedData = (self.serialLink.readData(3)) if ((receivedData[0] == chr(0x00))and(receivedData[1]==chr(int(sensorId)))): #print ("command successful" + repr(receivedData)) return True else: #print ("command failed" + repr(receivedData)) return False def __getFormatedDataFromSerialPort(self, lengthOfPacket, format): receivedData = (self.serialLink.readData(lengthOfPacket)) if receivedData[0] == chr(0x00): print "successful" actualData = receivedData[3:lengthOfPacket] outputData = list(struct.unpack(format, actualData)) return outputData else: print("data not avaialbe yet" + repr(receivedData)) return None def __sendDataToSerialPort(self, data): self.serialLink.sendData(data) def __getWirelessBinaryCommand(self, command, sensorId, commandData=[], format=""): sensorId = chr(int(sensorId)) if len(commandData) > 0: packedData = struct.pack(format, *commandData) sendingData = Commands.WIRELESS_STARTING_BYTE + sensorId + command + packedData + self.__getCheckSum( sensorId + command + packedData) return sendingData else: sendingData = Commands.WIRELESS_STARTING_BYTE + sensorId + command + self.__getCheckSum( sensorId + command) return sendingData def __getCheckSum(self, char_data): """ Calculates the checksum for the given data. Args: char_data: A string of data. """ checksum = 0 for byte in char_data: checksum += ord(byte) return chr(checksum % 256)
class SerialModem: """ Class representing a serial panstamp modem """ class Mode: """ Serial modes """ DATA = 0 COMMAND = 1 def stop(self): """ Stop serial gateway """ if self._serport is not None: self._serport.stop() def _serialPacketReceived(self, buf): """ Serial packet received. This is a callback function called from the SerialPort object @param buf: Serial packet received in String format """ # If modem in command mode if self._sermode == SerialModem.Mode.COMMAND: self._atresponse = buf self.__atresponse_received = True # If modem in data mode else: # Waiting for ready signal from modem? if self._wait_modem_start == False: if buf == "Modem ready!": self._wait_modem_start = True # Create CcPacket from string and notify reception elif self._ccpacket_received is not None: try: ccPacket = CcPacket(buf) self._ccpacket_received(ccPacket) except SwapException: raise def setRxCallback(self, cbFunct): """ Set callback reception function. Notify new CcPacket reception @param cbFunct: Definition of custom Callback function for the reception of packets """ self._ccpacket_received = cbFunct def goToCommandMode(self): """ Enter command mode (for AT commands) @return True if the serial gateway does enter Command Mode. Return false otherwise """ if self._sermode == SerialModem.Mode.COMMAND: return True self._sermode = SerialModem.Mode.COMMAND response = self.runAtCommand("+++", 5000) if response is not None: if response[:2] == "OK": return True self._sermode = SerialModem.Mode.DATA return False def goToDataMode(self): """ Enter data mode (for Rx/Tx operations) @return True if the serial gateway does enter Data Mode. Return false otherwise """ if self._sermode == SerialModem.Mode.DATA: return True response = self.runAtCommand("ATO\r") if response is not None: if response[0:2] == "OK": self._sermode = SerialModem.Mode.DATA; return True; return False; def reset(self): """ Reset serial gateway @return True if the serial gateway is successfully restarted """ # Switch to command mode if necessary if self._sermode == SerialModem.Mode.DATA: self.goToCommandMode() # Run AT command response = self.runAtCommand("ATZ\r") if response is None: return False if response[0:2] == "OK": self._sermode = SerialModem.Mode.DATA return True return False def runAtCommand(self, cmd="AT\r", timeout=1000): """ Run AT command on the serial gateway @param cmd: AT command to be run @param timeout: Period after which the function should timeout @return Response received from gateway or None in case of lack of response (timeout) """ self.__atresponse_received = False # Send command via serial if self._serport is None: raise SwapException("Port " + self.portname + " is not open") # Skip wireless packets self._atresponse = "(" # Send serial packet self._serport.send(cmd) # Wait for response from modem while len(self._atresponse) == 0 or self._atresponse[0] == '(': if not self._waitForResponse(timeout): return None # Return response received from gateway return self._atresponse def sendCcPacket(self, packet): """ Send wireless CcPacket through the serial gateway @param packet: CcPacket to be transmitted """ strBuf = packet.toString() + "\r" self._serport.send(strBuf) def setFreqChannel(self, value): """ Set frequency channel for the wireless gateway @param value: New frequency channel """ # Check format if value > 0xFF: raise SwapException("Frequency channels must be 1-byte length") # Switch to command mode if necessary if self._sermode == SerialModem.Mode.DATA: self.goToCommandMode() # Run AT command response = self.runAtCommand("ATCH=" + "{0:02X}".format(value) + "\r") if response is None: return False if response[0:2] == "OK": self.freq_channel = value return True return False def setSyncWord(self, value): """ Set synchronization word for the wireless gateway @param value: New synchronization word """ # Check format if value > 0xFFFF: raise SwapException("Synchronization words must be 2-byte length") # Switch to command mode if necessary if self._sermode == SerialModem.Mode.DATA: self.goToCommandMode() # Run AT command response = self.runAtCommand("ATSW=" + "{0:04X}".format(value) + "\r") if response is None: return False if response[0:2] == "OK": self.syncword = value return True else: return False def setDevAddress(self, value): """ Set device address for the serial gateway @param value: New device address """ # Check format if value > 0xFF: raise SwapException("Device addresses must be 1-byte length") # Switch to command mode if necessary if self._sermode == SerialModem.Mode.DATA: self.goToCommandMode() # Run AT command response = self.runAtCommand("ATDA=" + "{0:02X}".format(value) + "\r") if response is None: return False if response[0:2] == "OK": self.devaddress = value return True else: return False def _waitForResponse(self, millis): """ Wait a given amount of milliseconds for a response from the serial modem @param millis: Amount of milliseconds to wait for a response """ loops = millis / 10 while not self.__atresponse_received: time.sleep(0.01) loops -= 1 if loops == 0: return False return True def __init__(self, portname="/dev/ttyUSB0", speed=38400, verbose=False): """ Class constructor @param portname: Name/path of the serial port @param speed: Serial baudrate in bps @param verbose: Print out SWAP traffic (True or False) """ # Serial mode (command or data modes) self._sermode = SerialModem.Mode.DATA # Response to the last AT command sent to the serial modem self._atresponse = "" # AT response received from modem self.__atresponse_received = None # "Packet received" callback function. To be defined by the parent object self._ccpacket_received = None ## Name(path) of the serial port self.portname = portname ## Speed of the serial port in bps self.portspeed = speed ## Hardware version of the serial modem self.hwversion = None ## Firmware version of the serial modem self.fwversion = None try: # Open serial port self._serport = SerialPort(self.portname, self.portspeed, verbose) # Define callback function for incoming serial packets self._serport.setRxCallback(self._serialPacketReceived) # Run serial port thread self._serport.start() # This flags switches to True when the serial modem is ready self._wait_modem_start = False start = time.time() soft_reset = False while self._wait_modem_start == False: elapsed = time.time() - start if not soft_reset and elapsed > 5: self.reset() soft_reset = True elif soft_reset and elapsed > 10: raise SwapException("Unable to reset serial modem") # Retrieve modem settings # Switch to command mode if not self.goToCommandMode(): raise SwapException("Modem is unable to enter command mode") # Hardware version response = self.runAtCommand("ATHV?\r") if response is None: raise SwapException("Unable to retrieve Hardware Version from serial modem") self.hwversion = long(response, 16) # Firmware version response = self.runAtCommand("ATFV?\r") if response is None: raise SwapException("Unable to retrieve Firmware Version from serial modem") self.fwversion = long(response, 16) # Frequency channel response = self.runAtCommand("ATCH?\r") if response is None: raise SwapException("Unable to retrieve Frequency Channel from serial modem") ## Frequency channel of the serial gateway self.freq_channel = int(response, 16) # Synchronization word response = self.runAtCommand("ATSW?\r") if response is None: raise SwapException("Unable to retrieve Synchronization Word from serial modem") ## Synchronization word of the serial gateway self.syncword = int(response, 16) # Device address response = self.runAtCommand("ATDA?\r") if response is None: raise SwapException("Unable to retrieve Device Address from serial modem") ## Device address of the serial gateway self.devaddress = int(response, 16) # Switch to data mode self.goToDataMode() except: raise
def OnOk( self, event ): """ Clicked on OK """ twr_ser = self.cbTwrSerPort.GetValue().encode('ASCII') if twr_ser == "": wx.MessageBox("Please enter an valid serial port name for \ communicating with the tower ") self.set_invalid() return else: try: ser = SerialPort(twr_ser) ser.write_to_port('X0') # Write some known command for a check read_info = ser.read_from_twr() if read_info[1] == False: dlg = wx.MessageDialog(self, "The Tower did not respond with expected response."+ \ " Please make sure that you have selected appropriate port."+ \ "\n\n Do you want to retry with a different serial port ?", \ "Warning", wx.YES_NO) resp = dlg.ShowModal() dlg.Destroy() if resp == wx.ID_YES: ser.close_port() self.set_invalid() return else: self.config.set_twr_ser_port(twr_ser) ser.close_port() except IOError: wx.MessageBox("Could not open com port %s ", twr_ser) self.set_invalid() return dmm_ser = self.cbDmmSerPort.GetValue().encode('ASCII') if dmm_ser == "": wx.MessageBox("Please enter an valid serial port name for \ communicating with the DMM ") self.set_invalid() return else: try: ser = SerialPort(dmm_ser, '9600', '2') read_info = ser.read_from_dmm() if read_info[1] == False : dlg = wx.MessageDialog(self, "The dmm did not respond with expected response."+ \ " Please make sure that you have selected appropriate port."+ \ " And that the DMM has been set up properly " + \ "\n\n Do you want to retry with a different serial port ?", \ "Warning", wx.YES_NO) resp = dlg.ShowModal() dlg.Destroy() if resp == wx.ID_YES: ser.close_port() self.set_invalid() return else: self.config.set_dmm_ser_port(dmm_ser) ser.close_port() except IOError: wx.MessageBox("Could not open com port %s ", twr_ser) self.set_invalid() return if dmm_ser == twr_ser: # can't use same port for both DMM and Tower wx.MessageBox("Cannot use same port for communicating with both \n"+ "Tower and DMM ") self.set_invalid() return # Let us validate the exstince of the command file if os.path.exists(self.config.get_cmd_file()) == False: wx.MessageBox("Please enter a valid path for command file ") self.set_invalid() return if os.path.exists(self.config.get_log_file()) == False: wx.MessageBox("Please enter a valid path for log file ") self.set_invalid() return # if we have made it to this point, most of the things are valid # except for the serial ports which are dependent on user choice(s) self.set_valid() self.Close()
def start(self, config): self.serialPort = SerialPort(self, config.get('port_address'), Constants.SERIAL_MESSAGE_DELIMITER) self.serialPort.openPort() pass
def __init__(self, **kwargs): super(SDKApplication, self).__init__() with open("logconfig.yaml", "r") as f: logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader)) self.applogger = logging.getLogger("app") self.port_rx_stream_queue = Queue.Queue() self.parsed_message_queue = Queue.Queue() self.active_info = dict( [ (k, kwargs.get(k, v)) for (k, v) in [ ("app_id", None), ("app_ver", 0x03010A00), ("bundle_id", "12345678901234567890123456789012"), ] ] ) if not self.active_info.get("app_id"): raise TypeError('{}.__init__() must pass argument "app_id"!'.format(__class__)) encrypt_param = dict( [ (k, kwargs.get(k, v)) for (k, v) in [ ("crc16_init", 0x3AA3), ("crc16_poly", 0x18005), ("crc32_init", 0x3AA3), ("crc32_poly", 0x104C11DB7), ("aes256_key", None), ] ] ) if not encrypt_param.get("aes256_key"): raise TypeError('{}.__init__() must pass argument "aes256_key"!'.format(__class__)) EncryptCodec.initEncryptCodec(encrypt_param) port_param = dict( [ (k, kwargs.get(k, v)) for (k, v) in [ ("port", "/dev/ttyUSB0"), ("baudrate", 230400), ("read_bytes", 12), ("buffer_queue", self.port_rx_stream_queue), ] ] ) self.port = SerialPort(**port_param) self.parser = ProtocolParser(self.port_rx_stream_queue, self.parsed_message_queue) self.sm = SessionManager(self.port.write) self.register_data_handle() self.port.open() self.parser.start()
from SerialPort import SerialPort from time import sleep com = SerialPort('COM6', timeout=5) com.sendMsg('12 01 01 FF') sleep(3) com.sendMsg('05 14 2B 37 39 32 31 38 36 37 31 39 39 37 00 00 00 00 00 00 00 00 FF') # Wait UP batton com.waitMsg() com.sendMsg('1F 01 01 FF') #sleep(3) com.sendMsg('04 01 01 FF')
def __init__(self, *args, **kwargs): Tk.__init__(self, *args, **kwargs) self.activeTab = 0 self.geometry("775x550") self.title("Pedalbox") # self.iconbitmap("assets/pedal.ico") self.serial_data = '' self.filter_data = '' # Main Container container = Frame(self, bg='white') container.pack(fill="both") tablayout = Notebook(container) ################################################################ ## tab1 tab1 = Frame(tablayout, bg='white') tab1.pack(fill="both") clutch_cluster = ClutchCluster(tab1, self) brake_cluster = BrakeCluster(tab1, self) throttle_cluster = ThrottleCluster(tab1, self) clutch_cluster.grid(row=0, column=0, padx=10, pady=10, sticky="nsew") brake_cluster.grid(row=0, column=1, padx=10, pady=10, sticky="nsew") throttle_cluster.grid(row=0, column=2, padx=10, pady=10, sticky="nsew") tab1.grid_columnconfigure(0, weight=1) tab1.grid_columnconfigure(1, weight=1) tab1.grid_columnconfigure(2, weight=1) tablayout.add(tab1, text="Clusters") ################################################################ # tab2 tab2 = Frame(tablayout, bg='white') tab2.pack(fill="both", expand=1) clutch = Clutch(tab2, self) brake = Brake(tab2, self) throttle = Throttle(tab2, self) clutch.grid(row=0, column=0, padx=10, pady=10, sticky="nsew") brake.grid(row=0, column=1, padx=10, pady=10, sticky="nsew") throttle.grid(row=0, column=2, padx=10, pady=10, sticky="nsew") tab2.grid_columnconfigure(0, weight=1) tab2.grid_columnconfigure(1, weight=1) tab2.grid_columnconfigure(2, weight=1) tablayout.add(tab2, text="Settings") tablayout.pack(fill="both", expand=1) ################################################################ # tab3 tab3 = Frame(tablayout, bg='white') tab3.pack(fill="both", expand=1) serial_port_settings = SerialPort(tab3, self) serial_port_settings.grid(row=0, column=0, padx=10, pady=10, sticky="nsew") tablayout.add(tab3, text="config") tablayout.pack(fill="both", expand=1) tablayout.bind("<<NotebookTabChanged>>", lambda event: self.tab_changed(tablayout)) connect_button = Button( self, text="connect serial port", command=lambda: serial_connect(self, get_connection_info()[1], get_connection_info()[0])) connect_button.pack() disconect_button = Button(self, text="disconect serial port", command=serial_disconect) disconect_button.pack() pub.subscribe(get_map_update_clutch, 'clutch_map_update') pub.subscribe(get_map_update_brake, 'brake_map_update') pub.subscribe(get_map_update_throttle, 'throttle_map_update')
class SDKApplication(StoppableThread): def __init__(self, **kwargs): super(SDKApplication, self).__init__() with open('logconfig.yaml', 'r') as f: logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader)) self.applogger = logging.getLogger('app') self.port_rx_stream_queue = Queue.Queue() self.parsed_message_queue = Queue.Queue() self.active_info = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('app_id', None), ('api_level', 0x02), ('app_ver', 0x01), ('bundle_id', '12345678901234567890123456789012'), ]] ) if not self.active_info.get('app_id'): raise TypeError( '{}.__init__() must pass argument "app_id"!'.format(__class__)) encrypt_param = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('crc16_init', 0x3AA3), ('crc16_poly', 0x18005), ('crc32_init', 0x3AA3), ('crc32_poly', 0x104C11DB7), ('aes256_key', None), ]] ) if not encrypt_param.get('aes256_key'): raise TypeError( '{}.__init__() must pass argument "aes256_key"!'.format(__class__)) EncryptCodec.initEncryptCodec(encrypt_param) port_param = dict( [(k, kwargs.get(k, v)) for (k, v) in [ ('port', '/dev/ttyUSB0'), ('baudrate', 230400), ('read_bytes', 12), ('buffer_queue', self.port_rx_stream_queue), ]] ) self.port = SerialPort(**port_param) self.parser = ProtocolParser( self.port_rx_stream_queue, self.parsed_message_queue) self.sm = SessionManager(self.port.write) self.register_data_handle() self.port.open() self.parser.start() def register_data_handle(self): self.recv_data_handler_table = CMD_SET_R def launch(self): self.start() def close(self): self.sm.close_all_sessions() self.port.close() self.stop() def run(self): while (not self.stopped()): try: (header, data_buf) = self.parsed_message_queue.get( block=True, timeout=3.0) assert isinstance(header, ProtocolHeader) and isinstance( data_buf, bytes) if header.ack: self.sm.feed_ack(header.session, header.seq, data_buf) else: d = ProtocolData() cmd_set, cmd_id, content = d.parse(data_buf) self.recv_data_handler_table[cmd_set][cmd_id](content) # LOG('Data received.') except Queue.Empty, e: pass
class SDKApplication(StoppableThread): """ SDKApplication class for main entrance for api. Usage: >>> app = SDKApplication(app_id, aes256_key, port) >>> app.get_api_version() ... >>> app.active_api() ... >>> app.acquire_control() ... >>> app.release_control() ... >>> app.close() The following are the parameters supplied to the constructor. app_id -- your app id aes256_key -- your enc key port -- your serial port path baudrate -- your serial port baudrate """ def __init__(self, **kwargs): super(SDKApplication, self).__init__() with open("logconfig.yaml", "r") as f: logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader)) self.applogger = logging.getLogger("app") self.port_rx_stream_queue = Queue.Queue() self.parsed_message_queue = Queue.Queue() self.active_info = dict( [ (k, kwargs.get(k, v)) for (k, v) in [ ("app_id", None), ("app_ver", 0x03010A00), ("bundle_id", "12345678901234567890123456789012"), ] ] ) if not self.active_info.get("app_id"): raise TypeError('{}.__init__() must pass argument "app_id"!'.format(__class__)) encrypt_param = dict( [ (k, kwargs.get(k, v)) for (k, v) in [ ("crc16_init", 0x3AA3), ("crc16_poly", 0x18005), ("crc32_init", 0x3AA3), ("crc32_poly", 0x104C11DB7), ("aes256_key", None), ] ] ) if not encrypt_param.get("aes256_key"): raise TypeError('{}.__init__() must pass argument "aes256_key"!'.format(__class__)) EncryptCodec.initEncryptCodec(encrypt_param) port_param = dict( [ (k, kwargs.get(k, v)) for (k, v) in [ ("port", "/dev/ttyUSB0"), ("baudrate", 230400), ("read_bytes", 12), ("buffer_queue", self.port_rx_stream_queue), ] ] ) self.port = SerialPort(**port_param) self.parser = ProtocolParser(self.port_rx_stream_queue, self.parsed_message_queue) self.sm = SessionManager(self.port.write) self.register_data_handle() self.port.open() self.parser.start() def register_data_handle(self): self.recv_data_handler_table = CMD_SET_R def launch(self): self.start() def close(self): self.sm.close_all_sessions() self.port.close() self.stop() def run(self): while not self.stopped(): try: (header, data_buf) = self.parsed_message_queue.get(block=True, timeout=3.0) assert isinstance(header, ProtocolHeader) and isinstance(data_buf, bytes) if header.ack: self.sm.feed_ack(header.session, header.seq, data_buf) else: d = ProtocolData() cmd_set, cmd_id, content = d.parse(data_buf) self.recv_data_handler_table[cmd_set][cmd_id](content) # LOG('Data received.') except Queue.Empty, e: pass
class MainWindow(QMainWindow, Ui_MainWindow): serial_readyWrite_signal = QtCore.pyqtSignal(str, bytes, str) serial_readyRead_signal = QtCore.pyqtSignal(bool) def __init__(self): super().__init__() self.setupUi(self) self.comboBox = MyCombox(self.centralwidget) self.comboBox.setGeometry(QtCore.QRect(750, 40, 193, 30)) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.comboBox.sizePolicy().hasHeightForWidth()) self.comboBox.setSizePolicy(sizePolicy) self.comboBox.setMinimumSize(QtCore.QSize(0, 30)) self.comboBox.setObjectName("comboBox") self.comboBox.enter_event_signal.connect(self.onComboxEnterSlot) self.serial_port = SerialPort() self.serial_port.searchPort() self.serial_list = list(self.serial_port.port.keys()) self.serial_list.sort() for item in self.serial_list: self.comboBox.addItem(item) self.comboBox_2.addItem('1200') self.comboBox_2.addItem('2400') self.comboBox_2.addItem('4800') self.comboBox_2.addItem('9600') self.comboBox_2.addItem('19200') self.comboBox_2.addItem('38400') self.comboBox_2.addItem('57600') self.comboBox_2.addItem('115200') self.comboBox_2.setCurrentIndex(3) self.comboBox_2.currentIndexChanged.connect( self.onCombox_2IncdeChangeSlot) self.comboBox_3.addItem('1') self.comboBox_3.addItem('1.5') self.comboBox_3.addItem('2') self.comboBox_3.setCurrentIndex(0) self.comboBox_3.currentIndexChanged.connect( self.onCombox_3IncdeChangeSlot) self.comboBox_4.addItem('5') self.comboBox_4.addItem('6') self.comboBox_4.addItem('7') self.comboBox_4.addItem('8') self.comboBox_4.setCurrentIndex(3) self.comboBox_4.currentIndexChanged.connect( self.onCombox_4IncdeChangeSlot) self.comboBox_5.addItem('无') self.comboBox_5.addItem('奇校验') self.comboBox_5.addItem('偶校验') self.comboBox_5.setCurrentIndex(0) self.comboBox_5.currentIndexChanged.connect( self.onCombox_5IncdeChangeSlot) self.pushButton_flag = True self.pushButton.clicked.connect(self.onPushButtonClickedSlot) self.pushButton_2.clicked.connect(self.onPushButton_2ClickedSlot) self.pushButton_3.clicked.connect(self.onPushButton_3ClickedSlot) self.pushButton_4.clicked.connect(self.onPushButton_4ClickedSlot) self.pushButton_5.clicked.connect(self.onPushButton_5ClickedSlot) self.write_encodemode = 'utf-8' self.radioButton.toggled.connect(self.onRadioButtonToggledSlot) self.radioButton_2.toggled.connect(self.onRadioButton_2ToggledSlot) self.radioButton_3.toggled.connect(self.onRadioButton_3ToggledSlot) self.radioButton_4.toggled.connect(self.onRadioButton_4ToggledSlot) self.radioButton_5.toggled.connect(self.onRadioButton_5ToggledSlot) self.radioButton_6.toggled.connect(self.onRadioButton_6ToggledSlot) self.serial_write_thread = QtCore.QThread() self.serial_write_threadObject = SerialWriteThreadObject( self.serial_port) self.serial_write_threadObject.moveToThread(self.serial_write_thread) self.serial_write_threadObject.write_finished.connect( self.serialWriteThreadFinishedSlot) self.serial_readyWrite_signal.connect( self.serial_write_threadObject.serialWriteSlot) self.serial_write_thread.start() self.serial_read_thread = QtCore.QThread() self.serial_read_threadObject = SerialReadThreadObject( self.serial_port) self.serial_read_threadObject.moveToThread(self.serial_read_thread) self.serial_port.readyRead.connect(self.serialReadyReadSlot) self.serial_readyRead_signal.connect( self.serial_read_threadObject.serialReadSlot) self.serial_read_threadObject.read_finished.connect( self.serialReadThreadFinishedSlot) self.serial_read_thread.start() self.receive_color = QtGui.QColor(220, 20, 60) self.send_color = QtGui.QColor(153, 50, 204) self.textBrowser_text_list = [] self.textBrowser_addTime_flag = False self.textBrowser_hex_flag = False self.write_newLine_flag = False self.write_hex_flag = False self.textEdit_textNum = 0 def onComboxEnterSlot(self): if self.pushButton_flag: index = self.comboBox.currentIndex() text = self.comboBox.currentText() self.comboBox.clear() self.serial_port.searchPort() self.serial_list = list(self.serial_port.port.keys()) self.serial_list.sort() for item in self.serial_list: self.comboBox.addItem(item) self.comboBox.setCurrentIndex(index) if self.comboBox.currentText() != text: self.comboBox.setCurrentIndex(0) def onCombox_2IncdeChangeSlot(self): current_index = self.comboBox_2.currentIndex() if current_index == 0: self.serial_port.baund_rate = QSerialPort.Baud1200 elif current_index == 1: self.serial_port.baund_rate = QSerialPort.Baud2400 elif current_index == 2: self.serial_port.baund_rate = QSerialPort.Baud4800 elif current_index == 3: self.serial_port.baund_rate = QSerialPort.Baud9600 elif current_index == 4: self.serial_port.baund_rate = QSerialPort.Baud19200 elif current_index == 5: self.serial_port.baund_rate = QSerialPort.Baud38400 elif current_index == 6: self.serial_port.baund_rate = QSerialPort.Baud57600 elif current_index == 7: self.serial_port.baund_rate = QSerialPort.Baud115200 def onCombox_3IncdeChangeSlot(self): current_index = self.comboBox_3.currentIndex() if current_index == 0: self.serial_port.stop_bits = QSerialPort.OneStop elif current_index == 1: self.serial_port.stop_bits = QSerialPort.OneAndHalfStop elif current_index == 2: self.serial_port.stop_bits = QSerialPort.TwoStop def onCombox_4IncdeChangeSlot(self): current_index = self.comboBox_4.currentIndex() if current_index == 0: self.serial_port.data_bits = QSerialPort.Data5 elif current_index == 1: self.serial_port.data_bits = QSerialPort.Data6 elif current_index == 2: self.serial_port.data_bits = QSerialPort.Data7 elif current_index == 3: self.serial_port.data_bits = QSerialPort.Data8 def onCombox_5IncdeChangeSlot(self): current_index = self.comboBox_5.currentIndex() if current_index == 0: self.serial_port.parity = QSerialPort.NoParity elif current_index == 1: self.serial_port.parity = QSerialPort.OddParity elif current_index == 2: self.serial_port.parity = QSerialPort.EvenParity def onPushButtonClickedSlot(self): if self.pushButton_flag: port_name = self.comboBox.currentText() if port_name != '': self.serial_port.setPort(self.serial_port.port[port_name]) self.serial_port.open(QSerialPort.ReadWrite) self.serial_port.setBaudRate(self.serial_port.baund_rate) self.serial_port.setStopBits(self.serial_port.stop_bits) self.serial_port.setDataBits(self.serial_port.data_bits) self.serial_port.setParity(self.serial_port.parity) self.pushButton_flag = False self.pushButton.setStyleSheet("border-image: url(:/pic/on.png);") self.comboBox.setEnabled(False) self.comboBox_2.setEnabled(False) self.comboBox_3.setEnabled(False) self.comboBox_4.setEnabled(False) self.comboBox_5.setEnabled(False) else: self.serial_port.close() self.pushButton_flag = True self.pushButton.setStyleSheet("border-image: url(:/pic/off.png);") self.comboBox.setEnabled(True) self.comboBox_2.setEnabled(True) self.comboBox_3.setEnabled(True) self.comboBox_4.setEnabled(True) self.comboBox_5.setEnabled(True) def onPushButton_2ClickedSlot(self): file_name, _ = QtWidgets.QFileDialog.getSaveFileName( self, '文件保存', './untitled.txt', 'Text files (*.txt)') result = '' with open(file_name, 'w') as fp: for text_list in self.textBrowser_text_list: text = "%s%s\n%s" % (text_list[0], text_list[2], text_list[1]) result = result + '\n' + text fp.write(result) def onPushButton_3ClickedSlot(self): self.textBrowser.clear() self.textBrowser_text_list = [] def onPushButton_4ClickedSlot(self): self.textEdit.clear() def onPushButton_5ClickedSlot(self): if not self.pushButton_flag: text = self.textEdit.toPlainText() if text != '': text_bytes = b'' if self.write_newLine_flag: text = text + '\r\n' if self.write_hex_flag: text_bytes = StringProcess.hexStringToStingBytes(text) self.serial_readyWrite_signal.emit(text, text_bytes, self.write_encodemode) def onRadioButtonToggledSlot(self): if self.radioButton.isChecked(): self.textBrowser_addTime_flag = True self.textBrowser.clear() for text_list in self.textBrowser_text_list: text = "%s%s\n%s" % (text_list[0], text_list[2], text_list[1]) result_filter = StringProcess.stringToHtmlFilter(text) if text_list[0] == '[SEND]:': result = StringProcess.stringToHtml( result_filter, self.send_color) else: result = StringProcess.stringToHtml( result_filter, self.receive_color) self.textBrowser.append(result) else: self.textBrowser_addTime_flag = False self.textBrowser.clear() for text_list in self.textBrowser_text_list: text = "%s\n%s" % (text_list[0], text_list[1]) result_filter = StringProcess.stringToHtmlFilter(text) if text_list[0] == '[SEND]:': result = StringProcess.stringToHtml( result_filter, self.send_color) else: result = StringProcess.stringToHtml( result_filter, self.receive_color) self.textBrowser.append(result) def onRadioButton_2ToggledSlot(self): if self.radioButton_2.isChecked(): self.textBrowser_hex_flag = True else: self.textBrowser_hex_flag = False def onRadioButton_3ToggledSlot(self): text = self.textEdit.toPlainText() if self.radioButton_3.isChecked(): self.write_hex_flag = True self.textEdit.textChanged.connect(self.textEditTextChangeSlot) if text != '': result = StringProcess.stringToHexString( text, self.write_encodemode) self.textEdit.clear() self.textEdit.setText(result) else: self.write_hex_flag = False self.textEdit.textChanged.disconnect(self.textEditTextChangeSlot) if text != '': result, flag = StringProcess.hexStringToSting( self.textEdit.toPlainText(), self.write_encodemode) if not flag: self.write_hex_flag = True self.radioButton_3.toggled.disconnect( self.onRadioButton_3ToggledSlot) self.radioButton_3.setChecked(True) self.radioButton_3.toggled.connect( self.onRadioButton_3ToggledSlot) QtWidgets.QMessageBox.warning(self, '警告', '输入的16进制字节串无法用utf-8解码,请确认!') self.textEdit.textChanged.connect( self.textEditTextChangeSlot) else: self.textEdit.clear() self.textEdit.setText(result) def onRadioButton_4ToggledSlot(self): self.write_encodemode = 'utf-8' def onRadioButton_5ToggledSlot(self): self.write_encodemode = 'gbk' def onRadioButton_6ToggledSlot(self): if self.radioButton_6.isChecked(): self.write_newLine_flag = True else: self.write_newLine_flag = False def textEditTextChangeSlot(self): text = self.textEdit.toPlainText() if text != '': cursor = self.textEdit.textCursor() col = cursor.columnNumber() row = cursor.blockNumber() document = self.textEdit.document() block_text = document.findBlockByNumber(row).text() self.textEdit.textChanged.disconnect(self.textEditTextChangeSlot) if self.textEdit_textNum < len(text): if col > 0: if ('0' <= block_text[col-1] <= '9') or ('a' <= block_text[col-1] <= 'f') \ or ('A' <= block_text[col-1] <= 'F'): if col > 1: if block_text[col - 2] != ' ': if col == len(block_text): self.textEdit.insertPlainText(' ') elif block_text[col] != ' ' and block_text[ col] != '\n': self.textEdit.insertPlainText(' ') elif block_text[col - 1] != ' ' and block_text[col - 1] != '\n': QtWidgets.QMessageBox.warning( self, '输入警告', '在16进制输入下只允许0-9、a-f、A-F!') ch = block_text[col - 1] text = text.strip(ch) self.textEdit.setText(text) self.textEdit.moveCursor(QtGui.QTextCursor.End, QtGui.QTextCursor.MoveAnchor) self.textEdit.textChanged.connect(self.textEditTextChangeSlot) self.textEdit_textNum = len(text) def serialWriteThreadFinishedSlot(self): text = self.textEdit.toPlainText() current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') setting = '[SEND]:' if self.write_hex_flag: setting = setting + '(hex)' temp_list = [setting, text, current_time] self.textBrowser_text_list.append(temp_list) if self.textBrowser_addTime_flag: result = "%s(%s)\n%s" % (setting, current_time, text) else: result = "%s\n%s" % (setting, text) result_filter = StringProcess.stringToHtmlFilter(result) self.textBrowser.append( StringProcess.stringToHtml(result_filter, self.send_color)) def serialReadThreadFinishedSlot(self, data): current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') setting = '[RECEIVE]:' if self.textBrowser_hex_flag: setting = setting + '(hex)' temp_list = [setting, data, current_time] self.textBrowser_text_list.append(temp_list) if self.textBrowser_addTime_flag: result = "%s(%s)\n%s" % (setting, current_time, data) else: result = "%s\n%s" % (setting, data) result_filter = StringProcess.stringToHtmlFilter(result) self.textBrowser.append( StringProcess.stringToHtml(result_filter, self.receive_color)) def serialReadyReadSlot(self): self.serial_readyRead_signal.emit(self.textBrowser_hex_flag)
def __init__(self): super().__init__() self.setupUi(self) self.comboBox = MyCombox(self.centralwidget) self.comboBox.setGeometry(QtCore.QRect(750, 40, 193, 30)) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.comboBox.sizePolicy().hasHeightForWidth()) self.comboBox.setSizePolicy(sizePolicy) self.comboBox.setMinimumSize(QtCore.QSize(0, 30)) self.comboBox.setObjectName("comboBox") self.comboBox.enter_event_signal.connect(self.onComboxEnterSlot) self.serial_port = SerialPort() self.serial_port.searchPort() self.serial_list = list(self.serial_port.port.keys()) self.serial_list.sort() for item in self.serial_list: self.comboBox.addItem(item) self.comboBox_2.addItem('1200') self.comboBox_2.addItem('2400') self.comboBox_2.addItem('4800') self.comboBox_2.addItem('9600') self.comboBox_2.addItem('19200') self.comboBox_2.addItem('38400') self.comboBox_2.addItem('57600') self.comboBox_2.addItem('115200') self.comboBox_2.setCurrentIndex(3) self.comboBox_2.currentIndexChanged.connect( self.onCombox_2IncdeChangeSlot) self.comboBox_3.addItem('1') self.comboBox_3.addItem('1.5') self.comboBox_3.addItem('2') self.comboBox_3.setCurrentIndex(0) self.comboBox_3.currentIndexChanged.connect( self.onCombox_3IncdeChangeSlot) self.comboBox_4.addItem('5') self.comboBox_4.addItem('6') self.comboBox_4.addItem('7') self.comboBox_4.addItem('8') self.comboBox_4.setCurrentIndex(3) self.comboBox_4.currentIndexChanged.connect( self.onCombox_4IncdeChangeSlot) self.comboBox_5.addItem('无') self.comboBox_5.addItem('奇校验') self.comboBox_5.addItem('偶校验') self.comboBox_5.setCurrentIndex(0) self.comboBox_5.currentIndexChanged.connect( self.onCombox_5IncdeChangeSlot) self.pushButton_flag = True self.pushButton.clicked.connect(self.onPushButtonClickedSlot) self.pushButton_2.clicked.connect(self.onPushButton_2ClickedSlot) self.pushButton_3.clicked.connect(self.onPushButton_3ClickedSlot) self.pushButton_4.clicked.connect(self.onPushButton_4ClickedSlot) self.pushButton_5.clicked.connect(self.onPushButton_5ClickedSlot) self.write_encodemode = 'utf-8' self.radioButton.toggled.connect(self.onRadioButtonToggledSlot) self.radioButton_2.toggled.connect(self.onRadioButton_2ToggledSlot) self.radioButton_3.toggled.connect(self.onRadioButton_3ToggledSlot) self.radioButton_4.toggled.connect(self.onRadioButton_4ToggledSlot) self.radioButton_5.toggled.connect(self.onRadioButton_5ToggledSlot) self.radioButton_6.toggled.connect(self.onRadioButton_6ToggledSlot) self.serial_write_thread = QtCore.QThread() self.serial_write_threadObject = SerialWriteThreadObject( self.serial_port) self.serial_write_threadObject.moveToThread(self.serial_write_thread) self.serial_write_threadObject.write_finished.connect( self.serialWriteThreadFinishedSlot) self.serial_readyWrite_signal.connect( self.serial_write_threadObject.serialWriteSlot) self.serial_write_thread.start() self.serial_read_thread = QtCore.QThread() self.serial_read_threadObject = SerialReadThreadObject( self.serial_port) self.serial_read_threadObject.moveToThread(self.serial_read_thread) self.serial_port.readyRead.connect(self.serialReadyReadSlot) self.serial_readyRead_signal.connect( self.serial_read_threadObject.serialReadSlot) self.serial_read_threadObject.read_finished.connect( self.serialReadThreadFinishedSlot) self.serial_read_thread.start() self.receive_color = QtGui.QColor(220, 20, 60) self.send_color = QtGui.QColor(153, 50, 204) self.textBrowser_text_list = [] self.textBrowser_addTime_flag = False self.textBrowser_hex_flag = False self.write_newLine_flag = False self.write_hex_flag = False self.textEdit_textNum = 0
class SDKApplication(StoppableThread): ''' SDKApplication class for main entrance for api. Usage: >>> app = SDKApplication(app_id, aes256_key, port) >>> app.get_api_version() ... >>> app.active_api() ... >>> app.acquire_control() ... >>> app.release_control() ... >>> app.close() The following are the parameters supplied to the constructor. app_id -- your app id aes256_key -- your enc key port -- your serial port path baudrate -- your serial port baudrate ''' def __init__(self, **kwargs): super(SDKApplication, self).__init__() with open('logconfig.yaml', 'r') as f: logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader)) self.applogger = logging.getLogger('app') self.port_rx_stream_queue = Queue.Queue() self.parsed_message_queue = Queue.Queue() self.active_info = dict([(k, kwargs.get(k, v)) for (k, v) in [ ('app_id', None), ('app_ver', 0x03010A00), ('bundle_id', '12345678901234567890123456789012'), ]]) if not self.active_info.get('app_id'): raise TypeError( '{}.__init__() must pass argument "app_id"!'.format(__class__)) encrypt_param = dict([(k, kwargs.get(k, v)) for (k, v) in [ ('crc16_init', 0x3AA3), ('crc16_poly', 0x18005), ('crc32_init', 0x3AA3), ('crc32_poly', 0x104C11DB7), ('aes256_key', None), ]]) if not encrypt_param.get('aes256_key'): raise TypeError( '{}.__init__() must pass argument "aes256_key"!'.format( __class__)) EncryptCodec.initEncryptCodec(encrypt_param) port_param = dict([(k, kwargs.get(k, v)) for (k, v) in [ ('port', '/dev/ttyUSB0'), ('baudrate', 230400), ('read_bytes', 12), ('buffer_queue', self.port_rx_stream_queue), ]]) self.port = SerialPort(**port_param) self.parser = ProtocolParser(self.port_rx_stream_queue, self.parsed_message_queue) self.sm = SessionManager(self.port.write) self.register_data_handle() self.port.open() self.parser.start() def register_data_handle(self): self.recv_data_handler_table = CMD_SET_R def launch(self): self.start() def close(self): self.sm.close_all_sessions() self.port.close() self.stop() def run(self): while (not self.stopped()): try: (header, data_buf) = self.parsed_message_queue.get(block=True, timeout=3.0) assert isinstance(header, ProtocolHeader) and isinstance( data_buf, bytes) if header.ack: self.sm.feed_ack(header.session, header.seq, data_buf) else: d = ProtocolData() cmd_set, cmd_id, content = d.parse(data_buf) self.recv_data_handler_table[cmd_set][cmd_id](content) # LOG('Data received.') except Queue.Empty, e: pass
def __init__(self, portname="/dev/ttyUSB0", speed=38400, verbose=False): """ Class constructor @param portname: Name/path of the serial port @param speed: Serial baudrate in bps @param verbose: Print out SWAP traffic (True or False) """ # Serial mode (command or data modes) self._sermode = SerialModem.Mode.DATA # Response to the last AT command sent to the serial modem self._atresponse = "" # AT response received from modem self.__atresponse_received = None # "Packet received" callback function. To be defined by the parent object self._ccpacket_received = None ## Name(path) of the serial port self.portname = portname ## Speed of the serial port in bps self.portspeed = speed ## Hardware version of the serial modem self.hwversion = None ## Firmware version of the serial modem self.fwversion = None try: # Open serial port self._serport = SerialPort(self.portname, self.portspeed, verbose) # Define callback function for incoming serial packets self._serport.setRxCallback(self._serialPacketReceived) # Run serial port thread self._serport.start() # This flags switches to True when the serial modem is ready self._wait_modem_start = False start = time.time() soft_reset = False while self._wait_modem_start == False: elapsed = time.time() - start if not soft_reset and elapsed > 5: self.reset() soft_reset = True elif soft_reset and elapsed > 10: raise SwapException("Unable to reset serial modem") # Retrieve modem settings # Switch to command mode if not self.goToCommandMode(): raise SwapException("Modem is unable to enter command mode") # Hardware version response = self.runAtCommand("ATHV?\r") if response is None: raise SwapException("Unable to retrieve Hardware Version from serial modem") self.hwversion = long(response, 16) # Firmware version response = self.runAtCommand("ATFV?\r") if response is None: raise SwapException("Unable to retrieve Firmware Version from serial modem") self.fwversion = long(response, 16) # Frequency channel response = self.runAtCommand("ATCH?\r") if response is None: raise SwapException("Unable to retrieve Frequency Channel from serial modem") ## Frequency channel of the serial gateway self.freq_channel = int(response, 16) # Synchronization word response = self.runAtCommand("ATSW?\r") if response is None: raise SwapException("Unable to retrieve Synchronization Word from serial modem") ## Synchronization word of the serial gateway self.syncword = int(response, 16) # Device address response = self.runAtCommand("ATDA?\r") if response is None: raise SwapException("Unable to retrieve Device Address from serial modem") ## Device address of the serial gateway self.devaddress = int(response, 16) # Switch to data mode self.goToDataMode() except: raise
port.stop() port.disconnect() def printout(): end = time.time() print(end - start,"s -------------------------") print("chars received : ",count) print("in waiting :",port.get_rxloadmax()) print("errors :",errorcount) if port.isAlive(): t2 = Timer(1.0, printout) t2.start() port = SerialPort() port.start() port.connect("COM5",115200) synced = False count = 0 errorcount = 0 index = 0 sequence = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] t = Timer(10.0, stop) t.start() start = time.time() t2 = Timer(1.0, printout) t2.start()
from flask import Flask, jsonify from flask_socketio import SocketIO from flask_cors import CORS from RPi import GPIO from helpers.Database import Database from SerialPort import SerialPort import threading serialPort = SerialPort() GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) app = Flask(__name__) CORS(app) socketio = SocketIO(app) hallsensor = 4 f = 0 r = 0 eindpoint = '/api/vi/' conn = Database(app=app, host='192.168.4.1', port=3306, user='******', password='******',
from AT.NRB import NRB from equipment.Led import Led from equipment.Gpio import Gpio from equipment.Pi import Pi from equipment.Drive import Drive import threading serialPort = "/dev/ttyAMA0" # 串口 '''serialPort = "COM3" # 串口''' baudRate = 9600 # 波特率 """ 所有模块初始化 """ nnmi = NNMI() qlwevtind = QLWEVTIND() mSerial = SerialPort(serialPort, baudRate) receiveMsg = ReceiveMsg(mSerial, nnmi, qlwevtind) nmgs = NMGS(mSerial, receiveMsg) csq = CSQ(mSerial, receiveMsg) cfun = CFUN(mSerial, receiveMsg) cgatt = CGATT(mSerial, receiveMsg) qlwuldataex = QLWULDATAEX(mSerial, receiveMsg) nconfig = NCONFIG(mSerial, receiveMsg) nrb = NRB(mSerial, receiveMsg) gpio_equipment = Gpio() led_equipment = Led(gpio_equipment, nmgs) pi_equipment = Pi(mSerial, receiveMsg, nmgs, csq, cfun, cgatt, qlwuldataex, nconfig, nrb, gpio_equipment) drive = Drive(nnmi, receiveMsg, led_equipment, pi_equipment)
import threading import time from tkinter import * from tkinter import font from SystemUsageDisplay import init_system_usage_gui from TakeActions import init_take_actions_gui from VolumeDisplay import init_volume_display_gui from Buttons_Description import init_describe_button_gui from Resolver import Resolver from SerialPort import SerialPort ser = SerialPort(sys.argv[1], Resolver(), timeout=0) ser.start() window = Tk() window.title("Host") frames = [] for row in range(6): frame = Frame(window) frame.grid(column=0, row=row, padx=20, pady=20) frame.update() frames.append(frame) def get_scale(volume: str): ser.write(b'zad1') print(volume) ser.write(volume.encode())
from SerialPort import SerialPort com = SerialPort('COM6', timeout=1) com.waitMsg() com.sendMsg('01 02 00 01 FF') com.waitMsg() com.sendMsg('01 02 00 01 FF') com.waitMsg() com.sendMsg('22 22 07 30 30 32 34 30 34 31 39 66 66 63 64 00 45 37 31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF') while True: com.waitMsg()