Digispark ATtiny85: Manual Técnico Completo
Introdução
Neste manual, será apresentado como instalar, configurar e utilizar o módulo Digispark ATtiny85. Se desejar adquirir este produto, clique aqui.
Descrição geral do produto
O que é o Digispark ATtiny85?
O ATtiny85 é um microcontrolador compacto e versátil da família AVR, muito usado em projetos que exigem baixo consumo e tamanho reduzido. O módulo Digispark (RB0075) integra o chip ATtiny85 com uma interface USB em uma placa pronta de dimensões reduzidas, permitindo programação direta pela porta USB do computador.
Para que o ATtiny85 possa se comunicar via USB como as placas Digispark, é necessário gravar o bootloader Micronucleus, que permite programá-lo diretamente pela porta USB. O ATTinyCore do Spence Konde é um pacote para a Arduino IDE que facilita a configuração de fuses, gravação de bootloaders e programação de chips ATtiny, incluindo perfis prontos para o Micronucleus.
Para que serve?
- Projetos compactos de baixo consumo — wearables, sensores remotos e dispositivos portáteis alimentados por bateria;
- Prototipagem rápida — programação direta pela USB, sem precisar de gravador externo após a gravação inicial do bootloader;
- Aplicações de automação residencial — controle de LEDs, relés, leitura de sensores e comunicação I2C/SPI/PWM.
Por que devo usar?
- Tamanho e custo reduzidos — menor que uma placa Arduino tradicional, com preço acessível;
- USB integrada — o conector USB já vem na placa, sem necessidade de cabo ou módulo USB externo;
- Compatibilidade com a Arduino IDE — programa com a mesma linguagem e bibliotecas do Arduino.
Quando devo usar?
O Digispark ATtiny85 é indicado quando:
- O projeto exige placa mínima com poucos pinos de I/O e baixo consumo energético;
- A comunicação com o computador é feita pela USB direta, após a gravação do bootloader Micronucleus;
- O custo precisa ser baixo em projetos de produção em pequena escala.
Não é a melhor escolha quando:
- São necessários muitos pinos de I/O ou periféricos complexos (preferir ESP32, ESP8266 ou Arduino Mega);
- A aplicação exige comunicação WiFi ou Bluetooth nativa (preferir ESP32/ESP8266);
- A gravação precisa ser feita em massa via USB (o Micronucleus tem limite de tempo de 60 segundos para iniciar a gravação).
Como funciona o bootloader Micronucleus
O Micronucleus é um bootloader de código aberto que roda no ATtiny85 e em outros microcontroladores AVR. Ele ocupa uma parte da memória flash do chip e fica aguardando um sinal USB por até 60 segundos após a energização. Quando o computador inicia a gravação, o bootloader recebe o firmware pela USB e o grava no restante da memória flash.
O ATTinyCore do Spence Konde automatiza esse processo na Arduino IDE: ele configura os fuses do chip, grava o bootloader e deixa o ATtiny85 pronto para receber sketches pela porta USB, exatamente como uma placa Digispark.
Especificações técnicas
Principais especificações
| Parâmetro | Valor |
|---|---|
| Microcontrolador | ATtiny85 (família AVR) |
| Tensão de operação | 2,7 – 5,5 V |
| Memória flash | 8 KB |
| Memória EEPROM | 512 bytes |
| Memória SRAM | 512 bytes |
| Linhas de I/O | 6 (P0 a P5) |
| Canais ADC | 4 canais de 10 bits |
| Saídas PWM | 2 |
| Clock máximo | 20 MHz (cristal externo) |
| Interface USB | USB 2.0 (via bootloader Micronucleus) |
| Comunicação serial | I2C, SPI e UART (software) |
Interface de programação (ISP)
| Parâmetro | Valor |
|---|---|
| Protocolo de gravação | SPI (In-System Programming) |
| Pinos de gravação | MOSI (PB0), MISO (PB1), SCK (PB2), RESET (PB5) |
| Bootloader padrão | Micronucleus (16,5 MHz) |
⚠️ OBRIGATÓRIO: antes de gravar o bootloader, instale o pacote ATTinyCore do Spence Konde na Arduino IDE. Sem ele, não há perfis de placa prontos para o ATtiny85 com o Micronucleus.
Pinagem e descrição dos terminais
Pinos do módulo Digispark
| Pino | Nome | Função |
|---|---|---|
| 1 | P5 (PB5 / RESET) | Entrada de reset / I/O digital / programação ISP |
| 2 | P3 (PB3 / ADC3) | I/O digital / ADC / PWM |
| 3 | P4 (PB4 / ADC2) | I/O digital / ADC / PWM |
| 4 | GND | Terra (0V) |
| 5 | P0 (PB0 / MOSI) | I/O digital / SPI (MOSI) / programação ISP |
| 6 | P1 (PB1 / MISO) | I/O digital / SPI (MISO) / programação ISP |
| 7 | P2 (PB2 / SCK/ADC1) | I/O digital / SPI (SCK) / programação ISP |
| 8 | VCC | Alimentação (2,7 – 5,5V) |
⚠️ ATENÇÃO: o pino P5 é o RESET do chip. Se ele for usado como I/O digital (desabilitando o reset via fuse RSTDISBL), a programação via ISP pode ser bloqueada. Só use P5 como I/O se tiver certeza do procedimento para recuperar o chip.
Pinagem ISP do ATtiny85 (face plana, pino 1 no canto inferior esquerdo)
| Função | ATtiny85 (pino físico) | Programador (USBasp/USBtinyISP) |
|---|---|---|
| VCC | 8 | VCC (5V) |
| GND | 4 | GND |
| MOSI | 5 (PB0) | MOSI |
| MISO | 6 (PB1) | MISO |
| SCK | 7 (PB2) | SCK |
| RESET | 1 (PB5) | RST |
Instalação e conexão
Requisitos de hardware
- Módulo Digispark ATtiny85 (RB0075)
- Arduino IDE instalada no computador
- Programador USBasp ou USBtinyISP (Versão 1) ou Arduino UNO/Nano (Versão 2)
- Protoboard e jumpers
- Cabo USB compatível com a placa Digispark (para a gravação final do sketch)
Passo a passo da instalação
- Desligue qualquer fonte de alimentação antes de conectar o chip.
- Conecte o ATtiny85 ao programador conforme a tabela de pinagem ISP (VCC, GND, MOSI, MISO, SCK, RESET).
- Conecte o programador ao PC via USB (USBasp/USBtinyISP) ou conecte o Arduino UNO/Nano ao PC (Versão 2).
- Configure a Arduino IDE conforme a seção de configuração abaixo.
- Grave o bootloader e aguarde a confirmação da IDE.
- Desconecte o chip do programador e conecte-o à USB do computador (no caso do módulo Digispark) para gravar o sketch.
Conexão com Arduino UNO/Nano como ISP
| Arduino UNO/Nano | ATtiny85 (pino físico) |
|---|---|
| 5V | 8 (VCC) |
| GND | 4 (GND) |
| D11 | 5 (MOSI / PB0) |
| D12 | 6 (MISO / PB1) |
| D13 | 7 (SCK / PB2) |
| D10 | 1 (RESET / PB5) |
💡 Dica: para a gravação via USBasp/USBtinyISP, o ATtiny85 precisa de alimentação de 5V no VCC. Para a versão via Arduino ISP, o próprio Arduino fornece 5V ao chip pela tabela acima.
Configuração de software
Preparação do ambiente
- Abra a Arduino IDE.
- Vá em Arquivo → Preferências.
- Em “URLs Adicionais para Gerenciador de Placas” adicione:
http://drazzy.com/package_drazzy.com_index.json- Clique em OK.
- Vá em Ferramentas → Placa → Gerenciador de Placas, pesquise por ATTinyCore e instale o pacote de Spence Konde.
A tela do Gerenciador de Placas mostra o pacote ATTinyCore pronto para instalação:
💡 O ATTinyCore também pode ser instalado a partir de um arquivo ZIP baixado do repositório do projeto — o pacote do Spence Konde inclui perfis prontos para o Micronucleus.
Versão 1 — Usando USBasp ou USBtinyISP
Após instalar o ATTinyCore, configure a IDE:
- Placa: ATtiny85 (Micronucleus / DigiSpark) — ATTinyCore
- Chip: ATtiny85
- Clock: 16.5 MHz (PLL)
- BOD: 2.7 V (Enabled, out of spec)
- Bootloader: Micronucleus (16.5 MHz)
- Programador: USBasp ou USBtinyISP
A tela de configuração da placa na Arduino IDE mostra todas as opções do ATTinyCore: placa, chip, clock, BOD, bootloader e programador:
Gravação:
- Conecte o programador ao PC e ao ATtiny85 conforme a tabela ISP.
- Na Arduino IDE, configure conforme acima.
- Vá em Ferramentas → Gravar Bootloader (Burn Bootloader) e aguarde a confirmação.
Versão 2 — Usando Arduino UNO/Nano como ISP
- Conecte o Arduino ao PC.
- Na Arduino IDE, abra Arquivo → Exemplos → 11.ArduinoISP → ArduinoISP e envie para o UNO/Nano.
- Conecte o ATtiny85 ao Arduino conforme a tabela de conexão.
- Configure a IDE conforme a seção anterior, mas selecione Programador: Arduino as ISP.
- Vá em Ferramentas → Gravar Bootloader e aguarde a confirmação.
💡 O Arduino UNO/Nano usado como ISP precisa do sketch ArduinoISP gravado nele antes de conectar o ATtiny85 — sem esse firmware, o Arduino não sabe como enviar os sinais SPI de programação.
Gravando o primeiro sketch
Após gravar o bootloader, o ATtiny85/Digispark se comporta como uma placa Digispark padrão: basta conectá-lo à USB do computador, selecionar ATtiny85 (Micronucleus / DigiSpark) na IDE e enviar o sketch. O bootloader abre uma janela de 60 segundos para receber o firmware:
void setup() {
pinMode(1, OUTPUT); // define o pino P1 (PB1) como saída
}
void loop() {
digitalWrite(1, HIGH); // liga o LED conectado ao pino P1
delay(500); // aguarda meio segundo
digitalWrite(1, LOW); // desliga o LED
delay(500); // aguarda meio segundo
}💡 O pino P1 (PB1) é usado como saída digital nesse exemplo. Os pinos do Digispark são numerados P0 a P5 na placa — confirme a numeração impressa na sua placa antes de conectar o LED.
Exemplos de aplicação
- Pisca-LED (Blink): acenda e apague um LED em intervalos regulares para validar a placa após a gravação do bootloader;
- Leitura de sensor de temperatura: leia um sensor analógico nos pinos ADC (P3/P4) e envie o valor pela USB;
- Controle de LED RGB via PWM: use os pinos PWM (P0/P1) para controlar brilho e cor;
- Comunicação I2C/SPI: conecte displays, sensores e módulos externos pelos barramentos I2C (TWI) ou SPI.
Pisca-LED com sensor de luz (LDR)
Nesse exemplo, o Digispark lê um LDR no pino P3 e acende o LED no pino P1 quando a luz ambiente cai abaixo de um limite:
#define PINO_LDR 3 // pino P3 (ADC3) para o LDR
#define PINO_LED 1 // pino P1 para o LED
void setup() {
pinMode(PINO_LED, OUTPUT); // LED é saída
}
void loop() {
int leitura = analogRead(PINO_LDR); // lê o valor do LDR (0-1023)
if (leitura < 300) { // se estiver escuro
digitalWrite(PINO_LED, HIGH); // liga o LED
} else { // se estiver claro
digitalWrite(PINO_LED, LOW); // desliga o LED
}
delay(100); // aguarda 100 ms antes da próxima leitura
}💡 O LDR funciona como divisor de tensão com um resistor de 10 kΩ — conecte o LDR entre o pino P3 e o VCC, e o resistor entre o P3 e o GND. O valor de 300 no código é um limite aproximado — ajuste conforme a luminosidade do ambiente.
Conclusão
Este manual abordou de forma completa o módulo Digispark ATtiny85, desde os conceitos básicos até a gravação do bootloader Micronucleus:
- O que é e como funciona: microcontrolador ATtiny85 com USB integrada, que precisa do bootloader Micronucleus para ser programado pela porta USB.
- Pinagem e instalação: 8 pinos (P0 a P5, VCC, GND), tabela de ligações ISP e conexão com USBasp/USBtinyISP ou Arduino UNO/Nano.
- Configuração de software: instalação do ATTinyCore do Spence Konde, configuração de fuses e gravação do bootloader Micronucleus.
- Exemplos práticos: pisca-LED, leitura de sensores e controle de LEDs RGB via PWM.
Com o bootloader Micronucleus gravado e o ATTinyCore configurado, o Digispark ATtiny85 se torna uma placa de desenvolvimento compacta e de baixo custo para projetos de automação, sensores e robótica.
Solução de problemas
Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Digispark ATtiny85: Manual Técnico Completo e eu ajudarei a encontrar a solução.
O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.