Using Blynk with uasyncio

[andypnz]

Not really sure if this is the right place to seek help.....

I am (trying) to use Blynk with uasyncio to stop lack of wifi / internet / Blynk connection roadblocking the rest of my app. Basically I would like my app to run normally while Blynk tries re-connecting (inc wifi connection if necessary) in the background.

The below code almost(?) works. If I remove the Blynk write_handlers and don't use blynk.virtual_write either - it starts and restarts the wifi +/- Blynk cloud connection as needed, without blocking the rest of the code.

First problem is blynk.run() (which comes from a class or library) is not available - or rather I think it runs, but is not usable..... therefore blynk.virtual_write does not work. I think this is an issue of me not understanding uasyncio.

Second problem is getting the write_handlers working - once 'blynk_final_ready == True'. Obviously what I currently have does not work as it is only runs once (and the condition is false) - but I cant see a method of running these once 'blynk_final_ready == True'. I tried putting them inside a function, and that did not seem to work..... any idea how I can run (or activate) these conditionally? But I guess they need blynk.run() working first.....

But I think the bigger (first) issue is blynk.run() not correctly running (or is not usable after it runs?)

if (blynk_final_ready == True):
 print("Do this stuff")   
 @blynk.on("V0")
 def v5_write_handler(value):
    print('Requested water heater state: {}'.format(value[0]))
 @blynk.on("V5")
 def v5_write_handler(value):
    print('requested room heater state: {}'.format(value[0]))
etc.......

import utime
import network
import BlynkLib
import uasyncio
from usys import platform
import gc
from details import BLYNK_AUTH, ssid, password 
gc.collect()

RP2 = platform == 'rp2'
blynk_connection = False
blynk_final_ready = False
connected_wifi = False
 
voltpin = ADC(Pin(26))
readDelay = 2

global blynk
global f
global h
 
wlan = network.WLAN(network.STA_IF)

async def connect():
    await uasyncio.sleep(1)
    print("connect loop running")
    await uasyncio.sleep_ms(1000)
    global wlan
    global blynk
    global connected_wifi
    global h
    
    wlan.active(True)
    if RP2:
        rp2.country('NZ') 
        wlan.config(pm = 0xa11140) # turn off power savings
        
    wlan.connect(ssid, password)
    wait = 10
    
    while wait > 0:
        if wlan.status() < 0 or wlan.status() >= 3:
            break
        wait -= 1
        print('Waiting for connection...')
        await uasyncio.sleep_ms(10)
        
    if wlan.status() != 3:
        await uasyncio.sleep_ms(2000)
        return False
    else:
        print('Connected to', ssid, " WiFi")
        ip=wlan.ifconfig()[0]
        print(ssid, ' IP: ', ip)
        connected_wifi = True
        h = uasyncio.create_task(bconnect())
        return True

def restart_f():
    global f
    f.cancel()
    await uasyncio.sleep(0.1)
    f = uasyncio.create_task(connect())
    
async def bconnect():
    print("here ALREADY!!")
    await uasyncio.sleep(1)
    global f
    global blynk_connection
    global blynk
    # Initialize Blynk
    try:
        #blynk = BlynkLib.Blynk(BLYNK_AUTH) # faster
    #      or....
        blynk = BlynkLib.Blynk(BLYNK_AUTH,
                               insecure=True,
                               server='lon1.blynk.cloud',   # lon1 fra1.blynk.cloud, blynk.cloud or your local blynk server
                               port=80,
                               heartbeat=30,
                               log=print
                               )
        blynk_connection = True
        print("Blynk connection: ", blynk_connection)
    except OSError as e:
        print('ERROR', e)
        blynk_connection = False
        restart_f()

async def read_voltage():
  global f
  global h
  global i
  global blynk_final_ready
  global connected_wifi
  global blynk_connection
  await uasyncio.sleep(20)
  while True:
    voltage = voltpin.read_u16() / 1000
    print("voltage: " + "%.2f" % voltage +" (adc: "+str(voltpin.read_u16())+")")
    if (blynk_final_ready == True):
        print("Blynk Connected True")
        blynk.virtual_write(4, voltage)
    elif (blynk_connection == False and connected_wifi == True):
        print("wifi ok, no blynk connection, so restart blynk")
        h.cancel()
        await uasyncio.sleep(0.1)
        h=uasyncio.create_task(bconnect())
        await uasyncio.sleep(5)

    elif (blynk_connection == False and connected_wifi == False):
        print("no blynk connection, so restart wifi connection and blynk")
        f.cancel()
        await uasyncio.sleep(0.1)
        f=uasyncio.create_task(connect())
        await uasyncio.sleep(5)
    else:
        print("Blynk Final NOT ready")
        await uasyncio.sleep(5)
        i.cancel()
        await uasyncio.sleep(0.1)        
        i=uasyncio.create_task(main())
    await uasyncio.sleep_ms(500)
    
def set_global_exception():
    def handle_exception(loop, context):
        import sys
        sys.print_exception(context["exception"])
        sys.exit()
    loop = uasyncio.get_event_loop()
    loop.set_exception_handler(handle_exception)
 
if (blynk_final_ready == True):
 print("Do this stuff")   
 @blynk.on("V0")
 def v5_write_handler(value):
    print('Requested water heater state: {}'.format(value[0]))
      
 @blynk.on("V5")
 def v5_write_handler(value):
    print('requested room heater state: {}'.format(value[0]))

 @blynk.on("connected")
 def blynk_connected(ping):
    global blynk_connection
    blynk_connection = True
    print('Blynk ready. Ping:', ping, 'ms')

 @blynk.on("disconnected")
 def blynk_disconnected():
    blynk_connection = False
    print('Blynk disconnected')

else:
    print("still not done this")

async def main():
  global blynk_connection
  global blynk_final_ready
  global blynk
  gc.collect()
  set_global_exception()
  await uasyncio.sleep(0.1)
  print("main running")
  print("blynk connection: ", blynk_connection, " and blynk_final_ready", blynk_final_ready)
  if (blynk_connection == True and blynk_final_ready == False):
   uasyncio.wait_for(blynk.run(), 10)
   #await blynk.run() 
   blynk_final_ready = True

   print("Blynk final READY: ", blynk_final_ready)
   print("blynk connection: ", blynk_connection, " and blynk_final_ready", blynk_final_ready)
  
loop = uasyncio.get_event_loop()
f=uasyncio.create_task(connect())
g=uasyncio.create_task(read_voltage())
i=uasyncio.create_task(main())
loop.run_forever()

The result is close - blynk.virtual_write(4, voltage) does not work and of course the write_handler is not available....

Blynk final READY:  True
blynk connection:  True  and blynk_final_ready True
voltage: 14.24 (adc: 13779)
Blynk Connected True
< 20 2 | vw 4 14.243
voltage: 10.59 (adc: 11042)
Blynk Connected True
< 20 3 | vw 4 10.594
voltage: 10.72 (adc: 11234)
Blynk Connected True
< 20 4 | vw 4 10.722
Traceback (most recent call last):
  File "uasyncio/core.py", line 1, in run_until_complete
  File "<stdin>", line 105, in read_voltage
  File "BlynkLib.py", line 86, in virtual_write
  File "BlynkLib.py", line 119, in _send
  File "BlynkLib.py", line 251, in _write
OSError: [Errno 104] ECONNRESET

[peterhinch]

Unfortunately I have no experience of Blynk but I assume it is useless without a WiFi connection. Looking at your code I think there is a hazard whereby you might create more than one concurrent instance of the same task; this will probably cause chaos.

The way I would design something like this is to have a maintainer task which runs continuously whose job it is to create and maintain a WiFi connection (connections can drop out). When a connection is established, it starts Blynk and once Blynk is running, tasks that use it are started. If the WiFi connection is lost, maintainer cancels the Blynk-dependent tasks then cancels the Blynk task.

However this (and any solution) comes with a huge caveat. It will only work if Blynk periodically yields control to the scheduler, or if its interface consists of rapidly returning routines. If anything in Blynk blocks, uasyncio loses any ability to schedule other tasks. See the uasyncio tutorial for more information.

[andypnz]

Hi Peter Thank you - I will give that a go....

[andypnz]

Hi Peter

I have made some progress... this code now works - I have tested with no wifi, wifi on / off / on, and internet connection on / off / on with wifi remaining connected. It looks like Blynk is not blocking anything with uasyncio :-)

But the code is terrible - and I have ended up with stuff that should be in the maintainer loop in a new loop called test_loop.

I wonder if there is a way I can do everything inside the maintainer loop?

import utime
import network
import BlynkLib
import uasyncio
from usys import platform
import gc
from details2 import BLYNK_AUTH, ssid, password 
gc.collect()

RP2 = platform == 'rp2'
blynk_connected = False
blynk_final_ready = False
wifi_connected = False
 
voltpin = ADC(Pin(26))
readDelay = 2

global blynk
global f
global h
global i
 
wlan = network.WLAN(network.STA_IF)

async def test_loop():
    global wifi_connected
    global blynk_connected
    global f
    global i
    while True:
        print("Test loop running. Wifi status: ", wifi_connected, ". wlan status code: ", wlan.status()) 
        if (wifi_connected == False):
            print("Restarting wifi connection process")
            wifi_connected = True
            blynk_connected = False
            try:
                i.cancel()
            except:
                print("Could not cancel Blynk when restarting wifi")
            f.cancel()
            await uasyncio.sleep(0.1)
            f=uasyncio.create_task(maintainer())
        if (wifi_connected == True and wlan.status() != 3):
            blynk_connected = False
            try:
                i.cancel()
            except:
                print("cant cancel i")
            try:    
                f.cancel()
            except:
                print("cant cancel f")
            await uasyncio.sleep(0.1)
            f=uasyncio.create_task(maintainer())
        if (wifi_connected == True and blynk_connected == False):
            print("Restarting Blynk......")
            try:
                i.cancel()
            except:
                print("Cant cancel i")
            try:
                f.cancel()
                await uasyncio.sleep(0.1)
                f=uasyncio.create_task(maintainer())
            except:
                print("Could not restart maintainer")
        await uasyncio.sleep(5)
        
async def maintainer():
    print("Maintainer loop running")
    await uasyncio.sleep_ms(100)
    global wlan
    global blynk
    global wifi_connected
    global blynk_connected
    global i
    await uasyncio.sleep(1)   
    wlan.active(True)
    if RP2:
        rp2.country('NZ') 
        wlan.config(pm = 0xa11140) # turn off power savings  
    wlan.connect(ssid, password)
    wait = 10
    while wait > 0:
        if wlan.status() < 0 or wlan.status() >= 3:
            break
        wait -= 1
        print('Waiting for wifi connection...')
        await uasyncio.sleep_ms(100)
    if wlan.status() != 3:
        await uasyncio.sleep_ms(2000)
        print('Unable to connect wifi - trying again...')
        wifi_connected = False
    else:
        print("Connected to ", ssid, " WiFi")
        ip=wlan.ifconfig()[0]
        print(ssid, ' IP: ', ip)
        wifi_connected = True
        try:
            blynk = BlynkLib.Blynk(BLYNK_AUTH)
            i=uasyncio.create_task(blynk.run())
            blynk_handlers()
        except:
            print("Maintainer Blynk exception")
            
async def read_voltage():
  global blynk_final_ready
  global wifi_connected
  global blynk_connected
  await uasyncio.sleep(0.1)
  while True:
   print("Do other stuff here in the voltage loop that does not rely on Blynk")   
   if (blynk_connected == True):
    voltage = voltpin.read_u16() / 1000
    print("Voltage: " + "%.2f" % voltage +" (adc: "+str(voltpin.read_u16())+")")
    blynk.virtual_write(4, voltage)
    await uasyncio.sleep(2)
   else:
    print("Voltage loop - awaiting Blynk connection")   
    await uasyncio.sleep(2) 

def set_global_exception():
    def handle_exception(loop, context):
        import sys
        sys.print_exception(context["exception"])
        sys.exit()
    loop = uasyncio.get_event_loop()
    loop.set_exception_handler(handle_exception)

def blynk_handlers():
    @blynk.on("V0")
    def v5_write_handler(value):
        print('Requested water heater state: {}'.format(value[0]))
  
    @blynk.on("V5")
    def v5_write_handler(value):
        print('Requested room heater state: {}'.format(value[0]))

    @blynk.on("connected")
    def blynk_connected(ping):
        global blynk_connected
        blynk_connected = True
        print('Blynk ready. Ping:', ping, 'ms')

    @blynk.on("disconnected")
    def blynk_disconnected():
        global blynk_connected
        blynk_connected = False
        print('Blynk disconnected')

loop = uasyncio.get_event_loop()
k=uasyncio.create_task(test_loop())
f=uasyncio.create_task(maintainer())
g=uasyncio.create_task(read_voltage())
loop.run_forever()

[peterhinch]

There are two issues here, the detail of the code and the overall logic. Regarding the detail, I would get rid of the globals replacing them with bound variables of classes. If you do have globals, the global keyword here is redundant:

global blynk
global f
global h
global i
 
wlan = network.WLAN(network.STA_IF)

The global keyword only has meaning within a function or method: it is telling the function code to search for that variable in the outermost scope, rather than in the function local scope.

Another point of detail is that the event_loop stuff is no longer necessary. See the uasyncio tutorial.

Regarding the logic, I would regard your code as a proof of concept: you have demonstrated that there are no fundamental problems such as blocking. I would rewrite the maintainer function as a class method and ensure that its only purpose is maintaining a WiFi connection. When a connection is established it launches tasks that use the connection. When WiFi goes down, it cancels those tasks.
[EDIT]
My point here is that a simpler, more logical design can often be achieved by viewing the system as a set of tasks. This avoids polling and checking flags. Have the base task start dependent tasks. Those tasks then start sub-tasks that depend on them. In the event that a task fails, it cancels sub-tasks until it regains control. So the WiFi maintainer controls the Blynk task which itself controls measurement tasks.

[andypnz]

Hi Peter

Thank you - I will look at this again with those items on board!

Andrew