Frequentemente é possível desenvolver seus projetos no Arduino e depois rodá-los em um ATtiny, bem mais barato e mais modesto em termos de consumo de bateria.

O ATtiny85 é um dos primos modestos do ATmega328, o microcontrolador responsável pela inteligência do seu Arduino Uno ou Nano. Além de custar barato (é fácil encontrar no Brasil por menos de R$ 10), o Attiny85 também gasta menos energia: é fácil encontrar exemplos de Attinys rodando por vários meses com uma pilha de relógio.

Uma placa contendo um ATtiny85, led, resistor, botão e uma bateria de relógio CR2032

Vale observar que uma parte dessa diferença se deve ao fato de o Attiny não ser propriamente um Arduino, embora possa ser programado usando a linguagem e o ambiente de desenvolvimento do Arduino. Ele é apenas o microcontrolador, sem todo o aparato (regulador de tensão, interface serial/USB, oscilador, etc.) que vem numa placa Arduino. Você também poderia perfeitamente gastar menos dinheiro e energia rodando seus programas diretamente num ATmega328 idêntico ao que vem no Arduino; mas se conseguir fazê-lo num ATtiny, provavelmente a diferença (em custo e energia) será maior.

No caso do ATtiny85¹ especificamente, essa economia vem acompanhada de uma série de desapegos obrigatórios: você precisa se virar com apenas 5² pinos de dados, sendo que 2 deles podem ser usados para PWM, e os outros 3 podem ser usados como entradas analógicas. Sem usar um oscilador externo, geralmente³ o clock será escolhido entre 8MHz ou 1MHz (o do Arduino Uno é 16MHz), e a capacidade de armazenar programas é de 8KB, 1/4 dos ~32KB do Uno.

Em compensação, o Attiny85 consegue facilmente operar a tensões menores que as do Arduino (descendo até 1,8V; o máximo é 5,5V) e, quando colocado em modo de economia de energia, não tem os cômodos penduricalhos do Arduino (como o regulador de tensão, o led on/off e a interface USB) para continuar consumindo. É por isso que é possível usá-lo em aplicações práticas por meses a fio em uma bateria de relógio. Além disso, o preço bem mais baixo permite reduzir bastante a pena de "largá-lo" em um projeto após conclui-lo.

Muito do que foi dito acima decorre da diferença entre as ferramentas de desenvolvimento com microcontroladores (como é o caso do Arduino) e os microcontroladores em si (como o ATtiny85, ou o próprio ATmega328 que vem no Uno). As primeiras precisam oferecer certas facilidades, e os segundos são "nus", para que você inclua apenas o que precisar. No caso em questão, a diferença é ampliada pela escolha das linhas, como os próprios nomes indicam: mega é associado a gigantismo, enquanto tiny significa miúdo.

No interesse da clareza, vale observar que também existem ATtinys fisicamente maiores e com mais pinos, como o de baixo na foto acima. A diferença entre ATtinys e ATmegas não reside no tamanho físico, e sim nas especificações internas.

De modo geral, é possível programar os ATtinys usando a mesma IDE do Arduino, e é isso que vou descrever hoje.

ATtiny: Configurando o Arduino para o ATtiny85

O ATtiny85 é apenas um CI, não tem uma porta USB que possamos plugar diretamente ao computador para fazer upload dos programas.

Assim, precisamos recorrer a um intermediário que possa ser plugado à porta USB do computador e ao qual o ATtiny possa ser plugado. Esse intermediário pode ser um Arduino Uno que você já tenha, plugado à USB do computador e conectado a um ATtiny85 adequadamente cabeado em uma protoboard.

Vale destacar: depois de programado, o ATtiny85 funciona independentemente. O Arduino Uno entra neste nosso procedimento apenas como um instrumento para transferir programas ao ATtiny.

Antes de fazer a conexão física, é importante certificar-se de ter instalado o suporte à família ATtiny na IDE do Arduino. Eu fiz isso criando uma pasta chamada hardware dentro da pasta em que gravo os programas do Arduino, e colocando dentro dela a pasta attiny deste zip. Importante: a pasta copiada é a que se chama attiny, que está dentro da pasta attiny-master do zip.

Feito isso, fechei e voltei a abrir a IDE do Arduino, e verifiquei que passaram a aparecer vários modelos de ATtiny no menu Tools/Board.

Mas não selecionei ainda nenhum ATtiny: Mantive selecionado o meu Arduino Uno, pois ainda é necessário transferir para ele o programa que o faz agir como intermediário entre a IDE e o ATtiny (ou outro ATmega).

Esse programa se chama ArduinoISP, e não é necessário fazer nenhum download: ele está no menu File/Examples da sua IDE. Bastou abri-lo e transferi-lo sem alterações para o meu Arduino Uno, exatamente como eu faria para o exemplo Blink, ou outro qualquer.

Para completar a configuração de software, fui no menu Tools/Programmer e selecionei a opção “Arduino as ISP”, que indica que usarei meu Arduino como intermediário para programar outro equipamento.

Feita a configuração de software do Arduino, é hora de cabear. Coloquei o ATtiny em uma protoboard, e usei jumpers para fazer as ligações a seguir, considerando a pinagem física do ATtiny, que você vê na imagem acima.

Além de cabear como descrito, foi necessário também colocar um capacitor de 10uF entre o pino RST e o pino GND do Arduino Uno (o terminal negativo do capacitor vai no GND, naturalmente):

O capacitor impede que o Arduino reinicie no início do upload de código. Não esqueça de remover esse capacitor quando não estiver mais usando o Arduino como intermediário ;-)

Com isso (criação da pasta attiny, ativação do ArduinoISP, seleção da opção “Arduino as ISP”, conexão física e colocação do capacitor), o ATtiny85 estava pronto para ser programado pelo meu Arduino Uno, e eu o selecionei no menu Tools/Board.

Configurando o ATtiny85 para 8MHz

As configurações que vieram embutidas na pasta attiny que instalei na IDE do nosso Arduino incluem várias opções de frequência de clock para o ATtiny85, mas só 2 delas são possíveis sem incluir um oscilador externo: a de 1MHz (ativada por default) e a de 8MHz, que eu preferi.

Para ativar a de 8MHz, além de selecionar a opção ATtiny85 (internal 8MHz clock) no menu Tools/Board, foi necessária uma pequena mentira: dizer para a IDE que eu queria gravar um bootloader, por meio da opção Tools/Burn bootloader. A IDE não grava um bootloader no ATtiny85, mas com essa operação ela o configura permanentemente para 8MHz.

Nota: a mensagem “avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85” aparece mais de uma vez a cada operação de gravação no ATtiny. Ela pode ser ignorada: é uma ocorrência normal.

Como fazer upload de programas para o ATtiny85

Está na hora de fazer o upload de um programa para o ATtiny85, e chegou também a hora de levar em conta a mais visível diferença entre ele e o microcontrolador do Arduino: o número de pinos.

Para programar o ATtiny, considerei a pinagem lógica a partir das designações em vermelho neste diagrama:

Vale observar que os pinos 0 e 1 permitem PWM.

Como primeiro programa para o ATtiny, escolhi o familiar exemplo Blink, com uma pequena modificação: o ATtiny85 não tem pino 13, nem led embutido. Assim, conectei um led e um resistor ao seu pino lógico 3, e modifiquei o programa para trocar todas as referências ao 13 por 3:

void setup() {
  pinMode(3, OUTPUT);
}

void loop() {
  digitalWrite(3, HIGH);  
  delay(1000);             
  digitalWrite(3, LOW);   
  delay(1000);             
}

Usando a configuração descrita neste artigo, foi só compilar e transferir normalmente, como eu faria para um Arduino. A mensagem “avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85” apareceu como previsto, mas o programa foi transferido normalmente e o led logo começou a piscar.

Nesse momento já seria possível remover as conexões entre o ATtiny e o Arduino, conectar o ATtiny85 a alguma fonte de energia, e ele funcionaria independentemente.

Indo além

Com os passos acima você já pode fazer programas básicos usando os seguintes comandos básicos do Arduino: pinMode(), digitalWrite(), digitalRead(), analogRead(), analogWrite(), shiftOut(), pulseIn(), millis(), micros(), delay() e delayMicroseconds().

Talvez o que faça mais falta no início seja a possibilidade de usar o suporte nativo a um terminal serial (“Serial.print”), mas você pode pesquisar o uso da biblioteca SoftwareSerial.

Vários recursos avançados (timers, interrupções, modos) do ATtiny85 são diferentes dos encontrados na série ATmega, o que faz com que várias bibliotecas feitas para o Arduino não funcionem no ATtiny, ou que exijam modificações. Muitas vezes alguém já testou, descobriu como fazer e publicou os resultados, então vale a pena pesquisar.

Se você for usar o seu Uno com frequência para programar um ATtiny, pode valer a pena reservar uma breadboard permanentemente configurada para isso, ou mesmo desenvolver um shield caseiro com um soquete para o ATtiny85 conectado aos pinos relevantes do Arduino, além de já incluir o capacitor. O meu você vê na foto abaixo:

O led do shield está conectado ao pino 9 do Arduino, que o programa ArduinoISP usa para indicar informações de status. Se você precisar, conecte leds também aos pinos 8 e 7, nos quais o programa indica erro e transferência, respectivamente.

Minha referência básica é este artigo do High-Low Tech, que recomendo. Existem outras referências, outras configurações e outras formas de realizar tudo que descrevi acima. Pesquise bastante, e boa programação modesta para você ;-)