mirror
/
Wolf-LITE
kopia lustrzana https://github.com/UU5JPP/Wolf-LITE
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Update CW code

master
XGudron 2021-10-21 21:56:09 +03:00
rodzic eb88ab9e0c
commit 9bb3596294
12 zmienionych plików z 478 dodań i 359 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

44
STM32/Core/Src/audio_processor.c
Wyświetl plik

@ -6,6 +6,7 @@
#include "usbd_audio_if.h"
#include "auto_notch.h"
#include "trx_manager.h"
#include "cw.h"
// Public variables
volatile uint32_t AUDIOPROC_samples = 0; // audio samples processed in the processor
@ -283,6 +284,19 @@ void processTxAudio(void)
{
if (!Processor_NeedTXBuffer)
return;
//sync fpga to audio-codec
uint32_t dma_index = CODEC_AUDIO_BUFFER_SIZE * 2 - (uint16_t)__HAL_DMA_GET_COUNTER(hi2s3.hdmatx);
if(!WM8731_DMA_state && dma_index > (CODEC_AUDIO_BUFFER_SIZE * 2 - 100))
return;
if(WM8731_DMA_state && dma_index > (CODEC_AUDIO_BUFFER_SIZE - 100))
return;
static bool old_WM8731_DMA_state = false;
if(WM8731_DMA_state == old_WM8731_DMA_state)
return;
old_WM8731_DMA_state = WM8731_DMA_state;
bool start_WM8731_DMA_state = old_WM8731_DMA_state;
VFO *current_vfo = CurrentVFO();
AUDIOPROC_samples++;
uint_fast8_t mode = current_vfo->Mode;
@ -315,13 +329,6 @@ void processTxAudio(void)
//sendToDebug_uint32(CODEC_AUDIO_BUFFER_SIZE, false);
readFromCircleBuffer32((uint32_t *)&CODEC_Audio_Buffer_TX[0], (uint32_t *)&Processor_AudioBuffer_A[0], dma_index, CODEC_AUDIO_BUFFER_SIZE, AUDIO_BUFFER_SIZE);
}
//sendToDebug_int32(convertToSPIBigEndian(CODEC_Audio_Buffer_TX[0]), false);
//sendToDebug_int32(convertToSPIBigEndian(CODEC_Audio_Buffer_TX[380]), false);
//sendToDebug_int32(convertToSPIBigEndian(CODEC_Audio_Buffer_TX[640]), false);
//sendToDebug_newline();
//sendToDebug_int32(convertToSPIBigEndian(Processor_AudioBuffer_A[0]), true);
//sendToDebug_str(" ");
//sendToDebug_int32(Processor_AudioBuffer_A[0], false);
//One-signal zero-tune generator
if (TRX_Tune && !TRX.TWO_SIGNAL_TUNE)
@ -397,10 +404,6 @@ void processTxAudio(void)
//Mic Gain
arm_scale_f32(FPGA_Audio_Buffer_TX_I_tmp, TRX.MIC_GAIN, FPGA_Audio_Buffer_TX_I_tmp, AUDIO_BUFFER_HALF_SIZE);
arm_scale_f32(FPGA_Audio_Buffer_TX_Q_tmp, TRX.MIC_GAIN, FPGA_Audio_Buffer_TX_Q_tmp, AUDIO_BUFFER_HALF_SIZE);
// if (TRX.MIC_BOOST)
// WM8731_SendI2CCommand(B8(00001000), B8(00010101)); //R4 Analogue Audio Path Control
// else
// WM8731_SendI2CCommand(B8(00001000), B8(00010100)); //R4 Analogue Audio Path Control
//Mic Equalizer
if (mode != TRX_MODE_DIGI_L && mode != TRX_MODE_DIGI_U && mode != TRX_MODE_IQ)
@ -428,7 +431,7 @@ void processTxAudio(void)
case TRX_MODE_CW_U:
for (uint_fast16_t i = 0; i < AUDIO_BUFFER_HALF_SIZE; i++)
{
FPGA_Audio_Buffer_TX_I_tmp[i] = TRX_GenerateCWSignal(Processor_selected_RFpower_amplitude);
FPGA_Audio_Buffer_TX_I_tmp[i] = CW_GenerateSignal(Processor_selected_RFpower_amplitude);
FPGA_Audio_Buffer_TX_Q_tmp[i] = 0.0f;
}
break;
@ -584,14 +587,19 @@ void processTxAudio(void)
else
{
//CW SelfHear
if (TRX.CW_SelfHear && (TRX.CW_KEYER || TRX_key_serial || TRX_key_dot_hard || TRX_key_dash_hard) && (mode == TRX_MODE_CW_L || mode == TRX_MODE_CW_U) && !TRX_Tune)
if (TRX.CW_SelfHear && (TRX.CW_KEYER || CW_key_serial || CW_key_dot_hard || CW_key_dash_hard) && (mode == TRX_MODE_CW_L || mode == TRX_MODE_CW_U) && !TRX_Tune)
{
float32_t volume_gain_tx = volume2rate((float32_t)TRX.Volume / 100.0f);
float32_t amplitude = (db2rateV(TRX.AGC_GAIN_TARGET) * volume_gain_tx * CODEC_BITS_FULL_SCALE / 2.0f);
static float32_t cwgen_index = 0;
const float32_t SELFHEAR_Volume = 30.0f;
float32_t amplitude = volume2rate((float32_t)TRX.Volume / 100.0f) * volume2rate(SELFHEAR_Volume / 100.0f);
for (uint_fast16_t i = 0; i < AUDIO_BUFFER_HALF_SIZE; i++)
{
int32_t data = convertToSPIBigEndian((int32_t)(amplitude * ( FPGA_Audio_Buffer_TX_I_tmp[i] / Processor_selected_RFpower_amplitude) * arm_sin_f32(((float32_t)i / (float32_t)TRX_SAMPLERATE) * PI * 2.0f * (float32_t)TRX.CW_GENERATOR_SHIFT_HZ)));
if (WM8731_DMA_state)
const float32_t CW_Pitch_freq = 800;
float32_t point = generateSinF(amplitude * FPGA_Audio_Buffer_TX_I_tmp[i], &cwgen_index, TRX_SAMPLERATE, CW_Pitch_freq);
int32_t sample = 0;
arm_float_to_q31(&point, &sample, 1);
int32_t data = convertToSPIBigEndian(sample);
if (start_WM8731_DMA_state)
{
CODEC_Audio_Buffer_RX[AUDIO_BUFFER_SIZE + i * 2] = data;
CODEC_Audio_Buffer_RX[AUDIO_BUFFER_SIZE + i * 2 + 1] = data;
@ -603,7 +611,7 @@ void processTxAudio(void)
}
}
}
else if (TRX.CW_SelfHear)
else if (TRX.CW_SelfHear && mode != TRX_MODE_DIGI_L && mode != TRX_MODE_DIGI_U && mode != TRX_MODE_LOOPBACK)
{
memset(CODEC_Audio_Buffer_RX, 0x00, sizeof CODEC_Audio_Buffer_RX);
}

213
STM32/Core/Src/cw.c 100644
Wyświetl plik

@ -0,0 +1,213 @@
#include "stm32f4xx_hal.h"
#include "main.h"
#include "trx_manager.h"
#include "functions.h"
#include "lcd.h"
#include "fpga.h"
#include "settings.h"
#include "wm8731.h"
#include "fpga.h"
#include "bands.h"
#include "agc.h"
#include "audio_filters.h"
#include "usbd_audio_if.h"
#include "front_unit.h"
#include "rf_unit.h"
#include "system_menu.h"
#include "swr_analyzer.h"
volatile bool CW_key_serial = false;
volatile bool CW_old_key_serial = false;
volatile bool CW_key_dot_hard = false;
volatile bool CW_key_dash_hard = false;
volatile uint_fast16_t CW_Key_Timeout_est = 0;
volatile uint_fast8_t KEYER_symbol_status = 0; // status (signal or period) of the automatic key symbol
static uint32_t KEYER_symbol_start_time = 0; // start time of the automatic key character
static float32_t current_cw_power = 0.0f; // current amplitude (for rise/fall)
static bool iambic_first_button_pressed = false; //start symbol | false - dot, true - dash
static bool iambic_last_symbol = false; //last Iambic symbol | false - dot, true - dash
static bool iambic_sequence_started = false;
void CW_key_change(void)
{
if (TRX_Tune)
return;
if (CurrentVFO()->Mode != TRX_MODE_CW_L && CurrentVFO()->Mode != TRX_MODE_CW_U)
return;
bool TRX_new_key_dot_hard = !HAL_GPIO_ReadPin(KEY_IN_DOT_GPIO_Port, KEY_IN_DOT_Pin);
//if(TRX.CW_Invert)
//TRX_new_key_dot_hard = !HAL_GPIO_ReadPin(KEY_IN_DASH_GPIO_Port, KEY_IN_DASH_Pin);
if (CW_key_dot_hard != TRX_new_key_dot_hard)
{
CW_key_dot_hard = TRX_new_key_dot_hard;
if (CW_key_dot_hard == true && (KEYER_symbol_status == 0 || !TRX.CW_KEYER))
{
CW_Key_Timeout_est = TRX.CW_Key_timeout;
LCD_UpdateQuery.StatusInfoGUIRedraw = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
}
bool TRX_new_key_dash_hard = !HAL_GPIO_ReadPin(KEY_IN_DASH_GPIO_Port, KEY_IN_DASH_Pin);
//if(TRX.CW_Invert)
//TRX_new_key_dash_hard = !HAL_GPIO_ReadPin(KEY_IN_DOT_GPIO_Port, KEY_IN_DOT_Pin);
if (CW_key_dash_hard != TRX_new_key_dash_hard)
{
CW_key_dash_hard = TRX_new_key_dash_hard;
if (CW_key_dash_hard == true && (KEYER_symbol_status == 0 || !TRX.CW_KEYER))
{
CW_Key_Timeout_est = TRX.CW_Key_timeout;
LCD_UpdateQuery.StatusInfoGUIRedraw = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
}
if (CW_key_serial != CW_old_key_serial)
{
CW_old_key_serial = CW_key_serial;
if (CW_key_serial == true)
CW_Key_Timeout_est = TRX.CW_Key_timeout;
LCD_UpdateQuery.StatusInfoGUIRedraw = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
}
static float32_t CW_generateRiseSignal(float32_t power)
{
if (current_cw_power < power)
current_cw_power += power * 0.007f;
if (current_cw_power > power)
current_cw_power = power;
return current_cw_power;
}
static float32_t CW_generateFallSignal(float32_t power)
{
if (current_cw_power > 0.0f)
current_cw_power -= power * 0.007f;
if (current_cw_power < 0.0f)
current_cw_power = 0.0f;
return current_cw_power;
}
float32_t CW_GenerateSignal(float32_t power)
{
//Do no signal before start TX delay
//if ((HAL_GetTick() - TRX_TX_StartTime) < CALIBRATE.TX_StartDelay)
//return 0.0f;
//Keyer disabled
if (!TRX.CW_KEYER)
{
if (!CW_key_serial && !TRX_ptt_hard && !CW_key_dot_hard && !CW_key_dash_hard)
return CW_generateFallSignal(power);
return CW_generateRiseSignal(power);
}
//USB CW (Serial)
if(CW_key_serial)
return CW_generateRiseSignal(power);
//Keyer
const float32_t CW_DotToDashRate = 3.0f;
uint32_t dot_length_ms = 1200 / TRX.CW_KEYER_WPM;
uint32_t dash_length_ms = (float32_t)dot_length_ms * CW_DotToDashRate;
uint32_t sim_space_length_ms = dot_length_ms;
uint32_t curTime = HAL_GetTick();
//Iambic keyer start mode
if(CW_key_dot_hard && !CW_key_dash_hard)
iambic_first_button_pressed = false;
if(!CW_key_dot_hard && CW_key_dash_hard)
iambic_first_button_pressed = true;
if(CW_key_dot_hard && CW_key_dash_hard)
iambic_sequence_started = true;
//DOT .
if (KEYER_symbol_status == 0 && CW_key_dot_hard)
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 1;
}
if (KEYER_symbol_status == 1 && (KEYER_symbol_start_time + dot_length_ms) > curTime)
{
CW_Key_Timeout_est = TRX.CW_Key_timeout;
return CW_generateRiseSignal(power);
}
if (KEYER_symbol_status == 1 && (KEYER_symbol_start_time + dot_length_ms) < curTime)
{
iambic_last_symbol = false;
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 3;
}
//DASH -
if (KEYER_symbol_status == 0 && CW_key_dash_hard)
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 2;
}
if (KEYER_symbol_status == 2 && (KEYER_symbol_start_time + dash_length_ms) > curTime)
{
CW_Key_Timeout_est = TRX.CW_Key_timeout;
return CW_generateRiseSignal(power);
}
if (KEYER_symbol_status == 2 && (KEYER_symbol_start_time + dash_length_ms) < curTime)
{
iambic_last_symbol = true;
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 3;
}
//SPACE
if (KEYER_symbol_status == 3 && (KEYER_symbol_start_time + sim_space_length_ms) > curTime)
{
CW_Key_Timeout_est = TRX.CW_Key_timeout;
return CW_generateFallSignal(power);
}
if (KEYER_symbol_status == 3 && (KEYER_symbol_start_time + sim_space_length_ms) < curTime)
{
//if(!TRX.CW_Iambic) //classic keyer
KEYER_symbol_status = 0;
/*else //iambic keyer
{
//start iambic sequence
if(iambic_sequence_started)
{
if(!iambic_last_symbol) // iambic dot . , next dash -
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 2;
if(iambic_first_button_pressed && (!CW_key_dot_hard || !CW_key_dash_hard)) //iambic dash-dot sequence compleated
{
//println("-.e");
iambic_sequence_started = false;
KEYER_symbol_status = 0;
}
}
else // iambic dash - , next dot .
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 1;
if(!iambic_first_button_pressed && (!CW_key_dot_hard || !CW_key_dash_hard)) //iambic dot-dash sequence compleated
{
//println(".-e");
KEYER_symbol_status = 0;
iambic_sequence_started = false;
}
}
}
else //no sequence, classic mode
KEYER_symbol_status = 0;
}*/
}
return CW_generateFallSignal(power);
}

18
STM32/Core/Src/cw.h 100644
Wyświetl plik

@ -0,0 +1,18 @@
#ifndef CW_H
#define CW_H
#include "stm32f4xx_hal.h"
#include <stdbool.h>
#include "settings.h"
extern void CW_key_change(void);
extern float32_t CW_GenerateSignal(float32_t power);
volatile extern bool CW_key_serial;
volatile extern bool CW_old_key_serial;
volatile extern bool CW_key_dot_hard;
volatile extern bool CW_key_dash_hard;
volatile extern uint_fast16_t CW_Key_Timeout_est;
volatile extern uint_fast8_t KEYER_symbol_status;
#endif

9
STM32/Core/Src/functions.c
Wyświetl plik

@ -362,6 +362,15 @@ float32_t generateSin(float32_t amplitude, uint32_t index, uint32_t samplerate,
return ret;
}
float32_t generateSinF(float32_t amplitude, float32_t *index, uint32_t samplerate, uint32_t freq)
{
float32_t ret = amplitude * arm_sin_f32(*index * (2.0f * F_PI));
*index += ((float32_t)freq / (float32_t)samplerate);
while (*index >= 1.0f)
*index -= 1.0f;
return ret;
}
static uint32_t CPULOAD_startWorkTime = 0;
static uint32_t CPULOAD_startSleepTime = 0;
static uint32_t CPULOAD_WorkingTime = 0;

1
STM32/Core/Src/functions.h
Wyświetl plik

@ -138,6 +138,7 @@ extern void shiftTextLeft(char *string, uint_fast16_t shiftLength);
extern float32_t getMaxTXAmplitudeOnFreq(uint32_t freq);
//extern uint16_t getf_calibrate(uint16_t freq);
extern float32_t generateSin(float32_t amplitude, uint32_t index, uint32_t samplerate, uint32_t freq);
extern float32_t generateSinF(float32_t amplitude, float32_t *index, uint32_t samplerate, uint32_t freq);
extern int32_t convertToSPIBigEndian(int32_t in);
extern uint8_t rev8(uint8_t data);
extern bool SPI_Transmit(uint8_t *out_data, uint8_t *in_data, uint16_t count, GPIO_TypeDef *CS_PORT, uint16_t CS_PIN, bool hold_cs, uint32_t prescaler);

17
STM32/Core/Src/stm32f4xx_it.c
Wyświetl plik

@ -104,6 +104,7 @@
#include "system_menu.h"
#include "bootloader.h"
#include "swr_analyzer.h"
#include "cw.h"
static uint32_t ms10_counter = 0;
static uint32_t tim6_delay = 0;
@ -517,12 +518,12 @@ void TIM6_DAC_IRQHandler(void)
ms10_counter++;
// transmission release time after key signal
if (TRX_Key_Timeout_est > 0 && !TRX_key_serial && !TRX_key_dot_hard && !TRX_key_dash_hard)
if (CW_Key_Timeout_est > 0 && !CW_key_serial && !CW_key_dot_hard && !CW_key_dash_hard)
{
TRX_Key_Timeout_est -= 10;
if (TRX_Key_Timeout_est == 0)
CW_Key_Timeout_est -= 10;
if (CW_Key_Timeout_est == 0)
{
LCD_UpdateQuery.StatusInfoGUI = true;
LCD_UpdateQuery.StatusInfoGUI = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
@ -546,8 +547,8 @@ void TIM6_DAC_IRQHandler(void)
TRX_ptt_change();
// emulate the key via the COM port
if (TRX_key_serial != TRX_old_key_serial)
TRX_key_change();
if (CW_key_serial != CW_old_key_serial)
CW_key_change();
if ((ms10_counter % 10) == 0) // every 100ms
{
@ -851,11 +852,11 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
}
else if (GPIO_Pin == GPIO_PIN_1) //KEY DOT
{
TRX_key_change();
CW_key_change();
}
else if (GPIO_Pin == GPIO_PIN_0) //KEY DASH
{
TRX_key_change();
CW_key_change();
}
else if (GPIO_Pin == GPIO_PIN_7) //POWER OFF
{

186
STM32/Core/Src/trx_manager.c
Wyświetl plik

@ -14,15 +14,11 @@
#include "front_unit.h"
#include "rf_unit.h"
#include "system_menu.h"
#include "cw.h"
volatile bool TRX_ptt_hard = false;
volatile bool TRX_ptt_soft = false;
volatile bool TRX_old_ptt_soft = false;
volatile bool TRX_key_serial = false;
volatile bool TRX_old_key_serial = false;
volatile bool TRX_key_dot_hard = false;
volatile bool TRX_key_dash_hard = false;
volatile uint_fast16_t TRX_Key_Timeout_est = 0;
volatile bool TRX_RX_IQ_swap = false;
volatile bool TRX_TX_IQ_swap = false;
volatile bool TRX_Tune = false;
@ -42,7 +38,6 @@ volatile float32_t TRX_ALC = 0;
static uint_fast8_t autogain_wait_reaction = 0; // timer for waiting for a reaction from changing the ATT / PRE modes
volatile uint8_t TRX_AutoGain_Stage = 0; // stage of working out the amplification corrector
static uint32_t KEYER_symbol_start_time = 0; // start time of the automatic key character
static uint_fast8_t KEYER_symbol_status = 0; // status (signal or period) of the automatic key symbol
volatile float32_t TRX_IQ_phase_error = 0.0f;
volatile bool TRX_NeedGoToBootloader = false;
volatile bool TRX_Temporary_Stop_BandMap = false;
@ -58,7 +53,7 @@ static void TRX_Start_TXRX(void);
bool TRX_on_TX(void)
{
if (TRX_ptt_hard || TRX_ptt_soft || TRX_Tune || CurrentVFO()->Mode == TRX_MODE_LOOPBACK || TRX_Key_Timeout_est > 0)
if (TRX_ptt_hard || TRX_ptt_soft || TRX_Tune || CurrentVFO()->Mode == TRX_MODE_LOOPBACK || CW_Key_Timeout_est > 0)
return true;
return false;
}
@ -139,47 +134,6 @@ void TRX_ptt_change(void)
}
}
void TRX_key_change(void)
{
if (TRX_Tune)
return;
if (CurrentVFO()->Mode != TRX_MODE_CW_L && CurrentVFO()->Mode != TRX_MODE_CW_U)
return;
bool TRX_new_key_dot_hard = !HAL_GPIO_ReadPin(KEY_IN_DOT_GPIO_Port, KEY_IN_DOT_Pin);
if (TRX_key_dot_hard != TRX_new_key_dot_hard)
{
TRX_key_dot_hard = TRX_new_key_dot_hard;
if (TRX_key_dot_hard == true && (KEYER_symbol_status == 0 || !TRX.CW_KEYER))
{
TRX_Key_Timeout_est = TRX.CW_Key_timeout;
LCD_UpdateQuery.StatusInfoGUIRedraw = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
}
bool TRX_new_key_dash_hard = !HAL_GPIO_ReadPin(KEY_IN_DASH_GPIO_Port, KEY_IN_DASH_Pin);
if (TRX_key_dash_hard != TRX_new_key_dash_hard)
{
TRX_key_dash_hard = TRX_new_key_dash_hard;
if (TRX_key_dash_hard == true && (KEYER_symbol_status == 0 || !TRX.CW_KEYER))
{
TRX_Key_Timeout_est = TRX.CW_Key_timeout;
LCD_UpdateQuery.StatusInfoGUIRedraw = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
}
if (TRX_key_serial != TRX_old_key_serial)
{
TRX_old_key_serial = TRX_key_serial;
if (TRX_key_serial == true)
TRX_Key_Timeout_est = TRX.CW_Key_timeout;
LCD_UpdateQuery.StatusInfoGUIRedraw = true;
FPGA_NeedSendParams = true;
TRX_Restart_Mode();
}
}
void TRX_setFrequency(uint32_t _freq, VFO *vfo)
{
if (_freq < 1)
@ -210,61 +164,8 @@ void TRX_setFrequency(uint32_t _freq, VFO *vfo)
int8_t band = getBandFromFreq(CurrentVFO()->Freq, true);
VFO *current_vfo = CurrentVFO();
VFO *secondary_vfo = SecondaryVFO();
TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT);
TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq);
// switch (band)
// {
// case 1:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_160);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_160);
// break;
// case 2:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_80);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_80);
// break;
// case 4:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_40);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_40);
// break;
// case 5:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_30);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_30);
// break;
// case 6:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_20);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_20);
// break;
// case 7:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_17);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_17);
// break;
// case 8:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_15);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_15);
// break;
// case 9:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_12);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_12);
// break;
// case 10:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_sibi);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_sibi);
// break;
// case 11:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_10);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_10);
// break;
// case 12:
// TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT + CALIBRATE.freq_correctur_52);
// TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq + CALIBRATE.freq_correctur_52);
// break;
// }
// sendToDebug_str("TRX_freq_phrase:");
// sendToDebug_uint8(TRX_freq_phrase, false);
// sendToDebug_str("TRX_freq_phrase_tx:");
// sendToDebug_uint8(TRX_freq_phrase_tx, false);
TRX_freq_phrase = getRXPhraseFromFrequency((int32_t)current_vfo->Freq + TRX_SHIFT);
TRX_freq_phrase_tx = getTXPhraseFromFrequency((int32_t)current_vfo->Freq);
if (!TRX_on_TX())
{
@ -395,85 +296,6 @@ void TRX_DBMCalculate(void)
Processor_RX_Power_value = 0;
}
float32_t current_cw_power = 0.0f;
static float32_t TRX_generateRiseSignal(float32_t power)
{
if(current_cw_power < power)
current_cw_power += power * 0.01f;
if(current_cw_power > power)
current_cw_power = power;
return current_cw_power;
}
static float32_t TRX_generateFallSignal(float32_t power)
{
if(current_cw_power > 0.0f)
current_cw_power -= power * 0.01f;
if(current_cw_power < 0.0f)
current_cw_power = 0.0f;
return current_cw_power;
}
float32_t TRX_GenerateCWSignal(float32_t power)
{
if (!TRX.CW_KEYER)
{
if (!TRX_key_serial && !TRX_ptt_hard && !TRX_key_dot_hard && !TRX_key_dash_hard)
return TRX_generateFallSignal(power);
return TRX_generateRiseSignal(power);
}
uint32_t dot_length_ms = 1200 / TRX.CW_KEYER_WPM;
uint32_t dash_length_ms = dot_length_ms * 3;
uint32_t sim_space_length_ms = dot_length_ms;
uint32_t curTime = HAL_GetTick();
//dot
if (KEYER_symbol_status == 0 && TRX_key_dot_hard)
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 1;
}
if (KEYER_symbol_status == 1 && (KEYER_symbol_start_time + dot_length_ms) > curTime)
{
TRX_Key_Timeout_est = TRX.CW_Key_timeout;
return TRX_generateRiseSignal(power);
}
if (KEYER_symbol_status == 1 && (KEYER_symbol_start_time + dot_length_ms) < curTime)
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 3;
}
//dash
if (KEYER_symbol_status == 0 && TRX_key_dash_hard)
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 2;
}
if (KEYER_symbol_status == 2 && (KEYER_symbol_start_time + dash_length_ms) > curTime)
{
TRX_Key_Timeout_est = TRX.CW_Key_timeout;
return TRX_generateRiseSignal(power);
}
if (KEYER_symbol_status == 2 && (KEYER_symbol_start_time + dash_length_ms) < curTime)
{
KEYER_symbol_start_time = curTime;
KEYER_symbol_status = 3;
}
//space
if (KEYER_symbol_status == 3 && (KEYER_symbol_start_time + sim_space_length_ms) > curTime)
{
TRX_Key_Timeout_est = TRX.CW_Key_timeout;
return TRX_generateFallSignal(power);
}
if (KEYER_symbol_status == 3 && (KEYER_symbol_start_time + sim_space_length_ms) < curTime)
{
KEYER_symbol_status = 0;
}
return TRX_generateFallSignal(power);
}
void TRX_TemporaryMute(void)
{
WM8731_Mute();

5
STM32/Core/Src/trx_manager.h
Wyświetl plik

@ -20,11 +20,6 @@ extern void TRX_TemporaryMute(void);
volatile extern bool TRX_ptt_hard;
volatile extern bool TRX_ptt_soft;
volatile extern bool TRX_old_ptt_soft;
volatile extern bool TRX_key_serial;
volatile extern bool TRX_old_key_serial;
volatile extern bool TRX_key_dot_hard;
volatile extern bool TRX_key_dash_hard;
volatile extern uint_fast16_t TRX_Key_Timeout_est;
volatile extern bool TRX_RX_IQ_swap;
volatile extern bool TRX_TX_IQ_swap;
volatile extern bool TRX_Tune;

5
STM32/Core/Src/usbd_cat_if.c
Wyświetl plik

@ -5,6 +5,7 @@
#include <stdlib.h>
#include "lcd.h"
#include "fpga.h"
#include "cw.h"
#include "audio_filters.h"
#define CAT_APP_RX_DATA_SIZE 32
@ -126,11 +127,11 @@ static int8_t CAT_Control_FS(uint8_t cmd, uint8_t *pbuf)
}
if ((pbuf[2] & 0x1) == 0x1) //DTR
{
TRX_key_serial = true;
CW_key_serial = true;
}
else
{
TRX_key_serial = false;
CW_key_serial = false;
}
break;

328
STM32/MDK-ARM/WOLF-Lite.uvoptx
Wyświetl plik

Plik diff jest za duży Load Diff

10
STM32/MDK-ARM/WOLF-Lite.uvprojx
Wyświetl plik

@ -458,6 +458,16 @@
<FileType>5</FileType>
<FilePath>..\Core\Src\color_themes.h</FilePath>
</File>
<File>
<FileName>cw.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\cw.c</FilePath>
</File>
<File>
<FileName>cw.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Src\cw.h</FilePath>
</File>
<File>
<FileName>fft.c</FileName>
<FileType>1</FileType>

1
STM32/MDK-ARM/WOLF-Lite/WOLF-Lite.lnp
Wyświetl plik

@ -6,6 +6,7 @@
"wolf-lite\auto_notch.o"
"wolf-lite\bands.o"
"wolf-lite\bootloader.o"
"wolf-lite\cw.o"
"wolf-lite\fft.o"
"wolf-lite\fpga.o"
"wolf-lite\functions.o"