Sending variables to Auto Mode

[Adrien]

Hey,

As ship date ominously approaches, our team is scrambling to get some testing in. Currently our robot is set up to do all three autonomous positions (forward, middle, and back) however I've had some problems setting up our toggle switch so we can quickly toggle between positions.

Basically we've got a custom 3-state DPDT switch hooked up to our OI through Port 3 so that Switch Forward makes p3_sw_trig true, and switch back makes p3_sw_top true... if you know what I mean.

Anyway, the 3-state switch is used to determine our position in autonomous, but we also use it for harvesting and expelling balls in manual mode. It works properly in manual mode so I know it's wired and working properly. Getting it to work with auto mode is not so successful. Let me show you what I have set up:

main.c:

char position = 0;

void main (void)
{
#ifdef UNCHANGEABLE_DEFINITION_AREA
  IFI_Initialization ();        /* DO NOT CHANGE! */
#endif

  User_Initialization();        /* You edit this in user_routines.c */

  statusflag.NEW_SPI_DATA = 0;  /* DO NOT CHANGE! */ 

  while (1)   /* This loop will repeat indefinitely. */
  {
#ifdef _SIMULATOR
    statusflag.NEW_SPI_DATA = 1;
#endif

    if (statusflag.NEW_SPI_DATA)      /* 26.2ms loop area */
    {                                 /* I'm slow!  I only execute every 26.2ms because */
                                      /* that's how fast the Master uP gives me data. */
      position = Process_Data_From_Master_uP();   /* You edit this in user_routines.c */

      if (autonomous_mode)            /* DO NOT CHANGE! */
      {
		printf("Main: p: %d\r\n",(int)position);
        User_Autonomous_Code(position);        /* You edit this in user_routines_fast.c */
      }
    }
    Process_Data_From_Local_IO();     /* You edit this in user_routines_fast.c */
                                      /* I'm fast!  I execute during every loop.*/
  } /* while (1) */
}  /* END of Main */

user_routines.c:

char pos = 0;

char Process_Data_From_Master_uP(void)
{

	Getdata(&rxdata);
/* Camera and other important Stuff... */

	if(trig_fwd) //trig_fwd is p3_sw_trig
	{
		pos = 0;
	}
	else if(trig_rev) //trig_rev is p3_sw_top
	{
		pos = 2;
	}
	else
	{
		pos = 1;
	}
	Putdata(&txdata);

return pos;
}

user_routines_fast.c:

void User_Autonomous_Code(char position)
{
/* Important Stuff */

 while (autonomous_mode)   /* DO NOT CHANGE! */
  {
    if (statusflag.NEW_SPI_DATA)      /* 26.2ms loop area */
    {
        Getdata(&rxdata);   /* DO NOT DELETE, or you will be stuck here forever! */

		if(position == 0)
		{
                            // Auto Stuff
		}
		else if(position == 1)
		{
                            // Auto Stuff
		}
		else
		{
                            // Auto Stuff
		}
        Putdata(&txdata);   /* DO NOT DELETE, or you will get no PWM outputs! */
    }
  }
}

For some reason in user_routines.c, I think it falls through to the else so that pos=1 because no matter where the switch is, the position is always 1. So I do know the variable is being passed through he functions correctly, I just don't know why trig_fwd or trig_rev aren't being what they should be there... It looks like it should work to me, but maybe somebody will be able to find something messed up in the code.

Thanks for the help!

[Alan Anderson]

The problem is simple. When autonomous mode begins, all inputs from the OI are set to their neutral/off state. So neither trig_fwd nor trig_rev will be active when you read them the first time after the autonomous mode flag is set.

Fortunately, the solution too is simple. Instead of always calling Process_Data_From_Master_uP(), inside main(), only call it if you're not in autonomous mode. Make it the else clause of your if (autonomous_mode) statement. Make position a global (or static local) variable so you can use it later.

[Adrien]

Thanks for the response.

So basically you're saying that when autonomous_mode is true, everything from the OI is set to neutral, or off?

So that means when we're at the real competition, as soon as the bots are activated, they're put into autonomous mode, right? So that wouldn't work because it would never go to Process_Data_From_Master_uP()...

Although, when we start the bots up, they are running, but in a disabled state... Could the bots receive values from the OI before the match starts and then use them in auto mode? You know what I mean?

[jgannon]

Originally Posted by Adrien

Could the bots receive values from the OI before the match starts and then use them in auto mode?

Yes. The last values from the OI before autonomous starts, even when disabled, are available to you in autonomous mode.

[TimeOut]

Try this:

instead of of doing:
position = Process_Data_From_Master_uP();

do this:
if (!autonomous_mode) {
position = get_auto_mode();
}

The write a new function that all it does is return the position of the switch. We put ours in a seperate file that is just the TOLTECH's code.

During the disable and user modes you want the position to be updated. I'm not 100% sure how the game masters will transition to Autonomous. If they switch to autonomous BEFORE the loop hits the position assignment, then you'll get a 0 (or whatever you default case is). This solved the problem for us.

Sean

Originally Posted by jgannon

Yes. The last values from the OI before autonomous starts, even when disabled, are available to you in autonomous mode.