Tutorial de multiplexação de LED com Arduino: Controle mais LEDs com menos pinos

O Arduino Uno é uma ferramenta poderosa para prototipagem, mas acionar vários LEDs diretamente esgota rapidamente os seus 20 pinos GPIO e o seu limite absoluto de corrente total do encapsulamento de 200 mA. Para contornar estes estrangulamentos de hardware, engenheiros e entusiastas utilizam a multiplexagem de LED para escalar as saídas de display de forma eficiente sem atualizar o microcontrolador.

Neste guia, irá aprender os princípios fundamentais da varredura de matrizes de LED, Charlieplexing, temporização de atualização, correções de ghosting e código Arduino prático sem depender de quaisquer CI drivers ou de expansão externos.

O que é a multiplexagem de LED com Arduino?

Limites de GPIO do Arduino Uno explicados

Cada pino GPIO de um Arduino Uno baseado no ATmega328P tem limitações elétricas rigorosas.

• Máximo absoluto: Um único pino GPIO pode fornecer ou absorver até 40 mA em condições de pico não contínuas.
• Limite recomendado: O limite de funcionamento seguro para saída contínua é de 20 mA ou menos por pino.
• Limite total do encapsulamento: Crucialmente, a corrente combinada total que passa pelos pinos VCC e GND do chip não deve exceder 200 mA.

Tentar acionar uma matriz 4x4 de 16 LEDs diretamente a 15 mA cada exigiria 240 mA, arriscando danos térmicos permanentes ao silício.

Persistência da visão na multiplexagem de LED

A multiplexagem de LED baseia-se num fenómeno fisiológico conhecido como Persistência da Visão (PoV). O olho humano não consegue percetibilizar alterações na intensidade luminosa que ocorram mais rapidamente do que aproximadamente 50 a 100 Hz (um período de 10 a 20 milissegundos).

Se um LED for ligado durante 1 milissegundo e depois desligado durante 9 milissegundos, e este ciclo se repetir continuamente, o olho integra os pulsos de luz. Em vez de ver uma luz intermitente, percecionamos uma luz contínua e ligeiramente mais fraca. Ao percorrer uma série de LEDs sequencialmente a alta velocidade, todos parecem estar iluminados simultaneamente, resultando num display estável.

Acionamento direto de LED vs matriz multiplexada

Existem duas formas principais de acionar LEDs diretamente utilizando os pinos nativos do microcontrolador:

• Acionamento direto: Ligar um LED a um pino GPIO dedicado através de uma resistência de limitação de corrente. Embora seja simples de programar, escala mal, consumindo um pino completo por fonte de luz e atingindo rapidamente o limite de corrente total do encapsulamento do chip.
• Varrimento multiplexado: Organizar os LEDs numa grelha elétrica ou numa configuração especializada (como Charlieplexing). Os píxeis partilham ligações físicas, o que significa que o microcontrolador comuta rapidamente linhas específicas ao longo do tempo para endereçar coordenadas individuais utilizando uma fração dos pinos.

Técnicas de multiplexagem de LED com Arduino comparadas

As tabelas abaixo descrevem os principais compromissos das técnicas de expansão de LED por pinos diretos.

Varrimento de matriz linhas-colunas: 16 pinos acionam 64 LEDs

O varrimento de matriz organiza os LEDs numa grelha de linhas e colunas que se intersectam. Ao estruturar 64 LEDs como uma grelha 8x8, ligamos todos os ânodos de cada linha e todos os cátodos de cada coluna. Precisamos apenas de 16 pinos para endereçar cada píxel individualmente, reduzindo os requisitos físicos de pinos em 75% e simplificando a sua lógica de varrimento de matriz de LED Arduino.

Charlieplexing de LED com Arduino

O Charlieplexing é um método avançado de multiplexagem que explora a lógica tri-state dos pinos GPIO do microcontrolador (HIGH, LOW e INPUT de alta impedância). Ao colocar LEDs em pares anti-paralelos, o Charlieplexing escala eficientemente, permitindo que N pinos acionem N * (N - 1) LEDs.

Matriz de LED vs Charlieplexing

• Eficiência de pinos: O Charlieplexing é significativamente mais eficiente em pinos. Enquanto uma matriz linhas-colunas 8x8 requer 16 pinos para acionar 64 LEDs, o Charlieplexing requer apenas 9 pinos para atingir uma capacidade semelhante (acionando até 72 LEDs).
• Complexidade de firmware: O varrimento padrão linhas-colunas requer apenas a comutação de pinos entre estados binários HIGH e LOW. O Charlieplexing requer a alteração dinâmica das direções dos pinos entre saídas e entradas de alta impedância dentro do ciclo de execução principal.

Escolher o método de multiplexagem certo

Selecione o varrimento de matriz linhas-colunas se precisar de brilho consistente, encaminhamento mais fácil e um alinhamento de grelha padrão. Escolha o Charlieplexing se o seu projeto tiver restrições físicas severas de pinos, como um design wearable minúsculo, e puder tolerar um ciclo de trabalho global de display mais baixo.

Como construir uma matriz de LED 8x8 com Arduino

Uma matriz 8x8 é o ponto de partida ideal para aprender o controlo baseado em grelha.

Matriz de LED de ânodo comum vs cátodo comum

Como uma matriz de LED 8x8 é uma grelha de díodos que se intersectam, cada matriz é fisicamente tanto de ânodo comum como de cátodo comum simultaneamente, dependendo do eixo que se analisa. A designação comercial do fabricante refere-se especificamente à configuração de polaridade das Linhas:

• Linha de ânodo comum (Coluna de cátodo comum): Todos os LEDs numa determinada linha partilham os seus ânodos (positivo), enquanto as colunas se ligam aos cátodos partilhados (negativo). Para iluminar um píxel (por exemplo, Linha 1, Coluna 1), deve colocar a Linha 1 a HIGH (fornecimento) e a Coluna 1 a LOW (absorção).
• Linha de cátodo comum (Coluna de ânodo comum): Todos os LEDs numa determinada linha partilham os seus cátodos (negativo), enquanto as colunas se ligam aos ânodos partilhados (positivo). Para iluminar um píxel, deve colocar a Linha 1 a LOW (absorção) e a Coluna 1 a HIGH (fornecimento).

Diagrama de cablagem da matriz de LED Arduino

Abaixo está um layout conceptual de cablagem para uma matriz de LED Arduino 8x8 padrão de Linha de Ânodo Comum (Coluna de Cátodo Comum) acionada diretamente por um Arduino.

Figura: Diagrama esquemático de uma matriz de LED 8x8 de Linha de Ânodo Comum (Coluna de Cátodo Comum) ligada a um Arduino Uno, mostrando os pinos das linhas ligados aos ânodos e os pinos das colunas ligados aos cátodos através de resistências.

Colocação das resistências na matriz de LED

Deve colocar resistências de limitação de corrente nas colunas em vez de nas linhas (ou vice-versa, dependendo de qual eixo está a ser varrido).

• Porque é importante: Se colocar resistências nas linhas e fizer o varrimento por linha, o brilho dos LEDs mudará consoante quantos LEDs nessa linha estiverem ligados. Se apenas 1 LED estiver ativo, ficará brilhante; se os 8 estiverem ativos, a corrente é dividida, tornando-os muito fracos.
• A solução: Coloque uma resistência por linha ou coluna acionada independentemente. Dependendo do eixo de varrimento (varrimento por linha vs. varrimento por coluna), isto garante uma distribuição consistente de corrente e evita brilho desigual, uma vez que a corrente disponível é partilhada pelos LEDs ativos.

Utilize esta fórmula básica para calcular o valor da resistência:

Para uma alimentação padrão de 5V, consulte a tabela abaixo para valores de cálculo rápido:

Cálculo da taxa de atualização da matriz de LED Arduino

Para obter um display estável com eliminação de cintilação visível, a matriz deve ser varrida completamente pelo menos 60 vezes por segundo (60 Hz). Uma taxa de 100 Hz a 200 Hz é preferível para um desempenho de atualização suave. Taxas de atualização mais elevadas podem ser necessárias para evitar cintilação de rolling-shutter em câmaras de smartphones.

Para uma matriz de 8 linhas varrida uma linha de cada vez a 100 Hz:

Período total de frame = 1 / 100 Hz = 10 ms

Tempo ativo por linha = 10 ms / 8 linhas = 1,25 ms (1250 microssegundos)

O Arduino deve comutar as linhas a cada 1,25 milissegundos.

Código millis() para matriz de LED 8x8 Arduino

A utilização de temporização não bloqueante com millis() ou micros() é crucial para que o Arduino possa tratar de outras tarefas, como leitura de sensores ou comunicação série, enquanto atualiza o display.

Destaques do código:

• Inicializa linhas e colunas: Define as direções dos pinos e os estados desligados de base durante setup().
• Utiliza micros() não bloqueante: Executa um agendador de baixa sobrecarga que aciona os estados de atualização com base no tempo decorrido em vez de utilizar delay() bloqueante.
• Atualiza uma linha por ciclo de varrimento: Coloca seletivamente as linhas a HIGH e as colunas ativas a LOW, avançando linha a linha a cada tick.

// Variáveis Globais e Definições de Padrões
const int rowPins[8] = {13, 12, 11, 10, 9, 8, 7, 6};
const int colPins[8] = {5, 4, 3, 2, A5, A4, A3, A2};

byte heartPattern[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00000000
};

unsigned long lastScanTime = 0;
const unsigned long scanInterval = 1250;
int currentRow = 0;

// Função de Configuração
void setup() {
  for (int i = 0; i < 8; i++) {
    pinMode(rowPins[i], OUTPUT);
    pinMode(colPins[i], OUTPUT);
    digitalWrite(rowPins[i], LOW);
    digitalWrite(colPins[i], HIGH);
  }
}

// Ciclo Principal
void loop() {
  unsigned long currentMicros = micros();
  if (currentMicros - lastScanTime >= scanInterval) {
    lastScanTime = currentMicros;
    digitalWrite(rowPins[currentRow], LOW);
    for (int col = 0; col < 8; col++) {
      digitalWrite(colPins[col], HIGH);
    }
    currentRow = (currentRow + 1) % 8;
    for (int col = 0; col < 8; col++) {
      if (bitRead(heartPattern[currentRow], 7 - col) == 1) {
        digitalWrite(colPins[col], LOW);
      }
    }
    digitalWrite(rowPins[currentRow], HIGH);
  }
}

A função padrão digitalWrite() utilizada acima é simples e excelente para clareza educativa, mas é relativamente lenta. Cada chamada a digitalWrite() executa numerosas verificações de segurança em tempo de execução (verificar se o pino tem PWM, analisar tabelas de consulta para registos de portas, etc.), que consomem até 4 microssegundos de tempo de processamento.

Projetos avançados e críticos em desempenho contornam frequentemente isto utilizando manipulação direta de portas (por exemplo, escrever PORTD |= B00000100; que executa num único ciclo de clock—apenas 62,5 nanossegundos num microcontrolador de 16 MHz) ou utilizando interrupções de temporizador de hardware para alcançar a máxima eficiência de varrimento.

Consumo de corrente da matriz de LED Arduino

Ao projetar um display multiplexado, deve equilibrar a corrente de pico com a corrente média.

• Corrente de pico: A corrente máxima consumida quando uma linha ou coluna está totalmente ligada. Se 8 LEDs estiverem ligados numa coluna, o circuito driver deve suportar este pico cumulativo.
• Corrente média: Devido ao ciclo de trabalho ativo (por exemplo, 1/8 de um frame numa matriz 8x8), o consumo médio de potência de um único LED é muito inferior ao do acionamento contínuo.
• Limites de corrente USB: Uma porta USB 2.0 padrão de computador limita a corrente de alimentação a 500 mA. Projetos grandes de matriz de LED Arduino excedem frequentemente os limites de potência USB. Ao alimentar as suas matrizes multiplexadas diretamente por USB, garanta que as suas correntes de pico combinadas, incluindo a sobrecarga interna do Arduino (~50 mA), fiquem bem abaixo deste limite para evitar reinícios da porta.

Como implementar Charlieplexing de LED com Arduino

O Charlieplexing é uma forma altamente eficiente de endereçar uma grande matriz de LEDs com pinos mínimos, mas requer controlo preciso dos estados dos seus pinos.

Lógica GPIO tri-state para Charlieplexing

Um pino de microcontrolador padrão tem três estados: HIGH (5V), LOW (0V) e INPUT. Quando configurado como INPUT, o pino entra num estado de alta impedância (Hi-Z), atuando como um circuito aberto. O Charlieplexing aproveita este estado para isolar pares específicos de LEDs. Qualquer pino que não esteja a acionar ativamente o frame atual é colocado em estado de entrada para bloquear o fluxo de corrente.

Fórmula de contagem de LEDs em Charlieplexing

O número máximo de LEDs que pode acionar com N pinos é calculado como:

Este escalonamento matemático é altamente eficiente. Por exemplo, enquanto 3 pinos controlam apenas 6 LEDs, um ligeiro aumento para 6 pinos permite acionar até 30 LEDs.

A tabela abaixo destaca a rapidez com que o escalonamento de saídas aumenta à medida que adiciona pinos:

Diagrama de cablagem de Charlieplexing

Para compreender como o Charlieplexing opera, é útil visualizar o layout esquemático das configurações de LEDs anti-paralelos. Abaixo está uma representação visual de três pinos a controlar um nó Charlieplexed de seis LEDs:

Figura: Diagrama de circuito Charlieplexing com 3 pinos Arduino a controlar 6 LEDs em pares anti-paralelos, mostrando resistências em cada ramo de pino.

Código pinMode() para Charlieplexing Arduino

Acionar um único LED requer definir o seu pino de origem como OUTPUT HIGH, o seu pino de destino como OUTPUT LOW, e todos os outros pinos como INPUT (Hi-Z).

Destaques do código:

• Limpa os pinos ativos anteriores: Itera pelos pinos, repondo-os como INPUT para garantir que não permanecem percursos parasitas ativos.
• Define origem e destino dinamicamente: Reconfigura direções e estados utilizando uma máquina de estados switch-case correspondente ao LED alvo.

// Definições de Pinos
const int pins[3] = {9, 10, 11};

// Função auxiliar turnOnLED()
void turnOnLED(int ledIndex) {
  for (int i = 0; i < 3; i++) {
    pinMode(pins[i], INPUT);
    digitalWrite(pins[i], LOW);
  }
  switch(ledIndex) {
    case 1:
      pinMode(pins[0], OUTPUT); digitalWrite(pins[0], HIGH);
      pinMode(pins[1], OUTPUT); digitalWrite(pins[1], LOW);
      break;
    case 2:
      pinMode(pins[1], OUTPUT); digitalWrite(pins[1], HIGH);
      pinMode(pins[0], OUTPUT); digitalWrite(pins[0], LOW);
      break;
    case 3:
      pinMode(pins[1], OUTPUT); digitalWrite(pins[1], HIGH);
      pinMode(pins[2], OUTPUT); digitalWrite(pins[2], LOW);
      break;
  }
}

// Configuração
void setup() {}

// Ciclo Principal
void loop() {
  for (int i = 1; i <= 3; i++) {
    turnOnLED(i);
    delay(5);
  }
}

Limitações de brilho do Charlieplexing

Como o Charlieplexing só pode iluminar um LED de cada vez na sua implementação padrão, o ciclo de trabalho de qualquer LED individual diminui significativamente à medida que adiciona mais LEDs. Se estiver a acionar 30 LEDs, cada LED está ativo no máximo 1/30 do frame de varrimento. Este baixo ciclo de trabalho faz com que o display pareça visivelmente mais fraco.

Correção de ghosting em Charlieplexing

O ghosting ocorre quando a corrente de fuga flui através de percursos alternativos de díodos, iluminando fracamente LEDs inativos. Isto é causado por comutar os estados dos pinos demasiado lentamente ou por utilizar LEDs não emparelhados. Resolva sempre isto implementando um pequeno atraso de blanking (por exemplo, colocar todos os pinos como INPUT durante 50 microssegundos) entre a mudança de estados ativos.

Resolução de problemas de multiplexagem de LED Arduino

#1 Correção de cintilação de LED: aumentar a taxa de varrimento

Se vir pulsação visível, a sua taxa de varrimento é demasiado lenta. Aumente a frequência do temporizador ou da interrupção para que a taxa de atualização de frame completo exceda 80–100 Hz. Mantenha o código da ISR (Rotina de Serviço de Interrupção) leve e livre de funções lentas como analogRead() ou delay().

#2 Correção de LEDs fracos: reduzir a perda de ciclo de trabalho

Os displays multiplexados funcionam a uma fração do seu brilho contínuo padrão. Para compensar, pode pulsar os LEDs com uma corrente superior à sua classificação contínua. Alguns LEDs suportam correntes de pico mais elevadas em funcionamento com baixo ciclo de trabalho. Consulte a folha de dados do seu LED para encontrar os limites de pulsação de pico antes de diminuir a resistência para aumentar o brilho.

#3 Correção de ghosting de LED em displays multiplexados

Se um píxel ativo sangra para as colunas vizinhas, a causa é a carga residual nos pinos do driver. Antes de comutar a linha ativa para high:

1. Desligue todas as colunas (coloque-as num estado alto/inativo).
2. Comute as linhas.
3. Volte a ligar as colunas.

Esta sequência chama-se blanking e evita a corrente de fuga durante as transições de estado.

#4 Correção de linhas ou colunas de LED mortas

Se uma linha ou coluna inteira não iluminar, raramente se deve a um único LED queimado. Falhas de cablagem, curto-circuitos ou orientações incorretas de díodos podem desativar linhas ou colunas inteiras. Teste o seu sistema utilizando um multímetro no modo de verificação de díodo. Se estiver a utilizar dispositivos de montagem em superfície (SMDs), inspecione a placa com ampliação para detetar juntas de solda frias ou micro-fraturas na solda. Garantir um design adequado das pastilhas de solda na sua PCB evitará estes problemas de montagem.

#5 Problemas de corrente de fuga em Charlieplexing

O Charlieplexing é altamente sensível a variações nas tensões diretas dos LEDs. Se misturar LEDs vermelhos (2,0V) e azuis (3,2V) nas mesmas linhas tri-state, a corrente fluirá através dos LEDs de tensão mais baixa quando os pinos estiverem em modo de alta impedância, causando ghosting intenso. Utilize sempre LEDs idênticos com tensões diretas emparelhadas numa rede Charlieplexed.

Projetos práticos de multiplexagem de LED Arduino

#1 Animação em matriz de LED 8x8

Utilizando o varrimento direto de matriz por GPIO, pode escrever arrays personalizados para apresentar frames sequencialmente, criando animações simples de pixel art 8x8, recursos de jogos retro ou ícones de estado sem componentes de hardware adicionais.

#2 Multiplexagem de cubo de LED 4x4x4

Um cubo de LED 3D utiliza multiplexagem espacial. Ao ligar os ânodos de 16 colunas verticais diretamente a 16 pinos GPIO do Arduino e utilizar 4 pinos separados para percorrer os 4 planos horizontais de cátodo comum, pode endereçar todos os 64 LEDs individualmente no espaço 3D.

#3 Badge de LED com Charlieplexing

Como o Charlieplexing não requer absolutamente nenhum CI auxiliar externo, é perfeito para pins e badges wearable compactos e ultraleves. Permite-lhe executar uma matriz de 20 luzes de estado interativas utilizando apenas 5 ligações de traço finas encaminhadas para um microcontrolador miniatura.

#4 PCB personalizada para projetos de matriz de LED

Embora as breadboards sejam ótimas para prototipagem, os circuitos de LED multiplexados transformam-se rapidamente numa confusão desordenada de fios jumper, levando a ligações soltas, capacitância parasita e resistência elevada.

Figura: Renderização 3D de uma PCB shield personalizada para Arduino Uno, mostrando encaminhamento de traços limpo, componentes SMT e uma matriz de LED 8x8.

Para designs com grandes quantidades de LEDs SMD, resistências ou CI drivers, a JLCPCB também fornece obtenção de componentes e serviços de montagem de PCB. A montagem SMT profissional e a soldadura por refusão ajudam a reduzir o esforço de montagem manual, garantindo simultaneamente uma qualidade de fabrico consistente.

Conclusão

A multiplexagem direta de LED por software permite que pequenos microcontroladores controlem grandes displays utilizando temporização de varrimento cuidadosa e arquiteturas de cablagem partilhada. Embora o varrimento direto de matriz por GPIO e o Charlieplexing coloquem uma elevada exigência de processamento no seu software, proporcionam uma forma incrivelmente barata, minimalista e profundamente educativa de contornar os limites de pinos de hardware.

Projetar layouts personalizados, exportar Gerbers padrão e utilizar serviços profissionais de fabrico SMT como a Montagem de PCB da JLCPCB garantem uma soldadura de PCB perfeita e um funcionamento fiável do display, elevando os seus projetos eletrónicos a um acabamento de nível comercial.

Perguntas frequentes sobre multiplexagem de LED Arduino