zhangyuheng/custom-uv-k5-firmware
1
0
Fork 0
forked from mirror/uv-k5-firmware
Code Pull Requests Activity

Reorganised frequency configuration.

Browse Source
This commit is contained in:
Dual Tachyon 2023-08-30 10:35:41 +01:00
parent f7fdc68110
commit 1ba5c5ff53
11 changed files with 107 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
app/app.c
View File

@ -256,7 +256,7 @@ void FUN_0000773c(void)
gEeprom.ScreenChannel[gEeprom.RX_CHANNEL] = Previous;
RADIO_ConfigureChannel(gEeprom.RX_CHANNEL, 2);
} else {
gRxInfo->DCS[0].Frequency = g_20000418;
gRxInfo->ConfigRX.Frequency = g_20000418;
RADIO_ApplyOffset(gRxInfo);
RADIO_ConfigureSquelchAndOutputPower(gRxInfo);
}
@ -466,8 +466,8 @@ void FUN_000069f8(FUNCTION_Type_t Function)
}
if (IS_NOAA_CHANNEL(gRxInfo->CHANNEL_SAVE) && gIsNoaaMode) {
gRxInfo->CHANNEL_SAVE = gNoaaChannel + NOAA_CHANNEL_FIRST;
gRxInfo->pDCS_Current->Frequency = NoaaFrequencyTable[gNoaaChannel];
gRxInfo->pDCS_Reverse->Frequency = NoaaFrequencyTable[gNoaaChannel];
gRxInfo->pCurrent->Frequency = NoaaFrequencyTable[gNoaaChannel];
gRxInfo->pReverse->Frequency = NoaaFrequencyTable[gNoaaChannel];
gEeprom.ScreenChannel[gEeprom.RX_CHANNEL] = gRxInfo->CHANNEL_SAVE;
g_20000356 = 500;
gSystickFlag8 = false;
@ -509,13 +509,13 @@ void APP_SetFrequencyByStep(VFO_Info_t *pInfo, int8_t Step)
{
uint32_t Frequency;
Frequency = pInfo->DCS[0].Frequency + (Step * pInfo->StepFrequency);
Frequency = pInfo->ConfigRX.Frequency + (Step * pInfo->StepFrequency);
if (Frequency >= gUpperLimitFrequencyBandTable[pInfo->Band]) {
pInfo->DCS[0].Frequency = gLowerLimitFrequencyBandTable[pInfo->Band];
pInfo->ConfigRX.Frequency = gLowerLimitFrequencyBandTable[pInfo->Band];
} else if (Frequency < gLowerLimitFrequencyBandTable[pInfo->Band]) {
pInfo->DCS[0].Frequency = FREQUENCY_FloorToStep(gUpperLimitFrequencyBandTable[pInfo->Band], pInfo->StepFrequency, gLowerLimitFrequencyBandTable[pInfo->Band]);
pInfo->ConfigRX.Frequency = FREQUENCY_FloorToStep(gUpperLimitFrequencyBandTable[pInfo->Band], pInfo->StepFrequency, gLowerLimitFrequencyBandTable[pInfo->Band]);
} else {
pInfo->DCS[0].Frequency = Frequency;
pInfo->ConfigRX.Frequency = Frequency;
}
}
@ -1404,7 +1404,7 @@ void FUN_000075b0(void)
}
StepSetting = gRxInfo->STEP_SETTING;
StepFrequency = gRxInfo->StepFrequency;
RADIO_InitInfo(gRxInfo, gRxInfo->CHANNEL_SAVE, gRxInfo->Band, gRxInfo->pDCS_Current->Frequency);
RADIO_InitInfo(gRxInfo, gRxInfo->CHANNEL_SAVE, gRxInfo->Band, gRxInfo->pCurrent->Frequency);
gRxInfo->STEP_SETTING = StepSetting;
gRxInfo->StepFrequency = StepFrequency;
@ -1413,7 +1413,7 @@ void FUN_000075b0(void)
gIsNoaaMode = false;
if (g_20000458 == 1) {
gScanState = 1;
gScanFrequency = gRxInfo->pDCS_Current->Frequency;
gScanFrequency = gRxInfo->pCurrent->Frequency;
gStepSetting = gRxInfo->STEP_SETTING;
BK4819_PickRXFilterPathBasedOnFrequency(gScanFrequency);
BK4819_SetScanFrequency(gScanFrequency);
@ -1452,7 +1452,7 @@ void APP_ChangeStepDirectionMaybe(bool bFlag, int8_t Direction)
FUN_00007dd4();
} else {
if (bFlag) {
g_20000418 = gRxInfo->DCS[0].Frequency;
g_20000418 = gRxInfo->ConfigRX.Frequency;
}
APP_MoreRadioStuff();
}

2
app/main.c
View File

@ -98,7 +98,7 @@ void MAIN_Key_DIGITS(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
RADIO_ConfigureChannel(Vfo, 2);
}
Frequency += 75;
gTxInfo->DCS[0].Frequency = FREQUENCY_FloorToStep(
gTxInfo->ConfigRX.Frequency = FREQUENCY_FloorToStep(
Frequency,
gTxInfo->StepFrequency,
gLowerLimitFrequencyBandTable[gTxInfo->Band]

46
app/menu.c
View File

@ -191,10 +191,8 @@ int MENU_GetLimits(uint8_t Cursor, uint8_t *pMin, uint8_t *pMax)
void MENU_AcceptSetting(void)
{
uint8_t Min, Max;
uint8_t Sel;
uint8_t Code;
Sel = 0;
FREQ_Config_t *pConfig = &gTxInfo->ConfigRX;
if (!MENU_GetLimits(gMenuCursor, &Min, &Max)) {
if (gSubMenuSelection < Min) {
@ -226,43 +224,43 @@ void MENU_AcceptSetting(void)
return;
case MENU_T_DCS:
Sel = 1;
pConfig = &gTxInfo->ConfigTX;
// Fallthrough
case MENU_R_DCS:
if (gSubMenuSelection == 0) {
if (gTxInfo->DCS[Sel].CodeType != CODE_TYPE_DIGITAL && gTxInfo->DCS[Sel].CodeType != CODE_TYPE_REVERSE_DIGITAL) {
if (pConfig->CodeType != CODE_TYPE_DIGITAL && pConfig->CodeType != CODE_TYPE_REVERSE_DIGITAL) {
gRequestSaveChannel = 1;
return;
}
Code = 0;
gTxInfo->DCS[Sel].CodeType = CODE_TYPE_OFF;
pConfig->CodeType = CODE_TYPE_OFF;
} else if (gSubMenuSelection < 105) {
gTxInfo->DCS[Sel].CodeType = CODE_TYPE_DIGITAL;
pConfig->CodeType = CODE_TYPE_DIGITAL;
Code = gSubMenuSelection - 1;
} else {
gTxInfo->DCS[Sel].CodeType = CODE_TYPE_REVERSE_DIGITAL;
pConfig->CodeType = CODE_TYPE_REVERSE_DIGITAL;
Code = gSubMenuSelection - 105;
}
gTxInfo->DCS[Sel].RX_TX_Code = Code;
pConfig->RX_TX_Code = Code;
gRequestSaveChannel = 1;
return;
case MENU_T_CTCS:
Sel = 1;
pConfig = &gTxInfo->ConfigTX;
// Fallthrough
case MENU_R_CTCS:
if (gSubMenuSelection == 0) {
if (gTxInfo->DCS[Sel].CodeType != CODE_TYPE_CONTINUOUS_TONE) {
if (pConfig->CodeType != CODE_TYPE_CONTINUOUS_TONE) {
gRequestSaveChannel = 1;
return;
}
Code = 0;
gTxInfo->DCS[Sel].CodeType = CODE_TYPE_OFF;
pConfig->CodeType = CODE_TYPE_OFF;
} else {
gTxInfo->DCS[Sel].CodeType = CODE_TYPE_CONTINUOUS_TONE;
pConfig->CodeType = CODE_TYPE_CONTINUOUS_TONE;
Code = gSubMenuSelection - 1;
}
gTxInfo->DCS[Sel].RX_TX_Code = Code;
pConfig->RX_TX_Code = Code;
gRequestSaveChannel = 1;
return;
@ -581,12 +579,12 @@ void MENU_ShowCurrentSetting(void)
break;
case MENU_R_DCS:
switch (gTxInfo->DCS[0].CodeType) {
switch (gTxInfo->ConfigRX.CodeType) {
case CODE_TYPE_DIGITAL:
gSubMenuSelection = gTxInfo->DCS[0].RX_TX_Code + 1;
gSubMenuSelection = gTxInfo->ConfigRX.RX_TX_Code + 1;
break;
case CODE_TYPE_REVERSE_DIGITAL:
gSubMenuSelection = gTxInfo->DCS[0].RX_TX_Code + 105;
gSubMenuSelection = gTxInfo->ConfigRX.RX_TX_Code + 105;
break;
default:
gSubMenuSelection = 0;
@ -599,20 +597,20 @@ void MENU_ShowCurrentSetting(void)
break;
case MENU_R_CTCS:
if (gTxInfo->DCS[0].CodeType == CODE_TYPE_CONTINUOUS_TONE) {
gSubMenuSelection = gTxInfo->DCS[0].RX_TX_Code + 1;
if (gTxInfo->ConfigRX.CodeType == CODE_TYPE_CONTINUOUS_TONE) {
gSubMenuSelection = gTxInfo->ConfigRX.RX_TX_Code + 1;
} else {
gSubMenuSelection = 0;
}
break;
case MENU_T_DCS:
switch (gTxInfo->DCS[1].CodeType) {
switch (gTxInfo->ConfigTX.CodeType) {
case CODE_TYPE_DIGITAL:
gSubMenuSelection = gTxInfo->DCS[1].RX_TX_Code + 1;
gSubMenuSelection = gTxInfo->ConfigTX.RX_TX_Code + 1;
break;
case CODE_TYPE_REVERSE_DIGITAL:
gSubMenuSelection = gTxInfo->DCS[1].RX_TX_Code + 105;
gSubMenuSelection = gTxInfo->ConfigTX.RX_TX_Code + 105;
break;
default:
gSubMenuSelection = 0;
@ -621,8 +619,8 @@ void MENU_ShowCurrentSetting(void)
break;
case MENU_T_CTCS:
if (gTxInfo->DCS[1].CodeType == CODE_TYPE_CONTINUOUS_TONE) {
gSubMenuSelection = gTxInfo->DCS[1].RX_TX_Code + 1;
if (gTxInfo->ConfigTX.CodeType == CODE_TYPE_CONTINUOUS_TONE) {
gSubMenuSelection = gTxInfo->ConfigTX.RX_TX_Code + 1;
} else {
gSubMenuSelection = 0;
}

14
app/scanner.c
View File

@ -164,18 +164,18 @@ void SCANNER_Key_MENU(bool bKeyPressed, bool bKeyHeld)
if (g_20000458 == 0) {
RADIO_InitInfo(gTxInfo, gTxInfo->CHANNEL_SAVE, FREQUENCY_GetBand(gScanFrequency), gScanFrequency);
if (g_2000045C == 1) {
gTxInfo->DCS[0].CodeType = g_CxCSS_Type;
gTxInfo->DCS[0].RX_TX_Code = g_CxCSS_Index;
gTxInfo->ConfigRX.CodeType = g_CxCSS_Type;
gTxInfo->ConfigRX.RX_TX_Code = g_CxCSS_Index;
}
gTxInfo->DCS[1] = gTxInfo->DCS[0];
gTxInfo->ConfigTX = gTxInfo->ConfigRX;
gTxInfo->STEP_SETTING = gStepSetting;
} else {
RADIO_ConfigureChannel(0, 2);
RADIO_ConfigureChannel(1, 2);
gTxInfo->DCS[0].CodeType = g_CxCSS_Type;
gTxInfo->DCS[0].RX_TX_Code = g_CxCSS_Index;
gTxInfo->DCS[1].CodeType = g_CxCSS_Type;
gTxInfo->DCS[1].RX_TX_Code = g_CxCSS_Index;
gTxInfo->ConfigRX.CodeType = g_CxCSS_Type;
gTxInfo->ConfigRX.RX_TX_Code = g_CxCSS_Index;
gTxInfo->ConfigTX.CodeType = g_CxCSS_Type;
gTxInfo->ConfigTX.RX_TX_Code = g_CxCSS_Index;
}
if (IS_MR_CHANNEL(gTxInfo->CHANNEL_SAVE)) {

2
frequencies.c
View File

@ -130,7 +130,7 @@ int FREQUENCY_Check(VFO_Info_t *pInfo)
if (pInfo->CHANNEL_SAVE >= NOAA_CHANNEL_FIRST) {
return -1;
}
Frequency = pInfo->pDCS_Reverse->Frequency;
Frequency = pInfo->pReverse->Frequency;
if (gSetting_F_LOCK == F_LOCK_FCC) {
if ((Frequency + 14400000) < 399991) {
return 0;

2
functions.c
View File

@ -42,7 +42,7 @@ void FUNCTION_Init(void)
if (gRxInfo->IsAM) {
gCopyOfCodeType = CODE_TYPE_OFF;
} else {
gCopyOfCodeType = gRxInfo->pDCS_Current->CodeType;
gCopyOfCodeType = gRxInfo->pCurrent->CodeType;
}
}
} else {

88
radio.c
View File

@ -116,10 +116,10 @@ void RADIO_InitInfo(VFO_Info_t *pInfo, uint8_t ChannelSave, uint8_t Band, uint32
pInfo->CHANNEL_SAVE = ChannelSave;
pInfo->FrequencyReverse = false;
pInfo->OUTPUT_POWER = OUTPUT_POWER_HIGH;
pInfo->DCS[0].Frequency = Frequency;
pInfo->DCS[1].Frequency = Frequency;
pInfo->pDCS_Current = &pInfo->DCS[0];
pInfo->pDCS_Reverse = &pInfo->DCS[1];
pInfo->ConfigRX.Frequency = Frequency;
pInfo->ConfigTX.Frequency = Frequency;
pInfo->pCurrent = &pInfo->ConfigRX;
pInfo->pReverse = &pInfo->ConfigTX;
pInfo->FREQUENCY_OF_DEVIATION = 1000000;
RADIO_ConfigureSquelchAndOutputPower(pInfo);
}
@ -231,11 +231,11 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
Tmp = 0;
}
gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE = Tmp;
gEeprom.VfoInfo[VFO].DCS[0].CodeType = (Data[2] >> 0) & 0x0F;
gEeprom.VfoInfo[VFO].DCS[1].CodeType = (Data[2] >> 4) & 0x0F;
gEeprom.VfoInfo[VFO].ConfigRX.CodeType = (Data[2] >> 0) & 0x0F;
gEeprom.VfoInfo[VFO].ConfigTX.CodeType = (Data[2] >> 4) & 0x0F;
Tmp = Data[0];
switch (gEeprom.VfoInfo[VFO].DCS[0].CodeType) {
switch (gEeprom.VfoInfo[VFO].ConfigRX.CodeType) {
case CODE_TYPE_CONTINUOUS_TONE:
if (Tmp >= 50) {
Tmp = 0;
@ -248,13 +248,13 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
}
break;
default:
gEeprom.VfoInfo[VFO].DCS[0].CodeType = CODE_TYPE_OFF;
gEeprom.VfoInfo[VFO].ConfigRX.CodeType = CODE_TYPE_OFF;
break;
}
gEeprom.VfoInfo[VFO].DCS[0].RX_TX_Code = Tmp;
gEeprom.VfoInfo[VFO].ConfigRX.RX_TX_Code = Tmp;
Tmp = Data[1];
switch (gEeprom.VfoInfo[VFO].DCS[1].CodeType) {
switch (gEeprom.VfoInfo[VFO].ConfigTX.CodeType) {
case CODE_TYPE_CONTINUOUS_TONE:
if (Tmp >= 50) {
Tmp = 0;
@ -267,10 +267,10 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
}
break;
default:
gEeprom.VfoInfo[VFO].DCS[1].CodeType = CODE_TYPE_OFF;
gEeprom.VfoInfo[VFO].ConfigTX.CodeType = CODE_TYPE_OFF;
break;
}
gEeprom.VfoInfo[VFO].DCS[1].RX_TX_Code = Tmp;
gEeprom.VfoInfo[VFO].ConfigTX.RX_TX_Code = Tmp;
if (Data[4] == 0xFF) {
gEeprom.VfoInfo[VFO].FrequencyReverse = false;
@ -298,22 +298,22 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
EEPROM_ReadBuffer(Base, &Info, 8);
pRadio->DCS[0].Frequency = Info.Frequency;
pRadio->ConfigRX.Frequency = Info.Frequency;
if (Info.Offset >= 100000000) {
Info.Offset = 1000000;
}
gEeprom.VfoInfo[VFO].FREQUENCY_OF_DEVIATION = Info.Offset;
}
Frequency = pRadio->DCS[0].Frequency;
Frequency = pRadio->ConfigRX.Frequency;
if (Frequency < gLowerLimitFrequencyBandTable[Band]) {
pRadio->DCS[0].Frequency = gLowerLimitFrequencyBandTable[Band];
pRadio->ConfigRX.Frequency = gLowerLimitFrequencyBandTable[Band];
} else if (Frequency > gUpperLimitFrequencyBandTable[Band]) {
pRadio->DCS[0].Frequency = gUpperLimitFrequencyBandTable[Band];
pRadio->ConfigRX.Frequency = gUpperLimitFrequencyBandTable[Band];
} else if (Channel >= FREQ_CHANNEL_FIRST) {
pRadio->DCS[0].Frequency = FREQUENCY_FloorToStep(pRadio->DCS[0].Frequency, gEeprom.VfoInfo[VFO].StepFrequency, gLowerLimitFrequencyBandTable[Band]);
pRadio->ConfigRX.Frequency = FREQUENCY_FloorToStep(pRadio->ConfigRX.Frequency, gEeprom.VfoInfo[VFO].StepFrequency, gLowerLimitFrequencyBandTable[Band]);
}
pRadio->DCS[0].Frequency = Frequency;
pRadio->ConfigRX.Frequency = Frequency;
if (Frequency - 10800000 < 2799991) {
gEeprom.VfoInfo[VFO].FREQUENCY_DEVIATION_SETTING = FREQUENCY_DEVIATION_OFF;
@ -330,17 +330,17 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
}
if (!gEeprom.VfoInfo[VFO].FrequencyReverse) {
gEeprom.VfoInfo[VFO].pDCS_Current = &gEeprom.VfoInfo[VFO].DCS[0];
gEeprom.VfoInfo[VFO].pDCS_Reverse = &gEeprom.VfoInfo[VFO].DCS[1];
gEeprom.VfoInfo[VFO].pCurrent = &gEeprom.VfoInfo[VFO].ConfigRX;
gEeprom.VfoInfo[VFO].pReverse = &gEeprom.VfoInfo[VFO].ConfigTX;
} else {
gEeprom.VfoInfo[VFO].pDCS_Current = &gEeprom.VfoInfo[VFO].DCS[1];
gEeprom.VfoInfo[VFO].pDCS_Reverse = &gEeprom.VfoInfo[VFO].DCS[0];
gEeprom.VfoInfo[VFO].pCurrent = &gEeprom.VfoInfo[VFO].ConfigTX;
gEeprom.VfoInfo[VFO].pReverse = &gEeprom.VfoInfo[VFO].ConfigRX;
}
if (!gSetting_350EN) {
DCS_Info_t *pDCS = gEeprom.VfoInfo[VFO].pDCS_Current;
if (pDCS->Frequency - 35000000 < 4999991) {
pDCS->Frequency = 41001250;
FREQ_Config_t *pConfig = gEeprom.VfoInfo[VFO].pCurrent;
if (pConfig->Frequency - 35000000 < 4999991) {
pConfig->Frequency = 41001250;
}
}
@ -348,8 +348,8 @@ void RADIO_ConfigureChannel(uint8_t VFO, uint32_t Arg)
gEeprom.VfoInfo[VFO].IsAM = true;
gEeprom.VfoInfo[VFO].SCRAMBLING_TYPE = 0;
gEeprom.VfoInfo[VFO].DTMF_DECODING_ENABLE = false;
gEeprom.VfoInfo[VFO].DCS[0].CodeType = CODE_TYPE_OFF;
gEeprom.VfoInfo[VFO].DCS[1].CodeType = CODE_TYPE_OFF;
gEeprom.VfoInfo[VFO].ConfigRX.CodeType = CODE_TYPE_OFF;
gEeprom.VfoInfo[VFO].ConfigTX.CodeType = CODE_TYPE_OFF;
} else {
gEeprom.VfoInfo[VFO].IsAM = false;
}
@ -363,7 +363,7 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
uint16_t Base;
FREQUENCY_Band_t Band;
Band = FREQUENCY_GetBand(pInfo->pDCS_Current->Frequency);
Band = FREQUENCY_GetBand(pInfo->pCurrent->Frequency);
if (Band < BAND4_174MHz) {
Base = 0x1E60;
} else {
@ -393,7 +393,7 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
}
}
Band = FREQUENCY_GetBand(pInfo->pDCS_Reverse->Frequency);
Band = FREQUENCY_GetBand(pInfo->pReverse->Frequency);
EEPROM_ReadBuffer(0x1ED0 + (Band * 0x10) + (pInfo->OUTPUT_POWER * 3), Txp, 3);
pInfo->TXP_CalculatedSetting =
FREQUENCY_CalculateOutputPower(
@ -403,14 +403,14 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo)
LowerLimitFrequencyBandTable[Band],
MiddleFrequencyBandTable[Band],
UpperLimitFrequencyBandTable[Band],
pInfo->pDCS_Reverse->Frequency);
pInfo->pReverse->Frequency);
}
void RADIO_ApplyOffset(VFO_Info_t *pInfo)
{
uint32_t Frequency;
Frequency = pInfo->DCS[0].Frequency;
Frequency = pInfo->ConfigRX.Frequency;
switch (pInfo->FREQUENCY_DEVIATION_SETTING) {
case FREQUENCY_DEVIATION_OFF:
break;
@ -428,7 +428,7 @@ void RADIO_ApplyOffset(VFO_Info_t *pInfo)
Frequency = 60000000;
}
pInfo->DCS[1].Frequency = Frequency;
pInfo->ConfigTX.Frequency = Frequency;
}
@ -498,7 +498,7 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
BK4819_WriteRegister(BK4819_REG_3F, 0);
BK4819_WriteRegister(BK4819_REG_7D, gEeprom.MIC_SENSITIVITY_TUNING | 0xE940);
if (IS_NOT_NOAA_CHANNEL(gRxInfo->CHANNEL_SAVE) || !gIsNoaaMode) {
Frequency = gRxInfo->pDCS_Current->Frequency;
Frequency = gRxInfo->pCurrent->Frequency;
} else {
Frequency = NoaaFrequencyTable[gNoaaChannel];
}
@ -524,8 +524,8 @@ void RADIO_SetupRegisters(bool bSwitchToFunction0)
CodeType = gCodeType;
CodeWord = gCode;
if (g_20000381 == 0) {
CodeType = gRxInfo->pDCS_Current->CodeType;
CodeWord = gRxInfo->pDCS_Current->RX_TX_Code;
CodeType = gRxInfo->pCurrent->CodeType;
CodeWord = gRxInfo->pCurrent->RX_TX_Code;
}
switch (CodeType) {
case CODE_TYPE_DIGITAL:
@ -645,32 +645,32 @@ void RADIO_PrepareTransmit(void)
Bandwidth = BK4819_FILTER_BW_NARROW;
}
BK4819_SetFilterBandwidth(Bandwidth);
BK4819_SetFrequency(gCrossTxRadioInfo->pDCS_Reverse->Frequency);
BK4819_SetFrequency(gCrossTxRadioInfo->pReverse->Frequency);
BK4819_PrepareTransmit();
SYSTEM_DelayMs(10);
BK4819_PickRXFilterPathBasedOnFrequency(gCrossTxRadioInfo->pDCS_Reverse->Frequency);
BK4819_PickRXFilterPathBasedOnFrequency(gCrossTxRadioInfo->pReverse->Frequency);
BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1, true);
SYSTEM_DelayMs(5);
BK4819_SetupPowerAmplifier(gCrossTxRadioInfo->TXP_CalculatedSetting, gCrossTxRadioInfo->pDCS_Reverse->Frequency);
BK4819_SetupPowerAmplifier(gCrossTxRadioInfo->TXP_CalculatedSetting, gCrossTxRadioInfo->pReverse->Frequency);
SYSTEM_DelayMs(10);
if (gCrossTxRadioInfo->pDCS_Reverse->CodeType != CODE_TYPE_CONTINUOUS_TONE) {
if ((gCrossTxRadioInfo->pDCS_Reverse->CodeType != CODE_TYPE_DIGITAL) && (gCrossTxRadioInfo->pDCS_Reverse->CodeType != CODE_TYPE_REVERSE_DIGITAL)) {
if (gCrossTxRadioInfo->pReverse->CodeType != CODE_TYPE_CONTINUOUS_TONE) {
if ((gCrossTxRadioInfo->pReverse->CodeType != CODE_TYPE_DIGITAL) && (gCrossTxRadioInfo->pReverse->CodeType != CODE_TYPE_REVERSE_DIGITAL)) {
BK4819_ExitSubAu();
return;
}
BK4819_SetCDCSSCodeWord(
DCS_GetGolayCodeWord(
gCrossTxRadioInfo->pDCS_Reverse->CodeType,
gCrossTxRadioInfo->pDCS_Reverse->RX_TX_Code
gCrossTxRadioInfo->pReverse->CodeType,
gCrossTxRadioInfo->pReverse->RX_TX_Code
)
);
return;
}
BK4819_SetCTCSSBaudRate(CTCSS_Options[gCrossTxRadioInfo->pDCS_Reverse->RX_TX_Code]);
BK4819_SetCTCSSBaudRate(CTCSS_Options[gCrossTxRadioInfo->pReverse->RX_TX_Code]);
}
void RADIO_SomethingElse(uint8_t Arg)
@ -758,7 +758,7 @@ LAB_00007c20:
void RADIO_EnableCxCSS(void)
{
switch (gCrossTxRadioInfo->pDCS_Reverse->CodeType) {
switch (gCrossTxRadioInfo->pReverse->CodeType) {
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
BK4819_EnableCDCSS();

9
radio.h
View File

@ -63,12 +63,13 @@ typedef struct {
DCS_CodeType_t CodeType;
uint8_t RX_TX_Code;
uint8_t Padding[2];
} DCS_Info_t;
} FREQ_Config_t;
typedef struct VFO_Info_t {
DCS_Info_t DCS[2];
DCS_Info_t *pDCS_Current;
DCS_Info_t *pDCS_Reverse;
FREQ_Config_t ConfigRX;
FREQ_Config_t ConfigTX;
FREQ_Config_t *pCurrent;
FREQ_Config_t *pReverse;
uint32_t FREQUENCY_OF_DEVIATION;
uint16_t StepFrequency;
uint8_t CHANNEL_SAVE;

8
settings.c
View File

@ -188,14 +188,14 @@ void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO,
uint32_t State32[2];
uint8_t State8[8];
State32[0] = pVFO->DCS[0].Frequency;
State32[0] = pVFO->ConfigRX.Frequency;
State32[1] = pVFO->FREQUENCY_OF_DEVIATION;
EEPROM_WriteBuffer(OffsetVFO + 0, State32);
State8[0] = pVFO->DCS[0].RX_TX_Code;
State8[1] = pVFO->DCS[1].RX_TX_Code;
State8[2] = (pVFO->DCS[1].CodeType << 4) | pVFO->DCS[0].CodeType;
State8[0] = pVFO->ConfigRX.RX_TX_Code;
State8[1] = pVFO->ConfigTX.RX_TX_Code;
State8[2] = (pVFO->ConfigTX.CodeType << 4) | pVFO->ConfigRX.CodeType;
State8[3] = (pVFO->AM_CHANNEL_MODE << 4) | pVFO->FREQUENCY_DEVIATION_SETTING;
State8[4] = 0
| (pVFO->BUSY_CHANNEL_LOCK << 4)

2
ui/aircopy.c
View File

@ -40,7 +40,7 @@ void UI_DisplayAircopy(void)
UI_PrintString(String, 2, 127, 0, 8, true);
if (gInputBoxIndex == 0) {
NUMBER_ToDigits(gRxInfo->DCS[0].Frequency, String);
NUMBER_ToDigits(gRxInfo->ConfigRX.Frequency, String);
UI_DisplayFrequency(String, 16, 2, 0, 0);
UI_DisplaySmallDigits(2, String + 6, 97, 3);
} else {

22
ui/main.c
View File

@ -227,12 +227,12 @@ void UI_DisplayMain(void)
Channel = gEeprom.TX_CHANNEL;
}
if (Channel == i) {
NUMBER_ToDigits(gEeprom.VfoInfo[i].pDCS_Reverse->Frequency, String);
NUMBER_ToDigits(gEeprom.VfoInfo[i].pReverse->Frequency, String);
} else {
NUMBER_ToDigits(gEeprom.VfoInfo[i].pDCS_Current->Frequency, String);
NUMBER_ToDigits(gEeprom.VfoInfo[i].pCurrent->Frequency, String);
}
} else {
NUMBER_ToDigits(gEeprom.VfoInfo[i].pDCS_Current->Frequency, String);
NUMBER_ToDigits(gEeprom.VfoInfo[i].pCurrent->Frequency, String);
}
UI_DisplayFrequency(String, 31, i * 4, false, false);
if (IS_MR_CHANNEL(gEeprom.ScreenChannel[i])) {
@ -267,12 +267,12 @@ void UI_DisplayMain(void)
Channel = gEeprom.TX_CHANNEL;
}
if (Channel == i) {
NUMBER_ToDigits(gEeprom.VfoInfo[i].pDCS_Reverse->Frequency, String);
NUMBER_ToDigits(gEeprom.VfoInfo[i].pReverse->Frequency, String);
} else {
NUMBER_ToDigits(gEeprom.VfoInfo[i].pDCS_Current->Frequency, String);
NUMBER_ToDigits(gEeprom.VfoInfo[i].pCurrent->Frequency, String);
}
} else {
NUMBER_ToDigits(gEeprom.VfoInfo[i].pDCS_Current->Frequency, String);
NUMBER_ToDigits(gEeprom.VfoInfo[i].pCurrent->Frequency, String);
}
UI_DisplayFrequency(String, 31, i * 4, false, false);
if (IS_MR_CHANNEL(gEeprom.ScreenChannel[i])) {
@ -331,14 +331,14 @@ void UI_DisplayMain(void)
if (gEeprom.VfoInfo[i].IsAM) {
memcpy(pLine1 + 128 + 27, BITMAP_AM, sizeof(BITMAP_AM));
} else {
const DCS_Info_t *pDCS;
const FREQ_Config_t *pConfig;
if (SomeValue == 1) {
pDCS = gEeprom.VfoInfo[i].pDCS_Reverse;
pConfig = gEeprom.VfoInfo[i].pReverse;
} else {
pDCS = gEeprom.VfoInfo[i].pDCS_Current;
pConfig = gEeprom.VfoInfo[i].pCurrent;
}
switch (pDCS->CodeType) {
switch (pConfig->CodeType) {
case CODE_TYPE_CONTINUOUS_TONE:
memcpy(pLine1 + 128 + 27, BITMAP_CT, sizeof(BITMAP_CT));
break;
@ -364,7 +364,7 @@ void UI_DisplayMain(void)
break;
}
if (gEeprom.VfoInfo[i].DCS[0].Frequency != gEeprom.VfoInfo[i].DCS[1].Frequency) {
if (gEeprom.VfoInfo[i].ConfigRX.Frequency != gEeprom.VfoInfo[i].ConfigTX.Frequency) {
if (gEeprom.VfoInfo[i].FREQUENCY_DEVIATION_SETTING == FREQUENCY_DEVIATION_ADD) {
memcpy(pLine1 + 128 + 54, BITMAP_Add, sizeof(BITMAP_Add));
}