Charlieplexing - Charlieplexing
Charlieplexing er en teknikk for å kjøre en multiplekset skjerm der relativt få I / O-pinner på en mikrokontroller brukes, for eksempel for å drive en rekke lysdioder .
Metoden bruker trestatslogiske evner til mikrokontrollere for å oppnå effektivitet i forhold til tradisjonell multiplexing. Selv om det er mer effektivt i bruken av I / O, er det problemer som gjør at det blir mer komplisert å designe og gjøre det vanskelig for større skjermer. Disse problemene inkluderer driftssyklus , gjeldende krav og fremoverspenningene til lysdiodene.
Opprinnelse
Charlieplexing ble foreslått tidlig i 1995 av Charlie Allen ved Maxim Integrated etter offentliggjøring til PICLIST av Graham Daniel (på det tidspunktet g.daniel.invent.design) av hans design ved hjelp av PIC-brikker for å drive rader og kolonner med toveis LED. Etter noen diskusjoner om PICLISTEN ble ideen akseptert av PICLIST-samfunnet og ble senere inkludert i et Microchip-trikshefte, men uten henvisning. Graham opprettet på det tidspunktet enkle kretser med PIC 12C508-chips som kjørte 12 lysdioder av 5 pinner med et mini-kommandosett for å sette forskjellige belysningsdisplayer i bevegelse. Som med enhver multiplexing, er det et krav om å bla gjennom lysdiodene som er i bruk raskt, slik at utholdenheten i det menneskelige øye oppfatter skjermen som en helhet. Multiplexing kan vanligvis sees av en strobing-effekt og skjevhet hvis øyets fokuspunkt beveges raskt forbi skjermen. Metoden var imidlertid kjent og brukt av forskjellige parter mye tidligere på 1980-tallet, og har blitt beskrevet i detalj allerede i 1979 i et patent av Christopher W. Malinowski, Heinz Rinderle og Martin Siegle fra Institutt for forskning og utvikling. , AEG-Telefunken , Heilbronn, Tyskland for det de kalte et "trestatssignaliseringssystem".
Tradisjonell multiplexing
| Pins | LED-lys |
|---|---|
| 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 |
Skjermmultipleksering er veldig forskjellig fra multipleksing som brukes i dataoverføring, selv om den har de samme grunnleggende prinsippene. I displaymultipleksering er datalinjene til skjermene * koblet parallelt til en felles databus på mikrokontrolleren. Deretter slås skjermene på og adresseres individuelt. Dette tillater bruk av færre I / O-pinner enn det normalt ville ta å kjøre samme antall skjermer direkte. * Her kan hvert "display" for eksempel være ett kalkulator-siffer, ikke det komplette utvalget av sifre.
Når du bruker Charlieplexing, kan n stifter kjøre n sifre med n - 1 segmenter. Når det er forenklet, tilsvarer det at n- pinner kan kjøre n 2 - n segmenter eller lysdioder. Tradisjonell multiplexing krever mange flere pinner for å kjøre like mange lysdioder; 2 n pinner må brukes til å kjøre n 2 lysdioder (selv om en 1-av- n dekoderbrikke kan brukes til å redusere antall mikrokontroller I / O-pinner til ).
Hvis antall lysdioder er kjent, kan den forrige ligningen jobbes bakover for å bestemme antall pinner som kreves. Det vil si at L- lysdioder kan drives av pinner.
Utfyllende kjøretur
Charlieplexing i sin enkleste form fungerer ved hjelp av en diodematrise av komplementære par av lysdioder. Den enkleste mulige Charlieplexed-matrisen vil se slik ut:
Ved å legge en positiv spenning på pinne X1 og jordingspinne X2, vil LED1 lyse. Siden strøm ikke kan strømme gjennom lysdioder i omvendt retning ved denne lave spenningen, forblir LED2 ubelyst. Hvis spenningene på pinne X1 og pinne X2 er omvendt, lyser LED2 og LED1 lyser ikke.
Charlieplexing-teknikken gjør faktisk ikke en større matrise mulig bare ved bruk av to pinner, fordi to lysdioder kan drives av to pinner uten matriseforbindelser, og uten å bruke tri-state-modus. I dette to-LED-eksemplet ville Charlieplexing lagre en jordledning, noe som ville være nødvendig i en vanlig 2-pinners driver situasjon.
Imidlertid fungerer 2-pinners kretsen som et enkelt eksempel for å vise de grunnleggende konseptene før du går videre til større kretser der Charlieplexing faktisk viser en fordel.
Utvider: trestatslogikk
Hvis kretsen over skulle utvides til å omfatte 3 pinner og 6 lysdioder, ville det se slik ut:
Dette gir imidlertid et problem. For at denne kretsen skal fungere som den forrige, må en av tappene kobles fra før de resterende to blir ladet. Hvis for eksempel LED5 var ment å være tent, må X1 lades og X3 må være jordet. Imidlertid, hvis X2 også er ladet, vil LED3 også lyse. Hvis X2 i stedet ble jordet, ville LED1 lyse, noe som betyr at LED5 ikke kan tennes av seg selv. Dette kan løses ved å bruke de tre-tilstandslogiske egenskapene til mikrokontrollerpinner. Microcontroller-pinner har generelt tre tilstander: "høy" (5 V), "lav" (0 V) og "inngang". Inngangsmodus setter pinnen i en høyimpedansetilstand , som, elektrisk sett, "kobler" den pinnen fra kretsen, noe som betyr at liten eller ingen strøm vil strømme gjennom den. Dette gjør at kretsen kan se hvilket som helst antall pinner som er koblet til når som helst, ganske enkelt ved å endre pinnens tilstand. For å kjøre seks-LED-matrisen over, er de to pinnene som tilsvarer LED-en som skal tennes koblet til 5 V (I / O-pinne "høy" = binært tall 1) og 0 V (I / O-pinne "lav" = binær 0), mens den tredje pinnen er satt i inngangstilstand.
Ved å gjøre dette forhindres strømlekkasje ut av den tredje pinnen, noe som sørger for at LED-en som ønsket å lyse, er den eneste som lyser. Fordi ønsket lysdiode reduserer spenningen som er tilgjengelig etter motstanden, vil ikke strøm strømme over alternative baner (for eksempel finnes en alternativ 2-LED-bane for hvert par pinner i 3-pinners diagrammet), så lenge spenningsfallet ønsket LED-bane er mindre enn det totale spenningsfallet over hver streng med alternative LED-er. I varianten med individuelle motstander påvirker imidlertid denne spenningsregulerende effekten ikke de alternative banene, så du må sørge for at alle LED-lampene som brukes ikke lyser med halvparten av forsyningsspenningen, fordi denne varianten ikke drar nytte av den spenningsregulerende effekten av ønsket sti-LED.
Ved å bruke tristatslogikk kan matrisen teoretisk utvides til hvilken som helst størrelse, så lenge stifter er tilgjengelige. For n pinner kan n ( n - 1) lysdioder være i matrisen. Enhver LED kan tennes ved å bruke 5 V og 0 V på de tilsvarende pinnene og sette alle de andre pinnene som er koblet til matrisen til inngangsmodus. Under de samme begrensningene som diskutert ovenfor, kan opptil n - 1 lysdioder som deler en felles positiv eller negativ bane tennes parallelt.
Utvider
3-ledningskretsen kan omorganiseres til denne nesten ekvivalente matrisen (motstandene er flyttet).
Dette understreker likhetene mellom vanlig rutenettmultipleks og Charlieplex, og demonstrerer mønsteret som fører til " n- kvadrat minus n " -regelen.
I typisk bruk på et kretskort vil motstandene være fysisk plassert på toppen av søylene og koblet til inngangspinnen. Radene vil da være koblet direkte til inngangspinnen utenom motstanden.
Det første oppsettet er bare egnet når identiske lysdioder brukes, mens motstandene i den andre konfigurasjonen med individuelle motstander gjør det mulig å blande forskjellige typer lysdioder ved å gi hver sin motstand.
I disse konfigurasjonene gjør de flyttede motstandene det mulig å lyse flere lysdioder samtidig rad for rad, i stedet for å kreve at de blir tent individuelt. Radestrømkapasiteten kan økes av en NPN-emitterfølger i stedet for den typisk mye svakere I / U-pinnen.
Problemer med Charlieplexing
Oppdateringsfrekvens
Fordi bare et enkelt sett med lysdioder, som alle har en felles anode eller katode, kan tennes samtidig uten å slå på utilsiktede lysdioder, krever Charlieplexing hyppige utgangsendringer, gjennom en metode kjent som multiplexing . Når multipleksing er gjort, tennes ikke alle lysdioder ganske samtidig, men heller et sett med lysdioder lyses kort, deretter et nytt sett, og til slutt gjentas syklusen. Hvis det gjøres raskt nok, vil de synes å være på hele tiden for det menneskelige øye på grunn av synsevne . For at en skjerm ikke skal ha noen merkbar flimring, må oppdateringshastigheten for hver LED være større enn 50 Hz.
Anta at 8 tri-state-pinner brukes til å kontrollere 56 lysdioder gjennom Charlieplexing, noe som er nok til 8 7-segmentskjermbilder (uten desimaltegn). Vanligvis er 7-segment skjermer laget for å ha en felles katode, noen ganger en vanlig anode, men uten tap av generalitet antar at det er en vanlig katode. Alle lysdioder i alle 8 7-segmentskjermene kan ikke slås på samtidig i ønsket kombinasjon ved bruk av Charlieplexing. Det er umulig å få 56 biter av informasjon direkte fra 8 trits (betegnelsen for et base-3-tegn, da pinnene er 3-state) av informasjon, da 8 trits fundamentalt består av 8 log 2 3, eller omtrent 12,7 bits informasjon , som faller langt under de 56 bitene som kreves for å slå alle 56 lysdioder på eller av i en vilkårlig kombinasjon. I stedet må det menneskelige øye lure ved å bruke multiplexing.
Bare en 7-segment skjerm, ett sett med 7 lysdioder kan være aktive når som helst. Måten dette vil bli gjort på er at de 8 vanlige katodene til de 8 skjermene tildeles hver sin unike pin mellom de 8 I / O-portene. Når som helst vil en og bare en av de 8 kontrollerende I / O-pinnene være aktivt lave, og dermed er det bare 7-segment skjermen med sin felles katode koblet til den aktivt lave pinnen som kan ha noen av LED-lampene på. Det er den aktive 7-segmentskjermen. Anodene til de 7 LED-segmentene i det aktive 7-segmentet kan deretter slås på i en hvilken som helst kombinasjon ved å ha de andre 7 I / O-portene enten høye eller i høyimpedansmodus, i hvilken som helst kombinasjon. De er koblet til de resterende 7 pinnene, men gjennom motstander (den vanlige katodeforbindelsen er koblet til selve pinnen, ikke gjennom en motstand, fordi ellers vil strømmen gjennom hvert enkelt segment avhenge av antall totale segmenter slått på, da de måtte alle dele en enkelt motstand). Men for å vise et ønsket tall ved bruk av alle 8 sifrene, kan bare en 7-segmentdisplay vises om gangen, så alle 8 må sykles gjennom hver for seg og i 50 sekundet for hele 8. Dermed må oppdateres ved 400 Hz for perioden 8-syklus gjennom alle de 8 segmentene for å gjøre at LED-lampene ikke blinker saktere enn 50 ganger per sekund. Dette krever konstant avbrytelse av hvilken som helst ekstra behandling kontrolleren utfører, 400 ganger per sekund.
Toppstrøm
På grunn av den reduserte driftssyklusen øker det nåværende kravet til en Charlieplexed-skjerm mye raskere enn det ville gjort med et tradisjonelt multiplekset display. Når skjermen blir større, må gjennomsnittsstrømmen som strømmer gjennom LED-en være (omtrent) konstant for at den skal opprettholde konstant lysstyrke, og dermed krever toppstrømmen å øke proporsjonalt. Dette forårsaker en rekke problemer som begrenser den praktiske størrelsen på en Charlieplexed-skjerm.
- Lysdioder har ofte en maksimal toppstrømrating samt en gjennomsnittlig strømrangering.
- Hvis mikrokontrollerkoden krasjer, og en en-ledet-om-en-tid Charlieplex blir brukt, er den eneste LED-lampen som er igjen tent under mye høyere stress enn den ville være i en rad om gangen charliplexed skjerm eller i en tradisjonelt multiplekset skjerm, noe som øker risikoen for en feil før feilen oppdages.
Krav til tristate
Alle utgangene som brukes til å kjøre en Charlieplexed-skjerm, må være tristate. Hvis strømmen er lav nok til å drive skjermene direkte av I / O-pinnene på mikrokontrolleren, er dette ikke et problem, men hvis eksterne tristates må brukes, vil hvert tristate vanligvis kreve to utgangslinjer for å kontrollere, og eliminere det meste av fordelen med en Charlieplexed-skjerm. Siden strømmen fra mikrokontrollerpinner vanligvis er begrenset til 20 mA eller så, begrenser dette den praktiske størrelsen på en Charlieplexed-skjerm alvorlig. Det kan imidlertid gjøres ved å aktivere ett segment om gangen.
Kompleksitet
Charlieplex-matriser er betydelig mer kompliserte, både i det nødvendige PCB-oppsettet og programmeringen av mikrokontroller, enn ved bruk av forhåndsbygde multipleksmatriser. Dette øker designtiden. Loddekomponenter kan også være mer tidkrevende enn for multipleksede LED-matriser. En balanse mellom kompleksitet og pin-bruk kan oppnås ved å Charlieplexing flere forhåndsbygde multipleksede LED-matriser sammen.
Fremover spenning
Ved bruk av lysdioder med forskjellige forover spenninger , for eksempel ved bruk av forskjellige farge lysdioder, kan enkelte lysdioder lyser når det ikke er ønskelig.
I diagrammet over kan det sees at hvis LED 6 har en 4 V fremover spenning, og LED 1 og 3 har fremover spenninger på 2 V eller mindre, vil de lyse når LED 6 er ment å, da deres nåværende bane er kortere. Dette problemet kan lett unngås ved å sammenligne fremoverspenningene til lysdiodene som brukes i matrisen og sjekke for kompatibilitetsproblemer. Eller, enklere, ved hjelp av lysdioder som alle har samme fremoverspenning.
Dette er også et problem der lysdiodene bruker individuelle motstander i stedet for delte motstander, hvis det er en sti gjennom to lysdioder som har mindre lysdiode enn forsyningsspenningen, kan disse lysdiodene også lyse til utilsiktede tider.
LED-feil
Hvis en enkelt LED mislykkes, ved å bli enten åpen krets, kortslutning eller lekkasje (utvikler en parasittisk parallellmotstand, som tillater strøm i begge retninger), vil virkningen være katastrofal for skjermen som helhet. Videre kan den faktiske problematiske lysdioden være veldig vanskelig å identifisere, fordi potensielt et stort sett med lysdioder som ikke skal tennes, alle sammen kan komme sammen, og uten detaljert kunnskap om kretsen, forholdet mellom hvilken lysdiode som er dårlig og hvilket sett av lysdioder som alle kommer sammen kan ikke lett etableres.
Hvis den mislykkede lysdioden blir en åpen krets, kan spenningen mellom lysdiodenes 2 elektroder bygge seg opp til den finner en vei gjennom to andre lysdioder. Det er like mange slike baner som det er pinner som brukes til å kontrollere matrisen minus 2; hvis lysdioden med anode ved node m og katode ved node n svikter på denne måten, kan det være at hvert enkelt par lysdioder der ens anode er node m , katoden er p for en hvilken som helst verdi av p (med unntak at p ikke kan være m eller n , så det er så mange mulige valg for p som antall pinner som styrer matrisen minus 2), sammen med lysdioden hvis anode er p og katoden er n , vil alle lyse opp.
Hvis det er 8 I / O-pinner som styrer matrisen, betyr det at det vil være 6 parasittiske baner gjennom par med 2 lysdioder, og 12 lysdioder kan være utilsiktet, men heldigvis vil dette bare skje når den ene dårlige lysdioden skal komme på, noe som kan være en liten brøkdel av tiden og ikke viser noen skadelige symptomer når LED-lampen for problemet ikke skal lyses. Hvis problemet er kort mellom noder x og y , skal hver LED U med enten x eller y som sin anode eller katode og en eller annen node z som den andre elektroden antas å tennes (uten tap av generalitet, antar at U ' s katoden er koblet til x ), LED V med katoden y og anode z tennes i tillegg, slik helst node x eller y er aktivert som en anode eller en katode, vil to lysdiodene tennes i stedet for ett. I dette tilfellet lyser det bare en ekstra LED utilsiktet, men det gjør det langt oftere; ikke bare når den mislykkede lysdioden skal lyse, men når en hvilken som helst lysdiode som har en stift til felles med den mislykkede lysdioden, skal lyse.
De problematiske elementene blir spesielt vanskelige å identifisere hvis det er to eller flere LED-er på feil. Hva dette betyr er at i motsetning til de fleste metoder der tap av en enkelt LED bare forårsaker et enkelt utbrent segment, når Charlieplexing brukes, vil en eller to utbrente lysdioder, uansett feilmodus, nesten helt sikkert føre til en katastrofal kaskade av utilsiktet belysning av lysdiodene som fremdeles fungerer, og sannsynligvis gjør hele enheten fullstendig og umiddelbart ubrukelig. Dette må tas i betraktning når man vurderer den nødvendige levetiden og feilfunksjonene til enheten som skal utformes.
Inngangsmultipleksering
Charlieplexing kan også brukes til å multiplekse digitale inngangssignaler til en mikrokontroller. De samme diodekretsene brukes, bortsett fra at en bryter er plassert i serie med hver diode. For å lese om en bryter er åpen eller lukket, konfigurerer mikrokontrolleren en pinne som inngang med en intern opptrekksmotstand. Den andre pinnen er konfigurert som en utgang og satt til det lave logiske nivået. Hvis inngangspinnen leser lavt, er bryteren lukket, og hvis inngangspinnen leser høyt, er bryteren åpen.
En potensiell applikasjon for dette er å lese et standard (4 × 3) 12-tasters numerisk tastatur med bare 4 I / O-linjer. Den tradisjonelle metoden for radkolonneskanning krever 4 + 3 = 7 I / O-linjer. Dermed sparer Charlieplexing 3 I / O-linjer; imidlertid legger det til bekostning av 12 dioder, (siden diodene bare er gratis når LED-er brukes). En variasjon av kretsen med bare 4 dioder er mulig, men dette reduserer overføring av tastaturet. Mikrokontrolleren kan alltid oppdage når dataene er korrupte, men det er ingen garanti for at den kan føle at den originale tastetrykk, med mindre bare en knapp trykkes om gangen. (Det er imidlertid sannsynlig mulig å ordne kretsen slik at hvis det maksimalt trykkes på to tilstøtende knapper, vil det ikke forekomme datatap.) Inngangen er bare tapsfri i 4-diodekretsen hvis bare en knapp trykkes på en tid, eller hvis visse problematiske tastetrykk unngås. I 12-diodekretsen er dette ikke noe problem, og det er alltid en-til-en korrespondanse mellom knappetrykk og inngangsdata. Imidlertid er det så mange dioder som kreves for å bruke metoden (spesielt for større matriser) at det generelt ikke er kostnadsbesparelser i forhold til den tradisjonelle metoden for radkolonneskanning, med mindre kostnaden for en diode bare er en brøkdel av kostnaden for en I / O-pinne, der den brøkdelen er en over antall I / O-linjer.
Tucoplexing
Micah Elizabeth Scott utviklet en metode for å bruke 3 pinner til å kjøre 4 lysdioder og 4 brytere kalt Tucoplexing.
GuGaplexing
Gugaplexing er som charlieplexing med flere drivspenninger.
Chipiplexing
Chipiplexing legger til emitterfølgere for å øke styrken på radstasjonen slik at radene som er bredere enn en enkelt mikrocontrollerport kan kjøre for å bli tent.
Pulsbreddemodulasjon
Charlieplexing kan til og med brukes til å bruke pulsbreddemodulering for å kontrollere lysstyrken på 12 lysdioder med 4 pinner.
Kodeeksempel
I følgende kodeeksempel bruker kretsen ATtiny 8-pinners mikrokontroller som har 5 I / O-pinner for å lage en 7- sagsdisplay . Siden en 7-segment skjerm bare krever kontroll av 7 individuelle lysdioder, bruker vi 4 av ATtiny I / O-pinnene som utganger med lyspære (n * (n-1)). Forlater den femte I / O-pinnen som skal brukes som digital eller analog inngang eller annen utgang.
// 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));
}
