Programação Dual Core no Raspberry Pi Pico usando MicroPython

Publicado em por
Tempo de leitura: 4 minutes

Olá a todos, espero que estejam gostando da série de tutoriais do Raspberry Pi Pico. Neste tutorial, vamos controlar dois LEDs por multithreading com programação dual-core no Raspberry Pi Pico usando MicroPython. Até agora vimos como fazer a interface de um OLED, um LCD, um Servo, um Sensor Ultrassônico e implementamos a comunicação I2C, ADC, Bluetooth com o Raspberry Pi Pico. O microcontrolador RP2040 da placa pico possui dois núcleos. Se você não está familiarizado com a execução multithread, então pense apenas no sistema do seu computador. Ele pode executar vários programas ao mesmo tempo, que podem ser operados por um sistema operacional usando multithreading. Mas não temos nenhum sistema operacional no Raspberry Pi Pico que controle os ciclos da CPU, ele só pode suportar um thread por núcleo, o que é dois nesta situação.

 

Componentes necessários para a programação Dual-Core no Raspberry Pi Pico

Você precisa se certificar de que possui os seguintes componentes para demonstrar a programação dual-core na placa do Pico.

  • Raspberry Pi Pico
  • LED x2
  • Resistores x2 (330 ohms)
  • ProtoBoard
  • Fios de conexão

 

Diagrama do circuito do servo motor usando a placa Raspberry Pi Pico

O diagrama do circuito do Servo Motor é tão simples. Anexei dois LEDs usando dois resistores de 330ohm, respectivamente, com o GPIO15 e GPIO16. Os pinos de aterramento dos LEDs foram conectados aos pinos de aterramento da placa Pico.

Multithreading no Raspberry Pi Pico usando programação Dual Core

Abaixo desta explicação você terá o código completo do projeto, vamos discutir sobre o arquivo main.py.

from machine import Pin
import utime
import _thread

Primeiramente, precisamos importar a classe Pin() da biblioteca machine.py conforme mencionado acima. Em nossos tutoriais anteriores, usamos a biblioteca de máquina tantas vezes e espero que agora você esteja familiarizado com a biblioteca de máquina. Em seguida, precisamos importar a biblioteca “utime” para usar o relógio interno do pico. Estamos usando a biblioteca “_thread” para usar as funções de threading feitas pela comunidade raspberry pi pico.

led1 = Pin(16, machine.Pin.OUT)
led2 = Pin(15, machine.Pin.OUT)
sLock = _thread.allocate_lock()

No código acima, inicializei os dois LEDs com GPIO15 e GPIO16 como OUPUT usando as funções “Pin(16, machine.Pin.OUT)” e “Pin(15, machine.Pin.OUT)”. A função “_thread.allocate_lock()” pode ser usada para fornecer um bloqueio de semáforo para ambas as threads. Se você quiser saber mais sobre esta função, pode consultar a documentação da biblioteca “_thread”.

def CoreTask():
    while True:
        sLock.acquire()
        print("Entrou no segundo Tópico")
        utime.sleep(1)
        led2.high()
        print("Led 2 aceso")
        utime.sleep(2)
        led2.low()
        print("Led 2 apagado")
        utime.sleep(1)
        print("Saindo do 2º Tópico")
        utime.sleep(1)
        sLock.release()
_thread.start_new_thread(CoreTask, ())

Vamos usar a função “CoreTask()” no outro núcleo com uma única thread. No loop while dentro da função, estamos ativando um bloqueio de semáforo para segurar o thread até que seja concluído. Então eu liguei o led2 alto por 1 segundo e imprimi a instrução no terminal de saída do Thonny. Em seguida, estou liberando o bloqueio do semáforo quando a thread estiver concluída. A função “_thread.start_new_thread(CoreTask, ())” iniciará o thread. Esta função usa o nome da função de destino como o primeiro parâmetro. No meu caso é “CoreTask” e leva argumentos no segundo parâmetro. No meu caso, não tenho nenhum argumento a ser aprovado.

while True:
    # Adquirimos o bloqueio do semáforo
    sLock.acquire()
    print("Entrou no Tópico principal")
    led1.toggle()
    utime.sleep(0.15)
    print("O Led 1 iniciou para acender.")
    print("Saindo do Tópico principal")
    utime.sleep(1)
    # Liberamos o bloqueio do semáforo
    sLock.release()

No loop while acima, estamos usando outro bloqueio de semáforo para que a thread principal continue em execução até que seja concluída. Ele irá alternar o led1 e, em seguida, liberar o bloqueio do semáforo. Agora, no IDE Thonny, abra o arquivo “main.py”. Para começar, salve o arquivo “main.py” no quadro do Pico pressionando as teclas “ctrl+shift+s” em seu teclado. Antes de salvar os arquivos, certifique-se de que sua placa Pico está conectada ao seu laptop. Ao salvar o código, uma janela pop-up aparecerá, conforme mostrado na imagem abaixo. Você deve primeiro selecionar o Raspberry Pi Pico, então nomear o arquivo “main.py” e salvá-lo. Este procedimento permite que você execute o programa quando o Pico está ligado.

Ao fazer o upload e executar o código na placa Pico, você verá que o led1 que está conectado ao GPIO16 está alternando com um atraso de 1,15 segundos. Mas o led2 que está conectado ao GPIO15 está piscando com um atraso de 2 segundos.

 

Código

main.py

import machine
import utime
import _thread

led1 = machine.Pin(16, machine.Pin.OUT)
led2 = machine.Pin(15, machine.Pin.OUT)
sLock = _thread.allocate_lock()

def CoreTask():
    while True:
        sLock.acquire()
        print("Entrou no segundo Tópico")
        utime.sleep(1)
        led2.high()
        print("Led 2 aceso")
        utime.sleep(2)
        led2.low()
        print("Led 2 apagado")
        utime.sleep(1)
        print("Saindo do 2º Tópico")
        utime.sleep(1)
        sLock.release()
_thread.start_new_thread(CoreTask, ())

while True:
    # We acquire the semaphore lock
    sLock.acquire()
    print("Entrou no Tópico principal")
    led1.toggle()
    utime.sleep(0.15)
    print("O Led 1 iniciou para acender.")
    utime.sleep(1)
    print("Saindo do Tópico principal")
    utime.sleep(1)
    # Liberamos o bloqueio do semáforo
    sLock.release()

 

Twittar
Compartilhar
Compartilhar
0 Compart.