{"id":414,"date":"2015-10-01T15:53:10","date_gmt":"2015-10-01T22:53:10","guid":{"rendered":"http:\/\/thenscaler.com\/?p=414"},"modified":"2015-10-01T15:53:10","modified_gmt":"2015-10-01T22:53:10","slug":"a-programmable-layout-controller","status":"publish","type":"post","link":"https:\/\/thenscaler.com\/?p=414","title":{"rendered":"A Programmable Layout Controller"},"content":{"rendered":"

Programming an Arduino to run turnouts, lights or animation on the layout is only part of the challenge. The other part is how do you control the board and tell it what you want it to do?<\/p>\n

\"Servo<\/a>

Servo Control with LED Feedback<\/p><\/div>\n

From an Arduino point of view, any sensor attached to a pin can trigger action in a sketch. As shown in Turnout Control with Arduino & Servos<\/a>, mechanical buttons and switches can be attached to pins to tell the board what to do. In the example circuit, a single button triggers servo action. If you want to include feedback indicators as in this example circuit — these could be layout signals or panel indicators — you can hard-wire everything together to the same Arduino board.<\/p>\n

Until you run out of pins<\/h2>\n

Pin management is critical as you ask the Arduino to do more and more. Every new sensor or triggering device consumes pins (as does every new actuator or output device). While learning what I could do with an Arduino on the layout, I realized that I needed get beyond the hardwired controls used in experiments and demos to a generic, software-based control system. To do that I was going to have to network everything together.<\/p>\n

Networking Arduinos<\/h2>\n
\"Uno<\/a>

Uno with Ethernet Shield<\/p><\/div>\n

In Roundhouse Rebuild Part 2<\/a> I mentioned, without explanation, that I was using Ethernet, and went on to discuss the evolving Simple Network Command System. I decided to go with wired Ethernet because of the easy availability of inexpensive Ethernet shields based on the WIZnet W5100 Ethernet Controller chip (under 10 dollars per shield<\/a>), and an easy to use Arduino library included in the IDE<\/a>. It is as close to plug & play as networking gets on an Arduino. The only additional equipment required are one or more inexpensive 10\/100 switches (for example: TP-LINK TL-SF1005D 5-port 10\/100Mbps Desktop Switch<\/a>; don’t get gigabit switches to work with these shields, you’re just asking for trouble) to\u00a0 interconnect the devices. I use a per-device assigned address system<\/a> which helps keep the equipment roster simple (no router or DHCP <\/a>required).<\/p>\n

Why not just use the Digital Command Control system for the Arduino net? The short answer is that while it is clearly doable<\/em><\/strong>, for the purposes of this project I am going to keep the Arduino net separate because:<\/p>\n

    \n
  1. Everything I do here has to work for both DC and DCC layouts. I own both DCC and unconverted DC locomotives; the layout has to work the same in either mode.<\/li>\n
  2. Compared to conventional networking, DCC is a relatively difficult way to conduct bidirectional communications between Arduino boards.<\/li>\n
  3. Keeping them separate does not preclude enabling communication between the two systems down the road.<\/li>\n<\/ol>\n

    If you want to pursue DCC communication and Arduino, the Model Railroading with Arduino<\/a> site is a great place to start. The biggest impediment for most modelers will be the lack of commercial interface hardware to connect an Arduino to either track power or the command bus (although the circuits are easy enough to build); the closest commercial solution would be to use a USB interface, like the Digitrax PR3XTRA USB Programmer<\/a>, RR-CirKits LocoBuffer-USB<\/a> or the SPROG II USB<\/a>, to tap into the DCC command system just as you would with JMRI<\/a>.<\/p>\n

    My ultimate goal is to build the layout’s electronic and mechanical foundation around a network of Arduino boards. For communication among Arduino boards, Ethernet makes the most sense right now because it is the most “frictionless” route to achieve my goals (a wireless form would be even better, but would be a little more difficult to implement, so I’m holding that option for the future); communication between the Arduino net and the DCC system is a topic for the future\u2014and the possibilities go way beyond treating Arduinos as decoders.<\/p>\n

    Building The Controller<\/h2>\n
    \"2050-04\"<\/a>

    Adafruit 3.5″ TFT screen displaying a bitmap.<\/p><\/div>\n

    The concept for a prototype controller was simple enough: start with an Uno<\/a>, add an Ethernet shield and add a small touchscreen for display and user input. Put it all in a box with an Ethernet jack, a USB jack and power connector. Software generates screen displays, interprets touches and communicates with devices it is controlling.<\/p>\n

    For the screen I chose the Adafruit 3.5″ TFT Touchscreen<\/a>, seen here attached to an Uno via a breadboard (NB: The wiring shown is the minimum required to run the screen; the touch overlay and the SD Card reader require additional connections). It is capable of full 16bit color with a resolution of 320 x 480 pixels. The Adafruit library provides basic graphic primitive functions, basic text functions and bitmap functions allowing image display. It has a resistive touch overlay. Adafruit has an excellent tutorial<\/a> on using this screen with their library.<\/p>\n

    \"Back<\/a>

    Back of 3.5″ TFT Touchscreen<\/p><\/div>\n

    The screen comes with a choice of interfaces: you can use the SPI bus interface in order to use the fewest pins on your Arduino, or you can devote more pins to use the faster 8 bit interface. You select the interface and solder the header pins on the appropriate side.\u00a0 A\u00a0 solder jumper on the back determines which interface is active; the decision is reversible. An SD Card reader is included for convenient storage of bitmap files.<\/p>\n

    On an Uno, the Ethernet shield dictates that the TFT screen has to be run via SPI; there aren’t enough pins otherwise. The application does not require the SD Card Reader so I don’t connect it to the UNO.<\/p>\n

    I fabricated a wiring harness for attaching the screen to the Uno\\Ethernet combo, then mounted everything in a Radio Shack project box as shown below.<\/p>\n

    \"Wiring<\/a>

    Wiring Harness<\/p><\/div>\n

    The connectors on the wiring harness are male <\/a>or female <\/a>PCB Headers; I solder the wires to the PCB side of the fittings, then cover each connection with heat shrink tubing. White wires connect to digital pins 7 through 13 (except 10, which is reserved for the Ethernet shield) and are for the TFT interface. Green wires are for the touch overlay and connect to Analog pins A2 – A5. Red supplies 5v, and black ground, to the TFT screen. The Ethernet extension<\/a> cable and the USB extension<\/a> cable both came from Adafruit<\/a>.<\/p>\n

    \"Inside<\/a>

    Inside the Controller<\/p><\/div>\n

    \"Controller<\/a>

    Controller with Screen Wiring Attached<\/p><\/div>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

    Here it is in operation:<\/p>\n

    \"The<\/a>

    The Programmable Controller<\/p><\/div>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

    You may have guessed the fan ( on the left side ) was an afterthought. The cheap Ethernet shields I use are heat sensitive; they will crash when put in a confined space with poor air circulation.\u00a0 Out in the open no problem; in a box, its a problem. Found that out the hard way. So I added a little fan to pull the air through the box (if you look closely, you’ll see there are holes around the bottom); works fine if noisily. Obviously, I will plan for air circulation when I build the main layout control panel. Such is prototyping!<\/p>\n

    What it Does<\/h2>\n

    The controller sketch displays menus with buttons that, when touched, will cause the controller to either go to a different menu or send a command packet to the target device. Command packets are strings, formatted thus: function<\/em> \/ option<\/em> \/ data.<\/em> For more about my protocol and the network polling process, see the Simple Network Command System section near the end of Roundhouse Rebuild Part 2<\/a>.<\/p>\n

    The Main Menu provides access to sub-menus that I’ve created to support parts of the project.<\/p>\n

    \"Controller<\/a>

    Controller Main Menu<\/p><\/div>\n

    All menus are built with buttons. A structure type called button_t holds button data:<\/p>\n

    typedef struct {\r\n\u00a0 int x;\r\n\u00a0 int y;\r\n\u00a0 int txtX;\r\n\u00a0 int txt;\r\n} button_t;<\/pre>\n
    X<\/span> and y<\/span> are the coordinates of the upper left corner of the button; the width and height are the same for all buttons in this version of the system. txtX<\/span> is the x coordinate for the button text; the y coordinate is calculated and there is no text centering function. Finally, txt<\/span> is an offset into a button_labels array pointing to the button text.<\/p>\n
    For the main menu, the button set definition looks like this:<\/p>\n
    const button_t buttons_main[SIZE_MAIN_SET] = {\r\n\u00a0 {90, 80, 115, 0 },\r\n\u00a0 {250, 80, 254, 1},\r\n\u00a0 {175, 140, 185, 16}};<\/pre>\n
    Determining if a button has been touched is fairly straight forward. The coordinates of a touch p<\/span> are compared to each button, as b<\/span>, in the current set to see if it is on or within the button boundaries.<\/p>\n
    p.x >= b.x && p.x <= (b.x + BUTTON_WIDTH) && p.y >= b.y && p.y <= (b.y + BUTTON_HEIGHT)<\/pre>\n
    Whacking My Head on the Memory Ceiling<\/h2>\n
    The graphics libraries contain a lot of code. With the newest Arduino IDE<\/a>, the controller sketch compiles to 27,030 bytes, about 83% of available program space; it was about 29k bytes with the previous IDE.<\/p>\n
    That is still tight enough that I cannot include SD Card access and a function to draw a bitmap from a file without going 15% over the absolute memory limit for an UNO<\/a>. In the future I’ll use an Arduino MEGA 2560 Board<\/a> instead of an UNO for control panel applications because of its vastly superior memory resources (and it has a lot more pins to work with). The remaining 17% with the current sketch gives me plenty of room for now.<\/p>\n
    The trickier bit of memory management<\/a> is “dynamic memory,” which (on an UNO) is 2,048 bytes of shared memory space used for local variables. Local variables are created when functions are called and destroyed when they are exited. Global variables–variables declared outside of any function that are always in scope<\/em> and available wherever you are in your sketch–are also stored in the same space. Global variables reduce the amount of dynamic memory available for local variables and, if not managed, can strangle your sketch.<\/p>\n
    Fortunately, the majority of global variables turn out to be constants — unchanging values or text used by the application. This kind of data can be stored in the program space instead of dynamic memory; the limitations are that<\/p>\n