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

clean up

Browse Source
This commit is contained in:
OneOfEleven 2023-09-10 13:52:41 +01:00
parent 0176cb4214
commit 16434c8d14
13 changed files with 567 additions and 560 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
app/app.c
View File

@ -1661,8 +1661,7 @@ static void APP_ProcessKey(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
gUpdateStatus = true; gUpdateStatus = true;
} }
if (gF_LOCK) if (gF_LOCK && (Key == KEY_PTT || Key == KEY_SIDE2 || Key == KEY_SIDE1))
if (Key == KEY_PTT || Key == KEY_SIDE2 || Key == KEY_SIDE1)
return; return;
if (!bFlag) if (!bFlag)

70
driver/keyboard.c
View File

@ -37,33 +37,45 @@ KEY_Code_t KEYBOARD_Poll(void)
SYSTICK_DelayUs(1); SYSTICK_DelayUs(1);
// Keys connected to gnd // Keys connected to gnd
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0))
{
Key = KEY_SIDE1; Key = KEY_SIDE1;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1))
{
Key = KEY_SIDE2; Key = KEY_SIDE2;
goto Bye; goto Bye;
} }
// Original doesn't do PTT // Original doesn't do PTT
// First row // First row
GPIO_ClearBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_4); GPIO_ClearBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_4);
SYSTICK_DelayUs(1); SYSTICK_DelayUs(1);
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0)) { if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0))
{
Key = KEY_MENU; Key = KEY_MENU;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1))
{
Key = KEY_1; Key = KEY_1;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2))
{
Key = KEY_4; Key = KEY_4;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3))
{
Key = KEY_7; Key = KEY_7;
goto Bye; goto Bye;
} }
@ -75,19 +87,26 @@ KEY_Code_t KEYBOARD_Poll(void)
GPIO_SetBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_4); GPIO_SetBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_4);
SYSTICK_DelayUs(1); SYSTICK_DelayUs(1);
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0)) { if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0))
{
Key = KEY_UP; Key = KEY_UP;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1))
{
Key = KEY_2; Key = KEY_2;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2))
{
Key = KEY_5; Key = KEY_5;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3))
{
Key = KEY_8; Key = KEY_8;
goto Bye; goto Bye;
} }
@ -105,19 +124,26 @@ KEY_Code_t KEYBOARD_Poll(void)
GPIO_ClearBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_6); GPIO_ClearBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_6);
SYSTICK_DelayUs(1); SYSTICK_DelayUs(1);
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0)) { if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0))
{
Key = KEY_DOWN; Key = KEY_DOWN;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1))
{
Key = KEY_3; Key = KEY_3;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2))
{
Key = KEY_6; Key = KEY_6;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3))
{
Key = KEY_9; Key = KEY_9;
goto Bye; goto Bye;
} }
@ -129,19 +155,26 @@ KEY_Code_t KEYBOARD_Poll(void)
GPIO_SetBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_6); GPIO_SetBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_6);
SYSTICK_DelayUs(1); SYSTICK_DelayUs(1);
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0)) { if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_0))
{
Key = KEY_EXIT; Key = KEY_EXIT;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_1))
{
Key = KEY_STAR; Key = KEY_STAR;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_2))
{
Key = KEY_0; Key = KEY_0;
goto Bye; goto Bye;
} }
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3)) {
if (!GPIO_CheckBit(&GPIOA->DATA, GPIOA_PIN_KEYBOARD_3))
{
Key = KEY_F; Key = KEY_F;
goto Bye; goto Bye;
} }
@ -154,4 +187,3 @@ Bye:
return Key; return Key;
} }

2
driver/keyboard.h
View File

@ -41,7 +41,7 @@ enum KEY_Code_t {
KEY_PTT = 21, KEY_PTT = 21,
KEY_SIDE2 = 22, KEY_SIDE2 = 22,
KEY_SIDE1 = 23, KEY_SIDE1 = 23,
KEY_INVALID = 255, KEY_INVALID = 255
}; };
typedef enum KEY_Code_t KEY_Code_t; typedef enum KEY_Code_t KEY_Code_t;

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.

409
font.c
View File

@ -16,7 +16,8 @@
#include "font.h" #include "font.h"
const uint8_t gFontBig[95][16] = { const uint8_t gFontBig[95][16] =
{
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x70, 0xF8, 0xF8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x1B, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x70, 0xF8, 0xF8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x1B, 0x00, 0x00, 0x00},
{0x00, 0x1E, 0x3E, 0x00, 0x00, 0x3E, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x1E, 0x3E, 0x00, 0x00, 0x3E, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
@ -111,10 +112,11 @@ const uint8_t gFontBig[95][16] = {
{0x00, 0x80, 0x80, 0xF0, 0x78, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x1F, 0x10, 0x10, 0x00}, {0x00, 0x80, 0x80, 0xF0, 0x78, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x1F, 0x10, 0x10, 0x00},
{0x00, 0x00, 0x00, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x1F, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x1F, 0x00, 0x00, 0x00},
{0x00, 0x08, 0x08, 0x78, 0xF0, 0x80, 0x80, 0x00, 0x00, 0x10, 0x10, 0x1F, 0x0F, 0x00, 0x00, 0x00}, {0x00, 0x08, 0x08, 0x78, 0xF0, 0x80, 0x80, 0x00, 0x00, 0x10, 0x10, 0x1F, 0x0F, 0x00, 0x00, 0x00},
{ 0x10, 0x18, 0x08, 0x18, 0x10, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, {0x10, 0x18, 0x08, 0x18, 0x10, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
}; };
const uint8_t gFontBigDigits[11][26] = { const uint8_t gFontBigDigits[11][26] =
{
{0x00, 0xC0, 0xF0, 0xF8, 0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1C, 0xF8, 0xF0, 0xE0, 0x00, 0x07, 0x1F, 0x3F, 0x78, 0x60, 0x60, 0x60, 0x60, 0x70, 0x3F, 0x1F, 0x0F}, {0x00, 0xC0, 0xF0, 0xF8, 0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1C, 0xF8, 0xF0, 0xE0, 0x00, 0x07, 0x1F, 0x3F, 0x78, 0x60, 0x60, 0x60, 0x60, 0x70, 0x3F, 0x1F, 0x0F},
{0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0xFC, 0xFC, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0xFC, 0xFC, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x10, 0x38, 0x38, 0x1C, 0x0C, 0x0C, 0x0C, 0x0C, 0xFC, 0xF8, 0xF0, 0x00, 0x00, 0x70, 0x78, 0x7C, 0x7C, 0x6E, 0x66, 0x67, 0x67, 0x63, 0x61, 0x60, 0x00}, {0x00, 0x10, 0x38, 0x38, 0x1C, 0x0C, 0x0C, 0x0C, 0x0C, 0xFC, 0xF8, 0xF0, 0x00, 0x00, 0x70, 0x78, 0x7C, 0x7C, 0x6E, 0x66, 0x67, 0x67, 0x63, 0x61, 0x60, 0x00},
@ -125,10 +127,11 @@ const uint8_t gFontBigDigits[11][26] = {
{0x00, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x8C, 0xEC, 0xFC, 0x3C, 0x1C, 0x00, 0x00, 0x00, 0x40, 0x60, 0x78, 0x7C, 0x1F, 0x07, 0x03, 0x00, 0x00, 0x00}, {0x00, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x8C, 0xEC, 0xFC, 0x3C, 0x1C, 0x00, 0x00, 0x00, 0x40, 0x60, 0x78, 0x7C, 0x1F, 0x07, 0x03, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x78, 0xF8, 0xDC, 0x8C, 0x8C, 0x8C, 0x8C, 0xDC, 0xF8, 0x78, 0x00, 0x00, 0x1E, 0x3F, 0x3F, 0x73, 0x61, 0x61, 0x61, 0x61, 0x73, 0x3F, 0x3F, 0x1E}, {0x00, 0x00, 0x78, 0xF8, 0xDC, 0x8C, 0x8C, 0x8C, 0x8C, 0xDC, 0xF8, 0x78, 0x00, 0x00, 0x1E, 0x3F, 0x3F, 0x73, 0x61, 0x61, 0x61, 0x61, 0x73, 0x3F, 0x3F, 0x1E},
{0x00, 0xF0, 0xF8, 0xB8, 0x1C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1C, 0xB8, 0xF0, 0xE0, 0x00, 0x11, 0x33, 0x77, 0x67, 0x66, 0x66, 0x66, 0x76, 0x33, 0x3F, 0x1F, 0x07}, {0x00, 0xF0, 0xF8, 0xB8, 0x1C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1C, 0xB8, 0xF0, 0xE0, 0x00, 0x11, 0x33, 0x77, 0x67, 0x66, 0x66, 0x66, 0x76, 0x33, 0x3F, 0x1F, 0x07},
{ 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00 }, {0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00}
}; };
const uint8_t gFontSmallDigits[11][7] = { const uint8_t gFontSmallDigits[11][7] =
{
{0x00, 0x3E, 0x41, 0x41, 0x41, 0x41, 0x3E}, {0x00, 0x3E, 0x41, 0x41, 0x41, 0x41, 0x3E},
{0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00}, {0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00},
{0x00, 0x62, 0x51, 0x51, 0x49, 0x49, 0x46}, {0x00, 0x62, 0x51, 0x51, 0x49, 0x49, 0x46},
@ -139,219 +142,210 @@ const uint8_t gFontSmallDigits[11][7] = {
{0x00, 0x01, 0x71, 0x09, 0x05, 0x03, 0x00}, {0x00, 0x01, 0x71, 0x09, 0x05, 0x03, 0x00},
{0x00, 0x36, 0x49, 0x49, 0x49, 0x49, 0x36}, {0x00, 0x36, 0x49, 0x49, 0x49, 0x49, 0x36},
{0x00, 0x46, 0x49, 0x49, 0x49, 0x29, 0x1E}, {0x00, 0x46, 0x49, 0x49, 0x49, 0x29, 0x1E},
{ 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00 }, {0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00}
}; };
/* /*
const uint64_t gFont8x8[16 * 6] = const uint8_t gFont8x8[95][8] =
{ {
0x0000000000000000, // 'space' {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // 'space'
0x0808080800080000, // '!' {0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x00, 0x00}, // '!'
0x2828000000000000, // '"' {0x28, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '"'
0x00287C287C280000, // '#' {0x00, 0x28, 0x7C, 0x28, 0x7C, 0x28, 0x00, 0x00}, // '#'
0x081E281C0A3C0800, // '$' {0x08, 0x1E, 0x28, 0x1C, 0x0A, 0x3C, 0x08, 0x00}, // '$'
0x6094681629060000, // '%' {0x60, 0x94, 0x68, 0x16, 0x29, 0x06, 0x00, 0x00}, // '%'
0x1C20201926190000, // '&' {0x1C, 0x20, 0x20, 0x19, 0x26, 0x19, 0x00, 0x00}, // '&'
0x0808000000000000, // ''' {0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '''
0x0810202010080000, // '(' {0x08, 0x10, 0x20, 0x20, 0x10, 0x08, 0x00, 0x00}, // '('
0x1008040408100000, // ')' {0x10, 0x08, 0x04, 0x04, 0x08, 0x10, 0x00, 0x00}, // ')'
0x2A1C3E1C2A000000, // '*' {0x2A, 0x1C, 0x3E, 0x1C, 0x2A, 0x00, 0x00, 0x00}, // '*'
0x0008083E08080000, // '+' {0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00}, // '+'
0x0000000000081000, // ',' {0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x00}, // ','
0x0000003C00000000, // '-' {0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00}, // '-'
0x0000000000080000, // '.' {0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00}, // '.'
0x0204081020400000, // '/' {0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00}, // '/'
{0x18, 0x24, 0x42, 0x42, 0x24, 0x18, 0x00, 0x00}, // '0'
0x1824424224180000, // '0' {0x08, 0x18, 0x08, 0x08, 0x08, 0x1C, 0x00, 0x00}, // '1'
0x08180808081C0000, // '1' {0x3C, 0x42, 0x04, 0x18, 0x20, 0x7E, 0x00, 0x00}, // '2'
0x3C420418207E0000, // '2' {0x3C, 0x42, 0x04, 0x18, 0x42, 0x3C, 0x00, 0x00}, // '3'
0x3C420418423C0000, // '3' {0x08, 0x18, 0x28, 0x48, 0x7C, 0x08, 0x00, 0x00}, // '4'
0x081828487C080000, // '4' {0x7E, 0x40, 0x7C, 0x02, 0x42, 0x3C, 0x00, 0x00}, // '5'
0x7E407C02423C0000, // '5' {0x3C, 0x40, 0x7C, 0x42, 0x42, 0x3C, 0x00, 0x00}, // '6'
0x3C407C42423C0000, // '6' {0x7E, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00}, // '7'
0x7E04081020400000, // '7' {0x3C, 0x42, 0x3C, 0x42, 0x42, 0x3C, 0x00, 0x00}, // '8'
0x3C423C42423C0000, // '8' {0x3C, 0x42, 0x42, 0x3E, 0x02, 0x3C, 0x00, 0x00}, // '9'
0x3C42423E023C0000, // '9' {0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00}, // ':'
0x0000080000080000, // ':' {0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x10, 0x00}, // ';'
0x0000080000081000, // ';' {0x00, 0x06, 0x18, 0x60, 0x18, 0x06, 0x00, 0x00}, // '<'
0x0006186018060000, // '<' {0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00}, // '='
0x00007E007E000000, // '=' {0x00, 0x60, 0x18, 0x06, 0x18, 0x60, 0x00, 0x00}, // '>'
0x0060180618600000, // '>' {0x38, 0x44, 0x04, 0x18, 0x00, 0x10, 0x00, 0x00}, // '?'
0x3844041800100000, // '?' {0x00, 0x3C, 0x44, 0x9C, 0x94, 0x5C, 0x20, 0x1C}, // '@'
{0x18, 0x18, 0x24, 0x3C, 0x42, 0x42, 0x00, 0x00}, // 'A'
0x003C449C945C201C, // '@' {0x78, 0x44, 0x78, 0x44, 0x44, 0x78, 0x00, 0x00}, // 'B'
0x1818243C42420000, // 'A' {0x38, 0x44, 0x80, 0x80, 0x44, 0x38, 0x00, 0x00}, // 'C'
0x7844784444780000, // 'B' {0x78, 0x44, 0x44, 0x44, 0x44, 0x78, 0x00, 0x00}, // 'D'
0x3844808044380000, // 'C' {0x7C, 0x40, 0x78, 0x40, 0x40, 0x7C, 0x00, 0x00}, // 'E'
0x7844444444780000, // 'D' {0x7C, 0x40, 0x78, 0x40, 0x40, 0x40, 0x00, 0x00}, // 'F'
0x7C407840407C0000, // 'E' {0x38, 0x44, 0x80, 0x9C, 0x44, 0x38, 0x00, 0x00}, // 'G'
0x7C40784040400000, // 'F' {0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x00, 0x00}, // 'H'
0x3844809C44380000, // 'G' {0x3E, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00}, // 'I'
0x42427E4242420000, // 'H' {0x1C, 0x04, 0x04, 0x04, 0x44, 0x38, 0x00, 0x00}, // 'J'
0x3E080808083E0000, // 'I' {0x44, 0x48, 0x50, 0x70, 0x48, 0x44, 0x00, 0x00}, // 'K'
0x1C04040444380000, // 'J' {0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00, 0x00}, // 'L'
0x4448507048440000, // 'K' {0x41, 0x63, 0x55, 0x49, 0x41, 0x41, 0x00, 0x00}, // 'M'
0x40404040407E0000, // 'L' {0x42, 0x62, 0x52, 0x4A, 0x46, 0x42, 0x00, 0x00}, // 'N'
0x4163554941410000, // 'M' {0x1C, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x00}, // 'O'
0x4262524A46420000, // 'N' {0x78, 0x44, 0x78, 0x40, 0x40, 0x40, 0x00, 0x00}, // 'P'
0x1C222222221C0000, // 'O' {0x1C, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x02, 0x00}, // 'Q'
{0x78, 0x44, 0x78, 0x50, 0x48, 0x44, 0x00, 0x00}, // 'R'
0x7844784040400000, // 'P' {0x1C, 0x22, 0x10, 0x0C, 0x22, 0x1C, 0x00, 0x00}, // 'S'
0x1C222222221C0200, // 'Q' {0x7F, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00}, // 'T'
0x7844785048440000, // 'R' {0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00}, // 'U'
0x1C22100C221C0000, // 'S' {0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x00, 0x00}, // 'V'
0x7F08080808080000, // 'T' {0x41, 0x41, 0x49, 0x55, 0x63, 0x41, 0x00, 0x00}, // 'W'
0x42424242423C0000, // 'U' {0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x00, 0x00}, // 'X'
0x8142422424180000, // 'V' {0x41, 0x22, 0x14, 0x08, 0x08, 0x08, 0x00, 0x00}, // 'Y'
0x4141495563410000, // 'W' {0x7E, 0x04, 0x08, 0x10, 0x20, 0x7E, 0x00, 0x00}, // 'Z'
0x4224181824420000, // 'X' {0x38, 0x20, 0x20, 0x20, 0x20, 0x38, 0x00, 0x00}, // '['
0x4122140808080000, // 'Y' {0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00}, // '\'
0x7E040810207E0000, // 'Z' {0x38, 0x08, 0x08, 0x08, 0x08, 0x38, 0x00, 0x00}, // ']'
0x3820202020380000, // '[' {0x10, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '^'
0x4020100804020000, // '\' {0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00}, // '_'
0x3808080808380000, // ']' {0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '`'
0x1028000000000000, // '^' {0x00, 0x3C, 0x02, 0x3E, 0x46, 0x3A, 0x00, 0x00}, // 'a'
0x00000000007E0000, // '_' {0x40, 0x40, 0x7C, 0x42, 0x62, 0x5C, 0x00, 0x00}, // 'b'
{0x00, 0x00, 0x1C, 0x20, 0x20, 0x1C, 0x00, 0x00}, // 'c'
0x1008000000000000, // '`' {0x02, 0x02, 0x3E, 0x42, 0x46, 0x3A, 0x00, 0x00}, // 'd'
0x003C023E463A0000, // 'a' {0x00, 0x3C, 0x42, 0x7E, 0x40, 0x3C, 0x00, 0x00}, // 'e'
0x40407C42625C0000, // 'b' {0x00, 0x18, 0x10, 0x38, 0x10, 0x10, 0x00, 0x00}, // 'f'
0x00001C20201C0000, // 'c' {0x00, 0x00, 0x34, 0x4C, 0x44, 0x34, 0x04, 0x38}, // 'g'
0x02023E42463A0000, // 'd' {0x20, 0x20, 0x38, 0x24, 0x24, 0x24, 0x00, 0x00}, // 'h'
0x003C427E403C0000, // 'e' {0x08, 0x00, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00}, // 'i'
0x0018103810100000, // 'f' {0x08, 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x70}, // 'j'
0x0000344C44340438, // 'g' {0x20, 0x20, 0x24, 0x28, 0x30, 0x2C, 0x00, 0x00}, // 'k'
0x2020382424240000, // 'h' {0x10, 0x10, 0x10, 0x10, 0x10, 0x18, 0x00, 0x00}, // 'l'
0x0800080808080000, // 'i' {0x00, 0x00, 0x66, 0x5A, 0x42, 0x42, 0x00, 0x00}, // 'm'
0x0800180808080870, // 'j' {0x00, 0x00, 0x2E, 0x32, 0x22, 0x22, 0x00, 0x00}, // 'n'
0x20202428302C0000, // 'k' {0x00, 0x00, 0x3C, 0x42, 0x42, 0x3C, 0x00, 0x00}, // 'o'
0x1010101010180000, // 'l' {0x00, 0x00, 0x5C, 0x62, 0x42, 0x7C, 0x40, 0x40}, // 'p'
0x0000665A42420000, // 'm' {0x00, 0x00, 0x3A, 0x46, 0x42, 0x3E, 0x02, 0x02}, // 'q'
0x00002E3222220000, // 'n' {0x00, 0x00, 0x2C, 0x32, 0x20, 0x20, 0x00, 0x00}, // 'r'
0x00003C42423C0000, // 'o' {0x00, 0x1C, 0x20, 0x18, 0x04, 0x38, 0x00, 0x00}, // 's'
{0x00, 0x10, 0x3C, 0x10, 0x10, 0x18, 0x00, 0x00}, // 't'
0x00005C62427C4040, // 'p' {0x00, 0x00, 0x22, 0x22, 0x26, 0x1A, 0x00, 0x00}, // 'u'
0x00003A46423E0202, // 'q' {0x00, 0x00, 0x42, 0x42, 0x24, 0x18, 0x00, 0x00}, // 'v'
0x00002C3220200000, // 'r' {0x00, 0x00, 0x81, 0x81, 0x5A, 0x66, 0x00, 0x00}, // 'w'
0x001C201804380000, // 's' {0x00, 0x00, 0x42, 0x24, 0x18, 0x66, 0x00, 0x00}, // 'x'
0x00103C1010180000, // 't' {0x00, 0x00, 0x42, 0x22, 0x14, 0x08, 0x10, 0x60}, // 'y'
0x00002222261A0000, // 'u' {0x00, 0x00, 0x3C, 0x08, 0x10, 0x3C, 0x00, 0x00}, // 'z'
0x0000424224180000, // 'v' {0x1C, 0x10, 0x30, 0x30, 0x10, 0x1C, 0x00, 0x00}, // '{'
0x000081815A660000, // 'w' {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00}, // '|'
0x0000422418660000, // 'x' {0x38, 0x08, 0x0C, 0x0C, 0x08, 0x38, 0x00, 0x00}, // '}'
0x0000422214081060, // 'y' {0x00, 0x00, 0x00, 0x32, 0x4C, 0x00, 0x00, 0x00} // '~'
0x00003C08103C0000, // 'z'
0x1C103030101C0000, // '{'
0x0808080808080800, // '|'
0x38080C0C08380000, // '}'
0x000000324C000000, // '~'
0x7E7E7E7E7E7E0000 // 'DEL'
}; };
*/ */
const uint8_t gFont5x8[95][5] =
const uint8_t gFont6x8[96][6] =
{ {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, {0x00, 0x00, 0x00, 0x00, 0x00},
{ 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00 }, {0x00, 0x00, 0x5F, 0x00, 0x00},
{ 0x00, 0x07, 0x00, 0x07, 0x00, 0x00 }, {0x00, 0x07, 0x00, 0x07, 0x00},
{ 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00 }, {0x14, 0x7F, 0x14, 0x7F, 0x14},
{ 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00 }, {0x24, 0x2A, 0x7F, 0x2A, 0x12},
{ 0x23, 0x13, 0x08, 0x64, 0x62, 0x00 }, {0x23, 0x13, 0x08, 0x64, 0x62},
{ 0x36, 0x49, 0x56, 0x20, 0x50, 0x00 }, {0x36, 0x49, 0x56, 0x20, 0x50},
{ 0x00, 0x08, 0x07, 0x03, 0x00, 0x00 }, {0x00, 0x08, 0x07, 0x03, 0x00},
{ 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00 }, {0x00, 0x1C, 0x22, 0x41, 0x00},
{ 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00 }, {0x00, 0x41, 0x22, 0x1C, 0x00},
{ 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00 }, {0x2A, 0x1C, 0x7F, 0x1C, 0x2A},
{ 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00 }, {0x08, 0x08, 0x3E, 0x08, 0x08},
{ 0x00, 0x80, 0x70, 0x30, 0x00, 0x00 }, {0x00, 0x80, 0x70, 0x30, 0x00},
{ 0x08, 0x08, 0x08, 0x08, 0x08, 0x00 }, {0x08, 0x08, 0x08, 0x08, 0x08},
{ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 }, {0x00, 0x00, 0x60, 0x60, 0x00},
{ 0x20, 0x10, 0x08, 0x04, 0x02, 0x00 }, {0x20, 0x10, 0x08, 0x04, 0x02},
//{ 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00 }, {0x3E, 0x41, 0x41, 0x41, 0x3E},
{ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00 }, {0x00, 0x42, 0x7F, 0x40, 0x00},
{ 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00 }, {0x72, 0x49, 0x49, 0x49, 0x46},
{ 0x72, 0x49, 0x49, 0x49, 0x46, 0x00 }, {0x21, 0x41, 0x49, 0x4D, 0x33},
{ 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00 }, {0x18, 0x14, 0x12, 0x7F, 0x10},
{ 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00 }, {0x27, 0x45, 0x45, 0x45, 0x39},
{ 0x27, 0x45, 0x45, 0x45, 0x39, 0x00 }, {0x3C, 0x4A, 0x49, 0x49, 0x31},
{ 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00 }, {0x41, 0x21, 0x11, 0x09, 0x07},
{ 0x41, 0x21, 0x11, 0x09, 0x07, 0x00 }, {0x36, 0x49, 0x49, 0x49, 0x36},
{ 0x36, 0x49, 0x49, 0x49, 0x36, 0x00 }, {0x46, 0x49, 0x49, 0x29, 0x1E},
{ 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00 }, {0x00, 0x00, 0x14, 0x00, 0x00},
{ 0x00, 0x00, 0x14, 0x00, 0x00, 0x00 }, {0x00, 0x40, 0x34, 0x00, 0x00},
{ 0x00, 0x40, 0x34, 0x00, 0x00, 0x00 }, {0x00, 0x08, 0x14, 0x22, 0x41},
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 }, {0x14, 0x14, 0x14, 0x14, 0x14},
{ 0x14, 0x14, 0x14, 0x14, 0x14, 0x00 }, {0x00, 0x41, 0x22, 0x14, 0x08},
{ 0x00, 0x41, 0x22, 0x14, 0x08, 0x00 }, {0x02, 0x01, 0x59, 0x09, 0x06},
{ 0x02, 0x01, 0x59, 0x09, 0x06, 0x00 },
{ 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00 }, {0x3E, 0x41, 0x5D, 0x59, 0x4E},
{ 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00 }, {0x7C, 0x12, 0x11, 0x12, 0x7C},
{ 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00 }, {0x7F, 0x49, 0x49, 0x49, 0x36},
{ 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00 }, {0x3E, 0x41, 0x41, 0x41, 0x22},
{ 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00 }, {0x7F, 0x41, 0x41, 0x41, 0x3E},
{ 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00 }, {0x7F, 0x49, 0x49, 0x49, 0x41},
{ 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00 }, {0x7F, 0x09, 0x09, 0x09, 0x01},
{ 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00 }, {0x3E, 0x41, 0x41, 0x51, 0x73},
{ 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00 }, {0x7F, 0x08, 0x08, 0x08, 0x7F},
{ 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00 }, {0x00, 0x41, 0x7F, 0x41, 0x00},
{ 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00 }, {0x20, 0x40, 0x41, 0x3F, 0x01},
{ 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00 }, {0x7F, 0x08, 0x14, 0x22, 0x41},
{ 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00 }, {0x7F, 0x40, 0x40, 0x40, 0x40},
{ 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00 }, {0x7F, 0x02, 0x1C, 0x02, 0x7F},
{ 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00 }, {0x7F, 0x04, 0x08, 0x10, 0x7F},
{ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00 }, {0x3E, 0x41, 0x41, 0x41, 0x3E},
{ 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00 }, {0x7F, 0x09, 0x09, 0x09, 0x06},
{ 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00 }, {0x3E, 0x41, 0x51, 0x21, 0x5E},
{ 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00 }, {0x7F, 0x09, 0x19, 0x29, 0x46},
{ 0x26, 0x49, 0x49, 0x49, 0x32, 0x00 }, {0x26, 0x49, 0x49, 0x49, 0x32},
{ 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00 }, {0x03, 0x01, 0x7F, 0x01, 0x03},
{ 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00 }, {0x3F, 0x40, 0x40, 0x40, 0x3F},
{ 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00 }, {0x1F, 0x20, 0x40, 0x20, 0x1F},
{ 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00 }, {0x3F, 0x40, 0x38, 0x40, 0x3F},
{ 0x63, 0x14, 0x08, 0x14, 0x63, 0x00 }, {0x63, 0x14, 0x08, 0x14, 0x63},
{ 0x03, 0x04, 0x78, 0x04, 0x03, 0x00 }, {0x03, 0x04, 0x78, 0x04, 0x03},
{ 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00 }, {0x61, 0x59, 0x49, 0x4D, 0x43},
{ 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00 }, {0x00, 0x7F, 0x41, 0x41, 0x41},
{ 0x02, 0x04, 0x08, 0x10, 0x20, 0x00 }, {0x02, 0x04, 0x08, 0x10, 0x20},
{ 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00 }, {0x00, 0x41, 0x41, 0x41, 0x7F},
{ 0x04, 0x02, 0x01, 0x02, 0x04, 0x00 }, {0x04, 0x02, 0x01, 0x02, 0x04},
{ 0x40, 0x40, 0x40, 0x40, 0x40, 0x00 }, {0x40, 0x40, 0x40, 0x40, 0x40},
{ 0x00, 0x03, 0x07, 0x08, 0x00, 0x00 }, {0x00, 0x03, 0x07, 0x08, 0x00},
{ 0x20, 0x54, 0x54, 0x78, 0x40, 0x00 }, {0x20, 0x54, 0x54, 0x78, 0x40},
{ 0x7F, 0x28, 0x44, 0x44, 0x38, 0x00 }, {0x7F, 0x28, 0x44, 0x44, 0x38},
{ 0x38, 0x44, 0x44, 0x44, 0x28, 0x00 }, {0x38, 0x44, 0x44, 0x44, 0x28},
{ 0x38, 0x44, 0x44, 0x28, 0x7F, 0x00 }, {0x38, 0x44, 0x44, 0x28, 0x7F},
{ 0x38, 0x54, 0x54, 0x54, 0x18, 0x00 }, {0x38, 0x54, 0x54, 0x54, 0x18},
{ 0x00, 0x08, 0x7E, 0x09, 0x02, 0x00 }, {0x00, 0x08, 0x7E, 0x09, 0x02},
{ 0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00 }, {0x18, 0xA4, 0xA4, 0x9C, 0x78},
{ 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00 }, {0x7F, 0x08, 0x04, 0x04, 0x78},
{ 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00 }, {0x00, 0x44, 0x7D, 0x40, 0x00},
{ 0x20, 0x40, 0x40, 0x3D, 0x00, 0x00 }, {0x20, 0x40, 0x40, 0x3D, 0x00},
{ 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00 }, {0x7F, 0x10, 0x28, 0x44, 0x00},
{ 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00 }, {0x00, 0x41, 0x7F, 0x40, 0x00},
{ 0x7C, 0x04, 0x78, 0x04, 0x78, 0x00 }, {0x7C, 0x04, 0x78, 0x04, 0x78},
{ 0x7C, 0x08, 0x04, 0x04, 0x78, 0x00 }, {0x7C, 0x08, 0x04, 0x04, 0x78},
{ 0x38, 0x44, 0x44, 0x44, 0x38, 0x00 }, {0x38, 0x44, 0x44, 0x44, 0x38},
{ 0xFC, 0x18, 0x24, 0x24, 0x18, 0x00 }, {0xFC, 0x18, 0x24, 0x24, 0x18},
{ 0x18, 0x24, 0x24, 0x18, 0xFC, 0x00 }, {0x18, 0x24, 0x24, 0x18, 0xFC},
{ 0x7C, 0x08, 0x04, 0x04, 0x08, 0x00 }, {0x7C, 0x08, 0x04, 0x04, 0x08},
{ 0x48, 0x54, 0x54, 0x54, 0x24, 0x00 }, {0x48, 0x54, 0x54, 0x54, 0x24},
{ 0x04, 0x04, 0x3F, 0x44, 0x24, 0x00 }, {0x04, 0x04, 0x3F, 0x44, 0x24},
{ 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00 }, {0x3C, 0x40, 0x40, 0x20, 0x7C},
{ 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00 }, {0x1C, 0x20, 0x40, 0x20, 0x1C},
{ 0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00 }, {0x3C, 0x40, 0x30, 0x40, 0x3C},
{ 0x44, 0x28, 0x10, 0x28, 0x44, 0x00 }, {0x44, 0x28, 0x10, 0x28, 0x44},
{ 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00 }, {0x4C, 0x90, 0x90, 0x90, 0x7C},
{ 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00 }, {0x44, 0x64, 0x54, 0x4C, 0x44},
{ 0x00, 0x08, 0x36, 0x41, 0x00, 0x00 }, {0x00, 0x08, 0x36, 0x41, 0x00},
{ 0x00, 0x00, 0x77, 0x00, 0x00, 0x00 }, {0x00, 0x00, 0x77, 0x00, 0x00},
{ 0x00, 0x41, 0x36, 0x08, 0x00, 0x00 }, {0x00, 0x41, 0x36, 0x08, 0x00},
{ 0x02, 0x01, 0x02, 0x04, 0x02, 0x00 }, {0x02, 0x01, 0x02, 0x04, 0x02}
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }
}; };
/* /*
// ASCII 5x7 font // ASCII 5x7 font
@ -374,7 +368,6 @@ const uint8_t gFont5x7[96][5] =
{0x00, 0x00, 0x60, 0x60, 0x00}, {0x00, 0x00, 0x60, 0x60, 0x00},
{0x20, 0x10, 0x08, 0x04, 0x02}, {0x20, 0x10, 0x08, 0x04, 0x02},
// {0x3E, 0x51, 0x49, 0x45, 0x3E}, // '0'
{0x3E, 0x41, 0x41, 0x41, 0x3E}, // '0' {0x3E, 0x41, 0x41, 0x41, 0x3E}, // '0'
{0x00, 0x42, 0x7F, 0x40, 0x00}, {0x00, 0x42, 0x7F, 0x40, 0x00},
{0x72, 0x49, 0x49, 0x49, 0x46}, {0x72, 0x49, 0x49, 0x49, 0x46},

4
font.h
View File

@ -23,8 +23,8 @@ extern const uint8_t gFontBig[95][16];
extern const uint8_t gFontBigDigits[11][26]; extern const uint8_t gFontBigDigits[11][26];
extern const uint8_t gFontSmallDigits[11][7]; extern const uint8_t gFontSmallDigits[11][7];
//extern const uint64_t gFont8x8[16 * 6]; //extern const uint8_t gFont8x8[95][8];
extern const uint8_t gFont6x8[96][6]; extern const uint8_t gFont5x8[95][5];
//extern const uint8_t gFont5x7[96][5]; //extern const uint8_t gFont5x7[96][5];
#endif #endif

71
radio.c
View File

@ -116,7 +116,7 @@ void RADIO_InitInfo(VFO_Info_t *pInfo, uint8_t ChannelSave, uint8_t Band, uint32
pInfo->Band = Band; pInfo->Band = Band;
pInfo->SCANLIST1_PARTICIPATION = true; pInfo->SCANLIST1_PARTICIPATION = true;
pInfo->SCANLIST2_PARTICIPATION = true; pInfo->SCANLIST2_PARTICIPATION = true;
pInfo->STEP_SETTING = STEP_25_0kHz; pInfo->STEP_SETTING = STEP_12_5kHz; // STEP_25_0kHz;
pInfo->StepFrequency = 2500; pInfo->StepFrequency = 2500;
pInfo->CHANNEL_SAVE = ChannelSave; pInfo->CHANNEL_SAVE = ChannelSave;
pInfo->FrequencyReverse = false; pInfo->FrequencyReverse = false;
@ -137,8 +137,6 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
uint8_t Band; uint8_t Band;
bool bParticipation2; bool bParticipation2;
uint16_t Base; uint16_t Base;
uint8_t Data[8];
uint8_t Tmp;
uint32_t Frequency; uint32_t Frequency;
VFO_Info_t *pRadio = &gEeprom.VfoInfo[VFO]; VFO_Info_t *pRadio = &gEeprom.VfoInfo[VFO];
@ -199,8 +197,8 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
} }
Index = Channel - FREQ_CHANNEL_FIRST; Index = Channel - FREQ_CHANNEL_FIRST;
RADIO_InitInfo(pRadio, Channel, Index, gLowerLimitFrequencyBandTable[Index]);
RADIO_InitInfo(pRadio, Channel, Index, gLowerLimitFrequencyBandTable[Index]);
return; return;
} }
@ -232,27 +230,28 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
if (Arg == 2 || Channel >= FREQ_CHANNEL_FIRST) if (Arg == 2 || Channel >= FREQ_CHANNEL_FIRST)
{ {
EEPROM_ReadBuffer(Base + 8, Data, 8); uint8_t Tmp;
uint8_t Data[8];
EEPROM_ReadBuffer(Base + 8, Data, sizeof(Data));
Tmp = Data[3] & 0x0F; Tmp = Data[3] & 0x0F;
if (Tmp > 2) if (Tmp > 2)
Tmp = 0; Tmp = 0;
gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = Tmp; gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = Tmp;
gEeprom.VfoInfo[VFO].AM_CHANNEL_MODE = !!(Data[3] & 0x10); gEeprom.VfoInfo[VFO].AM_CHANNEL_MODE = !!(Data[3] & 0x10);
Tmp = Data[6]; Tmp = Data[6];
if (Tmp > STEP_8_33kHz) if (Tmp > STEP_8_33kHz)
Tmp = STEP_25_0kHz; Tmp = STEP_25_0kHz;
gEeprom.VfoInfo[VFO].STEP_SETTING = Tmp; gEeprom.VfoInfo[VFO].STEP_SETTING = Tmp;
gEeprom.VfoInfo[VFO].StepFrequency = StepFrequencyTable[Tmp]; gEeprom.VfoInfo[VFO].StepFrequency = StepFrequencyTable[Tmp];
Tmp = Data[7]; Tmp = Data[7];
if (Tmp > 10) if (Tmp > 10)
Tmp = 0; Tmp = 0;
gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE = Tmp; gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE = Tmp;
gEeprom.VfoInfo[VFO].ConfigRX.CodeType = (Data[2] >> 0) & 0x0F; gEeprom.VfoInfo[VFO].ConfigRX.CodeType = (Data[2] >> 0) & 0x0F;
gEeprom.VfoInfo[VFO].ConfigTX.CodeType = (Data[2] >> 4) & 0x0F; gEeprom.VfoInfo[VFO].ConfigTX.CodeType = (Data[2] >> 4) & 0x0F;
@ -307,10 +306,11 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
} }
else else
{ {
gEeprom.VfoInfo[VFO].FrequencyReverse = !!(Data[4] & 1u); const uint8_t d4 = Data[4];
gEeprom.VfoInfo[VFO].CHANNEL_BANDWIDTH = !!(Data[4] & 2u); gEeprom.VfoInfo[VFO].FrequencyReverse = !!(d4 & 0x01);
gEeprom.VfoInfo[VFO].OUTPUT_POWER = (Data[4] >> 2) & 3u; gEeprom.VfoInfo[VFO].CHANNEL_BANDWIDTH = !!(d4 & 0x02);
gEeprom.VfoInfo[VFO].BUSY_CHANNEL_LOCK = !!(Data[4] & 0x10); gEeprom.VfoInfo[VFO].OUTPUT_POWER = (d4 >> 2) & 0x03;
gEeprom.VfoInfo[VFO].BUSY_CHANNEL_LOCK = !!(d4 & 0x10);
} }
if (Data[5] == 0xFF) if (Data[5] == 0xFF)
@ -320,17 +320,17 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
} }
else else
{ {
gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = !!(Data[5] & 1u); gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = !!(Data[5] & 0x01);
gEeprom.VfoInfo[VFO].DTMF_PTT_ID_TX_MODE = (Data[5] >> 1) & 3u; gEeprom.VfoInfo[VFO].DTMF_PTT_ID_TX_MODE = (Data[5] >> 1) & 0x03;
} }
struct struct
{ {
uint32_t Frequency; uint32_t Frequency;
uint32_t Offset; uint32_t Offset;
} Info; } __attribute__((packed)) Info;
EEPROM_ReadBuffer(Base, &Info, 8); EEPROM_ReadBuffer(Base, &Info, sizeof(Info));
pRadio->ConfigRX.Frequency = Info.Frequency; pRadio->ConfigRX.Frequency = Info.Frequency;
@ -341,24 +341,23 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
} }
Frequency = pRadio->ConfigRX.Frequency; Frequency = pRadio->ConfigRX.Frequency;
// TODO: FIX-ME !!!
if (Frequency < gLowerLimitFrequencyBandTable[Band]) if (Frequency < gLowerLimitFrequencyBandTable[Band])
pRadio->ConfigRX.Frequency = gLowerLimitFrequencyBandTable[Band]; Frequency = gLowerLimitFrequencyBandTable[Band];
else else
if (Frequency > gUpperLimitFrequencyBandTable[Band]) if (Frequency > gUpperLimitFrequencyBandTable[Band])
pRadio->ConfigRX.Frequency = gUpperLimitFrequencyBandTable[Band]; Frequency = gUpperLimitFrequencyBandTable[Band];
else else
if (Channel >= FREQ_CHANNEL_FIRST) if (Channel >= FREQ_CHANNEL_FIRST)
pRadio->ConfigRX.Frequency = FREQUENCY_FloorToStep(pRadio->ConfigRX.Frequency, gEeprom.VfoInfo[VFO].StepFrequency, gLowerLimitFrequencyBandTable[Band]); Frequency = FREQUENCY_FloorToStep(Frequency, gEeprom.VfoInfo[VFO].StepFrequency, gLowerLimitFrequencyBandTable[Band]);
pRadio->ConfigRX.Frequency = Frequency; pRadio->ConfigRX.Frequency = Frequency;
if (Frequency >= 10800000 && Frequency < 13600000) if (Frequency >= 10800000 && Frequency < 13600000)
gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = FREQUENCY_DEVIATION_OFF; gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = FREQUENCY_DEVIATION_OFF;
else else
if (!IS_MR_CHANNEL(Channel)) if (!IS_MR_CHANNEL(Channel))
{ gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION = FREQUENCY_FloorToStep(gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION, gEeprom.VfoInfo[VFO].StepFrequency, 0);
Frequency = FREQUENCY_FloorToStep(gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION, gEeprom.VfoInfo[VFO].StepFrequency, 0);
gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION = Frequency;
}
RADIO_ApplyOffset(pRadio); RADIO_ApplyOffset(pRadio);
@ -466,6 +465,7 @@ void RADIO_ApplyOffset(VFO_Info_t *pInfo)
break; break;
} }
// limit to 50MHz to 600MHz
if (Frequency < 5000000) if (Frequency < 5000000)
Frequency = 5000000; Frequency = 5000000;
else else
@ -494,13 +494,12 @@ void RADIO_SelectVfos(void)
if (gEeprom.DUAL_WATCH == DUAL_WATCH_CHAN_A) if (gEeprom.DUAL_WATCH == DUAL_WATCH_CHAN_A)
gEeprom.TX_CHANNEL = 0; gEeprom.TX_CHANNEL = 0;
gTxVfo = &gEeprom.VfoInfo[gEeprom.TX_CHANNEL];
if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF)
gEeprom.RX_CHANNEL = gEeprom.TX_CHANNEL; gEeprom.RX_CHANNEL = gEeprom.TX_CHANNEL;
else else
gEeprom.RX_CHANNEL = (gEeprom.TX_CHANNEL == 0) ? 1 : 0; gEeprom.RX_CHANNEL = (gEeprom.TX_CHANNEL == 0) ? 1 : 0;
gTxVfo = &gEeprom.VfoInfo[gEeprom.TX_CHANNEL];
gRxVfo = &gEeprom.VfoInfo[gEeprom.RX_CHANNEL]; gRxVfo = &gEeprom.VfoInfo[gEeprom.RX_CHANNEL];
RADIO_SelectCurrentVfo(); RADIO_SelectCurrentVfo();
@ -509,11 +508,11 @@ void RADIO_SelectVfos(void)
void RADIO_SetupRegisters(bool bSwitchToFunction0) void RADIO_SetupRegisters(bool bSwitchToFunction0)
{ {
BK4819_FilterBandwidth_t Bandwidth; BK4819_FilterBandwidth_t Bandwidth;
uint16_t Status;
uint16_t InterruptMask; uint16_t InterruptMask;
uint32_t Frequency; uint32_t Frequency;
GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_AUDIO_PATH); GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_AUDIO_PATH);
gEnableSpeaker = false; gEnableSpeaker = false;
BK4819_ToggleGpioOut(BK4819_GPIO0_PIN28_GREEN, false); BK4819_ToggleGpioOut(BK4819_GPIO0_PIN28_GREEN, false);
@ -521,17 +520,18 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
Bandwidth = gRxVfo->CHANNEL_BANDWIDTH; Bandwidth = gRxVfo->CHANNEL_BANDWIDTH;
if (Bandwidth != BK4819_FILTER_BW_WIDE) if (Bandwidth != BK4819_FILTER_BW_WIDE)
Bandwidth = BK4819_FILTER_BW_NARROW; Bandwidth = BK4819_FILTER_BW_NARROW;
BK4819_SetFilterBandwidth(Bandwidth); BK4819_SetFilterBandwidth(Bandwidth);
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_RED, false); BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_RED, false);
BK4819_SetupPowerAmplifier(0, 0); BK4819_SetupPowerAmplifier(0, 0);
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1, false); BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1, false);
while (1) while (1)
{ {
Status = BK4819_ReadRegister(BK4819_REG_0C); const uint16_t Status = BK4819_ReadRegister(BK4819_REG_0C);
if ((Status & 1U) == 0) // INTERRUPT REQUEST if ((Status & 1u) == 0) // INTERRUPT REQUEST
break; break;
BK4819_WriteRegister(BK4819_REG_02, 0); BK4819_WriteRegister(BK4819_REG_02, 0);
@ -559,8 +559,12 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
gRxVfo->SquelchCloseNoiseThresh, gRxVfo->SquelchCloseNoiseThresh,
gRxVfo->SquelchCloseGlitchThresh, gRxVfo->SquelchCloseGlitchThresh,
gRxVfo->SquelchOpenGlitchThresh); gRxVfo->SquelchOpenGlitchThresh);
BK4819_PickRXFilterPathBasedOnFrequency(Frequency); BK4819_PickRXFilterPathBasedOnFrequency(Frequency);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2, true); BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2, true);
// AF Rx Gain and DAC
BK4819_WriteRegister(BK4819_REG_48, 0xB3A8); BK4819_WriteRegister(BK4819_REG_48, 0xB3A8);
InterruptMask = 0 | BK4819_REG_3F_SQUELCH_FOUND | BK4819_REG_3F_SQUELCH_LOST; InterruptMask = 0 | BK4819_REG_3F_SQUELCH_FOUND | BK4819_REG_3F_SQUELCH_LOST;
@ -571,11 +575,8 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
{ {
if (!gRxVfo->IsAM) if (!gRxVfo->IsAM)
{ {
uint8_t CodeType; uint8_t CodeType = gSelectedCodeType;
uint8_t Code; uint8_t Code = gSelectedCode;
CodeType = gSelectedCodeType;
Code = gSelectedCode;
if (gCssScanMode == CSS_SCAN_MODE_OFF) if (gCssScanMode == CSS_SCAN_MODE_OFF)
{ {
CodeType = gRxVfo->pRX->CodeType; CodeType = gRxVfo->pRX->CodeType;
@ -655,6 +656,8 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
BK4819_EnableDTMF(); BK4819_EnableDTMF();
InterruptMask |= BK4819_REG_3F_DTMF_5TONE_FOUND; InterruptMask |= BK4819_REG_3F_DTMF_5TONE_FOUND;
} }
// enable/disable BK4819 interrupts
BK4819_WriteRegister(BK4819_REG_3F, InterruptMask); BK4819_WriteRegister(BK4819_REG_3F, InterruptMask);
FUNCTION_Init(); FUNCTION_Init();

10
radio.h
View File

@ -48,7 +48,8 @@ enum PTT_ID_t {
typedef enum PTT_ID_t PTT_ID_t; typedef enum PTT_ID_t PTT_ID_t;
#if 0 #if 0
enum STEP_Setting_t { enum STEP_Setting_t
{
STEP_2_5kHz, STEP_2_5kHz,
STEP_5_0kHz, STEP_5_0kHz,
STEP_6_25kHz, STEP_6_25kHz,
@ -58,7 +59,8 @@ typedef enum PTT_ID_t PTT_ID_t;
STEP_8_33kHz, STEP_8_33kHz,
}; };
#else #else
enum STEP_Setting_t { enum STEP_Setting_t
{
STEP_1_25kHz, STEP_1_25kHz,
STEP_2_5kHz, STEP_2_5kHz,
STEP_6_25kHz, STEP_6_25kHz,
@ -71,7 +73,8 @@ typedef enum PTT_ID_t PTT_ID_t;
typedef enum STEP_Setting_t STEP_Setting_t; typedef enum STEP_Setting_t STEP_Setting_t;
enum VfoState_t { enum VfoState_t
{
VFO_STATE_NORMAL = 0, VFO_STATE_NORMAL = 0,
VFO_STATE_BUSY, VFO_STATE_BUSY,
VFO_STATE_BAT_LOW, VFO_STATE_BAT_LOW,
@ -156,4 +159,3 @@ void RADIO_PrepareCssTX(void);
void RADIO_SendEndOfTransmission(void); void RADIO_SendEndOfTransmission(void);
#endif #endif

35
ui/helper.c
View File

@ -92,50 +92,49 @@ void UI_PrintStringSmall(const char *pString, uint8_t Start, uint8_t End, uint8_
#if 0 #if 0
{ // 5x7 font { // 5x7 font
const unsigned int char_width = ARRAY_SIZE(gFont5x7[0]);
const unsigned int char_spacing = char_width + 1;
uint8_t *pFb = gFrameBuffer[Line] + Start;
for (i = 0; i < Length; i++) for (i = 0; i < Length; i++)
{ {
if (pString[i] >= 32) if (pString[i] >= 32)
{ {
const unsigned int Index = ((unsigned int)pString[i] - 32); const unsigned int Index = ((unsigned int)pString[i] - 32);
if (Index < ARRAY_SIZE(gFont5x7)) if (Index < ARRAY_SIZE(gFont5x7))
{ memcpy(pfB + (i * char_spacing), &gFont5x7[Index], char_width);
const unsigned int ofs = (unsigned int)Start + (i * 6);
memcpy(gFrameBuffer[Line] + ofs, &gFont5x7[Index], ARRAY_SIZE(gFont5x7[Index]));
} }
} }
} }
} #elif 1
#else { // 5x8 font
{ // 6x8 font const unsigned int char_width = ARRAY_SIZE(gFont5x8[0]);
const unsigned int char_spacing = char_width + 1;
uint8_t *pFb = gFrameBuffer[Line] + Start;
for (i = 0; i < Length; i++) for (i = 0; i < Length; i++)
{ {
if (pString[i] >= 32) if (pString[i] >= 32)
{ {
const unsigned int Index = (unsigned int)pString[i] - 32; const unsigned int Index = (unsigned int)pString[i] - 32;
if (Index < ARRAY_SIZE(gFont6x8)) if (Index < ARRAY_SIZE(gFont5x8))
{ memcpy(pFb + (i * char_spacing), &gFont5x8[Index], char_width);
const unsigned int ofs = (unsigned int)Start + (i * 7);
memcpy(gFrameBuffer[Line] + ofs, &gFont6x8[Index], ARRAY_SIZE(gFont6x8[Index]));
} }
} }
} }
} #else
/* { // 8x8 font .. not yet working
{ // 8x8 font const unsigned int char_width = ARRAY_SIZE(gFont8x8[0]);
const unsigned int char_spacing = char_width + 1;
uint8_t *pFb = gFrameBuffer[Line] + Start;
for (i = 0; i < Length; i++) for (i = 0; i < Length; i++)
{ {
if (pString[i] >= 32) if (pString[i] >= 32)
{ {
const unsigned int Index = (unsigned int)pString[i] - 32; const unsigned int Index = (unsigned int)pString[i] - 32;
if (Index < ARRAY_SIZE(gFont8x8)) if (Index < ARRAY_SIZE(gFont8x8))
{ memcpy(pFb + (i * char_spacing), &gFont8x8[Index], char_width);
const unsigned int ofs = (unsigned int)Start + (i * 8);
memcpy(gFrameBuffer[Line] + ofs, &gFont8x8[Index], 8);
} }
} }
} }
}
*/
#endif #endif
} }

1
ui/lock.c
View File

@ -15,6 +15,7 @@
*/ */
#include <string.h> #include <string.h>
#include "ARMCM0.h" #include "ARMCM0.h"
#include "app/uart.h" #include "app/uart.h"
#include "audio.h" #include "audio.h"

188
ui/main.c
View File

@ -43,11 +43,13 @@ void UI_DisplayMain(void)
return; return;
} }
//#ifndef SINGLE_VFO_CHAN // #ifdef SINGLE_VFO_CHAN
for (vfo_num = 0; vfo_num < 2; vfo_num++) // const bool single_vfo = (gEeprom.DUAL_WATCH == DUAL_WATCH_OFF && gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? true : false;
// #else // #else
// vfo_num = 0; const bool single_vfo = false;
// #endif // #endif
for (vfo_num = 0; vfo_num < 2; vfo_num++)
{ {
uint8_t Channel = gEeprom.TX_CHANNEL; uint8_t Channel = gEeprom.TX_CHANNEL;
bool bIsSameVfo = !!(Channel == vfo_num); bool bIsSameVfo = !!(Channel == vfo_num);
@ -56,6 +58,16 @@ void UI_DisplayMain(void)
uint8_t *pLine1 = gFrameBuffer[Line + 1]; uint8_t *pLine1 = gFrameBuffer[Line + 1];
uint32_t frequency_Hz = 0; uint32_t frequency_Hz = 0;
if (single_vfo)
{
if (!bIsSameVfo)
continue; // skip the unused vfo .. screen is dedicated to just a single 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)
Channel = gEeprom.RX_CHANNEL; Channel = gEeprom.RX_CHANNEL;
@ -67,73 +79,53 @@ void UI_DisplayMain(void)
if (!gDTMF_InputMode) if (!gDTMF_InputMode)
{ {
memset(Contact, 0, sizeof(Contact));
if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT) if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT)
{ strcpy(String, (gDTMF_State == DTMF_STATE_CALL_OUT_RSP) ? "CALL OUT(RSP)" : "CALL OUT");
if (gDTMF_State == DTMF_STATE_CALL_OUT_RSP)
strcpy(String, "CALL OUT(RSP)");
else
strcpy(String, "CALL OUT");
}
else else
if (gDTMF_CallState == DTMF_CALL_STATE_RECEIVED) if (gDTMF_CallState == DTMF_CALL_STATE_RECEIVED)
{ sprintf(String, "CALL:%s", (DTMF_FindContact(gDTMF_Caller, Contact)) ? Contact : gDTMF_Caller);
if (DTMF_FindContact(gDTMF_Caller, Contact))
sprintf(String, "CALL:%s", Contact);
else
sprintf(String, "CALL:%s", gDTMF_Caller);
}
else else
if (gDTMF_IsTx) if (gDTMF_IsTx)
{ strcpy(String, (gDTMF_State == DTMF_STATE_TX_SUCC) ? "DTMF TX(SUCC)" : "DTMF TX");
if (gDTMF_State == DTMF_STATE_TX_SUCC)
strcpy(String, "DTMF TX(SUCC)");
else
strcpy(String, "DTMF TX");
}
} }
else else
sprintf(String, ">%s", gDTMF_InputBox); sprintf(String, ">%s", gDTMF_InputBox);
UI_PrintString(String, 2, 127, vfo_num * 3, 8, false); UI_PrintString(String, 2, 127, vfo_num * 3, 8, false);
memset(String, 0, sizeof(String)); memset(String, 0, sizeof(String));
memset(Contact, 0, sizeof(Contact));
if (!gDTMF_InputMode) if (!gDTMF_InputMode)
{ {
memset(Contact, 0, sizeof(Contact));
if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT) if (gDTMF_CallState == DTMF_CALL_STATE_CALL_OUT)
{ {
if (DTMF_FindContact(gDTMF_String, Contact)) sprintf(String, ">%s", (DTMF_FindContact(gDTMF_String, Contact)) ? Contact : gDTMF_String);
sprintf(String, ">%s", Contact);
else
sprintf(String, ">%s", gDTMF_String);
} }
else else
if (gDTMF_CallState == DTMF_CALL_STATE_RECEIVED) if (gDTMF_CallState == DTMF_CALL_STATE_RECEIVED)
{ {
if (DTMF_FindContact(gDTMF_Callee, Contact)) sprintf(String, ">%s", (DTMF_FindContact(gDTMF_Callee, Contact)) ? Contact : gDTMF_Callee);
sprintf(String, ">%s", Contact);
else
sprintf(String, ">%s", gDTMF_Callee);
} }
else else
if (gDTMF_IsTx) if (gDTMF_IsTx)
sprintf(String, ">%s", gDTMF_String); sprintf(String, ">%s", gDTMF_String);
} }
UI_PrintString(String, 2, 127, 2 + (vfo_num * 3), 8, false); UI_PrintString(String, 2, 127, 2 + (vfo_num * 3), 8, false);
continue; continue;
} }
if (bIsSameVfo) // highlight the selected/used VFO with a marker
if (!single_vfo && bIsSameVfo)
memcpy(pLine0 + 2, BITMAP_VFO_Default, sizeof(BITMAP_VFO_Default)); memcpy(pLine0 + 2, BITMAP_VFO_Default, sizeof(BITMAP_VFO_Default));
} }
else else
{ if (!single_vfo)
{ // highlight the selected/used VFO with a marker
if (bIsSameVfo) if (bIsSameVfo)
memcpy(pLine0 + 2, BITMAP_VFO_Default, sizeof(BITMAP_VFO_Default)); memcpy(pLine0 + 2, BITMAP_VFO_Default, sizeof(BITMAP_VFO_Default));
else //else
memcpy(pLine0 + 2, BITMAP_VFO_NotDefault, sizeof(BITMAP_VFO_NotDefault)); //memcpy(pLine0 + 2, BITMAP_VFO_NotDefault, sizeof(BITMAP_VFO_NotDefault));
} }
// 0x8EE2 // 0x8EE2
@ -149,29 +141,23 @@ void UI_DisplayMain(void)
else else
#endif #endif
{ {
if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) Channel = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_CHANNEL : gEeprom.TX_CHANNEL;
Channel = gEeprom.RX_CHANNEL;
else
Channel = gEeprom.TX_CHANNEL;
if (Channel == vfo_num) if (Channel == vfo_num)
{ { // show the TX symbol
SomeValue = 1; SomeValue = 1;
memcpy(pLine0 + 14, BITMAP_TX, sizeof(BITMAP_TX)); memcpy(pLine0 + 14, BITMAP_TX, sizeof(BITMAP_TX));
} }
} }
} }
else else
{ { // 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)); memcpy(pLine0 + 14, BITMAP_RX, sizeof(BITMAP_RX));
} }
// 0x8F3C
if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num])) if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
{ { // show the mrmory channel number
memcpy(pLine1 + 2, BITMAP_M, sizeof(BITMAP_M)); memcpy(pLine1 + 2, BITMAP_M, sizeof(BITMAP_M));
if (gInputBoxIndex == 0 || gEeprom.TX_CHANNEL != vfo_num) if (gInputBoxIndex == 0 || gEeprom.TX_CHANNEL != vfo_num)
NUMBER_ToDigits(gEeprom.ScreenChannel[vfo_num] + 1, String); NUMBER_ToDigits(gEeprom.ScreenChannel[vfo_num] + 1, String);
@ -181,7 +167,7 @@ void UI_DisplayMain(void)
} }
else else
if (IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num])) if (IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
{ { // show the frequency band number
char c; char c;
memcpy(pLine1 + 14, BITMAP_F, sizeof(BITMAP_F)); memcpy(pLine1 + 14, BITMAP_F, sizeof(BITMAP_F));
c = (gEeprom.ScreenChannel[vfo_num] - FREQ_CHANNEL_FIRST) + 1; c = (gEeprom.ScreenChannel[vfo_num] - FREQ_CHANNEL_FIRST) + 1;
@ -189,7 +175,9 @@ void UI_DisplayMain(void)
} }
else else
{ {
// show the 'N' narrow band symbol
memcpy(pLine1 + 7, BITMAP_NarrowBand, sizeof(BITMAP_NarrowBand)); memcpy(pLine1 + 7, BITMAP_NarrowBand, sizeof(BITMAP_NarrowBand));
if (gInputBoxIndex == 0 || gEeprom.TX_CHANNEL != vfo_num) if (gInputBoxIndex == 0 || gEeprom.TX_CHANNEL != vfo_num)
{ {
NUMBER_ToDigits((gEeprom.ScreenChannel[vfo_num] - NOAA_CHANNEL_FIRST) + 1, String); NUMBER_ToDigits((gEeprom.ScreenChannel[vfo_num] - NOAA_CHANNEL_FIRST) + 1, String);
@ -209,16 +197,13 @@ void UI_DisplayMain(void)
#ifndef DISABLE_ALARM #ifndef DISABLE_ALARM
if (gCurrentFunction == FUNCTION_TRANSMIT && gAlarmState == ALARM_STATE_ALARM) if (gCurrentFunction == FUNCTION_TRANSMIT && gAlarmState == ALARM_STATE_ALARM)
{ {
if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) Channel = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_CHANNEL : gEeprom.TX_CHANNEL;
Channel = gEeprom.RX_CHANNEL;
else
Channel = gEeprom.TX_CHANNEL;
if (Channel == vfo_num) if (Channel == vfo_num)
State = VFO_STATE_ALARM; State = VFO_STATE_ALARM;
} }
#endif #endif
if (State) if (State != VFO_STATE_NORMAL)
{ {
uint8_t Width = 10; uint8_t Width = 10;
@ -226,23 +211,23 @@ void UI_DisplayMain(void)
switch (State) switch (State)
{ {
case 1: case VFO_STATE_BUSY:
strcpy(String, "BUSY"); strcpy(String, "BUSY");
Width = 15; Width = 15;
break; break;
case 2: case VFO_STATE_BAT_LOW:
strcpy(String, "BAT LOW"); strcpy(String, "BAT LOW");
break; break;
case 3: case VFO_STATE_TX_DISABLE:
strcpy(String, "DISABLE"); strcpy(String, "DISABLE");
break; break;
case 4: case VFO_STATE_TIMEOUT:
strcpy(String, "TIMEOUT"); strcpy(String, "TIMEOUT");
break; break;
case 5: case VFO_STATE_ALARM:
strcpy(String, "ALARM"); strcpy(String, "ALARM");
break; break;
case 6: case VFO_STATE_VOL_HIGH:
sprintf(String, "VOL HIGH"); sprintf(String, "VOL HIGH");
Width = 8; Width = 8;
break; break;
@ -251,7 +236,7 @@ void UI_DisplayMain(void)
UI_PrintString(String, 31, 111, vfo_num * 4, Width, true); UI_PrintString(String, 31, 111, vfo_num * 4, Width, true);
} }
else else
{ { // normal state
if (gInputBoxIndex && IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num]) && gEeprom.TX_CHANNEL == vfo_num) if (gInputBoxIndex && IS_FREQ_CHANNEL(gEeprom.ScreenChannel[vfo_num]) && gEeprom.TX_CHANNEL == vfo_num)
{ {
UI_DisplayFrequency(gInputBox, 31, vfo_num * 4, true, false); UI_DisplayFrequency(gInputBox, 31, vfo_num * 4, true, false);
@ -260,23 +245,17 @@ void UI_DisplayMain(void)
{ {
if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num])) if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
{ {
frequency_Hz = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
if (gCurrentFunction == FUNCTION_TRANSMIT) if (gCurrentFunction == FUNCTION_TRANSMIT)
{ { // transmitting
if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) Channel = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_CHANNEL : gEeprom.TX_CHANNEL;
Channel = gEeprom.RX_CHANNEL;
else
Channel = gEeprom.TX_CHANNEL;
if (Channel == vfo_num) if (Channel == vfo_num)
frequency_Hz = gEeprom.VfoInfo[vfo_num].pTX->Frequency; frequency_Hz = gEeprom.VfoInfo[vfo_num].pTX->Frequency;
else
frequency_Hz = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
} }
else
frequency_Hz = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
switch (gEeprom.CHANNEL_DISPLAY_MODE) switch (gEeprom.CHANNEL_DISPLAY_MODE)
{ {
case MDF_FREQUENCY: case MDF_FREQUENCY: // show the channel frequency
NUMBER_ToDigits(frequency_Hz, String); NUMBER_ToDigits(frequency_Hz, String);
// show the first lot of the frequency digits // show the first lot of the frequency digits
@ -296,13 +275,13 @@ void UI_DisplayMain(void)
frequency_Hz = 0; frequency_Hz = 0;
break; break;
case MDF_CHANNEL: case MDF_CHANNEL: // show the channel number
sprintf(String, "CH-%03d", gEeprom.ScreenChannel[vfo_num] + 1); sprintf(String, "CH-%03d", gEeprom.ScreenChannel[vfo_num] + 1);
UI_PrintString(String, 31, 112, vfo_num * 4, 8, true); UI_PrintString(String, 31, 112, vfo_num * 4, 8, true);
frequency_Hz = 0; frequency_Hz = 0;
break; break;
case MDF_NAME: case MDF_NAME: // show the channel name
if (gEeprom.VfoInfo[vfo_num].Name[0] == 0 || gEeprom.VfoInfo[vfo_num].Name[0] == 0xFF) if (gEeprom.VfoInfo[vfo_num].Name[0] == 0 || gEeprom.VfoInfo[vfo_num].Name[0] == 0xFF)
{ // channel number { // channel number
sprintf(String, "CH-%03d", gEeprom.ScreenChannel[vfo_num] + 1); sprintf(String, "CH-%03d", gEeprom.ScreenChannel[vfo_num] + 1);
@ -316,7 +295,7 @@ void UI_DisplayMain(void)
break; break;
#ifdef CHAN_NAME_FREQ #ifdef CHAN_NAME_FREQ
case MDF_NAME_FREQ: case MDF_NAME_FREQ: // show the channel name and frequency
if (gEeprom.VfoInfo[vfo_num].Name[0] == 0 || gEeprom.VfoInfo[vfo_num].Name[0] == 0xFF) if (gEeprom.VfoInfo[vfo_num].Name[0] == 0 || gEeprom.VfoInfo[vfo_num].Name[0] == 0xFF)
{ // channel number { // channel number
sprintf(String, "CH-%03d", gEeprom.ScreenChannel[vfo_num] + 1); sprintf(String, "CH-%03d", gEeprom.ScreenChannel[vfo_num] + 1);
@ -334,62 +313,61 @@ void UI_DisplayMain(void)
} }
else else
{ {
frequency_Hz = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
if (gCurrentFunction == FUNCTION_TRANSMIT) if (gCurrentFunction == FUNCTION_TRANSMIT)
{ { // transmitting
if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) Channel = (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF) ? gEeprom.RX_CHANNEL : gEeprom.TX_CHANNEL;
Channel = gEeprom.RX_CHANNEL;
else
Channel = gEeprom.TX_CHANNEL;
if (Channel == vfo_num) if (Channel == vfo_num)
frequency_Hz = gEeprom.VfoInfo[vfo_num].pTX->Frequency; frequency_Hz = gEeprom.VfoInfo[vfo_num].pTX->Frequency;
else
frequency_Hz = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
} }
else
frequency_Hz = gEeprom.VfoInfo[vfo_num].pRX->Frequency;
NUMBER_ToDigits(frequency_Hz, String); // 8 digits NUMBER_ToDigits(frequency_Hz, String); // 8 digits
// show main part of frequency
UI_DisplayFrequency(String, 31, vfo_num * 4, false, false); UI_DisplayFrequency(String, 31, vfo_num * 4, false, false);
// show the remaing 2 small frequency digits
UI_DisplaySmallDigits(2, String + 6, 112, Line + 1);
if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num])) if (IS_MR_CHANNEL(gEeprom.ScreenChannel[vfo_num]))
{ {
const uint8_t Attributes = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]]; const uint8_t Attributes = gMR_ChannelAttributes[gEeprom.ScreenChannel[vfo_num]];
if (Attributes & MR_CH_SCANLIST1) if (Attributes & MR_CH_SCANLIST1)
memcpy(pLine0 + 113, BITMAP_ScanList, sizeof(BITMAP_ScanList)); memcpy(pLine0 + 113, BITMAP_ScanList, sizeof(BITMAP_ScanList));
if (Attributes & MR_CH_SCANLIST2) if (Attributes & MR_CH_SCANLIST2)
memcpy(pLine0 + 120, BITMAP_ScanList, sizeof(BITMAP_ScanList)); memcpy(pLine0 + 120, BITMAP_ScanList, sizeof(BITMAP_ScanList));
} }
UI_DisplaySmallDigits(2, String + 6, 112, Line + 1);
frequency_Hz = 0; frequency_Hz = 0;
} }
} }
} }
// 0x926E { // show the TX/RX level
uint8_t Level = 0; uint8_t Level = 0;
if (SomeValue == 1) if (SomeValue == 1)
{ // TX power level
switch (gRxVfo->OUTPUT_POWER)
{ {
if (gRxVfo->OUTPUT_POWER == OUTPUT_POWER_LOW) case OUTPUT_POWER_LOW:
Level = 2; Level = 2;
else break;
if (gRxVfo->OUTPUT_POWER == OUTPUT_POWER_MID) case OUTPUT_POWER_MID:
Level = 4; Level = 4;
else break;
case OUTPUT_POWER_HIGH:
Level = 6; Level = 6;
break;
}
} }
else else
if (SomeValue == 2) if (SomeValue == 2)
{ { // RX signal level
if (gVFO_RSSI_Level[vfo_num]) if (gVFO_RSSI_Level[vfo_num])
Level = gVFO_RSSI_Level[vfo_num]; Level = gVFO_RSSI_Level[vfo_num];
} }
// show TX power level
if (Level >= 1) if (Level >= 1)
{ {
memcpy(pLine1 + 128 + 0, BITMAP_Antenna, sizeof(BITMAP_Antenna)); memcpy(pLine1 + 128 + 0, BITMAP_Antenna, sizeof(BITMAP_Antenna));
@ -405,25 +383,22 @@ void UI_DisplayMain(void)
if (Level >= 6) if (Level >= 6)
memcpy(pLine1 + 128 + 20, BITMAP_AntennaLevel6, sizeof(BITMAP_AntennaLevel6)); memcpy(pLine1 + 128 + 20, BITMAP_AntennaLevel6, sizeof(BITMAP_AntennaLevel6));
} }
}
// 0x931E
if (gEeprom.VfoInfo[vfo_num].IsAM) if (gEeprom.VfoInfo[vfo_num].IsAM)
{ { // show the AM symbol
memcpy(pLine1 + 128 + 27, BITMAP_AM, sizeof(BITMAP_AM)); memcpy(pLine1 + 128 + 27, BITMAP_AM, sizeof(BITMAP_AM));
} }
else else
{ { // show the CTCSS or DCS symbol
const FREQ_Config_t *pConfig; const FREQ_Config_t *pConfig = (SomeValue == 1) ? gEeprom.VfoInfo[vfo_num].pTX : gEeprom.VfoInfo[vfo_num].pRX;
pConfig = (SomeValue == 1) ? gEeprom.VfoInfo[vfo_num].pTX : gEeprom.VfoInfo[vfo_num].pRX;
switch (pConfig->CodeType) switch (pConfig->CodeType)
{ {
case CODE_TYPE_CONTINUOUS_TONE: case CODE_TYPE_CONTINUOUS_TONE: // CTCSS
memcpy(pLine1 + 128 + 27, BITMAP_CT, sizeof(BITMAP_CT)); memcpy(pLine1 + 128 + 27, BITMAP_CT, sizeof(BITMAP_CT));
break; break;
case CODE_TYPE_DIGITAL: case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL: case CODE_TYPE_REVERSE_DIGITAL: // DCS
memcpy(pLine1 + 128 + 24, BITMAP_DCS, sizeof(BITMAP_DCS)); memcpy(pLine1 + 128 + 24, BITMAP_DCS, sizeof(BITMAP_DCS));
break; break;
default: default:
@ -431,9 +406,8 @@ void UI_DisplayMain(void)
} }
} }
// 0x936C
switch (gEeprom.VfoInfo[vfo_num].OUTPUT_POWER) switch (gEeprom.VfoInfo[vfo_num].OUTPUT_POWER)
{ { // show the TX power symbol
case OUTPUT_POWER_LOW: case OUTPUT_POWER_LOW:
memcpy(pLine1 + 128 + 44, BITMAP_PowerLow, sizeof(BITMAP_PowerLow)); memcpy(pLine1 + 128 + 44, BITMAP_PowerLow, sizeof(BITMAP_PowerLow));
break; break;
@ -446,22 +420,26 @@ void UI_DisplayMain(void)
} }
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
if (gEeprom.VfoInfo[vfo_num].FREQUENCY_DEVIATION_SETTING == FREQUENCY_DEVIATION_ADD) if (gEeprom.VfoInfo[vfo_num].FREQUENCY_DEVIATION_SETTING == FREQUENCY_DEVIATION_ADD)
memcpy(pLine1 + 128 + 54, BITMAP_Add, sizeof(BITMAP_Add)); memcpy(pLine1 + 128 + 54, BITMAP_Add, sizeof(BITMAP_Add));
if (gEeprom.VfoInfo[vfo_num].FREQUENCY_DEVIATION_SETTING == FREQUENCY_DEVIATION_SUB) if (gEeprom.VfoInfo[vfo_num].FREQUENCY_DEVIATION_SETTING == FREQUENCY_DEVIATION_SUB)
memcpy(pLine1 + 128 + 54, BITMAP_Sub, sizeof(BITMAP_Sub)); memcpy(pLine1 + 128 + 54, BITMAP_Sub, sizeof(BITMAP_Sub));
} }
// show the TX/RX reverse symbol
if (gEeprom.VfoInfo[vfo_num].FrequencyReverse) if (gEeprom.VfoInfo[vfo_num].FrequencyReverse)
memcpy(pLine1 + 128 + 64, BITMAP_ReverseMode, sizeof(BITMAP_ReverseMode)); memcpy(pLine1 + 128 + 64, BITMAP_ReverseMode, sizeof(BITMAP_ReverseMode));
// 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 + 128 + 74, BITMAP_NarrowBand, sizeof(BITMAP_NarrowBand)); memcpy(pLine1 + 128 + 74, BITMAP_NarrowBand, sizeof(BITMAP_NarrowBand));
// 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 + 128 + 84, BITMAP_DTMF, sizeof(BITMAP_DTMF)); memcpy(pLine1 + 128 + 84, BITMAP_DTMF, sizeof(BITMAP_DTMF));
// 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 + 128 + 110, BITMAP_Scramble, sizeof(BITMAP_Scramble)); memcpy(pLine1 + 128 + 110, BITMAP_Scramble, sizeof(BITMAP_Scramble));