erst programmieren, dann schalten

Ein ATTiny2313 machts!

Kein normaler Chip hat 100 Ausgänge.

Müssen die 100 LED's gleichzeitig leuchten, oder dürfen sie als Matrix 
(http://www.mikrocontroller.net/articles/LED-Matrix) angesteuert werden?

Mit Mikrocontroller wird das relativ einfach machbar sein. Programmieren 
muss man ihn natürlich, in der Sprache C oder Bascom oder Assembler. 
Kannst Du das?

Ich befürchtete schön das kein IC 100 Ausgänge hat.

Ein ATTiny2313 mag es machen aber wie???

Es soll auch möglich sein das sich z.B. in der Stellung 1 95 LEDs 
einschalten sollen, in der Stellung 2 dann noch 3 und in der Stellung 3 
die letzten 2. Eben genau das möchte ich frei wählen können bzw. 
programmieren.

OK, das mit dem Strom kann man ja denn mit Transistoren lösen, es müssen 
an den Ausgängen nicht unbedingt gleich die LEDs angeschlossen werden, 
Transistoren wären auch ne möglichkeit woran ich ja dann die LEDs 
anschließen kann.

Aber der 74HC595 hat doch nur 16 Anschlüsse, da passen doch keine 100 
LEDs ran?

Muß es hier denn unbedingt eine elektronische Schaltung sein? Ich würde 
das Problem "mechanisch" lösen und jede der Leuchtdioden über Jumper 
(einen von drei) auf einen der drei Schalter legen. Der Schalter muß 
dabei den maximalen Strom der LED's vertragen: bei 10mA mal 100Dioden 
sind das 1000mA - kein Problem für die meisten Schalter. Durch die 
Jumper kann man beliebige Zuordnungen "programmieren".

Gruß. Tom

Ich ahnte es schon, klingt für mich wie böhmische Wälder.

Gibt es denn kein IC der 100 Ausgänge hat oder von mir aus auch 50 wovon 
ich dann eben 2 brauche oder einen IC mit 10 Ausgängen wovon ich dann 10 
ICs bräuchte welche ich ja dann individuell programmieren kann und alle 
an einen Schiebeschalter anschließe?

zu deiner Antwort:

> Muß es hir denn unbedingt eine elektronische Schaltung sein? Ich würde
  das Problem "mechanisch" lösen und jede der Leuchtdioden über Jumper
  (einen von drei) auf einen der drei Schalter legen. Der Schalter muß
  dabei den maximalen Strom der LED's vertragen: bei 10mA mal 100Dioden
  sind das 1000mA - kein Problem für die meisten Schalter. Durch die
  Jumper kann man beliebige Zuordnungen "programmieren".

  Gruß. Tom


Ein IC wäre mir lieber, da ich am Ende 10 Stellungen habe und ich bei 
100 LEDs dann 1000 Jumper bräuchte, das ist mir zu viel,

zu deiner Antwort:

> Wie oft und auf welchem Weg müssen die LED-Muster denn überhaupt
  programmiert werden? Wenn nur einmal, kann man genauso eine solder
  jumper Matrix auf eine Platine machen.



So oft wie ich möchte, das will ich jedesmal ändern wenn ich keine Lust 
mehr auf das vorherige Muster habe.

zu deiner Antwort:

>  Doch, gibt es:
  http://www.reichelt.de/STM-Controller/STM32-F103ZE...



Hey, der sieht doch schon ganz gut aus, doch wie schließe ich den an und 
wie programmiere ich den?

zu deiner Antwort:

> Dennoch empfehle ich eher eine Art "Matrix" (siehe Wegstaben
> Verbuchsler) auf zu bauen oder besser diesen 74HC595 zu verwenden.
>
> Wie sollen die LED's denn angeordnet sein?
> Zeichne mal bitte eine Skizze.



Die Anordnung ist völlig egal, es soll ein Sternenhimmel werden und jede 
der 10 Schalter soll immer ein anderes Muster am Himmel ergeben, welche 
ich auch mal ändern möchte.

zu deiner Antwort:

>  Und wie schon erwähnt wär 10x10 Multiplexing evtl ziemlich lohnend.
>  Dafür ist die Frage aber ob die LEDs was beleuchten sollen, sie schaffen
>  dann nur einen Teil der maximalen Helligkeit, was für Anzeigen in der
>  Regel okay, für Beleuchtung aber schlecht ist.



ich brauche schön die volle Lichtausbeute einer LED, da sind auch weiße 
dabei, die den Raum richtig erhellen sollen wenn ich mal richtig licht 
brauche.

zu deiner Antwort:

> Der hat 112 IO's
> - 100 LED's
> - 10 Schalterstellungen
> - 2 externes EEPROM
> und somit ist alls belegt.
>
> So wie in den Artikel gezeigt:
> STM32 für Einsteiger
> STM32 CooCox Installation
> STM32

> sowie die Demo-Codes von ST, die es auf der ST.com Homepage.




Ich danke euch erst mal alle für eure Tipps :-)

nur leider verstehe ich die Links nicht, ich bräuchte einen Schaltplan, 
sicherlich muss man den STM32-F103ZE an viele Bauteile anschließen damit 
er programmierbar ist oder?

kopfkratz
Wo liegt denn das Problem ?
Ein Tiny85 reicht da aus, ein Eingang und drei Ausgänge.
Schalter via Widerstände an einen ADC Eingang um zu wissen was leuchten 
soll.
Ein Ausgang für jeden Schalterzustand der mit Leistungsmosfet die LEDs 
von einer Konstantstromquelle versorgt.
Es sollen ja immer ALLE LEDs an/aus sein oder verstehe ich da was falsch 
?

Wenn die LED's LEUCHTEN sollen (nicht flimmern) geht eine Matric nicht. 
Deswegen habe ich ja schon ganz oben gefragt, ob eine Matrix in Frage 
kommt. In dem dort verlinkten Artikel findest Du auch hinweise, wie man 
so eine Matrix an einen Mikrocontroller anschließt.

Da Du offensichtlich noch keine Ahnung Ahnung von den Grundlagen hast, 
besorge Dir erstmal

- einen Mikrocontroller: z.B. den Atmega 16, 32, 164, 328, 644, 1284, 
8515 oder 8535. Die haben alle 40 Pins als ganz sicher genug I/O 
Leitungen für eine Matrix >Schaltung.
- ein Steckbrett
- einen ISP Programmieradapter
- 3 oder 4 Akkus mit Halter zur Stromversorgung (4,8V)
- ein paar LED's mit Vorwiderstand (220 Ohm)

Und dann übst Du erstmal, die LED's blinken zu lassen.

Wenn das soweit klappt, befasst Du Dich mit dem Matrix Thema. Da wirst 
Du Transistoren oder Treiber-IC's brauchen, wegen der Stromstärke.

zu deiner Antwort:

>  hier mal ein link zu sternhimmel:
>
>  http://flosserver.dyndns.org/Sternenhimmel.php
>
> würde sagen 10 led´s reichen und dann per glasfaser? viel einfacher
> zuschalten ;-)



Danke, aber möchte gerne 100 LEDs steuern :-)

zu deiner Antwort:

>Wenn die LED's LEUCHTEN sollen (nicht flimmern) geht eine Matric nicht.
>Deswegen habe ich ja schon ganz oben gefragt, ob eine Matrix in Frage
>kommt. In dem dort verlinkten Artikel findest Du auch hinweise, wie man
>so eine Matrix an einen Mikrocontroller anschließt.
>
>Da Du offensichtlich noch keine Ahnung Ahnung von den Grundlagen hast,
>besorge Dir erstmal
>
>- einen Mikrocontroller: z.B. den Atmega 16, 32, 164, 328, 644, 1284,
>8515 oder 8535. Die haben alle 40 Pins als ganz sicher genug I/O
>Leitungen für eine Matrix >Schaltung.
>- ein Steckbrett
>- einen ISP Programmieradapter
>- 3 oder 4 Akkus mit Halter zur Stromversorgung (4,8V)
>- ein paar LED's mit Vorwiderstand (220 Ohm)
>
>Und dann übst Du erstmal, die LED's blinken zu lassen.
>
>Wenn das soweit klappt, befasst Du Dich mit dem Matrix Thema. Da wirst
>Du Transistoren oder Treiber-IC's brauchen, wegen der Stromstärke.


Nein, bitte keine Matrix, ich möchte kein flimmern.

zu deiner Antwort:

>kopfkratz
>Wo liegt denn das Problem ?
>Ein Tiny85 reicht da aus, ein Eingang und drei Ausgänge.
>Schalter via Widerstände an einen ADC Eingang um zu wissen was leuchten
>soll.
>Ein Ausgang für jeden Schalterzustand der mit Leistungsmosfet die LEDs
>von einer Konstantstromquelle versorgt.
>Es sollen ja immer ALLE LEDs an/aus sein oder verstehe ich da was falsch
>?



Nein, es sollen nur die LEDs ein- und ausgeschaltet werden, die ich in 
den jeweiligen Schaltstellungen zur Ausgabe programmiert habe.

zu deiner Antwort:

>OK, dann ist eine Matrix nicht so gut.
>Auch ein Prozessor mit 100 LED Ausgänge nicht die richtige Wahl, denn
>dann müsste man enorm viele Drähte durch die ganze Decke legen.
>
>Mache besser keine Einzelmodule (Einzelplatinen) mit jeweils einem
>74HC595 Chip drauf, den kannst Du im Sternenhimmel überall verteilt
>montieren und mit relativ kurzen Drähten je 8 LED's anschließen.
>Das ganze ist zudem auch noch problemlos auf z.B. 200 LED's erweiterbar
>;-)


Also nochmal zur Verständnis :-)

Wenn ich nur einen IC habe den ich programmieren kann der 10 Eingange 
und 100 Ausgänge hat muss ich auch nur diesen einen Programmieren. Viele 
ICs bedeuten ja auch das ich dann jeden einzelnd programmieren muss, das 
wäre umständlicher daher wäre mir nur ein IC am liebsten.
Den möchte ich dann so programmieren das ich ihn z.B. sage: Wenn an Pin 
1 Strom dann bitte die Ausgänge Pin 5,6,7,8 öffnen, wenn an Pin 2 Strom 
dann bitte die Ausgänge Pin 18,19 öffnen usw.
Das möchte ich eben individuell festlegen können.

zu deiner Antwort:


>André schrieb:
>> Nein, es sollen nur die LEDs ein- und ausgeschaltet werden, die ich in
>> den jeweiligen Schaltstellungen zur Ausgabe programmiert habe.
>
>Genau das kann man mit dem 74HC595 machen.



Ja aber bestimmt nicht flackerfrei, da dieser ja nur 16 anschlüsse hat 
und keine 100.

zu deiner Antwort:

>Doch, Flackerfrei. Denn an jeden Ausgang (der hat 8) wird nur eine
>einzige LED angeschlossen. Der 74HC595 erhält seriell die Daten und
>sobald das "Latch" kommt werden die serielle Daten in den Ausgabetreiber
>kopiert. Und dieser Ausgang bleibt so lange anstehend bis ein erneutes
>Latch mit den neuen Daten geschrieben wird.
>Absolut Flackerfrei.
>
>Dazu hat der 74HC595 ein "OE" (Output Enable) mit dem könnte man nun ein
>PWM Signal drauf geben und damit könnte man die LED's flackern lassen
>(bzw. die Helligkeit einstellen). Muss man aber nicht benutzen.



Hm, ok, aber wie mache ich das, wie schließe ich den an, gibt es da 
schaltpläne?


ich habe mal noch diesen Link gefunden:



http://www.google.de/imgres?imgurl=http://www.wayengineer.com/images/boardimage/UET-STM32F103ZET6-core-1.jpg&imgrefurl=http://www.wayengineer.com/index.php?main_page%3Dproduct_info%26products_id%3D497&h=481&w=700&sz=166&tbnid=NwPsiqbz-lGGKM:&tbnh=90&tbnw=131&zoom=1&usg=__5W5lJv1DWxqPWzHAqukTFivsO6E=&docid=Ru7GIrmWmNGgiM&sa=X&ei=hszFUsDeDoTIswb33YDwCw&sqi=2&ved=0CFMQ9QEwAw&dur=3836



Finde ich ja recht interessant, zumal der schon fertig aufgebaut ist und 
ich den nur noch am PC anschließen muss um ihn zu programmieren, wie das 
allerdings geht weiß ich auch noch nicht. Und das tolle ist, das er 134 
anschlüsse hat, also genug für meine 100 LEDs und meinen 10 Schaltern 
die ja als Befehle dienen sollen.

Wenn es eine elektronische Lösung sein muß, kommt nur ein 
Mikrokontroller oder eine PLD in Frage. Beides setzt 
Programmierkenntnisse und eine Entwicklungsumgebung voraus, aus dem 
Stehgreif geht da nichts. Einen fertigen Baustein mit der geforderten 
Funktionalität gibt es nach meinem Wissen nicht.
Ohne Erfahrung und ohne geeignete Entwicklungsumgebung ist anzuraten, 
die Entwicklung von jemand machen zu lassen der die Voraussetzungen 
dafür hat. Vielleicht findet sich im Forum jemand, der dies für Dich 
erledigen kann.

Eine relativ einfache Lösung wäre noch die Bitmuster in ein (E)EPROM zu 
brennen und über die Adressierung (Schalterstellung) abzurufen, so 
können viele Bitmuster über Schalter abgerufen werden. Mit 13 
8Bit-Bausteinen wären 104 LED's möglich, welche die LED's im 
Dauerbetrieb ansteuern können. Hierfür sind keine Programmierkenntnisse 
erforderlich, aber Du benötigst ein Programmiergerät für (E)Eproms und 
einen Hex-Editor zum bearbeiten der Bitmuster.

Gruß. Tom

zu deiner Antwort:

>Wenn es eine elektronische Lösung sein muß, kommt nur ein
>Mikrokontroller oder eine PLD in Frage. Beides setzt
>Programmierkenntnisse und eine Entwicklungsumgebung voraus, aus dem
>Stehgreif geht da nichts. Einen fertigen Baustein mit der geforderten
>Funktionalität gibt es nach meinem Wissen nicht.
>Ohne Erfahrung und ohne geeignete Entwicklungsumgebung ist anzuraten,
>die Entwicklung von jemand machen zu lassen der die Voraussetzungen
>dafür hat. Vielleicht findet sich im Forum jemand, der dies für Dich
>erledigen kann.
>
>Eine relativ einfache Lösung wäre noch die Bitmuster in ein (E)EPROM zu
>brennen und über die Adressierung (Schalterstellung) abzurufen, so
>können viele Bitmuster über Schalter abgerufen werden. Mit 13
>8Bit-Bausteinen wären 104 LED's möglich, welche die LED's im
>Dauerbetrieb ansteuern können. Hierfür sind keine Programmierkenntnisse
>erforderlich, aber Du benötigst ein Programmiergerät für (E)Eproms und
>einen Hex-Editor zum bearbeiten der Bitmuster.
>
>Gruß. Tom


Ich wäre mit einen EPROM einverstanden doch welchen muss ich nehmen? Ein 
Hex-Editor habe ich doch wie schließe ich den EPROM dann am PC bzw. 
Laptop an um ihn dann im Hex-Editor programmieren zu können? Wie sieht 
da der Schaltplan aus? Hast du eine idee?

Ich werd erst mal ins Bett, ist doch echt viel Input hier ;-)


Lieben Gruß
André

Mit dem ARDUINO habe ich auch schon programmiert, dank des dicken Buches 
war dies recht einfach, doch leider hat eine Arduino zu wenig Anschlüsse 
für meine Idee, ich brauche nach wie vor 10 Pins für die Schalter und 
100 Ausgänge die entsprechend mit den 10 Schaltern angesteuert werden 
die ich über die Programmierung selbst festlegen möchte.

Anstelle des 74HC595 ginge auch TPIC6B595, wenn ein grösser LED-Strom 
gefragt ist auf den Modulen.

Oder eine andere Variante wäre evtl. mit dem WS2812 (RGB LED) die auch 
seriel hintereinander geschalten werden. Gerade für einen Sternenhimmel, 
wären da mehr Variantionen möglich.

Ich hab noch diese Variante gefunden:



http://www.amazon.de/SainSmart-Entwicklungsbrett-USB-Kabel-enthaltend-Mega2560/dp/B007VMA60E/ref=sr_1_79?ie=UTF8&qid=1388696781&sr=8-79&keywords=arduino



Zumindest sind dort genügend Pins ;-)

Würde meine Idee damit funktionieren?????

Noch ein gutes Beispiel mit den WS2812
http://www.instructables.com/id/Best-RGB-LEDs-for-any-project-WS2812/?lang=de

zu deiner Antwort:

>André versteht nicht, dass es Chips gibt, die Daten seriell empfangen
>können und parallel mit einem "Trigger-Puls" als statische Ausgänge
>schalten können.
>
>Wenn Du schon mal was mit einem Arduino gemacht hast, dann liegt es nahe
>dies wieder mit einem zu machen und die 74HC595 als Porterweiterung zu
>nehmen.
>Allerdings ist das etwas mehr Programmieraufwand als wie wenn Du einen
>STM32F103ZE-Board nehmen würdest.



Ja du hast recht, so richtig blicke ich nicht durch. Eine Aufklärung 
wäre toll :-)

Ich würde ja auch gerne das STM32F103ZE-Board nehmen aber das gibt es 
hier nicht zu kaufen.

Im Grunde ganz einfach, für den Anfang reicht ein (E)EPROM aus, damit 
sind 8 LED's steuerbar. Mit dem HEX-Editor wird der Inhalt des Bausteins 
festgelegt. Zum Beispiel in Adresse 0 der Wert 5Ah (Bitmuster 01011010). 
Bei direkten Anschluß der LED's ans EPROM gegen +5V, wird die LED bei 
0-Pegel leuchten. Besser ist es aber die LED's über Transistoren ans 
EPROM zu schalten, dan leuchtet die LED bei 1-Pegel, benötigt aber für 
jedee LED einen Transistor und einen Widerstand extra. Die Schalter 
werden an die Adresseingänge des EPROM gelegt, dadurch wählt man über 
die Schalter die Adresse und damit das gewünschte Bitmuster. mit einem 
Zähler anstelle der Schalter, werden die Bitmuster automatisch 
gewechselt. Die (E)EPROM Anschlüße OE und CE auf GND. Mit einem EPROM 
2764 oder einem EEPROM 2864 sind 8192 verschiedene Bitmuster möglich, 
welche über 13 Schalter wählbar sind. Wenn das alles wie gewünscht 
funktioniert, kannst du mehrere Bausteine paralell schalten. Je ein 
Baustein für 8 LED's. Dies ist nur ein Konzept, bei Interesse kann man 
das noch detailierter ausarbeiten. Jeder der sich ein wenig mit 
Speicherbausteinen auskennt kann dies in ein Gerät umsetzen.
Voraussetzung ist allerdings ein EPROM-Programmiergerät mit dem das 
(E)EPROM programmiert wird. Ein HEX-Editor, zum bearbeiten der 
Bitmuster, ist in der Regel in der Programmiergeräte-Software vorhanden.

Gruß. Tom

Hallo Andre,

ich sehe eben, daß Du mit Arduino programmieren kannst. Dann würde ich 
Dir auch eine Lösung mit Arduino und Schieberegister 74HC595 empfehlen. 
Da flimmert nichts - die 104 Bit der Reihe nach in die 13 Bausteine 
schieben, einen Übernahmeimpuls erzeugen und schon leuchten die 
aktivierten LED's. Und das solange bis ein neuer Schiebevorgang mit 
Übernahmeimpuls ein neues Bitmuster ausgibt. Ganz ohne flimmern.

Gruß. Tom

zu deiner Antwort:

>Im Grunde ganz einfach, für den Anfang reicht ein (E)EPROM aus, damit
>sind 8 LED's steuerbar. Mit dem HEX-Editor wird der Inhalt des Bausteins
>festgelegt. Zum Beispiel in Adresse 0 der Wert 5Ah (Bitmuster 01011010).
>Bei direkten Anschluß der LED's ans EPROM gegen +5V, wird die LED bei
>0-Pegel leuchten. Besser ist es aber die LED's über Transistoren ans
>EPROM zu schalten, dan leuchtet die LED bei 1-Pegel, benötigt aber für
>jedee LED einen Transistor und einen Widerstand extra. Die Schalter
>werden an die Adresseingänge des EPROM gelegt, dadurch wählt man über
>die Schalter die Adresse und damit das gewünschte Bitmuster. mit einem
>Zähler anstelle der Schalter, werden die Bitmuster automatisch
>gewechselt. Die (E)EPROM Anschlüße OE und CE auf GND. Mit einem EPROM
>2764 oder einem EEPROM 2864 sind 8192 verschiedene Bitmuster möglich,
>welche über 13 Schalter wählbar sind. Wenn das alles wie gewünscht
>funktioniert, kannst du mehrere Bausteine paralell schalten. Je ein
>Baustein für 8 LED's. Dies ist nur ein Konzept, bei Interesse kann man
>das noch detailierter ausarbeiten. Jeder der sich ein wenig mit
>Speicherbausteinen auskennt kann dies in ein Gerät umsetzen.
>Voraussetzung ist allerdings ein EPROM-Programmiergerät mit dem das
>(E)EPROM programmiert wird. Ein HEX-Editor, zum bearbeiten der
>Bitmuster, ist in der Regel in der Programmiergeräte-Software vorhanden.
>
>Gruß. Tom



Bei 100 LEDs bräuchte ich dann 13 EEPROMS richtig?  (100/8)

zu deiner Antwort:

>Hallo Andre,
>
>ich sehe eben, daß Du mit Arduino programmieren kannst. Dann würde ich
>Dir auch eine Lösung mit Arduino und Schieberegister 74HC595 empfehlen.
>Da flimmert nichts - die 104 Bit der Reihe nach in die 13 Bausteine
>schieben, einen Übernahmeimpuls erzeugen und schon leuchten die
>aktivierten LED's. Und das solange bis ein neuer Schiebevorgang mit
>Übernahmeimpuls ein neues Bitmuster ausgibt. Ganz ohne flimmern.
>
>Gruß. Tom



Ja ok, aber wie schließe ich das ganze zusammen?

zu deiner Antwort:

>Das Board würde auch gehen:
>Ebay-Artikel Nr. 251296142025




Wow, das nenn ich mal ein Board ;-) aber doch etwas zu teuer

Hallo Andre,

ja, bei der Lösung mit EPROM sind 13 Bausteine im Paralellbetrieb nötig. 
Damit sind dann maximal 104 LED's möglich. Ist aber eine mehr als 
abendfüllende Aufgabe die Bitmuster dafür einzutippen.

Gruß. Tom

zu deiner Antwort:

>Hallo Andre,
>
>ja, bei der Lösung mit EPROM sind 13 Bausteine im Paralellbetrieb nötig.
>Damit sind dann maximal 104 LED's möglich. Ist aber eine mehr als
>abendfüllende Aufgabe die Bitmuster dafür einzutippen.
>
>Gruß. Tom



Och das Basteln macht mir nix aus, im gegenteil, das macht Spaß und das 
Löten richt gut ;-)

Gibt es denn auch sowas wie ein EEPROM-Board? Sodas eine 
USB-Schnittstelle da ist die ich mit dem Laptop verbinden kann um den IC 
zu programmieren?

zu deiner Antwort:

>Andre, schau dir mal auf Youtube etc. beliebige "LED Cube" Filmchen an.
>du wirst feststellen, daß dort mit einem "einfachen" Controller durchaus
>mehr als 100 LED angeschlossen sind, und üebr diese Cubes alle LED
>einzeln in Helligkeit und ggf. sogar noch in Farbe angesteuert werden
>können. Jedes beliebige Muster kann durch auf die verschiendenen LED
>ausgegebene werden.
>
>Bei einem 5 x 5 x 5 cube hast du schon 125 einzelne LED. Das ganze
>steuerst du locker mit ein paar Portpins via Multiplexing an.
>Umfangreiche Schaltungsbeispiele gibt es auch an jeder Ecke.
>
>Ob du die LED nun in Würfelform anordnest, oder flach klpofst auf eine
>Ebene, ist den LED und dem steuernden Controller ziemlich egal.
>
>Bau erst mal dei Schaltung soweit auf, verlöte alle LED (in flacher
>Form), Programmier den Controller, und dann brauchst du nur die Ecke in
>der Software anzupassen, elche für das "Muster" zuständig ist.



Leider sind die alle auf Englisch und ohne Beschreibung aber werde 
weitersuchen. Danke

zu deiner Antwort:

>Ja, ein GALEP, der kann das. Es müsste auch billigere geben.
>
>Ich habe das Board auch bei Amazon gefunden:
>http://www.amazon.com/Core407Z-STM32F407ZxT6-STM32...



OK, Danke

Hi zusammen,

ich würde mich der Lösung mit den Schieberegistern anschließen. Andre, 
es ist es auf jeden Fall wert, dass Du Dir das mal in Ruhe anschaust.

Das gesamte System bestünde dann aus einem Controller (Arduino bietet 
sich an), der die Muster hat oder erzeugt, und aus 13 von den 74HC595 
mit je 8 LEDs (die 595 sind übrigens günstig zu haben und sollten für 
normale LEDs ausreichen).

Der Controller verteilt die Muster an die Schieberegister und diese 
steuern die LEDs an. Dieses Verteilen läuft über einen Schiebevorgang. 
Das ist hier richtig gut erklärt: 
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister

Wie Du das Ganze räumlich anordnest, hängt stark von den Gegebenheiten 
ab. Ich könnte mir vorstellen, dass Du mit 4 Strängen vom Arduino 
ausgehst und dann je 3 (einmal 4) Schieberegister hintereinander 
schaltest. Das könnte der Verteilung der Stern des Himmels 
entgegenkommen.

Ich bevorzuge 10pol. Flachbandleitungen zur Verbindung der einzelnen 
Platinen mit den Schieberegistern, die Stecker sind preiswert und 
hierfür völlig ausreichend.

Ich mache Dir auch gern eine Skizze, habe aber bisher das Gefühl, Du 
bist eher bei der 'Controller macht alles zentral'-Lösung. Denke nur mal 
an die 100 Leitungspaare, die Du dann an eine Stelle führen musst.

Gruß
Jens

Hallo Andre,

zu den Schieberegistern. Ich kenne Arduino nicht, aber ich nehme mal an 
daß sie auch SPI-Interface haben. Dort schließt man die Schieberegister 
am besten an. Den Datenausgang von SPI (MOSI) an den Dateneingang des 
ersten 595er. Den Datenausgang des ersten 595er an den Dateneingang des 
zweiten 595er und so weiter. Den Taktausgang SPI (SCLK) paralell an die 
Takteingänge der 595er. Dann noch ein beliebiges Portbit des Arduino 
paralell an die Strobe-Eingänge der 595er.
Im Programm zunächst die 13-Bytes des Bitmusters, per SPI, in die 
Schieberegister schreiben und anschließend durch einen Strobe-Impuls 
gleichzeitig zu den Ausgängen der 595er übernehmen. So werden alle 104 
Bit gleichzeitig geschaltet. Dies kann im Programm nun mit dem gleichen 
oder anderen Bitmustern wiederholt werden.
An irgendwelchen Eingängen können die Schalter gelesen werden und, 
abhängig von der Schalterstellung, ein anderes Bitmuster ausgegeben 
werden.

Dies nur als kleiner Überblick, ist nicht schwer das ganze in Hard- und 
Software umzusetzen.

Übrigens geht es auch ohne SPI, dann gibt man halt per programm auf ein 
Ausgabebit das Datenbit 0/1 und erzeugt an einem anderen Ausgabebit 
einen Taktimpuls dazu.

Anschluß 74HC595:
MR  = Master Reset auf High (+5V)
OE  = Output Enable auf Low
SHCP = Shift Register Clock Input auf Takt(SCLK)
STCP = Storage Register Clock Input auf Strobe (Übernahmeimpuls)
DS  = Serial Data Input auf Datenausgang SPI (MOSI)
Q0-Q7 = Paralell Ausgänge zu den LED's
Q7´ = Serial Data Output auf DS des Folgeregisters

Gruß. Tom

Prima Hartl,

genau so habe ich mir das vorgestellt.

Einzige Bedenken: 13 Register an einer Takt- und einer OE-Leitung ist 
eine ganze Menge. Besonders, wenn die Leitungen lang und durch 
LED-Ströme ggf. gestört werden.

Deswegen mein Vorschlag, mit mehreren Strängen wie dem von Dir 
gezeichneten zu arbeiten. Und das Schieben und Speichern per Software zu 
machen, um so praktisch alle Pins des Arduinos dafür hernehmen zu 
können.

Jens

Langsam nimmt die Geschichte Gestalt an. Die Ideen von M.H und Jens 
machen die Sache praktikabel und funtionsfähig. Jetzt dürfte es kein 
Problem mehr sein daraus ein funktionierendes Gerät zu machen. Fehlt nur 
noch die richtige Software dafür. :-)

Ja, genau!

Wobei die Aufteilung auf Platinen auch noch zu diskutieren ist. Ist der 
Abstand der LEDs eher groß, 1 595 pro Platine (also 14 gleiche Platinen) 
und diese mit Flachbandleitung (preiswert und ruck zuck zu 
konfektionieren) verbinden.

Oder 2 pro Platine und ggf. teilbestücken.

Oder 4 pro Platine...

Will sagen, diese Optimierung hängt von vielem ab:
 - Verteilung der LEDs, Montage-Vorstellungen)
 - Art der Platinen (Lochraster oder geätzt)
 - Herstellkosten (Stückzahlen sind billiger als große Platinen)
 - Vorlieben des Erbauers

Wichtig scheint mir noch eines: Wenn das Ganze ordentlich in der 
Software abgebildet wird, ist die Art des Aufbaus später unerheblich für 
die Mustererzeugung. Die Muster macht der Controller (wie auch immer), 
schreibt sie in eine Schnittstellenvariable und ein an die Hardware 
angepasstes Stück Software teilt sie dann aus.

So würde ich mir das jedenfalls vorstellen (und darf sagen, dass ich 
auch schon so realisiert habe für eine 64x8x2(Farben) 
Matrix-LED-Anzeige, gesteuert von einem Attiny85).

Jens

Witzig. Da is entweder ein Troll oder jemand der offenbar Null Plan hat 
und das beste was er empfohlen bekommt is ein STM32 der wohl ein 
kleinwenig Oversized ist.

Dann kommt irgendwann "Ich habe mal mit Arduino programmiert"

BING!

Arduino "Erfahrung" + serielle Schieberegister + ein wenig mitlesen und 
verstehen und kurz google nutzen und schon ist das Problem mit einer 
Handvoll Programmzeilen erledigt.

Dazu liesst man(n) sich das hier durch:

http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister

http://www.mikrocontroller.net/articles/Porterweiterung_mit_SPI

Versteht es und setzt es um. EINFACHER geht es nur noch mit ner Platine 
voll Jumpern die man jedesmal umsteckt...


Letztendlich läuft es hinaus auf:

Arduino als "Steuereinheit" die man jedemal umprogrammieren kann wenn 
man ein neues Muster will.

13 74HC595 kaskadiert und an jedes jeweils 8 LED angeschlossen.

Das wars dann auch grob an "besonderer" Hardware.

Und da der Arduino einen so "großen" Controller hat, könnte man da sogar 
soviele LED Muster in Arrays ablegen und später auswählen das es fast 
fürs ganze Jahr reicht...

Oo

Manchmal muss man aber auch einfach das unvermögen kritisieren sich aus 
gegebenen Inffos das richtige rauszusuchen. Und das Stichwort 
Schieberegister (74hc595) fiel schon öfter.

Da aber heute jeder drauf wartet das man Mundfertige Kost serviert 
bekommt... Naja. Pisa kommt nicht von ungefähr...

Wie wär's mit nem FPGA? Selbst der kleinste Spartan 6 hat genügend IOs 
;)

decimad schrieb:
> Wie wär's mit nem FPGA? Selbst der kleinste Spartan 6 hat genügend IOs

Kenne mich da nicht so aus, aber liefert so ein Ding die 1-2A für die 
100LEDs? Die gleiche Frage stellt sich auch für den großen 
Zentral-Controller.

Jens

Mein Vorschlag war durchaus nicht so ganz ernst gemeint ;)

@cyblord: Mich würde interessieren, wie Du 100 LED unabhängig und ohne 
Multiplex ansteuerst, ohne 100 Bit Parallelspeicher, egal ob der nun 
direkt von der MCU mit ner Million Pins kommt oder über Schieberegister 
aufgebaut wird oder wie auch immer.

Sind die handgelötet für 23,5eu? O.O

Max D. schrieb:
> Ich würde vlt. mal in Richtung "intelligenter LED-Strip" denken, da
> reichen je nach design 1-3 Pins um unendlich viele LEDs in RGB zu
> steuern.

Wurde schon mal geschrieben. Aber man ist scheinbar immun gegen andere 
Lösungen...

Markus schrieb:
> Noch ein gutes Beispiel mit den WS2812
> http://www.instructables.com/id/Best-RGB-LEDs-for-any-project-WS2812/?lang=de

Oder auch:
http://mg-x.de/ambilight-diy/
http://blog.simtronyx.de/stimmungsbeleuchtung-auf-basis-eines-ws2811-rgb-led-strips-einem-arduino-acrylglas-und-ein-paar-bauteilen-aus-dem-baumarkt/

Diese Schieberegister kann man auch direkt an den Parallel-Port eines 
PC's anschließen. Dann brauchst Du keinen Mikrocontroller und schreibst 
das Programm auf dem PC für den PC.

Die Schieberegister würden ihre Programmierungs solange beibehalten, wie 
Strom da ist. Bei Stromausfall verlieren sie ihre Programmierung, 
warscheinlich bekommst Du dann ein zufälliges Muster.

> So richtig interessant wird die Sache erst, wenn das ganze dynamisch wird

Ich habe in einer Arztpraxis mal eine Konstruktion bestaunen dürfen. Die 
hatten eine Reflektor-Glühlampe und ein Bündel Lichtleiter verwendet. 
Dazwischen eine Pappscheibe mit Löchern, die von einem Elektromotor 
langsam gedreht wurde.

Das Ergebnis sah sehr schick aus.

So bin wieder da :-)

Also ich habe mir num überlegt ob es nicht auch mit zwei ARDUINO MEGA 
funktionieren würde. Dieser hat immerhin 54 digitale Ausgänge und 16 
analoge Eingänge.

Wäre es mit dem möglich?

- 10 Schalter bzw. Taster sollen an 10 analoge Eingänge
- sobald an einem oder mehreren analogen Eingängen ein HI anliegt soll 
der
  ARDUINO wissen, welche digitalen Ausgänge er auf HI schalten soll
- welche digitalen Ausgänge eingeschaltet werden sollen möchte ich über 
das Programmieren selbst immer festlegen können


Hier mal einen Link zu einem ARDUINO MEGA:


http://www.amazon.de/SainSmart-Mega2560-ATmega2560-ATMEGA8U2-cable/dp/B00FLL8OZG/ref=sr_1_1?ie=UTF8&qid=1388762612&sr=8-1&keywords=arduino+mega

Es sind 54 digitale Pins und zusätzlich noch 16 analoge Pins, da wird 
nix umgeschaltet.

Die Frage ist, ob ich mit den sieben TLC5921 jede LED auch einzelnd 
anteuern kann?

Sag mal Andre, wo wohnst du denn ungefähr? Vielleicht mag sich mal 
jemand mit dir treffen und dir beim basteln helfen. Ich glaube in einem 
persönlichem Gespräch lassen sich viele von den Wissenslücken schneller 
klären.

Ja da gebe ich dir recht, doch ich glaube in Rostock bin ich der einzige 
der sich damit auseinandersetzen möchte.

Ich wohne in Rostock.

Auch eine Möglichkeit:
http://www.thisiscolossal.com/2011/06/hello-world-a-sign-built-from-5000-rocker-switches/

Eh Leute, ich versuche nur eine Lösung zu finden.

Zwei Bausteine sind immer noch weniger als sieben. Es soll so einfach 
wie möglich sein. Ich kenne mich nicht mit den Begriffen kaskadieren 
oder Ausgangslatch aus. Ich verstehe es nicht, würde es aber gerne 
vestehen und nicht kritisiert werden. Das wäre echt lieb wenn man mir es 
mit einfachen schritten oder auch mit Zeichnungen erklären würde. Und 
noch ein Wort zu PISA. In der Schule bekommt man sicherlich nicht die 
Mikroelektronik gelehrt, zumindest nicht in meiner frühreren Schule die 
bereits fast 20 Jahre zurück liegt.

Ich möchte nun eigentlich nur wissen ob man den ARDUINO sagen kann, dass 
wenn an einen bestimmten analogen Eingang ein HI anliegt (indem man 
einen Schalter umlegt oder einen Taster drückt), er dann z.B. die 
digitalen Ausgänge 5, 10, 15 und 21 auf HI schaltet usw.

wie wär's, wenn man fertig programmierte Bausteine nimmt? Die SN74LV8153 
sind quasi spezialisierte uCs und können 8 LEDs treiben und bekommen die 
8 Ein-/Aus-Befehle über eine normale serielle Schnittstelle, also nix 
Schieberegister ;)

Davon kann man 7 Stück (evt. auch 8) an einen COM-Port hängen, 2 
COM-Ports steuern also 112 LEDs. Die Steuerung braucht sonst nichts 
weiter, man kann also einen Arduino oder einen normalen PC nehmen. Als 
Programm würde auch ein bash-Script reichen, die Daten gehen dann per 
"echo $BITS > /dev/ttyUSB1" raus.

Die kleinen LED-Platinen brauchen pro Platine einen 5V-Spannungsregler 
und einen Inverter, das reicht für 1 bis 7 SN74LV8153. Die Verkabelung 
wird sehr einfach, man braucht nur Masse,9 bis 12 Volt und eine einzige 
Ader für die Daten. Normales 10er Flachkabel reicht also für reichlich 
LED-Strom.

http://www.digikey.de/product-search/de?WT.z_header=search_go&lang=de&site=de&keywords=SN74LV8153

Danke, dann werde ich es damit mal versuchen :-)

Erst mal danke für deine Antwort.

So ganz verstehe ich die Porterweiterung mit SPI nicht.



Nun mal meine Frage dazu:

Ich drücke Schalter 1 und dann sollen z.B. LED 1,2,3,4 und 5 leuchten.
Ich drücke danach Schalter 2 und dann sollen z.B. LED 5,10,11 und 12 
leuchten.
Ich drücke ich noch einmal Schalter 1 und dann sollen LED 1,2,3,4,5 aus 
gehen.
Ich drücke noch einmal Schalter 2 und es sollen die LEDs 5,10,11 und 12 
aus gehen.

Das LED 5 mit den Schalter 1 und 2 gesteuert werden soll ist gewollt und 
kein Tippfehler.



Ist diese Aufbauweise mit einem Arduino und der Porterweiterung SPI 
möglich?

Die Fabel vom Igel der fliegen wollte.

Es begab sich in einem großen Garten, in welchem viele Tiere lebten. 
Dort wohnte, glücklich und zufrieden, ein Igel. Eines Tages kam er auf 
die Idee "ich möchte fliegen wie ein Vogel". Es wurde nicht lange 
gezögert und die Tiere im Garten befragt "wie kann ich es anstellen zu 
fliegen?".
Die Tiere versammelten sich um den Igel und die Vögel gaben ihm 
Ratschläge wie er es anstellen kann. Die Meisen meinten "Du mußt nur 
schnell genug mit den Flügeln schlagen", die Raben verneinten das und 
sagten "gehe es ruhig an und bewege die Flügel gleichmäßig". Die Hühner 
warfen ein "richtig fliegen geht nicht, aber mit den Flügel flattern um 
über den Zaun zu kommen ist einfach"! Wie sehr der Igel auch zappelte 
und versuchte sich in die Luft zu erheben, es wollte nicht gelingen. Da 
kam er auf die Idee es mit Raketenantrieb zu versuchen. Zum 
Jahreswechsel hatte er es doch gesehen, es geht auch ohne Flügel. Er 
brauchte nur einen langen Stock am Bauch und auf dem Rücken ein 
Raketentriebwerk, oder zwei, oder drei.....
Doch was immer er versuchte, das fliegen ist ihm nicht gelungen.

Moral: Eine Aufgabe wird nicht gelingen, wenn die grundlegenden 
Voraussetzungen nicht erfüllt sind - Igel haben keine Flügel und keine 
Euronen sich Raketensätze zu kaufen!

Schönes Wochenende. Tom

Danke Dietrich

ich bin schon mal froh das es geht.

Ich werde mir mal das Arduino-Board besorgen und ein dickes handbuch 
dazu und dann loslegen :)

Hallo André,

ich versuche es auch noch mal...

Die elektrische Ansteuerung der LEDs, ob nun mit vielen Prozessorports 
oder Schieberegistern oder den anderen genannten Lösungen ist die eine 
Sache. Irgendwann hast Du dann eine Lösung aus Hard- und Software, die 
das gezielte Ein- und Ausschalten der LEDs ermöglicht. Z.B. über ein 
Feld von 100 Variablen, deren Wert 0 oder 1 dazu führt, dass die LEDs 
aus oder an sind.

Die zweite ist das Einlesen der Taster oder Schalter oder auch 
Potentiometer. Auch das ist irgendwie machbar, hier ist der Aufwand 
vermutlich kleiner als bei den LEDs und es braucht kaum Leistung.

Die dritte (und vermutlich schwierigste) ist das sinnvolle Erzeugen von 
LED-Zuständen aus den Eingangssignalen. Die Frage 'geht dies oder das' 
ist eigentlich nicht richtig - es geht praktisch alles. Nur eine Frage 
des Aufwandes in der Software bzw. eine Frage, wie pfiffig die Software 
angelegt ist.

Mal ein Beispiel: Du hast Dir 10 verschiedene Himmelsmuster ausgedacht 
und diese in einem Feld abgespeichert. Sinnvollerweise ist das Muster so 
abgespeichert, dass es sich leicht anlegen, aber auch leicht zu den LEDs 
übertragen lässt (erster Gedanke: 14 Bytes, in denen je ein Bit für eine 
LED steht).

Die Auswahl, welches Muster des Feldes benutzt wird, läuft über eine 
Zahl von 0..9. Diese Zahl wird durch die Eingangssignale bestimmt, nach 
einem Dir genehmen Verfahren, eben so, wie sich das Ergebnis verhalten 
soll.

Ein ganz anderer Ansatz: Du hast keine Muster als Feld, sondern 
Programmstücke, die bestimmte LEDs  ein- oder ausschalten (also Bits in 
den 14 Bytes setzen oder löschen). Die Programmstücke rufst Du in 
Abhängigkeit der Eingangssignale auf.

Was der bessere Ansatz ist (beide führen zum Erfolg), hängt von Deinen 
Mustern und der Eingangssignalen ab. Auch hier ein Beispiel: Enthält 
Dein Sternenhimmel bestimmte Sternbilder aus sagen wir 5 Sternen und Du 
willst diese gezielt und getrennt voneinander ein- und ausschalten, 
machen kurze Programmstücke mehr Sinn, da nur relativ wenige Sterne 
(LEDs) betroffen sind.

Soll sich aber der Himmel grossflächig verändern, sehe ich eher die 
umgeschalteten Datenfelder als sinnvolle Lösung an.

Gestatte einen Tipp: Nehme einen Arduino, schliesse Dir 10 LEDs und zwei 
Taster dran an (also direkt, ohne zusätzliche Bausteine) und spiele 
damit rum. Damit Du ein Gefühl für die richtige Art der Programmierung 
bekommst. Und dann plane Deinen Himmel!

Wir können Dir hier ein paar Tipps geben, aber die Sache als Ganzes 
lernt man nur Schritt für Schritt durch eigene Erfahrungen - gute und 
nicht so gute.

Gruß
Jens

Danke Jens, ich werde deinen Rat befolgen :)

Sorry, mein fehler, ich heiße natürlich immer noch André ;)

Hallo Andre,
du kannst aber nicht 50 oder gar 100 LED's direkt an einen 
Mikrocontroller anschließen. Soviel Strom verträgt der nicht.

Aber Du kannst 13 Schieberegister an einen beliebig kleinen 
Mikrocontroller anschließen. Die sind (zusammen gerechnet) erheblich 
höher belastbar, als ein oder zwei Mikrocontroller.

Und täglich grüßt das Murmeltier.

Den Vorschlag mit I²C Interface vergessen wir besser ganz schnell 
wieder. Wenn Du dich schon weigerst, Schieberegister zu verwenden, dann 
wirst Du mit dem I²C Bus erst Recht nicht klar kommen.

Das YouTube-Video hat mir sehr geholfen, ich werde Schieberegister 
verwenden, gibt es denn auch Schieberegister die größer sind als 8 Bit 
damit ich keine 13 stück brauche, oder was wäre der größte?

Und dann habe ich ja auch unterschiedliche Farben, eine rote LED braucht 
ja nur 2,2 V und eine blaube bis zu 4,5 V, gibt es da auch einen IC der 
das erkennt und immer die richtige Ausgangsspannung angibt?

OK habe ich verstanden. Somit müsste ich ja nur 4 oder 5 Kabel zur Decke 
hoch legen und dort über die 13 Schieberegister die LEDs in der nähe 
anschließen. Das ist eine gute Idee.

Unten bleibt dann mein Arduino in kleinster Form um ihn gegebenfalls 
umzuprogrammieren wenn mir das Muster an der Decke nicht mehr gefällt.

Wie klein kann der Arduino denn sein? Soweit ich weiß kann man doch die 
10 Schalter oder Taster (die ich ja haben will um immer ein anderes 
Muster zu erzeugen) auch Binär zum Arduino übertragen z.B. mit einem 
Dezimal->BCD-IC?

Dann bräuchte ich ja nur 4 Anschlüsse am Arduino um 10 Schalter oder 
Taster zu bedienen und dann noch die anderen 4 oder 5 Anschlüsse (das 
weiß ich jetzt nicht so genau) um die Schieberegister zu steuern.

OK habe ich verstanden. Somit müsste ich ja nur 4 oder 5 Kabel zur Decke
hoch legen und dort über die 13 Schieberegister die LEDs in der nähe
anschließen. Das ist eine gute Idee.

Unten bleibt dann mein Arduino in kleinster Form um ihn gegebenfalls
umzuprogrammieren wenn mir das Muster an der Decke nicht mehr gefällt.

Wie klein kann der Arduino denn sein? Soweit ich weiß kann man doch die
10 Schalter oder Taster (die ich ja haben will um immer ein anderes
Muster zu erzeugen) auch Binär zum Arduino übertragen z.B. mit einem
Dezimal->BCD-IC?

Dann bräuchte ich ja nur 4 Anschlüsse am Arduino um 10 Schalter oder
Taster zu bedienen und dann noch die anderen 4 oder 5 Anschlüsse (das
weiß ich jetzt nicht so genau) um die Schieberegister zu steuern.

> um 10 Schalter oder Taster zu bedienen

das würde ich auf einen Taster runterbrechen und den Rest der Software 
überlassen.

Nein, ich möchte nicht immer die Programme alle durchschalten müssen um 
irgendwann am richtigen anzukommen. Jedes Programm soll seinen eigenen 
Schalter bekommen.

Auch nicht schlecht aber ich möchte die Taster einzelnd nebeneinander 
anordnen

OK danke, ich werde es versuchen :-)

OK danke, der Code sieht gut aus, so stelle ich es mir vor

Als Nächstes sind Probleme mit der Taktleitung zu erwarten, dann Andre 
hat wohl vor, diese "etwas" länger zu machen.

@Andre: Bestelle schonmla gleich ein par 100 Ohm Widerstände und 220nF 
Kondensatoren mit.