STM32两轮自平衡小车资料

stm32单片机做的两轮自平衡小车资料，带完整的源码。还附带很多pdf教程 如pid控制和滤波的资料.

全部资料打包下载：
两轮自平衡小车资料.rar (8.27 MB, 下载次数: 195)

2017-3-18 11:47 上传

点击文件名下载附件
源代码




主程序预览：

1. #include "sys.h"
   
2. #include "usart.h"               
   
3. //#include "delay.h"       
   
4. 
   
5. // 编码器：100线；电机减速比：150
   
6. 
   
7. #include "ofme_led.h"
   
8. 
   
9. 
   
10. #include "ofme_filter.h"
    
11. #include "ofme_iic.h"
    
12. #include "ofme_iic_dev.h"
    
13. #include "ofme_pwm.h"
    
14. #include "ofme_pid.h"
    
15. #include "ofme_encoder.h"
    
16. #include "ofme_io.h"
    
17. #include "ofme_time.h"
    
18. #include "ofme_ir_nec.h"
    
19. 
    
20. #define PI (3.14159265)
    
21. // 度数表示的角速度*1000
    
22. #define MDPS (70)
    
23. // 弧度表示的角速度
    
24. #define RADPS ((float)MDPS*PI/180000)
    
25. // 每个查询周期改变的角度
    
26. #define RADPT (RADPS/(-100))
    
27. 
    
28. 
    
29. // 平衡的角度范围；+-60度(由于角度计算采用一阶展开，实际值约为46度)
    
30. #define ANGLE_RANGE_MAX (60*PI/180)
    
31. #define ANGLE_RANGE_MIN (-60*PI/180)
    
32. 
    
33. // 全局变量
    
34. pid_s sPID;                                        // PID控制参数结构体
    
35. float radian_filted=0;                // 滤波后的弧度
    
36. accelerometer_s acc;                // 加速度结构体，包含3维变量
    
37. gyroscope_s gyr;                        // 角速度结构体，包含3维变量
    
38. int speed=0, distance=0;        // 小车移动的速度，距离
    
39. int tick_flag = 0;                        // 定时中断标志
    
40. int pwm_speed = 0;                        // 电机pwm控制的偏置值，两个电机的大小、正负相同，使小车以一定的速度前进
    
41. int pwm_turn = 0;                        // 电机pwm控制的差异值，两个电机的大小相同，正负相反，使小车左、右转向
    
42. float angle_balance = 0;        // 小车的平衡角度。由于小车重心的偏移，小车的平衡角度不一定是radian_filted为零的时候
    
43. 
    
44. 
    
45. // 定时器周期中断，10ms
    
46. void sys_tick_proc(void)
    
47. {
    
48.         static unsigned int i = 0;
    
49. 
    
50.         tick_flag++;
    
51. 
    
52.         i++;
    
53.         if(i>=100) i=0;
    
54. 
    
55.         if(i==0)                   // 绿灯的闪烁周期为1秒
    
56.         {
    
57.                 LED1_OFF();
    
58.         }
    
59.         else if(i==50)
    
60.         {
    
61.                 LED1_ON();
    
62.         }
    
63. }
    
64. 
    
65. void control_proc(void)
    
66. {
    
67.         int i = ir_key_proc(); // 将红外接收到的按键值，转换为小车控制的相应按键值。
    
68. 
    
69.         switch(i)
    
70.         {
    
71.                 case KEY_TURN_LEFT:
    
72.                         if(pwm_turn<500) pwm_turn += 50;
    
73.                         break;
    
74.                 case KEY_TURN_RIGHT:
    
75.                         if(pwm_turn>-500) pwm_turn -= 50;
    
76.                         break;
    
77.                 case KEY_TURN_STOP:
    
78.                         pwm_turn = 0;
    
79.                         distance = 0;
    
80.                         pwm_speed = 0;
    
81.                         break;
    
82.                 case KEY_SPEED_UP:
    
83.                         if(pwm_speed<500) pwm_speed+=100;
    
84.                         break;
    
85.                 case KEY_SPEED_DOWN:
    
86.                         if(pwm_speed>-500) pwm_speed-=100;
    
87.                         break;
    
88.                 case KEY_SPEED_0:
    
89.                         pwm_speed = 0;
    
90.                         break;
    
91.                 case KEY_SPEED_F1:
    
92.                         pwm_speed = 150;
    
93.                         break;
    
94.                 case KEY_SPEED_F2:
    
95.                         pwm_speed = 300;
    
96.                         break;
    
97.                 case KEY_SPEED_F3:
    
98.                         pwm_speed = 450;
    
99.                         break;
    
100.                 case KEY_SPEED_F4:
     
101.                         pwm_speed = 600;
     
102.                         break;
     
103.                 case KEY_SPEED_F5:
     
104.                         pwm_speed = 750;
     
105.                         break;
     
106.                 case KEY_SPEED_F6:
     
107.                         pwm_speed = 900;
     
108.                         break;
     
109.                 case KEY_SPEED_B1:
     
110.                         pwm_speed = -150;
     
111.                 case KEY_SPEED_B2:
     
112.                         pwm_speed = -300;
     
113.                 case KEY_SPEED_B3:
     
114.                         pwm_speed = -450;
     
115.                         break;
     
116.                 default:
     
117.                         break;
     
118.         }
     
119. 
     
120.         pwm_turn *= 0.9;        // pwm_turn的值以0.9的比例衰减，使小车在接收到一个转向信号后只转动一定的时间后停止转动。
     
121. 
     
122. 
     
123.         speed = speed*0.7 +0.3*(encoder_read());        // 定周期（10ms）读取编码器数值得到实时速度，再对速度进行平滑滤波
     
124.         if(speed!=0)
     
125.         {
     
126.                 printf("speed: %d, dst: %d, pwm: %d \r\n", speed,distance,(int)(speed*6+distance*0.1));
     
127.         }
     
128. 
     
129. 
     
130. 
     
131.         encoder_write(0);                                                        // 编码器值重新设为0
     
132. 
     
133.         distance += speed;                                                        // 对速度进行积分，得到移动距离
     
134. 
     
135.         if(distance>6000) distance = 6000;                        // 减少小车悬空、空转对控制的影响
     
136.         else if(distance<-6000) distance = -6000;
     
137. 
     
138. }
     
139. 
     
140. void balance_proc(void)
     
141. {
     
142.         static unsigned int err_cnt=0;
     
143. 
     
144. //        float tFloat;
     
145.         int pwm_balance;
     
146. //        static float angle;
     
147. //        float angle_t;
     
148.         float radian, radian_pt;          // 当前弧度及弧度的微分(角速度，角度值用弧度表示）
     
149. 
     
150.         adxl345_read(&acc);                        // 读取当前加速度。由于传感器按照的位置原因，传感器的值在函数内部经过处理，变为小车的虚拟坐标系。
     
151.         l3g4200d_read(&gyr);                // 读取当前角速度。同样经过坐标系变换。
     
152. 
     
153. 
     
154. // 此段程序用于传感器出错时停止小车
     
155.         err_cnt = err_cnt*115>>7;        // err_cnt以0.9的比例系数衰减(115>>7的值约为0.9，避免浮点数，提高速度)
     
156.         if(acc.flag != 0x0F || gyr.flag != 0x0F)   // 读取的角度、角速度值有误。可能是电磁干扰、iic线太长等导致出错。
     
157.         {
     
158.                 LED0_ON();                // 亮红灯
     
159.                 err_cnt +=100;        // 等比数列，比例系数0.9(115>>7)，常数项100；根据公式，连续10项的和约为657
     
160.                 if(err_cnt>657) goto err;        // 当连续发生约10次（约0.1秒）错误则超过657而溢出。
     
161.         }
     
162. 
     
163. 
     
164. // 此段程序用于倒立或失重时停止小车
     
165.         if(acc.z<=0)
     
166.         {
     
167.                 goto err;
     
168.         }
     
169. 
     
170. 
     
171. // 小车的虚拟x轴方向为小车前进方向，虚拟y轴为小车左边，虚拟z轴为小车上升方向。
     
172. // 前倾角度为负，后倾角度为正。
     
173.         // 通过计算加速度分量，得到小车倾斜弧度（未滤波）
     
174.         radian = (float)(acc.x)/acc.z;        //  一阶展开：Q =f(x)=x-x^3/3+x^5/5+...+(-1)^k*x^(2k+1)/(2k+1)+...
     
175.         // 通过角速度传感器，得到小车的角速度（单位为 弧度/秒）
     
176.         radian_pt = gyr.y*RADPT;
     
177.         radian_filted = ofme_filter(radian_filted, radian, radian_pt);                // 互补滤波得到小车的倾斜角度
     
178. 
     
179. // 此段程序用于小车倾斜角度过大时，停止小车
     
180.         if(radian_filted> ANGLE_RANGE_MAX || radian_filted<ANGLE_RANGE_MIN)
     
181.         {
     
182.                 goto err;
     
183.         }
     
184. 
     
185. // 通过PID计算，得到保持小车角度为零所需要的电机pwm输出
     
186.         pwm_balance = pid_proc(&sPID, radian_filted, radian_pt);
     
187.         //        printf("%d\r\n",speed);
     
188. // 通过小车移动速度与移动距离，调整小车平衡所需的pwm输出
     
189.         pwm_balance += (speed*6+distance*0.1);
     
190. 
     
191. // 在pwm_balance的基础上，加上速度分量与转动分量，调整小车两个电机的转速。
     
192.         pwm_control(pwm_balance+pwm_speed+pwm_turn, pwm_balance+pwm_speed-pwm_turn);
     
193. 
     
194. // 如果pwm超出有效值，红灯亮。用于调试，了解系统状态。
     
195.         if(pwm_balance>=1000||pwm_balance<=-1000) LED1_ON();
     
196.         LED0_OFF();
     
197.         return;
     
198. err:
     
199.         puts("balance error.\r\n");
     
200.         pwm_control(0, 0);                                   // 关闭电机
     
201.         return;
     
202. }
     
203. 
     
204. 
     
205. int main(void)
     
206. {
     
207. //        int i=0, t;
     
208. //        int pwm;
     
209. //        float radian, radian_pt;
     
210. 
     
211.           Stm32_Clock_Init(9);//系统时钟设置
     
212.         uart_init(72,57600); //串口1初始化   
     
213.         hw_tick_start();   // 定时器周期性中断，用于提供系统脉搏
     
214. ////////////////////////////////////////////////////////////////////////////////
     
215.         led_init();
     
216.         pwm_init();
     
217.         iic_init();
     
218.         adxl345_init(&acc);
     
219.         l3g4200d_init(&gyr);
     
220.         hw_ir_init();
     
221.         encoder_init();
     
222.         while(0)
     
223.         {
     
224.                 if(tick_flag>100)
     
225.                 {
     
226.                         tick_flag = 0;
     
227.                         printf("count: %d\r\n",encoder_read());
     
228. 
     
229.                 }
     
230.         }
     
231. 
     
232. 
     
233. 
     
234. ////////////////////////////////////////////////////////////////////////////////
     
235. //        pid_init(&sPID, 4500,0,-300);6000--350        ;8000--350;11000--350;
     
236. //        pid_init(&sPID, 6000,0,-35000);
     
237.         pid_init(&sPID, 7500,0,-35000);          // 调节PID参数，后3个形参分别为：比例系数P，积分系数I，微分系数D
     
238.         sPID.target = -3.5*PI/180;
     
239. 
     
240.         radian_filted = 0;
     
241.         adxl345_init(&acc);
     
242.         l3g4200d_init(&gyr);
     
243.         while(1)
     
244.         {
     
245.                 if(tick_flag)
     
246.                 {
     
247.                         tick_flag = 0;
     
248.                         balance_proc();        // 调节小车，保持平衡
     
249.                         control_proc();        // 根据遥控接收到的数据，调整电机输出参数
     
250.                 }
     
251.         }
     
252. }
     
253. 
     

复制代码

iic部分源码：

1. #include "ofme_iic.h"
   
2. 
   
3. ////////////////////////////////////////////////////////////////////////////////
   
4. // ofme_iic.c
   
5. // v2012.12.20
   
6. // Copyright(C) ofourme@163.com
   
7. // All rights reserved
   
8. ////////////////////////////////////////////////////////////////////////////////
   
9. // iic 主机模拟程序 for F/S mode
   
10. // 不可重入
    
11. // 所有的函数结束后都是占有scl总线的，故不会有别的主机与之竞争（除非与别的主...
    
12. // 机处于完全同步），但别的主机也可能在程序运行期间加入竞争。
    
13. ////////////////////////////////////////////////////////////////////////////////
    
14. // 详见《I2C总线规范（周立功翻译版）》
    
15. // 传输格式：P8~P10
    
16. // 同步与仲裁：P10~P11
    
17. // 时序要求：P27~P28
    
18. // tag: 同步发生于主机活跃的所有时间
    
19. //      仲裁发生于主机发送数据的情况，包括ACK位
    
20. ////////////////////////////////////////////////////////////////////////////////
    
21. // 全局变量，用于保存IIC_TIME_OUT等错误信息。通过iic_error_check()获取。
    
22. static int _IIC_ERROR_CODE = IIC_OK;
    
23. ////////////////////////////////////////////////////////////////////////////////
    
24. #ifndef F_SCL
    
25.     #err "F_SCL not defined."
    
26. #elif (F_SCL==100)
    
27. ////////////////////////////////////////////////////////////////////////////////
    
28. // （重复）起始条件的保持时间。在这个周期后，产生第一个时间脉冲...
    
29. //  4.0us<t_hd_sta or 0.6us<t_hd_sta
    
30. #define T_HD_STA (4)
    
31. // SCL时钟的低电平周期 4.7us<t or 1.3us<t
    
32. // SDA should hold at least 300ns while SCL is falling
    
33. #define T_LOW1  (1)
    
34. #define T_LOW2  (4)
    
35. #define T_LOW   (T_LOW1+T_LOW2)
    
36. // SCL时钟的高电平周期 4.0us<t or 0.6us<t
    
37. #define T_HIGH  (4)
    
38. // 重复起始条件的建立时间 4.7us<t or 0.6us<t
    
39. #define T_SU_STA (5)
    
40. // 数据保持时间：
    
41. // IIC总线器件：0<t<3.45us or 0<t<0.9us
    
42. // 兼容CUBS的主机：5.0us<t<NULL or NULL<t<NULL
    
43. // SDA should hold at least 300ns while SCL is falling
    
44. #define T_HD_DAT (1)
    
45. // 数据建立时间：250ns<t or 100ns<t
    
46. #define T_SU_DAT (1)
    
47. // 停止条件的建立时间：4.0us<t or 0.6us<t
    
48. #define T_SU_STO (4)
    
49. // 停止和启动条件之间的总线空闲时间 4.7us<t_buf or 1.3us<t_buf
    
50. #define T_BUF   (5)
    
51. ////////////////////////////////////////////////////////////////////////////////
    
52. #elif (F_SCL==400)
    
53. ////////////////////////////////////////////////////////////////////////////////
    
54. #define T_HD_STA    (1)
    
55. #define T_LOW1      (1)
    
56. #define T_LOW2      (1)
    
57. #define T_LOW       (T_LOW1+T_LOW2)
    
58. #define T_HIGH      (1)
    
59. #define T_SU_STA    (1)
    
60. #define T_HD_DAT    (0)
    
61. #define T_SU_DAT    (1)
    
62. #define T_SU_STO    (1)
    
63. #define T_BUF       (2)
    
64. ////////////////////////////////////////////////////////////////////////////////
    
65. #else
    
66. #err "F_SCL value error."
    
67. #endif
    
68. ////////////////////////////////////////////////////////////////////////////////
    
69. // 提供给iic的延时函数，单位为1微秒。
    
70. #ifndef iic_delay
    
71.     #err "iic_delay() not defined."
    
72. #endif
    
73. ////////////////////////////////////////////////////////////////////////////////
    
74. // 主机释放SCL总线，而且等待外部主机、设备释放SCL总线。用于SCL同步。
    
75. /* "IIC SCL SYNCHRONIZE." 不属于异常错误，故大写表示。*/
    
76. #define IIC_SCL_RELEASE(t) \
    
77. {\
    
78.     SCL_H();\
    
79.         t = 0;\
    
80.         while(SCL==0)\
    
81.         {\
    
82.                 t++;\
    
83.                 if(t==IIC_RAISING_COUNT) IIC_DEBUG("IIC SCL SYNCHRONIZE.\r\n");\
    
84.                 if(t>=IIC_TIME_OUT_COUNT)\
    
85.                 {\
    
86.                         _IIC_ERROR_CODE = IIC_TIME_OUT;\
    
87.                         IIC_DEBUG("iic scl synchronize time out.\r\n");\
    
88.                         break;\
    
89.                 }\
    
90.         }\
    
91. }
    
92. ////////////////////////////////////////////////////////////////////////////////
    
93. // 保持时间T的高电平。但是如果总线电平被外部拉低，则提前退出。用于SCL同步。
    
94. #define IIC_SCL_HOLD(T, t) \
    
95. {\
    
96.     for(t=0; t<T; t++)\
    
97.     {\
    
98.         iic_delay(1);\
    
99.         if(SCL==0) break;\
    
100.     }\
     
101. }
     
102. ////////////////////////////////////////////////////////////////////////////////
     
103. void iic_init(void)
     
104. {
     
105.         hw_iic_init(); // 外部函数。配置端口为开漏输出。
     
106. //        _IIC_ERROR_CODE = IIC_OK;        // 延后到iic_start()里面设置。
     
107.         SCL_H();                // 释放端口
     
108.         SDA_H();
     
109. }
     
110. ////////////////////////////////////////////////////////////////////////////////
     
111. // iic_start()函数在总线忙碌的情况下返回失败值
     
112. int iic_start(void)
     
113. {
     
114. // 其它主机可能处于<1>start、<2>restart、<3>stop、<4>读写SDA且SDA为高电平。
     
115. // 有可能独占总线或与别的主机同步占有总线，这是我们希望的最好结果。
     
116. // 但iic协议是否有可能导致不同步地占有总线？
     
117. //
     
118. // 程序实际上应该检查总线在T_BUF期间是否被占用，保证起始标志时序不被打断，...
     
119. // 但使用软件查询方式无法确切认定在延时期间总线电平没有被外部主机拉低，...
     
120. // 本程序的缺陷有可能导致不同步地占有总线！！！
     
121. // 只能寄希望于程序在后面的多主机竞争中失败退出而避免错误了。
     
122. 
     
123. 
     
124.         _IIC_ERROR_CODE = IIC_OK;
     
125. 
     
126.     SCL_H();
     
127.     SDA_H();
     
128.     iic_delay(T_BUF+T_BUF_ALT);        // 保证SCL与SDA线的高电平维持时间
     
129. 
     
130.     if( SCL==0 )            // SCL总线忙
     
131.         {
     
132.         return IIC_SCL_BUSY;
     
133.         }
     
134.     if( SDA==0 )            // SDA总线忙
     
135.         {
     
136.                 return IIC_SDA_BUSY;
     
137.         }
     
138.        
     
139.     SDA_L();
     
140.     iic_delay(T_HD_STA);
     
141.     SCL_L();    // get the SCL & SDA bus
     
142. 
     
143.     return IIC_OK;
     
144. }
     
145. 
     
146. ////////////////////////////////////////////////////////////////////////////////
     
147. // 在传输完数据后可立即调用iic_restart()，与iic_start()类似。
     
148. void iic_restart(void)
     
149. {
     
150.         int t;
     
151. // scl==0
     
152.     SDA_H();
     
153.     iic_delay(T_LOW);
     
154.     IIC_SCL_RELEASE(t);
     
155.     iic_delay(T_SU_STA);
     
156.     SDA_L();
     
157.     iic_delay(T_HD_STA);
     
158.     SCL_L();    // get the SCL & SDA bus
     
159. }
     
160. ////////////////////////////////////////////////////////////////////////////////
     
161. void iic_stop(void)
     
162. {
     
163. // scl==0
     
164.     SDA_L();
     
165.     iic_delay(T_LOW);
     
166.         SCL_H();        // release SCL, ignore pulling down by other device.
     
167.     iic_delay(T_SU_STO);
     
168.     SDA_H();    // release SDA
     
169. }
     
170. 
     
171. ////////////////////////////////////////////////////////////////////////////////
     
172. // 主机接收数据发送ack, 比较响应位进行多主机仲裁，由于ack为低电平，故实际不仲裁
     
173. void iic_ack(void)
     
174. {
     
175.     int t;
     
176. 
     
177. // scl==0
     
178.     SDA_L();    // ack
     
179.     iic_delay(T_LOW);
     
180.     IIC_SCL_RELEASE(t);         // SCL SYNCHRONIZE
     
181.     IIC_SCL_HOLD(T_HIGH, t);   // SCL SYNCHRONIZE
     
182.     SCL_L();    // get the SCL bus
     
183. }
     
184. 
     
185. ////////////////////////////////////////////////////////////////////////////////
     
186. // 主机接收数据发送nack, 比较响应位进行多主机仲裁
     
187. int iic_nack(void)
     
188. {
     
189.     int t;
     
190. 
     
191. // scl==0
     
192.     SDA_H();  // nack
     
193.     iic_delay(T_LOW);
     
194.     IIC_SCL_RELEASE(t);         // SCL SYNCHRONIZE
     
195.     if(SDA==0)
     
196.     {   // scl & sda had been released before.
     
197.                 IIC_DEBUG("iic_nack() arbitrate failed.\r\n");
     
198.                 // 应该不用再发送时钟直到nack周期结束？
     
199.         return IIC_AARB_FAIL;
     
200.     }
     
201.     IIC_SCL_HOLD(T_HIGH, t);         // SCL SYNCHRONIZE
     
202.     SCL_L();    // get the SCL bus
     
203. 
     
204.     return IIC_OK;
     
205. }
     
206. ////////////////////////////////////////////////////////////////////////////////
     
207. // 主机发送数据完等待从机响应ack or nack，不进行多主机仲裁
     
208. int iic_wait_ack(void)
     
209. {
     
210.     int t, data;
     
211. 
     
212. // scl==0
     
213.     SDA_H();            // release SDA
     
214.     iic_delay(T_LOW);   // wait for SDA to be change
     
215.     IIC_SCL_RELEASE(t);        // SCL SYNCHRONIZE
     
216.         data = SDA;
     
217.     IIC_SCL_HOLD(T_HIGH, t);  // SCL SYNCHRONIZE
     
218.     SCL_L();    // get the SCL bus
     
219. 
     
220.     if(data) return IIC_NACK;
     
221.     else     return IIC_ACK;
     
222. }
     
223. ////////////////////////////////////////////////////////////////////////////////
     
224. // 主机读取数据，不比较数据位进行多主机仲裁
     
225. u8 iic_read(void)
     
226. {
     
227.     u8 d;
     
228.     int i, t;
     
229. 
     
230. // sda==0, scl==0;
     
231.     SDA_H(); // release SDA, wait for SDA to be change
     
232.     for(i=0, d=0; i<8; i++)
     
233.     {
     
234.         iic_delay(T_LOW);
     
235.         IIC_SCL_RELEASE(t);          // SCL SYNCHRONIZE
     
236. //      read_bit();
     
237.         d<<=1;
     
238.         if(SDA) d++;
     
239. // 理论上read函数和write函数在这里收发字节的第1位时，应不断检测SCL高电平期间，...
     
240. // SDA的电平有无变化以识别restart()或stop()标志，但同时还要检测SCL有无被外部拉低...
     
241. // 在不使用中断而采用纯粹查询手段的情况下，实现起来有困难，故不做判断。
     
242.         IIC_SCL_HOLD(T_HIGH, t);    // SCL SYNCHRONIZE
     
243.         SCL_L();    // get the SCL bus
     
244.     }
     
245. 
     
246.     return d;
     
247. }
     
248. 
     
249. ////////////////////////////////////////////////////////////////////////////////
     
250. // 主机发送数据，比较数据位进行多主机仲裁
     
251. // 主机在发送数据的第一位且第一位为1时，其它主机可能在SCL高电平期间发送...
     
252. // restart()或是stop()标志，也即电平0->1或是1->0，理论上程序应该检测这种...
     
253. // 情况的发生，并停止发送数据而发送一样的restart或是stop标志（见P11）。
     
254. // 为简化程序，一旦遇到这种情况既转化为IIC_ARB_FAIL处理。
     
255. int iic_write(u8 data)
     
256. {
     
257.     int i, t, err = IIC_OK;
     
258. 
     
259. // sda==0, scl==0;
     
260.     for(i=0; i<8; i++, data<<=1)
     
261.     {
     
262.         iic_delay(T_LOW1);
     
263. 
     
264. //                send_bit();
     
265.                if(data&0x80)
     
266.                    SDA_H();
     
267.                else
     
268.                    SDA_L();
     
269. //
     
270.             iic_delay(T_LOW2);
     
271.                IIC_SCL_RELEASE(t);          // SCL SYNCHRONIZE
     
272.                if( data&0x80 && (SDA==0) )//仲裁失败
     
273.                {   // scl & sda had been released before.
     
274.                         // 理论上仲裁失败就由其它主机接管控制器，程序可以停止产生SCL...
     
275.                         // 在这里我们应该可以直接返回 IIC_DARB_FAIL
     
276.             // return IIC_DARB_FAIL;
     
277.                         // 但我选择发送0xff直到字节结束
     
278.                         err = IIC_DARB_FAIL;
     
279.                         data = 0xFF;
     
280.         }
     
281.         IIC_SCL_HOLD(T_HIGH, t);    // SCL SYNCHRONIZE
     
282.         SCL_L();    // get the SCL bus
     
283.     }
     
284. 
     
285.     return err;
     
286. }
     
287. 
     
288. ////////////////////////////////////////////////////////////////////////////////
     
289. #if 0
     
290. int iic_dev_read(u8 dev, u8 addr, u8* data)
     
291. {
     
292. // 注意将IIC_DEBUG()放iic_stop()后面，以免影响总线时序。
     
293. 
     
294.     int i;
     
295. 
     
296.     i = iic_start();  // select the device and set address
     
297.     if( i != IIC_OK ) goto err_bus_busy;
     
298.     i = iic_write(dev);
     
299.     if( i != IIC_OK ) goto err_arb_fail;
     
300.     i = iic_wait_ack();
     
301.     if( i != IIC_ACK) goto err_dev_fail;
     
302.     i = iic_write(addr);
     
303.     if( i != IIC_OK ) goto err_arb_fail;
     
304.     i = iic_wait_ack();
     
305.     if( i != IIC_ACK) goto err_tar_fail;
     
306. 
     
307.     iic_restart();
     
308.     i = iic_write(dev|1);  // start read
     
309.     if( i != IIC_OK ) goto err_arb_fail;
     
310.     i = iic_wait_ack();
     
311.     if( i != IIC_ACK) goto err_dev_fail;
     
312.     *data = iic_read();
     
313.     i = iic_nack();// write nack to tell the slave stop transfer data.
     
314.     if( i != IIC_OK ) goto err_arb_fail;
     
315. 
     
316. //end:
     
317.     iic_stop();
     
318. //        IIC_DEBUG("R: IIC READ DONE.\r\n");
     
319.         if(_IIC_ERROR_CODE & IIC_TIME_OUT)
     
320.         {
     
321.                 IIC_DEBUG("r: iic time out.\r\n");
     
322.                 return _IIC_ERROR_CODE;
     
323.         }
     
324.     return IIC_OK;
     
325. err_bus_busy:
     
326.         if(i == IIC_SCL_BUSY)
     
327.                 IIC_DEBUG("r: iic scl bus busy.\r\n");
     
328.         else
     
329.                 IIC_DEBUG("r: iic sda bus busy.\r\n");
     
330.         return i | _IIC_ERROR_CODE;
     
331. err_arb_fail:
     
332. //  总线仲裁失败可能是由于硬件错误或是多主机竞争。如果是硬件错误，应继续产生...
     
333. //  时钟到字节传输结束，然后释放总线？不管怎样，都不应该再调用iic_stop();
     
334.         SDA_H();
     
335.         SCL_H();
     
336.         IIC_DEBUG("r: iic bus arbitrate failed.\r\n");
     
337.         return i | _IIC_ERROR_CODE;        // IIC_ARB_FAIL
     
338. err_dev_fail:
     
339.         iic_stop();
     
340.         IIC_DEBUG("r: iic device not respond.\r\n");
     
341.         return IIC_DEVICE_FAIL | _IIC_ERROR_CODE;
     
342. err_tar_fail:
     
343.         iic_stop();
     
344.         IIC_DEBUG("r: device target not respond.\r\n");
     
345.         return IIC_TARGET_FAIL | _IIC_ERROR_CODE;
     
346. }
     
347. #else
     
348. int iic_dev_read(u8 dev, u8 addr, u8* data)
     
349. {
     
350.         return iic_dev_gets(dev, addr, data, 1);
     
351. }
     
352. 
     
353. #endif
     
354. ////////////////////////////////////////////////////////////////////////////////
     
355. 
     
356. int iic_dev_gets(u8 dev, u8 addr, u8* data, u16 n)
     
357. {
     
358.     int i;
     
359. 
     
360.     i = iic_start();  // select the device and set address
     
361.     if( i != IIC_OK ) goto err_bus_busy;
     
362.     i = iic_write(dev);
     
363.     if( i != IIC_OK ) goto err_arb_fail;
     
364.     i = iic_wait_ack();
     
365.     if( i != IIC_ACK) goto err_dev_fail;
     
366.     i = iic_write(addr);
     
367.     if( i != IIC_OK ) goto err_arb_fail;
     
368.     i = iic_wait_ack();
     
369.     if( i != IIC_ACK) goto err_tar_fail;
     
370. 
     
371.     iic_restart();
     
372.     i = iic_write(dev|1);  // start read
     
373.     if( i != IIC_OK ) goto err_arb_fail;
     
374.     i = iic_wait_ack();
     
375.     if( i != IIC_ACK) goto err_dev_fail;
     
376.         if(n<1) n=1;
     
377.         while(--n)
     
378.     {
     
379.                 *data++ = iic_read();
     
380.                 iic_ack();
     
381.         }
     
382.         *data = iic_read();
     
383.     i = iic_nack();// write nack to tell the slave stop transfer data.
     
384.     if( i != IIC_OK ) goto err_arb_fail;
     
385. 
     
386. //end:
     
387.     iic_stop();
     
388. //        IIC_DEBUG("R: IIC READ DONE.\r\n");
     
389.         if(_IIC_ERROR_CODE & IIC_TIME_OUT)
     
390.         {
     
391.                 IIC_DEBUG("r: iic time out.\r\n");
     
392.                 return _IIC_ERROR_CODE;
     
393.         }
     
394.     return IIC_OK;
     
395. err_bus_busy:
     
396.         if(i == IIC_SCL_BUSY)
     
397.                 IIC_DEBUG("r: iic scl bus busy.\r\n");
     
398.         else
     
399.                 IIC_DEBUG("r: iic sda bus busy.\r\n");
     
400.         return i | _IIC_ERROR_CODE;
     
401. err_arb_fail:
     
402. //  总线仲裁失败可能是由于硬件错误或是多主机竞争。如果是硬件错误，应继续产生...
     
403. //  时钟到字节传输结束，然后释放总线？不管怎样，都不应该再调用iic_stop();
     
404.         SDA_H();
     
405.         SCL_H();
     
406.         IIC_DEBUG("r: iic bus arbitrate failed.\r\n");
     
407.         return i | _IIC_ERROR_CODE;        // IIC_ARB_FAIL
     
408. err_dev_fail:
     
409.         iic_stop();
     
410.         IIC_DEBUG("r: iic device not respond.\r\n");
     
411.         return IIC_DEVICE_FAIL | _IIC_ERROR_CODE;
     
412. err_tar_fail:
     
413.         iic_stop();
     
414.         IIC_DEBUG("r: device target not respond.\r\n");
     
415.         return IIC_TARGET_FAIL | _IIC_ERROR_CODE;
     
416. }
     
417. 
     
418. 
     
419. ////////////////////////////////////////////////////////////////////////////////
     
420. #if 0
     
421. int iic_dev_write(u8 dev, u8 addr, u8 data)
     
422. {
     
423. // 注意将IIC_DEBUG()放iic_stop()后面，以免影响总线时序。
     
424. 
     
425.     int i;
     
426. 
     
427.     i = iic_start();
     
428.     if( i != IIC_OK ) goto err_bus_busy;
     
429.     i = iic_write(dev);
     
430.     if( i != IIC_OK ) goto err_arb_fail;
     
431.     i = iic_wait_ack();
     
432.     if( i != IIC_ACK) goto err_dev_fail;
     
433.     i = iic_write(addr);
     
434.     if( i != IIC_OK ) goto err_arb_fail;
     
435.     i = iic_wait_ack();
     
436.     if( i != IIC_ACK) goto err_tar_fail;
     
437.     i = iic_write(data);
     
438.     if( i != IIC_OK ) goto err_arb_fail;
     
439. // 如果返回IIC_NACK，则不能再继续往从机写数据。本函数只写一字节的数据，故忽略。
     
440.     i = iic_wait_ack();
     
441. //end:
     
442.     iic_stop();
     
443. //        IIC_DEBUG("W: IIC WRITE DONE.\r\n");
     
444.         if( i != IIC_ACK)
     
445.                 IIC_DEBUG("w: IIC DEVICE NO ACK.\r\n");
     
446.         if(_IIC_ERROR_CODE & IIC_TIME_OUT)
     
447.         {
     
448.                 IIC_DEBUG("w: iic time out.\r\n");
     
449.                 return _IIC_ERROR_CODE;
     
450.         }
     
451.     return IIC_OK;
     
452. err_bus_busy:
     
453.         if(i == IIC_SCL_BUSY)
     
454.                 IIC_DEBUG("w: iic scl bus busy.\r\n");
     
455.         else
     
456.                 IIC_DEBUG("w: iic sda bus busy.\r\n");
     
457.         return i | _IIC_ERROR_CODE;
     
458. err_arb_fail:
     
459. //  总线仲裁失败可能是由于硬件错误或是多主机竞争。如果是硬件错误，应继续产生...
     
460. //  时钟到字节传输结束，然后释放总线？不管怎样，都不应该再调用iic_stop();
     
461.         SDA_H();
     
462.         SCL_H();
     
463.         IIC_DEBUG("w: iic bus arbitrate failed.\r\n");
     
464.         return i | _IIC_ERROR_CODE;        // IIC_ARB_FAIL
     
465. err_dev_fail:
     
466.         iic_stop();
     
467.         IIC_DEBUG("w: iic device not respond.\r\n");
     
468.         return IIC_DEVICE_FAIL | _IIC_ERROR_CODE;
     
469. err_tar_fail:
     
470.         iic_stop();
     
471.         IIC_DEBUG("w: device target not respond.\r\n");
     
472.         return IIC_TARGET_FAIL | _IIC_ERROR_CODE;
     
473. }
     
474. 
     
475. #else
     
476. 
     
477. int iic_dev_write(u8 dev, u8 addr, u8 data)
     
478. {
     
479.         u8 buf = data;
     
480.         return iic_dev_puts(dev, addr, &buf, 1);
     
481. }
     
482. 
     
483. #endif
     
484. 
     
485. ////////////////////////////////////////////////////////////////////////////////
     
486. 
     
487. int iic_dev_puts(u8 dev, u8 addr, u8* data, u16 n)
     
488. {
     
489. // 注意将IIC_DEBUG()放iic_stop()后面，以免影响总线时序。
     
490. 
     
491.     int i;
     
492. 
     
493.     i = iic_start();
     
494.     if( i != IIC_OK ) goto err_bus_busy;
     
495.     i = iic_write(dev);
     
496.     if( i != IIC_OK ) goto err_arb_fail;
     
497.     i = iic_wait_ack();
     
498.     if( i != IIC_ACK) goto err_dev_fail;
     
499.     i = iic_write(addr);
     
500.     if( i != IIC_OK ) goto err_arb_fail;
     
501.     i = iic_wait_ack();
     
502.     if( i != IIC_ACK) goto err_tar_fail;
     
503. 
     
504.         if(n<1) n=1;
     
505.         while(--n)
     
506.         {
     
507.                 i = iic_write(*data++);
     
508.             if( i != IIC_OK ) goto err_arb_fail;
     
509.             i = iic_wait_ack();
     
510.                 if( i != IIC_ACK) goto err_tar_fail;        //could not write data.
     
511.         }
     
512.         i = iic_write(*data);
     
513.            if( i != IIC_OK ) goto err_arb_fail;
     
514.            iic_wait_ack();        // 最后一个字节，忽略ack。
     
515. 
     
516. 
     
517. //end:
     
518.     iic_stop();
     
519. //        IIC_DEBUG("W: IIC WRITE DONE.\r\n");
     
520. 
     
521.         if(_IIC_ERROR_CODE & IIC_TIME_OUT)
     
522.         {
     
523.                 IIC_DEBUG("w: iic time out.\r\n");
     
524.                 return _IIC_ERROR_CODE;
     
525.         }
     
526.     return IIC_OK;
     
527. err_bus_busy:
     
528.         if(i == IIC_SCL_BUSY)
     
529.                 IIC_DEBUG("w: iic scl bus busy.\r\n");
     
530.         else
     
531.                 IIC_DEBUG("w: iic sda bus busy.\r\n");
     
532.         return i | _IIC_ERROR_CODE;
     
533. err_arb_fail:
     
534. //  总线仲裁失败可能是由于硬件错误或是多主机竞争。如果是硬件错误，应继续产生...
     
535. //  时钟到字节传输结束，然后释放总线？不管怎样，都不应该再调用iic_stop();
     
536.         SDA_H();
     
537.         SCL_H();
     
538.         IIC_DEBUG("w: iic bus arbitrate failed.\r\n");
     
539.         return i | _IIC_ERROR_CODE;        // IIC_ARB_FAIL
     
540. err_dev_fail:
     
541.         iic_stop();
     
542.         IIC_DEBUG("w: iic device not respond.\r\n");
     
543.         return IIC_DEVICE_FAIL | _IIC_ERROR_CODE;
     
544. err_tar_fail:
     
545.         iic_stop();
     
546.         IIC_DEBUG("w: device target not respond.\r\n");
     
547.         return IIC_TARGET_FAIL | _IIC_ERROR_CODE;
     
548. }
     
549. 
     
550. ////////////////////////////////////////////////////////////////////////////////
     

复制代码

红外遥控部分：

1. #include "ofme_ir_nec.h"
   
2. #include "ofme_time.h"
   
3. 
   
4. #define NEC_HEAD_PLUSE_MAX                (9000+900)
   
5. #define NEC_HEAD_PLUSE_MIN                (9000-630)
   
6. #define NEC_HEAD_SPACE_MAX                (4500+450)
   
7. #define NEC_HEAD_SPACE_MIN                (4500-315)
   
8. #define NEC_HEAD_MAX                        (NEC_HEAD_PLUSE_MAX+NEC_HEAD_SPACE_MAX)
   
9. #define NEC_HEAD_MIN                        (NEC_HEAD_PLUSE_MIN+NEC_HEAD_SPACE_MIN)
   
10. #define NEC_DATA_PLUSE_MAX                (560+56)
    
11. #define NEC_DATA_PLUSE_MIN                (560-56)
    
12. #define NEC_LOG0_SPACE_MAX                (560+56)
    
13. #define NEC_LOG0_SPACE_MIN                (560-56)
    
14. #define NEC_LOG0_MAX                        (NEC_DATA_PLUSE_MAX+NEC_LOG0_SPACE_MAX)
    
15. #define NEC_LOG0_MIN                        (NEC_DATA_PLUSE_MIN+NEC_LOG0_SPACE_MIN)
    
16. #define NEC_LOG1_SPACE_MAX                (1680+168)
    
17. #define NEC_LOG1_SPACE_MIN                (1680-168)
    
18. #define NEC_LOG1_MAX                        (NEC_DATA_PLUSE_MAX+NEC_LOG1_SPACE_MAX)
    
19. #define NEC_LOG1_MIN                        (NEC_DATA_PLUSE_MIN+NEC_LOG1_SPACE_MIN)
    
20. #define NEC_REPEAT_PLUSE_MAX        (9000+630)
    
21. #define NEC_REPEAT_PLUSE_MIN        (9000-900)
    
22. #define NEC_REPEAT_SPACE_MAX        (2500+175)
    
23. #define NEC_REPEAT_SPACE_MIN        (2500-250)
    
24. #define NEC_REPEAT_DELAY_MAX        (97940+9794+NEC_DATA_PLUSE_MAX)
    
25. #define NEC_REPEAT_DELAY_MIN        (97940-9794+NEC_DATA_PLUSE_MIN)
    
26. #define NEC_REPEAT_MAX                        (NEC_REPEAT_PLUSE_MAX+NEC_REPEAT_SPACE_MAX)
    
27. #define NEC_REPEAT_MIN                        (NEC_REPEAT_PLUSE_MIN+NEC_REPEAT_SPACE_MIN)
    
28. 
    
29. #define IR_INT_CLR()                        EXTI->PR = 1<<1
    
30. 
    
31. #define IR_NEC_DEBUG
    
32. 
    
33. // 接收到的数值
    
34. u32 ir_data;
    
35. // <0: ir_data无效; 0:ir_data有效，但已经被处理过；>0: 连发次数；当>0，外部程序可以进行-1操作表示读取数据
    
36. int        ir_repeat = -1;
    
37. // 0: OK; >0: error count; 外部程序可读取此数值了解有无干扰信号或用于debug
    
38. int ir_err_cnt = 0;
    
39. 
    
40. void hw_ir_init(void)
    
41. {
    
42. 
    
43. //初始化红外接收引脚的设置
    
44. //开启中断,并映射
    
45.         RCC->APB2ENR|=1<<4;       //PC时钟使能                  
    
46.         GPIOC->CRL&=0XFFFFFF0F;
    
47.         GPIOC->CRL|=0X00000080;        //PC1输入         
    
48.         GPIOC->ODR|=1<<1;                //PC.1上拉      
    
49.         Ex_NVIC_Config(GPIO_C,1,FTIR);//将line1映射到PC.1，下降沿触发.
    
50.         MY_NVIC_Init(2,1,EXTI1_IRQChannel,2);
    
51. 
    
52. }
    
53. // 一体化红外接收头只能通过38kHz左右的载波（抗干扰&节能），并转化为TTL低电平
    
54. // 下降沿中断
    
55. void EXTI1_IRQHandler(void)
    
56. //void ir_nec_receive(void)
    
57. {
    
58. //        step(<=-1：表示重复帧结束; 0：表示数据帧的开头；32：表示连续帧之间的间隔；>=33：表示重复帧的开头)
    
59.         static int step=-1;
    
60.         static int time1=0;
    
61.         int        time2;
    
62.         int interval;
    
63. 
    
64.         time2 = hw_time_get();
    
65.         interval = hw_interval_get(time1,time2);
    
66.         time1 = time2;
    
67. 
    
68.         if(interval>NEC_REPEAT_DELAY_MAX)//连发码之间的最大间隔
    
69.         {
    
70.                 step = -1;
    
71.                 goto err;
    
72.         }
    
73.         else if(interval>NEC_HEAD_MAX)
    
74.         {
    
75.                 goto err;
    
76.         }
    
77.         else if(interval>NEC_HEAD_MIN)
    
78.         {
    
79.                 ir_repeat=-1; // 表示ir_data无效
    
80.                 ir_data = 0;
    
81.                 step = 0;
    
82. #ifdef IR_NEC_DEBUG
    
83.                 putchar('[');
    
84. #endif
    
85.                 IR_INT_CLR();
    
86.                 return;
    
87.         }
    
88.         else if(interval>NEC_REPEAT_MAX)
    
89.         {
    
90.                 goto err;
    
91.         }
    
92.         else if(interval>NEC_REPEAT_MIN)
    
93.         {
    
94.                 if(step != 33) goto err;
    
95.                 step = 32;
    
96.                 ir_repeat++;
    
97. #ifdef IR_NEC_DEBUG
    
98.                 putchar('-');
    
99.                 putchar('R');
    
100.                 printf("-%d*%d.", (ir_data>>16)&0x0FF, ir_repeat);
     
101. #endif
     
102.                 IR_INT_CLR();
     
103.                 return;
     
104.         }
     
105.         else if(interval>NEC_LOG1_MAX)
     
106.         {
     
107.                 goto err;
     
108.         }
     
109.         else if(interval>NEC_LOG1_MIN)
     
110.         {
     
111.                 goto decode;
     
112.         }
     
113.         else if(interval>NEC_LOG0_MAX)
     
114.         {
     
115.                 goto err;
     
116.         }
     
117.         else if(interval>NEC_LOG0_MIN)
     
118.         {
     
119.                 goto decode;
     
120.         }
     
121.         else
     
122.         {
     
123.                 goto err;
     
124.         }
     
125. 
     
126. // 只有长度为0或1的脉冲才能执行到这里
     
127. decode:
     
128.         if(step<0 || step>=32) goto err;
     
129.         ir_data>>= 1;
     
130.         if(interval>NEC_LOG1_MIN)
     
131.         {
     
132.                 ir_data |= 0x80000000UL;
     
133.         }
     
134.         step++;
     
135.         if(step==32)
     
136.         {
     
137.                 ir_repeat = 1;
     
138. #ifdef IR_NEC_DEBUG
     
139.                 putchar(']');
     
140.                 printf("-%d*%d.", (ir_data>>16)&0x0FF, ir_repeat);
     
141. #endif
     
142.         }
     
143.         IR_INT_CLR();
     
144.         return;
     
145. 
     
146. err:
     
147. #ifdef IR_NEC_DEBUG
     
148.         putchar('\r');
     
149.         putchar('\n');
     
150. #endif
     
151.         if(step == 32)
     
152.         {
     
153.                 step = 33;
     
154. #ifdef IR_NEC_DEBUG
     
155.                 putchar('R');
     
156. #endif
     
157.         }
     
158.         else if(step>=0) // 数据接收出错
     
159.         {
     
160.                 ir_err_cnt++;
     
161.                 step = -1;
     
162. #ifdef IR_NEC_DEBUG
     
163.                 putchar('E');
     
164. #endif
     
165.         }
     
166.         else
     
167.         {
     
168. #ifdef IR_NEC_DEBUG
     
169.                 putchar('S');
     
170. #endif
     
171.         }
     
172. 
     
173.         IR_INT_CLR();
     
174.         return;
     
175. }
     

复制代码

两轮的人玩的不多呀

tam1974 发表于 2017-4-30 17:03
两轮的人玩的不多呀

难度比较大，所以玩得人少

是这样的

适合初学者  做嘛

学习

感谢分享

谢谢分享