Charlieplexing - Charlieplexing
Charlieplexing é uma técnica para acionar uma tela multiplexada na qual relativamente poucos pinos de I / O em um microcontrolador são usados, por exemplo, para acionar uma série de LEDs .
O método usa os recursos lógicos de três estados de microcontroladores para ganhar eficiência em relação à multiplexação tradicional. Embora seja mais eficiente no uso de E / S, há problemas que tornam seu design mais complicado e dificultam telas maiores. Esses problemas incluem o ciclo de trabalho , os requisitos de corrente e as tensões de avanço dos LEDs.
Origem
Charlieplexing foi proposto no início de 1995 por Charlie Allen na Maxim Integrated após a divulgação pública ao PICLIST por Graham Daniel (na época g.daniel.invent.design) de seu projeto usando chips PIC para acionar linhas e colunas de LEDs bidirecionais. Após alguma discussão sobre o PICLIST, a ideia foi aceita pela comunidade PICLIST e posteriormente incluída em um livreto de truques do Microchip, mas sem atribuição. Graham na época criou circuitos simples com chips PIC 12C508 acionando 12 LEDs de 5 pinos com um mini comando definido para colocar vários monitores de iluminação em movimento. Como em qualquer multiplexação, é necessário alternar rapidamente os LEDs em uso para que a persistência do olho humano perceba que a tela está iluminada como um todo. A multiplexação geralmente pode ser vista por um efeito estroboscópico e distorção se o ponto focal do olho for movido para além da tela rapidamente. O método, no entanto, era conhecido e utilizado por várias partes muito antes na década de 1980 e foi descrito em detalhes já em 1979 em uma patente de Christopher W. Malinowski, Heinz Rinderle e Martin Siegle do Departamento de Pesquisa e Desenvolvimento , AEG-Telefunken , Heilbronn, Alemanha pelo que eles chamaram de "sistema de sinalização de três estados".
Multiplexação tradicional
| Alfinetes | LEDs |
|---|---|
| 1 | 0 |
| 2 | 2 |
| 3 | 6 |
| 4 | 12 |
| 5 | 20 |
| 6 | 30 |
| 7 | 42 |
| 8 | 56 |
| 9 | 72 |
| 10 | 90 |
| 20 | 380 |
| 40 | 1560 |
| n | n 2 - n |
A multiplexação de exibição é muito diferente da multiplexação usada na transmissão de dados, embora tenha os mesmos princípios básicos. Na multiplexação de display, as linhas de dados dos displays * são conectadas em paralelo a um barramento de dados comum no microcontrolador. Em seguida, os visores são ligados e endereçados individualmente. Isso permite o uso de menos pinos de E / S do que normalmente seriam necessários para acionar o mesmo número de monitores diretamente. * Aqui, cada "exibição" pode, por exemplo, ser um dígito da calculadora, não a matriz completa de dígitos.
Ao usar o Charlieplexing, n pinos de unidade podem conduzir n dígitos com n - 1 segmentos. Quando simplificado, equivale a n pinos, podendo acionar n 2 - n segmentos ou LEDs. A multiplexação tradicional requer muito mais pinos para acionar o mesmo número de LEDs; 2 n pinos devem ser usados para acionar n 2 LEDs (embora um chip decodificador 1- of - n possa ser usado para reduzir o número de pinos de E / S do microcontrolador para ).
Se o número de LEDs for conhecido, a equação anterior pode ser trabalhada ao contrário para determinar o número de pinos necessários. Ou seja, os LEDs L podem ser acionados por pinos.
Impulso complementar
Charlieplexing em sua forma mais simples funciona usando uma matriz de diodo de pares complementares de LEDs. A matriz Charlieplexada mais simples possível seria assim:
Ao aplicar uma tensão positiva ao pino X1 e ao pino de aterramento X2, o LED1 acenderá. Uma vez que a corrente não pode fluir pelos LEDs na direção reversa nesta baixa tensão, o LED2 permanecerá apagado. Se as tensões nos pinos X1 e X2 forem invertidas, o LED2 acenderá e o LED1 ficará apagado.
A técnica de Charlieplexing não torna realmente possível uma matriz maior ao usar apenas dois pinos, porque dois LEDs podem ser acionados por dois pinos sem nenhuma conexão de matriz, e mesmo sem usar o modo tri-state. Neste exemplo de dois LEDs, o Charlieplexing economizaria um fio terra, que seria necessário em uma situação comum de driver de 2 pinos.
No entanto, o circuito de 2 pinos serve como um exemplo simples para mostrar os conceitos básicos antes de passar para circuitos maiores, onde o Charlieplexing realmente mostra uma vantagem.
Expansão: lógica tri-state
Se o circuito acima fosse expandido para acomodar 3 pinos e 6 LEDs, ficaria assim:
Isso apresenta um problema, entretanto. Para que este circuito atue como o anterior, um dos pinos deve ser desconectado antes de aplicar carga aos dois restantes. Se, por exemplo, LED5 deveria estar aceso, X1 deve ser carregado e X3 deve ser aterrado. No entanto, se o X2 também estiver carregado, o LED3 também acenderá. Se o X2 fosse aterrado, o LED1 acenderia, o que significa que o LED5 não pode ser aceso sozinho. Isso pode ser resolvido utilizando as propriedades lógicas de três estados dos pinos do microcontrolador. Os pinos do microcontrolador geralmente têm três estados: "alto" (5 V), "baixo" (0 V) e "entrada". O modo de entrada coloca o pino em um estado de alta impedância , que, eletricamente falando, "desconecta" aquele pino do circuito, significando que pouca ou nenhuma corrente fluirá por ele. Isso permite que o circuito veja qualquer número de pinos conectados a qualquer momento, simplesmente alterando o estado do pino. Para acionar a matriz de seis LEDs acima, os dois pinos correspondentes ao LED a ser aceso são conectados a 5 V (pino de E / S "alto" = número binário 1) e 0 V (pino de E / S "baixo" = binário 0), enquanto o terceiro pino é definido em seu estado de entrada.
Com isso, evita-se o vazamento de corrente do terceiro pino, garantindo que o LED que deseja acender seja o único aceso. Como o LED desejado reduz a tensão disponível após o resistor, a corrente não fluirá por caminhos alternativos (um caminho alternativo de 2 LEDs existe para cada par de pinos no diagrama de 3 pinos, por exemplo), desde que a tensão caia em o caminho do LED desejado é menor do que a queda total de tensão em cada string de LEDs alternativos. No entanto, na variante com resistores individuais, este efeito regulador de tensão não afeta os caminhos alternativos, então você deve garantir que todos os LEDs usados não acendam com metade da tensão de alimentação aplicada, porque esta variante não se beneficia do efeito regulador de tensão do LED do caminho desejado.
Usando a lógica tri-state, a matriz pode teoricamente ser expandida para qualquer tamanho, desde que os pinos estejam disponíveis. Para n pinos, n ( n - 1) LEDs podem estar na matriz. Qualquer LED pode ser aceso aplicando 5 V e 0 V aos pinos correspondentes e configurando todos os outros pinos conectados à matriz para o modo de entrada. Sob as mesmas restrições, conforme discutido acima, até n - 1 LEDs que compartilham um caminho comum positivo ou negativo podem ser acesos em paralelo.
Expandindo
O circuito de 3 fios pode ser reorganizado para esta matriz quase equivalente (os resistores foram realocados).
Isso enfatiza as semelhanças entre o multiplex de grade comum e o Charlieplex e demonstra o padrão que leva à regra do " n- quadrado menos n ".
Em uso típico em uma placa de circuito, os resistores estariam fisicamente localizados no topo das colunas e conectados ao pino de entrada. As linhas seriam então conectadas diretamente ao pino de entrada ignorando o resistor.
A primeira configuração é adequada apenas quando LEDs idênticos são usados, enquanto na segunda configuração com resistores individuais, os resistores tornam possível misturar diferentes tipos de LEDs, fornecendo a cada um seu resistor apropriado.
Nessas configurações, os resistores realocados possibilitam acender vários LEDs ao mesmo tempo, linha por linha, em vez de exigir que sejam acesos individualmente. A capacidade de corrente da linha pode ser aumentada por um seguidor de emissor NPN em vez do pino de E / S tipicamente muito mais fraco.
Problemas com Charlieplexing
Taxa de atualização
Como apenas um único conjunto de LEDs, todos tendo um ânodo ou cátodo comum, pode ser aceso simultaneamente sem ligar LEDs indesejados, o Charlieplexing requer mudanças frequentes de saída, por meio de um método conhecido como multiplexação . Quando a multiplexação é feita, nem todos os LEDs são acesos simultaneamente, mas um conjunto de LEDs é aceso brevemente, depois outro conjunto e, eventualmente, o ciclo se repete. Se for feito rápido o suficiente, eles parecerão estar sempre ligados, o tempo todo, aos olhos humanos por causa da persistência da visão . Para que uma tela não tenha nenhuma cintilação perceptível, a taxa de atualização de cada LED deve ser superior a 50 Hz.
Suponha que 8 pinos tri-state sejam usados para controlar 56 LEDs por meio do Charlieplexing, o que é suficiente para 8 visores de 7 segmentos (sem casas decimais). Normalmente, os monitores de 7 segmentos são feitos para ter um cátodo comum, às vezes um ânodo comum, mas sem perda de generalidade, suponha que seja um cátodo comum. Todos os LEDs em todos os 8 visores de 7 segmentos não podem ser ligados simultaneamente em qualquer combinação desejada usando Charlieplexing. É impossível obter 56 bits de informação diretamente de 8 trits (o termo para um caractere de base 3, pois os pinos são de 3 estados) de informação, já que 8 trits compreendem fundamentalmente 8 log 2 3, ou cerca de 12,7 bits de informação , que fica muito aquém dos 56 bits necessários para ligar ou desligar todos os 56 LEDs em qualquer combinação arbitrária. Em vez disso, o olho humano deve ser enganado pelo uso da multiplexação.
Apenas um display de 7 segmentos, um conjunto de 7 LEDs pode estar ativo a qualquer momento. Isso seria feito se os 8 catodos comuns dos 8 monitores fossem atribuídos a seu próprio pino exclusivo entre as 8 portas de E / S. A qualquer momento, um e apenas um dos 8 pinos de I / O de controle estará ativamente baixo e, portanto, apenas o display de 7 segmentos com seu cátodo comum conectado a esse pino ativamente baixo pode ter qualquer um de seus LEDs acesos. Esse é o display ativo de 7 segmentos. Os ânodos dos 7 segmentos de LED dentro do display ativo de 7 segmentos podem então ser ligados em qualquer combinação, tendo as outras 7 portas de E / S altas ou no modo de alta impedância, em qualquer combinação. Eles são conectados aos 7 pinos restantes, mas por meio de resistores (a conexão do cátodo comum é conectada ao próprio pino, não por meio de um resistor, porque senão a corrente através de cada segmento individual dependeria do número total de segmentos ligados, pois eles todos teriam que compartilhar um único resistor). Mas para mostrar um número desejado usando todos os 8 dígitos, apenas um display de 7 segmentos pode ser mostrado por vez, então todos os 8 devem ser alternados separadamente, e em um 50º de segundo para todo o período de 8. Assim, o display deve ser atualizado a 400 Hz para o período de 8 ciclos através de todos os 8 segmentos para fazer os LEDs piscarem mais lentamente do que 50 vezes por segundo. Isso requer interrupção constante de qualquer processamento adicional que o controlador execute, 400 vezes por segundo.
Corrente de pico
Devido ao ciclo de trabalho reduzido , o requisito atual de uma tela com Charlieplex aumenta muito mais rápido do que faria com uma tela tradicionalmente multiplexada. Conforme a tela fica maior, a corrente média que flui através do LED deve ser (aproximadamente) constante para manter o brilho constante, exigindo que a corrente de pico aumente proporcionalmente. Isso causa uma série de problemas que limitam o tamanho prático de uma tela Charlieplexada.
- Os LEDs geralmente têm uma classificação de corrente de pico máxima, bem como uma classificação de corrente média.
- Se o código do microcontrolador falhar, e um Charlieplex de um led de cada vez estiver sendo usado, o único LED aceso à esquerda está sob estresse muito maior do que estaria em um display linear de cada vez ou em um display tradicionalmente multiplexado, aumentando o risco de falha antes que a falha seja detectada.
Requisito para tristate
Todas as saídas usadas para acionar um display Charlieplexado devem ser tristate. Se a corrente for baixa o suficiente para acionar os visores diretamente pelos pinos de E / S do microcontrolador, isso não é um problema, mas se triestatos externos devem ser usados, então cada triestato geralmente exigirá duas linhas de saída para controlar, eliminando a maioria dos a vantagem de um display com configuração Charlie. Uma vez que a corrente dos pinos do microcontrolador é tipicamente limitada a 20 mA ou mais, isso restringe severamente o tamanho prático de um display Charlieplex. No entanto, isso pode ser feito ativando um segmento de cada vez.
Complexidade
As matrizes Charlieplex são significativamente mais complicadas, tanto no layout PCB necessário quanto na programação do microcontrolador, do que usar matrizes multiplex pré-construídas. Isso aumenta o tempo de design. Os componentes de soldagem também podem consumir mais tempo do que os conjuntos de LEDs multiplexados. Um equilíbrio entre a complexidade e o uso de pinos pode ser alcançado pelo Charlieplexing vários conjuntos de LEDs multiplexados pré-construídos juntos.
Tensão direta
Ao usar LEDs com tensões diretas diferentes , como quando usar LEDs de cores diferentes, alguns LEDs podem acender quando não desejados.
No diagrama acima, pode ser visto que se o LED 6 tiver uma tensão direta de 4 V e os LEDs 1 e 3 tiverem tensões diretas de 2 V ou menos, eles acenderão quando o LED 6 for pretendido, pois o caminho da corrente é mais curto. Esse problema pode ser facilmente evitado comparando-se as tensões diretas dos LEDs usados na matriz e verificando se há problemas de compatibilidade. Ou, mais simplesmente, usando LEDs que possuem a mesma voltagem direta.
Este também é um problema onde os LEDs estão usando resistores individuais em vez de resistores compartilhados; se houver um caminho através de dois LEDs que tenha menos queda de LED do que a tensão de alimentação, esses LEDs também podem acender em momentos indesejados.
Falha de LED
Se um único LED falhar, tornando-se um circuito aberto, curto-circuito ou vazado (desenvolvendo uma resistência paralela parasita, que permite corrente em ambas as direções), o impacto será catastrófico para a tela como um todo. Além disso, o LED problemático real pode ser muito difícil de identificar, porque potencialmente um grande conjunto de LEDs que não deveriam ser acesos podem acender todos juntos e - sem conhecimento detalhado do circuito - a relação entre qual LED está ruim e qual conjunto de LEDs que se acendem juntos não pode ser facilmente estabelecido.
Se o LED com falha se tornar um circuito aberto, a tensão entre os 2 eletrodos do LED pode aumentar até encontrar um caminho através de dois outros LEDs. Existem tantos caminhos como os pinos usados para controlar a matriz menos 2; se o LED com ânodo no nó m e cátodo no nó n falhar desta forma, pode ser que cada par de LEDs em que o ânodo seja o nó m , cátodo seja p para qualquer valor de p (com as exceções de que p não pode seja m ou n , então há tantas opções possíveis para p quanto o número de pinos controlando a matriz menos 2), junto com o LED cujo ânodo é p e cátodo é n , todos acenderão.
Se houver 8 pinos de E / S controlando a matriz, isso significa que haverá 6 caminhos parasitas através de pares de 2 LEDs, e 12 LEDs podem estar acesos acidentalmente, mas felizmente isso só acontecerá quando o LED defeituoso vier aceso, o que pode ser uma pequena fração do tempo e não exibirá nenhum sintoma deletério quando o LED problemático não estiver aceso. Se o problema está a uma curta entre nós x e y , em seguida, cada vez que qualquer LED U com qualquer x ou y como ânodo ou cátodo e alguns nó z como seu outro eletrodo deve vir em (sem perda de generalidade, vamos supor que U' s cátodo é conectado a x ), o LED V com cátodo y e ânodo z acenderá também, então sempre que QUALQUER nó x ou y for ativado como ânodo OU cátodo, dois LEDs acenderão em vez de um. Nesse caso, ele acende apenas um LED adicional sem querer, mas com muito mais frequência; não apenas quando o LED com falha deve acender, mas quando qualquer LED que tem um pino em comum com o LED com falha deve acender.
Os elementos problemáticos tornam-se especialmente difíceis de identificar se houver dois ou mais LEDs com falha. O que isso significa é que, ao contrário da maioria dos métodos em que a perda de um único LED apenas causa um único segmento queimado, quando o Charlieplexing é usado, um ou dois LEDs queimados, qualquer que seja o modo de falha, quase certamente causará um desastre catastrófico cascata de iluminações não intencionais dos LEDs que ainda funcionam, muito provavelmente tornando todo o dispositivo completa e imediatamente inutilizável. Isso deve ser levado em consideração ao considerar a vida útil necessária e as características de falha do dispositivo que está sendo projetado.
Multiplexação de dados de entrada
Charlieplexing também pode ser usado para multiplexar sinais de entrada digital em um microcontrolador. Os mesmos circuitos de diodo são usados, exceto que uma chave é colocada em série com cada diodo. Para ler se uma chave está aberta ou fechada, o microcontrolador configura um pino como uma entrada com um resistor pull-up interno. O outro pino é configurado como uma saída e definido para o nível lógico baixo. Se o pino de entrada estiver baixo, a chave está fechada e, se o pino de entrada estiver alta, a chave está aberta.
Uma aplicação potencial para isso é ler um teclado numérico padrão (4 × 3) de 12 teclas usando apenas 4 linhas de E / S. O método tradicional de varredura linha-coluna requer 4 + 3 = 7 linhas de E / S. Assim, o Charlieplexing economiza 3 linhas de E / S; no entanto, adiciona o custo de 12 diodos, (uma vez que os diodos só ficam livres quando os LEDs são usados). Uma variação do circuito com apenas 4 diodos é possível, porém isso reduz o rollover do teclado. O microcontrolador sempre pode detectar quando os dados estão corrompidos, mas não há garantia de que possa sentir os pressionamentos de tecla originais, a menos que apenas um botão seja pressionado por vez. (No entanto, é provavelmente possível organizar o circuito de forma que, se no máximo dois botões adjacentes forem pressionados, nenhuma perda de dados ocorrerá.) A entrada só é sem perdas no circuito de 4 diodos se apenas um botão for pressionado em um tempo, ou se certos pressionamentos problemáticos de várias teclas forem evitados. No circuito de 12 diodos, isso não é um problema e sempre há uma correspondência um a um entre o pressionamento de botões e os dados de entrada. No entanto, existem tantos diodos que são necessários para usar o método (especialmente para matrizes maiores) que geralmente não há economia de custos em relação ao método tradicional de varredura linha-coluna, a menos que o custo de um diodo seja apenas uma fração do custo de um pino de E / S, onde essa fração é um sobre o número de linhas de E / S.
Tucoplexing
Micah Elizabeth Scott desenvolveu um método para usar 3 pinos para executar 4 LEDs e 4 interruptores chamado Tucoplexing.
GuGaplexing
Gugaplexing é como charlieplexing com múltiplas tensões de drive.
Chipiplexing
Chipiplexing adiciona seguidores de emissor para aumentar a força da unidade de linha, permitindo que linhas mais largas do que uma única porta de microcontrolador pudesse acender simultaneamente.
Modulação de largura de pulso
Charlieplexing pode até ser usado para usar modulação de largura de pulso para controlar o brilho de 12 LEDs com 4 pinos.
Exemplo de código
No exemplo de código a seguir, o circuito usa um microcontrolador ATtiny de 8 pinos que possui 5 pinos de E / S para criar um display de 7 segmentos . Uma vez que um display de 7 segmentos requer apenas o controle de 7 LEDs individuais, usamos 4 dos pinos de E / S ATtiny como saídas charlieplexed (n * (n-1)). Deixando o quinto pino de E / S para ser usado como entrada digital ou analógica ou outra saída.
// ATtiny code
// Reads analog (or digital) input from pin 4 and every time the input goes below a set threshold
// it counts one and displays the increase in count either by activating up one of four LEDs (or transistors)
// or one of twelve charlieplexed LEDs.
// SET THESE VALUES:
int threshold = 500;
int maxCount = 7;
////////////////////
boolean sensorTriggered = false;
int count = 0;
int sensorValue = 0;
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 50; // the debounce time; increase if the output flickers
////////////////////////////////////////////////////////////////////////////////
void setup() {
for (int pin=0; pin<4; pin++) {
pinMode(pin, OUTPUT);
digitalWrite(pin, LOW);
}
pinMode(4, INPUT);
digitalWrite(4, HIGH); // internal pull-up
}
////////////////////////////////////////////////////////////////////////////////
void loop() {
testDigits();
}
void testDigits() {
charlieLoop();
}
////////////////////////////////////////////////////////////////////////////////
void readSensor() {
sensorValue = analogRead(2); // pin4!
delay(100);
if (sensorValue < threshold && sensorTriggered == false) {
sensorTriggered = true;
count++;
if (count > maxCount) count = 0;
charlieLoop();
}
if (sensorValue > threshold) sensorTriggered = false;
}
////////////////////////////////////////////////////////////////////////////////
void charlieLoop() {
count++;
for (int i=0; i<1000; i++) {
for (int c=0; c<count; c++) {
charliePlexPin(c);
}
}
delay(1000);
if (count > maxCount) count = 0;
}
////////////////////////////////////////////////////////////////////////////////
void charliePlexPin(int myLed){
// Make sure we don't feed random voltages to the LEDs
// during the brief time we are changing pin modes and voltages.
pinMode(0, INPUT);
pinMode(1, INPUT);
pinMode(2, INPUT);
pinMode(3, INPUT);
switch(myLed){
case 0:
pinMode(0, OUTPUT);
pinMode(2, OUTPUT);
digitalWrite(2, LOW);
digitalWrite(0, HIGH);
break;
case 1:
pinMode(3, OUTPUT);
pinMode(2, OUTPUT);
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
break;
case 2:
pinMode(3, OUTPUT);
pinMode(1, OUTPUT);
digitalWrite(1, LOW);
digitalWrite(3, HIGH);
break;
case 3:
pinMode(1, OUTPUT);
pinMode(0, OUTPUT);
digitalWrite(0, LOW);
digitalWrite(1, HIGH);
break;
case 4:
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
digitalWrite(1, LOW);
digitalWrite(0, HIGH);
break;
case 5:
pinMode(2, OUTPUT);
pinMode(0, OUTPUT);
digitalWrite(0, LOW);
digitalWrite(2, HIGH);
break;
case 6:
pinMode(2, OUTPUT);
pinMode(1, OUTPUT);
digitalWrite(1, LOW);
digitalWrite(2, HIGH);
break;
}
}
////////////////////////////////////////////////////////////////////////////////
void spwm(int freq, int pin, int sp) {
// call charlieplexing to set correct pin outs:
//on:
digitalWrite(pin, HIGH);
delayMicroseconds(sp * freq);
// off:
digitalWrite(pin, LOW);
delayMicroseconds(sp * (255 - freq));
}