hamaro_pwrscan.c

QPSK Tuner details, for conexant chipset.

        return False;
    }

    min_index = PWRSCAN_MAX_SAMPLES_TO_AVERAGE/2;   
    max_index = s_power_spectrum_data.filled_buffer_len - min_index;

    buffer_index = 0;
    memset(&temp_buffer[0], 0, sizeof(unsigned short)*(PWRSCAN_MAX_SAMPLES_TO_AVERAGE));
    for (index = min_index; index < max_index; index++)
    {
        average_accum = 0;
        for (average_index = (index-min_index); average_index <= (index+min_index); average_index++)
        {
            average_accum += s_power_spectrum_data.power[average_index];
        }
        temp_buffer[buffer_index] = (unsigned short)(average_accum / PWRSCAN_MAX_SAMPLES_TO_AVERAGE);
        buffer_index++;
        if (buffer_index == PWRSCAN_MAX_SAMPLES_TO_AVERAGE)
        {            
            copy_dst_index = 0;
            index--;
            for (copy_src_index = index-PWRSCAN_MAX_SAMPLES_TO_AVERAGE; copy_src_index < index; copy_src_index++)
            {
                s_power_spectrum_data.power[copy_src_index] = temp_buffer[copy_dst_index];
                copy_dst_index++;
            }
            index++;
            buffer_index = 0;
            memset(&temp_buffer[0], 0, sizeof(unsigned short)*(PWRSCAN_MAX_SAMPLES_TO_AVERAGE));
        }        
    }
    return (True);
}


BOOL
PWRSCAN_StitchPowerScanSegments() /* Use this only for the main buffer */
{
    unsigned char  segment_index;
    unsigned short buffer_index;
    signed char    aagc_prev, aagc_curr = 0;
    unsigned long power_prev, power_curr, scale;
    BOOL segment_found;
    unsigned long ratio;

    power_prev = s_power_spectrum_data.power[0];
    aagc_prev  = s_pwrscan_buffer_info[0].agcacc;

    scale = 3;
    s_scaled_max_power_reading = 0;

    for (buffer_index = 1; buffer_index < s_power_spectrum_data.filled_buffer_len; buffer_index++)
    {   
        power_curr = s_power_spectrum_data.power[buffer_index];
        segment_found = False;
        
        /* Get the aagc value */
        for (segment_index = 0; segment_index < s_buffer_info_index; segment_index++)
        {
            if (s_power_spectrum_data.abs_freq[buffer_index] <= s_pwrscan_buffer_info[segment_index].end_freq_hz)
            {
                segment_found = True;
                break;
            }
        }
        if (segment_found == True)
        {
            aagc_curr = s_pwrscan_buffer_info[segment_index].agcacc;
        }
        else
        {
            aagc_curr = aagc_prev;
        }
#if  STS_ENABLE_VERBOSE_LOG 
        STSDBG_WR_STR(" [PWRC] =", False);
        STSDBG_WR_INT(" ", power_prev);
        STSDBG_WR_STR(" [PWRP] =", False);
        STSDBG_WR_INT_LN(" ", power_curr);
#endif /* STS_ENABLE_VERBOSE_LOG */
        if (aagc_curr != aagc_prev)
        {
			if (!scale) 
			{
				scale++;
			}

            if (power_prev > power_curr)
            {
                if (power_curr != 0)
                {
                    ratio = ((power_prev * 10)/power_curr);
                    if ((ratio % 10) > 5)
                    {
						ratio += 5;
                        ratio /= 10;
                    }
                    else
                    {
                        ratio /= 10;
                    }
                    if (ratio == 0)
                    {
                        ratio = 1;
                    }
                    scale = scale * ratio;
                }
            }
            else
            {
                if (power_prev != 0)
                {
                    ratio = ((power_curr * 10)/power_prev);
                    if ((ratio % 10) > 5)
                    {
						ratio += 5;
                        ratio /= 10;
                    }
                    else
                    {
                        ratio /= 10;
                    }
                    if (ratio == 0)
                    {
                        ratio = 1;
                    }
                    scale = scale / ratio;
                }                
            }

            STSDBG_WR_STR("----------------------------------------------------------------------------------------------------------------------", True);
            STSDBG_WR_STR(" [SCALE] =", False);            
            STSDBG_WR_INT(" ", scale);
            STSDBG_WR_STR(" [AGCC]  =", False);
            STSDBG_WR_INT(" ", aagc_curr);
            STSDBG_WR_STR(" [AGCP]  =", False);
            STSDBG_WR_INT(" ", aagc_prev);
            STSDBG_WR_STR(" [FREQ]  =", False);
            STSDBG_WR_INT_LN(" ", s_power_spectrum_data.abs_freq[buffer_index]);
            STSDBG_WR_STR("----------------------------------------------------------------------------------------------------------------------", True);
        }

        s_power_spectrum_data.power[buffer_index] = (unsigned short)((power_curr * scale) >> 3); 

        if (buffer_index == 1)
        {
            s_power_spectrum_data.power[0] = s_power_spectrum_data.power[buffer_index];
        }
        /* Get the scaled maximum power reading */
        if (s_power_spectrum_data.power[buffer_index] > s_scaled_max_power_reading)
        {
            s_scaled_max_power_reading = s_power_spectrum_data.power[buffer_index];
        }
        power_prev = power_curr;
        aagc_prev  = aagc_curr;
    }
    return(True);
}


#if HAMARO_INCLUDE_DEBUG
void
PWRSCAN_LogSegmentData()
{
    unsigned char  segment_index;

    STSDBG_WR_STR("----------------------------------------------------------------------------------------------------------------------", True);
    for (segment_index = 0; segment_index < s_buffer_info_index; segment_index++)
    {
        STSDBG_WR_UNSIGNED_LN("SEGMENT #", segment_index);
        STSDBG_WR_INT_LN("AAGC = ", s_pwrscan_buffer_info[segment_index].agcacc);
        STSDBG_WR_UNSIGNED_LN("START FREQ = ", s_pwrscan_buffer_info[segment_index].start_freq_hz);
        STSDBG_WR_UNSIGNED_LN("END FREQ = ", s_pwrscan_buffer_info[segment_index].end_freq_hz);
        STSDBG_WR_UNSIGNED_LN("MAX POWER = ", s_pwrscan_buffer_info[segment_index].max_power_reading);
        STSDBG_WR_UNSIGNED_LN("LENGTH = ", s_pwrscan_buffer_info[segment_index].filled_buffer_length);
        STSDBG_WR_STR("----------------------------------------------------------------------------------------------------------------------", True);
    }
}
#endif /* HAMARO_INCLUDE_DEBUG */

BOOL 
PWRSCAN_GetSegmentLength(unsigned char* p_segment_len)
{
    if (p_segment_len == 0)
    {
        return (False);
    }
    *p_segment_len = (unsigned char)s_buffer_info_index;
    return (True);
}

BOOL
PWRSCAN_GetSegmentData(unsigned char index, HAMARO_PWRSCAN_BUFFER_INFO* p_data)
{
    if (index >= STS_MAX_NUM_OF_SCAN_SEGMENTS)
    {
        return (False);
    }
    memcpy(p_data, &s_pwrscan_buffer_info[index],  sizeof(HAMARO_PWRSCAN_BUFFER_INFO));
    return (True);
}

int
PWRSCAN_GetAGCFromFreq(unsigned long frequency)
{
    unsigned char  segment_index;

    for (segment_index = 0; segment_index < s_buffer_info_index; segment_index++)
    {
        if (frequency <= s_pwrscan_buffer_info[segment_index].end_freq_hz)
        {
            return s_pwrscan_buffer_info[segment_index].agcacc;
        }
    }
    return 0;
}

unsigned short
PWRSCAN_GetScaledMaxPowerReading()
{
    STSDBG_WR_UNSIGNED_LN("SCALED MAX POWER READING = ", s_scaled_max_power_reading);
    return s_scaled_max_power_reading;
}

/* Power scan: Stop state */
static void   
PWRSCAN_StopEnter()
{
    *p_filled_buffer_length = (unsigned short)s_power_scan_data.abs_freq_index;
    s_pwrscan_buffer_info[s_buffer_info_index].end_freq_index = *p_filled_buffer_length;

    STSDBG_WR_INT_LN("Total data points = ", s_power_scan_data.abs_freq_index);

    if (s_power_scan_data.power_index > 0)
    {
        s_power_spectrum_data.last_power_level = p_power_reading[0];
        STSDBG_WR_INT_LN("Last power level = ", s_power_spectrum_data.last_power_level);
    }

#if PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE
    PWRSCAN_FillTestDataFromFile();
#else /*PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE*/
#endif /* PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE */  

    if (s_power_scan_data.power_scan_input.full_scan == True)
    {
        s_continue_scan = True;

        s_pwrscan_buffer_info[s_buffer_info_index].max_power_reading = PWRSCAN_GetSegmentMaxPowerReading();

        s_pwrscan_buffer_info[s_buffer_info_index].start_freq_hz = s_power_spectrum_data.abs_freq[s_pwrscan_buffer_info[s_buffer_info_index].start_freq_index];
  
        s_pwrscan_buffer_info[s_buffer_info_index].end_freq_hz   = s_power_spectrum_data.abs_freq[s_pwrscan_buffer_info[s_buffer_info_index].end_freq_index-1];

        s_power_scan_data.power_scan_input.tuner_freq_hz = s_pwrscan_buffer_info[s_buffer_info_index].end_freq_hz;

        s_pwrscan_buffer_info[s_buffer_info_index].filled_buffer_length = s_pwrscan_buffer_info[s_buffer_info_index].end_freq_index 
                                                                          - s_pwrscan_buffer_info[s_buffer_info_index].start_freq_index;
       
        s_buffer_info_index++;
	    // include the center data reading.
    	s_power_scan_data.power_scan_input.tuner_freq_hz += (s_power_scan_data.power_scan_input.step_size_hz); 

        s_power_scan_data.b_last_set = False;
    }
    else
    {
        s_pwrscan_buffer_info[s_buffer_info_index].max_power_reading = PWRSCAN_GetSegmentMaxPowerReading();
        s_pwrscan_buffer_info[s_buffer_info_index].start_freq_hz = s_power_spectrum_data.abs_freq[s_pwrscan_buffer_info[s_buffer_info_index].start_freq_index];
        s_pwrscan_buffer_info[s_buffer_info_index].end_freq_hz = s_power_spectrum_data.abs_freq[s_pwrscan_buffer_info[s_buffer_info_index].end_freq_index-1];

        s_pwrscan_buffer_info[s_buffer_info_index].filled_buffer_length = s_pwrscan_buffer_info[s_buffer_info_index].end_freq_index 
                                                                          - s_pwrscan_buffer_info[s_buffer_info_index].start_freq_index;
    }
}

static BOOL   
PWRSCAN_Stop2TuneCriterion()
{
    return (s_continue_scan);
}

static STATE* 
PWRSCAN_Stop2Tune()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_tune_state);
	return &pwrscan_tune_state;
}

static BOOL   
PWRSCAN_Stop2ReadyCriterion()
{
    BOOL ret_value = False;
    
    if (s_power_scan_data.b_last_set)
    {
        ret_value = True;
    }
    else if (s_continue_scan == True)
    {
        if (s_power_scan_data.power_scan_input.tuner_freq_hz > s_power_scan_data.power_scan_input.upper_freq_limit_hz)
        {
            ret_value = True;
        }
    }
    else if (s_power_scan_data.power_scan_input.full_scan == False)
    {
        ret_value = True;
    }
    else if (s_buffer_info_index == STS_MAX_NUM_OF_SCAN_SEGMENTS)
    {
        ret_value = True;
    }

    if (ret_value == True)
    {
        PWRSCAN_Enable(False);

        if (STS_GetUseMainBuffer() == True)
        {
#if 0 //get powerscan data
            STS_SetPowerSpectrumLogFormat(1);
            STS_LogPowerSpectrum();
#endif                
            STS_UpdateProgress(HAMARO_STS_PROCESSING_BUFFER);
            if (s_power_scan_data.power_scan_input.stitch == True)
            {
                STSDBG_WR_STR ("[PWRSCAN_Stop2ReadyCriterion] SCALING DATA SEGMENTS...", True);
                /* parse the raw data */
                STS_ParsePowerDataInMainBuffer();
                STSDBG_WR_ELAPSED_TIME();
                
//                PWRSCAN_StitchPowerScanSegments();
                
                /* Check TPs with stitched data */
//                STS_CheckCandidateWithStitcheddata();
#if 0 //get stitched powerscan data
                STS_SetPowerSpectrumLogFormat(5);
                STS_LogPowerSpectrum();
#endif             
            }
            if (s_power_scan_data.power_scan_input.smooth == True)
            {
                PWRSCAN_SmoothingFilter();
                STSDBG_WR_STR ("[PWRSCAN_Stop2ReadyCriterion] SMOOTHING DATA...", True);
            }
#if HAMARO_INCLUDE_DEBUG
            PWRSCAN_LogSegmentData();
#endif /* HAMARO_INCLUDE_DEBUG */
        }
    }

    return (ret_value);
}


static STATE* 
PWRSCAN_Stop2Ready()
{
    DBG_CHECK_FSM_LIMITS(&pwrscan_ready_state);
	return &pwrscan_ready_state;
}


/* Power scan: Abort state */
static void   
PWRSCAN_AbortEnter()
{
    PWRSCAN_Enable(False);
}


/* Power scan: Ready state */
static void   
PWRSCAN_ReadyEnter()
{
    /* do nothing */
}

unsigned short
PWRSCAN_FindNearestStartIndex(unsigned long frequency_hz)
{
    unsigned char index;

    for (index = 0; index < s_power_scan_data.number_of_segments; index++)
    {
        if (frequency_hz >= s_pwrscan_buffer_info[index].start_freq_hz)
		{
            return (s_pwrscan_buffer_info[index].start_freq_index);
		}
    }
    return 0;
}

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