{"id":13416,"date":"2019-02-14T16:08:35","date_gmt":"2019-02-14T05:08:35","guid":{"rendered":"http:\/\/legoeng.local\/?p=13416"},"modified":"2019-04-02T15:14:19","modified_gmt":"2019-04-02T04:14:19","slug":"design-patterns-in-ev3","status":"publish","type":"post","link":"http:\/\/legoeng.local\/design-patterns-in-ev3\/","title":{"rendered":"Write Better Code with Design Patterns in EV3"},"content":{"rendered":"<p>A <em>software design pattern\u00a0<\/em>is a reusable solution for a commonly occurring problem. It is not a finished solution, but rather a template for how to solve problems in a variety of different contexts.\u00a0Using a design pattern saves a lot of time and helps to better understand, analyse, and organize the code to get the best solution.<\/p>\n<p>In this post, we propose using the language of <a href=\"https:\/\/en.wikipedia.org\/wiki\/Software_design_pattern\" target=\"_blank\" rel=\"noopener\">design patterns<\/a>\u00a0to describe some of the most common programing structures in the EV3 Software, and outline\u00a0the following design patterns:<\/p>\n<ul>\n<li>Simple design pattern (sequential programing)<\/li>\n<li>General design pattern (loop programing)<\/li>\n<li>Parallel loop design pattern<\/li>\n<li>Master and slave design pattern<\/li>\n<li>State machine design pattern<\/li>\n<\/ul>\n<h2>Simple design pattern<\/h2>\n<p>One of the simplest ways we can program an EV3 robot is to drop different action blocks onto the sequence beam in the order, or <em>sequence<\/em>, we want them executed.<\/p>\n<p>For example, to make a standard two-wheeled robot carry out a series of movements, we can drag out the required action blocks, arranging them as desired, from left to right. Each block is executed one at a time, all the way until the end of the program. We call this purely sequential approach the <em>simple design pattern<\/em>.<\/p>\n<figure id=\"attachment_13427\" aria-describedby=\"caption-attachment-13427\" style=\"width: 871px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence1.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13427 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence1.png\" alt=\"\" width=\"871\" height=\"109\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence1.png 871w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence1-300x38.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence1-768x96.png 768w\" sizes=\"(max-width: 871px) 100vw, 871px\" \/><\/a><figcaption id=\"caption-attachment-13427\" class=\"wp-caption-text\">An example using a sequential design pattern<\/figcaption><\/figure>\n<p>Note that the blocks are connected to each other by a data wire, known as the <em>sequence beam<\/em>, and that the sequence beam is normally hidden. Although we normally think of the blocks as being executed from left to right, it is in fact the sequence beam that determines the order of execution. To make the sequence beam visible, click the connector on the right hand of any block and the following block will move to the right.<\/p>\n<figure id=\"attachment_13566\" aria-describedby=\"caption-attachment-13566\" style=\"width: 310px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence-beam-v2.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13566 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence-beam-v2.png\" alt=\"\" width=\"310\" height=\"122\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence-beam-v2.png 310w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-sequence-beam-v2-300x118.png 300w\" sizes=\"(max-width: 310px) 100vw, 310px\" \/><\/a><figcaption id=\"caption-attachment-13566\" class=\"wp-caption-text\">Making the sequence beam visible<\/figcaption><\/figure>\n<p>It is quite natural to start designing programs sequentially. Most of the time, however, the events we need our robots to handle do not occur in an order that is known ahead of time. For example, what if some actions need to be repeated? What if different actions need to be taken under different specific conditions? What if the order that actions are taken depends on the current situation? What if we need to stop the program in a particular circumstance?<\/p>\n<p>To implement his kind of behaviour, we need a more complex design pattern.<\/p>\n<h2>General design pattern<\/h2>\n<p>When we have to repeat a series of actions, we need a more complex structure than the sequential design pattern.\u00a0In the <em>general design pattern<\/em>, the structure consists of some initial actions, a loop that contains the main program, and some closing actions. The main program of the loop may simply be a sequential program, but can be much more complex if required.<\/p>\n<figure id=\"attachment_13417\" aria-describedby=\"caption-attachment-13417\" style=\"width: 500px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-loop.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13417\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-loop-300x71.png\" alt=\"\" width=\"500\" height=\"118\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-loop-300x71.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-loop-768x181.png 768w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-loop.png 837w\" sizes=\"(max-width: 500px) 100vw, 500px\" \/><\/a><figcaption id=\"caption-attachment-13417\" class=\"wp-caption-text\">The general design pattern in EV3<\/figcaption><\/figure>\n<figure id=\"attachment_13431\" aria-describedby=\"caption-attachment-13431\" style=\"width: 763px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-general-example.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13431 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-general-example.png\" alt=\"\" width=\"763\" height=\"437\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-general-example.png 763w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-general-example-300x172.png 300w\" sizes=\"(max-width: 763px) 100vw, 763px\" \/><\/a><figcaption id=\"caption-attachment-13431\" class=\"wp-caption-text\">General design pattern example<\/figcaption><\/figure>\n<p>For example, let\u2019s imagine a wheeled robot with a colour sensor that drives forward, beeping each time it drives over a green line, and stops at a red line. We do not know how many green lines the robot will encounter before the red line &#8211; or even if it will see any at all before reaching the red line. <em>So how could we program the robot using a strictly sequential pattern?<\/em> Unless we know exactly how many lines the challenge has and in what order they are placed, we cannot. If one line is changed or removed, the program will not work anymore. Instead, we can use the general design pattern.<\/p>\n<p>We can of course perform many actions sequentially within each iteration of the loop, but we can also use nested switch blocks to establish an order of priority for a variety of actions, without having to know in what order they will occur when the program runs.<\/p>\n<p>For example, what if we want to our robot to not only beep as it crosses each line, but also change direction each time it encounters an obstacle? We can nest the colour sensor switch inside a distance sensor switch or vice-versa, depending on which condition should be checked first.<\/p>\n<figure id=\"attachment_13437\" aria-describedby=\"caption-attachment-13437\" style=\"width: 1858px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13437 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example.png\" alt=\"\" width=\"1858\" height=\"1150\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example.png 1858w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example-300x186.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example-768x475.png 768w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example-1024x634.png 1024w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-nested-switch-example-1320x817.png 1320w\" sizes=\"(max-width: 1858px) 100vw, 1858px\" \/><\/a><figcaption id=\"caption-attachment-13437\" class=\"wp-caption-text\">General design pattern example with a nested switch<\/figcaption><\/figure>\n<p>What if we need to repeatedly run different actions at the same time but at different rates? It is not enough to split the sequence beam inside the main loop because the main loop will not repeat until the longest split sequence is finished! The solution is to run different loops in parallel.<\/p>\n<h2>Parallel loop\u00a0design pattern<\/h2>\n<p>The <em>parallel loop design pattern<\/em> is a basic programming strategy that allows controlling simultaneously different independent tasks.<\/p>\n<figure id=\"attachment_13420\" aria-describedby=\"caption-attachment-13420\" style=\"width: 400px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-parallel-loop.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13420\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-parallel-loop-300x173.png\" alt=\"\" width=\"400\" height=\"230\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-parallel-loop-300x173.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-parallel-loop.png 585w\" sizes=\"(max-width: 400px) 100vw, 400px\" \/><\/a><figcaption id=\"caption-attachment-13420\" class=\"wp-caption-text\">Parallel loop design pattern<\/figcaption><\/figure>\n<p>Building on the first version of the previous example, let&#8217;s say that, in addition to moving forward and beeping as it crosses each green line, we want the robot to activate its gripper whenever it detects an obstacle in its path. Clearly the gripper needs to run independently and at a different rate than the main program. The only way we can accomplish this is by running two parallel loops\u00a0at the same time, one for the main program and another for the gripper.<\/p>\n<figure id=\"attachment_13433\" aria-describedby=\"caption-attachment-13433\" style=\"width: 1020px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-parallel-loops-example-1.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13433 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-parallel-loops-example-1.png\" alt=\"\" width=\"1020\" height=\"738\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-parallel-loops-example-1.png 1020w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-parallel-loops-example-1-300x217.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-parallel-loops-example-1-768x556.png 768w\" sizes=\"(max-width: 1020px) 100vw, 1020px\" \/><\/a><figcaption id=\"caption-attachment-13433\" class=\"wp-caption-text\">Parallel loop\u00a0 design pattern example<\/figcaption><\/figure>\n<p>Note: Care must be taken to avoid a <em>race condition<\/em>, which can occur when program blocks within multiple loops (or multiple branches) attempt to control the same resource at the same time. For example, if motor blocks in parallel loops attempt to control the same motor, the behaviour of the motor will depend on the timing of the loops. Race conditions often lead to unpredictable and undesirable results.<\/p>\n<p>But now the problem is: how can we control, coordinate, and communicate between the different loops of the parallel loop design pattern? Can we use data wires? The answer is not at all, because data wires will not allow the loops to run in parallel. In fact, a block connected to a data wire will not execute until the block connected at the left of the wire is executed. This is why we use the sequence beam as a very special data wire that ensures the sequential execution of the program blocks. The answer is: we need to use <em>variables<\/em>.<\/p>\n<h2>Master and slave\u00a0design pattern<\/h2>\n<p>The <em>master and slave design pattern<\/em> is useful when you have two or more processes running simultaneously but at different speeds that need some sort of coordination.<\/p>\n<p>One loop acts as the master and the others as the slaves. The master loop controls all the slave loops and communicates with them using <em>variables<\/em>.<\/p>\n<figure id=\"attachment_13421\" aria-describedby=\"caption-attachment-13421\" style=\"width: 781px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-master-slave.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13421 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-master-slave.png\" alt=\"\" width=\"781\" height=\"370\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-master-slave.png 781w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-master-slave-300x142.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-master-slave-768x364.png 768w\" sizes=\"(max-width: 781px) 100vw, 781px\" \/><\/a><figcaption id=\"caption-attachment-13421\" class=\"wp-caption-text\">Master\/slave design pattern architecture in EV3<\/figcaption><\/figure>\n<p>As an example, imagine we want to build a proximity sensor that beeps when an object is present. Furthermore, how could we implement this in such a way that the closer the object is, the faster the robot beeps?\u00a0Clearly the beep repetition speed will be proportional to the obstacle proximity. In addition, the beeper proximity function will have to run in parallel with whatever else the robot is doing and at its own speed. If the distance is already being read within the main program loop (the master loop), one solution is to store this value in a variable, and then read the stored value in a separate loop (the slave loop) that handles the beeping.<\/p>\n<figure id=\"attachment_13435\" aria-describedby=\"caption-attachment-13435\" style=\"width: 1024px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-master-slave-example.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13435 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-master-slave-example.png\" alt=\"\" width=\"1024\" height=\"411\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-master-slave-example.png 1024w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-master-slave-example-300x120.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/design-pattern-master-slave-example-768x308.png 768w\" sizes=\"(max-width: 1024px) 100vw, 1024px\" \/><\/a><figcaption id=\"caption-attachment-13435\" class=\"wp-caption-text\">Master\/slave design pattern example<\/figcaption><\/figure>\n<p><em>If we analyze the two loops what can we say about their execution speeds?<\/em><br \/>\nAlthough reading a sensor takes some time, like in this example\u2019s master loop, playing a sound and waiting to repeat the sound, such as in the slave loop, presumably takes much longer to execute. Because the slave loop runs slower than the master loop, we can expect that some distance values set by the master loop will be missed by the slave loop. Despite this, the beeps seem to be quite proportional to the obstacle distance anyway. In this situation, it is not crucial that the slave loop runs slower than the master.<\/p>\n<p>For more examples of the master\/slave design pattern, see these posts:<\/p>\n<ul>\n<li><a href=\"http:\/\/legoeng.local\/to-light-or-not-to-light\/\">To light or not to light<\/a><\/li>\n<li><a href=\"http:\/\/legoeng.local\/how-to-toggle-a-motor-on-off-with-a-touch-sensor\/\">How to toggle a motor on\/off with a touch sensor<\/a><\/li>\n<\/ul>\n<h2>State machine design pattern<\/h2>\n<p>In the simple design pattern, blocks are executed sequentially. The sequence beam establishes the program blocks execution order, from left to right. Although sequential programing is one of the most common and often more obvious programing styles, it is not always the most efficient, flexible or understandable approach in the long run.<\/p>\n<p>For example:<\/p>\n<ul>\n<li>What if we have to change the order that a sequence of actions is executed? For example, if the sensor events that trigger different actions is changed.<\/li>\n<li>What if we have to repeat one or more actions several times? For example, to repeat several turns to one side, or to go forward across several different color lines.<\/li>\n<li>What if we have to execute a sequence of code only when a specific condition is met? For example, if an obstacle is detected, drive around it, otherwise follow the line.<\/li>\n<li>What if we want to<span style=\"font-size: 17.6px;\">\u00a0<\/span>stop the execution of a program when a specific condition is met, without waiting until the rest of the sequence is finished?<\/li>\n<\/ul>\n<p><em>How can we improve\u00a0<strong>sequential programing<\/strong> to make it more functional, more compact, easier to understand, and easier to debug?<\/em> The answer is: by using the <strong><em>state machine design pattern.<\/em><\/strong><\/p>\n<p>A <em>state machine<\/em> is a system that consists of a finite number of <em>states<\/em> and rules that determine how the system transitions from one state to another. In the EV3 software, this can be implemented by using a Switch block that contains a case for each state. Each case contains <em>functionality code<\/em>\u00a0which consists of the code to be executed in the current state and a <em>transition function<\/em> which sets the next state.<\/p>\n<figure id=\"attachment_13422\" aria-describedby=\"caption-attachment-13422\" style=\"width: 879px\" class=\"wp-caption aligncenter\"><a href=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-state-machine.png\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-13422 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-state-machine.png\" alt=\"\" width=\"879\" height=\"193\" srcset=\"http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-state-machine.png 879w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-state-machine-300x66.png 300w, http:\/\/legoeng.local\/wp-content\/uploads\/2018\/11\/Design-pattern-state-machine-768x169.png 768w\" sizes=\"(max-width: 879px) 100vw, 879px\" \/><\/a><figcaption id=\"caption-attachment-13422\" class=\"wp-caption-text\">Basic elements of the state machine design pattern in EV3<\/figcaption><\/figure>\n<p>Often programs will have an initialization state, followed by a default state \u2013 where, for example, the sensors are read to make decisions and to call other states or take different actions \u2013 and finally, it can have a closing state to carry out some actions before ending the program.<\/p>\n<p>We&#8217;ll look at state machines in more depth in a future post, but for the time being, see this post:<\/p>\n<ul>\n<li><a href=\"http:\/\/legoeng.local\/from-sequential-programming-to-state-machines\/\">From sequential programming to state machines<\/a><\/li>\n<\/ul>\n<p>&nbsp;<\/p>\n<p><a href=\"http:\/\/www.bogatech.org\/\" target=\"_blank\" rel=\"noopener\"><img loading=\"lazy\" decoding=\"async\" class=\"alignright wp-image-12447 size-full\" src=\"http:\/\/legoeng.local\/wp-content\/uploads\/2017\/06\/logo_bogatech_petit.jpg\" alt=\"\" width=\"102\" height=\"141\" \/><\/a><em>This post was inspired by National Instruments&#8217; LabVIEW <a href=\"http:\/\/www.ni.com\/product-documentation\/14437\/en\/\" target=\"_blank\" rel=\"noopener\">Core 1<\/a> and <a href=\"http:\/\/www.ni.com\/product-documentation\/14662\/en\/\" target=\"_blank\" rel=\"noopener\">Core 2<\/a> courses\u00a0and is based on Unit 13 of my\u00a0<a href=\"http:\/\/www.bogatech.org\/index.htm?inicio=curs\/\" target=\"_blank\" rel=\"noopener\">Teachers Introduction Course to LEGO Mindstorms NXT &amp; EV3<\/a>.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"<p>A software design pattern\u00a0is a reusable solution for a commonly occurring problem. It is not a finished solution, but rather a template for how to solve problems in a variety of different contexts.\u00a0Using a design pattern saves a lot of time and helps to better understand, analyse, and organize the code to get the best [&hellip;]<\/p>\n","protected":false},"author":412,"featured_media":13420,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[38],"tags":[535,536,619,518,256],"_links":{"self":[{"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/posts\/13416"}],"collection":[{"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/users\/412"}],"replies":[{"embeddable":true,"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/comments?post=13416"}],"version-history":[{"count":0,"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/posts\/13416\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/media\/13420"}],"wp:attachment":[{"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/media?parent=13416"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/categories?post=13416"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/legoeng.local\/wp-json\/wp\/v2\/tags?post=13416"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}