def __init__(self, serial_id=2, baudrate=115200, **kwargs): """ id: used for topics id (negotiation) advertised_topics: manage already negotiated topics subscribing_topics: topics to which will be subscribed are here serial_id: uart id baudrate: baudrate used for serial comm """ self.id = 101 self.advertised_topics = dict() self.subscribing_topics = dict() self.serial_id = serial_id self.baudrate = baudrate if "serial" in kwargs: self.uart = kwargs.get("serial") elif "tx" in kwargs and "rx" in kwargs: self.uart = m.UART(self.serial_id, self.baudrate) self.uart.init( self.baudrate, tx=kwargs.get("tx"), rx=kwargs.get("rx"), bits=8, parity=None, stop=1, txbuf=0, ) else: self.uart = m.UART(self.serial_id, self.baudrate) self.uart.init(self.baudrate, bits=8, parity=None, stop=1, txbuf=0) if sys.platform == "esp32": threading.start_new_thread(self._listen, ()) else: threading.Thread(target=self._listen).start()
def main(): try: uos.dupterm(None, 1) # disable REPL on UART(0) uart = machine.UART(0) uart.init(115200, timeout=3000, bits=8, parity=None, stop=1, rxbuf=128) while True: if uart.any(): hostMsg = uart.readline() if hostMsg is not None: strMsg = hostMsg.decode().strip('\r\n') if '\x03' in strMsg: raise Exception('Cto repl') elif strMsg == '\x00': raise Exception('STOP code') else: for i in range(len(strMsg)): led.off() time.sleep(0.05) led.on() time.sleep(0.1) uart.write(strMsg+'\n') except Exception as err: uart.write('Exception was raised') led.on() finally: uos.dupterm(machine.UART(0, 115200), 1)
def uartspeed(newbaud): global uart command("AT+IPR=" + str(newbaud)) uart.deinit() if (newbaud==0): uart = machine.UART(uart_port, uart_default_baud, mode=UART.BINARY, timeout=uart_timeout) else: uart = machine.UART(uart_port, newbaud, mode=UART.BINARY, timeout=uart_timeout)
def main(): micropython.kbd_intr(-1) machine.UART(0, 9600).init( 9600) # 9600 baud rate recommended by LoLin NodeMcu board for line in sys.stdin: raw = line if not nic.isconnected(): led.on() if not network.STAT_CONNECTING: nic.connect('bloomu') else: led.off() if gprmcREG.match(raw): raw = raw.split(',') raw.pop(0) dateTime = raw[8] + raw[0] dateTime = dateTime.replace('.', '') locData = { "lat": raw[2] + raw[3], "long": raw[4] + raw[5], "speed": raw[6] } data = {dateTime: locData} urequests.patch(dataBaseURL, data=json.dumps(data), headers={"content-type": "application/json"}) data = {dateTime: raw} urequests.patch( "https://bloombus-163620.firebaseio.com/rawLog/.json", data=json.dumps(data), headers={"content-type": "application/json"})
def __init__(self, uart): self.uart = uart uart = machine.UART(1, baudrate=9600) utime.sleep_ms(100) self.buf = bytearray(2) self.t = 0
def __init__(self, port=8999): super().__init__(port=port, name='pymata') esp.uart_nostdio(1) self.gpio2 = machine.Pin(2) self.gpio2.init(machine.Pin.OUT) self.sport = machine.UART(0, 57600, timeout=0) self.reset()
def __init__(self, txPin=None, rxPin=None): self._ser = None self._serWrite = lambda x: x self._serRead = doNothing self._serAvailable = doNothing self.sleep = doNothing self._recvBuf = bytearray([]) if sys.platform.find("linux") >= 0: import serial self._ser = serial.Serial("/dev/ttyAMA0", 9600) self._serAvailable = self._ser.inWaiting self._serWrite = self._ser.write self._serRead = self._ser.read self.sleep = lambda t: time.sleep(t) self._ser.flushInput() elif sys.platform == "esp32": import machine import os self._os = os self._ser = machine.UART(1, baudrate=9600, rx=rxPin, tx=txPin) self._serAvailable = self._ser.any self._serWrite = self._ser.write self._serRead = self._ser.read self.sleep = lambda t: time.sleep(t) else: print("unsupport platform") exit()
def getFromUart(command): '''Write a command to the UART bus and return the result value. Accepted commands are: - `ATON`: turn relay on - `ATOFF`: turn relay off - `ATPRINT`: print status informations (every second) - `ATZERO`: reset energy consumption counter - `ATRESET`: reset any counter - `ATPOWER`: get actual power consumption - `ATREAD`: get actual current consumption - `ATSTATE`: get relay status (0/1) Since `uart.read()` is non-blocking, '\\n' is expected as terminating character.''' uart = machine.UART(1, baudrate=9600, rx=16, tx=17, timeout=10) uart.write(command) res = bytes() startTime = time.ticks_ms() # timeout for the loop below while b'\n' not in res: toAppend = uart.read() if toAppend: if res != b'': res += toAppend else: res = toAppend if time.ticks_diff(time.ticks_ms(), startTime) > READ_TIMEOUT: print('ERROR: read timeout') return b'ERROR: read timeout' res = res.decode('utf-8').replace('\n', '').encode() return res
def write_dev_value(self, addr, port, var_name, var_value): ser = 0 ret = 'unknow error' try: count = 0 while DynApp.serstat[port] != 0: utime.sleep_ms(200) count += 1 if count > 25: raise 'timeout' return "open serial timeout" ser = machine.UART(port, baudrate=self.baudrate) ser.init(self.baudrate, self.bytesize, self.parity, self.stopbits, self.timeout) if ser == 0: raise "open serial failed" else: DynApp.serstat[port] = 2 func = getattr(self, var_name, None) if func: ret = func(ser, addr, var_value) else: raise 'wrong data:%s' % var_name except Exception as e: ret = e.message # if ser != 0 and ser.isOpen(): # ser.deinit() DynApp.serstat[port] = 0 return ret
def read_dev_value(self, addr, port=2): ser = 0 try: count = 0 if port not in DynApp.serstat: DynApp.serstat[port] = 0 while DynApp.serstat[port] != 0: utime.sleep_ms(200) count += 1 if count > 25: raise 'timeout' return "open serial timeout" ser = machine.UART(port, baudrate=self.baudrate) ser.init(baudrate=self.baudrate, bits=self.bytesize, parity=self.parity, stop=self.stopbits, timeout=self.timeout) if ser == 0: raise "open serial failed" DynApp.serstat[port] = 1 value = self.read_device(addr, ser) if value is None or len(value) == 0: raise Exception("value is empty") except Exception as e: value = {'_status': 'offline', 'error': e} utime.sleep_ms(200) except DevError as e: value.update({'error': e.value}) utime.sleep_ms(200) # ser.deinit() DynApp.serstat[port] = 0 return value
def __init__(self, x=1, baudrate=9600, timeout=2, use_query_mode=True): """Initialise and open serial port. """ uart = machine.UART(x, baudrate) uart.init(baudrate, bits=8, parity=None, stop=1) self.uart = uart self.set_report_mode(active=not use_query_mode)
def test(N=50): adc = machine.ADC(0) pcd8544_test.showText(0, 0, 'Midiendo') time.sleep(1) pcd8544_test.clear() N = 50 uart = machine.UART(0, 9600) uart.init(9600) while True: media = 0 for i in range(0, N): value = adc.read() media += value * 1.0 time.sleep(0.1) value = media / N print(value) pcd8544_test.clear() pcd8544_test.showText(0, 0, str(value)) sys.stdout.write('<') msg = sys.stdin.readline().rstrip() if len(msg) < 1: msg = sys.stdin.readline().rstrip() pcd8544_test.showText(0, 10, msg) print(msg) try: v = float(msg) cte = v * 1023 / value pcd8544_test.showText(0, 40, str(cte)) print(cte) except Exception as e: print(str(e))
def __init__(self, rxpin=16, txpin=17): self.sensori = machine.UART(1) self.sensori.init(baudrate=9600, bits=8, parity=None, stop=1, rx=rxpin, tx=txpin) self.nollapiste_kalibroitu = False self.co2_arvo = 0 self.co2_keskiarvot = [] self.co2_keskiarvoja = 20 self.co2_keskiarvo = 0 self.sensori_aktivoitu_klo = utime.time() self.arvo_luettu_klo = utime.time() self.mittausvali = '0_5000' self.esilammitysaika = 10 # tulee olla 180 self.lukuvali = 10 # tulee olla 120 self.LUKU_KOMENTO = bytearray(b'\xFF\x01\x86\x00\x00\x00\x00\x00\x79') self.KALIBROI_NOLLAPISTE = bytearray( b'\xFF\x01\x87\x00\x00\x00\x00\x00\x78') self.KALIBROI_SPAN = bytearray(b'\xFF\x01\x88\x07\xD0\x00\x00\x00\xA0') self.ITSEKALIBROINTI_ON = bytearray( b'\xFF\x01\x79\xA0\x00\x00\x00\x00\xE6') self.ITSEKALIBTOINTI_OFF = bytearray( b'\xFF\x01\x79\x00\x00\x00\x00\x00\x86') self.MITTAUSVALI_0_2000PPM = bytearray( b'\xFF\x01\x99\x00\x00\x00\x07\xD0\x8F') self.MITTAUSVALI_0_5000PPM = bytearray( b'\xFF\x01\x99\x00\x00\x00\x13\x88\xCB') self.MITTAUSVALI_0_10000PPM = bytearray( b'\xFF\x01\x99\x00\x00\x00\x27\x10\x2F')
def esp_connect(): fm.register(board_info.WIFI_RX, fm.fpioa.UART2_TX) fm.register(board_info.WIFI_TX, fm.fpioa.UART2_RX) uart = machine.UART(machine.UART.UART2, 115200, timeout=1000, read_buf_len=4096) try: nic = network.ESP8285(uart) nic.connect(SSID, SSID_PWD) if (nic.isconnected): print("ip:{}/{}".format(nic.ifconfig()[0], nic.ifconfig()[1])) return True else: sleep(1) # retry if (nic.isconnected): print("ip:{}/{}".format(nic.ifconfig()[0], nic.ifconfig()[1])) return True else: print("network connection failed.\n") return False except: print(" try to connect ESP8286 TX to pin-{},RX to pin-{}".format( board_info.WIFI_TX, board_info.WIFI_RX)) print(" ,and ESP8286 must be runing on AT command mode.\n") return False
def open(self): if self.__isMicropython: port = self.port for sub in ( "/dev/ttyS", "/dev/ttyUSB", "/dev/ttyACM", "COM", "UART", ): port = port.replace(sub, "") try: self.__portNum = int(port.strip()) except ValueError: raise SerialException("Invalid port: %s" % self.port) try: import machine self.__lowlevel = machine.UART( self.__portNum, self.baudrate, self.bytesize, 0 if self.parity == PARITY_EVEN else 1, 1 if self.stopbits == STOPBITS_ONE else 2) print("Opened machine.UART(%d)" % self.__portNum) except Exception as e: raise SerialException("UART%d: Failed to open:\n%s" % (self.__portNum, str(e))) return raise NotImplementedError
def __init__(self, checkInterval=250, callback=None): self.checking = False self.sending = False self.uart = machine.UART(1, tx=32, rx=33) self.timer = machine.Timer(8457) self.callback = callback self.checkInterval = checkInterval
def __init__(self, id, password, contract_amperage, collect_date, *, progress_func=None, logger_name=__name__): global logger logger = logging.getLogger(logger_name) self.progress = progress_func if progress_func else lambda _: None self.uart = machine.UART(1, tx=0, rx=36) self.uart.init(115200, bits=8, parity=None, stop=1, timeout=2000) self.id = id self.password = password self.contract_amperage = int(contract_amperage) self.collect_date = int(collect_date) self.channel = None self.pan_id = None self.mac_addr = None self.lqi = None self.ipv6_addr = None self.power_coefficient = None self.power_unit = None self.timeout = 60
def UART(config): config = dict(config) port = config.pop('port') uart = machine.UART(port) uart.init(**config) #uart.init(921000, bits=8, parity=None, stop=1) return uart
def __init__(self, ble, name='TaxiMac'): self._name = name self._uart = machine.UART(1, 2400) #inicializar para UART 1 self._uart.init(baudrate=2400, bits=8, parity=None, stop=1, timeout=5000) self._cadena = [] self._ble = ble self._ble.active(True) self._ble.irq(handler=self._irq) (( self._tx, self._rx, ), ) = self._ble.gatts_register_services((_UART_SERVICE, )) print("tx: {}, rx:{}".format(self._tx, self._rx)) #((self._handle,),) = self._ble.gatts_register_services((_UART_SERVICE,)) self._connections = set() #self._payload = bytearray('\x02\x01\x02') + self.adv_encode_name('axelukan') self._payload = bytearray('\x02\x01\x02') + bytearray( (len(bytes(self._name, 'ascii')) + 1, 0x09)) + bytes( self._name, 'ascii') print("payload:{}".format(self._payload)) self._advertise()
def setup_serial(bus=0, baudrate=9600, bits=8): # os.dupterm(None) # Kill the REPL? logger.debug("Setting up serial") uart = machine.UART(bus, baudrate) uart.init(baudrate, bits=bits, parity=None, stop=1) logger.debug("Serial done") return uart
def __init__(self): self._gps_uart = machine.UART(1, 9600) self.cfg = ConfigRepository() self._gps_uart.init(tx=self.cfg.get("gps_uart_tx"), rx=self.cfg.get("gps_uart_rx")) self._gps = MicropyGPS() self._model = None
def selfTest(module_type): # CM # DM # test LED string(s) def read5VSupply(): supply5V = machine.ADC(3) conversion_factor = 3 * (3.3 / (65535)) # 5V supply into a divide-by-three resistive divider return (supply5V.read_u16() * conversion_factor) def getChar(): pass def putChar(port): pass from machine import UART, Pin import time uart1 = machine.UART(1, baudrate=9600, tx=Pin(8), rx=Pin(9)) uart0 = machine.UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1)) txData = b'hello world\n\r' uart1.write(txData) time.sleep(0.1) rxData = bytes() while uart0.any() > 0: rxData += uart0.read(1) print(rxData.decode('utf-8')) # # Main # # Determine if this is a Control Module or a Distribution Module by testing # whether it is running Python or MicroPython. # https://docs.micropython.org/en/latest/genrst/syntax.html try: ([i := -1 for i in range(4)]) module_type = "DM" # MicroPython
def __init__(self): import machine self.original_term = os.dupterm() os.dupterm(None) # disconnect the current serial port connection self.serial = machine.UART(0, 115200) self.poll = select.poll() self.poll.register(self.serial, select.POLLIN) self.write = self.serial.write
def __init__(self, device_no, tx_pin=None, rx_pin=None, timeout=None, *args, **kwargs): print("Creating logger") self.log = LogStub("Main.Nex.Protocol") if timeout is None: self.read_timeout = 0.1 # in milliseconds else: self.read_timeout = timeout assert self.read_timeout is not None self.init_args = { "baudrate": 9600, "bits": 8, "parity": None, "stop": 1, # UART takes timeout in milliseconds "timeout": int(self.read_timeout * 1000), "timeout_char": int(self.read_timeout * 1000), } if tx_pin: self.init_args["tx"] = tx_pin else: self.init_args["tx"] = 25 if rx_pin: self.init_args["rx"] = rx_pin else: self.init_args["rx"] = 26 print("Creating uart") self.uart = machine.UART( device_no, 9600, tx=self.init_args["tx"], rx=self.init_args["rx"], ) print("Configuring") print("uart init params:", self.init_args) self.uart.init(**self.init_args) self.probe_set_baud() print("Super call:", args, kwargs) super().__init__(*args, **kwargs)
def __init__(self): self.uart = machine.UART(1, tx=17, rx=16) self.uart.init(9600, bits=8, parity=None, stop=1) self.callback = None if self._reset() == 1: raise module.Module('Module lorawan not connect') self._timer = None self.uartString = '' time.sleep(2)
def connect(self): from fpioa_manager import fm import machine fm.register(35, fm.fpioa.UARTHS_RX, force=True) fm.register(34, fm.fpioa.UARTHS_TX, force=True) self.uart = machine.UART(machine.UART.UARTHS, 115200, 8, 0, 1, timeout=1000, read_buf_len=4096) self.uart.init() self.timer.start() return self.uart
def __init__(self, uartChannel, txPin, rxPin, timer=4, freq=5): self.txPin = txPin self.rxPin = rxPin self.uart = machine.UART(uartChannel) self.txTimer = timer self.connected = False self.payload = bytearray([]) self.freq = freq self.oldbuffer = bytes([])
def talktopico(msg, timeout=5000): try: uos.dupterm(None, 1) # disable REPL on UART(0) uart = machine.UART(0) uart.init(230400, timeout=3000, bits=8, parity=None, stop=1, rxbuf=128 * 16) uart.write('\n\n') # while uart.any(): uart.read() uart.write(msg) yield from read_response(uart) except Exception as err: yield str(err) finally: uos.dupterm(machine.UART(0, 115200), 1)
def init_uart(): uart = machine.UART(2, baudrate=9600, rx=16, tx=17, timeout=10, bits=8, parity=None, stop=1) return uart
def start(): uart = machine.UART(1, tx=25, rx=26, baudrate=9600) global pm pm = pms5003.PMS5003(uart, lock, active_mode=False, interval_passive_mode=60) pms5003.set_debug(True) pm.registerCallback(printit) asyncio.create_task(testing()) asyncio.get_event_loop().run_forever()