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

const renames + display updates

Browse Source
This commit is contained in:
OneOfEleven 2023-09-16 17:16:36 +01:00
parent e5c7c81276
commit 7bd011b057
17 changed files with 110 additions and 410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
app/app.c
View File

@ -98,7 +98,7 @@ static void APP_CheckForIncoming(void)
return; return;
} }
gDualWatchCountdown = dual_watch_count_after_rx; gDualWatchCountdown = dual_watch_count_after_rx_10ms;
gScheduleDualWatch = false; gScheduleDualWatch = false;
} }
else else
@ -163,7 +163,7 @@ static void APP_HandleIncoming(void)
{ {
if (gRxReceptionMode == RX_MODE_DETECTED) if (gRxReceptionMode == RX_MODE_DETECTED)
{ {
gDualWatchCountdown = dual_watch_count_after_1; gDualWatchCountdown = dual_watch_count_after_1_10ms;
gScheduleDualWatch = false; gScheduleDualWatch = false;
gRxReceptionMode = RX_MODE_LISTENING; gRxReceptionMode = RX_MODE_LISTENING;
return; return;
@ -442,7 +442,7 @@ void APP_StartListening(FUNCTION_Type_t Function)
{ {
gRxVfoIsActive = true; gRxVfoIsActive = true;
gDualWatchCountdown = dual_watch_count_after_2; gDualWatchCountdown = dual_watch_count_after_2_10ms;
gScheduleDualWatch = false; gScheduleDualWatch = false;
} }
@ -607,9 +607,9 @@ static void DUALWATCH_Alternate(void)
RADIO_SetupRegisters(false); RADIO_SetupRegisters(false);
#ifdef ENABLE_NOAA #ifdef ENABLE_NOAA
gDualWatchCountdown = gIsNoaaMode ? dual_watch_count_noaa : dual_watch_count_toggle; gDualWatchCountdown = gIsNoaaMode ? dual_watch_count_noaa_10ms : dual_watch_count_toggle_10ms;
#else #else
gDualWatchCountdown = dual_watch_count_toggle; gDualWatchCountdown = dual_watch_count_toggle_10ms;
#endif #endif
} }
@ -687,9 +687,9 @@ void APP_CheckRadioInterrupts(void)
gBatterySaveCountdownExpired = false; gBatterySaveCountdownExpired = false;
} }
if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && (gScheduleDualWatch || gDualWatchCountdown < dual_watch_count_after_vox)) if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && (gScheduleDualWatch || gDualWatchCountdown < dual_watch_count_after_vox_10ms))
{ {
gDualWatchCountdown = dual_watch_count_after_vox; gDualWatchCountdown = dual_watch_count_after_vox_10ms;
gScheduleDualWatch = false; gScheduleDualWatch = false;
} }
} }
@ -975,12 +975,12 @@ void APP_Update(void)
gCssScanMode != CSS_SCAN_MODE_OFF || gCssScanMode != CSS_SCAN_MODE_OFF ||
gScreenToDisplay != DISPLAY_MAIN || gScreenToDisplay != DISPLAY_MAIN ||
gDTMF_CallState != DTMF_CALL_STATE_NONE) gDTMF_CallState != DTMF_CALL_STATE_NONE)
gBatterySaveCountdown = battery_save_count; gBatterySaveCountdown = battery_save_count_10ms;
else else
if ((IS_NOT_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) && IS_NOT_NOAA_CHANNEL(gEeprom.ScreenChannel[1])) || !gIsNoaaMode) if ((IS_NOT_NOAA_CHANNEL(gEeprom.ScreenChannel[0]) && IS_NOT_NOAA_CHANNEL(gEeprom.ScreenChannel[1])) || !gIsNoaaMode)
FUNCTION_Select(FUNCTION_POWER_SAVE); FUNCTION_Select(FUNCTION_POWER_SAVE);
else else
gBatterySaveCountdown = battery_save_count; gBatterySaveCountdown = battery_save_count_10ms;
#else #else
if ( if (
#ifdef ENABLE_FMRADIO #ifdef ENABLE_FMRADIO
@ -993,7 +993,7 @@ void APP_Update(void)
gCssScanMode != CSS_SCAN_MODE_OFF || gCssScanMode != CSS_SCAN_MODE_OFF ||
gScreenToDisplay != DISPLAY_MAIN || gScreenToDisplay != DISPLAY_MAIN ||
gDTMF_CallState != DTMF_CALL_STATE_NONE) gDTMF_CallState != DTMF_CALL_STATE_NONE)
gBatterySaveCountdown = battery_save_count; gBatterySaveCountdown = battery_save_count_10ms;
else else
FUNCTION_Select(FUNCTION_POWER_SAVE); FUNCTION_Select(FUNCTION_POWER_SAVE);
#endif #endif
@ -1135,7 +1135,7 @@ void APP_CheckKeys(void)
return; return;
} }
if (++gDebounceCounter == key_debounce) if (++gDebounceCounter == key_debounce_10ms)
{ // debounced new key pressed { // debounced new key pressed
if (Key == KEY_INVALID) if (Key == KEY_INVALID)
@ -1158,7 +1158,7 @@ void APP_CheckKeys(void)
// key is being held pressed // key is being held pressed
if (gDebounceCounter == key_repeat_delay) if (gDebounceCounter == key_repeat_delay_10ms)
{ // initial delay after pressed { // initial delay after pressed
if (Key == KEY_STAR || if (Key == KEY_STAR ||
Key == KEY_F || Key == KEY_F ||
@ -1178,19 +1178,19 @@ void APP_CheckKeys(void)
return; return;
} }
if (gDebounceCounter > key_repeat_delay) if (gDebounceCounter > key_repeat_delay_10ms)
{ // key repeat { // key repeat
if (Key == KEY_UP || Key == KEY_DOWN) if (Key == KEY_UP || Key == KEY_DOWN)
{ {
gKeyBeingHeld = true; gKeyBeingHeld = true;
if ((gDebounceCounter % key_repeat) == 0) if ((gDebounceCounter % key_repeat_10ms) == 0)
APP_ProcessKey(Key, true, true); APP_ProcessKey(Key, true, true);
} }
if (gDebounceCounter < 0xFFFF) if (gDebounceCounter < 0xFFFF)
return; return;
gDebounceCounter = key_repeat_delay; gDebounceCounter = key_repeat_delay_10ms;
return; return;
} }
} }
@ -1374,7 +1374,7 @@ void APP_TimeSlice10ms(void)
GUI_SelectNextDisplay(DISPLAY_SCANNER); GUI_SelectNextDisplay(DISPLAY_SCANNER);
} }
gScanDelay = g_scan_delay; gScanDelay = scan_delay_10ms;
break; break;
case SCAN_CSS_STATE_SCANNING: case SCAN_CSS_STATE_SCANNING:
@ -1420,7 +1420,7 @@ void APP_TimeSlice10ms(void)
if (gScanCssState < SCAN_CSS_STATE_FOUND) if (gScanCssState < SCAN_CSS_STATE_FOUND)
{ {
BK4819_SetScanFrequency(gScanFrequency); BK4819_SetScanFrequency(gScanFrequency);
gScanDelay = g_scan_delay; gScanDelay = scan_delay_10ms;
break; break;
} }
@ -1753,7 +1753,7 @@ static void APP_ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
if (gCurrentFunction == FUNCTION_POWER_SAVE) if (gCurrentFunction == FUNCTION_POWER_SAVE)
FUNCTION_Select(FUNCTION_FOREGROUND); FUNCTION_Select(FUNCTION_FOREGROUND);
gBatterySaveCountdown = battery_save_count; gBatterySaveCountdown = battery_save_count_10ms;
if (gEeprom.AUTO_KEYPAD_LOCK) if (gEeprom.AUTO_KEYPAD_LOCK)
gKeyLockCountdown = 30; // 15 seconds gKeyLockCountdown = 30; // 15 seconds
@ -1792,7 +1792,7 @@ static void APP_ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
else else
{ {
if (Key != KEY_PTT) if (Key != KEY_PTT)
gVoltageMenuCountdown = g_menu_timeout; gVoltageMenuCountdown = menu_timeout_10ms;
BACKLIGHT_TurnOn(); BACKLIGHT_TurnOn();

8
app/main.c
View File

@ -266,7 +266,7 @@ static void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
uint8_t Vfo = gEeprom.TX_CHANNEL; uint8_t Vfo = gEeprom.TX_CHANNEL;
gKeyInputCountdown = key_input_timeout; gKeyInputCountdown = key_input_timeout_500ms;
INPUTBOX_Append(Key); INPUTBOX_Append(Key);
gRequestDisplayScreen = DISPLAY_MAIN; gRequestDisplayScreen = DISPLAY_MAIN;
@ -413,7 +413,7 @@ static void MAIN_Key_EXIT(bool bKeyPressed, bool bKeyHeld)
return; return;
gInputBox[--gInputBoxIndex] = 10; gInputBox[--gInputBoxIndex] = 10;
gKeyInputCountdown = key_input_timeout; gKeyInputCountdown = key_input_timeout_500ms;
#ifdef ENABLE_VOICE #ifdef ENABLE_VOICE
if (gInputBoxIndex == 0) if (gInputBoxIndex == 0)
@ -507,7 +507,7 @@ static void MAIN_Key_STAR(bool bKeyPressed, bool bKeyHeld)
if (gScanState == SCAN_OFF) if (gScanState == SCAN_OFF)
#endif #endif
{ {
gKeyInputCountdown = key_input_timeout; gKeyInputCountdown = key_input_timeout_500ms;
gDTMF_InputMode = true; gDTMF_InputMode = true;
memcpy(gDTMF_InputBox, gDTMF_String, 15); memcpy(gDTMF_InputBox, gDTMF_String, 15);
gDTMF_InputIndex = 0; gDTMF_InputIndex = 0;
@ -657,7 +657,7 @@ void MAIN_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
{ // add key to DTMF string { // add key to DTMF string
DTMF_Append(Character); DTMF_Append(Character);
gKeyInputCountdown = key_input_timeout; gKeyInputCountdown = key_input_timeout_500ms;
gRequestDisplayScreen = DISPLAY_MAIN; gRequestDisplayScreen = DISPLAY_MAIN;
gPttWasReleased = true; gPttWasReleased = true;
gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL; gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;

2
app/menu.c
View File

@ -1444,5 +1444,5 @@ void MENU_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
} }
if (gScreenToDisplay == DISPLAY_MENU && gMenuCursor == MENU_VOL) if (gScreenToDisplay == DISPLAY_MENU && gMenuCursor == MENU_VOL)
gVoltageMenuCountdown = g_menu_timeout; gVoltageMenuCountdown = menu_timeout_10ms;
} }

2
app/scanner.c
View File

@ -391,7 +391,7 @@ void SCANNER_Start(void)
BK4819_EnableFrequencyScan(); BK4819_EnableFrequencyScan();
} }
gScanDelay = g_scan_delay; gScanDelay = scan_delay_10ms;
gScanCssResultCode = 0xFF; gScanCssResultCode = 0xFF;
gScanCssResultType = 0xFF; gScanCssResultType = 0xFF;
gScanHitCount = 0; gScanHitCount = 0;

294
bitmaps.c
View File

@ -5,7 +5,7 @@
// turn your monitor 90deg anti-clockwise to see the images // turn your monitor 90deg anti-clockwise to see the images
const uint8_t BITMAP_PowerSave[] = const uint8_t BITMAP_PowerSave[] =
{ { // "S"
0b00000000, 0b00000000,
0b00100110, 0b00100110,
0b01001001, 0b01001001,
@ -127,7 +127,7 @@ const uint8_t BITMAP_BatteryLevel5[] =
}; };
const uint8_t BITMAP_USB_C[] = const uint8_t BITMAP_USB_C[] =
{ { // USB symbol
0b00000000, 0b00000000,
0b00011100, 0b00011100,
0b00100111, 0b00100111,
@ -140,7 +140,7 @@ const uint8_t BITMAP_USB_C[] =
}; };
const uint8_t BITMAP_KeyLock[] = const uint8_t BITMAP_KeyLock[] =
{ { // padlock symbol
0b00000000, 0b00000000,
0b01111100, 0b01111100,
0b01000110, 0b01000110,
@ -153,7 +153,7 @@ const uint8_t BITMAP_KeyLock[] =
}; };
const uint8_t BITMAP_F_Key[] = const uint8_t BITMAP_F_Key[] =
{ { // F-Key symbol
0b11111111, 0b11111111,
0b10000001, 0b10000001,
0b10111101, 0b10111101,
@ -167,7 +167,7 @@ const uint8_t BITMAP_F_Key[] =
}; };
const uint8_t BITMAP_VOX[] = const uint8_t BITMAP_VOX[] =
{ { // "VOX"
0b00000000, 0b00000000,
0b00011111, 0b00011111,
0b00100000, 0b00100000,
@ -192,7 +192,7 @@ const uint8_t BITMAP_VOX[] =
#if 0 #if 0
const uint8_t BITMAP_WX[] = const uint8_t BITMAP_WX[] =
{ { // "WX"
0b00000000, 0b00000000,
0b01111111, 0b01111111,
0b00100000, 0b00100000,
@ -210,7 +210,7 @@ const uint8_t BITMAP_VOX[] =
#else #else
// 'XB' (cross-band) // 'XB' (cross-band)
const uint8_t BITMAP_XB[] = const uint8_t BITMAP_XB[] =
{ { // "XB"
0b00000000, 0b00000000,
0b01100011, 0b01100011,
0b00010100, 0b00010100,
@ -228,7 +228,7 @@ const uint8_t BITMAP_VOX[] =
#endif #endif
const uint8_t BITMAP_TDR[] = const uint8_t BITMAP_TDR[] =
{ { // "DW"
0b00000000, 0b00000000,
0b01111111, 0b01111111,
0b01000001, 0b01000001,
@ -261,7 +261,7 @@ const uint8_t BITMAP_TDR[] =
#ifdef ENABLE_FMRADIO #ifdef ENABLE_FMRADIO
const uint8_t BITMAP_FM[] = const uint8_t BITMAP_FM[] =
{ { // "FM"
0b00000000, 0b00000000,
0b01111111, 0b01111111,
0b00001001, 0b00001001,
@ -280,7 +280,7 @@ const uint8_t BITMAP_TDR[] =
#ifdef ENABLE_NOAA #ifdef ENABLE_NOAA
const uint8_t BITMAP_NOAA[] = const uint8_t BITMAP_NOAA[] =
{ { // "NS"
0b00000000, 0b00000000,
0b01111111, 0b01111111,
0b00000100, 0b00000100,
@ -384,280 +384,8 @@ const uint8_t BITMAP_VFO_NotDefault[] =
0b00001000 0b00001000
}; };
const uint8_t BITMAP_TX[] =
{
0b00000000,
0b00000001,
0b00000001,
0b00000001,
0b01111111,
0b00000001,
0b00000001,
0b00000001,
0b00000000,
0b01100011,
0b00100010,
0b00010100,
0b00001000,
0b00010100,
0b00100010,
0b01100011
};
const uint8_t BITMAP_RX[] =
{
0b00000000,
0b01111111,
0b00001001,
0b00001001,
0b00001001,
0b00011001,
0b00101001,
0b01000110,
0b00000000,
0b01100011,
0b00100010,
0b00010100,
0b00001000,
0b00010100,
0b00100010,
0b01100011
};
const uint8_t BITMAP_M[] =
{
0b00000000,
0b01111111,
0b00000010,
0b00000100,
0b00011000,
0b00000100,
0b00000010,
0b01111111
};
const uint8_t BITMAP_FB[] =
{
0b00000000,
0b01111111,
0b00001001,
0b00001001,
0b00001001,
0b00001001,
0b00001001,
0b00000001,
0b00000000,
0b01111111,
0b01001001,
0b01001001,
0b01001001,
0b01001001,
0b01001001,
0b00110110
};
const uint8_t BITMAP_ReverseMode[] =
{
0b00000000,
0b01111111,
0b00001001,
0b00001001,
0b00001001,
0b00011001,
0b00101001,
0b01000110
};
const uint8_t BITMAP_NarrowBand[] =
{
0b00000000,
0b01111111,
0b00000010,
0b00000100,
0b00001000,
0b00010000,
0b00100000,
0b01111111
};
const uint8_t BITMAP_DTMF[] =
{
0b00000000,
0b01111111,
0b01000001,
0b01000001,
0b01000001,
0b00111110,
0b00000000,
0b00000001,
0b00000001,
0b01111111,
0b00000001,
0b00000001,
0b00000000,
0b01111111,
0b00000010,
0b00001100,
0b00000010,
0b01111111,
0b00000000,
0b01111111,
0b00001001,
0b00001001,
0b00001001,
0b00000001
};
const uint8_t BITMAP_Scramble[] =
{
0b00000000,
0b00100110,
0b01001001,
0b01001001,
0b01001001,
0b00110010,
0b00000000,
0b00111110,
0b01000001,
0b01000001,
0b01000001,
0b00100010,
0b00000000,
0b01111111,
0b00001001,
0b00011001,
0b00101001,
0b01000110
};
const uint8_t BITMAP_Add[] =
{
0b00000000,
0b00011000,
0b00011000,
0b01111110,
0b01111110,
0b01111110,
0b00011000,
0b00011000
};
const uint8_t BITMAP_Sub[] =
{
0b00000000,
0b00001100,
0b00001100,
0b00001100,
0b00001100,
0b00001100,
0b00001100,
0b00001100
};
const uint8_t BITMAP_PowerHigh[] =
{
0b00000000,
0b01111111,
0b00001000,
0b00001000,
0b00001000,
0b00001000,
0b00001000,
0b01111111
};
const uint8_t BITMAP_PowerMid[] =
{
0b00000000,
0b01111111,
0b00000010,
0b00000100,
0b00011000,
0b00000100,
0b00000010,
0b01111111
};
const uint8_t BITMAP_PowerLow[] =
{
0b00000000,
0b01111111,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01000000
};
const uint8_t BITMAP_AM[] =
{
0b00000000,
0b01111100,
0b00010010,
0b00010001,
0b00010010,
0b01111100,
0b00000000,
0b01111111,
0b00000010,
0b00001100,
0b00000010,
0b01111111
};
const uint8_t BITMAP_CT[] =
{
0b00000000,
0b00111110,
0b01000001,
0b01000001,
0b01000001,
0b00100010,
0b00000000,
0b00000001,
0b00000001,
0b01111111,
0b00000001,
0b00000001
};
const uint8_t BITMAP_DCS[] =
{
0b00000000,
0b01111111,
0b01000001,
0b01000001,
0b01000001,
0b00111110,
0b00000000,
0b00111110,
0b01000001,
0b01000001,
0b01000001,
0b00100010,
0b00000000,
0b00100110,
0b01001001,
0b01001001,
0b01001001,
0b00110010
};
const uint8_t BITMAP_ScanList[] = const uint8_t BITMAP_ScanList[] =
{ { // diamond symbol
0b00001000, 0b00001000,
0b00011100, 0b00011100,
0b00111110, 0b00111110,

26
bitmaps.h
View File

@ -53,32 +53,6 @@ extern const uint8_t BITMAP_CurrentIndicator[8];
extern const uint8_t BITMAP_VFO_Default[8]; extern const uint8_t BITMAP_VFO_Default[8];
extern const uint8_t BITMAP_VFO_NotDefault[8]; extern const uint8_t BITMAP_VFO_NotDefault[8];
extern const uint8_t BITMAP_TX[16];
extern const uint8_t BITMAP_RX[16];
extern const uint8_t BITMAP_M[8];
extern const uint8_t BITMAP_FB[16];
extern const uint8_t BITMAP_ReverseMode[8];
extern const uint8_t BITMAP_NarrowBand[8];
extern const uint8_t BITMAP_DTMF[24];
extern const uint8_t BITMAP_Scramble[18];
extern const uint8_t BITMAP_Add[8];
extern const uint8_t BITMAP_Sub[8];
extern const uint8_t BITMAP_PowerHigh[8];
extern const uint8_t BITMAP_PowerMid[8];
extern const uint8_t BITMAP_PowerLow[8];
extern const uint8_t BITMAP_AM[12];
extern const uint8_t BITMAP_CT[12];
extern const uint8_t BITMAP_DCS[18];
extern const uint8_t BITMAP_ScanList[6]; extern const uint8_t BITMAP_ScanList[6];
#endif #endif

4
driver/st7565.c
View File

@ -63,8 +63,7 @@ void ST7565_DrawLine(uint8_t Column, uint8_t Line, uint16_t Size, const uint8_t
void ST7565_BlitFullScreen(void) void ST7565_BlitFullScreen(void)
{ {
uint8_t Line; unsigned int Line;
uint8_t Column;
SPI_ToggleMasterMode(&SPI0->CR, false); SPI_ToggleMasterMode(&SPI0->CR, false);
@ -72,6 +71,7 @@ void ST7565_BlitFullScreen(void)
for (Line = 0; Line < 7; Line++) for (Line = 0; Line < 7; Line++)
{ {
unsigned int Column;
ST7565_SelectColumnAndLine(4, Line + 1); ST7565_SelectColumnAndLine(4, Line + 1);
GPIO_SetBit(&GPIOB->DATA, GPIOB_PIN_ST7565_A0); GPIO_SetBit(&GPIOB->DATA, GPIOB_PIN_ST7565_A0);
for (Column = 0; Column < 128; Column++) for (Column = 0; Column < 128; Column++)

BIN
firmware
View File

Binary file not shown.

BIN
firmware.bin
View File

Binary file not shown.

BIN
firmware.packed.bin
View File

Binary file not shown.

2
functions.c
View File

@ -183,7 +183,7 @@ void FUNCTION_Select(FUNCTION_Type_t Function)
break; break;
} }
gBatterySaveCountdown = battery_save_count; gBatterySaveCountdown = battery_save_count_10ms;
gSchedulePowerSave = false; gSchedulePowerSave = false;
#if defined(ENABLE_FMRADIO) #if defined(ENABLE_FMRADIO)
gFM_RestoreCountdown = 0; gFM_RestoreCountdown = 0;

36
misc.c
View File

@ -18,15 +18,26 @@
#include "misc.h" #include "misc.h"
const uint8_t key_input_timeout = 10; // 5 seconds const uint8_t menu_timeout_10ms = 20 * 2; // 20 seconds
const uint16_t key_repeat_delay = 40; // 400ms const uint8_t key_input_timeout_500ms = 8 * 2; // 8 seconds
const uint16_t key_repeat = 8; // was 15 (150ms) .. MUST be less than 'key_repeat_delay'
const uint16_t key_debounce = 2; // 20ms
const uint8_t g_scan_delay = 21; // 210ms const uint16_t key_repeat_delay_10ms = 400 / 10; // 400ms
const uint16_t key_repeat_10ms = 80 / 10; // 80ms .. MUST be less than 'key_repeat_delay'
const uint16_t key_debounce_10ms = 20 / 10; // 20ms
const uint8_t g_menu_timeout = 2 * 15; // 15 seconds const uint8_t scan_delay_10ms = 210 / 10; // 210ms
// 10ms count down resolution
const uint16_t dual_watch_count_after_tx_10ms = 3600 / 10; // 3.6 sec after TX ends
const uint16_t dual_watch_count_after_rx_10ms = 1000 / 10; // 1 sec after RX ends ?
const uint16_t dual_watch_count_after_1_10ms = 5000 / 10; // 5 sec
const uint16_t dual_watch_count_after_2_10ms = 3600 / 10; // 3.6 sec
const uint16_t dual_watch_count_toggle_10ms = 100 / 10; // 100ms between VFO toggles
const uint16_t dual_watch_count_noaa_10ms = 70 / 10; // 70ms
const uint16_t dual_watch_count_after_vox_10ms = 200 / 10; // 200ms
const uint16_t battery_save_count_10ms = 10000 / 10; // 10 seconds
const uint16_t gMax_bat_v = 843; // 8.43V const uint16_t gMax_bat_v = 843; // 8.43V
const uint16_t gMin_bat_v = 660; // 6.6V const uint16_t gMin_bat_v = 660; // 6.6V
@ -35,17 +46,6 @@ const uint32_t gDefaultAesKey[4] = {0x4AA5CC60, 0x0312CC5F, 0xFFD2DABB, 0x6BB
const uint8_t gMicGain_dB2[5] = {3, 8, 16, 24, 31}; const uint8_t gMicGain_dB2[5] = {3, 8, 16, 24, 31};
const uint16_t battery_save_count = 10000 / 10; // 10 seconds
// 10ms count down resolution
const uint16_t dual_watch_count_after_tx = 3600 / 10; // 3.6 sec after TX ends
const uint16_t dual_watch_count_after_rx = 1000 / 10; // 1 sec after RX ends ?
const uint16_t dual_watch_count_after_1 = 5000 / 10; // 5 sec
const uint16_t dual_watch_count_after_2 = 3600 / 10; // 3.6 sec
const uint16_t dual_watch_count_toggle = 100 / 10; // 100ms between VFO toggles
const uint16_t dual_watch_count_noaa = 70 / 10; // 70ms
const uint16_t dual_watch_count_after_vox = 200 / 10; // 200ms
bool gSetting_350TX; bool gSetting_350TX;
bool gSetting_KILLED; bool gSetting_KILLED;
bool gSetting_200TX; bool gSetting_200TX;
@ -72,7 +72,7 @@ uint16_t gEEPROM_1F8C;
uint8_t gMR_ChannelAttributes[207]; uint8_t gMR_ChannelAttributes[207];
volatile bool gNextTimeslice500ms; volatile bool gNextTimeslice500ms;
volatile uint16_t gBatterySaveCountdown = battery_save_count; volatile uint16_t gBatterySaveCountdown = battery_save_count_10ms;
volatile uint16_t gDualWatchCountdown; volatile uint16_t gDualWatchCountdown;
volatile uint16_t gTxTimerCountdown; volatile uint16_t gTxTimerCountdown;
volatile uint16_t gTailNoteEliminationCountdown; volatile uint16_t gTailNoteEliminationCountdown;

32
misc.h
View File

@ -74,31 +74,31 @@ enum CssScanMode_t
typedef enum CssScanMode_t CssScanMode_t; typedef enum CssScanMode_t CssScanMode_t;
extern const uint8_t key_input_timeout; extern const uint8_t key_input_timeout_500ms;
extern const uint16_t key_repeat_delay; extern const uint16_t key_repeat_delay_10ms;
extern const uint16_t key_repeat; extern const uint16_t key_repeat_10ms;
extern const uint16_t key_debounce; extern const uint16_t key_debounce_10ms;
extern const uint8_t g_scan_delay; extern const uint8_t scan_delay_10ms;
extern const uint8_t g_menu_timeout; extern const uint8_t menu_timeout_10ms;
extern const uint16_t battery_save_count_10ms;
extern const uint16_t dual_watch_count_after_tx_10ms;
extern const uint16_t dual_watch_count_after_rx_10ms;
extern const uint16_t dual_watch_count_after_1_10ms;
extern const uint16_t dual_watch_count_after_2_10ms;
extern const uint16_t dual_watch_count_toggle_10ms;
extern const uint16_t dual_watch_count_noaa_10ms;
extern const uint16_t dual_watch_count_after_vox_10ms;
extern const uint16_t gMax_bat_v; extern const uint16_t gMax_bat_v;
extern const uint16_t gMin_bat_v; extern const uint16_t gMin_bat_v;
extern const uint8_t gMicGain_dB2[5]; extern const uint8_t gMicGain_dB2[5];
extern const uint16_t battery_save_count;
extern const uint16_t dual_watch_count_after_tx;
extern const uint16_t dual_watch_count_after_rx;
extern const uint16_t dual_watch_count_after_1;
extern const uint16_t dual_watch_count_after_2;
extern const uint16_t dual_watch_count_toggle;
extern const uint16_t dual_watch_count_noaa;
extern const uint16_t dual_watch_count_after_vox;
extern bool gSetting_350TX; extern bool gSetting_350TX;
extern bool gSetting_KILLED; extern bool gSetting_KILLED;
extern bool gSetting_200TX; extern bool gSetting_200TX;

2
radio.c
View File

@ -842,7 +842,7 @@ void RADIO_PrepareTX(void)
{ {
if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF) if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF)
{ {
gDualWatchCountdown = dual_watch_count_after_tx; gDualWatchCountdown = dual_watch_count_after_tx_10ms;
gScheduleDualWatch = false; gScheduleDualWatch = false;
if (!gRxVfoIsActive) if (!gRxVfoIsActive)

2
ui/lock.c
View File

@ -67,7 +67,7 @@ void UI_DisplayLock(void)
if (gKeyReading0 == Key) if (gKeyReading0 == Key)
{ {
if (++gDebounceCounter == key_debounce) if (++gDebounceCounter == key_debounce_10ms)
{ {
if (Key == KEY_INVALID) if (Key == KEY_INVALID)
{ {

59
ui/main.c
View File

@ -68,9 +68,7 @@ void UI_DisplayMain(void)
if (!bIsSameVfo) if (!bIsSameVfo)
continue; // skip the unused vfo continue; // skip the unused vfo
//Line = 1;
//pLine0 = gFrameBuffer[Line + 0];
//pLine1 = gFrameBuffer[Line + 1];
} }
if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && gRxVfoIsActive) if (gEeprom.DUAL_WATCH != DUAL_WATCH_OFF && gRxVfoIsActive)
@ -151,7 +149,7 @@ void UI_DisplayMain(void)
if (Channel == vfo_num) if (Channel == vfo_num)
{ // show the TX symbol { // show the TX symbol
SomeValue = 1; SomeValue = 1;
memcpy(pLine0 + 14, BITMAP_TX, sizeof(BITMAP_TX)); UI_PrintStringSmall("TX", 14, 0, Line);
} }
} }
} }
@ -159,7 +157,7 @@ void UI_DisplayMain(void)
{ // receiving .. show the RX symbol { // receiving .. show the RX symbol
SomeValue = 2; SomeValue = 2;
if ((gCurrentFunction == FUNCTION_RECEIVE || gCurrentFunction == FUNCTION_MONITOR) && gEeprom.RX_CHANNEL == vfo_num) if ((gCurrentFunction == FUNCTION_RECEIVE || gCurrentFunction == FUNCTION_MONITOR) && gEeprom.RX_CHANNEL == vfo_num)
memcpy(pLine0 + 14, BITMAP_RX, sizeof(BITMAP_RX)); UI_PrintStringSmall("RX", 14, 0, Line);
} }
if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num])) if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
@ -168,23 +166,21 @@ void UI_DisplayMain(void)
const unsigned int x = 2; const unsigned int x = 2;
// show the memory channel symbol // show the memory channel symbol
memcpy(pLine1 + x, BITMAP_M, sizeof(BITMAP_M)); UI_PrintStringSmall("M", x, 0, Line + 1);
if (gInputBoxIndex == 0 || gEeprom.TX_CHANNEL != vfo_num) if (gInputBoxIndex == 0 || gEeprom.TX_CHANNEL != vfo_num)
NUMBER_ToDigits(gEeprom.ScreenChannel[vfo_num] + 1, String); // show the memory channel number NUMBER_ToDigits(gEeprom.ScreenChannel[vfo_num] + 1, String); // show the memory channel number
else else
memcpy(String + 5, gInputBox, 3); // show the input text memcpy(String + 5, gInputBox, 3); // show the input text
UI_DisplaySmallDigits(3, String + 5, x + sizeof(BITMAP_M), Line + 1, false); UI_DisplaySmallDigits(3, String + 5, x + 7, Line + 1, false);
} }
else else
if (IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num])) if (IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
{ {
const unsigned int x = 2; // was 14 const unsigned int x = 2; // was 14
// show the frequency band number // show the frequency band number
char c; sprintf(String, "FB%u", 1 + gEeprom.ScreenChannel[vfo_num] - FREQ_CHANNEL_FIRST);
memcpy(pLine1 + x, BITMAP_FB, sizeof(BITMAP_FB)); UI_PrintStringSmall(String, x, 0, Line + 1);
c = (gEeprom.ScreenChannel[vfo_num] - FREQ_CHANNEL_FIRST) + 1;
UI_DisplaySmallDigits(1, &c, x + sizeof(BITMAP_FB), Line + 1, false);
} }
else else
{ {
@ -405,7 +401,7 @@ void UI_DisplayMain(void)
if (gEeprom.VfoInfo[vfo_num].IsAM) if (gEeprom.VfoInfo[vfo_num].IsAM)
{ // show the AM symbol { // show the AM symbol
memcpy(pLine1 + display_width + 27, BITMAP_AM, sizeof(BITMAP_AM)); UI_PrintStringSmall("AM", display_width + 27, 0, Line + 1);
} }
else else
{ // show the CTCSS or DCS symbol { // show the CTCSS or DCS symbol
@ -416,51 +412,52 @@ void UI_DisplayMain(void)
case CODE_TYPE_OFF: case CODE_TYPE_OFF:
break; break;
case CODE_TYPE_CONTINUOUS_TONE: // CTCSS case CODE_TYPE_CONTINUOUS_TONE: // CTCSS
memcpy(pLine1 + display_width + 27, BITMAP_CT, sizeof(BITMAP_CT)); UI_PrintStringSmall("CT", display_width + 24, 0, Line + 1);
break; break;
case CODE_TYPE_DIGITAL: case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL: // DCS case CODE_TYPE_REVERSE_DIGITAL: // DCS
memcpy(pLine1 + display_width + 24, BITMAP_DCS, sizeof(BITMAP_DCS)); UI_PrintStringSmall("DCS", display_width + 24, 0, Line + 1);
break; break;
} }
} }
String[0] = '?';
switch (gEeprom.VfoInfo[vfo_num].OUTPUT_POWER) switch (gEeprom.VfoInfo[vfo_num].OUTPUT_POWER)
{ // show the TX power level symbol { // show the TX power level symbol
case OUTPUT_POWER_LOW: case OUTPUT_POWER_LOW: String[0] = 'L'; break;
memcpy(pLine1 + display_width + 44, BITMAP_PowerLow, sizeof(BITMAP_PowerLow)); case OUTPUT_POWER_MID: String[0] = 'M'; break;
break; case OUTPUT_POWER_HIGH: String[0] = 'H'; break;
case OUTPUT_POWER_MID:
memcpy(pLine1 + display_width + 44, BITMAP_PowerMid, sizeof(BITMAP_PowerMid));
break;
case OUTPUT_POWER_HIGH:
memcpy(pLine1 + display_width + 44, BITMAP_PowerHigh, sizeof(BITMAP_PowerHigh));
break;
} }
String[1] = '\0';
UI_PrintStringSmall(String, display_width + 46, 0, Line + 1);
if (gEeprom.VfoInfo[vfo_num].ConfigRX.Frequency != gEeprom.VfoInfo[vfo_num].ConfigTX.Frequency) if (gEeprom.VfoInfo[vfo_num].ConfigRX.Frequency != gEeprom.VfoInfo[vfo_num].ConfigTX.Frequency)
{ // show the TX offset symbol { // show the TX offset symbol
if (gEeprom.VfoInfo[vfo_num].TX_OFFSET_FREQUENCY_DIRECTION == TX_OFFSET_FREQUENCY_DIRECTION_ADD) String[0] = '\0';
memcpy(pLine1 + display_width + 54, BITMAP_Add, sizeof(BITMAP_Add)); switch (gEeprom.VfoInfo[vfo_num].TX_OFFSET_FREQUENCY_DIRECTION)
if (gEeprom.VfoInfo[vfo_num].TX_OFFSET_FREQUENCY_DIRECTION == TX_OFFSET_FREQUENCY_DIRECTION_SUB) {
memcpy(pLine1 + display_width + 54, BITMAP_Sub, sizeof(BITMAP_Sub)); case TX_OFFSET_FREQUENCY_DIRECTION_ADD: String[0] = '+'; break;
case TX_OFFSET_FREQUENCY_DIRECTION_SUB: String[0] = '-'; break;
}
String[1] = '\0';
UI_PrintStringSmall(String, display_width + 54, 0, Line + 1);
} }
// show the TX/RX reverse symbol // show the TX/RX reverse symbol
if (gEeprom.VfoInfo[vfo_num].FrequencyReverse) if (gEeprom.VfoInfo[vfo_num].FrequencyReverse)
memcpy(pLine1 + display_width + 64, BITMAP_ReverseMode, sizeof(BITMAP_ReverseMode)); UI_PrintStringSmall("R", display_width + 62, 0, Line + 1);
// show the narrow band symbol // show the narrow band symbol
if (gEeprom.VfoInfo[vfo_num].CHANNEL_BANDWIDTH == BANDWIDTH_NARROW) if (gEeprom.VfoInfo[vfo_num].CHANNEL_BANDWIDTH == BANDWIDTH_NARROW)
memcpy(pLine1 + display_width + 74, BITMAP_NarrowBand, sizeof(BITMAP_NarrowBand)); UI_PrintStringSmall("N", display_width + 70, 0, Line + 1);
// show the DTMF decoding symbol // show the DTMF decoding symbol
if (gEeprom.VfoInfo[vfo_num].DTMF_DECODING_ENABLE || gSetting_KILLED) if (gEeprom.VfoInfo[vfo_num].DTMF_DECODING_ENABLE || gSetting_KILLED)
memcpy(pLine1 + display_width + 84, BITMAP_DTMF, sizeof(BITMAP_DTMF)); UI_PrintStringSmall("DTMF", display_width + 78, 0, Line + 1);
// show the audio scramble symbol // show the audio scramble symbol
if (gEeprom.VfoInfo[vfo_num].SCRAMBLING_TYPE && gSetting_ScrambleEnable) if (gEeprom.VfoInfo[vfo_num].SCRAMBLING_TYPE && gSetting_ScrambleEnable)
memcpy(pLine1 + display_width + 110, BITMAP_Scramble, sizeof(BITMAP_Scramble)); UI_PrintStringSmall("SCR", display_width + 106, 0, Line + 1);
} }
ST7565_BlitFullScreen(); ST7565_BlitFullScreen();

1
ui/status.c
View File

@ -26,6 +26,7 @@
#include "helper/battery.h" #include "helper/battery.h"
#include "misc.h" #include "misc.h"
#include "settings.h" #include "settings.h"
//#include "ui/helper.h"
#include "ui/status.h" #include "ui/status.h"
void UI_DisplayStatus(const bool test_display) void UI_DisplayStatus(const bool test_display)