筱笙k

关于2022年TI省赛--F题信号调制度测量装置

赛题分析
理论分析
- AM信号处理方案
- - 方案一：
  - 方案二：
- FM信号处理方案
- - 方案一：
  - 方案二：
- FFT快速傅里叶变换与逆变换算法
- 带通抽样定律采样算法
电路设计
程序设计
- AD9910
- ADS8885
- 加窗函数
- 卡尔曼滤波
- 主要程序
结语

赛题分析

该装置测量并显示信号源输出的被测信号调制度等参数，识别并显示被测信号的调制方式，并且输出解调信号。该装置能实现频率为10MHz到30MHz正弦波为载波的普通单音调幅波、调频波以及载波的识别，测量对应的调幅度以及调频度输出无明显失真的解调信号。
我们采用抽样峰值检测的方法实现AM波的包络还原再重现对应的解调信号，采用带通抽样定律实现FM波的带宽计算调频度，给示波器显示输出部分采用AD9910DDS直接输出。
第三点有些难度，但不至于做不了，不过限于FM解调模块问题，不能实现全带宽的解调(因为需要有电位器微调，而在复测过程中是不允许的，这点也是坑，尽管我们小组已经使用了两块解调模块进行微调：一块店铺购买，一块自制，还是做不全)

理论分析

AM信号处理方案

方案一：

制作峰值采样电路
优点：即使载波的频率在大范围变化改电路采到的峰值任然为包络线，基本不受载波影响adc采集方便控制简单实现方便。
缺点：需要使用模拟开关以及二极管实现峰值采样，需要控制两个模拟开关交替开启，若同时打开电流较大，稍有不慎会烧毁芯片。

方案二：

使用包络检波电路
优点：电路实现简单，元器件少。
缺点：采样时容易受载波频率的影响，在载波增加时幅值会产生较大的衰减。

FM信号处理方案

方案一：

使用NE564模块，将FM波经过放大之后直接使用锁相环解调
优点：模块适用带宽范围较大，解调后输出波形平滑不失真。
缺点：若外部输入信号峰峰值太小会导致NE564模块的解调失败或严重自激。

方案二：

采用FPGA数字解调
优点：处理数据能力快，精度高，能够直接获取信号所有信息，对输入信号的峰峰值要求不高。
缺点：解调算法操作难度大，与外部通信实现度差。

FFT快速傅里叶变换与逆变换算法

为了较快检测到输入波形的谐波分量和失真度，本设计采用了FFT快速傅里叶变换算法。
将输入信号分解为泰勒展开式，对信号的奇偶性成两半：

再令：

式（2.4）只有一个常数项不同，相比普通傅里叶算法，整个计算量缩小了一半。
在实现FFT时，对于输入频率的分辨率可以表示为采样频率与采样点数之比，如式（2.5）。

由式（2.5）可知，输入信号基波频率不是分辨率的整数倍，某一频率的能量将会扩散到相邻频率点上，现频谱泄露的问题，既无法检测到基波频率，也无法准确测到幅值。在测量时要先对原信号频率进行测量，然后选择合适的采样频率和采样点进行计算，以此解决频谱泄露的问题。
在FFT结束并相乘后，得到多项式的点值表示，将点表示转化为系数表示，即可完成离散傅里叶逆变换。该过程可以封装表达为式（2.6）。

其中A意义为多项式的系数表示法;B意义为多项式的点值表示法。
在显示单周期波形时，利用快速傅里叶逆变换，用频率信息还原信号，可以突破对ADC采样点与电压值一一对应的依赖，拟合出多点曲线，使显示波形更加平滑。

带通抽样定律采样算法

根据奈奎斯特采样定理，为了能够完整地重建波形，采样至少应为最高频率的2倍。对于信号频率非常高的情况下，一般ADC达不到如此高的速度，所以带通采样能够节省采样频率，频谱将以采样频率为周期向左右两侧进行周期性延拓。

为了使带通采样的信号不发生混叠，因此平移的时候不能原信号发生混叠：

通过确定采样频率经过FFT计算，将带宽求出，利用带宽与调频度和最后频偏的关系式计算出来。

电路设计

程序设计

本题由于要用到大量的数字信号处理以及FFT计算，因此先引入DSP库准没错

注意：不要忘记在Cube界面中Software Packs中将DSP库勾选上，另外要在生成代码界面中勾选导入所有的 .c/ .h文件，以免DSP库导入不全。
其他的Cube配置没什么好说的，开启ADC+TIM+DMA，做到采样率能精准把控，使能DAC（DAC根据方案才使能，由于电路需求一个偏置电压），使能两串口，一个用于调试，一个用于与串口屏通信，另外需要把串口中断开启。

AD9910

/*******************************************************************************
 * @file     ad9910.h
 * @brief    ad9910驱动程序
 * @version  V2.0
 * @date     2022-7-23
 *
 * @note
 *
 ******************************************************************************/
#ifndef __AD9910_H__
#define __AD9910_H__

#include "main.h"
#include "usart.h"
#include "ad9910_RegMap.h"

#define ulong unsigned long int

extern uint8_t cfr2[4]; //cfr2控制字
extern uint8_t cfr1[4]; //cfr1控制字

#define REEST(x) 						x?HAL_GPIO_WritePin(RST_GPIO_Port,RST_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(RST_GPIO_Port,RST_Pin,GPIO_PIN_RESET)				//RST
#define AD9910_PWR(x) 			x?HAL_GPIO_WritePin(PWR_GPIO_Port,PWR_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(PWR_GPIO_Port,PWR_Pin,GPIO_PIN_RESET)				//PWR

#define PROFILE2(x) 				x?HAL_GPIO_WritePin(PF2_GPIO_Port,PF2_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(PF2_GPIO_Port,PF2_Pin,GPIO_PIN_RESET)				//PF2
#define PROFILE1(x) 				x?HAL_GPIO_WritePin(PF1_GPIO_Port,PF1_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(PF1_GPIO_Port,PF1_Pin,GPIO_PIN_RESET)				//PF1
#define PROFILE0(x) 				x?HAL_GPIO_WritePin(PF0_GPIO_Port,PF0_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(PF0_GPIO_Port,PF0_Pin,GPIO_PIN_RESET)				//PF0
#define IOUP(x) 						x?HAL_GPIO_WritePin(IOUP_GPIO_Port,IOUP_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(IOUP_GPIO_Port,IOUP_Pin,GPIO_PIN_RESET)				//IOUP
#define OSK(x) 							x?HAL_GPIO_WritePin(OSK_GPIO_Port,OSK_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(OSK_GPIO_Port,OSK_Pin,GPIO_PIN_RESET)				//OSK

#define DROVER(x) 					x?HAL_GPIO_WritePin(DRO_GPIO_Port,DRO_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(DRO_GPIO_Port,DRO_Pin,GPIO_PIN_RESET)				//DRO
#define DRCTL(x) 						x?HAL_GPIO_WritePin(DRC_GPIO_Port,DRC_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(DRC_GPIO_Port,DRC_Pin,GPIO_PIN_RESET)				//DRC
#define DRHOLD(x) 					x?HAL_GPIO_WritePin(DRH_GPIO_Port,DRH_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(DRH_GPIO_Port,DRH_Pin,GPIO_PIN_RESET)				//DPH
#define AD9910_SDIO(x) 			x?HAL_GPIO_WritePin(SDIO_GPIO_Port,SDIO_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(SDIO_GPIO_Port,SDIO_Pin,GPIO_PIN_RESET)				//SDIO

#define SCLK(x) 						x?HAL_GPIO_WritePin(SCK_GPIO_Port,SCK_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(SCK_GPIO_Port,SCK_Pin,GPIO_PIN_RESET)	     	//SCK
#define CSB(x) 							x?HAL_GPIO_WritePin(CSB_GPIO_Port,CSB_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(CSB_GPIO_Port,CSB_Pin,GPIO_PIN_RESET)				//CSB

void Init_AD9910(void);

void Freq_convert(ulong Freq);            //写频率
void Amp_convert(uint32_t Amplitude); 		//写幅度
void Set_cfr(void);
void Set_RAMprofile(void);
void Set_RAMdata(uint8_t wave_num);

void SweepFre(ulong Fre_L, ulong Fre_H, ulong StepFre, ulong SweepTime); //扫频
void Square_wave(uint32_t Sample_interval);		//方波;
void Sawtooth_wave(uint32_t Sample_interval);	//三角波

void AD9910_Init(void);

void Txd_8bit(uint8_t txData);				//ad9910写入的8位数据
void Txd_16bit(uint16_t txData);			//ad9910写入的16位数据
void Txd_32bit(uint32_t txData);			//ad9910写入的32位数据
void Txd_64bit(uint64_t txData);			//ad9910写入的64位数据

void TxCfr(void);											//ad9910发送频率值程序
void TxDRG(void);											//ad9910发送DRG参数程序
void Freq_convert_firm(uint64_t Freq);			//ad9910计算频偏字、频率字和发送程序
void write_Amplitude(uint32_t Amp);		//ad9910计算幅度字和发送程序
void SweepFre_firm(uint64_t SweepMinFre, uint64_t SweepMaxFre, uint64_t SweepStepFre, uint64_t SweepTime);		//ad9910设置扫频信号

#endif

/*******************************************************************************
 * @file     ad9910.h
 * @brief    ad9910驱动程序
 * @version  V2.0
 * @date     2022-7-23
 *
 * @note
 *
 ******************************************************************************/
 
#include "ad9910.h"

uint8_t cfr1[] = {0x00, 0x40, 0x00, 0x00};						  //cfr1控制字
uint8_t cfr2[] = {0x01, 0x00, 0x00, 0x00};						  //cfr2控制字
uint8_t cfr3[] = {0x05, 0x0F, 0x41, 0x32};						  //cfr3控制字  40M输入  25倍频  VC0=101   ICP=001;
uint8_t profile11[] = {0x3f, 0xff, 0x00, 0x00, 0x25, 0x09, 0x7b, 0x42}; //profile1控制字 0x25,0x09,0x7b,0x42
																	  //01振幅控制 23相位控制 4567频率调谐字

uint8_t ramprofile0[8] = {0x00};    //ramprofile0控制字
uint8_t drgparameter[20]={0x00};

//高14位幅度控制
const uint8_t ramdata_Square[4096] = 
{	
//方波
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 
	0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00, 0xff,0xfc,0x00,0x00,

	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 
	0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
};

//高14位幅度控制
const uint8_t ramdata_Sawtooth[4096] = 
{
//锯齿波
	0x00,0x00,0x00,0x00, 0x03,0xfc,0x00,0x00, 0x07,0xf8,0x00,0x00, 0x0b,0xf4,0x00,0x00, 
	0x0f,0xf0,0x00,0x00, 0x13,0xec,0x00,0x00, 0x17,0xe8,0x00,0x00, 0x1b,0xe4,0x00,0x00, 
	0x1f,0xe0,0x00,0x00, 0x23,0xdc,0x00,0x00, 0x27,0xd8,0x00,0x00, 0x2b,0xd4,0x00,0x00, 
	0x2f,0xd0,0x00,0x00, 0x33,0xcc,0x00,0x00, 0x37,0xc8,0x00,0x00, 0x3b,0xc4,0x00,0x00, 
	0x3f,0xc0,0x00,0x00, 0x43,0xbc,0x00,0x00, 0x47,0xb8,0x00,0x00, 0x4b,0xb4,0x00,0x00, 
	0x4f,0xb0,0x00,0x00, 0x53,0xac,0x00,0x00, 0x57,0xa8,0x00,0x00, 0x5b,0xa4,0x00,0x00, 
	0x5f,0xa0,0x00,0x00, 0x63,0x9c,0x00,0x00, 0x67,0x98,0x00,0x00, 0x6b,0x94,0x00,0x00, 
	0x6f,0x90,0x00,0x00, 0x73,0x8c,0x00,0x00, 0x77,0x88,0x00,0x00, 0x7b,0x84,0x00,0x00, 	

	0x7f,0x80,0x00,0x00, 0x83,0x7c,0x00,0x00, 0x87,0x78,0x00,0x00, 0x8b,0x74,0x00,0x00, 
	0x8f,0x70,0x00,0x00, 0x93,0x6c,0x00,0x00, 0x97,0x68,0x00,0x00, 0x9b,0x64,0x00,0x00, 
	0x9f,0x60,0x00,0x00, 0xa3,0x5c,0x00,0x00, 0xa7,0x58,0x00,0x00, 0xab,0x54,0x00,0x00, 
	0xaf,0x50,0x00,0x00, 0xb3,0x4c,0x00,0x00, 0xb7,0x48,0x00,0x00, 0xbb,0x44,0x00,0x00, 
	0xbf,0x40,0x00,0x00, 0xc3,0x3c,0x00,0x00, 0xc7,0x38,0x00,0x00, 0xcb,0x34,0x00,0x00, 
	0xcf,0x30,0x00,0x00, 0xd3,0x2c,0x00,0x00, 0xd7,0x28,0x00,0x00, 0xdb,0x24,0x00,0x00, 
	0xdf,0x20,0x00,0x00, 0xe3,0x1c,0x00,0x00, 0xe7,0x18,0x00,0x00, 0xeb,0x14,0x00,0x00, 
	0xef,0x10,0x00,0x00, 0xf3,0x0c,0x00,0x00, 0xf7,0x08,0x00,0x00, 0xfb,0x04,0x00,0x00,
};

/********************************************************************
* 函数： Set_bit(uint8_t dat)
* 参数： dat: 要发送的数据
* 说明： 发送数据到AD9910
********************************************************************/
static void Set_bit(uint8_t dat)
{
	uint8_t i, sbt;
	
	sbt = 0x80;
	SCLK(0);
	for (i = 0; i < 8; i++)
	{
		if((dat & sbt) == 0)
			AD9910_SDIO(0);
		else
			AD9910_SDIO(1);
		SCLK(1);
		sbt = sbt >> 1;
		SCLK(0);
	}
}

/********************************************************************
* 函数： Set_Control_word(uint16_t Addr, uint8_t *Str)
* 参数： Addr: CFRx控制地址
				 *Str: CFRx控制字
				 num:	要发送的控制字数量，即数组长度
* 说明： 写控制字到AD9910寄存器
********************************************************************/
static void Set_Control_word(uint16_t Addr, uint8_t *Str, uint16_t num)
{
	uint8_t i = 0;
	
	CSB(0);
	Set_bit(Addr);
	
	for(i=0; i<num; i++)
		Set_bit( *(Str + i) );

	CSB(1);
	HAL_Delay_us(10);
}

/********************************************************************
* 函数： Set_cfr(void)
* 参数： 无
* 说明： 发送CFRx控制字
********************************************************************/
void Set_cfr(void)
{
	Set_Control_word(0x00, cfr1, 4);//写CFR
	Set_Control_word(0x01, cfr2, 4);
	Set_Control_word(0x02, cfr3, 4);
	IOUP(1);
	HAL_Delay_us(10);
	IOUP(0);
	HAL_Delay(1);
}

/********************************************************************
* 函数： Init_AD9910(void)
* 参数： 无
* 说明： AD9910 初始化
********************************************************************/
void Init_AD9910(void)
{
	AD9910_PWR(0);  		 //软件拉低

	PROFILE0(0);
	PROFILE1(0);
	PROFILE2(0);
	
	DRCTL(0);
	DRHOLD(0);
	REEST(1);
	HAL_Delay(5);
	REEST(0);
	
}

/********************************************************************
* 函数： Set_prodile0(void)
* 参数： 无
* 说明： AD9910 发送profile0控制字
********************************************************************/
static void Set_prodile0(void)
{
	Set_Control_word(0x0e, profile11, 8);//写profile0控制字
	IOUP(1);
	IOUP(0);
}

/********************************************************************
* 函数： Freq_convert(ulong Freq)
* 参数： Freq: 频率
* 说明： 计算频偏字、频率字
********************************************************************/
void Freq_convert(ulong Freq)
{
	ulong Temp;
	
	Temp = (ulong)Freq * 4.294967296 * 1.4285714286; //将输入频率因子分为四个字节  4.294967296=(2^32)/1000000000
	profile11[7] = (uint8_t)Temp;
	profile11[6] = (uint8_t)(Temp >> 8);
	profile11[5] = (uint8_t)(Temp >> 16);
	profile11[4] = (uint8_t)(Temp >> 24);
	Set_prodile0();
}

/********************************************************************
* 函数： Amp_convert(uint32_t Amp)
* 参数： Amp: 幅值
* 说明： 计算幅值
********************************************************************/
void Amp_convert(uint32_t Amp)
{
	ulong Temp;
	
	Temp = (ulong)(Amp * 21.84533); //将输入幅度因子分为两个字节  21.84533=(2^14)/750
	if (Temp > 0x3fff)
		Temp = 0x3fff;
	Temp &= 0x3fff;
	profile11[1] = (uint8_t)Temp;
	profile11[0] = (uint8_t)(Temp >> 8);
	Set_prodile0();
}

/********************************************************************
* 函数： Set_DRG(void)
* 参数： 无
* 说明： 发送DRG参数
********************************************************************/
static void Set_DRG(void)
{
	Set_Control_word(0x0b, drgparameter,8);
	Set_Control_word(0x0c, drgparameter+8,8);
	Set_Control_word(0x0c, drgparameter+16,4);
	
	IOUP(1);
	HAL_Delay_us(10);
	IOUP(0);
	HAL_Delay(1);
}

/********************************************************************
* 函数： SweepFre(ulong Fre_L, ulong Fre_H, ulong StepFre, ulong SweepTime)
* 参数： Fre_L: 		扫频最低频率 		 Hz
				 Fre_H: 		设置扫频上限频率 Hz
				 StepFre: 	设置步进频率 		 Hz
				 SweepTime:	设置步进时间间隔 us
* 说明： 扫频参数设置
********************************************************************/
void SweepFre(ulong Fre_L, ulong Fre_H, ulong StepFre, ulong SweepTime)
{
	ulong Temp1, Temp2, ITemp3, DTemp3, ITemp4, DTemp4;
	
	Temp1 = (ulong)Fre_L*4.294967296;
	if(Fre_H > 400000000)
		Fre_H = 400000000;
	
	Temp2 = (ulong)Fre_H*4.294967296;
	if(StepFre > 400000000)
		StepFre = 400000000;
	
	ITemp3 = (ulong)StepFre*4.294967296;
	DTemp3 = ITemp3;
	ITemp4 = (ulong)SweepTime/4;             //1GHz/4, 单位：ns
	if(ITemp4 > 0xffff)
		ITemp4 = 0xffff;
	DTemp4 = ITemp4;
	
	//扫频上下限
	drgparameter[7]=(uint8_t)Temp1;
	drgparameter[6]=(uint8_t)(Temp1>>8);
	drgparameter[5]=(uint8_t)(Temp1>>16);
	drgparameter[4]=(uint8_t)(Temp1>>24);
	drgparameter[3]=(uint8_t)Temp2;
	drgparameter[2]=(uint8_t)(Temp2>>8);
	drgparameter[1]=(uint8_t)(Temp2>>16);
	drgparameter[0]=(uint8_t)(Temp2>>24);
	
	//频率步进（单位：Hz）
	drgparameter[15]=(uint8_t)ITemp3;
	drgparameter[14]=(uint8_t)(ITemp3>>8);
	drgparameter[13]=(uint8_t)(ITemp3>>16);
	drgparameter[12]=(uint8_t)(ITemp3>>24);
	drgparameter[11]=(uint8_t)DTemp3;
	drgparameter[10]=(uint8_t)(DTemp3>>8);
	drgparameter[9]=(uint8_t)(DTemp3>>16);
	drgparameter[8]=(uint8_t)(DTemp3>>24);
	
	//步进时间间隔（单位：us）
	drgparameter[19]=(uint8_t)ITemp4;
	drgparameter[18]=(uint8_t)(ITemp4>>8);
	drgparameter[17]=(uint8_t)DTemp4;
	drgparameter[16]=(uint8_t)(DTemp4>>8);
	
	//发送DRG参数
	Set_DRG();
	cfr1[0] = 0x00; //RAM 失能
	cfr2[1] = 0x0e; //DRG 使能
	Set_cfr(); 			//发送cfrx控制字
}

/********************************************************************
* 函数： Set_RAMprofile(void)
* 参数： 无
* 说明： 发送RAM profile0控制字
********************************************************************/
void Set_RAMprofile(void)
{
		Set_Control_word(0x0e, ramprofile0, 8);//发送RAM profile0控制字

		IOUP(1);
		HAL_Delay_us(10);
		IOUP(0);
		HAL_Delay(1);
}

/********************************************************************
* 函数： Set_RAMdata(int wave_num)
* 参数： wave_num: 输出选择，1方波，0锯齿波
* 说明： 发送RAM控制字
********************************************************************/
void Set_RAMdata(uint8_t wave_num)
{        
	if(wave_num==1)
	{		
			uint16_t m = 0;
		
			CSB(0);
			Set_bit(0x16);                      //发送ram控制字地址
			for (m=0; m<4096; m++)
				Set_bit(ramdata_Square[m]); 
				CSB(1);
		
			HAL_Delay_us(10);
			IOUP(1);
			HAL_Delay_us(10);
			IOUP(0);
			HAL_Delay(1);
	}
	else
	{
			uint16_t m = 0;
		
			CSB(0);
			Set_bit(0x16);                      //发送ram控制字地址
			for (m=0; m<4096; m++)
				Set_bit(ramdata_Sawtooth[m]); 
				CSB(1);
		
			HAL_Delay_us(10);
			IOUP(1);
			HAL_Delay_us(10);
			IOUP(0);
			HAL_Delay(1);
	}	
}

/********************************************************************
* 函数： Square_wave(uint32_t Sample_interval)
* 参数： Sample_interval:  采样频率
* 说明： 产生方波
********************************************************************/
void Square_wave(uint32_t Sample_interval)
{
		ulong Temp;

		//1GHz/4, 采样间隔范围：4*(1~65536)ns
		Temp = ((1000000000/(unsigned long int)(Sample_interval)/64/4)); 
		if(Temp > 0xffff)
						Temp = 0xffff;
		ramprofile0[7] = 0x24;
		ramprofile0[6] = 0x00;
		ramprofile0[5] = 0x00;
		ramprofile0[4] = 0xc0;
		ramprofile0[3] = 0x0f;
		ramprofile0[2] = (uint8_t)Temp;
		ramprofile0[1] = (uint8_t)(Temp>>8);
		ramprofile0[0] = 0x00;
		Set_RAMprofile();
		Set_RAMdata(1); 
		cfr1[0] = 0xc0;        //RAM 使能，幅度控制
		cfr2[1] = 0x00;        //DRG 失能
		Set_cfr();             //发送cfrx控制字				
}

/********************************************************************
* 函数： Sawtooth_wave(uint32_t Sample_interval)
* 参数： Sample_interval:  采样频率
* 说明： 产生锯齿波
********************************************************************/
void Sawtooth_wave(uint32_t Sample_interval)
{
		ulong Temp;

		//1GHz/4, 采样间隔范围：4*(1~65536)ns
		Temp = ((1000000000/(unsigned long int)(Sample_interval)/64/4));
		if(Temp > 0xffff)
						Temp = 0xffff;
		ramprofile0[7] = 0x24;
		ramprofile0[6] = 0x00;
		ramprofile0[5] = 0x00;
		ramprofile0[4] = 0xc0;
		ramprofile0[3] = 0x0f;
		ramprofile0[2] = (uint8_t)Temp;
		ramprofile0[1] = (uint8_t)(Temp>>8);
		ramprofile0[0] = 0x00;
		Set_RAMprofile();
		Set_RAMdata(0); 
		cfr1[0] = 0xc0;                          //RAM 使能，幅度控制
		cfr2[1] = 0x00;                          //DRG 失能
		Set_cfr();                               //发送cfrx控制字				
}

/* ======================================================================================================================================= */

 /**
  * @brief  ad9910写入的8位数据(地址)
  * @param  txData	写入的8位数据(地址)
  * @return none
	* @note		寄存器地址，单个字节操作
  */
void Txd_8bit(uint8_t txData)
{
	uint8_t i,dat;
	dat=0x80;
	SCLK(0);
	for(i=0;i<8;i++)
	{
		if((txData&dat)==0)
			AD9910_SDIO(0);
		else
			AD9910_SDIO(1);
		SCLK(1);
		dat>>=1;
		SCLK(0);
	}
}

/**
  * @brief  ad9910发送频率值程序
  * @param  none
  * @return none
	* @note		
  */
void TxCfr(void)
{
	uint8_t i;
	CSB(0);
	Txd_8bit(regControlSFMProfile0);
	for(i=0;i<8;i++)
		Txd_8bit(profile11[i]);
	CSB(1);
	
	IOUP(1);
	HAL_Delay(1);
	IOUP(0);
}

/**
  * @brief  ad9910计算频偏字、频率字和发送程序
  * @param  Freq	填入的频率值
  * @return none
	* @note		
  */
void Freq_convert_firm(uint64_t Freq)
{
	uint64_t Temp;
	Temp=(uint64_t)Freq*4.294967296;	   //将输入频率因子分为四个字节  4.294967296=(2^32)/1000000000
	Temp=Temp*1.44;
	profile11[7]=(uint8_t)Temp;
	profile11[6]=(uint8_t)(Temp>>8);
	profile11[5]=(uint8_t)(Temp>>16);
	profile11[4]=(uint8_t)(Temp>>24);
	TxCfr();
}

/**
  * @brief  ad9910计算幅度字和发送程序
  * @param  Amp	幅度字
  * @return none
	* @note		
  */
void write_Amplitude(uint32_t Amp)
{
	uint64_t temp;
	temp = (uint64_t)Amp * 25.20615385;//将输入幅度因子分为两个字节，25.20615385 = 2^14/650;
	if(temp > 0x3fff)
		temp = 0x3fff;
	temp &= 0x3fff;
	profile11[1] = (uint8_t)temp;
	profile11[0] = (uint8_t)(temp >> 8);
	TxCfr();
}

/**
  * @brief  ad9910设置扫频信号
  * @param  Amp	幅度字
  * @return none
	* @note		
  */
void SweepFre_firm(uint64_t SweepMinFre, uint64_t SweepMaxFre, uint64_t SweepStepFre, uint64_t SweepTime)
{
	uint64_t Temp1, Temp2, ITemp3, DTemp3, ITemp4, DTemp4;
	Temp1 = (uint64_t)SweepMinFre*4.294967296;
	if(SweepMaxFre > 400000000)
		SweepMaxFre = 400000000;
	Temp2 = (uint64_t)SweepMaxFre*4.294967296;
	if(SweepStepFre > 400000000)
		SweepStepFre = 400000000;
	ITemp3 = (uint64_t)SweepStepFre*4.294967296;
	DTemp3 = ITemp3;
	ITemp4 = (uint64_t)SweepTime/4; //1GHz/4, 单位：ns
	if(ITemp4 > 0xffff)
		ITemp4 = 0xffff;
	DTemp4 = ITemp4;
	
	//扫频上下限
	drgparameter[7]=(uint8_t)Temp1;
	drgparameter[6]=(uint8_t)(Temp1>>8);
	drgparameter[5]=(uint8_t)(Temp1>>16);
	drgparameter[4]=(uint8_t)(Temp1>>24);
	drgparameter[3]=(uint8_t)Temp2;
	drgparameter[2]=(uint8_t)(Temp2>>8);
	drgparameter[1]=(uint8_t)(Temp2>>16);
	drgparameter[0]=(uint8_t)(Temp2>>24);
	//频率步进（单位：Hz）
	drgparameter[15]=(uint8_t)ITemp3;
	drgparameter[14]=(uint8_t)(ITemp3>>8);
	drgparameter[13]=(uint8_t)(ITemp3>>16);
	drgparameter[12]=(uint8_t)(ITemp3>>24);
	drgparameter[11]=(uint8_t)DTemp3;
	drgparameter[10]=(uint8_t)(DTemp3>>8);
	drgparameter[9]=(uint8_t)(DTemp3>>16);
	drgparameter[8]=(uint8_t)(DTemp3>>24);
	//步进时间间隔（单位：us）
	drgparameter[19]=(uint8_t)ITemp4;
	drgparameter[18]=(uint8_t)(ITemp4>>8);
	drgparameter[17]=(uint8_t)DTemp4;
	drgparameter[16]=(uint8_t)(DTemp4>>8);
	//发送DRG参数
	TxDRG();
}

/**
  * @brief  ad9910发送DRG参数程序
  * @param  none
  * @return none
	* @note		
  */
void TxDRG(void)
{
	uint8_t m,k;

	CSB(0);
	Txd_8bit(0x0b);    //发送数字斜坡限制地址0x0b
	for (m=0;m<8;m++)
		Txd_8bit(drgparameter[m]); 
	CSB(1);
	for(k=0;k<10;k++);
	
	CSB(0);
	Txd_8bit(0x0c);    //发送数字斜坡步长地址0x0c
	for (m=8;m<16;m++)
		Txd_8bit(drgparameter[m]); 
	CSB(1);
	for(k=0;k<10;k++);
	
	CSB(0);
	Txd_8bit(0x0d);    //发送数字斜坡速率地址0x0d
	for (m=16;m<20;m++)
		Txd_8bit(drgparameter[m]); 
	CSB(1);
	for(k=0;k<10;k++);
	
	IOUP(1);
	for(k=0;k<10;k++);
	IOUP(0);
	HAL_Delay(1);
}

static void AD9910_GPIO_Config(void)
{
	REEST(0);
}

static void AD9910_CFR_Config(void)
{
	uint8_t k,m;
	AD9910_GPIO_Config();			//IO口初始化
	AD9910_PWR(0);
	PROFILE0(0);	PROFILE1(0);	PROFILE2(0);
	DRHOLD(0);	DRCTL(0);
	REEST(1);	HAL_Delay(5);	REEST(0);
	
	CSB(0);
	Txd_8bit(regControlCFR1);
	for(m=0;m<4;m++)
		Txd_8bit(cfr1[m]);
	CSB(1);
	for (k=0;k<10;k++);
	
	CSB(0);
	Txd_8bit(regControlCFR2);
	for(m=0;m<4;m++)
		Txd_8bit(cfr2[m]);
	CSB(1);
	for (k=0;k<10;k++);
	
	CSB(0);
	Txd_8bit(regControlCFR3);
	for(m=0;m<4;m++)
		Txd_8bit(cfr3[m]);
	CSB(1);
	for (k=0;k<10;k++);
	
	IOUP(1);
	for(k=0;k<10;k++);
	IOUP(0);
	HAL_Delay(1);
}

void AD9910_Init(void)
{
	AD9910_CFR_Config();
}

/**
  * @brief  ad9910写入的16位数据
  * @param  txData	写入的16位数据
  * @return none
	* @note		POW寄存器操作，双位字节操作
  */
void Txd_16bit(uint16_t txData)
{
	uint8_t i;
	uint16_t dat;
	dat=0x8000;
	SCLK(0);
	for(i=0;i<16;i++)
	{
		if((txData&dat)==0)
			AD9910_SDIO(0);
		else
			AD9910_SDIO(1);
		SCLK(1);
		dat>>=1;
		SCLK(0);
	}
}

/**
  * @brief  ad9910写入的32位数据
  * @param  txData	写入的32位数据
  * @return none
	* @note		对CFR1~3、DAC、IO更新速率、FTW、ASF、多芯片同步、斜坡速率、RAM操作
  */
void Txd_32bit(uint32_t txData)
{
	uint8_t i;
	uint32_t dat;
	dat=0x80000000;
	SCLK(0);
	for(i=0;i<32;i++)
	{
		if((txData&dat)==0)
			AD9910_SDIO(0);
		else
			AD9910_SDIO(1);
		SCLK(1);
		dat>>=1;
		SCLK(0);
	}
}

/**
  * @brief  ad9910写入的64位数据
  * @param  txData	写入的64位数据
  * @return none
	* @note		对斜坡限值、斜坡步长、Profile0~7(单频调制、RAM)操作
  */
void Txd_64bit(uint64_t txData)
{
	uint8_t i;
	uint64_t dat;
	dat=0x8000000000000000;
	SCLK(0);
	for(i=0;i<64;i++)
	{
		if((txData&dat)==0)
			AD9910_SDIO(0);
		else
			AD9910_SDIO(1);
		SCLK(1);
		dat>>=1;
		SCLK(0);
	}
}

ADS8885

/*******************************************************************************
 * @file     ads8885.h
 * @brief    ads8885驱动头文件
 * @version  V1.0
 * @date     2021-10-27
 *
 * @note
 *
 ******************************************************************************/
#ifndef __ADS_8885_H
#define __ADS_8885_H

#include "main.h"
//#include "spi.h"
#include "soft_spi.h"
#include "gpio.h"
#include "usart.h"

extern enum {	Wire3Soft_1=0,
							Wire3Soft_2,
							Wire4Soft_1,
							Wire4Soft_2} mode;

#define CTL_H  			HAL_GPIO_WritePin(CTL_GPIO_Port, CTL_Pin, GPIO_PIN_SET)
#define CTL_L  			HAL_GPIO_WritePin(CTL_GPIO_Port, CTL_Pin, GPIO_PIN_RESET)
//#define DIN_H   		HAL_GPIO_WritePin(DIN_GPIO_Port, DIN_Pin, GPIO_PIN_SET)
//#define DIN_L   		HAL_GPIO_WritePin(DIN_GPIO_Port, DIN_Pin, GPIO_PIN_RESET)
#define CONVST_H    HAL_GPIO_WritePin(CONVST_GPIO_Port, CONVST_Pin, GPIO_PIN_SET)
#define CONVST_L    HAL_GPIO_WritePin(CONVST_GPIO_Port, CONVST_Pin, GPIO_PIN_RESET)

//uint32_t getData_3Wire(void);
uint32_t getData_3WireSoft(void);
uint32_t getData_4WireSoft(void);

double TansformData(uint8_t mode);
							
void getRData(float *data, int Avg);
		
/*                           第二块ADS8885                          */
#define CTL2_H  			HAL_GPIO_WritePin(CTL2_GPIO_Port, CTL2_Pin, GPIO_PIN_SET)
#define CTL2_L  			HAL_GPIO_WritePin(CTL2_GPIO_Port, CTL2_Pin, GPIO_PIN_RESET)
#define CVST2_H    		HAL_GPIO_WritePin(CVST2_GPIO_Port, CVST2_Pin, GPIO_PIN_SET)
#define CVST2_L    		HAL_GPIO_WritePin(CVST2_GPIO_Port, CVST2_Pin, GPIO_PIN_RESET)			

uint32_t getData2_3WireSoft(void);
double TansformData_2ADS(uint8_t mode);
void getRData_2ADS(float *data, int Avg);

#endif

#ifndef __SOFT_SPI_H
#define __SOFT_SPI_H

#include "main.h"
#include "gpio.h"
#include "usart.h"

#define MOSI_H  HAL_GPIO_WritePin(MOSI_GPIO_Port, MOSI_Pin, GPIO_PIN_SET)
#define MOSI_L  HAL_GPIO_WritePin(MOSI_GPIO_Port, MOSI_Pin, GPIO_PIN_RESET)
#define SCLK_H   HAL_GPIO_WritePin(SCLK_GPIO_Port, SCLK_Pin, GPIO_PIN_SET)
#define SCLK_L   HAL_GPIO_WritePin(SCLK_GPIO_Port, SCLK_Pin, GPIO_PIN_RESET)
#define MISO    HAL_GPIO_ReadPin(MISO_GPIO_Port, MISO_Pin)

/* CPOL = 0, CPHA = 0, MSB first MODE0*/
uint8_t SOFT_SPI_RW_MODE0( uint8_t write_dat );
uint8_t SPI_Receiver_MODE0(void);
/* CPOL=0，CPHA=1, MSB first MODE1*/
uint8_t SOFT_SPI_RW_MODE1(uint8_t byte) ;
uint8_t SPI_Receiver_MODE1(void);
uint32_t SPI_Re_18Data(void);
/* CPOL=1，CPHA=0, MSB first MODE2*/
uint8_t SOFT_SPI_RW_MODE2(uint8_t byte) ;
uint8_t SPI_Receiver_MODE2(void);
/* CPOL = 1, CPHA = 1, MSB first MODE3*/
uint8_t SOFT_SPI_RW_MODE3( uint8_t write_dat );
uint8_t SPI_Receiver_MODE3(void);

/*                           第二块ADS8885                          */
#define MOSI2_H  	HAL_GPIO_WritePin(MOSI2_GPIO_Port, MOSI2_Pin, GPIO_PIN_SET)
#define MOSI2_L  	HAL_GPIO_WritePin(MOSI2_GPIO_Port, MOSI2_Pin, GPIO_PIN_RESET)
#define SCLK2_H   HAL_GPIO_WritePin(SCLK2_GPIO_Port, SCLK2_Pin, GPIO_PIN_SET)
#define SCLK2_L   HAL_GPIO_WritePin(SCLK2_GPIO_Port, SCLK2_Pin, GPIO_PIN_RESET)
#define MISO2    	HAL_GPIO_ReadPin(MISO2_GPIO_Port, MISO2_Pin)

uint32_t SPI2_Re_18Data(void);

#endif

/*******************************************************************************
 * @file     ads8885.c
 * @brief    ads8885
 * @version  V1.0
 * @date     2021-10-27
 *
 * @note
 *
 ******************************************************************************/
#include "ads8885.h"

/*ADS8885 三线操作*/
uint32_t getData_3WireSoft(void)
{
	uint32_t data;
	CTL_L;
	CONVST_H;
	HAL_Delay_us(1);
	CONVST_L;
	data = SPI_Re_18Data();
	CONVST_H;
	CTL_H;
	return data;
}

uint32_t getData2_3WireSoft(void)
{
	uint32_t data;
	CTL2_L;
	CVST2_H;
	HAL_Delay_us(1);
	CVST2_L;
	data = SPI2_Re_18Data();
	CVST2_H;
	CTL2_H;
	return data;
}

/*ADS8885 四线操作*/
/*
uint32_t getData_4WireSoft(void)
{
	uint32_t data;
	CTL_L;
	DIN_H;
	CONVST_H;
	HAL_Delay_us(1);
	DIN_L;
	data = SPI_Re_18Data();
	DIN_H;
	CONVST_L;
	CONVST_H;
	return data;
}
*/

double TansformData(uint8_t mode)
{
	double transdata;
	uint32_t data;
//	if(mode == Wire3Soft_1)
//	{
//		data = getData_3WireSoft()+105;
	data = getData_3WireSoft();
		if(data & 0x20000)
		{
			transdata = ((double)(data&0x1ffff)*4.096)/131071;
			if(transdata > 8)
				return 0;
			return transdata-4.096;
		}
		else 
		{
			transdata = ((double)data*4.096)/131071;
			if(transdata > 8)
				return 0;
			return transdata;
		}
	return 0;
}

void getRData(float *data, int Avg)
{
	for(int i=0;i<Avg;i++)
	{
		data[i] = TansformData(Wire3Soft_1);
//		HAL_Delay_us(1);
	}
}




/*                           第二块ADS8885                          */
double TansformData_2ADS(uint8_t mode)
{
	double transdata;
	uint32_t data;
	data = getData2_3WireSoft();
		if(data & 0x20000)
		{
			transdata = ((double)(data&0x1ffff)*4.096)/131071;
			if(transdata > 8)
				return 0;
			return transdata-4.096;
		}
		else 
		{
			transdata = ((double)data*4.096)/131071;
			if(transdata > 8)
				return 0;
			return transdata;
		}
	return 0;
}
void getRData_2ADS(float *data, int Avg)
{
	for(int i=0;i<Avg;i++)
	{
		data[i] = TansformData_2ADS(Wire3Soft_1);
	}
}



#if 0			//硬件SPI
uint32_t getData_3Wire(void)
{
	uint32_t data;
	uint8_t dat[3]={0};
	HAL_GPIO_WritePin(CTL_GPIO_Port,CTL_Pin,GPIO_PIN_SET);		//拉低CTL引脚，保持电平
	HAL_GPIO_WritePin(CONVST_GPIO_Port,CONVST_Pin,GPIO_PIN_SET);
	HAL_Delay_us(1);
	HAL_GPIO_WritePin(CONVST_GPIO_Port,CONVST_Pin,GPIO_PIN_RESET);
	if(HAL_SPI_Receive(&hspi3,(uint8_t*)dat,3,0xff) == HAL_OK)
	{
		data = ((dat[0]<<16) | (dat[1]<<8) | dat[2]);
	}
	HAL_GPIO_WritePin(CTL_GPIO_Port,CTL_Pin,GPIO_PIN_RESET);		//拉高CTL引脚，进行下一次转换
	HAL_Delay_us(1);
	return data;
}
#endif

#include "soft_spi.h"

/*********************************************
模式零         读数据
*********************************************/
/* CPOL = 0, CPHA = 0, MSB first MODE0*/
uint8_t SOFT_SPI_RW_MODE0( uint8_t write_dat )
{
    uint8_t i, read_dat;
    for( i = 0; i < 8; i++ )
    {
        if( write_dat & 0x80 )
            MOSI_H;
        else                    
            MOSI_L;  
        write_dat <<= 1;
        HAL_Delay_us(1);	
        SCLK_H; 
        read_dat <<= 1;  
        if( MISO ) 
            read_dat++; 
				HAL_Delay_us(1);
        SCLK_L; 
        __nop();
    }
    return read_dat;
}
uint8_t SPI_Receiver_MODE0(void)
{
	uint8_t n ,dat;
	for(n=0;n<8;n++)
	{
		SCLK_L;
		dat<<=1;
		if(MISO)		//读取电平
			dat|=0x01;
		else 
			dat&=0xfe;
		SCLK_H;
	}
	SCLK_L;
	return dat;
}

/*********************************************
模式一       读数据
*********************************************/
/* CPOL=0，CPHA=1, MSB first MODE1*/
uint8_t SOFT_SPI_RW_MODE1(uint8_t byte) 
{
  uint8_t i,Temp=0;
	for(i=0;i<8;i++)     // 循环8次
	{
		SCLK_H;     //拉高时钟
		if(byte&0x80)
        {
			MOSI_H;  //若最到位为高，则输出高
        }
		else      
		{
			MOSI_L;   //若最到位为低，则输出低
		}
		byte <<= 1;     // 低一位移位到最高位
		HAL_Delay_us(1);
		SCLK_L;     //拉低时钟
		Temp <<= 1;     //数据左移
 
		if(MISO)
			Temp++;     //若从从机接收到高电平，数据自加一
		HAL_Delay_us(1);
	}
	return (Temp);     //返回数据
}

uint8_t SPI_Receiver_MODE1(void)
{
 uint8_t n ,dat=0;
 for(n=0;n<8;n++)
 {
  SCLK_H;
   dat<<=1;
  if(MISO)
		dat|=0x01;
  else 
		dat&=0xfe;
  SCLK_L;
 }
  SCLK_L;
  return dat;
}
uint32_t SPI_Re_18Data(void)
{
	uint8_t n ;
	uint32_t dat=0;
	for(n=0;n<18;n++)
 {
 #if 1
 SCLK_H;
    dat<<=1;
  if(MISO)
		dat|=0x00001;
  else 
		dat&=0x3ffff;
  SCLK_L;
 }
  SCLK_L;
 dat = (~dat) & (0x3ffff);
 #endif
  return dat;
}
 

uint32_t SPI2_Re_18Data(void)
{
	uint8_t n ;
	uint32_t dat=0;
	for(n=0;n<18;n++)
 {
 #if 1
 SCLK2_H;
    dat<<=1;
  if(MISO2)
		dat|=0x00001;
  else 
		dat&=0x3ffff;
  SCLK2_L;
 }
  SCLK2_L;
 dat = (~dat) & (0x3ffff);
 #endif
  return dat;
}


/*********************************************
模式二          读数据
*********************************************/
/* CPOL=1，CPHA=0, MSB first MODE2*/
uint8_t SOFT_SPI_RW_MODE2(uint8_t byte) 
{
    uint8_t i,Temp=0;
 
	for(i=0;i<8;i++)     // 循环8次
	{
		if(byte&0x80)
    {
			MOSI_H;  //若最到位为高，则输出高
    }
		else      
		{
			MOSI_L;   //若最到位为低，则输出低
		}
		byte <<= 1;     // 低一位移位到最高位
		HAL_Delay_us(1);
		SCLK_L;     //拉低时钟
		Temp <<= 1;     //数据左移
 
		if(MISO)
			Temp++;     //若从从机接收到高电平，数据自加一
		HAL_Delay_us(1);
		SCLK_H;     //拉高时钟
	}
	return (Temp);     //返回数据
}
 
uint8_t SPI_Receiver_MODE2(void)
{
 uint8_t n ,dat;
 for(n=0;n<8;n++)
 {
  SCLK_H;
  dat<<=1;
  if(MISO)
		dat|=0x01;
  else 
		dat&=0xfe;
  SCLK_L;
 }
  SCLK_L;
  return dat;
}
 
/************************************
模式三          读数据
************************************/
/* CPOL = 1, CPHA = 1, MSB first MODE3*/
uint8_t SOFT_SPI_RW_MODE3( uint8_t write_dat )
{
    uint8_t i, read_dat;
    for( i = 0; i < 8; i++ )
    {
			SCLK_L;
			if( write_dat & 0x80 )
					MOSI_H;  
			else
					MOSI_L;  
			write_dat <<= 1;
			HAL_Delay_us(1);	
			SCLK_H; 
			read_dat <<= 1;  
			if( MISO ) 
					read_dat++; 
			HAL_Delay_us(1);
			__nop();
    }
    return read_dat;
}

uint8_t SPI_Receiver_MODE3(void)
{
 uint8_t n ,dat;
 SCLK_L;
 for(n=0;n<8;n++)
 { 
	SCLK_L;
	dat<<=1;
	if(MISO)
		dat|=0x01;
	else 
	  dat&=0xfe;
	SCLK_H;
 }
	SCLK_H;
	return dat;
}

注意：由于是使用了两块ADS8885分别对AM和FM两路解调信号进行采样，采到的数据经过加窗，FFT处理，可以得到解调信号的频率

加窗函数

/*
*file		WindowFunction.h
*author		Vincent Cui
*e-mail		[email protected]
*version	0.3
*data		31-Oct-2014
*brief		各种窗函数的C语言实现
*/

#ifndef _WINDOWFUNCTION_H_
#define _WINDOWFUNCTION_H_

#include 

#define besseli_Flag	0	//缺少besseli函数
#define prod_Flag		0	//缺少prod函数
#define linSpace_Flag	0	//缺少linSpace函数

#define BESSELI_K_LENGTH 10

#define FLATTOPWIN_A0  0.215578995
#define FLATTOPWIN_A1  0.41663158
#define FLATTOPWIN_A2  0.277263158
#define FLATTOPWIN_A3  0.083578947
#define FLATTOPWIN_A4  0.006947368

#define NUTTALL_A0   0.3635819
#define NUTTALL_A1   0.4891775
#define NUTTALL_A2   0.1365995
#define NUTTALL_A3   0.0106411

#define BLACKMANHARRIS_A0 0.35875
#define BLACKMANHARRIS_A1 0.48829
#define BLACKMANHARRIS_A2 0.14128
#define BLACKMANHARRIS_A3 0.01168

#define PI 3.14159265358979323846264338327950288419717  //定义圆周率值

typedef enum
{
	DSP_ERROR = 0,
	DSP_SUCESS,
}dspErrorStatus;

dspErrorStatus triangularWin(uint16_t N, double w[]);
dspErrorStatus bartlettWin(uint16_t N, double w[]);
dspErrorStatus bartLettHannWin(uint16_t N, double w[]);
dspErrorStatus blackManWin(uint16_t N, double w[]);
dspErrorStatus blackManHarrisWin(uint16_t N, double w[]);
dspErrorStatus bohmanWin(uint16_t N, double w[]);
dspErrorStatus chebyshevWin(uint16_t N, double r, double w[]);
dspErrorStatus flatTopWin(uint16_t N, double w[]);
dspErrorStatus gaussianWin(uint16_t N, double alpha, double w[]);
dspErrorStatus hammingWin(uint16_t N, double w[]);
dspErrorStatus hannWin(uint16_t N, double w[]);
dspErrorStatus nuttalWin(uint16_t N, double w[]);
dspErrorStatus parzenWin(uint16_t N, double w[]);
dspErrorStatus rectangularWin(uint16_t N, double w[]);

#if besseli_Flag
dspErrorStatus kaiserWin(uint16_t N, double beta, double w[]);
#endif

#if prod_Flag
dspErrorStatus taylorWin(uint16_t N, uint16_t nbar, double sll, double w[]);
#endif

#if linSpace_Flag
dspErrorStatus tukeyWin(uint16_t N, double r, double w[]);
#endif

#endif

/*
*file		WindowFunction.c
*author		Vincent Cui
*e-mail		[email protected]
*version	0.3
*data		31-Oct-2014
*brief		各种窗函数的C语言实现
*/

#include "winfun.h"
#include 
#include 

#if prod_Flag
/*函数名：taylorWin
*说明：计算泰勒窗。泰勒加权函数
*输入：
*输出：
*返回：
*调用：prod()连乘函数
*其它：用过以后，需要手动释放掉*w的内存空间
*        调用示例：ret = taylorWin(99, 4, 40, &w); 注意此处的40是正数 表示-40dB
*/
dspErrorStatus taylorWin(dspUint_16 N, dspUint_16 nbar, dspDouble sll, dspDouble **w)
{
	dspDouble A;
	dspDouble *retDspDouble;
	dspDouble *sf;
	dspDouble *result;
	dspDouble alpha, beta, theta;
	dspUint_16 i, j;

	/*A = R   cosh(PI, A) = R*/
	A = (dspDouble)acosh(pow((dspDouble)10.0, (dspDouble)sll / 20.0)) / PI;
	A = A * A;

	/*开出存放系数的空间*/
	retDspDouble = (dspDouble *)malloc(sizeof(dspDouble) * (nbar - 1));
	if (retDspDouble == NULL)
		return DSP_ERROR;
	sf = retDspDouble;

	/*开出存放系数的空间*/
	retDspDouble = (dspDouble *)malloc(sizeof(dspDouble) * N);
	if (retDspDouble == NULL)
		return DSP_ERROR;
	result = retDspDouble;

	alpha = prod(1, 1, (nbar - 1));
	alpha *= alpha;
	beta = (dspDouble)nbar / sqrt(A + pow((nbar - 0.5), 2));
	for (i = 1; i <= (nbar - 1); i++)
	{
		*(sf + i - 1) = prod(1, 1, (nbar - 1 + i)) * prod(1, 1, (nbar - 1 - i));
		theta = 1;
		for (j = 1; j <= (nbar - 1); j++)
		{
			theta *= 1 - (dspDouble)(i * i) / (beta * beta * (A + (j - 0.5) * (j - 0.5)));
		}
		*(sf + i - 1) = alpha * (dspDouble)theta / (*(sf + i - 1));
	}

	/*奇数阶*/
	if ((N % 2) == 1)
	{
		for (i = 0; i < N; i++)
		{
			alpha = 0;
			for (j = 1; j <= (nbar - 1); j++)
			{
				alpha += (*(sf + j - 1)) * cos(2 * PI * j * (dspDouble)(i - ((N - 1) / 2)) / N);
			}
			*(result + i) = 1 + 2 * alpha;
		}
	}
	/*偶数阶*/
	else
	{
		for (i = 0; i < N; i++)
		{
			alpha = 0;
			for (j = 1; j <= (nbar - 1); j++)
			{
				alpha += (*(sf + j - 1)) * cos(PI * j * (dspDouble)(2 * (i - (N / 2)) + 1) / N);
			}
			*(result + i) = 1 + 2 * alpha;

		}
	}
	*w = result;
	free(sf);

	return DSP_SUCESS;
}
#endif

/*
*函数名：triangularWin
*说明：计算三角窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = triangularWin(99, w);
*/
dspErrorStatus triangularWin(uint16_t N, double w[])
{
	uint16_t i;

	/*阶数为奇*/
	if ((N % 2) == 1)
	{
		for (i = 0; i < ((N - 1) / 2); i++)
		{
			w[i] = 2 * (double)(i + 1) / (N + 1);
		}
		for (i = ((N - 1) / 2); i < N; i++)
		{
			w[i] = 2 * (double)(N - i) / (N + 1);
		}
	}
	/*阶数为偶*/
	else
	{
		for (i = 0; i < (N / 2); i++)
		{
			w[i] = (i + i + 1) * (double)1 / N;
		}
		for (i = (N / 2); i < N; i++)
		{
			w[i] = w[N - 1 - i];
		}
	}

	return DSP_SUCESS;
}

#if linSpace_Flag
/*
*函数名：tukeyWin
*说明：计算tukey窗函数
*输入：
*输出：
*返回：linSpace()
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
*        调用示例：ret = tukeyWin(99, 0.5, &w);
*/
dspErrorStatus tukeyWin(dspUint_16 N, dspDouble r, dspDouble **w)
{
	dspErrorStatus retErrorStatus;
	dspUint_16        index;
	dspDouble        *x, *result, *retPtr;
	dspDouble        alpha;

	retErrorStatus = linSpace(0, 1, N, &x);
	if (retErrorStatus == DSP_ERROR)
		return DSP_ERROR;

	result = (dspDouble *)malloc(N * sizeof(dspDouble));
	if (result == NULL)
		return DSP_ERROR;

	/*r <= 0 就是矩形窗*/
	if (r <= 0)
	{
		retErrorStatus = rectangularWin(N, &retPtr);
		if (retErrorStatus == DSP_ERROR)
			return DSP_ERROR;
		/*将数据拷出来以后，释放调用的窗函数的空间*/
		memcpy(result, retPtr, (N * sizeof(dspDouble)));
		free(retPtr);
	}
	/*r >= 1 就是汉宁窗*/
	else if (r >= 1)
	{
		retErrorStatus = hannWin(N, &retPtr);
		if (retErrorStatus == DSP_ERROR)
			return DSP_ERROR;
		/*将数据拷出来以后，释放调用的窗函数的空间*/
		memcpy(result, retPtr, (N * sizeof(dspDouble)));
		free(retPtr);
	}
	else
	{
		for (index = 0; index < N; index++)
		{
			alpha = *(x + index);
			if (alpha < (r / 2))
			{
				*(result + index) = (dspDouble)(1 + cos(2 * PI * (dspDouble)(alpha - (dspDouble)r / 2) / r)) / 2;
			}
			else if ((alpha >= (r / 2)) && (alpha <(1 - r / 2)))
			{
				*(result + index) = 1;
			}
			else
			{
				*(result + index) = (dspDouble)(1 + cos(2 * PI * (dspDouble)(alpha - 1 + (dspDouble)r / 2) / r)) / 2;
			}

		}
	}

	free(x);

	*w = result;

	return DSP_SUCESS;
}
#endif

/*
*函数名：bartlettWin
*说明：计算bartlettWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = bartlettWin(99, w);
*/
dspErrorStatus bartlettWin(uint16_t N, double w[])
{
	
	uint16_t n;

	for (n = 0; n < (N - 1) / 2; n++)
	{
		w[n] = 2 * (double)n / (N - 1);
	}

	for (n = (N - 1) / 2; n < N; n++)
	{
		w[n] = 2 - 2 * (double)n / ((N - 1));
	}

	return DSP_SUCESS;
}

/*
*函数名：bartLettHannWin
*说明：计算bartLettHannWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = bartLettHannWin(99, w);
*/
dspErrorStatus bartLettHannWin(uint16_t N, double w[])
{
	uint16_t n;

	/*奇*/
	if ((N % 2) == 1)
	{
		for (n = 0; n < N; n++)
		{
			w[n] = 0.62 - 0.48 * fabs(((double)n / (N - 1)) - 0.5) + 0.38 * cos(2 * PI * (((double)n / (N - 1)) - 0.5));
		}
		for (n = 0; n < (N - 1) / 2; n++)
		{
			w[n] = w[N - 1 - n];
		}
	}
	/*偶*/
	else
	{
		for (n = 0; n < N; n++)
		{
			w[n] = 0.62 - 0.48 * fabs(((double)n / (N - 1)) - 0.5) + 0.38 * cos(2 * PI * (((double)n / (N - 1)) - 0.5));
		}
		for (n = 0; n < N / 2; n++)
		{
			w[n] = w[N - 1 - n];
		}
	}

	return DSP_SUCESS;
}

/*
*函数名：blackManWin
*说明：计算blackManWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = blackManWin(99, w);
*/
dspErrorStatus blackManWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = 0.42 - 0.5 * cos(2 * PI * (double)n / (N - 1)) + 0.08 * cos(4 * PI * (double)n / (N - 1));
	}

	return DSP_SUCESS;
}

/*
*函数名：blackManHarrisWin
*说明：计算blackManHarrisWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = blackManHarrisWin(99, w);
*  minimum 4-term Blackman-harris window -- From Matlab
*/
dspErrorStatus blackManHarrisWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = BLACKMANHARRIS_A0 - BLACKMANHARRIS_A1 * cos(2 * PI * (double)n / (N)) + \
			BLACKMANHARRIS_A2 * cos(4 * PI * (double)n / (N)) - \
			BLACKMANHARRIS_A3 * cos(6 * PI * (double)n / (N));
	}

	return DSP_SUCESS;
}

/*
*函数名：bohmanWin
*说明：计算bohmanWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = bohmanWin(99, w);
*/
dspErrorStatus bohmanWin(uint16_t N, double w[])
{
	uint16_t n;
	
	double x;

	for (n = 0; n < N; n++)
	{
		x = -1 + n *  (double)2 / (N - 1);
		/*取绝对值*/
		x = x >= 0 ? x : (x * (-1));
		w[n] = (1 - x) * cos(PI * x) + (double)(1 / PI) * sin(PI * x);
	}

	return DSP_SUCESS;
}

/*
*函数名：chebyshevWin
*说明：计算chebyshevWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = chebyshevWin(99,100, w);
*/
dspErrorStatus chebyshevWin(uint16_t N, double r, double w[])
{
	uint16_t n, index;
	
	double x, alpha, beta, theta, gama;

	/*10^(r/20)*/
	theta = pow((double)10, (double)(fabs(r) / 20));
	beta = pow(cosh(acosh(theta) / (N - 1)), 2);
	alpha = 1 - (double)1 / beta;

	if ((N % 2) == 1)
	{
		/*计算一半的区间*/
		for (n = 1; n < (N + 1) / 2; n++)
		{
			gama = 1;
			for (index = 1; index < n; index++)
			{
				x = index * (double)(N - 1 - 2 * n + index) / ((n - index) * (n + 1 - index));
				gama = gama * alpha * x + 1;
			}
			w[n] = (N - 1) * alpha * gama;
		}

		theta = w[(N - 1) / 2];
		w[0] = 1;

		for (n = 0; n < (N + 1) / 2; n++)
		{
			w[n] = (double)(w[n]) / theta;
		}

		/*填充另一半*/
		for (; n < N; n++)
		{
			w[n] = w[N - n - 1];
		}
	}
	else
	{
		/*计算一半的区间*/
		for (n = 1; n < (N + 1) / 2; n++)
		{
			gama = 1;
			for (index = 1; index < n; index++)
			{
				x = index * (double)(N - 1 - 2 * n + index) / ((n - index) * (n + 1 - index));
				gama = gama * alpha * x + 1;
			}
			w[n] = (N - 1) * alpha * gama;
		}

		theta = w[(N / 2) - 1];
		w[0] = 1;

		for (n = 0; n < (N + 1) / 2; n++)
		{
			w[n] = (double)(w[n]) / theta;
		}

		/*填充另一半*/
		for (; n < N; n++)
		{
			w[n] = w[N - n - 1];
		}
	}

	return DSP_SUCESS;
}

/*
*函数名：flatTopWin
*说明：计算flatTopWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = flatTopWin(99, w);
*/
dspErrorStatus flatTopWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = FLATTOPWIN_A0 - FLATTOPWIN_A1 * cos(2 * PI * (double)n / (N - 1)) + \
			FLATTOPWIN_A2 * cos(4 * PI * (double)n / (N - 1)) - \
			FLATTOPWIN_A3 * cos(6 * PI * (double)n / (N - 1)) + \
			FLATTOPWIN_A4 * cos(8 * PI * (double)n / (N - 1));
	}

	return DSP_SUCESS;
}


/*
*函数名：gaussianWin
*说明：计算gaussianWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = gaussianWin(99,2.5, w);
*/
dspErrorStatus gaussianWin(uint16_t N, double alpha, double w[])
{
	uint16_t n;
	double k, beta, theta;

	for (n = 0; n < N; n++)
	{
		if ((N % 2) == 1)
		{
			k = n - (N - 1) / 2;
			beta = 2 * alpha * (double)k / (N - 1);
		}
		else
		{
			k = n - (N) / 2;
			beta = 2 * alpha * (double)k / (N - 1);
		}

		theta = pow(beta, 2);
		w[n] = exp((-1) * (double)theta / 2);
	}

	return DSP_SUCESS;
}

/*
*函数名：hammingWin
*说明：计算hammingWin窗函数，汉明窗
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = hammingWin(99, w);
*/
dspErrorStatus hammingWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = 0.54 - 0.46 * cos(2 * PI *  (double)n / (N - 1));
	}

	return DSP_SUCESS;
}

/*
*函数名：hannWin
*说明：计算hannWin窗函数，汉宁窗
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = hannWin(99, w);
*/
dspErrorStatus hannWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = 0.5 * (1 - cos(2 * PI * (double)n / (N - 1)));
	}

	return DSP_SUCESS;
}

#if besseli_Flag
/*
*函数名：kaiserWin
*说明：计算kaiserWin窗函数
*输入：
*输出：
*返回：
*调用：besseli()第一类修正贝塞尔函数
*其它：用过以后，需要手动释放掉*w的内存空间
*        调用示例：ret = kaiserWin(99, 5, &w);
*/
dspErrorStatus kaiserWin(dspUint_16 N, dspDouble beta, dspDouble **w)
{
	dspUint_16 n;
	dspDouble *ret;
	dspDouble theta;

	ret = (dspDouble *)malloc(N * sizeof(dspDouble));
	if (ret == NULL)
		return DSP_ERROR;

	for (n = 0; n < N; n++)
	{
		theta = beta * sqrt(1 - pow(((2 * (dspDouble)n / (N - 1)) - 1), 2));
		*(ret + n) = (dspDouble)besseli(0, theta, BESSELI_K_LENGTH) / besseli(0, beta, BESSELI_K_LENGTH);
	}

	*w = ret;

	return DSP_SUCESS;
}
#endif

/*
*函数名：nuttalWin
*说明：计算nuttalWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = nuttalWin(99, w);
*/
dspErrorStatus nuttalWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = NUTTALL_A0 - NUTTALL_A1 * cos(2 * PI * (double)n / (N - 1)) + \
			NUTTALL_A2 * cos(4 * PI * (double)n / (N - 1)) - \
			NUTTALL_A3 * cos(6 * PI * (double)n / (N - 1));
	}

	return DSP_SUCESS;
}

/*
*函数名：parzenWin
*说明：计算parzenWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = parzenWin(99, w);
*/
dspErrorStatus parzenWin(uint16_t N, double w[])
{
	uint16_t n;
	
	double alpha, k;

	if ((N % 2) == 1)
	{
		for (n = 0; n < N; n++)
		{
			k = n - (N - 1) / 2;
			alpha = 2 * (double)fabs(k) / N;
			if (fabs(k) <= (N - 1) / 4)
			{
				w[n] = 1 - 6 * pow(alpha, 2) + 6 * pow(alpha, 3);
			}
			else
			{
				w[n] = 2 * pow((1 - alpha), 3);
			}
		}
	}
	else
	{
		for (n = 0; n < N; n++)
		{
			k = n - (N - 1) / 2;
			alpha = 2 * (double)fabs(k) / N;
			if (fabs(k) <= (double)(N - 1) / 4)
			{
				w[n] = 1 - 6 * pow(alpha, 2) + 6 * pow(alpha, 3);
			}
			else
			{
				w[n] = 2 * pow((1 - alpha), 3);
			}

		}
	}

	return DSP_SUCESS;
}

/*
*函数名：rectangularWin
*说明：计算rectangularWin窗函数
*输入：
*输出：
*返回：
*调用：
*调用示例：ret = rectangularWin(99, w);
*/
dspErrorStatus rectangularWin(uint16_t N, double w[])
{
	uint16_t n;

	for (n = 0; n < N; n++)
	{
		w[n] = 1;
	}

	return DSP_SUCESS;
}

卡尔曼滤波

#include "kalman.h"

/**
 *卡尔曼滤波器
 *@param 	Kalman *kfp 卡尔曼结构体参数
 *   			float input 需要滤波的参数的测量值（即传感器的采集值）
 *@return 滤波后的参数（最优值）
 */
float KalmanFilter(float inData)
{
		static float prevData = 0;                                 //上一个数据
		static float p = 10, q = 0.001, r = 0.001, kGain = 0;      // q 控制误差 r 控制响应速度
		p = p + q;
		kGain = p / ( p + r );                                      //计算卡尔曼增益
		inData = prevData + ( kGain * ( inData - prevData ) );      //计算本次滤波估计值
		p = ( 1 - kGain ) * p;                                      //更新测量方差
		prevData = inData;
		return inData;                                             //返回估计值

}

/* 优化后的卡尔曼滤波 
	更改Q值，响应加快，但太大会有震荡
	更改R值，响应减慢，越大稳定性会提高，但时间会增加
*/

unsigned long kalman_filter( unsigned long ADC_Value )
{
	float LastData;
	float NowData;
	float kalman_adc;
	static float kalman_adc_old = 0;
	static float PP;
	static float Q = 0.5;
	static float R = 10;
	static float Kg = 0;
	static float P = 1;
	NowData = ADC_Value;
	LastData = kalman_adc_old;
	P = PP + Q;
	Kg = P / ( P + R );
	kalman_adc = LastData + Kg * ( NowData - kalman_adc_old );
	PP = ( 1 - Kg ) * P;
	P = PP;
	kalman_adc_old = kalman_adc;
	return ( unsigned long )( kalman_adc );

}

/* 优化后的卡尔曼滤波 
	更改Q值，响应加快，但太大会有震荡
	更改R值，响应减慢，越大稳定性会提高，但时间会增加
*/

float kalman_filter_FPU( float Val )
{
	float LastData;
	float NowData;
	float kalman_adc;
	static float kalman_adc_old = 1.0;
	static float PP;
	static float Q = 0.5;
	static float R = 10;
	static float Kg = 0;
	static float P = 1;
	NowData = Val;
	LastData = kalman_adc_old;
	P = PP + Q;
	Kg = P / ( P + R );
	kalman_adc = LastData + Kg * ( NowData - kalman_adc_old );
	PP = ( 1 - Kg ) * P;
	P = PP;
	kalman_adc_old = kalman_adc;
	return ( kalman_adc );

}

主要程序

FFT的计算
void FFT_Caculate(uint16_t *adc_buf, uint16_t FFT)
{
	for(int i = 0; i < FFT; i++)
	{
		fft_inputbuf[2*i]=adc_buf[i] * 3.3 / 4096;  //实部
		fft_inputbuf[2*i+1]=0;//虚部全部为0
	}
	arm_cfft_f32(&arm_cfft_sR_f32_len1024,fft_inputbuf,0,1);
	arm_cmplx_mag_f32(fft_inputbuf,fft_outputbuf,FFT);    //把运算结果复数求模得幅值 
	
	fft_outputbuf[0] /= FFT;
	for(int i = 1; i < FFT/2 ;i++) 
	{
		fft_outputbuf[i] /= (FFT/2);
	}
	
	for(int i=0;i<FFT/2;i++)
	{
		printf("%f\n",fft_outputbuf[i]);
	}
}

void FFT_Caculate_NonePrint(uint16_t *adc_buf, uint16_t FFT)
{
	for(int i = 0; i < FFT; i++)
	{
		fft_inputbuf[2*i]=adc_buf[i] * 3.3 / 4096;  //实部
		fft_inputbuf[2*i+1]=0;//虚部全部为0
	}
	arm_cfft_f32(&arm_cfft_sR_f32_len1024,fft_inputbuf,0,1);
	arm_cmplx_mag_f32(fft_inputbuf,fft_outputbuf,FFT);    //把运算结果复数求模得幅值 
	
	fft_outputbuf[0] /= FFT;
	for(int i = 1; i < FFT/2 ;i++) 
	{
		fft_outputbuf[i] /= (FFT/2);
	}
}

unsigned long FFT_Caculate_Float(float *adc_8885_buf, uint16_t FFT)
{
	unsigned long dds_fre;
	float c_fre=0,m_fre;
	int temp_i;
	for(int i=0;i<FFT;i++)
	{
		fft_inputbuf[2*i]=adc_8885_buf[i];  //实部
		fft_inputbuf[2*i+1]=0;//虚部全部为0
	}
	arm_cfft_f32(&arm_cfft_sR_f32_len1024,fft_inputbuf,0,1);
	arm_cmplx_mag_f32(fft_inputbuf,fft_outputbuf,FFT_LENGTH);    //把运算结果复数求模得幅值
	
	for(int i=0;i<FFT_LENGTH/2;i++)
	{
		if(fft_outputbuf[i]>c_fre){
			c_fre=fft_outputbuf[i];
			temp_i = i;
		}
	}
	m_fre = (float)ADS8885_CLK/1024.0 * temp_i;			//基带频率
	dds_fre = (unsigned long)((m_fre/1000)+1)*1000;	//把频率给DDS
	return dds_fre;
}

ADS8885计算频率和幅度
void ADS8885_Calculat_Fre(double *fre)
{
	int temp_ii=0;
	float cmp_fre=0;
	getRData(adc8885_val,FFT_LENGTH);
	for(int i = 0; i < FFT_LENGTH; i++)
	{
		fft_inputbuf[2*i]=adc8885_val[i];
		fft_inputbuf[2*i+1]=0;//虚部全部为0
	}
	arm_cfft_f32(&arm_cfft_sR_f32_len1024,fft_inputbuf,0,1);
	arm_cmplx_mag_f32(fft_inputbuf,fft_outputbuf,FFT_LENGTH);    //把运算结果复数求模得幅值
	for(int i=10;i<FFT_LENGTH/2;i++)
	{
		if(fft_outputbuf[i]>cmp_fre){
			cmp_fre=fft_outputbuf[i];
			temp_ii = i;
		}
	}
	*fre = (float)ADS8885_CLK/1024.0 * temp_ii;
	*fre = (float)((int)(*fre/1000)+1)*1000;
}

void ADS8885_Calculat_Amg(float *adc8885_avgs)
{
	float adc8885_minval = 5.0;
	float adc8885_maxval = -5.0;
	for(int k=0;k<10;k++)
	{
		getRData(adc8885_val,FFT_LENGTH);
		for(int i=0;i<FFT_LENGTH/2;i++) {
			if(adc8885_val[i] > adc8885_maxval)
				adc8885_maxval=adc8885_val[i];
			if(adc8885_val[i] < adc8885_minval)
				adc8885_minval=adc8885_val[i];
		}
		*adc8885_avgs += (adc8885_maxval-(adc8885_minval));
	}
	*adc8885_avgs /= 10.0;
}

结语

main函数过于长且没整理，暂时不贴出
本次还是很可惜，没有将代码写全，若将第三部分的频率拓展到第一、二部分，那才是真真正正的将整个解决完毕，FM解调部分若是想10M-30M均能解调，使用模块的话是肯定不行的，除非至少三块或三块以上的解调模块来互补解调，所以这里的FM解调方法可能采用频谱分析仪的做工思想，用窄带滤波法，分几百Hz的带宽来在频带上一路扫过去，若只有一根则是无调制，三根则是AM调制，若干根则是FM调制。

你可能感兴趣的:(单片机,stm32)

STM32中的计时与延时 lupinjia STM32 stm32 单片机
前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程极客小张 stm32 qt 机器人物联网人机交互毕业设计 c语言
一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程极客小张 stm32 汽车嵌入式硬件物联网单片机 c语言
一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
51单片机——I2C总线存储器24C02的应用老侯（Old monkey） 51单片机嵌入式硬件单片机
目标实现功能单片机先向24C02写入256个字节的数据，再从24C02中一次读取2个字节的数据、并在数码管上动态显示，直至读完24C02中256个字节的数据。1.I2C总线简介I2C总线有两根双向的信号线，一根是数据线SDA,另一根是时钟线SCL。I2C总线通过上拉电阻接正电源，因此，当总线空闲时为高电平。2.I2C通信协议起始信号、停止信号由主机发出。在数据传送时，当时钟线为高电平时，数据线上的
嵌入式单片机中数码管基本实现方法嵌入式开发星球单片机项目实战操作之优秀单片机
1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
基于STM32的简易RTOS分析-预备知识騏威嵌入式
写下这篇文章的主要目的是对自己学习RTOS的历程做一个记录和总结，方便以后回忆翻看。以下内容主要来自宋岩先生翻译的《Cortex-M3权威指南》。目录一、Cortex-M3寄存器简介二、堆栈操作简介三、汇编指令简介LDR和STR指令STMDB和LDMIA指令B、BX、BL、BLX指令MRS和MSR指令四、中断简介中断响应过程简介SVC和PensSV中断简介软件中断五、汇编基础一、Cortex-M3
15-自编写rtos-结合stm32实际调试(ladylolo-os) Ladylolo-lsm stm32 嵌入式硬件单片机
一、任务调度:1.理解:任务切换，用堆栈指针SP保存即将要切换的任务的前后文，然后是用PendSV来执行这些操作的；由于是基于优先级的调度策略，所以每次“心跳”都会看有没有优先级更高的出现，如果有就用PendSV进行上下文切换。2.编写部分:①每个任务自己的属性统称为TCB任务控制块。②任务就绪表有设置优先级(设置的时候变量或上优先级的变量让某个位数等于1)，从任务就绪表中删除(删除时用与来得等于
小米嵌入式面试题目RTOS面试题目嵌入式面试题目好家伙VCC 面试杂谈杂谈面试职场和发展
第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
基于STM32F103C8T6定时器的PWM通道的重映射 —你的鼬先生 stm32 嵌入式硬件单片机
在我们平时的的使用中，我们最常使用的是TIM2和TIM3的PWM通道，但是由于C8T6的IO口有限，所以可能会出现PWM通道的资源不够的情况，从而我们可能会使用PWM4的PWM通道，但是TIM4的PWM通道并不能直接使用，它需要进行一个重映射，不然可能会导致PWM波不能正常发送。以下就是对PWM4的PWM通道进行一个重映射#include"stm32f10x.h"//Deviceheadervoi
【STM32系统】基于STM32设计的锂电池电量/电压检测报警器系统——文末完整资料下载（程序源码/电路原理图/电路PCB/设计文档/模块资料/元器件清单/实物图/答辩问题技巧/PPT模版等）阿齐Archie 单片机嵌入式项目 stm32 嵌入式硬件单片机
基于STM32设计的锂电池电量/电压检测报警器系统系统视频：摘要：本设计旨在研究一个基于STM32F103C8T6微控制器的锂电池电量/电压检测报警器系统，应用于便携式电子设备电池管理。系统通过STM32的ADC模块对锂电池电压进行采集，利用LCD1602显示模块实时显示电池电压，当检测到电池电量不足或电压异常时，蜂鸣器报警模块会发出警报提醒用户。系统采用简单的硬件结构和优化的软件架构，通过对实际
使用STM32实现简单的智能温控系统棂梓知识 stm32 单片机嵌入式硬件
智能温控系统是一种能够根据环境温度实时调整设备的工作状态的系统。在本篇文章中，我们将使用STM32微控制器来实现一个简单的智能温控系统。该系统将会有以下功能：实时监测环境温度，并显示在LCD屏幕上。当环境温度超过设定的阈值时，自动开启风扇。当环境温度恢复正常时，自动关闭风扇。通过按键模拟调节设定的阈值。系统设计首先，我们需要准备一些硬件设备。具体而言，我们需要以下组件：STM32F103C8T6开
STM32 HAL freertos零基础（九）任务通知啥也不会的小白研究生零基础学习Freertos stm32 嵌入式硬件单片机
1、任务通知任务通知用于任务之间同步和通信。任务通知允许一个任务向另一个任务发送一个32位的值，并可以选择是否唤醒正在等待通知的任务。这使得任务之间的同步更加简单和灵活。任务通知功能：发送通知：一个任务可以向另一个任务发送一个32位的值。接收通知：接收任务可以根据接收到的通知来决定何时执行某些操作。通知状态：可以检查任务的当前通知状态。2、相关APIxTaskNotify()//发送通知，带有通知
4×4矩阵键盘详解（STM32）辰哥单片机设计 STM32传感器教学矩阵计算机外设 stm32 嵌入式硬件单片机传感器
目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
STM32的寄存器深度解析千千道 STM32 stm32 单片机物联网
目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
STM32 如何生成随机数千千道 STM32 stm32 单片机物联网
目录一、引言二、STM32随机数发生器概述三、工作原理1.噪声源2.线性反馈移位寄存器（LFSR）3.数据寄存器（RNG_DR）4.监控和检测电路：5.控制和状态寄存器6.生成流程四、使用方法1.使能随机数发生器2.读取随机数3.错误处理五、注意事项1.随机数的质量2.安全性3.性能考虑六、总结一、引言在嵌入式系统开发中，随机数的生成常常是一个重要的需求。无论是用于加密、模拟、游戏还是其他需要不确
STM32——看门狗通俗解析百里与司空 stm32 嵌入式硬件单片机门控循环单元
笔者在学习看门狗的视频后，对看门狗仍然是一知半解，后面在实际应用中发现它是一个很好用的检测或者调试工具。所以总结一下笔者作为初学小白对看门狗的理解。主函数初始化阶段、循环阶段和复位众所周知，程序的运行一般是这样的：程序在进入循环阶段之前，会在初始化阶段将每个寄存器或者某些变量赋值。初始化阶段的代码执行一次后，就不再执行了。而循环阶段的代码会执行很多次，一直循环反复的执行下去。这时，如果进行了复位，
STM32 的 RTC（实时时钟）详解千千道 STM32 stm32 物联网单片机
目录一、引言二、RTC概述三、RTC的工作原理1.时钟源2.计数器3.闹钟功能4.备份寄存器四、RTC寄存器1.RTC_TR（TimeRegister，时间寄存器）2.RTC_DR（DateRegister，日期寄存器）3.RTC_SSR（SubsecondRegister，亚秒寄存器）4.RTC_PRER（PrescalerRegister，预分频器寄存器）5.RTC_CR（ControlReg
学单片机怎么在3-5个月内找到工作？无际单片机编程单片机嵌入式开发物联网 stm32 c语言
每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时
51单片机：P3.3口输入/P 1口输出实验 li星野单片机
51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
单片机中断 woainizhongguo. STM32单片机原理解析篇单片机嵌入式硬件
**在51单片机中，中断向量表的地址是如何被设置的？**在51单片机中，中断向量表的设置是中断系统的核心部分，它定义了中断服务程序的入口地址。以下是中断向量表的设置方法：中断向量表的位置：51单片机的中断向量表通常位于程序存储器的起始位置，即地址0x0000到0x000F（对于双字节的中断向量，实际占用0x0000到0x001F）。这些地址是固定的，由单片机的硬件设计决定。中断向量的分配：每个中断
arm-none-eabi-gcc 不识别__attribute__((at(xxx))命令如何将数据定义到外部SDAM（已验证）梓默 #C
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录可以利用__attribute__((section(".xxx")))实现同样的效果步骤：1.在linker链接文件中添加指定SDRAM加偏移地址2.添加SDRAM自定义section3.将数据定义到自定义区可以利用__attribute__((section(".xxx")))实现同样的效果步骤：从STM32H7xx参考手
基于STC12C5A60S2单片机的LED汉字显示系统的设计 lantiandianzi 单片机嵌入式硬件
本设计基于单片机的LED汉字显示装置，该设计以STC12C5A60S2单片机为核心，利用最小系统和多个模块完成设计，包括点阵驱动模块、时钟模块、串口通信模块、红外线接收模块以及LED点阵屏。其中，点阵驱动模块采用74HC245芯片设计完成，结合DS1302时钟芯片完成LED点阵显示屏的汉字与时间显示，使用按键、串口、红外线遥控可以完成时间的实时更新、自定义汉字显示、改变汉字显示颜色、改变汉字滚动方
51单片机-AT24C02-实验2-秒表实验（可参考上一节） Whappy001 51单片机嵌入式硬件单片机
利用定时器去对按键和数码管进行扫描(Whappy)main.c#include#include"LCD1602.h"#include"AT24C02.h"#include"Delay.h"#include"Timer0.h"#include"Nixie.h"#include"Key.h"unsignedcharKeyNum;unsignedcharMin,Sec,MiniSec;unsignedc
单片机在医疗设备中的应用实例教程 kkchenjj 单片机单片机嵌入式硬件
单片机在医疗设备中的应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、医疗设备等多个领域。特点集成度高：单片机将计算机的主要部件集成在一块芯片上
单片机与传感器接口技术应用实例教程 kkchenjj 单片机单片机 nosql 嵌入式硬件
单片机与传感器接口技术应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、通信设备、医疗器械等领域。特点集成度高：单片机将计算机的主要部件集成在一
Error: No STM32 target found! If your product embeds Debug Authentication, please perform a discover BABA8891 stm32 嵌入式硬件单片机
这个错误信息“Error:NoSTM32targetfound!IfyourproductembedsDebugAuthentication,pleaseperformadiscoveryusingDebugAuthentication”通常出现在使用STM32微控制器的开发过程中，尤其是在尝试通过调试接口（如SWD或JTAG）与设备通信时。这个错误表明调试器或开发工具无法识别或连接到STM32目
掌握单片机,其实并不难培林将军单片机嵌入式硬件
Fearwillbeyourenemy恐惧将会是你的敌人单片机的学习绝不仅仅是对一项知识的掌握。想要学好单片机，需要从硬件结构、内部资源、外设应用等几个方面多方位入手。而要想成为一名嵌入式工程师，就要对单片机的基础非常熟悉，并且掌握C语言当中各个功能的初始化、启动、停止各类函数的编写调试。那么想要掌握单片机需要从哪几个方面入手呢？数字I/O的应用在大多数的单片机实验中，跑马灯实验正是数字I/O的典
STM32与ESP8266的使用每天的积累嵌入式学习日记 stm32 stm32 单片机嵌入式硬件
串口透传“透传”通常指的是数据的透明传输，意思是在不对数据进行任何处理或修改的情况下，将数据从一个接口转发到另一个接口。值得注意的是要避免串口之间无限制的透明，可以采用互斥锁的方式进行限制使用方法对USART1和USART3(用他俩举例)的模式都是设置为Asynchronous，并开启对应的中断。RCC的HighSPeedCLock模式设置为Crystal/Ceramic配置对应的时钟为64Mhz
ARM-Cortex-M架构：1、STM32函数参数传递天城寺电子嵌入式软件开发 arm开发 stm32 汇编 C语言
文章目录参数传递概览堆栈传递参数具体过程参数传递概览在调用子函数时，ARMCortex-M3处理器可以使用寄存器和堆栈来传递参数。具体使用哪种方式取决于传递的参数数量和调用约定（callingconvention）。参数传递方式ARMCortex-M3处理器使用ARMEABI(EmbeddedApplicationBinaryInterface)标准来定义参数传递的约定。根据这个约定：1、寄存器传
jvm调优总结（从基本概念到深度优化） oloz java jvm jdk 虚拟机应用服务器
JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
【Scala十六】Scala核心十：柯里化函数 bit1129 scala
本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系 1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
HashMap dalan_123 java
HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构在java中，最基本的数据结构无外乎：数组和引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
Java Swing如何实时刷新JTextArea，以显示刚才加append的内容周凡杨 java 更新 swing JTextArea
在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
servlet或struts的Action处理ajax请求 g21121 servlet
其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
FineReport的公式编辑框的语法简介老A不折腾 finereport 公式总结
FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。简单的说下自己感觉的公式要注意的几个地方： 1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
linux mysql 数据库乱码的解决办法墙头上一根草 linux mysql 数据库乱码
linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写修改/etc/my.cnf 具体的修改内容如下: [client] default-character-set=utf8 [mysqld] datadir=/var/lib/mysql socket=/va
我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
mysql 基准测试之sysbench annan211 基准测试 mysql基准测试 MySQL测试 sysbench
1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz cd sysbench-0.5 chmod +x autogen.sh ./autogen.sh ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
sql的复杂查询使用案列与技巧百合不是茶 oracle sql 函数数据分页合并查询
本片博客使用的数据库表是oracle中的scott用户表; ------------------- 自然连接查询查询 smith 的上司(两种方法) &
深入学习Thread类 bijian1013 java thread 多线程 java多线程
一．线程的名字下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。同时，Thr
JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 java fastjson net.sf.json
在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。一.fastjson实例 JsonUtil.java package com.study; impor
【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
#!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
nginx三种获取用户真实ip的方法 ronin47
随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。实例环境：用户IP 120.22.11.11
java-判断二叉树是不是平衡 bylijinnan java
参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtils BeanUtils
BeanUtils.copyProperties VS PropertyUtils.copyProperties 作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
[金融与信息安全]最简单的数据结构最安全 comsci 数据结构
现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
vi区段删除 Cwind linux vi 区段删除
区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。 vi概述引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。 vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
清除tomcat缓存的方法总结 dashuaifu tomcat 缓存
用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开依然是以前的Jsp的页面。出现这种现象的原因主要是tomcat缓存的原因。解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
不要盲目的在项目中使用LESS CSS dcj3sjt126com Web less
　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。　　比如它的引用功能 ? .rounded_corners{
[入门]更上一层楼 dcj3sjt126com PHP yii2
更上一层楼通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。本章将介绍一些有助于更好使用 Yii 的资源：
Apache HttpClient使用详解 eksliang httpclient http协议
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
zxing二维码扫描功能 gundumw100 android zxing
经常要用到二维码扫描功能现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
纯HTML+CSS带说明的黄色导航菜单 ini html Web html5 css hovertree
HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果： <!DOCTYPE html > <html > <head> <title>HoverTree
fastjson初始化对性能的影响 kane_xie fastjson 序列化
之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。网上的说法： fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/ funct
java 计时器应用 tangqi609567707 java timer
mport java.util.TimerTask; import java.util.Calendar; public class MyTask extends TimerTask { private static final int
erlang输出调用栈信息 wudixiaotie erlang
在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。也可以用这个函数：erlang:get_s