Programação de microcontroladores: removendo o framework
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fda6af3af968432c80da5_remover-framework.jpg)
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.
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbb4b675dd9a0bb732f7b_WxOvKOBuFMof8vcaiyxDX46ibyjiHa_fgK-7Se5l2XW6pVOkJJiIR6RTb7AWU8V8_aHUNbQunW-_k_MqJGtZBZnlvPlMLl-Qw4mGIrdHr2aBxvRICjcPkT-jSN7ioIxVD8S4nqOu%3Ds0.png)
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.
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/63406deecc695c41e52ee920_framework%20(1).png)
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.
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbc17f14e1d5d961cc6c8_tlGgohbp4rk2QEzlVwcziC7Ji8Ia7m8HFW85k8Lv_K-CbJkDU8s9908retYFBZrZHDyVWnQXiE6QFdRbfvdYMQlQ8JKml6jhoPGCtigSrNVTtSuEWiTlGhUh5F3pXL8J8IZzp9X6%3Ds0.png)
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”.
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbca23a662e488d9a0bb4_SORhxgtIEagEOCdfHMhnLcxd8atDJcP_1EZu9I1xH9QgOIWnSSgzbZG8yFe4xpnPlrrJbcxVVXuBS0CkzQCJkRGWmATnVgqFXZ5ol5zqLLX7xYpOzVaK3nPd7g2j-c2du1Vt9SR6%3Ds0.png)
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbcac6e79c80eb71b04f1_9rzoB6p1sgvktI0nmAwi8qM8bYH9Dj9MIo2BCC6jCjZwVsMudI-gAMRqGfXci4n97kG4kpDgXpjYwqCpqJHbz1bOKD5qo_Q32ym7qkQyquL-AM8TpmOMTM5XsBBH154SJ0FfrOdN%3Ds0.png)
Na lista de microcontroladores que aparecerá em seguida, escolha Atmega382p como configuração para esse projeto
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbcc7b48bca5dadbc7a54_GRxvD5l779-cKCkaePZKC3CXP8fVhj3u299YbHvsgyJawmPVKaf1m5ieQBW_g908i8Iz93SJDyhFjHQHwudoHb0-FO3pJ7UwHJninag2JusQG_sFIqUHNQJq8tIvwT_W7HrnDxeo%3Ds0.png)
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:
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbcda7bfbfd25f0ed1a95_Mhbvy_Q0jsKLxJ9zAVXC6rTqkxDIsgsVhvQHECbpmnsU7XV9ib0MfYUz7HSifjJOKqdKWMThKmDWGKFB9pLgGdfdFZnCoL5xfyUUX1WtLbMdVk1knXy3kZggHSNnp880wvwGngfj%3Ds0.png)
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbce2c965da5b31809709_J-yvVUSyWYLJby_RmnK7j3DhO0vdJqEcDCgMY1YzV1Q2a5iDcmGD3fPi6z5LWftfXMtP3zC1XaniOSy246NxjDqi3C_mC4kpPehck0P3sYxwyjkynOaCLwCZGk1AkDea46LQcfnX%3Ds0.png)
Agora basta clicar em OK e acrescentar o seguinte código ao main.cpp
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbd815a2f210d59f5fc36_codigos.jpg)
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
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbdb07a3561d08e22d059_acFL4WBOnYMbFXnT7qKKF5qEURssyFmRIn7ipD7nkyl2f4Q2k-KLrf1NmmoxxD6ZazqpLBp54V2ar5zCSXKCVorOX_senarz_4aarJZq-lAyJ-pg586sJVSZnsi2ojn85NCbBnWO%3Ds0.png)
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:
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbdcbb8966c699d63de5a_bhkrjV6_a0QrHCDTv5jDv2pWaBZPQprBitlG_EZvQRh45ebZVKSySaepVpSVltbiJ4g2N5QLFN44DL8gHsmUk4qWBVm4J2qobGlNpcKiyHmtxYeuRyAo0ONKq9VFaSDipF6woz68%3Ds0.png)
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbddb6ba96f75a29df2e2_kecMfrhwXfG3sMB6N9BinAtZ7umNdewnoqQCozLs3qBnPsUwjRQuJOCTOY0EfoEjz9TQzOuNWZAuZkRP6YVWLC1gRt9H_HzPw4dYyJkwAdio1MbIcCwk1MJlHWbp1AoiMoAdQ9Lr%3Ds0.png)
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/612fbdeca8e7432d10d959e0_qS6T8hN6gBSffWq1BUC0PS8YuAweExF_XyLJqNiUXziqKLqqpEcA5awE_E_VB3pUNNIicmxs-tJq7xne4-gFb4Cji1qg5ZKUkYN36tHlb4h-NjVKJ5K_skgt5FccdRplsD5-liWV%3Ds0.png)
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.
![](https://cdn.prod.website-files.com/5f22d3200e71bc31364b77b1/669822044c232212fd04ca76_Moises%20Bezerril.jpg)
Moisés Cavalcanti
Não perca as nossas atualizações!
Assine para receber a newsletter da Vsoft e fique por dentro do mundo da identificação e tecnologia.