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

Fix F+3 and F+* search freq step size when saving result

Browse Source
This commit is contained in:
OneOfEleven 2023-10-13 15:12:32 +01:00
parent bc416c7433
commit 7f7c9490eb
30 changed files with 652 additions and 571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
app/action.c
View File

@ -88,10 +88,10 @@ void ACTION_Monitor(void)
g_monitor_enabled = false;
if (g_scan_state_dir != SCAN_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF)
{
g_scan_pause_delay_in_10ms = scan_pause_delay_in_1_10ms;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
g_scan_pause_mode = true;
}
@ -171,7 +171,7 @@ void ACTION_Scan(bool bRestart)
}
#endif
if (g_screen_to_display != DISPLAY_SCANNER)
if (g_screen_to_display != DISPLAY_SEARCH)
{ // not scanning
g_monitor_enabled = false;
@ -189,10 +189,10 @@ void ACTION_Scan(bool bRestart)
{
GUI_SelectNextDisplay(DISPLAY_MAIN);
if (g_scan_state_dir != SCAN_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF)
{ // already scanning
if (g_next_channel <= USER_CHANNEL_LAST)
if (g_scan_next_channel <= USER_CHANNEL_LAST)
{ // channel mode
// keep scanning but toggle between scan lists
@ -201,14 +201,14 @@ void ACTION_Scan(bool bRestart)
// jump to the next channel
CHANNEL_Next(true, g_scan_state_dir);
g_scan_pause_delay_in_10ms = 1;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
g_update_status = true;
}
else
{ // stop scanning
SCANNER_Stop();
SCAN_Stop();
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_SCANNING_STOP;
@ -218,7 +218,7 @@ void ACTION_Scan(bool bRestart)
else
{ // start scanning
CHANNEL_Next(true, SCAN_FWD);
CHANNEL_Next(true, SCAN_STATE_DIR_FORWARD);
#ifdef ENABLE_VOICE
AUDIO_SetVoiceID(0, VOICE_ID_SCANNING_BEGIN);
@ -236,14 +236,14 @@ void ACTION_Scan(bool bRestart)
}
else
// if (!bRestart)
if (!bRestart && g_next_channel <= USER_CHANNEL_LAST)
if (!bRestart && g_scan_next_channel <= USER_CHANNEL_LAST)
{ // channel mode, keep scanning but toggle between scan lists
g_eeprom.scan_list_default = (g_eeprom.scan_list_default + 1) % 3;
// jump to the next channel
CHANNEL_Next(true, g_scan_state_dir);
g_scan_pause_delay_in_10ms = 1;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
g_update_status = true;
}
@ -251,7 +251,7 @@ void ACTION_Scan(bool bRestart)
{ // stop scanning
g_monitor_enabled = false;
SCANNER_Stop();
SCAN_Stop();
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_SCANNING_STOP;

2
app/aircopy.c
View File

@ -84,7 +84,7 @@ void AIRCOPY_start_FSK_tx(const uint8_t request_packet)
// TX the packet
RADIO_SetTxParameters();
BK4819_SetupPowerAmplifier(0, g_current_vfo->pTX->frequency); // VERY low TX power
BK4819_SetupPowerAmplifier(0, g_current_vfo->p_tx->frequency); // VERY low TX power
// turn the RED LED on
BK4819_set_GPIO_pin(BK4819_GPIO1_PIN29_RED, true);

338
app/app.c
View File

@ -97,14 +97,14 @@ static void APP_CheckForIncoming(void)
// squelch is open
if (g_scan_state_dir == SCAN_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF)
{ // not RF scanning
if (g_css_scan_mode != CSS_SCAN_MODE_OFF && g_rx_reception_mode == RX_MODE_NONE)
{ // CTCSS/DTS scanning
g_scan_pause_delay_in_10ms = scan_pause_delay_in_5_10ms;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
g_rx_reception_mode = RX_MODE_DETECTED;
}
@ -169,7 +169,7 @@ static void APP_CheckForIncoming(void)
}
g_scan_pause_delay_in_10ms = scan_pause_delay_in_3_10ms;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
}
g_rx_reception_mode = RX_MODE_DETECTED;
@ -202,7 +202,7 @@ static void APP_HandleIncoming(void)
return;
}
flag = (g_scan_state_dir == SCAN_OFF && g_current_code_type == CODE_TYPE_NONE);
flag = (g_scan_state_dir == SCAN_STATE_DIR_OFF && g_current_code_type == CODE_TYPE_NONE);
#ifdef ENABLE_NOAA
if (IS_NOAA_CHANNEL(g_rx_vfo->channel_save) && g_noaa_count_down_10ms > 0)
@ -212,13 +212,13 @@ static void APP_HandleIncoming(void)
}
#endif
if (g_CTCSS_lost && g_current_code_type == CODE_TYPE_CONTINUOUS_TONE)
if (g_ctcss_lost && g_current_code_type == CODE_TYPE_CONTINUOUS_TONE)
{
flag = true;
g_found_CTCSS = false;
}
if (g_CDCSS_lost && g_CDCSS_code_type == CDCSS_POSITIVE_CODE && (g_current_code_type == CODE_TYPE_DIGITAL || g_current_code_type == CODE_TYPE_REVERSE_DIGITAL))
if (g_cdcss_lost && g_cdcss_code_type == CDCSS_POSITIVE_CODE && (g_current_code_type == CODE_TYPE_DIGITAL || g_current_code_type == CODE_TYPE_REVERSE_DIGITAL))
{
g_found_CDCSS = false;
}
@ -226,7 +226,7 @@ static void APP_HandleIncoming(void)
if (!flag)
return;
if (g_scan_state_dir == SCAN_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF)
{ // not scanning
if (g_rx_vfo->dtmf_decoding_enable || g_setting_killed)
{ // DTMF DCD is enabled
@ -270,7 +270,7 @@ static void APP_HandleReceive(void)
goto Skip;
}
if (g_scan_state_dir != SCAN_OFF && IS_FREQ_CHANNEL(g_next_channel))
if (g_scan_state_dir != SCAN_STATE_DIR_OFF && IS_FREQ_CHANNEL(g_scan_next_channel))
{
if (g_squelch_lost)
return;
@ -320,16 +320,16 @@ static void APP_HandleReceive(void)
case CODE_TYPE_NONE:
if (g_eeprom.squelch_level)
{
if (g_CxCSS_tail_found)
if (g_cxcss_tail_found)
{
Mode = END_OF_RX_MODE_TTE;
g_CxCSS_tail_found = false;
g_cxcss_tail_found = false;
}
}
break;
case CODE_TYPE_CONTINUOUS_TONE:
if (g_CTCSS_lost)
if (g_ctcss_lost)
{
g_found_CTCSS = false;
}
@ -340,16 +340,16 @@ static void APP_HandleReceive(void)
g_found_CTCSS_count_down_10ms = 100; // 1 sec
}
if (g_CxCSS_tail_found)
if (g_cxcss_tail_found)
{
Mode = END_OF_RX_MODE_TTE;
g_CxCSS_tail_found = false;
g_cxcss_tail_found = false;
}
break;
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
if (g_CDCSS_lost && g_CDCSS_code_type == CDCSS_POSITIVE_CODE)
if (g_cdcss_lost && g_cdcss_code_type == CDCSS_POSITIVE_CODE)
{
g_found_CDCSS = false;
}
@ -360,12 +360,12 @@ static void APP_HandleReceive(void)
g_found_CDCSS_count_down_10ms = 100; // 1 sec
}
if (g_CxCSS_tail_found)
if (g_cxcss_tail_found)
{
if (BK4819_GetCTCType() == 1)
Mode = END_OF_RX_MODE_TTE;
g_CxCSS_tail_found = false;
g_cxcss_tail_found = false;
}
break;
@ -405,7 +405,7 @@ Skip:
g_update_display = true;
if (g_scan_state_dir != SCAN_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF)
{
switch (g_eeprom.scan_resume_mode)
{
@ -414,11 +414,11 @@ Skip:
case SCAN_RESUME_CO:
g_scan_pause_delay_in_10ms = scan_pause_delay_in_7_10ms;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
break;
case SCAN_RESUME_SE:
SCANNER_Stop();
SCAN_Stop();
break;
}
}
@ -494,7 +494,7 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
if (g_setting_backlight_on_tx_rx >= 2)
backlight_turn_on();
if (g_scan_state_dir != SCAN_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF)
{
switch (g_eeprom.scan_resume_mode)
{
@ -502,7 +502,7 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
if (!g_scan_pause_mode)
{
g_scan_pause_delay_in_10ms = scan_pause_delay_in_1_10ms;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
g_scan_pause_mode = true;
}
break;
@ -510,7 +510,7 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
case SCAN_RESUME_CO:
case SCAN_RESUME_SE:
g_scan_pause_delay_in_10ms = 0;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
break;
}
@ -521,8 +521,8 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
if (IS_NOAA_CHANNEL(g_rx_vfo->channel_save) && g_is_noaa_mode)
{
g_rx_vfo->channel_save = g_noaa_channel + NOAA_CHANNEL_FIRST;
g_rx_vfo->pRX->frequency = NoaaFrequencyTable[g_noaa_channel];
g_rx_vfo->pTX->frequency = NoaaFrequencyTable[g_noaa_channel];
g_rx_vfo->p_rx->frequency = NOAA_FREQUENCY_TABLE[g_noaa_channel];
g_rx_vfo->p_tx->frequency = NOAA_FREQUENCY_TABLE[g_noaa_channel];
g_eeprom.screen_channel[chan] = g_rx_vfo->channel_save;
g_noaa_count_down_10ms = 500; // 5 sec
g_schedule_noaa = false;
@ -532,7 +532,7 @@ void APP_StartListening(function_type_t Function, const bool reset_am_fix)
if (g_css_scan_mode != CSS_SCAN_MODE_OFF)
g_css_scan_mode = CSS_SCAN_MODE_FOUND;
if (g_scan_state_dir == SCAN_OFF &&
if (g_scan_state_dir == SCAN_STATE_DIR_OFF &&
g_css_scan_mode == CSS_SCAN_MODE_OFF &&
g_eeprom.dual_watch != DUAL_WATCH_OFF)
{ // not scanning, dual watch is enabled
@ -632,6 +632,51 @@ uint32_t APP_SetFrequencyByStep(vfo_info_t *pInfo, int8_t Step)
return Frequency;
}
void SCAN_Stop(void)
{
const uint8_t Previous = g_scan_restore_channel;
if (g_scan_state_dir == SCAN_STATE_DIR_OFF)
return; // but, but, we weren't doing anything !
g_scan_state_dir = SCAN_STATE_DIR_OFF;
if (!g_scan_keep_frequency)
{
if (g_scan_next_channel <= USER_CHANNEL_LAST)
{
g_eeprom.user_channel[g_eeprom.rx_vfo] = g_scan_restore_channel;
g_eeprom.screen_channel[g_eeprom.rx_vfo] = Previous;
RADIO_ConfigureChannel(g_eeprom.rx_vfo, VFO_CONFIGURE_RELOAD);
}
else
{
g_rx_vfo->freq_config_rx.frequency = g_scan_restore_frequency;
RADIO_ApplyOffset(g_rx_vfo);
RADIO_ConfigureSquelchAndOutputPower(g_rx_vfo);
}
RADIO_SetupRegisters(true);
g_update_display = true;
return;
}
if (g_rx_vfo->channel_save > USER_CHANNEL_LAST)
{
RADIO_ApplyOffset(g_rx_vfo);
RADIO_ConfigureSquelchAndOutputPower(g_rx_vfo);
SETTINGS_SaveChannel(g_rx_vfo->channel_save, g_eeprom.rx_vfo, g_rx_vfo, 1);
return;
}
SETTINGS_SaveVfoIndices();
g_update_status = true;
}
static void FREQ_NextChannel(void)
{
g_rx_vfo->freq_config_rx.frequency = APP_SetFrequencyByStep(g_rx_vfo, g_scan_state_dir);
@ -656,7 +701,7 @@ static void USER_NextChannel(void)
const bool enabled = (g_eeprom.scan_list_default < 2) ? g_eeprom.scan_list_enabled[g_eeprom.scan_list_default] : true;
const int chan1 = (g_eeprom.scan_list_default < 2) ? g_eeprom.scan_list_priority_ch1[g_eeprom.scan_list_default] : -1;
const int chan2 = (g_eeprom.scan_list_default < 2) ? g_eeprom.scan_list_priority_ch2[g_eeprom.scan_list_default] : -1;
const unsigned int prev_chan = g_next_channel;
const unsigned int prev_chan = g_scan_next_channel;
unsigned int chan = 0;
if (enabled)
@ -664,17 +709,17 @@ static void USER_NextChannel(void)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough="
switch (g_current_scan_list)
switch (g_scan_current_scan_list)
{
case SCAN_NEXT_CHAN_SCANLIST1:
prevChannel = g_next_channel;
prevChannel = g_scan_next_channel;
if (chan1 >= 0)
{
if (RADIO_CheckValidChannel(chan1, false, 0))
{
g_current_scan_list = SCAN_NEXT_CHAN_SCANLIST1;
g_next_channel = chan1;
g_scan_current_scan_list = SCAN_NEXT_CHAN_SCANLIST1;
g_scan_next_channel = chan1;
break;
}
}
@ -684,8 +729,8 @@ static void USER_NextChannel(void)
{
if (RADIO_CheckValidChannel(chan2, false, 0))
{
g_current_scan_list = SCAN_NEXT_CHAN_SCANLIST2;
g_next_channel = chan2;
g_scan_current_scan_list = SCAN_NEXT_CHAN_SCANLIST2;
g_scan_next_channel = chan2;
break;
}
}
@ -699,16 +744,16 @@ static void USER_NextChannel(void)
// chan = g_eeprom.screen_channel[chan];
// if (chan <= USER_CHANNEL_LAST)
// {
// g_current_scan_list = SCAN_NEXT_CHAN_DUAL_WATCH;
// g_next_channel = chan;
// g_scan_current_scan_list = SCAN_NEXT_CHAN_DUAL_WATCH;
// g_scan_next_channel = chan;
// break;
// }
// }
default:
case SCAN_NEXT_CHAN_USER:
g_current_scan_list = SCAN_NEXT_CHAN_USER;
g_next_channel = prevChannel;
g_scan_current_scan_list = SCAN_NEXT_CHAN_USER;
g_scan_next_channel = prevChannel;
chan = 0xff;
break;
}
@ -718,7 +763,7 @@ static void USER_NextChannel(void)
if (!enabled || chan == 0xff)
{
chan = RADIO_FindNextChannel(g_next_channel + g_scan_state_dir, g_scan_state_dir, (g_eeprom.scan_list_default < 2) ? true : false, g_eeprom.scan_list_default);
chan = RADIO_FindNextChannel(g_scan_next_channel + g_scan_state_dir, g_scan_state_dir, (g_eeprom.scan_list_default < 2) ? true : false, g_eeprom.scan_list_default);
if (chan == 0xFF)
{ // no valid channel found
@ -726,13 +771,13 @@ static void USER_NextChannel(void)
// return;
}
g_next_channel = chan;
g_scan_next_channel = chan;
}
if (g_next_channel != prev_chan)
if (g_scan_next_channel != prev_chan)
{
g_eeprom.user_channel[g_eeprom.rx_vfo] = g_next_channel;
g_eeprom.screen_channel[g_eeprom.rx_vfo] = g_next_channel;
g_eeprom.user_channel[g_eeprom.rx_vfo] = g_scan_next_channel;
g_eeprom.screen_channel[g_eeprom.rx_vfo] = g_scan_next_channel;
RADIO_ConfigureChannel(g_eeprom.rx_vfo, VFO_CONFIGURE_RELOAD);
RADIO_SetupRegisters(true);
@ -749,14 +794,14 @@ static void USER_NextChannel(void)
g_scan_keep_frequency = false;
if (enabled)
if (++g_current_scan_list >= SCAN_NEXT_NUM)
g_current_scan_list = SCAN_NEXT_CHAN_SCANLIST1; // back round we go
if (++g_scan_current_scan_list >= SCAN_NEXT_NUM)
g_scan_current_scan_list = SCAN_NEXT_CHAN_SCANLIST1; // back round we go
}
#ifdef ENABLE_NOAA
static void NOAA_IncreaseChannel(void)
{
if (++g_noaa_channel >= ARRAY_SIZE(NoaaFrequencyTable))
if (++g_noaa_channel >= ARRAY_SIZE(NOAA_FREQUENCY_TABLE))
g_noaa_channel = 0;
}
#endif
@ -800,7 +845,7 @@ static void DUALWATCH_Alternate(void)
void APP_CheckRadioInterrupts(void)
{
if (g_screen_to_display == DISPLAY_SCANNER)
if (g_screen_to_display == DISPLAY_SEARCH)
return;
while (BK4819_ReadRegister(BK4819_REG_0C) & 1u)
@ -820,7 +865,7 @@ void APP_CheckRadioInterrupts(void)
// 3 = 240deg phase shift
// const uint8_t ctcss_shift = BK4819_GetCTCShift();
// if (ctcss_shift > 0)
// g_CTCSS_lost = true;
// g_ctcss_lost = true;
if (interrupt_status_bits & BK4819_REG_02_DTMF_5TONE_FOUND)
{ // save the RX'ed DTMF character
@ -862,22 +907,22 @@ void APP_CheckRadioInterrupts(void)
}
if (interrupt_status_bits & BK4819_REG_02_CxCSS_TAIL)
g_CxCSS_tail_found = true;
g_cxcss_tail_found = true;
if (interrupt_status_bits & BK4819_REG_02_CDCSS_LOST)
{
g_CDCSS_lost = true;
g_CDCSS_code_type = BK4819_get_CDCSS_code_type();
g_cdcss_lost = true;
g_cdcss_code_type = BK4819_get_CDCSS_code_type();
}
if (interrupt_status_bits & BK4819_REG_02_CDCSS_FOUND)
g_CDCSS_lost = false;
g_cdcss_lost = false;
if (interrupt_status_bits & BK4819_REG_02_CTCSS_LOST)
g_CTCSS_lost = true;
g_ctcss_lost = true;
if (interrupt_status_bits & BK4819_REG_02_CTCSS_FOUND)
g_CTCSS_lost = false;
g_ctcss_lost = false;
#ifdef ENABLE_VOX
if (interrupt_status_bits & BK4819_REG_02_VOX_LOST)
@ -942,7 +987,7 @@ void APP_EndTransmission(void)
RADIO_SendEndOfTransmission();
if (g_current_vfo->pTX->code_type != CODE_TYPE_NONE)
if (g_current_vfo->p_tx->code_type != CODE_TYPE_NONE)
{ // CTCSS/DCS is enabled
//if (g_eeprom.tail_note_elimination && g_eeprom.repeater_tail_tone_elimination > 0)
@ -988,7 +1033,7 @@ void APP_EndTransmission(void)
if (g_current_function == FUNCTION_RECEIVE || g_current_function == FUNCTION_MONITOR)
return;
if (g_scan_state_dir != SCAN_OFF || g_css_scan_mode != CSS_SCAN_MODE_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF || g_css_scan_mode != CSS_SCAN_MODE_OFF)
return;
if (g_vox_noise_detected)
@ -1084,13 +1129,13 @@ void APP_Update(void)
if (g_voice_write_index == 0)
#endif
{
if (g_screen_to_display != DISPLAY_SCANNER &&
g_scan_state_dir != SCAN_OFF &&
g_schedule_scan_listen &&
if (g_screen_to_display != DISPLAY_SEARCH &&
g_scan_state_dir != SCAN_STATE_DIR_OFF &&
g_scan_schedule_scan_listen &&
!g_ptt_is_pressed)
{ // scanning
if (IS_FREQ_CHANNEL(g_next_channel))
if (IS_FREQ_CHANNEL(g_scan_next_channel))
{
if (g_current_function == FUNCTION_INCOMING)
APP_StartListening(g_monitor_enabled ? FUNCTION_MONITOR : FUNCTION_RECEIVE, true);
@ -1107,19 +1152,19 @@ void APP_Update(void)
g_scan_pause_mode = false;
g_rx_reception_mode = RX_MODE_NONE;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
}
}
#ifdef ENABLE_VOICE
if (g_css_scan_mode == CSS_SCAN_MODE_SCANNING && g_schedule_scan_listen && g_voice_write_index == 0)
if (g_css_scan_mode == CSS_SCAN_MODE_SCANNING && g_scan_schedule_scan_listen && g_voice_write_index == 0)
#else
if (g_css_scan_mode == CSS_SCAN_MODE_SCANNING && g_schedule_scan_listen)
if (g_css_scan_mode == CSS_SCAN_MODE_SCANNING && g_scan_schedule_scan_listen)
#endif
{
MENU_SelectNextCode();
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
}
#ifdef ENABLE_NOAA
@ -1139,7 +1184,7 @@ void APP_Update(void)
#endif
// toggle between the VFO's if dual watch is enabled
if (g_screen_to_display != DISPLAY_SCANNER && g_eeprom.dual_watch != DUAL_WATCH_OFF)
if (g_screen_to_display != DISPLAY_SEARCH && g_eeprom.dual_watch != DUAL_WATCH_OFF)
{
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
//UART_SendText("dual watch\r\n");
@ -1151,7 +1196,7 @@ void APP_Update(void)
{
if (g_schedule_dual_watch)
{
if (g_scan_state_dir == SCAN_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF)
{
#ifdef ENABLE_FMRADIO
if (!g_fm_radio_mode)
@ -1204,7 +1249,7 @@ void APP_Update(void)
g_ptt_is_pressed ||
g_key_held ||
g_eeprom.battery_save == 0 ||
g_scan_state_dir != SCAN_OFF ||
g_scan_state_dir != SCAN_STATE_DIR_OFF ||
g_css_scan_mode != CSS_SCAN_MODE_OFF ||
g_screen_to_display != DISPLAY_MAIN ||
g_dtmf_call_state != DTMF_CALL_STATE_NONE)
@ -1230,7 +1275,7 @@ void APP_Update(void)
g_ptt_is_pressed ||
g_key_held ||
g_eeprom.battery_save == 0 ||
g_scan_state_dir != SCAN_OFF ||
g_scan_state_dir != SCAN_STATE_DIR_OFF ||
g_css_scan_mode != CSS_SCAN_MODE_OFF ||
g_screen_to_display != DISPLAY_MAIN ||
g_dtmf_call_state != DTMF_CALL_STATE_NONE)
@ -1266,7 +1311,7 @@ void APP_Update(void)
#endif
if (g_eeprom.dual_watch != DUAL_WATCH_OFF &&
g_scan_state_dir == SCAN_OFF &&
g_scan_state_dir == SCAN_STATE_DIR_OFF &&
g_css_scan_mode == CSS_SCAN_MODE_OFF)
{ // dual watch mode, toggle between the two VFO's
DUALWATCH_Alternate();
@ -1281,7 +1326,7 @@ void APP_Update(void)
}
else
if (g_eeprom.dual_watch == DUAL_WATCH_OFF ||
g_scan_state_dir != SCAN_OFF ||
g_scan_state_dir != SCAN_STATE_DIR_OFF ||
g_css_scan_mode != CSS_SCAN_MODE_OFF ||
g_update_rssi)
{ // dual watch mode, go back to sleep
@ -1723,46 +1768,46 @@ void APP_TimeSlice10ms(void)
}
#endif
if (g_screen_to_display == DISPLAY_SCANNER)
if (g_screen_to_display == DISPLAY_SEARCH)
{
uint32_t Result;
int32_t Delta;
uint16_t CtcssFreq;
BK4819_CSS_scan_result_t ScanResult;
g_scan_freq_css_timer_10ms++;
g_search_freq_css_timer_10ms++;
if (g_scan_delay_10ms > 0)
if (g_search_delay_10ms > 0)
{
if (--g_scan_delay_10ms > 0)
if (--g_search_delay_10ms > 0)
{
APP_CheckKeys();
return;
}
}
if (g_scanner_edit_state != SCAN_EDIT_STATE_NONE)
if (g_search_edit_state != SEARCH_EDIT_STATE_NONE)
{ // waiting for user input choice
APP_CheckKeys();
return;
}
g_update_display = true;
GUI_SelectNextDisplay(DISPLAY_SCANNER);
GUI_SelectNextDisplay(DISPLAY_SEARCH);
switch (g_scan_css_state)
switch (g_search_css_state)
{
case SCAN_CSS_STATE_OFF:
case SEARCH_CSS_STATE_OFF:
if (g_scan_freq_css_timer_10ms >= scan_freq_css_timeout_10ms)
if (g_search_freq_css_timer_10ms >= scan_freq_css_timeout_10ms)
{ // FREQ/CTCSS/CDCSS search timeout
if (!g_scan_single_frequency)
if (!g_search_single_frequency)
{ // FREQ search timeout
#ifdef ENABLE_FREQ_SEARCH_TIMEOUT
BK4819_DisableFrequencyScan();
g_scan_css_state = SCAN_CSS_STATE_FREQ_FAILED;
g_search_css_state = SEARCH_CSS_STATE_FREQ_FAILED;
AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
g_update_status = true;
@ -1775,7 +1820,7 @@ void APP_TimeSlice10ms(void)
#ifdef ENABLE_CODE_SEARCH_TIMEOUT
BK4819_DisableFrequencyScan();
g_scan_css_state = SCAN_CSS_STATE_FREQ_FAILED;
g_search_css_state = SEARCH_CSS_STATE_FREQ_FAILED;
AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
g_update_status = true;
@ -1789,14 +1834,14 @@ void APP_TimeSlice10ms(void)
break; // still scanning
// accept only within 1kHz
Delta = Result - g_scan_frequency;
g_scan_hit_count = (abs(Delta) < 100) ? g_scan_hit_count + 1 : 0;
Delta = Result - g_search_frequency;
g_search_hit_count = (abs(Delta) < 100) ? g_search_hit_count + 1 : 0;
BK4819_DisableFrequencyScan();
g_scan_frequency = Result;
g_search_frequency = Result;
if (g_scan_hit_count < 3)
if (g_search_hit_count < 3)
{ // keep scanning for an RF carrier
BK4819_EnableFrequencyScan();
}
@ -1804,32 +1849,32 @@ void APP_TimeSlice10ms(void)
{ // RF carrier found
// stop RF the scan and move on too the CTCSS/CDCSS scan
BK4819_SetScanFrequency(g_scan_frequency);
BK4819_SetScanFrequency(g_search_frequency);
g_scan_css_result_type = CODE_TYPE_NONE;
g_scan_css_result_code = 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;
g_search_css_result_type = CODE_TYPE_NONE;
g_search_css_result_code = 0xff;
g_search_hit_count = 0;
g_search_use_css_result = false;
g_search_freq_css_timer_10ms = 0;
g_search_css_state = SEARCH_CSS_STATE_SCANNING;
GUI_SelectNextDisplay(DISPLAY_SCANNER);
GUI_SelectNextDisplay(DISPLAY_SEARCH);
g_update_status = true;
g_update_display = true;
}
g_scan_delay_10ms = scan_freq_css_delay_10ms;
g_search_delay_10ms = scan_freq_css_delay_10ms;
break;
case SCAN_CSS_STATE_SCANNING:
case SEARCH_CSS_STATE_SCANNING:
if (g_scan_freq_css_timer_10ms >= scan_freq_css_timeout_10ms)
if (g_search_freq_css_timer_10ms >= scan_freq_css_timeout_10ms)
{ // CTCSS/CDCSS search timeout
#if defined(ENABLE_CODE_SEARCH_TIMEOUT)
BK4819_Disable();
g_scan_css_state = SCAN_CSS_STATE_FAILED;
g_search_css_state = SEARCH_CSS_STATE_FAILED;
AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
g_update_status = true;
@ -1837,10 +1882,10 @@ void APP_TimeSlice10ms(void)
break;
#else
if (!g_scan_single_frequency)
if (!g_search_single_frequency)
{
BK4819_Disable();
g_scan_css_state = SCAN_CSS_STATE_FAILED;
g_search_css_state = SEARCH_CSS_STATE_FAILED;
AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
g_update_status = true;
@ -1861,10 +1906,10 @@ void APP_TimeSlice10ms(void)
const uint8_t Code = DCS_GetCdcssCode(Result);
if (Code != 0xFF)
{
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_search_css_result_code = Code;
g_search_css_result_type = CODE_TYPE_DIGITAL;
g_search_css_state = SEARCH_CSS_STATE_FOUND;
g_search_use_css_result = true;
AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
g_update_status = true;
@ -1877,13 +1922,13 @@ void APP_TimeSlice10ms(void)
const uint8_t code = DCS_GetCtcssCode(CtcssFreq);
if (code != 0xFF)
{
if (code == g_scan_css_result_code &&
g_scan_css_result_type == CODE_TYPE_CONTINUOUS_TONE)
if (code == g_search_css_result_code &&
g_search_css_result_type == CODE_TYPE_CONTINUOUS_TONE)
{
if (++g_scan_hit_count >= 2)
if (++g_search_hit_count >= 2)
{
g_scan_css_state = SCAN_CSS_STATE_FOUND;
g_scan_use_css_result = true;
g_search_css_state = SEARCH_CSS_STATE_FOUND;
g_search_use_css_result = true;
AUDIO_PlayBeep(BEEP_880HZ_60MS_TRIPLE_BEEP);
g_update_status = true;
@ -1891,26 +1936,26 @@ void APP_TimeSlice10ms(void)
}
}
else
g_scan_hit_count = 0;
g_search_hit_count = 0;
g_scan_css_result_type = CODE_TYPE_CONTINUOUS_TONE;
g_scan_css_result_code = code;
g_search_css_result_type = CODE_TYPE_CONTINUOUS_TONE;
g_search_css_result_code = code;
}
}
if (g_scan_css_state == SCAN_CSS_STATE_OFF ||
g_scan_css_state == SCAN_CSS_STATE_SCANNING)
if (g_search_css_state == SEARCH_CSS_STATE_OFF ||
g_search_css_state == SEARCH_CSS_STATE_SCANNING)
{ // re-start scan
BK4819_SetScanFrequency(g_scan_frequency);
g_scan_delay_10ms = scan_freq_css_delay_10ms;
BK4819_SetScanFrequency(g_search_frequency);
g_search_delay_10ms = scan_freq_css_delay_10ms;
}
GUI_SelectNextDisplay(DISPLAY_SCANNER);
GUI_SelectNextDisplay(DISPLAY_SEARCH);
break;
//case SCAN_CSS_STATE_FOUND:
//case SCAN_CSS_STATE_FAILED:
//case SCAN_CSS_STATE_REPEAT:
//case SEARCH_CSS_STATE_FOUND:
//case SEARCH_CSS_STATE_FAILED:
//case SEARCH_CSS_STATE_REPEAT:
default:
break;
}
@ -2077,11 +2122,11 @@ void APP_TimeSlice500ms(void)
#endif
{
if (g_css_scan_mode == CSS_SCAN_MODE_OFF &&
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_REPEAT))
g_scan_state_dir == SCAN_STATE_DIR_OFF &&
(g_screen_to_display != DISPLAY_SEARCH ||
g_search_css_state == SEARCH_CSS_STATE_FOUND ||
g_search_css_state == SEARCH_CSS_STATE_FAILED ||
g_search_css_state == SEARCH_CSS_STATE_REPEAT))
{
if (g_eeprom.auto_keypad_lock &&
@ -2110,7 +2155,7 @@ void APP_TimeSlice500ms(void)
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 (g_screen_to_display == DISPLAY_SEARCH)
{
BK4819_StopScan();
@ -2147,7 +2192,7 @@ void APP_TimeSlice500ms(void)
if (disp == DISPLAY_INVALID)
{
#ifndef ENABLE_CODE_SEARCH_TIMEOUT
if (g_screen_to_display != DISPLAY_SCANNER)
if (g_screen_to_display != DISPLAY_SEARCH)
#endif
disp = DISPLAY_MAIN;
}
@ -2313,27 +2358,28 @@ void CHANNEL_Next(const bool flag, const scan_state_dir_t scan_direction)
{
RADIO_SelectVfos();
g_next_channel = g_rx_vfo->channel_save;
g_current_scan_list = SCAN_NEXT_CHAN_SCANLIST1;
g_scan_next_channel = g_rx_vfo->channel_save;
g_scan_current_scan_list = SCAN_NEXT_CHAN_SCANLIST1;
g_scan_state_dir = scan_direction;
if (g_next_channel <= USER_CHANNEL_LAST)
if (g_scan_next_channel <= USER_CHANNEL_LAST)
{ // channel mode
if (flag)
g_restore_channel = g_next_channel;
g_scan_restore_channel = g_scan_next_channel;
USER_NextChannel();
}
else
{ // frequency mode
if (flag)
g_restore_frequency = g_rx_vfo->freq_config_rx.frequency;
g_scan_restore_frequency = g_rx_vfo->freq_config_rx.frequency;
FREQ_NextChannel();
}
g_scan_pause_delay_in_10ms = scan_pause_delay_in_2_10ms;
g_schedule_scan_listen = false;
g_rx_reception_mode = RX_MODE_NONE;
g_scan_pause_mode = false;
g_scan_pause_delay_in_10ms = scan_pause_delay_in_2_10ms;
g_scan_schedule_scan_listen = false;
g_scan_pause_mode = false;
g_rx_reception_mode = RX_MODE_NONE;
g_scan_keep_frequency = false;
}
@ -2457,7 +2503,7 @@ static void APP_ProcessKey(const key_code_t Key, const bool key_pressed, const b
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
if (g_scan_state_dir != SCAN_OFF || g_css_scan_mode != CSS_SCAN_MODE_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF || g_css_scan_mode != CSS_SCAN_MODE_OFF)
{ // FREQ/CTCSS/CDCSS scanning
if ((Key >= KEY_0 && Key <= KEY_9) || Key == KEY_F)
@ -2603,8 +2649,8 @@ static void APP_ProcessKey(const key_code_t Key, const bool key_pressed, const b
MENU_ProcessKeys(Key, key_pressed, key_held);
break;
case DISPLAY_SCANNER:
SCANNER_ProcessKeys(Key, key_pressed, key_held);
case DISPLAY_SEARCH:
SEARCH_ProcessKeys(Key, key_pressed, key_held);
break;
#ifdef ENABLE_AIRCOPY
@ -2620,9 +2666,9 @@ static void APP_ProcessKey(const key_code_t Key, const bool key_pressed, const b
}
else
#ifdef ENABLE_AIRCOPY
if (g_screen_to_display != DISPLAY_SCANNER && g_screen_to_display != DISPLAY_AIRCOPY)
if (g_screen_to_display != DISPLAY_SEARCH && g_screen_to_display != DISPLAY_AIRCOPY)
#else
if (g_screen_to_display != DISPLAY_SCANNER)
if (g_screen_to_display != DISPLAY_SEARCH)
#endif
{
ACTION_Handle(Key, key_pressed, key_held);
@ -2654,10 +2700,10 @@ Skip:
g_flag_AcceptSetting = false;
}
if (g_flag_stop_scan)
if (g_search_flag_stop_scan)
{
BK4819_StopScan();
g_flag_stop_scan = false;
g_search_flag_stop_scan = false;
}
if (g_request_save_settings)
@ -2696,7 +2742,7 @@ Skip:
{
SETTINGS_SaveChannel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, g_request_save_channel);
if (g_screen_to_display != DISPLAY_SCANNER)
if (g_screen_to_display != DISPLAY_SEARCH)
if (g_vfo_configure_mode == VFO_CONFIGURE_NONE) // 'if' is so as we don't wipe out previously setting this variable elsewhere
g_vfo_configure_mode = VFO_CONFIGURE;
}
@ -2761,9 +2807,9 @@ Skip:
MENU_ShowCurrentSetting();
}
if (g_flag_start_scan)
if (g_search_flag_start_scan)
{
g_flag_start_scan = false;
g_search_flag_start_scan = false;
g_monitor_enabled = false;
@ -2772,9 +2818,7 @@ Skip:
AUDIO_PlaySingleVoice(true);
#endif
SCANNER_Start();
g_request_display_screen = DISPLAY_SCANNER;
SEARCH_Start();
}
if (g_flag_prepare_tx)

1
app/app.h
View File

@ -29,6 +29,7 @@ extern const uint8_t orig_mixer;
extern const uint8_t orig_pga;
void APP_EndTransmission(void);
void SCAN_Stop(void);
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);

2
app/dtmf.c
View File

@ -209,7 +209,7 @@ void DTMF_HandleRequest(void)
if (!g_dtmf_rx_pending)
return; // nothing new received
if (g_scan_state_dir != SCAN_OFF || g_css_scan_mode != CSS_SCAN_MODE_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF || g_css_scan_mode != CSS_SCAN_MODE_OFF)
{ // we're busy scanning
DTMF_clear_RX();
return;

12
app/generic.c
View File

@ -138,22 +138,22 @@ void GENERIC_Key_PTT(bool key_pressed)
// UART_printf("gene key 1 %u\r\n", key_pressed);
#endif
if (g_scan_state_dir != SCAN_OFF || // frequency/channel scanning
g_screen_to_display == DISPLAY_SCANNER || // CTCSS/CDCSS scanning
if (g_scan_state_dir != SCAN_STATE_DIR_OFF || // frequency/channel scanning
g_screen_to_display == DISPLAY_SEARCH || // CTCSS/CDCSS scanning
g_css_scan_mode != CSS_SCAN_MODE_OFF) // " "
{ // we're scanning .. stop
if (g_screen_to_display == DISPLAY_SCANNER)
if (g_screen_to_display == DISPLAY_SEARCH)
{ // CTCSS/CDCSS scanning .. stop
g_eeprom.cross_vfo_rx_tx = g_backup_cross_vfo_rx_tx;
g_flag_stop_scan = true;
g_search_flag_stop_scan = true;
g_vfo_configure_mode = VFO_CONFIGURE_RELOAD;
g_flag_reset_vfos = true;
}
else
if (g_scan_state_dir != SCAN_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF)
{ // frequency/channel scanning . .stop
SCANNER_Stop();
SCAN_Stop();
}
else
if (g_css_scan_mode != CSS_SCAN_MODE_OFF)

76
app/main.c
View File

@ -41,7 +41,7 @@
void toggle_chan_scanlist(void)
{ // toggle the selected channels scanlist setting
if (g_screen_to_display == DISPLAY_SCANNER || !IS_USER_CHANNEL(g_tx_vfo->channel_save))
if (g_screen_to_display == DISPLAY_SEARCH || !IS_USER_CHANNEL(g_tx_vfo->channel_save))
return;
if (g_tx_vfo->scanlist_1_participation)
@ -78,7 +78,8 @@ static void processFKeyFunction(const key_code_t Key)
switch (Key)
{
case KEY_0:
case KEY_0: // FM
#ifdef ENABLE_FMRADIO
ACTION_FM();
#else
@ -90,12 +91,13 @@ static void processFKeyFunction(const key_code_t Key)
#endif
break;
case KEY_1:
case KEY_1: // BAND
if (!IS_FREQ_CHANNEL(g_tx_vfo->channel_save))
{
g_fkey_pressed = false;
g_update_status = true;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_fkey_pressed = false;
g_update_status = true;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
return;
}
@ -120,7 +122,8 @@ static void processFKeyFunction(const key_code_t Key)
g_request_display_screen = DISPLAY_MAIN;
break;
case KEY_2:
case KEY_2: // A/B
if (g_eeprom.cross_vfo_rx_tx == CROSS_BAND_CHAN_A)
g_eeprom.cross_vfo_rx_tx = CROSS_BAND_CHAN_B;
else
@ -143,7 +146,7 @@ static void processFKeyFunction(const key_code_t Key)
g_request_display_screen = DISPLAY_MAIN;
break;
case KEY_3:
case KEY_3: // VFO/MR
#ifdef ENABLE_NOAA
if (g_eeprom.vfo_open && IS_NOT_NOAA_CHANNEL(g_tx_vfo->channel_save))
#else
@ -190,10 +193,11 @@ static void processFKeyFunction(const key_code_t Key)
break;
case KEY_4:
case KEY_4: // FC
g_fkey_pressed = false;
g_flag_start_scan = true;
g_scan_single_frequency = false;
g_search_flag_start_scan = true;
g_search_single_frequency = false;
g_backup_cross_vfo_rx_tx = g_eeprom.cross_vfo_rx_tx;
g_eeprom.cross_vfo_rx_tx = CROSS_BAND_OFF;
g_update_status = true;
@ -201,7 +205,8 @@ static void processFKeyFunction(const key_code_t Key)
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
break;
case KEY_5:
case KEY_5: // NOAA
#ifdef ENABLE_NOAA
if (IS_NOT_NOAA_CHANNEL(g_tx_vfo->channel_save))
@ -227,12 +232,14 @@ static void processFKeyFunction(const key_code_t Key)
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
break;
case KEY_6:
case KEY_6: // H/M/L
ACTION_Power();
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
break;
case KEY_7:
case KEY_7: // VOX
#ifdef ENABLE_VOX
ACTION_Vox();
#else
@ -241,13 +248,15 @@ static void processFKeyFunction(const key_code_t Key)
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
break;
case KEY_8:
case KEY_8: // R
g_tx_vfo->frequency_reverse = g_tx_vfo->frequency_reverse == false;
g_request_save_channel = 1;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
break;
case KEY_9:
case KEY_9: // CALL
if (RADIO_CheckValidChannel(g_eeprom.chan_1_call, false, 0))
{
g_eeprom.user_channel[Vfo] = g_eeprom.chan_1_call;
@ -268,6 +277,7 @@ static void processFKeyFunction(const key_code_t Key)
default:
g_update_status = true;
g_fkey_pressed = false;
g_fkey_pressed = false;
#ifdef ENABLE_FMRADIO
if (!g_fm_radio_mode)
@ -382,10 +392,10 @@ static void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
Frequency = FREQ_BAND_TABLE[0].lower;
}
else
if (Frequency >= BX4819_band1.upper && Frequency < BX4819_band2.lower)
if (Frequency >= BX4819_BAND1.upper && Frequency < BX4819_BAND2.lower)
{
const uint32_t center = (BX4819_band1.upper + BX4819_band2.lower) / 2;
Frequency = (Frequency < center) ? BX4819_band1.upper : BX4819_band2.lower;
const uint32_t center = (BX4819_BAND1.upper + BX4819_BAND2.lower) / 2;
Frequency = (Frequency < center) ? BX4819_BAND1.upper : BX4819_BAND2.lower;
}
else
if (Frequency > FREQ_BAND_TABLE[ARRAY_SIZE(FREQ_BAND_TABLE) - 1].upper)
@ -394,7 +404,7 @@ static void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
}
{
const FREQUENCY_Band_t band = FREQUENCY_GetBand(Frequency);
const frequency_band_t band = FREQUENCY_GetBand(Frequency);
#ifdef ENABLE_VOICE
g_another_voice_id = (voice_id_t)Key;
@ -416,10 +426,10 @@ static void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
Frequency = FREQUENCY_FloorToStep(Frequency, g_tx_vfo->step_freq, FREQ_BAND_TABLE[g_tx_vfo->band].lower);
if (Frequency >= BX4819_band1.upper && Frequency < BX4819_band2.lower)
if (Frequency >= BX4819_BAND1.upper && Frequency < BX4819_BAND2.lower)
{ // clamp the frequency to the limit
const uint32_t center = (BX4819_band1.upper + BX4819_band2.lower) / 2;
Frequency = (Frequency < center) ? BX4819_band1.upper - g_tx_vfo->step_freq : BX4819_band2.lower;
const uint32_t center = (BX4819_BAND1.upper + BX4819_BAND2.lower) / 2;
Frequency = (Frequency < center) ? BX4819_BAND1.upper - g_tx_vfo->step_freq : BX4819_BAND2.lower;
}
g_tx_vfo->freq_config_rx.frequency = Frequency;
@ -448,7 +458,7 @@ static void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
g_input_box_index = 0;
Channel = (g_input_box[0] * 10) + g_input_box[1];
if (Channel >= 1 && Channel <= ARRAY_SIZE(NoaaFrequencyTable))
if (Channel >= 1 && Channel <= ARRAY_SIZE(NOAA_FREQUENCY_TABLE))
{
Channel += NOAA_CHANNEL_FIRST;
#ifdef ENABLE_VOICE
@ -492,7 +502,7 @@ static void MAIN_Key_EXIT(bool key_pressed, bool key_held)
if (!g_fm_radio_mode)
#endif
{
if (g_scan_state_dir == SCAN_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF)
{
if (g_input_box_index == 0)
return;
@ -507,7 +517,7 @@ static void MAIN_Key_EXIT(bool key_pressed, bool key_held)
}
else
{
SCANNER_Stop();
SCAN_Stop();
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_SCANNING_STOP;
@ -570,7 +580,7 @@ static void MAIN_Key_MENU(const bool key_pressed, const bool key_held)
if (g_eeprom.vfo_open && g_css_scan_mode == CSS_SCAN_MODE_OFF)
{
if (g_scan_state_dir != SCAN_OFF)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF)
{
if (g_current_function != FUNCTION_INCOMING ||
g_rx_reception_mode == RX_MODE_NONE ||
@ -672,9 +682,9 @@ static void MAIN_Key_STAR(bool key_pressed, bool key_held)
{ // pressed without the F-key
#ifdef ENABLE_NOAA
if (g_scan_state_dir == SCAN_OFF && IS_NOT_NOAA_CHANNEL(g_tx_vfo->channel_save))
if (g_scan_state_dir == SCAN_STATE_DIR_OFF && IS_NOT_NOAA_CHANNEL(g_tx_vfo->channel_save))
#else
if (g_scan_state_dir == SCAN_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF)
#endif
{ // start entering a DTMF string
@ -703,8 +713,8 @@ static void MAIN_Key_STAR(bool key_pressed, bool key_held)
#endif
// scan the CTCSS/DCS code
g_flag_start_scan = true;
g_scan_single_frequency = true;
g_search_flag_start_scan = true;
g_search_single_frequency = true;
g_backup_cross_vfo_rx_tx = g_eeprom.cross_vfo_rx_tx;
g_eeprom.cross_vfo_rx_tx = CROSS_BAND_OFF;
}
@ -751,7 +761,7 @@ static void MAIN_Key_UP_DOWN(bool key_pressed, bool key_held, scan_state_dir_t D
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
}
if (g_scan_state_dir == SCAN_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF)
{
#ifdef ENABLE_NOAA
if (IS_NOT_NOAA_CHANNEL(Channel))
@ -810,7 +820,7 @@ static void MAIN_Key_UP_DOWN(bool key_pressed, bool key_held, scan_state_dir_t D
// jump to the next channel
CHANNEL_Next(false, Direction);
g_scan_pause_delay_in_10ms = 1;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
// g_ptt_was_released = true; // why is this being set ?
}

2
app/menu.c
View File

@ -88,7 +88,7 @@ void MENU_StartCssScan(int8_t Direction)
MENU_SelectNextCode();
g_scan_pause_delay_in_10ms = scan_pause_delay_in_2_10ms;
g_schedule_scan_listen = false;
g_scan_schedule_scan_listen = false;
}
void MENU_StopCssScan(void)

325
app/scanner.c
View File

@ -18,6 +18,7 @@
#include "app/generic.h"
#include "app/scanner.h"
#include "audio.h"
#include "board.h"
#include "driver/bk4819.h"
#include "driver/uart.h"
#include "frequencies.h"
@ -27,30 +28,33 @@
#include "ui/inputbox.h"
#include "ui/ui.h"
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 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;
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;
search_css_state_t g_search_css_state;
bool g_search_use_css_result;
dcs_code_type_t g_search_css_result_type;
uint8_t g_search_css_result_code;
static void SCANNER_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
bool g_search_flag_start_scan;
bool g_search_flag_stop_scan;
uint8_t g_search_show_chan_prefix;
bool g_search_single_frequency;
uint16_t g_search_freq_css_timer_10ms;
uint8_t g_search_delay_10ms;
uint8_t g_search_hit_count;
search_edit_state_t g_search_edit_state;
uint8_t g_search_channel;
uint32_t g_search_frequency;
step_setting_t g_search_step_setting;
static void SEARCH_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
{
if (key_held || key_pressed)
return;
if (g_scanner_edit_state == SCAN_EDIT_STATE_SAVE_CHAN)
if (g_search_edit_state == SEARCH_EDIT_STATE_SAVE_CHAN)
{
uint16_t Channel;
@ -58,7 +62,7 @@ static void SCANNER_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
INPUTBOX_Append(Key);
g_request_display_screen = DISPLAY_SCANNER;
g_request_display_screen = DISPLAY_SEARCH;
if (g_input_box_index < 3)
{
@ -76,8 +80,8 @@ static void SCANNER_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
#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;
g_search_show_chan_prefix = RADIO_CheckValidChannel(Channel, false, 0);
g_search_channel = (uint8_t)Channel;
return;
}
}
@ -85,21 +89,24 @@ static void SCANNER_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
}
static void SCANNER_Key_EXIT(bool key_pressed, bool key_held)
static void SEARCH_Key_EXIT(bool key_pressed, bool key_held)
{
if (key_held || key_pressed)
return;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
switch (g_scanner_edit_state)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough="
switch (g_search_edit_state)
{
case SCAN_EDIT_STATE_NONE:
case SEARCH_EDIT_STATE_NONE:
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;
g_search_flag_stop_scan = true;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_CANCEL;
@ -109,20 +116,18 @@ static void SCANNER_Key_EXIT(bool key_pressed, bool key_held)
g_update_display = true;
break;
case SCAN_EDIT_STATE_SAVE_CHAN:
case SEARCH_EDIT_STATE_SAVE_CHAN:
if (g_input_box_index > 0)
{
g_input_box[--g_input_box_index] = 10;
g_request_display_screen = DISPLAY_SCANNER;
g_request_display_screen = DISPLAY_SEARCH;
g_update_display = true;
break;
}
// Fallthrough
case SCAN_EDIT_STATE_SAVE_CONFIRM:
g_scanner_edit_state = SCAN_EDIT_STATE_NONE;
case SEARCH_EDIT_STATE_SAVE_CONFIRM:
g_search_edit_state = SEARCH_EDIT_STATE_NONE;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_CANCEL;
@ -132,31 +137,33 @@ static void SCANNER_Key_EXIT(bool key_pressed, bool key_held)
g_update_display = true;
break;
}
#pragma GCC diagnostic pop
}
static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
static void SEARCH_Key_MENU(bool key_pressed, bool key_held)
{
uint8_t Channel;
if (key_held || key_pressed)
return;
if (g_scan_css_state == SCAN_CSS_STATE_OFF && !g_scan_single_frequency)
if (g_search_css_state == SEARCH_CSS_STATE_OFF && !g_search_single_frequency)
{
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return;
}
if (g_scan_css_state == SCAN_CSS_STATE_SCANNING)
if (g_search_css_state == SEARCH_CSS_STATE_SCANNING)
{
if (g_scan_single_frequency)
if (g_search_single_frequency)
{
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return;
}
}
if (g_scan_css_state == SCAN_CSS_STATE_FAILED && g_scan_single_frequency)
if (g_search_css_state == SEARCH_CSS_STATE_FAILED && g_search_single_frequency)
{
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return;
@ -167,17 +174,18 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough="
switch (g_scanner_edit_state)
switch (g_search_edit_state)
{
case SCAN_EDIT_STATE_NONE:
if (!g_scan_single_frequency)
case SEARCH_EDIT_STATE_NONE:
if (!g_search_single_frequency)
{
#if 0
uint32_t Freq250 = FREQUENCY_FloorToStep(g_scan_frequency, 250, 0);
uint32_t Freq625 = FREQUENCY_FloorToStep(g_scan_frequency, 625, 0);
uint32_t Freq250 = FREQUENCY_FloorToStep(g_search_frequency, 250, 0);
uint32_t Freq625 = FREQUENCY_FloorToStep(g_search_frequency, 625, 0);
int16_t Delta250 = (int16_t)g_scan_frequency - (int16_t)Freq250;
int16_t Delta250 = (int16_t)g_search_frequency - (int16_t)Freq250;
int16_t Delta625;
if (125 < Delta250)
@ -186,7 +194,7 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
Freq250 += 250;
}
Delta625 = (int16_t)g_scan_frequency - (int16_t)Freq625;
Delta625 = (int16_t)g_search_frequency - (int16_t)Freq625;
if (312 < Delta625)
{
@ -196,16 +204,16 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (Delta625 < Delta250)
{
g_step_setting = STEP_6_25kHz;
g_scan_frequency = Freq625;
g_search_step_setting = STEP_6_25kHz;
g_search_frequency = Freq625;
}
else
{
g_step_setting = STEP_2_5kHz;
g_scan_frequency = Freq250;
g_search_step_setting = STEP_2_5kHz;
g_search_frequency = Freq250;
}
#elif 1
#elif 0
#ifdef ENABLE_1250HZ_STEP
const step_setting_t small_step = STEP_1_25kHz;
@ -218,11 +226,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(g_scan_frequency, small_step_freq, 0);
uint32_t freq_big_step = FREQUENCY_FloorToStep(g_scan_frequency, big_step_freq, 0);
uint32_t freq_small_step = FREQUENCY_FloorToStep(g_search_frequency, small_step_freq, 0);
uint32_t freq_big_step = FREQUENCY_FloorToStep(g_search_frequency, big_step_freq, 0);
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;
int32_t delta_small_step = (int32_t)g_search_frequency - freq_small_step;
int32_t delta_big_step = (int32_t)g_search_frequency - freq_big_step;
if (delta_small_step > 125)
{
@ -230,7 +238,7 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
freq_big_step += small_step_freq;
}
delta_big_step = (int32_t)g_scan_frequency - freq_big_step;
delta_big_step = (int32_t)g_search_frequency - freq_big_step;
if (delta_big_step > 312)
{
@ -240,13 +248,24 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (delta_small_step >= delta_big_step)
{
g_step_setting = small_step;
g_scan_frequency = freq_small_step;
g_search_step_setting = small_step;
g_search_frequency = freq_small_step;
}
else
{
g_step_setting = big_step;
g_scan_frequency = freq_big_step;
g_search_step_setting = big_step;
g_search_frequency = freq_big_step;
}
#else
// determine what the current step size is for the detected frequency
// use the 7 VFO channels/bands to determine it
const unsigned int band = (unsigned int)FREQUENCY_GetBand(g_search_frequency);
g_search_step_setting = BOARD_fetchFrequencyStepSetting(band, g_eeprom.tx_vfo);
{ // round to nearest step size
const uint16_t step_size = STEP_FREQ_TABLE[g_search_step_setting];
g_search_frequency = ((g_search_frequency + (step_size / 2)) / step_size) * step_size;
}
#endif
@ -254,30 +273,30 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (g_tx_vfo->channel_save <= USER_CHANNEL_LAST)
{ // save to channel
g_scan_channel = g_tx_vfo->channel_save;
g_show_chan_prefix = RADIO_CheckValidChannel(g_tx_vfo->channel_save, false, 0);
g_scanner_edit_state = SCAN_EDIT_STATE_SAVE_CHAN;
g_search_channel = g_tx_vfo->channel_save;
g_search_show_chan_prefix = RADIO_CheckValidChannel(g_tx_vfo->channel_save, false, 0);
g_search_edit_state = SEARCH_EDIT_STATE_SAVE_CHAN;
}
else
{ // save to VFO
g_scanner_edit_state = SCAN_EDIT_STATE_SAVE_CONFIRM;
g_search_edit_state = SEARCH_EDIT_STATE_SAVE_CONFIRM;
}
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
//UART_SendText("edit none\r\n");
#endif
g_scan_css_state = SCAN_CSS_STATE_FOUND;
g_search_css_state = SEARCH_CSS_STATE_FOUND;
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_MEMORY_CHANNEL;
#endif
g_request_display_screen = DISPLAY_SCANNER;
g_request_display_screen = DISPLAY_SEARCH;
g_update_status = true;
break;
case SCAN_EDIT_STATE_SAVE_CHAN:
case SEARCH_EDIT_STATE_SAVE_CHAN:
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
UART_SendText("edit save chan\r\n");
#endif
@ -287,52 +306,52 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
if (g_input_box_index == 0)
{
g_scanner_edit_state = SCAN_EDIT_STATE_SAVE_CONFIRM;
g_search_edit_state = SEARCH_EDIT_STATE_SAVE_CONFIRM;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_request_display_screen = DISPLAY_SCANNER;
g_request_display_screen = DISPLAY_SEARCH;
}
// break;
case SCAN_EDIT_STATE_SAVE_CONFIRM:
case SEARCH_EDIT_STATE_SAVE_CONFIRM:
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
UART_SendText("edit save confirm\r\n");
#endif
if (!g_scan_single_frequency)
{
RADIO_InitInfo(g_tx_vfo, g_tx_vfo->channel_save, g_scan_frequency);
if (!g_search_single_frequency)
{ // save to VFO
RADIO_InitInfo(g_tx_vfo, g_tx_vfo->channel_save, g_search_frequency);
if (g_scan_use_css_result)
if (g_search_use_css_result)
{
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_rx.code_type = g_search_css_result_type;
g_tx_vfo->freq_config_rx.code = g_search_css_result_code;
}
g_tx_vfo->freq_config_tx = g_tx_vfo->freq_config_rx;
g_tx_vfo->step_setting = g_step_setting;
g_tx_vfo->step_setting = g_search_step_setting;
}
else
{
RADIO_ConfigureChannel(0, VFO_CONFIGURE_RELOAD);
RADIO_ConfigureChannel(1, VFO_CONFIGURE_RELOAD);
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_rx.code_type = g_search_css_result_type;
g_tx_vfo->freq_config_rx.code = g_search_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;
g_tx_vfo->freq_config_tx.code_type = g_search_css_result_type;
g_tx_vfo->freq_config_tx.code = g_search_css_result_code;
}
if (g_tx_vfo->channel_save <= USER_CHANNEL_LAST)
{
Channel = g_scan_channel;
Channel = g_search_channel;
g_eeprom.user_channel[g_eeprom.tx_vfo] = Channel;
}
else
{
Channel = g_tx_vfo->band + FREQ_CHANNEL_FIRST;
Channel = FREQ_CHANNEL_FIRST + g_tx_vfo->band;
g_eeprom.freq_channel[g_eeprom.tx_vfo] = Channel;
}
@ -344,16 +363,16 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
g_another_voice_id = VOICE_ID_CONFIRM;
#endif
if (!g_scan_single_frequency)
if (!g_search_single_frequency)
{ // FREQ/CTCSS/CDCSS search mode .. do another search
g_scan_css_state = SCAN_CSS_STATE_REPEAT;
g_scanner_edit_state = SCAN_EDIT_STATE_NONE;
g_request_display_screen = DISPLAY_SCANNER;
g_search_css_state = SEARCH_CSS_STATE_REPEAT;
g_search_edit_state = SEARCH_EDIT_STATE_NONE;
g_request_display_screen = DISPLAY_SEARCH;
}
else
{ // CTCSS/CDCSS search mode .. only do a single search
g_scan_css_state = SCAN_CSS_STATE_OFF;
g_scanner_edit_state = SCAN_EDIT_STATE_NONE;
g_search_css_state = SEARCH_CSS_STATE_OFF;
g_search_edit_state = SEARCH_EDIT_STATE_NONE;
g_request_display_screen = DISPLAY_MAIN;
}
@ -369,16 +388,16 @@ static void SCANNER_Key_MENU(bool key_pressed, bool key_held)
#pragma GCC diagnostic pop
}
static void SCANNER_Key_STAR(bool key_pressed, bool key_held)
static void SEARCH_Key_STAR(bool key_pressed, bool key_held)
{
if (key_held || key_pressed)
return;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_flag_start_scan = true;
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
g_search_flag_start_scan = true;
}
static void SCANNER_Key_UP_DOWN(bool key_pressed, bool pKeyHeld, int8_t Direction)
static void SEARCH_Key_UP_DOWN(bool key_pressed, bool pKeyHeld, int8_t Direction)
{
if (pKeyHeld)
{
@ -394,17 +413,17 @@ static void SCANNER_Key_UP_DOWN(bool key_pressed, bool pKeyHeld, int8_t Directio
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
}
if (g_scanner_edit_state == SCAN_EDIT_STATE_SAVE_CHAN)
if (g_search_edit_state == SEARCH_EDIT_STATE_SAVE_CHAN)
{
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;
g_search_channel = NUMBER_AddWithWraparound(g_search_channel, Direction, 0, USER_CHANNEL_LAST);
g_search_show_chan_prefix = RADIO_CheckValidChannel(g_search_channel, false, 0);
g_request_display_screen = DISPLAY_SEARCH;
}
else
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
}
void SCANNER_ProcessKeys(key_code_t Key, bool key_pressed, bool key_held)
void SEARCH_ProcessKeys(key_code_t Key, bool key_pressed, bool key_held)
{
switch (Key)
{
@ -418,22 +437,22 @@ void SCANNER_ProcessKeys(key_code_t Key, bool key_pressed, bool key_held)
case KEY_7:
case KEY_8:
case KEY_9:
SCANNER_Key_DIGITS(Key, key_pressed, key_held);
SEARCH_Key_DIGITS(Key, key_pressed, key_held);
break;
case KEY_MENU:
SCANNER_Key_MENU(key_pressed, key_held);
SEARCH_Key_MENU(key_pressed, key_held);
break;
case KEY_UP:
SCANNER_Key_UP_DOWN(key_pressed, key_held, 1);
SEARCH_Key_UP_DOWN(key_pressed, key_held, 1);
break;
case KEY_DOWN:
SCANNER_Key_UP_DOWN(key_pressed, key_held, -1);
SEARCH_Key_UP_DOWN(key_pressed, key_held, -1);
break;
case KEY_EXIT:
SCANNER_Key_EXIT(key_pressed, key_held);
SEARCH_Key_EXIT(key_pressed, key_held);
break;
case KEY_STAR:
SCANNER_Key_STAR(key_pressed, key_held);
SEARCH_Key_STAR(key_pressed, key_held);
break;
case KEY_PTT:
GENERIC_Key_PTT(key_pressed);
@ -445,7 +464,7 @@ void SCANNER_ProcessKeys(key_code_t Key, bool key_pressed, bool key_held)
}
}
void SCANNER_Start(void)
void SEARCH_Start(void)
{
uint8_t BackupStep;
uint16_t BackupStepFreq;
@ -462,7 +481,7 @@ void SCANNER_Start(void)
BackupStep = g_rx_vfo->step_setting;
BackupStepFreq = g_rx_vfo->step_freq;
RADIO_InitInfo(g_rx_vfo, g_rx_vfo->channel_save, g_rx_vfo->pRX->frequency);
RADIO_InitInfo(g_rx_vfo, g_rx_vfo->channel_save, g_rx_vfo->p_rx->frequency);
g_rx_vfo->step_setting = BackupStep;
g_rx_vfo->step_freq = BackupStepFreq;
@ -473,19 +492,19 @@ void SCANNER_Start(void)
g_is_noaa_mode = false;
#endif
if (g_scan_single_frequency)
if (g_search_single_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;
g_search_css_state = SEARCH_CSS_STATE_SCANNING;
g_search_frequency = g_rx_vfo->p_rx->frequency;
g_search_step_setting = g_rx_vfo->step_setting;
BK4819_PickRXFilterPathBasedOnFrequency(g_scan_frequency);
BK4819_SetScanFrequency(g_scan_frequency);
BK4819_PickRXFilterPathBasedOnFrequency(g_search_frequency);
BK4819_SetScanFrequency(g_search_frequency);
}
else
{
g_scan_css_state = SCAN_CSS_STATE_OFF;
g_scan_frequency = 0xFFFFFFFF;
g_search_css_state = SEARCH_CSS_STATE_OFF;
g_search_frequency = 0xFFFFFFFF;
BK4819_PickRXFilterPathBasedOnFrequency(0xFFFFFFFF);
BK4819_EnableFrequencyScan();
@ -493,67 +512,25 @@ void SCANNER_Start(void)
DTMF_clear_RX();
g_scan_delay_10ms = scan_freq_css_delay_10ms;
g_scan_css_result_type = CODE_TYPE_NONE;
g_scan_css_result_code = 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;
#ifdef ENABLE_VOX
g_vox_lost = false;
#endif
g_update_status = true;
}
void SCANNER_Stop(void)
{
const uint8_t Previous = g_restore_channel;
if (g_scan_state_dir == SCAN_OFF)
return; // but, but, we weren't doing anything !
g_scan_state_dir = SCAN_OFF;
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.screen_channel[g_eeprom.rx_vfo] = Previous;
RADIO_ConfigureChannel(g_eeprom.rx_vfo, VFO_CONFIGURE_RELOAD);
}
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;
}
if (g_rx_vfo->channel_save > USER_CHANNEL_LAST)
{
RADIO_ApplyOffset(g_rx_vfo);
RADIO_ConfigureSquelchAndOutputPower(g_rx_vfo);
SETTINGS_SaveChannel(g_rx_vfo->channel_save, g_eeprom.rx_vfo, g_rx_vfo, 1);
return;
}
SETTINGS_SaveVfoIndices();
g_update_status = true;
g_cxcss_tail_found = false;
g_cdcss_lost = false;
g_cdcss_code_type = 0;
g_ctcss_lost = false;
g_squelch_lost = false;
g_search_delay_10ms = scan_freq_css_delay_10ms;
g_search_css_result_type = CODE_TYPE_NONE;
g_search_css_result_code = 0xff;
g_search_hit_count = 0;
g_search_use_css_result = false;
g_search_edit_state = SEARCH_EDIT_STATE_NONE;
g_search_freq_css_timer_10ms = 0;
// g_search_flag_start_scan = false;
g_request_display_screen = DISPLAY_SEARCH;
g_update_status = true;
}

75
app/scanner.h
View File

@ -14,58 +14,49 @@
* limitations under the License.
*/
#ifndef APP_SCANNER_H
#define APP_SCANNER_H
#ifndef APP_SEARCH_H
#define APP_SEARCH_H
#include "dcs.h"
#include "driver/keyboard.h"
#include "frequencies.h"
enum scan_css_state_e
enum search_css_state_e
{
SCAN_CSS_STATE_OFF = 0,
SCAN_CSS_STATE_SCANNING,
SCAN_CSS_STATE_FOUND,
SCAN_CSS_STATE_FAILED,
SCAN_CSS_STATE_FREQ_FAILED,
SCAN_CSS_STATE_REPEAT
SEARCH_CSS_STATE_OFF = 0,
SEARCH_CSS_STATE_SCANNING,
SEARCH_CSS_STATE_FOUND,
SEARCH_CSS_STATE_FAILED,
SEARCH_CSS_STATE_FREQ_FAILED,
SEARCH_CSS_STATE_REPEAT
};
typedef enum scan_css_state_e scan_css_state_t;
typedef enum search_css_state_e search_css_state_t;
enum scan_state_dir_e {
SCAN_REV = -1,
SCAN_OFF = 0,
SCAN_FWD = +1
enum search_edit_state_e {
SEARCH_EDIT_STATE_NONE = 0,
SEARCH_EDIT_STATE_SAVE_CHAN,
SEARCH_EDIT_STATE_SAVE_CONFIRM
};
typedef enum scan_state_dir_e scan_state_dir_t;
typedef enum search_edit_state_e search_edit_state_t;
enum scan_edit_state_e {
SCAN_EDIT_STATE_NONE = 0,
SCAN_EDIT_STATE_SAVE_CHAN,
SCAN_EDIT_STATE_SAVE_CONFIRM
};
typedef enum scan_edit_state_e scan_edit_state_t;
extern search_css_state_t g_search_css_state;
extern dcs_code_type_t g_search_css_result_type;
extern uint8_t g_search_css_result_code;
extern bool g_search_flag_start_scan;
extern bool g_search_flag_stop_scan;
extern uint8_t g_search_show_chan_prefix;
extern bool g_search_single_frequency;
extern search_edit_state_t g_search_edit_state;
extern uint8_t g_search_channel;
extern uint32_t g_search_frequency;
extern step_setting_t g_search_step_setting;
extern uint16_t g_search_freq_css_timer_10ms;
extern uint8_t g_search_delay_10ms;
extern uint8_t g_search_hit_count;
extern bool g_search_use_css_result;
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 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 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);
void SCANNER_Stop(void);
void SEARCH_ProcessKeys(key_code_t Key, bool key_pressed, bool key_held);
void SEARCH_Start(void);
#endif

4
app/spectrum.c
View File

@ -416,7 +416,7 @@ static void ToggleTX(bool on) {
RegBackupSet(BK4819_REG_51, 0x0000);
BK4819_SetupPowerAmplifier(gCurrentVfo->TXP_CalculatedSetting,
gCurrentVfo->pTX->Frequency);
gCurrentVfo->p_tx->Frequency);
} else {
RADIO_SendEndOfTransmission();
RADIO_EnableCxCSS();
@ -1328,7 +1328,7 @@ void APP_RunSpectrum() {
BackupRegisters();
// TX here coz it always? set to active VFO
VFO_Info_t vfo = g_eeprom.vfo_info[g_eeprom.TX_CHANNEL];
initialFreq = vfo.pRX->Frequency;
initialFreq = vfo.p_rx->Frequency;
currentFreq = initialFreq;
settings.scanStepIndex = gStepSettingToIndex[vfo.STEP_SETTING];
settings.listenBw = vfo.CHANNEL_BANDWIDTH == BANDWIDTH_WIDE

4
app/uart.c
View File

@ -452,8 +452,8 @@ static void cmd_052F(const uint8_t *pBuffer)
g_eeprom.rx_vfo = 0;
g_eeprom.dtmf_side_tone = false;
g_eeprom.vfo_info[0].frequency_reverse = false;
g_eeprom.vfo_info[0].pRX = &g_eeprom.vfo_info[0].freq_config_rx;
g_eeprom.vfo_info[0].pTX = &g_eeprom.vfo_info[0].freq_config_tx;
g_eeprom.vfo_info[0].p_rx = &g_eeprom.vfo_info[0].freq_config_rx;
g_eeprom.vfo_info[0].p_tx = &g_eeprom.vfo_info[0].freq_config_tx;
g_eeprom.vfo_info[0].tx_offset_freq_dir = TX_OFFSET_FREQ_DIR_OFF;
g_eeprom.vfo_info[0].dtmf_ptt_id_tx_mode = PTT_ID_OFF;
g_eeprom.vfo_info[0].dtmf_decoding_enable = false;

49
board.c
View File

@ -840,11 +840,57 @@ uint32_t BOARD_fetchChannelFrequency(const int channel)
uint32_t offset;
} __attribute__((packed)) info;
if (channel < 0 || channel > (int)FREQ_CHANNEL_LAST)
return 0;
if (!RADIO_CheckValidChannel(channel, false, 0))
return 0;
EEPROM_ReadBuffer(channel * 16, &info, sizeof(info));
return info.frequency;
}
unsigned int BOARD_fetchChannelStepSetting(const int channel)
{
uint8_t data[8];
unsigned int step_setting = 0;
if (channel < 0)
return 0;
if (channel <= USER_CHANNEL_LAST)
{
EEPROM_ReadBuffer(channel * 16, &data, sizeof(data));
}
else
if (channel <= FREQ_CHANNEL_LAST)
{
EEPROM_ReadBuffer(channel * 16, &data, sizeof(data));
}
step_setting = (data[6] >= ARRAY_SIZE(STEP_FREQ_TABLE)) ? STEP_12_5kHz : data[6];
// step_size = STEP_FREQ_TABLE[step_setting];
return step_setting;
}
unsigned int BOARD_fetchFrequencyStepSetting(const int channel, const int vfo)
{
uint8_t data[8];
unsigned int step_setting = 0;
if (channel < 0 || channel > (FREQ_CHANNEL_LAST - FREQ_CHANNEL_FIRST) || vfo < 0 || vfo >= 2)
return 0;
EEPROM_ReadBuffer(FREQ_CHANNEL_FIRST + (channel * 16 * 2) + vfo, &data, sizeof(data));
step_setting = (data[6] >= ARRAY_SIZE(STEP_FREQ_TABLE)) ? STEP_12_5kHz : data[6];
// step_size = STEP_FREQ_TABLE[step_setting];
return step_setting;
}
void BOARD_fetchChannelName(char *s, const int channel)
{
int i;
@ -854,13 +900,12 @@ void BOARD_fetchChannelName(char *s, const int channel)
memset(s, 0, 11); // 's' had better be large enough !
if (channel < 0)
if (channel < 0 || channel > (int)USER_CHANNEL_LAST)
return;
if (!RADIO_CheckValidChannel(channel, false, 0))
return;
EEPROM_ReadBuffer(0x0F50 + (channel * 16), s + 0, 8);
EEPROM_ReadBuffer(0x0F58 + (channel * 16), s + 8, 2);

24
board.h
View File

@ -19,17 +19,19 @@
#include <stdint.h>
void BOARD_FLASH_Init(void);
void BOARD_GPIO_Init(void);
void BOARD_PORTCON_Init(void);
void BOARD_ADC_Init(void);
void BOARD_ADC_GetBatteryInfo(uint16_t *pVoltage, uint16_t *pCurrent);
void BOARD_Init(void);
void BOARD_EEPROM_load(void);
void BOARD_EEPROM_LoadMoreSettings(void);
uint32_t BOARD_fetchChannelFrequency(const int channel);
void BOARD_fetchChannelName(char *s, const int channel);
void BOARD_FactoryReset(bool bIsAll);
void BOARD_FLASH_Init(void);
void BOARD_GPIO_Init(void);
void BOARD_PORTCON_Init(void);
void BOARD_ADC_Init(void);
void BOARD_ADC_GetBatteryInfo(uint16_t *pVoltage, uint16_t *pCurrent);
void BOARD_Init(void);
void BOARD_EEPROM_load(void);
void BOARD_EEPROM_LoadMoreSettings(void);
uint32_t BOARD_fetchChannelFrequency(const int channel);
unsigned int BOARD_fetchChannelStepSetting(const int channel);
void BOARD_fetchChannelName(char *s, const int channel);
unsigned int BOARD_fetchFrequencyStepSetting(const int channel, const int vfo);
void BOARD_FactoryReset(bool bIsAll);
#endif

BIN
firmware.bin
View File

Binary file not shown.

BIN
firmware.packed.bin
View File

Binary file not shown.

16
frequencies.c
View File

@ -18,12 +18,12 @@
#include "misc.h"
#include "settings.h"
// the initial AIRCOPY frequency to use
// the default AIRCOPY frequency to use
uint32_t g_aircopy_freq = 41002500;
// the BK4819 has 2 bands it covers, 18MHz ~ 630MHz and 760MHz ~ 1300MHz
const freq_band_table_t BX4819_band1 = { 1800000, 63000000};
const freq_band_table_t BX4819_band2 = {84000000, 130000000};
const freq_band_table_t BX4819_BAND1 = { 1800000, 63000000};
const freq_band_table_t BX4819_BAND2 = {84000000, 130000000};
const freq_band_table_t FREQ_BAND_TABLE[7] =
{
@ -49,7 +49,7 @@ const freq_band_table_t FREQ_BAND_TABLE[7] =
};
#ifdef ENABLE_NOAA
const uint32_t NoaaFrequencyTable[10] =
const uint32_t NOAA_FREQUENCY_TABLE[10] =
{
16255000,
16240000,
@ -72,13 +72,13 @@ const freq_band_table_t FREQ_BAND_TABLE[7] =
const uint16_t STEP_FREQ_TABLE[7] = {250, 500, 625, 1000, 1250, 2500, 833};
#endif
FREQUENCY_Band_t FREQUENCY_GetBand(uint32_t Frequency)
frequency_band_t FREQUENCY_GetBand(uint32_t Frequency)
{
int band;
for (band = ARRAY_SIZE(FREQ_BAND_TABLE) - 1; band >= 0; band--)
if (Frequency >= FREQ_BAND_TABLE[band].lower)
// if (Frequency < FREQ_BAND_TABLE[band].upper)
return (FREQUENCY_Band_t)band;
return (frequency_band_t)band;
return BAND1_50MHz;
// return BAND_NONE;
@ -134,7 +134,7 @@ int TX_freq_check(const uint32_t Frequency)
if (Frequency < FREQ_BAND_TABLE[0].lower || Frequency > FREQ_BAND_TABLE[ARRAY_SIZE(FREQ_BAND_TABLE) - 1].upper)
return -1; // not allowed outside this range
if (Frequency >= BX4819_band1.upper && Frequency < BX4819_band2.lower)
if (Frequency >= BX4819_BAND1.upper && Frequency < BX4819_BAND2.lower)
return -1; // BX chip does not work in this range
switch (g_setting_freq_lock)
@ -202,7 +202,7 @@ int RX_freq_check(const uint32_t Frequency)
if (Frequency < FREQ_BAND_TABLE[0].lower || Frequency > FREQ_BAND_TABLE[ARRAY_SIZE(FREQ_BAND_TABLE) - 1].upper)
return -1;
if (Frequency >= BX4819_band1.upper && Frequency < BX4819_band2.lower)
if (Frequency >= BX4819_BAND1.upper && Frequency < BX4819_BAND2.lower)
return -1;
return 0; // OK frequency

40
frequencies.h
View File

@ -21,19 +21,7 @@
#include "frequencies.h"
typedef struct {
const uint32_t lower;
const uint32_t upper;
} freq_band_table_t;
extern uint32_t g_aircopy_freq;
extern const freq_band_table_t BX4819_band1;
extern const freq_band_table_t BX4819_band2;
extern const freq_band_table_t FREQ_BAND_TABLE[7];
enum FREQUENCY_Band_t {
enum frequency_band_e {
BAND_NONE = -1,
BAND1_50MHz = 0,
BAND2_108MHz,
@ -43,11 +31,23 @@ enum FREQUENCY_Band_t {
BAND6_400MHz,
BAND7_470MHz
};
typedef enum FREQUENCY_Band_t FREQUENCY_Band_t;
typedef enum frequency_band_e frequency_band_t;
typedef struct {
const uint32_t lower;
const uint32_t upper;
} freq_band_table_t;
extern uint32_t g_aircopy_freq;
extern const freq_band_table_t BX4819_BAND1;
extern const freq_band_table_t BX4819_BAND2;
extern const freq_band_table_t FREQ_BAND_TABLE[7];
#ifdef ENABLE_1250HZ_STEP
// includes 1.25kHz step
enum step_setting_t {
enum step_setting_e {
STEP_1_25kHz = 0,
STEP_2_5kHz,
STEP_6_25kHz,
@ -58,7 +58,7 @@ typedef enum FREQUENCY_Band_t FREQUENCY_Band_t;
};
#else
// QS steps
enum step_setting_t {
enum step_setting_e {
STEP_2_5kHz = 0,
STEP_5_0kHz,
STEP_6_25kHz,
@ -68,15 +68,15 @@ typedef enum FREQUENCY_Band_t FREQUENCY_Band_t;
STEP_8_33kHz
};
#endif
typedef enum step_setting_t step_setting_t;
typedef enum step_setting_e step_setting_t;
extern const uint16_t STEP_FREQ_TABLE[7];
extern const uint16_t STEP_FREQ_TABLE[7];
#ifdef ENABLE_NOAA
extern const uint32_t NoaaFrequencyTable[10];
extern const uint32_t NOAA_FREQUENCY_TABLE[10];
#endif
FREQUENCY_Band_t FREQUENCY_GetBand(uint32_t Frequency);
frequency_band_t FREQUENCY_GetBand(uint32_t Frequency);
uint8_t FREQUENCY_CalculateOutputPower(uint8_t TxpLow, uint8_t TxpMid, uint8_t TxpHigh, int32_t LowerLimit, int32_t Middle, int32_t UpperLimit, int32_t Frequency);
uint32_t FREQUENCY_FloorToStep(uint32_t Upper, uint32_t Step, uint32_t Lower);

8
functions.c
View File

@ -49,7 +49,7 @@ void FUNCTION_Init(void)
{
g_current_code_type = g_selected_code_type;
if (g_css_scan_mode == CSS_SCAN_MODE_OFF)
g_current_code_type = g_rx_vfo->am_mode ? CODE_TYPE_NONE : g_rx_vfo->pRX->code_type;
g_current_code_type = g_rx_vfo->am_mode ? CODE_TYPE_NONE : g_rx_vfo->p_rx->code_type;
}
#ifdef ENABLE_NOAA
else
@ -58,9 +58,9 @@ void FUNCTION_Init(void)
DTMF_clear_RX();
g_CxCSS_tail_found = false;
g_CDCSS_lost = false;
g_CTCSS_lost = false;
g_cxcss_tail_found = false;
g_cdcss_lost = false;
g_ctcss_lost = false;
#ifdef ENABLE_VOX
g_vox_lost = false;

25
misc.c
View File

@ -156,6 +156,11 @@ volatile bool g_tx_timeout_reached;
volatile uint16_t g_tail_tone_elimination_count_down_10ms;
bool g_scan_pause_mode;
volatile bool g_scan_schedule_scan_listen = true;
volatile uint16_t g_scan_pause_delay_in_10ms;
scan_state_dir_t g_scan_state_dir;
#ifdef ENABLE_NOAA
volatile uint16_t g_noaa_count_down_10ms;
#endif
@ -201,10 +206,10 @@ bool g_flag_save_channel;
#ifdef ENABLE_FMRADIO
bool g_flag_SaveFM;
#endif
bool g_CDCSS_lost;
uint8_t g_CDCSS_code_type;
bool g_CTCSS_lost;
bool g_CxCSS_tail_found;
bool g_cdcss_lost;
uint8_t g_cdcss_code_type;
bool g_ctcss_lost;
bool g_cxcss_tail_found;
#ifdef ENABLE_VOX
bool g_vox_lost;
bool g_vox_noise_detected;
@ -216,12 +221,13 @@ uint8_t g_flash_light_state;
volatile uint16_t g_flash_light_blink_counter;
bool g_flag_end_tx;
uint16_t g_low_batteryCountdown;
uint8_t g_next_channel;
reception_mode_t g_rx_reception_mode;
uint8_t g_restore_channel;
scan_next_chan_t g_current_scan_list;
uint32_t g_restore_frequency;
uint8_t g_scan_next_channel;
uint8_t g_scan_restore_channel;
scan_next_chan_t g_scan_current_scan_list;
uint32_t g_scan_restore_frequency;
bool g_scan_keep_frequency;
bool g_rx_vfo_is_active;
#ifdef ENABLE_ALARM
@ -230,7 +236,6 @@ bool g_rx_vfo_is_active;
#endif
uint8_t g_menu_list_count;
uint8_t g_backup_cross_vfo_rx_tx;
uint8_t g_scan_delay_10ms;
#ifdef ENABLE_NOAA
bool g_is_noaa_mode;
@ -241,8 +246,6 @@ bool g_update_display;
bool g_unhide_hidden = false;
uint8_t g_show_chan_prefix;
volatile bool g_next_time_slice;
volatile uint8_t g_found_CDCSS_count_down_10ms;
volatile uint8_t g_found_CTCSS_count_down_10ms;

31
misc.h
View File

@ -101,6 +101,13 @@ enum scan_next_chan_e {
};
typedef enum scan_next_chan_e scan_next_chan_t;
enum scan_state_dir_e {
SCAN_STATE_DIR_REVERSE = -1,
SCAN_STATE_DIR_OFF = 0,
SCAN_STATE_DIR_FORWARD = +1
};
typedef enum scan_state_dir_e scan_state_dir_t;
extern const uint8_t obfuscate_array[16];
extern const uint8_t fm_resume_countdown_500ms;
@ -231,6 +238,11 @@ extern volatile bool g_tx_timeout_reached;
extern volatile uint16_t g_tail_tone_elimination_count_down_10ms;
extern bool g_scan_pause_mode;
extern volatile bool g_scan_schedule_scan_listen;
extern volatile uint16_t g_scan_pause_delay_in_10ms;
extern scan_state_dir_t g_scan_state_dir;
#ifdef ENABLE_FMRADIO
extern volatile uint16_t g_fm_play_count_down_10ms;
#endif
@ -276,10 +288,10 @@ extern bool g_flag_save_channel;
#ifdef ENABLE_FMRADIO
extern bool g_flag_SaveFM;
#endif
extern bool g_CDCSS_lost;
extern uint8_t g_CDCSS_code_type;
extern bool g_CTCSS_lost;
extern bool g_CxCSS_tail_found;
extern bool g_cdcss_lost;
extern uint8_t g_cdcss_code_type;
extern bool g_ctcss_lost;
extern bool g_cxcss_tail_found;
#ifdef ENABLE_VOX
extern bool g_vox_lost;
extern bool g_vox_noise_detected;
@ -291,19 +303,19 @@ extern uint8_t g_flash_light_state;
extern volatile uint16_t g_flash_light_blink_counter;
extern bool g_flag_end_tx;
extern uint16_t g_low_batteryCountdown;
extern uint8_t g_next_channel;
extern reception_mode_t g_rx_reception_mode;
extern uint8_t g_restore_channel;
extern scan_next_chan_t g_current_scan_list;
extern uint32_t g_restore_frequency;
extern uint8_t g_scan_next_channel;
extern uint8_t g_scan_restore_channel;
extern scan_next_chan_t g_scan_current_scan_list;
extern uint32_t g_scan_restore_frequency;
extern bool g_scan_keep_frequency;
extern bool g_rx_vfo_is_active;
extern uint8_t g_alarm_tone_counter;
extern uint16_t g_alarm_running_counter;
extern uint8_t g_menu_list_count;
extern uint8_t g_backup_cross_vfo_rx_tx;
extern uint8_t g_scan_delay_10ms;
#ifdef ENABLE_NOAA
extern bool g_is_noaa_mode;
extern uint8_t g_noaa_channel;
@ -314,7 +326,6 @@ extern bool g_unhide_hidden;
#ifdef ENABLE_FMRADIO
extern uint8_t g_fm_channel_position;
#endif
extern uint8_t g_show_chan_prefix;
extern volatile uint8_t g_found_CDCSS_count_down_10ms;
extern volatile uint8_t g_found_CTCSS_count_down_10ms;
#ifdef ENABLE_VOX

61
radio.c
View File

@ -41,7 +41,6 @@ vfo_info_t *g_current_vfo;
dcs_code_type_t g_selected_code_type;
dcs_code_type_t g_current_code_type;
uint8_t g_selected_code;
step_setting_t g_step_setting;
vfo_state_t g_vfo_state[2];
bool RADIO_CheckValidChannel(uint16_t Channel, bool bCheckScanList, uint8_t VFO)
@ -119,17 +118,17 @@ void RADIO_InitInfo(vfo_info_t *pInfo, const uint8_t ChannelSave, const uint32_t
memset(pInfo, 0, sizeof(*pInfo));
pInfo->band = FREQUENCY_GetBand(Frequency);
pInfo->scanlist_1_participation = true;
pInfo->scanlist_2_participation = true;
pInfo->scanlist_1_participation = true;
pInfo->scanlist_2_participation = true;
pInfo->step_setting = STEP_12_5kHz;
pInfo->step_freq = STEP_FREQ_TABLE[pInfo->step_setting];
pInfo->step_freq = STEP_FREQ_TABLE[pInfo->step_setting];
pInfo->channel_save = ChannelSave;
pInfo->frequency_reverse = false;
pInfo->frequency_reverse = false;
pInfo->output_power = OUTPUT_POWER_LOW;
pInfo->freq_config_rx.frequency = Frequency;
pInfo->freq_config_tx.frequency = Frequency;
pInfo->pRX = &pInfo->freq_config_rx;
pInfo->pTX = &pInfo->freq_config_tx;
pInfo->p_rx = &pInfo->freq_config_rx;
pInfo->p_tx = &pInfo->freq_config_tx;
pInfo->compander = 0; // off
if (ChannelSave == (FREQ_CHANNEL_FIRST + BAND2_108MHz))
@ -164,7 +163,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
#ifdef ENABLE_NOAA
if (Channel >= NOAA_CHANNEL_FIRST)
{
RADIO_InitInfo(pRadio, g_eeprom.screen_channel[VFO], NoaaFrequencyTable[Channel - NOAA_CHANNEL_FIRST]);
RADIO_InitInfo(pRadio, g_eeprom.screen_channel[VFO], NOAA_FREQUENCY_TABLE[Channel - NOAA_CHANNEL_FIRST]);
if (g_eeprom.cross_vfo_rx_tx == CROSS_BAND_OFF)
return;
@ -178,7 +177,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
if (Channel <= USER_CHANNEL_LAST)
{
Channel = RADIO_FindNextChannel(Channel, SCAN_FWD, false, VFO);
Channel = RADIO_FindNextChannel(Channel, SCAN_STATE_DIR_FORWARD, false, VFO);
if (Channel == 0xFF)
{
Channel = g_eeprom.freq_channel[VFO];
@ -394,18 +393,18 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
if (!g_eeprom.vfo_info[VFO].frequency_reverse)
{
g_eeprom.vfo_info[VFO].pRX = &g_eeprom.vfo_info[VFO].freq_config_rx;
g_eeprom.vfo_info[VFO].pTX = &g_eeprom.vfo_info[VFO].freq_config_tx;
g_eeprom.vfo_info[VFO].p_rx = &g_eeprom.vfo_info[VFO].freq_config_rx;
g_eeprom.vfo_info[VFO].p_tx = &g_eeprom.vfo_info[VFO].freq_config_tx;
}
else
{
g_eeprom.vfo_info[VFO].pRX = &g_eeprom.vfo_info[VFO].freq_config_tx;
g_eeprom.vfo_info[VFO].pTX = &g_eeprom.vfo_info[VFO].freq_config_rx;
g_eeprom.vfo_info[VFO].p_rx = &g_eeprom.vfo_info[VFO].freq_config_tx;
g_eeprom.vfo_info[VFO].p_tx = &g_eeprom.vfo_info[VFO].freq_config_rx;
}
if (!g_setting_350_enable)
{
freq_config_t *pConfig = g_eeprom.vfo_info[VFO].pRX;
freq_config_t *pConfig = g_eeprom.vfo_info[VFO].p_rx;
if (pConfig->frequency >= 35000000 && pConfig->frequency < 40000000) // not allowed in this range
pConfig->frequency = 43300000; // hop onto the ham band
}
@ -426,12 +425,12 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
void RADIO_ConfigureSquelchAndOutputPower(vfo_info_t *pInfo)
{
uint8_t TX_power[3];
FREQUENCY_Band_t Band;
frequency_band_t Band;
// *******************************
// squelch
Band = FREQUENCY_GetBand(pInfo->pRX->frequency);
Band = FREQUENCY_GetBand(pInfo->p_rx->frequency);
uint16_t Base = (Band < BAND4_174MHz) ? 0x1E60 : 0x1E00;
if (g_eeprom.squelch_level == 0)
@ -522,7 +521,7 @@ void RADIO_ConfigureSquelchAndOutputPower(vfo_info_t *pInfo)
// 1F20 5A 5A 5A 64 64 64 8F 91 8A FF FF FF FF FF FF FF .. 400 MHz
// 1F30 32 32 32 64 64 64 8C 8C 8C FF FF FF FF FF FF FF .. 470 MHz
Band = FREQUENCY_GetBand(pInfo->pTX->frequency);
Band = FREQUENCY_GetBand(pInfo->p_tx->frequency);
EEPROM_ReadBuffer(0x1ED0 + (Band * 16) + (pInfo->output_power * 3), TX_power, 3);
@ -533,7 +532,7 @@ void RADIO_ConfigureSquelchAndOutputPower(vfo_info_t *pInfo)
FREQ_BAND_TABLE[Band].lower,
(FREQ_BAND_TABLE[Band].lower + FREQ_BAND_TABLE[Band].upper) / 2,
FREQ_BAND_TABLE[Band].upper,
pInfo->pTX->frequency);
pInfo->p_tx->frequency);
// *******************************
}
@ -633,11 +632,11 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
#ifdef ENABLE_NOAA
if (IS_NOT_NOAA_CHANNEL(g_rx_vfo->channel_save) || !g_is_noaa_mode)
Frequency = g_rx_vfo->pRX->frequency;
Frequency = g_rx_vfo->p_rx->frequency;
else
Frequency = NoaaFrequencyTable[g_noaa_channel];
Frequency = NOAA_FREQUENCY_TABLE[g_noaa_channel];
#else
Frequency = g_rx_vfo->pRX->frequency;
Frequency = g_rx_vfo->p_rx->frequency;
#endif
BK4819_SetFrequency(Frequency);
@ -666,8 +665,8 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
uint8_t Code = g_selected_code;
if (g_css_scan_mode == CSS_SCAN_MODE_OFF)
{
code_type = g_rx_vfo->pRX->code_type;
Code = g_rx_vfo->pRX->code;
code_type = g_rx_vfo->p_rx->code_type;
Code = g_rx_vfo->p_rx->code;
}
switch (code_type)
@ -865,7 +864,7 @@ void RADIO_SetTxParameters(void)
#pragma GCC diagnostic pop
BK4819_SetFrequency(g_current_vfo->pTX->frequency);
BK4819_SetFrequency(g_current_vfo->p_tx->frequency);
// TX compressor
BK4819_SetCompander((g_rx_vfo->am_mode == 0 && (g_rx_vfo->compander == 1 || g_rx_vfo->compander >= 3)) ? g_rx_vfo->compander : 0);
@ -874,17 +873,17 @@ void RADIO_SetTxParameters(void)
SYSTEM_DelayMs(10);
BK4819_PickRXFilterPathBasedOnFrequency(g_current_vfo->pTX->frequency);
BK4819_PickRXFilterPathBasedOnFrequency(g_current_vfo->p_tx->frequency);
BK4819_set_GPIO_pin(BK4819_GPIO5_PIN1, true);
SYSTEM_DelayMs(5);
BK4819_SetupPowerAmplifier(g_current_vfo->txp_calculated_setting, g_current_vfo->pTX->frequency);
BK4819_SetupPowerAmplifier(g_current_vfo->txp_calculated_setting, g_current_vfo->p_tx->frequency);
SYSTEM_DelayMs(10);
switch (g_current_vfo->pTX->code_type)
switch (g_current_vfo->p_tx->code_type)
{
default:
case CODE_TYPE_NONE:
@ -892,12 +891,12 @@ void RADIO_SetTxParameters(void)
break;
case CODE_TYPE_CONTINUOUS_TONE:
BK4819_SetCTCSSFrequency(CTCSS_OPTIONS[g_current_vfo->pTX->code]);
BK4819_SetCTCSSFrequency(CTCSS_OPTIONS[g_current_vfo->p_tx->code]);
break;
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
BK4819_SetCDCSSCodeWord(DCS_GetGolayCodeWord(g_current_vfo->pTX->code_type, g_current_vfo->pTX->code));
BK4819_SetCDCSSCodeWord(DCS_GetGolayCodeWord(g_current_vfo->p_tx->code_type, g_current_vfo->p_tx->code));
break;
}
}
@ -981,7 +980,7 @@ void RADIO_PrepareTX(void)
State = VFO_STATE_TX_DISABLE;
}
else
if (TX_freq_check(g_current_vfo->pTX->frequency) == 0)
if (TX_freq_check(g_current_vfo->p_tx->frequency) == 0)
{ // TX frequency is allowed
if (g_current_vfo->busy_channel_lock && g_current_function == FUNCTION_RECEIVE)
State = VFO_STATE_BUSY; // busy RX'ing a station
@ -1052,7 +1051,7 @@ void RADIO_PrepareTX(void)
void RADIO_EnableCxCSS(void)
{
switch (g_current_vfo->pTX->code_type)
switch (g_current_vfo->p_tx->code_type)
{
default:
case CODE_TYPE_NONE:

8
radio.h
View File

@ -20,7 +20,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "app/scanner.h"
#include "misc.h"
#include "dcs.h"
#include "frequencies.h"
@ -74,8 +74,8 @@ typedef struct vfo_info_t
{
freq_config_t freq_config_rx;
freq_config_t freq_config_tx;
freq_config_t *pRX;
freq_config_t *pTX;
freq_config_t *p_rx;
freq_config_t *p_tx;
uint32_t tx_offset_freq;
uint16_t step_freq;
@ -124,8 +124,6 @@ extern dcs_code_type_t g_selected_code_type;
extern dcs_code_type_t g_current_code_type;
extern uint8_t g_selected_code;
extern step_setting_t g_step_setting;
extern vfo_state_t g_vfo_state[2];
bool RADIO_CheckValidChannel(uint16_t ChNum, bool bCheckScanList, uint8_t RadioNum);

8
scheduler.c
View File

@ -78,20 +78,20 @@ void SystickHandler(void)
if (g_current_function == FUNCTION_POWER_SAVE)
DECREMENT_AND_TRIGGER(g_power_save_10ms, g_power_save_expired);
if (g_scan_state_dir == SCAN_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF && g_eeprom.dual_watch != DUAL_WATCH_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF && g_eeprom.dual_watch != DUAL_WATCH_OFF)
if (g_current_function != FUNCTION_MONITOR && g_current_function != FUNCTION_TRANSMIT && g_current_function != FUNCTION_RECEIVE)
DECREMENT_AND_TRIGGER(g_dual_watch_count_down_10ms, g_schedule_dual_watch);
#ifdef ENABLE_NOAA
if (g_scan_state_dir == SCAN_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF && g_eeprom.dual_watch == DUAL_WATCH_OFF)
if (g_scan_state_dir == SCAN_STATE_DIR_OFF && g_css_scan_mode == CSS_SCAN_MODE_OFF && g_eeprom.dual_watch == DUAL_WATCH_OFF)
if (g_is_noaa_mode && g_current_function != FUNCTION_MONITOR && g_current_function != FUNCTION_TRANSMIT)
if (g_current_function != FUNCTION_RECEIVE)
DECREMENT_AND_TRIGGER(g_noaa_count_down_10ms, g_schedule_noaa);
#endif
if (g_scan_state_dir != SCAN_OFF || g_css_scan_mode == CSS_SCAN_MODE_SCANNING)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF || g_css_scan_mode == CSS_SCAN_MODE_SCANNING)
if (g_current_function != FUNCTION_MONITOR && g_current_function != FUNCTION_TRANSMIT)
DECREMENT_AND_TRIGGER(g_scan_pause_delay_in_10ms, g_schedule_scan_listen);
DECREMENT_AND_TRIGGER(g_scan_pause_delay_in_10ms, g_scan_schedule_scan_listen);
DECREMENT_AND_TRIGGER(g_tail_tone_elimination_count_down_10ms, g_flag_tail_tone_elimination_complete);

6
ui/main.c
View File

@ -599,12 +599,12 @@ void UI_DisplayMain(void)
}
else
{
uint32_t frequency = g_eeprom.vfo_info[vfo_num].pRX->frequency;
uint32_t frequency = g_eeprom.vfo_info[vfo_num].p_rx->frequency;
if (g_current_function == FUNCTION_TRANSMIT)
{ // transmitting
channel = (g_eeprom.cross_vfo_rx_tx == CROSS_BAND_OFF) ? g_eeprom.rx_vfo : g_eeprom.tx_vfo;
if (channel == vfo_num)
frequency = g_eeprom.vfo_info[vfo_num].pTX->frequency;
frequency = g_eeprom.vfo_info[vfo_num].p_tx->frequency;
}
if (g_eeprom.screen_channel[vfo_num] <= USER_CHANNEL_LAST)
@ -741,7 +741,7 @@ void UI_DisplayMain(void)
}
else
{ // or show the CTCSS/DCS symbol
const freq_config_t *pConfig = (mode == 1) ? g_eeprom.vfo_info[vfo_num].pTX : g_eeprom.vfo_info[vfo_num].pRX;
const freq_config_t *pConfig = (mode == 1) ? g_eeprom.vfo_info[vfo_num].p_tx : g_eeprom.vfo_info[vfo_num].p_rx;
const unsigned int code_type = pConfig->code_type;
const char *code_list[] = {"", "CT", "DCS", "DCR"};
if (code_type < ARRAY_SIZE(code_list))

70
ui/scanner.c
View File

@ -29,12 +29,12 @@
#include "ui/scanner.h"
#include "ui/ui.h"
void UI_DisplayScanner(void)
void UI_DisplaySearch(void)
{
char String[17];
bool text_centered = false;
if (g_screen_to_display != DISPLAY_SCANNER)
if (g_screen_to_display != DISPLAY_SEARCH)
return;
// clear display buffer
@ -46,27 +46,27 @@ void UI_DisplayScanner(void)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough="
switch (g_scan_css_state)
switch (g_search_css_state)
{
default:
case SCAN_CSS_STATE_OFF:
if (!g_scan_single_frequency)
case SEARCH_CSS_STATE_OFF:
if (!g_search_single_frequency)
{
strcpy(String, "FREQ scanning");
break;
}
case SCAN_CSS_STATE_SCANNING:
case SCAN_CSS_STATE_FOUND:
case SCAN_CSS_STATE_FAILED:
case SCAN_CSS_STATE_REPEAT:
case SEARCH_CSS_STATE_SCANNING:
case SEARCH_CSS_STATE_FOUND:
case SEARCH_CSS_STATE_FAILED:
case SEARCH_CSS_STATE_REPEAT:
{
const uint32_t freq = g_scan_frequency;
const uint32_t freq = g_search_frequency;
sprintf(String, "FREQ %u.%05u", freq / 100000, freq % 100000);
}
break;
case SCAN_CSS_STATE_FREQ_FAILED:
case SEARCH_CSS_STATE_FREQ_FAILED:
strcpy(String, "FREQ none found");
break;
}
@ -80,37 +80,37 @@ void UI_DisplayScanner(void)
memset(String, 0, sizeof(String));
switch (g_scan_css_state)
switch (g_search_css_state)
{
default:
case SCAN_CSS_STATE_OFF:
case SEARCH_CSS_STATE_OFF:
strcpy(String, "CODE");
break;
case SCAN_CSS_STATE_SCANNING:
case SEARCH_CSS_STATE_SCANNING:
strcpy(String, "CODE scanning");
break;
case SCAN_CSS_STATE_FOUND:
case SCAN_CSS_STATE_REPEAT:
case SEARCH_CSS_STATE_FOUND:
case SEARCH_CSS_STATE_REPEAT:
switch (g_scan_css_result_type)
switch (g_search_css_result_type)
{
default:
case CODE_TYPE_NONE:
strcpy(String, "CODE none found");
break;
case CODE_TYPE_CONTINUOUS_TONE:
sprintf(String, "CTCSS %u.%uHz", CTCSS_OPTIONS[g_scan_css_result_code] / 10, CTCSS_OPTIONS[g_scan_css_result_code] % 10);
sprintf(String, "CTCSS %u.%uHz", CTCSS_OPTIONS[g_search_css_result_code] / 10, CTCSS_OPTIONS[g_search_css_result_code] % 10);
break;
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
sprintf(String, "CDCSS D%03oN", DCS_OPTIONS[g_scan_css_result_code]);
sprintf(String, "CDCSS D%03oN", DCS_OPTIONS[g_search_css_result_code]);
break;
}
break;
case SCAN_CSS_STATE_FAILED:
case SEARCH_CSS_STATE_FAILED:
strcpy(String, "CODE none found");
break;
}
@ -125,36 +125,36 @@ void UI_DisplayScanner(void)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough="
switch (g_scanner_edit_state)
switch (g_search_edit_state)
{
default:
case SCAN_EDIT_STATE_NONE:
case SEARCH_EDIT_STATE_NONE:
switch (g_scan_css_state)
switch (g_search_css_state)
{
default:
case SCAN_CSS_STATE_OFF:
case SCAN_CSS_STATE_SCANNING: // rolling indicator
case SEARCH_CSS_STATE_OFF:
case SEARCH_CSS_STATE_SCANNING: // rolling indicator
memset(String, 0, sizeof(String));
memset(String, '.', 15);
String[(g_scan_freq_css_timer_10ms / 32) % 15] = '#';
String[(g_search_freq_css_timer_10ms / 32) % 15] = '#';
break;
case SCAN_CSS_STATE_FOUND:
case SEARCH_CSS_STATE_FOUND:
strcpy(String, "* repeat M save");
text_centered = true;
break;
case SCAN_CSS_STATE_FAILED:
if (!g_scan_single_frequency)
case SEARCH_CSS_STATE_FAILED:
if (!g_search_single_frequency)
{
strcpy(String, "* repeat M save");
text_centered = true;
break;
}
case SCAN_CSS_STATE_FREQ_FAILED:
case SCAN_CSS_STATE_REPEAT:
case SEARCH_CSS_STATE_FREQ_FAILED:
case SEARCH_CSS_STATE_REPEAT:
strcpy(String, "* repeat");
text_centered = true;
break;
@ -162,18 +162,18 @@ void UI_DisplayScanner(void)
break;
case SCAN_EDIT_STATE_SAVE_CHAN:
case SEARCH_EDIT_STATE_SAVE_CHAN:
strcpy(String, "SAVE ");
{
char s[11];
BOARD_fetchChannelName(s, g_scan_channel);
BOARD_fetchChannelName(s, g_search_channel);
if (s[0] == 0)
UI_GenerateChannelStringEx(s, g_show_chan_prefix ? "CH-" : "", g_scan_channel);
UI_GenerateChannelStringEx(s, g_search_show_chan_prefix ? "CH-" : "", g_search_channel);
strcat(String, s);
}
break;
case SCAN_EDIT_STATE_SAVE_CONFIRM:
case SEARCH_EDIT_STATE_SAVE_CONFIRM:
strcpy(String, "* repeat Save ?");
text_centered = true;
break;

2
ui/scanner.h
View File

@ -17,7 +17,7 @@
#ifndef UI_SCANNER_H
#define UI_SCANNER_H
void UI_DisplayScanner(void);
void UI_DisplaySearch(void);
#endif

4
ui/status.c
View File

@ -95,9 +95,9 @@ void UI_DisplayStatus(const bool test_display)
else
#endif
// SCAN indicator
if (g_scan_state_dir != SCAN_OFF || g_screen_to_display == DISPLAY_SCANNER || test_display)
if (g_scan_state_dir != SCAN_STATE_DIR_OFF || g_screen_to_display == DISPLAY_SEARCH || test_display)
{
if (g_next_channel <= USER_CHANNEL_LAST)
if (g_scan_next_channel <= USER_CHANNEL_LAST)
{ // channel mode
if (g_eeprom.scan_list_default == 0)
UI_PrintStringSmallBuffer("1", line + x);

6
ui/ui.c
View File

@ -61,8 +61,8 @@ void GUI_DisplayScreen(void)
UI_DisplayMenu();
break;
case DISPLAY_SCANNER:
UI_DisplayScanner();
case DISPLAY_SEARCH:
UI_DisplaySearch();
break;
#ifdef ENABLE_AIRCOPY
@ -88,7 +88,7 @@ void GUI_SelectNextDisplay(gui_display_type_t Display)
g_input_box_index = 0;
g_is_in_sub_menu = false;
g_css_scan_mode = CSS_SCAN_MODE_OFF;
g_scan_state_dir = SCAN_OFF;
g_scan_state_dir = SCAN_STATE_DIR_OFF;
#ifdef ENABLE_FMRADIO
g_fm_scan_state = FM_SCAN_OFF;
#endif

2
ui/ui.h
View File

@ -25,7 +25,7 @@ enum gui_display_type_e
DISPLAY_MAIN = 0,
DISPLAY_FM,
DISPLAY_MENU,
DISPLAY_SCANNER,
DISPLAY_SEARCH,
DISPLAY_AIRCOPY,
DISPLAY_INVALID // 0xff
};