Python UART.readall方法代码示例

# 需要导入模块: from pyb import UART [as 别名]
# 或者: from pyb.UART import readall [as 别名]
class WIFI:
  """docstring for wifi"""

  def __init__(self, uart, baudrate = 115200):
    """ uart = uart #1-6, baudrate must match what is set on the ESP8266. """
    self._uart = UART(uart, baudrate)

  def write( self, aMsg ) :
    self._uart.write(aMsg)
    res = self._uart.readall()
    if res:
      print(res.decode("utf-8"))

  def read( self ) : return self._uart.readall().decode("utf-8")

  def _cmd( self, cmd ) :
    """ Send AT command, wait a bit then return results. """
    self._uart.write("AT+" + cmd + "\r\n")
    udelay(500)
    return self.read()

  @property
  def IP(self): return self._cmd("CIFSR")

  @property
  def networks( self ) : return self._cmd("CWLAP")

  @property
  def baudrate(self): return self._cmd("CIOBAUD?")

  @baudrate.setter
  def baudrate(self, value): return self._cmd("CIOBAUD=" + str(value))

  @property
  def mode(self): return self._cmd("CWMODE?")

  @mode.setter
  def mode(self, value): self._cmd("CWMODE=" + str(value))

  def connect( self, ssid, password = "" ) :
    """ Connect to the given network ssid with the given password """
    constr = "CWJAP=\"" + ssid + "\",\"" + password + "\""
    return self._cmd(constr)

  def disconnect( self ) : return self._cmd("CWQAP")

  def reset( self ) : return self._cmd("RST")

# 需要导入模块: from pyb import UART [as 别名]
# 或者: from pyb.UART import readall [as 别名]
class ESP8266(object):

    def __init__(self):
        self.uart = UART(6, 115200)
    
    def write(self, command):
        self.uart.write(command)
        count = 5
        while count >= 0:
            if self.uart.any():
                print(self.uart.readall().decode('utf-8'))
            time.sleep(0.1)
            count-=1

# 需要导入模块: from pyb import UART [as 别名]
# 或者: from pyb.UART import readall [as 别名]
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)

# 需要导入模块: from pyb import UART [as 别名]
# 或者: from pyb.UART import readall [as 别名]
class BLE:
    BLE_NONE=0
    BLE_SHIELD=1

    def command(self, cmd):
        if self.type==self.BLE_SHIELD:
            self.uart.write(cmd)
            self.uart.write("\r\n")
            r=self.uart.read(9)
            if r[0]!=82: raise OSError("Response corrupted!")
            if r[1]==49: raise OSError("Command failed!")
            if r[1]==50: raise OSError("Parse error!")
            if r[1]==51: raise OSError("Unknown command!")
            if r[1]==52: raise OSError("Too few args!")
            if r[1]==53: raise OSError("Too many args!")
            if r[1]==54: raise OSError("Unknown variable or option!")
            if r[1]==55: raise OSError("Invalid argument!")
            if r[1]==56: raise OSError("Timeout!")
            if r[1]==57: raise OSError("Security mismatch!")
            if r[1]!=48: raise OSError("Response corrupted!")
            for i in range(2,6):
                if r[i]<48 or 57<r[i]: raise OSError("Response corrupted!")
            if r[7]!=13 or r[8]!=10: raise OSError("Response corrupted!")
            l=((r[2]-48)*10000)+\
              ((r[3]-48)*1000)+\
              ((r[4]-48)*100)+\
              ((r[5]-48)*10)+\
              ((r[6]-48)*1)
            if not l: return None
            if l==1 or l==2: raise OSError("Response corrupted!")
            response=self.uart.read(l-2)
            if self.uart.readchar()!=13: raise OSError("Response corrupted!")
            if self.uart.readchar()!=10: raise OSError("Response corrupted!")
            return response

    def deinit(self):
        if self.type==self.BLE_SHIELD:
            self.uart.deinit()
            self.rst=None
            self.uart=None
            self.type=self.BLE_NONE

    def init(self, type=BLE_SHIELD):
        self.deinit()
        if type==self.BLE_SHIELD:
            self.rst=Pin("P7",Pin.OUT_OD,Pin.PULL_NONE)
            self.uart=UART(3,115200,timeout_char=1000)
            self.type=self.BLE_SHIELD
            self.rst.low()
            sleep(100)
            self.rst.high()
            sleep(100)
            self.uart.write("set sy c m machine\r\nsave\r\nreboot\r\n")
            sleep(1000)
            self.uart.readall() # clear

    def uart(self):
        if self.type==self.BLE_SHIELD: return self.uart

    def type(self):
        if self.type==self.BLE_SHIELD: return self.BLE_SHIELD

    def __init__(self):
        self.rst=None
        self.uart=None
        self.type=self.BLE_NONE

# 需要导入模块: from pyb import UART [as 别名]
# 或者: from pyb.UART import readall [as 别名]
buf = bytearray(3)
print(uart1.readinto(buf, 1) == 1) 
print(buf)
print(uart1.readinto(buf) == 2)
print(buf)

# try initializing without the id
uart0 = UART(baudrate=1000000, pins=uart_pins[0][0])
uart0.write(b'1234567890')
pyb.delay(2) # because of the fifo interrupt levels
print(uart1.any() == 10)
print(uart1.readline() == b'1234567890')
print(uart1.any() == 0)

uart0.write(b'1234567890')
print(uart1.readall() == b'1234567890')

# tx only mode
uart0 = UART(0, 1000000, pins=('GP12', None))
print(uart0.write(b'123456') == 6)
print(uart1.read() == b'123456')
print(uart1.write(b'123') == 3)
print(uart0.read() == b'')

# rx only mode
uart0 = UART(0, 1000000, pins=(None, 'GP13'))
print(uart0.write(b'123456') == 6)
print(uart1.read() == b'')
print(uart1.write(b'123') == 3)
print(uart0.read() == b'123')