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)
