Steuerung für Modellbahn-Beleuchtung und ähnliches

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:

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

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

Anhang 26983

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

Anhang 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.
Anhang 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);
}

---

Gibt es das ganze auch für doofe (ohne ätzen und alles und vieleicht mit pc software mit der ich das gaze schalten kann):confused:

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

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