-         

Ergebnis 1 bis 4 von 4

Thema: Steuerung für Modellbahn-Beleuchtung und ähnliches

  1. #1

    Steuerung für Modellbahn-Beleuchtung und ähnliches

    Anzeige

    Hallo,

    ich habe eine modulare Steuerung für die Beleuchtung einer Häuser-Szenerie auf einer Modell-Eisenbahn-Anlage gebaut. Das ganze ist - finde zumindest ich - so gut geworden, dass ich es Euch gerne vorstellen würde. Vielleicht bringt es ja den ein oder anderen auf eine Idee.

    Herzstück des ganzen ist ein ATtiny Controller auf einem Digispark. Um an die I/O-Pins zu kommen, habe ich ihn auf eine kleine Platine gesetzt, die 4 I/O Pins und einen I2C-Bus über einzelne Stiftleisten heraus führt. Eine weitere Stiftleiste ist für den Anschluss der Versorgungsspannung. Damit man nicht immer erst überlegen muss, wo denn nun Plus und wo Minus hinkommt, habe ich dem ganzen auch gleich noch einen Gleichrichter als Schutz gegen Verpolung spendiert. Ein Spannungsregler ist ja auf dem Digispark-Board schon drauf:

    Klicke auf die Grafik für eine größere Ansicht

Name:	CPU_klein.jpg
Hits:	60
Größe:	44,3 KB
ID:	26981

    Über den I2C-Bus können dann weitere Platinen mit einem PCF8574 Portexpander angeschlossen werden. Um die Adresse einfach zu konfigurieren, haben die einen 3fach DIP-Schalter. Damit lassen sich also bis zu 8 dieser Platinen an den Bus hängen. Da jede Platine wiederum 8 Kanäle zur Verfügung stellt, können so bis zu 64 Ausgänge geschalten werden. Um kleinere Lasten direkt anschließen zu können, haben diese Platinen dann noch einen ULN2803 (mit entsprechenden Invertern davor, damit er im Ruhe-Zustand sperrt). Zusätzlich hat jede dieser Platinen eine eigenen Spannungsregeler um die max. 500 mA des Treiber Bausteins zur Verfügung stellen zu können.

    Klicke auf die Grafik für eine größere Ansicht

Name:	Interface-Treiber klein.jpg
Hits:	49
Größe:	47,6 KB
ID:	26982

    Die 5 Volt, die mit Hilfe des ULN geschaltet werden sind natürlich zu viel für eine LED. Deshalb habe ich eine kleine Adapter-Platine gebaut, die direkt auf die Pfostenleisten der Treiber-Platine gesteckt werden kann. Hierauf finden sich 8 Vorwiderstände und die entsprechenden Anschlüsse für die LED's.

    Klicke auf die Grafik für eine größere Ansicht

Name:	Widerstands-Interface klein.jpg
Hits:	46
Größe:	68,5 KB
ID:	26983

    Zusammen mit der Treiber-Platine sieht das dann so aus:

    Klicke auf die Grafik für eine größere Ansicht

Name:	Treiber mit Widerstands-Interface klein.jpg
Hits:	43
Größe:	51,7 KB
ID:	26984

    Durch die stapelbaren Leiterplattenverbinder lassen sich theoretisch auch mehrere dieser Adapter-Platinen übereinander stecken um unterschiedliche LED's anzuschließen.

    Alternativ habe ich mir überlegt, dass man ja vielleicht auch mal was anderes als LED's schalten will und habe eine 8fach Relais-Platine gebaut, die direkt vom ULN getrieben werden kann und mit der man bis zu 6 Ampere bei 30 Volt AC/DC schalten kann. Diese wird einfach an Stelle der LED-Adapter-Platine auf das Treiber-Modul gesteckt und fertig.
    Klicke auf die Grafik für eine größere Ansicht

Name:	006.JPG
Hits:	44
Größe:	91,7 KB
ID:	26985

    Hier noch ein einfacher Code, um die max. 64 Kanäle der bis zu 8 Treiber-Platinen per Zufalls-Steuerung ein und aus zu schalten:
    Code:
    // --------------------------------
    // Benötigte Bibliotheken einbinden
    // --------------------------------
    #include <TinyWireM.h>                  // I2C
     
    // ---------------------
    // Konstanten definieren
    // ---------------------
    #define adrModul1       0x20            // I2C-Adresse für erstes Treiber-Modul
    
    // ----------------------------
    // globale Variablen definieren
    // ----------------------------
    boolean channelBit [64];                // speichert den Schaltzustand der einzelnen Kanäle
    unsigned long channelMils [64];         // speichert den nächsten Umschaltzeitpunkt je Kanal
    
    // --------------------------------------------------------
    // Setup-Routine (wird automatisch beim Starten ausgeführt)
    // --------------------------------------------------------
    void setup(){
      int i;
      // I2C Schnittstelle initialisieren
      TinyWireM.begin();    
    
      // Zufallszahlen initialisieren
      for (i=0;i<64;i++){
        channelMils[i] =  millis() + random(40000);
        channelBit[i] = HIGH;
      }  
    }
    
    // ------------------------------------------------------------
    // Haupt-Routine (wird kontinuierlich als Schleife durchlaufen)
    // ------------------------------------------------------------
    void loop(){
      int i;
      int j;
      int out;
      
      // Zeiten auswerten
      for (i=0;i<64;i++){
        if (channelMils[i] < millis()){
         if (channelBit[i] == LOW){
          channelBit[i] = HIGH;
          channelMils[i] = millis() + random(60000);
         } else {
          channelBit[i] = LOW;
          channelMils[i] = millis() + random(40000);      
         } 
        }
      }  
      
      // einzelne Module durchgehen
      for (j=0; j<8; j++){
        // einzelne Bits durchgehen
        for (i=0; i<8; i++){
         bitWrite(out, i, channelBit[i+j*8]); 
        }
     
        // Byte an Modul übertragen
        writePort(adrModul1+j, out);   
      }
    }
    
    // -----------
    // I2C Routine
    // -----------
    void writePort(int address, byte data) {
      TinyWireM.beginTransmission(address);
      TinyWireM.send(data);
      TinyWireM.endTransmission();
      delay(5);
    }
    Geändert von cboden (21.12.2013 um 17:16 Uhr)

  2. #2
    Neuer Benutzer Öfters hier
    Registriert seit
    20.02.2014
    Beiträge
    20
    Gibt es das ganze auch für doofe (ohne ätzen und alles und vieleicht mit pc software mit der ich das gaze schalten kann)

  3. #3
    Neuer Benutzer Öfters hier
    Registriert seit
    30.10.2016
    Beiträge
    14
    Moin zusammen,
    ich habe mir vor einigen Wochen einen Sketch aus dem Netz gezogen und fand diesen auch ganz gut.
    Man benötigt nur einen Arduino nano und einige LEDs mit Vorwiederstand.

    Habe mir den Sketch heute noch einmal in aller Ruhe angeschaut und konnte dann auch gleich einiges ändern.
    PINs 3,5,6,10 haben die Aufgabe TVs zu simulieren.
    PINs 2,4,7,8,9,11,12,13 sind im an aus am Blinken.
    Es macht richtig Spass wenn das alles läuft.
    Hier mal der sketch:


    /* Simulation "belebtes Haus für die Modellbahn 8Lampen und 4TV*/
    /* Version "Flimmern nur wenn die Pin-13 LED an ist */
    byte pwmFlimmerPin1=3; // PWM Pin für das "analoge" Flimmern
    byte pwmFlimmerPin2=5; // PWM Pin für das "analoge" Flimmern
    byte pwmFlimmerPin3=6; // PWM Pin für das "analoge" Flimmern
    byte pwmFlimmerPin4=10; // PWM Pin für das "analoge" Flimmern
    unsigned long flimmerStart,flimmerEnd; // Anfangs- und Endzeiten für das Flimmern
    // LED Pins für das normale Blinken deklarieren
    byte leds[] ={ 2, 4, 7, 8, 9, 11, 12, 13};
    // LED Blinktakt in Millisekunden für diese Pins
    long ledtakt[]={22000, 30330, 26350, 42000, 50500, 60000, 10000, 72100}; // ein L hinter die Zahlenblöcke Zeitverlängern
    // Variablen zum Merken von millis()-Zeiten beim Schalten/Blinken
    unsigned long ledtime[sizeof(leds)];

    void setup() {
    // Serial.begin(9600);
    // hier werden die TV-PWMpins als Ausgang geschrieben
    pinMode(pwmFlimmerPin1, OUTPUT);
    pinMode(pwmFlimmerPin2, OUTPUT);
    pinMode(pwmFlimmerPin3, OUTPUT);
    pinMode(pwmFlimmerPin4, OUTPUT);
    for (int i=0;i<sizeof(leds);i++)
    {
    pinMode(leds[i], OUTPUT);
    ledtime[i]= -ledtakt[i]*9/12; // mit negativer Ablaufzeit initialisieren
    }
    }

    boolean milliSekundenTakt(long dauer, unsigned long &alterWert) {
    // Parameter "dauer": Dauer einer Blinkphase (an bzw. aus)
    // Parameter "alterWert": Variable zum Speichern des millis() Timers
    // Rückgabewert: true wenn die Zeit bis zum nächsten Umschalten abgelaufen ist, sonst false
    if (millis() - alterWert < dauer) return false;
    while (millis() - alterWert >= dauer) alterWert+=dauer;
    return true;
    }

    void blinkenImTakt() {

    // Alle gleichmäßig blinkenden LEDs in ihrem eigenen Takt blinken lassen
    for (int i=0;i<sizeof(leds);i++) // alle LEDs in einer Schleife durchgehen
    {
    if (milliSekundenTakt(ledtakt[i],ledtime[i])) // Takt für diese LED abgelaufen?
    {
    digitalWrite(leds[i],!digitalRead(leds[i])); // wenn ja ==> Umschalten
    if (leds[i]==13 && digitalRead(leds[i])) // Pin-13 LED wurde gerade eingeschaltet
    {
    flimmerStart=ledtime[i]+4000; // Anfangszeit für das Flimmern setzen
    flimmerEnd =ledtime[i]+ledtakt[i]-8000; // Endzeit für das Flimmern setzen
    }
    // Serial.print("Pin ");Serial.print(leds[i]);Serial.print(" = ");Serial.println(digitalRead(leds[i]));
    }
    }
    }


    void flimmernPwmPin1() {
    // Die flimmernde LED im Zufallsmodus flimmern lassen
    static unsigned long alterWert;
    static int flimmerDauer=200;
    static byte flimmerHelligkeit;
    if (milliSekundenTakt(flimmerDauer,alterWert)) // Takt abgelaufen?
    {
    flimmerDauer=1+random(200); // neue Flimmerdauer als Zufallswert
    if (millis()>flimmerStart && millis()<flimmerEnd)
    {
    flimmerHelligkeit=random(256); // neue Flimmerhelligkeit als Zufallswert
    // Serial.println(flimmerHelligkeit);
    }
    else
    flimmerHelligkeit=0; // Flimmern aus wenn falsche Zeit zum Flimmern
    analogWrite(pwmFlimmerPin1, flimmerHelligkeit);
    }
    }

    void flimmernPwmPin2() {
    // Die flimmernde LED im Zufallsmodus flimmern lassen
    static unsigned long alterWert;
    static int flimmerDauer=200;
    static byte flimmerHelligkeit;
    if (milliSekundenTakt(flimmerDauer,alterWert)) // Takt abgelaufen?
    {
    flimmerDauer=1+random(200); // neue Flimmerdauer als Zufallswert
    if (millis()>flimmerStart && millis()<flimmerEnd)
    {
    flimmerHelligkeit=random(256); // neue Flimmerhelligkeit als Zufallswert
    // Serial.println(flimmerHelligkeit);
    }
    else
    flimmerHelligkeit=0; // Flimmern aus wenn falsche Zeit zum Flimmern
    analogWrite(pwmFlimmerPin2, flimmerHelligkeit);
    }
    }

    void flimmernPwmPin3() {
    // Die flimmernde LED im Zufallsmodus flimmern lassen
    static unsigned long alterWert;
    static int flimmerDauer=200;
    static byte flimmerHelligkeit;
    if (milliSekundenTakt(flimmerDauer,alterWert)) // Takt abgelaufen?
    {
    flimmerDauer=1+random(200); // neue Flimmerdauer als Zufallswert
    if (millis()>flimmerStart && millis()<flimmerEnd)
    {
    flimmerHelligkeit=random(256); // neue Flimmerhelligkeit als Zufallswert
    // Serial.println(flimmerHelligkeit);
    }
    else
    flimmerHelligkeit=0; // Flimmern aus wenn falsche Zeit zum Flimmern
    analogWrite(pwmFlimmerPin3, flimmerHelligkeit);
    }
    }

    void flimmernPwmPin4() {
    // Die flimmernde LED im Zufallsmodus flimmern lassen
    static unsigned long alterWert;
    static int flimmerDauer=200;
    static byte flimmerHelligkeit;
    if (milliSekundenTakt(flimmerDauer,alterWert)) // Takt abgelaufen?
    {
    flimmerDauer=1+random(200); // neue Flimmerdauer als Zufallswert
    if (millis()>flimmerStart && millis()<flimmerEnd)
    {
    flimmerHelligkeit=random(256); // neue Flimmerhelligkeit als Zufallswert
    // Serial.println(flimmerHelligkeit);
    }
    else
    flimmerHelligkeit=0; // Flimmern aus wenn falsche Zeit zum Flimmern
    analogWrite(pwmFlimmerPin4, flimmerHelligkeit);
    }
    }

    void loop() {
    blinkenImTakt();
    flimmernPwmPin1();
    flimmernPwmPin2();
    flimmernPwmPin3();
    flimmernPwmPin4();
    }


    Bis bald Gruß,
    altenraucher
    Geändert von alterraucher (02.02.2017 um 19:17 Uhr)

  4. #4
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    05.11.2009
    Ort
    Gerblingerode
    Alter
    51
    Beiträge
    207
    hallo cboden

    saubere Arbeit =D>=D>=D>

    Den PCF8574 gibt es auch noch mit einem A und einem anderen Adressbereich,
    so könnte man 16 x 8 Pins ansteuern ...

    Dem I2C-Bus hätte ich aber je einen P82B96 gegönnt ... (http://www.nxp.com/documents/data_sheet/P82B96.pdf)

    ich habe mit diesem BUS-Treiber und 12V bereits Strecken von über 100m 2x2x0,6 mit 100kHz stabil zum laufen bekommen ...

    Der I2C-Bus(5V) ist eher für kurze Strecken (Gerät intern) gedacht ... längere Strecken kann funktionieren ...würde aber meine Hand nicht dafür ins Feuer legen ...
    Gruß Ralf ... Projekt-Beschreibungen www.greinert-dud.de ... "Alle sagten: Das geht nicht. Dann kam einer, der wusste das nicht und hat's gemacht."

Ähnliche Themen

  1. SRF02 oder ähnliches für den außenbereich
    Von KingTobi im Forum Suche bestimmtes Bauteil bzw. Empfehlung
    Antworten: 5
    Letzter Beitrag: 29.09.2009, 20:17
  2. Servo elktronik und ähnliches
    Von Devil im Forum Elektronik
    Antworten: 14
    Letzter Beitrag: 18.12.2007, 12:25
  3. Modellbahn-Steuerung mit DCC
    Von Der Papst im Forum C - Programmierung (GCC u.a.)
    Antworten: 1
    Letzter Beitrag: 12.03.2006, 13:49
  4. LDR oder Ähnliches für IR
    Von Spurius im Forum Sensoren / Sensorik
    Antworten: 6
    Letzter Beitrag: 27.07.2005, 16:23
  5. Roboterinformationen (Literatur und ähnliches)
    Von grind im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 1
    Letzter Beitrag: 22.09.2004, 14:12

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •