Adding a Turntable to the L&NC, Part 2

The Roundhouse / Turntable complex at the Red Bluffs Yard is the focal point of the lower level of the L&NC and one of the more complex projects planned for the layout. In the first installment  (which is also step 4 of the build out of Module 1, lower level) I wrote about how I built the pit and bridge base, and showed the mechanism I developed for the turntable using Actobotics robotics gear.  In this installment, step 5 ( Links to step 1, steps 2 & 3) of this module build out, we’ll take a look at the buildup around the turntable, adding track and integrating it into the scene.  I’ll also talk about how I completed and wired the bridge. Along the way I took the time to install basic scenery elements while I have free access to this section of the layout.

Step 5

Finishing the Pit

The first task after installing and leveling the turntable pit was to create a rim and cover the rough opening for the  pit. After looking at a lot of pictures of prototype turntables I concluded that the rim needed to be around 4 or 5 scale feet wide. Rather than try to cut a circle out of styrene, or something like that, I elected to use a strip of cork roadbed. With the beveled edge against pit wall, and the square edge forming the outer edge of the rim, the look seemed about right.

The flexibility of n scale cork roadbed made it the perfect material for rimming the turntable pit.

The flexibility of n scale cork roadbed made it the perfect material for rimming the turntable pit.

One thing I found out in my research was that track rails are typically attached directly to the rim material (usually concrete) without ties. I decided not to model it that way because I just don’t want to get bogged down with gauging problems. So I elected to mount the ties to the rim so that they will keep the track in gauge.

Its not prototypical, but that’s OK with me because this is one of those places were functional reliability has to win out over prototypical niceties.  As you can see in the picture below, I weaved the ties of the adjoining tracks between each other to achieve the correct track placement along the rim where it meets the bridge. Preliminary testing established that I’m getting good alignment and smooth wheel transits across the gap.

Track from the Roundhouse meets the turntable.

Track from the Roundhouse meets the turntable. Ballasting is in progress so there are bits ballast everywhere at the moment!

I painted the rim concrete to match the rest of the pit.  The texture of the roadbed material is a little rougher than I anticipated. A second coat of paint smoothed it out more and left me with a surface that is a little worn from the effects of time and weather.  I’m pleased with the effect; a perfectly smooth surface just wouldn’t be right.

Finishing the Bridge

In addition to the powered track that also serves as a reversing section, the turntable bridge has an operators hut containing a warming stove with a red LED for creating a hot coals effect. The central arch–which prototypically was often a rotating connection point for the incoming power line to run the turntable–is outfitted with a simulated rotating beacon that will run whenever the turntable is in operation. Not even remotely prototypical, this little enhancement is just a way to animate and make the turntable even more interesting.  I did say at the outset of this project that I was going to throw in animations at every opportunity!

I started the deck by creating a base frame to fit over the bridge and hold a piece of flextrack (I’m doing this layout in Peco code 80 gear).

Bridge deck base frame.

Bridge deck base frame. The track has not been trimmed to its final length yet.

Starting with the base frame, I continued adding cross-members until there was one in each space between ties. Then I decked it with .030 x .080 styrene “planks” cut to various lengths from scale 8′ to scale 32′, creating a plausible planking effect..

The bridge deck before painting.

The bridge deck before painting.

The central arch is fabricated from .080 square tubing. I added etched brass X-bracing in a scale 18″ size so that it would resemble beams fabricated from plates and X-braces. I thought about trying to fabricate brace & plate beams, but felt it would be a little too difficult to pull off and make strong enough for practical use.

The rotating beacon at the top of the arch is fabricated from three red micro SMD LEDS arranged in a triangle. The magnet wires (1 common anode and 3 cathodes) are connected to an incredibly small rotating beacon simulator board that I purchased from Ngineering.com. The have a nice collection of simulator boards geared to model railroading, with everything sized for N scale (these boards will work in any scale, so don’t be deterred if you don’t do N).

The Ngineering rotating beacon simulator board with leads attached.

The Ngineering rotating beacon simulator board with leads attached.

Actually I bought 2 because I ended up screwing up one of the outputs on the first one. These boards are smaller than a dime and soldering wires to them is tricky. On my second attempt I soldered short 30 gauge solid wire leads to the board (easier than soldering magnet wire), then soldered the 40 gauge magnet wire to the leads.

To answer the obvious quesiton, I could very well have done the rotating beacon effect with an Arduino.  However, this little board is particularly good at that job, and I don’t have to use 3 PWM pins (plus the timing sensitive programming) to do the job.  I can run this effect from a single connection on a Duino Node, simply turning it on when the bridge moves and off when it stops at its intended destination.  This is good example of how one has to balance all the trade-offs when designing a system based on Arduino technology. Sometimes an external utility board gets you to the right place more efficiently than doing it from scatch.

Base and walls of the hut, and the stove.

Base and walls of the hut, and the stove.

The operator hut is made from a white metal “trackside shanty” kit by Stewart Products. I decided that the hut needed a little stove for heating, to go with the smoke jack provided by the kit. So I fabricated one from a piece of brass tubing and a styrene circle for a top. I cut an opening in the brass to serve as the front opening.  A red led mounted in the bottom of the tube (not shown) will be used to create a fire effect that you will just barely see through the open door of the hut. I’ll produce the effect with PWM on an Arduino board instead of a dedicated simulator. So the turntable bridge will have two different light animations.

With all the pieces assembled, the wiring in and everything painted, it was time to connect all the wires to the leads from the spinner and attach the deck assembly to the bridge base. If you look carefully you’ll see a black object to the right of the center — that is the beacon simulator in protective heat shrink tubing.

Attaching the deck assembly to the bridge base.

Attaching the deck assembly to the bridge base.

Are those fishing weights attached to the underside of the deck? You guessed it! The white metal hut is rather heavy (relative to the weight of the styrene); the weights are needed to balance the bridge. The white object between the girders on the left is a nylon screw with a rare earth magnet (Neodymium, available from K & J Magnetics) glued to its head, screwed into a nylon nut attached to the bridge. That is for the position sensor reed switches I’ve previously described.

The turntable fully assembled.

The turntable fully assembled.

Scenery

In addition to finishing the turntable I am doing as much scenicking as possible while I have this module on its own on a work table. As I am doing this I am reaping a bonus from my modular design: the ability to take a module and place it on a work table for 360 degree access at chair height.

I'm using CadRail's layers to record information. Here I've recorded feeder positions (in red) and turnout servo positioning data.

Module 1, Lower Level

 

Referring to the drawing of this part of the layout above, I decided to add a small mountain in the space between the yard at the top and the  two legs of the reversing loop at the bottom.  This creates a view block that isolates the yard into its own little world.

I also decided to create a couple of roads using Woodland Scenic’s Road System paving tape and Smooth-It pavement material. The system works pretty well. I do recommend viewing their video tutorials for instruction in using the system, which you will find on the product pages.

Creating an access road at the Red Bluffs Yard.

Creating an access road at the Red Bluffs Yard.

After removing the forming tape, you are left with this:

The road at Red Bluffs with forming tape removed.

The road at Red Bluffs with forming tape removed.

You’ll see that the road includes a driveway and parking lot at the top of the picture, and another driveway at the bottom that will lead to a gravel parking lot. These are provisions for future structures I have planned –a multi-unit rooming house for railroad workers at the top and a yard office at the bottom. I also created a road on the opposite side of the module, running between the legs of he reversing loop as an access road to the roundhouse / turntable complex.  I figure the employees need some way to get to and from work!

The mountain was made from several layers of foam insulation glued together then carved to a rough shape. I glued the foam shape to the layout, then covered the whole thing in plaster cloth. Then I selected some rock molds and cast a few rocks. After gluing the rocks to the mountain  (Attach rocks with wet plaster? Forgetaboutit! Liquid Nails for Projects makes attaching hydrocal rocks to another surface a snap, with its strong tack and immediate hold), I filled holes and blended the rocks into the terrain with Sculptamold. I painted everything except the rocks the medium tan I’m using as a base color, then painted the rocks themselves with a combination of iron oxide and earth tones. I glued down some earth blend and other ground foams — and, voilà, the red bluffs were born.

The Red Bluffs

The Red Bluffs

What’s Next?

More scenicking, of course.  But it is getting to be time to go underneath the module again and install more of the electronics, including controller hardware for the 9 turnout servos and the controller package for the turntable / roundhouse.

Until then, happy railroading!

Basic Signaling for a Small Layout

Continuing with the theme of controlling a small layout with an UNO, I thought I’d accept my own challenge from the last post and talk about how one might implement signals on a small layout as I did on the Test Loop.

Signals on the Test Loop

While I was actively testing block occupancy detection on the test loop, I set up three sets of signals as part of that effort. I wanted to both test some off-the-shelf signals from Tomar and take a crack at building my own searchlight signals using BLMA unlit signal heads. The former turned out to work well, but because they are wired for common anode, they sent me on a quest to tame common anode wiring. The latter also came out well, once I learned how to reliably solder magnet wire to SMD micro LEDS!

Block and Signal layout on the Test Loop

Block and Signal layout on the Test Loop

I did this primarily to see the block detection system working (block detection is also shown on on my programmable control panel, but that is another story) as a train moves around the track.  You can see it in action in this video—note that only the locomotive is detectable by the block occupancy detection system; the rolling stock is not set up for detection.

Since the test loop is just an oval with a single turnout and siding, the system is fairly simple.  As you watch the train go around the oval you will see signals change state as the train moves in and out of blocks, and as the turnout changes state.  The logic is imperfect in a few cases but good enough to show the various parts of the system working as a whole under the control of an UNO, which was the point of the exercise.

A Framework for ABS

Automatic Block Signalling (ABS) is straight forward and prototypical for late nineteenth / early twentieth century railroads. ABS signals are autonomous and react to block occupancy and turnout status; the red (next block obstructed), yellow (a subsequent block is obstructed) and green (no obstruction) indicators are near universal. Typical implementations handle blocks in groups of three or four, depending on how far ahead the system sensors extend.

Because each signal is an autonomous object that responds to specific environmental conditions, ABS lends itself well to a data-oriented approach. As with turnouts in the previous post, the best starting point is to devise a data structure that will encapsulate and represent everything that needs to be known about each signal in your system. Here is what I came up with for the test loop (see this post for an explanation of my Duino nodes, and this post for the addressing system in use).

typedef struct SIGNAL_DEF {
  byte type; // bit mask indicating available signal aspects
             // bit 1 = Red; bit 2 = Green; bit 3 = Yellow)
             // 1=R; 2=G; 3=RG; 4=Y; 5=RY; 6=GY; 7=RGY
             // 3 and 7 are the two types on the test loop
  nodeAddress addr; // base address of the Duino node for this signal
  byte R_ID; // pin/bit id for red indication
  byte G_ID; // pin/bit id for green indication
  byte Y_ID; // pin/bit id for yellow indication
  
  // data elements for running the signal
  byte state; // current signal state
  T_ALIGN *turnouts; // these turnouts must be aligned as defined to get SIGNAL_GREEN
  byte numTurnouts;
  byte *following; // additional blocks ahead (depends on direction signal faces)
  // watched for occupancy resulting in SIGNAL_YELLOW caution   
  byte numFollowing; 
};

By now you should recognize that this is my preferred approach to dealing with complex, interactive objects in the system.  As always, I define a compound data structure (the structure contains other structures as elements, in this case the T_ALIGN and NODEADDRESS types)  to collect all relevant data for each signal. Feel free to reinvent any of this — the point is to collect all necessary data in one place for each signal.

“T_ALIGN *turnouts”  is an example of pointer notation which allows for an array of zero (empty array) or more of the respective types; the “numTurnouts” element indicates how many items the T_ALIGN array contains. The “byte *following” and “numFollowing” do the same thing for a list of subsequent block IDs that are watched for occupancy.

Here is the declaration of a signals array from the Test Loop encapsulating all the signals in use, using the data types discussed. Notice how structures and arrays within the SIGNAL_DEF structure are defined inside their own curly braces:

// Signals definitions and data
SIGNAL_DEF signals[NUM_SIGNALS] = {
  {3, {3, 0}, 0, 1, -1, SIGNAL_OFF,{0, ALIGN_DIVERGENT}, 1,{2}, 1 },
  {3, {3, 0}, 2, 3, -1, SIGNAL_OFF,{0, ALIGN_MAIN}, 1, {2}, 1 },
  {7, {1, 0}, 0, 1,  2, SIGNAL_OFF,{}, 0, {0}, 1},
  {7, {0, 0}, 0, 1,  2, SIGNAL_OFF,{0, ALIGN_DIVERGENT}, 1, {}, 0 },
  {3, {0, 0}, 3, 4, -1, SIGNAL_OFF,{0, ALIGN_MAIN}, 1,{2}, 1}
};

Signal logic is handled by one function that gets called at the end of each loop cycle on the UNO, after block occupancy has been established.

void refreshSignals() {
  // First pass, set Stop (RED) state; default is GREEN
  // from block occupancy or turnout states
  for(int i = 0; i < NUM_SIGNALS; i++){ // for each signal
    // default state
    int state = SIGNAL_GREEN;
    SIGNAL_DEF sig = signals[i];
    for(int j = 0; j < max(sig.numTurnouts, sig.numBlocks); j++){ 
      if(j < sig.numTurnouts){
        // if the turnout is in motion OR 
        // if turnout alignment does not equal the required alignment
        if(turnout[sig.turnouts[j].id].is_moving || 
            turnout[sig.turnouts[j].id].alignment != sig.turnouts[j].align){
         state = SIGNAL_RED;
        } 
      }
      if(j < sig.numBlocks){ // for each linked block in the SIGNAL_DEF
        if(blocks[sig.blocks[j]].occ){ // if occupied
          state = SIGNAL_RED;
        }
      }
    }
    setSignalBits(i, state);
  }
  
  // Second pass to set caution states on
  // signals that support it and are currently set to GREEN
  
  for(int i = 0; i < NUM_SIGNALS; i++){ // for each signal
    SIGNAL_DEF sig = signals[i];
    if(bitRead(sig.type, 2)){ // if the signal supports the caution state
      if(sig.numFollowing > 0 && sig.state == SIGNAL_GREEN){
        // check occupancy of following block(s) if any
        for(int j = 0; j < sig.numFollowing; j++){
          if(blocks[sig.following[j]].occ){
            setSignalBits(i, SIGNAL_YELLOW);
          }
        }
      }
    }
  }
  // Refresh the nodes to show signals in their updated state
  nodeRefresh();
}

void setSignalBits(int signalID, byte signalState) {
  SIGNAL_DEF sig = signals[signalID];
  if (sig.state != signalState) {
    signals[signalID].state = signalState;
    byte nodeBits = nodeGet(sig.addr);
    switch (signalState) {
      case SIGNAL_OFF:
        if(bitRead(sig.type, 0)) bitWrite(nodeBits, sig.R_ID, LOW);
        if(bitRead(sig.type, 1)) bitWrite(nodeBits, sig.G_ID, LOW);
        if(bitRead(sig.type, 2)) bitWrite(nodeBits, sig.Y_ID, LOW);
        break;
      case SIGNAL_RED:
        if(bitRead(sig.type, 0)) bitWrite(nodeBits, sig.R_ID, HIGH);
        if(bitRead(sig.type, 1)) bitWrite(nodeBits, sig.G_ID, LOW);
        if(bitRead(sig.type, 2)) bitWrite(nodeBits, sig.Y_ID, LOW);
        break;
      case SIGNAL_GREEN:
        if(bitRead(sig.type, 0)) bitWrite(nodeBits, sig.R_ID, LOW);
        if(bitRead(sig.type, 1)) bitWrite(nodeBits, sig.G_ID, HIGH);
        if(bitRead(sig.type, 2)) bitWrite(nodeBits, sig.Y_ID, LOW);
        break;
      case SIGNAL_YELLOW:
        if(bitRead(sig.type, 0)) bitWrite(nodeBits, sig.R_ID, LOW);
        if(bitRead(sig.type, 1)) bitWrite(nodeBits, sig.G_ID, LOW);
        if(bitRead(sig.type, 2)) bitWrite(nodeBits, sig.Y_ID, HIGH);
        break;
    }
    nodeSet(sig.addr, nodeBits);
  }
  return;
}

void setSignal(int signalID, byte signalState) {
  setSignalBits(signalID, signalState);
  nodeRefresh();
}

For more in-depth discussion of my Duino Node devices, node functions and how they are used,  see Adding Signals to the Test Loop and Adding Signals to the Test Loop Part 2.

The idea here is that the logic of the signal system is executed in the refreshSignals() function. That function, in turn, calls setSignalBits() to interface with the hardware, using the hardware specific Duino Node functions to  drive the hardware.

How to Integrate Signals into Your Small Layout

Adding signals to your small layout consists of two basic steps: 1) setup your signal hardware so that it can be turned on and off in some way; either by direct connection to your UNO or using a shift register chain along similar lines to what I do with Duino Nodes. The choice of common anode vs. common cathode wiring is yours to make, but will depend on how your signal gear is wired. 2) Integrate signal handling in the sketch using turnout state and (if you have it) block occupancy data. Call your signal logic function at the end of each iteration of the main loop, and let that function interact with the signal hardware. Your signal logic should be in one place, and should be written as an “abstraction” that doesn’t know how to change signal display, but relies on other hardware specific functions to do that job.

Tomar Signals

Tomar N Scale Signals

I consider signals to be the most basic form of animation you can add to your layout to bring it to life. Its a little bit of trouble, but I hope you can see its really not hard.  The advantage of the Arduino approach over a hardware/hardwired approach (eg, connecting signals to the outputs of a stand alone block occupancy device) is the flexibility you gain in implementing signals while keeping wiring to an absolute minimum. Adding Absolute Permissive Block signalling is just as matter of additional logic to the sketch for the stretch of track you are trying to protect. Even full CTC functionality can be readily supported by responding to messages from a CTC control panel or system.

You’ll be amazed that how much work a single UNO can actually do for you.