hamaro_findfall.c

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

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

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

static BOOL   
FALLEDGE_Reset2FallFlatCriterion()
{
    if (s_pattern == PATTERN_FLAT)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Reset2FallFlat()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_flat_state);
	return &fall_edge_flat_state; 
}

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

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

/* Fall edge uphill state */
static void   
FALLEDGE_Uphill()
{
    HAMARO_STS_SAMPLE* p_samples;

    s_step_forward = STS_StepForward();

    p_samples = STS_GetSamples();

    s_pattern = STS_PatternTest(*p_samples->p_power[0], 
                                *p_samples->p_power[1],
                                *p_samples->p_power[2], 
                                s_pattern_delta);
}

static BOOL   
FALLEDGE_Uphill2RiseReadyCriterion()
{
    return (!s_step_forward);
}

static STATE* 
FALLEDGE_Uphill2RiseReady()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_ready_state);
	return &fall_edge_ready_state;
}

static BOOL   
FALLEDGE_Uphill2FallHumpCriterion()
{
    if (s_pattern == PATTERN_HUMP)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Uphill2FallHump()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_hump_state);
	return &fall_edge_hump_state; 
}

static BOOL   
FALLEDGE_Uphill2FallDownHillCriterion()
{
    if (s_pattern == PATTERN_DOWNHILL)
    {
        return (True);
    }
	return (False);
}

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

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

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

static BOOL   
FALLEDGE_Uphill2FallFlatCriterion()
{
    if (s_pattern == PATTERN_FLAT)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Uphill2FallFlat()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_flat_state);
	return &fall_edge_flat_state; 
}

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

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

/* Fall edge hump state */
static void   
FALLEDGE_Hump()
{
    FALLEDGE_Uphill();
}

static BOOL   
FALLEDGE_Hump2FallUphillCriterion()
{
    if (s_pattern == PATTERN_UPHILL)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Hump2FallUphill()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_uphill_state);
	return &fall_edge_uphill_state; 
}

static BOOL   
FALLEDGE_Hump2FallDownHillCriterion()
{
    if (s_pattern == PATTERN_DOWNHILL)
    {
        return (True);
    }
	return (False);
}

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

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

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

static BOOL   
FALLEDGE_Hump2FallFlatCriterion()
{
    if (s_pattern == PATTERN_FLAT)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Hump2FallFlat()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_flat_state);
	return &fall_edge_flat_state;
}

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

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

/* Fall edge trough state */
static void   
FALLEDGE_Trough()
{
    FALLEDGE_Uphill();
}

static BOOL   
FALLEDGE_Trough2FallUphillCriterion()
{
    if (s_pattern == PATTERN_UPHILL)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Trough2FallUphill()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_uphill_state);
	return &fall_edge_uphill_state;
}

static BOOL   
FALLEDGE_Trough2FallHumpCriterion()
{
    if (s_pattern == PATTERN_HUMP)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Trough2FallHump()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_hump_state);
	return &fall_edge_hump_state;
}

static BOOL   
FALLEDGE_Trough2FallDownhillCriterion()
{
    if (s_pattern == PATTERN_DOWNHILL)
    {
        return (True);
    }
	return (False);
}

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

static BOOL   
FALLEDGE_Trough2FallFlatCriterion()
{
    if (s_pattern == PATTERN_FLAT)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Trough2FallFlat()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_flat_state);
	return &fall_edge_flat_state;
}

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

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

/* Fall edge downhill state */
static HAMARO_STS_CURVATURE s_curvature = CURVATURE_UNKNOWN;
static void   
FALLEDGE_DownhillEnter()
{
    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

    if (s_curvature == CURVATURE_CONVEX || s_curvature == CURVATURE_UNKNOWN)
    {
        s_step_forward = STS_StepForward();
    }
    else if (s_curvature == CURVATURE_CONCAVE)
    {
        STS_MoveLeft();
        s_step_size = s_step_size/2;
        STS_SetStep(s_step_size);
    }
}

static BOOL   
FALLEDGE_Downhill2RiseReadyCriterion()
{
    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);
    if (s_step_forward == False)
    {
        return (True);
    }

    if (s_curvature == CURVATURE_CONVEX || s_curvature == CURVATURE_CONCAVE || s_curvature == CURVATURE_STRAIGHT)
    {
        return(True);
    }
    else
    {
        if (STS_StepForward() == False)
        {
            s_step_forward = False;
            return (True);
        }
    }
    return (False);
}

static STATE* 
FALLEDGE_Downhill2RiseReady()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_ready_state);
	return &fall_edge_ready_state;
}

/* Rise edge ready state */
static void   
FALLEDGE_ReadyEnter()
{
    /* do nothing */
}

/* Rise edge abort state */
static void   
FALLEDGE_AbortEnter()
{
    /* do nothing */
}

/* Fall edge flat state */
static void   
FALLEDGE_Flat() /* Regular task */
{
    HAMARO_STS_SAMPLE* p_samples;

    s_step_forward = STS_StepForward();

    p_samples = STS_GetSamples();

    s_pattern = STS_PatternTest(*p_samples->p_power[0], 
                                *p_samples->p_power[1],
                                *p_samples->p_power[2], 
                                s_pattern_delta);
}

static BOOL   
FALLEDGE_Flat2FallUphillCriterion()
{
    if (s_pattern == PATTERN_UPHILL)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Flat2FallUphill()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_uphill_state);
	return &fall_edge_uphill_state;
}

static BOOL   
FALLEDGE_Flat2FallHumpCriterion()
{
    if (s_pattern == PATTERN_HUMP)
    {
        return (True);
    }
	return (False);
}

static STATE* 
FALLEDGE_Flat2FallHump()
{
    DBG_CHECK_FSM_LIMITS(&fall_edge_hump_state);
	return &fall_edge_hump_state;
}

static BOOL   
FALLEDGE_Flat2FallDownhillCriterion()
{
    if (s_pattern == PATTERN_DOWNHILL)