When most people start programming a robot, they think of the program flow as a series of if-thens, which is reminiscent of structured programming Figure 1. This type of programming is very easy to get started in and hardly requires any thought or design beforehand. A programmer can just sit at the computer and start typing although a little thought before the typing may avoid a lot of grief later.
Fig 1 Structured programming visualized. The problem is, the code ends up as spaghetti code; all tangled up and difficult to expand. The behavior control model, in contrast, requires a little more planning before coding begins, but the payoff is that each behavior is nicely encapsulated within an easy to understand structure.
This will theoretically make your code easier to understand by other programmers familiar with the behavior control model, but more importantly it becomes very easy to add or remove specific behaviors from the overall structure, without negative repercussions to the rest of the code.
It also makes it possible to test and debug each behavior by itself. Returns a boolean value to indicate if this behavior should become active. For example, if a touch sensor indicates the robot has bumped into an object, this method should return true.
This method should return quickly, not nxt robot bumper car a long calculation. The code in this method begins performing its task when the behavior becomes active. For example, if nxt robot bumper car detects the robot has collided with an object, the action code could make the robot back up and turn away from the object.
A behavior is active as long as its action method is running, so the action method should exit when its task is complete. Also, the action method should exit promptly when suppress is called. When it nxt robot bumper car, it should leave the robot in a safe state for the next behavior. As you can see, the three methods in the Behavior interface are quite simple.
If a robot has three discrete behaviors, then the programmer will need to create three classes, with each class implementing the Behavior interface. Once these classes are complete, your code should hand the behavior objects off to the Arbitrator to deal with.
Creates an Arbitrator object that regulates when each of the behaviors will become active. The priority nxt robot bumper car each behavior is its index in the array. So behaviors[0] has the lowest priority. Otherwise, the program runs until shut down by pressing the Enter and Escape buttons. The Arbitrator class is even easier to understand than Behavior.
When an Arbitrator object is instantiated, it is given an array of Behavior objects. Once it has these, the start method is called and it begins arbitrating; deciding which behavior will become active. The Arbitrator calls the takeControl method on each Behavior object, starting with the object with the highest index number in nxt robot bumper car array. It works its way down through the array, in decreasing nxt robot bumper car order till it finds a behavior that wants to take control.
If the priority index of this behavior is greater than that of the current active behavior, the active behavior is suppressed. The action method is then nxt robot bumper car on the behavior of this index. As a result, if several nxt robot bumper car want to take control, then only the highest priority behavior will become active.
For reliable performance of the behavior control system, it is essential that the action method terminates promptly when suppress is called. One way to guarantee this is to define a boolean flag suppressed in each behavior. This variable is set to true by the suppress method and tested in every loop of the action method. Of course, nxt robot bumper car first thing an action method must do is set this flag to false. The action method might be quite complex, such as a separate thread for line tracking or wall following, but it must be coded to ensure prompt exit from action when necessary.
This is the recommended design pattern. For this example, we will program some behavior for a simple robot with differential steering.
This robot will drive forward as its primary low-level behavior. This activity continues unless the robot hits an object, then a high priority behavior will become active to back the robot up and turn it 90 degrees. There will also be a third behavior which we will insert into the program after the first two have been completed. Let's start with the first behavior. As we saw in the Behavior interface, we must implement the methods actionsuppressnxt robot bumper car takeControl.
The behavior nxt robot bumper car driving forward will take place in the action method. It simply needs to make motors A and C rotate forward and it exits when the motors are no longer moving, nxt robot bumper car suppress is called.
This behavior remains active as long as the motors are turning. The method code is:. That was easy enough! Now the standard suppress method will stop this action when it is called:.
So far, so good. Now we need to implement a method to tell Arbitrator when this behavior should become active. As we outlined earlier, this robot will drive forward always, unless something else suppresses it, so this behavior nxt robot bumper car always want to take control it's a bit of a control freak.
The takeControl method should return true, no matter what is happening. This may seem nxt robot bumper car, but rest assured that higher level behaviors will be able to cut in on this behavior when the need arises. The method appears as follows:.
That's all it takes to define our first behavior to drive the robot forward. The complete code listing for this class is as follows:. The second behavior is a little more complicated than the first, but still very similar. The main action of this behavior is to reverse and turn when the robot strikes an object or detects one close by. In this example, we would like the behavior to take control only when the touch sensor strikes an object, or the ultrasonic sensor gets an echo from a close object.
Here is the takeControl method that does it:. This assumes that a Nxt robot bumper car object has been created in an instance variable called touch and a new UltraSonicSensor object has been assigned to the variable sonar. For the action, we nxt robot bumper car the robot to back up and rotate when it detects an object, so we will define the action method as follows:.
We now have our two behaviors defined, and it's a simple matter to make a class with a main method to get things started. All we need to do is create an array of our behavior objects, and instantiate and start the Nxt robot bumper car as shown in the following code listing:.
The above code is fairly easy to understand. The first two lines in the main method create instances of our behaviors. The third line places them into an array, with the lowest priority behavior taking the lowest array index. The fourth line creates the Arbitrator, and the fifth line starts the Arbitration process. Nxt robot bumper car this program is started the robot will scurry forwards until it bangs into an object, then it will retreat, rotate, and continue with its forward movement until the power is shut off.
This seems like a lot of extra work for two simple behaviors, but now let's see how easy it is to insert a third behavior without altering any code in the other classes.
This is the part that makes behavior control systems very appealing for robotics programming. Our third behavior could be just about anything. We'll have this new behavior monitor the battery level and play a tune when it dips below a certain level.
Examine the completed Behavior:. The complete tune is stored in the note array at line 6 and the method to play the notes is at line This behavior will take control only if the current battery level is less the voltage specified in nxt robot bumper car constructor. The takeControl method looks a little inflated, and that's because it also displays the battery charge to the LCD display.
The action method is comparatively easy. Action nxt robot bumper car a bunch of noise, then exits the program. Since this behavior stops the program, we might get away without a a suppress method.
But just in case we detect a wall, while playing the tune, we use one. To insert this behavior into our scheme is a trivial task. We simply alter the code of our main class as follows:. The voltage level of the NXT at rest is different from the voltage when in action.
The voltage level at rest might be 7. Make sure the voltage threshold used in the BatteryLow constructor is low enough. This example beautifully demonstrates the real benefit of behavior control coding. Inserting a new behavior, no matter nxt robot bumper car the rest of the code looks like, is simple. The reason for this is grounded in object oriented design; each behavior is a self contained, independent object.
When creating a behavior control system, it is best to program each behavior one at a time and test them individually. If you code all the behaviors and then upload them all at once to the NXT brick, there is a good chance a bug will exist somewhere in the behaviors, making it difficult to locate.
By programming and testing them one at a time it makes it easier to identify where the problem was introduced. In order to understand why we recommend this design pattern, it is useful to dig a little deeper into the inner workings of the arbitrator. The Arbitrator contains a monitor thread that cycles through each of the nxt robot bumper car, checking the takeControl method to see if the behavior should become active. It starts with behavior of largest index because they are are stored in increasing priority order and works down the array.
As soon as it comes across a behavior that should take control, this is the highest priority behavior that wants control at the moment. If this behavior has higher priority than the active behavior, the monitor thread executes suppress on the active behavior, and then starts checking each behavior from the top again.
The main thread of the Arbitrator is very simple.
Ethereum Network Now Supports Tether- Issued USDT and EURT. Bitcoin Exchanges why are the prices so far apart. The second section. Read also: The risky business of bitcoin: High- profile cryptocurrency catastrophes of.