?? hamaro_pwrscan.c
字號:
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 */?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -