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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 四轴/航模/飞行器DIY › STC51单片机四轴飞控开源项目原理图与源码资料分享
返回列表 发新帖
查看: 23373|回复: 33
打印 上一主题 下一主题
收起左侧

STC51单片机四轴飞控开源项目原理图与源码资料分享

  [复制链接]
跳转到指定楼层
#
ID:253663 发表于 2017-11-26 11:19 | 只看该作者 |只看大图 回帖奖励 |正序浏览 |阅读模式
四轴飞控-STC8A8K64S4A12-LQFP44-PPM-V10，来源于STC发布，按需取用
控制信号排针要靠在一起布线成3排针3*9*2.54
P1~P4对应接收机的俯仰、横滚、油门、航向PPM信号。M1~M4输出到4个电调的信号。P5备用。
四个电机安排顺序如下：

串口1: 下载、调试、控制信号输入.
串口2: 备用为GPS接口或数传接口.


原理图：



飞控的stc单片机程序源码：
  1. /* 本程序经过测试完全正常, 不提供电话技术支持, 如不能理解, 请自行补充相关基础.  */

  3. /***  特别注意: 下载时选择内部时钟24MHZ, 设置用户EEPROM大小为2K或以上.  ****/

  5. /*********************************************
  6.   四轴飞控-V10.C

  8. 使用遥控接收器型号: MC6B六通道2.4G 100mW.

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

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

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

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

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

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

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

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

  29. ***********************************************/

  31. #define                Baudrate1                        115200UL
  32. #define                TX1_LENGTH        128
  33. #define                RX1_LENGTH        128


  36. #include "config.h"
  37. #include "STC8xxx_PWM.H"
  38. #include "MPU6050.H"
  39. #include "AD.H"       
  40. #include "EEPROM.H"
  41. #include "PCA.h"
  42. #include <math.H>

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


  48. int                xdata g_x=0,g_y=0,g_z=0;                                        //陀螺仪矫正参数
  49. float        xdata a_x=0,a_y=0;                                                        //角度矫正参数
  50. float        data  AngleX=0,AngleY=0;                                        //四元数解算出的欧拉角
  51. float        xdata Angle_gx=0,Angle_gy=0,Angle_gz=0;                //由角速度计算的角速率(角度制)
  52. float        xdata Angle_ax=0,Angle_ay=0,Angle_az=0;                //由加速度计算的加速度(弧度制)
  53. float        xdata Ax=0,Ay=0,Az=0;                                                //加入遥控器控制量后的角度   
  54. float        data PID_x=0,PID_y=0,PID_z=0;                                //PID最终输出量
  55. int                data  speed0=0,speed1=0,speed2=0,speed3=0;        //电机速度参数
  56. int                data  PWM0=0,PWM1=0,PWM2=0,PWM3=0;//,PWM4=0,PWM5=0;                        //加载至PWM模块的参数

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


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

  65. float xdata Out_PID_X=0,Last_Angle_gx=0;                                        //外环PI输出量  上一次陀螺仪数据
  66. float xdata ERRORX_Out=0,ERRORX_In=0;                        //外环P  外环I  外环误差积分
  67. float xdata Out_PID_Y=0,Last_Angle_gy=0;
  68. float xdata ERRORY_Out=0,ERRORY_In=0;            //规则1:内外环P乘积等于10.5

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


  73. /******************************************************************************/
  74. #define        Out_XP        6.65f        //ADC0        外环P        V1 / 10
  75. #define        Out_XI        0.0074f        //ADC4        外环I        V2 / 10000
  76. #define        Out_XD        6.0f        //ADC5        外环D        V3 / 10

  78. #define        In_XP        0.8275f        //ADC6        内环P        V4 / 100
  79. #define        In_XI        0.0074f        //ADC4        内环I        V2 / 10000
  80. #define        In_XD        6.0f        //ADC5        内环D        V3 / 10


  83. #define        Out_YP        Out_XP
  84. #define        Out_YI        Out_XI
  85. #define        Out_YD        Out_XD

  87. #define        In_YP        In_XP
  88. #define        In_YI        In_XI
  89. #define        In_YD        In_XD


  92. #define        ZP        5.0f
  93. #define        ZI        0.1f
  94. #define        ZD        4.0f        //自旋控制的P D
  95. float Z_integral=0;//Z轴积分

  97. #define        ERR_MAX        500
  98. //======================================================================


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


  105. //======================================================================
  106. bit        B_8ms;        //8ms标志

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


  113. u8                xdata UART1_cmd=0;        //串口命令
  114. u8                xdata TX1_Read=0;        //发送读指针
  115. u8                xdata TX1_Write=0;        //发送写指针
  116. u8                xdata TX1_cnt=0;        //发送计数
  117. u8                 xdata TX1_Buffer[TX1_LENGTH];        //发送缓冲
  118. bit                B_TX1_Busy;                        //发送忙标志
  119. u8                 xdata RX1_Cnt,RX1_Timer;
  120. u8                 xdata RX1_Buffer[RX1_LENGTH];
  121. bit         B_RX1_OK;


  124. u8                xdata Cal_Setp=0;                        //校准步骤
  125. u8                xdata Cal_cnt=0;                        //校准平均值计数
  126. int                xdata x_sum,y_sum,z_sum;        //校准累加和
  127. float        xdata float_x_sum,float_y_sum;        //校准累加和

  129. u8        xdata BuzzerOnTime,BuzzerOffTime,BuzzerRepeat,BuzzerOnCnt,BuzzerOffCnt;
  130. u8        xdata cnt_100ms;


  133. /* =================== PPM接收相关变量 ========================== */
  134. u16        xdata CCAP0_RiseTime;                //捕捉到的上升沿时刻
  135. u8        xdata PPM1_Rise_TimeOut;        //高电平限时
  136. u8        xdata PPM1_Rx_TimerOut;                //接收超时计数
  137. u8        xdata PPM1_RxCnt;                        //接收次数计数
  138. u16        xdata PPM1_Cap;                                //捕捉到的PPM脉冲宽度
  139. bit        B_PPM1_OK;                                        //接收到一个PPM脉冲宽度

  141. u16        xdata CCAP1_RiseTime;
  142. u8        xdata PPM2_Rise_TimeOut;        //高电平限时
  143. u8        xdata PPM2_Rx_TimerOut;
  144. u8        xdata PPM2_RxCnt;
  145. u16        xdata PPM2_Cap;
  146. bit        B_PPM2_OK;

  148. u16        xdata CCAP2_RiseTime;
  149. u8        xdata PPM3_Rise_TimeOut;        //高电平限时
  150. u8        xdata PPM3_Rx_TimerOut;
  151. u8        xdata PPM3_RxCnt;
  152. u16        xdata PPM3_Cap;
  153. bit        B_PPM3_OK;

  155. u16        xdata CCAP3_RiseTime;
  156. u8        xdata PPM4_Rise_TimeOut;        //高电平限时
  157. u8        xdata PPM4_Rx_TimerOut;
  158. u8        xdata PPM4_RxCnt;
  159. u16        xdata PPM4_Cap;
  160. bit        B_PPM4_OK;

  162. u16        xdata CCAP_FallTime;

  164. u8        PPM1,PPM2,PPM3,PPM4;
  165. bit        B_Start;
  166. u8        cnt_start;

  168. /* ============================================= */


  171. void        UART1_config(void);
  172. void         PrintString1(u8 *puts);        //发送一个字符串
  173. void        TX1_write2buff(u8 dat);        //写入发送缓冲，指针+1
  174. void        TX1_int_value(int i);
  175. void        delay_ms(u8 ms);
  176. void        Return_Message(void);
  177. u16         MODBUS_CRC16(u8 *p,u8 n);        //input:        *p--->First Data Address,n----->Data Number,        return:        CRC16
  178. void        PCA_config(void);
  179. void         Timer0_Config(void);
  180. void         Timer1_Config(void);
  181. void        return_TTMx(u8 id,PPMx);
  182. void         Timer0_Config(void);
  183. u16         MODBUS_CRC16(u8 *p,u8 n);        //input:        *p--->First Data Address,n----->Data Number,        return:        CRC16

  185. extern xdata u16        adc0;
  186. extern xdata int        Battery;


  189. //*********************************************************************
  190. //****************角度计算*********************************************
  191. //*********************************************************************
  192. #define        pi                3.14159265f                           
  193. #define        Kp                0.8f                        
  194. #define        Ki                0.001f                        
  195. #define        halfT        0.004f           

  197. float idata q0=1,q1=0,q2=0,q3=0;   
  198. float idata exInt=0,eyInt=0,ezInt=0;  


  201. void IMUupdate(float gx, float gy, float gz, float ax, float ay, float az)
  202. {
  203.         float data norm;
  204.         float idata vx, vy, vz;
  205.         float idata ex, ey, ez;

  207.         norm = sqrt(ax*ax + ay*ay + az*az);        //把加速度计的三维向量转成单维向量   
  208.         ax = ax / norm;
  209.         ay = ay / norm;
  210.         az = az / norm;

  212.                 //        下面是把四元数换算成《方向余弦矩阵》中的第三列的三个元素。
  213.                 //        根据余弦矩阵和欧拉角的定义，地理坐标系的重力向量，转到机体坐标系，正好是这三个元素
  214.                 //        所以这里的vx vy vz，其实就是当前的欧拉角（即四元数）的机体坐标参照系上，换算出来的
  215.                 //        重力单位向量。
  216.         vx = 2*(q1*q3 - q0*q2);
  217.         vy = 2*(q0*q1 + q2*q3);
  218.         vz = q0*q0 - q1*q1 - q2*q2 + q3*q3 ;

  220.         ex = (ay*vz - az*vy) ;
  221.         ey = (az*vx - ax*vz) ;
  222.         ez = (ax*vy - ay*vx) ;

  224.         exInt = exInt + ex * Ki;
  225.         eyInt = eyInt + ey * Ki;
  226.         ezInt = ezInt + ez * Ki;

  228.         gx = gx + Kp*ex + exInt;
  229.         gy = gy + Kp*ey + eyInt;
  230.         gz = gz + Kp*ez + ezInt;

  232.         q0 = q0 + (-q1*gx - q2*gy - q3*gz) * halfT;
  233.         q1 = q1 + ( q0*gx + q2*gz - q3*gy) * halfT;
  234.         q2 = q2 + ( q0*gy - q1*gz + q3*gx) * halfT;
  235.         q3 = q3 + ( q0*gz + q1*gy - q2*gx) * halfT;

  237.         norm = sqrt(q0*q0 + q1*q1 + q2*q2 + q3*q3);
  238.         q0 = q0 / norm;
  239.         q1 = q1 / norm;
  240.         q2 = q2 / norm;
  241.         q3 = q3 / norm;

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



  249. //****************姿态计算*********************************************
  250. void PWM_int (void) interrupt         22        //PWM中断函数
  251. {
  252.         PWMCFG = 0;        //CBIF;        //清除中断标志

  254.         B_8ms = 1;

  256. //======================== 超时溢出处理 ==============================================
  257.         PPM1_Rise_TimeOut++;        //高电平限时
  258.         PPM2_Rise_TimeOut++;        //高电平限时
  259.         PPM3_Rise_TimeOut++;        //高电平限时
  260.         PPM4_Rise_TimeOut++;        //高电平限时

  262.         if(--PPM1_Rx_TimerOut == 0)                //超过100ms收不到信号
  263.         {
  264.                 PPM1_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
  265.                 PPM1 = 128;;                        //默认中点
  266.         }
  267.         if(--PPM2_Rx_TimerOut == 0)                //超过100ms收不到信号
  268.         {
  269.                 PPM2_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
  270.                 PPM2 = 128;;                        //默认中点
  271.         }
  272.         if(--PPM3_Rx_TimerOut == 0)                //超过200ms收不到信号
  273.         {
  274.                 PPM3_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
  275.         }
  276.         if(--PPM4_Rx_TimerOut == 0)                //超过100ms收不到信号
  277.         {
  278.                 PPM4_RxCnt = 0;                        //一旦出现溢出, 则开始的n个脉冲无效
  279.                 PPM4 = 128;                                //默认中点
  280.         }
  281. //======================================================================

  283.         if(++YM_LostCnt >= 250)                //失联2秒后
  284.         {
  285.                 YM_LostCnt = 200;                //重复0.4秒，失控保护
  286.                 if(PPM3 > 80)        PPM3--;
  287.                 else if(++Lost16S >= 40)
  288.                 {
  289.                         Lost16S = 250;
  290.                         PPM3 = 0;
  291.                         B_Start = 0;
  292.                 }
  293.         }
  294.         if(YM_LostCnt  >= 25)        //失联200ms
  295.         {
  296.                 PPM1 = 128;
  297.                 PPM2 = 128;                //俯仰 横滚 航向均归0
  298.                 PPM4 = 128;
  299.         }

  301.         FRX = PPM1;
  302.         FRY = PPM2;
  303.         YM  = PPM3;        //油门
  304.         FRZ = PPM4;
  305.        

  307. //********************************************************************************************
  308.         Read_MPU6050(tp);        //680us

  310.         Angle_ax = ((float)(((int *)&tp)[0])) / 8192.0;        //加速度处理        结果单位是 +- g
  311.         Angle_ay = ((float)(((int *)&tp)[1])) / 8192.0;        //转换关系        8192 LSB/g, 1g对应读数8192
  312.         Angle_az = ((float)(((int *)&tp)[2])) / 8192.0;        //加速度量程 +-4g/S
  313.         Last_Angle_gx = Angle_gx;                //储存上一次角速度数据
  314.         Last_Angle_gy = Angle_gy;
  315.         Angle_gx = ((float)(((int *)&tp)[4] - g_x)) / 65.5;        //陀螺仪处理        结果单位是 +-度
  316.         Angle_gy = ((float)(((int *)&tp)[5] - g_y)) / 65.5;        //陀螺仪量程 +-500度/S, 1度/秒 对应读数 65.536
  317.         Angle_gz = ((float)(((int *)&tp)[6] - g_z)) / 65.5;        //转换关系65.5 LSB/度

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

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

  324.         if(YM > 35)        ERRORX_Out += Ax,        ERRORX_Out += Ax,        ERRORX_Out += Ax;        //外环积分(油门小于某个值时不积分)
  325.         else                ERRORX_Out = 0; //油门小于定值时清除积分值
  326.                  if(ERRORX_Out >  1500)        ERRORX_Out =  1500;
  327.         else if(ERRORX_Out < -1500)        ERRORX_Out = -1500;        //积分限幅

  329.         Out_PID_X = Ax*Out_XP + ERRORX_Out*Out_XI + (Ax-Last_Ax)*Out_XD;        //外环PI
  330.         Last_Ax = Ax;
  331.        
  332.         if(YM > 35)        ERRORX_In += (Angle_gy - Out_PID_X);        //内环积分(油门小于某个值时不积分)
  333.         else                ERRORX_In = 0;        //油门小于定值时清除积分值
  334.                  if(ERRORX_In >  500)        ERRORX_In =  500;
  335.         else if(ERRORX_In < -500)        ERRORX_In = -500;        //积分限幅

  337.         PID_x = (Angle_gy + Out_PID_X) * In_XP + ERRORX_In * In_XI + (Angle_gy - Last_Angle_gy) * In_XD;        //内环PID
  338.         if(PID_x >  500)        PID_x =  500;        //输出量限幅
  339.         if(PID_x < -500)        PID_x = -500;

  341. //**************Y轴指向**************************************************
  342.         Ay  = AngleY - a_y + ((float)FRY - 128) / 4.0;                //角度控制量加载至角度
  343.        
  344.         if(YM > 35)        ERRORY_Out += Ay,        ERRORY_Out += Ay,        ERRORY_Out += Ay;        //外环积分(油门小于某个值时不积分)
  345.         else                ERRORY_Out = 0; //油门小于定值时清除积分值
  346.                  if(ERRORY_Out >  1500)        ERRORY_Out =  1500;
  347.         else if(ERRORY_Out < -1500)        ERRORY_Out = -1500;        //积分限幅
  348.        
  349.         Out_PID_Y = Ay * Out_YP + ERRORY_Out * Out_YI + (Ay-Last_Ay)*Out_YD;        //外环PID
  350.         Last_Ay = Ay;

  352.         if(YM > 35)        ERRORY_In += (Angle_gx - Out_PID_Y);  //内环积分(油门小于某个值时不积分)
  353.         else                ERRORY_In = 0; //油门小于定值时清除积分值
  354.                  if(ERRORY_In >  500)        ERRORY_In =  500;
  355.         else if(ERRORY_In < -500)        ERRORY_In = -500;        //积分限幅
  356.        
  357.         PID_y = (Angle_gx + Out_PID_Y) * In_YP + ERRORY_In * In_YI + (Angle_gx - Last_Angle_gx) * In_YD;        //内环PID
  358.        
  359.         if(PID_y > 500)        PID_y =  500;        //输出量限幅
  360.         if(PID_y <-500)        PID_y = -500;

  362. //**************Z轴指向(Z轴随便啦，自旋控制没必要上串级PID)*****************************       
  363.         Az = Angle_gz - ((float)FRZ - 128);
  364.        
  365.         if(YM > 35)        Z_integral += Az;        //Z轴积分
  366.         else                Z_integral = 0;                //油门小于40积分清零
  367.                  if(Z_integral >  500.0f)        Z_integral =  500.0f;        //积分限幅
  368.         else if(Z_integral < -500.0f)        Z_integral = -500.0f;        //积分限幅

  370.         PID_z = Az * ZP + Z_integral * ZI + (Az - Last_Az) * ZD;
  371.         Last_Az = Az;
  372.         if(PID_z >  200)        PID_z =  200;        //输出量限幅
  373.         if(PID_z < -200)        PID_z = -200;

  375.         speed0 = (int)(  PID_x + PID_y + PID_z);        //M1改为逆时针
  376.         speed1 = (int)(  PID_x - PID_y - PID_z);
  377.         speed2 = (int)( -PID_x - PID_y + PID_z);
  378.         speed3 = (int)( -PID_x + PID_y - PID_z);

  380. //**************将速度参数加载至PWM模块*************************************************       
  381.        
  382.         if(YM < 10)        PWM0 = 1000, PWM1 = 1000, PWM2 = 1000, PWM3 = 1000;
  383.         else if(YM < 35)        PWM0 = 860, PWM1 = 860, PWM2 = 860, PWM3 = 860;
  384.         else
  385.         {
  386.                 int_tmp = 1000 - (int)YM * 4;

  388.                 PWM0 = int_tmp - speed0;

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

  393.                 PWM1 = int_tmp - speed1;

  395.                          if(PWM1 > 1000)        PWM1 = 1000;
  396.                 else if(PWM1 < 10)                PWM1 = 10;

  398.                 PWM2 = int_tmp - speed2;

  400.                          if(PWM2 > 1000)        PWM2 = 1000;
  401.                 else if(PWM2 < 10)                PWM2 = 10;

  403.                 PWM3 = int_tmp - speed3;

  405.                          if(PWM3 > 1000)        PWM3 = 1000;
  406.                 else if(PWM3 < 10)                PWM3 = 10;
  407.         }

  409.         SW2_tmp = P_SW2;        //保存SW2设置
  410.         EAXSFR();        //访问XFR
  411.         PWM0T2 = (u16)(PWM0 * 2);
  412.         PWM1T2 = (u16)(PWM1 * 2);
  413.         PWM2T2 = (u16)(PWM2 * 2);
  414.         PWM3T2 = (u16)(PWM3 * 2);       
  415.         P_SW2  = SW2_tmp;        //恢复SW2设置

  417. }


  420. /********************** 蜂鸣函数 ************************/
  421. void        beep(void)        //100ms调用
  422. {
  423.         if(BuzzerRepeat > 0)        //蜂鸣器处理, 重复次数不为0，则蜂鸣器要发声
  424.         {
  425.                 if((BuzzerOnCnt == 0) && (BuzzerOffCnt == 0))        //On和OFF都为0，则开始装载On和Off的时间
  426.                 {
  427.                         P_BUZZER = 1;                        //允许蜂鸣
  428.                         BuzzerOnCnt  = BuzzerOnTime;        //装载on计数
  429.                         BuzzerOffCnt = BuzzerOffTime;        //装载off计数
  430.                 }
  431.                 else if(BuzzerOnCnt  > 0)        {if(--BuzzerOnCnt == 0)        P_BUZZER = 0;}        //On的时间
  432.                 else if(BuzzerOffCnt > 0)        //Off的时间
  433.                 {
  434.                         if(--BuzzerOffCnt == 0)        BuzzerRepeat--;
  435.                 }
  436.         }
  437.         else        P_BUZZER = 0;
  438. }

  440. void        SetBuzzer(u8 on,u8 off,u8 rep)        // rep: 重复次数, on: on的时间, off: off的时间
  441. {
  442.         BuzzerRepeat = rep;
  443.         BuzzerOnTime  = on;
  444.         BuzzerOffTime = off;
  445.         if(BuzzerOnTime  == 0)        BuzzerOnTime  = 1;
  446.         if(BuzzerOffTime == 0)        BuzzerOffTime = 1;
  447.         if(BuzzerRepeat == 1)        BuzzerOffTime = 1;
  448.         BuzzerOnCnt = 0,        BuzzerOffCnt = 0;
  449. }

  451. // ===================== 自动校准序列 =====================
  452. void        AutoCal(void)
  453. {
  454.         if(PPM3 < 40)        //停止时才允许校准
  455.         {
  456.                 if(Cal_Setp == 1)        //进入校准序列
  457.                 {
  458.                         x_sum = 0;        y_sum = 0;        z_sum = 0;
  459.                         Cal_cnt  = 0;
  460.                         Cal_Setp = 2;
  461.                 }
  462.                 else if(Cal_Setp == 2)        //对陀螺仪累加
  463.                 {
  464.                         x_sum += ((int *)&tp)[4];  //读取陀螺仪数据
  465.                         y_sum += ((int *)&tp)[5];
  466.                         z_sum += ((int *)&tp)[6];
  467.                         if(++Cal_cnt >= 64)
  468.                         {
  469.                                 g_x = x_sum / 64;
  470.                                 g_y = y_sum / 64;
  471.                                 g_z = z_sum / 64;
  472.                                 float_x_sum = 0;        float_y_sum = 0;
  473.                                 Cal_cnt  = 0;
  474.                                 Cal_Setp = 3;
  475.                         }
  476.                 }
  477.                 else if(Cal_Setp == 3)        //对X Y角度累加
  478.                 {
  479.                         float_x_sum += AngleX;
  480.                         float_y_sum += AngleY;
  481.                         if(++Cal_cnt >= 64)
  482.                         {
  483.                                 Cal_cnt  = 0;
  484.                                 Cal_Setp = 0;
  485.                                 a_x = float_x_sum / 64.0;
  486.                                 a_y = float_y_sum / 64.0;
  487.                                 IAP_Gyro();
  488.                                 SetBuzzer(5,1,1);
  489.                         }
  490.                 }
  491.         }
  492.         else
  493.         {
  494.                 Cal_Setp = 0;
  495.                 Cal_cnt  = 0;
  496.         }
  497. }

  499. // ===================== 主函数 =====================
  500. void main(void)
  501. {

  503.         //所有I/O口全设为准双向，弱上拉模式
  504.         P0M0=0x00;        P0M1=0x00;
  505.         P1M0=0x00;        P1M1=0x00;
  506.         P2M0=0x00;        P2M1=0x00;
  507.         P3M0=0x00;        P3M1=0x00;
  508.         P4M0=0x00;        P4M1=0x00;
  509.         P5M0=0x00;        P5M1=0x00;
  510.         P6M0=0x00;        P6M1=0x00;
  511.         P7M0=0x00;        P7M1=0x00;

  513.         PPM1 = 128;
  514.         PPM2 = 128;
  515.         PPM3 = 0;
  516.         PPM4 = 128;

  518.         PWMGO();

  520.         P_Light  = 0;
  521.         P_BUZZER = 0;
  522.         P5n_push_pull(0x30);

  524.         adc_init();    //启动A/D
  525.        
  526.         PCA_config();

  528.         delay_ms(100);
  529.         IAPRead();                //读取陀螺仪静差
  530.         InitMPU6050();        //初始化MPU-6050
  531.         delay_ms(100);

  533.         PWMCR =  0xc0;//ECBI;        //允许PWM计数器归零中断
  534.         EA = 1;        //允许总中断
  535.        
  536.         cnt_start = 0;
  537.         while(cnt_start < 25)        //等待油门最小        20ms * 25 = 500ms
  538.         {
  539.                 if(B_PPM3_OK)        //油门
  540.                 {
  541.                         B_PPM3_OK = 0;
  542.                         if(PPM3_Cap <= 1200)        cnt_start++;
  543.                 }
  544.                 delay_ms(1);
  545.         }
  546.         P_Light  = 0;
  547.        
  548.         cnt_start = 0;

  550.         SetBuzzer(5,1,1);
  551.        

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

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

  560.         while(1)
  561.         {
  562.                 if(B_PPM1_OK)        //左右(横滚)
  563.                 {
  564.                         B_PPM1_OK = 0;
  565.                                  if(PPM1_Cap < 1120)        PPM1_Cap = 1120;
  566.                         else if(PPM1_Cap > 1880)        PPM1_Cap = 1880;
  567.                         PPM2 = (u8)((PPM1_Cap-1116)/3);        //转为0~255, 中间值为128
  568.                 }
  569.                
  570.                 if(B_PPM2_OK)        //前后(俯仰)
  571.                 {
  572.                         B_PPM2_OK = 0;
  573.                                  if(PPM2_Cap < 1120)        PPM2_Cap = 1120;
  574.                         else if(PPM2_Cap > 1880)        PPM2_Cap = 1880;
  575.                         PPM1 = (u8)((PPM2_Cap-1116)/3);        //转为0~255, 中间值为128
  576.                 }
  577.                
  578.                 if(B_PPM4_OK)        //航向
  579.                 {
  580.                         B_PPM4_OK = 0;
  581.                                  if(PPM4_Cap < 1056)        PPM4_Cap = 1056;
  582.                                  if(PPM4_Cap > 1940)        PPM4_Cap = 1940;
  583.                                  if(PPM4_Cap < 1440)        PPM4_Cap = PPM4_Cap + 60;
  584.                         else if(PPM4_Cap > 1560)        PPM4_Cap = PPM4_Cap - 60;
  585.                         else        PPM4_Cap = 1500;
  586.                         PPM4 = (u8)((PPM4_Cap-1116)/3);        //转为0~255, 中间值为128
  587.                 }
  588.                
  589.                 if(B_PPM3_OK)        //油门
  590.                 {
  591.                         B_PPM3_OK = 0;
  592.                         if(PPM3_Cap < 1000)        PPM3_Cap = 1000;
  593.                         if(PPM3_Cap > 1900)        PPM3_Cap = 1900;

  595.                         if(B_Start)                //正在运行时,
  596.                         {
  597.                                 PPM3 = (u8)((PPM3_Cap-1000)/4);        //转为0~255,        实际8~225
  598.                                 if(PPM3 < 32)        PPM3 = 32;
  599.                                
  600.                                 if((PPM1 < 50) && (PPM2 < 50) && (PPM3_Cap < 1120) && (PPM4 > 200))        //下外八, 禁止
  601.                                 {
  602.                                         if(++cnt_start >= 50)        //1秒
  603.                                         {
  604.                                                 cnt_start = 0;
  605.                                                 B_Start = 0;
  606.                                                 SetBuzzer(1,1,2);
  607.                                         }
  608.                                 }
  609.                                 else        cnt_start = 0;
  610.                         }
  611.                         else        //禁止运行时, 等待内八开启
  612.                         {
  613.                                 PPM3 = 0;
  614.                                 if((PPM1 < 50) && (PPM2 > 200) && (PPM3_Cap < 1120) && (PPM4 < 50))        //下内八, 启动
  615.                                 {
  616.                                         if(++cnt_start >= 50)        //1秒
  617.                                         {
  618.                                                 cnt_start = 0;
  619.                                                 B_Start = 1;
  620.                                                 SetBuzzer(5,1,1);
  621.                                         }
  622.                                 }
  623.                                 else if((PPM1 > 200) && (PPM2 > 200) && (PPM3_Cap > 1850) && (PPM4 < 50))        //上内八, 水平校准
  624.                                 {
  625.                                         if(++cnt_start >= 50)        //1秒
  626.                                         {
  627.                                                 cnt_start = 0;
  628.                                                 SetBuzzer(2,1,1);
  629.                                                 Cal_Setp = 1;
  630.                                         }
  631.                                 }
  632.                                 else if((PPM1 > 200) && (PPM2 < 50) && (PPM3_Cap > 1850) && (PPM4 > 200))        //上外八, 取消水平校准
  633.                                 {
  634.                                         if(++cnt_start >= 50)        //1秒
  635.                                         {
  636.                                                 cnt_start = 0;
  637.                                                 g_x = 0;
  638.                                                 g_y = 0;
  639.                                                 g_z = 0;
  640.                                                 a_x = 0;
  641.                                                 a_y = 0;
  642.                                                 IAP_Gyro();
  643.                                                 SetBuzzer(1,1,2);
  644.                                         }
  645.                                 }
  646.                                 else        cnt_start = 0;
  647.                         }
  648.                 }


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

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

  660.                         B = cnt_ms;
  661.                         ++cnt_ms;
  662.                         B = (B ^ cnt_ms) & cnt_ms;

  664.                         if(B2)                //64ms
  665.                         {
  666.                                 if(!B_BAT_LOW && (YM_LostCnt < 120))        //电压足, 信号正常
  667.                                 {
  668.                                         if(!B_Start)        P_Light = 0;        // 空闲时, 则慢闪(每2048ms亮64ms)
  669.                                         else                         P_Light = 1;        // 启动后, 灯常亮
  670.                                 }
  671.                         }
  672.                         else if(B4)                //256ms
  673.                         {
  674.                                 if(B_BAT_LOW || (YM_LostCnt >= 120))        P_Light = ~P_Light;                //电压低, 或无信号, 航灯闪烁 2HZ
  675.                         }
  676.                         else if(B6)                //1024ms
  677.                         {
  678.                                 if(Battery < 1090)        B_BAT_LOW = 1;        else if(Battery > 1110)        B_BAT_LOW = 0;        //<10.90V电压低, >11.10V电压够
  679.                                
  680.                                 if(B_BAT_LOW)        SetBuzzer(1,1,2);        //电压低
  681.                                
  682.                                 if(B_rtn_ADC0)        Return_Message();        //请求返回ADC0数据

  684.                                 if(!B_BAT_LOW && (YM_LostCnt < 120))        P_Light = 1;        //遥控信号正常,        电压正常时
  685.                         }
  686.                         else if(B7)                //2048ms
  687.                         {
  688.                                 if(!B_BAT_LOW && (YM_LostCnt >= 120))        SetBuzzer(1,1,3);        //电压正常时 遥控信号丢失, 每两秒短鸣3次,
  689.                         }
  690.                 }


  693.                 if(UART1_cmd != 0)
  694.                 {
  695.                         if(UART1_cmd == 'a')                //PC发送a，飞控返回一些参数
  696.                         {
  697.                                 B_rtn_ADC0 = ~B_rtn_ADC0;
  698.                         }
  699.                         UART1_cmd = 0;
  700.                 }
  701.                
  702.                
  703.                 if((TX1_Read != TX1_Write) && (!B_TX1_Busy))        //有数据要发送, 并且发送空闲
  704.                 {
  705.                         SBUF = TX1_Buffer[TX1_Read];
  706.                         B_TX1_Busy = 1;
  707.                         if(++TX1_Read >= TX1_LENGTH)        TX1_Read = 0;
  708.                 }

  710.         }
  711. }

  713. //=========================================================

  715. void        Return_Message(void)
  716. {
  717.         TX1_write2buff('V');
  718.         TX1_write2buff('=');
  719.         TX1_write2buff(Battery/1000 + '0');
  720.         TX1_write2buff((Battery%1000)/100 + '0');
  721.         TX1_write2buff('.');
  722.         TX1_write2buff((Battery%100)/10 + '0');
  723.         TX1_write2buff(Battery%10 + '0');
  724.         TX1_write2buff(' ');
  725.         TX1_write2buff(' ');

  727.         PrintString1("AngleX=");
  728.         TX1_int_value((int)(AngleX * 10));

  730.         PrintString1("AngleY=");
  731.         TX1_int_value((int)(AngleY * 10));

  733.         PrintString1("AngleZ=");
  734.         TX1_int_value((int)(Angle_gz * 10));

  736.         PrintString1("a_x=");
  737.         TX1_int_value(a_x * 10);
  738.         PrintString1("a_y=");
  739.         TX1_int_value(a_y * 10);
  740.         PrintString1("g_z=");
  741.         TX1_int_value(g_z * 10);

  743.         TX1_cnt = 0;
  744.         TX1_write2buff(0x0d);
  745.         TX1_write2buff(0x0a);
  746. }


  749. void  delay_ms(u8 ms)
  750. {
  751.      u16 i;
  752.          do
  753.          {
  754.                  i = MAIN_Fosc / 13000;
  755.                 while(--i)        ;   //13T per loop
  756.      }while(--ms);
  757. }


  760. void        TX1_int_value(int i)
  761. {
  762.         if(i < 0)        TX1_write2buff('-'),        i = 0 - i;
  763.         else                TX1_write2buff(' ');
  764.         TX1_write2buff(i / 1000 + '0');
  765.         TX1_write2buff((i % 1000) / 100 + '0');
  766.         TX1_write2buff((i % 100) / 10 + '0');
  767.         TX1_write2buff('.');
  768.         TX1_write2buff(i % 10 + '0');
  769.         TX1_write2buff(' ');
  770.         TX1_write2buff(' ');
  771. }

  773. /*************** 装载串口1发送缓冲 *******************************/
  774. void TX1_write2buff(u8 dat)        //写入发送缓冲，指针+1
  775. {
  776.         TX1_Buffer[TX1_Write] = dat;
  777.         if(++TX1_Write >= TX1_LENGTH)        TX1_Write = 0;
  778. }


  781. //========================================================================
  782. // 函数: void PrintString1(u8 *puts)
  783. // 描述: 串口1发送字符串函数。
  784. // 参数: puts:  字符串指针.
  785. // 返回: none.
  786. // 版本: VER1.0
  787. // 日期: 2014-11-28
  788. // 备注:
  789. //========================================================================
  790. void PrintString1(u8 *puts)        //发送一个字符串
  791. {
  792.         for (; *puts != 0;        puts++)   TX1_write2buff(*puts);        //遇到停止符0结束
  793. }

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

  805. void        SetTimer2Baudrate(u16 dat)        // 选择波特率, 2: 使用Timer2做波特率, 其它值: 使用Timer1做波特率.
  806. {
  807.         AUXR &= ~(1<<4);        //Timer stop
  808.         AUXR &= ~(1<<3);        //Timer2 set As Timer
  809.         AUXR |=  (1<<2);        //Timer2 set as 1T mode
  810.         TH2 = dat / 256;
  811.         TL2 = dat % 256;
  812.         IE2  &= ~(1<<2);        //禁止中断
  813.         AUXR |=  (1<<4);        //Timer run enable
  814. }


  817. //========================================================================
  818. // 函数: void        UART1_config(u8 brt)
  819. // 描述: UART1初始化函数。
  820. // 参数: brt: 选择波特率, 2: 使用Timer2做波特率, 其它值: 使用Timer1做波特率.
  821. // 返回: none.
  822. // 版本: VER1.0
  823. // 日期: 2014-11-28
  824. // 备注:
  825. //========================================================================
  826. void        UART1_config(void)
  827. {
  828.         /*********** 波特率使用定时器2 *****************/
  829.         AUXR |= 0x01;                //S1 BRT Use Timer2;
  830.         SetTimer2Baudrate(65536UL - (MAIN_Fosc / 4) / Baudrate1);

  832.         /*********** 波特率使用定时器1 *****************/
  833. /*        TR1 = 0;
  834.         AUXR &= ~0x01;                //S1 BRT Use Timer1;
  835.         AUXR |=  (1<<6);        //Timer1 set as 1T mode
  836.         TMOD &= ~(1<<6);        //Timer1 set As Timer
  837.         TMOD &= ~0x30;                //Timer1_16bitAutoReload;
  838.         TH1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) / 256);
  839.         TL1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) % 256);
  840.         ET1 = 0;        //禁止中断
  841.         INT_CLKO &= ~0x02;        //不输出时钟
  842.         TR1  = 1;
  843. */        //========================================================================

  845.         SCON = (SCON & 0x3f) | 0x40;        //UART1模式, 0x00: 同步移位输出, 0x40: 8位数据,可变波特率, 0x80: 9位数据,固定波特率, 0xc0: 9位数据,可变波特率
  846.         PS  = 1;        //高优先级中断
  847.         ES  = 1;        //允许中断
  848.         REN = 1;        //允许接收
  849.         P_SW1 &= 0x3f;
  850.         P_SW1 |= 0x00;                //UART1 switch to, 0x00: P3.0 P3.1, 0x40: P3.6 P3.7, 0x80: P1.6 P1.7 (必须使用内部时钟)
  851. //        PCON2 |=  (1<<4);        //内部短路RXD与TXD, 做中继, ENABLE,DISABLE

  853.         B_TX1_Busy = 0;
  854.         TX1_Read   = 0;
  855.         TX1_Write  = 0;
  856.         UART1_cmd  = 0;
  857.         TX1_cnt    = 0;
  858. }


  861. //========================================================================
  862. // 函数: void UART1_int (void) interrupt UART1_VECTOR
  863. // 描述: UART1中断函数。
  864. // 参数: nine.
  865. // 返回: none.
  866. // 版本: VER1.0
  867. // 日期: 2014-11-28
  868. // 备注:
  869. //========================================================================
  870. void UART1_int (void) interrupt 4
  871. {
  872.         if(RI)
  873.         {
  874.                 RI = 0;
  875.                 UART1_cmd = SBUF;
  876.         }

  878.         if(TI)
  879.         {
  880.                 TI = 0;
  881.                 B_TX1_Busy = 0;
  882.         }
  883. }



  887. void        PCA_config(void)
  888. {
  889.         PPM1_Rise_TimeOut = 0;
  890.         PPM2_Rise_TimeOut = 0;
  891.         PPM3_Rise_TimeOut = 0;
  892.         PPM4_Rise_TimeOut = 0;

  894.         CR = 0;
  895.         CH = 0;
  896.         CL = 0;
  897.         AUXR1 = (AUXR1 & ~(3<<4)) | PCA_P12_P17_P16_P15_P14;        //切换IO口
  898.         CMOD  = (CMOD  & ~(7<<1)) | PCA_Clock_12T;                                //选择时钟源  STC8F8K D版本
  899. //        CMOD  = (CMOD  & ~1) | 1;                                                                //ECF
  900.         PPCA = 1;        //高优先级中断

  902.         CCAPM0     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
  903.         PCA_PWM0   = PCA_PWM_8bit;        //PWM宽度
  904. //        CCAP0L = (u8)CCAP0_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
  905. //        CCAP0H = (u8)(CCAP0_tmp >> 8);        //后写CCAPnH

  907.         CCAPM1     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
  908.         PCA_PWM1   = PCA_PWM_8bit;        //PWM宽度
  909. //        CCAP1L = (u8)CCAP1_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
  910. //        CCAP1H = (u8)(CCAP1_tmp >> 8);        //后写CCAPnH

  912.         CCAPM2     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
  913.         PCA_PWM2   = PCA_PWM_8bit;        //PWM宽度
  914. //        CCAP2L = (u8)CCAP2_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
  915. //        CCAP2H = (u8)(CCAP2_tmp >> 8);        //后写CCAPnH

  917.         CCAPM3     = PCA_Mode_Capture | PCA_Rise_Active | PCA_Fall_Active | ENABLE;        //工作模式, 中断模式
  918.         PCA_PWM3   = PCA_PWM_8bit;        //PWM宽度
  919. //        CCAP3L = (u8)CCAP3_tmp;                        //将影射寄存器写入捕获寄存器，先写CCAPnL
  920. //        CCAP3H = (u8)(CCAP3_tmp >> 8);        //后写CCAPnH

  922.         CR = 1;
  923. }


  926. //========================================================================
  927. // 函数: void        PCA_Handler (void) interrupt PCA_VECTOR
  928. // 描述: PCA中断处理程序.
  929. // 参数: None
  930. // 返回: none.
  931. // 版本: V1.0, 2012-11-22
  932. //========================================================================
  933. void        PCA_Handler (void) interrupt PCA_VECTOR
  934. {
  935.         if(CCF0)                //PCA模块0中断
  936.         {
  937.                 CCF0 = 0;                //清PCA模块0中断标志
  938.                 if(P17)        //上升沿
  939.                 {
  940.                         CCAP0_RiseTime = ((u16)CCAP0H << 8) + CCAP0L;        //读CCAP0
  941.                         PPM1_Rise_TimeOut = 1;        //收到上升沿, 高电平限时
  942.                 }
  943.                 else        //下降沿
  944.                 {
  945.                         CCAP_FallTime = ((u16)CCAP0H << 8) + CCAP0L;        //读CCAP0
  946.                         if((PPM1_Rise_TimeOut != 0) && (PPM1_Rise_TimeOut < 3))        //收到过上升沿, 高电平也没有溢出
  947.                         {
  948.                                 CCAP_FallTime = (CCAP_FallTime - CCAP0_RiseTime) >> 1;        //为了好处理, 转成单位为us
  949.                                 if((CCAP_FallTime >= 800) && (CCAP_FallTime <= 2500))
  950.                                 {
  951.                                         if(++PPM1_RxCnt >= 5)        PPM1_RxCnt = 5;                //连续接收到5个脉冲
  952.                                         if(PPM1_RxCnt == 5)
  953.                                         {
  954.                                                 if(!B_PPM1_OK)
  955.                                                 {
  956.                                                         PPM1_Cap = CCAP_FallTime;
  957.                                                         B_PPM1_OK = 1;                //标志收到一个脉冲
  958.                                                         PPM1_Rx_TimerOut = 12;        //限时收不到脉冲
  959.                                                 }
  960.                                         }
  961.                                 }
  962. ……………………

  964. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码




所有资料51hei提供下载:
四轴飞控-STC8A8K64S4A12-LQFP44-PPM-V10.rar (3.86 MB, 下载次数: 433)



单片机, 四轴飞行器资料, 程序示例
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏32 分享淘帖 顶顶8 踩踩

相关帖子
回复

使用道具 举报

来自 33#
ID:925561 发表于 2021-6-11 11:29 | 只看该作者
分享一下调试经验
1.起飞后会飞斜：在水平的地板上将四轴放平，开启遥控，油门打到最低，串口以文本输入a，开始串口打印X，Y的角度，大概是+-2左右，将这个数记下来，然后在程序这里加补偿（红字的部分），然后重新编译后下载程序，然后在开启串口打印，这时输出一般都在0-0.1这儿稳定了，起飞后，无风的情况下不会乱飞。
        AngleX = asin(2*(q0*q2 - q1*q3 )) * 57.2957795f+1.9; // 俯仰   换算成度
        AngleY = asin(2*(q0*q1 + q2*q3 )) * 57.2957795f+0.8; // 横滚

2.遥控器通道正反要按资料上的图片来拨，资料要求美国手，我买的日本手，实则都能用。用日本手要改接收机和单片机线的位置，用万用表对照程序注释一看便知。
3.这个程序配合MC6遥控器十分好用方便，可是把程序改成串口无线控制会发生一些问题，感觉是串口接受数据多，中断频率较高，而PWM中断等级较低，老是打断PWM中断，然后现象是某个固定的脚PWM输出会比其他高很多，串口改一下波特率或者发射加个延时，这个现象又转移到其他PWM引脚，目前还在优化中，，，，，，
4.前人栽树后人乘凉，由心的感谢程序作者无私的分享。


评分

参与人数 1黑币 +20 收起 理由
admin + 20 回帖助人的奖励！

查看全部评分

回复

使用道具 举报

32#
ID:1103557 发表于 2024-3-11 14:13 | 只看该作者

谢谢分享，有时间做一个玩
回复

使用道具 举报

31#
ID:704640 发表于 2022-5-25 08:23 | 只看该作者
哈哈，刚在官网上看到，然后在家里又看到，更想做一台来玩了
回复

使用道具 举报

30#
ID:925561 发表于 2022-1-1 10:49 | 只看该作者
putiz 发表于 2021-12-26 18:05
大佬，可以加下好友交流一下吗
2410025784

你好，已加未见回复，因为不清楚你那边啥情况，就这边回复一下我大概的调试过程吧
1.程序里面有个电池电压检测（ADC部分），要保证这边没问题，检测电压低是启动不了的，我这边是直接把该端口和VCC接一起的。（因为我用的隔离电源，不能和锂电池共地）
2.然后你的电路是否用的资料提供的电路？还是略有修改？PCA输入假如用光耦隔离的话，受光侧上拉电阻取值会影响波形的好坏，我这用的521光耦，原本用的103电阻，发现也是无法启动，换成102就可以了，实际上要更小才合适。
3.先看看程序有没有进入循环，还是卡在油门最小等待这一步，我在这儿加上串口打印配合调试
  PrintString1("注意准备等待油门最小了\r\n");
        while(cnt_start < 25)        //等待油门最小        20ms * 25 = 500ms
        {
                if(B_PPM3_OK)        //油门
                {
                        B_PPM3_OK = 0;
                        if(PPM3_Cap <= 1200)        cnt_start++;
                }
                delay_ms(1);
        }
        PrintString1("油门最小测试通过\r\n");
当油门通过后就是主要的工作啦，用串口不停地查看接收的数据是否与遥控一起在变化，
void        Return_Message(void)
{
        TX1_write2buff('V');
        TX1_write2buff('=');
        TX1_write2buff(Battery/1000 + '0');
        TX1_write2buff((Battery%1000)/100 + '0');
        TX1_write2buff('.');
        TX1_write2buff((Battery%100)/10 + '0');
        TX1_write2buff(Battery%10 + '0');
        TX1_write2buff(' ');
        TX1_write2buff(' ');
        //从这儿开始
        PrintString1("PPM1=");
        TX1_int_value((int)(PPM1 * 10));
        PrintString1("PPM2=");
        TX1_int_value((int)(PPM2 * 10));
        PrintString1("PPM3=");
        TX1_int_value((int)(PPM3 * 10));
        PrintString1("PPM4=");
        TX1_int_value((int)(PPM4 * 10));
/*     PrintString1("AngleX=");
        TX1_int_value((int)(AngleX * 10));
        PrintString1("AngleY=");
        TX1_int_value((int)(AngleY * 10));
        PrintString1("AngleZ=");
        TX1_int_value((int)(Angle_gz * 10));
*/
        PrintString1("a_x=");
        TX1_int_value(a_x * 10);
        PrintString1("a_y=");
        TX1_int_value(a_y * 10);
        PrintString1("g_z=");
        TX1_int_value(g_z * 10);
        TX1_cnt = 0;
        TX1_write2buff(0x0d);
        TX1_write2buff(0x0a);
}
这样就可以很直观的看出来遥控的接收情况了，即使线接反了，也可以看出实时的数据变化，找出对应的摇杆，因为这样很方便，我把买的日本手该成了中国手。。。。。
4.然后晶振频率和EEPROM大小不能错，遥控器通道正反要按资料图片来拨，其他没什么了，串口这儿就可以看出很多情况了，最后LQFP44我用的G版本
回复

使用道具 举报

29#
ID:975881 发表于 2021-12-26 18:05 | 只看该作者
CHNO 发表于 2021-6-5 17:11
从宏晶官网下载，然后打过板子，四轴可以平稳飞行，就是油门开大后不能稳定的停在原地，会偏，正在查找原因 ...

大佬，可以加下好友交流一下吗
2410025784
回复

使用道具 举报

28#
ID:975881 发表于 2021-12-26 17:41 | 只看该作者
CHNO 发表于 2021-6-11 11:29
分享一下调试经验
1.起飞后会飞斜：在水平的地板上将四轴放平，开启遥控，油门打到最低，串口以文本输入a ...

大佬，可以加下联系方式吗？
自己遇到了一些问题，想向您请教一下
回复

使用道具 举报

27#
ID:975881 发表于 2021-12-26 17:38 | 只看该作者
大家好，我看了几天的代码了，也尝试打印了一些数据来分析。
现状是刚开始启动后，电机不会启动，不会低速旋转。即使偶尔有几个会旋转，也不会受遥控器的控制。
经过打印一些信息发现：
  1.         SW2_tmp = P_SW2;        //保存SW2设置
  2.         EAXSFR();        //访问XFR
  3.         PWM0T2 = (u16)(PWM0 * 2);
  4.         PWM1T2 = (u16)(PWM1 * 2);
  5.         PWM2T2 = (u16)(PWM2 * 2);       
  6.         PWM3T2 = (u16)(PWM3 * 2);        //进行输出脉冲信号更新
  7.         P_SW2  = SW2_tmp;        //恢复SW2设置
复制代码

这样的代码，这些值不会发生变化和更新
  1.         PWM0T1 = 4000;//第一个翻转点 4000
  2.         PWM1T1 = 4000;
  3.         PWM2T1 = 4000;
  4.         PWM3T1 = 4000;
  5. //        PWM4T1 = 4000;
  6. //        PWM5T1 = 4000;
  7. //        PWM6T1 = 4000;
  8. //        PWM7T1 = 4000;

  10.         PWM0T2 = 2000;  //第二个翻转点 2000
  11.         PWM1T2 = 2000;
  12.         PWM2T2 = 2000;
  13.         PWM3T2 = 2000;
  14. //        PWM4T2 = 2000;
  15. //        PWM5T2 = 2000;
  16. //        PWM6T2 = 2000;
  17. //        PWM7T2 = 2000;
复制代码

在这样的初始化后打印出来的数据却是0 4000 8000 12337（PWM0T1 PWM1T1 PWM2T1 PWM3T1）
和初始化结果也是不一样的。
为什么我找这样的信息呢，因为我感觉首先遥控器不能控制波形的输出，刚开始输出的波形也不能让电动机启动。
因此我想试着找找这个原因，但是这个值不知道为什么不会发生变化
请问大佬可以回复下吗？真的不知道怎么办
回复

使用道具 举报

26#
ID:925561 发表于 2021-6-11 10:32 | 只看该作者
lzl12399 发表于 2021-6-10 11:45
板子打样，自己画得还是有现成得，小弟也想玩玩

我是自己画的
回复

使用道具 举报

25#
ID:97350 发表于 2021-6-10 11:45 | 只看该作者
CHNO 发表于 2021-6-5 17:11
从宏晶官网下载，然后打过板子，四轴可以平稳飞行，就是油门开大后不能稳定的停在原地，会偏，正在查找原因 ...

板子打样，自己画得还是有现成得，小弟也想玩玩
回复

使用道具 举报

24#
ID:925561 发表于 2021-6-5 17:11 来自手机 | 只看该作者
从宏晶官网下载，然后打过板子，四轴可以平稳飞行，就是油门开大后不能稳定的停在原地，会偏，正在查找原因中，
回复

使用道具 举报

23#
ID:63317 发表于 2021-5-23 19:48 | 只看该作者
学习无人机，谢谢你的分享
回复

使用道具 举报

22#
ID:915207 发表于 2021-5-14 22:27 | 只看该作者
感谢楼主分享，小白一名前来膜拜学习
回复

使用道具 举报

21#
ID:906597 发表于 2021-4-30 22:28 | 只看该作者
这个厉害啊，想学但是没怎么看懂哈哈
回复

使用道具 举报

20#
ID:385637 发表于 2021-4-22 08:05 | 只看该作者
关键还是软件算法
回复

使用道具 举报

19#
ID:628703 发表于 2020-3-18 15:11 | 只看该作者
谢谢分享
回复

使用道具 举报

18#
ID:517004 发表于 2020-2-10 17:26 | 只看该作者
请问您有飞行的视频么
回复

使用道具 举报

17#
ID:11546 发表于 2020-2-5 11:30 | 只看该作者
感谢分享，想问下，如果机身水平不变四个螺旋桨前后左右偏转改变飞行方向是否可行？机身姿态与控制方向非耦合状态，同时机身可在空中改变角度悬停。
回复

使用道具 举报

16#
ID:266164 发表于 2020-1-16 16:55 | 只看该作者
正在学习无人机，谢谢你的分享
回复

使用道具 举报

15#
ID:490427 发表于 2019-11-2 18:18 | 只看该作者
下载下来好好学习一下代码
回复

使用道具 举报

14#
ID:186764 发表于 2019-9-29 23:08 | 只看该作者
下载下来学习学习
回复

使用道具 举报

13#
ID:282431 发表于 2019-7-28 17:02 | 只看该作者
谢谢分享，学着做一个四轴飞控
回复

使用道具 举报

12#
ID:591598 发表于 2019-7-28 14:28 | 只看该作者
感谢楼主分享
回复

使用道具 举报

11#
ID:272906 发表于 2019-6-9 10:08 | 只看该作者
谢谢楼主分享！
回复

使用道具 举报

10#
ID:119159 发表于 2019-5-7 11:22 | 只看该作者
感谢~~~
回复

使用道具 举报

9#
ID:508475 发表于 2019-4-16 09:24 | 只看该作者
楼主，可否加个QQ，跟你学习下，我的QQ 75750462
回复

使用道具 举报

8#
ID:403129 发表于 2018-9-27 16:05 | 只看该作者
谢谢你的分享
回复

使用道具 举报

7#
ID:291952 发表于 2018-9-25 09:12 | 只看该作者
感谢分享，对于学习很有帮助
回复

使用道具 举报

6#
ID:394146 发表于 2018-9-5 16:57 | 只看该作者
关于玩四轴，我认为深入的玩法就是研究软硬件，特别是软件，如果只是组装比人的成品，没啥成就感；本着此想法所以下载学习此算法！
回复

使用道具 举报

5#
ID:380499 发表于 2018-7-29 16:26 | 只看该作者
为什么怎么也下不完呢，是有问题？
回复

使用道具 举报

地板
ID:149866 发表于 2018-5-6 22:02 | 只看该作者
感谢分享,支持原创,
回复

使用道具 举报

板凳
ID:155817 发表于 2018-1-5 14:40 | 只看该作者
感谢分享，有空学习下
回复

使用道具 举报

沙发
ID:243748 发表于 2017-12-4 14:52 来自手机 | 只看该作者
谢谢分享，有时间做一个玩下
回复

使用道具 举报

楼主
ID:61218 发表于 2017-11-28 11:24 | 只看该作者
下來試試...
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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