Multiplexing LED’s

21feb12

Zo sluit je een LED-lampje op een Arduino aan. Maar wat als je meer LEDjes hebt. Bijvoorbeeld in een rooster van 16 x 16 ?

Dan wordt het lastig. Gelukkig zijn er trucs voor, zoals multiplexing.

Belangrijk is verder dat 512 LED’s 512 x 20 miliAmpères trekken. Dus 10240 mA, terwijl de Arduino maar 200 mA aan kan. Je kunt dus nooit 512 LED-lampjes van stroom voorzien met één Arduino.

De truc hier is POV, wat staat voor persistence of vision. Als je 512 LED’s snel na elkaar aan en weer uit doet, lijkt het alsof ze allemaal aan staan. Ons zien werkt met ongeveer 24 beeldjes per seconde. Een Arduino op 16 MHz kan 512 LEDjes per seconde vele duizenden keren achter elkaar aan-en-uit doen. Dat ‘uit’ zien we echter niet. Het wordt verwerkt in de helderheid van de betreffende LED. Laat je alle LED’s per ronde maar 1 miliseconde aan staan en een andere 2 miliseconden, zal het lijken alsof de laatste feller brandt.

Terug naar MULTIPLEXING. Bedoeling is dat je per rij alle ‘minnen’ verbindt en per kolom de ‘plussen’. Hierdoor kan ieder individueel LEDje aan en uit worden gezet, maar nooit twee tegelijkertijd.

Hier zijn de ‘minnen’ verbonden:

En hier de ‘Plussen’:

Samen levert dit 2 x 16 = 32 aansluitingen op.

Alles samen met één plus en één min verbonden met een General Purpose Input Output lijn (GPIO).

Verstandig is het om de LEDs een eigen stroom voorziening te geven.

Door de 16 ‘plussen’ en 16 ‘minnen’ met een TRANSISTOR te verbinden met de PLUS en MIN van de stroomvoorziening, kunnen we met een klein beetje ’5 Volt’ stroom vanuit een GPIO van de Arduino, bijvoorbeeld 12 Volt met veel ampère aanzetten. Een transistor is een electronisch knopje. I.p.v. de vinger op de knop, wordt een klein beetje stroom gebruikt.

Zo zet je een Transistor aan de min kant:

Aan de Pluskant moet je de transistor omdraaien. De ‘E’ is van emitter en wijst richting aarde. de ‘C’ van een transistor is de Collector, ofwel de plus kant.

Hierboven zijn 2 x 16 NPN-transistors met een 1000 Ohm weerstand verbonden. Zo gaat er nog minder stroom ‘verloren’ aan de arduino kant van de LED matrix.

Van 16 x 16 naar 2 x 16 scheelt 14 x 16 GPIO lijnen, maar is nog te veel voor een Arduino met maar een handjevol GPIO pinnetjes. Er zijn meerdere manieren om van veel naar minder lijnen te gaan. Hieronder leg ik er één uit.

Hier zijn twee ’4 naar 16′ lijn decoders ingezet. Met 4 bits / lijnen, wordt bepaald welke van de 16 outputlijnen aan gaat. Nadeel zou zijn dat je geen twee lijnen tegelijk aan kan zetten, maar dat hebben we i.v.m. POV (zie boven) niet nodig.

Door voor de anode- (plus) en kathode- (min) kant een aparte ’4 to 16 line decoder’ te gebruiken, kunnen we met 8 lijnen bepalen welk van de 512 LEDjes aangaat.

Door nu ook een shift register met latch te gebruiken, kunnen we met één datalijn, één klok-lijn en de latch de 2 x 4 lijnen van de lijndecoders aansturen.

Opgemerkt dienst te worden dat de 4 naar 16 lijndecoders óók ieder een latch hebben. Ik heb het niet getest, maar deze zou met de latch van de shiftregister op een GPIO kunnen, daar het totaal een gesynchroniseerd proces is.

Hier nogmaals het schema met ook de PLUS, MIN en latches aangesloten. Daaronder een verfraaide weergave.

Zelf heb ik mijn electret microfoon op een 20 LED geMultiplexte en met één 3 naar 8 lijndecoder opgeleukt circuit gezet. Ik had een 5 x 4 rooster gemaakt, waardoor ik eindigde met 4 GPIO naar 4 Transistors en 5 GPIO via de lijndecoder. Hieronder het resultaat:

Arduino code voor bovenstaande

int pinA = 3; // 3 to 8 line decoder (kathode)
int pinB = 4; // 3 to 8 line decoder (kathode)
int pinC = 5;  // 3 to 8 line decoder (kathode)
int pin[] = {6, 7, 8, 9}; // losse transistors (anode)
int nrH = 0;
int nrL = 0;
int geluid;

void setup()
  {  
  Serial.begin(9600);    
  }

void loop()
  {
  ledOn(  map(  analogRead(A0) ,0 ,1023 ,0 ,20 ));
  }

/************************************************/

void ledOn(int nummer){
  digitalWrite(pin[nrL], LOW);
  nrH = (nummer / 4);
  nrL = nummer % 4;
  digitalWrite(pinC, (4 & nrH));  
  digitalWrite(pinB, (2 & nrH));  
  digitalWrite(pinA, (1 & nrH));  
  digitalWrite(pin[nrL], HIGH);
}

In de void ledOn( int nummer ) zet ik eerst het vorige LEDtje uit, en daarna het volgende LEDje weer aan. Dat laatste doe ik door het nummer van 0-19 te delen en de modulus te nemen. Door deze truck krijgen we twee keer een getal die als het ware de hoogte en breedte van de multiplex zijn. In mijn video is het 4 bij 5. Dus 4 anodes en 4 Kathodes. Volstrekt overbodig heb ik een 3 naar 8 lijn decoder ingezet. Ik win er één pin mee, die ik aan de latch van de IC weer kwijt ben.

Slimmer was het geweest om de 3 naar 8 lijn decoder optimaal te benutten. Dan zou ik met 3 arduino pinnetjes 8 transistors kunnen aansturen en met de andere 4 pinnetjes 32 LEDjes kunnen aansturen.

Ik heb op ebay een paar goedkope 4 naar 16 lijn decoders gevonden. Met 4 eenen of nullen krijg je binair 0000 tot 1111. Dat is decimaal van 0 tot 15. Dus 16 lijnen. Een 5 naar 32 lijn decoder heb ik nog nooit gezien, maar zou wel logisch zijn.

Je kunt natuurlijk met zo’n lijn decoder IC niet twee lijnen tegelijk aansturen. Dat kun je met een schift-register wel. Deze laatste heeft echter een seriele input, wat inhoudt: een klok-tik per bit naar binnen, dus acht + latch = negen kloktikken (o.i.d.) per byte. Bij 16 outputlijnen zit een shift-registor dus aan 16+ kloktikken. Bij een lijn decoder is de invoer parallel. 4 arduino pinnetjes bepalen tegelijk welke van 16 lijnen aangaat. Klok-tik-latch klaar. Lijn decoder wordt daarom gebruikt om geheugen te beheren. Lekker snel een van de 16 geheugenchips selecteren en hopla: van 8 naar 128 MB intern geheugen (als het een desktop computer betrof. Want geheugen op een ATmega chip is beperkt.)

Maar goed: hier wordt de 3 naar 8 lijn decoder gehoereerd voor Lamme LEDjes.

Je kunt ook kant en klare multiplex eenheidjes kopen, zoals onderstaande laat zien. Ik vond ze op ebay voor weinig. Verwacht en 5 in de post.Er zitten 64 rode en 64 groene LED’s in. Als je goed kijkt zijn alle PLUSen per rij met elkaar verbonden van beide kleuren LED’s. Dus 8 x 16 LED’s. Bij de MINen is het anders georganiseerd: de gele en de groene LEDs hebben ieder een eigen MIN per kolom. Dus 2 x 8.

Totaal = 8 x anode en 16 kathode = 24  pinnetjes.

Ik heb de laatste 5 weten te bemachtigen voor euro 11,95. Dus 5 x 8 x 8 x 2 = 640 LED’s op 5 x 24 = 120 pinnetjes.  Dat is 1,9 cent per LED en nog heel veel knutselen om het op een arduino te krijgen. Wil er een mini lichtkrant van maken.

Categories: Uncategorized

4 Responses to Multiplexing LED’s

  1. Peter says:

    Je weet me steeds weer te verrassen. Indrukwekkend en leerzaam.
    (ben ik nu gek? Bij mij is een rij echt van L > R, v.v.). Hoe zit dat dan met jouw “aanhef” bij de eerste twee plaatjes.
    Groet, Peter

  2. Paul says:

    je hebt gelijk. Heb tekst veranderd. Het maakt overigens niet uit. Zolang alle polen van een rij of kolom maar gelijk zijn.

  3. Rene says:

    Ik heb de tijd genomen om dit aandachtig te bekijken en je hebt het mooi uitgelegd!
    Hoe krijg je et uitgedacht.. Zal wel iets met geduld zijn ofzo LOL

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>