hamaro_findrise.c

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

static STATE*
RISEEDGE_Reset2RiseUnknown()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_unknown_state);
	return &rise_edge_unknown_state;
}

/* --- RISEEDGE Uphill State --- */
static HAMARO_STS_CURVATURE s_curvature = CURVATURE_UNKNOWN;
static unsigned long s_abs_channel_left_edge_hz = 0;
/*****************************************************************************/
/* FINDRISE_GetAbsLeftEdgeFreq() */
/*  */
/*****************************************************************************/
unsigned long
FINDRISE_GetAbsLeftEdgeFreq()
{
    return s_abs_channel_left_edge_hz;
}

/*****************************************************************************/
/* RISEEDGE_UphillEnter() */
/* Enter task */
/*****************************************************************************/
static BOOL s_complete_spectrum;
static void  
RISEEDGE_UphillEnter()
{
    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_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);

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

    s_abs_channel_left_edge_hz = *p_samples->p_freq[0];
    
    s_complete_spectrum = True;
}

/*
BOOL
FINDRISE_HasCompleteSpectrum()
{
    return s_complete_spectrum;
}
*/

static BOOL   
RISEEDGE_Uphill2RiseReadyCriterion()
{
    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_curvature == CURVATURE_CONCAVE || s_curvature == CURVATURE_CONVEX || s_curvature == CURVATURE_STRAIGHT)
    {
        return (True);
    }
    else
    {
        if (STS_StepForward() == False)
        {
            s_step_forward = False;
            return (True);
        } 
    }
    return (False);
}

static STATE* 
RISEEDGE_Uphill2RiseReady()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_ready_state);
	return &rise_edge_ready_state;
}

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

/* --- RISEEDGE Hump State --- */
/*****************************************************************************/
/* RISEEDGE_Hump() */
/* Regular task */
/*****************************************************************************/
static void   
RISEEDGE_Hump()
{
    HAMARO_STS_SAMPLE* p_samples;

    p_samples = STS_GetSamples();
    if (isFromReset2RiseHump==False)
    {
       s_step_size = s_step_size/4;
       STS_SetStep(s_step_size);
       STS_MoveLeft();
       STS_SetNoDoubleStep(); 
    }
    else
    {
    	STS_StepForward();
    	isFromReset2RiseHump = False;
    }
    s_pattern = STS_PatternTest(*p_samples->p_power[0], 
                                *p_samples->p_power[1],
                                *p_samples->p_power[2], 
                                s_pattern_delta);
}

/*****************************************************************************/
/* RISEEDGE_Hump() */
/* Regular task */
/*****************************************************************************/
static BOOL   
RISEEDGE_Hump2RiseUphillCriterion()
{
    if (s_pattern == PATTERN_UPHILL)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Hump() */
/* Regular task */
/*****************************************************************************/
static STATE* 
RISEEDGE_Hump2RiseUphill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_uphill_state);
	return &rise_edge_uphill_state; 
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseDownHillCriterion() */
/*  */
/*****************************************************************************/
static BOOL   
RISEEDGE_Hump2RiseDownHillCriterion()
{
    if (s_pattern == PATTERN_DOWNHILL)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseDownHill() */
/*  */
/*****************************************************************************/
static STATE* 
RISEEDGE_Hump2RiseDownHill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_downhill_state);
	return &rise_edge_downhill_state; 
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseTroughCriterion() */
/*  */
/*****************************************************************************/
static BOOL   
RISEEDGE_Hump2RiseTroughCriterion()
{
    if (s_pattern == PATTERN_TROUGH)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseTrough() */
/*  */
/*****************************************************************************/
static STATE* 
RISEEDGE_Hump2RiseTrough()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_trough_state);
	return &rise_edge_trough_state; 
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseFlatCriterion() */
/*  */
/*****************************************************************************/
static BOOL   
RISEEDGE_Hump2RiseFlatCriterion()
{
    if (s_pattern == PATTERN_FLAT)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseFlat() */
/*  */
/*****************************************************************************/
static STATE* 
RISEEDGE_Hump2RiseFlat()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_flat_state);
	return &rise_edge_flat_state; 
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseUnknownCriterion() */
/*  */
/*****************************************************************************/
static BOOL   
RISEEDGE_Hump2RiseUnknownCriterion()
{
    if (s_pattern == PATTERN_UNKNOWN)
    {
        return (True);
    }
	return (False);
}

/*****************************************************************************/
/* RISEEDGE_Hump2RiseUnknown() */
/*  */
/*****************************************************************************/
static STATE* 
RISEEDGE_Hump2RiseUnknown()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_unknown_state);
	return &rise_edge_unknown_state;
}

/* Rise edge downhill state */
static void   
RISEEDGE_Downhill()
{
    HAMARO_STS_SAMPLE* p_samples;

    if (s_pattern == PATTERN_DOWNHILL) 
    {
        if (STS_StepForward() == False)
        {
            s_step_forward = False;
        }
    }
    else
    {    
        STS_StepBackward();
    }

    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   
RISEEDGE_Downhill2RiseReadyCriterion()
{
    return (!s_step_forward);
}

static STATE* 
RISEEDGE_Downhill2RiseReady()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_ready_state);
	return &rise_edge_ready_state;
}

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

static STATE* 
RISEEDGE_Downhill2RiseUphill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_uphill_state);
	return &rise_edge_uphill_state;
}

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

static STATE* 
RISEEDGE_Downhill2Hump()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_hump_state);
	return &rise_edge_hump_state;
}

/*
static BOOL   
RISEEDGE_Downhill2DownhillCriterion() 
{
    RISEEDGE_Flat();
    RISEEDGE_Flat();
    if (s_pattern == PATTERN_DOWNHILL)
    {
        return (True);
    }
	return (False);
}

static STATE* 
RISEEDGE_Downhill2Downhill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_downhill_state);
	return &rise_edge_downhill_state;
}
*/

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

static STATE* 
RISEEDGE_Downhill2RiseTrough()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_trough_state);
	return &rise_edge_trough_state;
}

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

static STATE* 
RISEEDGE_Downhill2RiseFlat()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_flat_state);
	return &rise_edge_flat_state;
}

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

static STATE* 
RISEEDGE_Downhill2RiseUnknown()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_unknown_state);
	return &rise_edge_unknown_state;
}

/* Rise edge trough state */
static void   
RISEEDGE_Trough()
{
    HAMARO_STS_SAMPLE* p_samples;

    if (s_pattern == PATTERN_TROUGH) 
    {
        if (STS_StepForward() == False)
        {
            s_step_forward = False;
        }
    }
    else
    {    
        STS_StepBackward();
    }

    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   
RISEEDGE_Trough2RiseReadyCriterion()
{
    return (!s_step_forward);
}

static STATE* 
RISEEDGE_Trough2RiseReady()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_ready_state);
	return &rise_edge_ready_state;
}

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

static STATE* 
RISEEDGE_Trough2RiseUphill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_uphill_state);
	return &rise_edge_uphill_state;
}

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

static STATE* 
RISEEDGE_Trough2RiseHump()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_hump_state);
	return &rise_edge_hump_state;
}

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

static STATE* 
RISEEDGE_Trough2RiseDownhill()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_downhill_state);
	return &rise_edge_downhill_state;
}

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

static STATE* 
RISEEDGE_Trough2RiseFlat()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_flat_state);
	return &rise_edge_flat_state;
}

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

static STATE* 
RISEEDGE_Trough2RiseUnknown()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_unknown_state);
	return &rise_edge_unknown_state;
}