自编四轴飞控代码——开源共勉

项目承接

废话不说直接上代码，代码还在持续更新中，四轴DIY交流群：651925582
码云地址：https://gitee.com/s8888/four_axis_diy_code
当前飞机飞行调试状态视频
https://pan.baidu.com/s/186_9qj5sfNYck61N9ZJl_Q


遥控端

1. 
   
2. /**x轴，y轴，Speed模拟量读取变量定义 start***/
   
3. int x=0;
   
4. int y=0;
   
5. int s=0;
   
6. 
   
7. int x1=0;
   
8. int y1=0;
   
9. int s1=0;
   
10. int s2=0;
    
11. int ss=0;
    
12. /**x轴，y轴，Speed模拟量读取变量定义  end***/
    
13. 
    
14. int i=0;  //飞控端发回状态值变量
    
15. 
    
16. int op=0;//状态开关值
    
17. 
    
18. void setup() {
    
19.     /**串口初始化 start***/
    
20.    Serial2.begin(115200);
    
21.    Serial.begin(115200);
    
22.    /**串口初始化 end***/
    
23.    
    
24. pinMode(11,OUTPUT);       //蜂鸣器引脚初始化
    
25. pinMode(3,INPUT_PULLUP);  //遥控启动引脚初始化
    
26. 
    
27. /**遥控开机提示 start***/
    
28. for(int d=2;d>0;d--)
    
29. {
    
30. tone(11,2);
    
31.   delay(d*100);
    
32.   noTone(11);
    
33.   delay(100);
    
34. }
    
35. /**遥控开机提示 end***/
    
36. 
    
37. }
    
38. 
    
39. void loop() {
    
40.   /**遥控启动 start***/
    
41. if((digitalRead(3)==0)&&(op==0))
    
42. {
    
43. op=1;
    
44. }
    
45. /**遥控启动 end***/
    
46. 
    
47. /**拨码开关遥控停止 start***/
    
48. if((digitalRead(3)==1)&&(op==1))
    
49. {for(int d=2;d>0;d--)
    
50. {
    
51.   tone(11,2);
    
52.   delay(d*200);
    
53.   noTone(11);
    
54.   delay(100);
    
55. }
    
56. op=0;
    
57.    Serial2.print("$");//36//停止飞行指令
    
58.    Serial2.print("!");//33 用于将每次传入的数值读取到，防止缓冲导致读取的不及时！
    
59. 
    
60. }
    
61. /**拨码开关 遥控停止 end***/
    
62. 
    
63. /**遥控端接收 start***/
    
64.   if( Serial2.available()>1)
    
65. { i=Serial2.read();
    
66. // Serial.println(i);
    
67. }
    
68. /**遥控端接收 end***/
    
69. 
    
70.   /**飞控低压停止飞行 start***/
    
71.   if(i==49)
    
72. {
    
73.   if(op==1)
    
74.   {
    
75.   tone(11,5);
    
76.   delay(100);
    
77.   noTone(11);
    
78.   delay(100);
    
79.   }
    
80.   op==0;      //遥控停止状态值
    
81.   i=0;        //遥控接收端数值归零
    
82. }
    
83.   /**飞控低压停止飞行 end***/
    
84. 
    
85. 
    
86.    /**遥控模拟量读取 start***/
    
87.        x=analogRead(A0);
    
88.        y=analogRead(A1);
    
89.        s=analogRead(A2)/7;
    
90.       /**遥控模拟量读取 end***/
    
91. 
    
92.       /**x轴，y轴，Speed 遥控模拟量输出值设置 start***/
    
93.   if(x>950)
    
94.     x=1;
    
95.   else if(x<50)
    
96.    x=2;
    
97.    else
    
98.    x=0;
    
99.   if(y>950)  
    
100.     y=1;
     
101.   else if(y<50)
     
102.     y=2;
     
103. else
     
104. y=0;
     
105. if(s<15)
     
106. s=0;
     
107. if(s>120)
     
108. s=120;
     
109.     /**x轴，y轴，Speed 遥控模拟量输出值设置 end***/
     
110. 
     
111.    /**遥控发送 start***/
     
112. if((s!=s2)&&(op==1))
     
113. {  
     
114. pt();   //调用发送函数
     
115. }
     
116.   /**遥控发送 end***/
     
117. }
     
118.   /**遥控发送函数 start***/
     
119. void pt()
     
120. {
     
121.    /**防止速度间差值过大引起剧烈反应 start***/
     
122.   ss=s1-s;
     
123. if(ss<-25)
     
124. s1=s-25;
     
125. else if(ss>25)
     
126. s1=s1-25;
     
127. else
     
128.   s1=s;
     
129.    /**防止速度间差值过大引起剧烈反应 end***/
     
130.   
     
131.   x1=x;
     
132.   y1=y;
     
133.   
     
134.   s2=s;
     
135.    if(s!=0)
     
136. {
     
137. /**遥控端发送格式 start***/
     
138.      Serial2.print("&");//38
     
139.      Serial2.print(x1);
     
140.      Serial2.print("!");//33
     
141.      Serial2.print(y1);
     
142.      Serial2.print("!");
     
143.      Serial2.print(s1);
     
144.      Serial2.print("!");
     
145.      Serial2.print("%");//37
     
146.      Serial2.print("&");//38 用于将每次传入的数值读取到，防止缓冲导致读取的不及时！
     
147.       /**遥控端发送格式 end***/
     
148. }
     
149.   /**遥控端停止飞行指令 start***/
     
150.    else
     
151.    {
     
152.   if(ss>20)
     
153.   {
     
154.       s1=20;
     
155.      for(s1;s1>0;s1=s1-5)
     
156.       {
     
157.     Serial2.print("&");//38
     
158.     Serial2.print(x1);
     
159.     Serial2.print("!");//33
     
160.     Serial2.print(y1);
     
161.     Serial2.print("!");
     
162.     Serial2.print(s1);
     
163.     Serial2.print("!");
     
164.     Serial2.print("%");//37
     
165.     Serial2.print("&");//38 用于将每次传入的数值读取到，防止缓冲导致读取的不及时！
     
166.      delay(10);
     
167.      }
     
168.   }
     
169.      Serial2.print("&");//38
     
170.      Serial2.print(x1);
     
171.      Serial2.print("!");//33
     
172.      Serial2.print(y1);
     
173.      Serial2.print("!");
     
174.      Serial2.print(0);
     
175.      Serial2.print("!");
     
176.      Serial2.print("%");//37
     
177.      Serial2.print("&");//38 用于将每次传入的数值读取到，防止缓冲导致读取的不及时！
     
178.      delay(10);
     
179. }
     
180.   /**遥控端停止飞行指令 end***/
     
181. 
     
182. }
     
183. /**遥控发送函数 end***/
     

复制代码

飞控端

1. //MPU6050相关设置
   
2. #include <Kalman.h>
   
3. #include <Wire.h>
   
4. #include <Math.h>
   
5. float fRad2Deg = 57.295779513f; //将弧度转为角度的乘数
   
6. const int MPU = 0x68; //MPU-6050的I2C地址
   
7. const int nValCnt = 7; //一次读取寄存器的数量
   
8. const int nCalibTimes = 1000; //校准时读数的次数
   
9. int calibData[nValCnt]; //校准数据
   
10.    float realVals[7];
    
11. unsigned long nCurTime;
    
12. unsigned long nLastTime = 0; //上一次读数的时间
    
13. float fLastRoll = 0.0f; //上一次滤波得到的Roll角
    
14. float fLastPitch = 0.0f; //上一次滤波得到的Pitch角
    
15. Kalman kalmanRoll; //Roll角滤波器
    
16. Kalman kalmanPitch; //Pitch角滤波器
    
17. 
    
18. /**控制接收端变量设置start***/
    
19. int i=0;
    
20. int iii=0;
    
21. int ii[3];
    
22. int ss[4];
    
23. int s=0;//speed
    
24. int a=0;// RX init
    
25. int h=0;
    
26. int p=0;
    
27. int staus=0;// 当前状态，为1时可飞
    
28. int pp=0;//限飞电压
    
29. int limit=90;//pwm最大输出（0-255）
    
30. /**控制接收端变量设置end***/
    
31. 
    
32. 
    
33. /**pid变量设置start***/
    
34. unsigned long t=0;
    
35. float top;
    
36. float left;
    
37.   float topRate ;
    
38.   float leftRate ;
    
39.     float measured ;
    
40. int sampletime=4;//ms 控制间隔时间
    
41. 
    
42. //外环
    
43. double kp=0.001;//0.45
    
44. double ki=0.0035;
    
45. double kd=0.0015;//0.0023
    
46. //内环
    
47. double knp=0.025;//0.45
    
48. double kni=0.0035;
    
49. double knd=0.0055;//0.0023
    
50. int out1,out2,out3,out4;
    
51. float desired=0.5;//获取期望角度
    
52. int topp;//是否进行pid调整的中间变量
    
53. int leftp;//是否进行pid调整的中间变量
    
54. 
    
55. double error; //偏差：期望-测量值
    
56. double integ; //偏差积分
    
57. double iLimit; //作积分限制
    
58. double deriv; //微分应该可用陀螺仪角速度代替
    
59. 
    
60. double prerror;////前一次偏差
    
61. double prlerror;////前一次偏差
    
62. 
    
63. /**pid变量设置end***/
    
64. 
    
65. /**电机引脚变量设置start***/
    
66. int pin1=4;
    
67. int pin2=5;
    
68. int pin3=10;
    
69. int pin4=11;
    
70. /**电机引脚变量设置end***/
    
71. 
    
72. /**PID调整函数***/
    
73. void pid()
    
74. {
    
75.   h=s;                                 //遥控传进来的speed值赋值给h变量
    
76.   int ol=(nCurTime-t)/1000;            //获取间隔时间   单位ms  
    
77.   if(ol>sampletime){                   //此处判断是否进行调节
    
78.     t=nCurTime;
    
79.     measured=top;                      //获取roll角度
    
80.     /**PID外环roll方向  start***/
    
81.     error = desired - measured;        //偏差：期望-测量值
    
82.    float pout=kp*error;                //pid外环 P项比例输出
    
83.    float iout=ki*error*sampletime;     //pid外环 i项积分输出
    
84.    float rout=pout+iout;               //pid外环 外环输出
    
85.      /**PID外环roll方向 end***/
    
86.      
    
87.       /**PID内环roll方向 start***/
    
88.      error =rout-topRate;           //角速度偏差：外环积分值-陀螺仪roll角速度测量值直接用的
    
89.      pout=knp*error;                //pid内环 P项比例输出
    
90.      iout=kni*error*sampletime;     //pid内环 I项积分输出
    
91.      float dout=knd*(error-prerror);//pid内环 D项微分输出
    
92.      prerror=error;                 //保存本次误差
    
93.     float rrout=pout+iout+dout;     //pid内环 输出
    
94.      /**PID内环roll方向 end***/
    
95. 
    
96.       /**PID外环pitch方向  start***/
    
97.     measured=left;//pitch              //获取pitch角度
    
98.   
    
99.     error = desired - measured;        //偏差：期望-测量值
    
100.     pout=kp*error;                     //pid外环 P项比例输出
     
101.     iout=ki*error*sampletime;          //pid外环 I项积分输出
     
102.     rout=pout+iout;                    //pid外环 D项微分输出
     
103.       /**PID外环pitch方向 end***/
     
104. 
     
105.        /**PID内环pitch方向 start***/
     
106.      error =rout-leftRate;             //角速度偏差：外环积分值-陀螺仪pitch角速度测量值直接用的
     
107.      pout=knp*error;                   //pid内环 P项比例输出
     
108.   
     
109.      iout=kni*error*sampletime;        //pid内环 D项微分输出
     
110.      dout=knd*(error-prlerror);        //pid内环 D项微分输出
     
111.      prlerror=error;                   //保存本次误差
     
112.      float  piout=pout+iout+dout;      //pid内环 输出
     
113.       /**PID内环pitch方向 end***/
     
114. 
     
115.         /**PWM输出 start***/
     
116. out1=s-piout+rrout;
     
117. out3=s+piout-rrout;
     
118. out2=s-piout-rrout;
     
119. out4=s+piout+rrout;
     
120.         /**PWM输出 end***/
     
121. 
     
122.    /**PWM输出限幅 start***/
     
123. if(out1>limit)
     
124. out1=limit;
     
125. if(out2>limit)
     
126. out2=limit;
     
127. if(out3>limit)
     
128. out3=limit;
     
129. if(out4>limit)
     
130. out4=limit;
     
131. /**PWM输出限幅 end***/
     
132. 
     
133.   /**PWM停止输出判断 start***/
     
134. if(out3<0)
     
135. out3=0;
     
136. if(out2<0)
     
137. out2=0;
     
138. if(out1<0)
     
139. out1=0;
     
140. if(out4<0)
     
141. out4=0;
     
142. if(s==0)
     
143. {
     
144.   out1=0;
     
145.   out2=0;
     
146.   out3=0;
     
147.   out4=0;
     
148. }
     
149. /**PWM停止输出判断 end***/
     
150. 
     
151.   /**电路电源判断 start***/
     
152. //p=analogRead(A6);
     
153. //Serial.print("dianyuan:");
     
154. //Serial.println(p);
     
155. /**电路电源判断 end***/
     
156. 
     
157. /**PWM输出串口检测 start***/
     
158. //Serial.print("out1:");
     
159. //Serial.println(out1);
     
160. //Serial.print("out3:");
     
161. //Serial.println(out3);
     
162. //Serial.print("out2:");
     
163. //Serial.println(out2);
     
164. //Serial.print("out4:");
     
165. //Serial.println(out4);
     
166. /**PWM输出串口检测 end***/
     
167. 
     
168. /**PWM输出 start***/
     
169. analogWrite(pin1,out1);
     
170.   analogWrite(pin2,out2);
     
171.   analogWrite(pin3,out3);
     
172.   analogWrite(pin4,out4);
     
173.    /**PWM输出 end***/
     
174.   }
     
175. }
     
176. 
     
177. 
     
178. 
     
179. void setup() {
     
180.    /**飞控开机提示 start***/
     
181.   pinMode(25,OUTPUT);//蜂鸣器引脚
     
182. for(int d=1;d<4;d++)
     
183. {
     
184. tone(25, 3);
     
185.   delay(100);
     
186.   noTone(25);
     
187.   delay(100);
     
188. }
     
189.    /**飞控开机提示end***/
     
190. 
     
191.     /**MPU6050初始化 start***/
     
192.    Wire.begin(); //初始化Wire库
     
193.    WriteMPUReg(0x6B, 0); //启动MPU6050设备
     
194.    Calibration(); //执行校准
     
195.    nLastTime = micros(); //记录当前时间
     
196.     /**MPU6050初始化 end***/
     
197. 
     
198.     /**串口初始化 start***/
     
199.    Serial2.begin(115200);
     
200.    Serial.begin(115200);
     
201.    /**串口初始化 end***/
     
202. 
     
203.     /**电机输出口初始化 start***/
     
204.    pinMode(pin1,OUTPUT);
     
205.    pinMode(pin2,OUTPUT);
     
206.    pinMode(pin3,OUTPUT);
     
207.    pinMode(pin4,OUTPUT);
     
208.      /**电机输出口初始化 end***/
     
209. 
     
210. 
     
211. }
     
212. 
     
213. void loop() {
     
214. 
     
215. /**MPU6050测量结果输出 start***/
     
216.   int readouts[nValCnt];
     
217.   ReadAccGyr(readouts); //读出测量值
     
218.   Rectify(readouts, realVals); //根据校准的偏移量进行纠正
     
219.   //计算加速度向量的模长，均以g为单位
     
220.   float fNorm = sqrt(realVals[0] * realVals[0] + realVals[1] * realVals[1] + realVals[2] * realVals[2]);
     
221.   float fRoll = GetRoll(realVals, fNorm); //计算Roll角
     
222.   if (realVals[1] > 0) {
     
223.     fRoll = -fRoll;
     
224.   }
     
225.   float fPitch = GetPitch(realVals, fNorm); //计算Pitch角
     
226.   if (realVals[0] < 0) {
     
227.     fPitch = -fPitch;
     
228.   }
     
229.   //计算两次测量的时间间隔dt，以秒为单位
     
230.    nCurTime = micros();
     
231.   float dt = (double)(nCurTime - nLastTime) / 1000000.0;
     
232.   //对Roll角和Pitch角进行卡尔曼滤波
     
233.   float fNewRoll = kalmanRoll.getAngle(fRoll, realVals[4], dt);
     
234.   float fNewPitch = kalmanPitch.getAngle(fPitch, realVals[5], dt);
     
235.   //跟据滤波值计算角度速
     
236.   float fRollRate = (fNewRoll - fLastRoll) / dt;
     
237.   float fPitchRate = (fNewPitch - fLastPitch) / dt;
     
238.    //更新本次测的时间
     
239.   nLastTime = nCurTime;
     
240. //更新Roll角和Pitch角
     
241.   fLastRoll = fNewRoll;//top
     
242.   fLastPitch = fNewPitch;//left
     
243.   /**MPU6050测量结果输出 end***/
     
244.   
     
245.    
     
246.      /**pid 涉及相关变量初始化 start***/
     
247.     topRate=fRollRate;
     
248.     leftRate= fPitchRate;
     
249.     top=fNewRoll;
     
250.     left=fNewPitch;
     
251.      /**pid 涉及相关变量初始化 end***/
     
252. 
     
253.       /**pid 本次是否进行调整判断 start***/
     
254.     if(top<-1)
     
255.   topp=-top;
     
256.     else
     
257.       topp=top;
     
258.          if(left<-1)
     
259. leftp=-left;
     
260.     else
     
261.       leftp=left;
     
262. p=analogRead(A6);//电路电压测量
     
263. 
     
264.    if(((h!=s)||(topp>desired)||(leftp>desired))&&(staus==1)&&(p>pp))
     
265.   pid();
     
266.   /**pid 本次是否进行调整判断 end***/
     
267. 
     
268. 
     
269.        /**遥控数据接收 start***/
     
270.   if( Serial2.available()>1)
     
271. { i=Serial2.read();
     
272. if(i>0)
     
273. math();   //遥控数据处理函数调用
     
274. }
     
275.    /**遥控数据接收 end***/
     
276. 
     
277. 
     
278. /**电源判断，低压停止飞行 start***/
     
279. //   if((p<pp)&&(s>0)&&(staus==1))
     
280. // {
     
281. // power();
     
282. //
     
283. // }
     
284.   /**电源判断，低压停止飞行 end***/
     
285. 
     
286. }
     
287. 
     
288. 
     
289. 
     
290. //向MPU6050写入一个字节的数据
     
291. //指定寄存器地址与一个字节的值
     
292. void WriteMPUReg(int nReg, unsigned char nVal) {
     
293.   Wire.beginTransmission(MPU);
     
294.   Wire.write(nReg);
     
295.   Wire.write(nVal);
     
296.   Wire.endTransmission(true);
     
297. }
     
298. 
     
299. //从MPU6050读出一个字节的数据
     
300. //指定寄存器地址，返回读出的值
     
301. unsigned char ReadMPUReg(int nReg) {
     
302.   Wire.beginTransmission(MPU);
     
303.   Wire.write(nReg);
     
304.   Wire.requestFrom(MPU, 1, true);
     
305.   Wire.endTransmission(true);
     
306.   return Wire.read();
     
307. }
     
308. 
     
309. //从MPU6050读出加速度计三个分量、温度和三个角速度计
     
310. //保存在指定的数组中
     
311. void ReadAccGyr(int *pVals) {
     
312.   Wire.beginTransmission(MPU);
     
313.   Wire.write(0x3B);
     
314.   Wire.requestFrom(MPU, nValCnt * 2, true);
     
315.   Wire.endTransmission(true);
     
316.   for (long i = 0; i < nValCnt; ++i) {
     
317.     pVals[i] = Wire.read() << 8 | Wire.read();
     
318.   }
     
319. }
     
320. 
     
321. //对大量读数进行统计，校准平均偏移量
     
322. void Calibration()
     
323. {
     
324.   float valSums[7] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0};
     
325.   //先求和
     
326.   for (int i = 0; i < nCalibTimes; ++i) {
     
327.     int mpuVals[nValCnt];
     
328.     ReadAccGyr(mpuVals);
     
329.     for (int j = 0; j < nValCnt; ++j) {
     
330.       valSums[j] += mpuVals[j];
     
331.     }
     
332.   }
     
333.   //再求平均
     
334.   for (int i = 0; i < nValCnt; ++i) {
     
335.     calibData[i] = int(valSums[i] / nCalibTimes);
     
336.   }
     
337.   calibData[2] += 16384; //设芯片Z轴竖直向下，设定静态工作点。
     
338. }
     
339. 
     
340. //算得Roll角。算法见文档。
     
341. float GetRoll(float *pRealVals, float fNorm) {
     
342.   float fNormXZ = sqrt(pRealVals[0] * pRealVals[0] + pRealVals[2] * pRealVals[2]);
     
343.   float fCos = fNormXZ / fNorm;
     
344.   return acos(fCos) * fRad2Deg;
     
345. }
     
346. 
     
347. //算得Pitch角。算法见文档。
     
348. float GetPitch(float *pRealVals, float fNorm) {
     
349.   float fNormYZ = sqrt(pRealVals[1] * pRealVals[1] + pRealVals[2] * pRealVals[2]);
     
350.   float fCos = fNormYZ / fNorm;
     
351.   return acos(fCos) * fRad2Deg;
     
352. }
     
353. 
     
354. //对读数进行纠正，消除偏移，并转换为物理量。公式见文档。
     
355. void Rectify(int *pReadout, float *pRealVals) {
     
356.   for (int i = 0; i < 3; ++i) {
     
357.     pRealVals[i] = (float)(pReadout[i] - calibData[i]) / 16384.0f;
     
358.   }
     
359.   pRealVals[3] = pReadout[3] / 340.0f + 36.53;
     
360.   for (int i = 4; i < 7; ++i) {
     
361.     pRealVals[i] = (float)(pReadout[i] - calibData[i]) / 131.0f;
     
362.   }
     
363. }
     
364. 
     
365. 
     
366. //遥控数据处理函数
     
367. void math()
     
368. {
     
369.    /**停止飞行声音提醒 start***/
     
370.   if((i==36)&&(p>pp))
     
371.   {staus=0;    //是否可以飞行状态值
     
372.   
     
373.    stop_f();   //停止飞行函数
     
374.    for(int d=2;d>0;d--)
     
375. {
     
376. tone(25,3);
     
377.   delay(d*200);
     
378.   noTone(25);
     
379.   delay(100);
     
380. }
     
381.   }
     
382.   /**停止飞行声音提醒 end***/
     
383.   
     
384.    if(i==38)
     
385.   {
     
386.     a=1;
     
387.    
     
388.   }
     
389.   if(i==33)
     
390.   {
     
391. if(iii==1)
     
392. ss[a]=ii[0];
     
393. if(iii==2)
     
394. ss[a]=ii[0]*10+ii[1];
     
395. if(iii==3)
     
396. ss[a]=ii[0]*100+ii[1]*10+ii[2];
     
397. iii=0;
     
398. a=a+1;
     
399. 
     
400.   }
     
401.   if(i==37)
     
402.   {
     
403. //  x1=ss[1];  //x轴控制值
     
404. //  y1=ss[2];  //x轴控制值
     
405. 
     
406.   s=ss[3];     //Speed控制值
     
407. 
     
408.   
     
409.   //是否可以飞行状态值 设置
     
410. if((p>pp)&&(s>0))
     
411. staus=1;
     
412. 
     
413.    a=0;       //数据接收控制符
     
414.   }
     
415.   if(i>47)
     
416.   {
     
417.    iii=iii+1;
     
418.    if(iii==1)
     
419.    ii[0]=i-48;
     
420.     if(iii==2)
     
421.    ii[1]=i-48;
     
422.   if(iii==3)
     
423.    ii[2]=i-48;
     
424.       i=0;  
     
425.   }
     
426. }
     
427. /**遥控停止飞行函数 start***/
     
428. void stop_f()
     
429. {
     
430. Serial2.print(p);
     
431. if(s>10){
     
432. for(int sss=s;sss>0;sss--)
     
433.   {  
     
434.     analogWrite(pin1,sss);
     
435.     analogWrite(pin2,sss);
     
436.     analogWrite(pin3,sss);
     
437.     analogWrite(pin4,sss);
     
438. 
     
439.   delay(10);
     
440. 
     
441.   }
     
442.    analogWrite(pin1,0);
     
443.    analogWrite(pin2,0);
     
444.    analogWrite(pin3,0);
     
445.    analogWrite(pin4,0);
     
446. }
     
447. s=0;
     
448. staus=0;
     
449. }
     
450. /**遥控停止飞行函数 end***/
     
451. 
     
452.   /**低压停止飞行函数 start***/
     
453. void power()
     
454. {
     
455.   Serial2.print(1);//低压报警值，传至遥控端
     
456. if(s>0){
     
457. for(int sss=s;sss>0;sss--)
     
458.   {
     
459.    
     
460.     analogWrite(pin1,sss);
     
461.     analogWrite(pin2,sss);
     
462.     analogWrite(pin3,sss);
     
463.     analogWrite(pin4,sss);
     
464. 
     
465.   delay(10);
     
466. 
     
467.   }
     
468.     analogWrite(pin1,0);
     
469.     analogWrite(pin2,0);
     
470.     analogWrite(pin3,0);
     
471.     analogWrite(pin4,0);                                                                                                                                                                                                                                                                                                                                                                                                      
     
472.   
     
473. }
     
474.    s=0;
     
475. staus=0;
     
476. }
     
477.   /**低压停止飞行函数 end***/
     

复制代码

电路图正在整理ing~


当前飞机飞行调试状态视频
https://pan.baidu.com/s/186_9qj5sfNYck61N9ZJl_Q

HX711学习者

赞

wing

非常不错的项目，
但是为什么用水平拉线来固定机体呢？是不是出现了比较麻烦的自旋现象？

wing

我很想star你的项目，不过没有码云账号，然而用github帐号关联马云原来很麻烦，话说我也要告别github，所以算了。
☆☆只能在这里给你了

项目承接

wing 发表于 2018-8-26 10:15
非常不错的项目，
但是为什么用水平拉线来固定机体呢？是不是出现了比较麻烦的自旋现象？

恩，目前有点自旋问题，同时平衡也有问题

项目承接

wing 发表于 2018-8-26 10:22
我很想star你的项目，不过没有码云账号，然而用github帐号关联马云原来很麻烦，话说我也要告别github，所以 ...

哈哈，github后期会补上，最近家里网络不太好

项目承接

HX711学习者 发表于 2018-8-23 15:44
赞

昂，

PINKWALKMAN

建议参照APM的改，完全自己写走的弯路太多了。