ATtiny85 - Primeiros passos
ATtiny85 - Primeiros Passos
Precisa criar projetos pequenos e com baixo consumo energético? Neste tutorial vamos apresentar o ATtiny85, um pequeno Microcontrolador (MCU) de 8 pinos, que pode ser programado pela Arduino IDE!
[toc]
O ATtiny85
Este pequeno MCU, apesar de ser inferior em relação ao desempenho quando comparado diretamente ao existente em uma placa Arduino UNO (ATmega328P). O ATtiny85 é útil em diversos projetos, entre eles, os portáteis, os de baixo consumo energético, os que utilizam poucos pinos, robôs e até em pequenos módulos separados de uma central, que por sua vez, se comunicaria com o ATtiny85 através de I2C, SPI ou UART (Serial), para controlar itens específicos, como por exemplo, uma placa de reles.
Características
- Tensão: 1,8V a 5,5V.
- Clock interno: 1MHz - 8MHz.
- Flash: 8KB.
- RAM: 512B.
- EEPROM: 512B.
- Digital Pins: 6.
- Analog Input (ADC): 4 canais de 10bit.
- PWM: 3 canais de 8bit.
- UART: 0.
- I2C: 1.
- SPI: 1.
Mapa de pinos
Em muitos projetos simples que fazemos, não usamos nem metade dos pinos do Arduino UNO por exemplo. Assim desperdiçando um imenso hardware. Quando pensamos em algo portátil, qualquer consumo desnecessário é ruim ao projeto, porém, o ATtiny85 pode nos ajudar com isso.
Para efeitos de comparação, o Arduino UNO funcionando normalmente, consome aproximadamente ~50mA. Já o ATtiny85, consome aproximadamente ~1mA! Em relação ao Arduino UNO podemos melhorar isso usando Sleeps, no entanto, devido a existência de um LED indicando que a placa esta ligada e a diversos outros itens, portanto, mesmo com Deep Sleep, o Arduino UNO consome aproximadamente ~15mA. Já o ATtiny85, por não conter nada além do MCU, no modo Deep-Sleep consome ~0,0001mA ou ~100nA! Seus projetos portáteis irão melhorar muito na questão de autonomia, pois, é possível liga-lo com uma simples bateria CR2032 que encontramos em placa-mãe de CPUs.
Um dos problemas mais comuns é a falta dos pinos físicos de UART ,logo, se você for usar o Serial Monitor para algum debug ou até a comunicação com outros MCUs via UART (Serial), será necessário o uso da Software Serial. Esta biblioteca emula a comunicação Serial (UART) em qualquer pino do MCU e visto que o ATtiny85 não há pinos físicos para UART, devemos usa-la. Entretanto, a biblioteca ocupa uma imensa quantidade de Flash e RAM.
Podemos trabalhar, satisfatoriamente, com o Clock interno, que vai de 1MHz até 8MH. No entanto, Se for preciso mais velocidade, é necessário adicionar um cristal externo de até 20MHz.
Instalando na Arduino IDE
A Arduino IDE não suporta o ATtiny85 nativamente, portanto, precisamos adicionar o Core do ATtiny85 a ela para conseguir usar o ATtiny85.
1-) Entre em https://github.com/SpenceKonde/ATTinyCore e copie o link .JSON que esta descrito dentro do arquivo "Installation" . Com este link iremos baixar os arquivos na Arduino IDE.
2-) Vá em "Preferências", adicione o link copiado em "URLs adicionais" e clique em "OK".
3-) Vá em "Ferramentas" -> "Placa" -> "Gerenciador de Placas...". Procure pelo ATtinyCore na lista e instale.
4-) Volte em "Ferramentas" -> "Placa" e veja que apareceu o ATtiny!
Mãos a obra - Piscando o primeiro LED no ATtiny85
Componentes necessários
Montando o projeto
O ATtiny85 não conta com conversor Serial e muito menos uma porta USB, portanto, devemos dar upload a ele através de um gravador que
neste caso será o Arduino UNO. A explicação estará logo abaixo em "Entendendo a fundo: Hardware".
Para gravar o "Bootloader" (definição dos Fuses) e o código em si, devemos utilizar um gravador externo. Iremos usar o Arduino UNO como ISP.
1-) Abra o exemplo "ArduinoISP" no menu de exemplos , e faça o upload deste código no seu Arduino UNO. Não esqueça de selecionar a porta COM e a placa "Arduino UNO" no menu de ferramentas, caso não esteja selecionado.
2-) Após efetuar o upload do "ArduinoISP" no Arduino UNO, ele está apto a gravar códigos em Microcontroladores ISP sem Bootloader. Podemos agora concluir as ligações necessárias para upload do código e gravação dos Fuses ("Bootloader") no ATtiny85.
Muita atenção na posição do ATtiny85! Deixamos a "bolinha indicadora" para a esquerda, se você inverter, consequentemente irá inverter os pinos de alimentação e queimar seu tiny85! Sempre confira as ligações com o Mapa de pinos.
Os pinos utilizados são os mesmos de uma comunicação SPI e alimentação.
- 5V.
- GND.
- CLOCK (13).
- MISO (12).
- MOSI (11).
- CS (10).
3-) Plugue o Arduino UNO no computador e abra um novo Sketch (projeto). Precisamos selecionar as configurações de "Bootloader" (Fuses) para depois gravar o código no tiny85. Entre no menu de ferramentas e indicamos que deixe igual o da imagem, apenas altere se souber o que esta fazendo!
Obs: Altere a porta COM para a porta que seu Arduino UNO estiver conectado.
Após arrumar todos itens, clique em "Gravar Bootloader". Isso irá apenas configurar os Fuses do ATtiny85, ainda não é o upload do nosso código. Você só precisa fazer isso para o primeiro upload ou se for alterar alguma dessas configurações futuramente.
Agora que gravamos o "Bootloader", podemos finalmente dar upload de nossos códigos. Basta manter as configurações selecionadas anteriormente, escrever o código e dar upload.
Veja como ficou nossa montagem:
Código do projeto
void setup()
{
pinMode(4, OUTPUT);//Define o pino 4 (PB4) como saida.
}
void loop()
{
digitalWrite(4, !digitalRead(4));//Inverte o estado do pino.
delay(200);//Espera 200mS.
}
Colando para funcionar
Após a gravação do "Bootloader" e do código, podemos ver essa mini-maravilha funcionando! Removemos os fios de upload e deixamos apenas a alimentação (5V e GND) juntamente com o LED no pino PB4.
Entendendo a fundo
Software
-Função pinMode
pinMode(4, OUTPUT);//Define o pino 4 (PB4) como saida.
Como podemos ver no Mapa de pinos, as opções em verde são os pinos que podemos usar normalmente. Estes estão descritos como PB0 ao PB5 e podemos usar o número para programar. Usamos o pino 4, que é referente ao PB4 (localizado ao lado do GND).
-Blink
digitalWrite(4, !digitalRead(4));//Inverte o estado do pino. delay(200);//Espera 200mS.
Efetuamos um Blink (inversão de estado) no pino 4, para que vejamos o LED piscando.
Desafio
Como citado anteriormente, podemos utilizar esse pequeno MCU para fazer sub-módulos de controle, que estará conectado em uma central (um Arduino MEGA por exemplo). Tente fazer a comunicação Serial (UART) entre o Arduino UNO com o ATtiny85 para fazer o LED piscar a partir de comandos recebidos pela Serial (UART). Também citamos que não há pinos físicos para UART no tiny85, então você precisa usar a biblioteca Software Serial.
Fechamento
Com esse minúsculo Microcontrolador, podemos fazer diversos projetos onde tamanho e consumo energético são essenciais e importantes. Entretanto, a pouca RAM e Flash comparada ao UNO, pode ser fatal se seus modos de programação não forem os melhores. Não se esqueça de "boas práticas" para programa-lo e bons estudos.
Registrador de deslocamento
Registrador de deslocamento
Neste tutorial, você irá aprender a aumentar o número de portas do seu micro controlador (MCU) usando um registrador de deslocamento 74HC595 (Shift Register). Funciona com qualquer MCU: ATtiny85, Arduino, PIC, ESP8266, ESP32, Raspberry, Onion, etc. Usaremos neste tutorial um ATtiny85 para controlar 8 LEDs apenas com 3 pinos do MCU!
O que são?
Dentro de um registrador de deslocamento há diversos Flip-Flops interligados que de tal forma, consegue converter sinais de um tipo para outro (Serial-Paralelo/Paralelo-Serial) ou até mesmo para expansão de portas de um micro controlador.
Usaremos o 74HC595, um registrador de deslocamento Serial-Paralelo de 8bits, isto significa, que cada registrador irá controlar até 8 componentes. Também é possível liga-los em modo cascata, um após o outro. Com isto, podemos ligar diversos registradores e usando apenas 3 pinos, controlar 40, 80, 160 componentes e assim por diante. Este registrador tem apenas pinos de saída, caso seja necessário leitura de botões (input de dados), procure por outros, existem até alguns com comunicação I2C!
Para mais informações sobre registradores de deslocamento, clique AQUI.
As aplicações para um registrador de deslocamento são bem variadas, pode tanto fazer a conversão de dados Seriais para Paralelo, Paralelo para Serial, ou quando é necessário mais pinos para nosso MCU. Com 5 registradores de deslocamento de 8 bits em cascata, usamos 3 pinos do MCU para controlar até 40 componentes! Perfeito para matrizes de LED 3D ou robôs com vários atuadores.
Mãos à obra
Componente necessários
Para este tutorial, usaremos um ATtiny85, mas você pode usar qualquer MCU.
Montando o projeto
Agora vamos conectar os componentes do projeto. Monte seu circuito conforme a figura a seguir. Não se esqueça de ler a explicação do hardware logo abaixo.
Veja como ficou o nosso:
Código do projeto
/*
Pino 0 = Clock.
Pino 1 = Latch.
Pino 2 = Serial IN.
*/
void setup()
{
for (byte i = 0; i < 3; i++)//Declaração dos pinos de saida.
{
pinMode(i, OUTPUT);
}
int x = 1;
for (byte i = 0; i < 8; i++)//Ligamos um LED após o outro, permanecendo o estado do anterior.
{
s595(x);//Função que faz o gerencimento do registrador.
x = (x * 2) + 1;//Conta binaria que faz BitShift: 0b001 -> 0b011 -> 0b111...
delay(150);
}
}
void loop()
{
s595(random(0, 256));
delay(500);
}
void s595(byte data)//O argumento para acender os LEDs pode ser em binario
{
digitalWrite(1, LOW);//Fecha o Latch para input de dados.
shiftOut(2, 0, LSBFIRST, data);//Função própria da Arduino IDE.
digitalWrite(1, HIGH);//Abre o Latch para output dos dados.
}
Entendendo a fundo
Software
-Função s595()
void s595(byte data)
{
digitalWrite(1, LOW);//Fecha o Latch para input de dados.
shiftOut(2, 0, LSBFIRST, data);//Função própria da Arduino IDE.
digitalWrite(1, HIGH);//Abre o Latch para output dos dados.
}
Esta função criada faz todo o gerenciamento do registrador de deslocamento.
Primeiramente fechamos o Latch para a entrada de novos valores, após a entrada dos valores pelo shiftOut(), abrimos o Latch para que as saídas sejam iguais ao dados que definimos com a entrada anterior.
Para entender melhor sobre a função shiftOut(), clique AQUI.
O legal desta função é que podemos usar diretamente binário para representar os LEDs, por exemplo:
s595(0b11001100);
Com isto, os LEDs serão idênticos ao binário, respectivamente Q0 -> Q7. As saídas Q0, Q1, Q4 e Q5 estarão em HIGH e o restante em LOW.
Hardware
Pinos necessários para o registrador funcionar. Adicione MR ao Vcc e OE ao GND.
O nosso registrador de deslocamento usado, tem 3 pinos básicos: Serial data IN, Latch e Clock.
- Serial data IN: Aqui é adicionado os bit's para futuramente após o latch, virarem output.
- Output Enable (OE): Ativo em LOW.
- Latch: O latch funciona como se fosse um portão. quando em HIGH, o portão se abre, liberando os bit's que adicionamos anteriormente.
- Clock: O clock deve ser oscilado a cada bit de entrada, para que sejam armazenados corretamente.
- Master Reclear (MR): Ativo em LOW.
- Q7': Este pino é usado para a ligação em cascata de mais registradores de deslocamento.
- Q0 a Q7: São as saídas do registrador, use elas normalmente como se fossem pinos de saída, obedecendo os limites de tensão e corrente.
A figura abaixo mostra o efeito do Serial+Clock
Após a conclusão da entrada de dados, ao abrir o Latch, os pinos marcados com 1, ficarão em HIGH, e pinos com 0, em LOW. Então se usarmos "0b10010011", as saídas (Q0 até Q7) ficarão respectivamente: 1, 0, 0, 1, 0, 0, 1, 1.
Desafio
Primeiramente, veja qual LED acende com s595(0b10000000); e depois dentro da função s595(), troque "LSBFIRST" para "MSBFIRST", veja qual LED acende e nos conte porque isto acontece!
Finalizando
Em alguns projetos, como matrizes de LED 3D, é necessário o uso de MUX e registradores de deslocamento, uma vez que nosso MCU não tem pinos suficientes para fazer o controle de cada componente. Com este simples e eficiente componente, podemos controlar diversos outros com poucos pinos do MCU, deixando os outros pinos do MCU livres para tarefas mais complicadas.