Using asyncio inside a (seperate) class

[MrTinkerman]

Hi all,

I'm exploring asyncio and got it working in my main code.
However, I would also like to use asyncio in a separate class that can do it's own async stuff but I could use some hints.

My goal:
-- Main async code queues messages to the class
-- Class sends out the messages at a set interval

Why not do it in the main code? Because it's a lora class, 350 lines of code, handling SPI, the queue, message ID's, acks, retries.
And I would like it to be standalone for re-use.

So I have some code to test the basic working, but it doesn't work :(
So my question is, what should I do to get this working?

Thanks!

My main code

from time import ticks_ms as tms
import random
import asyncio as asc
from asyncio import sleep_ms as asms
from lib.tx import TX


# TX class should send out queued messages at a set interval (ms)
tx = TX(500)


# Function queues a random number of mesages to be transmitted by tx
# msg will be a string of random uppercase characters: K_V_G_R_P

async def que_msg():
    
    while 1:
    
        for m in range(random.randint(5, 10)):
            
            chars 	= [chr(n) for n in range(65, 91)]							
            msg   	= [random.choice(chars) for i in range(5)]
            msg 	= '_'.join(msg)
            
            tx.que_msg(msg)
        
        # Wait for a random number of seconds
        await asms(random.randint(2,5)*1000)


async def init():
    
    asc.create_task(que_msg())
    
    while 1: await asms(10_000)
    
    
asc.run(init())

My class

from time import ticks_ms as tms
import asyncio as asc
from asyncio import sleep_ms as asms


class TX:

    def __init__(self, tx_intv):
        
        self.msg_que = []
        self.tx_intv = tx_intv
        
        asc.run(self._run_tasks())
        
        
    def que_msg(self, msg):
        
        self.msg_que.append(msg)
        
        
    async def _send(self):
        
        while 1:
            
            if len(self.msg_que):
                
                msg = self.msg_que.pop(0)
                print(f'{tms()} Sending msg {msg}')
                
            await asms(self.tx_intv)
            
    
    async def _run_tasks(self):
        
        asc.create_task(self._send())
    
        while 1: await asms(10_000)	

[beetlegigg]

Only one asyncio loop is allowed and you are creating one in your main code and another in your class. So maybe the following is what you are after, but of course that just a quick slice and dice of your code example so it may not be exactly what you were after :)
main:

from time import ticks_ms as tms
import random
import asyncio as asc
from asyncio import sleep_ms as asms
from tx_lib import TX


# Function queues a random number of mesages to be transmitted by tx
# msg will be a string of random uppercase characters: K_V_G_R_P

async def que_msg(tx):  
    while True:    
        for m in range(random.randint(5, 10)):     
            chars 	= [chr(n) for n in range(65, 91)]							
            msg   	= [random.choice(chars) for i in range(5)]
            msg 	= '_'.join(msg)
            tx.que_msg(msg)
        # Wait for a random number of seconds
        await asms(random.randint(2,5)*1000)


async def init():
    tx = TX(500)
    asc.create_task(tx.tx_send())
    asc.create_task(que_msg(tx)) 
    
    while True:
        await asc.sleep(0)
    
asc.run(init())

and the tx_lib.py file contain the class

from time import ticks_ms as tms
import asyncio as asc
from asyncio import sleep_ms as asms

class TX:
    def __init__(self, tx_intv):
        self.msg_que = []
        self.tx_intv = tx_intv
            
    def que_msg(self, msg):
        self.msg_que.append(msg)
          
    async def tx_send(self):
        while True:
            if len(self.msg_que): 
                msg = self.msg_que.pop(0)
                print(f'{tms()} Sending msg {msg}')   
            await asms(self.tx_intv)
            

[MrTinkerman]

Ok, thanks.

So key is that you can only have one asyncio loop. I now have the code below and use that approach.

Main:

from time import ticks_ms as tms
import random
import asyncio as asc
from asyncio import sleep_ms as asms
from lib.tx import TX

tx = TX(250)

async def que_msg():
    while 1:
        for m in range(random.randint(5, 10)):
            chars 	= [chr(n) for n in range(65, 91)]							
            msg   	= [random.choice(chars) for i in range(5)]
            msg 	= '_'.join(msg)
            tx.que_msg(msg)
        
        await asms(random.randint(2,5)*1000)

async def init():
    asc.create_task(que_msg())
    asc.create_task(tx.send())
    
    while 1: await asms(10_000)
    
asc.run(init())

Class:

from time import ticks_ms as tms
from asyncio import sleep_ms as asms

class TX:

    def __init__(self, tx_intv):
        self.msg_que = []
        self.tx_intv = tx_intv
         
    def que_msg(self, msg):
        self.msg_que.append(msg)
        
    async def send(self):
        while 1:
            if len(self.msg_que):
                msg = self.msg_que.pop(0)
                print(f'{tms()}  Sending msg {msg}  que lenght: {len(self.msg_que)}')
            await asms(self.tx_intv)