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)
