[参考译文] CCS/LAUNCHXL-F2.8377万S：2.8377万S_FLASH_lnk.cmd-warning

HY Chris，

我等待新版本的controlSUITE继续我的开发，因此我安装了3.4 5版本，并且我正在使用您推荐的V210支持。

现在问题更是不一样了！

闪存和RAM中的构建正常，但RAM中的FIR算法不起作用，相反，闪存中的整个程序不起作用，我不理解原因。

这是我的代码：

//###################################################################
//文件：v伏特 计。c
//标题：通过ePWM为F2837xS触发ADC。
////
！ \addtogroup cpu01_example_list
//! <h1>ADC ePWM触发(ADC_SOC_ePWM)</h1>//
！
//！ 此示例设置ePWM以定期触发ADC。
//！
//！ 程序运行后，内存将包含：\n
//！ -\b AdcaResults \b：
来自//的一系列模数转换样本。 针脚A0。 样本之间的时间根据周期
//！ ePWM计时器。
//
//###########################################################################
//$TI发布：F2837xS支持库v191 $//
发布日期：星期五3月11日15：58：35 CST 2016美元
//$版权：版权所有(C) 2014-2016 Texas2016 Texas Instruments Incorporated -
//             http://www.ti.com/ 保留所有权利$//#########################################################################################


//文件：Voltmetic_FFT.c
//标题：ADC通过ePWM触发F2837xS。
////
！ \addtogroup cpu01_example_list
//! <h1>ADC ePWM触发(ADC_SOC_ePWM)</h1>//
！
//！ 此示例设置ePWM以定期触发ADC。
//！
//！ 程序运行后，内存将包含：\n
//！ -\b AdcaResults \b：
来自//的一系列模数转换样本。 针脚A0。 样本之间的时间根据周期
//！ ePWM计时器。
//
//###########################################################################
//$TI发布：F2837xS支持库v191 $//
发布日期：星期五3月11日15：58：35 CST 2016美元
//$版权：版权所有(C) 2014-2016 Texas2016 Texas Instruments Incorporated -
//             http://www.ti.com/ 保留所有权利$//#########################################################################################


#include "F28x_Project.h"// Device Headerfile and examples include File

#include <FPU_mathy.h>
#include <FPU_vector.h>
#include <FPU_filter.h>
#include <stdlib.h>
#include <stdio.h>
#include #FPu_FFt_fut_fh/fut#fut_fut#fut_h/fp_fut#fut_fut_fut_futh/fut#fp_fut_fh/fp_fp_fut_fh/fp_fh/fp_fp_fh/fp_fut_fut_fh_fut_fh/fut_fut_fh/fh/fp_fp_fh_fp_fh_fut_fut_fh/fut_fh_fh_fh/fp_fp_fut_fh_fut_fh/fp_fp_#include
#include #fp_














#define NPP16
#define UART0_BASE 0x7200
#define SizeCharDisplay 20





//......... FIR滤波器设置..........
#define FIR_ORDER 255

#pragma data_section(firfp,"firfilt")
FIR_FP firfp = FIR_FP_defaults;


#pragma data_section(dbuffer，"firldb")
float32 dbuffer[FIR_ORIORE+1]；

#pragma data_section(sigIn,"sigIn";
#pragma data_section(sigOut,"sigOut")；
float32 sigIn[RFFT_size]；
float32 sigOut[RFFT_size]；

#pragma data_section(coeff, "coefffilt")；
//float32 const coeffe[FIR_ORIENT+1]= FIR_1KHz_LOW；
float32 const coeffe[FIR_ORIENT+1]= FIR_LP_1kHz；
FIR_FP_HANDLE HND_FIRFP =&FIRFP;
//..................................

//RFFT_ADC_F32_struct rfft_adc；
//RFFT_ADC_F32_strut_handle HND_rfft_adc =&rfft_adc；

RFFT_F32_pragt rfft；RFFT_F32_pragt rfft rfft；
RFFT_buffa1





；RFabetfabet_fabetfabetfabetfabet;


#pragma data_section(RFFTmagBuff,"RFFTdata3")；
float32 RFFTmagBuff[RFFT_size/2]；

#pragma data_section(RF32Coef,"RFFTdataa4")；
float32 RFFTF32Coef[RFFT_size]；

#pragma data_section(Power,"praga5";
Float32 Power[RFFT_size/2]；

//#pragma data_section(PeakValueFFT,"RFFTdata6");
//float32 PeakValueFFT[RFFT_size/2]；



#pragma data_section(ADCin1Buff,"RFFTdata7")；
uint16_t ADBuff_1Ft;

#pragma data_section(Buffer_Signal_Scaled,"RFFTdata8")；
Float32 Buffer_Signal_Scaled[RFFT_size]；

//const float RFFTwindow[RFFT_size/2]= RECT2048；




void ConfigureADC(void); //ADC，PWM
void ConfigureEPWM (void)；
void SetupADCEpwm (UINT16通道)；


//void RFFT_F32_WIN (float *pbuffer，float *pWindow，uint16_t size)； //FFT
//void RFFT_F32_MAG(RFFT_F32_struct*)；
void PowerSpectrumCompute (void)；
void FFT(void)；
void FIR_Compute (void)；

void FloatToString(car *str, float f，char size)；//显示
void PrintFloatOnString (const char *Token1，float measure，char SizeMeasure，const char *Token2)；
void PrintIntegerOnString (const char *Token1，long measure，const char *Token2)；
void Print_Freq (float freq)；

//void useupart (void useart) //UART

中断void adca1_isr (void)；//ADC isr
中断void xint3_isr (void)；//GPIO60 isr

静态int max (const float A[]，const int dim，const int index)；


void set_Sample_Frequency (float fs)；//获取和详细
静态float True_RMS (float Signal)，const pin，const int[，const int]，const int index；void
(fid)
静态浮点频率_计算(const float Power_Spectrum []，const float FS，const int FFT_size，const unsigned int Max_Index)；
void AcqueSignal (void)；
void scale_input_buffer (void)；


void SetFreqUP (void)；



void SetPinLCD(void);// GPIO PIN

UINT16结果Index；
volatile UINT16 bufferFull；


float RMS_value =0；
float Freq；
float FSample，FSample_default；
unsigned int Max_Index =0；
volatile char state =0；
size_t p；
size_t q；


//unsigned int msg1len；//= strlen /msg1；

UART； 设置波特率，数据位数，关闭奇偶校验，停止位数和记忆棒模式。
//UINT32_t param1 =(UINT32_t)&SciaRegs;// 0x0.721万;//UINT32_t
param2 =(UART_CONFIG_WLEN_8| UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_EZ);
//UART32_t PARAM3 =5000万;//UINT32_T param1
，
启用

主参数
1，配置



1，配置0 初始化系统控制：
// PLL，看门狗，启用外设时钟
//此示例功能可在F2837xS_sysctrl.c文件中找到。
InitSysCtrl();//

步骤2. 初始化GPIO：
//此示例函数可在F2837xS_GPIO .c文件中找到，
//说明了如何将GPIO设置为其默认状态。
InitGpio();//跳过此示例


//步骤3。 清除所有中断并初始化PIE矢量表：
//禁用CPU中断
dint；

//将PIE控制寄存器初始化为其默认状态。
//默认状态是禁用所有PIE中断，
并清除标志//。
//此函数位于F2837xS_PIECTRL.c文件中。
InitPieCtrl();

SetPinLCD();//setta i pin per il显示器
initialize_lcd();
HOME_LCD();//

禁用CPU中断并清除所有CPU中断标志：
IER = 0x0000；
IFR = 0x0000；

//使用指向shell Interrupt
//服务例程(ISR)的指针初始化PIE矢量表。
//这将填充整个表，即使在此
示例中未使用中断//。 这对于调试非常有用。
// shell ISR例程位于F2837xS_DefaultIsr.C.中
//此函数位于F2837xS_PieVect.C.中
InitPieVectorTable()；





//Map ISR函数
EALLOW；
PieVectorTable.ADCA1_INT =&adca1_ISR;// ADCA中断1的函数
PieVectorTable.XINT3_INT =&xint3_isr；
EDIS；

//配置ADC并开机
ConfigureADC();//

配置ePWM
ConfigureEPWM();

//在通道0上设置ePWM触发转换的ADC
SetupADCEpwm (1)；



//启用全局中断和更高优先级的实时调试事件：
IER || M_INT1；//启用组1中断
EINT；//启用全局中断INTM
ERTM；//启用全局实时中断DBGM


结果索引=0；
缓冲器全轮= 0；

/* FIR通用过滤器初始化*/
hnd_firfp->order = FIR_ORDER；
hnd_firfp->dbuffer_ptr = dbuffer；
hnd_firfp->coeff_ptr =(float *) coeff;
hnd_firfp->init(Hnd_firfp);

//HND_rfft_ADC->Tail =&(HND_rfft->OutBuf)；
hnd_rfft->FFTSize = RFFT_SIZE；//FFT大小
hnd_rfft->FFTStages = RFFT_stages；//FFT stages
hnd_rfft->InBuf =&RFFTin1Buff[0]；//输入缓冲区(12位ADC)输入
hnd_rfft->OutBuf =&RFFToutBuff[0]；//输出缓冲区
HND_rfft->CosSinBuf =&RFFTF32Coef[0]；//twiddle因子
hnd_rfft->MagBuf =&RFFTmagBuff[0]；//幅值输出缓冲区
RFFT_F32_Sincostable (HND_rfft)；//计算宽度因子




//在PIE中启用Xint3：组12中断1
PieCtrlRegs.PIECTRL.bit.ENPIE =1；//启用PIE块
PieCtrlRegs.PIEIER12.bit.INTx1= 1;//启用PIE组12 INTx1
IER || M_INT12;//启用CPU INT12
EINT；//启用全局中断


XintRegs.XINT3CR.bit.POLARITY = 2；//下降边缘
XintRegs.XINT3CR.bit.enable = 1;//XINT3 interrpt enable


GPIO_SetupXINT3Gpio(60)；//GPIO60 SU XINT3



//启用PIE中断
PieCtrlRegs.PIEIER1.bit.INTx1 = 1；

//sync ePWM
EALLOW；
CpuSysRegs.PCLKCR0.bit.TBCLKSYNC = 1；


//无限循环转换
做
｛
开关(状态)
｛

案例1：
执行｛

IF (GPIO _ReadPin (4)== 0){
DELAY _US (1万)；
SetFreqUP();}


IF (GPIO _ReadPin (19)== 0){
DELAY _US (1万)；
SetFreqDWN();
}


PrintIntegerOnString ("速率："，(长) FSample，" Hz)；
HOME_LCD();
}同时(GPIO_ReadPin(61)!=0);

Set_Sample_Frequency (FSample)；
DELAY _US (1万)；
状态= 3；
中断；

案例2：
Set_Sample_Frequency (FSample)；
DELAY _US (1万)；
状态= 3；
中断；

案例3：
AcquitreSignal()；//获取信号
scale_input_buffer()；

对于(q = 0；q < RFFT_SIZE；q++)
｛
sigin[q]= Buffer_Signal_Scaled[q]= RFFTin1Buff[q]；
}
FI_Compute ()；
FFT();//FFT计算
PowerSpectrumCompute ()；//功率谱
Max_Index =最大值(功率，RFFT_SIZE>>>1,1)；//搜索索引最大值起点为1个元素(无DC组件)
频率=频率计算(功率，FSample，RFFT_Size，Max_Index)；
RMS_Value = True_RMS (Buffer_Signal_Scaled，RFFT_Size，Freq，FSample)；
PrintFloatOnString ("VRMS："，RMS_Value，3，" V")；
goto_line_lcd (2)；
print_Freq (Freq)；
GOTO LINE_LCD (3)；
PrintIntegerOnString ("速率："，(长) FSample，" Hz)；
HOME_LCD();
中断；

默认：
FSample = 5万.0 ；//10 KHz默认值
状态= 2；
中断；
}
ASM (" ESTOP0")；
} While (1)；


}//




写入ADC配置，并为ADC A和ADC B
void ConfigureADC(void){打开ADC的电源

EALLOW；

//写入配置
AdcaRegs.ADCCTL2.bit.prescale = 0b0110；//将ADCCLK除法器设置为/4
AdcSetMode (ADC_ADCA，ADC_Resolution _12位，ADC_SIGNALMODE_SINGLE)；


//将脉冲位置设置为延迟
AdcaRegs.ADCCTL1.bit.INTPULSEPOS = 1；

//打开ADC的电源
AdcaRegs.ADCCTL1.bit.ADCPWDNZ = 1；


//延迟1毫秒，以使ADC有时间开机
DELAY _US (1000)；

EDIS；
}

void ConfigureEPWM (void)
{
EALLOW；
//假定ePWM时钟已启用

EPwm1Regs.ETSEL.bit.SOCAEN = 0； //禁用组上的SOC
EPwm1Regs.ETSEL.bit.SOCASEL = 4； //在计数时选择SOC
EPwm1Regs.ETPS.bit.SOCAPRD = 1； //在第一个事件上生成脉冲
EPwm1Regs.CMPA.bit.CMPA = 311；
EPwm1Regs.TBPRD = 624；
EPwm1Regs.TBCTL.bit.CTRMODE = 3； //冻结计数器
EDIS；
}

void SetupADCEpwm (UINT16通道)
{
UINT16 acqps；

//根据分辨率确定最小采集窗口(在SYSCLKS中)
IF ((ADC_Resolution _12bit == AdcaRegs.ADCCTL2.bit.Resolution)｛
acqps =14;//75ns
}
否则｛//分辨率为16位
acqps =63;//320ns
}

//选择要转换的通道和转换结束标志
EALLOW；
AdcaRegs.ADCSOC0CTL.bit.CHSEL =通道；//SOC0将转换针A0

AdcaRegs.ADCSOC0CTL.bit.ACQPS = acqps；//样例窗口为100 SYSCLK周期

AdcaRegs.ADCSOC0CTL.bit.TRIGSEL = 5；// ePWM1 SOCA/C上的触发器

AdcaRegs.ADCINTSEL1N2.bit.INT1SEL = 0；//SOC0的结尾将设置INT1标志

AdcaRegs.ADCINTSEL1N2.bit.INT1E = 1；//启用INT1标志

AdcaRegs.ADCINTFLGCLL.bit.ADCINT1 =1；//确保INT1标志已清除
}


中断无效adca1_ISR(void){


ADCin1Buff[resultsIndex+]=(AddaResultRegs.ADCRESULT0)；
IF (RFFT_Size<=resultsIndex)
｛
结果索引=0；
缓冲区完全= 1;
}

ADcaRegs.ADCINTFLGCLL.bit.ADCINT1 = 1；//清除INT1标志
PieCtrlRegs.PIEACK_ALL = PIEACK_Group1;
}



中断无效xint3_ISR(void)
{
状态= 1；
PieCtrlRegs.PIEACK/ALL = PIEACK_Group12;

}




静态int max (const float a[]，const int dim，const int index)//cerca l'indice a Cui corrisponde il valore Massimo
{ //escludendo gli elemanti a partre dall'indice索引
浮动最大值= 0.0 ；
size_t IQ = 0；
size_t pq = 0；

用于(IQ =索引；IQ <(dim-index)；IQ++)
｛
IF (最大< A[IQ))
｛
最大值= A[IQ]；
PQ = IQ；
}

}

返回pq；
}




浮点最小值(Float A[]，int dim)
{

int min = NULL；
int ii；
用于(ii =0；ii < dim；ii+){

如果(min>a[ii])
｛
min=a[ii];}



}

返回最小值；
}




void SetPinLCD(void)
{

GPIO_SetupPinMux(41, GPIO_MUX_CPU1，0)；
GPIO_SetupPinOptions(41, GPIO_OUTPUT， GPIO_PushPull)；
GPIO设置PinMux (71，GPIO _MUX_CPU1，0)；
GPIO设置PinOptions (71， GPIO输出，GPIO _推送Pull)；
GPIO _设置PinMux (89，GPIO _MUX_CPU1，0)；
GPIO_SetupPinOptions (89，GPIO输出，GPIO _推送)；
GPIO _设置PinMux (90，GPIO _MUX_CPU1， 0)；
GPIO_SetupPinOptions (90，GPIO输出，GPIO PushPull)；
GPIO _SetupPinMux (72， GPIO_MUX_CPU1，0)；
GPIO设置引脚选项(72，GPIO输出，GPIO按钮)；
GPIO_SetupPinMux (78，GPIO _MUX_CPU1，0)；
GPIO _SetupPinOptions (78，GPIO输出， GPIO_PushPull)；
GPIO设置PinMux (65，GPIO _MUX_CPU1，0)；
GPIO设置PinOptions (65， GPIO输出，GPIO _推送Pull)；
GPIO _设置PinMux (43，GPIO _MUX_CPU1，0)；
GPIO_SetupPinOptions (43，GPIO输出，GPIO _推送)；

GPIO _设置PinMux (60，GPIO _MUX_CPU1， 0)；//usato per cambiare la freq di campionamento
gPIO_SetupPinOptions (60，gPIO_INPUT，gPIO_PushPull)；

gPIO_SetupPinMux (61，gPIO_MUX_CPU1， 0)；//confermo la freq di campionamento
gPIO_SetupPinOptions (61，gPIO_INPUT，gPIO_PushPull)；

gPIO_SetupPinMux (4，gPIO_MUX_CPU1， 0)；//增量la freq di campionamento
gPIO_SetupPinOptions (4，gPIO_INPUT，gPIO_PushPull)；

gPIO_SetupPinMux (19，gPIO_MUX_CPU1， 0//decimento la freq di campionamento
gPIO_SetupPinOptions(19, gPIO_INPUT，gPIO_PushPull)；



}//



将浮点转换为字符串，一次一位十进制数字
//假定浮点小于6.5536万且ARRAYSIZE足够大
//问题： 它在大小处截断数字而不舍入
// str是保存结果的char数组，float是要转换的数字
// size是

您可以使用void FloatToString (char *str，float f，char size)
{的小数位数

字符位置；//字符串中的位置

字符长度；//结果的小数部分的长度

CHAR* CURR；//下一个数字的临时保持符

长值；//要转换的十进制数字

位置= 0；//初始化位置，只是为了确定

value =(int)f;//截断浮点数
ltoa (value，str)；//这有点危险，取决于str的长度
//现在str数组的数字在小数点前

if (f <0)//处理负数
｛
f *=-1；
值*=-1;
}

len = strlen(str);//找出整数部分的大小
POS = len；//将指针定位到整数部分的末尾
str[pos++]='，'；//将小数点添加到字符串

while (pos <(size + len + 1))//处理剩余数字
｛
f = f -(浮点)值；//关闭数字的整个部分
f *=10;//将下一位移过
value =(int) f；//获取下一位数
ltoa (值，货币)；//将数字转换为字符串
str[pos++]=*Curr;//向结果字符串和增量指针添加数字
}
}/*




void PeakValueCompute (void){


尺寸_t i；
对于(i=0；i<=(RFFT_SIZE/2)；i++)
｛PeakValueFFT[i]=RFFTmagBuff[i]/RFFT_size；｝//calcola lo spettro di Potenza Che utilizziamo
//per la stula della frequenza fondamentale del segnale
}

*/




static float Frequency_Compute (const float Power_Spectrum []，const float fs，const int FFT_size，const unsigned int Max_Index)
{

float a =0；
float b =0；
size_t jk= 0;

ffor (jk = max_3; jk+
｛
a += Power_Spectrum[jk]*(FS/FFT_size)*jk;
b += Power_Spectrum [jk]；


}

返回a/b;
}



作废采集信号(void)
{
//启动ePWM
EPwm1Regs.ETSEL.bit.SOCAEN = 1；//启用SOCA
EPwm1Regs.TBCTL.bit.CTRMODE = 0；//unfreeze，并进入UP计数模式


//等待ePWM导致ADC转换，然后导致中断，
//填充结果缓冲区，最终设置bufferFull
//标志
while (！bufferFull)；
bufferFull = 0；//清除缓冲区已满标志

//停止ePWM
EPwm1Regs.ETSEL.bit.SOCAEN = 0；//禁用SOCA
EPwm1Regs.TBCTL.bit.CTRMODE =3;//freeze counter

}



void PowerSpectrumCompute (void){

大小_t j；
对于(j = 0；j <=(RFFT_SIZE/2)；j++)

POWER[j]=(RFFTmagBuff[j]*RFFTmagBuff[j])/(pow(RFFT_size,2))；//calcola lo spettro di Potenza Che izzutiliamo
//per la stula della frequenza fondamentale del segnale

}



void FFT(void){


RFFT_f32u (HND_Rfft)；
RFFT_F32_MAG_TMU0(HND_Rfft);
}





void set_Sample_Frequency(Float FS)
{
unsigned int TBPRD =0；
unsigned int CMPA =0；
TBPRD =(unsigned int)((rnd_sp_rs (2亿.0 /(4*FS)-1)))；
CMPA =(unsigned int)((rnd_sp_rs ((2.0)-1)))；
EPwm1Regs.CMPA.bit.CMPA = CMPA；
EPwm1Regs.TBPRD = TBPRD；

}



void PrintFloatOnString (const char *Token1，float measure，char SizeMeasure，const char *Token2)
{
大小_t ij；
CHAR String_empty_Spaces[SizeCharDisplay+1]=""；
char measure_float[SizeCharDisplay+1]=""；

CHAR StrToken1[SizeCharDisplay+1]=""；
CHAR StrToken2[SizeCharDisplay+1]=""；

字符模板字符串[SizeCharDisplay+1]=""；
字符结束字符串[SizeCharDisplay+1]=""；

strcpy (StrToken1，Token1)；
strcpy (StrToken2，Token2)；

strcpy (TempString，StrToken1)；

FloatToString (Measure_Float，Measure，SizeMeasure)；

strcat (TempString，measure_float)；
strcat (TempString，StrToken2)；

对于(ij = 0；ij < SizeCharDisplay-strlen (TempString)；ij++)
｛
string_empty_Spaces[ij]=''；
}
string_empty_spaces[+ij]='\0'；

strcat (TempString，String_empty_Spaces)；

strcpy (EndString，TempString)；
write_string_lcd((unsigned char*)EndString)；
}

void PrintIntegerOnString(const char *Token1, long measure, const char *Token2)
{
尺寸_t IQ；
CHAR String_empty_Spaces[SizeCharDisplay+1]=""；
char measure_long [SizeCharDisplay+1]=""；

CHAR StrToken1[SizeCharDisplay+1]=""；
CHAR StrToken2[SizeCharDisplay+1]=""；

字符模板字符串[SizeCharDisplay+1]=""；
字符结束字符串[SizeCharDisplay+1]=""；

strcpy (StrToken1，Token1)；
strcpy (StrToken2，Token2)；

strcpy (TempString，StrToken1)；

ltoa (measure，measure_long)；

strcat (TempString，Measure_Long)；
strcat (TempString，StrToken2)；

对于(IQ = 0；IQ < SizeCharDisplay-strlen (TempString)；IQ++)
｛
string_empty_Spaces[IQ)=''；
}
string_empty_spaces[+IQ]='\0'；

strcat (TempString，String_empty_Spaces)；

strcpy (EndString，TempString)；
write_string_lcd((unsigned char*)EndString);
}


void SetFreqUP (void){



IF ((FSample >= 800.0)&&(FSample < 1000.0))
FSample +=10；

否则IF ((FSample >= 1000.0)&&(FSample < 1万.0))
FSample +=100；

否则IF ((FSample >= 1万.0)&&(FSample < 10万.0))
FSample +=1000；

否则IF ((FSample >= 10万.0)&&(FSample < 120万.0))
FSample +=1万；

Else FSample = 800；


}


void SetFreqDWN (void)
{


IF ((FSample > 800.0)&&(FSample <= 1000.0))
FSample ---- 10；

否则IF (((FSample > 1000.0)&&(FSample <= 1万.0))
FSample ----=100；

否则IF (((FSample > 1万.0)&&(FSample <= 10万.0))
FSample -=1000；

否则IF (((FSample > 10万.0)&&(FSample <= 120万.0))
FSample -=1万；

否则FSample = 120万；

}






静态浮点True_RMS (浮点信号[]，const int dim，float Freq，float FS)
{

size_t z =0；

float somma_dei_quadrati = 0.0 ；
float media；
//unsigned int nsample =(unsigned int)((Floor(DIM*(Freq/FS)-1)*(FS/Freq)；



z = 0)；0.0 = z+

media ++ signal[z]；
}

media = media/dim;//calcolo la media del segnale



for (z =0；z < dim；z++)
{
signal[z]= signal[z]- media；//sottraggo la media dai valori del segnale icansito
}




for (z =0；z < dim；z++)// adesso ho un subarray che contiene un n iNTERO di periodi del mio segnale
{
somma_die_quadrati ++ Signal[z]*Signal[z]；

}


返回sqrt(somma_die_quadrat/dim)；//valore efficace


}









void Print_Freq(float freq)
{

float freq = freq;

if((Freq >= 0.0 Freq)&(Freq < 1000.0 ))//Hz
｛
IF ((Freq >= 0.0)&(Freq <= 9.999))// 0.001 - 9.999 3 cifre decimali，1 cifra intera.
PrintFloatOnString ("Fo："，Freq，3，" Hz)；

否则IF ((Freq >= 10.0)&(Freq <= 99.99)// 10.00 - 99.99 2 cifre decimali，2 cifre intere
PrintFloatOnString ("Fo："，Freq，2，" Hz)；

否则IF ((Freq >= 100.0)&(Freq <= 999.9)// 100.0 - 999.9 1 cifra decimale，3 cifre intere
PrintFloatOnString ("Fo："，Freq，1，" Hz")；
}




否则IF ((Freq >= 1000.0)&&(Freq < 100万.0))//KHz
｛
频率=频率/ 1000.0 ；
IF ((Freq >= 0.0)&(Freq <= 9.999))// 0.001 - 9.999 3 cifre decimali，1 cifra intera.
PrintFloatOnString ("Fo："，Freq，3，" kHz")；

否则IF ((Freq >= 10.0)&(Freq <= 99.99)// 10.00 - 99.99 2 cifre decimali，2 cifre intere
PrintFloatOnString ("Fo："，Freq，2，" kHz")；

否则IF ((Freq >= 100.0)&(Freq <= 999.9)// 100.0 - 999.9 1 cifra decimale，3 cifre intere
PrintFloatOnString ("Fo："，Freq，1，" kHz")；
}

否则IF ((Freq >= 100万.0)&&(Freq <= 500万.0)//MHz
｛
频率=频率/ 100万.0 ；
IF ((Freq >= 0.0)&(Freq <= 9.999))// 0.001 - 9.999 3 cifre decimali，1 cifra intera.
PrintFloatOnString ("Fo："，Freq，3，" MHz)；

否则IF ((Freq >= 10.0)&(Freq <= 99.99)// 10.00 - 99.99 2 cifre decimali，2 cifre intere
PrintFloatOnString ("Fo："，Freq，2，" MHz)；

否则IF ((Freq >= 100.0)&(Freq <= 999.9)// 100.0 - 999.9 1 cifra decimale，3 cifre intere
PrintFloatOnString ("Fo："，Freq，1，" MHz")；
}




}





void scale输入缓冲区(void){




大小_t k；
对于(k = 0；k <(RFFT_SIZE)；k = k+2)
｛
RFFTin1Buff[k]= 0.0.0732万421875</xmt-block>42.1875万 *(0b00001111111111111111和ADCin1Buff[k])；
RFFTin1Buff[k+1]= 0.0.0732万421875</xmt-block>42.1875万 *(0b0.0011万1111111111111111&ADCin1Buff[k+1]);
}11.1111万}</s>11.11111111亿 // 0.0.0732万421875</xmt-block>42.1875万 =3/4096 (3V ADC参考)


}




void FIR_Compute (void)
{
尺码_t fir；

对于(fir = 0；fir < RFFT_size；fir ++)
｛
hnd_firfp->input = sigin[fir];
hnd_firfp->calc (&firfp)；
sigOut[fir]= HND_FIRFP->输出；

}

复位时：

第一次迭代：

CCS中的设置似乎正常，闪存和ram版本的设置相同，只有命令链接程序更改。

我可以提供哪些其他信息来帮助您理解？

非常感谢

Paolo。