hamaro_findrise.c

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

/* Rise edge flat state */
static void   
RISEEDGE_Flat()
{
    HAMARO_STS_SAMPLE* p_samples;

    if (STS_StepForward() == False)
    {
        s_step_forward = False;
    }

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

static STATE* 
RISEEDGE_Flat2RiseReady()
{
    s_abort_state = True;
    DBG_CHECK_FSM_LIMITS(&rise_edge_ready_state);
	return &rise_edge_ready_state;
}

BOOL
RISEEDGE_IsAbortState()
{
    return s_abort_state;
}

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

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

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

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

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

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

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

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

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

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

/* Rise edge unknown state */
static void   
RISEEDGE_UnknownEnter()
{
    s_step_size = STS_FINDRISE_DEFAULT_STEP_SIZE; /* 500 kHz if scan step size was 125 kHz */
    STS_StartAllOver(s_step_size, 0xFFFF);
}

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

static STATE* 
RISEEDGE_Unknown2Reset()
{
    DBG_CHECK_FSM_LIMITS(&rise_edge_reset_state);
	return &rise_edge_reset_state;
}

/*****************************************************************************/
/*                               RISE RANGE FSM                              */
/*****************************************************************************/
/* Function prototypes */
/* Rise range Reset state */
static void   RISERANGE_ResetEnter();

static BOOL   RISERANGE_Reset2RiseConvexCriterion();
static STATE* RISERANGE_Reset2RiseConvex();

static BOOL   RISERANGE_Reset2RiseConcaveCriterion();
static STATE* RISERANGE_Reset2RiseConcave();

static BOOL   RISERANGE_Reset2RiseStraightCriterion();
static STATE* RISERANGE_Reset2RiseStraight();


/* Rise range convex state */
static void   RISERANGE_Convex();

static BOOL   RISERANGE_Convex2ConvexCriterion();
static STATE* RISERANGE_Convex2Convex();

static BOOL   RISERANGE_Convex2ReadyCriterion();
static STATE* RISERANGE_Convex2Ready();


/* Rise range concave state */
static void   RISERANGE_Concave();

static BOOL   RISERANGE_Concave2ConcaveCriterion();
static STATE* RISERANGE_Concave2Concave();

static BOOL   RISERANGE_Concave2ConvexCriterion();
static STATE* RISERANGE_Concave2Convex();

static BOOL   RISERANGE_Concave2ReadyCriterion();
static STATE* RISERANGE_Concave2Ready();


/* Rise range ready state */
static void   RISERANGE_ReadyEnter();

/* State tables */
STATE rise_range_reset_state = /* FIND_RISE_RANGE FSM, RESET state */
{
	RISERANGE_ResetEnter, /* Entry task */
   	{
      		{RISERANGE_Reset2RiseConvexCriterion,   RISERANGE_Reset2RiseConvex},   /* Criterion1 and Exit task */
      		{RISERANGE_Reset2RiseConcaveCriterion,  RISERANGE_Reset2RiseConcave},  /* Criterion2 and Exit task */
      		{RISERANGE_Reset2RiseStraightCriterion, RISERANGE_Reset2RiseStraight}, /* Criterion3 and Exit task */
      		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	RISERANGE_RESET_STATE /* state code */	
};

STATE rise_range_convex_state = /* FIND_RISE_RANGE FSM, CONVEX state */
{
	0, /* Entry task */
   	{
      		{RISERANGE_Convex2ConvexCriterion, RISERANGE_Convex2Convex},    /* Criterion1 and Exit task */
      		{RISERANGE_Convex2ReadyCriterion,  RISERANGE_Convex2Ready},     /* Criterion2 and Exit task */
      		{0,0} /* End of Criterion/Exit task */
   	},
   	RISERANGE_Convex, /* Regular/Routine task */
   	0, /* No counter */
   	RISERANGE_CONVEX_STATE /* state code */	
};

STATE rise_range_concave_state = /* FIND_RISE_RANGE FSM, CONCAVE state */
{
	0, /* Entry task */
   	{
      		{RISERANGE_Concave2ConcaveCriterion,   RISERANGE_Concave2Concave},   /* Criterion1 and Exit task */
        {RISERANGE_Concave2ConvexCriterion,    RISERANGE_Concave2Convex},   
      	{RISERANGE_Concave2ReadyCriterion,     RISERANGE_Concave2Ready},     
      		{0,0} /* End of Criterion/Exit task */
   	},
   	RISERANGE_Concave, /* Regular/Routine task */
   	0, /* No counter */
   	RISERANGE_CONCAVE_STATE /* state code */	
};

STATE rise_range_ready_state = /* FIND_RISE_EDGE FSM, READY state */
{
	RISERANGE_ReadyEnter, /* Entry task */
   	{
      		{0,0} /* End of Criterion/Exit task */
   	},
   	0, /* Regular/Routine task */
   	0, /* No counter */
   	RISERANGE_READY_STATE /* state code */	
};

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

/* Rise range Reset state */
static HAMARO_STS_CURVATURE s_curvature_status = CURVATURE_UNKNOWN;
static void 
RISERANGE_ResetEnter()
{    
    s_curvature_status = CURVATURE_UNKNOWN;
}

static BOOL   
RISERANGE_Reset2RiseConvexCriterion()
{
    if (s_curvature == CURVATURE_CONCAVE)
    {
        return (True);
    }
	return (False);
}

static STATE* 
RISERANGE_Reset2RiseConvex()
{
    DBG_CHECK_FSM_LIMITS(&rise_range_convex_state);
	return &rise_range_convex_state;    
}

static BOOL   
RISERANGE_Reset2RiseConcaveCriterion()
{
    if (s_curvature == CURVATURE_CONVEX || s_curvature == CURVATURE_UNKNOWN)
    {
    if (s_curvature == CURVATURE_CONVEX)
    {
            s_curvature_status = CURVATURE_CONVEX;
            STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);
        }
        return (True);
    }
	return (False);
}

static STATE* 
RISERANGE_Reset2RiseConcave()
{
    DBG_CHECK_FSM_LIMITS(&rise_range_concave_state);
	return &rise_range_concave_state; 
}

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

static STATE* 
RISERANGE_Reset2RiseStraight()
{
    STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature); 
    DBG_CHECK_FSM_LIMITS(&rise_range_ready_state); 
	return &rise_range_ready_state; 
}


/* Rise range convex state */
static void   
RISERANGE_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_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);
}

static BOOL   
RISERANGE_Convex2ConvexCriterion()
{
    if (s_curvature == CURVATURE_CONCAVE || s_curvature == CURVATURE_UNKNOWN)
    {
        if (s_curvature == CURVATURE_CONCAVE)
            {
            STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);
        }

       // if (STS_GetNoDoubleStep() == False) /* double step */
       // {
       //     s_step_size = s_step_size * 2;
       //     STS_SetStep(s_step_size);
       //     if (STS_StepForward() == False)
       //     {
       //         s_step_forward = False;
       //     }
       // }
       // else
        {
            if (STS_StepForward() == False)
            {
                s_step_forward = False;
            }
        }
        return (True);
    }
    	return (False);
}

static STATE* 
RISERANGE_Convex2Convex()
{
    DBG_CHECK_FSM_LIMITS(&rise_range_convex_state);
	return &rise_range_convex_state;    
}

static BOOL   
RISERANGE_Convex2ReadyCriterion()
{
    if (s_curvature == CURVATURE_CONVEX/* || s_curvature == CURVATURE_STRAIGHT*/) 
    {
      //  if (s_curvature == CURVATURE_STRAIGHT) 
      //  {
      //      STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, CURVATURE_CONVEX); 
      //  }
       // else /* re-visit */
        {
            STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature); 
        }
       // STS_MoveLeft();
        return (True);
    }
    else if (s_step_forward == False)
    {
        return (True);
    }

	return (False);
}

static STATE* 
RISERANGE_Convex2Ready()
{
    s_curvature_status = CURVATURE_UNKNOWN;
    DBG_CHECK_FSM_LIMITS(&rise_range_ready_state);
	return &rise_range_ready_state; 
}


/* Rise range concave state */
static void   
RISERANGE_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_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);
}

static BOOL   
RISERANGE_Concave2ConcaveCriterion()
{
    if (s_curvature_status == CURVATURE_CONVEX)
    {
        if (s_curvature == CURVATURE_CONVEX || s_curvature == CURVATURE_UNKNOWN)
        {
    if (s_curvature == CURVATURE_CONVEX)
    {
                STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);
            }

        STS_StepBackward();
        return (True);
    }
    }
    else if (s_curvature_status == CURVATURE_UNKNOWN)
    {
        // else 
        if (s_curvature == CURVATURE_UNKNOWN)
    {
        if (STS_StepForward() == False)
        {
            s_step_forward = False;
        }
        return (True);
    }
    }
	return (False);
}

static STATE* 
RISERANGE_Concave2Concave()
{
    DBG_CHECK_FSM_LIMITS(&rise_range_concave_state);
	return &rise_range_concave_state; 
}

static BOOL   
RISERANGE_Concave2ConvexCriterion()
{
    if (s_curvature_status == CURVATURE_CONVEX)
    {
        if (s_curvature == CURVATURE_CONCAVE)
        {
            STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, s_curvature);
            return (True);
        }
    }
    return (False);
}

static STATE* 
RISERANGE_Concave2Convex()
{
    DBG_CHECK_FSM_LIMITS(&rise_range_convex_state);
	return &rise_range_convex_state; 
}

static BOOL   
RISERANGE_Concave2ReadyCriterion()
{
    if (s_curvature == CURVATURE_CONCAVE /*|| s_curvature == CURVATURE_STRAIGHT*/) 
    {
        //if (s_curvature == CURVATURE_STRAIGHT) 
        {
            STS_UpdateRiseCurvaturePoints(&s_find_rise_range_curvature, CURVATURE_CONCAVE);
        }
       // STS_MoveRight();
        return (True);
    }
    else if (s_step_forward == False)
    {
        return (True);
    }

	return (False);
}

static STATE* 
RISERANGE_Concave2Ready()
{
    DBG_CHECK_FSM_LIMITS(&rise_range_ready_state);
    s_curvature_status = CURVATURE_UNKNOWN;
	return &rise_range_ready_state; 
}


/* Rise range ready state */
static void   
RISERANGE_ReadyEnter()
{
    /* do nothing */ 
}

/*****************************************************************************/
/* FINDRISE_GetRiseCurvaturePoints() */
/*  */
/*****************************************************************************/
HAMARO_STS_CURVATURE_POINTS* 
FINDRISE_GetRiseCurvaturePoints()
{
    return &s_find_rise_range_curvature;
}

/*****************************************************************************/
#endif /* #if HAMARO_SCAN_THE_SKY */