IoT

Muitos projetos de sistemas embarcados iniciam-se com uma ideia que começa a se materializar com um protótipo feito de gambiarras e fios enroscados, com componentes prontos conectados em uma protoboard e o software, a menos que o programador já seja experiente e já tenha produtos em funcionamento no mercado, acaba indo pela mesma linha de empilhamento caótico de testes de funcionalidades, bibliotecas, funções, trechos comentados e outros problemas de desorganização de código que são aceitáveis para um protótipo. Porém, conforme o projeto começa a caminhar para a solução final, o código precisa estar cada vez mais limpo e eficiente. E também para alcançar a eficiência máxima após todo o código estar otimizado, será necessário remover o framework. Mas por quê?

Diferença entre framework, API e bibliotecas

A primeira coisa que deve-se conhecer para entender até que ponto frameworks ajudam ou atrapalham, é saber o que exatamente é um framework e quais as diferenças para API ou bibliotecas.

O framework é basicamente um conjunto de códigos que irá receber e executar o código que foi desenvolvido por você, sem que os códigos originais sejam alterados, apenas utilizando as funcionalidades que ele já possui. Já a API não utiliza o seu código, irá apenas receber comandos que serão processados e então, devolver uma resposta, não havendo, assim, injeção de código na API. Por fim, a biblioteca é um código pronto que será injetado no seu, dando mais liberdade de uso e controle.

Lembrando que o uso de qualquer uma delas deve ser sempre feito com cuidado, pois nem sempre estão realmente otimizados, podendo causar mais problemas no código do que soluções.

Veja como é programação para microcontroladores: otimizando o código

Quando usar ou não frameworks

O uso do framework traz a vantagem de já entregar praticamente tudo pronto, um esqueleto que receberá o código do desenvolvedor, sem que ele se preocupe como acessar pinos, ou procedimentos de segurança, validação de valores antes de serem gravados nos registradores, pois já foi tudo preparado e testado, o que é ótimo para se iniciar um projeto onde é essencial velocidade para realizar uma prova de conceito para investidores, ou demonstrar a empresa um novo produto em potencial, mas que por outro lado traz também o problema de deixar o programador tão distante do hardware que o ajuste fino e torna difícil, uma vez que é necessário um controle maior do hardware. Portanto, quando o programa necessita de uma eficiência maior (menos memória de armazenamento, menos memória de programa e maior velocidade de execução) é necessário, então, remover o framework e passar a programar num nível mais baixo.

Programação para microcontroladores: adicionando precisão com interrupções


Ao remover o framework iremos otimizar o tamanho do código, pois iremos remover grandes encadeamentos de chamadas de funções, diminuindo o tempo de execução da atividade e a memória necessária para o armazenamento do programa, que pode ser observado, por exemplo, no acionamento de um pino, onde o framework faz uma série de chamadas de funções de validação de modelo do microcontrolador, de valores possíveis de pinos e valores antes de acionar o registrador, que irá por sua vez acionar o pino, gerando muitas linhas de código de linguagem de máquina após a compilação, necessitando assim, de mais memória para guardar o programa e desperdiçando mais ciclos do microcontrolador para realizar o acionamento, diminuindo o tempo de resposta do programa que poderia ser feito com apenas algumas linhas.

Realidade atual

Atualmente, o framework mais utilizado é o do Arduino (lembrando que Arduíno é uma marca que possui um framework próprio, placas de desenvolvimento IDE, entre outros produtos) que leva o nome da própria empresa, devido à facilidade do uso não só do framework mas também da IDE que será utilizada em conjunto e a grande quantidade de placas de desenvolvimento e microcontroladores já suportados, incluindo o microcontrolador tomado como base de estudos no primeiro artigo o Atmega328p.

Existem opções para a IDE como o VScode utilizando o plugin PlatformIO que trazem a funcionalidade do autocompletar e identação automática, porém, o plugin do PlatformIO utiliza também o framework do Arduino como base, sendo necessário migrar para uma IDE mais específica que será o Microchip Studio (antigo AtmelStudio antes da Atmel ser comprada pela Microchip), que é a IDE oficial da fabricante do Atmega328p, que é a Atmel que faz parte da Microchip.

Apesar de remover o framework não iremos remover agora o bootloader, que é o programa que já vem gravado nos microcontroladores presentes nas placas de desenvolvimento da Arduino, que é responsável pelo carregamento e gravação do programa via USB, pois sem ele, precisamos de um gravador oficial da Atmel para realizar a gravação pelos pinos específicos, possuindo um custo bastante elevado que tornaria o conhecimento desse artigo menos acessível, mas que é uma ótima opção para o desenvolvimento avançado, pois permite o debug de um código e um monitoramento mais preciso do microcontrolador.

Microcontroladores: o que considerar na hora de escolher?

Colocando a mão na massa: Migrando para o Microchip Studio

A primeira coisa a se fazer, é ir no site da Microchip e baixar o Microchip Studio. É fácil de encontrar com uma busca rápida no Google, mas o compartilharei o link ao final do artigo.

Após instalar o Microchip Studio, a próxima coisa a se fazer é abrir a IDE do Arduino, pois, é lá que iremos pegar o comando para gravar o programa já compilado via bootloader, que será utilizado pelo Microchip Studio (quem irá compilar e disponibilizar os drivers será o próprio Microchip Studio).

Em seguida execute a seguinte sequência de passos para obter o comando: 

Primeiramente abra um exemplo de blink e conecte a placa com cabo USB no computador.


O próximo passo é ir na janela de preferências e ativar a saída de mensagem durante o carregamento, e assim, veremos qual comando foi executado e se será esse comando que iremos copiar.

Em seguida, clique para carregar o programa para sua placa conectada ao computador e observe a saída, pois lá aparecerá qual o comando de upload foi utilizado. Copie-o e cole em qualquer editor de texto, pois iremos editá-lo antes de inserir no Microchip Studio. Certifique-se de que realmente copiou todo o comando até o fim.

E o último passo antes de abrir o Microchip Studio, será editar o comando para que possa ser utilizado para os padrões do projeto da nossa nova IDE. Seu comando deve ser semelhante a este:

D:\ProgramFiles(x86)\Arduino\hardware\tools\avr/bin/avrdude -CD:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf -v -patmega328p -carduino -PCOM6 -b115200 -D -Uflash:w:C:\Users\moise\AppData\Local\Temp\arduino_build_281782/Blink.ino.hex:i

Para entender melhor o que está sendo feito nesse comando vamos parti-lo em seções:

  • D:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude é a execução do programa responsável por fazer o carregamento do programa via USB que foi instalado junto com a IDE do Arduino
  • -CD:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf é o caminho do arquivo de configuração contendo os parâmetros de carregamento do programa
  • -patmega328p Seleciona o tipo de microcontrolador
  • -PCOM6 Porta em que se encontra a placa de desenvolvimento
  • -b115200 baudrate da gravação do programa
  • -Uflash:w:C:\Users\moise\AppData\Local\Temp\arduino_build_281782/Blink.ino.hex:i local do arquivo final compilado

Em seguida vamos editar o caminho do arquivo final trocando o caminho da pasta por “$(ProjectDir)Debug”, que será substituído através do Microchip Studio pelo respectivo nome da pasta do projeto. O nome do arquivo deve ser substituído por “$(TargetName).hex” que será alterado pelo nome do arquivo final automaticamente. Por fim, adicionar a extensão “.exe” ao nome do programa de carregamento. Aplicando as modificações ao comando de exemplo, o comando final ficaria:

D:\ProgramFiles(x86)\Arduino\hardware\tools\avr/bin/avrdude.exe 

-CD:\Arduino\hardware\tools\avr\etc\avrdude.conf -v -patmega328p -carduino -PCOM6 -b115200 -D -Uflash:w:$(ProjectDir)Debug/$(TargetName).hex:i

O próximo passo é abrir o Microchip Studio, clicar em File->New->Project… e escolher a opção “GCC C++ Executable project, para criarmos um novo projeto em C++ (ou se preferir, pode criar um projeto executável em C ). Dê o nome que preferir ao projeto, no caso do exemplo deste artigo será nomeado “Blink”.

Na lista de microcontroladores que aparecerá em seguida, escolha Atmega382p como configuração para esse projeto

Com o projeto aberto, vá no menu Tools e clique na opção “External tools…” e na janela que abrir em seguida, você irá preencher os campos com o comando final que foi obtido da IDE do Arduino e modificado, onde no primeiro campo será o nome da configuração, que nesse exemplo será “Atmega328p_with_bootloader”. O segundo campo será o caminho para o programa de gravação via USB (AVRDude), e o terceiro é todo o restante do comando modificado que são os argumentos do programa indicado no primeiro campo. Por último marque a opção “Use Output Window” para que possamos ver a saída e no final ficará semelhante as imagens abaixo:

Agora basta clicar em OK e acrescentar o seguinte código ao main.cpp


Por fim, vá no menu Build e selecione Build Solution ou pressione F7 para compilar todo o projeto e ao final, o arquivo .hex será criado para a pasta Debug, que será carregado para a nossa placa. Após a finalização com sucesso, vá em Tools e escolha a opção que possui o nome que foi dado ao comando que utiliza o AVRDude

Após todos os passos, se foi utilizada uma placa de Arduino, você deverá ver o LED de teste piscar a cada um segundo com um segundo de duração, significando que o programa foi carregado corretamente.


Vantagens

Logo de cara dá pra notar a grande redução da quantidade de bytes do programa para realizar a mesma tarefa, quando se usa as funções prontas do framework. Quando não se usa essas funções prontas, mas que ainda utilizar o framework para inserir o código, e quando o código é compilado apenas especificamente para o microcontrolador através da IDE da fabricante, como pode ser observado nas imagens abaixo:

Utilizando as funções prontas

Utilizando acesso direto mas ainda inserido no framework


Diretamente na IDE da fabricante sem o framework

Essa redução do tamanho do programa também significa menos instruções a serem executadas antes de ser executado de fato a parte que importa, tornando o tempo de resposta muito menor e adicionando mais estabilidade e precisão ao programa, podendo reduzir intervalos entre acionamento de pinos da casa de microssegundos para nanosegundos.


Desvantagens

Como a finalidade da IDE é a utilização do programador especial para microcontroladores da Microchip, o uso desse comando limita a porta que será usada, pois está escrita diretamente no comando de carregamento, ou seja, quando for necessário utilizar outra porta USB o comando deve ser editado e a nova porta deve ser inserida.

O segundo problema é que o Microchip Studio não suporta comandos que possuam espaços no caminho e acaba separando por espaços e quebrando o comando, portanto, a instalação do avrdude deve ficar em um caminho sem espaços no nome, sendo necessário mover a pasta da IDE do Arduino ou uma segunda instalação do avrdude em outra pasta a partir do instalador do site oficial do avrdude.

Conclusão

Apesar das desvantagens de configuração, o incremento de eficiência do programa pode ser facilmente percebido já no momento de compilação, faltando apenas o programador especial para permitir um debug e então tornar todo o processo de desenvolvimento profissional, abrindo assim, portas para a criação de um produto final pronto para mercado.

Se gostou do conteúdo, acompanhe o LinkedIn da Vsoft para receber mais novidades sobre o assunto e também acompanhar novos artigos publicados pelo time de Ambassadors.

Author

Moisés Cavalcanti

Posts relacionados

Todos os posts
go  top