O projeto Franzininho tem o objetivo de incentivar as pessoas nas áreas de eletrônica e programação. Através das oficinas de soldagem e programação na Arduino IDE, diversas pessoas tiveram o seu primeiro contato com essas áreas.
https://www.instagram.com/fabiosouza.io
https://www.youtube.com/channel/UCPrc3wf0Rib6_BXqbTyuY2Q
Sempre buscamos despertar o interesse de futuros profissionais para as áreas de sistemas embarcados. Uma das formas que consideramos importante para quem pensa em trabalhar com sistemas embarcados no futuro é aprender a programar olhando para a arquitetura do microcontrolador.
A placa Franzininho DIY é uma ótima ferramenta para os primeiros passos com linguagem C e aprender conceitos fundamentais para entrar com os dois pés na programação de microcontroladores.
Esse artigo tem o objetivo de mostrar os primeiros passos para programação de microcontroladores usando linguagem C e com abordagem mais próxima ao hardware.
Serão apresentados uma sequência de exemplos para programação da Franzininho DIY usando a AVR Libc.
Conhecendo o microcontrolador ATtiny85
O ATtiny85 é um microcontrolador de 8 bits da familia AVR da Microchip. Possui 8 KB de memória Flash, 512B de EEPROM, 512B SRAM, 6 GPIO, conversor A/D de 10 bits e opera a 20 MIPS em 20 MHz. Também possui comunicação I2C e saídas PWM. A figura 1 exibe o pinout do ATtiny85.
Apesar de a quantidade de pinos ser bem restrita, é possível realizar diversas aplicações interessantes com ele. Na figura 2 temos o diagrama de blocos do ATtiny85.
Com essa arquitetura simples (mas poderosa) podemos aprender diversos conceitos sobre programação de microcontroladores e fazer aplicações otimizadas para diversas áreas.
Pinout da placa Franzininho DIY
É importante que você tenha o pinout da Franzininho DIY sempre acessível para saber quais pinos e recursos irá utilizar (figura 3).
Note que mapeamos os recursos de cada pino nesse pinout.
Ferramentas necessárias
Você não precisará de um compilador específico ou IDE para compilar os exemplos apresentados. Porém, é importante que tenha as seguintes ferramentas instaladas na sua máquina:
• GCC AVR
• avr libc
• binutils-avr
• make
Arduino IDE
Caso você não queira montar o seu ambiente de desenvolvimento, todos os códigos apresentados podem ser compilados diretamente na Arduino IDE com a correta configuração para a Franzininho DIY: https://franzininho.github.io/docs-franzininho-site/docs/franzininho-diy/pacote
Wokwi
Você também pode usar o simulador Wokwi para reproduzir os projetos apresentados nessa série. Aproveite o template de projeto: https://wokwi.com/arduino/new?template=franzininho
Hello, World! Em linguagem C com AVR LibC
Esse exemplo básico nos dará estrutura para todos os nossos exemplos daqui para frente. Como já mencionado, usaremos a linguagem C em conjunto com a biblioteca AVR LibC. Para esse exemplo você só precisará da placa Franzininho DIY e as ferramentas de softwares listadas anteriormente.
O código a seguir exibe a estrutura mínima de um programa em linguagem C para microcontroladores. Se você tem dificuldades com a linguagem C, recomendo que confira os seguintes materiais:
• Playlist Linguagem C - https://www.youtube.com/watch?v=l9ZdS8kph0A&list=PLqY1DITQ0sB_5yUBqhnm37J5PxsjrVPKT
• Slideshare - https://www.slideshare.net/FabioSouza9/resumo-linguagem-c-para-microcontroladores-pic-usando-mikroc
Nesse momento é importante que você se atente a estrutura do código. Vamos usar alguns registradores para acionar o LED, mas não serão o foco da explicação. Confira os comentários no código a seguir:
/**
* @file main.c
* @author Fábio Souza
* @brief Exemplo para blink LED na placa Franzinino
* @version 0.1
* @date 2021-02-03
*
* @copyright Franzininho
* This example code is in the Public Domain (or CC0 licensed, at your option.)
* Unless required by applicable law or agreed to in writing, this
* software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <avr/io.h>
#include <util/delay.h>
#define F_CPU 16500000L
/**
* @brief Função main
*
* @return int
*/
int main(void)
{
DDRB |= (1 << PB1); // Configura Pino PB1 como saída (Pino do LED)
/**
* @brief loop infinito
*
*/
while (1)
{
PORTB |= (1 << PB1); // Liga LED
_delay_ms(500); // delay 500 ms
PORTB &= ~(1 << PB1); // desliga LED
_delay_ms(500); // delay 500 ms
}
return (0);
}
No próximo exemplo vamos detalhar sobre os registradores de IO. Nesse momento, além da estrutura inicial é importante que você entenda como usar a função _delay_ms().
Essa função espera o tempo passado em milissegundos.
Altere o código para que o LED fique 100 ms (on) e 1000 ms (off), veja o efeito.
Simule esse exemplo em: https://wokwi.com/arduino/projects/302846728334213645?view=diagram
Trabalhando com Saídas Digitais
O ATtiny85 possui 8 pinos, sendo que 6 deles podemos usar como I/O (entradas ou saídas) digitais. Os pinos de I/O são nomeados conforme a porta que eles pertencem. Na figura 1 vimos que os pinos do ATtiny85 são nomeados de PBx, onde x é o número correspondente ao pino no registrador (não se preocupe, veremos mais detalhes a seguir).
Cada pino de I/O pode ser usado como entrada ou saída e também como outras funções, nesse momento só vamos trabalhar com os pinos funcionando como GPIO (General Porpouse Input/Output).
Conforme exibido na imagem acima, temos os seguintes pinos disponíveis no ATtiny85:
PB0, PB1, PB2, PB3, PB4, PB5.
Registradores responsáveis pelos pinos de I/O
Para trabalhar com os pinos de I/O no ATtiny85 temos 3 registradores:
• PORTB: Registrador de dados. Responsável pela escrita nos pinos;
• DDRB: Registrador de direção do pino. Responsável pela configuração dos pinos para definir se será entrada ou saída;
• PINB: Registrador de entrada da porta. Responsável pela leitura do estado do pino.
Note que todos os registradores terminam com B no final. Isso significa que estamos trabalhando com o PORTB. Caso fosse um microcontrolador com maior quantidade de pinos teríamos os finais A, B, C, etc. Cada porta só possui no máximo 8 pinos.
Na seção 10 do datasheet do ATtiny85 temos todos os detalhes para se trabalhar com os I/O. A tabela a seguir, retirada do datasheet, exibe as configurações possíveis para os pinos:
A figura abaixo exibe os registradores responsáveis pelos pinos de I/O do PORTB:
Note que cada bit dos registradores é responsável por pino sendo indexado pelo número correspondente ao bit. Dessa forma, se quisermos usar o pino PB1 para acionar o LED, devemos configurar o registrador DDRB da seguinte forma:
E para acionar ligar/deligar o LED devemos colocar 1 ou no bit correspondente no PORTB.
Vamos a um exemplo para ficar mais claro.
/**
*
* @file main.c
* @author Fábio Souza
* @brief Exemplo para acionamento do LED na pino PB1
* @version 0.1
* @date 2021-02-03
*
* @copyright Franzininho
* This example code is in the Public Domain (or CC0 licensed, at your option.)
* Unless required by applicable law or agreed to in writing, this
* software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <avr/io.h>
#include <util/delay.h>
#define F_CPU 16500000L //frequência do oscilador. usado para a função de delay
/**
* @brief Função main
*
* @return int
*/
int main(void)
{
DDRB = 0b00000010; // Configura Pino PB1 como saída (Pino do LED)
/**
* @brief loop infinito
*
*/
while (1)
{
PORTB = 0b00000010; //liga LED
_delay_ms(250); // delay 250 ms
PORTB = 0b00000000; //desliga LED
_delay_ms(250); // delay 250 ms
}
return (0);
}
O exemplo acima pisca o LED em intervalos de 250 ms. A configuração do pino PB1 como saída foi feito colocando o bit1 de DDRB em 1. Já para ligar e desligar o LED foi manipulado o bit 1 de PORTB, hora em 1 hora em 0.
Projeto disponível em: https://github.com/Franzininho/exemplos-avr-libc
Confira a simulação em: https://wokwi.com/arduino/projects/302847336216789517?view=diagram
Conclusão
Os exemplos apresentados apresentam os primeiros passos para programar a Franzininho DIY em linguagem C. Você pode se aprofundar no estudo e aplicações em linguagem C com o microcontrolador ATtiny85 da Franzininho DIY. Como você pode observar o código compilado é bem pequeno, porém é necessário ter um conhecimento maior sobre os registradores e a configurações corretas dos mesmos. Fica como incentivo que você continue a explorar os demais exemplos da documentação do projeto Franzininho e crie aplicações com essa abordagem de programação.
Confira mais exemplos em linguagem C:
https://franzininho.github.io/docs-franzininho-site/docs/franzininho-diy/exemplos-avr-libc/primeiros-passos
