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
Angehängte Dateien:
-
Steuerung.png
88 KB
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.
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
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.
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).
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
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.
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?
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.
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,
Doch, gibt es: http://www.reichelt.de/STM-Controller/STM32-F103ZET6/3/index.html?&ACTION=3&LA=446&ARTICLE=125403&GROUPID=2950&artnr=STM32+F103ZET6
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.
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.
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?
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.
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.
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.
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.
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 ;-)
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.
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 ;-)
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.
Ich meinte: Mache besser kLeine Einzelmodule (Einzelplatinen) mit jeweils einem 74HC595 Chip drauf...
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
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.
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
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.
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
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
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.
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?????
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.
Noch ein gutes Beispiel mit den WS2812 http://www.instructables.com/id/Best-RGB-LEDs-for-any-project-WS2812/?lang=de
André schrieb: > 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????? Nein, der hat keine 110 I/O's. Das Board wo Du vorhin ausgesucht hast, hätte 112 IO's und würde gehen: 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
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
Das Board würde auch gehen: http://www.ebay.de/itm/STM32-ARM-Cortex-M4-Development-Evaluation-Board-STM32F407Z-with-Full-I-Os-/251296142025?pt=LH_DefaultDomain_0&hash=item3a826ad2c9
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)
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
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
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
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?
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
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
Das wäre ein passender Programmieradapter: http://www.amazon.com/Microcontrollers--circuit-debugger-programmer-emulator/dp/B00C7WDTLG/ref=sr_1_1?s=electronics&ie=UTF8&qid=1388699922&sr=1-1&keywords=st-link+v2
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
Angehängte Dateien:
-
24_LEDs.png
160 KB
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
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
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.
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...
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.
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
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.
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.
@Mod: Der Link zum Datenblatt des 74HC595 funktioniert nicht. Hier wäre eine Alternative: http://www.nxp.com/documents/data_sheet/74HC_HCT595.pdf
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. http://www.ebay.de/itm/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....
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/
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?"
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.
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
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. :)
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
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."
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.
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
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
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/
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.
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.
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.
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.
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...
Auch eine Möglichkeit: http://www.thisiscolossal.com/2011/06/hello-world-a-sign-built-from-5000-rocker-switches/
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.
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.
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 ;-)
> 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
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
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.
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
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
Schau dir mal diese Video an: http://youtu.be/7gnkbwbPZXo Vllt. hilf es dir beim Verstehen des Schiberegisters
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 :)
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?
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
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?
Ja, wir haben schon viele Beispiele gepostet, musst Du nur nochmal den Thread komplett durchlesen. z.B. hier; Beitrag "Re: erst programmieren, dann schalten"
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.
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
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.
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
Auch nicht schlecht aber ich möchte die Taster einzelnd nebeneinander anordnen
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.
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
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.
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.
Thread beobachten
Seitenaufteilung abschalten
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.