0% found this document useful (0 votes)
69 views6 pages

Defensesm

This document contains code for implementing a state machine called DefenseSM. It includes function definitions and documentation for the state machine's start, run, and during functions. The state machine uses states like DefDrive4Offset and Wait4Reload and processes events like EV_Y_TARGET_REACHED and ES_TIMEOUT to transition between states and perform behaviors like stopping the robot or returning other events. The code includes constants, variable declarations, and a history of revisions made to improve the state machine implementation.

Uploaded by

api-397492879
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
69 views6 pages

Defensesm

This document contains code for implementing a state machine called DefenseSM. It includes function definitions and documentation for the state machine's start, run, and during functions. The state machine uses states like DefDrive4Offset and Wait4Reload and processes events like EV_Y_TARGET_REACHED and ES_TIMEOUT to transition between states and perform behaviors like stopping the robot or returning other events. The code includes constants, variable declarations, and a history of revisions made to improve the state machine implementation.

Uploaded by

api-397492879
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

#define DEFENSE_DEBUG

/****************************************************************************
Module
DefenseSM.c

Revision
2.0.1

Description
This is a template file for implementing state machines.

Notes

History
When Who What/Why
-------------- --- --------
02/27/17 09:48 jec another correction to re-assign both CurrentEvent
and ReturnEvent to the result of the During function
this eliminates the need for the prior fix and allows
the during function to-remap an event that will be
processed at a higher level.
02/20/17 10:14 jec correction to Run function to correctly assign
ReturnEvent in the situation where a lower level
machine consumed an event.
02/03/16 12:38 jec updated comments to reflect changes made in '14 & '15
converted unsigned char to bool where appropriate
spelling changes on true (was True) to match standard
removed local var used for debugger visibility in 'C32
commented out references to Start & RunLowerLevelSM so
that this can compile.
02/07/13 21:00 jec corrections to return variable (should have been
ReturnEvent, not CurrentEvent) and several EV_xxx
event names that were left over from the old version
02/08/12 09:56 jec revisions for the Events and Services Framework Gen2
02/13/10 14:29 jec revised Start and run to add new kind of entry function
to make implementing history entry cleaner
02/13/10 12:29 jec added NewEvent local variable to During function and
comments about using either it or Event as the return
02/11/10 15:54 jec more revised comments, removing last comment in during
function that belongs in the run function
02/09/10 17:21 jec updated comments about internal transitions on During
funtion
02/18/09 10:14 jec removed redundant call to RunLowerlevelSM in EV_Entry
processing in During function
02/20/07 21:37 jec converted to use enumerated type for events & states
02/13/05 19:38 jec added support for self-transitions, reworked
to eliminate repeated transition code
02/11/05 16:54 jec converted to implment hierarchy explicitly
02/25/03 10:32 jec converted to take a passed event parameter
02/18/99 10:19 jec built template from MasterMachine.c
02/14/99 10:34 jec Began Coding
****************************************************************************/
/*----------------------------- Include Files -----------------------------*/
// Basic includes for a program using the Events and Services Framework
#include "ES_Configure.h"
#include "ES_Framework.h"
//#include <stdio.h>
//#include "ES_Port.h"
//#include "ES_DeferRecall.h"
#include "ES_Timers.h"
//#include "termio.h"
//#include "BITDEFS.h" // standard bit definitions to make things more readable
/* include header files for this state machine as well as any machines at the
next lower level in the hierarchy that are sub-machines to this machine
*/
#include "DefenseSM.h"
#include "Beacon.h"
//#include "ReloadSensor.h"
#include "DCMotor.h"

/*----------------------------- Module Defines ----------------------------*/


// define constants for the states for this machine
// and any other local defines
#define ENTRY_STATE DefDrive4Offset
#define RED 1
#define BLUE 0

//Assume 1000 ticks per sec

#define ONE_SEC 1000


#define ROTATE_TIME 0.2*ONE_SEC //rotation time per time
#define D4O_TIME 0.5*ONE_SEC
#define D2R_TIME 3*ONE_SEC //drive to reload station time
#define TURN_TIME 2*ONE_SEC
#define FW_TIME 2*ONE_SEC
#define BW_TIME 2*ONE_SEC

//motor defines
#define Forward 0
#define Backward 1
#define CWTurn 2
#define CCWTurn 3
#define LeftMotor 0
#define RightMotor 1

#define DriveSpeed 20
#define TurnSpeed 10

#define P5X 1235


#define P5Y 930

/*---------------------------- Module Functions ---------------------------*/


/* prototypes for private functions for this machine, things like during
functions, entry & exit functions.They should be functions relevant to the
behavior of this state machine
*/
static ES_Event_t DuringDrive4Offset(ES_Event_t Event);
static ES_Event_t DuringWait4Reload(ES_Event_t Event);

/*---------------------------- Module Variables ---------------------------*/


// everybody needs a state variable, you may need others as well
static DefenseState_t CurrentState;
static uint16_t TEAM = 1; //set default team color to red

/*------------------------------ Module Code ------------------------------*/


/****************************************************************************
Function
RunDefenseSM

Parameters
ES_Event: the event to process

Returns
ES_Event: an event to return

Description
add your description here
Notes
uses nested switch/case to implement the machine.
Author
J. Edward Carryer, 2/11/05, 10:45AM
****************************************************************************/
ES_Event_t RunDefenseSM( ES_Event_t CurrentEvent )
{
bool MakeTransition = false;/* set MakeTransition to false */
DefenseState_t NextState = CurrentState;
ES_Event_t EntryEventKind = { ES_ENTRY, 0 };// default to normal entry to new
state
ES_Event_t ReturnEvent = CurrentEvent; // assume we are not consuming event

switch ( CurrentState )
{
case DefDrive4Offset : // If current state is DefDrive4Offense
// Execute During function for this state. ES_ENTRY & ES_EXIT are
// processed here allow the lower level state machines to re-map
// or consume the event
ReturnEvent = CurrentEvent = DuringDrive4Offset(CurrentEvent);
//process any events
if ( CurrentEvent.EventType != ES_NO_EVENT ) //If an event is active
{
switch (CurrentEvent.EventType)
{
case EV_Y_TARGET_REACHED : //if this event is EV_Y_TARGET_REACHED
//stop the robot
StopRobot();
NextState = Wait4Reload;//Decide the next state to be Wait4Reload
// for internal transitions, skip changing MakeTransition
MakeTransition = true; //mark that we are taking a transition
// if transitioning to a state with history change kind of entry
EntryEventKind.EventType = ES_ENTRY_HISTORY;
// optionally, consume or re-map this event for the upper
// level state machine
ReturnEvent.EventType = ES_NO_EVENT;
break;
default:
;
// repeat cases as required for relevant events
}
}
break;
// repeat state pattern as required for other states
case Wait4Reload : // If current state is Wait4Reload
// Execute During function for state one. ES_ENTRY & ES_EXIT are
// processed here allow the lower level state machines to re-map
// or consume the event
ReturnEvent = CurrentEvent = DuringWait4Reload(CurrentEvent);
//process any events
if ( CurrentEvent.EventType != ES_NO_EVENT ) //If an event is active
{
switch (CurrentEvent.EventType)
{
case ES_TIMEOUT : //if this event is ES_TIMEOUT from SHOTCLK
if (CurrentEvent.EventParam == SHOTCLK)
{
NextState = Wait4Reload;//Decide the next state to be
Wait4Reload
// for internal transitions, skip changing MakeTransition
MakeTransition = false; //mark that we are not taking a
transition
// if transitioning to a state with history change kind of entry
EntryEventKind.EventType = ES_ENTRY_HISTORY;
// optionally, consume or re-map this event for the upper
// level state machine
ReturnEvent.EventType = EV_DEFENSE_RELOAD; //we return
EV_DEFENSE_RELOAD to upper level machine
//so that we can transite to FaceOff state to reload
}
break;
default:
;
// repeat cases as required for relevant events
}
}
break;

// repeat state pattern as required for other states


}
// If we are making a state transition
if (MakeTransition == true)
{
// Execute exit function for current state
CurrentEvent.EventType = ES_EXIT;
RunDefenseSM(CurrentEvent);

CurrentState = NextState; //Modify state variable

// Execute entry function for new state


// this defaults to ES_ENTRY
RunDefenseSM(EntryEventKind);
}
return(ReturnEvent);
}
/****************************************************************************
Function
StartDefenseSM

Parameters
None

Returns
None

Description
Does any required initialization for this state machine
Notes

Author
J. Edward Carryer, 2/18/99, 10:38AM
****************************************************************************/
void StartDefenseSM ( ES_Event_t CurrentEvent )
{
// to implement entry to a history state or directly to a substate
// you can modify the initialization of the CurrentState variable
// otherwise just start in the entry state every time the state machine
// is started

CurrentState = ENTRY_STATE;

//grab team color info


TEAM = CurrentEvent.EventParam; //grab TEAM color info

// call the entry function (if any) for the ENTRY_STATE


RunDefenseSM(CurrentEvent);
}
/****************************************************************************
Function
QueryDefenseSM

Parameters
None

Returns
TemplateState_t The current state of the Template state machine

Description
returns the current state of the Template state machine
Notes

Author
J. Edward Carryer, 2/11/05, 10:38AM
****************************************************************************/
DefenseState_t QueryDefenseSM ( void )
{
return(CurrentState);
}

/***************************************************************************
private functions
***************************************************************************/
static ES_Event_t DuringDrive4Offset( ES_Event_t Event)
{
ES_Event_t ReturnEvent = Event; // assume no re-mapping or consumption

// process ES_ENTRY, ES_ENTRY_HISTORY & ES_EXIT events


if ( (Event.EventType == ES_ENTRY) ||
(Event.EventType == ES_ENTRY_HISTORY) )
{
// implement any entry actions required for this state machine
//upon entering this state, we start a timer and start to drive the robot

//set the robot to move backward to (P5X, P5Y) which is roughly


//the center of the field so that we can go to reload station later
SetRobotDir(Backward);
SetRobotSpeed(LeftMotor, DriveSpeed);
SetRobotSpeed(RightMotor, DriveSpeed);
SetTargetPosition(P5X, P5Y);

// after that start any lower level machines that run in this state
//StartLowerLevelSM( Event );
// repeat the StartxxxSM() functions for concurrent state machines
// on the lower level
}
else if ( Event.EventType == ES_EXIT )
{
// on exit, give the lower levels a chance to clean up first
//RunLowerLevelSM(Event);
// repeat for any concurrently running state machines
// now do any local exit functionality

}else
// do the 'during' function for this state
{
// run any lower level state machine
// ReturnEvent = RunLowerLevelSM(Event);

// repeat for any concurrent lower level machines


// do any activity that is repeated as long as we are in this state
}
// return either Event, if you don't want to allow the lower level machine
// to remap the current event, or ReturnEvent if you do want to allow it.
return(ReturnEvent);
}

static ES_Event_t DuringWait4Reload( ES_Event_t Event)


{
ES_Event_t ReturnEvent = Event; // assume no re-mapping or consumption

// process ES_ENTRY, ES_ENTRY_HISTORY & ES_EXIT events


if ( (Event.EventType == ES_ENTRY) ||
(Event.EventType == ES_ENTRY_HISTORY) )
{
// implement any entry actions required for this state machine
//upon entering this state, we start a timer and start to drive the robot

// Start Timer for waiting for reload


ES_Timer_InitTimer(SHOTCLK, ONE_SEC*2);
// after that start any lower level machines that run in this state
//StartLowerLevelSM( Event );
// repeat the StartxxxSM() functions for concurrent state machines
// on the lower level
}
else if ( Event.EventType == ES_EXIT )
{
// on exit, give the lower levels a chance to clean up first
//RunLowerLevelSM(Event);
// repeat for any concurrently running state machines
// now do any local exit functionality

}else
// do the 'during' function for this state
{
// run any lower level state machine
// ReturnEvent = RunLowerLevelSM(Event);

// repeat for any concurrent lower level machines

// do any activity that is repeated as long as we are in this state


}
// return either Event, if you don't want to allow the lower level machine
// to remap the current event, or ReturnEvent if you do want to allow it.
return(ReturnEvent);
}

You might also like