MicroPython é uma implementação de software da linguagem de programação Python 3 para microcontroladores. Quase todas as principais plataformas de microcontroladores são suportadas pelo firmware do MicroPython.
MicroPython facilita o desenvolvimento de sistemas embarcados de duas maneiras. Por um lado, permite aos usuários programar microcontroladores e microcomputadores em uma linguagem de programação comum (como Python, que é atualmente a linguagem de programação mais popular para o desenvolvimento de aplicações embarcadas em rede em microcomputadores). MicroPython traz a mesma sintaxe e recursos de programação para as plataformas de microcontroladores.
Em segundo lugar, Python é uma linguagem de programação de alto nível com uma sintaxe limpa e de tipo fraco, especialmente em comparação com C incorporado. Isso permite que os usuários acessem vários recursos de programação de alto nível com microcontroladores, tornando possível a programação de aplicativos incorporados em rede.
Compreendendo o MicroPython
Como MicroPython é um subconjunto da linguagem de programação Python 3, ele compartilha a mesma sintaxe e estilo de programação. No entanto, o MicroPython é destinado ao uso com microcontroladores e plataformas de hardware de baixo nível, portanto possui limitações relacionadas à linguagem.
Suas bibliotecas incluem as bibliotecas padrão reescritas do Python 3, bem como outras escritas do zero para gerenciar funções e recursos específicos de hardware. Como resultado, mesmo um desenvolvedor Python experiente pode encontrar erros de sintaxe e bugs de programação se seguir o Python padrão ao criar scripts de códigos MicroPython.
Para aproveitar ao máximo este artigo, certifique-se de carregar seu firmware MicroPython em uma placa de microcontrolador compatível, como ESP, Arduino, Raspberry Pi Pico ou Pyboard. Além disso, certifique-se de que seu ambiente de programação MicroPython inclua uPyCraft ou Thonny IDE.
A seguir, examinaremos os fundamentos da programação para ajudar os programadores MicroPython e Python a reconhecer as principais diferenças entre os dois.
Importando módulos
As primeiras instruções em um script MicroPython são módulos de importação. Cada programa MicroPython usa um ou mais módulos. Módulos de máquina e/ou tempo são usados em todos os aplicativos incorporados executados em MicroPython.
Módulos/bibliotecas já disponíveis são ideais para economizar tempo e focar em novos desenvolvimentos. Módulos ou bibliotecas são uma coleção de funções e classes escritas para tarefas/aplicações específicas e são excelentes para organizar blocos de código semelhantes e relacionados. Os desenvolvedores também podem escrever seus próprios módulos para adicionar ou oferecer suporte a novas funções e recursos.
Nos scripts MicroPython, os módulos são importados usando esta sintaxe:
importar nome_do_módulo
Como os códigos MicroPython normalmente são carregados em microcontroladores que possuem RAM e memória flash limitadas, é possível importar classes específicas de um módulo usando esta sintaxe:
de module_name importar class_name
Na verdade, diversas classes de um módulo podem ser importadas em uma única instrução usando:
de module_name importar class_name1, class_name2
Aqui estão alguns exemplos de importação de módulos no MicroPython:
máquina de importação
do Pin de importação da máquina
da importação da máquina Pin, PWM
da importação da máquina, Pin, PWM, ADC, ADCBlock
Tipos de dados
Assim como o nome indica, os tipos de dados são os tipos de dados suportados em uma linguagem de programação. Os tipos de dados especificam o tipo de valor e quais operações podem ser realizadas nesse tipo.
Existem cinco tipos de dados suportados no MicroPython:
1. Inteiros (int): armazena números inteiros positivos e negativos, incluindo zero
2. Flutuar (flutuar): armazena números decimais positivos e negativos, incluindo zero
3. Sequência (str): armazena um conjunto de caracteres de texto entre aspas
4. Booleano (bool): armazena True ou False — uma expressão que resulta em um valor diferente de zero é considerada True e uma expressão que resulta em um valor igual a zero é considerada False.
5. Objeto (obj): uma instanciação de uma classe, que fornece acesso a todas as propriedades e métodos de uma classe especificada
Muito parecido com o Python, o MicroPython é uma linguagem de tipo fraco. Isto significa que as variáveis não devem ser declaradas explicitamente com tipos de dados específicos. Em vez disso, as variáveis podem ser instanciadas em qualquer lugar do código e o tipo de dados é assumido com base no valor atribuído a elas.
No entanto, o tipo de uma variável pode ser confirmado chamando o método type(variable), que é útil se a validação de dados for necessária.
Variáveis
Variáveis são os espaços reservados para valores de dados. O valor armazenado em uma variável pode mudar durante um programa.
No MicroPython, o tipo de dados para as variáveis não precisa ser definido e é instanciado atribuindo um valor a um identificador.
Exemplos:
novoPWMfreq = 10
defPWMfreq = 1000
msg = “Dados registrados no cartão SD”
As variáveis podem ser instanciadas em qualquer lugar do código. Seu tipo de dados é automaticamente assumido ou alterado com base no valor atribuído a ele.
As variáveis para instanciar objetos de classe são definidas por atribuição à função construtora. Por exemplo, esta instrução instancia uma variável como um objeto pin:
led = Pino (5, Pino.OUT)
Os identificadores usados como nomes de variáveis devem começar com uma letra ou sublinhado e podem conter números, letras e sublinhado. Embora caracteres especiais não sejam permitidos em nomes de variáveis. Por convenção, as funções e classes devem ter identificadores em forma de camelo e as variáveis devem ter todos os identificadores em minúsculas.
Exemplos de nomes de variáveis válidos:
liderado
led2
adc1_2
Exemplos de nomes de variáveis inválidos:
1led
levou&1
Comentários
Os comentários são uma excelente forma de documentar scripts. MicroPython permite comentários no estilo shell, que são comentários de linha única começando com o caractere hash (#). Tudo, desde o caractere hash até o final da linha, é considerado um comentário e não faz parte do script executado.
Em scripts MicroPython, os comentários devem ser usados apenas minimamente ou se forem inevitáveis. Isso ocorre porque um grande número de comentários no código pode aumentar significativamente o tamanho do script de execução e comprometer a memória flash da porta de destino. (Observação: os arquivos de script são carregados na memória flash do microcontrolador de destino.) Eles também não são convertidos em um executável como ocorre em outras linguagens de programação, como C incorporado.
Exemplos de comentários do MicroPython:
led = Pino (5, Pin.OUT) #LED conectado ao GPIO5
#função para ler dados do sensor via UART
Operadores matemáticos
MicroPython permite operações aritméticas. Os operadores matemáticos suportados incluem: adição (+), subtração (-), multiplicação
divisão (/), resto após divisão (%) e divisão descartando ponto decimal (//).
Operações matemáticas e constantes adicionais podem ser acessadas importando o módulo matemático. O módulo fornece duas constantes: math.e e math.pi.
As funções disponíveis no módulo matemático do MicroPython incluem: math.acos(x), math.acosh(x), math.asin(x), math.asinh(x), math.atan(x), math.atan2(y, x), math.atanh(x), math.ceil(x), math.copysign(x, y), math.cos(x), math.cosh(x), math.degrees(x), math.erf (x), math.erfc(x), math.exp(x), math.expm1(x), math.fabs(x), math.floor(x), math.fmod(x, y), matemática. frexp(x), math.gamma(x), math.isfinite(x), math.isinf(x), math.isnan(x), math.ldexp(x, exp), math.lgamma(x), matemática .log(x), math.log10(x), math.log2(x), math.modf(x), math.pow(x, y), math.radians(x), math.sin(x), math.sinh(x), math.sqrt(x), math.tan(x), math.tanh(x) e math.trunc(x).
Exemplos de operadores matemáticos:
5*8+9
>>>49
589/256
>>>2.3007815
2022%4
>>>2
Operadores relacionais
Os operadores relacionais são utilizados para comparação de valores. Esses operadores são úteis para escrever expressões de instruções condicionais.
Os operadores relacionais suportados no MicroPython incluem: igual a (==), diferente de (!=), maior que (>), menor que (<), maior ou igual a (>=) e menor ou igual para (<=).
As expressões que utilizam operadores relacionais utilizam apenas dois operandos, que são colocados em cada lado do operador relacional. O resultado de uma expressão de um operador relacional é sempre Verdadeiro ou Falso.
Exemplos de operadores relacionais:
5>3
>>> Verdade
2/3 = 1,5
>>> Verdade
5,3 >= 5,3
>>> Verdade
Declarações condicionais
Declarações condicionais são usadas para avaliar as condições com base na comparação de valores. Dois valores são comparados em uma expressão usando operadores relacionais. O resultado da expressão é Verdadeiro ou Falso. Se o resultado da expressão relacional for True, o corpo da condição será executado — caso contrário, será ignorado durante a execução do programa.
No MicroPython, a comparação pode ser entre valores inteiros e strings. Os métodos chamados para um objeto também podem retornar True ou False. O corpo da condicional inclui uma ou várias instruções de programa.
Ao contrário do C incorporado, o corpo da condicional não está entre colchetes. Em vez disso, seu objetivo é agrupar um único bloco de código. Somente o uso de dois pontos é necessário após a expressão condicional.
Existem três instruções condicionais suportadas no MicroPython: 1. declaração if:
testa uma única expressão e executa ou ignora um bloco de código, dependendo do resultado.
Um exemplo válido de MicroPython quando a instrução “if” é condicional:
uma = 1
b = 2
se (uma == b):
imprimir(“a e b são iguais”) 2. instrução else:
testa uma única expressão e executa ou ignora um bloco de código, dependendo do resultado. Se a expressão for False, um bloco de código será definido após a execução da instrução “else”.
Um exemplo válido de MicroPython quando a instrução “else” é condicional:
uma = 1
b = 2
se (uma == b):
imprimir(“a e b são iguais”)
outro:
print(“a e b não são iguais”) 3. declaração elif:
testa múltiplas condições e, com base em uma correspondência, executa um dos blocos de código. Depois que uma expressão é correspondida, um bloco de código para a expressão fornecida é executado e o programa sai da condição.
Um exemplo válido de MicroPython quando a instrução “elif” é condicional.
uma = 3
se (uma == 0):
imprimir(“a é igual a 0”)
Elif (uma == 1):
imprimir(“a é igual a 1”)
Elif (a == 2):
imprimir(“a é igual a 2”)
Elif (a == 3):
imprimir(“a é igual a 3”)
outro:
print(“a não recebe nenhum valor”)
No MicroPython, um recuo requer apenas dois espaços (um recuo em Python3.x usa quatro). Isso é feito para minimizar o tamanho do script de execução, pois ele deve ser carregado em microcontroladores com restrição de memória.
Classes e objetos
Assim como Python é uma linguagem de programação orientada a objetos, o MicroPython também o é, que é uma reimplementação do Python 3. Na programação orientada a objetos, as entidades da vida real são primeiro modeladas como objetos. A definição de um modelo para determinados objetos é chamada de classe.
Os atributos dessas entidades são especificados com a ajuda das variáveis associadas a uma determinada classe. Essas variáveis são chamadas de propriedades ou atributos. As operações computacionais associadas às entidades são expressas como as definições de funções associadas à classe dada. Essas funções são chamadas de métodos.
No MicroPython, a definição de uma classe começa com a palavra-chave “class”, seguida pelo nome da classe e um par de parênteses. O nome da classe é seguido por dois pontos (:) para iniciar a definição da classe.
O protótipo de uma classe em MicroPython:
classe nome_classe :
definição_classe
A definição de uma classe inclui a instanciação das propriedades/atributos associados, um construtor e a definição dos métodos específicos da classe. As propriedades ou atributos são instanciados como variáveis com o corpo de uma determinada classe.
Exemplo:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
No código acima, pin, temp e hum são as propriedades/atributos da classe DHT11. Se as propriedades/atributos forem referenciadas na definição da classe, a palavra-chave “self” será usada. Fora da definição da classe, os atributos são acessados pelo nome do objeto, seguido de um ponto (.) e do nome do atributo.
Um exemplo válido de chamada de um atributo dentro de uma definição de classe:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
def getTemp :
….
self.temp = temp
imprimir(self.temp)
Um exemplo válido de acesso aos atributos de uma classe fora de sua definição:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
dht = DHT11
currentTemp = dht.temp
A definição de uma classe pode incluir um ou vários métodos. Os métodos são usados para realizar operações computacionais em atributos de classe e/ou variáveis globais. Os métodos são definidos como funções dentro de um corpo de classe.
Exemplo de definição de um método para uma determinada classe:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
def getTemp :
retornar self.temp
Se um método precisar ser acessado dentro de uma definição de classe, a palavra-chave “self” será usada. Se precisar ser acessado fora da definição de classe, ele deverá ser chamado pelo nome da classe, seguido de um ponto (.) e do nome do método.
Exemplo de chamada de método dentro de uma definição de classe:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
def getTemp :
retornar self.temp
def printTemp :
temperatura = self.getTemp
imprima(“Temperatura:“)
imprimir (temperatura)
Exemplo de chamada de método fora de uma definição de classe:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
def getTemp :
retornar self.temp
dht = DHT11
temperatura = dht.getTemp
Os valores dos atributos obrigatórios de uma classe podem ser atribuídos assim que um objeto de uma determinada classe for instanciado. Isso primeiro requer a definição de um método construtor. O método construtor define explicitamente os valores padrão para os atributos ou atribui os valores dos atributos essenciais passando argumentos.
O método construtor é definido usando a função __init__ . Se o valor dos atributos for definido pelo usuário, a definição do construtor utiliza um ou mais parâmetros.
Exemplo de construtor que define explicitamente os valores dos atributos:
login de classe :
nome de usuário = usuário
senha = senha
def __init__ :
self.user = “root”
self.password = “framboesa”
logcredenciais = login
Exemplo de construtor que permite ao usuário especificar o valor dos atributos de classe necessários:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
def __init__(pino):
pino = self.pin
dhtpin = Pino (5, Pino.IN)
dht11 = DHT11(dhtpin)
Um objeto de uma determinada classe é instanciado chamando o método construtor. Fora da definição da classe, o método construtor tem o mesmo nome que o nome da classe.
Um exemplo válido de definição de uma classe, instanciando um objeto da classe e usando seus atributos e métodos:
classe DHT11 :
pino = 0
temperatura = 0
hum = 0
def __init__(pino):
pino = self.pin
def getTemp :
….
def getHumdity :
….
dhtpin = Pino (5, Pino.IN)
dht11 = DHT11(dhtpin)
dht11.getTemp
dht11.getHumidity
se dht11.temp > 25:
…
Conclusão
Neste artigo, cobrimos os fundamentos da programação MicroPython, um subconjunto do Python 3 – o que significa que o MicroPython compartilha grande parte da mesma sintaxe e programação orientada a objetos do Python 3. No entanto, existem pequenas diferenças e os desenvolvedores Python podem enfrentar erros de sintaxe e bugs se eles aplicarem seu conhecimento de Python apenas ao domínio MicroPython.
Os fundamentos dos recursos de programação da sintaxe Pythonic são aplicáveis em scripts MicroPython, que são abordados neste artigo. Esses princípios básicos da linguagem podem servir como base para seus scripts MicroPython.
