Modellbau Steuerungen selber bauen...

So zum Frühstück für die Nicht-"Informatiker" mal noch die erklärung der For Schleife und der if Bedingung

for Schleife:

Die for Schleife dient im allgemeinen dazu eine Reihe von Befehlen zu wiederholen.
Im letzten Programm gleich zu Beginn die Festlegung was der Pin für eine Verwendung hat.

Der Grundsätzliche Aufbau einer For Schleife ist:

Code:
for (Initialisierung; Test; Fortsetzung){Anweisung}

Bei der Intialisierung wird der "Zähler" und sein Startwert festgelegt: int Zähler = 1;

Der Zweite Teil wird die Endbedingung festgelegt die bei jedem durchlauf geprüft wird: Zähler < 14;

Im Dritten Schritt wird definiert man wie gezählt werden soll am häufigsten wird man wohl + oder - verwenden.
dabei entspricht Zähler = Zähler + 1; der Kurzform Zähler++; und Zähler = Zähler - 1; der Kurzform Zähler--; Natürlich kann man auch Zähler = Zähler + n; oder -n verwenden um in beliebigen Schritten weiter zu zählen.

if Bedingung:

Die If-Bedingung dient in erster Linie als Abfrage einzelner Werte,
dabei gibt es die Vergleichsmöglichkeiten >, =,
 
Danke für deine ausführliche Erklärung!Ich hoffe das einigen damit einen Schritt weit geholfen wurde!Beste Grüße Tobias
 
So, wie versprochen gibt es jetzt noch die "Knight-Rider" Steuerung ;-)


Zunächst legen wir wieder die Variablen und Pins fest, wie bei dem normalen Lauflicht:
Code:
const int ledCount = 14;
int led[] = {0, 1, 2, 3 , 4 , 5 , 6 , 7 , 8 , 9, 10, 11, 12, 13};

void setup() {
// loop over the pin array and set them all to output:
for (int thisLed = 1; thisLed < ledCount; thisLed++) {
pinMode(led[thisLed], OUTPUT);
}
}

Für den Wechsel der Laufrichtung müssen wir die for Schleife zunächst etwas anpassen:

Code:
void loop() {
for(int thisLed = 1; thisLed < ledCount; thisLed++){
int thisLed2 = thisLed - 1;
if (thisLed2 == 0){thisLed2 = 13;}
digitalWrite(led[thisLed], HIGH);
digitalWrite(led[thisLed2], LOW);

// Zur Vermeidung einer unnötigen Pause wird hier die Pause bei Kanal 13 nicht ausgeführt
if (thisLed != 13){delay(150);}
}

Jetzt müssen wir das ganze nur noch "Rückwärts" laufen lassen:

Code:
// da wir ja nun mit der LED 13 anfangen müssen wir nun rückwärts zählen
for(int thisLed = 13; thisLed > 0; thisLed--){

// Das selbe gilt natürlich auch für den 2ten Kanal der in jedem Schritt angesprochen wird, auch hier arbeiten wir Spiegelverkehrt
int thisLed2 = thisLed + 1;
if (thisLed2 == 14){thisLed2 = 1;}

digitalWrite(led[thisLed], HIGH);
digitalWrite(led[thisLed2], LOW);

// Wie in der ersten Schleife, wird auch hier beim letzten Schritt die Pause einfach blockiert
if (thisLed != 1){delay(150);}
}  
}

Wie dieses Beispiel zeigt lassen sich auch scheinbar "komplexe" Laufmuster durch die Verwendung von for()-Schleifen und if-Anweisungen einfach realisieren.

Der gesamte Code in einem Stück:
Code:
const int ledCount = 14;
int led[] = {0, 1, 2, 3 , 4 , 5 , 6 , 7 , 8 , 9, 10, 11, 12, 13};

void setup() {
// loop over the pin array and set them all to output:
for (int thisLed = 1; thisLed < ledCount; thisLed++) {
pinMode(led[thisLed], OUTPUT);
}
}

void loop() {
for(int thisLed = 1; thisLed < ledCount; thisLed++){
int thisLed2 = thisLed - 1;
if (thisLed2 == 0){thisLed2 = 13;}
digitalWrite(led[thisLed], HIGH);
digitalWrite(led[thisLed2], LOW);
if (thisLed != 13){delay(150);}
}

for(int thisLed = 13; thisLed > 0; thisLed--){
int thisLed2 = thisLed + 1;
if (thisLed2 == 14){thisLed2 = 1;}
digitalWrite(led[thisLed], HIGH);
digitalWrite(led[thisLed2], LOW);
if (thisLed != 1){delay(150);}
}  
}
 
Mal ne kurze Zwischenfrage an die Elektronik-Profis.

Das Board selbst liefert ja nur 5V an den Ausgängen, für ne Sinnvolle Beleuchtung recht wenig...
lässt sich das "Problem" mit einer Emitterschaltung mit Spannungsgegenkopplung lösen (und wie müsste der Schaltplan sinnvollerweise aussehen (http://www.elektronik-kompendium.de/sites/slt/1102161.htm hier fehlen mir leider die Werte))

Oder besser eine Ansteuerung mit Relais?!?


P.S. wenn am Wochenende Zeit bleibt erkläre ich noch die verschachtelten Schleifen, wie man dimmt... und wenn ganz viel Zeit ist auch noch wie man einen SERVO ansteuern kann ;-)
 
So, leider war alles etwas hektisch die letzten Tage und wollte hier nicht auf die Schnelle was hinkritzeln.


So kommen wir nun zu den "verschachtelten" Schleifen und als kleines Bonbon lagern wir noch eine Funktion aus ;-)

Den Anfangsteil vor dem loop Bereich können wir wieder übernehmen.

Bei dieser Steuerung läuft das Licht bis zu Kanal 13 welcher eingeschaltet bleibt beginnt wieder von 1 bis 12 dann von 1 bis 11 und so weiter bis alle Kanäle leuchten.

Code:
void loop() {

for (int Counter = (ledCount - 1); Counter >= 0; Counter--){
Die erste Counterschleife, hier wird festgelegt wie häufig die eigentliche Schleife wiederholt werden muss. In Unserem Fall 14 mal, da der PC aber mit 0 beginnt zu zählen müssen wir den Startwert dennoch auch 13 (ledCount - 1) setzen.

Code:
int Hilfscounter = Counter + 1;
Da wir wissen müssen wie weit die eigntliche Schleife laufen muss benötigen wir den Hilfscounter.

Code:
if (Hilfscounter != 1){
Für den Reibungslosen Ablauf und damit auch die letzte LED am Ende aktiviert wird benötigen wir hier eine if Abfrage damit die Schleife nur ausgeführt wird, wenn es sich um ein Lauflicht handelt.

Code:
for(int thisLed = 1; thisLed < Hilfscounter; thisLed++){
int thisLed2 = thisLed - 1;
if (thisLed2 == 0){thisLed2 = Counter;}
digitalWrite(led[thisLed], HIGH);
digitalWrite(led[thisLed2], LOW);
delay(100);
}
Diese Schleife ist das eigentliche Lauflicht wie schon in den Letzten Beispielen.

Code:
} else {
digitalWrite(led[1], HIGH);
}
}
Hier die bereits früher einmal erwähnte "else" Variante in der if-Abfrage. Wenn der Wert 1 ist wird dieser Teil ausgeführt und in unserem Fall LED1 angeschaltet.

Code:
delay(5000);
LedsAus();
}
Nach einer gewissen Zeit (hier 5 Sekunden) sollen die LEDs ausgeschaltet werden. Hier hätten wir die Möglichkeit die Schleife direkt zu integrieren, funktions-bausteine die jedoch regelmässig verwendet werden, lassen sich sinnvoller in einer eigenen funktion auslagern und extra aufrufen.


Code:
void LedsAus(){
for(int thisLed = 1; thisLed < ledCount; thisLed++){
digitalWrite(led[thisLed], LOW);
delay(1);
}
}
Hier wird die neue Funktion eingebaut (nach dem Loop Teil) die Funktion selbst enthält wieder unsere For-Schleife, die einfach nur alle PINs deaktiviert. Das delay von 1 wäre nicht nötig, ist auch nicht wirklich erkennbar, erhöht jedoch dennoch die Performanze.

Und hier nocheinmal das komplette Script in einem Stück
Code:
const int ledCount = 14;
int led[] = {0, 1, 2, 3 , 4 , 5 , 6 , 7 , 8 , 9, 10, 11, 12, 13};

void setup() {
// loop over the pin array and set them all to output:
for (int thisLed = 1; thisLed < ledCount; thisLed++) {
pinMode(led[thisLed], OUTPUT);
}
}

void loop() {

for (int Counter = (ledCount - 1); Counter >= 0; Counter--){
int Hilfscounter = Counter + 1;
if (Hilfscounter != 1){
for(int thisLed = 1; thisLed < Hilfscounter; thisLed++){
int thisLed2 = thisLed - 1;
if (thisLed2 == 0){thisLed2 = Counter;}
digitalWrite(led[thisLed], HIGH);
digitalWrite(led[thisLed2], LOW);
delay(100);
}
} else {
digitalWrite(led[1], HIGH);
}
}
delay(5000);

LedsAus();
}


void LedsAus(){
for(int thisLed = 1; thisLed < ledCount; thisLed++){
digitalWrite(led[thisLed], LOW);
delay(1);
}
}

Sobald ich die Zeitfinde werde ich mal ein Video von dem Effekt online stellen.


HARDWARE:
Für den Test der Software hab ich mir einfach in Ermangelung einer Platine Lötnägel auf ein Holzbrettchen genagelt und entsprechend LEDs mit Vorwiderstand daran gelötet. Alle - mit einem Draht verbunden und einfach in einen GND ausgang gesteckt. Die + Pole habe ich jeweils einzeln mit Telefondraht an die Ausgänge 1 - 13 angeschlossen.
Sieht zwar etwas chaotisch aus... Und die Elektronik Profis würden schreiend davon laufen, erfüllt aber seinen Zweck und ich musste nicht geduldig warten bis C mir endlich meine Materiallieferung zukommen lässt ;-)
 
Hi Tarabas 77,

deine Beiträge finde ich sehr interessant.
Ich würde mich freuen, wenn du auch erklären könntest, wie
man mit der Steuerung eine Lampe dimmen kann.

Gruß Dominik
 
Kommt noch...

Da ich das aber auch gleich mit einem interessanten Beispiel verbinden möchte, bin ich da noch etwas am Rechnen ;-)
 
Jetzt lassen wir dem "Zufall" eine Chanze.

Mit Zufalls werten lässt sich vieles noch induvidueller und realistischer darstellen.

Eine Möglichkeit wäre es verschiedene Lauflichtmuster in funktionen auszulagern und dann via Zufall aufzurufen, dies werde ich später auch noch zeigen, jedoch wird dort noch ein weiterer Befehl benötigt, so das ich hier zunächst ein anderes Beispiel nehme.

Nicht nur die Fahrgeschäfte haben bekanntlich Licht, sondern auch der Fuhrpark, bzw. die Unterkünfte der Schausteller. Nichts wirkt langweiliger wie die Funktion alle Lichter an und aus zur selben Zeit...
Natürlich könnten wir mit den bisherigen Mitteln auch eine Reihenfolge und Zeitdauer selbst festlegen...

Nur wenn wir schon die Möglichkeit haben... warum nicht realistischer ;-) Steuern wir Einschaltzeitpunkt und Ausschaltzeitpunkt, und Reihenfolge doch einfach mal via Zufall ;-)


Als erstes Benötigen wir noch ein paar zusätzliche Variablen ZufallA und ZufallB dienen uns als Zwischenspeicher.
In dem neuen Array ledS[] werden wir zwischenspeicher ob das Licht aktuell aus (0) oder an(1) ist.
Code:
const int ledCount = 14;
long ZufallA;
long ZufallB;

int led[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int ledS[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};


Im Setup legen wir zunächst fest das zu Beginn alle LEDs aus sind.
Code:
void setup() {
for (int thisLed = 1; thisLed < ledCount; thisLed++) {
pinMode(led[thisLed], OUTPUT);
ledS[thisLed] = 0;
}
}

mit dem Befehl "random(min, max)" rufen wir einen Zufalls Wert auf der zwischen min und max-1 liegt.
Da der max Wert nur als max-1 verwendet wird, können wir für ZufallA einfach den Wert von ledCount übernehmen.

ZufallB verwende ich hier damit der Zeitabstand unregelmässig ist, in diesem Fall zwischen 200 und 499 Millisekunden.
Code:
void loop() {
ZufallA = random(1, ledCount);
ZufallB = random(200, 500);

Bevor wir wissen ob eine LED ein oder ausgeschaltet wird müssen prüfen wir ob die LED ein oder ausgeschaltet ist. Nach dem ein-/ausschalten speichern wir den aktuellen Status noch in dem Array ledS[].
Code:
if (ledS[ZufallA] == 0){
digitalWrite(led[ZufallA], HIGH);
ledS[ZufallA] = 1;
} else {
digitalWrite(led[ZufallA], LOW);
ledS[ZufallA] = 0;
}

delay(ZufallB);
}

Wie im wirklichen Leben, kommt jetzt nicht mehr jeder zur selben Zeit nach Hause und schaltet das Licht an ;-)


Hier nochmal der Code in einem Stück:
Code:
const int ledCount = 14;
long ZufallA;
long ZufallB;

int led[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int ledS[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

void setup() {
// loop over the pin array and set them all to output:
for (int thisLed = 1; thisLed < ledCount; thisLed++) {
pinMode(led[thisLed], OUTPUT);
ledS[thisLed] = 0;
}
}

void loop() {
ZufallA = random(1, ledCount);
ZufallB = random(2, 500);
if (ledS[ZufallA] == 0){
digitalWrite(led[ZufallA], HIGH);
ledS[ZufallA] = 1;
} else {
digitalWrite(led[ZufallA], LOW);
ledS[ZufallA] = 0;
}
ZufallB = ZufallB * 100;
}
 
So, es geht mal wieder weiter...

Heute trauen wir uns an das Dimmen von LEDs bzw Glühbirnen.

Das Arduino Uno Rev 3 Board das ich verwende hat 6 Kanäle (3, 5, 6, 9, 10 und 11) bei denen man Licht auch dimmen kann, hier bei handelt es sich dann um die Ausgänge die mit PWM bzw ~ Gekennzeichnet sind.

Programmtechnisch erfolgt die Dimmung über 256 Stufen von 0 bis 255.

Für dieses Beispiel habe ich eine kleine einfache Tag/Nacht Steuerung geschrieben. Ob diese sich soweit erweitern lässt, das damit tatsächlich auch Raumlicht und nicht nur ein kleines Diorama damit ausgeleuchtet werden kann, müssen die Elektroniker/Elektriker beantworten (vielleicht tut das ja einer ;-) )

Den Anfangscode, habe ich in diesem Fall etwas verändert, auch wenn man ihn ansonsten einfach übernehmen könnte.

Der pinMode Teil im void Setup bereich ist diesesmal nicht notwendig, daher legen wir die Kanäle direkt im Script fest.

Für das Morgen bzw. Abendrot benötigen wir eine Parabel. Den Multiplikator hierfür legen wir in der Variablen faktorRot ab. Da es sich um eine Kommazahl handelt verwenden wir anstatt int den typ float.

Außerdem werde ich zur Abwechslung das Delay nicht als Zahl eingeben sondern aus der Festgelegten Dauer in Minuten berechnen, warum und was für Forteile uns das bringt erkläre ich in einem späteren Tutorial ;-)

Code:
// Wir benötigen nur 3 Kanäle, daher können wir diesmal die Kanäle einfacher benennen.
int lichtBlau = 9;
int lichtRot = 10;
int lichtWeiss = 11;


// Die Dauer für Tag, Abend, Nacht und Morgen geben wir in Minuten in den Entsprechenden Variablen an.
int dauerTag = 14;
int dauerAbend = 1;
int dauerNacht = 14;
int dauerMorgen = 1;


void setup() {
// hier passiert heute nichts ;-)
}



void loop() {
// Hier berechnen wir den Faktor für die Parabel des Rotanteiles im Licht.
float faktorRot = 255 / (127.5 * 127.5);
faktorRot = 0 - faktorRot;


// Um die Minuten in Millisekunden umzurechnen, müssen wir das ganze mit 60.000 multiplizieren
int drTag = dauerTag * 60000;
int drNacht = dauerNacht * 60000;

// Damit die Dämmerung auch auf die 255 Schritte unterteilt wird wird für den Abend/Morgen
// der Wert zusätzlich durch 255 geteilt.
float HdrAbend = (dauerAbend * 60000) / 255;
float HdrMorgen = (dauerMorgen * 60000) / 255;
int drAbend = int(HdrAbend);
int drMorgen = int(HdrMorgen);



// ABEND: Für den Übergang zur Nacht erhöhen wir den Blauanteil und senken gleichzeitig den
// Weissanteil.
for (int wertB = 0; wertB < 256; wertB++){
int wertW = 255 - wertB;
int wertR = 0;

// Damit die Parabel sich auch bei etwa der Hälfte umkehrt müssen wir dies mit einer zusätzlichen
// if-Abfrage manuell regeln ;-)
if (wertB < 129){
int xW = 126 - wertB;
float wertRh = (faktorRot * (xW * xW)) + 255.5;
wertR = int(wertRh);
} else {
int xW = 126 - wertW;
float wertRh = (faktorRot * (xW * xW)) + 255.5;
wertR = int(wertRh);
}

// Hier das eigentlich neue: bisher haben wir digitalWrite verwendet, da sich damit aber nur zwei
// Zustände (ein oder aus) festlegen lassen, verwenden wir heute analogWrite. Hier können wir
// einen Wert von 0 (entspricht LOW) bis 255 (entspricht HIGH) angeben.
analogWrite(lichtBlau, wertB);
analogWrite(lichtRot, wertR);
analogWrite(lichtWeiss, wertW);
delay(drAbend);
}

// Um sicher zu stellen das auch wirklich bis 0 gerechnet wird deaktivieren wir den Rotanteil
// zusätzlich manuell.

analogWrite(lichtRot, 0);

// Die Nacht selbst geben wir einfach nur als delay an.
delay(drNacht);

// Der Morgen entspricht der selben Funktion wie der Tag, nur das wir jetzt den Blau-Anteil
// veringern und den Weiss-Anteil erhöhen.

for (int wertW = 0; wertW < 256; wertW++){
int wertB = 255 - wertW;
int wertR = 0;

if (wertW < 129){
int xW = 126 - wertW;
float wertRh = (faktorRot * (xW * xW)) + 255.5;
wertR = int(wertRh);
} else {
int xW = 126 - wertB;
float wertRh = (faktorRot * (xW * xW)) + 255.5;
wertR = int(wertRh);
}

analogWrite(lichtBlau, wertB);
analogWrite(lichtRot, wertR);
analogWrite(lichtWeiss, wertW);
delay(drMorgen);
}
analogWrite(lichtRot, 0);

// Der Tag ist wieder ein einfaches Delay
delay(drTag);
}
 
Hi,

du bist ein richtig guter Programmierer.

Kurze Frage: Mit dem Dimmen kann man doch auch Gleichstrommotoren langsam anlaufen lassen und dann

immer schneller oder?

Gruß Dominik
 
Im Prinzip ja, nur darfst du das ganze nicht direkt anschliessen, und dann bleibt noch die Frage...

Soll der Motor nur in eine Richtung oder in beide Richtungen laufen ;-)
 
Ein Motor hat auch einen höheren Anlaufstrom....Das kann man nicht so einfach aus dem Beleuchtungsbereich übernehmen....
 
Darum schrieb ich ja auch das dies nur im PRINZIP der Fall ist.

Programmtechnisch wird es tatsächlich so umgesetzt...

"ANGABE OHNE GEWÄHR DA ICH KEIN ELEKTRIKER/ELEKTRONIKER BIN":
Der Motor wird mit einer externen Spannungsquelle Grundversorgt und mittels eines Transistors oder Darlington-Schaltung angesteuert.
Eine Diode sollte zur Absicherung paralell zum Motor geschalten sein.

Via Pin wird dann die Basis angesteuert und GND vom Board und der Versorgungsspannung verbunden.

Wenn jetzt noch verschiedene Richtungen ins Spiel kommen... geht das am einfachsten mit einem 2fach Umschaltrelais... dessen Zuleitungen entsprechend den Motoranschluss erhalten. Und die Schaltpins über einen Seperaten Pin gesteuert werden... auch hier sollte wieder mit Dioden abgesichert werden.

Sollten die Bauteile noch vor meinem Finnlandurlaub eintreffen, werde ich das ganze eventuell noch bebildert vorstellen...

Auf jeden Fall zeige ich heute abend mal noch wie man einen Servo-Motor steuern kann...
 
So, wie versprochen gibt es heute noch eine kurze Anleitung wie man einen Servomotor steuern kann.

Zunächst schliesen wir den Servo an das Board an...

Das schwarze Kabel des Servos wird mit einem der GND-Ausgänge verbunden
Das rote Kabel verbinden wir mit dem +5V-Ausgang am Board.

Die Steuerleitung (je nach Modell weiß, gelb, orange) schliessen wir an PIN 9 an

Mit der Programmieroberfläche wird uns der wichtigste Baustein schon mitgeliefert...
die Servo-Bibliothek. Als erstes binden wir diese wie folgt ein:
Code:
#include

Als nächstes müssen wir ein Servo-Objekt anlegen und ihm den entsprechenden Pin, in unserem Fall 9 zuweisen. Außerdem benötigen wir noch eine variable in der wir die Position Abspeichern.
Code:
Servo myservo; 
int pos = 0;

void setup()
{
myservo.attach(9);
}


Das eigentliche Program ist wieder unsere Standart for-Schleife, geändert habe ich hier die Methode des addierens. pos += 1 entspricht der Funktion pos = pos + 1, natürlich könnten wir hier auch pos++ verwenden, nur mit diesem Beispiel können wir auch in anderen Schritten als 1 Arbeiten.

Das Program lässt den Servo zunächst langsam von der Ausgangsposition in 1° Schritten bis zur maximal-Position von 180° laufen, wartet dort 5 Sekunden und läuft schnell zurück.
Code:
void loop()
{
int x=1;
for(pos = 0; pos =0; pos-=1)
{							    
myservo.write(pos);
delay(10);
}

}

Wenn man sämtliche Sperren aus dem Servo entfernt, kann man mit diesen auch als "normalen" Motor benutzen und mittels der Servo Bibliothek steuern.
Wobei dann pos = 90 Stillstand und die Werte 91 - 180 bzw 89 - 0 die Geschwindigkeits-Stufen in die unterschiedlichen Richtungen darstellen.

Mein Versuch dieser Steuerung ist bisher daran gescheitert, das ich bisher das Potentiometer aus dem Servo noch nicht durch 2 gleich-Starke Widerständer ersetzt habe, so das eine theoretische 90° Position auf der internen Steuereinheit des Servos erzeugt wird.
 
Hallo ihr lieben!

Erstmal vielen DANK an Tarabas77 der das Thema hier sehr gut mit gestaltet!!

Das Ansteuern von Motoren ist mit dem Dimmen diereckt zu vergleichen! Zumindestens insofern, dass der Code übernommen werden kann. Dem Controller ist es egal was am Pin hängt. Jedoch muß elektronisch Verstärkt werden. Dies wird entweder mit einem Transistor erreicht (Immer eine Richtung) oder mit einer H-Brücke. (zwei Richtungen) Da ich mir die Verkabelung ersparen möchte kaufe ich die H-Brücke immer als IC.
Mein bevorzugtes IC ist das L293D. Es hat insgesamt 4 Kanäle. So können immer 2 Motoren angeschlossen werden. Je nach gewünschter Richtung (abhängig von der Verkabelung) muß dann ein Pin auf 0 gesetzt werden (analogWrite(pinX, 0); und der andere kann nun im Wert variieren(analogWrite(pinY, 0 bis 255).

Ein Beispiel folgt!!!

Beste Grüße und nochmals danke an Tarabas77!
Torsten
 
Schön, das Du auch wieder dabei bist...

Freut mich wenn du die H-Brücke via IC demonstrierst...

Dann zeige ich die Eigenbau "H-Brücke" wenn die Teile alle da sind ;-)

Schön wäre noch wenn Du zeigen könntest wie man den Atmel ohne Board anschliesen kann, das habe ich noch nicht so ganz kapiert... Wer möchte schon wegen einem 5 Euro - Bauteil immer gleich ein ganzes Board kaufen

Und nach Finnland (juhu nur noch heute Arbeiten dann geht es am Montag los) Zeig ich wie wir unser 13 Kanal-Lauflicht einfach und billig auf 32 Kanäle "pimpen" können - dann lassen sich bei dem Starkverkehr an Zugmaschinen auch komplexere Ampel-Anlagen einfach realisieren *ggg
 
Ihr zwei seit technisch äußert versiert.Mich fesselt dieses Thema!Viel Spaß in Finnland Liebe Grüße Tobias
 
Danke, werd ich hoffentlich haben... für die regnerischen Tage hab ich mir zur Sicherheit mal die alten Elektronik-Sammelordner von meinem Vater eingepackt...
 
Hallo zusammen,

da ich heute immernoch interessant das Thema verfolge, würde ich es gerne pushen, um noch mehr hilfreiche Tips zu bekommen.
Es wurde uns ja etwas versprochen, was mich auch sehr reizen würde ;)

Vielen Dank bisher an die sehr nützlichen Infos

LG
Aqua
 

Premium Mitglied

Keine Lust auf Werbung | Du möchtest das Forum unterstützen | Extra Banner .
Zurück
Oben