Hallo

Angeregt durch ein Projekt hier im Forum, habe ich mich nun daran gemacht ebenfalls eine Steuerung für eine Zimmerbeleuchtung mit Hilfe eines Arduino zu bauen.
Leider gibt es da ein paar Probleme.
Aber erstmal will ich die Ausgangslage beschreiben.
Zum Einsatz sollen zwei Streifen RGB-Led kommen, mit je 5 Meter Länge und 150 Led.
Des weiteren soll ein Streifen warm Weiße Led von 3 Meter Länge und 360 Led verwendet werden.
Das ganze wird in einen Kabelkanal von 10cm Breite und 4cm Höhe auf eine Länge von 3,5 Meter (eventuell 4 Meter, muss ich noch entscheiden) eingeklebt.
In die Mitte die Weißen Led, links und rechts davon die RGB-Led.
Folgender Ablauf soll eigentlich durch den Arduino gesteuert werden.
Wenn Strom angeschaltet, sollen alle Led angehen, sodass alles Weiß ausgeleuchtet wird.
Drücke ich nun einen Taster, sollen zu erst die Weißen Led runtergedimmt werden.
Sind diese aus sollen nun die grünen heruntergedimmt werden, aber noch während das passiert sollen auch die blauen gedimmt werden.
Allerdings sollen die blauen erst mit dem dimmen anfangen wenn die grünen schon ungefähr zur hälfte gedimmt sind.
Genauso soll es mit den roten gehandhabt werden.
Desweitern soll aber auch wenn alles ausgegangen ist, über ein zweiten Taster die Möglichkeit bestehen die blauen Led wieder "hoch zu fahren" .
Allerdings nicht unbedingt wieder auf volle Pulle, da ja das Mondlicht simuliert werden soll.
Was habe nun schon erreicht? (mit einer Experimentierschaltung mit Rot, Grün und Blauer Led)
Ich habe mir ein kleines Programm geschrieben mit dem ich es hinbekomme per Tastendruck zuerst die grüne Led zu dimmen und anschließend die rote.
Das ganze könnte ich auch auf die blaue erweitern.
Aber --- die Led bleiben nicht aus, wenn die rote fertig herunter gedimmt wurde gehen sie wieder an, bis ich das nächste mal den Taster drücke.
Nun stellen sich mir folgende Fragen:
Wie erreiche ich es, das die Led aus bleiben?
Wie bekomme ich es hin das sie erst bei einem zweiten Tastendruck wieder angehen?
Wie kann ich das dimmen für die einzelnen Farben versetzt zu einander realisieren?
Und Schlussendlich wie kann ich blau wieder hoch fahren, ohne das die anderen Led auch wieder angehen?
Es wäre echt Toll wenn mir jemand auf die Sprünge helfen könnte.
Ich beschäftige mich leider noch nicht allzu lange mit dieser Materie und stehe entsprechend auf dem Schlauch.
Eigentlich wollte ich das Sketch was ich geschrieben habe hier anhängen, aber das geht wohl nicht.
Es ist im Übrigen ein modifiziertes aus dem Internet, ursprünglich für eine Aquariumbeleuchtung.
Ich werde das Sketch als Antwort auf dieses Posting machen, damit man es besser sehen kann.

Gruß Bernd
Tante Edit sagt --- da sich ja niemand zu meinem Sketch äußern will, entferne ich es und stelle lieber die inzwischen
gemachten Fortschritte dar. Sollte dann jemand Interesse an dem Sketch haben, kann er sich ja an mich wenden.
Derjenige könnte es ja dann per Mail bekommen.

Inzwischen bin ich nun soweit das die Led runter dimmen und auch aus bleiben.
Weiterhin ist nun ein zweiter Taster dazu gekommen.
Mit diesem können dann die Led wieder "hoch gefahren" werden.
Offen ist noch die Frage wie ich das dimmen so gestalten kann, das sich Mischfarben ergeben.
Im Moment werden die Farben nacheinander abgearbeitet, nötig wäre aber ein sich überlagerndes dimmen.
Und das auch wieder nur teilweise.
Naja, ich werde weiter forschen.
Wenn allerdings jemand den unbändigen Drang verspürt mir mit Rat zur Seite stehen zu wollen, wäre mir das auch willkommen.

Gruß Bernd

Hallo,

Zitat von Behagen

---

da sich ja niemand zu meinem Sketch äußern will, entferne ich es ...

---

tja, wenn Du uns nicht mal einen Tag zum Nachdenken läßt ...

Den Tipp mit den Code-Tags wollte ich Dir gestern reinstellen - um dann festzustellen, dass Du den Sketch doch noch drangehängt hast. Jetzt wollte ich mir den Sketch noch mal ansehen, da ist er schon wieder weg.

Auch gut, aber Hilfe bekommt man mit diesem System eher nicht ...

Viele Grüße, Bodo

Hallo Bodo

Es ist immer schön wenn man sich nur das rauspicken kann was einem gefällt.
Da Du ja offensichtlich mein PS: gelesen hast, dürfte Dir auch nicht entgangen sein
das ich das Sketch bei Interesse gerne per Mail zu sende.
Das Ding ist zwar nur 3kb groß, nimmt als Listing auf dem Bildschirm aber einigen Platz ein.
Und mir widerstrebt es nun mal das Forum mit unübersichtlichen Ausdrucken vollzumüllen.
Das ganze wäre wesentlich einfacher zu Hand haben, wenn man hier Dateianhänge machen könnte.

Im übrigen stand es zwei Tage hier, aber in der Zwischenzeit hatte es ja auch Veränderungen gegeben,
die es sowieso völlig überholt hatten.
Sei es wie es sei --- ich werde mich weiter mit dem Thema beschäftigen und bin mir sicher, das ich es
zu einem vernünftigen Ergebnis bringen werde. Zumal es jetzt schon annähernd so funktioniert wie
ich es mir vorstelle.

Gruß Bernd

Hallo Bernd,

willst Du nun Hilfe oder nicht?
Wenn ja, wäre es schon sinnvoll, den Code nicht nur auf Anforderung zur Verfügung zu stellen. Falls es Dir darum geht, Deinen sonstigen Text nicht im Code untergehen zu lassen, setze Deinen Code doch einfach in einen "spoiler", dann wird er erst nach Anklicken sichtbar.
Wenn nein, auch gut.

Hallo Bernd,

gezippt kann man ihn auch als Datei anhängen (kenne jetzt die Größenveschränkung nicht, aber bei Wintrack Files klappt das, sollte für einen Sketch also auch gehen).

Spoiler ist natürlich auch mobil lesbar und erhält die Übersichtlichkeit.

Hallo
Natürlich würde ich gerne auf die Hilfe des Forums zurückgreifen.

An die Spoilerfunktion habe ich in diesem Zusammenhang gar nicht gedacht.
Wie man allerdings eine Zip-Datei hier anhängt habe ich leider immer noch nicht begriffen.

Also ich hänge das aktuelle Sketch nun mal als Spoiler hier ran.
Mit diesem kann ich über Taster 1 die Led dunkel machen.
Zu erst wird Blau runter gedimmt, danach Rot und Grün gemeinsam.
Über Taster 2 wird der Vorgang sozusagen Rückwärts abgearbeitet.
Der Schwachpunkt an der Sache ist, das ich Rot und Grün nicht unterschiedlich schnell bzw. nicht zeitversetzt dimmen kann.
Entweder gemeinsam oder Nacheinander funktionieren, bringen aber nicht das gewünschte Ergebnis.

Gruß Bernd

Hallo Bernd,

kenne mich mit Sketchen nicht aus, verstehe allerdings das Programm ungefähr.
Grundsätzlich müßtest Du in der Schleife rot und grün nicht auf r dimmen, sondern auf f1(r) und f2(r). r sollte dann vielleicht einen größeren Bereich bekommen, F1 und F2 sollten Werte zwischen 255 und 0 ergeben.
Die Funktionen dann so definieren, daß das gewünschte Ergebnis rauskommt.
Zb F2 schneller gegen 0 laufen lassen...

Verstehst Du was ich meine ?
Wäre das eine Möglichkeit?

Hallo Jörg

Erstmal danke ich Dir das Du Dich bemühst mir zu helfen.
Wie ich ja geschrieben habe, bin ich noch ein blutiger Anfänger was die Programmierung des Arduino angeht.
Ich habe zwar früher mal auf meinem Amiga ein wenig mit Basic her rum geklimpert, aber lang, lang ist es her.
Also ich bin gerade in der Learning by doing Phase, was den Arduino angeht.
Zurückgreifen kann ich dabei eigentlich nur auf ein Programmierhandbuch aus dem Internet (25 Seiten)
Dabei bin ich beim "studieren" von anderen Sketchen darauf gestoßen, das mir dieses Handbuch wohl einiges verschweigt.
Lange Rede, kurzer Sinn --- im Moment kann ich Dir nicht folgen.
Was sollen F1 und F2 sein und wie beeinflusst man sie?

Gruß Bernd

Hi.

Wenn Du mehrere Dinge gleichzeitig machen willst, dann kannst Du nicht mit einzelnen "delay"-Schleifen arbeiten. Wie willst Du die zeitversetzt oder gleichzeitig abarbeiten?

Wie sah der Code aus, mit dem Du zeitversetzt oder gegenläufig dimmen wolltest?

Gruß
Martin

Also Beispiel:
r läuft von 3*255 bis 0
f1(r)= r/3 ( also wie bisher linearer Abfall der Helligkeit)
f2(r)=r/30 (Nachkomma stellen abschneiden, hier ist also eher Dunkel)
Das ist jetzt ein einfaches Beispiel, man könnte auch quadratische Funktionen nehmen oder irgendwas anderes, je nachdem wie der Verlauf sein soll.

Hallo Martin

Hab ich irgendwo geschrieben das ich zeitversetzt dimmen kann ?
Im Gegenteil, das ist ja mein Problem, das ich lösen möchte.
Einzig und allein das Nacheinander dimmen , oder das Gleichzeitige dimmen bekomme ich hin.
Also erst eine Farbe runter dimmen --- wenn fertig --- dann zweite Farbe runter dimmen.
Haben möchte ich aber z.B. Grün wird gedimmt, ist auf einen bestimmten Wert gefallen( der aber noch größer als Null ist),
nun fängt Rot ebenfalls an zu dimmen.

Gruß Bernd

Hi,
ein Beispiel, wie man delay() vermeidet, damit man mehrere Dinge gleichzeitig machen kann, ist das hier:
http://playground.arduino.cc/Learning/BlinkWithoutDelayDe
Gruß
Martin

P.S.: Klar, im Beispiel gehts um Blinken. Aber die Logik, die hier die Verwendung von delay() vermeidet, kannst Du auch fürs Dimmen verwenden.

Zitat von Behagen

---

Haben möchte ich aber z.B. Grün wird gedimmt, ist auf einen bestimmten Wert gefallen( der aber noch größer als Null ist) nun fängt Rot ebenfalls an zu dimmen.

---

Hi,
das geht auch mit delay().
Was passiert denn, wenn Du innerhalb der Schleife, mit der Du grün dimmst, den momentanen Wert von Grün auf den "bestimmten Wert" abfragst, und wenn ja, dem von Rot auch 1 abziehst?
Gruß
Martin

Hallo Bernd!
Deinen Sketch wirst Du wahrscheinlich irgendwann dazu bringen, das zu machen was Dir vorschwebt - falls Du dann aber einen anderen Lichtverlauf möchtest, musst Du den Sketch aufwändig überarbeiten. Will heißen: Deine Programmstruktur ist etwas eng und mit delay() lässt sich nicht gut arbeiten...
Auf die Schnelle und ungetestet würde ich folgendes vorschlagen:
In der Hauptschleife loop() setzt Du je nach Schalter oder sonstwie drei Byte-Variablen rSoll, gSoll und bSoll auf die Werte, die die jeweilige Farbe annehmen soll, das kann auch in Abhängigkeit der Farbe sein, soll z.B. rot erst aufdimmen wenn blau auf 50% steht, wäre eine Abfrage if(b==12 rSoll=255; in loop() machbar. Der Phantasie sind keine Grenzen gesetzt.....
Das Dimmen selbst lässt Du ein Unterprogramm erledigen, z.B. dimmen().

void dimmen(){
if(millis()-rMillis>FadeZeit){
rMillis=millis();
if(rSoll<r) r--;
if(rSoll>r) r++;
analogWrite(RED,r);
}
if(millis()-gMillis>FadeZeit){
//dasselbe jetzt für Grün...
gMillis=millis();
//usw.
//...

}
//Und noch eine If-Abfrage für Blau....
//...

}
rMillis,gMillis und bMillis sind als "unsigned long" deklarierte Variable
Wenn Du es noch flexibler haben möchtest, könntest Du FadeZeit pro Farbe getrennt wählen, z.B. rFadeZeit usw.
Die Sollwerte müssen nicht 0 oder 255 sein, so kannst Du auf beliebige Zwischentöne dimmen lassen.
Wie gesagt: ohne Gewähr auf die Schnelle hingeschrieben.
Wenn was nicht klappt einfach nachfragen.

Edit: Was Jörg wahrscheinlich meint, ist dass eine lineare Zu/Abnahme von r,g,b keine lineare Helligkeitsänderung der roten, grünen und blauen LEDs bewirkt - das sind halt nun mal keine linearen Bausteine. Hier kann man mit dem Umweg über f[r] usw. eine Linearisierung erreichen - bei Bedarf mehr darüber.

Edit2: Ein Codeschnipsel, wie es in loop() aussehen könnte:

.....
if(Schalter1==LOW) state=1;
if(Schalter2==LOW) state=2;
//usw.
switch(state){
case 1:
gSoll=0; //Grün beginnt abzudimmen
if(g==12 bSoll=0; //Blau beginnt abzudimmen wenn grün bei 50%
if(g==196) rSoll=0; //Rot beginnt abzudimmen wenn grün bei 75%
break;
case 2:
bSoll=64; //Blau wird auf 25% gedimmt
break;
}
.....
dimmen();
.....


"state" ist als Byte-Variable definiert.

Hallo
@ alle

Ich danke Euch für die Anregungen, da habe ich jetzt etwas was ich mir erstmal durch den Kopf gehen lassen muss.
Ich hoffe das ich Euch bald über die gemachten Fortschritte unterrichten kann.

Gruß Bernd

Beim dimmen hat man leider noch mit einem ganz anderen, leider deutlich unangenehmeren Problem zu tun. Das menschliche Auge kann sich der Umgebungshelligkeit in weiten Bereichen anpassen. Das bedeutet, dass man bei sehr wenig Licht verhältnismäßig viel sehen kann. Das kommt dadurch zustande, dass das Auge eine nichtlineare Kennlinie hat. Wenn man nun die PWM in gleichmäßigen Schritten dimmt, ist das für ein Messgerät linear, für das Auge hingegen nicht. Man muss nun also eine Kurve erstellen, die verschiedene Punkte des linearen Dimmens einem logarithmierten Wert für die Augen zuweist. Soweit auch noch kein Problem, wenn man die korrigierten Helligkeitswerte in einem Array ablegt und aufrufen lässt. Allerdings können die günstigeren Arduinos nur zwei PWM Kanäle mit 16bit generieren, die restlichen vier nur mit 8bit. Da bleiben dann nicht mehr viele mögliche Schritte übrig, was zu Helligkeitssprüngen führen kann. Man muss nun mehr Kanäle mit höherer Auflösung bereitstellen. Wahlweise durch mehrere Controller, einen passenden, der etwas größer als ein Mega 328P ausfällt, passende PWM Bausteine oder per software PWM

Lässt sich alles umsetzen, wird nur etwas Zeit in Anspruch nehmen

Hier ist das ganze meiner Meinung nach recht gut beschrieben:

http://www.mikrocontroller.net/articles/LED-Fading

Das Codebeispiel ist allerdings etwas rudimentärer. Die ganzen verschiedenen Register, die dort verwendet werden, spricht man im Arduino meistens über fertige Funktionen auf. Allerdings kann man auch alles wie gehabt schreiben.

Hallo Bernd!
Wenn Du schon dabei bist, Dir Dein Projekt durch den Kopf gehen zu lassen, dann hier noch einige Anmerkungen:
Wenn Du schon in eine derart aufwändige Beleuchtung investierst, könnte man deren Möglichkeiten weiter ausschöpfen. Zunächst würde ich nicht nur drei Kanäle (r,g,b) dimmen sondern auch weiß. Weiter wäre denkbar, nicht nur zwei Zustände (zwei Schalter) zu benutzen sondern deutlich mehr, dann ließen sich per Schalter z.B. "Dämmerung", "Heller Tag", "Gewitter", "Vollmond", usw. einstellen und die Beleuchtung dimmt dann auf diese Lichtstimmung. Weiter würde ich an die Analogeingänge 5 Potis anschließen: Für jede Farbe eins, eines für weiß und eines für FadeZeit. So ließe sich die FadeZeit verändern. Ein zusätzlicher Schalter schaltet die Potis ein, so dass es relativ einfach wäre, Lichtstimmungen auszuprobieren - zudem ich mir vorstellen kann, dass das Herumspielen Spass macht. Um es noch komfortabler zu gestalten, könnte man daran denken, dass die eingestellte Lichtstimmung dann per Knopfdruck im EEPROM gespeichert wird und dann mit den Schaltern für die Lichtstimmungen wieder abgerufen werden kann. Und....

Hallo

Leider bin ich bisher noch nicht wieder dazu gekommen, mich mit der Software auseinander zu setzen.
Montagabend habe ich erst mal etwas an der Hardware gebastelt. Bisher hatte ich nur auf dem Arduino
ein Shield von Vellemann ( KA01) auf dem sich auch je eine Rot, Grüne und Blaue LED befinden im Einsatz.
Dieses soll später die LED-Bänder "befeuern" (kann bis 6A belastet werden) .
Allerdings kann man so nicht gut sehen wie das Ergebnis der Programmierung letztlich wirkt.
Also habe ich nun das LED-Band gekürzt und einen Teil direkt an den Arduino angeschlossen.
Dabei konnte ich dann feststellen, das es beim dimmen ab einem bestimmten Punkt zu einem Flimmereffekt kommt.
Ich denke Philipp meint mit seinem Posting dieses Problem.
Also muss man zumindest die Kanäle Rot und Grün besser auf lösen, wenn ich das richtig verstanden habe.
Stellt sich die Frage --- reichen dazu dann 16bit und welches sind die beiden passenden Anschlüsse ?

@ Uli
In meinem ersten Posting habe ich ja schon geschrieben, das ich beabsichtige ein weißes LED-Band mit zu verwenden.
Dieses soll natürlich noch vor den RGB-LED gedimmt werden.
Auch soll über einen dritten Taster ein "Mondschein" simuliert werden.
Aber weiter möchte ich es dann auch nicht mehr treiben.
Wenn ich all das was Du so beschreibst umsetzen wollte, bliebe erstens keine Zeit mehr für die Modellbahn
und zweitens könnte ich dann gleich die Fernbedienung die dabei war behalten und das Licht so abstimmen
Nein im Ernst --- mich stellt das Projekt ja so schon vor eine ordentliche Herausforderung und irgendwo muss
man es ja auch mal gut sein lassen.

Gruß Bernd
PS: übrigens --- die letzten beiden Tage konnte ich abends nicht mehr auf das Forum zugreifen.
irgendwas mit dem Server sei nicht in Ordnung wurde mir auf den Bildschirm geschrieben ?

Zitat von Behagen

---

übrigens --- die letzten beiden Tage konnte ich abends nicht mehr auf das Forum zugreifen.

---

Hi,
das passiert immer dann, wenns draußen kalt ist, zusätzlich auch noch dunkel, nix im Fernsehen kommt, und auch sonst nix los ist. Abendessen ist vorbei, und zum Ins-Bett-Gehen noch zu früh. Dann tummeln sie sich alle im Stummiforum. Alle gleichzeitig. Das kann nicht gut gehen.
Am besten wiederkommen, wenn draußen die Sonne scheint, es Mittagessenzeit ist. Und Dortmund-Bayern im Fernsehen kommt. Dann ist die Performance vom Forum am besten.

Gruß
Martin

Hallo
@ Martin

Aber wenn Dortmund/Bayern im Fernsehen kommt langweilen sich doch auch die Leute ---oder ?


Ohje jetzt gibt es bald einen an Fußball nicht interessierten weniger.

@Philipp
Könntest Du mir mit dem von Dir verlinkten Beispiel etwas auf die Sprünge helfen?
Insbesondere der am Programmanfang gehaltene (Grüne) Teil ist mir nicht klar.
Da das Programm ja für einen anderen AVR mit angeschlossenem STK500 gedacht ist, komme ich da ins Straucheln.
Um was es sich bei dem STK500 handelt habe ich herausbekommen, aber das bringt mich nicht wirklich weiter.
Im Programm tauchen dann mit einem mal OCR1A und TCCR1A sowie TCCR1b auf --- wo kommen die her und was machen die ?
wäre sehr nett wenn Du mir da auf die Sprünge helfen könntest.

Gruß Bernd

Hallo Bernd,
ich habe es ohne Arduino einfach mit einem ATMEGA88 gemacht. Ich habe damit 3 Leuchtstoffröhren( weiss, weiss mit roten Krepppapier, weiss mit blauen Krepppapier) über dimmbare Vorschaltgeräte(0..10V) gemacht. Klappt auch prima. Dazu habe ich dann auch LED Streifen (rote, blaue und warm Weise) dazu gebaut. Und als "Highlight" noch ein Relaisausgang der beim dunkel werden die Modelbahnbeleuchtung einschaltet.
Letzten Herbst habe ich dann nochmal erweitert mit einem Soundmodul von ELV (20€), darauf habe ich dann Gewitter MP3 Files gespielt. Wenn es jetzt Nacht ist kommt ab und zu auch noch das grollen vom Gewitterschlag, mit den weisen Leds wird dann das Blitzen simuliert...
Werde es aber wahrscheinlich nochmal umbauen bzw erweitern auf eine manuelle Bedienungsmöglichkeit, nicht immer kann man die Nacht gebrauchen.
Wer einen Schaltplan oder eine Platinenplan haben möchte, gebe ich gerne ab.
Bernd Bömer

Hallo Namensvetter

Interessanter Lösungsansatz, aber ich bin nun schon soweit in der Sache das ich nichts mehr
(Hardwareseitig) anders machen möchte.
Die Beleuchtung muss nun auch in den nächsten Tagen fertig werden, damit ich mit den anderen
Sachen weitermachen kann. Erst wenn die Beleuchtung montiert ist kann ich anfangen den Rahmen
für meine Anlage aufzubauen.

Gruß Bernd

Hallo Bernd,
sollte auch nur eine Anregung sein, was man so alles machen kann....

Gruß
Bernd

Zitat von Behagen

---

@Philipp
Könntest Du mir mit dem von Dir verlinkten Beispiel etwas auf die Sprünge helfen?
Insbesondere der am Programmanfang gehaltene (Grüne) Teil ist mir nicht klar.
Da das Programm ja für einen anderen AVR mit angeschlossenem STK500 gedacht ist, komme ich da ins Straucheln.
Um was es sich bei dem STK500 handelt habe ich herausbekommen, aber das bringt mich nicht wirklich weiter.
Im Programm tauchen dann mit einem mal OCR1A und TCCR1A sowie TCCR1b auf --- wo kommen die her und was machen die ?
wäre sehr nett wenn Du mir da auf die Sprünge helfen könntest.

Gruß Bernd

---

#include <avr/io.h>
#include <avr/pgmspace.h>

#define F_CPU 8000000L
#include <util/delay.h>

#define STK500 0

#if STK500
// inverted PWM on OC1A for STK500
#define INVERT_PWM (1 << COM1A0)
#else
// non-inverted PWM on OC1A
#define INVERT_PWM 0
#endif // STK500

Das bedeutet folgendes:

#include bedeutet, dass man die entsprechende .h Datei einbindet. Diese beinhaltet Funktionen, mit denen bestimmte Dinge passieren oder die Information für den Compiler, welcher Prozessor welchen Pin an welcher Stelle hat.
#Define ist eine Definition, also zB die Information für die Berechnung, dass der Prozessor mit 8MHz taktet.
#if ist eine if Abfrage, mit der man festlegen kann, ob man den Prozessor auf dem STK500 benutzt. Das dient in dem Fall dazu, die PWM im invertierten, also umgekehrten Modus laufen zu lassen. Das ist notwendig, weil die LEDs auf dem STK Board leuchten, wenn der Pin am Prozessor ausgeschaltet ist.

Das sind alles Dinge, die man vorab einstellen muss, wenn man in einer etwas nackteren Programmierumgebung arbeitet, zum Beispiel dem AVR Studio oder einem Texteditor. Das Arduino Programm macht das schon automatisch für dich, sodass du es nicht selbst machen musst. Dabei werden diese Dinge von der Arduino Oberfläche passend gewählt, je nachdem, welches Arduinoboard du einstellst. Das braucht dich also zunächst nicht zu interessieren.

Die Registerangaben sind die Namen für Hardwareadressen auf dem Prozessor. Im Prinzip kann man das mit einer digitalen Modellbahn vergleichen. Man wählt eine bestimmte Lokadresse und übergibt ihr eine Wertekombination, die beschreibt, mit welcher Geschwindigkeit und welchen Funktionen die Lok fahren soll. Auf dem Prozessor macht man genau dies auch. Wenn man zum Beispiel möchte, dass der PWM Pin OCR1A eine bestimmte Pulsfolge ausgibt, muss man erstmal TCCR1A und TCCR1B passend beschreiben und dann OCR1A einen Wert zuweisen. Die Arduinooberfläche macht nun folgendes: Wenn du ein AnalogWrite() auf einen Pin ausführst, wird genau das gemacht. Das ist im Prinzip wie bei MFX, wenn man über Lokkarten eine Lok auswählt. Man kümmert sich nicht mehr um die Adresse, nimmt aber dafür das, was vorgegeben ist.

Falls dich die genaueren Zusammenhänge interessieren sollten: Auf der Mikrocontroller.net Seite findest du links das AVR GCC Tutorial. Da werden die Grundlagen sehr ausführlich beschrieben. Im Prinzip kannst du aber das Meiste wie gesagt auch in der Arduinowelt umsetzen.

Ab von der Programmierung: Das grundlegende Problem des ruppigen Dimmens wird im oberen Artikel auch ganz gut beschrieben. Man hat dabei nun immer einen Zielkonflikt, zwischen PWM Auflösung und Wiederholfrequenz. Das kommt folgendermaßen zu stande: Der Prozessor taktet mit einer bestimmten Frequenz. Im Fall des Arduinos sind dies im Regelfall 16MHz. Habe ich nun eine 8bit PWM, hat diese 256 Schritte pro Durchlauf und es ergibt sich eine PWM Frequenz von 16000000MHz/256=62,5KHz. Bei einer 16bit PWM hat man entsprechend noch 16000000MHz/65536=244Hz. Die 244 reichen für einen flimmerfreien Betrieb aus. Der einzige Nachteil dabei im Fall eines Arduino Unos: Er hat nur 2 PWM Kanäle die 16bit Auflösung bieten. Man muss also entweder darauf verzichten oder sich anderweitig behelfen. Das ist allerdings wieder etwas komplizierter. Deshalb würde ich dir dazu raten, zunächst einmal auf die 8bit Variante zurückzugreifen und die Helligkeitskurve auf zB 16 Schritte zu beschränken. So kannst du dich ersteinmal an die Steuerung des ganzen heran arbeiten. Wenn du einmal die grundlegende Funktion hast und richtig verstehst, worauf es bei der Abfolge ankommt, kannst du zum einen die Auflösung erhöhen, zum Anderen die oben genannten Vorschläge mit zusätzlichen Funktionen relativ einfach einbauen.