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

Reduced eeprom wear

Browse Source
This commit is contained in:
OneOfEleven 2023-10-19 14:21:37 +01:00
parent add4d6d7e1
commit ba677b3440
18 changed files with 337 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/aircopy.c
View File

@ -650,7 +650,7 @@ static void AIRCOPY_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
g_aircopy_freq = Frequency;
#ifdef ENABLE_AIRCOPY_REMEMBER_FREQ
SETTINGS_SaveSettings(); // remeber the frequency for the next time
SETTINGS_save(); // remeber the frequency for the next time
#endif
g_rx_vfo->freq_config_rx.frequency = Frequency;

26
app/app.c
View File

@ -652,11 +652,11 @@ void APP_stop_scan(void)
{ // frequency mode
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);
SETTINGS_save_channel(g_rx_vfo->channel_save, g_eeprom.rx_vfo, g_rx_vfo, 1);
return;
}
SETTINGS_SaveVfoIndices();
SETTINGS_save_vfo_indices();
}
#ifdef ENABLE_VOICE
@ -1549,27 +1549,27 @@ void APP_time_slice_10ms(void)
if (g_flag_save_vfo)
{
SETTINGS_SaveVfoIndices();
SETTINGS_save_vfo_indices();
g_flag_save_vfo = false;
}
if (g_flag_save_settings)
{
SETTINGS_SaveSettings();
SETTINGS_save();
g_flag_save_settings = false;
}
#ifdef ENABLE_FMRADIO
if (g_flag_save_fm)
{
SETTINGS_SaveFM();
SETTINGS_save_fm();
g_flag_save_fm = false;
}
#endif
if (g_flag_save_channel)
{
SETTINGS_SaveChannel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, g_flag_save_channel ? 1 : 0);
SETTINGS_save_channel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, g_flag_save_channel ? 1 : 0);
g_flag_save_channel = false;
RADIO_configure_channel(g_eeprom.tx_vfo, VFO_CONFIGURE);
@ -2734,7 +2734,7 @@ Skip:
if (g_request_save_settings)
{
if (!key_held)
SETTINGS_SaveSettings();
SETTINGS_save();
else
g_flag_save_settings = 1;
@ -2746,7 +2746,7 @@ Skip:
if (g_request_save_fm)
{
if (!key_held)
SETTINGS_SaveFM();
SETTINGS_save_fm();
else
g_flag_save_fm = true;
@ -2757,7 +2757,7 @@ Skip:
if (g_request_save_vfo)
{
if (!key_held)
SETTINGS_SaveVfoIndices();
SETTINGS_save_vfo_indices();
else
g_flag_save_vfo = true;
@ -2768,7 +2768,7 @@ Skip:
{
if (!key_held)
{
SETTINGS_SaveChannel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, g_request_save_channel);
SETTINGS_save_channel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, g_request_save_channel);
if (g_screen_to_display != DISPLAY_SEARCH)
if (g_vfo_configure_mode == VFO_CONFIGURE_NONE) // don't wipe previous variable setting
@ -2787,10 +2787,6 @@ Skip:
if (g_vfo_configure_mode != VFO_CONFIGURE_NONE)
{
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
UART_printf("audio gap\r\n");
#endif
if (g_flag_reset_vfos)
{
RADIO_configure_channel(0, g_vfo_configure_mode);
@ -2819,6 +2815,8 @@ Skip:
RADIO_setup_registers(true);
// g_tx_vfo->frequency_channel = BOARD_find_channel(frequency);
g_dtmf_auto_reset_time_500ms = 0;
g_dtmf_call_state = DTMF_CALL_STATE_NONE;
g_dtmf_tx_stop_count_down_500ms = 0;

4
app/dtmf.c
View File

@ -244,7 +244,7 @@ void DTMF_HandleRequest(void)
DTMF_clear_RX();
SETTINGS_SaveSettings();
SETTINGS_save();
g_dtmf_reply_state = DTMF_REPLY_AB;
@ -283,7 +283,7 @@ void DTMF_HandleRequest(void)
DTMF_clear_RX();
SETTINGS_SaveSettings();
SETTINGS_save();
g_dtmf_reply_state = DTMF_REPLY_AB;
g_dtmf_call_state = DTMF_CALL_STATE_NONE;

2
app/fm.c
View File

@ -163,7 +163,7 @@ void FM_PlayAndUpdate(void)
FM_ConfigureChannelState();
BK1080_SetFrequency(g_eeprom.fm_frequency_playing);
SETTINGS_SaveFM();
SETTINGS_save_fm();
g_fm_play_count_down_10ms = 0;
g_schedule_fm = false;

116
app/main.c
View File

@ -43,8 +43,14 @@
void toggle_chan_scanlist(void)
{ // toggle the selected channels scanlist setting
// if (IS_FREQ_CHANNEL(g_tx_vfo->channel_save))
if (IS_NOAA_CHANNEL(g_tx_vfo->channel_save))
{
g_beep_to_play = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return;
}
if (g_screen_to_display != DISPLAY_MAIN ||
!IS_USER_CHANNEL(g_tx_vfo->channel_save) ||
g_current_function == FUNCTION_TRANSMIT ||
g_current_function == FUNCTION_PANADAPTER)
{
@ -76,7 +82,7 @@ void toggle_chan_scanlist(void)
g_tx_vfo->scanlist_1_participation = 1;
}
SETTINGS_UpdateChannel(g_tx_vfo->channel_save, g_tx_vfo, true);
SETTINGS_save_chan_attribs_name(g_tx_vfo->channel_save, g_tx_vfo);
g_vfo_configure_mode = VFO_CONFIGURE;
g_flag_reset_vfos = true;
@ -406,9 +412,6 @@ void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
return;
}
// #ifdef ENABLE_NOAA
// if (IS_NOT_NOAA_CHANNEL(g_tx_vfo->channel_save))
// #endif
if (IS_FREQ_CHANNEL(g_tx_vfo->channel_save))
{ // user is entering a frequency
@ -457,13 +460,13 @@ void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
g_eeprom.screen_channel[Vfo] = band + FREQ_CHANNEL_FIRST;
g_eeprom.freq_channel[Vfo] = band + FREQ_CHANNEL_FIRST;
SETTINGS_SaveVfoIndices();
SETTINGS_save_vfo_indices();
RADIO_configure_channel(Vfo, VFO_CONFIGURE_RELOAD);
}
// Frequency += 75; // is this meant to be rounding ?
Frequency += g_tx_vfo->step_freq / 2; // no idea, but this is
Frequency += g_tx_vfo->step_freq / 2; // no idea, but this is
Frequency = FREQUENCY_FloorToStep(Frequency, g_tx_vfo->step_freq, FREQ_BAND_TABLE[g_tx_vfo->band].lower);
@ -474,10 +477,18 @@ void MAIN_Key_DIGITS(key_code_t Key, bool key_pressed, bool key_held)
}
g_tx_vfo->freq_config_rx.frequency = Frequency;
// 1of11 .. test to prevent the monitor being turned off
// g_request_save_channel = 1;
SETTINGS_SaveChannel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, 1);
RADIO_setup_registers(true);
// find the first channel that contains this frequency
g_tx_vfo->frequency_channel = BOARD_find_channel(Frequency);
// 1of11 .. test to prevent monitor mode being turned off
#if 0
// this currently also turns monitor mode off :(
g_request_save_channel = 1;
#else
SETTINGS_save_channel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, 1);
RADIO_setup_registers(true);
#endif
return;
}
@ -615,9 +626,9 @@ void MAIN_Key_MENU(const bool key_pressed, const bool key_held)
#ifdef ENABLE_COPY_CHAN_TO_VFO_TO_CHAN
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_scan_state_dir == SCAN_STATE_DIR_OFF &&
g_css_scan_mode == CSS_SCAN_MODE_OFF &&
g_eeprom.dual_watch == DUAL_WATCH_OFF &&
g_eeprom.vfo_open)
{ // not scanning
@ -647,28 +658,36 @@ void MAIN_Key_MENU(const bool key_pressed, const bool key_held)
g_update_display = true;
}
else
if (IS_FREQ_CHANNEL(g_eeprom.screen_channel[vfo]))
{ // copy VFO to channel
if (IS_NOT_NOAA_CHANNEL(g_eeprom.screen_channel[vfo]))
{ // copy VFO to a channel
// search the channels to see if the frequency is already present
const unsigned int chan = BOARD_find_channel(g_eeprom.vfo_info[vfo].p_tx->frequency);
unsigned int chan = BOARD_find_channel(g_eeprom.vfo_info[vfo].p_tx->frequency);
if (chan > USER_CHANNEL_LAST)
{ // find next next free channel
//for (chan = g_eeprom.screen_channel[vfo]; chan <= USER_CHANNEL_LAST; chan++)
for (chan = 0; chan <= USER_CHANNEL_LAST; chan++)
if (!RADIO_CheckValidChannel(chan, false, vfo))
break;
}
g_screen_to_display = DISPLAY_INVALID;
GUI_SelectNextDisplay(DISPLAY_MENU);
g_flag_refresh_menu = false;
g_menu_cursor = MENU_MEM_SAVE;
g_is_in_sub_menu = true;
if (chan <= USER_CHANNEL_LAST)
{ // go straight to the channel that holds the same frequency
{
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
UART_printf("vfo to mem %u\r\n", chan);
#endif
g_sub_menu_selection = chan;
g_flag_refresh_menu = false;
g_screen_to_display = DISPLAY_MENU;
g_update_display = false;
UI_DisplayMenu();
}
g_screen_to_display = DISPLAY_MENU;
g_update_display = false;
UI_DisplayMenu();
#ifdef ENABLE_VOICE
g_another_voice_id = VOICE_ID_MENU;
#endif
@ -796,27 +815,31 @@ void MAIN_Key_UP_DOWN(bool key_pressed, bool key_held, scan_state_dir_t Directio
g_beep_to_play = BEEP_1KHZ_60MS_OPTIONAL;
}
if (!key_pressed &&
g_scan_state_dir == SCAN_STATE_DIR_OFF &&
IS_NOT_NOAA_CHANNEL(Channel) &&
IS_FREQ_CHANNEL(Channel))
{ // key released in frequency mode
#ifdef ENABLE_SQ_OPEN_WITH_UP_DN_BUTTS
if (key_held && !monitor_was_enabled && g_current_function == FUNCTION_MONITOR)
{ // re-enable the squelch
APP_start_listening(FUNCTION_RECEIVE, false);
g_monitor_enabled = false;
}
#endif
if (!key_pressed)
{
if (g_scan_state_dir == SCAN_STATE_DIR_OFF && IS_FREQ_CHANNEL(Channel))
{ // key released in frequency mode
// only update eeprom when the key is released - saves a LOT of wear and tear on the little eeprom
SETTINGS_SaveChannel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, 1);
#ifdef ENABLE_SQ_OPEN_WITH_UP_DN_BUTTS
if (key_held && !monitor_was_enabled && g_current_function == FUNCTION_MONITOR)
{ // re-enable the squelch
APP_start_listening(FUNCTION_RECEIVE, false);
g_monitor_enabled = false;
}
#endif
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("save chan\r\n");
#endif
// find the first channel that contains this frequency
g_tx_vfo->frequency_channel = BOARD_find_channel(g_tx_vfo->freq_config_rx.frequency);
// only update eeprom when the key is released - saves a LOT of wear and tear on the little eeprom
SETTINGS_save_channel(g_tx_vfo->channel_save, g_eeprom.tx_vfo, g_tx_vfo, 1);
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("save chan\r\n");
#endif
}
}
if (key_held || !key_pressed)
{ // long press
@ -874,6 +897,13 @@ void MAIN_Key_UP_DOWN(bool key_pressed, bool key_held, scan_state_dir_t Directio
g_tx_vfo->freq_config_rx.frequency = frequency;
// find the first channel that contains this frequency
// currently takes to long to scan all the channels
//
// TODO: include this once we have the entire eeprom loaded
//
//g_tx_vfo->frequency_channel = BOARD_find_channel(frequency);
if (new_band != old_band)
{ // original slow method
g_request_save_channel = 1;

10
app/menu.c
View File

@ -527,7 +527,7 @@ void MENU_AcceptSetting(void)
// save the channel name
memset(g_tx_vfo->name, 0, sizeof(g_tx_vfo->name));
memmove(g_tx_vfo->name, g_edit, 10);
SETTINGS_SaveChannel(g_sub_menu_selection, g_eeprom.tx_vfo, g_tx_vfo, 3);
SETTINGS_save_channel(g_sub_menu_selection, g_eeprom.tx_vfo, g_tx_vfo, 3);
g_flag_reconfigure_vfos = true;
return;
@ -614,14 +614,14 @@ void MENU_AcceptSetting(void)
case MENU_S_ADD1:
g_tx_vfo->scanlist_1_participation = g_sub_menu_selection;
SETTINGS_UpdateChannel(g_tx_vfo->channel_save, g_tx_vfo, true);
SETTINGS_save_chan_attribs_name(g_tx_vfo->channel_save, g_tx_vfo);
g_vfo_configure_mode = VFO_CONFIGURE;
g_flag_reset_vfos = true;
return;
case MENU_S_ADD2:
g_tx_vfo->scanlist_2_participation = g_sub_menu_selection;
SETTINGS_UpdateChannel(g_tx_vfo->channel_save, g_tx_vfo, true);
SETTINGS_save_chan_attribs_name(g_tx_vfo->channel_save, g_tx_vfo);
g_vfo_configure_mode = VFO_CONFIGURE;
g_flag_reset_vfos = true;
return;
@ -657,7 +657,7 @@ void MENU_AcceptSetting(void)
#if 1
g_request_save_channel = 1;
#else
SETTINGS_SaveChannel(g_sub_menu_selection, g_eeprom.tx_vfo, g_tx_vfo, 3);
SETTINGS_save_channel(g_sub_menu_selection, g_eeprom.tx_vfo, g_tx_vfo, 3);
g_flag_reconfigure_vfos = true;
#endif
return;
@ -783,7 +783,7 @@ void MENU_AcceptSetting(void)
#endif
case MENU_MEM_DEL:
SETTINGS_UpdateChannel(g_sub_menu_selection, NULL, false);
SETTINGS_save_chan_attribs_name(g_sub_menu_selection, NULL);
g_vfo_configure_mode = VFO_CONFIGURE_RELOAD;
g_flag_reset_vfos = true;
return;

10
bitmaps.c
View File

@ -400,3 +400,13 @@ const uint8_t BITMAP_COMPAND[6] =
__extension__ 0b01000010,
__extension__ 0b00100100
};
const uint8_t BITMAP_FREQ_CHAN[6] =
{
__extension__ 0b00000000,
__extension__ 0b01111110,
__extension__ 0b00010010,
__extension__ 0b00010010,
__extension__ 0b00000010,
__extension__ 0b00000010
};

2
bitmaps.h
View File

@ -61,5 +61,7 @@ extern const uint8_t BITMAP_SCANLIST2[6];
extern const uint8_t BITMAP_COMPAND[6];
extern const uint8_t BITMAP_FREQ_CHAN[6];
#endif

2
board.c
View File

@ -992,7 +992,7 @@ void BOARD_FactoryReset(bool bIsAll)
g_rx_vfo->freq_config_rx.frequency = Frequency;
g_rx_vfo->freq_config_tx.frequency = Frequency;
g_rx_vfo->band = FREQUENCY_GetBand(Frequency);
SETTINGS_SaveChannel(USER_CHANNEL_FIRST + i, 0, g_rx_vfo, 2);
SETTINGS_save_channel(USER_CHANNEL_FIRST + i, 0, g_rx_vfo, 2);
}
}
}

58
driver/eeprom.c
View File

@ -14,40 +14,60 @@
* limitations under the License.
*/
#include <string.h> // NULL and memcmp
#include "driver/eeprom.h"
#include "driver/i2c.h"
#include "driver/system.h"
void EEPROM_ReadBuffer(uint16_t Address, void *pBuffer, uint8_t Size)
void EEPROM_ReadBuffer(const uint16_t address, void *p_buffer, const unsigned int size)
{
I2C_Start();
if (p_buffer == NULL || address >= 0x2000 || size == 0)
return;
I2C_Start();
I2C_Write(0xA0);
I2C_Write((Address >> 8) & 0xFF);
I2C_Write((Address >> 0) & 0xFF);
I2C_Write((address >> 8) & 0xFF);
I2C_Write((address >> 0) & 0xFF);
I2C_Start();
I2C_Write(0xA1);
I2C_ReadBuffer(pBuffer, Size);
I2C_ReadBuffer(p_buffer, size);
I2C_Stop();
}
void EEPROM_WriteBuffer(uint16_t Address, const void *pBuffer)
void EEPROM_WriteBuffer(const uint16_t address, const void *p_buffer)
{
if (p_buffer == NULL || address >= 0x2000)
return;
#if 0
// normal way
I2C_Start();
I2C_Write(0xA0);
I2C_Write((Address >> 8) & 0xFF);
I2C_Write((Address >> 0) & 0xFF);
I2C_WriteBuffer(pBuffer, 8);
I2C_Write((address >> 8) & 0xFF);
I2C_Write((address >> 0) & 0xFF);
I2C_WriteBuffer(p_buffer, 8);
I2C_Stop();
SYSTEM_DelayMs(10);
#else
// eeprom wear reduction
// only write the data IF it's different to what's already in eeprom
uint8_t buffer[8];
EEPROM_ReadBuffer(address, buffer, 8);
if (memcmp(p_buffer, buffer, 8) != 0)
{
I2C_Start();
I2C_Write(0xA0);
I2C_Write((address >> 8) & 0xFF);
I2C_Write((address >> 0) & 0xFF);
I2C_WriteBuffer(p_buffer, 8);
I2C_Stop();
}
#endif
// give the EEPROM time to burn the data in (apparently takes 5ms)
SYSTEM_DelayMs(8);
}

4
driver/eeprom.h
View File

@ -19,8 +19,8 @@
#include <stdint.h>
void EEPROM_ReadBuffer(uint16_t Address, void *pBuffer, uint8_t Size);
void EEPROM_WriteBuffer(uint16_t Address, const void *pBuffer);
void EEPROM_ReadBuffer(const uint16_t address, void *p_buffer, const unsigned int size);
void EEPROM_WriteBuffer(const uint16_t address, const void *p_buffer);
#endif

BIN
firmware.bin
View File

Binary file not shown.

BIN
firmware.packed.bin
View File

Binary file not shown.

67
radio.c
View File

@ -22,6 +22,7 @@
#include "app/fm.h"
#endif
#include "audio.h"
#include "board.h"
#include "bsp/dp32g030/gpio.h"
#include "dcs.h"
#include "driver/bk4819.h"
@ -120,8 +121,8 @@ 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 = 1;
pInfo->scanlist_2_participation = 1;
pInfo->step_setting = STEP_12_5kHz;
pInfo->step_freq = STEP_FREQ_TABLE[pInfo->step_setting];
pInfo->channel_save = ChannelSave;
@ -132,6 +133,7 @@ void RADIO_InitInfo(vfo_info_t *pInfo, const uint8_t ChannelSave, const uint32_t
pInfo->p_rx = &pInfo->freq_config_rx;
pInfo->p_tx = &pInfo->freq_config_tx;
pInfo->compand = 0; // off
pInfo->frequency_channel = 0xff;
if (ChannelSave == (FREQ_CHANNEL_FIRST + BAND2_108MHz))
pInfo->am_mode = 1;
@ -144,10 +146,8 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
uint8_t Channel;
uint8_t Attributes;
uint8_t Band;
bool bParticipation2;
uint16_t Base;
uint32_t Frequency;
vfo_info_t *pRadio = &g_eeprom.vfo_info[VFO];
if (!g_setting_350_enable)
{
@ -160,12 +160,14 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
Channel = g_eeprom.screen_channel[VFO];
g_eeprom.vfo_info[VFO].frequency_channel = 0xff;
if (IS_VALID_CHANNEL(Channel))
{
#ifdef ENABLE_NOAA
if (Channel >= NOAA_CHANNEL_FIRST)
{
RADIO_InitInfo(pRadio, g_eeprom.screen_channel[VFO], NOAA_FREQUENCY_TABLE[Channel - NOAA_CHANNEL_FIRST]);
RADIO_InitInfo(&g_eeprom.vfo_info[VFO], g_eeprom.screen_channel[VFO], NOAA_FREQUENCY_TABLE[Channel - NOAA_CHANNEL_FIRST]);
if (g_eeprom.cross_vfo_rx_tx == CROSS_BAND_OFF)
return;
g_eeprom.cross_vfo_rx_tx = CROSS_BAND_OFF;
@ -206,32 +208,36 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
Index = Channel - FREQ_CHANNEL_FIRST;
RADIO_InitInfo(pRadio, Channel, FREQ_BAND_TABLE[Index].lower);
RADIO_InitInfo(&g_eeprom.vfo_info[VFO], Channel, FREQ_BAND_TABLE[Index].lower);
return;
}
Band = Attributes & USER_CH_BAND_MASK;
if (Band > BAND7_470MHz)
{
Band = BAND6_400MHz;
}
if (Channel <= USER_CHANNEL_LAST)
{
{ // user channel
g_eeprom.vfo_info[VFO].band = Band;
g_eeprom.vfo_info[VFO].scanlist_1_participation = (Attributes & USER_CH_SCANLIST1) ? true : false;
bParticipation2 = (Attributes & USER_CH_SCANLIST2) ? true : false;
g_eeprom.vfo_info[VFO].scanlist_2_participation = (Attributes & USER_CH_SCANLIST2) ? 1 : 0;
g_eeprom.vfo_info[VFO].scanlist_1_participation = (Attributes & USER_CH_SCANLIST1) ? 1 : 0;
}
else
{
if (IS_FREQ_CHANNEL(Channel))
{ // VFO channel
Band = Channel - FREQ_CHANNEL_FIRST;
g_eeprom.vfo_info[VFO].band = Band;
bParticipation2 = true;
g_eeprom.vfo_info[VFO].scanlist_1_participation = true;
g_eeprom.vfo_info[VFO].band = Band; // shouldn't this be "Band / 2" ? .. two VFO's per band
#if 0
g_eeprom.vfo_info[VFO].scanlist_2_participation = 1;
g_eeprom.vfo_info[VFO].scanlist_1_participation = 1;
#else
// allowing the vfo's to be included in the scanning
g_eeprom.vfo_info[VFO].scanlist_2_participation = (Attributes & USER_CH_SCANLIST2) ? 1 : 0;
g_eeprom.vfo_info[VFO].scanlist_1_participation = (Attributes & USER_CH_SCANLIST1) ? 1 : 0;
#endif
}
g_eeprom.vfo_info[VFO].scanlist_2_participation = bParticipation2;
g_eeprom.vfo_info[VFO].channel_save = Channel;
g_eeprom.vfo_info[VFO].channel_save = Channel;
if (Channel <= USER_CHANNEL_LAST)
Base = Channel * 16;
@ -353,7 +359,7 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
EEPROM_ReadBuffer(Base, &info, sizeof(info));
pRadio->freq_config_rx.frequency = info.frequency;
g_eeprom.vfo_info[VFO].freq_config_rx.frequency = info.frequency;
if (info.offset >= 100000000)
info.offset = 1000000;
@ -362,11 +368,14 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
// ***************
}
Frequency = pRadio->freq_config_rx.frequency;
Frequency = g_eeprom.vfo_info[VFO].freq_config_rx.frequency;
#if 1
// fix previously set incorrect band
// fix previously maybe incorrect set band
Band = FREQUENCY_GetBand(Frequency);
g_eeprom.vfo_info[VFO].band = Band;
#endif
if (Frequency < FREQ_BAND_TABLE[Band].lower)
@ -378,21 +387,23 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
if (Channel >= FREQ_CHANNEL_FIRST)
Frequency = FREQUENCY_FloorToStep(Frequency, g_eeprom.vfo_info[VFO].step_freq, FREQ_BAND_TABLE[Band].lower);
pRadio->freq_config_rx.frequency = Frequency;
g_eeprom.vfo_info[VFO].freq_config_rx.frequency = Frequency;
if (Frequency >= 10800000 && Frequency < 13600000)
g_eeprom.vfo_info[VFO].tx_offset_freq_dir = TX_OFFSET_FREQ_DIR_OFF;
g_eeprom.vfo_info[VFO].tx_offset_freq_dir = TX_OFFSET_FREQ_DIR_OFF; // air band
else
if (Channel > USER_CHANNEL_LAST)
g_eeprom.vfo_info[VFO].tx_offset_freq = FREQUENCY_FloorToStep(g_eeprom.vfo_info[VFO].tx_offset_freq, g_eeprom.vfo_info[VFO].step_freq, 0);
RADIO_ApplyOffset(pRadio);
if (IS_FREQ_CHANNEL(Channel))
g_eeprom.vfo_info[VFO].frequency_channel = BOARD_find_channel(Frequency); // remember if a channel has this frequency
RADIO_ApplyOffset(&g_eeprom.vfo_info[VFO]);
memset(g_eeprom.vfo_info[VFO].name, 0, sizeof(g_eeprom.vfo_info[VFO].name));
if (Channel < USER_CHANNEL_LAST)
{ // 16 bytes allocated to the channel name but only 10 used, the rest are 0's
EEPROM_ReadBuffer(0x0F50 + (Channel * 16), g_eeprom.vfo_info[VFO].name + 0, 8);
EEPROM_ReadBuffer(0x0F58 + (Channel * 16), g_eeprom.vfo_info[VFO].name + 8, 2);
if (Channel <= USER_CHANNEL_LAST)
{ // only 10 bytes used
EEPROM_ReadBuffer(0x0F50 + (Channel * 16), g_eeprom.vfo_info[VFO].name, 10);
}
if (!g_eeprom.vfo_info[VFO].frequency_reverse)
@ -421,7 +432,7 @@ void RADIO_configure_channel(const unsigned int VFO, const unsigned int configur
g_eeprom.vfo_info[VFO].freq_config_tx.code_type = CODE_TYPE_NONE;
}
RADIO_ConfigureSquelchAndOutputPower(pRadio);
RADIO_ConfigureSquelchAndOutputPower(&g_eeprom.vfo_info[VFO]);
}
void RADIO_ConfigureSquelchAndOutputPower(vfo_info_t *pInfo)

2
radio.h
View File

@ -113,6 +113,8 @@ typedef struct vfo_info_t
uint8_t compand;
uint8_t frequency_channel; // channel number if a channel is set to this vfo's frequency
char name[16];
} vfo_info_t;

153
settings.c
View File

@ -27,7 +27,7 @@
eeprom_config_t g_eeprom;
#ifdef ENABLE_FMRADIO
void SETTINGS_SaveFM(void)
void SETTINGS_save_fm(void)
{
unsigned int i;
@ -51,7 +51,7 @@ eeprom_config_t g_eeprom;
}
#endif
void SETTINGS_SaveVfoIndices(void)
void SETTINGS_save_vfo_indices(void)
{
uint8_t State[8];
@ -188,10 +188,10 @@ void SETTINGS_restore_calibration(void)
// *************************************************
void SETTINGS_SaveSettings(void)
void SETTINGS_save(void)
{
uint8_t State[8];
State[0] = g_eeprom.chan_1_call;
State[1] = g_eeprom.squelch_level;
State[2] = g_eeprom.tx_timeout_timer;
@ -336,118 +336,107 @@ void SETTINGS_SaveSettings(void)
#endif
State[7] = (State[7] & ~(3u << 6)) | ((g_setting_backlight_on_tx_rx & 3u) << 6);
EEPROM_WriteBuffer(0x0F40, State);
memset(State, 0xFF, sizeof(State));
State[0] = g_eeprom.scan_hold_time_500ms;
EEPROM_WriteBuffer(0x0F48, State);
}
void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const vfo_info_t *pVFO, uint8_t Mode)
void SETTINGS_save_channel(const uint8_t channel, const uint8_t vfo, const vfo_info_t *p_vfo, const uint8_t mode)
{
const uint16_t OffsetMR = Channel * 16;
uint16_t OffsetVFO = OffsetMR;
uint8_t State[8];
const uint16_t offset_mem = channel * 16;
uint16_t offset_vfo = offset_mem;
uint8_t state[16];
// t_channel channel_data;
if (IS_NOAA_CHANNEL(Channel))
if (p_vfo == NULL || IS_NOAA_CHANNEL(channel))
return;
if (IS_FREQ_CHANNEL(Channel))
if (IS_FREQ_CHANNEL(channel))
{ // it's a VFO
OffsetVFO = (VFO == 0) ? 0x0C80 : 0x0C90;
OffsetVFO += (Channel - FREQ_CHANNEL_FIRST) * 32;
offset_vfo = (vfo == 0) ? 0x0C80 : 0x0C90;
offset_vfo += (channel - FREQ_CHANNEL_FIRST) * 16 * 2;
}
if (Mode < 2 && Channel <= USER_CHANNEL_LAST)
if (mode < 2 && channel <= USER_CHANNEL_LAST)
return;
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("sav_chan %u %u %u\r\n", Channel, VFO, Mode);
// UART_printf("sav_chan %u %u %u\r\n", channel, vfo, mode);
#endif
((uint32_t *)State)[0] = pVFO->freq_config_rx.frequency;
((uint32_t *)State)[1] = pVFO->tx_offset_freq;
EEPROM_WriteBuffer(OffsetVFO + 0, State);
((uint32_t *)state)[0] = p_vfo->freq_config_rx.frequency;
((uint32_t *)state)[1] = p_vfo->tx_offset_freq;
EEPROM_WriteBuffer(offset_vfo, state);
State[0] = pVFO->freq_config_rx.code;
State[1] = pVFO->freq_config_tx.code;
State[2] = (pVFO->freq_config_tx.code_type << 4) | pVFO->freq_config_rx.code_type;
State[3] = ((pVFO->am_mode & 1u) << 4) | pVFO->tx_offset_freq_dir;
State[4] =
(pVFO->compand << 6) |
(pVFO->busy_channel_lock << 4) |
(pVFO->output_power << 2) |
(pVFO->channel_bandwidth << 1) |
(pVFO->frequency_reverse << 0);
State[5] = ((pVFO->dtmf_ptt_id_tx_mode & 7u) << 1) | ((pVFO->dtmf_decoding_enable & 1u) << 0);
State[6] = pVFO->step_setting;
State[7] = pVFO->scrambling_type;
EEPROM_WriteBuffer(OffsetVFO + 8, State);
state[0] = p_vfo->freq_config_rx.code;
state[1] = p_vfo->freq_config_tx.code;
state[2] = (p_vfo->freq_config_tx.code_type << 4) | p_vfo->freq_config_rx.code_type;
state[3] = ((p_vfo->am_mode & 1u) << 4) | p_vfo->tx_offset_freq_dir;
state[4] =
((p_vfo->compand & 3u) << 6) |
((p_vfo->busy_channel_lock & 3u) << 4) |
((p_vfo->output_power & 1u) << 2) |
((p_vfo->channel_bandwidth & 1u) << 1) |
((p_vfo->frequency_reverse & 1u) << 0);
state[5] = ((p_vfo->dtmf_ptt_id_tx_mode & 7u) << 1) | ((p_vfo->dtmf_decoding_enable & 1u) << 0);
state[6] = p_vfo->step_setting;
state[7] = p_vfo->scrambling_type;
EEPROM_WriteBuffer(offset_vfo + 8, state);
SETTINGS_UpdateChannel(Channel, pVFO, true);
SETTINGS_save_chan_attribs_name(channel, p_vfo);
if (Channel > USER_CHANNEL_LAST)
if (channel > USER_CHANNEL_LAST)
return; // it's not a user memory channel
#ifndef ENABLE_KEEP_MEM_NAME
// clear/reset the channel name
memset(&State, 0, sizeof(State));
EEPROM_WriteBuffer(0x0F50 + OffsetMR, State);
EEPROM_WriteBuffer(0x0F58 + OffsetMR, State);
{ // clear/reset the channel name
memset(&state, 0, sizeof(state));
EEPROM_WriteBuffer(0x0F50 + 0 + offset_mem, state + 0);
EEPROM_WriteBuffer(0x0F50 + 8 + offset_mem, state + 8);
}
#else
if (Mode >= 3)
if (mode >= 3)
{ // save the channel name
memmove(State, pVFO->name + 0, 8);
EEPROM_WriteBuffer(0x0F50 + OffsetMR, State);
memset(State, 0, sizeof(State));
memmove(State, pVFO->name + 8, 2);
EEPROM_WriteBuffer(0x0F58 + OffsetMR, State);
memset(state, 0, sizeof(state));
memmove(state, p_vfo->name, 10);
EEPROM_WriteBuffer(0x0F50 + 0 + offset_mem, state + 0);
EEPROM_WriteBuffer(0x0F50 + 8 + offset_mem, state + 8);
}
#endif
}
void SETTINGS_UpdateChannel(uint8_t Channel, const vfo_info_t *pVFO, bool keep)
void SETTINGS_save_chan_attribs_name(const uint8_t channel, const vfo_info_t *p_vfo)
{
uint8_t State[8];
uint8_t Attributes = 0xFF; // default attributes
uint16_t Offset = 0x0D60 + (Channel & ~7u);
if (IS_NOAA_CHANNEL(Channel))
if (p_vfo == NULL || channel >= ARRAY_SIZE(g_user_channel_attributes))
return;
EEPROM_ReadBuffer(Offset, State, sizeof(State));
if (IS_NOAA_CHANNEL(channel))
return;
if (keep)
{
Attributes = (pVFO->scanlist_1_participation << 7) | (pVFO->scanlist_2_participation << 6) | (pVFO->band << 0);
if (State[Channel & 7u] == Attributes)
return; // no change in the attributes .. don't place wear on the eeprom
{ // channel attributes
const uint8_t attribs =
((p_vfo->scanlist_1_participation & 1u) << 7) |
((p_vfo->scanlist_2_participation & 1u) << 6) |
((3u) << 4) |
((p_vfo->band & 7u) << 0);
const unsigned int index = channel & ~7u; // eeprom writes are always 8 bytes in length
g_user_channel_attributes[channel] = attribs; // remember new attributes
EEPROM_WriteBuffer(0x0D60 + index, g_user_channel_attributes + index);
}
if (channel <= USER_CHANNEL_LAST)
{ // user memory channel
const unsigned int index = channel * 16;
uint8_t name[16];
State[Channel & 7u] = Attributes;
memset(name, 0, sizeof(name));
memmove(name, p_vfo->name, 10);
EEPROM_WriteBuffer(Offset, State);
g_user_channel_attributes[Channel] = Attributes;
// #ifndef ENABLE_KEEP_MEM_NAME
if (Channel <= USER_CHANNEL_LAST)
{ // user memory channel
const uint16_t OffsetMR = Channel * 16;
if (!keep)
{ // clear/reset the channel name
memset(&State, 0, sizeof(State));
EEPROM_WriteBuffer(0x0F50 + OffsetMR, State);
EEPROM_WriteBuffer(0x0F58 + OffsetMR, State);
}
// else
// { // update the channel name
// memmove(State, pVFO->name + 0, 8);
// EEPROM_WriteBuffer(0x0F50 + OffsetMR, State);
// memset(State, 0, sizeof(State));
// memmove(State, pVFO->name + 8, 2);
// EEPROM_WriteBuffer(0x0F58 + OffsetMR, State);
// }
}
// #endif
EEPROM_WriteBuffer(0x0F50 + 0 + index, name + 0);
EEPROM_WriteBuffer(0x0F50 + 8 + index, name + 8);
}
}

14
settings.h
View File

@ -268,8 +268,8 @@ typedef struct {
// 0x0D60
struct { // these channel attribute settings could have been in the t_channel structure !
uint8_t band:4; // why do QS have these 4 bits ? .. band can/is computed from the frequency
uint8_t unused:2; // 0's
uint8_t band:4; // why do QS have these bits ? .. band can/is computed from the frequency
uint8_t unused:2; //
uint8_t scanlist2:1; // set if is in scan list 2
uint8_t scanlist1:1; // set if is in scan list 1
} __attribute__((packed)) channel_attr[200]; //
@ -559,12 +559,12 @@ typedef struct {
extern eeprom_config_t g_eeprom;
#ifdef ENABLE_FMRADIO
void SETTINGS_SaveFM(void);
void SETTINGS_save_fm(void);
#endif
void SETTINGS_SaveVfoIndices(void);
void SETTINGS_save_vfo_indices(void);
//void SETTINGS_restore_calibration(void);
void SETTINGS_SaveSettings(void);
void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const vfo_info_t *pVFO, uint8_t Mode);
void SETTINGS_UpdateChannel(uint8_t Channel, const vfo_info_t *pVFO, bool keep);
void SETTINGS_save(void);
void SETTINGS_save_channel(const uint8_t channel, const uint8_t vfo, const vfo_info_t *p_vfo, const uint8_t mode);
void SETTINGS_save_chan_attribs_name(const uint8_t channel, const vfo_info_t *p_vfo);
#endif

116
ui/main.c
View File

@ -240,39 +240,39 @@ void UI_drawBars(uint8_t *p, const unsigned int level)
{
// const int16_t s0_dBm = -127; // S0 .. base level
const int16_t s0_dBm = -147; // S0 .. base level
const int16_t s9_dBm = s0_dBm + (6 * 9); // S9 .. 6dB/S-Point
const int16_t bar_max_dBm = s9_dBm + 30; // S9+30dB
// const int16_t bar_min_dBm = s0_dBm + (6 * 0); // S0
const int16_t bar_min_dBm = s0_dBm + (6 * 4); // S4
// ************
const unsigned int txt_width = 7 * 8; // 8 text chars
const unsigned int bar_x = 2 + txt_width + 4; // X coord of bar graph
const unsigned int bar_width = LCD_WIDTH - 1 - bar_x;
const int16_t rssi_dBm = (rssi / 2) - 160;
const int16_t clamped_dBm = (rssi_dBm <= bar_min_dBm) ? bar_min_dBm : (rssi_dBm >= bar_max_dBm) ? bar_max_dBm : rssi_dBm;
const unsigned int bar_range_dB = bar_max_dBm - bar_min_dBm;
const unsigned int len = ((clamped_dBm - bar_min_dBm) * bar_width) / bar_range_dB;
const unsigned int line = 3;
uint8_t *p_line = g_frame_buffer[line];
char s[16];
if (g_eeprom.key_lock && g_keypad_locked > 0)
return false; // display is in use
if (g_current_function == FUNCTION_TRANSMIT ||
g_screen_to_display != DISPLAY_MAIN ||
g_dtmf_call_state != DTMF_CALL_STATE_NONE)
return false; // display is in use
if (now)
memset(p_line, 0, LCD_WIDTH);
if (rssi_dBm >= (s9_dBm + 6))
{ // S9+XXdB, 1dB increment
const char *fmt[] = {"%3d 9+%u ", "%3d 9+%2u "};
@ -285,12 +285,12 @@ void UI_drawBars(uint8_t *p, const unsigned int level)
sprintf(s, "%4d S%u ", rssi_dBm, s_level);
}
UI_PrintStringSmall(s, 2, 0, line);
draw_bar(p_line + bar_x, len, bar_width);
if (now)
ST7565_BlitFullScreen();
return true;
}
@ -643,28 +643,13 @@ void UI_DisplayMain(void)
if (g_eeprom.screen_channel[vfo_num] <= USER_CHANNEL_LAST)
{ // it's a channel
// show the channel symbols
const uint8_t attributes = g_user_channel_attributes[g_eeprom.screen_channel[vfo_num]];
if (attributes & USER_CH_SCANLIST1)
memmove(p_line0 + 113, BITMAP_SCANLIST1, sizeof(BITMAP_SCANLIST1));
if (attributes & USER_CH_SCANLIST2)
memmove(p_line0 + 120, BITMAP_SCANLIST2, sizeof(BITMAP_SCANLIST2));
#ifndef ENABLE_BIG_FREQ
if (g_eeprom.vfo_info[vfo_num].compand)
memmove(p_line0 + 120 + LCD_WIDTH, BITMAP_COMPAND, sizeof(BITMAP_COMPAND));
#else
// TODO: // find somewhere else to put the symbol
#endif
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough="
switch (g_eeprom.channel_display_mode)
{
case MDF_FREQUENCY: // show the channel frequency
case MDF_FREQUENCY: // just channel frequency
#ifdef ENABLE_BIG_FREQ
NUMBER_ToDigits(frequency, String);
// show the main large frequency digits
@ -676,35 +661,41 @@ void UI_DisplayMain(void)
sprintf(String, "%03u.%05u", frequency / 100000, frequency % 100000);
UI_PrintString(String, 32, 0, line, 8);
#endif
break;
case MDF_CHANNEL: // show the channel number
case MDF_CHANNEL: // just channel number
sprintf(String, "CH-%03u", g_eeprom.screen_channel[vfo_num] + 1);
UI_PrintString(String, 32, 0, line, 8);
break;
case MDF_NAME: // show the channel name
case MDF_NAME_FREQ: // show the channel name and frequency
case MDF_NAME: // channel name
case MDF_NAME_FREQ: // channel name and frequency
BOARD_fetchChannelName(String, g_eeprom.screen_channel[vfo_num]);
if (String[0] == 0)
{ // no channel name, show the channel number instead
{ // no channel name available, channel number instead
sprintf(String, "CH-%03u", g_eeprom.screen_channel[vfo_num] + 1);
}
if (g_eeprom.channel_display_mode == MDF_NAME)
{
{ // just the name
UI_PrintString(String, 32, 0, line, 8);
}
else
{
{ // name & frequency
// name
#ifdef ENABLE_SMALL_BOLD
UI_PrintStringSmallBold(String, 32 + 4, 0, line);
#else
UI_PrintStringSmall(String, 32 + 4, 0, line);
#endif
// show the channel frequency below the channel number/name
// frequency
sprintf(String, "%03u.%05u", frequency / 100000, frequency % 100000);
UI_PrintStringSmall(String, 32 + 4, 0, line + 1);
}
@ -715,6 +706,7 @@ void UI_DisplayMain(void)
#pragma GCC diagnostic pop
}
else
// if (IS_FREQ_CHANNEL(g_eeprom.screen_channel[vfo_num]))
{ // frequency mode
#ifdef ENABLE_BIG_FREQ
NUMBER_ToDigits(frequency, String); // 8 digits
@ -727,16 +719,48 @@ void UI_DisplayMain(void)
sprintf(String, "%03u.%05u", frequency / 100000, frequency % 100000);
UI_PrintString(String, 32, 0, line, 8);
#endif
// show the channel symbols
//const uint8_t attributes = g_user_channel_attributes[g_eeprom.screen_channel[vfo_num]];
if (g_eeprom.vfo_info[vfo_num].compand)
#ifdef ENABLE_BIG_FREQ
memmove(p_line0 + 120, BITMAP_COMPAND, sizeof(BITMAP_COMPAND));
#else
memmove(p_line0 + 120 + LCD_WIDTH, BITMAP_COMPAND, sizeof(BITMAP_COMPAND));
#endif
}
// show channel symbols
//if (g_eeprom.screen_channel[vfo_num] <= USER_CHANNEL_LAST)
if (IS_NOT_NOAA_CHANNEL(g_eeprom.screen_channel[vfo_num]))
{ // it's a user channel or VFO
unsigned int x = LCD_WIDTH - 1 - sizeof(BITMAP_SCANLIST2) - sizeof(BITMAP_SCANLIST1);
const uint8_t attributes = g_user_channel_attributes[g_eeprom.screen_channel[vfo_num]];
if (attributes & USER_CH_SCANLIST1)
memmove(p_line0 + x, BITMAP_SCANLIST1, sizeof(BITMAP_SCANLIST1));
x += sizeof(BITMAP_SCANLIST1);
if (attributes & USER_CH_SCANLIST2)
memmove(p_line0 + x, BITMAP_SCANLIST2, sizeof(BITMAP_SCANLIST2));
//x += sizeof(BITMAP_SCANLIST2);
}
#ifdef ENABLE_BIG_FREQ
// no room for these symbols
#else
{
unsigned int x = LCD_WIDTH + LCD_WIDTH - 1 - sizeof(BITMAP_FREQ_CHAN) - sizeof(BITMAP_COMPAND);
if (g_eeprom.vfo_info[vfo_num].compand)
memmove(p_line0 + x, BITMAP_COMPAND, sizeof(BITMAP_COMPAND));
x += sizeof(BITMAP_COMPAND);
if (IS_FREQ_CHANNEL(g_eeprom.screen_channel[vfo_num]))
{
//g_eeprom.vfo_info[vfo_num].frequency_channel = BOARD_find_channel(frequency);
if (g_eeprom.vfo_info[vfo_num].frequency_channel <= USER_CHANNEL_LAST)
memmove(p_line0 + x, BITMAP_FREQ_CHAN, sizeof(BITMAP_FREQ_CHAN));
//x += sizeof(BITMAP_FREQ_CHAN);
}
}
#endif
}
// ************