Freitag, 20. Dezember 2019

Arduino UNO R3 / ATtiny - Sketch für Faller 120120 Stellwerk

Faller H0 120120 - Stellwerk "Mittelstadt"

In meinem Post zum Faller Stellwerk 120120 Klick hier! habe ich das beleuchtete Stellpult gezeigt. Es werden diverse Weichenstellungen und Fahrstrassen simultan angezeigt. Die Steuerung der LED´s übernimmt ein ATtiny84, den ich mit dem Arduino UNO R3 programmiert habe. Eine Anleitung dazu habe ich hier gepostet: ATtiny 84 mit dem Arduino UNO R3 programmieren.

ATtiny84 Ports vs. SMD LED´s!


Die Schaltung habe ich auf eine Streifenrasterplatine aufgebaut. Zu sehen sind auf der Platinenoberseite der ATtiny84A, ein Spannungsregler 12V für die direkte Ansteuerung der SMD LED - Aussenlampe und der Spannungsregler 5V für die Spannungsversorgung des ATtiny84A und die daran angeschlossenen SMD LED´s. Auf der Platinenunterseite (nicht im Bild) befinden sich die benötigten SMD Widerstände. Damit die Ausleuchtung nicht so hell ist habe ich für die SMD LED´s 0604 Orange je 1kOhm und für die 0604 Warmweiß je 4,7kOhm verwendet.


Die Funktion zeige ich als kleines Video auf YouTube:


Nachfolgend veröffentliche ich den Sketch, gültig für den ATtiny 84A, programmiert mit dem Arduino UNO R3.
Anmerkung: Port 6 ist für die dimmbare Innenbeleuchtung (SMD LED´s)!

// ATtiny84 Stellwerk/Tableau
// Programming by https://meine-modelleisenbahn-digitalisiert.blogspot.com
// © 2019
//
// An dieser Stelle noch der Hinweis:
// der Nachbau geschieht auf eigene Gefahr.
// Ich übernehme keine Haftung für eventuell entstandene Schäden!
//

const byte InnenLED = 6; //LED für Innenbeleuchtung

int ledPins[8] = {10, 9, 8, 7, 2, 3, 5, 4};

int Stellwerkphasen[24][8] = {
  {1, 0, 0, 0, 0, 0, 1, 0}, // state 1   5000
  {1, 0, 1, 0, 0, 0, 1, 0}, // state 2   2000
  {1, 0, 1, 1, 0, 0, 1, 0}, // state 3   6000
  {0, 1, 1, 1, 0, 0, 1, 0}, // state 4   4000
  {0, 1, 1, 1, 1, 0, 1, 0}, // state 5   2000
  {0, 1, 1, 1, 1, 1, 1, 0}, // state 6   6000
  {0, 1, 1, 1, 1, 1, 0, 1}, // state 7   4000
  {0, 1, 0, 1, 1, 1, 0, 1}, // state 8   3000
  {0, 1, 0, 0, 1, 1, 0, 1}, // state 9   5000
  {0, 1, 0, 0, 1, 1, 1, 0}, // state 10  5000
  {0, 1, 0, 0, 0, 1, 1, 0}, // state 11  2500
  {0, 1, 0, 0, 0, 0, 1, 0}, // state 12  6000
  {0, 1, 0, 0, 0, 0, 0, 1}, // state 13  5000
  {0, 1, 0, 1, 0, 0, 0, 1}, // state 14  2000
  {0, 1, 1, 1, 0, 0, 0, 1}, // state 15  5000
  {1, 0, 1, 1, 0, 0, 0, 1}, // state 16  6000
  {1, 0, 1, 0, 0, 0, 0, 1}, // state 17  2000
  {1, 0, 0, 0, 0, 0, 0, 1}, // state 18  6000
  {0, 1, 0, 0, 0, 0, 0, 1}, // state 19  3000
  {0, 1, 0, 0, 1, 0, 0, 1}, // state 20  2500
  {0, 1, 0, 0, 1, 1, 0, 1}, // state 21  2500
  {0, 1, 0, 0, 1, 1, 1, 0}, // state 22  3000
  {0, 1, 0, 0, 0, 1, 1, 0}, // state 23  2000
  {0, 1, 0, 0, 0, 0, 1, 0}  // state 24  2000
};

int wartezeiten[24] = {5000, 2000, 6000, 4000, 2000, 6000, 4000, 3000, 5000, 5000, 2500, 6000, 5000, 2000, 5000, 6000, 2000, 6000, 3000, 2500, 2500, 3000, 2000, 2000};

int myState = 0;

void setup() {

pinMode(InnenLED, OUTPUT); //LED am Ausgang PB6 deklariert

  for (int i = 0; i < 8; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void zeigeStellwerkphase() {
  for (int i = 0; i < 24; i++) {
    digitalWrite(ledPins[i], Stellwerkphasen[myState][i]);
  }
  delay(wartezeiten[myState]);
}

void loop() {

analogWrite(InnenLED, 100); //gedimmte Innenbeleuchtung

  zeigeStellwerkphase();
  myState++;
  if (myState >= 24) myState = 0;
}

An dieser Stelle noch der Hinweis:
der Nachbau geschieht auf eigene Gefahr.
Ich übernehme keine Haftung für eventuell entstandene Schäden!


Mittwoch, 18. Dezember 2019

Faller 120120 Stellwerk "Mittelstadt" - mal ganz anders!

Nachdem ich mich in letzter Zeit viel mit dem Einbau von SMD LED´s in Modellautos beschäftigt habe, wollte ich zur Abwechslung mal wieder einen H0 Gebäudebausatz zusammenbauen. Als passendes Objekt fand ich den ungebauten Bausatz eines Stellwerkes von Faller in meinem Modellbahnsortiment.

Faller H0 120120 - Stellwerk "Mittelstadt"


Da das Endergebnis nicht ein "normales" Stellwerk sein sollte, begann ich im Vorfeld mir Gedanken über mögliche Verbesserungen zu machen. Als erstes musste am Gebäude die Kunststoffoberfläche nachbearbeitet werden, also patinieren. Ich wählte eine relativ einfache Methode:
- Revell Aqua Color Farbe verdünnt auf die Oberfläche streichen, nach kurzer Trockenzeit mit einem fusselfreien Tuch die Farbe oberflächlich wegwischen und voilá, in den Vertiefungen und leicht auf der Oberfläche war die Farbe noch vorhanden, so habe ich es gewollt. Vor dem Zusammenkleben sollte die Farbe komplett durchgetrocknet sein!

Sonntag, 1. Dezember 2019

ATtiny 84 mit dem Arduino UNO R3 programmieren

Der ATtiny45/85 reicht mit seinen fünf PIO für größere Projekte nicht immer aus, als Alternative nutze ich einen ATtiny84A-PU. Dieser stellt elf PIO zur Verfügung (P0 bis P7, P9 bis P10), P5 bis P8 unterstützen zusätzlich noch PWM (Pulse Width Modulation). Der ATtiny84 arbeitet wie sein Bruder ATiny85 mit einer Geschwindigkeit von 20Mhz, die Speichergröße ist 8kByte, der EEPROM und der RAM haben 512Byte.


ATtiny84A-20 PU - DIP-14!


Für die Programmierung benutze ich wie auch schon in meinem Post zum ATtiny85 Click here! beschrieben, einen Arduino UNO R3.


ELEGOO UNO R3, voll kompatibel zum Arduino UNO R3!

Der ATtiny84A wird am Arduino UNO R3 wie folgt angeschlossen:
(HINWEIS: es werden hier die Pins genannt. nicht die Ports!)

ATtiny84A - Pin: Arduino - Pin:
1 ==> VCC 5V
4 ==> 10
7 ==> 11
8 ==> 12
9 ==> 13
14 ==> GND

Zwischen den Arduino Pins "RESET" und "GND" ist noch ein ELKO 10uF/25V anzuschliessen. Der Kondensator sorgt dafür, dass der Arduino beim Upload nicht resettet.


Schematische Darstellung der Verdrahtung!


Montag, 11. November 2019

ATtiny 85 für Herpa H0 309554 - MB S Schörling Kehrfahrzeug kommunal

In meinem Post Herpa H0 309554 - MB S Schörling Kehrfahrzeug kommunal mit Beleuchtung zeige ich das Herpa H0 Kehrfahrzeug mit Beleuchtungseffekte, die über einen ATtiny 85 gesteuert werden.

Das Modell im Video auf meinem YouTube Kanal!


Die Elektronikbauteile habe ich auf ein Stück Streifenplatine aufgebaut. Neben dem 8pol. IC Sockel mit gesteckten ATtiny 85 befindet sich auf der Platine noch ein 5V Spannungsregler (LM7805), der den ATtiny mit Spannung versorgt. Des weiteren habe ich noch einen 12V Spannungsregler (LM7812) verbaut, der die SMD LED´s für die Scheinwerfer, die Rückleuchten und die Armaturenbeleuchtung direkt versorgt. Auf der Rückseite der Platine habe ich für jeden belegten Pin des ATtiny´s einen 670 Ohm SMD Widerstand (1206) gelötet, an denen die Anoden der SMD LED´s angeschlossen wurden. Am Output vom 12V Spannungsregler habe ich zwei 4,7 kOhm SMD Widerstände gelötet. An einen Widerstand habe ich die Anoden der SMD LED´s für Scheinwerfer und Armaturenbeleuchtung angeschlossen, an den anderen Widerstand die Anoden der SMD LED´s für die Rückleuchten. Die Kathoden der SMD-LED´s habe ich an die auf der Platine vorbereiteten GND Lötpunkte angeschlossen.

Platine - Vorderseite
Platine - Rückseite



Schaltplan ATtiny 85 Herpa Kehrfahrzeug!



Boardansicht ATtiny 85 Herpa Kehrfahrzeug!



Nachfolgend veröffentliche ich den Sketch, gültig für den ATtiny 85, programmiert mit dem Arduino UNO R3.

// ATtiny45 / ATtiny85 Strassenreinigungsfahrzeug
// 2 Rundumleuchten asynchron, LED Monitor, LED Innenraum gedimmt
// Programming by https://meine-modelleisenbahn-digitalisiert.blogspot.com
// © 2019
//
// An dieser Stelle noch der Hinweis:
// der Nachbau geschieht auf eigene Gefahr.
// Ich übernehme keine Haftung für eventuell entstandene Schäden!
//

static byte flimmerHelligkeit;
unsigned long blaustartMillis; //globale Variable für Rundumleuchte
unsigned long int currentMillis; // Merker fuer millis()
enum Phase1 {ON1, OFF1, ON2, OFF2, ON3, OFF3, ON4, OFF4 }; // "Namen" fuer die 
Phasen Rundumleuchte
int d1[] = {60, 60, 60, 150, 60, 60, 60, 150 }; // Dauer der Phasen in ms für 
Rundumleuchte
Phase1 phase1; // Enthaelt die aktuelle Phase Rundumleuchte

const byte blauLED01 = 3; //LED 1 für Rundumleuchte 1
const byte blauLED02 = 4; //LED 2 für Rundumleuchte 2
const byte flimmerLED = 0; //LED für Flimmerleuchte
const byte armaturLED = 1; //LED Armaturbeleuchtung

void setup()
{
  pinMode(blauLED01, OUTPUT); //LED am Ausgang PB2 deklariert
  pinMode(blauLED02, OUTPUT); //LED am Ausgang PB3 deklariert
  pinMode(flimmerLED, OUTPUT); //LED am Ausgang PB0 deklariert
  pinMode(armaturLED, OUTPUT); //LED am Ausgang PB1 deklariert
  blaustartMillis = millis(); //initialisiere Startzeit Rundumleuchte
  phase1 = ON1; //Phase Rundumleuchte Start ON1
  currentMillis = millis(); //Festlegung der aktuellen Zeit (aktuelle Millisekunden seit Programmstart)
}

bool milliSekundenTakt(int dauer, 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 loop()
{
  currentMillis = millis(); //Festlegung der aktuellen Zeit (aktuelle Millisekunden seit Programmstart)
  blau();
  flimmern();
  armatur();
}

void blau()
{ // Anfang Phase Rundumleuchte
  switch (phase1)
  {
    case ON1:
      if (millis() - blaustartMillis < d1[0])
      {
        digitalWrite(blauLED01, HIGH);
      }
      else
      {
        phase1 = OFF1;
      }
      break;

    case OFF1:
      if (millis() - blaustartMillis < d1[0] + d1[1])
      {
        digitalWrite(blauLED01, LOW);
      }
      else
      {
        phase1 = ON2;
      }
      break;

    case ON2:
      if (millis() - blaustartMillis < d1[0] + d1[1] + d1[2])
      {
        digitalWrite(blauLED01, HIGH);
      }
      else
      {
        phase1 = OFF2;
      }
      break;

    case OFF2:
      if (millis() - blaustartMillis < d1[0] + d1[1] + d1[2] + d1[3])
      {
        digitalWrite(blauLED01, LOW);
      }
      else
      {
        phase1 = ON3;
      }
      break;

    case ON3:
      if (millis() - blaustartMillis < d1[0] + d1[1] + d1[2] + d1[3] + d1[4])
      {
        digitalWrite(blauLED02, HIGH);
      }
      else
      {
        phase1 = OFF3;
      }
     break;

    case OFF3:
      if (millis() - blaustartMillis < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5])
      {
        digitalWrite(blauLED02, LOW);
      }
      else
      {
        phase1 = ON4;
      }
      break;

    case ON4:
      if (millis() - blaustartMillis < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6])
      {
        digitalWrite(blauLED02, HIGH);
      }
      else
      {
        phase1 = OFF4;
      }
      break;

    case OFF4:
      if (millis() - blaustartMillis < d1[0] + d1[1] + d1[2] + d1[3] + d1[4] + d1[5] + d1[6] + d1[7])
      {
        digitalWrite(blauLED02, LOW);
      }
      else
      {
        phase1 = ON1; blaustartMillis = millis();
      }
      break;
  }
}// Ende Phase Rundumleuchte

void flimmern()
{
  static long alterWert;
  static int flimmerDauer = 200;
  static byte flimmerHelligkeit;
  if (milliSekundenTakt(flimmerDauer, alterWert)) // Takt abgelaufen?
  {
    flimmerDauer = 1 + random(200); // neue Flimmerdauer als Zufallswert
    flimmerHelligkeit = random(3, 8); // neue Flimmerhelligkeit als Zufallswert 0-255
    // zwischen (xxx, xxx) oder von 0 bis (xxx)
    analogWrite(flimmerLED, flimmerHelligkeit);
  }
}

void armatur()
 {
  analogWrite(armaturLED, 3); //gedimmte Armaturenbeleuchtung
}

Weiterführende Links zur Programmierung des ATtinys 85 auf meinem Blog:


An dieser Stelle noch der Hinweis:
der Nachbau geschieht auf eigene Gefahr.
Ich übernehme keine Haftung für eventuell entstandene Schäden!

Sonntag, 10. November 2019

ATtiny 85 mit dem Arduino UNO R3 programmieren - die Software!

Nachdem die Hardware so wie in meinem Post
ATtiny 85 mit dem Arduino UNO R3 programmieren/flashen - die Hardware! beschrieben, vorbereitet wurde, kann mit dem programmieren/flashen der ATtiny-Familie begonnen werden. Die Software für den Arduino UNO R3 steht auf der Arduino-Homepage für Windows, Mac OS X und Linux zur Verfügung. Die aktuelle Version (Stand: 10.11.2019) ist die 1.8.10. Ich benutze die Mac OS X - Version, evtl. weicht die Darstellung zu den anderen Betriebssystemen ab.


Sonntag, 3. November 2019

ATtiny 85 mit dem Arduino UNO R3 programmieren - die Hardware!

Der Mikrocontroller ATtiny85 eignet sich besonders gut für kleine Beleuchtungseffekte im Modellbau. Er ist günstig zu erwerben und relativ leicht zu programmieren. Ein weiterer Pluspunkt ist der geringe Stromverbrauch und das kleine Format. Die Ports PB0 bis PB4 sind als digitale Ein-/Ausgänge nutzbar, PB0 und PB1 unterstützen zusätzlich noch PWM (Pulse Width Modulation). Die Ports PB2 bis PB4 können ebenfalls als analoge Eingänge verwendet werden. Der ATtiny85 arbeitet mit einer Geschwindigkeit von 20Mhz, die Speichergröße ist 8kByte, der EEPROM und der RAM haben 512Byte. Mit fünf Ausgängen kann man schon gute Lichteffekte erzielen. Beispielhaft möchte ich auf einen Post auf meinem Blog verweisen, hier setze ich einen ATtiny85 für die Beleuchtungseffekte in einem H0 Fahrzeug ein Click Here!

ATtiny85-20 PU - DIP-8!


Freitag, 1. November 2019

Herpa H0 309554 - MB S Schörling Kehrfahrzeug kommunal mit Beleuchtung

Nach der Sommerpause geht es weiter! Ich habe mich mit der Beleuchtung von Lkw´s in der Spurweite H0 weiter befasst und habe als nächstes Modell den Lkw
"Herpa 309554 H0 MERCEDES BENZ S Schörling Kehrfahrzeug kommunal"
mit SMD LED´s ausgestattet.
Für die Beleuchtung der beiden Rundumleuchten habe ich wie auch in meinen anderen Posts
z.B. Click here! schon beschrieben, von innen eingeklebt.


Modell mit SMD LED´s 0805 warmweiß für Scheinwerfer!



Modell mit SMD LED´s 0805 rot für Rückleuchten!



Detailansicht Scheinwerfer!



Detailansicht Rückleuchte!



Modell mit eingeschalteter Beleuchtung!




Als besonderes Gimmick habe ich dem Fahrzeug eine Armaturenbeleuchtung in blau und eine LED für den Monitor der Überwachungskamera spendiert.


Die Monitor - SMD LED 0402 weiß wird über einen Flimmereffekt angesteuert und erweckt dadurch den Anschein eines wechselnden Kamerabildes.


Die Kehrmaschine wird mit einer SMD LED 0805 weiß beleuchtet.



Die Lichtsteuerung übernimmt ein ATtiny85, den ich für die Lichteffekte entsprechend programmiert habe. Link zum Sketch, Schaltplan, Platinenlayout!



Das Modell im Video auf meinem YouTube Kanal!


Bezugsquelle für die verbauten SMD LED´s: Sabenne Modellbau


Weiterführtende Links:
ATtiny 85 mit dem Arduino UNO R3 programmieren/flashen - die Hardware!
ATtiny 85 mit dem Arduino UNO R3 programmieren/flashen - die Software!

An dieser Stelle noch der Hinweis:
der Nachbau geschieht auf eigene Gefahr.
Ich übernehme keine Haftung für eventuell entstandene Schäden!

Samstag, 7. September 2019

Wiking H0 - MAN 13.192 F Koffer Lkw - 500 Jahre Post

Passend zu dem Post Wiking H0 Unimog Kabelrollentransport habe ich ein weiteres Modell von Wiking mit LED Beleuchtung ausgestattet. Es handelt sich hier um einen MAN 13.192 F Koffer-Lkw mit dem Aufdruck "500 Jahre Post". Als kleines Gimmick habe ich in der Fahrerkabine eine blaue SMD LED eingesetzt.

Wiking H0 - MAN 13.192 Koffer Lkw mit SMD LED´s!



Detailansicht der verbauten SMD LED´s!



Modell mit eingeschalteten SMD LED´s!



Detailansicht der Fahrerkabinenbeleuchtung!


Für die Beleuchtung habe ich folgende LED-Typen verwendet:

  • Scheinwerfer - 0603 warmweiss
  • Rückleuchten - 0805 rot
  • Seitenbegrenzungsleuchten - 0603 gelb
  • Fahrerkabinenbeleuchtung - 0603 blau

Für die Anschlüsse der SMD LED´s setzte ich wie auch schon in meinen früheren Posts gezeigt, das Modul SM-FM von Sabenne Modelbau ein.

SM-FM - Fahrzeugmodul made by Sabenne Modellbau



Bezugsquelle für die verbauten SMD LED´s und dem Modul SM-EFM: Sabenne Modellbau


An dieser Stelle noch der Hinweis:
der Nachbau geschieht auf eigene Gefahr.
Ich übernehme keine Haftung für eventuell entstandene Schäden!

Sonntag, 2. Juni 2019

Wiking H0 88001218 - Lanz Bulldog gepimpt

The next one...

In meiner Bastelkiste habe ich noch ein weiteres Objekt für den Einbau vom SMD LED´s gefunden.
Dabei handelt es sich um den Trecker / Traktor Lanz Bulldog von Wiking in H0
(Art.-Nr. 88001218).


Wiking H0 88001218 - Lanz Bulldog mit SMD LED´s!


Scheinwerfer: SMD LED 0402 warmweiss!



Rücklichter: SMD LED 0603 rot!

Da für die Rücklichter am Modell kein Platz vorgesehen ist habe ich die SMD LED´s einfach am Rahmen aufgeklebt.


Wiking H0 88001218 - Lanz Bulldog mit Beleuchtung!



Detailansicht der SMD LED´s!



Für den Anschluß der SMD LED´s verwendete ich das Modul SM-FM3 von Sabenne Modellbau.




Bezugsquelle für die verbauten SMD LED´s und dem Modul SM-FM3: Sabenne Modellbau


An dieser Stelle noch der Hinweis:
der Nachbau geschieht auf eigene Gefahr.
Ich übernehme keine Haftung für eventuell entstandene Schäden!

Freitag, 31. Mai 2019

Herpa H0 093361 - Audi Q2 Notarzt mit Beleuchtung

The Show must go on...

In der Kategorie "Beleuchtung in H0 Cars & Trucks" ein weiteres Modell, das ich mit SMD LED´s aufgewertet habe.
Der Audi Q2 - Notarzt von Herpa in H0 eignet sich hervorragend für Beleuchtungseffekte, die mit dem Modul "SM-EFM" von Sabenne Modellbau gesteuert werden


Herpa H0 093361 - Audi Q2 Notarzt mit SMD LED´s!


Da hinter den Lichtkörpern nicht genug Platz ist, habe ich die Lichtkörper für die Scheinwerfer kurzerhand herausgenommen und stattdessen die SMD LED´s auf dem Träger geklebt. Am Kühlergrill befinden sich die zwei SMD LED´s für das Blitzlicht. Für die Rücklichter klebte ich die SMD LED´s auf den Lichtkörper, ist zwar gewöhnungsbedürftig aber funktionell .


Herpa H0 093361 - Audi Q2 Notarzt "im Einsatz"!


Für den Blaulichtbalken auf dem Dach habe ich wie auch schon in meinen älteren Posts, z.B.
Herpa H0 - Volvo Zugmaschine und Teletrailer-Auflieger 4A
oder
Herpa H0 - Man TGS M Euro 6 Rüstwagen RW2 Feuerwehr
beschrieben, die SMD - LED im Dach eingeklebt und von unten geschwärzt.


Für die Beleuchtung wurden folgende LED-Typen verwendet worden:

  • Scheinwerfer - 0805 weiss
  • Blitzleuchten - 0603 blau
  • Rückleuchten - 0603 rot
  • Warnlichtbalken - 0603 blau

Für die Lichteffekte setzte ich wie auch schon in meinen früheren Posts gezeigt, das Modul SM-EFM von Sabenne Modelbau ein.

SM-EFM - Einsatzfahrzeugmodul made by Sabenne Modellbau



Das Modell im Video auf meinem YouTube Kanal!


Bezugsquelle für die verbauten SMD LED´s und dem Modul SM-EFM: Sabenne Modellbau


An dieser Stelle noch der Hinweis:
der Nachbau geschieht auf eigene Gefahr.
Ich übernehme keine Haftung für eventuell entstandene Schäden!