def start(mqtt_link):
global reset_count
mqtt_link.subscribe('green', qos, cbgreen) # LED control qos 1
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(ramcheck, mqtt_link)()) # Check RAM every 30 minutes
loop.create_task(asyn.Cancellable(publish, mqtt_link, 10)()) # Publish a count every 10 seconds
loop.create_task(pulse(blue)) # Flash blue LED each time we restart ESP8266
reset_count += 1
async def start(self, loop):
loop.create_task(asyn.Cancellable(
self.foo, 1)()) # 3 instances in default group 0
loop.create_task(asyn.Cancellable(self.foo, 2)())
loop.create_task(asyn.Cancellable(self.foo, 3)())
loop.create_task(asyn.NamedTask('my bar', self.bar, 4, y=42)())
await asyncio.sleep(4.5)
await asyn.NamedTask.cancel('my bar')
await asyn.Cancellable.cancel_all()
await asyncio.sleep(1)
print('Done')
async def start(self, loop):
loop.create_task(asyn.Cancellable(self.foo, 1)()) # 3 instances in default group 0
loop.create_task(asyn.Cancellable(self.foo, 2)())
loop.create_task(asyn.Cancellable(self.foo, 3)())
loop.create_task(asyn.NamedTask('my bar', self.bar, 4)())
print('bar running status is', asyn.NamedTask.is_running('my bar'))
await asyncio.sleep(4.5)
asyn.NamedTask.cancel('my bar')
print('bar instance scheduled for cancellation.')
await asyn.Cancellable.cancel_all()
print('foo instances have been cancelled.')
print('bar running status is', asyn.NamedTask.is_running('my bar'))
print('Done')
async def cond_go(loop):
ntasks = 7
barrier = asyn.Barrier(ntasks + 1)
loop.create_task(asyn.Cancellable(cond01)())
loop.create_task(asyn.Cancellable(cond03)())
for n in range(ntasks):
loop.create_task(cond02(n, barrier))
await barrier # All instances of cond02 have completed
# Test wait_for
barrier = asyn.Barrier(2)
loop.create_task(cond04(99, barrier))
await barrier
# cancel continuously running coros.
await asyn.Cancellable.cancel_all()
print('Done.')
async def run_cancel_test(loop):
res = await asyn.Cancellable(add_one, 41)
print('Result: ', res)
loop.create_task(asyn.Cancellable(print_nums, res)())
await asyn.sleep(7.5)
# Cancel any cancellable tasks still running
await asyn.Cancellable.cancel_all()
print('Done')
async def main(loop):
print('Press Pyboard usr button to stop test.')
bar = asyn.Barrier(4, refresh, (ssd,))
# Asynchronously flash Pyboard LED's. Because we can.
loop.create_task(asyn.Cancellable(flash, 1, 200)())
loop.create_task(asyn.Cancellable(flash, 2, 233)())
# Task for each meter and GUI LED
loop.create_task(asyn.Cancellable(meter, bar, 2, 'left')())
loop.create_task(asyn.Cancellable(meter, bar, 50, 'right')())
loop.create_task(asyn.Cancellable(meter, bar, 98, 'bass')())
try:
while True:
await asyncio.sleep_ms(800)
# If necessary wait until all meters have updated.
# Barrier callback updates display.
await bar
except asyn.StopTask:
ssd.fill(0) # Clear display at end.
refresh(ssd)
async def run_cancel_test4():
await asyn.Cancellable(cant41, 0, 5)
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(cant40,
1)()) # 3 instances in default group 0
loop.create_task(asyn.Cancellable(cant40, 2)())
loop.create_task(asyn.Cancellable(cant40, 3)())
loop.create_task(
asyn.Cancellable(chained, 4, 1, 2, red=3, blue=4, group=1)())
loop.create_task(asyn.Cancellable(cant41, 5)()) # Runs to completion
print('Running tasks')
await asyncio.sleep(3)
print('About to cancel group 0 tasks')
await asyn.Cancellable.cancel_all() # All in default group 0
print('Group 0 tasks were cancelled')
await asyncio.sleep(1) # Demo chained still running
print('About to cancel group 1 tasks')
await asyn.Cancellable.cancel_all(1) # Group 1
print('Group 1 tasks were cancelled')
await asyncio.sleep(1)
async def action_handler(self, action: str, *args, **kwargs):
""" Run specified action after cancelled previous
"""
if action in ['front', 'tail', 'blink_tail']:
getattr(self.lights, action)(*args, **kwargs)
return
await self.lights.rgb_cancel()
if action != 'cancel':
asyncio.get_event_loop().create_task(
asyn.Cancellable(getattr(self.lights, 'rgb_' + action), *args,
**kwargs)())
async def run_cancel_test6(loop):
for name in ('complete', 'cancel me'):
loop.create_task(asyn.NamedTask(name, cant60, name)())
loop.create_task(asyn.Cancellable(cant61)())
await asyncio.sleep(4.5)
print('Cancelling task \"{}\". 1.5 secs latency.'.format(name))
await asyn.NamedTask.cancel(name)
await asyncio.sleep(7)
name = 'cancel wait'
loop.create_task(asyn.NamedTask(name, cant60, name)())
await asyncio.sleep(0.5)
print('Cancelling task \"{}\". 1.5 secs latency.'.format(name))
t = time.ticks_ms()
await asyn.NamedTask.cancel('cancel wait', nowait=False)
print('Was cancelled in {} ms'.format(time.ticks_diff(time.ticks_ms(), t)))
print('Cancelling cant61')
await asyn.Cancellable.cancel_all()
print('Done')
@asyn.cancellable
async def main(loop):
print('Press Pyboard usr button to stop test.')
bar = asyn.Barrier(4, refresh, (ssd,))
# Asynchronously flash Pyboard LED's. Because we can.
loop.create_task(asyn.Cancellable(flash, 1, 200)())
loop.create_task(asyn.Cancellable(flash, 2, 233)())
# Task for each meter and GUI LED
loop.create_task(asyn.Cancellable(meter, bar, 2, 'left')())
loop.create_task(asyn.Cancellable(meter, bar, 50, 'right')())
loop.create_task(asyn.Cancellable(meter, bar, 98, 'bass')())
try:
while True:
await asyncio.sleep_ms(800)
# If necessary wait until all meters have updated.
# Barrier callback updates display.
await bar
except asyn.StopTask:
ssd.fill(0) # Clear display at end.
refresh(ssd)
async def killer():
sw = pyb.Switch()
while not sw():
await asyncio.sleep_ms(100)
await asyn.Cancellable.cancel_all()
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(main, loop)())
loop.run_until_complete(killer())
l.text(txt(v), fgcolor=color(v))
refresh(ssd)
await asyncio.sleep_ms(t)
@asyn.cancellable
async def flash(n, t):
led = pyb.LED(n)
try:
while True:
led.toggle()
await asyncio.sleep_ms(t)
except asyn.StopTask:
led.off()
print('LED {} was cancelled.'.format(n))
async def killer():
sw = pyb.Switch()
while not sw():
await asyncio.sleep_ms(100)
await asyn.Cancellable.cancel_all()
print('Press Pyboard usr button to stop test.')
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(meter, 1, 2, 'left', 700)())
loop.create_task(asyn.Cancellable(meter, 2, 50, 'right', 1000)())
loop.create_task(asyn.Cancellable(meter, 3, 98, 'bass', 1500)())
loop.create_task(asyn.Cancellable(flash, 1, 200)())
loop.create_task(asyn.Cancellable(flash, 2, 233)())
loop.run_until_complete(killer())
def start(mqtt_link):
mqtt_link.subscribe('green', qos, cbgreen) # LED control qos 1
mqtt_link.wifi_handler(cbnet) # Detect WiFi changes
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(
publish, mqtt_link, 10)()) # Publish a count every 10 seconds
async def start(self, channel):
self.vbprint('Starting...')
self.subs = {} # Callbacks indexed by topic
self._pub_free = True # No publication in progress
self._running = False
if self.lw_topic is not None:
channel.send(argformat(WILL, self.lw_topic, self.lw_msg, self.lw_retain, self.lw_qos))
res = await channel.await_obj()
if res is None: # SynCom timeout
await self.s_han(self, ESP_FAIL)
return self.quit('ESP8266 fail 1. Resetting.')
command, action = self.get_cmd(res)
if command == STATUS:
iact = self.do_status(action, -1)
await self.s_han(self, iact)
if iact in _BAD_STATUS:
return self.quit('Bad status: {}. Resetting.'.format(iact))
else:
self.vbprint('Expected will OK got: ', command, action)
channel.send(self.init_str)
while not self._running: # Until RUNNING status received
res = await channel.await_obj()
if res is None:
await self.s_han(self, ESP_FAIL)
return self.quit('ESP8266 fail 2. Resetting.')
command, action = self.get_cmd(res)
if command == STATUS:
iact = self.do_status(action, -1)
result = await self.s_han(self, iact)
if iact == SPECNET:
if result == 1:
channel.send('1') # Any string will do
else:
return self.quit()
if iact in _BAD_STATUS:
return self.quit('Bad status. Resetting.')
else:
self.vbprint('Init got: ', command, action)
self.vbprint('About to run user program.')
if self.user_start is not None:
self.user_start[0](self, *self.user_start[1]) # User start function
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(self._publish)())
self.rtc_synchroniser._start() # Run coro if synchronisation is required.
cb, args = self.wifi_han
cb(True, *args)
# Initialisation is complete. Process messages from ESP8266.
iact = -1 # Invalidate last status for change detection
while True: # print incoming messages, handle subscriptions
chan_state = channel.any()
if chan_state is None: # SynCom Timeout
self._running = False
elif chan_state > 0:
res = await channel.await_obj()
command, action = self.get_cmd(res)
if command == SUBSCRIPTION:
if action[0] in self.subs: # topic found
cb, args = self.subs[action[0]]
action += args
cb(*action) # Run the callback
elif command == STATUS: # 1st arg of status is an integer
iact = self.do_status(action, iact) # Update pub q and wifi status
await self.s_han(self, iact)
if iact in _DIRE_STATUS:
return self.quit('Fatal status. Resetting.')
elif command == TIME:
self.rtc_synchroniser._do_time(action)
elif command == MEM: # Wouldn't ask for this if we didn't want a printout
print('ESP8266 RAM free: {} allocated: {}'.format(action[0], action[1]))
else:
await self.s_han(self, UNKNOWN)
return self.quit('Got unhandled command, resetting ESP8266:', command, action) # ESP8266 has failed
await asyncio.sleep_ms(20)
if not self._running: # self.quit() has been called.
await self.s_han(self, NO_NET)
return self.quit('Not running, resetting ESP8266')
def _start(self):
i = self._rtc_interval # 0 == no synch. -1 == once only. > 1 = secs
if i and (i > 0 or self._rtc_last_syn == 0):
loop = asyncio.get_event_loop()
loop.create_task(asyn.Cancellable(self._do_rtc)())