BRNSystems/brnQuanFW
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Testing
All checks were successful
Build Firmware / build (push) Successful in 2m2s
Details

Browse Source
This commit is contained in:
Bruno Rybársky
2025-06-03 22:17:31 +02:00
parent bbeb1d8fab
commit 8e48a5f4c5
7 changed files with 201 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -14,7 +14,7 @@ ENABLE_ALARM ?= 0
ENABLE_TX1750 ?= 0 ENABLE_TX1750 ?= 0
ENABLE_PWRON_PASSWORD ?= 0 ENABLE_PWRON_PASSWORD ?= 0
ENABLE_DTMF_CALLING ?= 0 ENABLE_DTMF_CALLING ?= 0
ENABLE_FLASHLIGHT ?= 1 ENABLE_FLASHLIGHT ?= 0
# ---- CUSTOM MODS ---- # ---- CUSTOM MODS ----
ENABLE_SPECTRUM ?= 1 ENABLE_SPECTRUM ?= 1

2
app/app.c
View File

@@ -29,10 +29,10 @@
#include "app/chFrScanner.h" #include "app/chFrScanner.h"
#include "app/dtmf.h" #include "app/dtmf.h"
#include "../ui/fmradio.h"
#ifdef ENABLE_FLASHLIGHT #ifdef ENABLE_FLASHLIGHT
#include "app/flashlight.h" #include "app/flashlight.h"
#include "../ui/fmradio.h"
#endif #endif
#ifdef ENABLE_FMRADIO #ifdef ENABLE_FMRADIO

303
app/fm.c
View File

@@ -31,22 +31,22 @@
#include "settings.h" #include "settings.h"
#include "ui/inputbox.h" #include "ui/inputbox.h"
#include "ui/ui.h" #include "ui/ui.h"
#include "driver/systick.h"
#ifndef ARRAY_SIZE #ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
#endif #endif
uint16_t gFM_Channels[20]; uint16_t gFM_Channels[20];
bool gFmRadioMode; bool gFmRadioMode;
uint8_t gFmRadioCountdown_500ms; uint8_t gFmRadioCountdown_500ms;
volatile uint16_t gFmPlayCountdown_10ms; volatile uint16_t gFmPlayCountdown_10ms;
volatile int8_t gFM_ScanState; volatile int8_t gFM_ScanState;
bool gFM_AutoScan; bool gFM_AutoScan;
uint8_t gFM_ChannelPosition; uint8_t gFM_ChannelPosition;
bool gFM_FoundFrequency; bool gFM_FoundFrequency;
bool gFM_AutoScan; bool gFM_AutoScan;
uint16_t gFM_RestoreCountdown_10ms; uint16_t gFM_RestoreCountdown_10ms;
const uint8_t BUTTON_STATE_PRESSED = 1 << 0; const uint8_t BUTTON_STATE_PRESSED = 1 << 0;
@@ -54,21 +54,19 @@ const uint8_t BUTTON_STATE_HELD = 1 << 1;
const uint8_t BUTTON_EVENT_PRESSED = BUTTON_STATE_PRESSED; const uint8_t BUTTON_EVENT_PRESSED = BUTTON_STATE_PRESSED;
const uint8_t BUTTON_EVENT_HELD = BUTTON_STATE_PRESSED | BUTTON_STATE_HELD; const uint8_t BUTTON_EVENT_HELD = BUTTON_STATE_PRESSED | BUTTON_STATE_HELD;
const uint8_t BUTTON_EVENT_SHORT = 0; const uint8_t BUTTON_EVENT_SHORT = 0;
const uint8_t BUTTON_EVENT_LONG = BUTTON_STATE_HELD; const uint8_t BUTTON_EVENT_LONG = BUTTON_STATE_HELD;
static void Key_FUNC(KEY_Code_t Key, uint8_t state); static void Key_FUNC(KEY_Code_t Key, uint8_t state);
bool FM_CheckValidChannel(uint8_t Channel) bool FM_CheckValidChannel(uint8_t Channel) {
{ return Channel < ARRAY_SIZE(gFM_Channels) &&
return Channel < ARRAY_SIZE(gFM_Channels) && gFM_Channels[Channel] >= BK1080_GetFreqLoLimit(gEeprom.FM_Band) &&
gFM_Channels[Channel] >= BK1080_GetFreqLoLimit(gEeprom.FM_Band) && gFM_Channels[Channel] < BK1080_GetFreqHiLimit(gEeprom.FM_Band);
gFM_Channels[Channel] < BK1080_GetFreqHiLimit(gEeprom.FM_Band);
} }
uint8_t FM_FindNextChannel(uint8_t Channel, uint8_t Direction) uint8_t FM_FindNextChannel(uint8_t Channel, uint8_t Direction) {
{
for (unsigned i = 0; i < ARRAY_SIZE(gFM_Channels); i++) { for (unsigned i = 0; i < ARRAY_SIZE(gFM_Channels); i++) {
if (Channel == 0xFF) if (Channel == 0xFF)
Channel = ARRAY_SIZE(gFM_Channels) - 1; Channel = ARRAY_SIZE(gFM_Channels) - 1;
@@ -82,8 +80,7 @@ uint8_t FM_FindNextChannel(uint8_t Channel, uint8_t Direction)
return 0xFF; return 0xFF;
} }
int FM_ConfigureChannelState(void) int FM_ConfigureChannelState(void) {
{
gEeprom.FM_FrequencyPlaying = gEeprom.FM_SelectedFrequency; gEeprom.FM_FrequencyPlaying = gEeprom.FM_SelectedFrequency;
if (gEeprom.FM_IsMrMode) { if (gEeprom.FM_IsMrMode) {
@@ -92,17 +89,16 @@ int FM_ConfigureChannelState(void)
gEeprom.FM_IsMrMode = false; gEeprom.FM_IsMrMode = false;
return -1; return -1;
} }
gEeprom.FM_SelectedChannel = Channel; gEeprom.FM_SelectedChannel = Channel;
gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel]; gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel];
} }
return 0; return 0;
} }
void FM_TurnOff(void) void FM_TurnOff(void) {
{ gFmRadioMode = false;
gFmRadioMode = false; gFM_ScanState = FM_SCAN_OFF;
gFM_ScanState = FM_SCAN_OFF;
gFM_RestoreCountdown_10ms = 0; gFM_RestoreCountdown_10ms = 0;
AUDIO_AudioPathOff(); AUDIO_AudioPathOff();
@@ -110,17 +106,16 @@ void FM_TurnOff(void)
BK1080_Init0(); BK1080_Init0();
gUpdateStatus = true; gUpdateStatus = true;
#ifdef ENABLE_FEAT_F4HWN_RESUME_STATE #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
gEeprom.CURRENT_STATE = 0; gEeprom.CURRENT_STATE = 0;
SETTINGS_WriteCurrentState(); SETTINGS_WriteCurrentState();
#endif #endif
} }
void FM_EraseChannels(void) void FM_EraseChannels(void) {
{ uint8_t Template[8];
uint8_t Template[8];
memset(Template, 0xFF, sizeof(Template)); memset(Template, 0xFF, sizeof(Template));
for (unsigned i = 0; i < 5; i++) for (unsigned i = 0; i < 5; i++)
@@ -129,18 +124,18 @@ void FM_EraseChannels(void)
memset(gFM_Channels, 0xFF, sizeof(gFM_Channels)); memset(gFM_Channels, 0xFF, sizeof(gFM_Channels));
} }
void FM_Tune(uint16_t Frequency, int8_t Step, bool bFlag) void FM_Tune(uint16_t Frequency, int8_t Step, bool bFlag) {
{
AUDIO_AudioPathOff(); AUDIO_AudioPathOff();
gEnableSpeaker = false; gEnableSpeaker = false;
gFmPlayCountdown_10ms = (gFM_ScanState == FM_SCAN_OFF) ? fm_play_countdown_noscan_10ms : fm_play_countdown_scan_10ms; gFmPlayCountdown_10ms = (gFM_ScanState == FM_SCAN_OFF) ? fm_play_countdown_noscan_10ms
: fm_play_countdown_scan_10ms;
gScheduleFM = false; gScheduleFM = false;
gFM_FoundFrequency = false; gFM_FoundFrequency = false;
gAskToSave = false; gAskToSave = false;
gAskToDelete = false; gAskToDelete = false;
gEeprom.FM_FrequencyPlaying = Frequency; gEeprom.FM_FrequencyPlaying = Frequency;
if (!bFlag) { if (!bFlag) {
@@ -158,12 +153,11 @@ void FM_Tune(uint16_t Frequency, int8_t Step, bool bFlag)
BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/); BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
} }
void FM_PlayAndUpdate(void) void FM_PlayAndUpdate(void) {
{
gFM_ScanState = FM_SCAN_OFF; gFM_ScanState = FM_SCAN_OFF;
if (gFM_AutoScan) { if (gFM_AutoScan) {
gEeprom.FM_IsMrMode = true; gEeprom.FM_IsMrMode = true;
gEeprom.FM_SelectedChannel = 0; gEeprom.FM_SelectedChannel = 0;
} }
@@ -172,16 +166,15 @@ void FM_PlayAndUpdate(void)
SETTINGS_SaveFM(); SETTINGS_SaveFM();
gFmPlayCountdown_10ms = 0; gFmPlayCountdown_10ms = 0;
gScheduleFM = false; gScheduleFM = false;
gAskToSave = false; gAskToSave = false;
AUDIO_AudioPathOn(); AUDIO_AudioPathOn();
gEnableSpeaker = true; gEnableSpeaker = true;
} }
int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit) int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit) {
{
int ret = -1; int ret = -1;
const uint16_t Test2 = BK1080_ReadRegister(BK1080_REG_07_TEST1); const uint16_t Test2 = BK1080_ReadRegister(BK1080_REG_07_TEST1);
@@ -191,7 +184,7 @@ int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
if (BK1080_REG_07_GET_SNR(Test2) <= 2) { if (BK1080_REG_07_GET_SNR(Test2) <= 2) {
BK1080_FrequencyDeviation = Deviation; BK1080_FrequencyDeviation = Deviation;
BK1080_BaseFrequency = Frequency; BK1080_BaseFrequency = Frequency;
return ret; return ret;
} }
@@ -200,7 +193,7 @@ int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
if ((Status & BK1080_REG_10_MASK_AFCRL) != BK1080_REG_10_AFCRL_NOT_RAILED || BK1080_REG_10_GET_RSSI(Status) < 10) { if ((Status & BK1080_REG_10_MASK_AFCRL) != BK1080_REG_10_AFCRL_NOT_RAILED || BK1080_REG_10_GET_RSSI(Status) < 10) {
BK1080_FrequencyDeviation = Deviation; BK1080_FrequencyDeviation = Deviation;
BK1080_BaseFrequency = Frequency; BK1080_BaseFrequency = Frequency;
return ret; return ret;
} }
@@ -208,17 +201,16 @@ int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
//if (Deviation > -281 && Deviation < 280) //if (Deviation > -281 && Deviation < 280)
if (Deviation >= 280 && Deviation <= 3815) { if (Deviation >= 280 && Deviation <= 3815) {
BK1080_FrequencyDeviation = Deviation; BK1080_FrequencyDeviation = Deviation;
BK1080_BaseFrequency = Frequency; BK1080_BaseFrequency = Frequency;
return ret; return ret;
} }
// not BLE(less than or equal) // not BLE(less than or equal)
if (Frequency > LowerLimit && (Frequency - BK1080_BaseFrequency) == 1) { if (Frequency > LowerLimit && (Frequency - BK1080_BaseFrequency) == 1) {
if (BK1080_FrequencyDeviation & 0x800 || (BK1080_FrequencyDeviation < 20)) if (BK1080_FrequencyDeviation & 0x800 || (BK1080_FrequencyDeviation < 20)) {
{
BK1080_FrequencyDeviation = Deviation; BK1080_FrequencyDeviation = Deviation;
BK1080_BaseFrequency = Frequency; BK1080_BaseFrequency = Frequency;
return ret; return ret;
} }
@@ -227,10 +219,9 @@ int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
// not BLT(less than) // not BLT(less than)
if (Frequency >= LowerLimit && (BK1080_BaseFrequency - Frequency) == 1) { if (Frequency >= LowerLimit && (BK1080_BaseFrequency - Frequency) == 1) {
if ((BK1080_FrequencyDeviation & 0x800) == 0 || (BK1080_FrequencyDeviation > 4075)) if ((BK1080_FrequencyDeviation & 0x800) == 0 || (BK1080_FrequencyDeviation > 4075)) {
{
BK1080_FrequencyDeviation = Deviation; BK1080_FrequencyDeviation = Deviation;
BK1080_BaseFrequency = Frequency; BK1080_BaseFrequency = Frequency;
return ret; return ret;
} }
@@ -238,14 +229,15 @@ int FM_CheckFrequencyLock(uint16_t Frequency, uint16_t LowerLimit)
ret = 0; ret = 0;
BK1080_FrequencyDeviation = Deviation; BK1080_FrequencyDeviation = Deviation;
BK1080_BaseFrequency = Frequency; BK1080_BaseFrequency = Frequency;
return ret; return ret;
} }
static void Key_DIGITS(KEY_Code_t Key, uint8_t state) static void Key_DIGITS(KEY_Code_t Key, uint8_t state) {
{ enum {
enum { STATE_FREQ_MODE, STATE_MR_MODE, STATE_SAVE }; STATE_FREQ_MODE, STATE_MR_MODE, STATE_SAVE
};
if (state == BUTTON_EVENT_SHORT && !gWasFKeyPressed) { if (state == BUTTON_EVENT_SHORT && !gWasFKeyPressed) {
uint8_t State; uint8_t State;
@@ -257,8 +249,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
if (gAskToSave) { if (gAskToSave) {
State = STATE_SAVE; State = STATE_SAVE;
} } else {
else {
if (gFM_ScanState != FM_SCAN_OFF) { if (gFM_ScanState != FM_SCAN_OFF) {
gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
return; return;
@@ -278,20 +269,20 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
gInputBox[0] = 0; gInputBox[0] = 0;
gInputBoxIndex = 2; gInputBoxIndex = 2;
} }
} } else if (gInputBoxIndex > 3) {
else if (gInputBoxIndex > 3) {
uint32_t Frequency; uint32_t Frequency;
gInputBoxIndex = 0; gInputBoxIndex = 0;
Frequency = StrToUL(INPUTBOX_GetAscii()); Frequency = StrToUL(INPUTBOX_GetAscii());
if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band) || BK1080_GetFreqHiLimit(gEeprom.FM_Band) < Frequency) { if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band) ||
gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; BK1080_GetFreqHiLimit(gEeprom.FM_Band) < Frequency) {
gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
gRequestDisplayScreen = DISPLAY_FM; gRequestDisplayScreen = DISPLAY_FM;
return; return;
} }
gEeprom.FM_SelectedFrequency = (uint16_t)Frequency; gEeprom.FM_SelectedFrequency = (uint16_t) Frequency;
#ifdef ENABLE_VOICE #ifdef ENABLE_VOICE
gAnotherVoiceID = (VOICE_ID_t)Key; gAnotherVoiceID = (VOICE_ID_t)Key;
#endif #endif
@@ -300,8 +291,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
gRequestSaveFM = true; gRequestSaveFM = true;
return; return;
} }
} } else if (gInputBoxIndex == 2) {
else if (gInputBoxIndex == 2) {
uint8_t Channel; uint8_t Channel;
gInputBoxIndex = 0; gInputBoxIndex = 0;
@@ -318,8 +308,7 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
gRequestSaveFM = true; gRequestSaveFM = true;
return; return;
} }
} } else if (Channel < 20) {
else if (Channel < 20) {
#ifdef ENABLE_VOICE #ifdef ENABLE_VOICE
gAnotherVoiceID = (VOICE_ID_t)Key; gAnotherVoiceID = (VOICE_ID_t)Key;
#endif #endif
@@ -336,19 +325,17 @@ static void Key_DIGITS(KEY_Code_t Key, uint8_t state)
#ifdef ENABLE_VOICE #ifdef ENABLE_VOICE
gAnotherVoiceID = (VOICE_ID_t)Key; gAnotherVoiceID = (VOICE_ID_t)Key;
#endif #endif
} } else
else
Key_FUNC(Key, state); Key_FUNC(Key, state);
} }
static void Key_FUNC(KEY_Code_t Key, uint8_t state) static void Key_FUNC(KEY_Code_t Key, uint8_t state) {
{
if (state == BUTTON_EVENT_SHORT || state == BUTTON_EVENT_HELD) { if (state == BUTTON_EVENT_SHORT || state == BUTTON_EVENT_HELD) {
bool autoScan = gWasFKeyPressed || (state == BUTTON_EVENT_HELD); bool autoScan = gWasFKeyPressed || (state == BUTTON_EVENT_HELD);
gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL; gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
gWasFKeyPressed = false; gWasFKeyPressed = false;
gUpdateStatus = true; gUpdateStatus = true;
gRequestDisplayScreen = DISPLAY_FM; gRequestDisplayScreen = DISPLAY_FM;
switch (Key) { switch (Key) {
@@ -361,10 +348,10 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
gRequestSaveFM = true; gRequestSaveFM = true;
break; break;
// case KEY_2: // case KEY_2:
// gEeprom.FM_Space = (gEeprom.FM_Space + 1) % 3; // gEeprom.FM_Space = (gEeprom.FM_Space + 1) % 3;
// gRequestSaveFM = true; // gRequestSaveFM = true;
// break; // break;
case KEY_3: case KEY_3:
gEeprom.FM_IsMrMode = !gEeprom.FM_IsMrMode; gEeprom.FM_IsMrMode = !gEeprom.FM_IsMrMode;
@@ -372,32 +359,99 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
if (!FM_ConfigureChannelState()) { if (!FM_ConfigureChannelState()) {
BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/); BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
gRequestSaveFM = true; gRequestSaveFM = true;
} } else
else
gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
break; break;
case KEY_4: case KEY_4:
gEeprom.BK1080_AGC_ENABLED = !gEeprom.BK1080_AGC_ENABLED; gEeprom.BK1080_AGC_ENABLED = !gEeprom.BK1080_AGC_ENABLED;
BK1080_UpdateSysconf(); BK1080_UpdateSysconf();
gRequestSaveSettings = true; gRequestSaveSettings = true;
gRequestSaveFM = true; gRequestSaveFM = true;
break; break;
case KEY_5: case KEY_5:
gEeprom.BK1080_DEEMPHASIS_CONFIG++; gEeprom.BK1080_DEEMPHASIS_CONFIG++;
BK1080_UpdateSysconf(); BK1080_UpdateSysconf();
gRequestSaveSettings = true; gRequestSaveSettings = true;
gRequestSaveFM = true; gRequestSaveFM = true;
break; break;
case KEY_6: case KEY_6:
gEeprom.BK1080_BLEND_CONFIG++; gEeprom.BK1080_BLEND_CONFIG++;
BK1080_UpdateSysconf(); BK1080_UpdateSysconf();
gRequestSaveSettings = true; gRequestSaveSettings = true;
gRequestSaveFM = true; gRequestSaveFM = true;
break; break;
case KEY_7:
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, true);
// mask just in case
uint32_t id24 = 0x00A38C;
uint8_t btn = 0x04;
uint8_t out[10];
// 3-byte big-endian ID
out[0] = (id24 >> 16) & 0xFF;
out[1] = (id24 >> 8) & 0xFF;
out[2] = (id24 >> 0) & 0xFF;
// first nibble<6C>\redundancy copy: 0xBB if btn=0xB
out[3] = (btn << 4) | 0x04;
// second copy with MSB flipped (btn ^ 0x8) in the high nibble
out[4] = ((btn ^ 0x8) << 4);
BK4819_EnterTxMute();
RADIO_SetTxParameters();
BK4819_WriteRegister(BK4819_REG_70, BK4819_REG_70_ENABLE_TONE1 |
((127 & 0x7f) << BK4819_REG_70_SHIFT_TONE1_TUNING_GAIN));
uint16_t datX = BK4819_REG_30_ENABLE_VCO_CALIB |
BK4819_REG_30_ENABLE_UNKNOWN |
BK4819_REG_30_DISABLE_RX_LINK |
BK4819_REG_30_DISABLE_AF_DAC |
BK4819_REG_30_ENABLE_DISC_MODE |
BK4819_REG_30_ENABLE_PLL_VCO |
BK4819_REG_30_ENABLE_PA_GAIN |
BK4819_REG_30_DISABLE_MIC_ADC |
BK4819_REG_30_ENABLE_TX_DSP |
BK4819_REG_30_DISABLE_RX_DSP;
BK4819_WriteRegister(BK4819_REG_30,
datX);
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
SYSTEM_DelayMs(20);
for (unsigned int x = 0; x < 24; x++) {
for (unsigned int y = 0; y < sizeof(out); y++) {
for (unsigned char i = 7; i < 8; i--) {
if ((out[y] >> i) & 1) {
// datX |= BK4819_REG_30_ENABLE_PA_GAIN;
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, true);
SYSTICK_DelayUs(400 * 3 - 350);
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
// datX &= ~BK4819_REG_30_ENABLE_PA_GAIN;
SYSTICK_DelayUs(400 * 1 - 350);
} else {
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, true);
// datX |= BK4819_REG_30_ENABLE_PA_GAIN;
SYSTICK_DelayUs(400 * 1 - 350);
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
// datX &= ~BK4819_REG_30_ENABLE_PA_GAIN;
SYSTICK_DelayUs(400 * 3 - 350);
}
}
}
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
SYSTEM_DelayMs(3);
}
BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false);
SYSTEM_DelayMs(100);
BK4819_WriteRegister(BK4819_REG_30, 0xC1FE);
BK4819_ToggleGpioOut(BK4819_GPIO6_PIN2_GREEN, false);
break;
case KEY_STAR: case KEY_STAR:
ACTION_Scan(autoScan); ACTION_Scan(autoScan);
break; break;
@@ -409,8 +463,7 @@ static void Key_FUNC(KEY_Code_t Key, uint8_t state)
} }
} }
static void Key_EXIT(uint8_t state) static void Key_EXIT(uint8_t state) {
{
gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL; gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
if (state == BUTTON_EVENT_SHORT) { if (state == BUTTON_EVENT_SHORT) {
@@ -424,10 +477,9 @@ static void Key_EXIT(uint8_t state)
return; return;
} }
gAskToSave = false; gAskToSave = false;
gAskToDelete = false; gAskToDelete = false;
} } else {
else {
gInputBox[--gInputBoxIndex] = 10; gInputBox[--gInputBoxIndex] = 10;
if (gInputBoxIndex) { if (gInputBoxIndex) {
@@ -447,8 +499,7 @@ static void Key_EXIT(uint8_t state)
#ifdef ENABLE_VOICE #ifdef ENABLE_VOICE
gAnotherVoiceID = VOICE_ID_CANCEL; gAnotherVoiceID = VOICE_ID_CANCEL;
#endif #endif
} } else {
else {
FM_PlayAndUpdate(); FM_PlayAndUpdate();
#ifdef ENABLE_VOICE #ifdef ENABLE_VOICE
gAnotherVoiceID = VOICE_ID_SCANNING_STOP; gAnotherVoiceID = VOICE_ID_SCANNING_STOP;
@@ -458,14 +509,13 @@ static void Key_EXIT(uint8_t state)
gRequestDisplayScreen = DISPLAY_FM; gRequestDisplayScreen = DISPLAY_FM;
} }
static void Key_MENU(uint8_t state) static void Key_MENU(uint8_t state) {
{
if (state != BUTTON_EVENT_SHORT) if (state != BUTTON_EVENT_SHORT)
return; return;
gRequestDisplayScreen = DISPLAY_FM; gRequestDisplayScreen = DISPLAY_FM;
gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL; gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
if (gFM_ScanState == FM_SCAN_OFF) { if (gFM_ScanState == FM_SCAN_OFF) {
if (!gEeprom.FM_IsMrMode) { if (!gEeprom.FM_IsMrMode) {
@@ -474,8 +524,7 @@ static void Key_MENU(uint8_t state)
gRequestSaveFM = true; gRequestSaveFM = true;
} }
gAskToSave = !gAskToSave; gAskToSave = !gAskToSave;
} } else {
else {
if (gAskToDelete) { if (gAskToDelete) {
gFM_Channels[gEeprom.FM_SelectedChannel] = 0xFFFF; gFM_Channels[gEeprom.FM_SelectedChannel] = 0xFFFF;
@@ -486,10 +535,9 @@ static void Key_MENU(uint8_t state)
} }
gAskToDelete = !gAskToDelete; gAskToDelete = !gAskToDelete;
} }
} } else {
else {
if (gFM_AutoScan || !gFM_FoundFrequency) { if (gFM_AutoScan || !gFM_FoundFrequency) {
gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
gInputBoxIndex = 0; gInputBoxIndex = 0;
return; return;
} }
@@ -502,8 +550,7 @@ static void Key_MENU(uint8_t state)
} }
} }
static void Key_UP_DOWN(uint8_t state, int8_t Step) static void Key_UP_DOWN(uint8_t state, int8_t Step) {
{
if (state == BUTTON_EVENT_PRESSED) { if (state == BUTTON_EVENT_PRESSED) {
if (gInputBoxIndex) { if (gInputBoxIndex) {
gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL; gBeepToPlay = BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL;
@@ -511,13 +558,13 @@ static void Key_UP_DOWN(uint8_t state, int8_t Step)
} }
gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL; gBeepToPlay = BEEP_1KHZ_60MS_OPTIONAL;
} else if (gInputBoxIndex || state!=BUTTON_EVENT_HELD) { } else if (gInputBoxIndex || state != BUTTON_EVENT_HELD) {
return; return;
} }
if (gAskToSave) { if (gAskToSave) {
gRequestDisplayScreen = DISPLAY_FM; gRequestDisplayScreen = DISPLAY_FM;
gFM_ChannelPosition = NUMBER_AddWithWraparound(gFM_ChannelPosition, Step, 0, 19); gFM_ChannelPosition = NUMBER_AddWithWraparound(gFM_ChannelPosition, Step, 0, 19);
return; return;
} }
@@ -537,10 +584,9 @@ static void Key_UP_DOWN(uint8_t state, int8_t Step)
if (Channel == 0xFF || gEeprom.FM_SelectedChannel == Channel) if (Channel == 0xFF || gEeprom.FM_SelectedChannel == Channel)
goto Bail; goto Bail;
gEeprom.FM_SelectedChannel = Channel; gEeprom.FM_SelectedChannel = Channel;
gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel]; gEeprom.FM_FrequencyPlaying = gFM_Channels[Channel];
} } else {
else {
uint16_t Frequency = gEeprom.FM_SelectedFrequency + Step; uint16_t Frequency = gEeprom.FM_SelectedFrequency + Step;
if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band)) if (Frequency < BK1080_GetFreqLoLimit(gEeprom.FM_Band))
@@ -548,20 +594,19 @@ static void Key_UP_DOWN(uint8_t state, int8_t Step)
else if (Frequency > BK1080_GetFreqHiLimit(gEeprom.FM_Band)) else if (Frequency > BK1080_GetFreqHiLimit(gEeprom.FM_Band))
Frequency = BK1080_GetFreqLoLimit(gEeprom.FM_Band); Frequency = BK1080_GetFreqLoLimit(gEeprom.FM_Band);
gEeprom.FM_FrequencyPlaying = Frequency; gEeprom.FM_FrequencyPlaying = Frequency;
gEeprom.FM_SelectedFrequency = gEeprom.FM_FrequencyPlaying; gEeprom.FM_SelectedFrequency = gEeprom.FM_FrequencyPlaying;
} }
gRequestSaveFM = true; gRequestSaveFM = true;
Bail: Bail:
BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/); BK1080_SetFrequency(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
gRequestDisplayScreen = DISPLAY_FM; gRequestDisplayScreen = DISPLAY_FM;
} }
void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld) void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld) {
{
uint8_t state = bKeyPressed + 2 * bKeyHeld; uint8_t state = bKeyPressed + 2 * bKeyHeld;
switch (Key) { switch (Key) {
@@ -597,12 +642,11 @@ void FM_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld)
GUI_DisplayScreen(); GUI_DisplayScreen();
} }
void FM_Play(void) void FM_Play(void) {
{
if (!FM_CheckFrequencyLock(gEeprom.FM_FrequencyPlaying, BK1080_GetFreqLoLimit(gEeprom.FM_Band))) { if (!FM_CheckFrequencyLock(gEeprom.FM_FrequencyPlaying, BK1080_GetFreqLoLimit(gEeprom.FM_Band))) {
if (!gFM_AutoScan) { if (!gFM_AutoScan) {
gFmPlayCountdown_10ms = 0; gFmPlayCountdown_10ms = 0;
gFM_FoundFrequency = true; gFM_FoundFrequency = true;
if (!gEeprom.FM_IsMrMode) if (!gEeprom.FM_IsMrMode)
gEeprom.FM_SelectedFrequency = gEeprom.FM_FrequencyPlaying; gEeprom.FM_SelectedFrequency = gEeprom.FM_FrequencyPlaying;
@@ -632,24 +676,23 @@ void FM_Play(void)
GUI_SelectNextDisplay(DISPLAY_FM); GUI_SelectNextDisplay(DISPLAY_FM);
} }
void FM_Start(void) void FM_Start(void) {
{ gDualWatchActive = false;
gDualWatchActive = false; gFmRadioMode = true;
gFmRadioMode = true; gFM_ScanState = FM_SCAN_OFF;
gFM_ScanState = FM_SCAN_OFF;
gFM_RestoreCountdown_10ms = 0; gFM_RestoreCountdown_10ms = 0;
BK1080_Init(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/); BK1080_Init(gEeprom.FM_FrequencyPlaying, gEeprom.FM_Band/*, gEeprom.FM_Space*/);
AUDIO_AudioPathOn(); AUDIO_AudioPathOn();
gEnableSpeaker = true; gEnableSpeaker = true;
gUpdateStatus = true; gUpdateStatus = true;
#ifdef ENABLE_FEAT_F4HWN_RESUME_STATE #ifdef ENABLE_FEAT_F4HWN_RESUME_STATE
gEeprom.CURRENT_STATE = 3; gEeprom.CURRENT_STATE = 3;
SETTINGS_WriteCurrentState(); SETTINGS_WriteCurrentState();
#endif #endif
} }
#endif #endif

4
app/fskmodem.c
View File

@@ -30,8 +30,10 @@ typedef enum {
RXState rxState = Ready; RXState rxState = Ready;
uint8_t SMSResponseCounterTarget = 6;
void FSKModem_TimeSlice500ms(void) { void FSKModem_TimeSlice500ms(void) {
if (SMSResponseCounter && SMSResponseCounter++ > 6) { if (SMSResponseCounter && FUNCTION_IsRx() && SMSResponseCounter++ > SMSResponseCounterTarget) {
switch (gSMSResponseState) { switch (gSMSResponseState) {
case SMS_RESPONSE_ACK: case SMS_RESPONSE_ACK:
MSG_FSKSendData(&inBoundPacket); MSG_FSKSendData(&inBoundPacket);

14
radio.c
View File

@@ -235,7 +235,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel)) { if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel)) {
uint8_t tmp; uint8_t tmp;
uint8_t data[10]; uint8_t data[8];
// *************** // ***************
@@ -256,12 +256,6 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
pVfo->STEP_SETTING = tmp; pVfo->STEP_SETTING = tmp;
pVfo->StepFrequency = gStepFrequencyTable[tmp]; pVfo->StepFrequency = gStepFrequencyTable[tmp];
tmp = data[8];
pVfo->SCRAMBLING_TYPE = tmp ;
tmp = data[9];
pVfo->SCRAMBLING_TYPE |= tmp << 8;
//pVfo->SCRAMBLING_TYPE = 0;
pVfo->freq_config_RX.CodeType = (data[2] >> 0) & 0x0F; pVfo->freq_config_RX.CodeType = (data[2] >> 0) & 0x0F;
pVfo->freq_config_TX.CodeType = (data[2] >> 4) & 0x0F; pVfo->freq_config_TX.CodeType = (data[2] >> 4) & 0x0F;
@@ -335,6 +329,12 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure
// *************** // ***************
EEPROM_ReadBuffer(base + 16, data, sizeof(data));
uint16_t * data16 = (uint16_t *)data;
pVfo->SCRAMBLING_TYPE = data16[0];
struct { struct {
uint32_t Frequency; uint32_t Frequency;
uint32_t Offset; uint32_t Offset;

4
settings.c
View File

@@ -798,12 +798,12 @@ void SETTINGS_SaveChannel(uint8_t Channel, uint8_t VFO, const VFO_Info_t *pVFO,
#endif #endif
; ;
State._8[6] = pVFO->STEP_SETTING; State._8[6] = pVFO->STEP_SETTING;
EEPROM_WriteBuffer(OffsetVFO + sizeof (State._32), State._8);
State._16[0] = pVFO->SCRAMBLING_TYPE; State._16[0] = pVFO->SCRAMBLING_TYPE;
EEPROM_WriteBuffer(OffsetVFO + sizeof (State._32), State._8);
EEPROM_WriteBuffer(OffsetVFO + sizeof (State._32) + sizeof (State._8), State._16); EEPROM_WriteBuffer(OffsetVFO + sizeof (State._32) + sizeof (State._8), State._16);
SETTINGS_UpdateChannel(Channel, pVFO, true, true, true); SETTINGS_UpdateChannel(Channel, pVFO, true, true, true);
if (IS_MR_CHANNEL(Channel)) { if (IS_MR_CHANNEL(Channel)) {

14
ui/status.c
View File

@@ -54,6 +54,17 @@ static void convertTime(uint8_t *line, uint8_t type)
#endif #endif
#endif #endif
//static const char* const FunctionStrings[] = {
// [FUNCTION_FOREGROUND] = "FG",
// [FUNCTION_TRANSMIT] = "TX",
// [FUNCTION_MONITOR] = "MON",
// [FUNCTION_INCOMING] = "INC",
// [FUNCTION_RECEIVE] = "RX",
// [FUNCTION_POWER_SAVE] = "PWS",
// [FUNCTION_BAND_SCOPE] = "BS",
// [FUNCTION_N_ELEM] = "NE"
//};
void UI_DisplayStatus() void UI_DisplayStatus()
{ {
char str[8] = ""; char str[8] = "";
@@ -276,5 +287,8 @@ void UI_DisplayStatus()
// ************** // **************
// x2 -= (7 * strlen(str));
// UI_PrintStringSmallBufferNormal(FunctionStrings[gCurrentFunction], line + x2 - 20);
ST7565_BlitStatusLine(); ST7565_BlitStatusLine();
} }