def test_readlines(self): """Test readlines method""" self.s.write(serial.to_bytes([0x31, 0x0A, 0x32, 0x0A, 0x33, 0x0A])) self.assertEqual( self.s.readlines(), [serial.to_bytes([0x31, 0x0A]), serial.to_bytes([0x32, 0x0A]), serial.to_bytes([0x33, 0x0A])], )
def test_readlines(self): """Test readlines method""" self.s.write(serial.to_bytes([0x31, 0x0a, 0x32, 0x0a, 0x33, 0x0a])) self.failUnlessEqual( self.s.readlines(), [serial.to_bytes([0x31, 0x0a]), serial.to_bytes([0x32, 0x0a]), serial.to_bytes([0x33, 0x0a])] )
def test_readlines(self): """Test readlines method""" self.s.write(serial.to_bytes(b"1\n2\n3\n")) self.assertEqual( self.s.readlines(), [serial.to_bytes(b"1\n"), serial.to_bytes(b"2\n"), serial.to_bytes(b"3\n")] )
def FunBridge(ser,serBridge): global global_RXArray global global_RXCmd ser.write(serial.to_bytes([0xc1,0x03,0x05,0x03,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') time.sleep(0.1) print ("reciver:") while True: ser.write(serial.to_bytes([0xc1,0x06,0x00])) data = ser.read(3) if len(data)>=2 : len1=int(data[2].encode('hex'),16) cmd = ser.read(1) data2 = ser.read(len1-1) CRC = ser.read(1) isSame=numpy.array_equal(data2,global_RXArray) #print (cmd,16) if isSame == False or global_RXCmd!=cmd : global_RXArray=data2 global_RXCmd=cmd print ('Bridge data') print data2.encode('HEX') else: exit(2)
def FunSerial(USBPort,USBRate,SendReceive,data_array): try: #ser = serial.Serial("/dev/ttyAMA0", 115200, timeout=5) #ser = serial.Serial("/dev/cu.usbserial-A700eGFx", 115200, timeout=1) #ser = serial.Serial("/dev/cu.usbserial", 115200, timeout=1) print '----------------------------------' ser = serial.Serial(USBPort, USBRate, timeout=0.5) ser.write(serial.to_bytes([0x80,0x00,0x00])) data = ser.read(6) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x01,0x00])) data = ser.read(5) print data.encode('hex') #time.sleep(0.1) ser.write(serial.to_bytes([0xc1,0x02,0x00])) data = ser.read(12) print data.encode('hex') #time.sleep(0.1) if SendReceive == 'R': FunRX(ser) else: FunTX(ser,data_array) ser.close() except serial.serialutil.SerialException: print 'cannot open Serial Port'
def FunTX(ser): ser.write(serial.to_bytes([0xc1,0x03,0x05,0x02,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x05,0x03,0x01,0x02,0x03])) data = ser.read(5) print data.encode('hex')
def FunSerial(USBPort,USBRate): try: #ser = serial.Serial("/dev/ttyAMA0", 115200, timeout=5) #ser = serial.Serial("/dev/cu.usbserial-A700eGFx", 115200, timeout=1) #ser = serial.Serial("/dev/cu.usbserial", 115200, timeout=1) print '----------------------------------' ser = serial.Serial(USBPort, USBRate, timeout=0.5) ser.write(serial.to_bytes([0x80,0x00,0x00])) data = ser.read(6) #print(data) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x01,0x00])) data = ser.read(5) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x02,0x00])) data = ser.read(12) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x03,0x05,0x03,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x06,0x00])) data = ser.read(7) print ("reciver:") print data.encode('hex') ser.close() except serial.serialutil.SerialException: print 'cannot open Serial Port'
def test_to_bytes(self): self.assertEqual(serial.to_bytes([1, 2, 3]), b'\x01\x02\x03') self.assertEqual(serial.to_bytes(b'\x01\x02\x03'), b'\x01\x02\x03') self.assertEqual(serial.to_bytes(bytearray([1,2,3])), b'\x01\x02\x03') # unicode is not supported test. use decode() instead of u'' syntax to be # compatible to Python 3.x < 3.4 self.assertRaises(TypeError, serial.to_bytes, b'hello'.decode('utf-8'))
def test_alternate_eol(self): """Test readline with alternative eol settings (skipped for io based systems)""" if hasattr(self.s, 'xreadlines'): # test if it is our FileLike base class self.s.write(serial.to_bytes("no\rno\nyes\r\n")) self.failUnlessEqual( self.s.readline(eol=serial.to_bytes("\r\n")), serial.to_bytes("no\rno\nyes\r\n"))
def velCallback(self, Twist): x_vel = Twist.linear.x y_vel = Twist.linear.y w_vel = Twist.angular.z m_unit = [] m_unit.append(y_vel - x_vel + pi * w_vel * (self.a_ + self.b_)) m_unit.append(y_vel + x_vel - pi * w_vel * (-self.a_ + self.b_)) m_unit.append(y_vel - x_vel - pi * w_vel * (self.a_ + self.b_)) m_unit.append(y_vel + x_vel + pi * w_vel * (self.a_ + self.b_)) # m_unit.append( x_vel - y_vel + (4 / (3*pi)) * w_vel * (self.a_ + self.b_) ** 1/2) # m_unit.append( x_vel + y_vel + (4 / pi) * w_vel * (self.a_ + self.b_) ** 1/2) # m_unit.append( x_vel - y_vel - (4 / pi) * w_vel * (self.a_ + self.b_) ** 1/2) # m_unit.append( x_vel + y_vel - (4 / (3*pi)) * w_vel * (self.a_ + self.b_) ** 1/2) self.m1_target = int(127 + 60 * (m_unit[0])) self.m2_target = int(127 + 60 * (m_unit[1])) self.m3_target = int(127 + 60 * (m_unit[2])) self.m4_target = int(127 + 60 * (m_unit[3])) self.serial.write(serial.to_bytes([mini_target, m1_, self.m1_target])) self.serial.write(serial.to_bytes([mini_target, m2_, self.m2_target])) self.serial.write(serial.to_bytes([mini_target, m3_, self.m3_target])) self.serial.write(serial.to_bytes([mini_target, m4_, self.m4_target]))
def FunRX(ser): global global_RXArray global global_RXCmd ser.write(serial.to_bytes([0xc1,0x03,0x05,0x03,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') time.sleep(0.1) print ("reciver:") while True: ser.write(serial.to_bytes([0xc1,0x06,0x00])) data = ser.read(3) if len(data)>=2 : len1=int(data[2].encode('hex'),16) cmd = ser.read(1) data2 = ser.read(len1-1) CRC = ser.read(1) isSame=numpy.array_equal(data2,global_RXArray) #print (cmd,16) if isSame == False or global_RXCmd!=cmd : global_RXArray=data2 global_RXCmd=cmd print data2.encode('hex') if data2[0] == 0x71: GPIO.output(7,True) ## Turn on GPIO pin 7 elif data2[0] == 0x70: GPIO.output(7,False) ## Turn off GPIO pin 7 elif data2[0] == 0xb1: GPIO.output(11,True) ## Turn on GPIO pin 7 elif data2[0] == 0xb0: GPIO.output(11,False) ## Turn off GPIO pin 7 #tarray=['0'] #FunTX(ser,tarray) else: exit(2)
def test_readlines(self): """Test readlines method""" self.s.write(serial.to_bytes("1\n2\n3\n")) self.failUnlessEqual( self.s.readlines(), [serial.to_bytes("1\n"), serial.to_bytes("2\n"), serial.to_bytes("3\n")] )
def test_readline(self): """Test readline method""" self.s.write(serial.to_bytes(b"1\n2\n3\n")) self.assertEqual(self.s.readline(), serial.to_bytes(b"1\n")) self.assertEqual(self.s.readline(), serial.to_bytes(b"2\n")) self.assertEqual(self.s.readline(), serial.to_bytes(b"3\n")) # this time we will get a timeout self.assertEqual(self.s.readline(), serial.to_bytes(""))
def test_xreadlines(self): """Test xreadlines method (skipped for io based systems)""" if hasattr(self.s, 'xreadlines'): self.s.write(serial.to_bytes([0x31, 0x0a, 0x32, 0x0a, 0x33, 0x0a])) self.failUnlessEqual( list(self.s), [serial.to_bytes([0x31, 0x0a]), serial.to_bytes([0x32, 0x0a]), serial.to_bytes([0x33, 0x0a])] )
def test_readline(self): """Test readline method""" self.s.write(serial.to_bytes([0x31, 0x0a, 0x32, 0x0a, 0x33, 0x0a])) self.failUnlessEqual(self.s.readline(), serial.to_bytes([0x31, 0x0a])) self.failUnlessEqual(self.s.readline(), serial.to_bytes([0x32, 0x0a])) self.failUnlessEqual(self.s.readline(), serial.to_bytes([0x33, 0x0a])) # this time we will get a timeout self.failUnlessEqual(self.s.readline(), serial.to_bytes([]))
def test_xreadlines(self): """Test xreadlines method (skipped for io based systems)""" if hasattr(self.s, "xreadlines"): self.s.write(serial.to_bytes([0x31, 0x0A, 0x32, 0x0A, 0x33, 0x0A])) self.assertEqual( list(self.s.xreadlines()), [serial.to_bytes([0x31, 0x0A]), serial.to_bytes([0x32, 0x0A]), serial.to_bytes([0x33, 0x0A])], )
def test_xreadlines(self): """Test xreadlines method (skipped for io based systems)""" if hasattr(self.s, 'xreadlines'): self.s.write(serial.to_bytes(b"1\n2\n3\n")) self.assertEqual( list(self.s), [serial.to_bytes(b"1\n"), serial.to_bytes(b"2\n"), serial.to_bytes(b"3\n")] )
def FunRX(ser): ser.write(serial.to_bytes([0xc1,0x03,0x05,0x03,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') ser.write(serial.to_bytes([0xc1,0x06,0x00])) data = ser.read(7) print ("reciver:") print data.encode('hex')
def test_for_in(self): """Test for line in s""" self.s.write(serial.to_bytes([0x31, 0x0A, 0x32, 0x0A, 0x33, 0x0A])) lines = [] for line in self.s: lines.append(line) self.assertEqual( lines, [serial.to_bytes([0x31, 0x0A]), serial.to_bytes([0x32, 0x0A]), serial.to_bytes([0x33, 0x0A])] )
def test_for_in(self): """Test for line in s""" self.s.write(serial.to_bytes(b"1\n2\n3\n")) lines = [] for line in self.s: lines.append(line) self.assertEqual( lines, [serial.to_bytes(b"1\n"), serial.to_bytes(b"2\n"), serial.to_bytes(b"3\n")] )
def FunRX(ser): ser.write(serial.to_bytes([0xc1,0x03,0x05,0x03,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') time.sleep(0.1) ser.write(serial.to_bytes([0xc1,0x06,0x00])) data = ser.read(3) print ("reciver:") print data.encode('hex') print ("data:") #print (data[2],hex) #print(data[2].encode('hex')) data2 = ser.read(int(data[2].encode('hex'),16)) print data2.encode('hex')
def encode(self, data, final=False): """\ Incremental encode, keep track of digits and emit a byte when a pair of hex digits is found. The space is optional unless the error handling is defined to be 'strict'. """ state = self.state encoded = [] for c in data.upper(): if c in HEXDIGITS: z = HEXDIGITS.index(c) if state: encoded.append(z + (state & 0xf0)) state = 0 else: state = 0x100 + (z << 4) elif c == ' ': # allow spaces to separate values if state and self.errors == 'strict': raise UnicodeError('odd number of hex digits') state = 0 else: if self.errors == 'strict': raise UnicodeError('non-hex digit found: %r' % c) self.state = state return serial.to_bytes(encoded)
def _inputLoop(self): """ Loop and copy console->serial until EXIT_CHARCTER character is found. """ try: while self.alive: try: c = console.getkey() except KeyboardInterrupt: print('kbint') c = serial.to_bytes([3]) if c == self.EXIT_CHARACTER: self.stop() elif c == '\n': # Convert newline input into \r self.serial.write(self.WRITE_TERM) if self.echo: # Locally just echo the real newline sys.stdout.write(c) sys.stdout.flush() else: #print('writing: ', c) self.serial.write(c) if self.echo: sys.stdout.write(c) sys.stdout.flush() except: self.alive = False raise
def write_bytes(self, b): """ Write raw bytes at the current cursor position. """ b = serial.to_bytes(b) LOGGER.info("Byte string: %r", b) self._writebytes([CMD_WRITE]) self._writebytes(b) self._writebytes([CMD_NULL])
def FunRX(ser): global global_RXArray ser.write(serial.to_bytes([0xc1,0x03,0x05,0x03,0xe4,0xc0,0x00,0x03])) data = ser.read(5) print data.encode('hex') time.sleep(0.1) print ("reciver:") while True: ser.write(serial.to_bytes([0xc1,0x06,0x00])) data = ser.read(3) if len(data)>=2 : data2 = ser.read(int(data[2].encode('hex'),16)) cmd = ser.read(1) isSame=numpy.array_equal(data2,global_RXArray) if isSame == False : global_RXArray=data2 print data2.encode('hex') else: exit(2)
def FunLora_ChipSendByte(self,array1): try: print array1 self.ser.write(serial.to_bytes(array1)) time.sleep(0.04) bytesToRead = self.ser.inWaiting() data = self.ser.read(bytesToRead) print(data.encode('hex')) except (OSError, serial.SerialException): pass return data
def _writebytes(self, b): """ Write bytes directly to the device. """ b = serial.to_bytes(b) LOGGER.debug("Write: %r", b) self.tty.write(b) self.tty.flush() # XXX: Writing commands too fast seems to cause errors time.sleep(0.01)
def writer(self): """loop forever and copy socket->serial""" while self.alive: try: data = self.socket.recv(1024) if not data: break self.serial.write(serial.to_bytes(self.rfc2217.filter(data))) except socket.error, msg: self.log.error("%s" % (msg,)) # probably got disconnected break
def send(self, message): """Sends the specified message to the projector object.""" if self.ser.isOpen(): self.ser.write(serial.to_bytes(message) + vp21.NULL) bytes = self.ser.read(BUF) if bytes == vp21.NULL: return CMD_SUCCESS else: return CMD_FAILURE log.warning('Command \"%s\" rejected.') else: return CMD_FAILURE
def show_mem(oparr, ser): address = 0 mem_load_length = default_mem_load_length file_name = None try: address = int(oparr[1], 16) if address < access_l_b or address > access_r_b: raise Exception() if len(oparr) >= 3: mem_load_length = int(oparr[2]) if len(oparr) >= 4: file_name = oparr[3] except Exception as e: print 'Invalid Arugment' return True if file_name: try: fout = open(file_name, 'w') except Exception as e: print 'Can not read file' return True ser.write('D') ser.write(serial.to_bytes(word_to_bytes(address))) ser.write(serial.to_bytes(word_to_bytes(address + mem_load_length * 4))) time.sleep(0.1) for i in range(0, mem_load_length): raw_data = read_a_word(ser) hex_s = hex_str(raw_data) if file_name: # TODO: check the endian of host raw_data.reverse() for i in raw_data: fout.write(chr(i)) else: print '%s: 0x%s' % (hex(address + i * 4), hex_s) if file_name: fout.close() read_wait(ser) return True
def write_color_change(self): ser.write(serial.to_bytes([0x02])) time_t.sleep(0.1) while ser.inWaiting() > 0: out = (ser.read(1)) print(out)
def FunLora_2_ReadSetup(): # * 讀取設定狀態 print("讀取設定狀態") ser.write(serial.to_bytes([0xC1, 0x02, 0x00, 0xC3])) data = ser.read(12) print(data.encode('hex'))
def write(self, degrees): cmd = ServoProtocol.cmd_header.copy() cmd.extend(degrees) cmd.append(sum(degrees) % 0xff) self.sr.write(serial.to_bytes(cmd)) return self.sr.read_all() == b'255'
def makeCmd(cmd): tmp = [0xA0, len(cmd) + 2, matAddr] + cmd tmp.append(chkSum(tmp)) return serial.to_bytes(tmp)
def mouse_set_zero(): global xy_old for i in range(6): ser.write(serial.to_bytes([0x08, 0x00, 0xA1, 0x02, 0, 128, 128, 0])) xy_old = (0, 0)
import libscrc sPort = 'COM3' payloadW = [0x00, 0x00, 0x01, 0x01, 0xc0, 0x74, 0x0d, 0x0a, 0x00, 0x00] payload1 = [0x01, 0x03, 0x00, 0x3F, 0x00, 0x09, 0xB5, 0xC0, 0x0d, 0x0a] payload2 = [0x02, 0x03, 0x00, 0x3f, 0x00, 0x09, 0xB5, 0xF3, 0x0d, 0x0a] payloadV = [0x01, 0x03, 0x00, 0x45, 0x00, 0x09, 0x94, 0x19, 0x0d, 0x0a] payloadT = [0x01, 0x03, 0x00, 0x50, 0x00, 0x07, 0x04, 0x19, 0x0d, 0x0a] s = serial.Serial(port=sPort, baudrate=9600, parity=serial.PARITY_MARK, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=1) s.write(serial.to_bytes(payloadW)) #print("Woke up serial device") s.flush() s.close() print(serial.to_bytes(payload1)) s = serial.Serial(port=sPort, baudrate=115200, parity=serial.PARITY_MARK, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=1) s.write(serial.to_bytes(payloadV)) outputV = s.readline() s.write(serial.to_bytes(payloadT))
def off(self, idx): self.state &= ~(1 << idx) self.ser.write(serial.to_bytes([self.state])) # with BitBangDevice(device_id) as bb: # bb.port &= ~(1 << idx) if (self.DEBUG): print "off(", idx, "):", hex(self.state)
#!/Users/cody/Projects/github/arduino-cloud-compiler/bin/python # Very simple serial terminal # (C)2002-2011 Chris Liechti <*****@*****.**> # Input characters are sent directly (only LF -> CR/LF/CRLF translation is # done), received characters are displayed as is (or escaped trough pythons # repr, useful for debug purposes) import sys, os, serial, threading try: from serial.tools.list_ports import comports except ImportError: comports = None EXITCHARCTER = serial.to_bytes([0x1d]) # GS/CTRL+] MENUCHARACTER = serial.to_bytes([0x14]) # Menu: CTRL+T DEFAULT_PORT = None DEFAULT_BAUDRATE = 9600 DEFAULT_RTS = None DEFAULT_DTR = None def key_description(character): """generate a readable description for a key""" ascii_code = ord(character) if ascii_code < 32: return 'Ctrl+%c' % (ord('@') + ascii_code) else: return repr(character)
def writer(self): """\ Loop and copy console->serial until EXITCHARCTER character is found. When MENUCHARACTER is found, interpret the next key locally. """ menu_active = False try: while self.alive: try: b = console.getkey() except KeyboardInterrupt: b = serial.to_bytes([3]) c = character(b) if menu_active: if c == MENUCHARACTER or c == EXITCHARCTER: # Menu character again/exit char -> send itself self.serial.write(b) # send character if self.echo: sys.stdout.write(c) elif c == '\x15': # CTRL+U -> upload file sys.stderr.write('\n--- File to upload: ') sys.stderr.flush() console.cleanup() filename = sys.stdin.readline().rstrip('\r\n') if filename: try: file = open(filename, 'r') sys.stderr.write('--- Sending file %s ---\n' % filename) while True: line = file.readline().rstrip('\r\n') if not line: break self.serial.write(line) self.serial.write('\r\n') # Wait for output buffer to drain. self.serial.flush() sys.stderr.write( '.') # Progress indicator. sys.stderr.write('\n--- File %s sent ---\n' % filename) except IOError, e: sys.stderr.write( '--- ERROR opening file %s: %s ---\n' % (filename, e)) console.setup() elif c in '\x08hH?': # CTRL+H, h, H, ? -> Show help sys.stderr.write(get_help_text()) elif c == '\x12': # CTRL+R -> Toggle RTS self.rts_state = not self.rts_state self.serial.setRTS(self.rts_state) sys.stderr.write( '--- RTS %s ---\n' % (self.rts_state and 'active' or 'inactive')) elif c == '\x04': # CTRL+D -> Toggle DTR self.dtr_state = not self.dtr_state self.serial.setDTR(self.dtr_state) sys.stderr.write( '--- DTR %s ---\n' % (self.dtr_state and 'active' or 'inactive')) elif c == '\x02': # CTRL+B -> toggle BREAK condition self.break_state = not self.break_state self.serial.setBreak(self.break_state) sys.stderr.write( '--- BREAK %s ---\n' % (self.break_state and 'active' or 'inactive')) elif c == '\x05': # CTRL+E -> toggle local echo self.echo = not self.echo sys.stderr.write( '--- local echo %s ---\n' % (self.echo and 'active' or 'inactive')) elif c == '\x09': # CTRL+I -> info self.dump_port_settings() elif c == '\x01': # CTRL+A -> cycle escape mode self.repr_mode += 1 if self.repr_mode > 3: self.repr_mode = 0 sys.stderr.write('--- escape data: %s ---\n' % (REPR_MODES[self.repr_mode], )) elif c == '\x0c': # CTRL+L -> cycle linefeed mode self.convert_outgoing += 1 if self.convert_outgoing > 2: self.convert_outgoing = 0 self.newline = NEWLINE_CONVERISON_MAP[ self.convert_outgoing] sys.stderr.write('--- line feed %s ---\n' % (LF_MODES[self.convert_outgoing], )) elif c in 'pP': # P -> change port dump_port_list() sys.stderr.write('--- Enter port name: ') sys.stderr.flush() console.cleanup() try: port = sys.stdin.readline().strip() except KeyboardInterrupt: port = None console.setup() if port and port != self.serial.port: # reader thread needs to be shut down self._stop_reader() # save settings settings = self.serial.getSettingsDict() try: try: new_serial = serial.serial_for_url( port, do_not_open=True) except AttributeError: # happens when the installed pyserial is older than 2.5. use the # Serial class directly then. new_serial = serial.Serial() new_serial.port = port # restore settings and open new_serial.applySettingsDict(settings) new_serial.open() new_serial.setRTS(self.rts_state) new_serial.setDTR(self.dtr_state) new_serial.setBreak(self.break_state) except Exception, e: sys.stderr.write( '--- ERROR opening new port: %s ---\n' % (e, )) new_serial.close() else: self.serial.close() self.serial = new_serial sys.stderr.write( '--- Port changed to: %s ---\n' % (self.serial.port, )) # and restart the reader thread self._start_reader() elif c in 'bB': # B -> change baudrate sys.stderr.write('\n--- Baudrate: ') sys.stderr.flush() console.cleanup() backup = self.serial.baudrate try: self.serial.baudrate = int( sys.stdin.readline().strip()) except ValueError, e: sys.stderr.write( '--- ERROR setting baudrate: %s ---\n' % (e, )) self.serial.baudrate = backup else:
def send_cmd(ser, cmd): UD_MOTOR = 0x10 DOWN_DIR = 0x10 UP_DIR = 0x1f LR_MOTOR = 0x11 LEFT_DIR = 0x10 RIGHT_DIR = 0x1f FB_MOTOR = 0x12 BACK_DIR = 0x10 FOR_DIR = 0x1f EN_CMD = 0x30 DS_CMD = 0x31 SUCK_CMD = 0x40 UNSUCK_CMD = 0x41 for c in cmd: l = [] read_length = 0 # first part if c[0] == "enable": l.append(EN_CMD) read_length = 1 elif c[0] == "disable": l.append(DS_CMD) read_length = 1 elif c[0] == "suck": l.append(SUCK_CMD) read_length = 1 elif c[0] == "unsuck": l.append(UNSUCK_CMD) read_length = 1 elif c[0] == "up": l = [UD_MOTOR, UP_DIR, c[1]] read_length = 4 elif c[0] == "down": l = [UD_MOTOR, DOWN_DIR, c[1]] read_length = 4 elif c[0] == "left": l = [LR_MOTOR, LEFT_DIR, c[1]] read_length = 4 elif c[0] == "right": l = [LR_MOTOR, RIGHT_DIR, c[1]] read_length = 4 elif c[0] == "for": l = [FB_MOTOR, FOR_DIR, c[1]] read_length = 4 elif c[0] == "back": l = [FB_MOTOR, BACK_DIR, c[1]] read_length = 4 else: print("Unknown command.") continue # second part l.append(0xff) # send the command to the serial port ser.write(serial.to_bytes(l)) ser.read(read_length) # print information print("Perform command:", c[0], "Send:", l) # sleep time.sleep(0.03)
def hex_encode(input, errors='strict'): return (serial.to_bytes([int(h, 16) for h in input.split()]), len(input))
import urllib.request import json import serial from time import sleep print('Welcome to Freeways Server controller!') port = 'COM10' lastSentData = None ser = serial.Serial(port) while (True): try: resp = urllib.request.urlopen( "http://169.254.102.215/api.php?json=1&set=0") data = json.load(resp) if data != lastSentData: lastSentData = data red = int(data['red']) green = int(data['green']) blue = int(data['blue']) print('Updating colors to : ' + str(red) + ' ' + str(green) + ' ' + str(blue)) ser.write(serial.to_bytes([red, green, blue])) sleep(0.5) except: print('Error occured, repeating!')
import serial import numpy as np Supatipunno = serial.Serial(port='COM8', baudrate=576000, xonxoff=0, rtscts=0, bytesize=8, parity='N', stopbits=1) try: Supatipunno.is_open print('\nCOMMUNICATION WITH PORT NAME : ' + Supatipunno.portstr) print('UART PORT IS OPEN. READY TO COMMUNICATION \n') except: Supatipunno.open() print('UART PORT IS CLOSE. PLEASE TRY AGAIN LATER \n') data = [255, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 160, 105] Supatipunno.write(serial.to_bytes(data)) print(serial.to_bytes(data))
def FunLora_0_GetChipID(): # * 讀取F/W版本及Chip ID print("讀取F/W版本及Chip ID") ser.write(serial.to_bytes([0x80, 0x00, 0x00, 0x80])) data = ser.read(10) print(data.encode('hex'))
def write_dummy(self): ser.write(serial.to_bytes([0x00])) time_t.sleep(0.1) while ser.inWaiting() > 0: out = (ser.read(1)) print(out)
def encode(self, data, errors='strict'): """'40 41 42' -> b'@ab'""" return serial.to_bytes([int(h, 16) for h in data.split()])
def write_speed(self, *args): ser.write(serial.to_bytes([int(args[1])])) time_t.sleep(0.1) while ser.inWaiting() > 0: out = (ser.read(1)) print(out)
def hex_encode(data, errors='strict'): """'40 41 42' -> b'@ab'""" return (serial.to_bytes([int(h, 16) for h in data.split()]), len(data))
#!/usr/bin/python import serial from time import localtime, strftime import time port = serial.Serial("/dev/serial0", baudrate=9600, timeout=1.5) dir = "/home/pi/data/" if port.isOpen(): print("Port was opened, closed now.") port.close() port.open() # Disable Auto Send and verify port.write(serial.to_bytes([0x68, 0x01, 0x20, 0x77])) resp = port.read(4) if ord(resp[0]) == 165 and ord(resp[1]) == 165: print("Auto Send disabled.") else: print("ERROR: Auto Send NOT disabled.") # Start the fan and measurements port.write(serial.to_bytes([0x68, 0x01, 0x01, 0x96])) resp = port.read(4) if ord(resp[0]) == 165 and ord(resp[1]) == 165: print("Fan and measurement started.") else: print("ERROR: Fan and measurement NOT started.") print("Wait for 10 seconds for fresh air...")
def mouse_release(): ser.write(serial.to_bytes([0x08, 0x00, 0xA1, 0x02, 0, 0, 0, 0])) time.sleep(0.3)
def test_IotTsensorTemp(self): """ Test to verify the temperature reading on the device under test board. Five consecutive reading is performed for both external and on board sensors. Average of five readings is compared. :return: """ temp_list = [] ref_temp = 0 sample_times = 5 for i in range(0, sample_times): self._serial.reset_input_buffer() cmd = "iot_tests test 12 1" self._serial.write('\r\n'.encode('utf-8')) self._serial.write(cmd.encode('utf-8')) self._serial.write('\r\n'.encode('utf-8')) res = self._serial.read_until(terminator=serial.to_bytes( [ord(c) for c in 'Ignored '])).decode('utf-8') # print(res) temp = [] # Extract temperature readings from all of on board sensors. for x in res.split('\n'): # Look for the line with ADC reading. if x.find('TEST(TEST_IOT_TSENSOR, AFQP_IotTsensorTemp)') != -1: for s in x.split(): if s.isdigit(): temp.append(int(s)) temp_list.append(temp) # Wait serial to flush out. sleep(0.2) # Get reference temperature. self.run_shell_script(" ".join( [self.shell_script, self._ip, self._login, self._pwd])) fp = open(self.rpi_output_file) line = fp.readline() fp.close() try: ref_temp = ref_temp + float(line) except: print("Failed to get ref temp") return 'Fail' avg_temp = [ sum([_list[i] for _list in temp_list]) / len(temp_list) for i in range(len(temp_list[0])) ] ref_temp = ref_temp / sample_times if len(temp) == 0: print("Failed to get temp from DUT.") return 'Fail' for temp in avg_temp: if abs(temp / 1000 - ref_temp) > 5: print("DUT temp:", temp / 1000, "Ref temp:", ref_temp) self.clean() return 'Fail' # print(avg_temp) self.clean() return 'Pass'
0x73)) DIGCF_PRESENT = 2 DIGCF_DEVICEINTERFACE = 16 INVALID_HANDLE_VALUE = 0 ERROR_INSUFFICIENT_BUFFER = 122 SPDRP_HARDWAREID = 1 SPDRP_FRIENDLYNAME = 12 ERROR_NO_MORE_ITEMS = 259 DICS_FLAG_GLOBAL = 1 DIREG_DEV = 0x00000001 KEY_READ = 0x20019 REG_SZ = 1 # workaround for compatibility between Python 2.x and 3.x PortName = serial.to_bytes([80, 111, 114, 116, 78, 97, 109, 101]) # "PortName" def comports(): """This generator scans the device registry for com ports and yields port, desc, hwid""" g_hdi = SetupDiGetClassDevs(ctypes.byref(GUID_CLASS_COMPORT), None, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE) #~ for i in range(256): for dwIndex in range(256): did = SP_DEVICE_INTERFACE_DATA() did.cbSize = ctypes.sizeof(did) if not SetupDiEnumDeviceInterfaces( g_hdi, None, ctypes.byref(GUID_CLASS_COMPORT), dwIndex, ctypes.byref(did)): if ctypes.GetLastError() != ERROR_NO_MORE_ITEMS:
import os import serial import time fd = serial.Serial('/dev/ttyUSB0', 230400, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE) motorInit = serial.to_bytes([ 0xE2, 0x3F, 0x70, 0xC0, 0xB8, 0x04, 0xF0, 0x20, 0x58, 0x02, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x23, 0x01, 0x02, 0xF0, 0x26, 0x01, 0x1F, 0xF2, 0x13, 0x01, 0x00, 0x7A, 0x73, 0xE3 ]) motor1kRpm = serial.to_bytes([ 0xE2, 0x3F, 0x70, 0xC0, 0xB8, 0x04, 0xF0, 0x20, 0x58, 0x04, 0x3E, 0xFF, 0xFF, 0x01, 0x00, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x23, 0x01, 0x02, 0xF0, 0x26, 0x01, 0x39, 0xF2, 0x13, 0x01, 0x00, 0x95, 0xC8, 0xE3 ])
def Fun_ser_Write(self, array1): try: self.ser.write(serial.to_bytes(array1)) except SerialException: print("Fun_ser_Write error")
import serial ser = serial.Serial(port='/dev/ttyAMA0', baudrate=9600, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS) ser.open() ser.write(serial.to_bytes([0x30])) sleep(1) ser.readline() ser.write(serial.to_bytes([0x02]))
def encode(self, input, errors='strict'): return serial.to_bytes([int(h, 16) for h in input.split()])
def send_msg(self): self.__serial_port.write(serial.to_bytes(self.__get_msg()))
def __init__(self, ser): self.ser = ser self.ser.write(serial.to_bytes([0xAA, 0x00, 0xAA]))
def FunLora_1_Init(): # * 重置 & 初始化 print("重置 & 初始化") ser.write(serial.to_bytes([0xC1, 0x01, 0x00, 0xC0])) data = ser.read(5) print(data.encode('hex'))
def mouse_hold(): ser.write(serial.to_bytes([0x08, 0x00, 0xA1, 0x02, 1, 0, 0, 0])) time.sleep(0.3)