hamaro_pwrscan.c

QPSK Tuner details, for conexant chipset.

static STATE* 
PWRSCAN_Tune2Start()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_start_state);
	return &pwrscan_start_state;
}

/* Power scan: Start state */
static void   
PWRSCAN_StartEnter()
{
    s_power_scan_data.abs_freq_khz = 0;
    *p_max_pwr_reading = 0;

    if (s_continue_scan == False)
    {
        s_power_scan_data.power_index = s_power_scan_data.abs_freq_index = 0; // agc_index = 0;    
    }

    s_pwrscan_buffer_info[s_buffer_info_index].start_freq_index = (unsigned short)s_power_scan_data.abs_freq_index;

    PWRSCAN_ReadyClear();
}

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

static STATE* 
PWRSCAN_Start2Step()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_step_state);
	return &pwrscan_step_state;
}


static BOOL   
PWRSCAN_Start2AbortCriterion()
{
    if (s_power_scan_data.b_abort == True)
    {
        return (True);
    }
    return (False);
}

static STATE* 
PWRSCAN_Start2Abort()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_abort_state);
	return &pwrscan_abort_state;
}


static clock_t start;
static void 
PWRSCAN_SetTimer(void)
{
    STSDBG_WR_STR("SRBIN_SetTimer1", True);
    start = clock();
}

static unsigned short 
PWRSCAN_GetElapsedTimeMilliSec(void)
{
    clock_t finish;
    unsigned short duration;
  
    finish = clock();
    duration = (unsigned short)(finish - start);
    return duration;
}

/* Power scan: Step state */
static BOOL s_first_step = False;
static BOOL s_adjust_power = False;
static void   
PWRSCAN_StepEnter()
{
    int agcacc_local = 0;

    s_power_scan_data.iter = 0;

    s_power_scan_data.initial_freq_step = PWRSCAN_GetInitialFreqStep(s_power_scan_data.power_scan_input.step_size_hz, 
                                                                     s_power_scan_data.number_freq_cnt);

    s_power_scan_data.center_frequency_hz = PWRSCAN_GetInitialCenterFreq(s_power_scan_data.power_scan_input.search_span_mhz, 
                                                                         s_power_scan_data.initial_freq_step);
    s_power_scan_data.center_frequency_upperbound_hz = (s_power_scan_data.center_frequency_hz - s_power_scan_data.initial_freq_step);
    
    s_power_scan_data.abs_freq_khz = s_power_scan_data.tuner_freq_khz - (s_power_scan_data.center_frequency_hz - s_power_scan_data.initial_freq_step)/1000;

    STSDBG_WR_INT_LN ("Initial absolute freq (khz) = ", s_power_scan_data.abs_freq_khz);

    PWRSCAN_SetObservationWindow(s_power_scan_data.power_scan_input.observation_window);

#if 1
    PWRSCAN_SetTimer();

    while (PWRSCAN_GetElapsedTimeMilliSec() < 100) /* Small delay for the AAGC to settle down */
    {
    }

    if (HAMARO_GetAGCAcc(hamaro_nim_list.nim[0], &agcacc_local) == False) 
    {
        s_power_scan_data.b_abort = True;
        return;
    }
    *p_agcacc = (signed char)agcacc_local;
    STSDBG_WR_INT_LN("####### AAGC ########### = ", agcacc_local);
    if ((PWRSCAN_IsAAGCFilter() == True) && (*p_agcacc > PWRSCAN_AGC_THRESHOLD) && (STS_GetUseMainBuffer() == True))
    {
        //s_power_scan_data.b_abort = True; 
    }
    /* Now freeze AAGC */
    if (PWRSCAN_AAGCControl(True) == False)
    {
        return;
    }
#endif
    s_first_step   = True;
    s_adjust_power = False;
    s_pwrscan_buffer_info[s_buffer_info_index].agcacc = *p_agcacc;
}


static void   
PWRSCAN_Step()
{
    s_power_scan_data.frequency_step_hz = PWRSCAN_GetInitialFreqStep(s_power_scan_data.power_scan_input.step_size_hz, 
                                                                     s_power_scan_data.number_freq_cnt); 

#if SKYSCAN_IQ_INVERSION == YES
    PWRSCAN_WriteCenterFreq(-s_power_scan_data.center_frequency_hz);
#else
    PWRSCAN_WriteCenterFreq(s_power_scan_data.center_frequency_hz);
#endif    
    
    /* 6)  Set observation window (STS Page=0, add=0x03)  STS_Len=7;(window=2^16) */

    s_power_scan_data.actual_freq_count = s_power_scan_data.number_freq_cnt;
    for (s_power_scan_data.offset = 0; s_power_scan_data.offset < s_power_scan_data.actual_freq_count; s_power_scan_data.offset++) 
    {
        if (PWRSCAN_WriteFreqStep(s_power_scan_data.offset, 
                                  s_power_scan_data.frequency_step_hz, 
                                  s_power_scan_data.power_scan_input.symbol_rate_khz*1000) == False)
        {
            s_power_scan_data.b_abort = True;
            return;
        }
        
        s_power_scan_data.total_freq_offset_hz = PWRSCAN_GetTotalFreqOffset(s_power_scan_data.center_frequency_hz, 
                                                                            s_power_scan_data.frequency_step_hz);
        s_power_scan_data.curr_abs_freq_khz = (s_power_scan_data.tuner_freq_khz - s_power_scan_data.total_freq_offset_hz/1000); 
        
#if STS_ENABLE_VERBOSE_LOG
        STSDBG_WR_INT(" | Absolute freq (khz) = ", s_power_scan_data.curr_abs_freq_khz);
        //WINDBG_FileWriteNewLine();
#endif /* STS_ENABLE_VERBOSE_LOG */

        s_power_scan_data.abs_freq_hz = s_power_scan_data.curr_abs_freq_khz; 

        s_power_scan_data.abs_freq_hz *= 1000UL;
        
        if (s_power_scan_data.abs_freq_index < s_power_scan_data.max_index)
        {
            p_freq_reading[s_power_scan_data.abs_freq_index] = (s_power_scan_data.tuner_freq_khz - s_power_scan_data.total_freq_offset_hz/1000) * 1000UL;

                
#if STS_ENABLE_VERBOSE_LOG
        STSDBG_WR_UNSIGNED(" p_freq_reading", p_freq_reading[s_power_scan_data.abs_freq_index]);
        STSDBG_WR_INT(" | center_frequency_hz = ", s_power_scan_data.center_frequency_hz);
        if (s_power_scan_data.frequency_step_hz == 0)
        {
            STSDBG_WR_INT(" | frequency_step_hz =           ", s_power_scan_data.frequency_step_hz);
        }
        else
        {
            STSDBG_WR_INT(" | frequency_step_hz = ", s_power_scan_data.frequency_step_hz);
        }
        STSDBG_WR_INT(" | tuner_freq_khz = ", s_power_scan_data.tuner_freq_khz);
        STSDBG_WR_INT_LN(" | total_freq_offset_hz = ", s_power_scan_data.total_freq_offset_hz/1000);
#endif /* STS_ENABLE_VERBOSE_LOG */      

            s_power_scan_data.abs_freq_index++;
        }

        if (s_power_scan_data.abs_freq_hz < TUNER_LOW_LIMIT)
        {
            STSDBG_WR_UNSIGNED_LN("Exceeded low offset", s_power_scan_data.abs_freq_hz);
            s_power_scan_data.actual_freq_count = s_power_scan_data.offset+1;
            s_power_scan_data.b_last_set = True;
            break; 
        }
        else if (s_power_scan_data.abs_freq_hz > TUNER_HIGH_LIMIT)
        {
            STSDBG_WR_UNSIGNED_LN("Exceeded high offset = ", s_power_scan_data.abs_freq_hz);
            s_power_scan_data.actual_freq_count = s_power_scan_data.offset+1;
            s_power_scan_data.b_last_set = True;
            break; 
        }

        if (s_power_scan_data.center_frequency_hz <= -s_power_scan_data.center_frequency_upperbound_hz)
        {
#if STS_ENABLE_VERBOSE_LOG
            STSDBG_WR_INT_LN("Completed specified range = ", (s_power_scan_data.center_frequency_hz + s_power_scan_data.frequency_step_hz));
#endif /* STS_ENABLE_VERBOSE_LOG */
            s_power_scan_data.actual_freq_count = s_power_scan_data.offset+1;
            s_power_scan_data.b_last_set = True;
            break;
        }
        s_power_scan_data.delta_abs_freq_khz = abs(s_power_scan_data.curr_abs_freq_khz - s_power_scan_data.abs_freq_khz);

        s_power_scan_data.frequency_step_hz += s_power_scan_data.power_scan_input.step_size_hz; 
    }      

    /* 7)  Set STS page=1, add=0x00,  load 0 */
#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT_LN("actual_freq_count", s_power_scan_data.actual_freq_count);
#endif /* STS_ENABLE_VERBOSE_LOG */

    PWRSCAN_WriteFreqCount(s_power_scan_data.actual_freq_count); 

    if (PWRSCAN_WaitForMeasurement() == True)
    {
        for (s_power_scan_data.offset = 0; s_power_scan_data.offset < s_power_scan_data.actual_freq_count; s_power_scan_data.offset++) 
        {
            if (STS_READ_OFFSET(STS_POWER_ACCUM_SCALED, s_power_scan_data.offset, &s_power_scan_data.reg_value) == False)
            {
                STSDBG_WR_INT_LN("Read failed for power count = ", s_power_scan_data.offset);
                s_power_scan_data.b_abort = True;
                return;
            }
            if (s_power_scan_data.power_index < s_power_scan_data.max_index)
            {
                p_power_reading[s_power_scan_data.power_index] = s_power_scan_data.reg_value;
                s_power_scan_data.power_index++;

                /* Record the max reading */
                if (s_power_scan_data.reg_value > *p_max_pwr_reading)
                {
                    *p_max_pwr_reading = s_power_scan_data.reg_value;
                }
            }
        }            
    }
    else 
    {
        STSDBG_WR_STR("Measurement ready bit stuck (aborting scan...) = ", True);
        s_power_scan_data.b_abort = True;
        return;
    }

    /* 8) Clear PWRSCAN_Ready (STS Page=0, Add=0x6) */
    PWRSCAN_ReadyClear();    

    s_power_scan_data.center_frequency_hz = PWRSCAN_GetNextCenterFreq(s_power_scan_data.actual_freq_count, 
                                                                      s_power_scan_data.power_scan_input.step_size_hz);
    
#if STS_ENABLE_VERBOSE_LOG
    STSDBG_WR_INT_LN ("----- Freq group starting: ", s_power_scan_data.center_frequency_hz);
    STSDBG_WR_INT_LN ("iter: ", s_power_scan_data.iter);
#endif /* STS_ENABLE_VERBOSE_LOG */
    s_power_scan_data.iter++;
}


static BOOL   
PWRSCAN_Step2StopCriterion()
{
    if (s_power_scan_data.b_last_set == True) /* absolute frequency reached the limit */
    {
        STSDBG_WR_INT_LN("b_last_set = ", s_power_scan_data.b_last_set);        
        return (True);
    }

    if (s_power_scan_data.iter > s_power_scan_data.max_number_of_sets)
    {
        STSDBG_WR_INT("iter = ", s_power_scan_data.iter);
        STSDBG_WR_INT_LN(" | exceeded or equal max sets = ", s_power_scan_data.max_number_of_sets);
        return (True);
    }

    return (False);
}


static STATE* 
PWRSCAN_Step2Stop()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_stop_state);
	return &pwrscan_stop_state;
}


static BOOL   
PWRSCAN_Step2AbortCriterion()
{
    if (s_power_scan_data.b_abort == True)
    {
        return (True);
    }
    return (False);
}


static STATE* 
PWRSCAN_Step2Abort()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_abort_state);
	return &pwrscan_abort_state;
}

#if (HAMARO_INCLUDE_DEBUG & PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE)
static FILE *stream;
/*static*/ void 
PWRSCAN_FillTestDataFromFile()
{
    unsigned long last_freq = 0, first_freq = 0;
    unsigned long read_freq = 0;
    short index = *p_filled_buffer_length-1;
    unsigned short read_power;

    if((stream = fopen("C:\\dev\\Hamaro\\Software\\src\\Driver\\pwrspectrum.txt", "r+")) == NULL)
    {
        return;
    }    

    if (STS_GetFirstFreq(&first_freq) == False)
    {
        return;
    }

    if (STS_GetLastFreq(&last_freq) == False)
    {
        return;
    }

    do 
    {
        if (fscanf(stream, "%d %d", &read_freq, &read_power) == EOF)
        {
            return;
        }
    } while (read_freq != first_freq);

    p_freq_reading[index]  = read_freq;  
    p_power_reading[index] = read_power;
    index--;

    do 
    {
        if (fscanf(stream, "%d %d", &read_freq, &read_power) == EOF)
        {
            return;
        }
        p_freq_reading[index]  = read_freq;  
        p_power_reading[index] = read_power;
        index--;
        if (index < 0)
        {
            break;
        }
    } while (read_freq != last_freq);

    fclose(stream);
}
#else /* HAMARO_INCLUDE_DEBUG & PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE */
static void 
PWRSCAN_FillTestDataFromFile()
{
    /* do nothing */
}
#endif /* HAMARO_INCLUDE_DEBUG & PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE*/


/*****************************************************************************/
/* PWRSCAN_SmoothingFilter. Does Symmetrical averaging. */
/*  */
/*****************************************************************************/
#define PWRSCAN_MAX_SAMPLES_TO_AVERAGE  31
/*static*/ BOOL
PWRSCAN_SmoothingFilter() /* use this only for the main buffer */
{
    unsigned short index, min_index, max_index;
    unsigned short average_index, buffer_index;
    unsigned short copy_src_index, copy_dst_index;
    unsigned long  average_accum;
    unsigned short temp_buffer[PWRSCAN_MAX_SAMPLES_TO_AVERAGE];

    if (s_power_spectrum_data.filled_buffer_len == 0)
    {