标题: 51单片机四轴飞控STC8A8K16S4A12-LQFP44-PPM-V10源码与说明资料下载 [打印本页]

---

作者: avicii    时间: 2018-3-26 12:24
标题: 51单片机四轴飞控STC8A8K16S4A12-LQFP44-PPM-V10源码与说明资料下载
开源了，感兴趣的朋友看一下，里面有代码和pcb都有的.

STC8A8K飞控使用说明
本飞控使用世界上速度最快的51:宏晶科技出品的STC8系列单片机STC8A8K64S4A12 LQFP44
嘴主控，单片机价在3yuan左右，更宜好用。
本飞控已严格调试通过，用户可d行参考、消化程序，不提供技术支持。
持別注意：下载时选杼内部时钟24MHZ，设罝用户EEPROM大小为2K或以上.
资源简介：
内核：
超髙速805丨内核（1T),是全球最快速的8051,比传统805丨玦丨2倍，井且价格低廉.
指令代码究全兼容传统8051的111条指令
22个中断源，4级中断优先级.
支持在线编程（丨SP).
支持在线仿真《
工作电压：2(K5.5V.内建LDO.
工作温度：WC〜85-C,
FLASH存储器：最大64K字节FLASH空间.
用户可将部分FLASH配置为EEPROM. 512字节单页療除。
SRA.X1: 128字节直接或间接访问RAM  (DATA或IDATA访问）
128 字节间接 RAM ( IDATA)
8192字节内部扩展RAM (内部XDATA)
外部可扩展64K字节RAM (外部XDATA)
时钟：内部24MI1Z高精度时钟（ISP编程可调整)，常温（25)误差±0.3%。
温度范围-20°C〜65 °C时温漂-丨.0%~-0.5%,温度范围-40°C ~85 °C时温漂-1.8%—0.8%
内部32KJIZ低速时钟（误差较大）。
外部晶振或外部时钟（4MI1Z〜33VI11Z),用户软件自由选择这3种时钟源。
中断： 22个中断源。
数字外设：5个16位定时器，4个高速串口，4路PCA模块，8路15位增强型PWM,   SPI ,   I2C。
模拟外设：16通道12位ADC, 1组比较器。
GPIO:  LQFP44 封装又 39 个io, LQFP48 有 43 个丨0, LQFP64S 有 59 个io。


飞控的电路原理图：

本飞控仅仅是姿态飞行控制，没有GPS、电子罗盘、气压高度计、超声波测距、光流传感器等等， 不能实现定点悬停，但是飞行感觉非常好，稳定，特别是暴力飞行的刺激，是很多玩家所喜欢的。用户 可以A行增加这些传感器，编写相关的程序，以获得更好的飞行性能。
本飞控通过调整PID参数可以适应从250mm轴距到750mm轴距的，都实际装机验证过，效果很 好。
本例实用F450的四轴机架，大约40元，安装简单，入门快，让玩家可以快速的装配成功，如动手 能力强可以A己买配件做机架，铝合金或碳纤维均可。我喜欢用铝合金方管，好加工，强度好，还很轻。配套使用MC6B的遥控、接收套件，左手油门（俗称“美国手”)，大约130元，是我能找到的最 便宜的遥控器了，不差钱的玩家可以使用更昂贵的遥控器套件。四轴实物照片如K阁所示。本例只说明如何使用飞控,对于四轴工作原理不做描述，要科普的用户可以A行上网搜索相关知识。
主要零件：
STC8A8K16S4A12 LQFP44 做的飞控 1 块。
MPU-6050三轴陀螺仪、三轴加速度传感器模块1块。
MC6B遥控、接收机1套。
F450玻纤四轴机架1套。
2212无刷电机4个（配香蕉插)。
20A电调4个。
9450正反桨2对（实际买多些，因为新手会有损耗)。
3S锂电池4200mAH  1块（用户可以购买多块爽飞）。
B6平衡充（带12V 5A电源）1套。
T插插头1个。
12号硅胶线红、黑色给20cm。
魔术带（捆绑电池的）1条。
3M双而胶（3*7cm,粘电调、飞控用）2片。
扎丝或扎带若千（我喜欢扎丝，因为可以方便的拧下来)。
红光、绿光LED灯条（可选）各2条。（用户可以先不装，要夜航的才装，我就喜欢夜航)。


单片机源程序如下:

1. /* 本程序经过测试完全正常, 不提供电话技术支持, 如不能理解, 请自行补充相关基础.  */
   
2. /***  特别注意: 下载时选择内部时钟24MHZ, 设置用户EEPROM大小为2K或以上.  ****/
   
3. /*********************************************
   
4.   四轴飞控-V10.C
   
5. 使用遥控接收器型号: MC6B六通道2.4G 100mW.
   
6. 
   
7. 四轴上电待机：上电后，航灯不亮，接收机LED闪烁，此时打开遥控器，将左右油门下拉到最小，接收机收到信号LED常亮，
   
8.               表示RF通讯已连接。此时蜂鸣器"哔"一声，航灯闪烁，表示待机模式。
   
9. 
   
10. 四轴启动：将遥控器左右操纵杆掰成下内八，启动四轴，四轴"哔"一声，4个螺旋桨开始低速旋转，航灯常亮。
    
11.           此后提升油门，就可以加速螺旋桨，直到起飞。
    
12. 
    
13. 四轴飞行：起飞后，可以操纵右手的俯仰、横滚操纵杆，实现前后左右或任意方向的飞行。
    
14.           左手油门杆左掰是航向逆时针转，右掰是航向顺时钟转。
    
15. 
    
16. 四轴下降停止：收油门，四轴逐渐下降到地面，然后两操纵杆掰成下外八，停止四轴，重新处于待机模式。
    
17. 
    
18. 四轴水平校准：将四轴放置于水平地面，处于待机模式，然后两操纵杆掰成上内八，四轴"哔"一声进入校准，完成后"哔哔"两声完成校准。
    
19. 
    
20. 四轴取消水平校准：将四轴放置于水平地面，处于待机模式，然后两操纵杆掰成上外八，四轴"哔"一声取消校准。取消水平校准或未进行水平校准过的四轴，起飞时即使无风也可能会有明显漂移。
    
21. 
    
22. 电池低压报警：当电池低压时，蜂鸣器"哔哔"报警，同时航灯闪烁，此时请尽快回航降落。
    
23. 
    
24. 无遥控信号异常：当四轴在空中突然收不到遥控信号时，四轴蜂鸣器发出"哔哔哔"报警，同时航灯闪烁，四轴保持水平，逐渐自动减小油门降落。
    
25. ***********************************************/
    
26. 
    
27. #define                Baudrate1                        115200UL
    
28. #define                TX1_LENGTH        128
    
29. #define                RX1_LENGTH        128
    
30. 
    
31. 
    
32. #include "config.h"
    
33. #include "STC8xxx_PWM.H"
    
34. #include "MPU6050.H"
    
35. #include "AD.H"       
    
36. #include "EEPROM.H"
    
37. #include "PCA.h"
    
38. #include <math.H>
    
39. 
    
40. sbit        P_Light  = P5^4;        //航灯
    
41. sbit        P_BUZZER = P5^5;        //蜂鸣器
    
42. 
    
43. 
    
44. int                xdata g_x=0,g_y=0,g_z=0;                                        //陀螺仪矫正参数
    
45. float        xdata a_x=0,a_y=0;                                                        //角度矫正参数
    
46. float        data  AngleX=0,AngleY=0;                                        //四元数解算出的欧拉角
    
47. float        xdata Angle_gx=0,Angle_gy=0,Angle_gz=0;                //由角速度计算的角速率(角度制)
    
48. float        xdata Angle_ax=0,Angle_ay=0,Angle_az=0;                //由加速度计算的加速度(弧度制)
    
49. float        xdata Ax=0,Ay=0,Az=0;                                                //加入遥控器控制量后的角度   
    
50. float        data PID_x=0,PID_y=0,PID_z=0;                                //PID最终输出量
    
51. int                data  speed0=0,speed1=0,speed2=0,speed3=0;        //电机速度参数
    
52. int                data  PWM0=0,PWM1=0,PWM2=0,PWM3=0;//,PWM4=0,PWM5=0;                        //加载至PWM模块的参数
    
53. 
    
54. int                int_tmp;
    
55. u8                YM=0,FRX=128,FRY=128,FRZ=128;                                //4通道遥控信号.
    
56. u8                xdata        tp[16];                //读MP6050缓冲
    
57. 
    
58. 
    
59. //****************姿态处理和PID*********************************************
    
60. 
    
61. float xdata Out_PID_X=0,Last_Angle_gx=0;                                        //外环PI输出量  上一次陀螺仪数据
    
62. float xdata ERRORX_Out=0,ERRORX_In=0;                        //外环P  外环I  外环误差积分
    
63. float xdata Out_PID_Y=0,Last_Angle_gy=0;
    
64. float xdata ERRORY_Out=0,ERRORY_In=0;            //规则1:内外环P乘积等于10.5
    
65. 
    
66. float xdata Last_Ax=0,Last_Ay=0,Last_Az=0;
    
67. 
    
68. 
    
69. /******************************************************************************/
    
70. #define        Out_XP        6.65f        //ADC0        外环P        V1 / 10
    
71. #define        Out_XI        0.0074f        //ADC4        外环I        V2 / 10000
    
72. #define        Out_XD        6.0f        //ADC5        外环D        V3 / 10
    
73. 
    
74. #define        In_XP        0.8275f        //ADC6        内环P        V4 / 100
    
75. #define        In_XI        0.0074f        //ADC4        内环I        V2 / 10000
    
76. #define        In_XD        6.0f        //ADC5        内环D        V3 / 10
    
77. 
    
78. 
    
79. #define        Out_YP        Out_XP
    
80. #define        Out_YI        Out_XI
    
81. #define        Out_YD        Out_XD
    
82. 
    
83. #define        In_YP        In_XP
    
84. #define        In_YI        In_XI
    
85. #define        In_YD        In_XD
    
86. 
    
87. 
    
88. #define        ZP        5.0f
    
89. #define        ZI        0.1f
    
90. #define        ZD        4.0f        //自旋控制的P D
    
91. float Z_integral=0;//Z轴积分
    
92. 
    
93. #define        ERR_MAX        500
    
94. //======================================================================
    
95. 
    
96. 
    
97. u8        data YM_LostCnt=0, Lost16S; //上一次RxBuf[0]数据(RxBuf[0]数据在不断变动的)   状态标识
    
98. u8        SW2_tmp;
    
99. 
    
100. 
     
101. //======================================================================
     
102. bit        B_8ms;        //8ms标志
     
103. 
     
104. bit        B_rtn_ADC0;        //请求返回信息
     
105. bit        B_BAT_LOW;        //低电压标志
     
106. u8        xdata cnt_ms;                //时间计数
     
107. 
     
108. 
     
109. u8                xdata UART1_cmd=0;        //串口命令
     
110. u8                xdata TX1_Read=0;        //发送读指针
     
111. u8                xdata TX1_Write=0;        //发送写指针
     
112. u8                xdata TX1_cnt=0;        //发送计数
     
113. u8                 xdata TX1_Buffer[TX1_LENGTH];        //发送缓冲
     
114. bit                B_TX1_Busy;                        //发送忙标志
     
115. u8                 xdata RX1_Cnt,RX1_Timer;
     
116. u8                 xdata RX1_Buffer[RX1_LENGTH];
     
117. bit         B_RX1_OK;
     
118. 
     
119. 
     
120. u8                xdata Cal_Setp=0;                        //校准步骤
     
121. u8                xdata Cal_cnt=0;                        //校准平均值计数
     
122. int                xdata x_sum,y_sum,z_sum;        //校准累加和
     
123. float        xdata float_x_sum,float_y_sum;        //校准累加和
     
124. 
     
125. u8        xdata BuzzerOnTime,BuzzerOffTime,BuzzerRepeat,BuzzerOnCnt,BuzzerOffCnt;
     
126. u8        xdata cnt_100ms;
     
127. 
     
128. 
     
129. /* =================== PPM接收相关变量 ========================== */
     
130. u16        xdata CCAP0_RiseTime;                //捕捉到的上升沿时刻
     
131. u8        xdata PPM1_Rise_TimeOut;        //高电平限时
     
132. u8        xdata PPM1_Rx_TimerOut;                //接收超时计数
     
133. u8        xdata PPM1_RxCnt;                        //接收次数计数
     
134. u16        xdata PPM1_Cap;                                //捕捉到的PPM脉冲宽度
     
135. bit        B_PPM1_OK;                                        //接收到一个PPM脉冲宽度
     
136. 
     
137. u16        xdata CCAP1_RiseTime;
     
138. u8        xdata PPM2_Rise_TimeOut;        //高电平限时
     
139. u8        xdata PPM2_Rx_TimerOut;
     
140. u8        xdata PPM2_RxCnt;
     
141. u16        xdata PPM2_Cap;
     
142. bit        B_PPM2_OK;
     
143. 
     
144. u16        xdata CCAP2_RiseTime;
     
145. u8        xdata PPM3_Rise_TimeOut;        //高电平限时
     
146. u8        xdata PPM3_Rx_TimerOut;
     
147. u8        xdata PPM3_RxCnt;
     
148. u16        xdata PPM3_Cap;
     
149. bit        B_PPM3_OK;
     
150. 
     
151. u16        xdata CCAP3_RiseTime;
     
152. u8        xdata PPM4_Rise_TimeOut;        //高电平限时
     
153. u8        xdata PPM4_Rx_TimerOut;
     
154. u8        xdata PPM4_RxCnt;
     
155. u16        xdata PPM4_Cap;
     
156. bit        B_PPM4_OK;
     
157. 
     
158. u16        xdata CCAP_FallTime;
     
159. 
     
160. u8        PPM1,PPM2,PPM3,PPM4;
     
161. bit        B_Start;
     
162. u8        cnt_start;
     
163. 
     
164. /* ============================================= */
     
165. 
     
166. 
     
167. void        UART1_config(void);
     
168. void         PrintString1(u8 *puts);        //发送一个字符串
     
169. void        TX1_write2buff(u8 dat);        //写入发送缓冲，指针+1
     
170. void        TX1_int_value(int i);
     
171. void        delay_ms(u8 ms);
     
172. void        Return_Message(void);
     
173. u16         MODBUS_CRC16(u8 *p,u8 n);        //input:        *p--->First Data Address,n----->Data Number,        return:        CRC16
     
174. void        PCA_config(void);
     
175. void         Timer0_Config(void);
     
176. void         Timer1_Config(void);
     
177. void        return_TTMx(u8 id,PPMx);
     
178. void         Timer0_Config(void);
     
179. u16         MODBUS_CRC16(u8 *p,u8 n);        //input:        *p--->First Data Address,n----->Data Number,        return:        CRC16
     
180. 
     
181. extern xdata u16        adc0;
     
182. extern xdata int        Battery;
     
183. 
     
184. 
     
185. //*********************************************************************
     
186. //****************角度计算*********************************************
     
187. //*********************************************************************
     
188. #define        pi                3.14159265f                           
     
189. #define        Kp                0.8f                        
     
190. #define        Ki                0.001f                        
     
191. #define        halfT        0.004f           
     
192. 
     
193. float idata q0=1,q1=0,q2=0,q3=0;   
     
194. float idata exInt=0,eyInt=0,ezInt=0;  
     
195. 
     
196. 
     
197. void IMUupdate(float gx, float gy, float gz, float ax, float ay, float az)
     
198. {
     
199.         float data norm;
     
200.         float idata vx, vy, vz;
     
201.         float idata ex, ey, ez;
     
202. 
     
203.         norm = sqrt(ax*ax + ay*ay + az*az);        //把加速度计的三维向量转成单维向量   
     
204.         ax = ax / norm;
     
205.         ay = ay / norm;
     
206.         az = az / norm;
     
207. 
     
208.                 //        下面是把四元数换算成《方向余弦矩阵》中的第三列的三个元素。
     
209.                 //        根据余弦矩阵和欧拉角的定义，地理坐标系的重力向量，转到机体坐标系，正好是这三个元素
     
210.                 //        所以这里的vx vy vz，其实就是当前的欧拉角（即四元数）的机体坐标参照系上，换算出来的
     
211.                 //        重力单位向量。
     
212.         vx = 2*(q1*q3 - q0*q2);
     
213.         vy = 2*(q0*q1 + q2*q3);
     
214.         vz = q0*q0 - q1*q1 - q2*q2 + q3*q3 ;
     
215. 
     
216.         ex = (ay*vz - az*vy) ;
     
217.         ey = (az*vx - ax*vz) ;
     
218.         ez = (ax*vy - ay*vx) ;
     
219. 
     
220.         exInt = exInt + ex * Ki;
     
221.         eyInt = eyInt + ey * Ki;
     
222.         ezInt = ezInt + ez * Ki;
     
223. 
     
224.         gx = gx + Kp*ex + exInt;
     
225.         gy = gy + Kp*ey + eyInt;
     
226.         gz = gz + Kp*ez + ezInt;
     
227. 
     
228.         q0 = q0 + (-q1*gx - q2*gy - q3*gz) * halfT;
     
229.         q1 = q1 + ( q0*gx + q2*gz - q3*gy) * halfT;
     
230.         q2 = q2 + ( q0*gy - q1*gz + q3*gx) * halfT;
     
231.         q3 = q3 + ( q0*gz + q1*gy - q2*gx) * halfT;
     
232. 
     
233.         norm = sqrt(q0*q0 + q1*q1 + q2*q2 + q3*q3);
     
234.         q0 = q0 / norm;
     
235.         q1 = q1 / norm;
     
236.         q2 = q2 / norm;
     
237.         q3 = q3 / norm;
     
238. 
     
239.         AngleX = asin(2*(q0*q2 - q1*q3 )) * 57.2957795f; // 俯仰   换算成度
     
240.         AngleY = asin(2*(q0*q1 + q2*q3 )) * 57.2957795f; // 横滚
     
241. }
     
242. 
     
243. 
     
244. 
     
245. //****************姿态计算*********************************************
     
246. void PWM_int (void) interrupt         22        //PWM中断函数
     
247. {
     
248.         PWMCFG = 0;        //CBIF;        //清除中断标志
     
249. 
     
250.         B_8ms = 1;
     
251. 
     
252. //======================== 超时溢出处理 ==============================================
     
253.         PPM1_Rise_TimeOut++;        //高电平限时
     
254.         PPM2_Rise_TimeOut++;        //高电平限时
     
255.         PPM3_Rise_TimeOut++;        //高电平限时
     
256.         PPM4_Rise_TimeOut++;        //高电平限时
     
257. 
     
258.         if(--PPM1_Rx_TimerOut == 0)                //超过100ms收不到信号
     
259.         {
     
260.                 PPM1_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
     
261.                 PPM1 = 128;;                        //默认中点
     
262.         }
     
263.         if(--PPM2_Rx_TimerOut == 0)                //超过100ms收不到信号
     
264.         {
     
265.                 PPM2_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
     
266.                 PPM2 = 128;;                        //默认中点
     
267.         }
     
268.         if(--PPM3_Rx_TimerOut == 0)                //超过200ms收不到信号
     
269.         {
     
270.                 PPM3_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
     
271.         }
     
272.         if(--PPM4_Rx_TimerOut == 0)                //超过100ms收不到信号
     
273.         {
     
274.                 PPM4_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
     
275.                 PPM4 = 128;                                //默认中点
     
276.         }
     
277. //======================================================================
     
278. 
     
279.         if(++YM_LostCnt >= 250)                //失联2秒后
     
280.         {
     
281.                 YM_LostCnt = 200;                //重复0.4秒，失控保护
     
282.                 if(PPM3 > 80)        PPM3--;
     
283.                 else if(++Lost16S >= 40)
     
284.                 {
     
285.                         Lost16S = 250;
     
286.                         PPM3 = 0;
     
287.                         B_Start = 0;
     
288.                 }
     
289.         }
     
290.         if(YM_LostCnt  >= 25)        //失联200ms
     
291.         {
     
292.                 PPM1 = 128;
     
293.                 PPM2 = 128;                //俯仰 横滚 航向均归0
     
294.                 PPM4 = 128;
     
295.         }
     
296. 
     
297.         FRX = PPM1;
     
298.         FRY = PPM2;
     
299.         YM  = PPM3;        //油门
     
300.         FRZ = PPM4;
     
301.        
     
302. 
     
303. //********************************************************************************************
     
304.         Read_MPU6050(tp);        //680us
     
305. 
     
306.         Angle_ax = ((float)(((int *)&tp)[0])) / 8192.0;        //加速度处理        结果单位是 +- g
     
307.         Angle_ay = ((float)(((int *)&tp)[1])) / 8192.0;        //转换关系        8192 LSB/g, 1g对应读数8192
     
308.         Angle_az = ((float)(((int *)&tp)[2])) / 8192.0;        //加速度量程 +-4g/S
     
309.         Last_Angle_gx = Angle_gx;                //储存上一次角速度数据
     
310.         Last_Angle_gy = Angle_gy;
     
311.         Angle_gx = ((float)(((int *)&tp)[4] - g_x)) / 65.5;        //陀螺仪处理        结果单位是 +-度
     
312.         Angle_gy = ((float)(((int *)&tp)[5] - g_y)) / 65.5;        //陀螺仪量程 +-500度/S, 1度/秒 对应读数 65.536
     
313.         Angle_gz = ((float)(((int *)&tp)[6] - g_z)) / 65.5;        //转换关系65.5 LSB/度
     
314. 
     
315.         IMUupdate(Angle_gx*0.0174533f, Angle_gy*0.0174533f, Angle_gz*0.0174533f, Angle_ax,Angle_ay,Angle_az);
     
316. 
     
317. //**********************************X轴指向************************************************
     
318.         Ax  = AngleX - a_x - ((float)FRX - 128) / 4.0;                //角度控制量加载至角度
     
319. 
     
320.         if(YM > 35)        ERRORX_Out += Ax,        ERRORX_Out += Ax,        ERRORX_Out += Ax;        //外环积分(油门小于某个值时不积分)
     
321.         else                ERRORX_Out = 0; //油门小于定值时清除积分值
     
322.                  if(ERRORX_Out >  1500)        ERRORX_Out =  1500;
     
323.         else if(ERRORX_Out < -1500)        ERRORX_Out = -1500;        //积分限幅
     
324. 
     
325.         Out_PID_X = Ax*Out_XP + ERRORX_Out*Out_XI + (Ax-Last_Ax)*Out_XD;        //外环PI
     
326.         Last_Ax = Ax;
     
327.        
     
328.         if(YM > 35)        ERRORX_In += (Angle_gy - Out_PID_X);        //内环积分(油门小于某个值时不积分)
     
329.         else                ERRORX_In = 0;        //油门小于定值时清除积分值
     
330.                  if(ERRORX_In >  500)        ERRORX_In =  500;
     
331.         else if(ERRORX_In < -500)        ERRORX_In = -500;        //积分限幅
     
332. 
     
333.         PID_x = (Angle_gy + Out_PID_X) * In_XP + ERRORX_In * In_XI + (Angle_gy - Last_Angle_gy) * In_XD;        //内环PID
     
334.         if(PID_x >  500)        PID_x =  500;        //输出量限幅
     
335.         if(PID_x < -500)        PID_x = -500;
     
336. 
     
337. //**************Y轴指向**************************************************
     
338.         Ay  = AngleY - a_y + ((float)FRY - 128) / 4.0;                //角度控制量加载至角度
     
339.        
     
340.         if(YM > 35)        ERRORY_Out += Ay,        ERRORY_Out += Ay,        ERRORY_Out += Ay;        //外环积分(油门小于某个值时不积分)
     
341.         else                ERRORY_Out = 0; //油门小于定值时清除积分值
     
342.                  if(ERRORY_Out >  1500)        ERRORY_Out =  1500;
     
343.         else if(ERRORY_Out < -1500)        ERRORY_Out = -1500;        //积分限幅
     
344.        
     
345.         Out_PID_Y = Ay * Out_YP + ERRORY_Out * Out_YI + (Ay-Last_Ay)*Out_YD;        //外环PID
     
346.         Last_Ay = Ay;
     
347. 
     
348.         if(YM > 35)        ERRORY_In += (Angle_gx - Out_PID_Y);  //内环积分(油门小于某个值时不积分)
     
349.         else                ERRORY_In = 0; //油门小于定值时清除积分值
     
350.                  if(ERRORY_In >  500)        ERRORY_In =  500;
     
351.         else if(ERRORY_In < -500)        ERRORY_In = -500;        //积分限幅
     
352.        
     
353.         PID_y = (Angle_gx + Out_PID_Y) * In_YP + ERRORY_In * In_YI + (Angle_gx - Last_Angle_gx) * In_YD;        //内环PID
     
354.        
     
355.         if(PID_y > 500)        PID_y =  500;        //输出量限幅
     
356.         if(PID_y <-500)        PID_y = -500;
     
357. 
     
358. //**************Z轴指向(Z轴随便啦，自旋控制没必要上串级PID)*****************************       
     
359.         Az = Angle_gz - ((float)FRZ - 128);
     
360.        
     
361.         if(YM > 35)        Z_integral += Az;        //Z轴积分
     
362.         else                Z_integral = 0;                //油门小于40积分清零
     
363.                  if(Z_integral >  500.0f)        Z_integral =  500.0f;        //积分限幅
     
364.         else if(Z_integral < -500.0f)        Z_integral = -500.0f;        //积分限幅
     
365. 
     
366.         PID_z = Az * ZP + Z_integral * ZI + (Az - Last_Az) * ZD;
     
367.         Last_Az = Az;
     
368.         if(PID_z >  200)        PID_z =  200;        //输出量限幅
     
369.         if(PID_z < -200)        PID_z = -200;
     
370. 
     
371.         speed0 = (int)(  PID_x + PID_y + PID_z);        //M1改为逆时针
     
372.         speed1 = (int)(  PID_x - PID_y - PID_z);
     
373.         speed2 = (int)( -PID_x - PID_y + PID_z);
     
374.         speed3 = (int)( -PID_x + PID_y - PID_z);
     
375. 
     
376. //**************将速度参数加载至PWM模块*************************************************       
     
377.        
     
378.         if(YM < 10)        PWM0 = 1000, PWM1 = 1000, PWM2 = 1000, PWM3 = 1000;
     
379.         else if(YM < 35)        PWM0 = 860, PWM1 = 860, PWM2 = 860, PWM3 = 860;
     
380.         else
     
381.         {
     
382.                 int_tmp = 1000 - (int)YM * 4;
     
383. 
     
384.                 PWM0 = int_tmp - speed0;
     
385. 
     
386.                          if(PWM0 > 1000)        PWM0 = 1000;    //速度参数控制，防止超过PWM参数范围0-1000
     
387.                 else if(PWM0 < 10)                PWM0 = 10;
     
388. 
     
389.                 PWM1 = int_tmp - speed1;
     
390. 
     
391.                          if(PWM1 > 1000)        PWM1 = 1000;
     
392.                 else if(PWM1 < 10)                PWM1 = 10;
     
393. 
     
394.                 PWM2 = int_tmp - speed2;
     
395. 
     
396.                          if(PWM2 > 1000)        PWM2 = 1000;
     
397.                 else if(PWM2 < 10)                PWM2 = 10;
     
398. 
     
399.                 PWM3 = int_tmp - speed3;
     
400. 
     
401.                          if(PWM3 > 1000)        PWM3 = 1000;
     
402.                 else if(PWM3 < 10)                PWM3 = 10;
     
403.         }
     
404. 
     
405.         SW2_tmp = P_SW2;        //保存SW2设置
     
406.         EAXSFR();        //访问XFR
     
407.         PWM0T2 = (u16)(PWM0 * 2);
     
408.         PWM1T2 = (u16)(PWM1 * 2);
     
409.         PWM2T2 = (u16)(PWM2 * 2);
     
410.         PWM3T2 = (u16)(PWM3 * 2);       
     
411.         P_SW2  = SW2_tmp;        //恢复SW2设置
     
412. 
     
413. }
     
414. 
     
415. 
     
416. /********************** 蜂鸣函数 ************************/
     
417. void        beep(void)        //100ms调用
     
418. {
     
419.         if(BuzzerRepeat > 0)        //蜂鸣器处理, 重复次数不为0，则蜂鸣器要发声
     
420.         {
     
421.                 if((BuzzerOnCnt == 0) && (BuzzerOffCnt == 0))        //On和OFF都为0，则开始装载On和Off的时间
     
422.                 {
     
423.                         P_BUZZER = 1;                        //允许蜂鸣
     
424.                         BuzzerOnCnt  = BuzzerOnTime;        //装载on计数
     
425.                         BuzzerOffCnt = BuzzerOffTime;        //装载off计数
     
426.                 }
     
427.                 else if(BuzzerOnCnt  > 0)        {if(--BuzzerOnCnt == 0)        P_BUZZER = 0;}        //On的时间
     
428.                 else if(BuzzerOffCnt > 0)        //Off的时间
     
429.                 {
     
430.                         if(--BuzzerOffCnt == 0)        BuzzerRepeat--;
     
431.                 }
     
432.         }
     
433.         else        P_BUZZER = 0;
     
434. }
     
435. 
     
436. void        SetBuzzer(u8 on,u8 off,u8 rep)        // rep: 重复次数, on: on的时间, off: off的时间
     
437. {
     
438.         BuzzerRepeat = rep;
     
439.         BuzzerOnTime  = on;
     
440.         BuzzerOffTime = off;
     
441.         if(BuzzerOnTime  == 0)        BuzzerOnTime  = 1;
     
442.         if(BuzzerOffTime == 0)        BuzzerOffTime = 1;
     
443.         if(BuzzerRepeat == 1)        BuzzerOffTime = 1;
     
444.         BuzzerOnCnt = 0,        BuzzerOffCnt = 0;
     
445. }
     
446. 
     
447. // ===================== 自动校准序列 =====================
     
448. void        AutoCal(void)
     
449. {
     
450.         if(PPM3 < 40)        //停止时才允许校准
     
451.         {
     
452.                 if(Cal_Setp == 1)        //进入校准序列
     
453.                 {
     
454.                         x_sum = 0;        y_sum = 0;        z_sum = 0;
     
455.                         Cal_cnt  = 0;
     
456.                         Cal_Setp = 2;
     
457.                 }
     
458.                 else if(Cal_Setp == 2)        //对陀螺仪累加
     
459.                 {
     
460.                         x_sum += ((int *)&tp)[4];  //读取陀螺仪数据
     
461.                         y_sum += ((int *)&tp)[5];
     
462.                         z_sum += ((int *)&tp)[6];
     
463.                         if(++Cal_cnt >= 64)
     
464.                         {
     
465.                                 g_x = x_sum / 64;
     
466.                                 g_y = y_sum / 64;
     
467.                                 g_z = z_sum / 64;
     
468.                                 float_x_sum = 0;        float_y_sum = 0;
     
469.                                 Cal_cnt  = 0;
     
470.                                 Cal_Setp = 3;
     
471.                         }
     
472.                 }
     
473.                 else if(Cal_Setp == 3)        //对X Y角度累加
     
474.                 {
     
475.                         float_x_sum += AngleX;
     
476.                         float_y_sum += AngleY;
     
477.                         if(++Cal_cnt >= 64)
     
478.                         {
     
479.                                 Cal_cnt  = 0;
     
480.                                 Cal_Setp = 0;
     
481.                                 a_x = float_x_sum / 64.0;
     
482.                                 a_y = float_y_sum / 64.0;
     
483.                                 IAP_Gyro();
     
484.                                 SetBuzzer(5,1,1);
     
485.                         }
     
486.                 }
     
487.         }
     
488.         else
     
489.         {
     
490.                 Cal_Setp = 0;
     
491.                 Cal_cnt  = 0;
     
492.         }
     
493. }
     
494. 
     
495. // ===================== 主函数 =====================
     
496. void main(void)
     
497. {
     
498. 
     
499.         //所有I/O口全设为准双向，弱上拉模式
     
500.         P0M0=0x00;        P0M1=0x00;
     
501.         P1M0=0x00;        P1M1=0x00;
     
502.         P2M0=0x00;        P2M1=0x00;
     
503.         P3M0=0x00;        P3M1=0x00;
     
504.         P4M0=0x00;        P4M1=0x00;
     
505.         P5M0=0x00;        P5M1=0x00;
     
506.         P6M0=0x00;        P6M1=0x00;
     
507.         P7M0=0x00;        P7M1=0x00;
     
508. 
     
509.         PPM1 = 128;
     
510.         PPM2 = 128;
     
511.         PPM3 = 0;
     
512.         PPM4 = 128;
     
513. 
     
514.         PWMGO();
     
515. 
     
516.         P_Light  = 0;
     
517.         P_BUZZER = 0;
     
518.         P5n_push_pull(0x30);
     
519. 
     
520.         adc_init();    //启动A/D
     
521.        
     
522.         PCA_config();
     
523. 
     
524.         delay_ms(100);
     
525.         IAPRead();                //读取陀螺仪静差
     
526.         InitMPU6050();        //初始化MPU-6050
     
527.         delay_ms(100);
     
528. 
     
529.         PWMCR =  0xc0;//ECBI;        //允许PWM计数器归零中断
     
530.         EA = 1;        //允许总中断
     
531.        
     
532.         cnt_start = 0;
     
533.         while(cnt_start < 25)        //等待油门最小        20ms * 25 = 500ms
     
534.         {
     
535.                 if(B_PPM3_OK)        //油门
     
536.                 {
     
537.                         B_PPM3_OK = 0;
     
538.                         if(PPM3_Cap <= 1200)        cnt_start++;
     
539.                 }
     
540.                 delay_ms(1);
     
541.         }
     
542.         P_Light  = 0;
     
543.        
     
544.         cnt_start = 0;
     
545. 
     
546.         SetBuzzer(5,1,1);
     
547.        
     
548. 
     
549. //==============================================
     
550.         UART1_config();        // 选择波特率, 2: 使用Timer2做波特率, 其它值: 使用Timer1做波特率.
     
551.         PrintString1("STC15W4K系列大四轴飞控程序!\r\n");        //SUART1发送一个字符串
     
552. //==============================================
     
553. 
     
554.         B_Start = 0;        //上电禁止运行
     
555. 
     
556.         while(1)
     
557.         {
     
558.                 if(B_PPM1_OK)        //左右(横滚)
     
559.                 {
     
560.                         B_PPM1_OK = 0;
     
561.                                  if(PPM1_Cap < 1120)        PPM1_Cap = 1120;
     
562.                         else if(PPM1_Cap > 1880)        PPM1_Cap = 1880;
     
563.                         PPM2 = (u8)((PPM1_Cap-1116)/3);        //转为0~255, 中间值为128
     
564.                 }
     
565.                
     
566.                 if(B_PPM2_OK)        //前后(俯仰)
     
567.                 {
     
568.                         B_PPM2_OK = 0;
     
569.                                  if(PPM2_Cap < 1120)        PPM2_Cap = 1120;
     
570.                         else if(PPM2_Cap > 1880)        PPM2_Cap = 1880;
     
571.                         PPM1 = (u8)((PPM2_Cap-1116)/3);        //转为0~255, 中间值为128
     
572.                 }
     
573.                
     
574.                 if(B_PPM4_OK)        //航向
     
575.                 {
     
576.                         B_PPM4_OK = 0;
     
577.                                  if(PPM4_Cap < 1056)        PPM4_Cap = 1056;
     
578.                                  if(PPM4_Cap > 1940)        PPM4_Cap = 1940;
     
579.                                  if(PPM4_Cap < 1440)        PPM4_Cap = PPM4_Cap + 60;
     
580.                         else if(PPM4_Cap > 1560)        PPM4_Cap = PPM4_Cap - 60;
     
581.                         else        PPM4_Cap = 1500;
     
582.                         PPM4 = (u8)((PPM4_Cap-1116)/3);        //转为0~255, 中间值为128
     
583.                 }
     
584.                
     
585.                 if(B_PPM3_OK)        //油门
     
586.                 {
     
587.                         B_PPM3_OK = 0;
     
588.                         if(PPM3_Cap < 1000)        PPM3_Cap = 1000;
     
589.                         if(PPM3_Cap > 1900)        PPM3_Cap = 1900;
     
590. 
     
591.                         if(B_Start)                //正在运行时,
     
592.                         {
     
593.                                 PPM3 = (u8)((PPM3_Cap-1000)/4);        //转为0~255,        实际8~225
     
594.                                 if(PPM3 < 32)        PPM3 = 32;
     
595.                                
     
596.                                 if((PPM1 < 50) && (PPM2 < 50) && (PPM3_Cap < 1120) && (PPM4 > 200))        //下外八, 禁止
     
597.                                 {
     
598.                                         if(++cnt_start >= 50)        //1秒
     
599.                                         {
     
600.                                                 cnt_start = 0;
     
601.                                                 B_Start = 0;
     
602.                                                 SetBuzzer(1,1,2);
     
603.                                         }
     
604.                                 }
     
605.                                 else        cnt_start = 0;
     
606.                         }
     
607.                         else        //禁止运行时, 等待内八开启
     
608.                         {
     
609.                                 PPM3 = 0;
     
610.                                 if((PPM1 < 50) && (PPM2 > 200) && (PPM3_Cap < 1120) && (PPM4 < 50))        //下内八, 启动
     
611.                                 {
     
612.                                         if(++cnt_start >= 50)        //1秒
     
613.                                         {
     
614.                                                 cnt_start = 0;
     
615.                                                 B_Start = 1;
     
616.                                                 SetBuzzer(5,1,1);
     
617.                                         }
     
618.                                 }
     
619.                                 else if((PPM1 > 200) && (PPM2 > 200) && (PPM3_Cap > 1850) && (PPM4 < 50))        //上内八, 水平校准
     
620.                                 {
     
621.                                         if(++cnt_start >= 50)        //1秒
     
622.                                         {
     
623.                                                 cnt_start = 0;
     
624.                                                 SetBuzzer(2,1,1);
     
625.                                                 Cal_Setp = 1;
     
626.                                         }
     
627.                                 }
     
628.                                 else if((PPM1 > 200) && (PPM2 < 50) && (PPM3_Cap > 1850) && (PPM4 > 200))        //上外八, 取消水平校准
     
629.                                 {
     
630.                                         if(++cnt_start >= 50)        //1秒
     
631.                                         {
     
632.                                                 cnt_start = 0;
     
633.                                                 g_x = 0;
     
634.                                                 g_y = 0;
     
635.                                                 g_z = 0;
     
636.                                                 a_x = 0;
     
637.                                                 a_y = 0;
     
638.                                                 IAP_Gyro();
     
639.                                                 SetBuzzer(1,1,2);
     
640.                                         }
     
641.                                 }
     
642.                                 else        cnt_start = 0;
     
643.                         }
     
644.                 }
     
645. 
     
646. 
     
647.                 if(B_8ms)                //8ms到
     
648.                 {
     
649.                         B_8ms = 0;
     
650.                        
     
651.                         if(Cal_Setp != 0)        AutoCal();        //是否执行自动校准序列
     
652.                         AD();                // 读ADC计算电压
     
653. 
     
654.                         if(++cnt_100ms >= 12)        cnt_100ms = 0,        beep();        //100ms处理一次蜂鸣器
     
655. 
     
656.                         B = cnt_ms;
     
657.                         ++cnt_ms;
     
658.                         B = (B ^ cnt_ms) & cnt_ms;
     
659. 
     
660.                         if(B2)                //64ms
     
661.                         {
     
662.                                 if(!B_BAT_LOW && (YM_LostCnt < 120))        //电压足, 信号正常
     
663.                                 {
     
664.                                         if(!B_Start)        P_Light = 0;        // 空闲时, 则慢闪(每2048ms亮64ms)
     
665.                                         else                         P_Light = 1;        // 启动后, 灯常亮
     
666.                                 }
     
667.                         }
     
668.                         else if(B4)                //256ms
     
669.                         {
     
670.                                 if(B_BAT_LOW || (YM_LostCnt >= 120))        P_Light = ~P_Light;                //电压低, 或无信号, 航灯闪烁 2HZ
     
671.                         }
     
672.                         else if(B6)                //1024ms
     
673.                         {
     
674.                                 if(Battery < 1090)        B_BAT_LOW = 1;        else if(Battery > 1110)        B_BAT_LOW = 0;        //<10.90V电压低, >11.10V电压够
     
675.                                
     
676.                                 if(B_BAT_LOW)        SetBuzzer(1,1,2);        //电压低
     
677.                                
     
678.                                 if(B_rtn_ADC0)        Return_Message();        //请求返回ADC0数据
     
679. 
     
680.                                 if(!B_BAT_LOW && (YM_LostCnt < 120))        P_Light = 1;        //遥控信号正常,        电压正常时
     
681.                         }
     
682.                         else if(B7)                //2048ms
     
683.                         {
     
684.                                 if(!B_BAT_LOW && (YM_LostCnt >= 120))        SetBuzzer(1,1,3);        //电压正常时 遥控信号丢失, 每两秒短鸣3次,
     
685.                         }
     
686.                 }
     
687. 
     
688. 
     
689.                 if(UART1_cmd != 0)
     
690.                 {
     
691.                         if(UART1_cmd == 'a')                //PC发送a，飞控返回一些参数
     
692.                         {
     
693.                                 B_rtn_ADC0 = ~B_rtn_ADC0;
     
694.                         }
     
695.                         UART1_cmd = 0;
     
696.                 }
     
697.                
     
698.                
     
699.                 if((TX1_Read != TX1_Write) && (!B_TX1_Busy))        //有数据要发送, 并且发送空闲
     
700.                 {
     
701.                         SBUF = TX1_Buffer[TX1_Read];
     
702.                         B_TX1_Busy = 1;
     
703.                         if(++TX1_Read >= TX1_LENGTH)        TX1_Read = 0;
     
704.                 }
     
705. 
     
706.         }
     
707. }
     
708. 
     
709. //=========================================================
     
710. 
     
711. void        Return_Message(void)
     
712. {
     
713.         TX1_write2buff('V');
     
714.         TX1_write2buff('=');
     
715.         TX1_write2buff(Battery/1000 + '0');
     
716.         TX1_write2buff((Battery%1000)/100 + '0');
     
717.         TX1_write2buff('.');
     
718.         TX1_write2buff((Battery%100)/10 + '0');
     
719.         TX1_write2buff(Battery%10 + '0');
     
720.         TX1_write2buff(' ');
     
721.         TX1_write2buff(' ');
     
722. 
     
723.         PrintString1("AngleX=");
     
724.         TX1_int_value((int)(AngleX * 10));
     
725. 
     
726.         PrintString1("AngleY=");
     
727.         TX1_int_value((int)(AngleY * 10));
     
728. 
     
729.         PrintString1("AngleZ=");
     
730.         TX1_int_value((int)(Angle_gz * 10));
     
731. 
     
732.         PrintString1("a_x=");
     
733.         TX1_int_value(a_x * 10);
     
734.         PrintString1("a_y=");
     
735.         TX1_int_value(a_y * 10);
     
736.         PrintString1("g_z=");
     
737.         TX1_int_value(g_z * 10);
     
738. 
     
739.         TX1_cnt = 0;
     
740.         TX1_write2buff(0x0d);
     
741.         TX1_write2buff(0x0a);
     
742. }
     
743. 
     
744. 
     
745. void  delay_ms(u8 ms)
     
746. {
     
747.      u16 i;
     
748.          do
     
749.          {
     
750.                  i = MAIN_Fosc / 13000;
     
751.                 while(--i)        ;   //13T per loop
     
752.      }while(--ms);
     
753. }
     
754. 
     
755. 
     
756. void        TX1_int_value(int i)
     
757. {
     
758.         if(i < 0)        TX1_write2buff('-'),        i = 0 - i;
     
759.         else                TX1_write2buff(' ');
     
760.         TX1_write2buff(i / 1000 + '0');
     
761.         TX1_write2buff((i % 1000) / 100 + '0');
     
762.         TX1_write2buff((i % 100) / 10 + '0');
     
763.         TX1_write2buff('.');
     
764.         TX1_write2buff(i % 10 + '0');
     
765.         TX1_write2buff(' ');
     
766.         TX1_write2buff(' ');
     
767. }
     
768. 
     
769. /*************** 装载串口1发送缓冲 *******************************/
     
770. void TX1_write2buff(u8 dat)        //写入发送缓冲，指针+1
     
771. {
     
772.         TX1_Buffer[TX1_Write] = dat;
     
773.         if(++TX1_Write >= TX1_LENGTH)        TX1_Write = 0;
     
774. }
     
775. 
     
776. 
     
777. //========================================================================
     
778. // 函数: void PrintString1(u8 *puts)
     
779. // 描述: 串口1发送字符串函数。
     
780. // 参数: puts:  字符串指针.
     
781. // 返回: none.
     
782. // 版本: VER1.0
     
783. // 日期: 2014-11-28
     
784. // 备注:
     
785. //========================================================================
     
786. void PrintString1(u8 *puts)        //发送一个字符串
     
787. {
     
788.         for (; *puts != 0;        puts++)   TX1_write2buff(*puts);        //遇到停止符0结束
     
789. }
     
790. 
     
791. //========================================================================
     
792. // 函数: SetTimer2Baudrate(u16 dat)
     
793. // 描述: 设置Timer2做波特率发生器。
     
794. // 参数: dat: Timer2的重装值.
     
795. // 返回: none.
     
796. // 版本: VER1.0
     
797. // 日期: 2014-11-28
     
798. // 备注:
     
799. //========================================================================
     
800. 
     
801. void        SetTimer2Baudrate(u16 dat)        // 选择波特率, 2: 使用Timer2做波特率, 其它值: 使用Timer1做波特率.
     
802. {
     
803.         AUXR &= ~(1<<4);        //Timer stop
     
804.         AUXR &= ~(1<<3);        //Timer2 set As Timer
     
805.         AUXR |=  (1<<2);        //Timer2 set as 1T mode
     
806.         TH2 = dat / 256;
     
807.         TL2 = dat % 256;
     
808.         IE2  &= ~(1<<2);        //禁止中断
     
809.         AUXR |=  (1<<4);        //Timer run enable
     
810. }
     
811. 
     
812. 
     
813. //========================================================================
     
814. // 函数: void        UART1_config(u8 brt)
     
815. // 描述: UART1初始化函数。
     
816. // 参数: brt: 选择波特率, 2: 使用Timer2做波特率, 其它值: 使用Timer1做波特率.
     
817. // 返回: none.
     
818. // 版本: VER1.0
     
819. // 日期: 2014-11-28
     
820. // 备注:
     
821. //========================================================================
     
822. void        UART1_config(void)
     
823. {
     
824.         /*********** 波特率使用定时器2 *****************/
     
825.         AUXR |= 0x01;                //S1 BRT Use Timer2;
     
826.         SetTimer2Baudrate(65536UL - (MAIN_Fosc / 4) / Baudrate1);
     
827. 
     
828.         /*********** 波特率使用定时器1 *****************/
     
829. /*        TR1 = 0;
     
830.         AUXR &= ~0x01;                //S1 BRT Use Timer1;
     
831.         AUXR |=  (1<<6);        //Timer1 set as 1T mode
     
832.         TMOD &= ~(1<<6);        //Timer1 set As Timer
     
833.         TMOD &= ~0x30;                //Timer1_16bitAutoReload;
     
834.         TH1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) / 256);
     
835.         TL1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) % 256);
     
836.         ET1 = 0;        //禁止中断
     
837.         INT_CLKO &= ~0x02;        //不输出时钟
     
838.         TR1  = 1;
     
839. */        //========================================================================
     
840. 
     
841.         SCON = (SCON & 0x3f) | 0x40;        //UART1模式, 0x00: 同步移位输出, 0x40: 8位数据,可变波特率, 0x80: 9位数据,固定波特率, 0xc0: 9位数据,可变波特率
     
842.         PS  = 1;        //高优先级中断
     
843.         ES  = 1;        //允许中断
     
844.         REN = 1;        //允许接收
     
845.         P_SW1 &= 0x3f;
     
846.         P_SW1 |= 0x00;                //UART1 switch to, 0x00: P3.0 P3.1, 0x40: P3.6 P3.7, 0x80: P1.6 P1.7 (必须使用内部时钟)
     
847. //        PCON2 |=  (1<<4);        //内部短路RXD与TXD, 做中继, ENABLE,DISABLE
     
848. 
     
849.         B_TX1_Busy = 0;
     
850.         TX1_Read   = 0;
     
851.         TX1_Write  = 0;
     
852.         UART1_cmd  = 0;
     
853.         TX1_cnt    = 0;
     
854. }
     
855. 
     
856. 
     
857. //========================================================================
     
858. // 函数: void UART1_int (void) interrupt UART1_VECTOR
     
859. // 描述: UART1中断函数。
     
860. // 参数: nine.
     
861. // 返回: none.
     
862. // 版本: VER1.0
     
863. // 日期: 2014-11-28
     
864. // 备注:
     
865. //========================================================================
     
866. void UART1_int (void) interrupt 4
     
867. {
     
868.         if(RI)
     
869.         {
     
870.                 RI = 0;
     
871.                 UART1_cmd = SBUF;
     
872.         }
     
873. 
     
874.         if(TI)
     
875.         {
     
876.                 TI = 0;
     
877.                 B_TX1_Busy = 0;
     
878.         }
     
879. }
     
880. 
     
881. 
     
882. 
     
883. void        PCA_config(void)
     
884. {
     
885.         PPM1_Rise_TimeOut = 0;
     
886.         PPM2_Rise_TimeOut = 0;
     
887.         PPM3_Rise_TimeOut = 0;
     
888.         PPM4_Rise_TimeOut = 0;
     
889. 
     
890.         CR = 0;
     
891.         CH = 0;
     
892.         CL = 0;
     
893.         AUXR1 = (AUXR1 & ~(3<<4)) | PCA_P12_P17_P16_P15_P14;        //切换IO口
     
894.         CMOD  = (CMOD  & ~(7<<1)) | PCA_Clock_12T;                                //选择时钟源  STC8F8K D版本
     
895. //        CMOD  = (CMOD  & ~1) | 1;                                                                //ECF
     
896.         PPCA = 1;        //高优先级中断
     
897. 
     
898.         CCAPM0     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
     
899.         PCA_PWM0   = PCA_PWM_8bit;        //PWM宽度
     
900. //        CCAP0L = (u8)CCAP0_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
     
901. //        CCAP0H = (u8)(CCAP0_tmp >> 8);        //后写CCAPnH
     
902. 
     
903.         CCAPM1     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
     
904.         PCA_PWM1   = PCA_PWM_8bit;        //PWM宽度
     
905. //        CCAP1L = (u8)CCAP1_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
     
906. //        CCAP1H = (u8)(CCAP1_tmp >> 8);        //后写CCAPnH
     
907. 
     
908.         CCAPM2     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
     
909.         PCA_PWM2   = PCA_PWM_8bit;        //PWM宽度
     
910. //        CCAP2L = (u8)CCAP2_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
     
911. //        CCAP2H = (u8)(CCAP2_tmp >> 8);        //后写CCAPnH
     
912. 
     
913.         CCAPM3     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
     
914.         PCA_PWM3   = PCA_PWM_8bit;        //PWM宽度
     
915. //        CCAP3L = (u8)CCAP3_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
     
916. //        CCAP3H = (u8)(CCAP3_tmp >> 8);        //后写CCAPnH
     
917. 
     
918.         CR = 1;
     
919. }
     
920. 
     
921. 
     
922. //========================================================================
     
923. // 函数: void        PCA_Handler (void) interrupt PCA_VECTOR
     
924. // 描述: PCA中断处理程序.
     
925. // 参数: None
     
926. // 返回: none.
     
927. // 版本: V1.0, 2012-11-22
     
928. //========================================================================
     
929. void        PCA_Handler (void) interrupt PCA_VECTOR
     
930. {
     
931.         if(CCF0)                //PCA模块0中断
     
932.         {
     
933.                 CCF0 = 0;                //清PCA模块0中断标志
     
934.                 if(P17)        //上升沿
     
935.                 {
     
936.                         CCAP0_RiseTime = ((u16)CCAP0H << 8) + CCAP0L;        //读CCAP0
     
937.                         PPM1_Rise_TimeOut = 1;        //收到上升沿, 高电平限时
     
938.                 }
     
939.                 else        //下降沿
     
940.                 {
     
941.                         CCAP_FallTime = ((u16)CCAP0H << 8) + CCAP0L;        //读CCAP0
     
942.                         if((PPM1_Rise_TimeOut != 0) && (PPM1_Rise_TimeOut < 3))        //收到过上升沿, 高电平也没有溢出
     
943.                         {
     
944.                                 CCAP_FallTime = (CCAP_FallTime - CCAP0_RiseTime) >> 1;        //为了好处理, 转成单位为us
     
945.                                 if((CCAP_FallTime >= 800) && (CCAP_FallTime <= 2500))
     
946.                                 {
     
947.                                         if(++PPM1_RxCnt >= 5)        PPM1_RxCnt = 5;                //连续接收到5个脉冲
     
948.                                         if(PPM1_RxCnt == 5)
     
949.                                         {
     
950.                                                 if(!B_PPM1_OK)
     
951.                                                 {
     
952.                                                         PPM1_Cap = CCAP_FallTime;
     
953.                                                         B_PPM1_OK = 1;                //标志收到一个脉冲
     
954.                                                         PPM1_Rx_TimerOut = 12;        //限时收不到脉冲
     
955.                                                 }
     
956.                                         }
     
957.                                 }
     
958.                         }
     
959.                         PPM1_Rise_TimeOut = 0;
     
960.                 }
     
961.         }
     
962. 
     
963.         if(CCF1)        //PCA模块1中断
     
964.         {
     
965.                 CCF1 = 0;                //清PCA模块1中断标志
     
966.                 if(P16)        //上升沿
     
967.                 {
     
968.                         CCAP1_RiseTime = ((u16)CCAP1H << 8) + CCAP1L;        //读CCAP1
     
969.                         PPM2_Rise_TimeOut = 1;        //收到上升沿, 高电平限时
     
970.                 }
     
971.                 else        //下降沿
     
972.                 {
     
973.                         CCAP_FallTime = ((u16)CCAP1H << 8) + CCAP1L;        //读CCAP1
     
974.                         if((PPM2_Rise_TimeOut != 0) && (PPM2_Rise_TimeOut < 3))        //收到过上升沿, 高电平也没有溢出
     
975.                         {
     
976.                                 CCAP_FallTime = (CCAP_FallTime - CCAP1_RiseTime) >> 1;        //为了好处理, 转成单位为us
     
977.                                 if((CCAP_FallTime >= 800) && (CCAP_FallTime <= 2500))
     
978.                                 {
     
979.                                         if(++PPM2_RxCnt >= 5)        PPM2_RxCnt = 5;
     
980.                                         if(PPM2_RxCnt == 5)
     
981.                                         {
     
982.                                                 if(!B_PPM2_OK)
     
983.                                                 {
     
984.                                                         PPM2_Cap = CCAP_FallTime;
     
985.                                                         B_PPM2_OK = 1;                //标志收到一个脉冲
     
986.                                                         PPM2_Rx_TimerOut = 12;        //限时收不到脉冲
     
987.                                                 }
     
988.                                         }
     
989.                                 }
     
990.                         }
     
991.                         PPM2_Rise_TimeOut = 0;
     
992.                 }
     
993.         }
     
994. 
     
995.         if(CCF2)        //PCA模块2中断
     
996.         {
     
997.                 CCF2 = 0;                //清PCA模块1中断标志
     
998.                 if(P15)        //上升沿
     
999.                 {
     
1000.                         CCAP2_RiseTime = ((u16)CCAP2H << 8) + CCAP2L;        //读CCAP2
      
1001.                         PPM3_Rise_TimeOut = 1;        //收到上升沿, 高电平限时
      
1002.                 }
      
1003.                 else        //下降沿
      
1004.                 {
      
1005.                         CCAP_FallTime = ((u16)CCAP2H << 8) + CCAP2L;        //读CCAP2
      
1006.                         if((PPM3_Rise_TimeOut != 0) && (PPM3_Rise_TimeOut < 3))        //收到过上升沿, 高电平也没有溢出
      
1007.                         {
      
1008.                                 CCAP_FallTime = (CCAP_FallTime - CCAP2_RiseTime) >> 1;        //为了好处理, 转成单位为us
      
1009.                                 if((CCAP_FallTime >= 800) && (CCAP_FallTime <= 2500))
      
1010.                                 {
      
1011.                                         if(++PPM3_RxCnt >= 5)        PPM3_RxCnt = 5;
      
1012.                                         if(PPM3_RxCnt == 5)
      
1013.                                         {
      
1014.                                                 if(!B_PPM3_OK)
      
1015.                                                 {
      
1016.                                                         PPM3_Cap = CCAP_FallTime;
      
1017.                                                         B_PPM3_OK = 1;                //标志收到一个脉冲
      
1018.                                                         PPM3_Rx_TimerOut = 25;        //限时收不到脉冲
      
1019.                                                         YM_LostCnt = 0;
      
1020.                                                         Lost16S    = 0;
      
1021.                                                 }
      
1022.                                         }
      
1023.                                 }
      
1024.                         }
      
1025.                         PPM3_Rise_TimeOut = 0;
      
1026.                 }
      
1027.         }
      
1028. 
      
1029.         if(CCF3)        //PCA模块3中断
      
1030.         {
      
1031.                 CCF3 = 0;                //清PCA模块1中断标志
      
1032.                 if(P14)        //上升沿
      
1033.                 {
      
1034.                         CCAP3_RiseTime = ((u16)CCAP3H << 8) + CCAP3L;        //读CCAP3
      
1035.                         PPM4_Rise_TimeOut = 1;        //收到上升沿, 高电平限时
      
1036.                 }
      
1037.                 else        //下降沿
      
1038.                 {
      
1039.                         CCAP_FallTime = ((u16)CCAP3H << 8) + CCAP3L;        //读CCAP3
      
1040.                         if((PPM4_Rise_TimeOut != 0) && (PPM4_Rise_TimeOut < 3))        //收到过上升沿, 高电平也没有溢出
      
1041.                         {
      
1042.                                 CCAP_FallTime = (CCAP_FallTime - CCAP3_RiseTime) >> 1;        //为了好处理, 转成单位为us
      
1043.                                 if((CCAP_FallTime >= 800) && (CCAP_FallTime <= 2500))
      
1044.                                 {
      
1045.                                         if(++PPM4_RxCnt >= 5)        PPM4_RxCnt = 5;
      
1046.                                         if(PPM4_RxCnt == 5)
      
1047.                                         {
      
1048.                                                 if(!B_PPM4_OK)
      
1049.                                                 {
      
1050.                                                         PPM4_Cap = CCAP_FallTime;
      
1051.                                                         B_PPM4_OK = 1;                //标志收到一个脉冲
      
1052.                                                         PPM4_Rx_TimerOut = 12;        //限时收不到脉冲
      
1053.                                                 }
      
1054.                                         }
      
1055.                                 }
      
1056.                         }
      
1057.                         PPM4_Rise_TimeOut = 0;
      
1058.                 }
      
1059.         }
      
1060. 
      
1061. //        if(CF)        //PCA溢出中断
      
1062. //        {
      
1063. //                CF = 0;                        //清PCA溢出中断标志
      
1064. //        }
      
1065. 
      
1066. }
      

复制代码

所有资料51hei提供下载:
四轴飞控-STC8A8K16S4A12-LQFP44-PPM-V10.zip (3.87 MB, 下载次数: 144)

2018-3-26 12:24 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: 老婆当家    时间: 2018-6-3 20:38
好像没有人喜欢这个帖子啊

---

作者: 合吾小舍    时间: 2018-9-21 10:43
算法方面有吗，截图好像没有工程啊

---

作者: qq451987409    时间: 2019-6-26 19:51
感谢分享

---

作者: 987654321123    时间: 2019-11-3 00:26
没有pcb板程序呀？pcb板上的走线布置，信号处理能学习到很多知识

---

作者: CuChulainn    时间: 2019-11-27 14:36
谢谢分享

---

作者: 腾飞的龙    时间: 2019-12-14 15:37
感谢分享！！！！赞

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1