Curso Raspberry Pi – #14 – Python Básico, GPIO

26 Abril, 201814 Julho, 2020 info@electrofun.pt

Nós já sabemos como usar os pinos GPIO universais usando a linha de comando e terminal de scripting. Muitas vezes verifica-se que esse controlo não é muito confortável. Nesta parte, mostraremos como usar o GPIO com o Python. A propósito, aprenderemos o básico desta linguagem de programação popular.

A grande vantagem (que às vezes é uma desvantagem) do Raspberry é a capacidade de resolver o mesmo problema de várias maneiras. No caso do Arduino, a vida é mais simples. Na grande maioria dos casos, temos o Arduino IDE, escrevemos um programa em C ++ e executamos pressionando um botão. O Raspberry Pi oferece mais opções, o que às vezes dificulta a escolha da solução correta. Porém, vale a pena aprender métodos diferentes de fazer tarefas semelhantes num Raspberry.

Python – o que vale a pena conhecer?

Nesta parte, vamos lidar com a linguagem de programação extremamente popular, Python. Primeiro de tudo, o que pode ser um choque para muitos, o nome desta linguagem não tem nada a ver com cobras. “Python” vem da série Monty Python’s Flying Circus, se ainda não viu, provavelmente é hora de ver!

A segunda coisa são as versões linguísticas: atualmente as duas principais são usadas – Python 2.xe 3.x. Em poucas palavras, há cerca de dez anos, os desenvolvedores da linguagem decidiram fazer modificações significativas e introduzir um novo número de versão 3. Infelizmente, a linguagem já é tão popular que mudanças rápidas não são bem-vindas. Como resultado, em vez de substituir a versão 2 pela nova versão 3, ainda existem os dois – de uma maneira paralela.

Executando o Python no Raspberry Pi

O Python é uma das linguagens interpretadas, por isso funciona como scripts de shell sem a necessidade de compilar. No entanto, um intérprete de idioma é necessário para a operação. O Raspbian usado por nós fornece o interpretador Python por padrão.

Além disso, as versões 2 e 3 são instaladas por padrão.

Está na hora de praticar! No início, nos conectamos ao Raspberry Pi de uma maneira escolhida por nós (por exemplo, por SSH) e verificamos qual versão do Python é usada por padrão. Para este fim, nós emitimos o comando:

python --version

No nosso caso, esta é a versão 2.7.13. Se quisermos ter certeza de que usamos a versão 2, em vez de python, devemos executar o python2 , ou seja:

python2 --version

O mesmo para a versão 3:

python3 --version

Trabalho interativo com Python

Uma das vantagens das linguagens interpretadas é a capacidade de inserir e executar comandos individualmente. Assim como com os comandos do terminal. Vamos verificar agora como funciona. Nós executamos o interpretador Python com o comando python3:

python3

Vamos ver um sinal “>”, muitas vezes são 3. É aqui que podemos inserir comandos que serão tratados como código Python:

Para começar, um “exemplo imortal”, ou seja, Hello world!:

print("Hello world!")

Como podemos ver, o programa respondeu escrevendo uma mensagem. Com a ajuda da print, também pode “imprimir” mensagens um pouco mais complicadas ou resultados de cálculos:

print(2+2)

GPIO em Python

Este curso não é focado em programação, então temos que adiar isto para uma ocasião diferente – agora só vamos conhecer o básico na prática. Vamos direto ao exemplo usando a linha GPIO.

Anteriormente, já controlamos o díodo (a partir da linha de comando), vale a pena começar com o mesmo exercício. Nós conectamos o mesmo circuito que usamos na peça com o GPIO. Nós conectamos o díodo luminoso ao pino número 40 (rotulado como GPIO21). Este pino está localizado no canto do conector e seu “vizinho” mais próximo é o pino número 39 (GND).

Na prática, o layout pode ter a seguinte aparência:

Precisamos de uma biblioteca adequada para controlar os pinos. Na verdade, sempre que escrevemos programas em Python, usamos algumas bibliotecas. É verdade que, em comparação com outros idiomas, o Python permite o uso fácil e agradável de soluções prontas.

Não é diferente no nosso caso – o que precisamos é da biblioteca RPi.GPIO. A biblioteca em si já está instalada (pacote python3-rpi.gpio), que pode ser verificado com o seguinte comando:

apt list --installed | grep rpi.gpio

Agora só precisa importá-lo. No caso do Arduino, a importação de uma nova biblioteca requer o uso de um rato, em Python nós simplesmente escrevemos:

import RPi.GPIO as GPIO

Poderíamos escrever o mesmo “import RPi.GPIO”, mas a cada vez teríamos que dar o prefixo “RPi.” na frente do nome da função que está sendo executada. Uma mistura de letras maiúsculas e minúsculas é um pesadelo programável. Com a ajuda da nota “as GPIO”, apresentamos nosso nome local GPIO , o que facilita muito o trabalho com a biblioteca.

Claro, poderíamos facilmente usar um nome diferente!

Como nos lembramos das partes anteriores do curso, manipular os pinos no Raspberry é repleto de uma “bagunça” numérica. Em Python, essa “bagunça” também existe. Antes de usar os pinos , temos que escolher o método de numeração. Queremos usar o pino GPIO21, então escrevemos:

GPIO.setmode(GPIO.BCM)

Agora o nosso díodo terá o número 21. Poderíamos usar uma numeração diferente escrevendo, por exemplo, “GPIO.setmode (GPIO.BOARD)”, então o número do pino físico no conector seria usado. De acordo com essa descrição, o nosso díodo seria então conectado ao pino 40.

No entanto, ficamos com a nossa numeração (BCM). Similar ao anterior, no início definimos o modo de linha como uma saída. Para este fim, escrevemos:

GPIO.setup(21, GPIO.OUT)

Está na hora de ligar o díodo:

GPIO.output(21, GPIO.HIGH)

Pode desligar o díodo:

GPIO.output(21, GPIO.LOW)

Em vez de GPIO.HIGH e GPIO.LOW, poderíamos usar valores numéricos 1 e 0.

No final da diversão com os pinos, devemos “limpar”, ou seja, restaurar o programa usado por nós para a sua configuração padrão. O comando é usado para isso:

GPIO.cleanup()

Para sair do interpretador Python, podemos usar a configuração CTRL + Z já conhecida.

Criando scripts em Python

Ligamos no modo interativo – é uma ótima maneira de conhecer as bibliotecas e a própria linguagem. No entanto, digitar comandos cada vez que inicia é cansativo, por isso vamos tentar escrever um script, que é um código de programa que podemos fazer repetidamente.

No caso do Python, escrever scripts é muito simples. Nós executamos o nosso editor de texto favorito e criamos um novo arquivo – desta vez com a extensão “py” como Python.

nano led_on.py

No interior, digite o seguinte conteúdo:

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

GPIO.setup(21, GPIO.OUT)
GPIO.output(21, GPIO.HIGH)

No final do script, não há uma chamada GPIO.cleanup() porque a limpeza desativará o díodo. É uma solução racional, mas neste caso seria desconfortável. Se deixar um código sem a limpeza da próxima vez que utilizar os pinos gera um aviso (ANG. Advertências). Então, para não ver esses avisos, desligamos essas mensagens chamando GPIO.setwarnings(False). Esta não é uma solução bastante elegante, mas neste caso, podemos fazê-lo dessa maneira.

Da mesma forma, criamos um script para desativar o díodo:

nano led_off.py

O conteúdo será praticamente idêntico (só mudamos o estado do pino):

import RPi.GPIO as GPIO
 
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
 
GPIO.setup(21, GPIO.OUT)
GPIO.output(21, GPIO.LOW)

Scripts escritos desta maneira são executados com o comando:

python3 led_on.py

ou:

python3 led_off.py

No caso de scripts escritos em Python, antes de executar os programas, não é necessário alterar as permissões dos arquivos como no caso de scripts escritos no shell.

Loops e delays no Python

Vamos para os próximos elementos do novo idioma, escreva uma programação que pisque com um díodo. Para tornar o piscar visível, temos que introduzir delays. Para fazer isso, vamos usar a biblioteca de time. Também já está instalado por padrão e só precisa de importá-lo.

Desta vez vamos usar uma forma diferente da instrução de importação:

from time import *

Agora todas as funções incluídas no “time” estarão disponíveis no nosso programa sem ter que escrever o nome da biblioteca no começo. É um pouco menos elegante, mas às vezes uma solução mais conveniente.

Na biblioteca importada, encontrará a função sleep(). Como pode imaginar, ele coloca o programa em suspensão por um período de tempo selecionado. O parâmetro é o tempo em segundos – mas pode usar frações, então se quiser colocar o programa para dormir por 200 ms, apenas escreva:

sleep(0.2)

Acima, pode até mesmo omitir 0 e digitar o mesmo sleep (.2).

Para que o LED pisque, um loop ainda será necessário. Assim como em C temos em loop de Python, while que executa até que o parâmetro seja real.

Portanto, salvamos o loop infinito:

while True:

Curiosamente, o Python não usa instruções begin/end ou chaves {} para definir blocos de código. Esse recuo é definido por blocos sucessivos do programa. Graças a isso, os programas escritos em Python devem ser bem formatados – caso contrário, eles não funcionarão.

É difícil dizer inequivocamente se é uma vantagem da linguagem ou falta de habilidades de programação dos seus criadores. Idiomas antigos também exigiam cuidadosa atenção ao posicionamento das instruções e, de alguma forma, ninguém os tratava como uma vantagem…

Usando os elementos do Python descritos aqui, pode criar um script como o blink.py:

import RPi.GPIO as GPIO
from time import *
 
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(21, GPIO.OUT)
 
while True:
    GPIO.output(21, GPIO.HIGH)
    sleep(1)
    GPIO.output(21, GPIO.LOW)
    sleep(1)

O LED irá piscar:

Semáforos em Python

Para treino adicional, vale a pena recriar o sistema de semáforos descrito na parte anterior do curso . Desta vez vamos escrever um programa similar em Python. Como antes, os díodos são conectados através de resistências de 1.2kΩ aos seguintes pinos: 16 (vermelho), 20 (amarelo) e 21 (verde).

Na prática, o layout era o seguinte:

O código do programa final ficará assim:

import RPi.GPIO as GPIO
from time import *
 
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(16, GPIO.OUT)
GPIO.setup(20, GPIO.OUT)
GPIO.setup(21, GPIO.OUT)
 
while True:
    GPIO.output(16, GPIO.HIGH)
    GPIO.output(20, GPIO.LOW)
    GPIO.output(21, GPIO.LOW)
    sleep(1)
 
    GPIO.output(20, GPIO.HIGH)
    sleep(1)
 
    GPIO.output(16, GPIO.LOW)
    GPIO.output(20, GPIO.LOW)
    GPIO.output(21, GPIO.HIGH)
    sleep(1)
 
    GPIO.output(20, GPIO.HIGH)
    GPIO.output(21, GPIO.LOW)
    sleep(1)
 
    GPIO.output(16, GPIO.HIGH)
    GPIO.output(20, GPIO.LOW)
    sleep(1)

O efeito deve ser o mesmo de antes:

Sumário

Nesta parte do curso, vimos como escrever scripts usando o Python. É uma linguagem muito simples e popular nos últimos tempos. A sua vantagem é o desempenho ligeiramente superior dos programas do que no caso de scripts de shell, mas mais importante, maior legibilidade do código.

Na próxima parte do curso, veremos os próximos fundamentos do Python, que mostrarão ainda mais vantagens dessa linguagem. Entre outras coisas, usamos um sensor de temperatura digital – comparamos como a leitura de temperatura se parece com scripts de shell e como no Python. Se já foi tentado a aprender Python (não apenas no contexto do Raspberry), então encontrará facilmente muitos livros sobre esse assunto. Ao escolher materiais para aprender, só precisa de se lembrar sobre como escolher a versão correta do Python.

___________

O que achou deste artigo? Deixe o seu comentário abaixo, e partilhe nas Redes Sociais que certamente será útil e interessante para os seus amigos!

Curso Raspberry Pi – #1 – Introdução, Índice