Charlieplexing vs. Schieberegister

Hallo zusammen, ich hoffe ich bin hier im richtigen Forum ;).

Ich möchte eine LED-Funkuhr bauen (mit dem Atmega32) und benötige dazu min. 36 LEDs. Diese möchte ich jetzt entweder über Charlieplexing oder Schieberegister ansprechen. Das Charlieplexing funktioniert schon ganz gut, benötigt für die LEDs allerdings 16 Pins (es werden 4 x 9 LEDs, also eigentlich 4 x 12 LEDs angesteuert). Daher überlege ich auf Schieberegister zu wechseln.

Könnte mir jemand die Vor- und Nachteile von Schieberegistern gegenüber Charlieplexing erklären? Ich bin noch relativ neu in der Materie ;). Leuchtet z. B. bei Schieberegistern auch immer nur eine LED oder können auch mehrere gleichzeitig leuchten? Muss man was besonderes beachten etc. ;)?

Bin für jede Hilfe dankbar :).

mfg,
gyrosp

Wenn ich das so lese, dann denke ich eher, das du deine LEDs bisher per Multiplexing angeschlossen hast. Nachteil ist, das deine LEDs halt nicht die ganze Zeit leuchten, sondern nur (bei 4x9) zu einem Viertel der Zeit.

Schieberegister bergen den Nachteil, das du alle Anzeigeinfos erstmal in diesen Strang schieben musst und dir in dieser Zeit die Anzeige spinnt oder es dunkel ist. Wie stark das stört, liegt natürlich an der "Länge" des Schieberegisters.

Ich würde es weder über Schieberegister, noch über Multiplexing, sondern über Latches realisieren, wenn die Dunkelphasen stören.

Wenn die Dunkelphasen nicht stören, würde ich es bei Multiplexing belassen, allerdings mit 5x8 LEDs = 13 Pins, bzw. 11 Pins, wenn die Gruppenauswahl über nen Binär-Dezimal-Dekoder geht.

Das mit den Schieberegistern ist die aufwändigste Lösung und nur dann meiner Meinung nach sinnvoll, wenn die Anzahl der verfügbaren Pins
zu gering ist, oder die Anzahl der zu steuernden LEDs erheblich höher.
Denkbar ist dann auch eine Kombination aus Schieberegistern und Multiplexing. So habe ich z.B. LED-Matrix mit 105 LEDs gebaut, die über 8 Pins angesteuert wird.

Siehe http://www.youtube.com/watch?v=S_BhZdTcSvE

Gruß MeckPommER

Danke erstmal für die Antwort :).

Zitat:

Zitat von MeckPommER

Ich würde es weder über Schieberegister, noch über Multiplexing, sondern über Latches realisieren, wenn die Dunkelphasen stören.

Ist vielleicht ne dumme Frage aber was sind Latches und wie verwendet man die?

Zitat:

Zitat von MeckPommER

Wenn die Dunkelphasen nicht stören, würde ich es bei Multiplexing belassen, allerdings mit 5x8 LEDs = 13 Pins, bzw. 11 Pins, wenn die Gruppenauswahl über nen Binär-Dezimal-Dekoder geht.

Ich benötige 4 Segmente a 9 LEDS (Zehner Stunden, Einer Stunden, Zehner Minuten, Zehner Minuten). Daher habe ich bis jetzt für jedes Segment 4 Pins beim Charlieplexing eingeplant, womit ich also sogar 12 LEDS ansteuern könnte.

Ich sehe den Vorteil deines Charlieplexings momentan nicht. Du erhälst ein Tastverhältnis von 1:9 bei 9 LEDs und 16 Pins, wogegen du bei "normalem" Multiplexen zwischen den Stellen der Uhr bei 1:4 und 13 Pins wärst.

Latches sind Zwischenspeicher. Bei einem Latch legst du deine Informationen am Eingang an und gibst einen Impuls auf ein Steuerpin. Nun werden die die Infos am Eingang zu den Ausgängen durchgereicht und bleiben (das ist der Sinn der Sache) auch dann erhalten, wenn sich die Infos am Eingang ändern.
Du kannst also z.B. von 8-Bit am µC ausgehend 4 Latches parallel anschließen und die Infos am µC landen nur dort, wo du auch den Übernahmepin aktivierst. Das ist etwas mehr Schaltung, aber dafür keine Dunkelzeit an den LEDs.

Wie kommst du auf 9 LEDs pro Ziffer? 7 als 7-Segmentanzeige + 2 für Dezimalpunkte?

Gruß MeckPommER

Zitat:

Zitat von MeckPommER

Wie kommst du auf 9 LEDs pro Ziffer? 7 als 7-Segmentanzeige + 2 für Dezimalpunkte?

Sorry, hatte ich vergessen zu erwähnen. Ein Segment zeigt den Zahlenwert als Farbpunkt an, nicht als eigentliche zahl. Eine 3 wird z.B. durch drei Punkte dargestellt.

Zitat:

Zitat von MeckPommER

Ich sehe den Vorteil deines Charlieplexings momentan nicht. Du erhälst ein Tastverhältnis von 1:9 bei 9 LEDs und 16 Pins, wogegen du bei "normalem" Multiplexen zwischen den Stellen der Uhr bei 1:4 und 13 Pins wärst.

Das verstehe ich jetzt nicht ganz. Ich habe 16 Pins bei 36 LEDs (4 Pins pro 9LED-Segment). Ich bin wie gesagt noch nicht ganz so vertraut mit der Materie und mir ist gerade auch nicht der genaue Unterschied zwischen Charlie- und Multiplexing bekannt ;).

Zitat:

Zitat von MeckPommER

Latches sind Zwischenspeicher. Bei einem Latch legst du deine Informationen am Eingang an und gibst einen Impuls auf ein Steuerpin. Nun werden die die Infos am Eingang zu den Ausgängen durchgereicht und bleiben (das ist der Sinn der Sache) auch dann erhalten, wenn sich die Infos am Eingang ändern.

Das hört sich interessant an. Hast Du vielleicht einen Link zu einem Beispielprojekt (Schaltplan und/oder C-Quellcode). Das wäre vielleicht eine gute Alternative.

Kann ich Latches denn auch der PMW betreiben? Ich würde Die Uhr gerne mit einem Helligkeitssensor betreiben, der die LEDs je nach Umgebungslicht dimmt. Beim Charlieplexing hab ich überlegt Transistoren hinter die Controller-Pins zu klemmen und mittels PMW zu 'steuern'. Gibt es für Latches eine ähnliche Möglichkeit?

Ahhh *klick* :-) Die Zahlen als Balkenanzeige, NU hab ichs verstanden :-)

Multiplexing ist um einiges einfacher zu realisieren als Charlieplexing. Stelle dir einfach deine 4 x 9 Dioden als Gitter (oder Matrix) vor. Die Anoden zeilenweise verbunden, die Kathoden spaltenweise. Wenn du nun vom µC aus 9 Leitungen an die Zeilen legst (+ aktiv) und 4 Leitungen an die Spalten (GND aktiv), dann kannst du die 36 LEDs ohne viel Aufwand steuern.
WELCHE der 9 LEDs leuchten soll, bestimmst du mit deinen 9 Leitungen zu den Zeilen. WO, also an welcher Stelle die leuchten sollten, bestimmst du mit den 4 Leitungen zu den Spalten.

Auch hier wäre PWM-Dimmung möglich, indem du z.b. an die Spaltenleitungen die Transistoren setzt. Allerdings sollte die PWM-Frequenz um ein mehrfaches höher sein als die Umschaltfrequenz zwischen den einzelnen Spalten, sonst bekommst du schöne aber ungewollte Lichteffekte.

Mit Latches geht PWM auch, allerdings würde man die Transistoren nicht (aus der Sicht der LEDs) nicht auf die Seite der Latches anbringen.

Latches erscheinen mir für dieses Projekt aber wenig sinnvoll, da ja nur zwischen 4 Zeilen multiplext wird.

Mal ne andere Idee ... vielleicht wäre es ja eine nette Idee, die Ziffernwerte nicht als einfachen Balken darzustellen, sondern in Form einer Würfelanzeige :-) Warum? Wenn du 7 oder 8 LEDs in einer Reihe am leuchten hast, kann das Auge die Anzahl der LEDs nicht mit einem Blick erfassen. Stellst du die Anzahl als Würfelaugen (2 Würfel übereinander pro Ziffer) dar, kann das Auge das erheblich schneller erfassen. Nur so eine Idee :-) Selbst wenn du das Ganze mit zwei kompletten Würfeln pro Ziffer realisierst und gleiche Ziffern nicht immer mit den selben Würfelkombinationen darstellst, brauchst du 14 LEDs pro Ziffer = 18 Pins.

MeckPommer, ich glaube er meinte nicht als Balkenanzeigen, sondern so hier:

Bild hier

Also erstmal vielen Dank für die vielen Antworten, Tips und Erklärungen, langsam steig ich durch ;).

Zitat:

Zitat von MeckPommER

Mal ne andere Idee ... vielleicht wäre es ja eine nette Idee, die Ziffernwerte nicht als einfachen Balken darzustellen, sondern in Form einer Würfelanzeige Freudig Warum? Wenn du 7 oder 8 LEDs in einer Reihe am leuchten hast, kann das Auge die Anzahl der LEDs nicht mit einem Blick erfassen. Stellst du die Anzahl als Würfelaugen (2 Würfel übereinander pro Ziffer) dar, kann das Auge das erheblich schneller erfassen. Nur so eine Idee Freudig Selbst wenn du das Ganze mit zwei kompletten Würfeln pro Ziffer realisierst und gleiche Ziffern nicht immer mit den selben Würfelkombinationen darstellst, brauchst du 14 LEDs pro Ziffer = 18 Pins.

Genau das hatte ich vor :). Ich hab einen großen Bilderrahmen (ca. 120cm x 40cm) der 4 abgetrennte Bildbereiche nebeneinander hat. Jeder Bildbereich stellt dann eine Ziffer in einer 3x3 Matrix dar ;). Ich möchte dann verschiedene Anzeigemodi entwerfen, wie z.B. Würfel, Zufall etc. :).

Da jedes Segment ne 3x3 Matrix ist und ich die einzeln ansteuern möchte, werde ich wohl beim Charlieplexing bleiben (Hab ich doch jetzt richtig verstanden, Multiplexing bräuchte 6 Pins und Charlieplexing 4 oder ;)?).

Eine Frage fällt mir da gerade noch ein ;):
Sind zum dimmen eher 'normale' Kondensatoren oder Feldeffektkondensatoren geeignet?

@gyrosp, versuch dich mal gedanklich davon zu trennen, das eine optische Anordnung auch einer schaltungstechnischen Anordnung entspricht.
Nur weil die LEDs eines Segments in einer 3x3 Matrix angeordnet sind, musst du deswegen keine 3x3 Schaltungsmatrix aufbauen.
Bleibe einfach beim 4x9 Multiplexing, das wird dir die wenigstens Schwierigkeiten machen.
Auch die Programmierung vom Charlieplexing ist komplexer als beim Multiplexen ... ich würde es an deiner Stelle mit dem Charlieplexing lieber lassen, ehrlich!

Öhm ... was willst du mit den Kondensatoren beim Dimmen? Falls du transistoren meinst, so reichen "normalen" Transistoren aus. BC548 oder BD179 (grob geschätzt) je nach Stromhunger deiner favorisierten LEDs. Ein Blick ins Datenblatt der Transistoren ist angebracht.

@thewulf00: 12:34 ... sieht cool aus :-)

Zitat:

Zitat von MeckPommER

@gyrosp, versuch dich mal gedanklich davon zu trennen, das eine optische Anordnung auch einer schaltungstechnischen Anordnung entspricht.
Nur weil die LEDs eines Segments in einer 3x3 Matrix angeordnet sind, musst du deswegen keine 3x3 Schaltungsmatrix aufbauen.

Das stimmt natürlich, fällt mir aber noch ein bißchen schwer. Ich bin noch in der Phase in der es einfacher ist, wenn die Schaltung auch dem Aufbau der Logik entspricht ;).

Zitat:

Zitat von MeckPommER

Bleibe einfach beim 4x9 Multiplexing, das wird dir die wenigstens Schwierigkeiten machen.
Auch die Programmierung vom Charlieplexing ist komplexer als beim Multiplexen ... ich würde es an deiner Stelle mit dem Charlieplexing lieber lassen, ehrlich!

Ich habe schon eine 3 Pin Charlieplexing-Testschaltung mit 6 LEDs aufgebaut und entsprechend programmiert. Funktioniert auch ;). Daher wäre ein Umstieg auf Multiplexing jetzt wahrscheinlich mehr Arbeit als die Erweiterung der bestehenden auf 4 Pins und 9, bzw. theoretischen 12 LEDs.

Zitat:

Zitat von MeckPommER

Öhm ... was willst du mit den Kondensatoren beim Dimmen?

Oh, ich meinte natürlich Transistoren ;).

Danke nochmal! Werde gleich meil beim Reichelt ein bißchen was bestellen ;).

Für 36 LEDs benötigt man übrigends nur 7 Pins wenn man charlieplexed:
http://www.josepino.com/pic_projects...ntrol_leds.jpc

Schon ... aber das Tastverhältnis wird irgendwann gruselig, oder? ;-)

Zitat:

Zitat von radbruch

Für 36 LEDs benötigt man übrigends nur 7 Pins wenn man charlieplexed:
http://www.josepino.com/pic_projects...ntrol_leds.jpc

Stimmt, aber ich möchte die 4 Segmente separat als 3x3 Matrizen verschalten (bitte nicht nach Sinn und Unsinn dieser Maßnahme fragen ;)) und brauche daher pro Segment 4 Pins, insgesamt also 16.

Zitat:

...ich möchte die 4 Segmente separat als 3x3 Matrizen verschalten

Das habe ich leider überflogen obwohl du es gleich zu Beginn erklärt hast. Sorry.

Zitat:

Ich bin noch in der Phase in der es einfacher ist, wenn die Schaltung auch dem Aufbau der Logik entspricht

Die logische Zuordnung der LEDs zu den einzelnen "Segmenten" geschieht eh softwaremässig. Es ist dann egal ob du 4x9 oder 1x36 aufbaust.

Zitat:

aber das Tastverhältnis wird irgendwann gruselig

Ich schätze mal dass man das kurze Nachleuchten der LEDs nutzen kann. Aber Erfahrung habe ich damit auch keine, über 12LEDs/4Pins bin ich noch nicht hinaus.

gyrosp, ich kann dir die 4*9 Matrix nur ans Herz legen, denn 4 * charlieplex gleichzeitig ansteuern - viel Vergnügen, da ist das Multiplexen erheblich einfacher. Zumal das Tastverhältnis auch gegen Charlieplexen spricht, da du nur eine von 9 LEDs gleichzeitig leuchten lassen kannst. Ob die 3*3 Leds pro Segment optisch in einer Reihe oder kreisrund oder sonstwie angeordnet sind spielt wirklich keine Rolle.
Wenn du unbedingt eine 4*3*3 Matrix auf eine mehr als ungünstige und komplizierte Weise (sowohl hardware- als auch softwaremäßig) ansteuern möchtest, dann ist das natürlich dein gutes Recht :)

Viel Glück

MeckPommER

Zitat:

Zitat von MeckPommER

gyrosp, ich kann dir die 4*9 Matrix nur ans Herz legen, denn 4 * charlieplex gleichzeitig ansteuern - viel Vergnügen, da ist das Multiplexen erheblich einfacher. Zumal das Tastverhältnis auch gegen Charlieplexen spricht, da du nur eine von 9 LEDs gleichzeitig leuchten lassen kannst. Ob die 3*3 Leds pro Segment optisch in einer Reihe oder kreisrund oder sonstwie angeordnet sind spielt wirklich keine Rolle.

Mhh, ich denke vielleicht doch nochmal drüber nach ;). Ich werde jetzt erstmal ein paar Versuchsaufbauten machen.

AS1110 oder aehnliches von anderen Herstellern?

Hallo

Ich habe nun einen kleinen Test mit 2*12 LEDs an 8 Pins gemacht. Gesteuert wird mit dem asuro (8MHz, ATMega8) in C. Die "Lücken" beim Schwenken sind die Impuls/Pause-Zeiten der PWM. Nochmal der Hinweis: Beim Charlieplexing brennt (pro Leiste) immer nur eine LED!

Bild hier
http://www.youtube.com/watch?v=dboh5SFD29g

Das Programm gibt per ISR je LED-Leiste ein Bitmuster mit PWM aus:

Code:

#include <avr/io.h> #include <avr/interrupt.h> #define pin1a_on DDRB |= (1<<PB1); PORTB |= (1<<PB1) #define pin1a_off DDRB |= (1<<PB1); PORTB &=~(1<<PB1) #define pin1a_x DDRB &=~(1<<PB1); PORTB &=~(1<<PB1) #define pin2a_on DDRB |= (1<<PB2); PORTB |= (1<<PB2) #define pin2a_off DDRB |= (1<<PB2); PORTB &=~(1<<PB2) #define pin2a_x DDRB &=~(1<<PB2); PORTB &=~(1<<PB2) #define pin3a_on DDRB |= (1<<PB4); PORTB |= (1<<PB4) #define pin3a_off DDRB |= (1<<PB4); PORTB &=~(1<<PB4) #define pin3a_x DDRB &=~(1<<PB4); PORTB &=~(1<<PB4) #define pin4a_on DDRB |= (1<<PB5); PORTB |= (1<<PB5) #define pin4a_off DDRB |= (1<<PB5); PORTB &=~(1<<PB5) #define pin4a_x DDRB &=~(1<<PB5); PORTB &=~(1<<PB5) #define pin1b_on DDRC |= (1<<PC0); PORTC |= (1<<PC0) #define pin1b_off DDRC |= (1<<PC0); PORTC &=~(1<<PC0) #define pin1b_x DDRC &=~(1<<PC0); PORTC &=~(1<<PC0) #define pin2b_on DDRC |= (1<<PC1); PORTC |= (1<<PC1) #define pin2b_off DDRC |= (1<<PC1); PORTC &=~(1<<PC1) #define pin2b_x DDRC &=~(1<<PC1); PORTC &=~(1<<PC1) #define pin3b_on DDRD |= (1<<PD4); PORTD |= (1<<PD4) #define pin3b_off DDRD |= (1<<PD4); PORTD &=~(1<<PD4) #define pin3b_x DDRD &=~(1<<PD4); PORTD &=~(1<<PD4) #define pin4b_on DDRD |= (1<<PD5); PORTD |= (1<<PD5) #define pin4b_off DDRD |= (1<<PD5); PORTD &=~(1<<PD5) #define pin4b_x DDRD &=~(1<<PD5); PORTD &=~(1<<PD5) volatile unsigned char count72kHz, pwm; unsigned int bitmustera=0b111111111111, bitmusterb=0b110010010011; /* uses 72kHz timer => Sleep(x) = x/72kHz [sec] */ void Sleep(unsigned char time72kHz) { count72kHz = 0; while (count72kHz < time72kHz); } void Msleep(unsigned char dauer) { while(dauer--) Sleep(72); } int main(void) { //unsigned char i; TCCR2 = (1 << WGM21) | (1 << COM20) | (1 << CS20); OCR2 = 0x6E; // 36kHz @8MHz TIMSK |= (1 << OCIE2); // 36kHz counter for sleep sei(); while(1) { for(pwm=50; pwm > 0; pwm--) Msleep(5); for(pwm=0; pwm < 50; pwm++) Msleep(5); } return(0); } /* uses timer2 (36kHz for IR communication */ /* counts falling and rising edge => 36kHz*2 = 72kHz */ SIGNAL (SIG_OUTPUT_COMPARE2) { static unsigned char bit=0, count=0; count72kHz ++; pin1a_x; pin2a_x; pin3a_x; pin4a_x; if(count < pwm) { if((bitmustera & (1<<bit))==1){ pin1a_on; pin2a_off; pin3a_x; pin4a_x; } if((bitmustera & (1<<bit))==2){ pin1a_on; pin2a_x; pin3a_off; pin4a_x; } if((bitmustera & (1<<bit))==4){ pin1a_on; pin2a_x; pin3a_x; pin4a_off; } if((bitmustera & (1<<bit))==8){ pin1a_off; pin2a_on; pin3a_x; pin4a_x; } if((bitmustera & (1<<bit))==16){ pin1a_x; pin2a_on; pin3a_off; pin4a_x; } if((bitmustera & (1<<bit))==32){ pin1a_x; pin2a_on; pin3a_x; pin4a_off; } if((bitmustera & (1<<bit))==64){ pin1a_off; pin2a_x; pin3a_on; pin4a_x; } if((bitmustera & (1<<bit))==128){ pin1a_x; pin2a_off; pin3a_on; pin4a_x; } if((bitmustera & (1<<bit))==256){ pin1a_x; pin2a_x; pin3a_on; pin4a_off; } if((bitmustera & (1<<bit))==512){ pin1a_off; pin2a_x; pin3a_x; pin4a_on; } if((bitmustera & (1<<bit))==1024){ pin1a_x; pin2a_off; pin3a_x; pin4a_on; } if((bitmustera & (1<<bit))==2048){ pin1a_x; pin2a_x; pin3a_off; pin4a_on; } } pin1b_x; pin2b_x; pin3b_x; pin4b_x; if(count > pwm) { if((bitmusterb & (1<<bit))==1){ pin1b_on; pin2b_off; pin3b_x; pin4b_x; } if((bitmusterb & (1<<bit))==2){ pin1b_on; pin2b_x; pin3b_off; pin4b_x; } if((bitmusterb & (1<<bit))==4){ pin1b_on; pin2b_x; pin3b_x; pin4b_off; } if((bitmusterb & (1<<bit))==8){ pin1b_off; pin2b_on; pin3b_x; pin4b_x; } if((bitmusterb & (1<<bit))==16){ pin1b_x; pin2b_on; pin3b_off; pin4b_x; } if((bitmusterb & (1<<bit))==32){ pin1b_x; pin2b_on; pin3b_x; pin4b_off; } if((bitmusterb & (1<<bit))==64){ pin1b_off; pin2b_x; pin3b_on; pin4b_x; } if((bitmusterb & (1<<bit))==128){ pin1b_x; pin2b_off; pin3b_on; pin4b_x; } if((bitmusterb & (1<<bit))==256){ pin1b_x; pin2b_x; pin3b_on; pin4b_off; } if((bitmusterb & (1<<bit))==512){ pin1b_off; pin2b_x; pin3b_x; pin4b_on; } if((bitmusterb & (1<<bit))==1024){ pin1b_x; pin2b_off; pin3b_x; pin4b_on; } if((bitmusterb & (1<<bit))==2048){ pin1b_x; pin2b_x; pin3b_off; pin4b_on; } } if(bit<11) bit++; else { bit=0; if(count) count --; else count=49; } }

Das ist allerdings echt nur ein Testcode, die ISR läuft gnadenlos über. Aber als Einstieg schon mal nicht schlecht. Mit ein paar Optimierungen sollten 36 LEDs kein Problem sein.

Gruß

mic

Sieht nice aus :-)

Aber der Nachteil liegt auf der Hand: hast du 36 LEDs, leuchtet nur eine von 36 - also kann eine LED nur 1/36 der Zeit an sein, was keine gute Leuchtkraft mehr zuläßt. Teilst du die 36 LEDs in 4 Gruppen auf, mußt du 4 Charlie-Matrix-Felder gleichzeitig bedienen ... das ist dann schon etwas heftiger vom Programmieraufwand her.

Falls man aber wirklich nur wenige Pins zur Verfügung hat, ist Charlieplexing eine sehr feine Sache!

Gruß MeckPommER

Ich verstehe nicht, was gegen Schieberegister mit eingebauten Konstantstromquellen spricht...

Zusätzliche ICs, die beim Multiplexen nicht gebraucht werden. Zumal es ein Erstlingsprojekt ist, bei dem ich den Schaltungsaufwand möglichst gering halten würde.

Ansonsten ist eine Lösung mit einem Schieberegister natürlich die bessere Lösung, da die LEDs mit voller Leuchtkraft betrieben werden können.

Viel geringer gehts doch nicht, ist doch nur ein SPI-Bus... ;) Naja, ihr macht das schon.

Klar, es sind weniger Leitungen vom µC zum Schieberegister, aber dafür halt z.B. 4 Käfer mehr. Ich selber würde es sicherlich auch mir SR machen, da ich gerne mit PortPins geize :)
Für die Fehlersuche und als Anfangsprojekt würde ich halt nur, wie gesagt, die Schaltung einfach halten.

Ich bin auch sicher, das gyrosp das hinbekommt. Er lötet nicht gleich drauflos, sondern plant erstmal :-)

Hallo

Als Fan des Charlieplexing (weil es so minimalistisch ist) habe ich mir darüber noch ein paar Gedanken gemacht:

Zitat:

...aber das Tastverhältnis wird irgendwann gruselig, oder?

Für neun LEDs an 4 Pins kann man das erwartete 1:9-Verhältniss eigentlich recht einfach auf 1:3 verbessern. Das funktioniert einfach, weil das hier nicht stimmt:

Zitat:

Nochmal der Hinweis: Beim Charlieplexing brennt... immer nur eine LED!

Am Beispiel 4 Ports/12 LEDs erklärt: Die 12 LEDs sind eigentlich in vier 3er-Gruppen zusammengefasst, je gesetztem Ausgang entsprechen drei nicht gesetzte oder hochohmige Ausgänge der jeweils leuchtenden LED. Bei vier Ausgängen A0 bis A3 sieht der Aufbau der ersten Gruppe so aus: Je eine LED mit Vorwiderstand von A0 nach A1,A2 und A3, alle Anoden an A0. Ein Programm zur einzelnen Ansteuerung muss folgende Ausgangsmuster erzeugen:

LED0: A0=1, A1=0 A2=x A3=x (1 ist Ausgang high, 0 ist Ausgang low und x ist Eingang ohne PullUp)
LED1: A0=1, A1=x A2=0 A3=x
LED2: A0=1, A1=x A2=x A3=0

Die anderen drei Gruppen sind analog mit A1, A2 und A3 als Anodenanschluss aufgebaut. Bei jedem Aufruf der ISR wird jeweils nur eine Kombination ausgegeben und es leuchtet deshalb auch nur eine LED. Um nun alle LEDs anzusteuern muss die ISR 12 mal aufgerufen werden.

Einfacher und schneller geht es wohl (ich habe es noch nicht getestet) wenn man die LEDs gruppenweise ansteuert:

If(gruppe==0)
{
A0=1
if(LED0) A1=0 else A1=x
if(LED1) A2=0 else A2=x
if(LED2) A3=0 else A3=x
}
If(gruppe==1)
{
A1=1
if(LED3) A0=0 else A0=x
if(LED4) A2=0 else A2=x
if(LED5) A3=0 else A3=x
}
...

Man benötigt so nur 4 ISR-Aufrufe um alle 12 Leds auszugeben, bzw. 3 Aufrufe für 9 LEDs. Nachteil: Der gemeinsame Pin muss bis zu drei LED-Stöme treiben, das muss man bei der Auswahl der Vorwiderstände berücksichtigen. Ich hoffe, dass funktioniert auch in der Praxis.

Gruß

mic

Wenn ein Pin den Strom für mehrere LEDs treiben muß, dann hat nicht viel damit gewonnen das man mehrere LEDs Gleichzeitig an hat. Das Problem mit dem Tastverhältnis ist weniger der Rechenaufwand als die Gesamthelligkeit und da kann man nicht viel machen, wenn der Strom durch die Leistungsfähigkeit der Portpins bestimmt wird. Bei 12 LEDs überchariepxeling kreigt man halt entweder 1/12 der Zeit 24 mA oder 1/4 der Zeit 8 mA. Das entspricht dann 2 mA im Mittel. Das kann mit hellen LEDs noch reichen, bei low Cost LEDs aber kaum.
Wirklich was einsparen kann man nur wenn man weiß, das nie alle LEDs gleichzeitig an sind.