STM32+FDC2214的手势识别装置程序+原理图PCB文件

用stm32做的手势识别装置，有原理图和pcb文件，2018年电赛D题。以下为FDC2214部分代码
Altium Designer画的原理图和PCB图如下：(附件中可下载工程文件)
pcb文件及其原理图.zip (15.65 MB, 售价: 1 工控币)

2020-5-19 00:57 上传

点击文件名下载附件
STM32 FDC2214的手势识别程序源码.zip (331.42 KB, 售价: 1 工控币)

2020-5-19 00:57 上传

点击文件名下载附件

部分stm32程序源码

1. #include "fdc2214.h"
   
2. #include "delay.h"
   
3. u32 Data_FDC;
   
4. void FDC_IIC_Delay(void)
   
5. {
   
6.         delay_us(2);
   
7. }
   
8. 
   
9. void FDC_GPIO_Init(void)
   
10. {
    
11.         
    
12. }
    
13. 
    
14. void FDC_IIC_Init(void)
    
15. {                                             
    
16.   GPIO_InitTypeDef  GPIO_InitStructure;
    
17.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);//先使能外设IO PORTC时钟
    
18.                
    
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_5;//端口配置
    
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                 //推挽输出
    
21.         //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    
22.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                //IO口速度为50MHz
    
23.   GPIO_Init(GPIOC, &GPIO_InitStructure);                                            //根据设定参数初始化GPIO
    
24.         
    
25.   GPIO_SetBits(GPIOC,GPIO_Pin_4|GPIO_Pin_5);                                  //PC.4,PC.5 输出高        
    
26. }
    
27. 
    
28. //产生IIC起始信号
    
29. void FDC_IIC_Start(void)
    
30. {
    
31.         FDC_SDA_OUT();     //sda线输出
    
32.         FDC_IIC_SDA=1;                    
    
33.         FDC_IIC_SCL=1;
    
34.         FDC_IIC_Delay();
    
35.          FDC_IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
36.         FDC_IIC_Delay();
    
37.         FDC_IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    
38. }         
    
39. //产生IIC停止信号
    
40. void FDC_IIC_Stop(void)
    
41. {
    
42.         FDC_SDA_OUT();//sda线输出
    
43.         FDC_IIC_SCL=0;
    
44.         FDC_IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
45.          FDC_IIC_Delay();
    
46.         FDC_IIC_SCL=1;
    
47.         FDC_IIC_SDA=1;//发送I2C总线结束信号
    
48.         FDC_IIC_Delay();                                                                  
    
49. }
    
50. //等待应答信号到来
    
51. //返回值：1，接收应答失败
    
52. //        0，接收应答成功
    
53. u8 FDC_IIC_Wait_Ack(void)
    
54. {
    
55.         u8 ucErrTime=0;
    
56.         FDC_SDA_IN();      //SDA设置为输入  
    
57.         FDC_IIC_SDA=1;FDC_IIC_Delay();           
    
58.         FDC_IIC_SCL=1;FDC_IIC_Delay();         
    
59.         while(FDC_READ_SDA)
    
60.         {
    
61.                 ucErrTime++;
    
62.                 if(ucErrTime>250)
    
63.                 {
    
64.                         FDC_IIC_Stop();
    
65.                         return 1;
    
66.                 }
    
67.         }
    
68.         FDC_IIC_SCL=0;//时钟输出0            
    
69.         return 0;  
    
70. }
    
71. 
    
72. 
    
73. //产生ACK应答
    
74. //void FDC_IIC_Ack(void)
    
75. //{
    
76. //        FDC_IIC_SCL=0;
    
77. //        FDC_SDA_OUT();
    
78. //        FDC_IIC_SDA=0;
    
79. //        FDC_IIC_Delay();
    
80. //        FDC_IIC_SCL=1;
    
81. //        FDC_IIC_Delay();
    
82. //        FDC_IIC_SCL=0;
    
83. //}
    
84. 
    
85. //debug
    
86. void FDC_IIC_Ack(void)
    
87. {
    
88.         FDC_IIC_SCL=0;
    
89.         FDC_IIC_SDA=0;
    
90.         FDC_IIC_Delay();
    
91.         FDC_IIC_SCL=1;
    
92.         FDC_IIC_Delay();
    
93.         FDC_IIC_SCL=0;
    
94.         FDC_IIC_Delay();
    
95.         FDC_IIC_SDA=1;
    
96. }
    
97. 
    
98. 
    
99. //不产生ACK应答                    
    
100. void FDC_IIC_NAck(void)
     
101. {
     
102.         FDC_IIC_SCL=0;
     
103.         FDC_SDA_OUT();
     
104.         FDC_IIC_SDA=1;
     
105.         FDC_IIC_Delay();
     
106.         FDC_IIC_SCL=1;
     
107.         FDC_IIC_Delay();
     
108.         FDC_IIC_SCL=0;
     
109. }                                                                              
     
110. //IIC发送一个字节
     
111. //返回从机有无应答
     
112. //1，有应答
     
113. //0，无应答                          
     
114. void FDC_IIC_Send_Byte(u8 txd)
     
115. {                        
     
116.   u8 t;   
     
117.         FDC_SDA_OUT();            
     
118.     FDC_IIC_SCL=0;//拉低时钟开始数据传输
     
119.     for(t=0;t<8;t++)
     
120.     {              
     
121.         FDC_IIC_SDA=(txd&0x80)>>7;
     
122.         txd<<=1;           
     
123.                     FDC_IIC_SCL=1;
     
124.                     FDC_IIC_Delay();
     
125.                     FDC_IIC_SCL=0;        
     
126.                     FDC_IIC_Delay();
     
127.     }         
     
128. }            
     
129. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
     
130. u8 FDC_IIC_Read_Byte(unsigned char ack)
     
131. {
     
132.         unsigned char i,receive=0;
     
133.         FDC_SDA_IN();//SDA设置为输入
     
134.     for(i=0;i<8;i++ )
     
135.         {
     
136.         FDC_IIC_SCL=0;
     
137.         FDC_IIC_Delay();
     
138.                 FDC_IIC_SCL=1;
     
139.         receive<<=1;
     
140.         if(FDC_READ_SDA)receive++;   
     
141.                 FDC_IIC_Delay();
     
142.     }                                 
     
143.     if (!ack)
     
144.         FDC_IIC_NAck();//发送nACK
     
145.     else
     
146.         FDC_IIC_Ack(); //发送ACK   
     
147.     return receive;
     
148. }
     
149. 
     
150. u8 Set_FDC2214(u8 reg,u8 MSB,u8 LSB)                                 
     
151. {
     
152.     FDC_IIC_Start();
     
153.         FDC_IIC_Send_Byte((FDC2214_ADDR<<1)|0);//发送器件地址+写命令        
     
154.         if(FDC_IIC_Wait_Ack())        //等待应答
     
155.         {
     
156.                 FDC_IIC_Stop();                 
     
157.                 return 1;               
     
158.         }
     
159.     FDC_IIC_Send_Byte(reg);//写寄存器地址
     
160.     FDC_IIC_Wait_Ack();                 //等待应答
     
161.         FDC_IIC_Send_Byte(MSB);  //发送数据1
     
162.         if(FDC_IIC_Wait_Ack())         //等待ACK
     
163.         {
     
164.                 FDC_IIC_Stop();         
     
165.                 return 1;                 
     
166.         }                 
     
167.         FDC_IIC_Send_Byte(LSB);  //发送数据2
     
168.         if(FDC_IIC_Wait_Ack())         //等待ACK
     
169.         {
     
170.                 FDC_IIC_Stop();         
     
171.                 return 1;                 
     
172.         }        
     
173.     FDC_IIC_Stop();         
     
174.         return 0;
     
175. }
     
176. 
     
177. u16 FDC_Read(u8 reg)
     
178. {
     
179.         u16 res;
     
180.    FDC_IIC_Start();
     
181.         FDC_IIC_Send_Byte((FDC2214_ADDR<<1)|0);//发送器件地址+写命令        
     
182.         FDC_IIC_Wait_Ack();                //等待应答
     
183.     FDC_IIC_Send_Byte(reg);        //写寄存器地址
     
184.     FDC_IIC_Wait_Ack();                //等待应答
     
185.     FDC_IIC_Start();
     
186.         FDC_IIC_Send_Byte((FDC2214_ADDR<<1)|1);//发送器件地址+读命令        
     
187.     FDC_IIC_Wait_Ack();                //等待应答
     
188.         res=FDC_IIC_Read_Byte(1)<<8;//读取数据,发送ACK
     
189.         
     
190. //        FDC_IIC_Ack();
     
191.         res|=FDC_IIC_Read_Byte(0);//读取数据,发送nACK
     
192.     FDC_IIC_Stop();                        //产生一个停止条件
     
193.         return res;               
     
194. }
     
195. 
     
196. u32 FCD2214_ReadCH(u8 index)
     
197. {
     
198.         u32 result;
     
199.         switch(index)
     
200.         {
     
201.                 case 0:
     
202.                   result = FDC_Read(DATA_CH0)&0x0FFF;
     
203.                   result = (result<<16)|(FDC_Read(DATA_LSB_CH0));
     
204.                         break;
     
205.                 case 1:
     
206.                         result = FDC_Read(DATA_CH1)&0x0FFF;
     
207.                   result = (result<<16)|(FDC_Read(DATA_LSB_CH1));
     
208.                         break;
     
209.                 case 2:
     
210.                         result = FDC_Read(DATA_CH2)&0x0FFF;
     
211.                   result = (result<<16)|(FDC_Read(DATA_LSB_CH2));
     
212.                         break;
     
213.                 case 3:
     
214.                         result = FDC_Read(DATA_CH3)&0x0FFF;
     
215.                   result = (result<<16)|(FDC_Read(DATA_LSB_CH3));
     
216.                         break;
     
217.                 default:break;
     
218.         }
     
219.         result =result&0x0FFFFFFF;
     
220.         return result;
     
221. }
     
222. 
     
223. /*FDC2214初始化函数
     
224. *返回值:0：初始化正常
     
225. *       1：不正常
     
226. */
     
227. u8 FDC2214_Init(void)
     
228. {
     
229.         u16 res,ID_FDC2214;
     
230.         FDC_GPIO_Init();
     
231.         FDC_IIC_Init();
     
232.         res=FDC_Read(MANUFACTURER_ID);//测试设备读取是否正常
     
233.         ID_FDC2214 = FDC_Read(DEVICE_ID);
     
234.         
     
235.         printf("DEVICE_ID:0X%x\r\n",ID_FDC2214);
     
236.         if(res==0x5449)
     
237.         {
     
238.                 //设置Set_FDC2214寄存器
     
239.                 Set_FDC2214(RCOUNT_CH0,0x34,0xFB);//参考计数转换间隔时间（T=(RCOUNT_CH0*16)/Frefx）
     
240.                 Set_FDC2214(RCOUNT_CH1,0x34,0xFB);
     
241.                 Set_FDC2214(RCOUNT_CH2,0x34,0xFB);
     
242.                 Set_FDC2214(RCOUNT_CH3,0x34,0xFB);
     
243.                
     
244.                 Set_FDC2214(SETTLECOUNT_CH0,0x00,0x1B);//转换之前的稳定时间（T=(SETTLECOUNT_CHx*16)/Frefx）
     
245.                 Set_FDC2214(SETTLECOUNT_CH1,0x00,0x1B);
     
246.                 Set_FDC2214(SETTLECOUNT_CH2,0x00,0x1B);
     
247.                 Set_FDC2214(SETTLECOUNT_CH3,0x00,0x1B);
     
248.                
     
249.                 Set_FDC2214(CLOCK_DIVIDERS_C_CH0,0x20,0x02);//选择在0.01MHz ~ 10MHz的传感器频率
     
250.                 Set_FDC2214(CLOCK_DIVIDERS_C_CH1,0x20,0x02);//Frefx = Fclk = 43.4MHz/2(2分频)
     
251.                 Set_FDC2214(CLOCK_DIVIDERS_C_CH2,0x20,0x02);//CHx_REF_DIVIDER=2;CHx_FIN_SEL=2
     
252.                 Set_FDC2214(CLOCK_DIVIDERS_C_CH3,0x20,0x02);//CHx_REF_DIVIDER=2;CHx_FIN_SEL=2
     
253.                
     
254.                 Set_FDC2214(DRIVE_CURRENT_CH0,0x78,0x00);//0.146ma（传感器时钟建立+转换时间的驱动电流）
     
255.                 Set_FDC2214(DRIVE_CURRENT_CH1,0x78,0x00);
     
256.                 Set_FDC2214(DRIVE_CURRENT_CH2,0x78,0x00);
     
257.                 Set_FDC2214(DRIVE_CURRENT_CH3,0x78,0x00);
     
258.                
     
259.                 Set_FDC2214(ERROR_CONFIG,0x00,0x00);//全部禁止错误汇报
     
260.                
     
261.                 Set_FDC2214(MUX_CONFIG,0xC2,0x0D);//通道0，1，2 ，3；选择10Mhz为超过振荡槽振荡频率的最低设置，多通道，四通道
     
262.                
     
263.                 Set_FDC2214(CONFIG,0x14,0x01);//激活模式，使用内部振荡器做参考频率，INTB引脚会随状态寄存器更新被置位
     
264.         }
     
265.         else return 1;
     
266.         
     
267.         return 0;
     
268. }
     
269. 
     
270. float Cap_Calculate(u8 chx)
     
271. {
     
272.         float Cap;
     
273.         Data_FDC = FCD2214_ReadCH(chx);
     
274.         Cap = 232021045.248/(Data_FDC);
     
275.         return (Cap*Cap);
     
276. }

复制代码