{"id":661,"date":"2016-02-07T23:56:45","date_gmt":"2016-02-08T07:56:45","guid":{"rendered":"http:\/\/thenscaler.com\/?page_id=661"},"modified":"2016-02-29T23:36:06","modified_gmt":"2016-03-01T07:36:06","slug":"multiple-turnouts-and-other-multitasking","status":"publish","type":"page","link":"https:\/\/thenscaler.com\/?page_id=661","title":{"rendered":"Multiple Turnouts and Other Multitasking"},"content":{"rendered":"
\"Arduino

Arduino Uno R3<\/p><\/div>\n

The microcontroller at the heart of your Arduino contains a single processor that can execute one instruction at a time.\u00a0 But it can do that task over and over very quickly — around 16 million times per second on an UNO<\/a>. At that speed, the microcontroller can handle a lot of different tasks, more or less simultaneously.<\/p>\n

That said, the processor can only do what you tell it to do, one instruction at a time; it is up to the programmer to structure the code in a way that effectively divvies up processor time between different tasks.<\/p>\n

Avoid Delay()<\/h2>\n

The enemy of multitasking is the delay() function, which is frequently used to time actions. The problem with delay() is that it stops the program flow cold; nothing can happen while thousands of cycles are frittered away. In Arduino parlance, delay() is a blocking function.<\/p>\n

The classic Arduino example for timing actions without using delay() is the Blink Without Delay sketch<\/a>, where the main loop checks the elapsed time and, if a wait period has passed, turns the LED on or off creating a blinking LED. In between changing the state of the LED, the loop runs and could do other things.<\/p>\n

Looping for Multiple Tasks<\/h2>\n

Checking the elapsed time at the start of every iteration of your main loop(), then taking actions based on time, is at the heart of simple multitasking. To make it work effectively, you have to split up tasks that take time to complete, handle complex actions that consume multiple cycles as efficiently as possible and prioritize the tasks so they interact in the ways you want.<\/p>\n

For example, the test loop UNO<\/a> has four task groups it has to handle simultaneously:<\/p>\n

    \n
  1. Block Occupancy Detection — all five sensors have to be checked on each cycle and the block state updated as necessary.<\/li>\n
  2. Turnout Management — move the turnout when commanded over several seconds for slow turnout motion.<\/li>\n
  3. Signal Management — maintain and change signal states based on turnout position and block occupancy, or in response to a command override.<\/li>\n
  4. Communications — listening for messages, processing and executing commands and transmitting data to other devices.<\/li>\n<\/ol>\n

    That is quite a bit to do, but well within the capabilities of the UNO. Each of these task groups gets its turn during each iteration of the main loop.<\/p>\n

    To get a sense of how that works, lets focus in on one core task group: turnout management. Running multiple slow motion turnouts encompasses all the techniques needed for simple Arduino multitasking.<\/p>\n

    Slow Motion Turnouts<\/h2>\n
    \"Complete

    Demo servo installation.<\/p><\/div>\n

    If you’ve experimented with using servo motors as turnout motors, or read Turnout Control with Arduino and Servos<\/a>, then you know that slowing the motion down requires moving one degree at a time, with a time delay between moves. Using delay() to time the motion, as in the basic example<\/a>, renders the microcontroller unable to do anything else while the turnout is moving. Further, with this method only one turnout can be moved at any one time, which would be a problem with multiple trains, turnouts and operators.<\/p>\n

    Using our multitasking model to handle turnout motion requires keeping track of the turnout’s current position, whether of not it is currently moving, and its destination if in motion.\u00a0 With that data we can effectively divide its motion into smaller increments, executing the next move whenever a delay period has passed. Scaling to multiple turnouts is primarily a matter of organizing your turnout data appropriately.<\/p>\n

    Organizing Turnout Data<\/h2>\n

    I start with a data structure to represent a turnout:<\/p>\n

    typedef struct TURNOUT_DEF {\r\n\u00a0 int pin;\r\n\u00a0 int pos_main;\r\n\u00a0 int pos_div;\r\n};\r\ntypedef struct TURNOUT_DATA {\r\n\u00a0 TURNOUT_DEF data;\r\n\u00a0 bool is_moving;\r\n\u00a0 byte alignment;\r\n\u00a0 int pos_now;\r\n\u00a0 int target_pos;\r\n\u00a0 unsigned long last_move;\r\n};<\/pre>\n
    The test loop has a single turnout, but I declare the data for the turnout in the form of an array of TURNOUT_DATA structures just as I would with a multi-turnout layout. This way, a single variable turnouts<\/em> <\/strong>represents all turnouts the sketch has to manage:<\/p>\n
    TURNOUT_DATA turnouts[NUM_TURNOUTS] = {\r\n\u00a0 {{8, 93, 117}, false, ALIGN_MAIN, 93, 93, 0}\r\n};<\/pre>\n
    Methods<\/h2>\n
    The methods for using the array would be the same no matter how many turnouts there are. For example, in setup, a for<\/em> loop is used to step through the turnout array and initialize the servos ( variable servos<\/em> is an array of pointers to servo objects, declared in this way: servo *servos[NUM_TURNOUTS]. The servo pointer could be included within the TURNOUT_DEF structure, but here I chose to keep the servo pointers in a separate array, index synchronized with turnouts<\/em>.):<\/p>\n
    \/\/ initialize turnouts\r\n\u00a0 for(i = 0; i < NUM_TURNOUTS; i++){\r\n\u00a0\u00a0\u00a0 \/\/ create a SERVO instance and store it in the servos array\r\n\u00a0\u00a0\u00a0 servos[i] = new Servo; \r\n\u00a0\u00a0\u00a0 servos[i]->attach(turnouts[i].data.pin);\r\n\u00a0\u00a0\u00a0 setTurnout(i, ALIGN_MAIN);\u00a0 \/\/ set initial turnout position\r\n\u00a0 }<\/pre>\n
    The setTurnout() function does exactly what you expect — sets a turnout position — but it does not move the turnout. Instead, it initiates motion by setting turnout data elements: assigning a destination to the target_pos<\/em> element, setting the is_moving<\/em> element to true and setting the last_move<\/em> element to zero. ALIGN_MAIN and ALIGN_DIVERGENT are arbitrary integer macro\/constants used to represent those alignment states.<\/p>\n
    void setTurnout(int id, int align){\r\n\u00a0\u00a0 switch(align){\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 case ALIGN_MAIN:\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].is_moving = true;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].last_move = 0;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].target_pos = turnout[id].data.pos_main;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].alignment = ALIGN_MAIN;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 break;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 case ALIGN_DIVERGENT:\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].is_moving = true;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].last_move = 0;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].target_pos = turnout[id].data.pos_div;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[id].alignment = ALIGN_DIVERGENT;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 break;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n}<\/pre>\n
    The command and communications process elsewhere in the test loop sketch uses setTurnout() to trigger turnout moves when it receives appropriate commands.<\/p>\n
    Moving Along<\/h2>\n
    Actual turnout motion is handled within the main loop, beginning with a call to millis() at the beginning of the loop to get current elapsed time in milliseconds. Then the code steps through the turnouts array, checking the is_moving<\/em> element to determine if a turnout is in motion. If is_moving<\/em> is true, the code then checks to see if enough time has elapsed since the last move — if so, another move is made and the time is recorded.<\/p>\n
    Movement timing is controlled by by the macro\/constant STEP_DELAY, which is the number of milliseconds (200 on the test loop) to delay between moves. If you wanted to customize the delay for different turnouts, add a member to the data structure to hold the delay period for each turnout, and use that data instead of STEP_DELAY. Every turnout or other animated object can have its own unique delay period.<\/p>\n
    \u00a0 \/\/ get elapsed milliseconds at loop start\r\n\u00a0 unsigned long currentMillis = millis();\r\n\r\n\u00a0 \/\/ Turnout Control\r\n\u00a0 for(int i = 0; i < NUM_TURNOUTS; i++){\r\n\u00a0\u00a0\u00a0 if (turnouts[i].is_moving) {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0 if ( (currentMillis - turnouts[i].last_move) >= STEP_DELAY ) {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[i].last_move = currentMillis;\r\n        \/\/ if the new angle is higher\r\n        \/\/ and not already at destination\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 if (turnouts[i].pos_now < turnouts[i].target_pos) { \r\n          \/\/ increment and write the new position\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 servos[i]->write(++turnouts[i].pos_now);\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 } else {\u00a0 \r\n           \/\/ otherwise the new angle is equal or lower\r\n           \/\/ if not already at destination\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 if (turnouts[i].pos_now != turnouts[i].target_pos) { \r\n            \/\/ decrement and write the new position\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 servos[i]->write(--turnouts[i].pos_now);\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n      \/\/ if target position is reached, turn motion off\r\n\u00a0\u00a0\u00a0\u00a0\u00a0 if (turnouts[i].pos_now == turnouts[i].target_pos) {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 turnouts[i].is_moving = false;\r\n\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n\u00a0\u00a0\u00a0 }\r\n\u00a0 }<\/pre>\n
    Using this technique, turnouts start and stop moving asynchronously and can be independently controlled.<\/p>\n
    \"Station<\/a><\/p>\n
    Extending the Technique<\/h2>\n
    Any number of animated objects could be handled in this fashion. The key is to represent your animated object with data, then use the data to trigger and control motion, moving incrementally with a delay. Start each iteration of the main loop by getting the current elapsed time with millis(), then use the time to determine when incremental actions should happen.<\/p>\n
    Since the Arduino IDE is a C++ platform, you could write the same code as a C++ object encapsulating the data for each turnout,\u00a0 and the methods used, in turnout objects. This kind of problem lends itself well to an Object Oriented approach.<\/p>\n
    OOP would be semantically elegant, but not necessarily more efficient. This is a matter of personal preference.\u00a0 I love OOP programming, but find the efficiency of straight C coding compelling for many Arduino tasks.\u00a0 Plus, I think, straight C is easier for novices to read and understand, especially if they’ve been exposed to any other structured procedural language (javascript, for example). So the code here is all C; but OOP would work fine.<\/p>\n
    \n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    The microcontroller at the heart of your Arduino contains a single processor that can execute one instruction at a time.\u00a0 But it can do that task over and over very quickly — around 16 million times per second on an UNO. At that speed, the microcontroller can handle a lot of different tasks, more or […]<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":157,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-661","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/pages\/661","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thenscaler.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=661"}],"version-history":[{"count":18,"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/pages\/661\/revisions"}],"predecessor-version":[{"id":703,"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/pages\/661\/revisions\/703"}],"up":[{"embeddable":true,"href":"https:\/\/thenscaler.com\/index.php?rest_route=\/wp\/v2\/pages\/157"}],"wp:attachment":[{"href":"https:\/\/thenscaler.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=661"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}