Imagem 1: LED aceso pela Labrador

Pré-Post                                                                                

Requisitos: Ter a IDE do Python 3 instalada na Labrador

Informações da Placa

Kernel: 4.14.13
SO: debian-armhf 4.14.13
Link: https://caninosloucos.org/pt/labrador-32-pt/

Introdução 

Nesse post daremos os primeiros passos no uso da Labrador. Faremos um projeto básico que piscará um LED, conectado à um pino GPIO, a cada 1 segundo, e imprimirá na tela o estado do LED atualizado.

O projeto

Componentes do projeto

- Placa Labrador
- 1 Diodo emissor de luz (LED)
- 1 Resistor de 330 Ω
- 2 Jumpers macho-fêmea
- 1 Protoboard
Montagem do circuito
Para montar o circuito, vamos primeiro entender a correspondência dos pinos da placa com suas respectivas funções. A versão da Labrador usada nesse projeto tem correspondência análoga à placa da Raspberry Pi Zero, como ilustrada na imagem a seguir:

Imagem 2: Correspondência dos pinos entre Raspberry Pi Zero e Labrador

Para o projeto, escolhemos os pinos 11 (GPIO 0) e 9 (Terra). O resistor deve ser conectado ao pino 11, e o ânodo do LED (perna mais longa) conectado em serie ao resistor. É nesse terminal que ocorre a alimentação do LED. O cátodo do LED (perna mais curta) deve ser conectado ao pino 9, ou seja, ao terra.
Esquematicamente, temos:

Imagem 3: Circuito esquemático

Com a protoboard, temos:
Imagem 4: Circuito montado


Programa

Agora é hora de escrever o código do programa pra rodar o projeto. Abra a IDE do Python, linguagem que usaremos, e escreva o seguinte código. Os comentários (linhas verde entre ' ' ) ficam a seu critério, comentamos o código para facilitar o entendimento de cada comando. A seguir, falaremos de cada comando do programa.

Imagem 5: Programa em Python


Agora para rodar o programa, clique no botão "Run" na barra de ferramentas da IDE, e em seguida em "Run Module". Se não houver nenhum erro de código ou de ligação no circuito, o LED piscará repetidamente, e na tela do seu monitor, aparecerá a seguinte janela.

 Imagem 6: Saída do programa

Note que quando o LED acende, o programa imprime a frase "LED ligado", e quando desliga, "LED desligado".

Entendendo o Programa

Um computador ou microcontrolador, assim como a nossa placa, não dispõem de uma inteligência como a do ser humano. Para executar tarefas, eles obedecem uma lista de comandos de forma ordenada. Essa lista de comandos é o algoritmo, a ser escrito numa linguagem compatível com o compilador da Labrador, no nosso caso, o Python.

Começaremos com o cabeçalho do programa:


O primeiro comando (import time) nos permite introduzir o módulo tempo ao nosso programa, pra usarmos comandos que facilitem na contagem de tempo.
O segundo comando (from gpio import GPIO) nos permite manipular os pinos da placa em nosso programa, de acordo com nossas necessidades de projeto. Criamos um objeto, de nome GPIO para manipular os pinos a partir de comandos específicos por meio do módulo gpio. Note que algumas palavras que digitamos aparecem coloridas, pois essas palavras são reservadas a serem comandos específicos da linguagem. 

Após o cabeçalho, criamos uma variável chamada led_pin para manipular no programa e nos dar acesso à GPIO 0 (pino 11) por meio do seguinte comando,

 
e definimos esse pino como saída (out). É nesse pino que conectamos o LED, e defini-lo como saída, quer dizer que o placa enviará um sinal elétrico ao pino que acenderá ou apagará o LED de acordo com a condição de momento.
Em resumo, o que fizemos foi chamar a GPIO 0 de led_pin e definimos esse pino como saída. Sempre que quisermos manipular esse pino no programa, usaremos o nome da variável que escolhemos, led_pin. Essa pratica facilita no entendimento do código e na hora de corrigir algum problema. Imagine um projeto com 50 LEDs de diferentes cores definidos apenas pelo número dos pinos aos quais foram ligados. Seria muito difícil e gastaria muito tempo pra encontrar e corrigir um simples erro. Por isso, ao nomear alguma variável e defini-la à algum pino, dê um nome que remeta diretamente ao objeto com o que esta lidando, seja um sensor, seja um LED.

A seguir, o comando que manipula diretamente a condição do LED.


A função write() manipula um pino diretamente, colocando-o em um nível de tensão alto ou baixo.
No nosso caso, aplicamos a função write() na variável led_pin, que é a GPIO 0, e determinamos que o nível de tensão nesse pino seja baixo (GPIO.LOW), ou 0 V. Desse modo, garantimos que ao inicializar o programa, o LED esteja apagado.

Todos esses comandos até aqui, são lidos apenas uma vez pelo programa, a partir do momento em que começou a rodar. Agora, o programa vai entrar em um loop por meio do seguinte comando:


O programa rodará ciclicamente as instruções que estiverem dentro desse bloco, como a seguir:


O primeiro comando dentro do bloco é outra aplicação da função write(), dessa vez, para impor um nível alto de tensão (5 V) na GPIO 0, ligando assim o LED.
O comando a seguir, print(), imprimirá na tela o que está entre parênteses, no caso, LED ligado, atualizando assim o status do LED.
O comando time.sleep(1) na sequência determina a espera de 1 segundo, até que o programa vá para a seguinte linha, onde pela segunda vez a função write() é chamada, dessa vez para apagar o LED. Em sequência, o status do LED é atualizado, também pela segunda vez, e impresso na tela, e por fim, o ultimo comando do bloco com a chamada de time.sleep(1)  para a espera de 1 segundo. Após a execução desse comando, o programa volta para o primeiro comando do bloco, ascendendo o LED, e percorrendo a sequência do bloco repetidamente. 

Resumo e Conclusões

Aqui vemos um pequeno vídeo do projeto em funcionamento:



Nesse post você aprendeu a piscar um LED com a Labrador pela GPIO. Agora que você deu os primeiros passos na exploração da Labrador, pode partir para desafios mais complexos. Fique ligado que em breve, compartilharemos mais projetos por aqui.

Palavras-Chave e Termos importantes para se saber

  • GPIO - Pinos de terra (Ground), alimentação (Power), entrada (In) e saída (Out)
  • write() - Função que tem como argumento um objeto que remete a um pino de saída e manipula seu nível lógico para alto (5 V) ou baixo (0 V).
  • import time - introduz o módulo tempo ao programa, permitindo o uso de comandos prontos para manipulação temporal.

Referências

  1. Programação GPIO - Caninos Loucos. Wiki Caninos Loucos. Disponível em: https://wiki.caninosloucos.org.br/index.php/Programa%C3%A7%C3%A3o_GPIO. Acesso em: 0308/2020
  2. Python - Date & Time. Tutorials Point. Disponível em: https://www.tutorialspoint.com/python/python_date_time.htm. Acesso em: 03/08/2020.
  3. Labrador/led-blink. GitLab - Geovane Fedrecheski. Disponível em: https://gitlab.com/geonnave/sbpc-workshop/-/tree/master/labrador/led-blink. Acesso em: 04/08/2020.

Referências para imagens e ícones