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

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;
}
if (gF_LOCK)
if (Key == KEY_PTT || Key == KEY_SIDE2 || Key == KEY_SIDE1)
if (gF_LOCK && (Key == KEY_PTT || Key == KEY_SIDE2 || Key == KEY_SIDE1))
return;
if (!bFlag)

70
driver/keyboard.c
View File

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

2
driver/keyboard.h
View File

@ -41,7 +41,7 @@ enum KEY_Code_t {
KEY_PTT = 21,
KEY_SIDE2 = 22,
KEY_SIDE1 = 23,
KEY_INVALID = 255,
KEY_INVALID = 255
};
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"
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, 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},
@ -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, 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},
{ 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, 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},
@ -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, 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, 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, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00},
{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, 0x36, 0x49, 0x49, 0x49, 0x49, 0x36},
{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'
0x0808080800080000, // '!'
0x2828000000000000, // '"'
0x00287C287C280000, // '#'
0x081E281C0A3C0800, // '$'
0x6094681629060000, // '%'
0x1C20201926190000, // '&'
0x0808000000000000, // '''
0x0810202010080000, // '('
0x1008040408100000, // ')'
0x2A1C3E1C2A000000, // '*'
0x0008083E08080000, // '+'
0x0000000000081000, // ','
0x0000003C00000000, // '-'
0x0000000000080000, // '.'
0x0204081020400000, // '/'
0x1824424224180000, // '0'
0x08180808081C0000, // '1'
0x3C420418207E0000, // '2'
0x3C420418423C0000, // '3'
0x081828487C080000, // '4'
0x7E407C02423C0000, // '5'
0x3C407C42423C0000, // '6'
0x7E04081020400000, // '7'
0x3C423C42423C0000, // '8'
0x3C42423E023C0000, // '9'
0x0000080000080000, // ':'
0x0000080000081000, // ';'
0x0006186018060000, // '<'
0x00007E007E000000, // '='
0x0060180618600000, // '>'
0x3844041800100000, // '?'
0x003C449C945C201C, // '@'
0x1818243C42420000, // 'A'
0x7844784444780000, // 'B'
0x3844808044380000, // 'C'
0x7844444444780000, // 'D'
0x7C407840407C0000, // 'E'
0x7C40784040400000, // 'F'
0x3844809C44380000, // 'G'
0x42427E4242420000, // 'H'
0x3E080808083E0000, // 'I'
0x1C04040444380000, // 'J'
0x4448507048440000, // 'K'
0x40404040407E0000, // 'L'
0x4163554941410000, // 'M'
0x4262524A46420000, // 'N'
0x1C222222221C0000, // 'O'
0x7844784040400000, // 'P'
0x1C222222221C0200, // 'Q'
0x7844785048440000, // 'R'
0x1C22100C221C0000, // 'S'
0x7F08080808080000, // 'T'
0x42424242423C0000, // 'U'
0x8142422424180000, // 'V'
0x4141495563410000, // 'W'
0x4224181824420000, // 'X'
0x4122140808080000, // 'Y'
0x7E040810207E0000, // 'Z'
0x3820202020380000, // '['
0x4020100804020000, // '\'
0x3808080808380000, // ']'
0x1028000000000000, // '^'
0x00000000007E0000, // '_'
0x1008000000000000, // '`'
0x003C023E463A0000, // 'a'
0x40407C42625C0000, // 'b'
0x00001C20201C0000, // 'c'
0x02023E42463A0000, // 'd'
0x003C427E403C0000, // 'e'
0x0018103810100000, // 'f'
0x0000344C44340438, // 'g'
0x2020382424240000, // 'h'
0x0800080808080000, // 'i'
0x0800180808080870, // 'j'
0x20202428302C0000, // 'k'
0x1010101010180000, // 'l'
0x0000665A42420000, // 'm'
0x00002E3222220000, // 'n'
0x00003C42423C0000, // 'o'
0x00005C62427C4040, // 'p'
0x00003A46423E0202, // 'q'
0x00002C3220200000, // 'r'
0x001C201804380000, // 's'
0x00103C1010180000, // 't'
0x00002222261A0000, // 'u'
0x0000424224180000, // 'v'
0x000081815A660000, // 'w'
0x0000422418660000, // 'x'
0x0000422214081060, // 'y'
0x00003C08103C0000, // 'z'
0x1C103030101C0000, // '{'
0x0808080808080800, // '|'
0x38080C0C08380000, // '}'
0x000000324C000000, // '~'
0x7E7E7E7E7E7E0000 // 'DEL'
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // 'space'
{0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x00, 0x00}, // '!'
{0x28, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '"'
{0x00, 0x28, 0x7C, 0x28, 0x7C, 0x28, 0x00, 0x00}, // '#'
{0x08, 0x1E, 0x28, 0x1C, 0x0A, 0x3C, 0x08, 0x00}, // '$'
{0x60, 0x94, 0x68, 0x16, 0x29, 0x06, 0x00, 0x00}, // '%'
{0x1C, 0x20, 0x20, 0x19, 0x26, 0x19, 0x00, 0x00}, // '&'
{0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '''
{0x08, 0x10, 0x20, 0x20, 0x10, 0x08, 0x00, 0x00}, // '('
{0x10, 0x08, 0x04, 0x04, 0x08, 0x10, 0x00, 0x00}, // ')'
{0x2A, 0x1C, 0x3E, 0x1C, 0x2A, 0x00, 0x00, 0x00}, // '*'
{0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00}, // '+'
{0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x00}, // ','
{0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00}, // '-'
{0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00}, // '.'
{0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00}, // '/'
{0x18, 0x24, 0x42, 0x42, 0x24, 0x18, 0x00, 0x00}, // '0'
{0x08, 0x18, 0x08, 0x08, 0x08, 0x1C, 0x00, 0x00}, // '1'
{0x3C, 0x42, 0x04, 0x18, 0x20, 0x7E, 0x00, 0x00}, // '2'
{0x3C, 0x42, 0x04, 0x18, 0x42, 0x3C, 0x00, 0x00}, // '3'
{0x08, 0x18, 0x28, 0x48, 0x7C, 0x08, 0x00, 0x00}, // '4'
{0x7E, 0x40, 0x7C, 0x02, 0x42, 0x3C, 0x00, 0x00}, // '5'
{0x3C, 0x40, 0x7C, 0x42, 0x42, 0x3C, 0x00, 0x00}, // '6'
{0x7E, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00}, // '7'
{0x3C, 0x42, 0x3C, 0x42, 0x42, 0x3C, 0x00, 0x00}, // '8'
{0x3C, 0x42, 0x42, 0x3E, 0x02, 0x3C, 0x00, 0x00}, // '9'
{0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00}, // ':'
{0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x10, 0x00}, // ';'
{0x00, 0x06, 0x18, 0x60, 0x18, 0x06, 0x00, 0x00}, // '<'
{0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00}, // '='
{0x00, 0x60, 0x18, 0x06, 0x18, 0x60, 0x00, 0x00}, // '>'
{0x38, 0x44, 0x04, 0x18, 0x00, 0x10, 0x00, 0x00}, // '?'
{0x00, 0x3C, 0x44, 0x9C, 0x94, 0x5C, 0x20, 0x1C}, // '@'
{0x18, 0x18, 0x24, 0x3C, 0x42, 0x42, 0x00, 0x00}, // 'A'
{0x78, 0x44, 0x78, 0x44, 0x44, 0x78, 0x00, 0x00}, // 'B'
{0x38, 0x44, 0x80, 0x80, 0x44, 0x38, 0x00, 0x00}, // 'C'
{0x78, 0x44, 0x44, 0x44, 0x44, 0x78, 0x00, 0x00}, // 'D'
{0x7C, 0x40, 0x78, 0x40, 0x40, 0x7C, 0x00, 0x00}, // 'E'
{0x7C, 0x40, 0x78, 0x40, 0x40, 0x40, 0x00, 0x00}, // 'F'
{0x38, 0x44, 0x80, 0x9C, 0x44, 0x38, 0x00, 0x00}, // 'G'
{0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x00, 0x00}, // 'H'
{0x3E, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00}, // 'I'
{0x1C, 0x04, 0x04, 0x04, 0x44, 0x38, 0x00, 0x00}, // 'J'
{0x44, 0x48, 0x50, 0x70, 0x48, 0x44, 0x00, 0x00}, // 'K'
{0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00, 0x00}, // 'L'
{0x41, 0x63, 0x55, 0x49, 0x41, 0x41, 0x00, 0x00}, // 'M'
{0x42, 0x62, 0x52, 0x4A, 0x46, 0x42, 0x00, 0x00}, // 'N'
{0x1C, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x00}, // 'O'
{0x78, 0x44, 0x78, 0x40, 0x40, 0x40, 0x00, 0x00}, // 'P'
{0x1C, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x02, 0x00}, // 'Q'
{0x78, 0x44, 0x78, 0x50, 0x48, 0x44, 0x00, 0x00}, // 'R'
{0x1C, 0x22, 0x10, 0x0C, 0x22, 0x1C, 0x00, 0x00}, // 'S'
{0x7F, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00}, // 'T'
{0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00}, // 'U'
{0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x00, 0x00}, // 'V'
{0x41, 0x41, 0x49, 0x55, 0x63, 0x41, 0x00, 0x00}, // 'W'
{0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x00, 0x00}, // 'X'
{0x41, 0x22, 0x14, 0x08, 0x08, 0x08, 0x00, 0x00}, // 'Y'
{0x7E, 0x04, 0x08, 0x10, 0x20, 0x7E, 0x00, 0x00}, // 'Z'
{0x38, 0x20, 0x20, 0x20, 0x20, 0x38, 0x00, 0x00}, // '['
{0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00}, // '\'
{0x38, 0x08, 0x08, 0x08, 0x08, 0x38, 0x00, 0x00}, // ']'
{0x10, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '^'
{0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00}, // '_'
{0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // '`'
{0x00, 0x3C, 0x02, 0x3E, 0x46, 0x3A, 0x00, 0x00}, // 'a'
{0x40, 0x40, 0x7C, 0x42, 0x62, 0x5C, 0x00, 0x00}, // 'b'
{0x00, 0x00, 0x1C, 0x20, 0x20, 0x1C, 0x00, 0x00}, // 'c'
{0x02, 0x02, 0x3E, 0x42, 0x46, 0x3A, 0x00, 0x00}, // 'd'
{0x00, 0x3C, 0x42, 0x7E, 0x40, 0x3C, 0x00, 0x00}, // 'e'
{0x00, 0x18, 0x10, 0x38, 0x10, 0x10, 0x00, 0x00}, // 'f'
{0x00, 0x00, 0x34, 0x4C, 0x44, 0x34, 0x04, 0x38}, // 'g'
{0x20, 0x20, 0x38, 0x24, 0x24, 0x24, 0x00, 0x00}, // 'h'
{0x08, 0x00, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00}, // 'i'
{0x08, 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x70}, // 'j'
{0x20, 0x20, 0x24, 0x28, 0x30, 0x2C, 0x00, 0x00}, // 'k'
{0x10, 0x10, 0x10, 0x10, 0x10, 0x18, 0x00, 0x00}, // 'l'
{0x00, 0x00, 0x66, 0x5A, 0x42, 0x42, 0x00, 0x00}, // 'm'
{0x00, 0x00, 0x2E, 0x32, 0x22, 0x22, 0x00, 0x00}, // 'n'
{0x00, 0x00, 0x3C, 0x42, 0x42, 0x3C, 0x00, 0x00}, // 'o'
{0x00, 0x00, 0x5C, 0x62, 0x42, 0x7C, 0x40, 0x40}, // 'p'
{0x00, 0x00, 0x3A, 0x46, 0x42, 0x3E, 0x02, 0x02}, // 'q'
{0x00, 0x00, 0x2C, 0x32, 0x20, 0x20, 0x00, 0x00}, // 'r'
{0x00, 0x1C, 0x20, 0x18, 0x04, 0x38, 0x00, 0x00}, // 's'
{0x00, 0x10, 0x3C, 0x10, 0x10, 0x18, 0x00, 0x00}, // 't'
{0x00, 0x00, 0x22, 0x22, 0x26, 0x1A, 0x00, 0x00}, // 'u'
{0x00, 0x00, 0x42, 0x42, 0x24, 0x18, 0x00, 0x00}, // 'v'
{0x00, 0x00, 0x81, 0x81, 0x5A, 0x66, 0x00, 0x00}, // 'w'
{0x00, 0x00, 0x42, 0x24, 0x18, 0x66, 0x00, 0x00}, // 'x'
{0x00, 0x00, 0x42, 0x22, 0x14, 0x08, 0x10, 0x60}, // 'y'
{0x00, 0x00, 0x3C, 0x08, 0x10, 0x3C, 0x00, 0x00}, // 'z'
{0x1C, 0x10, 0x30, 0x30, 0x10, 0x1C, 0x00, 0x00}, // '{'
{0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00}, // '|'
{0x38, 0x08, 0x0C, 0x0C, 0x08, 0x38, 0x00, 0x00}, // '}'
{0x00, 0x00, 0x00, 0x32, 0x4C, 0x00, 0x00, 0x00} // '~'
};
*/
const uint8_t gFont6x8[96][6] =
const uint8_t gFont5x8[95][5] =
{
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00 },
{ 0x00, 0x07, 0x00, 0x07, 0x00, 0x00 },
{ 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00 },
{ 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00 },
{ 0x23, 0x13, 0x08, 0x64, 0x62, 0x00 },
{ 0x36, 0x49, 0x56, 0x20, 0x50, 0x00 },
{ 0x00, 0x08, 0x07, 0x03, 0x00, 0x00 },
{ 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00 },
{ 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00 },
{ 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00 },
{ 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00 },
{ 0x00, 0x80, 0x70, 0x30, 0x00, 0x00 },
{ 0x08, 0x08, 0x08, 0x08, 0x08, 0x00 },
{ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 },
{ 0x20, 0x10, 0x08, 0x04, 0x02, 0x00 },
{0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x5F, 0x00, 0x00},
{0x00, 0x07, 0x00, 0x07, 0x00},
{0x14, 0x7F, 0x14, 0x7F, 0x14},
{0x24, 0x2A, 0x7F, 0x2A, 0x12},
{0x23, 0x13, 0x08, 0x64, 0x62},
{0x36, 0x49, 0x56, 0x20, 0x50},
{0x00, 0x08, 0x07, 0x03, 0x00},
{0x00, 0x1C, 0x22, 0x41, 0x00},
{0x00, 0x41, 0x22, 0x1C, 0x00},
{0x2A, 0x1C, 0x7F, 0x1C, 0x2A},
{0x08, 0x08, 0x3E, 0x08, 0x08},
{0x00, 0x80, 0x70, 0x30, 0x00},
{0x08, 0x08, 0x08, 0x08, 0x08},
{0x00, 0x00, 0x60, 0x60, 0x00},
{0x20, 0x10, 0x08, 0x04, 0x02},
//{ 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00 },
{ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00 },
{ 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00 },
{ 0x72, 0x49, 0x49, 0x49, 0x46, 0x00 },
{ 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00 },
{ 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00 },
{ 0x27, 0x45, 0x45, 0x45, 0x39, 0x00 },
{ 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00 },
{ 0x41, 0x21, 0x11, 0x09, 0x07, 0x00 },
{ 0x36, 0x49, 0x49, 0x49, 0x36, 0x00 },
{ 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00 },
{ 0x00, 0x00, 0x14, 0x00, 0x00, 0x00 },
{ 0x00, 0x40, 0x34, 0x00, 0x00, 0x00 },
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 },
{ 0x14, 0x14, 0x14, 0x14, 0x14, 0x00 },
{ 0x00, 0x41, 0x22, 0x14, 0x08, 0x00 },
{ 0x02, 0x01, 0x59, 0x09, 0x06, 0x00 },
{0x3E, 0x41, 0x41, 0x41, 0x3E},
{0x00, 0x42, 0x7F, 0x40, 0x00},
{0x72, 0x49, 0x49, 0x49, 0x46},
{0x21, 0x41, 0x49, 0x4D, 0x33},
{0x18, 0x14, 0x12, 0x7F, 0x10},
{0x27, 0x45, 0x45, 0x45, 0x39},
{0x3C, 0x4A, 0x49, 0x49, 0x31},
{0x41, 0x21, 0x11, 0x09, 0x07},
{0x36, 0x49, 0x49, 0x49, 0x36},
{0x46, 0x49, 0x49, 0x29, 0x1E},
{0x00, 0x00, 0x14, 0x00, 0x00},
{0x00, 0x40, 0x34, 0x00, 0x00},
{0x00, 0x08, 0x14, 0x22, 0x41},
{0x14, 0x14, 0x14, 0x14, 0x14},
{0x00, 0x41, 0x22, 0x14, 0x08},
{0x02, 0x01, 0x59, 0x09, 0x06},
{ 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00 },
{ 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00 },
{ 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00 },
{ 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00 },
{ 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00 },
{ 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00 },
{ 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00 },
{ 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00 },
{ 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00 },
{ 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00 },
{ 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00 },
{ 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00 },
{ 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00 },
{ 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00 },
{ 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00 },
{ 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00 },
{0x3E, 0x41, 0x5D, 0x59, 0x4E},
{0x7C, 0x12, 0x11, 0x12, 0x7C},
{0x7F, 0x49, 0x49, 0x49, 0x36},
{0x3E, 0x41, 0x41, 0x41, 0x22},
{0x7F, 0x41, 0x41, 0x41, 0x3E},
{0x7F, 0x49, 0x49, 0x49, 0x41},
{0x7F, 0x09, 0x09, 0x09, 0x01},
{0x3E, 0x41, 0x41, 0x51, 0x73},
{0x7F, 0x08, 0x08, 0x08, 0x7F},
{0x00, 0x41, 0x7F, 0x41, 0x00},
{0x20, 0x40, 0x41, 0x3F, 0x01},
{0x7F, 0x08, 0x14, 0x22, 0x41},
{0x7F, 0x40, 0x40, 0x40, 0x40},
{0x7F, 0x02, 0x1C, 0x02, 0x7F},
{0x7F, 0x04, 0x08, 0x10, 0x7F},
{0x3E, 0x41, 0x41, 0x41, 0x3E},
{ 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00 },
{ 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00 },
{ 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00 },
{ 0x26, 0x49, 0x49, 0x49, 0x32, 0x00 },
{ 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00 },
{ 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00 },
{ 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00 },
{ 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00 },
{ 0x63, 0x14, 0x08, 0x14, 0x63, 0x00 },
{ 0x03, 0x04, 0x78, 0x04, 0x03, 0x00 },
{ 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00 },
{ 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00 },
{ 0x02, 0x04, 0x08, 0x10, 0x20, 0x00 },
{ 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00 },
{ 0x04, 0x02, 0x01, 0x02, 0x04, 0x00 },
{ 0x40, 0x40, 0x40, 0x40, 0x40, 0x00 },
{0x7F, 0x09, 0x09, 0x09, 0x06},
{0x3E, 0x41, 0x51, 0x21, 0x5E},
{0x7F, 0x09, 0x19, 0x29, 0x46},
{0x26, 0x49, 0x49, 0x49, 0x32},
{0x03, 0x01, 0x7F, 0x01, 0x03},
{0x3F, 0x40, 0x40, 0x40, 0x3F},
{0x1F, 0x20, 0x40, 0x20, 0x1F},
{0x3F, 0x40, 0x38, 0x40, 0x3F},
{0x63, 0x14, 0x08, 0x14, 0x63},
{0x03, 0x04, 0x78, 0x04, 0x03},
{0x61, 0x59, 0x49, 0x4D, 0x43},
{0x00, 0x7F, 0x41, 0x41, 0x41},
{0x02, 0x04, 0x08, 0x10, 0x20},
{0x00, 0x41, 0x41, 0x41, 0x7F},
{0x04, 0x02, 0x01, 0x02, 0x04},
{0x40, 0x40, 0x40, 0x40, 0x40},
{ 0x00, 0x03, 0x07, 0x08, 0x00, 0x00 },
{ 0x20, 0x54, 0x54, 0x78, 0x40, 0x00 },
{ 0x7F, 0x28, 0x44, 0x44, 0x38, 0x00 },
{ 0x38, 0x44, 0x44, 0x44, 0x28, 0x00 },
{ 0x38, 0x44, 0x44, 0x28, 0x7F, 0x00 },
{ 0x38, 0x54, 0x54, 0x54, 0x18, 0x00 },
{ 0x00, 0x08, 0x7E, 0x09, 0x02, 0x00 },
{ 0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00 },
{ 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00 },
{ 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00 },
{ 0x20, 0x40, 0x40, 0x3D, 0x00, 0x00 },
{ 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00 },
{ 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00 },
{ 0x7C, 0x04, 0x78, 0x04, 0x78, 0x00 },
{ 0x7C, 0x08, 0x04, 0x04, 0x78, 0x00 },
{ 0x38, 0x44, 0x44, 0x44, 0x38, 0x00 },
{0x00, 0x03, 0x07, 0x08, 0x00},
{0x20, 0x54, 0x54, 0x78, 0x40},
{0x7F, 0x28, 0x44, 0x44, 0x38},
{0x38, 0x44, 0x44, 0x44, 0x28},
{0x38, 0x44, 0x44, 0x28, 0x7F},
{0x38, 0x54, 0x54, 0x54, 0x18},
{0x00, 0x08, 0x7E, 0x09, 0x02},
{0x18, 0xA4, 0xA4, 0x9C, 0x78},
{0x7F, 0x08, 0x04, 0x04, 0x78},
{0x00, 0x44, 0x7D, 0x40, 0x00},
{0x20, 0x40, 0x40, 0x3D, 0x00},
{0x7F, 0x10, 0x28, 0x44, 0x00},
{0x00, 0x41, 0x7F, 0x40, 0x00},
{0x7C, 0x04, 0x78, 0x04, 0x78},
{0x7C, 0x08, 0x04, 0x04, 0x78},
{0x38, 0x44, 0x44, 0x44, 0x38},
{ 0xFC, 0x18, 0x24, 0x24, 0x18, 0x00 },
{ 0x18, 0x24, 0x24, 0x18, 0xFC, 0x00 },
{ 0x7C, 0x08, 0x04, 0x04, 0x08, 0x00 },
{ 0x48, 0x54, 0x54, 0x54, 0x24, 0x00 },
{ 0x04, 0x04, 0x3F, 0x44, 0x24, 0x00 },
{ 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00 },
{ 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00 },
{ 0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00 },
{ 0x44, 0x28, 0x10, 0x28, 0x44, 0x00 },
{ 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00 },
{ 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00 },
{ 0x00, 0x08, 0x36, 0x41, 0x00, 0x00 },
{ 0x00, 0x00, 0x77, 0x00, 0x00, 0x00 },
{ 0x00, 0x41, 0x36, 0x08, 0x00, 0x00 },
{ 0x02, 0x01, 0x02, 0x04, 0x02, 0x00 },
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }
{0xFC, 0x18, 0x24, 0x24, 0x18},
{0x18, 0x24, 0x24, 0x18, 0xFC},
{0x7C, 0x08, 0x04, 0x04, 0x08},
{0x48, 0x54, 0x54, 0x54, 0x24},
{0x04, 0x04, 0x3F, 0x44, 0x24},
{0x3C, 0x40, 0x40, 0x20, 0x7C},
{0x1C, 0x20, 0x40, 0x20, 0x1C},
{0x3C, 0x40, 0x30, 0x40, 0x3C},
{0x44, 0x28, 0x10, 0x28, 0x44},
{0x4C, 0x90, 0x90, 0x90, 0x7C},
{0x44, 0x64, 0x54, 0x4C, 0x44},
{0x00, 0x08, 0x36, 0x41, 0x00},
{0x00, 0x00, 0x77, 0x00, 0x00},
{0x00, 0x41, 0x36, 0x08, 0x00},
{0x02, 0x01, 0x02, 0x04, 0x02}
};
/*
// ASCII 5x7 font
@ -374,7 +368,6 @@ const uint8_t gFont5x7[96][5] =
{0x00, 0x00, 0x60, 0x60, 0x00},
{0x20, 0x10, 0x08, 0x04, 0x02},
// {0x3E, 0x51, 0x49, 0x45, 0x3E}, // '0'
{0x3E, 0x41, 0x41, 0x41, 0x3E}, // '0'
{0x00, 0x42, 0x7F, 0x40, 0x00},
{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 gFontSmallDigits[11][7];
//extern const uint64_t gFont8x8[16 * 6];
extern const uint8_t gFont6x8[96][6];
//extern const uint8_t gFont8x8[95][8];
extern const uint8_t gFont5x8[95][5];
//extern const uint8_t gFont5x7[96][5];
#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->SCANLIST1_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->CHANNEL_SAVE = ChannelSave;
pInfo->FrequencyReverse = false;
@ -137,8 +137,6 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
uint8_t Band;
bool bParticipation2;
uint16_t Base;
uint8_t Data[8];
uint8_t Tmp;
uint32_t Frequency;
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;
RADIO_InitInfo(pRadio, Channel, Index, gLowerLimitFrequencyBandTable[Index]);
RADIO_InitInfo(pRadio, Channel, Index, gLowerLimitFrequencyBandTable[Index]);
return;
}
@ -232,27 +230,28 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
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;
if (Tmp > 2)
Tmp = 0;
gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = Tmp;
gEeprom.VfoInfo[VFO].AM_CHANNEL_MODE = !!(Data[3] & 0x10);
Tmp = Data[6];
if (Tmp > STEP_8_33kHz)
Tmp = STEP_25_0kHz;
gEeprom.VfoInfo[VFO].STEP_SETTING = Tmp;
gEeprom.VfoInfo[VFO].StepFrequency = StepFrequencyTable[Tmp];
Tmp = Data[7];
if (Tmp > 10)
Tmp = 0;
gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE = Tmp;
gEeprom.VfoInfo[VFO].ConfigRX.CodeType = (Data[2] >> 0) & 0x0F;
gEeprom.VfoInfo[VFO].ConfigTX.CodeType = (Data[2] >> 4) & 0x0F;
@ -307,10 +306,11 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
}
else
{
gEeprom.VfoInfo[VFO].FrequencyReverse = !!(Data[4] & 1u);
gEeprom.VfoInfo[VFO].CHANNEL_BANDWIDTH = !!(Data[4] & 2u);
gEeprom.VfoInfo[VFO].OUTPUT_POWER = (Data[4] >> 2) & 3u;
gEeprom.VfoInfo[VFO].BUSY_CHANNEL_LOCK = !!(Data[4] & 0x10);
const uint8_t d4 = Data[4];
gEeprom.VfoInfo[VFO].FrequencyReverse = !!(d4 & 0x01);
gEeprom.VfoInfo[VFO].CHANNEL_BANDWIDTH = !!(d4 & 0x02);
gEeprom.VfoInfo[VFO].OUTPUT_POWER = (d4 >> 2) & 0x03;
gEeprom.VfoInfo[VFO].BUSY_CHANNEL_LOCK = !!(d4 & 0x10);
}
if (Data[5] == 0xFF)
@ -320,17 +320,17 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
}
else
{
gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = !!(Data[5] & 1u);
gEeprom.VfoInfo[VFO].DTMF_PTT_ID_TX_MODE = (Data[5] >> 1) & 3u;
gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = !!(Data[5] & 0x01);
gEeprom.VfoInfo[VFO].DTMF_PTT_ID_TX_MODE = (Data[5] >> 1) & 0x03;
}
struct
{
uint32_t Frequency;
uint32_t Offset;
} Info;
} __attribute__((packed)) Info;
EEPROM_ReadBuffer(Base, &Info, 8);
EEPROM_ReadBuffer(Base, &Info, sizeof(Info));
pRadio->ConfigRX.Frequency = Info.Frequency;
@ -341,24 +341,23 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
}
Frequency = pRadio->ConfigRX.Frequency;
// TODO: FIX-ME !!!
if (Frequency < gLowerLimitFrequencyBandTable[Band])
pRadio->ConfigRX.Frequency = gLowerLimitFrequencyBandTable[Band];
Frequency = gLowerLimitFrequencyBandTable[Band];
else
if (Frequency > gUpperLimitFrequencyBandTable[Band])
pRadio->ConfigRX.Frequency = gUpperLimitFrequencyBandTable[Band];
Frequency = gUpperLimitFrequencyBandTable[Band];
else
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;
if (Frequency >= 10800000 && Frequency < 13600000)
gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = FREQUENCY_DEVIATION_OFF;
else
if (!IS_MR_CHANNEL(Channel))
{
Frequency = FREQUENCY_FloorToStep(gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION, gEeprom.VfoInfo[VFO].StepFrequency, 0);
gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION = Frequency;
}
gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION = FREQUENCY_FloorToStep(gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION, gEeprom.VfoInfo[VFO].StepFrequency, 0);
RADIO_ApplyOffset(pRadio);
@ -466,6 +465,7 @@ void RADIO_ApplyOffset(VFO_Info_t *pInfo)
break;
}
// limit to 50MHz to 600MHz
if (Frequency < 5000000)
Frequency = 5000000;
else
@ -494,13 +494,12 @@ void RADIO_SelectVfos(void)
if (gEeprom.DUAL_WATCH == DUAL_WATCH_CHAN_A)
gEeprom.TX_CHANNEL = 0;
gTxVfo = &gEeprom.VfoInfo[gEeprom.TX_CHANNEL];
if (gEeprom.CROSS_BAND_RX_TX == CROSS_BAND_OFF)
gEeprom.RX_CHANNEL = gEeprom.TX_CHANNEL;
else
gEeprom.RX_CHANNEL = (gEeprom.TX_CHANNEL == 0) ? 1 : 0;
gTxVfo = &gEeprom.VfoInfo[gEeprom.TX_CHANNEL];
gRxVfo = &gEeprom.VfoInfo[gEeprom.RX_CHANNEL];
RADIO_SelectCurrentVfo();
@ -509,11 +508,11 @@ void RADIO_SelectVfos(void)
void RADIO_SetupRegisters(bool bSwitchToFunction0)
{
BK4819_FilterBandwidth_t Bandwidth;
uint16_t Status;
uint16_t InterruptMask;
uint32_t Frequency;
GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_AUDIO_PATH);
gEnableSpeaker = false;
BK4819_ToggleGpioOut(BK4819_GPIO0_PIN28_GREEN, false);
@ -521,17 +520,18 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
Bandwidth = gRxVfo->CHANNEL_BANDWIDTH;
if (Bandwidth != BK4819_FILTER_BW_WIDE)
Bandwidth = BK4819_FILTER_BW_NARROW;
BK4819_SetFilterBandwidth(Bandwidth);
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_RED, false);
BK4819_SetupPowerAmplifier(0, 0);
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1, false);
while (1)
{
Status = BK4819_ReadRegister(BK4819_REG_0C);
if ((Status & 1U) == 0) // INTERRUPT REQUEST
const uint16_t Status = BK4819_ReadRegister(BK4819_REG_0C);
if ((Status & 1u) == 0) // INTERRUPT REQUEST
break;
BK4819_WriteRegister(BK4819_REG_02, 0);
@ -559,8 +559,12 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
gRxVfo->SquelchCloseNoiseThresh,
gRxVfo->SquelchCloseGlitchThresh,
gRxVfo->SquelchOpenGlitchThresh);
BK4819_PickRXFilterPathBasedOnFrequency(Frequency);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2, true);
// AF Rx Gain and DAC
BK4819_WriteRegister(BK4819_REG_48, 0xB3A8);
InterruptMask = 0 | BK4819_REG_3F_SQUELCH_FOUND | BK4819_REG_3F_SQUELCH_LOST;
@ -571,11 +575,8 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
{
if (!gRxVfo->IsAM)
{
uint8_t CodeType;
uint8_t Code;
CodeType = gSelectedCodeType;
Code = gSelectedCode;
uint8_t CodeType = gSelectedCodeType;
uint8_t Code = gSelectedCode;
if (gCssScanMode == CSS_SCAN_MODE_OFF)
{
CodeType = gRxVfo->pRX->CodeType;
@ -655,6 +656,8 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
BK4819_EnableDTMF();
InterruptMask |= BK4819_REG_3F_DTMF_5TONE_FOUND;
}
// enable/disable BK4819 interrupts
BK4819_WriteRegister(BK4819_REG_3F, InterruptMask);
FUNCTION_Init();

10
radio.h
View File

@ -48,7 +48,8 @@ enum PTT_ID_t {
typedef enum PTT_ID_t PTT_ID_t;
#if 0
enum STEP_Setting_t {
enum STEP_Setting_t
{
STEP_2_5kHz,
STEP_5_0kHz,
STEP_6_25kHz,
@ -58,7 +59,8 @@ typedef enum PTT_ID_t PTT_ID_t;
STEP_8_33kHz,
};
#else
enum STEP_Setting_t {
enum STEP_Setting_t
{
STEP_1_25kHz,
STEP_2_5kHz,
STEP_6_25kHz,
@ -71,7 +73,8 @@ typedef enum PTT_ID_t PTT_ID_t;
typedef enum STEP_Setting_t STEP_Setting_t;
enum VfoState_t {
enum VfoState_t
{
VFO_STATE_NORMAL = 0,
VFO_STATE_BUSY,
VFO_STATE_BAT_LOW,
@ -156,4 +159,3 @@ void RADIO_PrepareCssTX(void);
void RADIO_SendEndOfTransmission(void);
#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
{ // 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++)
{
if (pString[i] >= 32)
{
const unsigned int Index = ((unsigned int)pString[i] - 32);
if (Index < ARRAY_SIZE(gFont5x7))
{
const unsigned int ofs = (unsigned int)Start + (i * 6);
memcpy(gFrameBuffer[Line] + ofs, &gFont5x7[Index], ARRAY_SIZE(gFont5x7[Index]));
memcpy(pfB + (i * char_spacing), &gFont5x7[Index], char_width);
}
}
}
}
#else
{ // 6x8 font
#elif 1
{ // 5x8 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++)
{
if (pString[i] >= 32)
{
const unsigned int Index = (unsigned int)pString[i] - 32;
if (Index < ARRAY_SIZE(gFont6x8))
{
const unsigned int ofs = (unsigned int)Start + (i * 7);
memcpy(gFrameBuffer[Line] + ofs, &gFont6x8[Index], ARRAY_SIZE(gFont6x8[Index]));
if (Index < ARRAY_SIZE(gFont5x8))
memcpy(pFb + (i * char_spacing), &gFont5x8[Index], char_width);
}
}
}
}
/*
{ // 8x8 font
#else
{ // 8x8 font .. not yet working
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++)
{
if (pString[i] >= 32)
{
const unsigned int Index = (unsigned int)pString[i] - 32;
if (Index < ARRAY_SIZE(gFont8x8))
{
const unsigned int ofs = (unsigned int)Start + (i * 8);
memcpy(gFrameBuffer[Line] + ofs, &gFont8x8[Index], 8);
memcpy(pFb + (i * char_spacing), &gFont8x8[Index], char_width);
}
}
}
}
*/
#endif
}

1
ui/lock.c
View File

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

188
ui/main.c
View File

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