mirrors/uv-k5-firmware-custom
0
Fork 0
mirror of https://github.com/OneOfEleven/uv-k5-firmware-custom.git synced 2025-04-27 13:51:25 +03:00
Code Issues Releases Activity
uv-k5-firmware-custom/radio.c

1312 lines
37 KiB
C
Raw Permalink Blame History

/* Copyright 2023 Dual Tachyon
* https://github.com/DualTachyon
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "app/app.h"
#include "app/dtmf.h"
#ifdef ENABLE_FMRADIO
#include "app/fm.h"
#endif
#ifdef ENABLE_AM_FIX
#include "am_fix.h"
#endif
#include "audio.h"
#include "board.h"
#include "bsp/dp32g030/gpio.h"
#include "dcs.h"
#include "driver/bk4819.h"
#include "driver/eeprom.h"
#include "driver/gpio.h"
#include "driver/system.h"
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
#include "driver/uart.h"
#endif
#include "frequencies.h"
#include "functions.h"
#include "helper/battery.h"
#ifdef ENABLE_MDC1200
#include "mdc1200.h"
#endif
#include "misc.h"
#ifdef ENABLE_PANADAPTER
#include "panadapter.h"
#endif
#include "radio.h"
#include "settings.h"
#include "ui/menu.h"
#include "ui/ui.h"
vfo_info_t g_vfo_info[2];
vfo_info_t *g_tx_vfo;
vfo_info_t *g_rx_vfo;
vfo_info_t *g_current_vfo;
dcs_code_type_t g_selected_code_type;
dcs_code_type_t g_current_code_type;
uint8_t g_selected_code;
vfo_state_t g_vfo_state[2];
bool RADIO_channel_valid(uint16_t Channel, bool bCheckScanList, uint8_t VFO)
{ // return true if the channel appears valid
unsigned int i;
uint8_t priority_channel[2];
if (Channel > USER_CHANNEL_LAST)
return false;
if (g_eeprom.config.channel_attributes[Channel].band > BAND7_470MHz)
return false;
if (bCheckScanList)
{
switch (VFO)
{
case 0:
if (g_eeprom.config.channel_attributes[Channel].scanlist1 == 0)
return false;
for (i = 0; i < 2; i++)
priority_channel[i] = g_eeprom.config.setting.priority_scan_list[VFO].channel[i];
break;
case 1:
if (g_eeprom.config.channel_attributes[Channel].scanlist2 == 0)
return false;
for (i = 0; i < 2; i++)
priority_channel[i] = g_eeprom.config.setting.priority_scan_list[VFO].channel[i];
break;
default:
return true;
}
if (priority_channel[0] == Channel)
return false;
if (priority_channel[1] == Channel)
return false;
}
return true;
}
uint8_t RADIO_FindNextChannel(uint8_t Channel, scan_state_dir_t Direction, bool bCheckScanList, uint8_t VFO)
{
unsigned int i;
for (i = 0; i <= USER_CHANNEL_LAST; i++)
{
if (Channel == 0xFF)
Channel = USER_CHANNEL_LAST;
else
if (Channel > USER_CHANNEL_LAST)
Channel = USER_CHANNEL_FIRST;
if (RADIO_channel_valid(Channel, bCheckScanList, VFO))
return Channel;
Channel += Direction;
}
return 0xFF;
}
void RADIO_InitInfo(vfo_info_t *p_vfo, const uint8_t ChannelSave, const uint32_t Frequency)
{
if (p_vfo == NULL)
return;
memset(p_vfo, 0, sizeof(*p_vfo));
p_vfo->channel_attributes.band = FREQUENCY_GetBand(Frequency);
p_vfo->channel_attributes.scanlist1 = 1;
p_vfo->channel_attributes.scanlist2 = 1;
p_vfo->channel.step_setting = STEP_12_5kHz;
p_vfo->step_freq = STEP_FREQ_TABLE[p_vfo->channel.step_setting];
p_vfo->channel_save = ChannelSave;
p_vfo->channel.frequency_reverse = false;
p_vfo->channel.tx_power = OUTPUT_POWER_LOW;
p_vfo->freq_config_rx.frequency = Frequency;
p_vfo->freq_config_tx.frequency = Frequency;
p_vfo->p_rx = &p_vfo->freq_config_rx;
p_vfo->p_tx = &p_vfo->freq_config_tx;
p_vfo->channel.compand = COMPAND_OFF;
p_vfo->channel.squelch_level = 0; // use main squelch
p_vfo->freq_in_channel = 0xff;
if (ChannelSave == (FREQ_CHANNEL_FIRST + BAND2_108MHz))
p_vfo->channel.mod_mode = MOD_MODE_AM;
RADIO_ConfigureSquelch(p_vfo);
// RADIO_ConfigureTXPower(p_vfo);
}
void RADIO_configure_channel(const unsigned int VFO, const unsigned int configure)
{
unsigned int channel;
unsigned int chan;
t_channel_attrib attributes;
// uint16_t base;
uint32_t frequency;
vfo_info_t *p_vfo = &g_vfo_info[VFO];
if (!g_eeprom.config.setting.enable_350)
{
if (g_eeprom.config.setting.indices.vfo[VFO].frequency == (FREQ_CHANNEL_LAST - 2))
g_eeprom.config.setting.indices.vfo[VFO].frequency = FREQ_CHANNEL_LAST - 1;
if (g_eeprom.config.setting.indices.vfo[VFO].screen == (FREQ_CHANNEL_LAST - 2))
g_eeprom.config.setting.indices.vfo[VFO].screen = FREQ_CHANNEL_LAST - 1;
}
channel = g_eeprom.config.setting.indices.vfo[VFO].screen;
p_vfo->freq_in_channel = 0xff;
if (IS_VALID_CHANNEL(channel))
{
#ifdef ENABLE_NOAA
if (channel >= NOAA_CHANNEL_FIRST)
{
RADIO_InitInfo(p_vfo, g_eeprom.config.setting.indices.vfo[VFO].screen, NOAA_FREQUENCY_TABLE[channel - NOAA_CHANNEL_FIRST]);
if (g_eeprom.config.setting.cross_vfo == CROSS_BAND_OFF)
return;
g_eeprom.config.setting.cross_vfo = CROSS_BAND_OFF;
g_update_status = true;
return;
}
#endif
if (channel <= USER_CHANNEL_LAST)
{
channel = RADIO_FindNextChannel(channel, SCAN_STATE_DIR_FORWARD, false, VFO);
if (!IS_VALID_CHANNEL(channel))
{
channel = g_eeprom.config.setting.indices.vfo[VFO].frequency;
g_eeprom.config.setting.indices.vfo[VFO].screen = channel;
}
else
{
g_eeprom.config.setting.indices.vfo[VFO].screen = channel;
g_eeprom.config.setting.indices.vfo[VFO].user = channel;
}
}
}
else
{
channel = FREQ_CHANNEL_LAST - 1;
}
chan = CHANNEL_NUM(channel, VFO);
attributes = g_eeprom.config.channel_attributes[channel];
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("config chan 1 %u %u %u %u %u\r\n", channel, chan, attributes.band, attributes.scanlist1, attributes.scanlist2);
#endif
if (attributes.attributes == 0xff)
{ // invalid/unused channel
unsigned int index;
if (channel <= USER_CHANNEL_LAST)
{
channel = g_eeprom.config.setting.indices.vfo[VFO].frequency;
g_eeprom.config.setting.indices.vfo[VFO].screen = channel;
}
index = channel - FREQ_CHANNEL_FIRST;
RADIO_InitInfo(p_vfo, channel, FREQ_BAND_TABLE[index].lower);
return;
}
if (attributes.band > BAND7_470MHz)
attributes.band = BAND6_400MHz;
if (channel <= USER_CHANNEL_LAST)
{ // USER channel
p_vfo->channel_attributes = attributes;
}
else
if (IS_FREQ_CHANNEL(channel))
{ // VFO channel
attributes.band = channel - FREQ_CHANNEL_FIRST;
p_vfo->channel_attributes = attributes;
#if 0
// don't allow the VFO's to change their scanlist bits
p_vfo->channel_attributes.scanlist2 = 1;
p_vfo->channel_attributes.scanlist1 = 1;
#endif
}
p_vfo->channel_save = channel;
// if (channel <= USER_CHANNEL_LAST)
// base = channel * 16;
// else
// base = 0x0C80 + ((channel - FREQ_CHANNEL_FIRST) * 16 * 2) + (VFO * 16); // VFO channel
if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel))
{
// EEPROM_ReadBuffer(Base, &m_channel, sizeof(t_channel));
// EEPROM_ReadBuffer(Base, p_vfo->channel, sizeof(t_channel));
memcpy(&p_vfo->channel, &g_eeprom.config.channel[chan], sizeof(t_channel));
p_vfo->step_freq = STEP_FREQ_TABLE[p_vfo->channel.step_setting];
p_vfo->channel_attributes = g_eeprom.config.channel_attributes[channel];
p_vfo->freq_config_rx.frequency = p_vfo->channel.frequency;
p_vfo->freq_config_rx.code_type = p_vfo->channel.rx_ctcss_cdcss_type;
p_vfo->freq_config_rx.code = p_vfo->channel.rx_ctcss_cdcss_code;
p_vfo->freq_config_tx.code_type = p_vfo->channel.tx_ctcss_cdcss_type;
p_vfo->freq_config_tx.code = p_vfo->channel.tx_ctcss_cdcss_code;
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("config chan 2 %u %u %u %u %u %uHz\r\n", channel, chan, p_vfo->channel_attributes.band, p_vfo->channel_attributes.scanlist1, p_vfo->channel_attributes.scanlist2, p_vfo->channel.frequency * 10);
#endif
}
else
{
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("config chan 3 %u %u %u %u %uHz\r\n", channel, p_vfo->channel_attributes.band, p_vfo->channel_attributes.scanlist1, p_vfo->channel_attributes.scanlist2, p_vfo->channel.frequency * 10);
#endif
}
frequency = p_vfo->freq_config_rx.frequency;
if (frequency < FREQ_BAND_TABLE[attributes.band].lower)
frequency = FREQ_BAND_TABLE[attributes.band].lower;
else
if (frequency >= FREQ_BAND_TABLE[attributes.band].upper)
frequency = FREQUENCY_floor_to_step(frequency, p_vfo->step_freq, FREQ_BAND_TABLE[attributes.band].lower, FREQ_BAND_TABLE[attributes.band].upper);
// else
// if (channel >= FREQ_CHANNEL_FIRST)
// frequency = FREQUENCY_floor_to_step(frequency, p_vfo->step_freq, FREQ_BAND_TABLE[attributes.band].lower, FREQ_BAND_TABLE[attributes.band].upper);
if (!g_eeprom.config.setting.enable_350 && frequency >= 35000000 && frequency < 40000000)
{ // 350~400Mhz not allowed
// hop onto the next band up
frequency = 43350000;
p_vfo->freq_config_rx.frequency = frequency;
p_vfo->freq_config_tx.frequency = frequency;
attributes.band = FREQUENCY_GetBand(frequency);
p_vfo->channel_attributes.band = attributes.band;
p_vfo->channel.frequency_reverse = 0;
p_vfo->channel.tx_offset_dir = TX_OFFSET_FREQ_DIR_OFF;
p_vfo->channel.tx_offset = 0;
// TODO: also update other settings such as step size
}
p_vfo->freq_config_rx.frequency = frequency;
if (frequency >= AIR_BAND.lower && frequency < AIR_BAND.upper)
{ // air band
p_vfo->channel.tx_offset_dir = TX_OFFSET_FREQ_DIR_OFF;
p_vfo->channel.tx_offset = 0;
}
else
if (channel > USER_CHANNEL_LAST)
{
p_vfo->channel.tx_offset = FREQUENCY_floor_to_step(p_vfo->channel.tx_offset + (p_vfo->step_freq / 2), p_vfo->step_freq, 0, p_vfo->channel.tx_offset + p_vfo->step_freq);
}
RADIO_apply_offset(p_vfo, true);
// channel name
memset(&p_vfo->channel_name, 0, sizeof(p_vfo->channel_name));
if (channel <= USER_CHANNEL_LAST)
// EEPROM_ReadBuffer(0x0F50 + (channel * 16), p_vfo->channel_name, 10); // only 10 bytes used
memcpy(p_vfo->channel_name.name, &g_eeprom.config.channel_name[channel].name, sizeof(p_vfo->channel_name.name));
if (p_vfo->channel.mod_mode != MOD_MODE_FM)
{ // freq/chan is in AM mode
// disable stuff, even though it can all still be used with AM ???
p_vfo->channel.scrambler = 0;
// p_vfo->channel.dtmf_decoding_enable = 0;
p_vfo->freq_config_rx.code_type = CODE_TYPE_NONE;
p_vfo->freq_config_tx.code_type = CODE_TYPE_NONE;
}
RADIO_ConfigureSquelch(p_vfo);
// RADIO_ConfigureTXPower(p_vfo);
#ifdef ENABLE_AM_FIX
AM_fix_reset(VFO);
if (p_vfo->channel.mod_mode != MOD_MODE_FM && g_eeprom.config.setting.am_fix)
{
#ifdef ENABLE_PANADAPTER
if (!PAN_scanning())
{
AM_fix_10ms(VFO);
}
else
{ // don't do agc
BK4819_DisableAGC();
BK4819_write_reg(0x13, (g_orig_lnas << 8) | (g_orig_lna << 5) | (g_orig_mixer << 3) | (g_orig_pga << 0));
}
#else
AM_fix_10ms(VFO);
#endif
}
else
{ // don't do agc in FM mode
BK4819_DisableAGC();
BK4819_write_reg(0x13, (g_orig_lnas << 8) | (g_orig_lna << 5) | (g_orig_mixer << 3) | (g_orig_pga << 0));
}
#else
if (p_vfo->mod_mode != MOD_MODE_FM)
{
#ifdef ENABLE_PANADAPTER
if (!PAN_scanning())
{
BK4819_EnableAGC();
}
else
{ // don't do agc
BK4819_DisableAGC();
BK4819_write_reg(0x13, (g_orig_lnas << 8) | (g_orig_lna << 5) | (g_orig_mixer << 3) | (g_orig_pga << 0));
}
#else
BK4819_EnableAGC();
#endif
}
else
{ // don't do agc in FM mode
BK4819_DisableAGC();
BK4819_write_reg(0x13, (g_orig_lnas << 8) | (g_orig_lna << 5) | (g_orig_mixer << 3) | (g_orig_pga << 0));
}
#endif
// if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel))
if (IS_FREQ_CHANNEL(channel))
p_vfo->freq_in_channel = SETTINGS_find_channel(frequency); // find channel that has this frequency
}
#ifdef ENABLE_VOX
void RADIO_enable_vox(unsigned int level)
{
uint16_t threshold_enable;
uint16_t threshold_disable;
if (level > (ARRAY_SIZE(g_eeprom.calib.vox_threshold_enable) - 1))
level = ARRAY_SIZE(g_eeprom.calib.vox_threshold_enable) - 1;
// my eeprom values ..
//
// vox threshold enable 30 50 70 90 110 130 150 170 200 230 FFFF FFFF
// vox threshold disable 20 40 60 80 100 120 140 160 190 220 FFFF FFFF
//
#ifdef ENABLE_VOX_MORE_SENSITIVE
// more sensitive
threshold_enable = g_eeprom.calib.vox_threshold_enable[level] / 3;
threshold_disable = (threshold_enable > 13) ? threshold_enable - 10 : 3;
#else
threshold_enable = g_eeprom.calib.vox_threshold_enable[level];
threshold_disable = g_eeprom.calib.vox_threshold_disable[level];
#endif
BK4819_EnableVox(threshold_enable, threshold_disable);
BK4819_write_reg(0x3F, BK4819_read_reg(0x3F) | BK4819_REG_3F_VOX_FOUND | BK4819_REG_3F_VOX_LOST);
}
#endif
void RADIO_ConfigureSquelch(vfo_info_t *p_vfo)
{
const unsigned int squelch_level = (p_vfo->channel.squelch_level > 0 && p_vfo->channel.squelch_level < 10) ? p_vfo->channel.squelch_level : g_eeprom.config.setting.squelch_level;
// note that 'noise' and 'glitch' values are inverted compared to 'rssi' values
// peters readings, all on 156.550
//
// no antenna no signal r 53 g 83 n 73
// signal generator -100dBm signal r 114 g 0 n 17
// signal generator -110dBm signal r 95 g 0 n 32
// signal generator -120dBm signal r 75 g 0 n 34
//
// ext antenna no signal r 93~133 g 150 n 78
// ext antenna strong signal r 123~160 g 0 n 16~18
if (squelch_level == 0)
{ // squelch == 0 (off)
p_vfo->squelch_open_rssi_thresh = 0; // 0 ~ 255
p_vfo->squelch_close_rssi_thresh = 0; // 0 ~ 255
p_vfo->squelch_open_noise_thresh = 127; // 127 ~ 0
p_vfo->squelch_close_noise_thresh = 127; // 127 ~ 0
p_vfo->squelch_open_glitch_thresh = 255; // 255 ~ 0
p_vfo->squelch_close_glitch_thresh = 255; // 255 ~ 0
}
else
{ // squelch >= 1
// my calibration data
//
// bands 4567
// 0A 4B 53 56 59 5C 5F 62 64 66 FF FF FF FF FF FF // open rssi
// 05 46 50 53 56 59 5C 5F 62 64 FF FF FF FF FF FF // close rssi
// 5A 2D 29 26 23 20 1D 1A 17 14 FF FF FF FF FF FF // open noise
// 64 30 2D 29 26 23 20 1D 1A 17 FF FF FF FF FF FF // close noise
// 5A 14 11 0E 0B 08 03 02 02 02 FF FF FF FF FF FF // open glitch
// 64 11 0E 0B 08 05 05 04 04 04 FF FF FF FF FF FF // close glitch
//
// bands 123
// 32 68 6B 6E 6F 72 75 77 79 7B FF FF FF FF FF FF // open rssi
// 28 64 67 6A 6C 6E 71 73 76 78 FF FF FF FF FF FF // close rssi
// 41 32 2D 28 24 21 1E 1A 17 16 FF FF FF FF FF FF // open noise
// 46 37 32 2D 28 25 22 1E 1B 19 FF FF FF FF FF FF // close noise
// 5A 19 0F 0A 09 08 07 06 05 04 FF FF FF FF FF FF // open glitch
// 64 1E 14 0F 0D 0C 0B 0A 09 08 FF FF FF FF FF FF // close glitch
unsigned int band = (unsigned int)FREQUENCY_GetBand(p_vfo->p_rx->frequency);
band = (band < BAND4_174MHz) ? 1 : 0;
p_vfo->squelch_open_rssi_thresh = g_eeprom.calib.squelch_band[band].open_rssi_thresh[squelch_level];
p_vfo->squelch_close_rssi_thresh = g_eeprom.calib.squelch_band[band].close_rssi_thresh[squelch_level];
p_vfo->squelch_open_noise_thresh = g_eeprom.calib.squelch_band[band].open_noise_thresh[squelch_level];
p_vfo->squelch_close_noise_thresh = g_eeprom.calib.squelch_band[band].close_noise_thresh[squelch_level];
p_vfo->squelch_open_glitch_thresh = g_eeprom.calib.squelch_band[band].open_glitch_thresh[squelch_level];
p_vfo->squelch_close_glitch_thresh = g_eeprom.calib.squelch_band[band].close_glitch_thresh[squelch_level];
// *********
int16_t rssi_open = p_vfo->squelch_open_rssi_thresh; // 0 ~ 255
int16_t rssi_close = p_vfo->squelch_close_rssi_thresh; // 0 ~ 255
int16_t noise_open = p_vfo->squelch_open_noise_thresh; // 127 ~ 0
int16_t noise_close = p_vfo->squelch_close_noise_thresh; // 127 ~ 0
int16_t glitch_open = p_vfo->squelch_open_glitch_thresh; // 255 ~ 0
int16_t glitch_close = p_vfo->squelch_close_glitch_thresh; // 255 ~ 0
// *********
#if ENABLE_SQUELCH_MORE_SENSITIVE
// make squelch a little more sensitive
//
// getting the best general settings here is experimental, bare with me
#if 0
rssi_open = (rssi_open * 8) / 9;
noise_open = (noise_open * 9) / 8;
glitch_open = (glitch_open * 9) / 8;
#else
// even more sensitive .. use when RX bandwidths are fixed (no weak signal auto adjust)
rssi_open = (rssi_open * 1) / 2;
noise_open = (noise_open * 2) / 1;
glitch_open = (glitch_open * 2) / 1;
#endif
// *********
// ensure the 'close' threshold is lower than the 'open' threshold
// ie, maintain a minimum level of hysteresis
rssi_close = (rssi_open * 4) / 6;
noise_close = (noise_open * 6) / 4;
glitch_close = (glitch_open * 6) / 4;
if (rssi_open < 8)
rssi_open = 8;
if (rssi_close > (rssi_open - 8))
rssi_close = rssi_open - 8;
if (noise_open > (127 - 4))
noise_open = 127 - 4;
if (noise_close < (noise_open + 4))
noise_close = noise_open + 4;
if (glitch_open > (255 - 8))
glitch_open = 255 - 8;
if (glitch_close < (glitch_open + 8))
glitch_close = glitch_open + 8;
#else
// a bit more sensitive
rssi_open = (rssi_open * 1) / 2;
noise_open = (noise_open * 2) / 1;
glitch_open = (glitch_open * 2) / 1;
rssi_close = (rssi_close * 1) / 2;
noise_close = (noise_close * 2) / 1;
glitch_close = (glitch_close * 2) / 1;
#endif
// *********
p_vfo->squelch_open_rssi_thresh = (rssi_open > 255) ? 255 : (rssi_open < 0) ? 0 : rssi_open;
p_vfo->squelch_close_rssi_thresh = (rssi_close > 255) ? 255 : (rssi_close < 0) ? 0 : rssi_close;
p_vfo->squelch_open_noise_thresh = (noise_open > 127) ? 127 : (noise_open < 0) ? 0 : noise_open;
p_vfo->squelch_close_noise_thresh = (noise_close > 127) ? 127 : (noise_close < 0) ? 0 : noise_close;
p_vfo->squelch_open_glitch_thresh = (glitch_open > 255) ? 255 : (glitch_open < 0) ? 0 : glitch_open;
p_vfo->squelch_close_glitch_thresh = (glitch_close > 255) ? 255 : (glitch_close < 0) ? 0 : glitch_close;
}
}
void RADIO_ConfigureTXPower(vfo_info_t *p_vfo)
{
// my eeprom calibration data
//
// 1ED0 32 32 32 64 64 64 8C 8C 8C FF FF FF FF FF FF FF .. 50 MHz
// 1EE0 32 32 32 64 64 64 8C 8C 8C FF FF FF FF FF FF FF .. 108 MHz
// 1EF0 5F 5F 5F 69 69 69 91 91 8F FF FF FF FF FF FF FF .. 137 MHz
// 1F00 32 32 32 64 64 64 8C 8C 8C FF FF FF FF FF FF FF .. 174 MHz
// 1F10 5A 5A 5A 64 64 64 82 82 82 FF FF FF FF FF FF FF .. 350 MHz
// 1F20 5A 5A 5A 64 64 64 8F 91 8A FF FF FF FF FF FF FF .. 400 MHz
// 1F30 32 32 32 64 64 64 8C 8C 8C FF FF FF FF FF FF FF .. 470 MHz
const unsigned int band = (unsigned int)FREQUENCY_GetBand(p_vfo->p_tx->frequency);
uint8_t tx_power[3];
memcpy(tx_power, g_eeprom.calib.tx_band_power[band].level[p_vfo->channel.tx_power], 3);
#ifndef ENABLE_TX_POWER_CAL_MENU
#ifdef ENABLE_TX_POWER_FIX
switch (p_vfo->channel.tx_power)
{
case OUTPUT_POWER_LOW: // ~ 10mW
// if (p_vfo->p_tx->frequency <= 26000000)
// { // 137 ~ 174
// tx_power[0] = 0x13;
// tx_power[1] = 0x13;
// tx_power[2] = 0x13;
// }
// else
// { // 400 ~ 470
tx_power[0] = 0x13;
tx_power[1] = 0x13;
tx_power[2] = 0x13;
// }
break;
default:
case OUTPUT_POWER_MID: // ~ 500mW
if (p_vfo->p_tx->frequency <= 26000000)
{ // 137 ~ 174
tx_power[0] = 0x29;
tx_power[1] = 0x29;
tx_power[2] = 0x29;
}
else
{ // 400 ~ 470
tx_power[0] = 0x37;
tx_power[1] = 0x37;
tx_power[2] = 0x37;
}
break;
case OUTPUT_POWER_HIGH: // ~ 4W
if (p_vfo->p_tx->frequency <= 26000000)
{ // 137 ~ 174
tx_power[0] = 0x7F;
tx_power[1] = 0x84;
tx_power[2] = 0x8C;
}
else
{ // 400 ~ 470
tx_power[0] = 0x96;
tx_power[1] = 0x96;
tx_power[2] = 0x8C;
}
break;
}
#endif
#endif
if (p_vfo->channel.tx_power == OUTPUT_POWER_USER)
p_vfo->txp_reg_value = 8 + (p_vfo->channel.tx_power_user * 1);
else
p_vfo->txp_reg_value = FREQUENCY_CalculateOutputPower(tx_power[0], tx_power[1], tx_power[2], p_vfo->p_tx->frequency);
}
void RADIO_apply_offset(vfo_info_t *p_vfo, const bool set_pees)
{
uint32_t Frequency = p_vfo->freq_config_rx.frequency;
switch (p_vfo->channel.tx_offset_dir)
{
case TX_OFFSET_FREQ_DIR_OFF:
break;
case TX_OFFSET_FREQ_DIR_SUB:
Frequency -= p_vfo->channel.tx_offset;
break;
case TX_OFFSET_FREQ_DIR_ADD:
Frequency += p_vfo->channel.tx_offset;
break;
}
if (Frequency < FREQ_BAND_TABLE[0].lower)
Frequency = FREQ_BAND_TABLE[0].lower;
else
if (Frequency > FREQ_BAND_TABLE[ARRAY_SIZE(FREQ_BAND_TABLE) - 1].upper)
Frequency = FREQ_BAND_TABLE[ARRAY_SIZE(FREQ_BAND_TABLE) - 1].upper;
p_vfo->freq_config_tx.frequency = Frequency;
if (set_pees)
{
if (!p_vfo->channel.frequency_reverse)
{
p_vfo->p_rx = &p_vfo->freq_config_rx;
p_vfo->p_tx = &p_vfo->freq_config_tx;
}
else
{
p_vfo->p_rx = &p_vfo->freq_config_tx;
p_vfo->p_tx = &p_vfo->freq_config_rx;
}
}
}
void RADIO_select_vfos(void)
{
g_eeprom.config.setting.tx_vfo_num = get_TX_VFO();
g_rx_vfo_num = (g_eeprom.config.setting.cross_vfo == CROSS_BAND_OFF) ? g_eeprom.config.setting.tx_vfo_num : (g_eeprom.config.setting.tx_vfo_num + 1) & 1u;
g_tx_vfo = &g_vfo_info[g_eeprom.config.setting.tx_vfo_num];
g_rx_vfo = &g_vfo_info[g_rx_vfo_num];
g_current_vfo = (g_eeprom.config.setting.cross_vfo == CROSS_BAND_OFF) ? g_rx_vfo : &g_vfo_info[g_eeprom.config.setting.tx_vfo_num];
}
BK4819_filter_bandwidth_t RADIO_set_bandwidth(BK4819_filter_bandwidth_t bandwidth, const int mode)
{
uint16_t deviation;
switch (bandwidth)
{
default:
bandwidth = BK4819_FILTER_BW_WIDE;
// Fallthrough
case BK4819_FILTER_BW_WIDE:
case BK4819_FILTER_BW_NARROW:
case BK4819_FILTER_BW_NARROWER:
break;
}
switch (mode)
{
case MOD_MODE_FM:
//BK4819_set_AFC(2);
BK4819_set_AFC(0);
break;
case MOD_MODE_AM:
//BK4819_set_AFC(2);
BK4819_set_AFC(0);
break;
case MOD_MODE_DSB:
bandwidth = BK4819_FILTER_BW_NARROWER;
BK4819_set_AFC(0);
break;
}
if (g_eeprom.calib.deviation < FM_DEV_LIMIT_LOWER || g_eeprom.calib.deviation > FM_DEV_LIMIT_UPPER)
deviation = FM_DEV_LIMIT_DEFAULT;
else
deviation = g_eeprom.calib.deviation;
BK4819_set_TX_deviation(deviation);
BK4819_SetFilterBandwidth(bandwidth);
return bandwidth;
}
void RADIO_setup_registers(bool switch_to_function_foreground)
{
BK4819_filter_bandwidth_t Bandwidth = g_rx_vfo->channel.channel_bandwidth;
uint16_t interrupt_mask;
uint32_t Frequency;
if (!g_monitor_enabled)
{
#ifdef ENABLE_FMRADIO
if (!g_fm_radio_mode && g_request_display_screen != DISPLAY_FM)
#endif
GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_SPEAKER); // speaker off
}
// green LED off
BK4819_set_GPIO_pin(BK4819_GPIO6_PIN2_GREEN, false);
Bandwidth = RADIO_set_bandwidth(Bandwidth, g_rx_vfo->channel.mod_mode);
BK4819_write_reg(0x30, 0);
BK4819_write_reg(0x30,
BK4819_REG_30_ENABLE_VCO_CALIB |
// BK4819_REG_30_ENABLE_UNKNOWN |
BK4819_REG_30_ENABLE_RX_LINK |
BK4819_REG_30_ENABLE_AF_DAC |
BK4819_REG_30_ENABLE_DISC_MODE |
BK4819_REG_30_ENABLE_PLL_VCO |
// BK4819_REG_30_ENABLE_PA_GAIN |
// BK4819_REG_30_ENABLE_MIC_ADC |
// BK4819_REG_30_ENABLE_TX_DSP |
BK4819_REG_30_ENABLE_RX_DSP |
0);
BK4819_set_GPIO_pin(BK4819_GPIO5_PIN1_RED, false); // red LED off
BK4819_SetupPowerAmplifier(0, 0); //
BK4819_set_GPIO_pin(BK4819_GPIO1_PIN29_PA_ENABLE, false); // PA off
do { // wait for interrupts to clear
const uint16_t int_bits = BK4819_read_reg(0x0C);
if ((int_bits & (1u << 0)) == 0)
break;
BK4819_write_reg(0x02, 0); // clear the interrupt bits ?
SYSTEM_DelayMs(1);
} while (1);
BK4819_write_reg(0x3F, 0); // disable interrupts
#ifdef ENABLE_NOAA
if (IS_NOAA_CHANNEL(g_rx_vfo->channel_save) && g_noaa_mode)
Frequency = NOAA_FREQUENCY_TABLE[g_noaa_channel];
else
#endif
Frequency = g_rx_vfo->p_rx->frequency;
// set VCO/PLL frequency
BK4819_set_rf_frequency(Frequency, true);
BK4819_set_rf_filter_path(Frequency);
// set squelch level
BK4819_SetupSquelch(
g_rx_vfo->squelch_open_rssi_thresh, g_rx_vfo->squelch_close_rssi_thresh,
g_rx_vfo->squelch_open_noise_thresh, g_rx_vfo->squelch_close_noise_thresh,
g_rx_vfo->squelch_close_glitch_thresh, g_rx_vfo->squelch_open_glitch_thresh);
// enable the RX front end
BK4819_set_GPIO_pin(BK4819_GPIO0_PIN28_RX_ENABLE, true);
// AF RX Gain and DAC
// if (g_rx_vfo->channel.mod_mode != MOD_MODE_FM)
// {
// BK4819_write_reg(0x48, 0xB3A8); // 1011 0011 1010 1000
// }
// else
{
BK4819_write_reg(0x48,
(11u << 12) | // ??? .. 0 ~ 15, doesn't seem to make any difference
( 0u << 10) | // AF Rx Gain-1
(g_eeprom.calib.volume_gain << 4) | // AF Rx Gain-2
(g_eeprom.calib.dac_gain << 0)); // AF DAC Gain (after Gain-1 and Gain-2)
}
if (!g_monitor_enabled)
{ // set modulation mode FM, AM etc
#ifdef ENABLE_FMRADIO
if (!g_fm_radio_mode && g_request_display_screen != DISPLAY_FM)
#endif
{
#ifdef ENABLE_VOICE
#ifdef MUTE_AUDIO_FOR_VOICE
if (g_voice_write_index == 0)
AUDIO_set_mod_mode(g_rx_vfo->channel.mod_mode);
#else
AUDIO_set_mod_mode(g_rx_vfo->channel.mod_mode);
#endif
#else
AUDIO_set_mod_mode(g_rx_vfo->channel.mod_mode);
#endif
}
}
interrupt_mask = BK4819_REG_3F_SQUELCH_FOUND | BK4819_REG_3F_SQUELCH_LOST;
if (IS_NOT_NOAA_CHANNEL(g_rx_vfo->channel_save))
{
if (g_rx_vfo->channel.mod_mode == MOD_MODE_FM)
{ // FM
uint8_t code_type = g_selected_code_type;
uint8_t code = g_selected_code;
if (g_css_scan_mode == CSS_SCAN_MODE_OFF)
{
code_type = g_rx_vfo->p_rx->code_type;
code = g_rx_vfo->p_rx->code;
}
switch (code_type)
{
default:
case CODE_TYPE_NONE:
BK4819_set_CTCSS_freq(670);
BK4819_set_tail_detection(550); // QS's 55Hz tone method
interrupt_mask |= BK4819_REG_3F_CxCSS_TAIL;
break;
case CODE_TYPE_CONTINUOUS_TONE:
BK4819_set_CTCSS_freq(CTCSS_TONE_LIST[code]);
// #ifdef ENABLE_CTCSS_TAIL_PHASE_SHIFT
// BK4819_set_tail_detection(CTCSS_TONE_LIST[code]); // doesn't work in RX mode
// #else
// BK4819_set_tail_detection(550); // QS's 55Hz tone method
// #endif
interrupt_mask |=
BK4819_REG_3F_CxCSS_TAIL |
BK4819_REG_3F_CTCSS_FOUND |
BK4819_REG_3F_CTCSS_LOST;
break;
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
BK4819_set_CDCSS_code(DCS_GetGolayCodeWord(code_type, code));
interrupt_mask |=
BK4819_REG_3F_CxCSS_TAIL |
BK4819_REG_3F_CDCSS_FOUND |
BK4819_REG_3F_CDCSS_LOST;
break;
}
if (g_eeprom.config.setting.enable_scrambler)
BK4819_set_scrambler(g_rx_vfo->channel.scrambler);
else
BK4819_set_scrambler(0);
}
}
#ifdef ENABLE_NOAA
else
{
BK4819_set_CTCSS_freq(0); // NOAA 1050Hz stuff
interrupt_mask |= BK4819_REG_3F_CTCSS_FOUND | BK4819_REG_3F_CTCSS_LOST;
}
#endif
#ifdef ENABLE_VOX
if (
#ifdef ENABLE_FMRADIO
!g_fm_radio_mode &&
#endif
g_eeprom.config.setting.vox_enabled &&
IS_NOT_NOAA_CHANNEL(g_rx_vfo->channel_save) &&
g_rx_vfo->channel.mod_mode == MOD_MODE_FM)
{
RADIO_enable_vox(g_eeprom.config.setting.vox_level);
interrupt_mask |= BK4819_REG_3F_VOX_FOUND | BK4819_REG_3F_VOX_LOST;
}
else
#endif
BK4819_DisableVox();
// RX expander
BK4819_SetCompander((g_rx_vfo->channel.mod_mode == MOD_MODE_FM) ? g_rx_vfo->channel.compand : COMPAND_OFF);
BK4819_EnableDTMF();
interrupt_mask |= BK4819_REG_3F_DTMF_5TONE_FOUND;
#ifdef ENABLE_MDC1200
BK4819_enable_mdc1200_rx(true);
interrupt_mask |= BK4819_REG_3F_FSK_RX_SYNC | BK4819_REG_3F_FSK_RX_FINISHED | BK4819_REG_3F_FSK_FIFO_ALMOST_FULL;
#endif
// enable BK4819 interrupts
BK4819_write_reg(0x3F, interrupt_mask);
FUNCTION_Init();
if (switch_to_function_foreground)
FUNCTION_Select(FUNCTION_FOREGROUND);
// if (g_monitor_enabled)
// GPIO_SetBit(&GPIOC->DATA, GPIOC_PIN_SPEAKER);
#if defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("setup-reg %4u.%05u MHz, %u\r\n", Frequency / 100000, Frequency % 100000, Bandwidth);
#endif
}
#ifdef ENABLE_NOAA
void RADIO_ConfigureNOAA(void)
{
uint8_t ChanAB;
g_update_status = true;
if (g_eeprom.config.setting.noaa_auto_scan)
{
if (g_eeprom.config.setting.dual_watch != DUAL_WATCH_OFF)
{
if (IS_NOT_NOAA_CHANNEL(g_eeprom.config.setting.indices.vfo[0].screen))
{
if (IS_NOT_NOAA_CHANNEL(g_eeprom.config.setting.indices.vfo[1].screen))
{
g_noaa_mode = false;
return;
}
ChanAB = 1;
}
else
ChanAB = 0;
if (!g_noaa_mode)
g_noaa_channel = g_vfo_info[ChanAB].channel_save - NOAA_CHANNEL_FIRST;
g_noaa_mode = true;
return;
}
if (g_rx_vfo->channel_save >= NOAA_CHANNEL_FIRST)
{
g_noaa_mode = true;
g_noaa_channel = g_rx_vfo->channel_save - NOAA_CHANNEL_FIRST;
g_noaa_tick_10ms = noaa_tick_2_10ms;
g_schedule_noaa = false;
}
else
g_noaa_mode = false;
}
else
g_noaa_mode = false;
}
#endif
void RADIO_enableTX(const bool fsk_tx)
{
BK4819_filter_bandwidth_t Bandwidth = g_current_vfo->channel.channel_bandwidth;
GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_SPEAKER);
BK4819_set_GPIO_pin(BK4819_GPIO0_PIN28_RX_ENABLE, false);
Bandwidth = RADIO_set_bandwidth(Bandwidth, g_current_vfo->channel.mod_mode);
// if DTMF is enabled when TX'ing, it changes the TX audio filtering ! .. 1of11
// so MAKE SURE that DTMF is disabled - until needed
BK4819_DisableDTMF();
BK4819_SetCompander((!fsk_tx && g_current_vfo->channel.mod_mode == MOD_MODE_FM) ? g_current_vfo->channel.compand : COMPAND_OFF);
// ******************
BK4819_set_rf_frequency(g_current_vfo->p_tx->frequency, true);
BK4819_set_rf_filter_path(g_current_vfo->p_tx->frequency);
BK4819_PrepareTransmit();
RADIO_ConfigureTXPower(g_current_vfo);
BK4819_set_GPIO_pin(BK4819_GPIO1_PIN29_PA_ENABLE, true); // PA on
if (g_current_display_screen != DISPLAY_AIRCOPY)
BK4819_SetupPowerAmplifier(g_current_vfo->txp_reg_value, g_current_vfo->p_tx->frequency);
else
BK4819_SetupPowerAmplifier(0, g_current_vfo->p_tx->frequency); // very low power when in AIRCOPY mode
BK4819_set_GPIO_pin(BK4819_GPIO5_PIN1_RED, true); // turn the RED LED on
// ******************
if (fsk_tx)
{
BK4819_disable_sub_audible();
}
else
{
switch (g_current_vfo->p_tx->code_type)
{
default:
case CODE_TYPE_NONE:
BK4819_disable_sub_audible();
break;
case CODE_TYPE_CONTINUOUS_TONE:
BK4819_gen_tail(4);
BK4819_set_CTCSS_freq(CTCSS_TONE_LIST[g_current_vfo->p_tx->code]);
break;
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
BK4819_gen_tail(4);
BK4819_set_CDCSS_code(DCS_GetGolayCodeWord(g_current_vfo->p_tx->code_type, g_current_vfo->p_tx->code));
break;
}
}
}
void RADIO_set_vfo_state(vfo_state_t State)
{
if (State == VFO_STATE_NORMAL)
{
g_vfo_state[0] = VFO_STATE_NORMAL;
g_vfo_state[1] = VFO_STATE_NORMAL;
}
else
{
if (State == VFO_STATE_VOLTAGE_HIGH)
{
g_vfo_state[0] = VFO_STATE_VOLTAGE_HIGH;
g_vfo_state[1] = VFO_STATE_TX_DISABLE;
}
else
{ // 1of11
const unsigned int vfo = (g_eeprom.config.setting.cross_vfo == CROSS_BAND_OFF) ? g_rx_vfo_num : g_eeprom.config.setting.tx_vfo_num;
g_vfo_state[vfo] = State;
}
// cause a display update to remove the message
g_update_screen_tick_500ms = 8; // 4 seconds
}
g_update_display = true;
}
void RADIO_PrepareTX(void)
{
vfo_state_t State = VFO_STATE_NORMAL; // default to OK for TX
#ifdef ENABLE_ALARM
if (g_alarm_state == ALARM_STATE_TX_ALARM && g_eeprom.config.setting.alarm_mode != ALARM_MODE_TONE)
{ // enable the alarm tone but not the TX
g_alarm_state = ALARM_STATE_ALARM;
GUI_DisplayScreen();
BK4819_start_tone(500, 28, g_current_function == FUNCTION_TRANSMIT, false);
SYSTEM_DelayMs(60);
BK4819_ExitTxMute();
g_alarm_tone_counter_10ms = 0;
return;
}
#endif
if (g_eeprom.config.setting.dual_watch != DUAL_WATCH_OFF)
{ // dual-RX is enabled
#if 0
if (g_rx_vfo_is_active)
{ // use the TX vfo
g_rx_vfo_num = g_eeprom.config.setting.tx_vfo_num;
g_rx_vfo = &g_vfo_info[g_eeprom.config.setting.tx_vfo_num];
g_rx_vfo_is_active = false;
}
g_current_vfo = g_rx_vfo;
#else
if (!g_rx_vfo_is_active)
{ // use the current RX vfo
g_rx_vfo_num = g_eeprom.config.setting.tx_vfo_num;
g_rx_vfo = &g_vfo_info[g_eeprom.config.setting.tx_vfo_num];
g_rx_vfo_is_active = true;
}
g_current_vfo = g_rx_vfo;
#endif
g_update_status = true;
}
g_current_vfo = (g_eeprom.config.setting.cross_vfo == CROSS_BAND_OFF) ? g_rx_vfo : &g_vfo_info[g_eeprom.config.setting.tx_vfo_num];
#ifndef ENABLE_TX_WHEN_AM
if (g_current_vfo->channel.mod_mode != MOD_MODE_FM)
{ // not allowed to TX if not in FM mode
State = VFO_STATE_TX_DISABLE;
}
else
#endif
#if defined(ENABLE_UART)
if (!g_eeprom.config.setting.tx_enable || g_serial_config_tick_500ms > 0)
#else
if (!g_eeprom.config.setting.tx_enable)
#endif
{ // TX is disabled or config upload/download in progress
State = VFO_STATE_TX_DISABLE;
}
else
if (FREQUENCY_tx_freq_check(g_current_vfo->p_tx->frequency) == 0)
{ // TX frequency is allowed
if (g_current_vfo->channel.busy_channel_lock && g_current_function == FUNCTION_RECEIVE)
State = VFO_STATE_BUSY; // busy RX'ing a station
else
if (g_battery_display_level == 0)
State = VFO_STATE_BAT_LOW; // charge your battery !
// else
// if (g_battery_display_level >= 6)
// State = VFO_STATE_VOLTAGE_HIGH; // over voltage (no doubt to protect the PA) .. this is being a pain
}
else
State = VFO_STATE_TX_DISABLE; // TX frequency not allowed
if (State != VFO_STATE_NORMAL)
{ // TX not allowed
RADIO_set_vfo_state(State);
#if defined(ENABLE_ALARM) || (ENABLE_TX_TONE_HZ > 0)
g_alarm_state = ALARM_STATE_OFF;
#endif
g_dtmf_reply_state = DTMF_REPLY_NONE;
AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL);
return;
}
// ******************************
// TX is allowed
#if defined(ENABLE_DTMF_CALLING) && defined(ENABLE_UART) && defined(ENABLE_UART_DEBUG)
// UART_printf("radio prepare tx %u %s\r\n", g_dtmf_reply_state, g_dtmf_string);
#endif
#ifdef ENABLE_DTMF_CALLING
if (g_dtmf_reply_state == DTMF_REPLY_STR || g_dtmf_reply_state == DTMF_REPLY_ANI)
{
if (g_dtmf_call_mode == DTMF_CALL_MODE_DTMF)
{
g_dtmf_call_state = DTMF_CALL_STATE_NONE;
g_dtmf_tx_stop_tick_500ms = dtmf_txstop_500ms;
g_dtmf_is_tx = true;
}
else
{
g_dtmf_call_state = DTMF_CALL_STATE_CALL_OUT;
g_dtmf_is_tx = false;
}
}
#else
if (g_dtmf_reply_state == DTMF_REPLY_STR)
{
g_dtmf_tx_stop_tick_500ms = dtmf_txstop_500ms;
g_dtmf_is_tx = true;
}
#endif
FUNCTION_Select(FUNCTION_TRANSMIT);
}
void RADIO_enable_CxCSS_tail(void)
{
switch (g_current_vfo->p_tx->code_type)
{
default:
case CODE_TYPE_NONE:
break;
case CODE_TYPE_CONTINUOUS_TONE:
BK4819_enable_CTCSS_tail();
SYSTEM_DelayMs(200);
break;
case CODE_TYPE_DIGITAL:
case CODE_TYPE_REVERSE_DIGITAL:
BK4819_enable_CDCSS_tail();
SYSTEM_DelayMs(200);
break;
}
}
void RADIO_PrepareCssTX(void)
{
GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_SPEAKER);
RADIO_PrepareTX();
SYSTEM_DelayMs(200);
RADIO_enable_CxCSS_tail();
RADIO_setup_registers(true);
}
void RADIO_tx_eot(void)
{
#if defined(ENABLE_ALARM) || (ENABLE_TX_TONE_HZ > 0)
if (g_alarm_state != ALARM_STATE_OFF)
{ // don't send EOT if TX'ing tone/alarm
BK4819_ExitDTMF_TX(true);
return;
}
#endif
if (
#ifdef ENABLE_DTMF_CALLING
g_dtmf_call_state == DTMF_CALL_STATE_NONE &&
#endif
(g_current_vfo->channel.dtmf_ptt_id_tx_mode == PTT_ID_EOT || g_current_vfo->channel.dtmf_ptt_id_tx_mode == PTT_ID_BOTH))
{ // end-of-tx
if (g_eeprom.config.setting.dtmf.side_tone)
{
GPIO_SetBit(&GPIOC->DATA, GPIOC_PIN_SPEAKER);
SYSTEM_DelayMs(60);
}
BK4819_EnterDTMF_TX(g_eeprom.config.setting.dtmf.side_tone);
BK4819_PlayDTMFString(
g_eeprom.config.setting.dtmf.key_down_code,
0,
g_eeprom.config.setting.dtmf.first_code_persist_time * 10,
g_eeprom.config.setting.dtmf.hash_code_persist_time * 10,
g_eeprom.config.setting.dtmf.code_persist_time * 10,
g_eeprom.config.setting.dtmf.code_interval_time * 10);
GPIO_ClearBit(&GPIOC->DATA, GPIOC_PIN_SPEAKER);
}
else
#ifdef ENABLE_MDC1200
if (g_current_vfo->channel.mdc1200_mode == MDC1200_MODE_EOT || g_current_vfo->channel.mdc1200_mode == MDC1200_MODE_BOTH)
{
BK4819_send_MDC1200(MDC1200_OP_CODE_POST_ID, 0x00, g_eeprom.config.setting.mdc1200_id, false);
#ifdef ENABLE_MDC1200_SIDE_BEEP
BK4819_start_tone(880, 10, true, true);
SYSTEM_DelayMs(120);
BK4819_stop_tones(true);
#endif
}
else
#endif
if (g_current_vfo->channel.dtmf_ptt_id_tx_mode == PTT_ID_APOLLO)
{
BK4819_start_tone(APOLLO_TONE2_HZ, 28, true, false);
SYSTEM_DelayMs(APOLLO_TONE_MS);
BK4819_stop_tones(true);
}
else
if (g_eeprom.config.setting.roger_mode != ROGER_MODE_OFF)
{
BK4819_PlayRoger(g_eeprom.config.setting.roger_mode);
}
BK4819_ExitDTMF_TX(true);
}
View Git Blame Copy Permalink