All tags
Linear Stepper to Operate Turnouts
May 2019 - Using stepper motors to operate model rail turnouts
After being a bit disappointed with both my muscle wire and servo experiments to operate turnouts, I started doing a bit of research on linear actuators. While most were very expensive, I eventually stumbled on some at AliExpress by searching for the term ‘Miniature Slide Screw Stepper’ or ‘linear stepper’ and various combinations of similar words. They looked ideal so I bought some, similar to these:
Muscle Wire Update
May 2018 - Using muscle wire to operate model rail turnouts - updated from my old blog
This now happened quite a while ago now but as luck would have it, barely a week after I made my last post on using muscle wire for turnout actuators my last bit of wire broke :-( It was a bit of a shame really, as the test rig had operated for months without any problems.
What happened was that I built an actuator based on the crank system as described in a previous post on servos and at Tamalpais Valley Railroad, but instead of using a servo to move the crank I reused my last bit of muscle wire to pull on one side of the crank and a spring on the other side to pull the crank back. I used a small piece of styrene with 3 holes in it to connect the muscle wire, the crank and the spring:
Muscle Wire to Operate Turnouts
May 2018 - Using muscle wire to operate turnouts - updated from my old blog
Well I know I haven’t posted much in a while, but rest assured there have been exciting developments going on over here on a number of fronts.
The first thing is, I am gradually becoming convinced that I may have ‘cracked’ the holy grail of finding a cheap turnout actuator for my layout. My last couple of posts have looked at using servos, and they show a lot of promise, however I have been experimenting with something better - muscle wire.
Now, truth to tell, I have thought of using muscle wire - Nitinol wire - for a long while now. I bought a wire sample kit and book nearly 10 years ago and have off and on (mainly off) tried to actuate turnouts using various mechanisms. I have a small drawer of ‘experiments’ gone wrong as you can see here (note the fried resister in the experiment at the top):
RC Servos to Operate Turnouts
Apr 2018 - Using rc servos to operate points - updated from my old blog
I’ve been working on low cost ways to control turnouts. I bought some servos (AU$7 for 4) on eBay and tried to operate my hand made turnout with one of them. Here is a picture of the initial setup:
First Turnouts Using Dremel Tool Jig
Mar 2017 - This post are some pictures of the first set of points made with the new jig.
Here is a picture of the first set of points made with the turnout jig and proper materials. This took about 3 hours to make. I think it turned out pretty well.
Dremel Tool Turnout Jig
Jan 2017 - A jig to speed up the making turnouts - updated from my old blog
As mentioned in my last post, I have discovered that a Dremel type moto-tool makes an excellent point shaping tool for constructing model railroad turnouts. Combined with the simple jig below I found the process to be much easier and faster than the traditional filing method.
Here is a picture of the completed unit:
Turnouts 4 and 5
Jan 2017 - Fifth post in a series on how to build handmade n scale turnouts, including constructing some jigs to speed up the process - updated from my old blog
A few days after that router episode I hit on the idea of using my Dremel Tool to grind the turnout points. I probably would have thought of it earlier but I only just got the Dremel for Christmas and wasn’t really familiar with it. I quickly grabbed a short piece of rail, put it in a vice and stuck a No. 409 grinding disk into the Dremel. Success! Time to make another jig!
A Turnout Jig
Jan 2017 - Fourth post in a series on how to build handmade n scale turnouts, including constructing some jigs to speed up the process - updated from my old blog
After building 3 turnouts I have been thinking a bit on how to speed up their construction. By far the slowest - and hardest - part is filing the 2 switch rail points and a corresponding notch on the stock rails. It’s also quite stressful and easy to mess up.
My first idea was to create some sort of jig and use a wood router to grind the rail to a point. This might seem strange but I have accidentally routed straight through a nail while cutting slots in wood on several occasions without much ill effect to the router bit, so it seemed quite a reasonable idea at the time :-)
My First Hand Built Turnout
Jan 2017 - Second post in a series on how to build handmade n scale turnouts, including constructing some jigs to speed up the process - updated from my old blog
Well it took a while - at least 6 hours spread over a few days - but here it is. I think it isn’t too bad for a first effort.
Some Posts From My Old Blog
Jan 2017 -
As I mentioned in my first post, I had an earlier blog with a number of entries about building handmade turnouts. Unfortunately the blogs’ Wordpress database got borked so I had to start again, but I did manage to retrieve many of the posts.
So without further ado I’ll put them back up.
Software Available
Jan 2015 - Some basic mac software to send dcc signals using Arduino microcontrollers.
I’ve added the software that I have been developing to my GitHub repository. The link can be found on the Software Downloads page.
The repository contains a simple Arduino sketch to send a DCC signal to a booster, a very simple ‘booster tester’ that just flips the port connected to the booster every 5 seconds (basically a modified ‘blink’ sketch) so that you can measure the booster output with a multimeter, and a very early version of my MacDCC Command Station software.
MacDCC Command Station
Jan 2015 - Using Arduino microcontrollers to send and monitor dcc signals
Over the last few weeks I have been building an Arduino and Mac based DCC command station and today it all successfully came together with the running of my first locomotive under DCC control!
The Arduino software is quite simple, just receiving raw bytes from my Mac in a very simple format, which is then converted to DCC and sent out to a booster. The format is just a byte specifying how many further bytes are in the message, followed by the actual DCC bytes including checksum. After the required number of bytes have been received by the Arduino, the message is validated using the checksum, then replaces the oldest of the current two messages being sent. The Arduino software continuously sends out the last two commands that it receives so that no message is sent twice in a row. It is only a slight modification of the code mentioned in this post.
Thinking About a Command Station
Jan 2015 - Using Arduino microcontrollers to send and monitor dcc signals
In the discussion below to keep everything straight as to which code I am talking about:
- Communication from a PC (in my case a Mac) to the Arduino I’ll call a ‘command’.
- Communication from the Arduino to the booster I’ll call a ‘packet’.
- A message or message packet is a ‘command’ packet as distinguished from an idle packet.
The overriding philosophy of my command station will be to keep the code in the Arduino as simple as possible and have most of the smarts in the software running on the Mac. With this in mind, probably the simplest possible command station for the Arduino would be code to accept a new command from a Mac (or PC) via the serial port, convert this command to a valid DCC packet, and then continuously send this packet to the booster. However, while this would probably work, it would be out of spec because the NMRA standard S 9.2 (line 116) says:
Sending DCC With An Arduino
Jan 2015 - Using Arduino microcontrollers to send and monitor dcc signals
In my last post I mentioned that I now have 2 Arduino controller boards for experimenting with creating my own DCC command station, booster and DCC decoder. However, one of the problems with developing your own software and hardware that works together is that when something doesn’t work it can be difficult to figure out just where the problem is.
To help get around this I figured that it should be possible to simplify things by hooking two Arduinos directly together and send DCC commands from one to the other. This would at least ensure that the software was working before even having to think about the electronics.
So that’s what I did, and it worked!
Created with Ignite