_thread | NameError

[amilcartostes]

Hi!

I'm writing a very simple program in MicroPython to run on a Raspberry Pi Pico. I'm using MicroPython version 1.23.0 and I wrote a function to monitor the microcontroller's GPIO inputs using Python's _thread mode to support multithreading.

However, I noticed that the task placed in the microcontroller's core sometimes works correctly and when it doesn't, it is interrupted and displays the following message on the console:

Unhandled exception in thread started by <function Watchdog at 0x20007860>
Traceback (most recent call last):
File "", line 171, in Watchdog 26.85357NameError
: name 'Remoto' isn't defined

The global variable "Remoto" was declared at the beginning of the "Watchdog" function and its initial value is "False". This variable is also declared and initialized in the main program body.

I must be making some basic syntax error since I recently started programming in Python. I ask for everyone's help to solve this problem.

Below is the script for the Watchdog function:

import time
from machine import Pin
from machine import ADC
import _thread

#--------------------------- Watchdog --------------------------------#

Watchdog

This function operates on the second core of the processor and is intended to

to monitor the status of the control panel inputs and outputs

def Watchdog():

global Fluxo_Agua
global Temp_Agua
global Purga 
global Temp_Sonda
global Remoto
global Temp_Int
global Status_Sonda

Fluxo_Agua = False
Temp_Agua = False
Purga = False
Temp_Sonda = False
Remoto = False
Temp_Int = False
Status_Sonda = False

Sensor_Fluxo_Agua = Pin(0,Pin.IN,Pin.PULL_UP)
Sensor_Temperatura_Agua = Pin(1,Pin.IN,Pin.PULL_UP)
Sensor_Pressao_Purga = Pin(2,Pin.IN,Pin.PULL_UP)
Sensor_Temperatura_Sonda = Pin(3,Pin.IN,Pin.PULL_UP)
Chave_Local = Pin(4,Pin.IN,Pin.PULL_UP)
Botao_Local_Inserir = Pin(5,Pin.IN,Pin.PULL_UP)
Botao_Local_Remover = Pin(6,Pin.IN,Pin.PULL_UP)
Botao_Remoto = Pin(7,Pin.IN,Pin.PULL_UP)
Sensor_Temp_Int = ADC(4)

low = 0
Temp_Int_Max = 70
t_sonda_in = 500
t_sonda_out = 500

while True:

    #----------- Water Flow Ctrl ----------#

    if Sensor_Fluxo_Agua.value() == low:
        Fluxo_Agua = True
    else:
        Fluxo_Agua = False
    
    #----------- Water Temperature ----------#

    if Sensor_Temperatura_Agua.value() == low:
        Temp_Agua = True
    else:
        Temp_Agua = False
    
    #----------- Purge Pressure ----------#

    if Sensor_Pressao_Purga.value() == low:
        Purga = True
    else:
        Purga = False

    #----------- Probe Temperature ----------#

    if Sensor_Temperatura_Sonda.value() == low:
        Temp_Sonda = True
    else:
        Temp_Sonda = False

    #----------- Local/Remote Key ----------#

    if Chave_Local.value() == low:
        Remoto = False
    else:
        Remoto = True

    #----------- Internal Temperature ----------#
    
    Read_Temp = (Sensor_Temp_Int.read_u16() * 3.3)/65356
    Vlr_Temp = 27 - (Read_Temp - 0.706)/0.001721

    if Vlr_Temp < Temp_Int_Max:
        Temp_Int = True
    else:
        Temp_Int = False
        
    #--------------- Insert Local Probe ---------------------#
    
    if Remoto == False and Status_Sonda == False:               # Panel in "Local" and Retracted Probe
        if Botao_Local_Inserir.value() == low:
            Status_Sonda = True                                                 # Insert the Probe
            time.sleep_ms(t_sonda_in)
            
    #---------------- Remove Local Probe --------------------#
    
    if Remoto == False and Status_Sonda == True:                # Panel in "Local" and Probe Inserted
        if Botao_Local_Remover.value() == low:
            Status_Sonda = False                                                #Remove the Probe
            time.sleep_ms(t_sonda_out)
            
    #--------------- Insert Remote Probe --------------------#
    
    if Remoto == True and Status_Sonda == False:               # Remote Panel and Retracted Probe
        if Botao_Remoto.value() == low:
            Status_Sonda = True                                                #Insert the Probe
            time.sleep_ms(t_sonda_in)
            
    #---------------- Remove Remote Probe -------------------#
    
    if Remoto == True and Status_Sonda == True:                # Remote Panel and Insert Probe
        if Botao_Remoto.value() == low:
            Status_Sonda = False                                                # Remove the Probe
            time.sleep_ms(t_sonda_out)

_thread.start_new_thread(Watchdog,())

[GitHubsSilverBullet]

Would be a good idea to put data which is accessible from both running cores into a global array.
While regular variables are destroyed and recreated:

a=0
print(id(a))
a +=1
print(id(a))

arrays will stay in memory for their entire lifetime. So, I'd try

float_var = array.array('f', (3.14159,))
print(id(float_var), float_var[0])
float_var[0] += 1.0
print(id(float_var), float_var[0])

Using that technique AND a proper locking mechanism, I had never any problems using two threads communicating.

[peterhinch]

As a very general comment, threaded code is an advanced technique which is best deployed when other, simpler approaches, are inadequate. The best way to achieve reliable concurrency in most applications is with asyncio. See official docs and tutorial.

[bixb922]

Please format posted code with backticks, see #9111

Use asyncio instead of threads, as explained in the previous post.

Initialize global variables in the global scope instead of inside the Watchdog function. If main() runs before Watchdog() has gone through the global variable initialization, there will be a NameError. On other words: move the global variable initialization to be done before the def main() and def Watchdog() statements.