Das erste Modul der RailFX-Serie ist das Jahrmarkt-Modul. Es handelt sich dabei um verschiedene Effekte, die man auf einem Jahrmarkt erwarten darf:

• Riesenrad
• Karussell
• Lauflicht
• Straßenbeleuchtung
• Stroboskop
• Soundmodul

Video – RailFX, Jahrmarkt-Modul

Wir benötigen Ihre Zustimmung um den Inhalt von YouTube laden zu können.

Mit dem Klick auf das Video werden durch den mit uns gemeinsam Verantwortlichen Youtube [Google Ireland Limited, Irland] das Video abgespielt, auf Ihrem Endgerät Skripte geladen, Cookies gespeichert und personenbezogene Daten erfasst. Damit kann Google Aktivitäten im Internet verfolgen und Werbung zielgruppengerecht ausspielen. Es erfolgt eine Datenübermittlung in die USA, diese verfügt über keinen EU-konformen Datenschutz. Weitere Informationen finden Sie hier.

Hier klicken um den Inhalt zu aktivieren.

Jmx0O2RpdiBjbGFzcz0mcXVvdDtudi1pZnJhbWUtZW1iZWQmcXVvdDsmZ3Q7Jmx0O2lmcmFtZSB0aXRsZT0mcXVvdDtSYXlsRlggSmFocm1hcmt0ICZuZGFzaDsgRWZmZWt0ZSBmJnV1bWw7ciBNb2RlbGxiYWhuIHVuZCBNb2RlbGxiYXUgbWl0IEFyZHVpbm8mcXVvdDsgd2lkdGg9JnF1b3Q7MTIwMCZxdW90OyBoZWlnaHQ9JnF1b3Q7Njc1JnF1b3Q7IHNyYz0mcXVvdDtodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9kcGJ2RjV3WHo5ND9mZWF0dXJlPW9lbWJlZCZxdW90OyBmcmFtZWJvcmRlcj0mcXVvdDswJnF1b3Q7IGFsbG93PSZxdW90O2FjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBjbGlwYm9hcmQtd3JpdGU7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmU7IHdlYi1zaGFyZSZxdW90OyBhbGxvd2Z1bGxzY3JlZW4mZ3Q7Jmx0Oy9pZnJhbWUmZ3Q7Jmx0Oy9kaXYmZ3Q7

Bauteile

Das hier sind die Komponenten, die ich verwendet habe:

• Arduino Nano*
• Breadboard und Kabel*
• Schrittmotore und Treiberplatine
• LEDs
• DFPlayer Mini MP3 Player Modul (Bitte nicht das ähnlich aussehende MP3-TP-16P Modul kaufen)
• MicroSD-Karte
• Lautsprecher
• 1x 1kOhm Widerstand

Schaltplan

Wie alle RailFX-Module benötigt auch das Jahrmarkt-Modul Verbindungen zum Control-Modul (Davon benötigt man nur ein einziges Modul im gesamten System!). Dabei handelt es sich um eine Verbindung aller A4 Pins (benutzt wird dieser Pin als digitaler Input 18) und eine Verbindung zur Stromversorgung (5V+ und GND).

Achtung: Am Pin A4 ist das Control-Signal des RailFX Control-Moduls angelegt. Es steuert die Tageszeit und ist zwingend erforderlich, um alle Module zu synchronisieren.

Bei dem Riesenrad und Karussell handelt es sich um zwei Schrittmotoren, die die Modelle der jeweiligen Fahrgeschäfte antreiben. Beide Schrittmotoren werden über jeweils einen Schrittmotortreiber gesteuert.

Die LEDs für die Lauflichter, die Straßenbeleuchtung und das Stroboskop sind jeweils über einen Vorwiderstand an digitale Arduino Pins angeschlossen. Der Widerstand begrenz den Stromfluss. Wenn man mehr LEDs benötigt, kann man diese einfach nach dem Vorwiderstand parallel schalten. Sie leuchten dann alle weniger hell. Sicherlich gibt es ein Maximum an LEDs, die man so verschalten kann. Eine genaue Zahl kenne ich nicht. Hier empfehle ich, das einfach auszuprobieren.

Wenn man viel mehr LEDs benötigt, sollte man die Kanäle verstärken. Das kann man z.B. mit einem ULN2803A Darlington-Transistor-Array erreichen.

Für die Tonausgabe wird der DFPlayer Mini verwendet. Er spielt MP3- und WAV-Dateien von einer SD-Karte ab. Für die Nutzung muss die DFPlayer Mini Bibliothek eingebunden werden. Klicke dafür im Arduino-Menü auf Sketch>Bibliotheken einbinden>Bibliotheken verwalten und gib im Suchfeld »dfplayer mini« ein. Installiere die Bibliothek DFPlayer Mini MP3 by Makuna in der aktuellen Version.

Die SD-Karte muss im FAT16 oder FAT32-Dateisystem formatiert sein. Darüber hinaus müssen sich die Dateien im Ordner »01« befinden und die Dateinamen müssen aufeinander folgend 001.mp3, 002.mp3, 003.mp3 usw. benannt sein. Wie erwähnt, dürfen auch WAV-Dateien verwendet werden: 001.mp3, 002.wav, 003.mp3 …

Da die Schrittmotoren einiges an Energie benötigen und das mit unter den DFPlayer stört, kann man einen Stützkondensator (100uF) in die Stromschienen nahe der Treiberplatinen stecken.

Ein paar Beispieldateien kann man hier herunterladen.

Einstellungen im Code

int lauflichtTimeout = 100;              // Lauflicht Geschwindigkeit (ms)
int strobeFlashTimeout = 100;            // Stroboskop Impulsdauer (ms)
int strobePauseTimeout = 1000;           // Stroboskop Pausendauer (ms)
int riesenradPauseTimeout = 3;           // Riesenrad Pausendauer (s)
int karussellPauseTimeout = 2;           // Karussell Pausendauer (s)
int strassenlampenTimeout = 100;         // Einschaltzeit der Straßenlampen (ms)
int lautstaerke = 10;                    // Lautstärke des DFPlayers (0 – 30);

int mp3Anzahl = 7;                       // Menge der MP3-Dateien auf der SD-Karte
int mp3Dauer[] = {28, 9, 20, 2, 4, 17, 23}; // Dauer der MP3-Dateien in Sekunden
int mp3Wahrscheinlichkeit = 10;          // Wahrscheinlichkeit, mit der MP3s abgespielt werden, 10 oft, 100 selten

Im Code lassen sich unterschiedliche Einstellungen treffen:

• Lauflicht Geschwindigkeit in Millisekunden
• Stroboskop Impulsdauer in Millisekunden
• Stroboskop Pausendauer in Millisekunden
• Riesenrad Pausendauer in Sekunden
• Karussell Pausendauer in Sekunden
• Einschaltzeit der Straßenlampen in Millisekunden
• Lautstärke des DFPlayers (0 – 30);
• Menge der MP3-Dateien auf der SD-Karte
• Dauer der MP3-Dateien in Sekunden (kann kürzer als die MP3s sein)
• Wahrscheinlichkeit, mit der MP3s abgespielt werden: 10 oft, 100 selten

Gesamter Programm-Code

/*
     Rail-FX Jahrmarkt-Modul
     StartHardware.org

     Permalink: https://starthardware.org/railfx-jahrmarkt-modul/
*/

#include <CheapStepper.h>
#include "SoftwareSerial.h"              // Wird für den DFPlayer benötigt
#include "DFRobotDFPlayerMini.h"         // Wird für den DFPlayer benötigt

/* ***** ***** Einstellungen ***** ***** ***** *****  ***** ***** ***** *****  ***** ***** ***** ***** */

int meineAdresse = 2;                    // muss im System einzigartig sein! Darf es also nur einmal geben.

int lauflichtTimeout = 100;              // Lauflicht Geschwindigkeit (ms)
int strobeFlashTimeout = 100;            // Stroboskop Impulsdauer (ms)
int strobePauseTimeout = 1000;           // Stroboskop Pausendauer (ms)
int riesenradPauseTimeout = 3;           // Riesenrad Pausendauer (s)
int karussellPauseTimeout = 2;           // Karussell Pausendauer (s)
int strassenlampenTimeout = 100;         // Einschaltzeit der Straßenlampen (ms)
int lautstaerke = 10;                    // Lautstärke des DFPlayers (0 – 30);

int mp3Anzahl = 7;                       // Menge der MP3 Dateien auf der SD-Karte
int mp3Dauer[] = {28, 9, 20, 2, 4, 17, 23}; // Dauer der MP3 Dateien in Sekunden
int mp3Wahrscheinlichkeit = 10;          // Wahrscheinlichkeit, mit der MP3s abgespielt werden, 10 oft, 100 selten

/* ***** ***** Ab hier beginnt der Programmcode, der nicht angepasst werden muss ***** ***** ***** ***** */

int strassenlampenPin = 9;              // an diesem Pin sind die Straßenlampen angeschlossen
int lauflicht1Pin = 8;                  // an diesem Pin sind die Lauflicht A Lampen 2 angeschlossen
int lauflicht2Pin = 7;                  // an diesem Pin sind die Lauflicht A Lampen 3 angeschlossen
int lauflicht3Pin = 6;                  // an diesem Pin sind die Lauflicht B Lampen 1 angeschlossen
int lauflicht4Pin = 5;                  // an diesem Pin sind die Lauflicht B Lampen 2 angeschlossen
int strobePin = 4;                      // an diesem Pin ist ein Stroboskop (weiße LED?) angeschlossen

//int motorPins1[4] = {10, 11, 12, 13};    // Pins des Stepper-Motors 1
//int motorPins2[4] = {14, 15, 16, 17};    // Pins des Stepper-Motors 2

/* Speicher-Variablen */
int lauflichtPosition = 0;              // speichert die Position des Lauflichts A
int strassenlampenHelligkeit = 0;       // speichert, wie hell die Straßenlampen leuchten

/* Timer Variablen */
long strassenlampenTimer = 0;            // Timer der Straßenlampen
long lauflichtTimer = 0;                 // Timer Lauflicht
long strobeTimer = 0;                    // Timer des Stroboskop
long riesenradTimer = 0;                 // Timer des Risenrads
long karussellTimer = 0;                 // Timer des Karussells
long soundTimer = 0;                     // Timer des DFPlayers
long soundTimeout = 0;                   // Speichert die Abspieldauer des aktuellen MP3
long moveStartTime1 = 0; // this will save the time (millis()) when we started each new move
long moveStartTime2 = 0; // this will save the time (millis()) when we started each new move

/* State Variablen */
int myState = 3;                         // Status der Haupt-Statemachine, startet bei 3, da hier alles abgeschaltet ist
int riesenradState = 0;                  // Status des Riesenrads
int karussellState = 0;                  // Status des Karussell
int strobeState = 0;                     // Status des Stroboskops
int soundState = 0;                      // Status des DFPlayers
bool moveClockwise21 = true;
bool moveClockwise22 = true;
int stepsLeft1 = 0;
int stepsLeft2 = 0;

int soundRandom;
int theSound;
int soundPlaying = false;

bool moveClockwise1 = true;
bool moveClockwise2 = true;

String stateName;

/* Variablen vom Controlmodul um die Uhrzeit festzustellen*/
boolean receive = false;
boolean receiveStarted = false;
int receiveTimeout = 10;
long receiveTimer = 0;
int receivedTime = 0;
int receivePulse = 0;
int lastReceivePulse = 0;
int receivePin = 18;
int myTime = 0;

/* Objekte anlegen */
SoftwareSerial mySoftwareSerial(3, 2);   // RX, TX für den DFPlayer
DFRobotDFPlayerMini myDFPlayer;          // DFPlayer Objekt

CheapStepper stepper1 (14, 15, 16, 17);  // Erstellen eines Stepperobjekts für das Risenrad
CheapStepper stepper2 (10, 11, 12, 13);  // Erstellen eines Stepperobjekts für das Karussell

#define PAYLOAD_SIZE 2                   // nötig für die Kommunikation zum Master
int uhrzeit = 0;                         // speichert die uhrzeit vom Master-Modul (0 und 255)
byte nodePayload[PAYLOAD_SIZE];          // speichert die Daten vom Master-Modul zwischen

void setup() {
  mySoftwareSerial.begin(9600);          // started die serielle Kommunikation für den DFPlayer
  Serial.begin(115200);                  // started die serielle Kommunikation
  
  pinMode(receivePin, INPUT);            // Empfangspin vom Control-Modul
  pinMode(lauflicht1Pin, OUTPUT);        // Lauflicht als Output festlegen
  pinMode(lauflicht2Pin, OUTPUT);        // Lauflicht als Output festlegen
  pinMode(lauflicht3Pin, OUTPUT);        // Lauflicht als Output festlegen
  pinMode(lauflicht4Pin, OUTPUT);        // Lauflicht als Output festlegen
  pinMode(strobePin, OUTPUT);            // Strobe als Output festlegen
  lauflichtAus();
  strobeAus();
  strassenlampenAus();
  stepper1.setRpm(16);
  stepper2.setRpm(12);

  randomSeed(19);

  /* DFPlayer Setup */
  Serial.println(F("Initializing DFPlayer ... "));
  if (!myDFPlayer.begin(mySoftwareSerial,false,true)) {  // nutze softwareSerial um mit dem DFPlayer zu sprechen 
    Serial.println(F("Fehler: Prüfe Verbindung zum DFPlayer und SD-Karte"));
    while (true) {
      delay(0); // Code to compatible with ESP8266 watch dog.
    }
  }
  Serial.println(F("DFPlayer Mini online."));
  myDFPlayer.volume(lautstaerke);       // Lautstärke wird zugewiesen
  delay(500);
}

void loop() {

  receiveFunction();              // Führe Anweisungen für Empfang aus
  if (receiveStarted == false) {
    if (myTime > 22) {              // ***** Später Abend *****
      strassenlampenAn();           // Straßenlampen an
      lauflichtAn();                // Lauflicht an
      strobeAn();                   // Stroboskop an
      soundAn();                    // Sound An
      riesenradmotorAn();           // Risenradmotor an
      karussellmotorAn();           // Karussellmotor an
    } else if (myTime > 18) {       // ***** Abend *****
      strassenlampenAn();          // Straßenlampen an
      lauflichtAn();               // Lauflicht an
      strobeAn();                  // Stroboskop an
      soundAn();                   // Sound An
      riesenradmotorAn();          // Risenradmotor an
      karussellmotorAn();          // Karussellmotor an
    } else if (myTime > 12) {       // ***** Nachmittag *****
      strassenlampenAus();          // Straßenlampen aus
      lauflichtAus();               // Lauflicht aus
      strobeAus();                  // Stroboskop aus
      soundAus();                   // Sound aus
      riesenradmotorAn();           // Risenradmotor an
      karussellmotorAus();          // Karussellmotor aus

    } else if (myTime > 9) {        // ***** Vormittag *****
      strassenlampenAus();          // Straßenlampen aus
      lauflichtAus();               // Lauflicht aus
      strobeAus();                  // Stroboskop aus
      soundAus();                   // Sound aus
      riesenradmotorAus();          // Risenradmotor aus
      karussellmotorAus();          // Karussellmotor aus

    } else if (myTime > 7) {        // ***** Morgen *****
      strassenlampenAus();           // Straßenlampen an
      lauflichtAus();               // Lauflicht aus
      strobeAus();                  // Stroboskop aus
      soundAus();                   // Sound aus
      riesenradmotorAus();          // Risenradmotor aus
      karussellmotorAus();          // Karussellmotor aus

    } else {                        // ***** Nacht *****
      strassenlampenAn();           // Straßenlampen an
      lauflichtAus();                // Lauflicht aus
      strobeAus();                  // Stroboskop aus
      soundAus();                   // Sound aus
      riesenradmotorAus();          // Risenradmotor aus
      karussellmotorAus();          // Karussellmotor aus
    }
  }
}

void strassenlampenAn() {
  if (strassenlampenTimer + strassenlampenTimeout < millis()) {
    strassenlampenHelligkeit++;
    if (strassenlampenHelligkeit > 255) strassenlampenHelligkeit = 255;
    strassenlampenTimer = millis();
    analogWrite(strassenlampenPin, 255-strassenlampenHelligkeit);
  }
}

void strassenlampenAus() {
  strassenlampenHelligkeit = 0;
  analogWrite(strassenlampenPin, 255);
  strassenlampenTimer = millis();
}

void lauflichtAn() {
  if (lauflichtTimer + lauflichtTimeout < millis()) {
    lauflichtTimer = millis();
    lauflichtPosition++;
    if (lauflichtPosition > 3) {
      lauflichtPosition = 0;
    }
    if (lauflichtPosition == 0) {
      digitalWrite(lauflicht1Pin, HIGH);
      digitalWrite(lauflicht2Pin, HIGH);
      digitalWrite(lauflicht3Pin, HIGH);
      digitalWrite(lauflicht4Pin, LOW);
    } else if (lauflichtPosition == 1) {
      digitalWrite(lauflicht1Pin, HIGH);
      digitalWrite(lauflicht2Pin, HIGH);
      digitalWrite(lauflicht3Pin, LOW);
      digitalWrite(lauflicht4Pin, HIGH);
    } else if (lauflichtPosition == 2) {
      digitalWrite(lauflicht1Pin, HIGH);
      digitalWrite(lauflicht2Pin, LOW);
      digitalWrite(lauflicht3Pin, HIGH);
      digitalWrite(lauflicht4Pin, HIGH);
    } else if (lauflichtPosition == 3) {
      digitalWrite(lauflicht1Pin, LOW);
      digitalWrite(lauflicht2Pin, HIGH);
      digitalWrite(lauflicht3Pin, HIGH);
      digitalWrite(lauflicht4Pin, HIGH);
    }
  }
}

void lauflichtAus() {
  lauflichtTimer = millis();
  digitalWrite(lauflicht1Pin, HIGH);
  digitalWrite(lauflicht2Pin, HIGH);
  digitalWrite(lauflicht3Pin, HIGH);
  digitalWrite(lauflicht4Pin, HIGH);
}

void strobeAn() {
  switch (strobeState) {
    case 0:
      digitalWrite(strobePin, LOW);
      if (strobeTimer + strobeFlashTimeout < millis()) {
        strobeTimer = millis();
        strobeState = 1;
      }
      break;
    case 1:
      digitalWrite(strobePin, HIGH);
      if (strobeTimer + strobePauseTimeout < millis()) {
        strobeState = 0;
        strobeTimer = millis();
      }
      break;
  }
}

void strobeAus() {
  digitalWrite(strobePin, HIGH);
  strobeTimer = millis();
}

void riesenradmotorAn() {
  stepper1.run();

  switch (riesenradState) {
    case 0: // fahren
      stepsLeft1 = stepper1.getStepsLeft();
      if (stepsLeft1 == 0) {
        moveClockwise1 = !moveClockwise1;
        if (random(3) <= 1) {
          riesenradState = 1;
          riesenradTimer = millis();
        } else {
          stepper1.newMoveDegrees (moveClockwise1, 360 + random(360));
        }
      }
      break;
    case 1: // pause
      if (riesenradTimer + (riesenradPauseTimeout * 1000) < millis()) {
        riesenradState = 0;
      }
      break;
  }
}

void riesenradmotorAus() {
  /*stepsLeft1 = stepper1.getStepsLeft();
    if (stepsLeft1>0) stepper1.stop();*/
}

void karussellmotorAn() {
  stepper2.run();
  switch (karussellState) {
    case 0: // fahren
      stepsLeft2 = stepper2.getStepsLeft();
      if (stepsLeft2 == 0) {
        moveClockwise2 = !moveClockwise2;
        if (random(5) <= 1) {
          karussellState = 1;
          karussellTimer = millis();
        } else {
          stepper2.newMoveDegrees (moveClockwise2, 90 + random(360));
        }
      }
      break;
    case 1: // pause
      if (karussellTimer + (karussellPauseTimeout * 1000) < millis()) {
        karussellState = 0;
      }
      break;
  }
}

void karussellmotorAus() {
  /*stepsLeft2 = stepper2.getStepsLeft();
    if (stepsLeft2>0) stepper2.stop();*/
}

void soundAn() {
  switch (soundState) {
    case 0:
      Serial.println("soundTimer 0");
      soundRandom = random(mp3Wahrscheinlichkeit);
      if (soundRandom < 1) {
        soundState = 1;
        theSound = random(mp3Anzahl) + 1;
        soundTimer = millis();
        soundTimeout = mp3Dauer[theSound - 1] * 1000;
        Serial.print("Playsound: \t\t\t"); Serial.print(theSound); Serial.print("\t\t\t"); Serial.println(soundTimeout);
        myDFPlayer.playFolder(1, theSound); //play specific mp3 in SD:/15/004.mp3; Folder Name(1~99); File Name(1~255)
        soundPlaying = true;
      } else {
        soundTimer = millis();
        soundTimeout = 500;
        soundState = 1;
      }
      break;
    case 1:
      if (soundTimer + soundTimeout < millis()) {
        soundPlaying = false;
        soundState = 0;
      }
      break;
  }
}

void soundAus() {
  if (soundPlaying == true) {
    Serial.println(soundPlaying);
    myDFPlayer.pause();
    soundPlaying = false;
  }
}

void printDetail(uint8_t type, int value) {     // DF Player Fehlermeldungen
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      break;
    case DFPlayerUSBInserted:
      Serial.println("USB Inserted!");
      break;
    case DFPlayerUSBRemoved:
      Serial.println("USB Removed!");
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
}

void receiveFunction() {                      // Empfängt die Uhrzeit vom Control-Modul
  receivePulse = digitalRead(receivePin);     // Lies den Empfangspin aus
  
  if ((receiveTimer + receiveTimeout < millis()) && (receiveStarted == true)) {
    // Bei Timeout und aktivem Empfang
    receiveStarted = false;                   // beende aktiven Empfang
    myTime = receivedTime - 1;                // speichere die empfangene Zeit
    receivedTime = 0;                         // setze die Hilfsvariable zum Zeitempfang zurück
    Serial.println(myTime);                   // serielle Ausgabe
  }
  // falls ein Puls am Empfangspin erfasst wird, der vorher nicht da war
  if ((receivePulse == 0) && (lastReceivePulse == 1)) {
    receiveTimer = millis();                  // starte Timer neu
    if (receiveStarted == false) receiveStarted = true;  // starte aktiven Empfang, wenn noch nicht geschehen
    receivedTime++;                           // es gab einen Puls, also erhöhe die Hilfsvariable zum Zeitempfang
  }
  lastReceivePulse = receivePulse;            // aktuellen Zustand am Pin für nächsten Durchlauf merken
}

---

Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!

• Die beliebtesten Arduino-Projekte von StartHardware
• Inklusive Schaltplan, Beschreibung und Code
• Arduino-Schnellstart-Kapitel
• Kompakter Programmierkurs

Jetzt ansehen!

---