?? hamaro_fsm.c
字號:
/* hamaro_fsm.c */
/*+++ *******************************************************************\
*
* Abstract:
*
* Hamaro FSM framework implementation file.
*
* Created: 07/15/2005
*
*
* Copyright and Disclaimer:
*
* ---------------------------------------------------------------
* This software is provided "AS IS" without warranty of any kind,
* either expressed or implied, including but not limited to the
* implied warranties of noninfringement, merchantability and/or
* fitness for a particular purpose.
* ---------------------------------------------------------------
*
* Author: Amar Puttur
*
* Module Revision Id:
*
* $Header: hamaro_fsm.c, 5, 2006-10-20 7:01:12, Sunbey (VSS Migration)$
*
* Copyright (c) 2005 Conexant Systems, Inc.
* All rights reserved.
*
\******************************************************************* ---*/
#include "hamaro_fsm.h"
#if HAMARO_SCAN_THE_SKY
#include "hamaro_sts.h"
#if HAMARO_WIN_DEBUG
#define STSDBG_WR_INT_LN(str, val) (WINDBG_WriteIntegerLn((char*)(str), val))
#define STSDBG_WR_INT(str, val) (WINDBG_WriteInteger((char*)(str), val))
#define STSDBG_WR_HEX(str, val) (WINDBG_WriteHex((char*)(str), val))
#define STSDBG_WR_UNSIGNED_LN(str, val) (WINDBG_WriteUnsignedLn((char*)(str), val))
#define STSDBG_WR_UNSIGNED(str, val) (WINDBG_WriteUnsigned((char*)(str), val))
#define STSDBG_WR_STR(str, nl) (WINDBG_WriteString((char*)(str), nl))
#define STSDBG_WR_ELAPSED_TIME() (WINDBG_FileWriteDuration())
#define STSDBG_START_TIMER() (WINDBG_SetTimer()) /* used for time measurements */
#else // HAMARO_WIN_DEBUG
#define STSDBG_WR_INT_LN(str, val) /* Expands to nothing */
#define STSDBG_WR_INT(str, val) /* Expands to nothing */
#define STSDBG_WR_UNSIGNED_LN(str, val) /* Expands to nothing */
#define STSDBG_WR_UNSIGNED(str, val) /* Expands to nothing */
#define STSDBG_WR_STR(str, nl) /* Expands to nothing */
#define STSDBG_WR_ELAPSED_TIME() /* Expands to nothing */
#define STSDBG_START_TIMER() /* Expands to nothing */
#endif /* HAMARO_WIN_DEBUG */
/* Common state for all FSMs */
STATE idle_state = {0, {0, 0}, 0, 0, 0};
#if HAMARO_INCLUDE_DEBUG
static FSM_STATE_SEQUENCE_DATA fsm_sequence_data[STS_MAX_STATE_SEQUENCES+1];
/* Array indices - used to manage the data points and array limits */
static unsigned char sequence_index;
#endif /* HAMARO_INCLUDE_DEBUG */
/*****************************************************************************/
/* FSM_Init() */
/* */
/*****************************************************************************/
void
FSM_Init(FSM *fsm)
{
fsm->p_prev = &idle_state;
fsm->p_curr = &idle_state;
fsm->time_counter = 0;
}
/*****************************************************************************/
/* FSM_Poll() */
/* */
/*****************************************************************************/
void
FSM_Poll(FSM *fsm)
{
unsigned long tmp;
CRITERIA *curr_criterion;
/* update state coding */
tmp = *fsm->p_state_code;
tmp &= ~(fsm->state_code_mask);
tmp |= (fsm->p_curr->coding && fsm->state_code_mask);
*fsm->p_state_code = tmp;
/* Optimization: Exit state machine immediately in case it's not started yet. */
if (fsm->p_curr == &idle_state)
{
return;
}
if (fsm->p_prev != fsm->p_curr) /* state transition */
{
DBG_UPDATE_STATE_SEQUENCE(fsm->p_curr->coding);
fsm->time_counter = 0;
if (1 == fsm->p_curr->counter_type)
{
fsm->last_time_value = 0; /* TBD: Get system clock ticks in msec; */
}
if (fsm->p_curr->enter_task) /* execute the enter task once */
{
fsm->p_curr->enter_task();
}
fsm->p_prev = fsm->p_curr;
}
if (fsm->p_curr->regular_task) /* regular task run every poll */
{
fsm->p_curr->regular_task();
}
/* start executing criterion and corresponding exit tasks one by one */
curr_criterion = &fsm->p_curr->criteria[0];
while(curr_criterion->condition) /* criterion exist/valid */
{
if (curr_criterion->condition(fsm->time_counter)) /* criterion returns True */
{ /* execute the exit task to transit to some other state */
fsm->p_curr = curr_criterion->exit_task();
break;
}
++curr_criterion;
}
/* keep accumulating timer ticks (delta) */
/* This is optionally implemented when state transition criterions start using timeouts */
if (1 == fsm->p_curr->counter_type)
{
tmp = 0; /* TBD : Get system clock ticks in msec; */
fsm->time_counter += (tmp >= fsm->last_time_value ?
(unsigned long)(tmp-fsm->last_time_value) :
(unsigned long)0xFFFF-( unsigned long)(fsm->last_time_value-tmp));
fsm->last_time_value = tmp;
}
}
/*****************************************************************************/
/* FSM_CheckState() */
/* Checks if the given FSM is in the requested state */
/*****************************************************************************/
BOOL
FSM_CheckState(FSM *fsm, unsigned long state)
{
if (fsm == 0)
{
return (False);
}
if (fsm->p_curr->coding == state)
{
return (True);
}
else
{
return (False);
}
}
/*****************************************************************************/
/* D E B U G S E C T I O N */
/*****************************************************************************/
#if HAMARO_INCLUDE_DEBUG
/*****************************************************************************/
/* DEBUG_Init() */
/* */
/*****************************************************************************/
void DEBUG_Init()
{
unsigned char index;
for (index = 0; index < STS_MAX_STATE_SEQUENCES; index++)
{
fsm_sequence_data[index].state = 0;
fsm_sequence_data[index].time_spent = 0;
}
sequence_index = 0;
}
/*****************************************************************************/
/* DEBUG_UpdateTimeSpent() */
/* */
/*****************************************************************************/
void DEBUG_UpdateTimeSpent(unsigned short time)
{
time = 0; /* TBD */
}
/*****************************************************************************/
/* DEBUG_UpdateStateSequence() */
/* */
/*****************************************************************************/
void DEBUG_UpdateStateSequence(unsigned long state)
{
if (sequence_index < STS_MAX_STATE_SEQUENCES)
{
fsm_sequence_data[sequence_index].state = state;
sequence_index++;
}
}
/*****************************************************************************/
/* DEBUG_DumpStateSequence() */
/* */
/*****************************************************************************/
void DEBUG_DumpStateSequence()
{
unsigned char index;
STSDBG_WR_STR("\nState sequence...\n-----------------\n", False);
for (index = 0; index < sequence_index; index++)
{
STSDBG_WR_INT_LN("State: ", fsm_sequence_data[index].state);
}
}
/* Debug functions to set and get state_limits */
static unsigned long state_code_limits;
/*****************************************************************************/
/* DEBUG_CheckFSMLimits() */
/* */
/*****************************************************************************/
void
DEBUG_SetFSMLimits(unsigned long limits)
{
state_code_limits = limits;
}
/*****************************************************************************/
/* DEBUG_CheckFSMLimits() */
/* */
/*****************************************************************************/
static unsigned long
DEBUG_GetFSMLimits(void)
{
return state_code_limits;
}
/*****************************************************************************/
/* DEBUG_StateCode2String() */
/* */
/*****************************************************************************/
static void
DEBUG_StateCode2String(unsigned long coding)
{
#if HAMARO_WIN_DEBUG
STSDBG_WR_HEX("FSM State = ", coding);
switch (coding)
{ /* STS FSM */
case STS_RESET_STATE: STSDBG_WR_STR("[STS_RESET_STATE]", True); break; /* 1 */
case STS_PWRSCAN_STATE: STSDBG_WR_STR("[STS_PWRSCAN_STATE]", True); break; /* 2 */
case STS_RISING_EDGE_STATE: STSDBG_WR_STR("[STS_RISING_EDGE_STATE]", True); break; /* 3 */
case STS_BINARY_SEARCH_STATE: STSDBG_WR_STR("[STS_BINARY_SEARCH_STATE]", True); break; /* 4 */
case STS_FALLING_EDGE_STATE: STSDBG_WR_STR("[STS_FALLING_EDGE_STATE]", True); break; /* 5 */
case STS_RESCAN_STATE: STSDBG_WR_STR("[STS_RESCAN_STATE]", True); break; /* 6 */
case STS_READY_STATE: STSDBG_WR_STR("[STS_READY_STATE]", True); break; /* 7 */
case STS_SRBIN_STATE: STSDBG_WR_STR("[STS_SRBIN_STATE]", True); break; /* 8 */
case STS_COMPLETE_STATE: STSDBG_WR_STR("[STS_COMPLETE_STATE]", True); break; /* 9 */
/* BINARY SEARCH FSM */
case BINSEARCH_RESET_STATE: STSDBG_WR_STR("[BINSEARCH_RESET_STATE]", True); break; /* (1 << 4) */
case BINSEARCH_BEGIN_STATE: STSDBG_WR_STR("[BINSEARCH_BEGIN_STATE]", True); break; /* (2 << 4) */
case BINSEARCH_CONVEX_STATE: STSDBG_WR_STR("[BINSEARCH_CONVEX_STATE]", True); break; /* (3 << 4) */
case BINSEARCH_CONCAVE_STATE: STSDBG_WR_STR("[BINSEARCH_CONCAVE_STATE]", True); break; /* (4 << 4) */
case BINSEARCH_READY_STATE: STSDBG_WR_STR("[BINSEARCH_READY_STATE]", True); break; /* (5 << 4) */
/* RISING EDGE FSM */
case RISEEDGE_UPHILL_STATE: STSDBG_WR_STR("[RISEEDGE_UPHILL_STATE]", True); break; /* (1 << 8) */
case RISEEDGE_DOWNHILL_STATE: STSDBG_WR_STR("[RISEEDGE_DOWNHILL_STATE]", True); break; /* (2 << 8) */
case RISEEDGE_FLAT_STATE: STSDBG_WR_STR("[RISEEDGE_FLAT_STATE]", True); break; /* (3 << 8) */
case RISEEDGE_TROUGH_STATE: STSDBG_WR_STR("[RISEEDGE_TROUGH_STATE]", True); break; /* (4 << 8) */
case RISEEDGE_PEAK_STATE: STSDBG_WR_STR("[RISEEDGE_PEAK_STATE]", True); break; /* (5 << 8) */
case RISEEDGE_UNKNOWN_STATE: STSDBG_WR_STR("[RISEEDGE_UNKNOWN_STATE]", True); break; /* (6 << 8) */
case RISEEDGE_RESET_STATE: STSDBG_WR_STR("[RISEEDGE_RESET_STATE]", True); break; /* (7 << 8) */
case RISEEDGE_READY_STATE: STSDBG_WR_STR("[RISEEDGE_READY_STATE]", True); break; /* (8 << 8) */
/* RISING RANGE FSM */
case RISERANGE_RESET_STATE: STSDBG_WR_STR("[RISERANGE_RESET_STATE]", True); break; /* (1 << 12) */
case RISERANGE_CONVEX_STATE: STSDBG_WR_STR("[RISERANGE_CONVEX_STATE]", True); break; /* (2 << 12) */
case RISERANGE_CONCAVE_STATE: STSDBG_WR_STR("[RISERANGE_CONCAVE_STATE]", True); break; /* (3 << 12) */
case RISERANGE_READY_STATE: STSDBG_WR_STR("[RISERANGE_READY_STATE]", True); break; /* (4 << 12) */
/* FALLING EDGE FSM */
case FALLEDGE_UPHILL_STATE: STSDBG_WR_STR("[FALLEDGE_UPHILL_STATE]", True); break; /* (1 << 16) */
case FALLEDGE_DOWNHILL_STATE: STSDBG_WR_STR("[FALLEDGE_DOWNHILL_STATE]", True); break; /* (2 << 16) */
case FALLEDGE_FLAT_STATE: STSDBG_WR_STR("[FALLEDGE_FLAT_STATE]", True); break; /* (3 << 16) */
case FALLEDGE_TROUGH_STATE: STSDBG_WR_STR("[FALLEDGE_TROUGH_STATE]", True); break; /* (4 << 16) */
case FALLEDGE_PEAK_STATE: STSDBG_WR_STR("[FALLEDGE_PEAK_STATE]", True); break; /* (5 << 16) */
case FALLEDGE_UNKNOWN_STATE: STSDBG_WR_STR("[FALLEDGE_UNKNOWN_STATE]", True); break; /* (6 << 16) */
case FALLEDGE_RESET_STATE: STSDBG_WR_STR("[FALLEDGE_RESET_STATE]", True); break; /* (7 << 16) */
case FALLEDGE_ABORT_STATE: STSDBG_WR_STR("[FALLEDGE_ABORT_STATE]", True); break; /* (8 << 16) */
case FALLEDGE_READY_STATE: STSDBG_WR_STR("[FALLEDGE_READY_STATE]", True); break; /* (9 << 16) */
/* FALLING RANGE FSM */
case FALLRANGE_RESET_STATE: STSDBG_WR_STR("[FALLRANGE_RESET_STATE]", True); break; /* (1 << 20) */
case FALLRANGE_CONVEX_STATE: STSDBG_WR_STR("[FALLRANGE_CONVEX_STATE]", True); break; /* (2 << 20) */
case FALLRANGE_CONCAVE_STATE: STSDBG_WR_STR("[FALLRANGE_CONCAVE_STATE]", True); break; /* (3 << 20) */
case FALLRANGE_PRE_READY_STATE: STSDBG_WR_STR("[FALLRANGE_PRE_READY_STATE]", True);break; /* (4 << 20) */
case FALLRANGE_READY_STATE: STSDBG_WR_STR("[FALLRANGE_READY_STATE]", True); break; /* (5 << 20) */
/* SYMB RATE BIN FSM */
case SRBIN_RESET_STATE: STSDBG_WR_STR("[SRBIN_RESET_STATE]", True); break; /* (1 << 24) */
case SRBIN_NEXT_CHANNEL_STATE: STSDBG_WR_STR("[SRBIN_NEXT_CHANNEL_STATE]", True); break; /* (2 << 24) */
case SRBIN_NEXT_BIN_STATE: STSDBG_WR_STR("[SRBIN_NEXT_BIN_STATE]", True); break; /* (3 << 24) */
case SRBIN_LOCK_TEST_STATE: STSDBG_WR_STR("[SRBIN_LOCK_TEST_STATE]", True); break; /* (4 << 24) */
case SRBIN_CLEANUP_STATE: STSDBG_WR_STR("[SRBIN_CLEANUP_STATE]", True); break; /* (5 << 24) */
case SRBIN_READY_STATE: STSDBG_WR_STR("[SRBIN_READY_STATE]", True); break; /* (6 << 24) */
/* POWER SCAN FSM */
case PWRSCAN_RESET_STATE: STSDBG_WR_STR("[PWRSCAN_RESET_STATE]", True); break; /* (1 << 28) */
case PWRSCAN_TUNE_STATE: STSDBG_WR_STR("[PWRSCAN_TUNE_STATE]", True); break; /* (2 << 28) */
case PWRSCAN_START_STATE: STSDBG_WR_STR("[PWRSCAN_START_STATE]", True); break; /* (3 << 28) */
case PWRSCAN_STEP_STATE: STSDBG_WR_STR("[PWRSCAN_STEP_STATE]", True); break; /* (4 << 28) */
case PWRSCAN_STOP_STATE: STSDBG_WR_STR("[PWRSCAN_STOP_STATE]", True); break; /* (5 << 28) */
case PWRSCAN_READY_STATE: STSDBG_WR_STR("[PWRSCAN_READY_STATE]", True); break; /* (6 << 28) */
case PWRSCAN_ABORT_STATE: STSDBG_WR_STR("[PWRSCAN_ABORT_STATE]", True); break; /* (7 << 28) */
default:STSDBG_WR_STR("[UNDEFINED STATE]", True); break;
}
#endif /* HAMARO_WIN_DEBUG */
}
/*****************************************************************************/
/* DEBUG_CheckFSMLimits() */
/* */
/*****************************************************************************/
STATE*
DEBUG_CheckFSMLimits(STATE* curr_state)
{
DEBUG_StateCode2String(curr_state->coding);
if ((curr_state->coding & (DEBUG_GetFSMLimits())) != 0)
{
return &idle_state;
}
return curr_state;
}
#endif /* HAMARO_INCLUDE_DEBUG */
#endif /* HAMARO_SCAN_THE_SKY */
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -