Forum: Mikrocontroller und Digitale Elektronik erst programmieren, dann schalten


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von André (Gast)


Angehängte Dateien:

Lesenswert?

Hallo :-)

ich habe leider noch nicht viel Ahnung, ich hoffe Ihr könnt mir helfen.

Ich suche einen IC den man programmieren kann und die Einstellungen auch 
speichert, sodass beim nächsten Einschalten die programmierten Daten 
noch vorhanden sind.

Ich möchte gerne mit einem Schiebeschalter 3 verschiedene Ausgänge 
schalten. Dabei sollen insgesammt 100 LEDs angesteuert werden. Wenn ich 
also den Schiebeschalter in der Stellung 1 habe, so sollen die LEDs 1 
bis 20 leuchten, ist der Schiebeschalter in Stellung 2 so sollen die 
LEDs 21 bis 50 leuchten, ist der Schiebeschalter in der Stellung 3 so 
sollen die LEDs 51 bis 100 leuchten.
Und nun kommt meine knifflige Idee dazu. Welche der LEDs in den 
einzelnen Stellungen leuchten sollen, möchte ich gerne selbst festlegen 
über das Programmieren eines ICs, sodass ich den IC sagen kann, welche 
Ausgänge er in den jeweiligen Stellungen des Schiebeschalters 
einschalten soll.

Im Angang ist grob dargestellt wie ich die Schaltung aufbauen möchte.

Wer kann mir helfen welchen IC ich brauche und welches Programm um diesn 
programmieren zu können?

Liebe Grüße aus Rostock

von ponnyprogger (Gast)


Lesenswert?

Ein ATTiny2313 machts!

von Stefan ⛄ F. (stefanus)


Lesenswert?

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?

von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

Stefan us schrieb:
> Kein normaler Chip hat 100 Ausgänge.

Es gibt viele "normale" Chips im LQFP144 Gehäuse die haben über 120 
I/O's. (z.B. einer aus der STM32 Reihe oder LPC1xxx)

Die Anzahl der IO's ist nicht das Problem, viel mehr dass der µC nicht 
den Strom von 100 LED's verkraftet.
Außer man verwendet LED's die man nur mit 2mA betreibt.

Programmieren könnte man den mit CooCox, siehe:
STM32 CooCox Installation

: Bearbeitet durch User
von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

Wenn Dich der STM32 tatsächlich interessieren sollte, dann kannst Du 
hier lesen:
STM32 für Einsteiger

Oder man nimmt einen kleineren Prozessor und erweitert die IO's mittels 
74HC595 (oder TPIC6C595 LED Driver).

von Marcel S. (thason)


Lesenswert?

Hallo,

wenn Du Dich noch nicht all so sehr mit Mikrocontroller, deren 
Programmierung und Beschaltung auskennst, kann ich Dir hierbei das 
Projekt "Arduino" empfehlen.

Hierbei ist das Programmieren relativ "einfach" gehalten und das 
Ansteuern von 100 und noch mehr LED's ließe sich zum Beispiel mit einem 
nachgeschalteten Shiftregister (z.B. 74HC595) umsetzen.

Wäre jetzt nur mal ein Vorschlag von meiner Seite. Analog zu "Arduino" 
gibt es auch zum Beispiel noch das "Raspberry PI".

Vielleicht helfen Dir die Tipps etwas weiter.

Viele Grüße, Marcel Stach

von André (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?

Ja, klar. Der eine hat 8 Ausgänge und den Chip kann man kaskadieren.
Also 13x den hintereinander und man hat 104 Ausgänge.

Der Prozessor benötigt somit nur
- 1x Daten-Ausgang
- 1x Clock
- 1x Latchen

und die Daten werden so seriell vom µC ausgegeben bis alle 104 Bits 
gesendet wurden und dann ein mal gelatcht und die 104 Ausgänge werden 
geschrieben.

von Tom (Gast)


Lesenswert?

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

von André (Gast)


Lesenswert?

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?

von Gerhard W. (gerhard86)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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,

von Markus M. (mmvisual)


Lesenswert?


von André (Gast)


Lesenswert?

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.

von Wegstaben V. (wegstabenverbuchsler)


Lesenswert?

Machs mit Multiplexing. für 100 LED barauchst du 10 + 10 Ausgänge. (Mit 
64 LED wäre es wesentlich bequemer, dann bräuchtest du nur 8 + 8 
Ausgänge)

Jeder dieser LED kannst du so "ansteuern", daß sie für dich wie an oder 
aus aussehen. Welches Bitmuster du da draufgibst (10 LED an, 10 LED aus, 
dann wieder 10 LLED an etc) kanst du recht einfach definieren.

von André (Gast)


Lesenswert?

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?

von Markus M. (mmvisual)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

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.

von Gerhard W. (gerhard86)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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.

von Andre S. (andys)


Lesenswert?

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 ;-)

von André (Gast)


Lesenswert?

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?

von kopfkratzer (Gast)


Lesenswert?

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 
?

von Stefan ⛄ F. (stefanus)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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 :-)

von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

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 
;-)

von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

Ich meinte:
Mache besser kLeine Einzelmodule (Einzelplatinen) mit jeweils einem
74HC595 Chip drauf...

von Markus M. (mmvisual)


Lesenswert?

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.

: Bearbeitet durch User
von André (Gast)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

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.

>da dieser ja nur 16 anschlüsse hat und keine 100.
Deshalb braucht Du auch 13 Stück davon. (+ einen µC der die 13 
ansteuert, denn die sind nicht programmierbar)

: Bearbeitet durch User
von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

Programmieren kann man den mit so einem Teil:
http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168
(ca. 30 EUR)

oder dem hier:
http://www.segger.com/j-link-edu.html
(besser, dafür 50 EUR)

Beide Programmieradapter können direkt in das Board eingesteckt werden. 
Als Programmieroberfläche kann diese verwendet werden, die funktioniert 
mit beiden Adaptern gleichermaßen:
STM32 CooCox Installation

: Bearbeitet durch User
von Tom (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?

Bei dem µC der André herausgesucht hat ist die Programmierung 
überschaubar klein.
- Ein Array mit den 10 Schalterstellungen und 100 LED's
- Das Array einfach auf die Ausgänge kopieren
das war's

EEPROM oder sonstiges ist unwichtig. Wenn er ein anderes Muster will, 
dann das Array umprogrammieren.

von André (Gast)


Lesenswert?

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é

von André (Gast)


Lesenswert?

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.

von Markus (Gast)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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?????

von Markus M. (mmvisual)


Lesenswert?

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.

von Markus (Gast)


Lesenswert?


von Markus M. (mmvisual)


Lesenswert?


von André (Gast)


Lesenswert?

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.

von Tom (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?

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

von Tom (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?

@Tom:
Habe ich ihm alles auch schon mal geschrieben ;-)

von André (Gast)


Lesenswert?

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)

von Wegstaben V. (wegstabenverbuchsler)


Lesenswert?

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.

: Bearbeitet durch User
von André (Gast)


Lesenswert?

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?

von André (Gast)


Lesenswert?

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

von Tom (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?

Und das EEPROM Programmiergerät gibt es auch nicht gratis...

Eigentlich würde das Board reichen:
http://www.wvshare.com/product/Core407Z.htm
Lieferung allerdings aus Honkong

von André (Gast)


Lesenswert?

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?

von Markus M. (mmvisual)


Lesenswert?

André schrieb:
> 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?

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-STM32F407ZET6-Cortex-M4-Development/dp/B00E0FJFVG

von André (Gast)


Lesenswert?

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

von André (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?


von Jens (Gast)


Lesenswert?

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

von Max H. (hartl192)


Angehängte Dateien:

Lesenswert?

André schrieb:
> Hm, ok, aber wie mache ich das, wie schließe ich den an, gibt es da
> schaltpläne?
Porterweiterung mit SPI
Du musst aber 13 und nicht 2 wie im Schaltplan hintereinander schalten.
Der 47HC595 ist ein Logik IC, den musst du nicht Programmieren. Du 
musst dann die Leitungen SCK MOSI und EN mit einem Mikrocontroller 
verbinden. Mit dem Mikrocontroller musst du also nur die 10 Tasten und 
die 3 Leitungen für Schieberegister verbinden.
Tom schrieb:
> Eine relativ einfache Lösung wäre noch die Bitmuster in ein (E)EPROM zu
> brennen und über die Adressierung (Schalterstellung) abzurufen,
Gute Idee...

André schrieb:
> 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
Wenn du die Porterweiterung mit SPI verwendest, brauchst du nur 3 + 
10 Pins am Arduino.
Wenn du mit Arduino schon was gemacht hast würde ich dabei bleiben und 
nicht für dieses Projekt was ganz neues lernen, da es mit Arduino recht 
einfach zu lösen sein sollte.

Im Anhang habe ich noch einen Schaltplan für dich.
Der ist jetzt nur für 24 LEDs lässt sich aber leicht auch 100 
erweitern...
Die Pins SCK MOSI und EN verbindest du mit dem SPI deines Arduinos.
Die LEDs flimmern nicht...
Die Widerstände musst du neu für deine LEDs berechnen.

Jens schrieb:
> 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.
Full ACK

: Bearbeitet durch User
von Tom (Gast)


Lesenswert?

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

von Jens (Gast)


Lesenswert?

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

von Max H. (hartl192)


Lesenswert?

Jens schrieb:
> 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.
Also das von mit Gezeichnete 4 1/3 mal als Platine fertigen und jede 
Platine mit einem anderen Soft SPI ansteuern?
Macht sinn.

von Tom (Gast)


Lesenswert?

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. :-)

von Jens (Gast)


Lesenswert?

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

von Manuel X. (vophatec)


Lesenswert?

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...

von Max H. (hartl192)


Lesenswert?

Manuel Z. schrieb:
> 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...
Ich weiß jetzt nicht wie viele Muster in Flash platz haben, aber mit dem 
10 Schaltern, könnte er ja 1024 Muster Codieren.

von decimad (Gast)


Lesenswert?

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

von Cyblord -. (cyblord)


Lesenswert?

Tja das nenn ich mal Transferdenken:

1 IO kann eine LED treiben.
5 IOs können 5 LEDs treiben.
Um 100 LEDs zu treiben, braucht man dann natürlich 100 IOs

Klasse. Ich will ja nicht behaupten dass ein solcher Mangel an 
Transferdenken und Kreativität vom Arduino Gebrauch alleine kommt. Aber 
befördert dies sicher und zieht gleichzteitig Leute an, die solch einer 
Denkweise nahestehen.

Durch echtes Entwickeln lernt man Abstrahieren und das Lösen von neuen 
Problemen durch verändertes kreatives Anwenden von altem Wissen. Um muss 
nicht stumpf bekannte Denkmuster 1:1 übernehmen.

gruß cyblord

von Jens (Gast)


Lesenswert?

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

von decimad (Gast)


Lesenswert?

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.

von Max H. (hartl192)


Lesenswert?

Mit welchem Strom willst du die LEDs betreiben?
Der 74HC595 kann max. 70mA am Vcc Pin du kannst also max. 8mA pro LED 
ziehen. Da es aber ein Sternenhimmel und keine Beleuchtung wird, müssten 
8mA leicht genug sein.
Wenn es mehr sein muss, könntest du an jedes Schieberegister einen 
ULN2803 hängen.

von Cyblord -. (cyblord)


Lesenswert?

decimad schrieb:
> @cyblord: ....

Mein Post war an den TE gerichtet, nicht an dich.

von Max H. (hartl192)


Lesenswert?

@Mod: Der Link zum Datenblatt des 74HC595 funktioniert nicht.
Hier wäre eine Alternative: 
http://www.nxp.com/documents/data_sheet/74HC_HCT595.pdf

von Max D. (max_d)


Lesenswert?

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.

Ebay-Artikel Nr. 111237007066 hier, da hat ein Chinese so viel 
davon, dass er sie verkaufen muss
Das sind 50 LEDs und alles was man tun muss ist für jede LED die RGB 
werte reinzuschieben (und für die übernahme kurz warten, wenn ich mich 
richtig an das db erinner)
Jeder Chip hat einen gebufferten clock und datenausgang, damit muss der 
master in der chain nur den ersten Chip "befeuern", der verstärkt dann 
die signale für den nächsten usw.
Man kann so unendlich viele LEDs kaskadieren, man muss nur genug Strom 
reinfüttern um alle zu betreiben....

von decimad (Gast)


Lesenswert?

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

von Markus (Gast)


Lesenswert?

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/

von Jörg W. (dl8dtl) (Moderator) Benutzerseite


Lesenswert?

M. H. schrieb:
> @Mod: Der Link zum Datenblatt des 74HC595 funktioniert nicht.

Da können wir Moderatoren auch nichts dagegen tun.

Am besten hier "melden":

Beitrag "Datenblatt URL ändern?"

von Jörg W. (dl8dtl) (Moderator) Benutzerseite


Lesenswert?

M. H. schrieb:
> Wenn es mehr sein muss, könntest du an jedes Schieberegister einen
> ULN2803 hängen.

Es gibt teilweise von den Herstellern auch LED-Treiber mit eingebautem
Schieberegister.  Habe sowas beispielsweise von Allegro benutzt für
"meine" LED-Pseudo-Analog-Uhr (knapp 500 LEDs, schaltbar in 192
einzelnen Strängen, hatte hier auch mal irgendwo ein Foto).

Da aber für André ja mental nur ein Controller mit 100+ IOs in Frage
kommt, weil er sich alle anderen Lösungen nicht vorstellen kann, und
er sich über Stromergiebigkeit, Verlustleistung etc. offenbar noch
gar keine Gedanken gemacht hat, wird ihn das vermutlich nicht
weiter interessieren.  Schließlich hat ein Arduino ja für ihn zu wenig
IOs …  Ich habe die Allegros auch bloß mit'm ATmega88 gesteuert.  Mehr
braucht man für ein bissel Uhr halt nicht.

von Markus M. (mmvisual)


Lesenswert?

Nur zur Vollständigkeit, ich habe ihm nicht nur STM32 sondern auch 
Arduino und auch 74hc595 und LED Treiber IC empfohlen.
13 Einzelplatinen, die man schön verteilt anbringen könnte.

Wobei der STM32 durchaus Vorteile wegen den vielen Pins hätte:
Soft-PWM um zu dimmen
und einfacher zu programmieren (nur ein Array auf die Ports kopieren)

: Bearbeitet durch User
von Jörg W. (dl8dtl) (Moderator) Benutzerseite


Lesenswert?

Markus Müller schrieb:

> Wobei der STM32 durchaus Vorteile wegen den vielen Pins hätte:
> Soft-PWM um zu dimmen
> und einfacher zu programmieren (nur ein Array auf die Ports kopieren)

Allerdings muss man dann eben auch 100 Drähte von einer Stelle
wegführen.  EMV-mäßig ist eine Soft-PWM in so einer Konfiguration
tödlich, und selbst ohne PWM ist das ein ziemlicher Klumpen an
Draht, der da von einer Stelle abgeht.

Soft-PWM geht auch mit den Schieberegistern: ein paar Kilohertz
PWM-Frequenz bekommt man da schon noch durchgeschoben.  Schwieriger
wird es allerdings mit hohen SPI-Frequenzen, wenn die Dinger verteilt
angeordnet werden.

Aber da er ja sowieso "Flimmern" kategorisch ausgeschlossen hat und
nur "Ein/Aus" wollte, ist das kein großes Thema, da kann man auch mit
gemütlichen SPI-Frequenzen arbeiten. :)

von Karl H. (kbuchegg)


Lesenswert?

Markus Müller schrieb:
> Nur zur Vollständigkeit, ich habe ihm nicht nur STM32 sondern auch
> Arduino und auch 74hc595 und LED Treiber IC empfohlen.
> 13 Einzelplatinen, die man schön verteilt anbringen könnte.

Da ich genau sowas schon gemacht hab (auch Sternenhimmel), möchte ich 
als Senf dazugeben, dass dieser Aufbau nicht zu verachten ist. Mit einem 
kleinen Flachbandkabel-Bus fährt man von einer 595 Platine zur nächsten 
und zweigt von dort jeweils 8 LED ab. Der Verkabelungsaufwand hält sich 
dadurch in Grenzen und im Falle eines Falles ist das Ganze auch noch 
problemlos erweiterbar (denn 100 LED hört sich erst mal viel an, ist es 
aber nicht, wenn die erst mal an der Decke sind).


Die 'Sache mit den Mustern': Der Appetit kommt mit dem Essen. Statische 
Muster werden ganz schnell fad. So richtig interessant wird die Sache 
erst, wenn das ganze dynamisch wird. Gerade im Winter, wenn es kalt 
wird, flackern Sterne. Zudem gibt es noch andere 'Muster', die ihren 
Reiz haben. Selbst wenn das ganze als Sternenhimmel gedacht ist, so eine 
"Stadion mit glitzernden Blitzlichtern" hat dann auch was: LED fahren in 
Grundhelligkeit und zufallsgesteuert blitzen in kurzer Folge einige bis 
viele auf. Da gibt es viele Variationsmöglichkeiten.

: Bearbeitet durch User
von Markus M. (mmvisual)


Lesenswert?

Ich zu meiner Frau:
"Weißt Du wie man einen Sternenhimmel macht?"

Sie:
"Ja, man nimmt einen Hammer und schlägt sich auf den Kopf."

von Stefanus (Gast)


Lesenswert?

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.

von Stefanus (Gast)


Lesenswert?

> 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.

von Simon S. (-schumi-)


Lesenswert?

Ich wollte nur mal in den Raum werfen, dass es neben der sehr 
vernünftigen Lösung mit Arduino+Schieberegister noch ein zweite sehr 
ähnliche gibt:

http://www.nxp.com/documents/data_sheet/SAA1064_CNV.pdf

Das ist ein I2C-Baustein, der 16 Konstantstromsenken eingebaut hat. 
Damit lassen sich 16LEDs ohne Vorwiderstände ansteuern und sogar 
(zusammen) in der Helligkeit programmieren (bis 21mA). Wenn man das 
eingebaute Multiplexing nutzt (zusätzlich 2 Transistoren benötigt), kann 
man sogar 32LEDs ansteuern. Aber dann reicht die Helligkeit für 
Zimmerbeleuchtung evtl. nicht mehr aus.

Wenn man jetzt 16LEDs pro Baustein nimmt:
- 7 Bausteine = 112LEDs
- 4 Bausteine pro I2C-Bus -> zwei Busse -> SDA parallel und SCL mit 
Wechslerrelais schalten
- Die Helligkeigkeit der 7 Gruppen lässt sich jeweils einstellen

von André (Gast)


Lesenswert?

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

von Markus M. (mmvisual)


Lesenswert?

In Englisch bist Du ja nicht so gut, aber kannst Du französisch?

Dann lese mal hier:
http://www.zem.fr/decouverte-du-composant-74hc595-8-bit-shift-register/

von Max H. (hartl192)


Lesenswert?

André schrieb:
> Dieser hat immerhin 54 digitale Ausgänge und 16
> analoge Eingänge.
>
> Wäre es mit dem möglich?

Ich weiß jetzt nicht, ob die analogen Eingänge und die Digitalen 
verschiedene Pins verwenden oder von den 54 digitalen 16 auf analog 
umgeschaltet werden könnten.
Wenn die Ein-/Ausgänge verschiedene Pins verwenden müsste es mit 2 
Arduino Mega möglich sein. Es bleibt aber die Frage wie viel Strom du 
einer LED gibst, und ob der µC auf dem Arduino Mega so viel Strom auf 
den Vcc Pins kann. Wenn nicht müsstest du Transistoren oder Transistor 
Array dazwischen schalten.
Was spricht eigentlich gegen die Schieberegister oder LEDs mit 
integriertem Controller?
Der TLC5921 ist ein 16 LED konstantstrom Treiber mit integriertem 
Schieberegister. Du kannst also 7 davon kaskadieren und Kannst mit 3 
Ausgängen deines Mikrocontrollers 112 LEDs ansteuern. Weil der TLC 
integrierte Konstantstromquellen hat, brauchst du für die LEDs keine 
Vorwiderstände.

von André (Gast)


Lesenswert?

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?

von Eumel (Gast)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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.

von Max H. (hartl192)


Lesenswert?

André schrieb:
> Die Frage ist, ob ich mit den sieben TLC5921 jede LED auch einzelnd
> anteuern kann?
Du kannst jede LED einzeln ansteuern. Da wird nix gemultipelxt. Jede LED 
hat seinen eigenen Ausgang am TLC5921.
Der LCD ist im Prinzip ein Speicher mit konstantsrom Ausgang, den du mit 
3 Pins deines µCs beschreiben kannst.

von Andreas S. (Firma: Schweigstill IT) (schweigstill) Benutzerseite


Lesenswert?

Jörg Wunsch schrieb:
> Aber da er ja sowieso "Flimmern" kategorisch ausgeschlossen hat und
> nur "Ein/Aus" wollte, ist das kein großes Thema, da kann man auch mit
> gemütlichen SPI-Frequenzen arbeiten. :)

Nein, das geht nicht, denn André hat uns doch schon darüber belehrt, 
dass schieberegisterbasierte Lösungen immer flackern. :-( Wer wagt es da 
noch, seiner Ahnungslosigkeit zu widersprechen.

von Max H. (hartl192)


Lesenswert?

Andreas Schweigstill schrieb:
> dass schieberegisterbasierte Lösungen immer flackern.
Wenn das SR ein Ausganslatch hat, werde die sicher nicht flakern, außer 
man schreibt die Software so, dass sie flackern...

von decimad (Gast)


Lesenswert?


von Andreas S. (Firma: Schweigstill IT) (schweigstill) Benutzerseite


Lesenswert?

M. H. schrieb:
> Andreas Schweigstill schrieb:
>> dass schieberegisterbasierte Lösungen immer flackern.
> Wenn das SR ein Ausganslatch hat, werde die sicher nicht flakern, außer
> man schreibt die Software so, dass sie flackern...

Ach wirklich? Glaubst Du, mir wäre das nicht klar? André lehnt aber 
solch ein Lösung kategorisch ab, weil sie seiner Meinung nach flackert.

Auf der einen Seite bemängelt er zudem, bei einer Schieberegisterlösung 
müssten alle Bausteine separat programmiert werden, was natürlich auch 
völliger Humbug ist, kommt dann aber selbst mit einer 
Doppelprozessorlösung an, die aber genau gegen dieses Kriterium mehrerer 
programmierbarer Bausteine verstößt.

von André (Gast)


Lesenswert?

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.

von Markus M. (mmvisual)


Lesenswert?

Daher gibt es für André nur eine einzige Lösung:
Ein Board mit einem STM32F407ZE (112 I/Os / 144Pinner)

Es völlig unwichtig dass der Prozessor zu viel Leistung kann, die 
braucht man ja nicht aktivieren. Das Board hatte ich oben bereits schon 
mal verlinkt (Core407Z, 
http://www.amazon.com/Core407Z-STM32F407ZxT6-STM32F407ZET6-Cortex-M4-Development/dp/B00E0FJFVG).

Die Programmierung ist Easy:

- Port Clock aktivieren
- 100 Port-Pins als Ausgang parametrieren
- je nach Schalterstellung die Ports setzen/löschen.

fertig.

So wie in diesem Demo gezeigt:
STM32 CooCox Installation
nur eben 100 LED's nicht nur 4.

Kein EEPROM programmieren, keine serielle SPI Ausgabe programmieren, und 
sonst auch nichts großartig denken. Die CPU läuft dann mit 16MHz, das 
sollte ausreichend sein für diese Anforderung ;-)

von Markus M. (mmvisual)


Lesenswert?

> Das wäre echt lieb wenn man mir es mit einfachen schritten oder auch mit
> Zeichnungen erklären würde.

Haben wir alle hier schon mehrfach versucht. Zeichnungen wurden bereits 
angehängt und Seiten verlinkt. Einige haben das alles auch schon gut 
beschrieben.

: Bearbeitet durch User
von gnd3 (Gast)


Lesenswert?

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

von André (Gast)


Lesenswert?

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

von Max H. (hartl192)


Lesenswert?

Andreas Schweigstill schrieb:
> Ach wirklich? Glaubst Du, mir wäre das nicht klar? André lehnt aber
> solch ein Lösung kategorisch ab, weil sie seiner Meinung nach flackert
Ich wollte dem TO nur nach mal bestätigen, dass die LEDs mit SR nicht 
flackern, ich wollte nicht dein Wissen in Frage stellen.

Andreas Schweigstill schrieb:
> Auf der einen Seite bemängelt er zudem, bei einer Schieberegisterlösung
> müssten alle Bausteine separat programmiert werden, was natürlich auch
> völliger Humbug ist,
Genau die Schieberegister muss man nicht Programmieren. Nicht alles was 
im DIP Gehäuse ist ein Programmierbarer IC

André schrieb:
> Ich verstehe es nicht, würde es aber gerne
> vestehen und nicht kritisiert werden.
Nur um zu wissen wo wir stehen: Hast du die den Artikel 
Porterweiterung mit SPI nicht durchgelesen oder nicht verstanden?

André schrieb:
> Zwei Bausteine sind immer noch weniger als sieben.
Das stimmt, wenn du 2 Arduinos verwendest musst du aber beide 
Programmieren, die 7 TLC5921 muss (und kann) man nicht Programmieren

André schrieb:
> kaskadieren
Kaskadieren, bedeutet in diesem Fall die Schieberegister 
hintereinanderschalten, wie auf meinem Schaltplan zu sehen.

André schrieb:
> 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.
Ja kann man, ich kann dir aber nicht sagen wie, da ich mit Arduino noch 
nie was gemacht habe.

gnd3 schrieb:
> SN74LV8153
Ich kannte diesen IC noch nicht, aber wenn der TO die LEDs über seinen 
PC ansteuern will, scheint mir das in Verbindung mit einem USB/Seriell 
Adapter, falls er keine Serielle hat eine gute und recht einfache 
Lösung.

von André (Gast)


Lesenswert?

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?

von Markus M. (mmvisual)


Lesenswert?

Ja, ganz ohne Flackern.

: Bearbeitet durch User
von Tom (Gast)


Lesenswert?

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

von Dietrich L. (dietrichl)


Lesenswert?

André schrieb:
> Ist diese Aufbauweise mit einem Arduino und der Porterweiterung SPI
> möglich?

André, ich habe den Eindruck, Dein Verständnis für die Zusammenhänge ist 
etwas "konfus". Aber ich versuche es mal....

Du solltest gedanklich mal unterscheiden zwischen
- der Hardware, die Deine Wünsche erfüllen können. Das ist mit einem 
µC (z.B. Arduino) + Porterweiterung (z.B. Schieberegister oder 
ähnliches) möglich.
- die Software, die der Hardware die Eigenschaften verleihen, das zu 
tun, was Du willst: welche LEDs bei welcher Schalterstellung leuchten 
sollen.
Dazu muss die Software erstellt (geschrieben) werden. Dazu braucht man 
eine Entwicklungsumgebung (Programm auf dem PC + Programmiergerät) und 
Kenntnisse, um das Programm zu schreiben, das genau Deine Wünsche 
umsetzt.
Das wäre in dem Fall also:
- Abfrage der Schalter,
- Auswahl der gewünschten Bitmuster (leuchtenden LEDs) abhängig von den 
Schalterstellungen,
- Ausgabe des ausgewählten Bitmusters an die Porterweiterung.

Diese Wünsche:
> 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.
werden also alle durch die Software "erledigt". Und da sind (fast) keine 
Grenzen durch die Hardware (Arduino + Porterweiterung) gesetzt, höchsten 
durch die Fähigkeiten des Programmierers. Aber so schwierig ist die 
Aufgabe eigentlich nicht.

Vielleicht hilft das...

Gruß Dietrich

von Max H. (hartl192)


Lesenswert?

Schau dir mal diese Video an:
http://youtu.be/7gnkbwbPZXo
Vllt. hilf es dir beim Verstehen des Schiberegisters

von Steffen (Gast)


Lesenswert?

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 :)

von Max H. (hartl192)


Lesenswert?

Noch eine frage an den TO:
Könntest du so etwas mit dem Arduino realisieren, wenn du  z.B. nur 10 
LED und 3 Tasten hättest?

von Jens (Gast)


Lesenswert?

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

von Steffen (Gast)


Lesenswert?

Danke Jens, ich werde deinen Rat befolgen :)

von Markus M. (mmvisual)


Lesenswert?

Heißt jetzt der "André" "Steffen"?

von André (Gast)


Lesenswert?

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

von Stefan ⛄ F. (stefanus)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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?

von Markus M. (mmvisual)


Lesenswert?

Ja, wir haben schon viele Beispiele gepostet, musst Du nur nochmal den 
Thread komplett durchlesen.

z.B. hier;
Beitrag "Re: erst programmieren, dann schalten"

von Jörg W. (dl8dtl) (Moderator) Benutzerseite


Lesenswert?

André schrieb:
> 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,

Siehe oben.  Ich habe in meiner LED-Uhr Allegro-LED-Treiber benutzt
mit je 16 Ausgängen.  (Allerdings gibt's die nicht im DIL-Gehäuse.)

Auch jemand anders hat von einem ähnlichen Baustein geschrieben.

> oder was wäre der größte?

Danach darfst du bei den Herstellern schon mal selbst suchen.

> 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?

Dir fehlen die Grundlagen.  LEDs werden nicht mit einer konstanten
Spannung betrieben, sondern mit konstantem Strom.  Die passende
Flussspannung stellt sich von selbst ein (deine Spannungsversorgung
muss natürlich genügend bereitstellen).

Daher sind LED-Treiber typischerweise Konstantstromsenken.  Also
ähnlich wie eine Konstantstromquelle, jedoch sie werden gegen
Masse (GND) aktiv, wenn sie eingeschaltet werden.  An deren
Schaltausgang hängen dann die LEDs (können auch mehrere in Reihe sein,
wenn man diese gleichzeitig schalten will) gegen eine genügend hohe
positive Versorgungsspannung.

von Karl H. (kbuchegg)


Lesenswert?

André schrieb:
> 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?

Du scheinst eines immer noch nicht begriffen zu haben.
Die 13 Stück sind kein Nachteil!

Denn die Schieberegister müssen ja nicht physikalisch nebeneinander 
angeordnet werden. Du kannst 1 Schieberegister mit dem nächsten 
verbinden und dabei 30 zentimeter Flachbandkabel dazwischen haben. 
Dadurch hast du lauter kleine Einzelplatinen, auf der jeweils 1 
Schieberegister sitzt (oder auch 2). Der springende Punkt ist, dass dir 
dieses die Komplettverkabelung enorm vereinfacht. Denn du setzt dann 
jeweils eine dieser Platinen physikalisch in die Nähe von jeweils 8 
(oder 16) LED, was dir den Verkabelungsaufwand der LED an die Schaltung 
enorm vereinfacht, weil du dann keine langen Wege hast. Oder willst du 
100 doppeladrige Kabel an einer Stelle sternförmig zusammenführen? 
Kannst du dir vorstellen was das für ein Verkabelungschaos ergibt? So 
hast du ein paar Knotenpunkte, an denen jeweils 8 oder 16 dieser Kabel 
zusammenlaufen und die Knotenpunkte sind mit einem zb. 10 poligen 
Flachbandkabel untereinander verbunden.

> 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?

LED sind stromgesteuert und nicht spannungsgesteuert. D.h. du brauchst 
sowieso Vorwiderstände. Die werden auf den Strombedarf der LED bzw. 
deren Spannungslage abgestimmt. Angesteuert wird aber alles immer mit 
5V.

: Bearbeitet durch User
von Steffen (Gast)


Lesenswert?

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.

von André (Gast)


Lesenswert?

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.

von chris (Gast)


Lesenswert?

> um 10 Schalter oder Taster zu bedienen

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

von André (Gast)


Lesenswert?

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

von Dietrich L. (dietrichl)


Lesenswert?

André schrieb:
> 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.

Alternative wäre ein Kodierschalter, z.B. 
http://www.reichelt.de/Dip-Kodierschalter/KMR-10/3/index.html?&ACTION=3&LA=446&ARTICLE=9433&GROUPID=3287&artnr=KMR+10&SEARCH=kodierschalter, 
der ist schon BCD-kodiert.

Gruß Dietrich

von André (Gast)


Lesenswert?

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

von Max H. (hartl192)


Lesenswert?

André schrieb:
> Auch nicht schlecht aber ich möchte die Taster einzelnd
> nebeneinander
> anordnen
Dann brauchst du einen Arduino mit >13 Pins: 10 für die Tasten 3 Furs 
die Schieberegister.

Die LEDs betreibt man mit konstantem Srom, nicht konstanter Spannung. 
Die Standart lösungen dafur sind:
- Vorwiderstände die man so berechner: R=(Ub-Uled)/Iled
- Die Schiberegister mit konstantstrom Ausgang die ich weiter oben 
genannt habe.

von André (Gast)


Lesenswert?

OK danke, ich werde es versuchen :-)

von Max H. (hartl192)


Lesenswert?

Man könnte das ganze ungefähr so lösen. Ich denke mein Code ist relativ 
einfach zu verstehen sein:
1
while(1)
2
{
3
  if(schalter1)
4
  {
5
    schieberegister1 |= 0b01001001  
6
    schieberegister2 |= 0b00110110  
7
    ... 
8
  }
9
  else
10
  {
11
    schieberegister1 &= ~0b01001001  
12
    schieberegister2 &= ~0b00110110  
13
    ...     
14
  }
15
  if(schalter2)
16
  ...
17
18
  send(schieberegister1)
19
  send(schieberegister2)
20
  ...
21
22
  LE=1
23
  LE=0
24
}

Ich würde in µC für jedes Schieberegister eine Variable erstellen, die 
mit 0 initialisiert wird und abhängig von der Schalterposition in diesen 
Variablen einzelne bits Setzen und löschen. Am ende jeden 
Schleifendurchlaufs werden alle Variablen an die Schieberegister 
gesendet.

Wenn du eine LED in mehreren mustern verwenden willst, musst du aber 
nicht auf den Zustände der Tasten, sondern auf die Flanken an den 
Eingänge schauen.
Da ich keine Ahnung von Arduino habe kannst du den Code natürlich nicht 
1:1 verwenden.

: Bearbeitet durch User
von André (Gast)


Lesenswert?

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

von Stefanus (Gast)


Lesenswert?

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.

von Karl H. (kbuchegg)


Lesenswert?

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

Wobei:
In seiner Aufgabenstellung muss er nicht 'Full-Speed' takten. Wenn es 
nur darum geht, LED ein bzw. aus zu schalten, kann er ganz gemütlich vor 
sich hintakten. Anders sieht es aus, wenn er auch noch Soft-PWM machen 
will. Aber soweit ist er (momentan) noch nicht.

Bei mir hat es gereicht, im Flachbandkabel jeweils abwechselnd eine 
Signalleitung und eine GND vzw. Vcc Leitung vorzusehen. Das jedes SR 
seinen Blockkondensator bekommt, ist sowieso selbstverständlich.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.