UL/TX
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity
Files
aaa7f0dc29b9f53101334d1e10373e499b0aaac7
TX/source/frq.c

968 lines
21 KiB
C
Raw Normal View History

initial check in based on SVN revision 575
2025-05-14 12:57:39 -05:00
/*
* frq.c
*
* Created on: Jun 8, 2022
* Author: Keith.Lloyd
*/
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "arm_math.h"
#include "spi.h"
#include "fsl_gpio.h"
#include "frq.h"
#include "LPC54114_cm4.h"
#include "display.h"
#include "utils.h"
#include "init.h"
#include "amps.h"
#include "ports.h"
#include "timer.h"
#include "mode.h"
#include "stdbool.h"
#include "eeprom.h"
#include "pwr_level.h"
Lots of refactoring
2025-06-11 10:55:00 -05:00
#include "System/system.h"
initial check in based on SVN revision 575
2025-05-14 12:57:39 -05:00
extern uint8_t Test_Mode, catch_up_flag;
extern uint8_t Taps_Flag;
extern uint32_t new_freq;
extern uint8_t frequency,Cur_Mode,LD_Flag;
extern uint8_t Dds_Pot_Val[2];
extern uint16_t Sys_Chk_tmr;
uint8_t Tx_mode, frq_chg_tmr,old_freq;
FREQDATA_t freq;
FREQUENCY_t freqArray[FREQ_MAX_NUM];
uint8_t foo[4]; //stuff the 2 16-bit values into an array of 4 uint8_t
uint8_t frq_update_flag;
extern uint8_t Power_Level;
extern ClampData_t clampData;
extern uint32_t systemTime;
uint32_t Calc_Freq(uint32_t fout) // Calculate frequency word for DDS
{
float Freg;
uint32_t Frq_result;
Freg = fout * 268435456.0; // FREG = (Frequency * 2^28)/fclk = 12MHz normally
Frq_result = Freg/DDS_CLK + 0.5;
return(Frq_result);
}
void Load_Ramp(uint32_t ramp_freq) // Sets up RAMP DDS for PWM AMP
{
uint16_t ramp_hi = FREQ0_REG; //top 2 bits 0x01 for Freq0 register address
uint16_t ramp_lo = FREQ0_REG;
if (ramp_freq > 0)
{
Send_Ctrl_Word(RAMP_CTRL_WORD1,RAMP); // send Control word to hold setup
ramp_lo |= (ramp_freq & 0x3fff);
ramp_freq >>= 14;
ramp_hi |= (ramp_freq & 0x3fff);
//ramp_hi |= (ramp_freq & 0xc000) >> 14; // Preserve upper 2 bits
foo[0] = (uint8_t)(ramp_lo >> 8); //LS 16-bit word, MSB
foo[1] = (uint8_t)(ramp_lo & 0x00ff); //LS 16-bit word, LSB
foo[2] = (uint8_t)(ramp_hi >> 8);
foo[3] = (uint8_t)(ramp_hi & 0x00ff);
SPI0_SendBytes(foo, 4, RAMP);
Send_Ctrl_Word(RAMP_CTRL_WORD2,RAMP); // send Control word to release setup
}
else
{
Send_Ctrl_Word(RAMP_CTRL_WORD3,RAMP); // Control word to hold setup and put part to sleep
GPIO_PinWrite(GPIO, RAMP_PORT, RAMP_RST_GPIO_PIN, HI); //Hold RST HI
while(1); //stop
}
}
void Load_Frq_Gen(FRQ_OUT_SELECT_t Freq_Mode, int32_t f1, int32_t f2)
{
uint8_t x=0;
uint16_t freq_hi = FREQ0_REG;
uint16_t freq_lo = FREQ0_REG;
if (Freq_Mode == NULL_FREQ)
x = 1; // Switch both DDS chips OFF
if (Freq_Mode == SINGLE)
{
x = 2; // Switch the primary DDS ON
Send_Ctrl_Word(FRQ_CTRL_WORD1,SIGNAL); // send Control word to hold setup
freq_lo |= (f1 & 0x3fff);
f1 >>= 14;
freq_hi |= (f1 & 0x3fff);
foo[0] = (uint8_t)(freq_lo >> 8); //LS 16-bit word, MSB
foo[1] = (uint8_t)(freq_lo & 0x00ff); //LS 16-bit word, LSB
foo[2] = (uint8_t)(freq_hi >> 8);
foo[3] = (uint8_t)(freq_hi & 0x00ff);
// freq_hi |= (f1 & 0xc000) >> 14; // Preserve upper 2 bits
// freq_lo |= (f1 & 0x3fff);
// foo[0] = (uint8_t)(freq_lo >> 8);
// foo[1] = (uint8_t)(freq_lo & 0x00ff);
// foo[2] = (uint8_t)(freq_hi >> 8);
// foo[3] = (uint8_t)(freq_hi & 0x00ff);
SPI0_SendBytes(foo, 4, SIGNAL);
Send_Ctrl_Word(FRQ_CTRL_WORD2,SIGNAL); // send Control word to release setup
}
if (Freq_Mode == DUAL)
{ // ############---Switch both DDS chips ON SYNCHRONOUSLY--######
// Set RESET to hold
// Load F1
Send_Ctrl_Word(FRQ_CTRL_WORD1,SIGNAL); // send Control word to hold setup
freq_lo |= (f1 & 0x3fff);
f1 >>= 14;
freq_hi |= (f1 & 0x3fff);
foo[0] = (uint8_t)(freq_lo >> 8); //LS 16-bit word, MSB
foo[1] = (uint8_t)(freq_lo & 0x00ff); //LS 16-bit word, LSB
foo[2] = (uint8_t)(freq_hi >> 8);
foo[3] = (uint8_t)(freq_hi & 0x00ff);
SPI0_SendBytes(foo, 4, SIGNAL);
Send_Ctrl_Word(FRQ_CTRL_WORD2,SIGNAL); // send Control word to release setup
// Load F2
freq_hi = FREQ0_REG;
freq_lo = FREQ0_REG;
Send_Ctrl_Word(FRQ_CTRL_WORD1,SDSIGNAL); // send Control word to hold setup
freq_lo |= (f2 & 0x3fff);
f2 >>= 14;
freq_hi |= (f2 & 0x3fff);
foo[0] = (uint8_t)(freq_lo >> 8); //LS 16-bit word, MSB
foo[1] = (uint8_t)(freq_lo & 0x00ff); //LS 16-bit word, LSB
foo[2] = (uint8_t)(freq_hi >> 8);
foo[3] = (uint8_t)(freq_hi & 0x00ff);
SPI0_SendBytes(foo, 4, SDSIGNAL);
Send_Ctrl_Word(FRQ_CTRL_WORD2,SDSIGNAL); // send Control word to release setup
// Send_Ctrl_Word(SLP_CTRL_WRD,SIGNAL); // TEST ONLY REMOVE Put unused DDS to sleep
// Send_Ctrl_Word(PHASE_RESET,SIGNAL); // // Set Phase F1 to 0
// Send_Ctrl_Word(PHASE_RESET,SDSIGNAL); // Set Phase F2 to 0
// Send_Ctrl_Word(FRQ_CTRL_WORD2,BOTH_SIGNAL); // Send release code word simultaneously
// End#.
// GPIO_PinWrite(GPIO, 1, 13, 1);
// Set high SD_RST
// Set high SIG_RST
// Set up both Sine Wave generators
// set low SD_RST
// set low SIG_RST.
}
}
void Send_Ctrl_Word(uint16_t Control_Reg, SPI_MODE_t mode)
{
//Set the control register Send MS Byte first then LSByte
foo[0] = (uint8_t)(Control_Reg >> 8); // Reset bit held
foo[1] = (uint8_t)(Control_Reg & 0x00ff);
SPI0_SendBytes(foo, 2, mode);
}
void AddFrequency(uint32_t frequency1,uint32_t frequency2, uint8_t enabled, uint8_t bc_enabled,uint8_t bc_mask,uint8_t pot,float i_lo,float i_hi,float v_lo,float v_hi)
{
uint32_t i = freq.numFrequencies;
freqArray[i].frequency1 = frequency1;
freqArray[i].frequency2 = frequency2;
freqArray[i].enabled = enabled;
freqArray[i].bc_enabled = bc_enabled;
freqArray[i].bc_Mask = bc_mask;
freqArray[i].max_pot = pot;
// freqArray[i].v_coeff_lo = 0.876923;
freqArray[i].v_coeff_lo = v_lo;
freqArray[i].i_coeff_hi = i_hi;
freqArray[i].i_coeff_lo = i_lo;
freq.numFrequencies++;
}
void ClearFreqArray(void)
{
for(uint32_t i = 0; i < FREQ_MAX_NUM; i++)
{
freqArray[i].frequency1 = 0;
freqArray[i].frequency2 = 0;
freqArray[i].enabled = 0;
freqArray[i].bc_enabled = 0;
}
}
Refactoring menu code to be non-blocking Added macros for GPIO read/write
2025-05-16 07:56:18 -05:00
#define PIN_OUTPUT()
initial check in based on SVN revision 575
2025-05-14 12:57:39 -05:00
void FREQ_Init(void)
{
uint32_t tmp;
GPIO_PinWrite(GPIO, SIGNAL_PORT, SIG_RST_GPIO_PIN, 1); // Set all RESET signals to RESET
GPIO_PinWrite(GPIO, SIGNAL_PORT, SD_RST_GPIO_PIN, 1);
GPIO_PinWrite(GPIO, SIGNAL_PORT, RAMP_RST_GPIO_PIN, 1);
Delay_Ticks(1);
GPIO_PinWrite(GPIO, SIGNAL_PORT, RAMP_RST_GPIO_PIN, 0);
GPIO_PinWrite(GPIO, SIGNAL_PORT, SIG_RST_GPIO_PIN, 0); // Set all RESET signals to RESET
GPIO_PinWrite(GPIO, SIGNAL_PORT, SD_RST_GPIO_PIN, 0); // 8/26/24
freq.numFrequencies = 0;
Lots of refactoring
2025-06-11 10:55:00 -05:00
if(!EE_LoadFrequencies())
initial check in based on SVN revision 575
2025-05-14 12:57:39 -05:00
{
FREQ_LoadFactoryDefaults();
}
Send_Ctrl_Word(SLP_CTRL_WRD,SDSIGNAL); // Put unused DDS to sleep
Load_Ramp(6710886); // 300KHz ramp waveform
}
void FREQ_LoadFactoryDefaults(void)
{
#if 1 //Use new function so we don't have to specify all the parameters
//These are the FACTORY TEST Frequencies
FREQ_ClearFrequencies();
FREQ_AddFrequency(512, 1, 1, FT_ACTIVE);
FREQ_AddFrequency(3140, 1, 1, FT_ACTIVE);
FREQ_AddFrequency(8192, 1, 1, FT_ACTIVE);
FREQ_AddFrequency(29433, 1, 1, FT_ACTIVE);
FREQ_AddFrequency(32770, 1, 1, FT_ACTIVE);
FREQ_AddFrequency(65055, 1, 1, FT_ACTIVE);
FREQ_AddFrequency(88779, 1, 1, FT_ACTIVE);
#else //Or we can specify all the parameters
AddFrequency(98, 0, 0, 0, 0, 0,0,0,0,0);
AddFrequency(128, 0, 0, 0, 0, 0,0,0,0,0);
AddFrequency(263, 0, 1, 0, 0, 165,0.8396,0.47,0.876923,0);
AddFrequency(440, 0, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(440, 220, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(512, 0, 1, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(512, 256, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(560, 0, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(577, 0, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(640, 0, 0, 0, 0,180,0.8396,0.47,0.876923,0);
AddFrequency(640, 320, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(815, 0, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(870, 0, 1, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(870, 435, 0, 0, 0, 180,0.8396,0.47,0.876923,0);
AddFrequency(940, 0, 0, 0, 0, 180,0.8105,0.47,0.876923,0);
AddFrequency(940, 470, 0, 0, 0, 180,0.8105,0.47,0.876923,0);
AddFrequency(1024, 0, 0, 0, 0, 180,0.8105,0.49,0.911538,0);
AddFrequency(1170, 0, 1, 0, 0, 180,0.8105,0.49,0.911538,0);
AddFrequency(1170, 585, 0, 0, 0, 180,0.8105,0.49,0.911538,0);
AddFrequency(3140, 0, 1, 1, MASK_144, 180,0.8634,0.482,0.97083,0);
AddFrequency(3140, 1570, 0, 0, 0 , 180,0.8634,0.482,0.97083,0);
AddFrequency(4096, 0, 1, 0, 0, 180,0.8634,0.482,0.97083,0);
AddFrequency(6000, 0, 1, 0, 0, 180,0.8634,0.482,0.97083,0);
AddFrequency(8010, 0, 0, 1,MASK_144, 180,0.8976,0.53,1.025,0);
AddFrequency(8192, 0, 1, 1,MASK_144, 180,0.8976,0.53,1.025,0);
AddFrequency(9820, 0, 1, 0,MASK_144, 180,0.8976,0.53,1.025,0);
AddFrequency(29433, 0, 1, 1,MASK_58, 180,0.9534,0.69,1.043,0);
AddFrequency(32770, 0, 1, 1,MASK_58, 180,0.9581,0.713333333,1.009,0);
AddFrequency(44499, 0, 1, 1,MASK_15, 180,1,0.91,1.035,0);
AddFrequency(66055, 0, 1, 1,MASK_58, 120,1.215,1.35,1.6375,0);
AddFrequency(88779, 0, 1, 1,MASK_15, 120,1.355,1.36,1.8857,0);
AddFrequency(99037, 0, 0, 1,MASK_58, 120,1.355,01.36,0,0);
AddFrequency(200000, 0, 1, 1,MASK_144, 120,1.355,01.36,7.6,0);
AddFrequency(480000, 0, 0, 0,MASK_144, 120,4.111,2.111,7.6,0);
#endif
}
/*
* Pack frequency data and return
* Packed data is used for saving to FLASH
*/
uint32_t FREQ_GetPackedFrequency(uint32_t index)
{
uint32_t packed = freqArray[index].frequency1;
//packed |= freqArray[index].type << FREQ_PACK_SHIFT_TYPE;
packed |= (uint32_t)freqArray[index].enabled << FREQ_PACK_SHIFT_ENABLED;
//packed |= (uint32_t)freqArray[index].inMenu << FREQ_PACK_SHIFT_INMENU;
return packed;
}
/*
* Add a frequency to the list from packed data
* Packed data is used for saving to FLASH
*/
void FREQ_AddPackedFrequency(uint32_t packedFreq)
{
uint32_t frequency = packedFreq & FREQ_PACK_MASK_FREQ;
//FREQ_TYPE_t type = (packedFreq & FREQ_PACK_MASK_TYPE) >> FREQ_PACK_SHIFT_TYPE;
bool enabled = packedFreq & FREQ_PACK_MASK_ENABLED;
//bool inMenu = packedFreq & FREQ_PACK_MASK_INMENU;
FREQ_AddFrequency(frequency, enabled, 1, FT_ACTIVE); //inMenu always 1, all FT_ACTIVE
}
/*
* Clear the frequency list
* Zero out all data and set freq.numFrequencies to zero
*/
void FREQ_ClearFrequencies(void)
{
// frq_update_flag = true;
for(uint32_t i = 0; i < freq.numFrequencies; i++)
{
freqArray[i].frequency1 = 0;
freqArray[i].enabled = 0;
}
freq.numFrequencies = 0;
frequency = 0;
}
/*
* Add a Frequency from UM Setup
*/
void FREQ_AddFrequency(uint32_t f1, uint8_t enabledTemp, uint8_t inMenu, FREQ_TYPE_t type)
{
if(!inMenu)
{
return; //ignore freqs that are not in menu
}
if((type != FT_ACTIVE) && (type != FT_LD_ACTIVE))
{
return; //ignore RX frequency types
}
//TODO: Calculate other things in Keith's freqArray[] here
//frequency2 for LD needs a function to determine 2nd frequency
//Doesn't matter yet since RX doesn't support LD
//scale factors
//other crap
//f2
uint32_t f2 = 0;
if(type == FT_LD_ACTIVE)
{
if(f1 <= FREQ_LD_SWITCH_POINT)
{
f2 = f1 * 2;
}
else if(f1 <= FREQ_LD_MAX_FREQUENCY)
{
f2 = f1 / 2; //TODO: This will break for odd frequencies since it's an integer. Need to rework freqs...
}
else
{
f2 = 0;
}
}
//TODO: Generate values for these!!!!!!!!!!
uint32_t bc_enabledTemp = BC_Enable_Chk(f1);
uint32_t bc_maskTemp = BC_Mask_Chk(f1); //Todo remove as unused
uint32_t max_pot = Max_Pot_Chk(f1);
float32_t v_coeff_lo = V_coeff_lo_Chk(f1);
float32_t i_coeff_hi = I_coeff_hi_Chk(f1);
float32_t i_coeff_lo = I_coeff_lo_Chk(f1);
float32_t v_coeff_hi = V_coeff_hi_Chk(f1); //always 0
AddFrequency(f1, f2, enabledTemp, bc_enabledTemp, bc_maskTemp, max_pot, i_coeff_lo, i_coeff_hi, v_coeff_lo, v_coeff_hi);
}
uint8_t BC_Enable_Chk(uint32_t f1)
{
if((f1 >= BCAST_MIN) && (f1 < BCAST_MAX+1))
return(1);
else
return(0);
}
uint8_t BC_Mask_Chk(uint32_t f1)
{
if((f1 >= BCAST_MIN) && (f1 < 9820)|| (f1 >= 200000) && (f1 <=480000))
return(MASK_144);
else if(f1 == 29430 || f1==32768 || f1==65536 || f1==131072)
return(MASK_58);
else if(f1 == 44624 || f1== 83078)
return(MASK_15);
else
{
return 99;
}
}
uint8_t Max_Pot_Chk(uint32_t f1)
{
if(f1 < 440)
return(180);//165
if((f1 >= 440) && (f1 < 12000)) // 29430
return(235);
if((f1 >= 12000) && (f1 < 29430))
return(245);
if((f1 >= 29430)&& (f1 <= 44500))
return(250);
if((f1 > 44624) && (f1 < 200000))
return(200);
if(f1 == 200000)
return(140);
else
return(140);
//TODO set up default value
}
float V_coeff_lo_Chk(uint32_t f1)
{
float a;
switch(f1)
{
case 1 ... 940:
a= 0.876923;
break;
case 941 ... 1170:
a = 0.911538;
break;
case 1171 ... 6000:
a = 0.97083;
break;
case 6001 ... 8009:
a = 1.025;
break;
case 8010 ... 9820:
a = 1.025;
break;
case 9821 ... 29430:
a = 0.81;
break;
case 29431 ... 32768:
a = 0.81;//1.009;
break;
case 32769 ... 44100:
a = 1.035;
break;
case 44101 ... 65536:
a = 1.0;
break;
case 65537 ... 80000:
a = 1.1;
break;
case 80001 ... 199999:
a = 1.36;
break;
case 200000 ... 480000:
a = 4.5;
break;
default:
a = 0.53;
}
return(a);
}
float V_coeff_hi_Chk(uint32_t f1)
{
return(0);
}
float I_coeff_lo_Chk(uint32_t f1)
{
float a;
// a = freqArray[Search_for_frq(f1)].i_coeff_lo;
switch(f1)
{
case 1 ... 500:
a = 1;
break;
case 501 ... 870:
a= 0.8396;
break;
case 871 ... 1170:
a = 0.8105;
break;
case 1171 ... 3139:
a = 0.8634;
break;
case 3140 ... 6000:
a = 0.8634;
break;
case 6001 ... 8009:
a = 0.8634;
break;
case 8010 ... 9820:
a = 0.8976;
break;
case 9821 ... 29430:
a = 0.8976;
break;
case 29431 ... 32768:
a = 0.8976;
break;
case 32769 ... 44100:
a = 0.91;
break;
case 44101 ... 65536:
a = 1.015;
break;
case 65537 ... 199999:
a = 1.255;
break;
case 200000 ... 480000:
a = 3.111;
break;
default:
a = 0.8976;
}
return(a);
}
float I_coeff_hi_Chk(uint32_t f1)
{
float a;
a = freqArray[Search_for_frq(f1)].i_coeff_hi;
switch(f1)
{
case 1 ... 940:
a= 0.47;
break;
case 941 ... 1170:
a = 0.49;
break;
case 1171 ... 6000:
a = 0.482;
break;
case 6001 ... 8009:
a = 0.53;
break;
case 8010 ... 9820:
a = 0.53;
break;
case 9821 ... 29430:
a = 0.69;
break;
case 29431 ... 32768:
a = 0.71333;
break;
case 32769 ... 44100:
a = 1.035;
break;
case 44101 ... 65536:
a = 1.35;
break;
case 65537 ... 200000:
a = 1.36;
break;
case 200001 ... 480000:
a = 2.111;
break;
default:
a = 0.53;
}
return(a);
}
uint8_t Search_for_frq(uint32_t f1)
{
uint8_t i =0;
for(i=0; i < FREQ_MAX_NUM - 1; i++)
{
if((f1 == freqArray[i].frequency1)) //(freqArray[frq_tmp].enabled > 0)
break;
}
return(i);
}
void FREQ_ToggleEnable(uint32_t selected) //selected is same as frequency index
{
freqArray[selected].enabled ^= 1;
}
FREQUENCY_t FREQ_GetFreqByIndex(uint32_t index)
{
return freqArray[index];
}
Lots of refactoring
2025-06-11 10:55:00 -05:00
FREQUENCY_t* FREQ_GetFreqPointerByIndex(uint32_t index)
{
return &freqArray[index];
}
initial check in based on SVN revision 575
2025-05-14 12:57:39 -05:00
uint32_t FREQ_GetNumFrequencies(void)
{
return freq.numFrequencies;
}
uint8_t Next_Frequency(uint8_t frq_tmp) // increments frequency
{
uint8_t found = false;
uint8_t i;
frq_tmp = frequency;
if (frq_tmp < FREQ_MAX_NUM - 1)
frq_tmp++;
else
frq_tmp = 0;
for(i=0; i < FREQ_MAX_NUM - 1; i++)
{
if(Check_freq_enabled(frq_tmp)) //(freqArray[frq_tmp].enabled > 0)
{
found = 1;
break;
}
if (frq_tmp < FREQ_MAX_NUM - 1)
frq_tmp++;
else
frq_tmp= 0;
}
return(frq_tmp);
}
bool Check_freq_enabled(uint8_t frq_tmp)
{
bool x;
x = false;
if(Cur_Mode != BROADCAST && (freqArray[frq_tmp].enabled > 0))
x= true;
else
if ((Cur_Mode == BROADCAST) && (freqArray[frq_tmp].bc_enabled > 0) && (freqArray[frq_tmp].enabled > 0))
x = true;
return(x);
}
/* Generate name for the frequency at the specified index
* @param index index in the frequency list
* @param *string pointer to the storage location for the name string
*/
void FREQ_GetFrequencyName(uint32_t index, uint8_t *string)
{
//Generate frequency name
// < 1000Hz: "xxxHz"
// < 10kHz: "x.xxkHz"
// < 100kHz: "xx.xkHz"
// >=100kHz: "xxxkHz"
uint32_t freqTemp = freqArray[index].frequency1; //the numeric freqTemp
if(freqArray[index].frequency2 != 0)
{
if(freqTemp < 1000)
{
sprintf(string, "LD %dHz", freqTemp);
}
else if(freqTemp < 10000)
{
sprintf(string, "LD %.2fkHz", (float32_t)freqTemp / 1000.0);
}
else
{
sprintf(string, "ERROR");
}
}
else
{
if(freqTemp < 1000)
{
sprintf(string, "%dHz", freqTemp);
}
else if(freqTemp < 10000)
{
sprintf(string, "%.2fkHz", (float32_t)freqTemp / 1000.0);
}
else if(freqTemp < 100000)
{
sprintf(string, "%.1fkHz", (float32_t)freqTemp / 1000.0);
}
else if(freqTemp < 500000)
{
sprintf(string, "%.0fkHz", (float32_t)freqTemp / 1000.0);
}
else
{
sprintf(string, "ERROR");
}
}
}
/*while(!found && frq_tmp < FREQ_MAX_NUM)
{
frq_tmp++;
if(freqArray[frq_tmp].enabled > 0)
found = true;
if(frq_tmp >= FREQ_MAX_NUM)
frq_tmp = FREQ_MIN;
} */
void Update_Min_Frequency(void)
{
}
void Update_Frequency()
{
uint32_t tmp;
if (Cur_Mode != BROADCAST) // IF - ! Broadcast
{
Enable_Amplifier(); // Select correct amplifier
Select_Transformer(); // Select correct transformer
// tmp = Calc_Freq(freqArray[frequency].frequency1);
// Load_Frq_Gen(SINGLE,tmp,0); // # update the frequency generators
Set_Selected_Freq();
Taps_Flag = false;
if((ACCY_GetConnectedAccessory(1) == ID_CLAMP) || (ACCY_GetConnectedAccessory(2) == ID_CLAMP))
{
Get_Clamp_Value(); // Ensure correct table for Clamp amplitude
SPI0_SendBytes(Dds_Pot_Val, 2, AMPLITUDE);
}
else
if ((ACCY_GetConnectedAccessory(1) == ID_CLAMP2) || (ACCY_GetConnectedAccessory(2) == ID_CLAMP2))
{
clampData.regulate = true;
if (freqArray[frequency].frequency1 < 800)
{
clampData.maxPower = MAX_POWER_TARGET_VLF;
}
else
if (freqArray[frequency].frequency1 < 45000)
{
clampData.maxPower = MAX_POWER_TARGET_LF;
}
else
{
clampData.maxPower = MAX_POWER_TARGET_HF;
}
Get_Clamp_Value();
clampData.timeout = systemTime + CLAMP_REGULATE_DELAY;
if (Power_Level > 0)
{
clampData.prevPowerLevel = 0;
setTestPot();
}
}
// Select_Output_Port(ONE); // Switch in the correct pathway
}
else // else
{
All_Amps_Off(); // shut down Amplifiers DC connections
Disable_DC();
Enable_BC(); // Enable BCAST circuitry using either Minimum or previously selected freq
LD_Flag = false;
// Init_PWM(); // update PWM generators
}
old_freq = frequency; // Indicate done
}
void Set_Selected_Freq(void)
{
uint32_t frq1;
uint32_t frq2;
if(LD_Flag && freqArray[frequency].frequency1 <= MAX_LD_FREQ)
{
frq1 = Calc_Freq(freqArray[frequency].frequency1);
frq2 = freqArray[frequency].frequency1;
frq2 = frq2 * 2.0;
// frq2 = 9100; // test only
frq2 = Calc_Freq(frq2);
Load_Frq_Gen(DUAL,frq1,frq2); // # update the frequency generators
}
else
{
frq1 = Calc_Freq(freqArray[frequency].frequency1);
frq2 = 0;
Load_Frq_Gen(SINGLE,frq1,frq2); // # update the frequency generators
Send_Ctrl_Word(SLP_CTRL_WRD,SDSIGNAL); // Put unused DDS to sleep
}
}
void Reset_DDS(void)
{
GPIO_PinWrite(GPIO, SIGNAL_PORT, SIG_RST_GPIO_PIN, 1); // Set all RESET signals to RESET
GPIO_PinWrite(GPIO, SIGNAL_PORT, SD_RST_GPIO_PIN, 1);
GPIO_PinWrite(GPIO, SIGNAL_PORT, RAMP_RST_GPIO_PIN, 1);
Delay_Ticks(1);
GPIO_PinWrite(GPIO, SIGNAL_PORT, RAMP_RST_GPIO_PIN, 0);
GPIO_PinWrite(GPIO, SIGNAL_PORT, SIG_RST_GPIO_PIN, 0); // Set all RESET signals to RESET
}
void Change_to_next_dc_frq(void)
{
uint32_t tmp_frqx;
uint8_t count;
if((ACCY_GetConnectedAccessory(1) == ID_CLAMP) || (ACCY_GetConnectedAccessory(2) == ID_CLAMP))
{
frequency = Next_Frequency(frequency); // increment the frequency
new_freq = freqArray[frequency].frequency1;
if(freqArray[frequency].frequency1 <= MIN_CTYPE)// is frequecny > min
{
count = 0;
while(freqArray[frequency].frequency1 < MIN_CTYPE && count < FREQ_MAX_NUM)
{
frequency = Next_Frequency(frequency); // increment the frequency
new_freq = freqArray[frequency].frequency1;
count++;
}
// tmp_frqx = Search_Frequency(256); // select minimum frequency for DC Clamp operation
// if (tmp_frqx < FREQ_MAX_NUM) // set up new min freq
// {
// frequency = tmp_frqx;
// new_freq = freqArray[frequency].frequency1;
// }
}
else
{
// frequency = Next_Frequency(frequency); // increment the frequency
new_freq = freqArray[frequency].frequency1;
}
}
else
{
frequency = Next_Frequency(frequency); // increment the frequency
new_freq = freqArray[frequency].frequency1;
Sys_Chk_tmr= DELAY_500MS; // Allow system settling before checking measurements
// catch_up_flag = true;
}
}
void Change_To_Next_BC_Freq(void)
{
uint32_t tmp_frqx;
if(Cur_Mode == BROADCAST) // Special case only if BC mode already selected
{
if (freqArray[frequency].frequency1 < BCAST_MIN) // if (freq < min freq) ToDo
tmp_frqx = Search_Frequency(3140); // select minimum frequency for BCAST
if (tmp_frqx < FREQ_MAX_NUM)
{
frequency = tmp_frqx;
new_freq = freqArray[frequency].frequency1;
}
}
}
Reference in New Issue Copy Permalink