mirrors/uv-k5-firmware-custom
0
Fork 0
mirror of https://github.com/OneOfEleven/uv-k5-firmware-custom.git synced 2025-06-19 06:39:49 +03:00
Code Issues Releases Activity

Timeout added to the code scan part of F+4 freq/code scan operation

Browse Source
This commit is contained in:
OneOfEleven
2023-10-09 17:01:26 +01:00
parent 7a42f332fa
commit 4e4868c212
16 changed files with 464 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/action.c
View File

@ -92,7 +92,7 @@ void ACTION_Monitor(void)
{
g_scan_pause_delay_in_10ms = scan_pause_delay_in_1_10ms;
g_schedule_scan_listen = false;
gScanPauseMode = true;
g_scan_pause_mode = true;
}
#ifdef ENABLE_NOAA

297
app/app.c
View File

@ -495,11 +495,11 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
switch (g_eeprom.scan_resume_mode)
{
case SCAN_RESUME_TO:
if (!gScanPauseMode)
if (!g_scan_pause_mode)
{
g_scan_pause_delay_in_10ms = scan_pause_delay_in_1_10ms;
g_schedule_scan_listen = false;
gScanPauseMode = true;
g_scan_pause_mode = true;
}
break;
@ -510,7 +510,7 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
break;
}
bScanKeepFrequency = true;
g_scan_keep_frequency = true;
}
#ifdef ENABLE_NOAA
@ -637,7 +637,7 @@ static void FREQ_NextChannel(void)
g_scan_pause_delay_in_10ms = scan_pause_delay_in_6_10ms;
#endif
bScanKeepFrequency = false;
g_scan_keep_frequency = false;
g_update_display = true;
}
@ -737,7 +737,7 @@ static void USER_NextChannel(void)
g_scan_pause_delay_in_10ms = scan_pause_delay_in_3_10ms;
#endif
bScanKeepFrequency = false;
g_scan_keep_frequency = false;
if (enabled)
if (++g_current_scan_list >= SCAN_NEXT_NUM)
@ -1094,7 +1094,7 @@ void APP_Update(void)
USER_NextChannel(); // switch to next channel
}
gScanPauseMode = false;
g_scan_pause_mode = false;
g_rx_reception_mode = RX_MODE_NONE;
g_schedule_scan_listen = false;
}
@ -1149,7 +1149,7 @@ void APP_Update(void)
GUI_SelectNextDisplay(DISPLAY_MAIN);
g_rx_vfo_is_active = false;
gScanPauseMode = false;
g_scan_pause_mode = false;
g_rx_reception_mode = RX_MODE_NONE;
g_schedule_dual_watch = false;
}
@ -1330,7 +1330,7 @@ void APP_CheckKeys(void)
g_ptt_debounce_counter = 0;
// *****************
// scan the hardware keys
Key = KEYBOARD_Poll();
@ -1350,7 +1350,7 @@ void APP_CheckKeys(void)
g_boot_counter_10ms = 0; // cancel the boot-up screen
return; // the PC is uploading/downloading config
}
if (g_key_reading_0 != Key)
{ // new key pressed
@ -1557,10 +1557,12 @@ void APP_TimeSlice10ms(void)
if (g_screen_to_display == DISPLAY_SCANNER)
{
uint32_t Result;
int32_t Delta;
uint32_t Result;
int32_t Delta;
uint16_t CtcssFreq;
BK4819_CSS_scan_result_t ScanResult;
uint16_t CtcssFreq;
g_scan_freq_css_timer_10ms++;
if (g_scan_delay_10ms > 0)
{
@ -1571,58 +1573,95 @@ void APP_TimeSlice10ms(void)
}
}
if (gScannerEditState != SCAN_EDIT_STATE_NONE)
if (g_scanner_edit_state != SCAN_EDIT_STATE_NONE)
{
APP_CheckKeys();
return;
}
switch (gScanCssState)
g_update_display = true;
GUI_SelectNextDisplay(DISPLAY_SCANNER);
switch (g_scan_css_state)
{
case SCAN_CSS_STATE_OFF:
if (g_scan_freq_css_timer_10ms >= scan_freq_css_timeout_10ms)
{ // freq/css scan timeout
#ifdef ENABLE_CODE_SCAN_TIMEOUT
BK4819_DisableFrequencyScan();
g_scan_css_state = SCAN_CSS_STATE_FREQ_FAILED;
g_update_status = true;
g_update_display = true;
break;
#endif
}
if (!BK4819_GetFrequencyScanResult(&Result))
break;
break; // still scanning
// accept only within 1kHz
Delta = Result - gScanFrequency;
gScanHitCount = (abs(Delta) < 100) ? gScanHitCount + 1 : 0;
Delta = Result - g_scan_frequency;
g_scan_hit_count = (abs(Delta) < 100) ? g_scan_hit_count + 1 : 0;
BK4819_DisableFrequencyScan();
#if 0
gScanFrequency = Result;
g_scan_frequency = Result;
#else
{ // round to nearest step multiple
const uint32_t step = STEP_FREQ_TABLE[g_step_setting];
gScanFrequency = ((Result + (step / 2)) / step) * step;
g_scan_frequency = ((Result + (step / 2)) / step) * step;
}
#endif
if (gScanHitCount < 3)
if (g_scan_hit_count < 3)
{ // keep scanning for an RF carrier
BK4819_EnableFrequencyScan();
}
else
{ // RF carrier found .. stop RF scanning
BK4819_SetScanFrequency(gScanFrequency);
{ // RF carrier found
// stop RF the scan and move on too the CTCSS/CDCSS scan
// start CTCSS/CTDSS scanning
gScanCssResultCode = 0xFF;
gScanCssResultType = 0xFF;
gScanHitCount = 0;
gScanUseCssResult = false;
gScanProgressIndicator = 0;
gScanCssState = SCAN_CSS_STATE_SCANNING;
BK4819_SetScanFrequency(g_scan_frequency);
g_scan_css_result_code = 0xFF;
g_scan_css_result_type = 0xFF;
g_scan_hit_count = 0;
g_scan_use_css_result = false;
g_scan_freq_css_timer_10ms = 0;
g_scan_css_state = SCAN_CSS_STATE_SCANNING;
GUI_SelectNextDisplay(DISPLAY_SCANNER);
g_update_status = true;
g_update_status = true;
g_update_display = true;
}
g_scan_delay_10ms = scan_freq_css_delay_10ms;
break;
case SCAN_CSS_STATE_SCANNING:
if (g_scan_freq_css_timer_10ms >= scan_freq_css_timeout_10ms)
{ // timeout
#if defined(ENABLE_CODE_SCAN_TIMEOUT)
BK4819_Disable();
g_scan_css_state = SCAN_CSS_STATE_FAILED;
g_update_status = true;
g_update_display = true;
break;
#elif defined(ENABLE_FREQ_CODE_SCAN_TIMEOUT)
if (!g_scan_single_frequency)
{
BK4819_Disable();
g_scan_css_state = SCAN_CSS_STATE_FAILED;
g_update_status = true;
g_update_display = true;
break;
}
#endif
}
ScanResult = BK4819_GetCxCSSScanResult(&Result, &CtcssFreq);
if (ScanResult == BK4819_CSS_RESULT_NOT_FOUND)
break;
@ -1634,46 +1673,52 @@ void APP_TimeSlice10ms(void)
const uint8_t Code = DCS_GetCdcssCode(Result);
if (Code != 0xFF)
{
gScanCssResultCode = Code;
gScanCssResultType = CODE_TYPE_DIGITAL;
gScanCssState = SCAN_CSS_STATE_FOUND;
gScanUseCssResult = true;
g_update_status = true;
g_scan_css_result_code = Code;
g_scan_css_result_type = CODE_TYPE_DIGITAL;
g_scan_css_state = SCAN_CSS_STATE_FOUND;
g_scan_use_css_result = true;
g_update_status = true;
g_update_display = true;
}
}
else
if (ScanResult == BK4819_CSS_RESULT_CTCSS)
{
const uint8_t Code = DCS_GetCtcssCode(CtcssFreq);
if (Code != 0xFF)
const uint8_t code = DCS_GetCtcssCode(CtcssFreq);
if (code != 0xFF)
{
if (Code == gScanCssResultCode && gScanCssResultType == CODE_TYPE_CONTINUOUS_TONE)
if (code == g_scan_css_result_code &&
g_scan_css_result_type == CODE_TYPE_CONTINUOUS_TONE)
{
if (++gScanHitCount >= 2)
if (++g_scan_hit_count >= 2)
{
gScanCssState = SCAN_CSS_STATE_FOUND;
gScanUseCssResult = true;
g_update_status = true;
g_scan_css_state = SCAN_CSS_STATE_FOUND;
g_scan_use_css_result = true;
g_update_status = true;
g_update_display = true;
}
}
else
gScanHitCount = 0;
g_scan_hit_count = 0;
gScanCssResultType = CODE_TYPE_CONTINUOUS_TONE;
gScanCssResultCode = Code;
g_scan_css_result_type = CODE_TYPE_CONTINUOUS_TONE;
g_scan_css_result_code = code;
}
}
if (gScanCssState == SCAN_CSS_STATE_OFF || gScanCssState == SCAN_CSS_STATE_SCANNING)
if (g_scan_css_state == SCAN_CSS_STATE_OFF ||
g_scan_css_state == SCAN_CSS_STATE_SCANNING)
{ // re-start scan
BK4819_SetScanFrequency(gScanFrequency);
BK4819_SetScanFrequency(g_scan_frequency);
g_scan_delay_10ms = scan_freq_css_delay_10ms;
break;
}
GUI_SelectNextDisplay(DISPLAY_SCANNER);
break;
//case SCAN_CSS_STATE_FOUND:
//case SCAN_CSS_STATE_FAILED:
//case SCAN_CSS_STATE_FREQ_FAILED:
default:
break;
}
@ -1835,75 +1880,80 @@ void APP_TimeSlice500ms(void)
#endif
{
#ifdef ENABLE_AIRCOPY
if (g_scan_state_dir == SCAN_OFF && g_screen_to_display != DISPLAY_AIRCOPY && (g_screen_to_display != DISPLAY_SCANNER || gScanCssState >= SCAN_CSS_STATE_FOUND))
#else
if (g_scan_state_dir == SCAN_OFF && (g_screen_to_display != DISPLAY_SCANNER || gScanCssState >= SCAN_CSS_STATE_FOUND))
if (g_screen_to_display != DISPLAY_AIRCOPY)
#endif
{
if (g_eeprom.auto_keypad_lock && g_key_lock_count_down > 0 && !g_dtmf_input_mode)
{
if (g_scan_state_dir == SCAN_OFF &&
(g_screen_to_display != DISPLAY_SCANNER ||
g_scan_css_state == SCAN_CSS_STATE_FOUND ||
g_scan_css_state == SCAN_CSS_STATE_FAILED ||
g_scan_css_state == SCAN_CSS_STATE_FREQ_FAILED))
{
if (--g_key_lock_count_down == 0)
g_eeprom.key_lock = true; // lock the keyboard
g_update_status = true; // lock symbol needs showing
}
if (exit_menu)
{
g_menu_count_down = 0;
if (g_eeprom.backlight == 0)
if (g_eeprom.auto_keypad_lock && g_key_lock_count_down > 0 && !g_dtmf_input_mode)
{
g_backlight_count_down = 0;
GPIO_ClearBit(&GPIOB->DATA, GPIOB_PIN_BACKLIGHT); // turn the backlight OFF
if (--g_key_lock_count_down == 0)
g_eeprom.key_lock = true; // lock the keyboard
g_update_status = true; // lock symbol needs showing
}
if (g_input_box_index > 0 || g_dtmf_input_mode)
AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
/*
if (g_screen_to_display == DISPLAY_SCANNER)
if (exit_menu)
{
BK4819_StopScan();
RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
RADIO_SetupRegisters(true);
}
*/
DTMF_clear_input_box();
g_f_key_was_pressed = false;
g_input_box_index = 0;
g_ask_to_save = false;
g_ask_to_delete = false;
g_update_status = true;
g_update_display = true;
{
gui_display_type_t disp = DISPLAY_INVALID;
#ifdef ENABLE_FMRADIO
if (g_fm_radio_mode &&
g_current_function != FUNCTION_RECEIVE &&
g_current_function != FUNCTION_MONITOR &&
g_current_function != FUNCTION_TRANSMIT)
{
disp = DISPLAY_FM;
}
#endif
if (disp == DISPLAY_INVALID)
g_menu_count_down = 0;
if (g_eeprom.backlight == 0)
{
#ifndef ENABLE_CODE_SCAN_TIMEOUT
if (g_screen_to_display != DISPLAY_SCANNER)
#endif
disp = DISPLAY_MAIN;
g_backlight_count_down = 0;
GPIO_ClearBit(&GPIOB->DATA, GPIOB_PIN_BACKLIGHT); // turn the backlight OFF
}
if (g_input_box_index > 0 || g_dtmf_input_mode)
AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
/*
if (g_screen_to_display == DISPLAY_SCANNER)
{
BK4819_StopScan();
RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
RADIO_SetupRegisters(true);
}
*/
DTMF_clear_input_box();
g_f_key_was_pressed = false;
g_input_box_index = 0;
g_ask_to_save = false;
g_ask_to_delete = false;
g_update_status = true;
g_update_display = true;
{
gui_display_type_t disp = DISPLAY_INVALID;
#ifdef ENABLE_FMRADIO
if (g_fm_radio_mode &&
g_current_function != FUNCTION_RECEIVE &&
g_current_function != FUNCTION_MONITOR &&
g_current_function != FUNCTION_TRANSMIT)
{
disp = DISPLAY_FM;
}
#endif
if (disp == DISPLAY_INVALID)
{
#ifndef ENABLE_CODE_SCAN_TIMEOUT
if (g_screen_to_display != DISPLAY_SCANNER)
#endif
disp = DISPLAY_MAIN;
}
if (disp != DISPLAY_INVALID)
GUI_SelectNextDisplay(disp);
}
if (disp != DISPLAY_INVALID)
GUI_SelectNextDisplay(disp);
}
}
}
@ -1983,27 +2033,6 @@ void APP_TimeSlice500ms(void)
}
}
if (g_screen_to_display == DISPLAY_SCANNER &&
gScannerEditState == SCAN_EDIT_STATE_NONE &&
gScanCssState < SCAN_CSS_STATE_FOUND)
{
gScanProgressIndicator++;
#ifdef ENABLE_CODE_SCAN_TIMEOUT
if (gScanProgressIndicator > 32)
{
if (gScanCssState == SCAN_CSS_STATE_SCANNING && !g_scan_single_frequency)
gScanCssState = SCAN_CSS_STATE_FOUND;
else
gScanCssState = SCAN_CSS_STATE_FAILED;
g_update_status = true;
}
#endif
g_update_display = true;
}
if (g_current_function != FUNCTION_TRANSMIT)
{
if (g_dtmf_decode_ring_count_down_500ms > 0)
@ -2080,7 +2109,7 @@ void APP_TimeSlice500ms(void)
}
#endif
void CHANNEL_Next(const bool flag, const int8_t scan_direction)
void CHANNEL_Next(const bool flag, const scan_state_dir_t scan_direction)
{
RADIO_SelectVfos();
@ -2104,8 +2133,8 @@ void CHANNEL_Next(const bool flag, const int8_t scan_direction)
g_scan_pause_delay_in_10ms = scan_pause_delay_in_2_10ms;
g_schedule_scan_listen = false;
g_rx_reception_mode = RX_MODE_NONE;
gScanPauseMode = false;
bScanKeepFrequency = false;
g_scan_pause_mode = false;
g_scan_keep_frequency = false;
}
static void APP_ProcessKey(const key_code_t Key, const bool key_pressed, const bool key_held)

2
app/app.h
View File

@ -29,7 +29,7 @@ extern const uint8_t orig_mixer;
extern const uint8_t orig_pga;
void APP_EndTransmission(void);
void CHANNEL_Next(const bool flag, const int8_t scan_direction);
void CHANNEL_Next(const bool flag, const scan_state_dir_t scan_direction);
void APP_StartListening(function_type_t Function, const bool reset_am_fix);
uint32_t APP_SetFrequencyByStep(vfo_info_t *pInfo, int8_t Step);
void APP_Update(void);

2
app/main.c
View File

@ -709,7 +709,7 @@ static void MAIN_Key_STAR(bool key_pressed, bool key_held)
g_update_status = true;
}
static void MAIN_Key_UP_DOWN(bool key_pressed, bool key_held, int8_t Direction)
static void MAIN_Key_UP_DOWN(bool key_pressed, bool key_held, scan_state_dir_t Direction)
{
uint8_t Channel = g_eeprom.screen_channel[g_eeprom.tx_vfo];

288
app/scanner.c
View File

@ -26,103 +26,103 @@
#include "ui/inputbox.h"
#include "ui/ui.h"
dcs_code_type_t gScanCssResultType;
uint8_t gScanCssResultCode;
dcs_code_type_t g_scan_css_result_type;
uint8_t g_scan_css_result_code;
bool g_flag_start_scan;
bool g_flag_stop_scan;
bool g_scan_single_frequency;
SCAN_edit_state_t gScannerEditState;
uint8_t gScanChannel;
uint32_t gScanFrequency;
bool gScanPauseMode;
SCAN_CssState_t gScanCssState;
scan_edit_state_t g_scanner_edit_state;
uint8_t g_scan_channel;
uint32_t g_scan_frequency;
bool g_scan_pause_mode;
scan_css_state_t g_scan_css_state;
volatile bool g_schedule_scan_listen = true;
volatile uint16_t g_scan_pause_delay_in_10ms;
uint8_t gScanProgressIndicator;
uint8_t gScanHitCount;
bool gScanUseCssResult;
int8_t g_scan_state_dir;
bool bScanKeepFrequency;
uint16_t g_scan_freq_css_timer_10ms;
uint8_t g_scan_hit_count;
bool g_scan_use_css_result;
scan_state_dir_t g_scan_state_dir;
bool g_scan_keep_frequency;
static void SCANNER_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
{
if (!key_held && key_pressed)
if (key_held || !key_pressed)
return;
if (g_scanner_edit_state == SCAN_EDIT_STATE_BUSY)
{
if (gScannerEditState == SCAN_EDIT_STATE_BUSY)
uint16_t Channel;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
INPUTBOX_Append(Key);
g_request_display_screen = DISPLAY_SCANNER;
if (g_input_box_index < 3)
{
uint16_t Channel;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
INPUTBOX_Append(Key);
g_request_display_screen = DISPLAY_SCANNER;
if (g_input_box_index < 3)
{
#ifdef ENABLE_VOICE
g_another_voice_id = (voice_id_t)Key;
#endif
return;
}
g_input_box_index = 0;
Channel = ((g_input_box[0] * 100) + (g_input_box[1] * 10) + g_input_box[2]) - 1;
if (Channel <= USER_CHANNEL_LAST)
{
#ifdef ENABLE_VOICE
g_another_voice_id = (voice_id_t)Key;
#endif
g_show_chan_prefix = RADIO_CheckValidChannel(Channel, false, 0);
gScanChannel = (uint8_t)Channel;
return;
}
#ifdef ENABLE_VOICE
g_another_voice_id = (voice_id_t)Key;
#endif
return;
}
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
g_input_box_index = 0;
Channel = ((g_input_box[0] * 100) + (g_input_box[1] * 10) + g_input_box[2]) - 1;
if (Channel <= USER_CHANNEL_LAST)
{
#ifdef ENABLE_VOICE
g_another_voice_id = (voice_id_t)Key;
#endif
g_show_chan_prefix = RADIO_CheckValidChannel(Channel, false, 0);
g_scan_channel = (uint8_t)Channel;
return;
}
}
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
}
static void SCANNER_Key_EXIT(bool key_pressed, bool key_held)
{
if (!key_held && key_pressed)
if (key_held || !key_pressed)
return;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
switch (g_scanner_edit_state)
{
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
case SCAN_EDIT_STATE_NONE:
g_request_display_screen = DISPLAY_MAIN;
switch (gScannerEditState)
{
case SCAN_EDIT_STATE_NONE:
g_request_display_screen = DISPLAY_MAIN;
g_eeprom.cross_vfo_rx_tx = g_backup_cross_vfo_rx_tx;
g_update_status = true;
g_flag_stop_scan = true;
g_vfo_configure_mode = VFO_CONFIGURE_RELOAD;
g_flag_reset_vfos = true;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_CANCEL;
#endif
break;
g_eeprom.cross_vfo_rx_tx = g_backup_cross_vfo_rx_tx;
g_update_status = true;
g_flag_stop_scan = true;
g_vfo_configure_mode = VFO_CONFIGURE_RELOAD;
g_flag_reset_vfos = true;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_CANCEL;
#endif
case SCAN_EDIT_STATE_BUSY:
if (g_input_box_index > 0)
{
g_input_box[--g_input_box_index] = 10;
g_request_display_screen = DISPLAY_SCANNER;
break;
}
case SCAN_EDIT_STATE_BUSY:
if (g_input_box_index > 0)
{
g_input_box[--g_input_box_index] = 10;
g_request_display_screen = DISPLAY_SCANNER;
break;
}
// Fallthrough
// Fallthrough
case SCAN_EDIT_STATE_DONE:
gScannerEditState = SCAN_EDIT_STATE_NONE;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_CANCEL;
#endif
g_request_display_screen = DISPLAY_SCANNER;
break;
}
case SCAN_EDIT_STATE_DONE:
g_scanner_edit_state = SCAN_EDIT_STATE_NONE;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_CANCEL;
#endif
g_request_display_screen = DISPLAY_SCANNER;
break;
}
}
@ -136,13 +136,13 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (!key_pressed)
return;
if (gScanCssState == SCAN_CSS_STATE_OFF && !g_scan_single_frequency)
if (g_scan_css_state == SCAN_CSS_STATE_OFF && !g_scan_single_frequency)
{
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return;
}
if (gScanCssState == SCAN_CSS_STATE_SCANNING)
if (g_scan_css_state == SCAN_CSS_STATE_SCANNING)
{
if (g_scan_single_frequency)
{
@ -151,7 +151,7 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
}
}
if (gScanCssState == SCAN_CSS_STATE_FAILED)
if (g_scan_css_state == SCAN_CSS_STATE_FAILED)
{
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return;
@ -159,17 +159,17 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
switch (gScannerEditState)
switch (g_scanner_edit_state)
{
case SCAN_EDIT_STATE_NONE:
if (!g_scan_single_frequency)
{
#if 0
uint32_t Freq250 = FREQUENCY_FloorToStep(gScanFrequency, 250, 0);
uint32_t Freq625 = FREQUENCY_FloorToStep(gScanFrequency, 625, 0);
uint32_t Freq250 = FREQUENCY_FloorToStep(g_scan_frequency, 250, 0);
uint32_t Freq625 = FREQUENCY_FloorToStep(g_scan_frequency, 625, 0);
int16_t Delta250 = (int16_t)gScanFrequency - (int16_t)Freq250;
int16_t Delta250 = (int16_t)g_scan_frequency - (int16_t)Freq250;
int16_t Delta625;
if (125 < Delta250)
@ -178,7 +178,7 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
Freq250 += 250;
}
Delta625 = (int16_t)gScanFrequency - (int16_t)Freq625;
Delta625 = (int16_t)g_scan_frequency - (int16_t)Freq625;
if (312 < Delta625)
{
@ -189,12 +189,12 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (Delta625 < Delta250)
{
g_step_setting = STEP_6_25kHz;
gScanFrequency = Freq625;
g_scan_frequency = Freq625;
}
else
{
g_step_setting = STEP_2_5kHz;
gScanFrequency = Freq250;
g_scan_frequency = Freq250;
}
#else
@ -209,11 +209,11 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
const uint32_t small_step_freq = STEP_FREQ_TABLE[small_step];
const uint32_t big_step_freq = STEP_FREQ_TABLE[big_step];
uint32_t freq_small_step = FREQUENCY_FloorToStep(gScanFrequency, small_step_freq, 0);
uint32_t freq_big_step = FREQUENCY_FloorToStep(gScanFrequency, big_step_freq, 0);
uint32_t freq_small_step = FREQUENCY_FloorToStep(g_scan_frequency, small_step_freq, 0);
uint32_t freq_big_step = FREQUENCY_FloorToStep(g_scan_frequency, big_step_freq, 0);
int32_t delta_small_step = (int32_t)gScanFrequency - freq_small_step;
int32_t delta_big_step = (int32_t)gScanFrequency - freq_big_step;
int32_t delta_small_step = (int32_t)g_scan_frequency - freq_small_step;
int32_t delta_big_step = (int32_t)g_scan_frequency - freq_big_step;
if (delta_small_step > 125)
{
@ -221,7 +221,7 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
freq_big_step += small_step_freq;
}
delta_big_step = (int32_t)gScanFrequency - freq_big_step;
delta_big_step = (int32_t)g_scan_frequency - freq_big_step;
if (delta_big_step > 312)
{
@ -232,28 +232,28 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (delta_small_step >= delta_big_step)
{
g_step_setting = small_step;
gScanFrequency = freq_small_step;
g_scan_frequency = freq_small_step;
}
else
{
g_step_setting = big_step;
gScanFrequency = freq_big_step;
g_scan_frequency = freq_big_step;
}
#endif
}
if (g_tx_vfo->channel_save <= USER_CHANNEL_LAST)
{
gScannerEditState = SCAN_EDIT_STATE_BUSY;
gScanChannel = g_tx_vfo->channel_save;
g_scanner_edit_state = SCAN_EDIT_STATE_BUSY;
g_scan_channel = g_tx_vfo->channel_save;
g_show_chan_prefix = RADIO_CheckValidChannel(g_tx_vfo->channel_save, false, 0);
}
else
{
gScannerEditState = SCAN_EDIT_STATE_DONE;
g_scanner_edit_state = SCAN_EDIT_STATE_DONE;
}
gScanCssState = SCAN_CSS_STATE_FOUND;
g_scan_css_state = SCAN_CSS_STATE_FOUND;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_MEMORY_CHANNEL;
@ -268,19 +268,19 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
{
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_request_display_screen = DISPLAY_SCANNER;
gScannerEditState = SCAN_EDIT_STATE_DONE;
g_scanner_edit_state = SCAN_EDIT_STATE_DONE;
}
break;
case SCAN_EDIT_STATE_DONE:
if (!g_scan_single_frequency)
{
RADIO_InitInfo(g_tx_vfo, g_tx_vfo->channel_save, gScanFrequency);
RADIO_InitInfo(g_tx_vfo, g_tx_vfo->channel_save, g_scan_frequency);
if (gScanUseCssResult)
if (g_scan_use_css_result)
{
g_tx_vfo->freq_config_rx.code_type = gScanCssResultType;
g_tx_vfo->freq_config_rx.code = gScanCssResultCode;
g_tx_vfo->freq_config_rx.code_type = g_scan_css_result_type;
g_tx_vfo->freq_config_rx.code = g_scan_css_result_code;
}
g_tx_vfo->freq_config_tx = g_tx_vfo->freq_config_rx;
@ -291,15 +291,15 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
g_tx_vfo->freq_config_rx.code_type = gScanCssResultType;
g_tx_vfo->freq_config_rx.code = gScanCssResultCode;
g_tx_vfo->freq_config_tx.code_type = gScanCssResultType;
g_tx_vfo->freq_config_tx.code = gScanCssResultCode;
g_tx_vfo->freq_config_rx.code_type = g_scan_css_result_type;
g_tx_vfo->freq_config_rx.code = g_scan_css_result_code;
g_tx_vfo->freq_config_tx.code_type = g_scan_css_result_type;
g_tx_vfo->freq_config_tx.code = g_scan_css_result_code;
}
if (g_tx_vfo->channel_save <= USER_CHANNEL_LAST)
{
Channel = gScanChannel;
Channel = g_scan_channel;
g_eeprom.user_channel[g_eeprom.tx_vfo] = Channel;
}
else
@ -316,7 +316,7 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
g_another_voice_id = VOICE_ID_CONFIRM;
#endif
gScannerEditState = SCAN_EDIT_STATE_NONE;
g_scanner_edit_state = SCAN_EDIT_STATE_NONE;
g_request_display_screen = DISPLAY_SCANNER;
break;
@ -329,12 +329,11 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
static void SCANNER_Key_STAR(bool key_pressed, bool key_held)
{
if (!key_held && key_pressed)
{
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_flag_start_scan = true;
}
return;
if (key_held || !key_pressed)
return;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_flag_start_scan = true;
}
static void SCANNER_Key_UP_DOWN(bool key_pressed, bool pKeyHeld, int8_t Direction)
@ -353,10 +352,10 @@ static void SCANNER_Key_UP_DOWN(bool key_pressed, bool pKeyHeld, int8_t Directio
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
}
if (gScannerEditState == SCAN_EDIT_STATE_BUSY)
if (g_scanner_edit_state == SCAN_EDIT_STATE_BUSY)
{
gScanChannel = NUMBER_AddWithWraparound(gScanChannel, Direction, 0, USER_CHANNEL_LAST);
g_show_chan_prefix = RADIO_CheckValidChannel(gScanChannel, false, 0);
g_scan_channel = NUMBER_AddWithWraparound(g_scan_channel, Direction, 0, USER_CHANNEL_LAST);
g_show_chan_prefix = RADIO_CheckValidChannel(g_scan_channel, false, 0);
g_request_display_screen = DISPLAY_SCANNER;
}
else
@ -423,8 +422,8 @@ void SCANNER_Start(void)
RADIO_InitInfo(g_rx_vfo, g_rx_vfo->channel_save, g_rx_vfo->pRX->frequency);
g_rx_vfo->step_setting = BackupStep;
g_rx_vfo->step_freq = BackupStepFreq;
g_rx_vfo->step_setting = BackupStep;
g_rx_vfo->step_freq = BackupStepFreq;
RADIO_SetupRegisters(true);
@ -434,17 +433,17 @@ void SCANNER_Start(void)
if (g_scan_single_frequency)
{
gScanCssState = SCAN_CSS_STATE_SCANNING;
gScanFrequency = g_rx_vfo->pRX->frequency;
g_scan_css_state = SCAN_CSS_STATE_SCANNING;
g_scan_frequency = g_rx_vfo->pRX->frequency;
g_step_setting = g_rx_vfo->step_setting;
BK4819_PickRXFilterPathBasedOnFrequency(gScanFrequency);
BK4819_SetScanFrequency(gScanFrequency);
BK4819_PickRXFilterPathBasedOnFrequency(g_scan_frequency);
BK4819_SetScanFrequency(g_scan_frequency);
}
else
{
gScanCssState = SCAN_CSS_STATE_OFF;
gScanFrequency = 0xFFFFFFFF;
g_scan_css_state = SCAN_CSS_STATE_OFF;
g_scan_frequency = 0xFFFFFFFF;
BK4819_PickRXFilterPathBasedOnFrequency(0xFFFFFFFF);
BK4819_EnableFrequencyScan();
@ -452,22 +451,22 @@ void SCANNER_Start(void)
DTMF_clear_RX();
g_scan_delay_10ms = scan_freq_css_delay_10ms;
gScanCssResultCode = 0xFF;
gScanCssResultType = 0xFF;
gScanHitCount = 0;
gScanUseCssResult = false;
g_CxCSS_tail_found = false;
g_CDCSS_lost = false;
g_CDCSS_code_type = 0;
g_CTCSS_lost = false;
#ifdef ENABLE_VOX
g_vox_lost = false;
#endif
g_squelch_lost = false;
gScannerEditState = SCAN_EDIT_STATE_NONE;
gScanProgressIndicator = 0;
// g_flag_start_scan = false;
g_scan_delay_10ms = scan_freq_css_delay_10ms;
g_scan_css_result_code = 0xFF;
g_scan_css_result_type = 0xFF;
g_scan_hit_count = 0;
g_scan_use_css_result = false;
g_CxCSS_tail_found = false;
g_CDCSS_lost = false;
g_CDCSS_code_type = 0;
g_CTCSS_lost = false;
#ifdef ENABLE_VOX
g_vox_lost = false;
#endif
g_squelch_lost = false;
g_scanner_edit_state = SCAN_EDIT_STATE_NONE;
g_scan_freq_css_timer_10ms = 0;
// g_flag_start_scan = false;
g_update_status = true;
}
@ -477,15 +476,15 @@ void SCANNER_Stop(void)
const uint8_t Previous = g_restore_channel;
if (g_scan_state_dir == SCAN_OFF)
return; // but, but, we weren't !
return; // but, but, we weren't doing anything !
g_scan_state_dir = SCAN_OFF;
if (!bScanKeepFrequency)
if (!g_scan_keep_frequency)
{
if (g_next_channel <= USER_CHANNEL_LAST)
{
g_eeprom.user_channel[g_eeprom.rx_vfo] = g_restore_channel;
g_eeprom.user_channel[g_eeprom.rx_vfo] = g_restore_channel;
g_eeprom.screen_channel[g_eeprom.rx_vfo] = Previous;
RADIO_ConfigureChannel(g_eeprom.rx_vfo, VFO_CONFIGURE_RELOAD);
@ -493,10 +492,13 @@ void SCANNER_Stop(void)
else
{
g_rx_vfo->freq_config_rx.frequency = g_restore_frequency;
RADIO_ApplyOffset(g_rx_vfo);
RADIO_ConfigureSquelchAndOutputPower(g_rx_vfo);
}
RADIO_SetupRegisters(true);
g_update_display = true;
return;
}

39
app/scanner.h
View File

@ -20,45 +20,48 @@
#include "dcs.h"
#include "driver/keyboard.h"
enum SCAN_CssState_e
enum scan_css_state_e
{
SCAN_CSS_STATE_OFF = 0,
// SCAN_CSS_STATE_FREQ_SCANNING,
SCAN_CSS_STATE_SCANNING,
SCAN_CSS_STATE_FOUND,
SCAN_CSS_STATE_FAILED
SCAN_CSS_STATE_FAILED,
SCAN_CSS_STATE_FREQ_FAILED
};
typedef enum SCAN_CssState_e SCAN_CssState_t;
typedef enum scan_css_state_e scan_css_state_t;
enum {
enum scan_state_dir_e {
SCAN_REV = -1,
SCAN_OFF = 0,
SCAN_FWD = +1
};
typedef enum scan_state_dir_e scan_state_dir_t;
enum SCAN_edit_state_e {
enum scan_edit_state_e {
SCAN_EDIT_STATE_NONE = 0,
SCAN_EDIT_STATE_BUSY,
SCAN_EDIT_STATE_DONE
};
typedef enum SCAN_edit_state_e SCAN_edit_state_t;
typedef enum scan_edit_state_e scan_edit_state_t;
extern dcs_code_type_t gScanCssResultType;
extern uint8_t gScanCssResultCode;
extern dcs_code_type_t g_scan_css_result_type;
extern uint8_t g_scan_css_result_code;
extern bool g_flag_start_scan;
extern bool g_flag_stop_scan;
extern bool g_scan_single_frequency;
extern SCAN_edit_state_t gScannerEditState;
extern uint8_t gScanChannel;
extern uint32_t gScanFrequency;
extern bool gScanPauseMode;
extern SCAN_CssState_t gScanCssState;
extern scan_edit_state_t g_scanner_edit_state;
extern uint8_t g_scan_channel;
extern uint32_t g_scan_frequency;
extern bool g_scan_pause_mode;
extern scan_css_state_t g_scan_css_state;
extern volatile bool g_schedule_scan_listen;
extern volatile uint16_t g_scan_pause_delay_in_10ms;
extern uint8_t gScanProgressIndicator;
extern uint8_t gScanHitCount;
extern bool gScanUseCssResult;
extern int8_t g_scan_state_dir;
extern bool bScanKeepFrequency;
extern uint16_t g_scan_freq_css_timer_10ms;
extern uint8_t g_scan_hit_count;
extern bool g_scan_use_css_result;
extern scan_state_dir_t g_scan_state_dir;
extern bool g_scan_keep_frequency;
void SCANNER_ProcessKeys(key_code_t Key, bool key_pressed, bool key_held);
void SCANNER_Start(void);