设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 四轴/航模/飞行器DIY › 51单片机四轴飞控STC8A8K16S4A12-LQFP44-PPM-V10源码与 ...
返回列表 发新帖
查看: 10729|回复: 6
收起左侧

51单片机四轴飞控STC8A8K16S4A12-LQFP44-PPM-V10源码与说明资料下载

  [复制链接]
ID:80420 发表于 2018-3-26 12:24 | 显示全部楼层 |阅读模式
开源了，感兴趣的朋友看一下，里面有代码和pcb都有的.
0.jpg
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。
0.jpg

飞控的电路原理图：
0.png
本飞控仅仅是姿态飞行控制，没有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条。（用户可以先不装，要夜航的才装，我就喜欢夜航)。
0.jpg

单片机源程序如下:
  1. /* 本程序经过测试完全正常, 不提供电话技术支持, 如不能理解, 请自行补充相关基础.  */
  2. /***  特别注意: 下载时选择内部时钟24MHZ, 设置用户EEPROM大小为2K或以上.  ****/
  3. /*********************************************
  4.   四轴飞控-V10.C
  5. 使用遥控接收器型号: MC6B六通道2.4G 100mW.

  7. 四轴上电待机：上电后，航灯不亮，接收机LED闪烁，此时打开遥控器，将左右油门下拉到最小，接收机收到信号LED常亮，
  8.               表示RF通讯已连接。此时蜂鸣器"哔"一声，航灯闪烁，表示待机模式。

  10. 四轴启动：将遥控器左右操纵杆掰成下内八，启动四轴，四轴"哔"一声，4个螺旋桨开始低速旋转，航灯常亮。
  11.           此后提升油门，就可以加速螺旋桨，直到起飞。

  13. 四轴飞行：起飞后，可以操纵右手的俯仰、横滚操纵杆，实现前后左右或任意方向的飞行。
  14.           左手油门杆左掰是航向逆时针转，右掰是航向顺时钟转。

  16. 四轴下降停止：收油门，四轴逐渐下降到地面，然后两操纵杆掰成下外八，停止四轴，重新处于待机模式。

  18. 四轴水平校准：将四轴放置于水平地面，处于待机模式，然后两操纵杆掰成上内八，四轴"哔"一声进入校准，完成后"哔哔"两声完成校准。

  20. 四轴取消水平校准：将四轴放置于水平地面，处于待机模式，然后两操纵杆掰成上外八，四轴"哔"一声取消校准。取消水平校准或未进行水平校准过的四轴，起飞时即使无风也可能会有明显漂移。

  22. 电池低压报警：当电池低压时，蜂鸣器"哔哔"报警，同时航灯闪烁，此时请尽快回航降落。

  24. 无遥控信号异常：当四轴在空中突然收不到遥控信号时，四轴蜂鸣器发出"哔哔哔"报警，同时航灯闪烁，四轴保持水平，逐渐自动减小油门降落。
  25. ***********************************************/

  27. #define                Baudrate1                        115200UL
  28. #define                TX1_LENGTH        128
  29. #define                RX1_LENGTH        128


  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>

  40. sbit        P_Light  = P5^4;        //航灯
  41. sbit        P_BUZZER = P5^5;        //蜂鸣器


  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模块的参数

  54. int                int_tmp;
  55. u8                YM=0,FRX=128,FRY=128,FRZ=128;                                //4通道遥控信号.
  56. u8                xdata        tp[16];                //读MP6050缓冲


  59. //****************姿态处理和PID*********************************************

  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

  66. float xdata Last_Ax=0,Last_Ay=0,Last_Az=0;


  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

  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


  79. #define        Out_YP        Out_XP
  80. #define        Out_YI        Out_XI
  81. #define        Out_YD        Out_XD

  83. #define        In_YP        In_XP
  84. #define        In_YI        In_XI
  85. #define        In_YD        In_XD


  88. #define        ZP        5.0f
  89. #define        ZI        0.1f
  90. #define        ZD        4.0f        //自旋控制的P D
  91. float Z_integral=0;//Z轴积分

  93. #define        ERR_MAX        500
  94. //======================================================================


  97. u8        data YM_LostCnt=0, Lost16S; //上一次RxBuf[0]数据(RxBuf[0]数据在不断变动的)   状态标识
  98. u8        SW2_tmp;


  101. //======================================================================
  102. bit        B_8ms;        //8ms标志

  104. bit        B_rtn_ADC0;        //请求返回信息
  105. bit        B_BAT_LOW;        //低电压标志
  106. u8        xdata cnt_ms;                //时间计数


  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;


  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;        //校准累加和

  125. u8        xdata BuzzerOnTime,BuzzerOffTime,BuzzerRepeat,BuzzerOnCnt,BuzzerOffCnt;
  126. u8        xdata cnt_100ms;


  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脉冲宽度

  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;

  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;

  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;

  158. u16        xdata CCAP_FallTime;

  160. u8        PPM1,PPM2,PPM3,PPM4;
  161. bit        B_Start;
  162. u8        cnt_start;

  164. /* ============================================= */


  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

  181. extern xdata u16        adc0;
  182. extern xdata int        Battery;


  185. //*********************************************************************
  186. //****************角度计算*********************************************
  187. //*********************************************************************
  188. #define        pi                3.14159265f                           
  189. #define        Kp                0.8f                        
  190. #define        Ki                0.001f                        
  191. #define        halfT        0.004f           

  193. float idata q0=1,q1=0,q2=0,q3=0;   
  194. float idata exInt=0,eyInt=0,ezInt=0;  


  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;

  203.         norm = sqrt(ax*ax + ay*ay + az*az);        //把加速度计的三维向量转成单维向量   
  204.         ax = ax / norm;
  205.         ay = ay / norm;
  206.         az = az / norm;

  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 ;

  216.         ex = (ay*vz - az*vy) ;
  217.         ey = (az*vx - ax*vz) ;
  218.         ez = (ax*vy - ay*vx) ;

  220.         exInt = exInt + ex * Ki;
  221.         eyInt = eyInt + ey * Ki;
  222.         ezInt = ezInt + ez * Ki;

  224.         gx = gx + Kp*ex + exInt;
  225.         gy = gy + Kp*ey + eyInt;
  226.         gz = gz + Kp*ez + ezInt;

  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;

  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;

  239.         AngleX = asin(2*(q0*q2 - q1*q3 )) * 57.2957795f; // 俯仰   换算成度
  240.         AngleY = asin(2*(q0*q1 + q2*q3 )) * 57.2957795f; // 横滚
  241. }



  245. //****************姿态计算*********************************************
  246. void PWM_int (void) interrupt         22        //PWM中断函数
  247. {
  248.         PWMCFG = 0;        //CBIF;        //清除中断标志

  250.         B_8ms = 1;

  252. //======================== 超时溢出处理 ==============================================
  253.         PPM1_Rise_TimeOut++;        //高电平限时
  254.         PPM2_Rise_TimeOut++;        //高电平限时
  255.         PPM3_Rise_TimeOut++;        //高电平限时
  256.         PPM4_Rise_TimeOut++;        //高电平限时

  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. //======================================================================

  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.         }

  297.         FRX = PPM1;
  298.         FRY = PPM2;
  299.         YM  = PPM3;        //油门
  300.         FRZ = PPM4;
  301.        

  303. //********************************************************************************************
  304.         Read_MPU6050(tp);        //680us

  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/度

  315.         IMUupdate(Angle_gx*0.0174533f, Angle_gy*0.0174533f, Angle_gz*0.0174533f, Angle_ax,Angle_ay,Angle_az);

  317. //**********************************X轴指向************************************************
  318.         Ax  = AngleX - a_x - ((float)FRX - 128) / 4.0;                //角度控制量加载至角度

  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;        //积分限幅

  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;        //积分限幅

  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;

  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;

  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;

  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;        //积分限幅

  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;

  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);

  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;

  384.                 PWM0 = int_tmp - speed0;

  386.                          if(PWM0 > 1000)        PWM0 = 1000;    //速度参数控制，防止超过PWM参数范围0-1000
  387.                 else if(PWM0 < 10)                PWM0 = 10;

  389.                 PWM1 = int_tmp - speed1;

  391.                          if(PWM1 > 1000)        PWM1 = 1000;
  392.                 else if(PWM1 < 10)                PWM1 = 10;

  394.                 PWM2 = int_tmp - speed2;

  396.                          if(PWM2 > 1000)        PWM2 = 1000;
  397.                 else if(PWM2 < 10)                PWM2 = 10;

  399.                 PWM3 = int_tmp - speed3;

  401.                          if(PWM3 > 1000)        PWM3 = 1000;
  402.                 else if(PWM3 < 10)                PWM3 = 10;
  403.         }

  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设置

  413. }


  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. }

  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. }

  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. }

  495. // ===================== 主函数 =====================
  496. void main(void)
  497. {

  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;

  509.         PPM1 = 128;
  510.         PPM2 = 128;
  511.         PPM3 = 0;
  512.         PPM4 = 128;

  514.         PWMGO();

  516.         P_Light  = 0;
  517.         P_BUZZER = 0;
  518.         P5n_push_pull(0x30);

  520.         adc_init();    //启动A/D
  521.        
  522.         PCA_config();

  524.         delay_ms(100);
  525.         IAPRead();                //读取陀螺仪静差
  526.         InitMPU6050();        //初始化MPU-6050
  527.         delay_ms(100);

  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;

  546.         SetBuzzer(5,1,1);
  547.        

  549. //==============================================
  550.         UART1_config();        // 选择波特率, 2: 使用Timer2做波特率, 其它值: 使用Timer1做波特率.
  551.         PrintString1("STC15W4K系列大四轴飞控程序!\r\n");        //SUART1发送一个字符串
  552. //==============================================

  554.         B_Start = 0;        //上电禁止运行

  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;

  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.                 }


  647.                 if(B_8ms)                //8ms到
  648.                 {
  649.                         B_8ms = 0;
  650.                        
  651.                         if(Cal_Setp != 0)        AutoCal();        //是否执行自动校准序列
  652.                         AD();                // 读ADC计算电压

  654.                         if(++cnt_100ms >= 12)        cnt_100ms = 0,        beep();        //100ms处理一次蜂鸣器

  656.                         B = cnt_ms;
  657.                         ++cnt_ms;
  658.                         B = (B ^ cnt_ms) & cnt_ms;

  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数据

  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.                 }


  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.                 }

  706.         }
  707. }

  709. //=========================================================

  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(' ');

  723.         PrintString1("AngleX=");
  724.         TX1_int_value((int)(AngleX * 10));

  726.         PrintString1("AngleY=");
  727.         TX1_int_value((int)(AngleY * 10));

  729.         PrintString1("AngleZ=");
  730.         TX1_int_value((int)(Angle_gz * 10));

  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);

  739.         TX1_cnt = 0;
  740.         TX1_write2buff(0x0d);
  741.         TX1_write2buff(0x0a);
  742. }


  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. }


  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. }

  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. }


  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. }

  791. //========================================================================
  792. // 函数: SetTimer2Baudrate(u16 dat)
  793. // 描述: 设置Timer2做波特率发生器。
  794. // 参数: dat: Timer2的重装值.
  795. // 返回: none.
  796. // 版本: VER1.0
  797. // 日期: 2014-11-28
  798. // 备注:
  799. //========================================================================

  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. }


  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);

  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. */        //========================================================================

  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

  849.         B_TX1_Busy = 0;
  850.         TX1_Read   = 0;
  851.         TX1_Write  = 0;
  852.         UART1_cmd  = 0;
  853.         TX1_cnt    = 0;
  854. }


  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.         }

  874.         if(TI)
  875.         {
  876.                 TI = 0;
  877.                 B_TX1_Busy = 0;
  878.         }
  879. }



  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;

  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;        //高优先级中断

  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

  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

  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

  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

  918.         CR = 1;
  919. }


  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.         }

  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.         }

  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.         }

  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.         }

  1061. //        if(CF)        //PCA溢出中断
  1062. //        {
  1063. //                CF = 0;                        //清PCA溢出中断标志
  1064. //        }

  1066. }
复制代码
0.png

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

使用道具 举报

ID:138918 发表于 2018-6-3 20:38 | 显示全部楼层
好像没有人喜欢这个帖子啊
回复

使用道具 举报

ID:392801 发表于 2018-9-21 10:43 | 显示全部楼层
算法方面有吗，截图好像没有工程啊
回复

使用道具 举报

ID:440524 发表于 2019-6-26 19:51 | 显示全部楼层
感谢分享
回复

使用道具 举报

ID:490427 发表于 2019-11-3 00:26 | 显示全部楼层
没有pcb板程序呀？pcb板上的走线布置，信号处理能学习到很多知识
回复

使用道具 举报

ID:650780 发表于 2019-11-27 14:36 | 显示全部楼层
谢谢分享
回复

使用道具 举报

ID:79544 发表于 2019-12-14 15:37 | 显示全部楼层
感谢分享！！！！赞
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表