Error when using two cores #12391

ropellanda · 2023-09-07T19:14:55Z

ropellanda
Sep 7, 2023

Hi all, been trying to use multicore processing for running a webserver and checking for button input simultaneously, the problem is that things are getting a little confusing when using classes to share data between threads (I'm a begginer), the code is quite long but any help would be greatly appreciated.

Error:

Unhandled exception in thread started by <function thread_function at 0x20012a00>
TypeError: function takes 4 positional arguments but 0 were given
Connecting to Network...
connected
ip = xxx.xxx.x.x
Setting up webserver...
TypeError: function takes 1 positional arguments but 2 were given

Code:

import network
import socket
import time
import utime
import _thread

from machine import Pin
import uasyncio as asyncio

ssid = 'ssid'
password = 'password'

html = """<!DOCTYPE html>
<html>
    <head> <title>Pico W</title> </head>
    <body> <h1>Pico W</h1>
        <p>%s</p>
    </body>
</html>
"""

wlan = network.WLAN(network.STA_IF)

class buttonThread:
    button_presses = 0
    last_time = 0
    old_presses = 0
    button_pin = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_UP)

    
    @classmethod
    def button_pressed_handler(cls):
        new_time = utime.ticks_ms()
        if (new_time - cls.last_time) > 200: 
            cls.button_presses +=1
            cls.last_time = new_time
    @classmethod
    def check_button(cls):
        cls.button_pin.irq(trigger=machine.Pin.IRQ_FALLING, handler = cls.button_pressed_handler)
        if cls.button_presses != cls.old_presses:
           print(cls.button_presses)
           cls.old_presses = cls.button_presses
           print('button pressed')

def thread_function(button_presses, last_time, old_presses, button_pin):
    while True:
        if button_presses != old_presses:
            print(button_presses)
            old_presses = button_presses

def connect_to_network():
    wlan.active(True)
    wlan.config(pm = 0xa11140)  # Disable power-save mode
    wlan.connect(ssid, password)

    max_wait = 10
    while max_wait > 0:
        if wlan.status() < 0 or wlan.status() >= 3:
            break
        max_wait -= 1
        print('waiting for connection...')
        time.sleep(1)

    if wlan.status() != 3:
        raise RuntimeError('network connection failed')
    else:
        print('connected')
        status = wlan.ifconfig()
        print('ip = ' + status[0])

async def serve_client(reader, writer):
    print("Client connected")
    request_line = await reader.readline()
    print("Request:", request_line)
    # We are not interested in HTTP request headers, skip them
    while await reader.readline() != b"\r\n":
        pass

    request = str(request_line)
    led_on = request.find('/light/on')
    led_off = request.find('/light/off')
    print( 'led on = ' + str(led_on))
    print( 'led off = ' + str(led_off))

    stateis = ""
    if led_on == 6:
        print("led on")
        led.value(1)
        stateis = "LED is ON"
    
    if led_off == 6:
        print("led off")
        led.value(0)
        stateis = "LED is OFF"
        
    response = html % stateis
    writer.write('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
    writer.write(response)

    await writer.drain()
    await writer.wait_closed()
    print("Client disconnected")

async def main():
    global button_presses, last_time, old_presses, button_pin
    print('Connecting to Network...')
    connect_to_network()
    print('Setting up webserver...')
    asyncio.create_task(asyncio.start_server(serve_client, "0.0.0.0", 80))
    while True:
        while True:
            buttonThread.check_button()
try:
    new_thread = _thread.start_new_thread(thread_function, ())
   
    asyncio.run(main())
finally:
    asyncio.new_event_loop()

Answered by andrewleech

Sep 7, 2023

Hi, yues concurrency in embedded code can be tricky to get working!

Just for a start, personally I try to avoid threads in micropython. Keeping objects in sync between threads can have a fair bit of complexity; and it's worth nothing that the rp2 only support 1 extra thread as it's implemented as code running on the second core.
Once using asyncio for an application (which I always use) I find it's best to try to keep everything in async unless its timing is particularly critical at which point I'll add Timer exceptions for time critical stuff.
Something that might be worth looking at are these couple of example asyncio pushbutton reading classes, both with debouncing:

https://github.com…

View full answer

andrewleech · 2023-09-07T23:04:14Z

andrewleech
Sep 7, 2023
Collaborator Sponsor

Hi, yues concurrency in embedded code can be tricky to get working!

Just for a start, personally I try to avoid threads in micropython. Keeping objects in sync between threads can have a fair bit of complexity; and it's worth nothing that the rp2 only support 1 extra thread as it's implemented as code running on the second core.
Once using asyncio for an application (which I always use) I find it's best to try to keep everything in async unless its timing is particularly critical at which point I'll add Timer exceptions for time critical stuff.
Something that might be worth looking at are these couple of example asyncio pushbutton reading classes, both with debouncing:

I see you're already using the pin interrupt for the switch so you could be just printing / handling the button press in the interrupt handler (which by default will be a soft hander anyway iirc) so possibly wouldn't need the thread anyway.

That being said, that's not what you asked here, and your code with thread is certainly technically a valid course of action and interesting to learn about threads vs irq vs asyncio!

Unhandled exception in thread started by <function thread_function at 0x20012a00>
TypeError: function takes 4 positional arguments but 0 were given

Luckily this exception messate points the the function that's triggered it! I see you've defined thread_function as a function with 4 args, but _thread.start_new_thread(thread_function, ()) isn't passing any args. The args are passed in the tuple, eg _thread.start_new_thread(thread_function, (arg1, arg2, arg3, arg4)).
In this case I'd suggest passing in just the class instance, rather than the individual attributes as args as they will be copied rather than referencing the class which you're using the share the data. eg.

def thread_function(bt: buttonThread):
    while True:
        if bt.button_presses != bt.old_presses:
            print(bt.button_presses)
            bt.old_presses = bt.button_presses
...
_thread.start_new_thread(thread_function, (buttonThread,))`

Note the extra , after buttonThread there, if you pass just (buttonThread) it doesn't actually create a tuple, it's just brackets that don't do anything, adding hte comma ensures the tuple is created / passed :-)

TypeError: function takes 1 positional arguments but 2 were given

This one's a bit trickier as you have to figure out where it comes from. When there's no stack trace / location identified it usually means the error has been raised by some "internal" functionality, eg an interrupt handler.
cls.button_pressed_handler is being passed as the irq handler for the button.
Checking the docs here https://docs.micropython.org/en/latest/library/machine.Pin.html#machine.Pin.irq the handler function will be passed an argument when it's called, the instance of Pin that triggered the irq. So the function would need to be def check_button(cls, pin):
It could be slightly confusing as the docs say the handler has only one argument, but this has now got two (inclusing the cls) however the cls doesn't really count as an argument as far as code that calls the function is concerned.

Also, I see in your main you've got

    while True:
        while True:
            buttonThread.check_button()

This is an infinite loop that would block the rest of the main code from ever running? cls.button_pin.irq() should only really be ever run once (to init the irq handler) so I don't think `buttonThread.check_button()' should be in any loop at all.

2 replies

peterhinch Sep 8, 2023
Collaborator

@andrewleech It's worse than that. The code

    while True:
        while True:
            buttonThread.check_button()

runs in the main task and does not yield to the scheduler. So asyncio will be stalled.

ropellanda Sep 11, 2023
Author

Thank you so much for the detailed answer and examples, it was very helpful.
I handled the button press inside the interrupt handler like you said and that was a much simpler approach which ended up working very well.

peterhinch · 2023-09-08T08:27:34Z

peterhinch
Sep 8, 2023
Collaborator

@ropellanda When beginners come to MicroPython they read about the amazing features such as interrupts, threading, multi-core programming, hard and soft timers. With a mental "whoopee" the temptation is to wade in, thinking "I've got a fuzzbox and I'm gonna use it".

Alas these are all advanced programming tools which the experienced user draws on when the normal approach is inadequate. The normal approach - as you have discovered - is asyncio which is entirely capable of responding to a button press. I suggest you look at the tutorial also this doc which details drivers for switches, pushbuttons etc.

Multi-core programming is the hardest technique to get right for reasons discussed here. The techniques are well worth learning, but a little reading can save a lot of frustrating bug hunting.

2 replies

ropellanda Sep 11, 2023
Author

I ended up using asyncio and an interrupt handler, it was much simpler than multi-core.
Once i gather more experience I will surely try and learn how to write multi-core code in the right way.
Thank you for your answer!

jimmo Sep 13, 2023
Maintainer

"I've got a fuzzbox and I'm gonna use it"

@peterhinch 🇬🇧 🎸 🤣

shariltumin · 2023-09-10T12:11:11Z

shariltumin
Sep 10, 2023

Do not be discouraged, concurrency is not easy. It takes time to learn and master. The level of mastery is related to the amount of effort you put in.

Some useful examples can be found in the test scripts at https://github.com/micropython/micropython/tree/master/tests/thread.

It is better to start slowly and understand the basic principles.

It is easier to think of the various concurrent functions as long-running tasks. A task is "normally" a function that never returns, i.e. has a while True: loop.

The rpi-pico can multitask with two threads with two cores, whereas the esp32 can multitask with 25 threads on one core.

Using the task definition above, rpi-pico can run 2 tasks, while esp32 can run 25 tasks. However, on rpi-pico the 2 tasks are on 2 different cores. Whereas on esp32 the tasks share the same CPU (core1) in what we call time-sharing.

On esp32, the RTOS will preemptively take the CPU away from a running task to allow other tasks to run.

Although rpi-pico can run 2 tasks on 2 separate cores, other resources such as variables, input/output streams, GPIOs are shared between the 2 tasks.

Here is a simple two-task example. If you're interested, you can give it a shot.

'z.py':

import time
from x import NS

def test():
    while True:
       if not NS.mutex.locked():
          NS.mutex.acquire() # will block
          NS.z_cnt += 1
          print('Message from z, x count is', NS.x_cnt)
          NS.mutex.release()
       time.sleep(5)

'x.py':

# usage: import x
import _thread
import time

def run_z():
    import z  # z refer to x.NS
    z.test()

def test():
    while True:
       if not NS.mutex.locked():
          NS.mutex.acquire() # this is blocking
          NS.x_cnt += 1
          print('Message from x, z count is', NS.z_cnt)
          NS.mutex.release()
       time.sleep(4)

def main():
    new_thread = _thread.start_new_thread(run_z, ()) 
    test()

class NS:mutex=_thread.allocate_lock();x_cnt=0;z_cnt=0

print("write x.main() at REPL to start z loop on core 1 and x loop on core 0")
print("<ctrl+c> will abort x loop")
print("write x.test() at REPL to start x loop again")
print("<ctrl+c><ctrl+d> will soft-reset")

On rpi-pico, the "z task" will run on core1 and the "x task" will run on core0. This is not the case on esp32.

We will get similar results from rpi-pico or esp32 boards.

I hope this is useful to someone.

2 replies

billbreit Sep 10, 2023

class NS:mutex=_thread.allocate_lock();x_cnt=0;z_cnt=0

Thank you and congrats ! I'll be looking over that line code in the future. I didn't know it was possible.

ropellanda Sep 11, 2023
Author

Thank you for your explanation and example (it was very useful!)

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

MicroPython

Error when using two cores #12391

Uh oh!

{{title}}

Uh oh!

Replies: 3 comments 6 replies

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

MicroPython

Error when using two cores #12391

Uh oh!

ropellanda Sep 7, 2023

Replies: 3 comments · 6 replies

Uh oh!

andrewleech Sep 7, 2023 Collaborator Sponsor

Uh oh!

peterhinch Sep 8, 2023 Collaborator

Uh oh!

ropellanda Sep 11, 2023 Author

Uh oh!

peterhinch Sep 8, 2023 Collaborator

Uh oh!

ropellanda Sep 11, 2023 Author

Uh oh!

jimmo Sep 13, 2023 Maintainer

Uh oh!

shariltumin Sep 10, 2023

Uh oh!

billbreit Sep 10, 2023

Uh oh!

ropellanda Sep 11, 2023 Author

ropellanda
Sep 7, 2023

Replies: 3 comments 6 replies

andrewleech
Sep 7, 2023
Collaborator Sponsor

peterhinch Sep 8, 2023
Collaborator

ropellanda Sep 11, 2023
Author

peterhinch
Sep 8, 2023
Collaborator

ropellanda Sep 11, 2023
Author

jimmo Sep 13, 2023
Maintainer

shariltumin
Sep 10, 2023

ropellanda Sep 11, 2023
Author