Kit Controlador de Display Fluorescente a Vácuo (VFD) Baseado em Arduino
Componentes e Materiais
| Componente | Quantidade | Observações |
|---|---|---|
| Arduino UNO | 1 | Ou qualquer Arduino de 8 bits |
| Display VFD | 1 | Nosso componente principal |
| CD4094 | 2 | CI DIP (shift register) |
| CD4017 | 2 | CI DIP (contador década) |
| BC557 | 17 | Ou equivalente PNP (2N3906, 2SA733) ou PNP de maior tensão |
| BC547 | 2 | Ou equivalente NPN (2N3904, 2SC945) |
| PC817 | 1 | Optoacoplador comum |
| 1N4007 – Diodo Alta Tensão | 4 | |
| Capacitores Eletrolíticos | 4 | Ver esquemático para valores e tensões |
| Capacitor 470nF | 1 | Qualquer tipo serve |
| Perfboard (placa de ensaio) | 1 | Protoboard, placa de papel, etc. |
| Resistores 1/4W | 24 | Ver esquemático para valores |
| Jumpers Dupont | 1 | Ou conectores de sua preferência |
| Fios finos | 1 | Para circuito e conexão do display (espaçamento de pinos variável) |
Ferramentas Necessárias
- Ferro de solda (genérico)
- Solda (preferencialmente 0,5mm, evite solda barata)
- Alicate de corte
Sobre o Projeto
Qual a Utilidade?
Displays VFD não são mais tendência por razões óbvias: são de vidro, têm filamento incandescente, são basicamente tubos a vácuo, produzem luz muito brilhante (às vezes colorida) que requer filtro escuro. Geralmente precisam de um CI dedicado para controle (I2C/SPI). Se você tem um display VFD sem esse CI, não é trivial "conectar e usar". O ideal seria comprar o CI driver (geralmente SMD). Este circuito oferece uma interface decente para Arduino e pode controlar praticamente qualquer VFD, inclusive os tubulares vintage, mas displays matriciais com milhares de segmentos não são recomendados.
Prós e Contras
Prós
- Custo quase zero (esperançosamente)
- Componentes fáceis de encontrar
- Capacidade de alta tensão (até centenas de Volts nos ânodos)
- Tensões independentes para grades e ânodos
- Apenas 3 linhas digitais de dados necessárias
- Expansível (pode exigir mais processamento da CPU)
- Código pronto para qualquer Arduino de 8 bits
Contras
- Requer várias fontes de tensão diferentes (comum em VFDs)
- Sem função de dimerização (exceto via tensão de drive)
- Usa dois recursos do Arduino: SPI e timer1
- Não se pode travar o microcontrolador, senão o scan congela numa grade
- Não é apenas resistores e LEDs; exige algum trabalho
Princípio de Funcionamento
Um VFD opera de forma multiplexada, como uma matriz 2D (eixos X e Y). É necessário aquecer o filamento (cátodo), aterrá-lo, aplicar tensão positiva numa grade (grade de controle, eixo X) e num pino de segmento (ânodo, eixo Y) para acender um segmento. Para acender combinações arbitrárias com poucos fios, o multiplexamento seleciona uma grade por vez e configura os ânodos correspondentes. Acelerando esse varredura contínua, a persistência da visão (POV) faz parecer que todas as grades estão acesas simultaneamente.
Este circuito usa dois CI da mesma família: dois CD4094 para os ânodos (armazenam configuração high/low nas saídas) e dois CD4017 para as grades (saídas sequenciais de 10 passos). Após carregar os CD4094, o sinal de "strobe" aplica a configuração e avança o CD4017 automaticamente.
A parte de potência usa transistores BC557 para permitir maior oscilação de tensão nos ânodos (displays VFD exigem mais que 5V do Arduino). As grades são驱动 diretamente pelos CD4017; um optoacoplador PC817 permite tensão maior que 5V nos CD4017 e nível diferente dos CD4094, simplificando muito.
O Arduino deve orquestrar tudo: armazenar configurações de segmentos e recarregar os CD4094 a cada troca de grade. O código usa interrupção baseada em timer (~1000 vezes/segundo), resultando em taxa de atualização de 100Hz para 10 grades. Um array de dados armazena a configuração dos segmentos e pode ser modificado no código; a rotina de interrupção faz o upload automaticamente.
Fontes de Alimentação
- Grades (CD4017): 5V a 18V DC, ≥50mA, não precisa ser regulada. 12V costuma bastar.
- Ânodos (BC557): 0V até o limite dos transistores (50V para BC557). 20-30V DC funciona bem, não regulada. ~50mA suficiente.
- Lógica (CD4094): 5V ou 3.3V (para Arduinos 3.3V), ~100mA. Se CD4094 ficar lento, reduza clock SPI no código ou use saída "Q'S" do primeiro 4094.
- Filamento: ≥5V, 200-300mA. Se já tem fonte DC, pode omitir retificador e capacitor 1000uF. NÃO use a mesma fonte do Arduino. Filamentos típicos operam ~3V, 150mA.





Dicas e Observações
- Antes de ligar, se não souber a pinagem, teste o display: duas pilhas AA em série para o filamento (geralmente contatos laterais), duas pilhas 9V em série para polarização positiva de grades e ânodos. Grades e ânodos costumam ser agrupados; identifique o "ânodo zero" (primeiro segmento numérico/alfanumérico, geralmente mesma ordem para todas as grades). Ligar invertido torna o software mais complicado.
- Vá devagar na alimentação do filamento, aumente corrente aos poucos, no escuro. Quando o filamento começar a brilhar levemente, reduza um pouco. Potenciômetro de potência é ideal.
- Aumente tensões de grades/ânodos com moderação; fósforos podem queimar irreversivelmente. O circuito varre, então se o sistema travar, uma grade receberá potência contínua.
- Busque equilíbrio entre tensões de grades/ânodos; grades consomem corrente, não vale forçar; foque nos ânodos.
- Usar um único transformador para todo o projeto é ideal. Fontes chaveadas e aterradas podem causar problemas; para experimentação, fontes com transformador clássico são mais seguras.
- Pode expandir adicionando mais CD4094 e/ou CD4017. Se precisa ≤8 ânodos, pode omitir o segundo 4094; mesmo para 4017. Mas para ter driver completo, construa o máximo possível.
- Não há resistores nas bases dos transistores de ânodo: dá drive super-rápido e reduz componentes, mas faz CD4094 consumir alguma potência. Eles não esquentam, mas alguns chips podem ter saída muito forte; verifique consumo se necessário (corrente ~4mA/pino a 5V).
- Displays velhos e fracos podem ser recuperados com choques de corrente no filamento: levar fios a incandescência visível (amarelo) ~5 vezes por alguns segundos. Pode exigir o dobro da tensão nominal; arriscado, pode romper fios. Mais útil para displays antigos/antigos.
Código
Arduino com Rotina de Funcionamento (Arduino)
/* Versatile VFD Display Hardware Interface Arduino Program
Copyright (C) 2019 Genny A. Carogna
Licença GPL v3 ou posterior.
*/
// Este código usa timer1 e SPI do Arduino "por trás dos panos",
// então pode haver conflitos se você usar SPI, pinos SPI ou
// funcionalidades baseadas no timer1. O circuito não tem memória
// onboard, então a configuração dos segmentos deve ser "varrida"
// continuamente, cada grade, 100 vezes/segundo, a partir do array
// segments[] do Arduino. Overhead de CPU ~3%.
// Funciona em qualquer Arduino de 8 bits; 3.3V deve funcionar, talvez
// reduza frequência SCK (CD4094 alimentados junto podem "undervolt").
#define ledLed 13
#define strobePin 4
#define strobeHold 10 // microssegundos
// Definições para meus displays (videocassete, CD player, mini system)
// Apague e defina apenas gridAmount e anodeAmount
#define JVC
#define mitsubishiGrids 10
#define mitsubishiAnodes 9
#define marantzGrids 9
#define marantzAnodes 14
#define JVCGrids 11
#define JVCAnodes 19
#if defined mitsubishi
#define gridAmount mitsubishiGrids
#define anodeAmount mitsubishiAnodes
#elif defined marantz
#define gridAmount marantzGrids
#define anodeAmount marantzAnodes
#elif defined JVC
#define gridAmount JVCGrids
#define anodeAmount JVCAnodes
#endif
// Array segments[x] armazena bits de segmento por grade
// segments[0] = grade 0, bit menos significativo = segmento 0
// Acesse e modifique este array livremente; efeito imediato no display.
#if anodeAmount > 16
volatile uint32_t segments[gridAmount] = {0};
#elif anodeAmount > 8
volatile uint16_t segments[gridAmount] = {0};
#else
volatile uint8_t segments[gridAmount] = {0};
#endif
void setup(){
// Configura pinos SPI e strobe como saída (forma rápida/direta)
*portModeRegister(digitalPinToPort(PIN_SPI_SS)) |= digitalPinToBitMask(PIN_SPI_SS);
*portModeRegister(digitalPinToPort(PIN_SPI_MOSI)) |= digitalPinToBitMask(PIN_SPI_MOSI);
*portModeRegister(digitalPinToPort(PIN_SPI_SCK)) |= digitalPinToBitMask(PIN_SPI_SCK);
*portModeRegister(digitalPinToPort(strobePin)) |= digitalPinToBitMask(strobePin);
*portOutputRegister(digitalPinToPort(strobePin)) &= ~digitalPinToBitMask(strobePin); // low
*portModeRegister(digitalPinToPort(ledLed)) |= digitalPinToBitMask(ledLed);
*portOutputRegister(digitalPinToPort(ledLed)) &= ~digitalPinToBitMask(ledLed); // low
delay(800); // espera reset CD4017 completar
cli(); // desabilita interrupções para configuração
// Timer1: interrupção "grids * 100" por segundo → 100Hz total
TCCR1A = 0; TCCR1B = 0; TCNT1 = 0;
OCR1A = 160000 / gridAmount;
TCCR1B |= (1 << WGM12);
TCCR1B |= (1 << CS10);
TIMSK1 |= (1 << OCIE1A);
// SPI: não podemos usar ferramentas Arduino SPI (dependem de interrupções)
// Precisamos comunicação DENTRO de interrupção.
SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // 1MHz SCK
// SPSR = (1 << SPI2X); // descomente e mude acima para metade do clock
sei(); // reabilita interrupções
// Coloque seu setup() adicional a partir daqui
}
void loop() {
show(); // screensaver, pode apagar
}
// Rotina de serviço de interrupção: a cada troca de grade, 100x/seg
ISR(TIMER1_COMPA_vect){
static uint8_t turn = 1; // grade atual
// Transferência SPI dos bits de segmento (negados por causa dos transistores)
#if anodeAmount > 24
SPDR = ~uint8_t(segments[turn] >> 24); while (!(SPSR & (1 << SPIF))) ;
#endif
#if anodeAmount > 16
SPDR = ~uint8_t(segments[turn] >> 16); while (!(SPSR & (1 << SPIF))) ;
#endif
#if anodeAmount > 8
SPDR = ~uint8_t(segments[turn] >> 8); while (!(SPSR & (1 << SPIF))) ;
#endif
SPDR = ~uint8_t(segments[turn]); while (!(SPSR & (1 << SPIF))) ;
// Strobe: também avança CD4017
*portOutputRegister(digitalPinToPort(strobePin)) |= digitalPinToBitMask(strobePin);
delayMicroseconds(strobeHold);
*portOutputRegister(digitalPinToPort(strobePin)) &= ~digitalPinToBitMask(strobePin);
// Próxima grade
turn++; if (turn == gridAmount) turn = 0;
}
// --- DEMO ESPECÍFICA PARA MEUS DISPLAYS (pode apagar daqui para baixo) ---
void show() {
#ifdef mitsubishi
for (uint8_t i = 0; i < 9; i++) for (uint8_t j = 0; j < 11; j++) { delay(200); mitsubishiPrintNum(j, i); }
for (uint8_t i = 0; i < 9; i++) for (uint8_t j = 0; j < 11; j++) { delay(20); mitsubishiPrintNum(j, i); }
#elif defined marantz
for (uint8_t i = 0; i < 6; i++) for (uint8_t j = 0; j < 11; j++) { delay(200); marantzPrintNum(j, i); }
for (uint8_t i = 0; i < 6; i++) for (uint8_t j = 0; j < 11; j++) { delay(20); marantzPrintNum(j, i); }
#elif defined JVC
// ... (código omitido)
#endif
delay(500);
// Resto da demo...
}
Esquemático
Evitei desenhar todos os transistores BC557 pois são idênticos e conectados a todas as saídas dos CD4094.
Há um seletor de jumper (linha vermelha) que deve ser configurado nos chips 4017: ele reseta os dois 4017 ao final da varredura das grades. Conecte (ou solde) o jumper voador no pino de saída APÓS a última grade. Se seu display tem 10 grades, o jumper vai no 11º output.
Conexões do Arduino em vermelho. Pode usar USB para o Arduino, mas fortemente recomendado usar transformador comum para as demais fontes se já tem fonte aterrada (como PC). Fontes devem ser DC, exceto talvez a do filamento. Adicionei diodos pois provavelmente precisa de transformador separado com secundário de baixa tensão. Filamento costuma ser ~3V 150mA; transformador 5V AC serve. O "ballast" pode ser potenciômetro de fio ~100Ω, resistor fixo, ou diodos 1N4007 para reduzir tensão.
Transistores BC557 puxam ânodos para tensão anódica; resistores 100kΩ deixam tensão cair quando segmento desliga, enquanto CD4094 ficam em 5V.
CD4017 alimentados com tensão de grade, não precisam transistores adicionais. Circuito de reset "gambiarra" para 4017 dura ~0.1s; aguarde estabilizar antes de rodar código. O esquema original para cascata de CD4017 exigia portas lógicas extras; usei transistor NPN e o próprio optoacoplador para replicar porta AND: rápido no fechamento, perfeito; mais lento na abertura, mas não importa porque entradas de clock dos 4017 são Schmitt-trigger e velocidade não é "assustadora".
Há vários grounds para chips e componentes; observe bem.

Processo de manufatura
- Construa uma Boneca Interativa Temática de Round 6 com Arduino UNO – Projeto DIY
- Guia Profissional de Animação de Bitmap no Shield TFT Touchscreen ILI9341 2,4″ com Arduino
- Sistema de Iluminação DMX Controlado via Web – Controlador Mestre Arduino
- Construa o Clássico Jogo Pong no Arduino UNO com Display OLED – Tutorial Passo a Passo
- Controle USB para Jogos DIY com Arduino – Construa Seu Próprio Gamepad de Alto Desempenho
- Unopad: Controlador MIDI Arduino Perfeito para Ableton Live
- Monitor de Temperatura e Relógio Tempo Real com Arduino Due e Display TFT 3.2"
- Projeto HMI Interativo com Nextion, Arduino Mega e Sensores
- Construa um Voltímetro DIY com Arduino e Display Nokia 5110 – Guia Passo a Passo
- Exibir Temperatura, Umidade e Pressão do BME280 em Touchscreen Nextion