class JYMCU(object):
"""JY-MCU Bluetooth serial device driver. This is simply a light UART wrapper
with addition AT command methods to customize the device."""
def __init__(self, uart, baudrate):
""" uart = uart #1-6, baudrate must match what is set on the JY-MCU.
Needs to be a #1-C. """
self._uart = UART(uart, baudrate)
def __del__(self):
self._uart.deinit()
def any(self):
return self._uart.any()
def write(self, astring):
return self._uart.write(astring)
def writechar(self, achar):
self._uart.writechar(achar)
def read(self, num=None):
return self._uart.read(num)
def readline(self):
return self._uart.readline()
def readchar(self):
return self._uart.readchar()
def readall(self):
return self._uart.readall()
def readinto(self, buf, count=None):
return self._uart.readinto(buf, count)
def _cmd(self, cmd):
""" Send AT command, wait a bit then return result string. """
self._uart.write("AT+" + cmd)
udelay(500)
return self.readline()
def baudrate(self, rate):
""" Set the baud rate. Needs to be #1-C. """
return self._cmd("BAUD" + str(rate))
def name(self, name):
""" Set the name to show up on the connecting device. """
return self._cmd("NAME" + name)
def pin(self, pin):
""" Set the given 4 digit numeric pin. """
return self._cmd("PIN" + str(pin))
def version(self):
return self._cmd("VERSION")
def setrepl(self):
repl_uart(self._uart)
class uart_tmcl_interface(tmcl_interface, tmcl_host_interface):
def __init__(self, port=3, data_rate=9600, host_id=2, module_id=1, debug=False):
tmcl_interface.__init__(self, host_id, module_id, debug)
tmcl_host_interface.__init__(self, host_id, module_id, debug)
self.__uart = UART(port, data_rate)
self.__uart.init(baudrate=data_rate, bits=8, parity=None, stop=1, timeout=10000, timeout_char=10000)
def __enter__(self):
return self
def __exit__(self, exitType, value, traceback):
del exitType, value, traceback
self.close()
def close(self):
self.__uart.deinit()
return 0;
def data_available(self, hostID=None, moduleID=None):
del hostID, moduleID
return self.__uart.any()
def _send(self, hostID, moduleID, data):
del hostID, moduleID
self.__uart.write(data)
def _recv(self, hostID, moduleID):
del hostID, moduleID
read = self.__uart.read(9)
return read
def printInfo(self):
pass
def enableDebug(self, enable):
self._debug = enable
@staticmethod
def supportsTMCL():
return True
@staticmethod
def supportsCANopen():
return False
@staticmethod
def available_ports():
return set([2, 3, 4])
class cjmcu(object):
"""docstring for cjmcu"""
_CONTINUOUS = const(1)
_POLL = const(2)
_RATEBASE = 0x11
_BAUD9600 = const(0)
_BAUD19200 = const(1)
_BAUD38400 = const(2)
def __init__(self, aLoc):
super(cjmcu, self).__init__()
self._uart = UART(aLoc, 9600)
self._mode = _POLL
self._output = bytearray(4)
self._output[0] = 0x66
self._output[1] = 0x66
self._output[2] = self._mode
self._output[3] = 0x56
self._input = bytearray(9)
self.update()
def write(self):
'''write output buffer to board.'''
self._uart.write(self._output)
def read(self):
'''read into input buffer from board. Always 9 bytes.'''
self._uart.readinto(self._input)
def update(self):
'''Send command to prompt data output from board, then read data.
Note that this only needs to be done if board in in POLL mode.'''
self.write()
self.read()
def setbaud(self, aBaud):
'''Set baud rate on board then re-connect with new rate.'''
self._output[2] = _BAUDBASE + aBaud
self.update()
self._output[2] = self._mode
self._uart.deinit()
self._uart.init(9600 << aBaud)
def temps(self):
'''Return (ambient, object) temperatures in celcius.'''
v1 = (self._input[4] << 8) | self._input[5]
v2 = (self._input[6] << 8) | self._input[7]
return (v1 / 100.0, v2 / 100.0)
class JYMCU(object):
"""JY-MCU Bluetooth serial device driver. This is simply a light UART wrapper
with addition AT command methods to customize the device."""
def __init__( self, uart, baudrate ):
""" uart = uart #1-6, baudrate must match what is set on the JY-MCU.
Needs to be a #1-C. """
self._uart = UART(uart, baudrate)
def __del__( self ) : self._uart.deinit()
def any( self ) : return self._uart.any()
def write( self, astring ) : return self._uart.write(astring)
def writechar( self, achar ) : self._uart.writechar(achar)
def read( self, num = None ) : return self._uart.read(num)
def readline( self ) : return self._uart.readline()
def readchar( self ) : return self._uart.readchar()
def readall( self ) : return self._uart.readall()
def readinto( self, buf, count = None ) : return self._uart.readinto(buf, count)
def _cmd( self, cmd ) :
""" Send AT command, wait a bit then return result string. """
self._uart.write("AT+" + cmd)
udelay(500)
return self.readline()
def baudrate( self, rate ) :
""" Set the baud rate. Needs to be #1-C. """
return self._cmd("BAUD" + str(rate))
def name( self, name ) :
""" Set the name to show up on the connecting device. """
return self._cmd("NAME" + name)
def pin( self, pin ) :
""" Set the given 4 digit numeric pin. """
return self._cmd("PIN" + str(pin))
def version( self ) : return self._cmd("VERSION")
def setrepl( self ) : repl_uart(self._uart)
def ChangeLEDState(num_):
global leds
len_ = len(leds)
for i in range(0, len_):
if i != num_:
leds[i].off()
else:
leds[i].on()
while True:
u2.init(2400, bits=8, parity=None, stop=1)
pyb.delay(80)
Quality = 'DATA NULL'
if (u2.any() > 0):
u2.deinit()
_dataRead = u2.readall()
#R代表截取数据的起始位
R = _dataRead.find(b'\xaa')
#R>-1代表存在起始位，长度大于起始位位置+2
if R > -1 and len(_dataRead) > (R + 2):
P = _dataRead[R + 1]
L = _dataRead[R + 2]
#把串口收到的十六进制数据转换成十进制
SHI = P * 256 + L
SHUCHU = SHI / G * A
if (SHUCHU < 35):
Quality = 'Excellente'
print('环境质量:优', 'PM2.5=', SHUCHU)
count_ = 1
elif (35 < SHUCHU < 75):
class Terminal(IOBase):
def __init__(self,
columns,
rows,
uart_id,
background=BLUE,
foreground=YELLOW,
enable_cursor=True):
self.uart = UART(uart_id, 115200)
self.key_buffer = deque((), 10)
self.screen = Screen(columns, rows)
self.screen.dirty.clear()
self.screen_buffer = [[None] * columns for _ in range(rows)]
self.input_stream = Stream(self.screen)
self.lcd_device = LCD(rate=42000000)
self.lcd = self.lcd_device.initCh(color=foreground,
font='Amstrad_8',
scale=1)
self.foreground = foreground
self.background = background
self.lcd.fillMonocolor(background)
self.rows = rows
self.columns = columns
self.show_cursor = True
self.cursor_delay = 20
self.last_draw_cursor_time = time.ticks_ms()
self.last_cursor_x = 0
self.last_cursor_y = 0
self.draw_cursor_in_progress = False
self.enable_cursor = enable_cursor
def __del__(self):
self.close()
def read(self):
data = self.uart.read(11)
if data is not None:
if (len(data) == 11) and (data[0] == STX) and (
data[1] == 0x08) and (data[10] == ETX):
return self.input_byte_array(data[2:10])
else:
for i in range(0, len(data)):
if data[i] == STX:
report = data[i:len(data)] + self.uart.read(
11 - (len(data) - i))
if (len(report) == 11) and (report[0] == STX) and (
report[1] == 0x08) and (report[10] == ETX):
return self.input_byte_array(report[2:10])
def close(self):
self.uart.deinit()
def readinto(self, buf):
key_input = self.read()
if self.enable_cursor:
self.draw_cursor()
self._gcCollect()
if key_input is not None:
bytes_key_input = str.encode(key_input)
count = len(key_input)
for i in range(count):
self.key_buffer.append(bytes_key_input[i])
try:
buf[0] = self.key_buffer.popleft()
return 1
except:
return None
@micropython.viper
def _gcCollect(self):
gc.collect()
def show_cursor(self):
self.enable_cursor = True
def hide_cursor(self):
self.enable_cursor = False
def clear_screen(self):
self.screen.reset()
self.screen.dirty.clear()
self.last_cursor_x = 0
self.last_cursor_y = 0
self.lcd.fillMonocolor(self.background)
def write(self, buf):
try:
if self.screen.cursor.y == self.rows - 1:
self.clear_screen()
str_buf = str(buf, 'utf-8')
if str_buf == "\x1b[K":
self.clear_line(self.screen.cursor.x * 8,
self.screen.cursor.y * 8)
self.input_stream.feed(str_buf)
del str_buf
self.update_screen()
except:
pass
def set_color(self, background=BLUE, foreground=YELLOW):
self.background = background
if foreground != self.foreground:
self.lcd = self.lcd_device.initCh(color=foreground,
font='Amstrad_8',
scale=1)
self.foreground = foreground
self.clear_screen()
def clear_line(self, x, y):
self.lcd.drawHline(x, y, 320, self.background, 8)
def draw_text(
self,
text,
x,
y,
):
if text is None or text == ' ':
self.lcd.drawHline(x, y, 8, self.background, 8)
else:
count = len(text)
for i in range(count):
if text[i] != ' ':
if text[i] == 'i' or text[i] == 'l':
offset = 2
else:
offset = 0
# self.lcd.drawHline(x + i * 8, y, 8, self.background, 8)
self.lcd.printChar(text[i], x + i * 8 + offset, y)
def update_screen(self):
for dirty_row in self.screen.dirty:
for column in range(self.columns):
if self.screen_buffer[dirty_row][column] != self.screen.buffer[
dirty_row][column].data:
self.draw_text(self.screen.buffer[dirty_row][column],
column * 8 + 1, dirty_row * 8 + 1)
self.screen.dirty.clear()
for row in range(self.rows):
for column in range(self.columns):
self.screen_buffer[row][column] = self.screen.buffer[row][
column].data
@staticmethod
def decode_key_modifier(code):
key = ''
if (code & hid_key_left_meta) | (code & hid_key_right_meta):
key += "WIN-"
if (code & hid_key_left_control) | (code & hid_key_right_control):
key += "CTRL-"
if (code & hid_key_left_shift) | (code & hid_key_right_shift):
key += "SHIFT-"
if (code & hid_key_left_alt) | (code & hid_key_right_alt):
key += "ALT-"
if len(key) > 0:
key = key[:-1]
return key
@staticmethod
def decode_key_codes(codes):
key = ''
for code in codes:
if hid_key_code[code] is not None:
key += hid_key_code[code] + "-"
if len(key) > 0:
key = key[:-1]
return key
@staticmethod
def translate_code1(modifier, codes):
ascii_code = ''
shift = ""
if 'SHIFT' in modifier:
shift = 's'
if codes is not None and len(codes) > 0:
scan_codes = codes.split('-')
for scan_code in scan_codes:
if scan_code in key_code_ascii:
ascii_code += key_code_ascii[shift + scan_code]
if len(ascii_code) == 0:
return None
return ascii_code
@staticmethod
def translate_code(modifier, code):
shift = ""
if (modifier & hid_key_left_shift) | (modifier
& hid_key_right_shift) > 0:
shift = 's'
ascii_code = key_code_ascii[shift + hid_key_code[code]]
if len(ascii_code) == 0:
return None
return ascii_code
def input_byte_array(self, data):
report_modifier = memoryview(data)[0:1]
report_keys = memoryview(data)[2:3]
# modifier = self.decode_key_modifier(report_modifier[0])
# codes = self.decode_key_codes(report_keys)
if report_keys[0] != 0:
return self.translate_code(report_modifier[0], report_keys[0])
return None
def draw_cursor(self):
if not self.draw_cursor_in_progress:
self.draw_cursor_in_progress = True
delta = time.ticks_diff(time.ticks_ms(),
self.last_draw_cursor_time)
if delta > self.cursor_delay:
self._gcCollect()
self.last_draw_cursor_time = time.ticks_ms()
if self.show_cursor:
self.draw_text(
self.screen_buffer[self.screen.cursor.y]
[self.screen.cursor.x], self.screen.cursor.x * 8 + 1,
self.screen.cursor.y * 8 + 1)
self.show_cursor = False
else:
self.show_cursor = True
self.lcd.drawHline(self.screen.cursor.x * 8 + 1,
self.screen.cursor.y * 8 + 7, 8,
self.foreground, 1)
time.sleep_ms(100)
self.draw_text(
self.screen_buffer[self.screen.cursor.y]
[self.screen.cursor.x], self.screen.cursor.x * 8 + 1,
self.screen.cursor.y * 8 + 1)
self.draw_cursor_in_progress = False
uart0 = UART(0, 1000000)
uart1 = UART(1, 1000000)
# next ones must raise
try:
UART(0, 9600, parity=None, pins=('GP12', 'GP13', 'GP7'))
except Exception:
print('Exception')
try:
UART(0, 9600, parity=UART.ODD, pins=('GP12', 'GP7'))
except Exception:
print('Exception')
uart0 = UART(0, 1000000)
uart0.deinit()
try:
uart0.any()
except Exception:
print('Exception')
try:
uart0.read()
except Exception:
print('Exception')
try:
uart0.write('abc')
except Exception:
print('Exception')
uart0 = UART(0, 1000000)
uart1 = UART(1, 1000000)
# next ones must raise
try:
UART(0, 9600, parity=2, pins=('GP12', 'GP13', 'GP7'))
except Exception:
print('Exception')
try:
UART(0, 9600, parity=2, pins=('GP12', 'GP7'))
except Exception:
print('Exception')
uart0 = UART(0, 1000000)
uart0.deinit()
try:
uart0.any()
except Exception:
print('Exception')
try:
uart0.read()
except Exception:
print('Exception')
try:
uart0.write('abc')
except Exception:
print('Exception')
