Multitasking [sticky] - When and When Not to Multitask

bfeher · Wed Jun 22, 2011 1:17 pm

Multitasking is when the robot performs multiple complex behaviors at the same time (simultaneously). If a robot performs behaviors step-by-step (sequentially) then it is not multitasking and should not be programmed with multiple tasks. Let’s look at few examples and determine whether or not multitasking should be used.

A robot drives forward until the sonar sensor sees and object at 30 cm or less away, turns right and stops.

A flowchart of this program would look like this:


	Code: Program starts, Motors start going forward, Keep going until the sonar sees something <= 30 cm, Turn right (right motor negative, left motor positive), Stop (both motors at 0), End Program.

As you can see, this program is sequential because each step comes after the one above it. We DO NOT use multitasking in this example. Let’s look at another:

A robot follows a line until it is 20 cm or less away from a basket and then drops a ball into the basket.

A flowchart of this program would look like this:


	Code: Program starts, Sonar starts checking for objects <= 20 cm away, Light sensor reads dark: Motors turn slightly one direction, Light sensor reads light: Motors turn slightly in the other direction, Sonar sees the basket <= 20 cm away, Motors stop, Arm motor starts and drops ball into basket, End Program.

This program also runs from top-to bottom, but this time we have a sonar sensor and a light sensor that are checking their values and performing behaviors at the same time.
Should we use multiple tasks here? No because we can combine the multiple behaviors into a single task like this:


	Code: task main() { // do the things in this loop while the sonar sensor is > 30 cm while(SensorValue(sonar) > 30) { // follow line: if(SensorValue(lineFollower) < threshold) { // turn sligtly one direction motor[rightMotor] = 50; motor[leftMotor] = 0; } else { // turn slightly in the other direction motor[rightMotor] = 0; motor[leftMotor] = 50; } } // stop motors and dump ball into basket: motor[rightMotor] = 0; motor[leftMotor] = 0; motor[armMotor] = 25 wait1Msec(1000); motor[armMotor] = 0; }

When multiple behaviors can be combined into a single task, we should always choose to do so instead of multitasking!

When should one use multitasking then? Imagine a program that drives a robot around a room vacuuming up objects while avoiding people. The robot comes with an emergency stop button just incase the systems for avoiding people fail or the robot uprising begins and we need to deactivate our robot quickly (in the real world, kill switches are important for human safety). How would a flowchart for this program look like? It is difficult to make a linear step-by-step chart for this program because it is doing multiple things at the same time. Also, the emergency stop button needs constantly be checking while other behaviors are running because the robot must stop immediately when the button is pressed, no matter what else it may be doing at the time. We need multiple flow charts side-by-side:

Driving flowchart:


	Code: Start program, Turn on vacuum, Start driving around, If sonar sees a person: stop motors, turn off vacuum, Sonar no longer sees person: turn on vacuum, contine driving around, Loop back to start of program.

E-stop flowchart:


	Code: Begin loop: If E-stop button pressed: End Program. If E-stop button not pressed: Go back to top of loop,

The actual program would look something like this:


	Code: task e_stop() { while(true) { if(SensorValue(e_stopBtn) == 1) { StopAllTasks(); // this ends the program } wait1Msec(10); // this prevents the current task from hogging the CPU } } task main() { StartTask(e_stop); while(true) { if(SensorValue(sonar) <= 10) { motor[rightMotor] = 0; motor[leftMotor] = 0; motor[vacuumMotor] = 0; } else { // code for driving around room here } wait1Msec(10); // this prevents the current task from hogging the CPU } }

Notice that even though behavior for picking up objects and the behavior for avoiding people are running at the same time, they can be combined into a single task. However, the emergency stop button requires a task on its own that runs in the background while the other behaviors are also running. Also please note the two “wait1Msec” commands that prevent each task from hogging the CPU. If a task doesn’t have any waiting in it, it may hog the CPU meaning that it will not let any other tasks run.

It’s important to remember that task main is the main task of the program and when it finishes execution, all other tasks will be force-quit and the program will end. In our example, task main was always in a while(true) loop and didn’t end until task e_stop stopped all tasks.

This very basic example shows a good use for when to use multitasking, however many very important and dangerous concepts have not been addressed.
I encourage those who wish to know more to research Multitasking (multi threading) in C.

Remember:
99% of all ROBOTC programs can be written without multiple tasks if you combine related behaviors!
and
99.9% of all errors in programs that use multitasking are because of improper use of multitasking!!

Multitasking [sticky] - When and When Not to Multitask

Who is online