408 lines
6.9 KiB
C
408 lines
6.9 KiB
C
#include <stdio.h>
|
|
#include "fgen.h"
|
|
#include "dds.h"
|
|
#include "io.h"
|
|
#include "spi.h"
|
|
#include "eeprom.h"
|
|
#include "arm_math.h"
|
|
#include "soft_timer.h"
|
|
|
|
static fgen_t _fgen;
|
|
|
|
enum
|
|
{
|
|
FREQ_512 = 512,
|
|
FREQ_3K14 = 3140,
|
|
FREQ_8K = 8192,
|
|
};
|
|
|
|
static 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);
|
|
}
|
|
|
|
|
|
|
|
static float V_coeff_hi_Chk(uint32_t f1)
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
static 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);
|
|
}
|
|
|
|
static float I_coeff_hi_Chk(uint32_t f1)
|
|
{
|
|
float a;
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
dds_t* fgen_getDDS(dds_type_t dds)
|
|
{
|
|
return &_fgen.dds[dds];
|
|
}
|
|
|
|
void fgen_enableDDS(dds_type_t dds, bool enable)
|
|
{
|
|
|
|
}
|
|
|
|
void fgen_clearFrequencies(void)
|
|
{
|
|
for(uint32_t i = 0; i < _fgen.numFrequencies; i++)
|
|
{
|
|
_fgen.frequencies[i].frequency = 0;
|
|
_fgen.frequencies[i].enabled = 0;
|
|
|
|
}
|
|
|
|
_fgen.numFrequencies = 0;
|
|
}
|
|
|
|
void fgen_addFrequency(uint32_t frequency, uint8_t enabled, 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
|
|
}
|
|
|
|
FREQUENCY_t *freq = &_fgen.frequencies[_fgen.numFrequencies];
|
|
|
|
freq->ldFrequency = 0;
|
|
if(type == FT_LD_ACTIVE)
|
|
{
|
|
if(frequency <= FREQ_LD_SWITCH_POINT)
|
|
{
|
|
freq->ldFrequency = frequency * 2;
|
|
}
|
|
else if(frequency <= FREQ_LD_MAX_FREQUENCY)
|
|
{
|
|
freq->ldFrequency = frequency / 2; //TODO: This will break for odd frequencies since it's an integer. Need to rework freqs...
|
|
}
|
|
}
|
|
|
|
float32_t v_coeff_lo = V_coeff_lo_Chk(frequency);
|
|
float32_t i_coeff_hi = I_coeff_hi_Chk(frequency);
|
|
float32_t i_coeff_lo = I_coeff_lo_Chk(frequency);
|
|
float32_t v_coeff_hi = V_coeff_hi_Chk(frequency); //always 0
|
|
|
|
|
|
|
|
freq->frequency = frequency;
|
|
|
|
freq->enabled = enabled;
|
|
|
|
freq->v_coeff_hi = v_coeff_hi;
|
|
freq->v_coeff_lo = v_coeff_lo;
|
|
freq->i_coeff_hi = i_coeff_hi;
|
|
freq->i_coeff_lo = i_coeff_lo;
|
|
|
|
_fgen.numFrequencies++;
|
|
|
|
}
|
|
|
|
FREQUENCY_t *fgen_getByIndex(int index)
|
|
{
|
|
if (index >= _fgen.numFrequencies)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return &_fgen.frequencies[index];
|
|
}
|
|
|
|
// find the nearest enabled frequency higher than freq
|
|
FREQUENCY_t* fgen_findNearest(uint32_t freq)
|
|
{
|
|
for (int i=0; i < _fgen.numFrequencies; ++i)
|
|
{
|
|
FREQUENCY_t *f = &_fgen.frequencies[i];
|
|
|
|
if (f->frequency >= freq)
|
|
{
|
|
return f;
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
uint32_t fgen_getNumFrequencies(void)
|
|
{
|
|
return _fgen.numFrequencies;
|
|
}
|
|
|
|
/* 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 fgen_getFrequencyName(FREQUENCY_t *freq, uint8_t *string)
|
|
{
|
|
//Generate frequency name
|
|
// < 1000Hz: "xxxHz"
|
|
// < 10kHz: "x.xxkHz"
|
|
// < 100kHz: "xx.xkHz"
|
|
// >=100kHz: "xxxkHz"
|
|
|
|
uint32_t freqTemp = freq->frequency; //the numeric freqTemp
|
|
|
|
if(freq->ldFrequency != 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");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void loadDefaults(void)
|
|
{
|
|
//These are the FACTORY TEST Frequencies
|
|
fgen_clearFrequencies();
|
|
|
|
fgen_addFrequency(512, 1, 1, FT_ACTIVE);
|
|
fgen_addFrequency(3140, 1, 1, FT_ACTIVE);
|
|
fgen_addFrequency(8192, 1, 1, FT_ACTIVE);
|
|
fgen_addFrequency(29433, 1, 1, FT_ACTIVE);
|
|
fgen_addFrequency(32770, 1, 1, FT_ACTIVE);
|
|
fgen_addFrequency(65055, 1, 1, FT_ACTIVE);
|
|
fgen_addFrequency(88779, 1, 1, FT_ACTIVE);
|
|
}
|
|
|
|
|
|
static bool loadFrequencies(void)
|
|
{
|
|
bool success = true;
|
|
|
|
//Load frequencies
|
|
uint32_t tempNumFreqs = EE_ReadUINT32(EE_FREQ_NUM);
|
|
if((tempNumFreqs > FREQ_MAX_NUM) || (tempNumFreqs == 0)) //Error check numFreqs
|
|
{
|
|
loadDefaults();
|
|
}
|
|
else
|
|
{
|
|
for(uint32_t i = 0; i < tempNumFreqs; i++)
|
|
{
|
|
uint32_t packedFreq = EE_ReadUINT32(EE_FREQ_START + EE_BYTES_PER_WORD * i);
|
|
|
|
uint32_t frequency = packedFreq & FREQ_PACK_MASK_FREQ;
|
|
bool enabled = packedFreq & FREQ_PACK_MASK_ENABLED;
|
|
|
|
fgen_addFrequency(frequency, enabled, 1, FT_ACTIVE); //inMenu always 1, all FT_ACTIVE
|
|
|
|
}
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
void fgen_init(void)
|
|
{
|
|
uint32_t tmp;
|
|
gpio_pin_t resetPin;
|
|
|
|
// init sets reset
|
|
resetPin.port = PORT(PIN_SIG_RESET);
|
|
resetPin.pin = PIN (PIN_SIG_RESET);
|
|
dds_init(&_fgen.dds[DDS_SIGNAL], SIGNAL, resetPin);
|
|
|
|
resetPin.port = PORT(PIN_SD_RESET);
|
|
resetPin.pin = PIN (PIN_SD_RESET);
|
|
dds_init(&_fgen.dds[DDS_DIRECTION], SDSIGNAL, resetPin);
|
|
|
|
resetPin.port = PORT(PIN_RAMP_RST);
|
|
resetPin.pin = PIN (PIN_RAMP_RST);
|
|
dds_init(&_fgen.dds[DDS_RAMP], RAMP, resetPin);
|
|
|
|
stimer_delay(10);
|
|
|
|
// clear reset after delay
|
|
for (int i=0; i<NUM_DDS; ++i)
|
|
{
|
|
dds_reset(&_fgen.dds[i], false);
|
|
}
|
|
|
|
_fgen.numFrequencies = 0;
|
|
|
|
loadFrequencies();
|
|
|
|
dds_sleep(&_fgen.dds[DDS_DIRECTION], true, false);
|
|
|
|
}
|
|
|