?? hamaro_pwrscan.c
字號:
{
STSDBG_WR_INT_LN("Write failed for frequency count = ", addr);
return (False);
}
return (True);
}
/*****************************************************************************/
/* PWRSCAN_GetTotalFreqOffset() */
/*****************************************************************************/
static int
PWRSCAN_GetTotalFreqOffset(int center_frequency, int frequency_step)
{
int total_freq_offset;
total_freq_offset = center_frequency - frequency_step;
#if STS_ENABLE_VERBOSE_LOG
STSDBG_WR_INT(" | Center = ", center_frequency);
STSDBG_WR_INT(" | Step size = ", frequency_step);
STSDBG_WR_INT(" | Center + step_size = ", total_freq_offset);
#endif /* STS_ENABLE_VERBOSE_LOG */
return (total_freq_offset);
}
/*****************************************************************************/
/* PWRSCAN_WriteFreqCount() */
/*****************************************************************************/
static BOOL
PWRSCAN_WriteFreqCount(unsigned short value)
{
if (STS_WRITE(STS_FREQ_CNT, value) == False)
{
return (False);
}
return (True);
}
/*****************************************************************************/
/* PWRSCAN_GetInitialCenterFreq() */
/*****************************************************************************/
static int s_center_frequency;
static int
PWRSCAN_GetInitialCenterFreq(unsigned char span_mhz, int additional_offset)
{
s_center_frequency = ((unsigned long)span_mhz * 1000000UL) / 2UL;
s_center_frequency = (s_center_frequency + additional_offset);
return s_center_frequency;
}
/*****************************************************************************/
/* PWRSCAN_GetNextCenterFreq() */
/*****************************************************************************/
static int
PWRSCAN_GetNextCenterFreq(unsigned short freq_count, unsigned long step_size_hz)
{
s_center_frequency -= ((int)freq_count * (int)step_size_hz); /* next set */
return s_center_frequency;
}
/*****************************************************************************/
/* PWRSCAN_GetInitialFreqStep() */
/*****************************************************************************/
static int s_initial_freq_step;
static int
PWRSCAN_GetInitialFreqStep(unsigned long step_size_hz, unsigned short number_freq_cnt)
{
s_initial_freq_step = (step_size_hz * number_freq_cnt) >> 1;
return -s_initial_freq_step;
}
/*****************************************************************************/
/* PWRSCAN_GetReadyBitTimeout() */
/* */
/*****************************************************************************/
static long window_length_lookup[STS_MAX_OBSERVATION_WINDOW_INDEX] =
{
0x200, /* 2POW09 */
0x400, /* 2POW10 */
0x800, /* 2POW11 */
0x1000, /* 2POW12 */
0x2000, /* 2POW13 */
0x4000, /* 2POW14 */
0x8000, /* 2POW15 */
0x10000, /* 2POW16 */
0x20000, /* 2POW17 */
0x40000, /* 2POW18 */
0x80000, /* 2POW19 */
0x100000, /* 2POW20 */
0x200000, /* 2POW21 */
0x400000, /* 2POW22 */
0x800000, /* 2POW23 */
0x1000000 /* 2POW24 */
};
static long
PWRSCAN_GetReadyBitTimeout(unsigned short observation_window, unsigned long match_filter_clock_khz)
{
long delay_msec, delay_buffer;
if (observation_window > (STS_MAX_OBSERVATION_WINDOW_INDEX-1))
{
return 0;
}
delay_msec = (window_length_lookup[observation_window] / (long)match_filter_clock_khz) + 1L;
delay_buffer = delay_msec / 20; /* 5% buffer */
delay_msec = delay_msec + delay_buffer;
/* STSDBG_WR_INT_LN("Ready bit timeout (msec) = ", delay_msec); */
return (delay_msec);
}
static void
PWRSCAN_Sleep(clock_t wait_msec)
{
clock_t goal;
goal = wait_msec + clock();
while( goal > clock() )
{ /* loop until timeout */
}
}
/* PWRSCAN_WaitForMeasurement() */
/* */
/*****************************************************************************/
static long delay = 0;
static BOOL
PWRSCAN_WaitForMeasurement()
{
unsigned short read_count;
int forever = 1;
#if HAMARO_WIN_DEBUG
unsigned short read_val1 = 0, read_val2 = 0;
#endif /* HAMARO_WIN_DEBUG */
if (STS_WRITE(STS_AUTO_MODE, 0) == False)
{
return (False);
}
/* Wait for STS ready (STS Page=0, Add=0x05) */
read_count = 0;
do {
delay = PWRSCAN_GetReadyBitTimeout(s_power_scan_data.power_scan_input.observation_window, s_power_scan_data.power_scan_input.symbol_rate_khz);
PWRSCAN_Sleep(delay);
PWRSCAN_CheckErrors();
#if HAMARO_WIN_DEBUG
if (STS_READ(STS_LEN, &read_val1) == False)
{
return (False);
}
if (STS_READ(STS_LEN_SEL, &read_val2) == False)
{
return (False);
}
if (s_power_scan_data.power_scan_input.observation_window != read_val2)
{
STSDBG_WR_UNSIGNED("ERROR: STS_LEN_SEL = ", read_val2);
STSDBG_WR_UNSIGNED_LN(" does not match programmed value = ", s_power_scan_data.power_scan_input.observation_window);
}
if (read_val1 != read_val2)
{
STSDBG_WR_UNSIGNED("ERROR: STS_LEN_SEL = ", read_val2);
STSDBG_WR_UNSIGNED_LN(" does not match STS_LEN = ", read_val1);
}
#endif /* HAMARO_WIN_DEBUG */
if (PWRSCAN_IsReady() == True)
{
#if STS_ENABLE_VERBOSE_LOG
STSDBG_WR_UNSIGNED("Total delay = ", delay);
STSDBG_WR_UNSIGNED(" x ", read_count+1);
STSDBG_WR_STR(" times ", True);
#endif /* STS_ENABLE_VERBOSE_LOG */
break;
}
if (read_count == STS_WAIT_FOR_MEASUREMENT_TIMEOUT)
{
STSDBG_WR_STR("PWRSCAN_WaitForMeasurement::STS_WAIT_FOR_MEASUREMENT_TIMEOUT", True);
return (False);
}
read_count++;
} while (forever);
return (True);
}
/* Power Scan: Reset state */
extern unsigned short s_max_raw_power_reading;
extern unsigned short s_sub_max_raw_power_reading;
static void
PWRSCAN_ResetEnter()
{
unsigned long symbol_rate_mhz;
unsigned long step_size_khz;
s_power_scan_data.delta_abs_freq_khz = 0;
s_power_scan_data.b_last_set = False;
s_power_scan_data.forever = 1;
p_power_reading = 0;
p_freq_reading = 0;
p_filled_buffer_length = 0;
s_power_scan_data.b_abort = False;
s_continue_scan = False;
s_stop = False;
symbol_rate_mhz = s_power_scan_data.power_scan_input.symbol_rate_khz/1000;
if (symbol_rate_mhz < STS_MIN_MATCH_FILTER_CLK_MHZ)
{
s_power_scan_data.power_scan_input.symbol_rate_khz = STS_MIN_MATCH_FILTER_CLK_MHZ * 1000;
}
else if (symbol_rate_mhz > STS_MAX_MATCH_FILTER_CLK_MHZ)
{
s_power_scan_data.power_scan_input.symbol_rate_khz = STS_MAX_MATCH_FILTER_CLK_MHZ * 1000;
}
step_size_khz = s_power_scan_data.power_scan_input.step_size_hz/1000;
if (step_size_khz < STS_MIN_STEP_SIZE_KHZ) /* cannot do steps less than 10khz */
{
s_power_scan_data.power_scan_input.step_size_hz = STS_MIN_STEP_SIZE_KHZ * 1000;
}
else if (step_size_khz > STS_MAX_STEP_SIZE_KHZ) /* 1Mhz. */
{
s_power_scan_data.power_scan_input.step_size_hz = STS_MAX_STEP_SIZE_KHZ * 1000;
}
s_power_scan_data.number_freq_cnt = PWRSCAN_GetNumFreqCount((unsigned char)(s_power_scan_data.power_scan_input.symbol_rate_khz/1000),
(unsigned short)(s_power_scan_data.power_scan_input.step_size_hz/1000));
if (STS_GetUseMainBuffer() == True)
{
p_power_reading = &s_power_spectrum_data.power[0];
p_freq_reading = &s_power_spectrum_data.abs_freq[0];
p_filled_buffer_length = &s_power_spectrum_data.filled_buffer_len;
s_power_scan_data.max_index = STS_MAX_INDEX;
p_max_pwr_reading = &s_max_raw_power_reading;
p_agcacc = &s_power_spectrum_data.agcacc;
}
else
{
p_power_reading = &s_power_spectrum_data.sub_power[0];
p_freq_reading = &s_power_spectrum_data.sub_abs_freq[0];
p_filled_buffer_length = &s_power_spectrum_data.filled_sub_buffer_len;
s_power_scan_data.max_index = STS_MAX_SUB_INDEX;
p_max_pwr_reading = &s_sub_max_raw_power_reading;
p_agcacc = &s_power_spectrum_data.sub_agcacc;
}
if (s_power_scan_data.power_scan_input.search_span_mhz > STS_MAX_SPAN_MHZ)
{
s_power_scan_data.power_scan_input.search_span_mhz = STS_MAX_SPAN_MHZ;
}
s_power_scan_data.max_number_of_sets = PWRSCAN_GetMaxNumberSets(s_power_scan_data.power_scan_input.search_span_mhz,
s_power_scan_data.number_freq_cnt,
s_power_scan_data.power_scan_input.step_size_hz);
PWRSCAN_ResetBuffers();
if (s_power_scan_data.number_freq_cnt > STS_MAX_FREQ_MEM_REGISTERS) /* max registers */
{
s_power_scan_data.b_abort = True;
return;
}
if (s_power_scan_data.power_scan_input.search_span_mhz % 2)
{
s_power_scan_data.power_scan_input.search_span_mhz++;
}
PWRSCAN_ProgramPLLMult(STS_PLL_MULT);
/* 3) Set symbol rate */
HAMARO_SetSymbolRate(hamaro_nim_list.nim[0], s_power_scan_data.power_scan_input.symbol_rate_khz);
PWRSCAN_Enable(True);
}
static BOOL
PWRSCAN_Reset2TuneCriterion()
{
return (True);
}
static STATE*
PWRSCAN_Reset2Tune()
{
DBG_CHECK_FSM_LIMITS(&pwrscan_tune_state);
return &pwrscan_tune_state;
}
static BOOL
PWRSCAN_Reset2AbortCriterion()
{
if (s_power_scan_data.b_abort == True)
{
return (True);
}
return (False);
}
static STATE*
PWRSCAN_Reset2Abort()
{
DBG_CHECK_FSM_LIMITS(&pwrscan_abort_state);
return &pwrscan_abort_state;
}
/* Power scan: Tune state */
static void
PWRSCAN_TuneEnter()
{
s_power_scan_data.number_of_segments++;
if (s_power_scan_data.power_scan_input.tuner_freq_hz > SCAN_HIGH_LIMIT)
{
s_power_scan_data.b_last_set = True;
return;
}
s_power_scan_data.power_scan_input.tuner_freq_hz += ((unsigned long)s_power_scan_data.power_scan_input.search_span_mhz * 1000000UL) >> 1UL;
if (s_power_scan_data.power_scan_input.tuner_freq_hz < SCAN_LOW_LIMIT)
{
s_power_scan_data.b_abort = True;
return;
}
/* 1) For channel sensing, we need to open the tuner anti-alias filter to maximum. */
/* Anti-alias Filter Bandwidth = Acquisition Freq Offset + roll-off * Symbol Rate */
if (s_power_scan_data.power_scan_input.bw_symbol_rate_mhz > STS_MAX_SYMBOL_RATE_MHZ)
{
s_power_scan_data.power_scan_input.bw_symbol_rate_mhz = STS_MAX_SYMBOL_RATE_MHZ;
}
if (s_power_scan_data.power_scan_input.bw_symbol_rate_mhz == STS_MAX_SYMBOL_RATE_MHZ) /* open max bandwidth */
{
PWRSCAN_OpenBandwidth(675UL, STS_MAX_SYMBOL_RATE_MHZ*1000UL, 5000L);
}
else
{
PWRSCAN_OpenBandwidth(675UL, (unsigned long)(s_power_scan_data.power_scan_input.bw_symbol_rate_mhz)*1000UL, 0L);
}
PWRSCAN_AAGCControl(False); /* normal operation */
s_power_scan_data.pll_lock = 0;
s_power_scan_data.actual_tuner_frequency = 0;
/* 4) Set Tuner frequency */
PWRSCAN_SetTunerFrequency(s_power_scan_data.power_scan_input.tuner_freq_hz,
&s_power_scan_data.pll_lock,
&s_power_scan_data.actual_tuner_frequency);
s_power_scan_data.tuner_freq_khz = (int)(s_power_scan_data.power_scan_input.tuner_freq_hz/1000);
}
static BOOL
PWRSCAN_Tune2AbortCriterion()
{
if (s_power_scan_data.b_abort == True)
{
return (True);
}
return (False);
}
static STATE*
PWRSCAN_Tune2Abort()
{
DBG_CHECK_FSM_LIMITS(&pwrscan_abort_state);
return &pwrscan_abort_state;
}
static BOOL
PWRSCAN_Tune2StartCriterion()
{
return (True);
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -