def init(self): if self.is_configured: return # if failed to configure - probably a different scanner # in this case fallback to PIN trigger mode FIXME self.clean_uart() self.is_configured = self.configure() if self.is_configured: print("Scanner: automatic mode") return # Try one more time with different baudrate self.uart = pyb.UART(self.uart_bus, 115200, read_buf_len=2048) self.clean_uart() self.is_configured = self.configure() if self.is_configured: print("Scanner: automatic mode") return # PIN trigger mode self.uart = pyb.UART(self.uart_bus, 9600, read_buf_len=2048) self.trigger = pyb.Pin(QRSCANNER_TRIGGER, pyb.Pin.OUT) self.trigger.on() self.is_configured = True print("Scanner: Pin trigger mode")
def test(duration): if rtc_time.use_utime: # Not running in low power mode pyb.LED(3).on() uart2 = pyb.UART(2, 9600) uart4 = pyb.UART(4, 115200) # Instantiate event loop before using it in Latency class loop = asyncio.get_event_loop() lp = rtc_time.Latency(50) # ms loop.create_task(sender(uart4)) loop.create_task(receiver(uart4, uart2)) loop.run_until_complete(killer(duration))
def __init__(self, pins, positionTask): self.position = positionTask #self.sensorOffset = array.array('f', [ -45 , -45 , 45 , 45 ] ) # Angle of each sensor wrt servo [deg] self.sensorOffset = array.array( 'f', [45]) # Angle of each sensor wrt servo [deg] self.servo = servo.Servo(1, offset=0) self.angles = array.array( 'f', [-90, 90, 15]) # start angle, max angle, inc angle #self.angles = array.array('f', [0, 0, 15] ) # start angle, max angle, inc angle self.servoWait = 200 # ms of wait time for servo to reach new angle # Create rangeFinder driver objects self.rangeFinders = [ #rangeFinder.RangeFinder( pins["Rangefinder 4"] , [0, 0, 0] ), # Top Left #rangeFinder.RangeFinder( pins["Rangefinder 3"] , [0, 55, -2]), # Bottom Left #rangeFinder.RangeFinder( pins["Rangefinder 2"] , [0, 0, 0] ), # Top Right rangeFinder.RangeFinder(pins["Rangefinder 3"], [7, 50.0, -1.97]) # Bottom Right ] self.servo.setAngle(self.angles[0]) self.runTime = pyb.millis() + self.servoWait self.bluetooth = pyb.UART(2, 9600) self.bluetooth.init(9600, bits=8, parity=None, stop=1) return
def test_7(self): self.uart = pyb.UART(0) self.uart.init(9600, bits=8, parity=None, stop=1, timeout=100, timeout_char=0, read_buf_len=32, packet_mode=True) self.uart.write("Test string") to = 400 while to > 0: if self.uart.any(): break pyb.delay(1) to -= 1 self.assertNotEqual(0, to, "any() method in packet mode") data = self.uart.readall() self.assertEqual(11, len(data), "Amount of received bytes packet mode") self.assertEqual(bytearray("Test string"), data, "Content comparison")
async def log_kml(fn='/sd/log.kml', interval=10): yellow.on() # Waiting for data uart = pyb.UART(4, 9600, read_buf_len=200) # Data on X2 sreader = asyncio.StreamReader(uart) gps = as_GPS.AS_GPS(sreader, fix_cb=toggle_led) await gps.data_received(True, True, True, True) yellow.off() with open(fn, 'w') as f: f.write(str_start) while not sw.value(): f.write(gps.longitude_string(as_GPS.KML)) f.write(',') f.write(gps.latitude_string(as_GPS.KML)) f.write(',') f.write(str(gps.altitude)) f.write('\r\n') blue.toggle() for _ in range(interval * 10): await asyncio.sleep_ms(100) if sw.value(): break f.write(str_end) red.off() green.on()
def __init__(self, channel=1, baud=4800, UART_object=None, debug=False): if UART_object is not None: self.UART = UART_object else: self.UART = pyb.UART(channel, baud) self.debug = debug
def __init__(self, path, trigger=None, uart="YA", baudrate=9600): super().__init__(path) # default settings, extend it with more settings if applicable self.settings = { "enabled": True, "aim": True, "light": False, "sound": True, } if simulator: self.EOL = b"\r\n" else: self.EOL = b"\r" self.f = None self.uart_bus = uart self.uart = pyb.UART(uart, baudrate, read_buf_len=2048) if simulator: print("Connect to 127.0.0.1:22849 to send QR code content") self.trigger = None self.is_configured = False if trigger is not None or simulator: self.trigger = pyb.Pin(trigger, pyb.Pin.OUT) self.trigger.on() self.is_configured = True self.scanning = False self.parts = None
def int_uart(): pa_moder[PA_RXD] = 0 # Input pa_pupdr[PA_RXD] = 1 # Pull-up resistor print("Before setup...") dump(regs_uart_int) uart4 = pyb.UART(4) uart4.init(4800, 8, None, 1, timeout=100, timeout_char=100) print("After setup...") dump(regs_uart_int) while True: message = input("Type a string to send: ") if not message: break uart4.write(message.encode()) line = uart4.read() if not line: print("-- TIMEOUT --") else: print(line.decode()) print() print("After usage...") dump(regs_uart_int)
async def gps_test(): global gps, uart # For shutdown print('Initialising') # Adapt UART instantiation for other MicroPython hardware uart = pyb.UART(4, 9600, read_buf_len=200) # read_buf_len is precautionary: code runs reliably without it. sreader = asyncio.StreamReader(uart) swriter = asyncio.StreamWriter(uart, {}) timer = aswitch.Delay_ms(cb_timeout) sentence_count = 0 gps = as_rwGPS.GPS(sreader, swriter, local_offset=1, fix_cb=callback, fix_cb_args=(timer,), msg_cb = message_cb) await asyncio.sleep(2) await gps.command(as_rwGPS.DEFAULT_SENTENCES) print('Set sentence frequencies to default') #await gps.command(as_rwGPS.FULL_COLD_START) #print('Performed FULL_COLD_START') print('awaiting first fix') loop = asyncio.get_event_loop() loop.create_task(sat_test(gps)) loop.create_task(stats(gps)) loop.create_task(navigation(gps)) loop.create_task(course(gps)) loop.create_task(date(gps)) await gps.data_received(True, True, True, True) # all messages loop.create_task(change_status(gps, uart))
def main(): import pyb # Cycle Power pyb.Pin.board.EN_3V3.off() pyb.delay(1000) pyb.Pin.board.EN_3V3.on() pyb.delay(500) # Create device pyb.Pin('Y5', pyb.Pin.OUT, value=0) # enable Y5 Pin as output max3221e = MAX3221E(pyb.Pin.board.Y5) uart = pyb.UART(1, 9600, bits=8, parity=None, stop=1, timeout=1000) # Power up Tx Driver max3221e.tx_force_on() cmd_string = '$?' cmd_bytes = cmd_string.encode('utf-8') uart.write(cmd_bytes) # Power down Tx Driver max3221e.tx_force_off() # Receive and process resp_bytes = uart.read(20) if resp_bytes: print(resp_bytes.decode('utf-8')) print("====Ends====")
def init_uart(self, uart_bus, baud_rate, update_rate): self.uart = pyb.UART(uart_bus, baud_rate, read_buf_len=1000) pyb.delay(50) # get RMC and GGA sentences at 1 hz if update_rate == 1: self.send_command(PMTK_SET_NMEA_OUTPUT_RMCGGA) self.send_command(PMTK_SET_NMEA_UPDATE_1HZ) self.send_command(PMTK_API_SET_FIX_CTL_1HZ) elif update_rate == 5: # get RMC and GGA sentences at 5 hz self.send_command(PMTK_SET_NMEA_OUTPUT_RMCGGA) self.send_command(PMTK_SET_NMEA_UPDATE_5HZ) self.send_command(PMTK_API_SET_FIX_CTL_5HZ) elif update_rate == 10: if baud_rate == 9600: # send less data if using slower baud rate self.send_command(PMTK_SET_NMEA_OUTPUT_RMCONLY) elif baud_rate == 57600: self.send_command(PMTK_SET_NMEA_OUTPUT_RMCGGA) else: raise ValueError("Invalid baud rate:", baud_rate) self.send_command(PMTK_SET_NMEA_UPDATE_10HZ) # fix can't update at 10 hz self.send_command(PMTK_API_SET_FIX_CTL_5HZ) else: raise ValueError("Invalid update rate:", update_rate)
def test_1(self): flagOk = False try: uart = pyb.UART(0) flagOk = True except: pass self.assertEqual(True, flagOk, "Create Object OK")
def test_2(self): flagOk = False try: uart = pyb.UART(99) flagOk = True except: pass self.assertEqual(False, flagOk, "Create Object Invalid uart number")
def init_tty(device, baud): import pyb Editor.sdev = device if Editor.sdev: Editor.serialcomm = pyb.UART(device, baud) else: Editor.serialcomm = pyb.USB_VCP() Editor.serialcomm.setinterrupt(-1)
async def setup(): print('Initialising') uart = pyb.UART(4, 9600) sreader = asyncio.StreamReader(uart) swriter = asyncio.StreamWriter(uart, {}) gps = as_rwGPS.GPS(sreader, swriter, local_offset=1) await asyncio.sleep(2) await gps.baudrate(BAUDRATE) uart.init(BAUDRATE)
def test_4(self): flagOk = False try: uart = pyb.UART(0) uart.init(9600, bits=8, parity=None, stop=99) flagOk = True except: pass self.assertEqual(False, flagOk, "Create Object Invalid Stop bits")
def init(): if False: uart = pyb.UART(6,115200) pyb.repl_uart(uart) print("REPL is also on UART 6 (Y1=Tx Y2=Rx)") if True: bufsize = 100 print("Setting alloc_emergency_exception_buf to", bufsize) micropython.alloc_emergency_exception_buf(bufsize)
def __init__(self): self.seconds = 0 self.tmp36 = TMP36('Y12') self.sht31d = SHT31D(bus=1, address=0x44) self.tmp36_ref = self.tmp36.get_temperature self.sht31d_ref = self.sht31d.get_temperature self.get_temp_ref = self.get_temperature self.serial = pyb.UART(1, 115200) self.serial.init(9600, bits=8, parity=None, stop=1) self.strf_format = '{:02d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}'
def set_uart(self): if 'Uart' in self.config: self.uart_bus = dfl.UARTS[dfl.DEVS.index( self.name)] if self.name in dfl.DEVS else dfl.UARTS[ cfg.DEVS.index(self.name)] try: self.uart = pyb.UART(self.uart_bus, int(self.config['Uart']['Baudrate'])) except Exception as err: log(self.__qualname__, type(err).__name__, err, type='e')
async def setup(): red = pyb.LED(1) green = pyb.LED(2) uart = pyb.UART(UART_ID, 9600, read_buf_len=200) sreader = asyncio.StreamReader(uart) pps_pin = pyb.Pin(PPS_PIN, pyb.Pin.IN) return GPS_Timer(sreader, pps_pin, local_offset=1, fix_cb=lambda *_: red.toggle(), pps_cb=lambda *_: green.toggle())
def outputthread(outbuf, test=False): if test: outputserial = None else: outputserial = pyb.UART(6, 115200) if upower.vbat() < 2.0: outbuf.write(ERR('Low Backup Battery').msg) while True: yield 0.1 outbuf.print(outputserial)
def open(self): """Open a (previously initialized) port on dummy_serial.""" if VERBOSE: _print_out('\nDummy_serial: Opening port\n') if self._isOpen: raise IOError('Dummy_serial: The port is already open') self._isOpen = True self.port = self.initial_port_name self.ser = pyb.UART(self.port, self.baudrate)
def __init__(self, uartno): # pos =1 or 2 depending on skin position self._uart = pyb.UART(uartno, 9600, read_buf_len=2048) self.incoming_action = None self.no_carrier_action = None self.clip_action = None self._clip = None self.msg_action = None self._msgid = 0 self.savbuf = None self.credit = '' self.credit_action = None
async def us_setup(tick): red = pyb.LED(1) yellow = pyb.LED(3) uart = pyb.UART(UART_ID, 9600, read_buf_len=200) sreader = asyncio.StreamReader(uart) pps_pin = pyb.Pin(PPS_PIN, pyb.Pin.IN) return GPS_Timer(sreader, pps_pin, local_offset=1, fix_cb=lambda *_: red.toggle(), pps_cb=us_cb, pps_cb_args=(tick, yellow))
def get_uart(): global _uart if not _uart: _uart = pyb.UART(6, baudrate=230400, read_buf_len=4096, bits=8, parity=None, stop=1, timeout=200, timeout_char=200) return _uart
def __init__(self, com): #self.repl = pyb.USB_VCP() self.uart = pyb.UART(com, 9600,bits=8, parity=None, stop=1,read_buf_len=15024,timeout=10) # ,bits=8, parity=None, stop=1,read_buf_len=64 #self.pin = pyb.Pin('X18', pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE) #self.pin.low() self.data=None self.read_n='DATA' self.msgss=None #self.word='' tr1 = Thread(target=self.download)#, args=(self.data) tr1.start()
def __init__(self, trigger="D5", uart="YA", baudrate=9600): if simulator: self.EOL = "\r\n" else: self.EOL = "\r" self.trigger = pyb.Pin(trigger, pyb.Pin.OUT) self.trigger.on() self.uart = pyb.UART(uart, baudrate, read_buf_len=1024) self.uart.read(self.uart.any()) self.scanning = False self.t0 = None self.callback = None
def DebugUART(n): u = pyb.UART(n) u.init(115200, read_buf_len=128) n = 0 cb = 0 while True: cb = u.any() if cb != 0: print("Got " + str(cb) + " data:" + str(u.read(cb))) pyb.delay(50) print(n) n += 1
def test_6(self): self.uart = pyb.UART(0) self.uart.init(9600, bits=8, parity=None, stop=1) self.uart.write("A") pyb.delay(150) any = self.uart.any() self.assertEqual(True, any, "any() method in char mode") data = self.uart.readall() self.assertEqual(0x41, data[0], "Received character") self.uart = None
def seatalkthread(out_buff): stream = pyb.UART(4, 4800, bits=9) yield 0.5 st = Seatalk(stream) #, out_buff.log['daily']) wf = Poller(st.Poll, (4, ), 5) while True: reason = (yield wf()) if reason[1]: st.update(out_buff) #out_buff.write(st.output) #st.output = [] if reason[2]: out_buff.write(ERR('ST DATA TIMEOUT').msg)