async def do_usec(minutes): tick = asyn.Event() print('Setting up GPS.') gps = await us_setup(tick) print('Waiting for time data.') await gps.ready() max_us = 0 min_us = 0 sd = 0 nsamples = 0 count = 0 terminate = asyn.Event() loop = asyncio.get_event_loop() loop.create_task(killer(terminate, minutes)) while not terminate.is_set(): await tick usecs = tick.value() tick.clear() err = 1000000 - usecs count += 1 print('Timing discrepancy is {:4d}μs {}'.format( err, '(skipped)' if count < 3 else '')) if count < 3: # Discard 1st two samples from statistics continue # as these can be unrepresentative max_us = max(max_us, err) min_us = min(min_us, err) sd += err * err nsamples += 1 # SD: apply Bessel's correction for infinite population sd = int(math.sqrt(sd / (nsamples - 1))) print( 'Timing discrepancy is: {:5d}μs max {:5d}μs min. Standard deviation {:4d}μs' .format(max_us, min_us, sd)) gps.close()
def __init__(self, mgr): self.pan = mgr.pan self.targetNodeId = None self.nodeOnlineEvent = asyn.Event() mgr.setPanCallback(self.onPanEvent) asyncio.create_task(self.loopTask()) # run a asyncio task log.info('App Starting')
def __init__(self, mgr, loop, pan): self.log = logging.getLogger("APP") self.log.setLevel(logging.DEBUG) self.pan = pan self.loop = loop self.targetNodeId = None self.nodeOnlineEvent = asyn.Event() mgr.setPanCallback(self.onPanEvent) self.loop.create_task(self.task()) # run a asyncio task self.log.info('App Starting')
async def run_ack(): loop = asyncio.get_event_loop() event = asyn.Event() ack1 = asyn.Event() ack2 = asyn.Event() count = 0 while True: loop.create_task(event_wait(event, ack1, 1)) loop.create_task(event_wait(event, ack2, 2)) event.set(count) count += 1 print('event was set') await ack1 ack1.clear() print('Cleared ack1') await ack2 ack2.clear() print('Cleared ack2') event.clear() print('Cleared event') await asyncio.sleep(1)
async def run_event_test(lp): print('Test Lock class') loop = asyncio.get_event_loop() lock = asyn.Lock() loop.create_task(run_lock(1, lock)) loop.create_task(run_lock(2, lock)) loop.create_task(run_lock(3, lock)) print('Test Event class') event = asyn.Event(lp) loop.create_task(eventset(event)) await eventwait(event) # run_event_test runs fast until this point print('Event status {}'.format('Incorrect' if event.is_set() else 'OK')) print('Tasks complete')
def __init__(self): self.p_red = Pin(env.PIN_NO_RED, Pin.OUT) self.p_green = Pin(env.PIN_NO_GREEN, Pin.OUT) self.p_blue = Pin(env.PIN_NO_BLUE, Pin.OUT) self.off() #p_red = PWM(Pin(env.PIN_NO_RED, Pin.OUT), freq=1000) #p_green = PWM(Pin(env.PIN_NO_GREEN, Pin.OUT), freq=1000) #p_blue = PWM(Pin(env.PIN_NO_BLUE, Pin.OUT), freq=1000) self.blinking_defs = {} self.blinking_def_id_sequence = 1 self.blinking_def_id = None self.event = asyn.Event() loop = asyncio.get_event_loop() loop.create_task(self.blinking_watcher())
async def do_drift(minutes): print('Setting up GPS.') gps = await setup() print('Waiting for time data.') await gps.ready() terminate = asyn.Event() loop = asyncio.get_event_loop() loop.create_task(killer(terminate, minutes)) print('Setting RTC.') await gps.set_rtc() print('Measuring drift.') change = await drift_test(terminate, gps) ush = int(60 * change / minutes) spa = int(ush * 365 * 24 / 1000000) print('Rate of change {}μs/hr {}secs/year'.format(ush, spa)) gps.close()
async def do_time(minutes): fstr = '{}ms Time: {:02d}:{:02d}:{:02d}:{:06d}' print('Setting up GPS.') gps = await setup() print('Waiting for time data.') await gps.ready() print('Setting RTC.') await gps.set_rtc() terminate = asyn.Event() loop = asyncio.get_event_loop() loop.create_task(killer(terminate, minutes)) while not terminate.is_set(): await asyncio.sleep(1) # In a precision app, get the time list without allocation: t = gps.get_t_split() print(fstr.format(gps.get_ms(), t[0], t[1], t[2], t[3])) gps.close()
self.maxLimitPin = Pin(maxLimitPinNo, Pin.IN) # self.minLimitPin = Pin(minLimitPinNo,Pin.IN) # N) self.maxLimitPin = Pin(maxLimitPinNo,Pin.IN) def minLimit(self): return self.minLimitPin.value() def maxLimit(self): return True # return self.maxLimitPin.value() if __name__ == '__main__': readOK = asyn.Event() async def hello(): while (True): tim = time.time() print("Mike %d " % tim) await asyncio.sleep(1) async def bounce(): while (True): print('bounce forward') asyncio.create_task(s1.move(1, 300)) print('wait') await asyncio.sleep(10) print('bounce stop') s1.stop()
import uasyncio as asyncio from config import * from checkconnection import check_connection from mqtt_helpers import * from basesensor import BaseSensor import builtins # Board specific modules from si7021sensor import SI7021sensor builtins.MESSAGES = {} builtins.debug = True builtins.CONFIG = {} builtins.loop = asyncio.get_event_loop() builtins.event = asyn.Event() list_of_instances = [] if init_config(): load_config(CONFIG) else: save_default_config() class Sensor01(BaseSensor, SI7021sensor): publish_state_to_mqtt = True def __init__(self): super(Sensor01, self).__init__() print('Sensor class 01')
uos.mount(sd, "/sd") break except: utime.sleep_ms(100) # create file exception.txt if it does not yet exist files = uos.listdir("/sd") if not 'exception.txt' in files: f = open('/sd/exception.txt', mode='wt', encoding='utf-8') f.close() # wrap the application in a global exception catcher try: loop = asyncio.get_event_loop(ioq_len=2) lock = asyn.Lock() event_new_pm_data = asyn.Event(PM_POLLING_DELAY_MS) event_mqtt_publish = asyn.Event() spec_sensors = SpecSensors() temp_hum = THSensor() ps = ParticulateSensor(lock, event_new_pm_data) display = Display() if modes[operating_mode].aq == 'periodic': interval_timer = IntervalTimer(event_mqtt_publish) if modes[operating_mode].logging == 1: sdcard_logger = SDCardLogger() mic = Microphone()