PROJECT PAGE

Sun City G-Scale Railroad Crossing

A complete, Arduino-driven railroad crossing package: IR detection, alternating LEDs, dual servos, and a looping crossing bell sound — designed, documented, and taught as a live workshop for the Sun City model railroad club.

Arduino UNO R4 WiFi G-Scale model railroad IR sensor → LEDs → Servos → MP3 Workshop + printed guide

⬅ Back 📁 Projects 🏠 Home

Snapshot Parts Journey Build & Demo Wiring & Hardware The Sketch After the Workshop

Project Snapshot

The goal: build a reliable, repeatable railroad crossing for a G-scale layout that felt like a real piece of infrastructure — and use it as the centerpiece for a hands-on class.

Trigger: Infrared sensor watching the track.
Effects: Alternating LEDs, two synchronized servos, and a crossing bell loop.
Audience: Sun City model railroad club members, most new to Arduino.
Deliverables: Working hardware, final sketch, wiring diagram, and printed guide.

This page is the portfolio view: the journey, design choices, and finished package. The full step-by-step teaching guide lives with the club materials in Sun City.

Role & Responsibilities

Hardware design & prototyping (sensors, LEDs, servos, MP3).
Arduino firmware: detection logic, timing, animation, and MP3 control.
Wiring diagram & documentation for non-technical builders.
Delivered live demo: laptop setup → code upload → crossing in action.

Exact Parts Used in the Final Build

This is the hardware that went into the final Sun City demo crossing — the exact stack that drove the IR detection, lights, gates, and sound.

Control & Sensing

1 × Arduino UNO R4 WiFi (5 V, main controller)
1 × IR sensor module (3-pin, digital output, active-LOW)

Indicators & Motion

4 × 5 mm red LEDs for the crossing signals
4 × 220 Ω resistors (LED current limiting)
2 × hobby servos for the crossing arms

Audio Path

1 × serial MP3 player module (microSD-based)
1 × microSD card with 001.mp3 crossing bell sound
1 × small 8 Ω speaker
1 × 1 kΩ resistor in series with Arduino TX → MP3 RX

Power & Prototyping

1 × solderless breadboard for the demo build
Jumper wires (male–male and male–female)
5 V USB power for the Arduino
Optional: separate 5 V rail for servos if using higher-torque motors

For the class handout, these parts were summarized into a printable list along with the wiring diagram so anyone could rebuild the crossing from scratch.

The Journey: From Idea to Workshop

The first requirement was simple on paper: “When the train goes by, make the lights flash and the gates go down.” In practice, it became a small systems project involving sensing, motion, sound, power, and a friendly tuning experience for the club.

Proof of concept. Started with a hall (magnetic) sensor test just to prove out the idea of the Arduino reacting to the train.
Settling on IR. Moved to an IR sensor for more stable detection on the actual track.
Adding personality. LEDs began alternating, servos were tuned, and the crossing got a voice via a small serial MP3 module.
Packaging for teaching. Locked down pin mapping, created a clean wiring diagram, and wrote a sketch with a few clearly-labeled constants so the class could safely “play.”
Live day in Sun City. Installed the Arduino IDE on a fresh laptop, uploaded the final sketch in front of the group, and assembled hardware on new Arduino. Modified LED speed and gate timing and re-uploaded to see results.

What started as a simple toy crossing ended up as a small but complete embedded system with a story, documentation, and a room full of people watching it come to life.

Build & Demo Videos

These clips capture how the project evolved — from a bare proof-of-concept on the bench to a full G-scale crossing with sound on the layout.

1. Proof of concept — Hall sensor

2. IR sensor version

3. IR + sound module

4. Full G-scale demo with train & sound

Wiring & Hardware Layout

The final wiring diagram became the core of the handout. It ties together the IR sensor on D2, LEDs and resistors on D3/D4 and D6/D7, servos on D5 and D8, and the serial MP3 board on D10/D11 with a 1 kΩ resistor on the Arduino TX line.

During the workshop, this diagram was projected and printed so builders could trace every connection without feeling lost in the jumper wire jungle.

Click the diagram to zoom in.

Final wiring diagram for the G-scale railroad crossing project

The Sketch — Final Version

The firmware is intentionally straightforward: a small state machine handling three phases (idle, active, returning up), plus a simple servo animator and a few MP3 helper functions. The class could safely experiment by changing only the constants at the top.

Copy/paste directly into the Arduino IDE (UNO R4 WiFi selected) and upload.

/*
  G-Scale RR Crossing (UNO R4 WiFi) 
  Purpose: IR on D2 triggers bell + alternating LEDs + both gates DOWN; after hold, gates return UP.

  Pins
  - IR: D2 (active-LOW)
  - Crossing A: LEDs D3/D4 (each LED anode → 220Ω), Servo D5
  - Crossing B: LEDs D6/D7 (each LED anode → 220Ω), Servo D8
  - MP3: D10 = Arduino RX (from MP3 TX), D11 = Arduino TX → 1kΩ → MP3 RX

  Tunables
  - HOLD_AFTER_DETECT_MS (gate stay-down time), LED_BLINK_MS (smaller = faster),
    SERVO_UP_ANGLE (home), SERVO_DELTA_DOWN (+45° = DOWN).

*/


#include <Arduino.h>
#include <Servo.h>
#include <SoftwareSerial.h>

// ---- Pins ----
const uint8_t PIN_IR = 2;

const uint8_t PIN_MP3_RX = 10;  // Arduino RX  <- MP3 TX
const uint8_t PIN_MP3_TX = 11;  // Arduino TX  -> MP3 RX (series ~1kΩ)

const uint8_t PIN_A_LED_L = 3;  //LED Anode (series 220Ω)
const uint8_t PIN_A_LED_R = 4;  //LED Anode (series 220Ω)
const uint8_t PIN_A_SERVO = 5;

const uint8_t PIN_B_LED_L = 6;  //LED Anode (series 220Ω)
const uint8_t PIN_B_LED_R = 7;  //LED Anode (series 220Ω)
const uint8_t PIN_B_SERVO = 8;

// ---- Tunables ----
const uint16_t HOLD_AFTER_DETECT_MS = 2500;
const uint16_t LED_BLINK_MS         = 400;    // 
const uint8_t  MP3_VOLUME           = 25;     //Default MP3 Volume

// Servo motion: start UP at 92°, move DOWN by +45° (flip sign if needed)
const int SERVO_UP_ANGLE    = 92;   // standing UP
const int SERVO_DELTA_DOWN  = +45;  // DOWN = UP + 45°  (was -45 before)
const int SERVO_DOWN_ANGLE  = SERVO_UP_ANGLE + SERVO_DELTA_DOWN;

const int SERVO_STEP_DEG    = 2;
const uint16_t SERVO_STEP_MS = 15;

// ---- Globals ----
Servo servoA, servoB;
int   servoCur = SERVO_UP_ANGLE;
int   servoTgt = SERVO_UP_ANGLE;

uint32_t lastDetectMs = 0;
uint32_t lastBlinkMs  = 0;
uint32_t lastStepMs   = 0;
bool     blinkLeft    = true;

SoftwareSerial mp3(PIN_MP3_RX, PIN_MP3_TX); // RX, TX
bool bell = false;

enum Phase { UP_IDLE, DOWN_ACTIVE, RETURNING_UP };
Phase phase = UP_IDLE;

// ---- MP3 helpers ----
void mp3Send(uint8_t cmd, uint8_t data1=0, uint8_t data2=0){
  uint8_t buf[10] = {
    0x7E, 0xFF, 0x06,
    cmd,
    0x00,
    data1,
    data2,
    0x00, 0x00,
    0xEF
  };

  // Calculate checksum
  uint16_t sum = 0;
  for(int i=1;i<7;i++) sum += buf[i];
  sum = 0 - sum;

  buf[7] = (sum >> 8) & 0xFF;
  buf[8] = sum & 0xFF;

  for(uint8_t i=0;i<10;i++){
    mp3.write(buf[i]);
  }
}

void mp3SetVolume(uint8_t v){
  if(v>30) v=30;
  mp3Send(0x06, 0, v);
}
void mp3PlayTrack(uint16_t n){
  mp3Send(0x03, (uint8_t)(n>>8), (uint8_t)(n & 0xFF));
}
void mp3Stop(){
  mp3Send(0x16);
}
void mp3LoopOn(){
  mp3Send(0x11,0x00,0x01); // loop all
}
void mp3LoopOff(){
  mp3Send(0x11,0x00,0x00);
}

void startBell(){ 
  if(!bell){
    mp3LoopOn();
    mp3PlayTrack(1);  // assumes track 001.mp3
    bell=true;
  }
}
void stopBell() { 
  if(bell){
    mp3LoopOff();
    mp3Stop();
    bell=false;
  }
}

// ---- LEDs ----
void setLEDs(uint8_t L, uint8_t R, bool leftOn){
  digitalWrite(L, leftOn?HIGH:LOW);
  digitalWrite(R, leftOn?LOW:HIGH);
}
void setAllLEDsOff(){
  digitalWrite(PIN_A_LED_L,LOW); digitalWrite(PIN_A_LED_R,LOW);
  digitalWrite(PIN_B_LED_L,LOW); digitalWrite(PIN_B_LED_R,LOW);
}

// ---- Servos ----
inline int clampAngle(int a){ return a<0?0:(a>180?180:a); }
void writeBoth(int angle){ angle=clampAngle(angle); servoA.write(angle); servoB.write(angle); }
void goDown(){ servoTgt = clampAngle(SERVO_DOWN_ANGLE); }
void goUp()  { servoTgt = clampAngle(SERVO_UP_ANGLE);   }

void stepServos(){
  uint32_t now = millis();
  if(now - lastStepMs < SERVO_STEP_MS) return;
  lastStepMs = now;

  if(servoCur < servoTgt)      servoCur = min(servoCur + SERVO_STEP_DEG, servoTgt);
  else if(servoCur > servoTgt) servoCur = max(servoCur - SERVO_STEP_DEG, servoTgt);

  writeBoth(servoCur);
}

// ---- Setup ----
void setup(){
  pinMode(PIN_IR, INPUT_PULLUP);

  pinMode(PIN_A_LED_L,OUTPUT);
  pinMode(PIN_A_LED_R,OUTPUT);
  pinMode(PIN_B_LED_L,OUTPUT);
  pinMode(PIN_B_LED_R,OUTPUT);
  setAllLEDsOff();

  servoA.attach(PIN_A_SERVO);
  servoB.attach(PIN_B_SERVO);
  writeBoth(SERVO_UP_ANGLE);

  mp3.begin(9600);
  delay(500);
  mp3SetVolume(MP3_VOLUME);
  stopBell();

  lastBlinkMs = millis();
}

// ---- Main Loop ----
void loop(){
  uint32_t now = millis();
  bool irActive = (digitalRead(PIN_IR) == LOW); // active-LOW

  // Always step toward target
  stepServos();

  switch(phase){
    case UP_IDLE:
      if(irActive){
        lastDetectMs = now;
        startBell();
        goDown(); // DOWN is UP + 45°
        setLEDs(PIN_A_LED_L, PIN_A_LED_R, blinkLeft);
        setLEDs(PIN_B_LED_L, PIN_B_LED_R, blinkLeft);
        phase = DOWN_ACTIVE;
      }
      break;

    case DOWN_ACTIVE:
      if(irActive){
        lastDetectMs = now; // refresh hold time
      }

      // LED blink timing
      if(now - lastBlinkMs >= LED_BLINK_MS){
        lastBlinkMs = now;
        blinkLeft = !blinkLeft;
        setLEDs(PIN_A_LED_L, PIN_A_LED_R, blinkLeft);
        setLEDs(PIN_B_LED_L, PIN_B_LED_R, blinkLeft);
      }

      // If hold time has expired after last detection, start returning UP
      if(now - lastDetectMs >= HOLD_AFTER_DETECT_MS){
        goUp();
        stopBell();
        phase = RETURNING_UP;
      }
      break;

    case RETURNING_UP:
      // Keep LEDs blinking while the arms are coming back up
      if(now - lastBlinkMs >= LED_BLINK_MS){
        lastBlinkMs = now;
        blinkLeft = !blinkLeft;
        setLEDs(PIN_A_LED_L, PIN_A_LED_R, blinkLeft);
        setLEDs(PIN_B_LED_L, PIN_B_LED_R, blinkLeft);
      }

      // When we reach UP angle, turn everything off & go idle
      if(servoCur == SERVO_UP_ANGLE){
        setAllLEDsOff();
        phase = UP_IDLE;
      }

      // If another train arrives while gates are returning, treat it as active again
      if(irActive){
        lastDetectMs = now;
        startBell();
        goDown();
        phase = DOWN_ACTIVE;
      }
      break;
  }
}

After the Workshop

The Sun City railroad crossing lives on as both a working feature on the layout and a teaching artifact. The hardware can be cloned from the wiring diagram, the sketch is classroom-friendly, and the project now serves as a jumping-off point for future additions: sensors on other tracks, ambient lighting, or even computer-controlled schedules.

For the club, it was a first dive into microcontrollers. For me, it was a chance to wrap hardware, firmware, documentation, and teaching into one package — and then watch a room full of people light up the first time the gates dropped on their own. The next step will be installing at the Red Poppy Railroad sometime early 2026.