hamaro_findfall.c

机顶盒Hamaro解调器驱动。包含自动搜台

    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Flat2FallDownhill()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_downhill_state);
	return &fall_edge_downhill_state;
}

static BOOL   
FALLEDGE_Flat2FallTroughCriterion()
{
    if (s_pattern == PATTERN_TROUGH)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Flat2FallTrough()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_trough_state);
	return &fall_edge_trough_state;
}

static BOOL   
FALLEDGE_Flat2FallUnknownCriterion()
{
    if (s_pattern == PATTERN_UNKNOWN)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Flat2FallUnknown()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_unknown_state);
	return &fall_edge_unknown_state;
}

/* Fall edge unknown state */
static void   
FALLEDGE_UnknownEnter()
{
    /* do nothing */
}

static BOOL   
FALLEDGE_Unknown2ResetCriterion()
{
    return(True); /* always return to reset state */
}

static STATE* 
FALLEDGE_Unknown2Reset()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_reset_state);
	return &fall_edge_reset_state;
}

/*****************************************************************************/
/*                               FALL RANGE FSM                              */
/*****************************************************************************/
/* Function prototypes */
/* Fall range Reset state */
static void   FALLRANGE_ResetEnter();

static BOOL   FALLRANGE_Reset2FallConvexCriterion();
static STATE* FALLRANGE_Reset2FallConvex();

static BOOL   FALLRANGE_Reset2FallConcaveCriterion();
static STATE* FALLRANGE_Reset2FallConcave();

static BOOL   FALLRANGE_Reset2FallStraightCriterion();
static STATE* FALLRANGE_Reset2FallStraight();


/* Fall range convex state */
static void   FALLRANGE_ConvexEnter();

static void   FALLRANGE_Convex();

static BOOL   FALLRANGE_Convex2ConvexCriterion();
static STATE* FALLRANGE_Convex2Convex();

static BOOL   FALLRANGE_Convex2ConcaveCriterion();
static STATE* FALLRANGE_Convex2Concave();

static BOOL   FALLRANGE_Convex2PreReadyCriterion();
static STATE* FALLRANGE_Convex2PreReady();


/* Fall range concave state */
static void   FALLRANGE_Concave();

static BOOL   FALLRANGE_Concave2ConcaveCriterion();
static STATE* FALLRANGE_Concave2Concave();

static BOOL   FALLRANGE_Concave2PreReadyCriterion();
static STATE* FALLRANGE_Concave2PreReady();

/* Fall range pre-ready state */
static void   FALLRANGE_PreReadyEnter();

static BOOL   FALLRANGE_PreReady2ReadyCriterion();
static STATE* FALLRANGE_PreReady2Ready();

/* Fall range ready state */
static void   FALLRANGE_ReadyEnter();

/* State tables */
STATE fall_range_reset_state = /* FIND_FALL_RANGE FSM, RESET state */
{
	FALLRANGE_ResetEnter, /* Entry task */
   	{
      		{FALLRANGE_Reset2FallConvexCriterion,   FALLRANGE_Reset2FallConvex},   /* Criterion1 and Exit task */
      		{FALLRANGE_Reset2FallConcaveCriterion,  FALLRANGE_Reset2FallConcave},  /* Criterion2 and Exit task */
      		{FALLRANGE_Reset2FallStraightCriterion, FALLRANGE_Reset2FallStraight}, /* Criterion3 and Exit task */
      		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	FALLRANGE_RESET_STATE /* state code */	
};

STATE fall_range_convex_state = /* FIND_FALL_RANGE FSM, CONVEX state */
{
	FALLRANGE_ConvexEnter, /* Entry task */
   	{
        {FALLRANGE_Convex2ConvexCriterion,    FALLRANGE_Convex2Convex},    
        {FALLRANGE_Convex2ConcaveCriterion,   FALLRANGE_Convex2Concave},    
      		{FALLRANGE_Convex2PreReadyCriterion,  FALLRANGE_Convex2PreReady},     /* Criterion2 and Exit task */
      		{0,0} /* End of Criterion/Exit task */
   	},
   	FALLRANGE_Convex, /* Regular/Routine task */
   	0, /* No counter */
   	FALLRANGE_CONVEX_STATE /* state code */	
};

STATE fall_range_concave_state = /* FIND_FALL_RANGE FSM, CONCAVE state */
{
	0, /* Entry task */
   	{
        {FALLRANGE_Concave2PreReadyCriterion,  FALLRANGE_Concave2PreReady},     
        {FALLRANGE_Concave2ConcaveCriterion,   FALLRANGE_Concave2Concave},   
      		{0,0} /* End of Criterion/Exit task */
   	},
   	FALLRANGE_Concave, /* Regular/Routine task */
   	0, /* No counter */
   	FALLRANGE_CONCAVE_STATE /* state code */	
};

STATE fall_range_pre_ready_state = /* FIND_FALL_EDGE FSM, PRE-READY state */
{
	FALLRANGE_PreReadyEnter, /* Entry task */
   	{
            {FALLRANGE_PreReady2ReadyCriterion,   FALLRANGE_PreReady2Ready},   /* Criterion1 and Exit task */
      		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	FALLRANGE_PRE_READY_STATE /* state code */	
};

STATE fall_range_ready_state = /* FIND_FALL_EDGE FSM, READY state */
{
	FALLRANGE_ReadyEnter, /* Entry task */
   	{
      		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	FALLRANGE_READY_STATE /* state code */	
};

/*****************************************************************************/
/* FALLRANGE_Start() */
/* Main FSM function  */
/*****************************************************************************/
void 
FALLRANGE_Start(FSM *fsm)
{  
   fsm->p_curr = &fall_range_reset_state; 
}

/* Fall range Reset state */
static HAMARO_STS_CURVATURE s_curvature_status = CURVATURE_UNKNOWN;
static void 
FALLRANGE_ResetEnter()
{
    s_curvature_status = CURVATURE_UNKNOWN;
    STS_SetStep(STS_FINDFALL_DEFAULT_STEP_SIZE); 
}

static BOOL   
FALLRANGE_Reset2FallConvexCriterion()
{
    if (s_curvature == CURVATURE_CONCAVE || s_curvature == CURVATURE_UNKNOWN)
    {
    if (s_curvature == CURVATURE_CONCAVE)
    {
            s_curvature_status = CURVATURE_CONCAVE;
            STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); 
        }
        return (True);
    }
	return (False);
}

static STATE* 
FALLRANGE_Reset2FallConvex()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_convex_state);
	return &fall_range_convex_state;    
}

static BOOL   
FALLRANGE_Reset2FallConcaveCriterion()
{
    if (s_curvature == CURVATURE_CONVEX)
    {
        STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); 
        return (True);
    }
	return (False);
}

static STATE* 
FALLRANGE_Reset2FallConcave()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_concave_state);
	return &fall_range_concave_state; 
}

static BOOL   
FALLRANGE_Reset2FallStraightCriterion()
{
    if (s_curvature == CURVATURE_STRAIGHT)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLRANGE_Reset2FallStraight()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_pre_ready_state);
	return &fall_range_pre_ready_state; 
}


/* Fall range convex state */
static unsigned char s_convex2convex_count;
static void   
FALLRANGE_ConvexEnter()
{
    s_convex2convex_count = 0;
}

static void   
FALLRANGE_Convex()
{
    HAMARO_STS_SAMPLE* p_samples;
    
    p_samples = STS_GetSamples();

    s_curvature = STS_CurvatureTest(*p_samples->p_power[0],
                                    *p_samples->p_power[1], 
                                    *p_samples->p_power[2],
                                    STS_CURVATURE_TEST_THRESH);

    //STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); // REVISIT : changed rise to fall
}

static BOOL   
FALLRANGE_Convex2ConvexCriterion()
{
    if (s_curvature_status == CURVATURE_CONCAVE)
    {
    if (s_curvature == CURVATURE_CONCAVE || s_curvature == CURVATURE_UNKNOWN)
    {
            if (s_curvature == CURVATURE_CONCAVE)
            {
                STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); 
            }
        STS_StepBackward();
        return (True);
    }
    }
    else if (s_curvature_status == CURVATURE_UNKNOWN)
    {
        if (s_curvature == CURVATURE_CONCAVE || s_curvature == CURVATURE_UNKNOWN)
        {
            if (s_curvature == CURVATURE_CONCAVE)
            {
                s_curvature_status = CURVATURE_CONCAVE;
                STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); 
            }
            STS_StepBackward();
            return (True);
        }
    }

 	return (False);
}

static STATE* 
FALLRANGE_Convex2Convex()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_convex_state);
	return &fall_range_convex_state;    
}

static BOOL   
FALLRANGE_Convex2ConcaveCriterion()
{
    if (s_curvature_status == CURVATURE_UNKNOWN)
    {
        if (s_curvature == CURVATURE_CONVEX)
        {
            STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); 
            return (True);
        }
    }
	return (False);
}

static STATE* 
FALLRANGE_Convex2Concave()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_concave_state);
	return &fall_range_concave_state;    
}

static BOOL   
FALLRANGE_Convex2PreReadyCriterion()
{
    if (s_curvature_status == CURVATURE_CONCAVE)
    {
        if (s_curvature == CURVATURE_CONVEX/* || s_curvature == CURVATURE_STRAIGHT*/) // Added CURVATURE_STRAIGHT
    {
        STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature); 
            //STS_MoveRight();
        return (True);
    }
    }
	return (False);
}

static STATE* 
FALLRANGE_Convex2PreReady()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_pre_ready_state);
	return &fall_range_pre_ready_state; 
}


/* Fall range concave state */
static void   
FALLRANGE_Concave()
{
    HAMARO_STS_SAMPLE* p_samples;
    
    p_samples = STS_GetSamples();

    s_curvature = STS_CurvatureTest(*p_samples->p_power[0],
                                    *p_samples->p_power[1], 
                                    *p_samples->p_power[2],
                                    STS_CURVATURE_TEST_THRESH);

   // STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature);
}

static BOOL   
FALLRANGE_Concave2ConcaveCriterion()
{
    if (s_curvature == CURVATURE_CONVEX || s_curvature == CURVATURE_UNKNOWN)
    {
        if (s_curvature == CURVATURE_CONVEX)
        {
            STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature);
        }
        s_step_forward = STS_StepForward();
        return (True);
    }
    	return (False);
}

static STATE* 
FALLRANGE_Concave2Concave()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_concave_state);
	return &fall_range_concave_state; 
}

static BOOL   
FALLRANGE_Concave2PreReadyCriterion()
{
    if (s_curvature == CURVATURE_CONCAVE/* || s_curvature == CURVATURE_STRAIGHT*/) 
    {
        STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, s_curvature);
        //STS_MoveLeft();
        return (True);
    }
    else if (s_step_forward == False)
    {
        return (True);
    }

	return (False);
}

static STATE* 
FALLRANGE_Concave2PreReady()
{
    s_curvature_status = CURVATURE_UNKNOWN;
    DBG_CHECK_FSM_LIMITS(&fall_range_pre_ready_state);
	return &fall_range_pre_ready_state; 
}


/* Fall range pre-ready state */
static void   
FALLRANGE_PreReadyEnter()
{
    if (s_curvature == CURVATURE_STRAIGHT)
    {
        STS_UpdateFallCurvaturePoints(&s_find_fall_range_curvature, CURVATURE_STRAIGHT); 
    }
}

static BOOL   
FALLRANGE_PreReady2ReadyCriterion()
{
    return (True);
}

static STATE*
FALLRANGE_PreReady2Ready()
{
    DBG_CHECK_FSM_LIMITS(&fall_range_ready_state);
	return &fall_range_ready_state; 
}

/* Fall range ready state */
static void   
FALLRANGE_ReadyEnter()
{
    /* do nothing */    
}

/* other function */
/*****************************************************************************/
/* FINDFALL_GetFallCurvaturePoints() */
/*  */
/*****************************************************************************/
HAMARO_STS_CURVATURE_POINTS* 
FINDFALL_GetFallCurvaturePoints()
{
    return &s_find_fall_range_curvature;
}

void
FINDFALL_ResetCurvaturePoints()
{
    STS_ResetCurvaturePoints(&s_find_fall_range_curvature, STS_EDGE_FALLING); 
}

#endif /* #if HAMARO_SCAN_THE_SKY */