4.1 Subtasks in C++

A Little Background

Have you heard of “multithreading”?  Multithreading is the ability of a central processing unit (CPU), or a single core in a multi-core processor, to provide multiple threads of execution concurrently.  You may have also heard the term “hyperthreading.”  It’s the same thing, it’s just what Intel calls it.  The ability to do two things at once can be very useful, especially when you want to monitor something (like a sensor, for example) at all times (literally) and execute code the instant a condition changes favorably (or unfavorably).

We can make our robots do this by using multiple tasks.  We already know that the main task is what the robot runs when we execute the program.  What you may not know is that it’s the first and only task the robot will execute without being explicitly told to do so.  Hence the name “main.”  All other tasks, if they are to be run, must be defined prior to the main task and then initiated from within the main task.  The robot will then continue to run the main task while simultaneously running the sub task you initiated.

The Emergency Stop Button

In this example, we are going to create an emergency stop button.  This is a useful piece of code you should probably put into your template code so that it’ll show up in every program you write.  It will disable the motors if you press X on the controller.  It comes in very handy when you’re testing code and the robot starts going rogue.  Runaway robots are no longer a problem as long as this handy subtask is running in the background.  Just press X and everything stops!

We will achieve this by having a sub task monitor the X button on the controller using a loop.  If it is pressed, it will then read through and execute our code which will stop our motors repetitively.  Originally this code also included the task::stopAll(); command which would stop all tasks including the main task.  Inexplicably, this changed and the command no longer stops the main task.  As a workaround, the code we will be using will execute stop motor commands in an infinite loop that will defeat any physical actions the main task attempts to initiate.

STEP 1: Create a subtask

Do this before your main task (int main).  In my example, I created it on line 31.  Simply write “int” followed by the name you wish to call it and then empty parameters ( )

Why int?  Good question.  As you know, int stands for integer, a type of variable.  Whenever you create a task, the robot needs to evaluate the beginning and end of the task.  It’s looking for a way to confirm the task has run successfully.  In order to do that, it needs to “return” something to prove it ended successfully.  That “thing” will be a simple integer to prove it’s done.  Below, we’ll see this in action.

STEP 2 Create your loop

While(true) is an infinite loop and will work well for us here.  Insert the code you wish to execute in the curlies following it (see below).  In this example you can see we have set an if statement to check if Button X is being pressed.  If not, it skips the code group below it and waits 10 milliseconds.  You can set that wait value to anything you wish, but you should be sure to include it so that the CPU does not have to work so hard.  If Button X is pressed, it will execute the stop commands that follow.  This will effectively end your code!

Notice the return(0); command at the bottom.  This is where we allow the robot to prove to itself that the subtask finished.  Ironically, it will never return that elusive 0 because only two possibilities exist:  The if statement is either true of false.  If it’s false, it will remain in the loop forever.  If it is true, it will execute the code which will terminate all tasks before it can exit the loop.  But it doesn’t matter, you still need it because the compiler will be looking for it.   So why don’t you need to put return(0); at the end of your main task?  Well, you can.  It’ll let you.  But the main task has an assumed return(0); inserted by the VEXcode Pro V5 gods, so it’s not necessary.  Some would consider it good practice to put it in just the same.

STEP 3 Run your subtask

Now you must run it.  Remember that the subtask will not run unless you tell it to start somewhere inside your main task.  For this example, we should start it right away.  To do this, use the vex::task command.  This should be followed by the letter t with the name of your subtask in parentheses:

Why t?  Another good question.  Some smarty pants decided t for task would be appropriate.  Fun fact, though, you can run more than one sub task by using t1, t2, etc.  Basically, t becomes associated with that specific task, so it can’t be reused, so add a numeric value to distinguish them.

FINALLY

Now let’s put it all together and look at the complete code:

BONUS CONTENT!

What if I want to stop a running subtask without stopping the main task?  Simply use the t.stop(TASKNAME); command.

Thanks to Jay Fulreader for lending me his code.  I made it better, of course, but I did use his code to start this.