Multiple command_lists

[Jon236]

In the Navigation code I downloaded, it is apparent that the command_list data structure contained in commands.h provides a list of actions for the robot to accomplish. Using robot_command(), one can call this from either the autonomous or the manual mode. But how can we create multiple lists of commands to be used from various autonomous programs? Can we re-create the data structure in different iterations in a .c file?

Kevin, I would feel a lot better if you moved a little farther from the cliff!


Jon Mittelman
Team 236 Mentor

[Chris_Elston]

Originally Posted by Jon236

In the Navigation code I downloaded, it is apparent that the command_list data structure contained in commands.h provides a list of actions for the robot to accomplish. Using robot_command(), one can call this from either the autonomous or the manual mode. But how can we create multiple lists of commands to be used from various autonomous programs? Can we re-create the data structure in different iterations in a .c file?

Kevin, I would feel a lot better if you moved a little farther from the cliff!


Jon Mittelman
Team 236 Mentor

If it was me, we have used thumb wheels in the form of binary input to some digital I/O. So we work out which program we are going to run before the match starts, set the thumb wheel to select the program we want to run. In code it sort of looks like this:

if (thumb_wheel = 1)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}


if (thumb_wheel = 2)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}

if (thumb_wheel = 3)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}

[Jon236]

Originally Posted by chakorules

If it was me, we have used thumb wheels in the form of binary input to some digital I/O. So we work out which program we are going to run before the match starts, set the thumb wheel to select the program we want to run. In code it sort of looks like this:

if (thumb_wheel = 1)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}


if (thumb_wheel = 2)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}

if (thumb_wheel = 3)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}

Godd idea....but what I was wondering was how to list the different lists...can you put them in different .h files or all in the code files?

[Jon236]

Originally Posted by chakorules

If it was me, we have used thumb wheels in the form of binary input to some digital I/O. So we work out which program we are going to run before the match starts, set the thumb wheel to select the program we want to run. In code it sort of looks like this:

if (thumb_wheel = 1)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}


if (thumb_wheel = 2)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}

if (thumb_wheel = 3)
	{
	do these commands;
	do these commands;
	do these commands;
	do these commands;
	}

Good idea....but what I was wondering was how to list the different lists...can you put them in different .h files or all in the code files?

[devicenull]

That depends. Multiple header files will work, if you call each array in them a different name, then you can use code similar to above, and call the correct command on each array.

[Kevin Watson]

Originally Posted by Jon236

In the Navigation code I downloaded, it is apparent that the command_list data structure contained in commands.h provides a list of actions for the robot to accomplish. Using robot_command(), one can call this from either the autonomous or the manual mode. But how can we create multiple lists of commands to be used from various autonomous programs? Can we re-create the data structure in different iterations in a .c file?

Actually, Rich Petras, another JPL engineer wrote this code. I talked with Rich tonight and he said that when he gets a chance, he wants to add conditional branching to the code, which will make it easier to do what you want. If he doesn't get to it in the next few days, I'll start working on it.

Originally Posted by Jon236

Kevin, I would feel a lot better if you moved a little farther from the cliff!

In which direction <grin>?

-Kevin

[Anthony Kesich]

I would suggest making a two dimentional array.

Example commands.h file:

#define AUTO_MODE 1

struct commands command_list[][] =
     {
          {Set 0 of autonomous commands;}
     },
     {
          {set 1 of autonomous commands;}
     },
     {
          {set 2 of autonomous commands;}
     }

Example robot.c code:

switch (command_list[AUTO_MODE][current_command].command)
  {
  case NULL:
    {
	rc = 0;    // We don't want to increment to the next command
    break;
    }

  case CMD_SHOW_STATE:
    {
    rc = cmd_show_state();
    break;
    }
...so on and so forth

Anyways, this allows for multiple programs that change with one macro definition. If you're worried about space, just have multiple codes in you commands.h file, and comment them all out except for the one you want.

This array decliration can also be used if you have multiple programs and want to change between them with a switch on the robot without recompiling and downloading. Just replace the macro definition with the input source.

-Tony K

[Astronouth7303]

What I did was redid the code so that it accessed a pointer to the array, than made that pointer an argument:

struct commands *command_list;
//...
void robot_control(struct commands *script)
{
robot_command(script);
robot_timer();
robot_position();
}

void robot_command(struct commands *script)
{
//...
}

Of course, I also macro'ed access to the elements in the array, which makes such changes easy:

#define GET_COMMAND(index) command_list[(index)]
#define CUR_COMMAND GET_COMMAND(current_command)
#define COMMAND CUR_COMMAND.command
#define PARAM1 CUR_COMMAND.parm_1
#define PARAM2 CUR_COMMAND.parm_2
#define PARAM3 CUR_COMMAND.parm_3

So my autonomous mode is now:

    robot_control(default_script);

After you set all of this up, you can easily add something to select which mode.

[Rich Petras]

[quote=Jon236]In the Navigation code I downloaded, it is apparent that the command_list data structure contained in commands.h provides a list of actions for the robot to accomplish. Using robot_command(), one can call this from either the autonomous or the manual mode. But how can we create multiple lists of commands to be used from various autonomous programs? Can we re-create the data structure in different iterations in a .c file?

Kevin suggested that I jump in and answer this one. (He doesn't want to take the blame if you find any errors in my part of the code.)

There are a couple of ways to do what you want. A trivial one is to write a version
of CMD_JUMP that jumps within the existing command list based on a DIO signal.

If you want to get fancy, you could write a command that rewrites the whole command list. It is a variable after all, and not a constant. Just remember to allocate an array big
enough to hold your largest sequence. You would probably want to reset your command number to zero before the next pass through the loop too.

I looked at a few of the suggestions others have made. Any of them will work, but it can make it hard to share commands if you change the underlying operation. I tried to avoid pointers, this is the elegant solution, but so many people get screwed up by pointers that we thought it might be better to not do that.