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')