• C51智能小车（循迹、跟随、避障、测速、蓝牙、wifie、4g、语音识别）总结

    目录

    1.电机模块开发

    1.1 让小车动起来

    1.2 串口控制小车方向

    1.3 如何进行小车PWM调速

    1.4 PWM方式实现小车转向

    2.循迹小车 

    2.1 循迹模块使用

    2.2 循迹小车原理

    2.3 循迹小车核心代码

    3.跟随/避障小车

    3.1 红外壁障模块分析​编辑

    3.2 跟随小车的原理

    3.3 跟随小车开发和调试代码

    3.4 超声波模块介绍

    3.5 摇头测距小车开发和调试代码

    4.测速小车

    4.1 测速模块

    4.2 测试原理和单位换算

    4.3 定时器和中断实现测速开发和调试代码

    4.4 小车速度显示在OLED屏

    5.远程控制小车

    5.1 蓝牙控制小车

    5.2 蓝牙控制并测速小车

    5.3 wifi控制测速小车

    5.4 4g控制小车

    6.语音控制小车

    6.1语音模块配置：

    6.2 语音控制小车开发和调试代码

    1.电机模块开发

    L9110s概述

    接通VCC，GND 模块电源指示灯亮， 以下资料来源官方，具体根据实际调试

    IA1输入高电平，IA1输入低电平，【OA1 OB1】电机正转；

    IA1输入低电平，IA1输入高电平，【OA1 OB1】电机反转；

    IA2输入高电平，IA2输入低电平，【OA2 OB2】电机正转；

    IA2输入低电平，IA2输入高电平，【OA2 OB2】电机反转；

    1.1 让小车动起来

    核心代码：

    1. #include "reg52.h"
    2. #include "intrins.h"
    3.  
    4. sbit RightCon1A = P3^2;
    5. sbit RightCon1B = P3^3;
    6.  
    7. sbit LeftCon1A = P3^4;
    8. sbit LeftCon1B = P3^5;
    9.  
    10. void Delay1000ms()		//@11.0592MHz
    11. {
    12. 	unsigned char i, j, k;
    13.  
    14. 	_nop_();
    15. 	i = 8;
    16. 	j = 1;
    17. 	k = 243;
    18. 	do
    19. 	{
    20. 		do
    21. 		{
    22. 			while (--k);
    23. 		} while (--j);
    24. 	} while (--i);
    25. }
    26.  
    27.  
    28. void goForward()
    29. {
    30. 	LeftCon1A = 0;
    31. 	LeftCon1B = 1;
    32. 	
    33. 	RightCon1A = 0;
    34. 	RightCon1B = 1;
    35. }
    36.  
    37. void goLeft()
    38. {
    39. 	LeftCon1A = 0;
    40. 	LeftCon1B = 0;
    41. 	
    42. 	RightCon1A = 0;
    43. 	RightCon1B = 1;
    44. }
    45.  
    46. void goRight()
    47. {
    48. 	LeftCon1A = 0;
    49. 	LeftCon1B = 1;
    50. 	
    51. 	RightCon1A = 0;
    52. 	RightCon1B = 0;
    53. }
    54.  
    55. void goBack()
    56. {
    57. 	LeftCon1A = 1;
    58. 	LeftCon1B = 0;
    59. 	
    60. 	RightCon1A = 1;
    61. 	RightCon1B = 0;
    62. }
    63.  
    64. void main()
    65. {
    66. 	while(1){
    67. 		goForward();
    68. 		Delay1000ms();
    69. 		Delay1000ms();
    70. 		goBack();
    71. 		Delay1000ms();
    72. 		Delay1000ms();
    73. 		goLeft();
    74. 		Delay1000ms();
    75. 		Delay1000ms();
    76. 		goRight();
    77. 		Delay1000ms();
    78. 		Delay1000ms();
    79. 	}
    80. }
    81.  
    82.
    1.2 串口控制小车方向
    • 串口分文件编程进行代码整合——通过现象来改代码
    • 接入蓝牙模块，通过蓝牙控制小车
    • 添加点动控制，如果APP支持按下一直发数据，松开就停止发数据（蓝牙调试助手的自定义按键不 能实现），就能实现前进按键按下后小车一直往前走的功能
    1.3 如何进行小车PWM调速

    原理： 全速前进是LeftCon1A = 0; LeftCon1B = 1;完全停止是LeftCon1A = 0;LeftCon1B = 0;那么单位时 间内，比如20ms, 有15ms是全速前进，5ms是完全停止， 速度就会比5ms全速前进，15ms完全停止获得的功率多，相应的速度更快！

    开发：借用PWM的舵机控制代码

    核心代码：

    1. #include "motor.h"
    2. #include "delay.h"
    3. #include "uart.h"
    4. #include "time.h"
    5.  
    6. extern char speed;
    7.  
    8. void main()
    9. {
    10. 	Time0Init();
    11. 	//UartInit();
    12. 	
    13. 	while(1){
    14. 		speed = 10;//10份单位时间全速运行，30份停止，所以慢，20ms是40份的500us
    15. 		Delay1000ms();
    16. 		Delay1000ms();
    17. 		speed = 20;
    18. 		Delay1000ms();
    19. 		Delay1000ms();
    20. 		speed = 40;
    21. 		Delay1000ms();
    22. 		Delay1000ms();
    23. 	}
    24. }
    25.  
    26.  
    27. //time.c
    28. #include "motor.h"
    29. #include "reg52.h"
    30.  
    31. char speed;
    32. char cnt = 0;
    33.  
    34. void Time0Init()
    35. {
    36. 	//1. 配置定时器0工作模式位16位计时
    37. 	TMOD = 0x01;
    38. 	//2. 给初值，定一个0.5出来
    39. 	TL0=0x33;
    40. 	TH0=0xFE;
    41. 	//3. 开始计时
    42. 	TR0 = 1;
    43. 	TF0 = 0;
    44. 	//4. 打开定时器0中断
    45. 	ET0 = 1;
    46. 	//5. 打开总中断EA
    47. 	EA = 1;
    48. }
    49.  
    50. void Time0Handler() interrupt 1
    51. {
    52. 	cnt++;  //统计爆表的次数. cnt=1的时候，报表了1
    53. 	//重新给初值
    54. 	TL0=0x33;
    55. 	TH0=0xFE;
    56. 	
    57. 	//控制PWM波
    58. 	if(cnt < speed){
    59. 		//前进
    60. 		goForward();
    61. 	}else{
    62. 		//停止
    63. 		stop();
    64. 	}
    65. 	
    66. 	if(cnt == 40){//爆表40次，经过了20ms
    67. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    68. 	}
    69. 		
    70. }
    1.4 PWM方式实现小车转向

    原理： 左轮定时器0调速，右轮定时器1调速，那么左转就是右轮速度大于左轮!

    核心代码：

    1. #include "motor.h"
    2. #include "reg52.h"
    3.  
    4. char speedLeft;
    5. char cntLeft = 0;
    6.  
    7. char speedRight;
    8. char cntRight = 0;
    9.  
    10. void Time1Init()
    11. {
    12. 	//1. 配置定时器1工作模式位16位计时
    13. 	TMOD &= 0x0F;
    14. 	TMOD |= 0x1 << 4;
    15. 	//2. 给初值，定一个0.5出来
    16. 	TL1=0x33;
    17. 	TH1=0xFE;
    18. 	//3. 开始计时
    19. 	TR1 = 1;
    20. 	TF1 = 0;
    21. 	//4. 打开定时器1中断
    22. 	ET1 = 1;
    23. 	//5. 打开总中断EA
    24. 	EA = 1;
    25. }
    26.  
    27.  
    28. void Time0Init()
    29. {
    30. 	//1. 配置定时器0工作模式位16位计时
    31. 	TMOD = 0x01;
    32. 	//2. 给初值，定一个0.5出来
    33. 	TL0=0x33;
    34. 	TH0=0xFE;
    35. 	//3. 开始计时
    36. 	TR0 = 1;
    37. 	TF0 = 0;
    38. 	//4. 打开定时器0中断
    39. 	ET0 = 1;
    40. 	//5. 打开总中断EA
    41. 	EA = 1;
    42. }
    43.  
    44. void Time1Handler() interrupt 3
    45. {
    46. 	cntRight++;  //统计爆表的次数. cnt=1的时候，报表了1
    47. 	//重新给初值
    48. 	TL1=0x33;
    49. 	TH1=0xFE;
    50. 	
    51. 	//控制PWM波
    52. 	if(cntRight < speedRight){
    53. 		//右前进
    54. 		goForwardRight();
    55. 	}else{
    56. 		//停止
    57. 		stopRight();
    58. 	}
    59. 	
    60. 	if(cntRight == 40){//爆表40次，经过了20ms
    61. 		cntRight = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    62. 	}
    63. 		
    64. }
    65.  
    66. void Time0Handler() interrupt 1
    67. {
    68. 	cntLeft++;  //统计爆表的次数. cnt=1的时候，报表了1
    69. 	//重新给初值
    70. 	TL0=0x33;
    71. 	TH0=0xFE;
    72. 	
    73. 	//控制PWM波
    74. 	if(cntLeft < speedLeft){
    75. 		//左前进
    76. 		goForwardLeft();
    77. 	}else{
    78. 		//停止
    79. 		stopLeft();
    80. 	}
    81. 	
    82. 	if(cntLeft == 40){//爆表40次，经过了20ms
    83. 		cntLeft = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    84. 	}
    85. 		
    86. }

    2.循迹小车 

    2.1 循迹模块使用
    • TCRT5000传感器的红外发射二极管不断发射红外线
    • 当发射出的红外线没有被反射回来或被反射回来但强度不够大时
    • 红外接收管一直处于关断状态，此时模块的输出端为高电平，指示二极管一直处于熄灭状态
    • 被检测物体出现在检测范围内时，红外线被反射回来且强度足够大，红外接收管饱和
    • 此时模块的输出端为低电平，指示二极管被点亮
    • 总结就是一句话，没反射回来，D0输出高电平，灭灯

    接线方式

    • VCC:接电源正极（3-5V）
    • GND:接电源负极 DO:TTL开关信号输出0、1
    • AO:模拟信号输出(不同距离输出不同的电压，此脚一般可以不接）
    2.2 循迹小车原理

    由于黑色具有较强的吸收能力，当循迹模块发射的红外线照射到黑线时，红外线将会被黑线吸收，导致 循迹模块上光敏三极管处于关闭状态，此时模块上一个LED熄灭。在没有检测到黑线时，模块上两个LED常亮

    总结就是一句话，有感应到黑线，D0输出高电平 ，灭灯

    2.3 循迹小车核心代码
    1. //main.c
    2. #include "motor.h"
    3. #include "delay.h"
    4. #include "uart.h"
    5. #include "time.h"
    6. #include "reg52.h"
    7. extern char speedLeft;
    8. extern char speedRight;
    9.  
    10.  
    11. sbit leftSensor = P2^7;
    12. sbit rightSensor = P2^6;
    13.  
    14. void main()
    15. {
    16. 	Time0Init();
    17. 	Time1Init();
    18. 	//UartInit();
    19. 	
    20. 	while(1){
    21. 		
    22. 		if(leftSensor == 0 && rightSensor == 0){
    23. 				speedLeft = 32;
    24. 				speedRight = 40;
    25. 		}
    26. 		if(leftSensor == 1 && rightSensor == 0){
    27. 				speedLeft = 12;//10份单位时间全速运行，30份停止，所以慢，20ms是40份的500us
    28. 				speedRight = 40;
    29. 		}
    30. 		
    31. 		if(leftSensor == 0 && rightSensor == 1){
    32. 				speedLeft = 32;
    33. 				speedRight = 20;
    34. 		}
    35. 		
    36. 		if(leftSensor == 1 && rightSensor == 1){
    37. 			//停
    38. 				speedLeft = 0;
    39. 				speedRight = 0;
    40. 		}
    41. 	}
    42. }
    43.  
    44. //motor.c
    45. #include "reg52.h"
    46.  
    47. sbit RightCon1A = P3^2;
    48. sbit RightCon1B = P3^3;
    49.  
    50. sbit LeftCon1A = P3^4;
    51. sbit LeftCon1B = P3^5;
    52.  
    53. void goForwardLeft()
    54. {
    55. 	LeftCon1A = 0;
    56. 	LeftCon1B = 1;
    57. }
    58.  
    59. void stopLeft()
    60. {
    61. 	LeftCon1A = 0;
    62. 	LeftCon1B = 0;
    63. }
    64.  
    65. void goForwardRight()
    66. {
    67. 	RightCon1A = 0;
    68. 	RightCon1B = 1;
    69. }
    70. void stopRight()
    71. {
    72. 	RightCon1A = 0;
    73. 	RightCon1B = 0;
    74. }
    75.  
    76.  
    77.  
    78. void goForward()
    79. {
    80. 	LeftCon1A = 0;
    81. 	LeftCon1B = 1;
    82. 	
    83. 	RightCon1A = 0;
    84. 	RightCon1B = 1;
    85. }
    86.  
    87. void goRight()
    88. {
    89. 	LeftCon1A = 0;
    90. 	LeftCon1B = 1;
    91. 	
    92. 	RightCon1A = 0;
    93. 	RightCon1B = 0;
    94. }
    95.  
    96.  
    97. void goLeft()
    98. {
    99. 	LeftCon1A = 0;
    100. 	LeftCon1B = 0;
    101. 	
    102. 	RightCon1A = 0;
    103. 	RightCon1B = 1;
    104. }
    105.  
    106. void goBack()
    107. {
    108. 	LeftCon1A = 1;
    109. 	LeftCon1B = 0;
    110. 	
    111. 	RightCon1A = 1;
    112. 	RightCon1B = 0;
    113. }
    114.  
    115. void stop()
    116. {
    117. 	LeftCon1A = 0;
    118. 	LeftCon1B = 0;
    119. 	
    120. 	RightCon1A = 0;
    121. 	RightCon1B = 0;
    122. }
    123.  
    124. //delay.c
    125. #include "intrins.h"
    126.  
    127. void Delay1000ms()		//@11.0592MHz
    128. {
    129. 	unsigned char i, j, k;
    130.  
    131. 	_nop_();
    132. 	i = 8;
    133. 	j = 1;
    134. 	k = 243;
    135. 	do
    136. 	{
    137. 		do
    138. 		{
    139. 			while (--k);
    140. 		} while (--j);
    141. 	} while (--i);
    142. }
    143.  
    144.  
    145.  
    146. //time.c
    147. #include "motor.h"
    148. #include "reg52.h"
    149.  
    150. char speedLeft;
    151. char cntLeft = 0;
    152.  
    153. char speedRight;
    154. char cntRight = 0;
    155.  
    156. void Time1Init()
    157. {
    158. 	//1. 配置定时器1工作模式位16位计时
    159. 	TMOD &= 0x0F;
    160. 	TMOD |= 0x1 << 4;
    161. 	//2. 给初值，定一个0.5出来
    162. 	TL1=0x33;
    163. 	TH1=0xFE;
    164. 	//3. 开始计时
    165. 	TR1 = 1;
    166. 	TF1 = 0;
    167. 	//4. 打开定时器1中断
    168. 	ET1 = 1;
    169. 	//5. 打开总中断EA
    170. 	EA = 1;
    171. }
    172.  
    173.  
    174. void Time0Init()
    175. {
    176. 	//1. 配置定时器0工作模式位16位计时
    177. 	TMOD = 0x01;
    178. 	//2. 给初值，定一个0.5出来
    179. 	TL0=0x33;
    180. 	TH0=0xFE;
    181. 	//3. 开始计时
    182. 	TR0 = 1;
    183. 	TF0 = 0;
    184. 	//4. 打开定时器0中断
    185. 	ET0 = 1;
    186. 	//5. 打开总中断EA
    187. 	EA = 1;
    188. }
    189.  
    190. void Time1Handler() interrupt 3
    191. {
    192. 	cntRight++;  //统计爆表的次数. cnt=1的时候，报表了1
    193. 	//重新给初值
    194. 	TL1=0x33;
    195. 	TH1=0xFE;
    196. 	
    197. 	//控制PWM波
    198. 	if(cntRight < speedRight){
    199. 		//右前进
    200. 		goForwardRight();
    201. 	}else{
    202. 		//停止
    203. 		stopRight();
    204. 	}
    205. 	
    206. 	if(cntRight == 40){//爆表40次，经过了20ms
    207. 		cntRight = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    208. 	}
    209. 		
    210. }
    211.  
    212. void Time0Handler() interrupt 1
    213. {
    214. 	cntLeft++;  //统计爆表的次数. cnt=1的时候，报表了1
    215. 	//重新给初值
    216. 	TL0=0x33;
    217. 	TH0=0xFE;
    218. 	
    219. 	//控制PWM波
    220. 	if(cntLeft < speedLeft){
    221. 		//左前进
    222. 		goForwardLeft();
    223. 	}else{
    224. 		//停止
    225. 		stopLeft();
    226. 	}
    227. 	
    228. 	if(cntLeft == 40){//爆表40次，经过了20ms
    229. 		cntLeft = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    230. 	}
    231. 		
    232. }
    233.

    3.跟随/避障小车

    3.1 红外壁障模块分析

    原理和循迹是一样的，循迹红外观朝下，跟随朝前

    3.2 跟随小车的原理
    • 左边跟随模块能返回红外，输出低电平，右边不能返回，输出高电平，说明物体在左边，需要左转
    • 右边跟随模块能返回红外，输出低电平，左边不能返回，输出高电平，说明物体在右边，需要右转
    3.3 跟随小车开发和调试代码
    1. //main.c
    2. #include "motor.h"
    3. #include "delay.h"
    4. #include "reg52.h"
    5.  
    6. //sbit leftSensor = P2^7;
    7. //sbit rightSensor = P2^6;
    8.  
    9. sbit leftSensor = P2^5;
    10. sbit rightSensor = P2^4;
    11.  
    12. void main()
    13. {
    14.  
    15. 	while(1){
    16. 		if(leftSensor == 0 && rightSensor == 0){
    17. 			goForward();
    18. 		}
    19. 		if(leftSensor == 1 && rightSensor == 0){
    20. 			goRight();
    21. 		}
    22. 		
    23. 		if(leftSensor == 0 && rightSensor == 1){
    24. 			
    25. 			goLeft();
    26. 		}
    27. 		
    28. 		if(leftSensor == 1 && rightSensor == 1){
    29. 			//停
    30. 			stop();
    31. 		}
    32. 	}
    33. }
    34.  
    35.  
    36. //motor.c
    37. #include "reg52.h"
    38.  
    39. sbit RightCon1A = P3^2;
    40. sbit RightCon1B = P3^3;
    41.  
    42. sbit LeftCon1A = P3^4;
    43. sbit LeftCon1B = P3^5;
    44.  
    45. void goForward()
    46. {
    47. 	LeftCon1A = 0;
    48. 	LeftCon1B = 1;
    49. 	
    50. 	RightCon1A = 0;
    51. 	RightCon1B = 1;
    52. }
    53.  
    54. void goRight()
    55. {
    56. 	LeftCon1A = 0;
    57. 	LeftCon1B = 1;
    58. 	
    59. 	RightCon1A = 0;
    60. 	RightCon1B = 0;
    61. }
    62.  
    63.  
    64. void goLeft()
    65. {
    66. 	LeftCon1A = 0;
    67. 	LeftCon1B = 0;
    68. 	
    69. 	RightCon1A = 0;
    70. 	RightCon1B = 1;
    71. }
    72.  
    73. void goBack()
    74. {
    75. 	LeftCon1A = 1;
    76. 	LeftCon1B = 0;
    77. 	
    78. 	RightCon1A = 1;
    79. 	RightCon1B = 0;
    80. }
    81.  
    82. void stop()
    83. {
    84. 	LeftCon1A = 0;
    85. 	LeftCon1B = 0;
    86. 	
    87. 	RightCon1A = 0;
    88. 	RightCon1B = 0;
    89. }
    90.  
    91. //delay.c
    92.  
    93. #include "intrins.h"
    94.  
    95. void Delay1000ms()		//@11.0592MHz
    96. {
    97. 	unsigned char i, j, k;
    98.  
    99. 	_nop_();
    100. 	i = 8;
    101. 	j = 1;
    102. 	k = 243;
    103. 	do
    104. 	{
    105. 		do
    106. 		{
    107. 			while (--k);
    108. 		} while (--j);
    109. 	} while (--i);
    110. }
    111.  
    112.  
    113.
    3.4 超声波模块介绍

    使用超声波模块，型号：HC-SR04

    • 怎么让它发送波 Trig ，给Trig端口至少10us的高电平
    • 怎么知道它开始发了 Echo信号，由低电平跳转到高电平，表示开始发送波
    • 怎么知道接收了返回波 Echo，由高电平跳转回低电平，表示波回来了
    • 怎么算时间 Echo引脚维持高电平的时间！ 波发出去的那一下，开始启动定时器 波回来的拿一下，我们开始停止定时器，计算出中间经过多少时间
    • 怎么算距离 距离 = 速度 （340m/s）* 时间/2

    时序图：

    3.5 摇头测距小车开发和调试代码
    1. //main.c
    2. #include "reg52.h"
    3. #include "hc04.h"
    4. #include "delay.h"
    5. #include "sg90.h"
    6. #include "motor.h"
    7.  
    8. #define MIDDLE 0
    9. #define LEFT 1
    10. #define RIGHT 2
    11.  
    12. void main()
    13. {
    14. 	char dir;
    15. 	
    16. 	double disMiddle;
    17. 	double disLeft;
    18. 	double disRight;
    19. 	
    20. 	Time0Init();
    21. 	Time1Init();
    22. 	//舵机的初始位置
    23.  
    24. 	sgMiddle();
    25. 	Delay300ms();
    26. 	Delay300ms();
    27. 	dir = MIDDLE;
    28. 	
    29. 	while(1){
    30. 		
    31. 		if(dir != MIDDLE){
    32. 			sgMiddle();
    33. 			dir = MIDDLE;
    34. 			Delay300ms();
    35. 		}
    36. 		disMiddle = get_distance();
    37. 		
    38. 		if(disMiddle > 35){
    39. 			//前进
    40. 			goForward();
    41. 		}else if(disMiddle < 10){
    42. 			goBack();
    43. 			
    44. 		}else
    45. 		{
    46. 			//停止
    47. 			stop();
    48. 			//测左边距离
    49. 			sgLeft();
    50. 			Delay300ms();
    51. 			disLeft = get_distance();
    52. 			
    53. 			sgMiddle();
    54. 			Delay300ms();
    55. 			
    56. 			sgRight();
    57. 			dir = RIGHT;
    58. 			Delay300ms();
    59. 			disRight = get_distance();
    60. 			
    61. 			if(disLeft < disRight){
    62. 				goRight();
    63. 				Delay150ms();
    64. 				stop();
    65. 			}
    66. 			if(disRight < disLeft){
    67. 				goLeft();
    68. 				Delay150ms();
    69. 				stop();
    70. 			}
    71. 		}
    72. 		
    73. 	}
    74. }
    75.  
    76. //hc04.c
    77. #include "reg52.h"
    78. #include "delay.h"
    79.  
    80. sbit Trig     = P2^3;
    81. sbit Echo     = P2^2;
    82.  
    83. void Time1Init()
    84. {	
    85. 	TMOD &= 0x0F;		//设置定时器模式
    86. 	TMOD |= 0x10;
    87. 	TH1 = 0;
    88. 	TL1 = 0;
    89. 	//设置定时器0工作模式1，初始值设定0开始数数，不着急启动定时器
    90. }
    91.  
    92. void startHC()
    93. {
    94. 	Trig = 0;
    95. 	Trig = 1;
    96. 	Delay10us();
    97. 	Trig = 0;
    98. }
    99.  
    100. double get_distance()
    101. {
    102. 		double time;
    103. 		//定时器数据清零，以便下一次测距
    104. 		TH1 = 0;
    105. 		TL1 = 0;
    106. 	//1. Trig ，给Trig端口至少10us的高电平
    107. 		startHC();
    108. 		//2. echo由低电平跳转到高电平，表示开始发送波
    109. 		while(Echo == 0);
    110. 		//波发出去的那一下，开始启动定时器
    111. 		TR1 = 1;
    112. 		//3. 由高电平跳转回低电平，表示波回来了
    113. 		while(Echo == 1);
    114. 		//波回来的那一下，我们开始停止定时器
    115. 		TR1 = 0;
    116. 		//4. 计算出中间经过多少时间
    117. 		time = (TH1 * 256 + TL1)*1.085;//us为单位
    118. 		//5. 距离 = 速度 （340m/s）* 时间/2
    119. 		return  (time * 0.017);
    120. }
    121.  
    122. //delay.c
    123. #include "intrins.h"
    124.  
    125. void Delay2000ms()		//@11.0592MHz
    126. {
    127. 	unsigned char i, j, k;
    128.  
    129. 	i = 15;
    130. 	j = 2;
    131. 	k = 235;
    132. 	do
    133. 	{
    134. 		do
    135. 		{
    136. 			while (--k);
    137. 		} while (--j);
    138. 	} while (--i);
    139. }
    140.  
    141.  
    142. void Delay10us()		//@11.0592MHz
    143. {
    144. 	unsigned char i;
    145.  
    146. 	i = 2;
    147. 	while (--i);
    148. }
    149.  
    150. void Delay300ms()		//@11.0592MHz
    151. {
    152. 	unsigned char i, j, k;
    153.  
    154. 	_nop_();
    155. 	i = 3;
    156. 	j = 26;
    157. 	k = 223;
    158. 	do
    159. 	{
    160. 		do
    161. 		{
    162. 			while (--k);
    163. 		} while (--j);
    164. 	} while (--i);
    165. }
    166.  
    167.  
    168. void Delay150ms()		//@11.0592MHz
    169. {
    170. 	unsigned char i, j, k;
    171.  
    172. 	i = 2;
    173. 	j = 13;
    174. 	k = 237;
    175. 	do
    176. 	{
    177. 		do
    178. 		{
    179. 			while (--k);
    180. 		} while (--j);
    181. 	} while (--i);
    182. }
    183.  
    184. void Delay450ms()		//@11.0592MHz
    185. {
    186. 	unsigned char i, j, k;
    187.  
    188. 	_nop_();
    189. 	i = 4;
    190. 	j = 39;
    191. 	k = 209;
    192. 	do
    193. 	{
    194. 		do
    195. 		{
    196. 			while (--k);
    197. 		} while (--j);
    198. 	} while (--i);
    199. }
    200.  
    201. //sg90.c
    202. #include "reg52.h"
    203. #include "delay.h"
    204.  
    205. sbit sg90_con = P1^1;
    206.  
    207. int jd;
    208. int cnt = 0;
    209.  
    210. void Time0Init()
    211. {
    212. 	//1. 配置定时器0工作模式位16位计时
    213. 	TMOD &= 0xF0;		//设置定时器模式
    214. 	TMOD |= 0x01;
    215. 	//2. 给初值，定一个0.5出来
    216. 	TL0=0x33;
    217. 	TH0=0xFE;
    218. 	//3. 开始计时
    219. 	TR0 = 1;
    220. 	TF0 = 0;
    221. 	//4. 打开定时器0中断
    222. 	ET0 = 1;
    223. 	//5. 打开总中断EA
    224. 	EA = 1;
    225. }
    226.  
    227. void sgMiddle()
    228. {
    229. 	//中间位置
    230. 	jd = 3; //90度 1.5ms高电平
    231. 	cnt = 0;
    232. }
    233.  
    234. void sgLeft()
    235. {
    236. 	//左边位置
    237. 	jd = 5; //135度 1.5ms高电平
    238. 	cnt = 0;
    239. }
    240.  
    241. void sgRight()
    242. {
    243. 	//右边位置
    244. 	jd = 1; //0度
    245. 	cnt = 0;
    246. }
    247.  
    248.  
    249. void Time0Handler() interrupt 1
    250. {
    251. 	cnt++;  //统计爆表的次数. cnt=1的时候，报表了1
    252. 	//重新给初值
    253. 	TL0=0x33;
    254. 	TH0=0xFE;
    255. 	
    256. 	//控制PWM波
    257. 	if(cnt < jd){
    258. 		sg90_con = 1;
    259. 	}else{
    260. 		sg90_con = 0;
    261. 	}
    262. 	
    263. 	if(cnt == 40){//爆表40次，经过了20ms
    264. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    265. 		sg90_con = 1;
    266. 	}
    267. 		
    268. }
    269.  
    270. //motor.c
    271. #include "reg52.h"
    272.  
    273. sbit RightCon1A = P3^2;
    274. sbit RightCon1B = P3^3;
    275.  
    276. sbit LeftCon1A = P3^4;
    277. sbit LeftCon1B = P3^5;
    278.  
    279. void goForward()
    280. {
    281. 	LeftCon1A = 0;
    282. 	LeftCon1B = 1;
    283. 	
    284. 	RightCon1A = 0;
    285. 	RightCon1B = 1;
    286. }
    287.  
    288. void goRight()
    289. {
    290. 	LeftCon1A = 0;
    291. 	LeftCon1B = 1;
    292. 	
    293. 	RightCon1A = 0;
    294. 	RightCon1B = 0;
    295. }
    296.  
    297.  
    298. void goLeft()
    299. {
    300. 	LeftCon1A = 0;
    301. 	LeftCon1B = 0;
    302. 	
    303. 	RightCon1A = 0;
    304. 	RightCon1B = 1;
    305. }
    306.  
    307. void goBack()
    308. {
    309. 	LeftCon1A = 1;
    310. 	LeftCon1B = 0;
    311. 	
    312. 	RightCon1A = 1;
    313. 	RightCon1B = 0;
    314. }
    315.  
    316. void stop()
    317. {
    318. 	LeftCon1A = 0;
    319. 	LeftCon1B = 0;
    320. 	
    321. 	RightCon1A = 0;
    322. 	RightCon1B = 0;
    323. }
    324.  
    325.  
    326.  
    327.  
    328.  
    329.

    4.测速小车

    4.1 测速模块

    • 用途：广泛用于电机转速检测，脉冲计数,位置限位等。
    • 有遮挡，输出高电平；无遮挡，输出低电平
    • 接线 :VCC 接电源正极3.3-5V
    • GND 接电源负极 DO TTL开关信号输出
    • AO 此模块不起作用
    4.2 测试原理和单位换算
    • 轮子走一圈，经过一个周长，C = 2x3.14x半径= 3.14 x 直径（6.5cm）
    • 对应的码盘也转了一圈，码盘有20个格子，每经过一个格子，会遮挡（高电平）和不遮挡（低电平）， 那么一个脉冲就是走了 3.14 * 6.5 cm /20 = 1.0205CM
    • 定时器可以设计成一秒，统计脉冲数，一个脉冲就是1cm
    • 假设一秒有80脉冲，那么就是80cm/s
    4.3 定时器和中断实现测速开发和调试代码

    测试数据通过串口发送到上位机

    1. //main.c
    2. #include "motor.h"
    3. #include "delay.h"
    4. #include "uart.h"
    5. #include "reg52.h"
    6. #include "time.h"
    7. #include "stdio.h"
    8.  
    9. sbit speedIO = P3^2;//外部中断0
    10. unsigned int speedCnt = 0; //统计格子，脉冲次数
    11. extern unsigned int speed;//速度
    12. extern char signal; //主程序发速度数据的通知
    13. char speedMes[24];  //主程序发送速度数据的字符串缓冲区
    14.  
    15. void Ex0Init()
    16. {
    17. 	EX0 = 1;//允许中断
    18. 	//EA = 1;在串口初始化函数中已经打开了总中断
    19. 	IT0 = 1;//外部中断的下降沿触发
    20. }
    21.  
    22. void main()
    23. {
    24. 	Time0Init();//定时器0初始化
    25. 	UartInit();//串口相关初始化
    26. 	//外部中断初始化
    27. 	Ex0Init();
    28. 	
    29. 	while(1){
    30. 		if(signal){//定时器1s到点，把signal置一，主程序发送速度
    31. 			sprintf(speedMes,"speed:%d cm/s",speed);//串口数据的字符串拼装，speed是格子，每个格子1cm
    32. 			SendString(speedMes);//速度发出去
    33. 			signal = 0;//清0speed,下次由定时器1s后的中断处理中再置一
    34. 		}
    35. 	}
    36. }
    37.  
    38. void speedHandler() interrupt 0 //外部中断处理函数
    39. {
    40. 	speedCnt++;//码盘转动了一个格子
    41. }
    42.  
    43. //uart.c
    44. #include "reg52.h"
    45. #include "motor.h"
    46. #include "string.h"
    47. sbit D5 = P3^7;
    48. #define SIZE 12
    49.  
    50. sfr AUXR = 0x8E;
    51. char buffer[SIZE];
    52.  
    53. void UartInit(void)		//9600bps@11.0592MHz
    54. {
    55. 	AUXR = 0x01;
    56. 	SCON = 0x50; //配置串口工作方式1，REN使能接收
    57. 	TMOD &= 0x0F;
    58. 	TMOD |= 0x20;//定时器1工作方式位8位自动重装
    59. 	
    60. 	TH1 = 0xFD;
    61. 	TL1 = 0xFD;//9600波特率的初值
    62. 	TR1 = 1;//启动定时器
    63. 	
    64. 	EA = 1;//开启总中断
    65. 	ES = 1;//开启串口中断
    66. }
    67.  
    68.  
    69. void SendByte(char mydata)
    70. {
    71. 	SBUF = mydata;
    72. 	while(!TI);
    73. 	TI = 0;
    74. }
    75.  
    76. void SendString(char *str)
    77. {
    78. 	while(*str != '\0'){
    79. 		SendByte(*str);
    80. 		str++;
    81. 	}
    82. }
    83.  
    84.  
    85. //M1qian  M2 hou M3 zuo  M4 you
    86. void Uart_Handler() interrupt 4
    87. {
    88. 	static int i = 0;//静态变量，被初始化一次
    89. 	char tmp;
    90.  
    91. 	if(RI)//中断处理函数中，对于接收中断的响应
    92. 	{
    93. 			RI = 0;//清除接收中断标志位
    94. 			tmp = SBUF;
    95. 			if(tmp == 'M'){
    96. 				i = 0;
    97. 			}
    98. 			buffer[i++] = tmp;
    99. 		
    100. 			//灯控指令
    101. 			if(buffer[0] == 'M'){
    102. 				switch(buffer[1]){
    103. 					case '1':
    104. 						goForward();
    105. 						break;
    106. 					case '2':
    107. 						goBack();
    108. 						break;
    109. 					case '3':
    110. 						goLeft();
    111. 						break;
    112. 					case '4':
    113. 						goRight();
    114. 						break;
    115. 					default:
    116. 						stop();
    117. 						break;
    118. 				}
    119. 			}
    120. 		
    121. 			if(i == 12) {
    122. 				memset(buffer, '\0', SIZE);
    123. 				i = 0;
    124. 			}
    125. 	}
    126. 		
    127. }
    128.  
    129. //motor.c
    130. #include "reg52.h"
    131.  
    132. sbit RightCon1A = P3^7;
    133. sbit RightCon1B = P3^3;
    134.  
    135. sbit LeftCon1A = P3^4;
    136. sbit LeftCon1B = P3^5;
    137.  
    138. void goForward()
    139. {
    140. 	LeftCon1A = 0;
    141. 	LeftCon1B = 1;
    142. 	
    143. 	RightCon1A = 0;
    144. 	RightCon1B = 1;
    145. }
    146.  
    147. void goRight()
    148. {
    149. 	LeftCon1A = 0;
    150. 	LeftCon1B = 1;
    151. 	
    152. 	RightCon1A = 0;
    153. 	RightCon1B = 0;
    154. }
    155.  
    156.  
    157. void goLeft()
    158. {
    159. 	LeftCon1A = 0;
    160. 	LeftCon1B = 0;
    161. 	
    162. 	RightCon1A = 0;
    163. 	RightCon1B = 1;
    164. }
    165.  
    166. void goBack()
    167. {
    168. 	LeftCon1A = 1;
    169. 	LeftCon1B = 0;
    170. 	
    171. 	RightCon1A = 1;
    172. 	RightCon1B = 0;
    173. }
    174.  
    175. void stop()
    176. {
    177. 	LeftCon1A = 0;
    178. 	LeftCon1B = 0;
    179. 	
    180. 	RightCon1A = 0;
    181. 	RightCon1B = 0;
    182. }
    183.  
    184. //time.c
    185. #include "motor.h"
    186. #include "reg52.h"
    187.  
    188. extern unsigned int speedCnt;
    189. unsigned int speed;
    190. char signal = 0;
    191. unsigned int cnt = 0;
    192.  
    193. void Time0Init()
    194. {
    195. 	//1. 配置定时器0工作模式位16位计时
    196. 	TMOD = 0x01;
    197. 	//2. 给初值，定一个0.5出来
    198. 	TL0=0x33;
    199. 	TH0=0xFE;
    200. 	//3. 开始计时
    201. 	TR0 = 1;
    202. 	TF0 = 0;
    203. 	//4. 打开定时器0中断
    204. 	ET0 = 1;
    205. 	//5. 打开总中断EA
    206. 	EA = 1;
    207. }
    208.  
    209. void Time0Handler() interrupt 1
    210. {
    211. 	cnt++;  //统计爆表的次数. cnt=1的时候，报表了1
    212. 	//重新给初值
    213. 	TL0=0x33;
    214. 	TH0=0xFE;
    215. 	
    216. 	if(cnt == 2000){//爆表2000次，经过了1s
    217. 		signal = 1;
    218. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    219. 		//计算小车的速度，也就是拿到speedCnt的值
    220. 		speed = speedCnt;
    221. 		speedCnt = 0;//1秒后拿到speedCnt个格子，就能算出这1s的速度，格子清零
    222. 	}
    223. 		
    224. }
    4.4 小车速度显示在OLED屏

    使用oled模块

    1. //main.c
    2. #include "reg52.h"
    3. #include "intrins.h"
    4. #include "Oled.h"
    5.  
    6. void main()
    7. {
    8. 		//1. OLED初始化
    9. 		Oled_Init();
    10. 		Oled_Clear();
    11. 		Oled_Show_Str(2,2,"speed:35cm/s");
    12. 	
    13. 		while(1);
    14. }
    15.  
    16. //oled.c
    17. #include "reg52.h"
    18. #include "intrins.h"
    19. #include "Oledfont.h"
    20.  
    21.  
    22. sbit scl = P1^2;
    23. sbit sda = P1^3;
    24.  
    25. void IIC_Start()
    26. {
    27. 	scl = 0;
    28. 	sda = 1;
    29. 	scl = 1;
    30. 	_nop_();
    31. 	sda = 0;
    32. 	_nop_();
    33. }
    34.  
    35. void IIC_Stop()
    36. {
    37. 	scl = 0;
    38. 	sda = 0;
    39. 	scl = 1;
    40. 	_nop_();
    41. 	sda = 1;
    42. 	_nop_();
    43. }
    44.  
    45. char IIC_ACK()
    46. {
    47. 	char flag;
    48. 	sda = 1;//就在时钟脉冲9期间释放数据线
    49. 	_nop_();
    50. 	scl = 1;
    51. 	_nop_();
    52. 	flag = sda;
    53. 	_nop_();
    54. 	scl = 0;
    55. 	_nop_();
    56. 	
    57. 	return flag;
    58. }
    59.  
    60. void IIC_Send_Byte(char dataSend)
    61. {
    62. 	int i;
    63. 	
    64. 	for(i = 0;i<8;i++){
    65. 		scl = 0;//scl拉低，让sda做好数据准备
    66. 		sda = dataSend & 0x80;//1000 0000获得dataSend的最高位，给sda
    67. 		_nop_();//发送数据建立时间
    68. 		scl = 1;//scl拉高开始发送
    69. 		_nop_();//数据发送时间
    70. 		scl = 0;//发送完毕拉低
    71. 		_nop_();//
    72. 		dataSend = dataSend << 1;
    73. 	}
    74. }
    75.  
    76. void Oled_Write_Cmd(char dataCmd)
    77. {
    78. 	//	1. start()
    79. 	IIC_Start();
    80. 	//		
    81. 	//	2. 写入从机地址  b0111 1000 0x78
    82. 	IIC_Send_Byte(0x78);
    83. 	//	3. ACK
    84. 	IIC_ACK();
    85. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    86. 	IIC_Send_Byte(0x00);
    87. 	//	5. ACK
    88. 	IIC_ACK();
    89. 	//6. 写入指令/数据
    90. 	IIC_Send_Byte(dataCmd);
    91. 	//7. ACK
    92. 	IIC_ACK();
    93. 	//8. STOP
    94. 	IIC_Stop();
    95. }
    96.  
    97. void Oled_Write_Data(char dataData)
    98. {
    99. 	//	1. start()
    100. 	IIC_Start();
    101. 	//		
    102. 	//	2. 写入从机地址  b0111 1000 0x78
    103. 	IIC_Send_Byte(0x78);
    104. 	//	3. ACK
    105. 	IIC_ACK();
    106. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    107. 	IIC_Send_Byte(0x40);
    108. 	//	5. ACK
    109. 	IIC_ACK();
    110. 	///6. 写入指令/数据
    111. 	IIC_Send_Byte(dataData);
    112. 	//7. ACK
    113. 	IIC_ACK();
    114. 	//8. STOP
    115. 	IIC_Stop();
    116. }
    117.  
    118.  
    119. void Oled_Init(void){
    120. 	Oled_Write_Cmd(0xAE);//--display off
    121. 	Oled_Write_Cmd(0x00);//---set low column address
    122. 	Oled_Write_Cmd(0x10);//---set high column address
    123. 	Oled_Write_Cmd(0x40);//--set start line address  
    124. 	Oled_Write_Cmd(0xB0);//--set page address
    125. 	Oled_Write_Cmd(0x81); // contract control
    126. 	Oled_Write_Cmd(0xFF);//--128   
    127. 	Oled_Write_Cmd(0xA1);//set segment remap 
    128. 	Oled_Write_Cmd(0xA6);//--normal / reverse
    129. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
    130. 	Oled_Write_Cmd(0x3F);//--1/32 duty
    131. 	Oled_Write_Cmd(0xC8);//Com scan direction
    132. 	Oled_Write_Cmd(0xD3);//-set display offset
    133. 	Oled_Write_Cmd(0x00);//
    134. 	
    135. 	Oled_Write_Cmd(0xD5);//set osc division
    136. 	Oled_Write_Cmd(0x80);//
    137. 	
    138. 	Oled_Write_Cmd(0xD8);//set area color mode off
    139. 	Oled_Write_Cmd(0x05);//
    140. 	
    141. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
    142. 	Oled_Write_Cmd(0xF1);//
    143. 	
    144. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
    145. 	Oled_Write_Cmd(0x12);//
    146. 	
    147. 	Oled_Write_Cmd(0xDB);//set Vcomh
    148. 	Oled_Write_Cmd(0x30);//
    149. 	
    150. 	Oled_Write_Cmd(0x8D);//set charge pump enable
    151. 	Oled_Write_Cmd(0x14);//
    152. 	
    153. 	Oled_Write_Cmd(0xAF);//--turn on oled panel		
    154. }
    155.  
    156. void Oled_Clear()
    157. {
    158. 	unsigned char i,j; //-128 --- 127
    159. 	
    160. 	for(i=0;i<8;i++){
    161. 		Oled_Write_Cmd(0xB0 + i);//page0--page7
    162. 		//每个page从0列
    163. 		Oled_Write_Cmd(0x00);
    164. 		Oled_Write_Cmd(0x10);
    165. 		//0到127列，依次写入0，每写入数据，列地址自动偏移
    166. 		for(j = 0;j<128;j++){
    167. 			Oled_Write_Data(0);
    168. 		}
    169. 	}
    170. }
    171.  
    172. void Oled_Show_Char(char row,char col,char oledChar){ //row*2-2
    173. 	unsigned int  i;
    174. 	Oled_Write_Cmd(0xb0+(row*2-2));                           //page 0
    175. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    176. 	Oled_Write_Cmd(0x10+(col>>4));                            //high	
    177. 	for(i=((oledChar-32)*16);i<((oledChar-32)*16+8);i++){
    178. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    179. 	}
    180.  
    181. 	Oled_Write_Cmd(0xb0+(row*2-1));                           //page 1
    182. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    183. 	Oled_Write_Cmd(0x10+(col>>4));                            //high
    184. 	for(i=((oledChar-32)*16+8);i<((oledChar-32)*16+8+8);i++){
    185. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    186. 	}		
    187. }
    188.  
    189.  
    190. /******************************************************************************/
    191. // 函数名称：Oled_Show_Char 
    192. // 输入参数：oledChar 
    193. // 输出参数：无 
    194. // 函数功能：OLED显示单个字符
    195. /******************************************************************************/
    196. void Oled_Show_Str(char row,char col,char *str){
    197. 	while(*str!=0){
    198. 		Oled_Show_Char(row,col,*str);
    199. 		str++;
    200. 		col += 8;	
    201. 	}		
    202. }

    5.远程控制小车

    5.1 蓝牙控制小车
    • 使用蓝牙模块，串口透传
    • 蓝牙模块，又叫做蓝牙串口模块

    串口透传技术：

    • 透传即透明传送，是指在数据的传输过程中，通过无线的方式这组数据不发生任何形式的改变，仿 佛传输过程是透明的一样，同时保证传输的质量，原封不动地到了最终接收者手里。
    • 以太网，蓝牙，Zigbee, GPRS 等模块玩法一样，对嵌入式程序员来说，不需要关心通讯模块内部数据 及协议栈工作原理，只要通过串口编程获得数据即可

    代码实现：

    1. //main.c
    2. #include "motor.h"
    3. #include "delay.h"
    4. #include "uart.h"
    5.  
    6. void main()
    7. {
    8. 	UartInit();
    9. 	
    10. 	while(1){
    11. 		stop();
    12. 	}
    13. }
    14.  
    15. //uart.c
    16. #include "reg52.h"
    17. #include "motor.h"
    18. #include "string.h"
    19. #include "delay.h"
    20. sbit D5 = P3^7;
    21. #define SIZE 12
    22.  
    23. sfr AUXR = 0x8E;
    24. char buffer[SIZE];
    25.  
    26. void UartInit(void)		//9600bps@11.0592MHz
    27. {
    28. 	AUXR = 0x01;
    29. 	SCON = 0x50; //配置串口工作方式1，REN使能接收
    30. 	TMOD &= 0x0F;
    31. 	TMOD |= 0x20;//定时器1工作方式位8位自动重装
    32. 	
    33. 	TH1 = 0xFD;
    34. 	TL1 = 0xFD;//9600波特率的初值
    35. 	TR1 = 1;//启动定时器
    36. 	
    37. 	EA = 1;//开启总中断
    38. 	ES = 1;//开启串口中断
    39. }
    40.  
    41. //M1qian  M2 hou M3 zuo  M4 you
    42. void Uart_Handler() interrupt 4
    43. {
    44. 	static int i = 0;//静态变量，被初始化一次
    45. 	char tmp;
    46.  
    47. 	if(RI)//中断处理函数中，对于接收中断的响应
    48. 	{
    49. 			RI = 0;//清除接收中断标志位
    50. 			tmp = SBUF;
    51. 			if(tmp == 'M'){
    52. 				i = 0;
    53. 			}
    54. 			buffer[i++] = tmp;
    55. 		
    56. 			//灯控指令
    57. 			if(buffer[0] == 'M'){
    58. 				switch(buffer[1]){
    59. 					case '1':
    60. 						goForward();
    61. 						Delay10ms();
    62. 						break;
    63. 					case '2':
    64. 						goBack();
    65. 						Delay10ms();
    66. 						break;
    67. 					case '3':
    68. 						goLeft();
    69. 						Delay10ms();
    70. 						break;
    71. 					case '4':
    72. 						goRight();
    73. 						Delay10ms();
    74. 						break;
    75. 					default:
    76. 						stop();
    77. 						break;
    78. 				}
    79. 			}
    80. 		
    81. 			if(i == 12) {
    82. 				memset(buffer, '\0', SIZE);
    83. 				i = 0;
    84. 			}
    85. 	}
    86. 		
    87. }
    88.  
    89. //motor.c
    90. #include "reg52.h"
    91.  
    92. sbit RightCon1A = P3^2;
    93. sbit RightCon1B = P3^3;
    94.  
    95. sbit LeftCon1A = P3^4;
    96. sbit LeftCon1B = P3^5;
    97.  
    98. void goForward()
    99. {
    100. 	LeftCon1A = 0;
    101. 	LeftCon1B = 1;
    102. 	
    103. 	RightCon1A = 0;
    104. 	RightCon1B = 1;
    105. }
    106.  
    107. void goRight()
    108. {
    109. 	LeftCon1A = 0;
    110. 	LeftCon1B = 1;
    111. 	
    112. 	RightCon1A = 0;
    113. 	RightCon1B = 0;
    114. }
    115.  
    116.  
    117. void goLeft()
    118. {
    119. 	LeftCon1A = 0;
    120. 	LeftCon1B = 0;
    121. 	
    122. 	RightCon1A = 0;
    123. 	RightCon1B = 1;
    124. }
    125.  
    126. void goBack()
    127. {
    128. 	LeftCon1A = 1;
    129. 	LeftCon1B = 0;
    130. 	
    131. 	RightCon1A = 1;
    132. 	RightCon1B = 0;
    133. }
    134.  
    135. void stop()
    136. {
    137. 	LeftCon1A = 0;
    138. 	LeftCon1B = 0;
    139. 	
    140. 	RightCon1A = 0;
    141. 	RightCon1B = 0;
    142. }
    143.  
    144. //delay.c
    145.  
    146. #include "intrins.h"
    147.  
    148. void Delay10ms()		//@11.0592MHz
    149. {
    150. 	unsigned char i, j;
    151.  
    152. 	i = 18;
    153. 	j = 235;
    154. 	do
    155. 	{
    156. 		while (--j);
    157. 	} while (--i);
    158. }
    159.  
    160. void Delay1000ms()		//@11.0592MHz
    161. {
    162. 	unsigned char i, j, k;
    163.  
    164. 	_nop_();
    165. 	i = 8;
    166. 	j = 1;
    167. 	k = 243;
    168. 	do
    169. 	{
    170. 		do
    171. 		{
    172. 			while (--k);
    173. 		} while (--j);
    174. 	} while (--i);
    175. }
    176.  
    177.  
    178.
    5.2 蓝牙控制并测速小车

    原理：运用上面讲到的蓝牙模块和测速模块

    代码实现：

    1. //main.c
    2. #include "motor.h"
    3. #include "delay.h"
    4. #include "uart.h"
    5. #include "reg52.h"
    6. #include "time.h"
    7. #include "stdio.h"
    8. #include "Oled.h"
    9.  
    10. sbit speedIO = P3^2;//外部中断0
    11. unsigned int speedCnt = 0; //统计格子，脉冲次数
    12. extern unsigned int speed;//速度
    13. extern char signal; //主程序发速度数据的通知
    14. char speedMes[24];  //主程序发送速度数据的字符串缓冲区
    15.  
    16. void Ex0Init()
    17. {
    18. 	EX0 = 1;//允许中断
    19. 	//EA = 1;在串口初始化函数中已经打开了总中断
    20. 	IT0 = 1;//外部中断的下降沿触发
    21. }
    22.  
    23. void main()
    24. {
    25. 	Time0Init();//定时器0初始化
    26. 	UartInit();//串口相关初始化
    27. 	//外部中断初始化
    28. 	Ex0Init();
    29. 	Oled_Init();
    30. 	Oled_Clear();
    31. 	while(1){
    32. 		if(signal){//定时器1s到点，把signal置一，主程序发送速度
    33. 			sprintf(speedMes,"speed:%d cm/s",speed);//串口数据的字符串拼装，speed是格子，每个格子1cm
    34. 			SendString(speedMes);//速度发出去
    35. 		
    36. 			signal = 0;//清0speed,下次由定时器1s后的中断处理中再置一
    37. 		}
    38. 		Oled_Show_Str(2,2,speedMes);
    39. 	}
    40. }
    41.  
    42. void speedHandler() interrupt 0 //外部中断处理函数
    43. {
    44. 	speedCnt++;//码盘转动了一个格子
    45. }
    46.  
    47. //uart.c
    48. #include "reg52.h"
    49. #include "motor.h"
    50. #include "string.h"
    51. sbit D5 = P3^7;
    52. #define SIZE 12
    53.  
    54. sfr AUXR = 0x8E;
    55. char buffer[SIZE];
    56.  
    57. void UartInit(void)		//9600bps@11.0592MHz
    58. {
    59. 	AUXR = 0x01;
    60. 	SCON = 0x50; //配置串口工作方式1，REN使能接收
    61. 	TMOD &= 0x0F;
    62. 	TMOD |= 0x20;//定时器1工作方式位8位自动重装
    63. 	
    64. 	TH1 = 0xFD;
    65. 	TL1 = 0xFD;//9600波特率的初值
    66. 	TR1 = 1;//启动定时器
    67. 	
    68. 	EA = 1;//开启总中断
    69. 	ES = 1;//开启串口中断
    70. }
    71.  
    72.  
    73. void SendByte(char mydata)
    74. {
    75. 	SBUF = mydata;
    76. 	while(!TI);
    77. 	TI = 0;
    78. }
    79.  
    80. void SendString(char *str)
    81. {
    82. 	while(*str != '\0'){
    83. 		SendByte(*str);
    84. 		str++;
    85. 	}
    86. }
    87.  
    88.  
    89. //M1qian  M2 hou M3 zuo  M4 you
    90. void Uart_Handler() interrupt 4
    91. {
    92. 	static int i = 0;//静态变量，被初始化一次
    93. 	char tmp;
    94.  
    95. 	if(RI)//中断处理函数中，对于接收中断的响应
    96. 	{
    97. 			RI = 0;//清除接收中断标志位
    98. 			tmp = SBUF;
    99. 			if(tmp == 'M'){
    100. 				i = 0;
    101. 			}
    102. 			buffer[i++] = tmp;
    103. 		
    104. 			//灯控指令
    105. 			if(buffer[0] == 'M'){
    106. 				switch(buffer[1]){
    107. 					case '1':
    108. 						goForward();
    109. 						break;
    110. 					case '2':
    111. 						goBack();
    112. 						break;
    113. 					case '3':
    114. 						goLeft();
    115. 						break;
    116. 					case '4':
    117. 						goRight();
    118. 						break;
    119. 					default:
    120. 						stop();
    121. 						break;
    122. 				}
    123. 			}
    124. 		
    125. 			if(i == 12) {
    126. 				memset(buffer, '\0', SIZE);
    127. 				i = 0;
    128. 			}
    129. 	}
    130. 		
    131. }
    132.  
    133. //motor.c
    134. #include "reg52.h"
    135.  
    136. sbit RightCon1A = P3^7;
    137. sbit RightCon1B = P3^3;
    138.  
    139. sbit LeftCon1A = P3^4;
    140. sbit LeftCon1B = P3^5;
    141.  
    142. void goForward()
    143. {
    144. 	LeftCon1A = 0;
    145. 	LeftCon1B = 1;
    146. 	
    147. 	RightCon1A = 0;
    148. 	RightCon1B = 1;
    149. }
    150.  
    151. void goRight()
    152. {
    153. 	LeftCon1A = 0;
    154. 	LeftCon1B = 1;
    155. 	
    156. 	RightCon1A = 0;
    157. 	RightCon1B = 0;
    158. }
    159.  
    160.  
    161. void goLeft()
    162. {
    163. 	LeftCon1A = 0;
    164. 	LeftCon1B = 0;
    165. 	
    166. 	RightCon1A = 0;
    167. 	RightCon1B = 1;
    168. }
    169.  
    170. void goBack()
    171. {
    172. 	LeftCon1A = 1;
    173. 	LeftCon1B = 0;
    174. 	
    175. 	RightCon1A = 1;
    176. 	RightCon1B = 0;
    177. }
    178.  
    179. void stop()
    180. {
    181. 	LeftCon1A = 0;
    182. 	LeftCon1B = 0;
    183. 	
    184. 	RightCon1A = 0;
    185. 	RightCon1B = 0;
    186. }
    187.  
    188. //time.c
    189. #include "motor.h"
    190. #include "reg52.h"
    191.  
    192. extern unsigned int speedCnt;
    193. unsigned int speed;
    194. char signal = 0;
    195. unsigned int cnt = 0;
    196.  
    197. void Time0Init()
    198. {
    199. 	//1. 配置定时器0工作模式位16位计时
    200. 	TMOD = 0x01;
    201. 	//2. 给初值，定一个0.5出来
    202. 	TL0=0x33;
    203. 	TH0=0xFE;
    204. 	//3. 开始计时
    205. 	TR0 = 1;
    206. 	TF0 = 0;
    207. 	//4. 打开定时器0中断
    208. 	ET0 = 1;
    209. 	//5. 打开总中断EA
    210. 	EA = 1;
    211. }
    212.  
    213. void Time0Handler() interrupt 1
    214. {
    215. 	cnt++;  //统计爆表的次数. cnt=1的时候，报表了1
    216. 	//重新给初值
    217. 	TL0=0x33;
    218. 	TH0=0xFE;
    219. 	
    220. 	if(cnt == 2000){//爆表2000次，经过了1s
    221. 		signal = 1;
    222. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    223. 		//计算小车的速度，也就是拿到speedCnt的值
    224. 		speed = speedCnt;
    225. 		speedCnt = 0;//1秒后拿到speedCnt个格子，就能算出这1s的速度，格子清零
    226. 	}
    227. 		
    228. }
    229.  
    230. //oled.c
    231. #include "reg52.h"
    232. #include "intrins.h"
    233. #include "Oledfont.h"
    234.  
    235.  
    236. sbit scl = P1^2;
    237. sbit sda = P1^3;
    238.  
    239. void IIC_Start()
    240. {
    241. 	scl = 0;
    242. 	sda = 1;
    243. 	scl = 1;
    244. 	_nop_();
    245. 	sda = 0;
    246. 	_nop_();
    247. }
    248.  
    249. void IIC_Stop()
    250. {
    251. 	scl = 0;
    252. 	sda = 0;
    253. 	scl = 1;
    254. 	_nop_();
    255. 	sda = 1;
    256. 	_nop_();
    257. }
    258.  
    259. char IIC_ACK()
    260. {
    261. 	char flag;
    262. 	sda = 1;//就在时钟脉冲9期间释放数据线
    263. 	_nop_();
    264. 	scl = 1;
    265. 	_nop_();
    266. 	flag = sda;
    267. 	_nop_();
    268. 	scl = 0;
    269. 	_nop_();
    270. 	
    271. 	return flag;
    272. }
    273.  
    274. void IIC_Send_Byte(char dataSend)
    275. {
    276. 	int i;
    277. 	
    278. 	for(i = 0;i<8;i++){
    279. 		scl = 0;//scl拉低，让sda做好数据准备
    280. 		sda = dataSend & 0x80;//1000 0000获得dataSend的最高位，给sda
    281. 		_nop_();//发送数据建立时间
    282. 		scl = 1;//scl拉高开始发送
    283. 		_nop_();//数据发送时间
    284. 		scl = 0;//发送完毕拉低
    285. 		_nop_();//
    286. 		dataSend = dataSend << 1;
    287. 	}
    288. }
    289.  
    290. void Oled_Write_Cmd(char dataCmd)
    291. {
    292. 	//	1. start()
    293. 	IIC_Start();
    294. 	//		
    295. 	//	2. 写入从机地址  b0111 1000 0x78
    296. 	IIC_Send_Byte(0x78);
    297. 	//	3. ACK
    298. 	IIC_ACK();
    299. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    300. 	IIC_Send_Byte(0x00);
    301. 	//	5. ACK
    302. 	IIC_ACK();
    303. 	//6. 写入指令/数据
    304. 	IIC_Send_Byte(dataCmd);
    305. 	//7. ACK
    306. 	IIC_ACK();
    307. 	//8. STOP
    308. 	IIC_Stop();
    309. }
    310.  
    311. void Oled_Write_Data(char dataData)
    312. {
    313. 	//	1. start()
    314. 	IIC_Start();
    315. 	//		
    316. 	//	2. 写入从机地址  b0111 1000 0x78
    317. 	IIC_Send_Byte(0x78);
    318. 	//	3. ACK
    319. 	IIC_ACK();
    320. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    321. 	IIC_Send_Byte(0x40);
    322. 	//	5. ACK
    323. 	IIC_ACK();
    324. 	///6. 写入指令/数据
    325. 	IIC_Send_Byte(dataData);
    326. 	//7. ACK
    327. 	IIC_ACK();
    328. 	//8. STOP
    329. 	IIC_Stop();
    330. }
    331.  
    332.  
    333. void Oled_Init(void){
    334. 	Oled_Write_Cmd(0xAE);//--display off
    335. 	Oled_Write_Cmd(0x00);//---set low column address
    336. 	Oled_Write_Cmd(0x10);//---set high column address
    337. 	Oled_Write_Cmd(0x40);//--set start line address  
    338. 	Oled_Write_Cmd(0xB0);//--set page address
    339. 	Oled_Write_Cmd(0x81); // contract control
    340. 	Oled_Write_Cmd(0xFF);//--128   
    341. 	Oled_Write_Cmd(0xA1);//set segment remap 
    342. 	Oled_Write_Cmd(0xA6);//--normal / reverse
    343. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
    344. 	Oled_Write_Cmd(0x3F);//--1/32 duty
    345. 	Oled_Write_Cmd(0xC8);//Com scan direction
    346. 	Oled_Write_Cmd(0xD3);//-set display offset
    347. 	Oled_Write_Cmd(0x00);//
    348. 	
    349. 	Oled_Write_Cmd(0xD5);//set osc division
    350. 	Oled_Write_Cmd(0x80);//
    351. 	
    352. 	Oled_Write_Cmd(0xD8);//set area color mode off
    353. 	Oled_Write_Cmd(0x05);//
    354. 	
    355. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
    356. 	Oled_Write_Cmd(0xF1);//
    357. 	
    358. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
    359. 	Oled_Write_Cmd(0x12);//
    360. 	
    361. 	Oled_Write_Cmd(0xDB);//set Vcomh
    362. 	Oled_Write_Cmd(0x30);//
    363. 	
    364. 	Oled_Write_Cmd(0x8D);//set charge pump enable
    365. 	Oled_Write_Cmd(0x14);//
    366. 	
    367. 	Oled_Write_Cmd(0xAF);//--turn on oled panel		
    368. }
    369.  
    370. void Oled_Clear()
    371. {
    372. 	unsigned char i,j; //-128 --- 127
    373. 	
    374. 	for(i=0;i<8;i++){
    375. 		Oled_Write_Cmd(0xB0 + i);//page0--page7
    376. 		//每个page从0列
    377. 		Oled_Write_Cmd(0x00);
    378. 		Oled_Write_Cmd(0x10);
    379. 		//0到127列，依次写入0，每写入数据，列地址自动偏移
    380. 		for(j = 0;j<128;j++){
    381. 			Oled_Write_Data(0);
    382. 		}
    383. 	}
    384. }
    385.  
    386. void Oled_Show_Char(char row,char col,char oledChar){ //row*2-2
    387. 	unsigned int  i;
    388. 	Oled_Write_Cmd(0xb0+(row*2-2));                           //page 0
    389. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    390. 	Oled_Write_Cmd(0x10+(col>>4));                            //high	
    391. 	for(i=((oledChar-32)*16);i<((oledChar-32)*16+8);i++){
    392. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    393. 	}
    394.  
    395. 	Oled_Write_Cmd(0xb0+(row*2-1));                           //page 1
    396. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    397. 	Oled_Write_Cmd(0x10+(col>>4));                            //high
    398. 	for(i=((oledChar-32)*16+8);i<((oledChar-32)*16+8+8);i++){
    399. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    400. 	}		
    401. }
    402.  
    403.  
    404. /******************************************************************************/
    405. // 函数名称：Oled_Show_Char 
    406. // 输入参数：oledChar 
    407. // 输出参数：无 
    408. // 函数功能：OLED显示单个字符
    409. /******************************************************************************/
    410. void Oled_Show_Str(char row,char col,char *str){
    411. 	while(*str!=0){
    412. 		Oled_Show_Char(row,col,*str);
    413. 		str++;
    414. 		col += 8;	
    415. 	}		
    416. }
    417.

    5.3 wifi控制测速小车
    • Wifi模块-ESP-01s
    • 蓝牙，ESP-01s，Zigbee, NB-Iot等通信模块都是基于AT指令的设计

    AT指令介绍：

    • AT指令集是从终端设备（Terminal Equipment，TE)或数据终端设备（Data Terminal Equipment，DTE)向终端适配器(Terminal Adapter，TA)或数据电路终端设备(Data Circuit Terminal Equipment，DCE)发送的。
    • 其对所传输的数据包大小有定义：即对于AT指令的发送，除AT两个字符外，最多可以接收1056个 字符的长度（包括最后的空字符）。
    • 每个AT命令行中只能包含一条AT指令；对于由终端设备主动向PC端报告的URC指示或者response 响应，也要求一行最多有一个，不允许上报的一行中有多条指示或者响应。AT指令以回车作为结 尾，响应或上报以回车换行为结尾。

    代码实现：

    1. //main.c
    2. #include "motor.h"
    3. #include "delay.h"
    4. #include "uart.h"
    5. #include "reg52.h"
    6. #include "time.h"
    7. #include "stdio.h"
    8. #include "Oled.h"
    9. #include "esp8266.h"
    10.  
    11. sbit speedIO = P3^2;//外部中断0
    12. unsigned int speedCnt = 0; //统计格子，脉冲次数
    13. extern unsigned int speed;//速度
    14. extern char signal; //主程序发速度数据的通知
    15. char speedMes[24];  //主程序发送速度数据的字符串缓冲区
    16. //发送数据
    17. char FSSJ[] = "AT+CIPSEND=0,5\r\n";
    18.  
    19. void Ex0Init()
    20. {
    21. 	EX0 = 1;//允许中断
    22. 	//EA = 1;在串口初始化函数中已经打开了总中断
    23. 	IT0 = 1;//外部中断的下降沿触发
    24. }
    25.  
    26. void main()
    27. {
    28. 	Time0Init();//定时器0初始化
    29. 	UartInit();//串口相关初始化
    30. 	Delay1000ms();//给espwifi模块上电时间
    31. 	
    32. 	initWifi_AP(); //初始化wifi工作在ap模式
    33. 	waitConnect(); //等待客户端的连接
    34. 	
    35. 	//外部中断初始化
    36. 	Ex0Init();
    37. 	Oled_Init();
    38. 	Oled_Clear();
    39. 	while(1){
    40. 		if(signal){//定时器1s到点，把signal置一，主程序发送速度
    41. 			SendString(FSSJ);
    42. 			Delay1000ms();
    43. 			sprintf(speedMes,"%dcms",speed);//串口数据的字符串拼装，speed是格子，每个格子1cm
    44. 			SendString(speedMes);//速度发出去
    45. 		
    46. 			signal = 0;//清0speed,下次由定时器1s后的中断处理中再置一
    47. 		}
    48. 		Oled_Show_Str(2,2,speedMes);
    49. 	}
    50. }
    51.  
    52. void speedHandler() interrupt 0 //外部中断处理函数
    53. {
    54. 	speedCnt++;//码盘转动了一个格子
    55. }
    56.  
    57. //uart.c
    58. #include "reg52.h"
    59. #include "motor.h"
    60. #include "string.h"
    61. sbit D5 = P3^7;
    62. #define SIZE 12
    63.  
    64. sfr AUXR = 0x8E;
    65. char buffer[SIZE];
    66.  
    67. extern char AT_OK_Flag;				//OK返回值的标志位
    68. extern char Client_Connect_Flag;
    69.  
    70. void UartInit(void)		//9600bps@11.0592MHz
    71. {
    72. 	AUXR = 0x01;
    73. 	SCON = 0x50; //配置串口工作方式1，REN使能接收
    74. 	TMOD &= 0x0F;
    75. 	TMOD |= 0x20;//定时器1工作方式位8位自动重装
    76. 	
    77. 	TH1 = 0xFD;
    78. 	TL1 = 0xFD;//9600波特率的初值
    79. 	TR1 = 1;//启动定时器
    80. 	
    81. 	EA = 1;//开启总中断
    82. 	ES = 1;//开启串口中断
    83. }
    84.  
    85.  
    86. void SendByte(char mydata)
    87. {
    88. 	SBUF = mydata;
    89. 	while(!TI);
    90. 	TI = 0;
    91. }
    92.  
    93. void SendString(char *str)
    94. {
    95. 	while(*str != '\0'){
    96. 		SendByte(*str);
    97. 		str++;
    98. 	}
    99. }
    100.  
    101.  
    102. //M1qian  M2 hou M3 zuo  M4 you
    103. void Uart_Handler() interrupt 4
    104. {
    105. 	static int i = 0;//静态变量，被初始化一次
    106. 	char tmp;
    107.  
    108. 	if(RI)//中断处理函数中，对于接收中断的响应
    109. 	{
    110. 			RI = 0;//清除接收中断标志位
    111. 			tmp = SBUF;
    112. 			if(tmp == 'M' || tmp == 'O' || tmp == '0'){
    113. 				i = 0;
    114. 			}
    115. 			buffer[i++] = tmp;
    116. 		
    117. 			//连接服务器等OK返回值指令的判断
    118. 			if(buffer[0] == 'O' && buffer[1] == 'K'){
    119. 				AT_OK_Flag	= 1;
    120. 				memset(buffer, '\0', SIZE);
    121. 			}
    122. 			
    123. 			if(buffer[0] == '0' && buffer[2] == 'C'){
    124. 				Client_Connect_Flag	= 1;
    125. 				memset(buffer, '\0', SIZE);
    126. 			}
    127. 			//灯控指令
    128. 			if(buffer[0] == 'M'){
    129. 				switch(buffer[1]){
    130. 					case '1':
    131. 						goForward();
    132. 						break;
    133. 					case '2':
    134. 						goBack();
    135. 						break;
    136. 					case '3':
    137. 						goLeft();
    138. 						break;
    139. 					case '4':
    140. 						goRight();
    141. 						break;
    142. 					default:
    143. 						stop();
    144. 						break;
    145. 				}
    146. 			}
    147. 		
    148. 			if(i == 12) {
    149. 				memset(buffer, '\0', SIZE);
    150. 				i = 0;
    151. 			}
    152. 	}
    153. 		
    154. }
    155.  
    156. //motor.c
    157. #include "reg52.h"
    158.  
    159. sbit RightCon1A = P3^7;
    160. sbit RightCon1B = P3^3;
    161.  
    162. sbit LeftCon1A = P3^4;
    163. sbit LeftCon1B = P3^5;
    164.  
    165. void goForward()
    166. {
    167. 	LeftCon1A = 0;
    168. 	LeftCon1B = 1;
    169. 	
    170. 	RightCon1A = 0;
    171. 	RightCon1B = 1;
    172. }
    173.  
    174. void goRight()
    175. {
    176. 	LeftCon1A = 0;
    177. 	LeftCon1B = 1;
    178. 	
    179. 	RightCon1A = 0;
    180. 	RightCon1B = 0;
    181. }
    182.  
    183.  
    184. void goLeft()
    185. {
    186. 	LeftCon1A = 0;
    187. 	LeftCon1B = 0;
    188. 	
    189. 	RightCon1A = 0;
    190. 	RightCon1B = 1;
    191. }
    192.  
    193. void goBack()
    194. {
    195. 	LeftCon1A = 1;
    196. 	LeftCon1B = 0;
    197. 	
    198. 	RightCon1A = 1;
    199. 	RightCon1B = 0;
    200. }
    201.  
    202. void stop()
    203. {
    204. 	LeftCon1A = 0;
    205. 	LeftCon1B = 0;
    206. 	
    207. 	RightCon1A = 0;
    208. 	RightCon1B = 0;
    209. }
    210.  
    211. //time.c
    212. #include "motor.h"
    213. #include "reg52.h"
    214.  
    215. extern unsigned int speedCnt;
    216. unsigned int speed;
    217. char signal = 0;
    218. unsigned int cnt = 0;
    219.  
    220. void Time0Init()
    221. {
    222. 	//1. 配置定时器0工作模式位16位计时
    223. 	TMOD = 0x01;
    224. 	//2. 给初值，定一个0.5出来
    225. 	TL0=0x33;
    226. 	TH0=0xFE;
    227. 	//3. 开始计时
    228. 	TR0 = 1;
    229. 	TF0 = 0;
    230. 	//4. 打开定时器0中断
    231. 	ET0 = 1;
    232. 	//5. 打开总中断EA
    233. 	EA = 1;
    234. }
    235.  
    236. void Time0Handler() interrupt 1
    237. {
    238. 	cnt++;  //统计爆表的次数. cnt=1的时候，报表了1
    239. 	//重新给初值
    240. 	TL0=0x33;
    241. 	TH0=0xFE;
    242. 	
    243. 	if(cnt == 2000){//爆表2000次，经过了1s
    244. 		signal = 1;
    245. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    246. 		//计算小车的速度，也就是拿到speedCnt的值
    247. 		speed = speedCnt;
    248. 		speedCnt = 0;//1秒后拿到speedCnt个格子，就能算出这1s的速度，格子清零
    249. 	}
    250. 		
    251. }
    252.  
    253. //oled.c
    254. #include "reg52.h"
    255. #include "intrins.h"
    256. #include "Oledfont.h"
    257.  
    258.  
    259. sbit scl = P1^2;
    260. sbit sda = P1^3;
    261.  
    262. void IIC_Start()
    263. {
    264. 	scl = 0;
    265. 	sda = 1;
    266. 	scl = 1;
    267. 	_nop_();
    268. 	sda = 0;
    269. 	_nop_();
    270. }
    271.  
    272. void IIC_Stop()
    273. {
    274. 	scl = 0;
    275. 	sda = 0;
    276. 	scl = 1;
    277. 	_nop_();
    278. 	sda = 1;
    279. 	_nop_();
    280. }
    281.  
    282. char IIC_ACK()
    283. {
    284. 	char flag;
    285. 	sda = 1;//就在时钟脉冲9期间释放数据线
    286. 	_nop_();
    287. 	scl = 1;
    288. 	_nop_();
    289. 	flag = sda;
    290. 	_nop_();
    291. 	scl = 0;
    292. 	_nop_();
    293. 	
    294. 	return flag;
    295. }
    296.  
    297. void IIC_Send_Byte(char dataSend)
    298. {
    299. 	int i;
    300. 	
    301. 	for(i = 0;i<8;i++){
    302. 		scl = 0;//scl拉低，让sda做好数据准备
    303. 		sda = dataSend & 0x80;//1000 0000获得dataSend的最高位，给sda
    304. 		_nop_();//发送数据建立时间
    305. 		scl = 1;//scl拉高开始发送
    306. 		_nop_();//数据发送时间
    307. 		scl = 0;//发送完毕拉低
    308. 		_nop_();//
    309. 		dataSend = dataSend << 1;
    310. 	}
    311. }
    312.  
    313. void Oled_Write_Cmd(char dataCmd)
    314. {
    315. 	//	1. start()
    316. 	IIC_Start();
    317. 	//		
    318. 	//	2. 写入从机地址  b0111 1000 0x78
    319. 	IIC_Send_Byte(0x78);
    320. 	//	3. ACK
    321. 	IIC_ACK();
    322. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    323. 	IIC_Send_Byte(0x00);
    324. 	//	5. ACK
    325. 	IIC_ACK();
    326. 	//6. 写入指令/数据
    327. 	IIC_Send_Byte(dataCmd);
    328. 	//7. ACK
    329. 	IIC_ACK();
    330. 	//8. STOP
    331. 	IIC_Stop();
    332. }
    333.  
    334. void Oled_Write_Data(char dataData)
    335. {
    336. 	//	1. start()
    337. 	IIC_Start();
    338. 	//		
    339. 	//	2. 写入从机地址  b0111 1000 0x78
    340. 	IIC_Send_Byte(0x78);
    341. 	//	3. ACK
    342. 	IIC_ACK();
    343. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    344. 	IIC_Send_Byte(0x40);
    345. 	//	5. ACK
    346. 	IIC_ACK();
    347. 	///6. 写入指令/数据
    348. 	IIC_Send_Byte(dataData);
    349. 	//7. ACK
    350. 	IIC_ACK();
    351. 	//8. STOP
    352. 	IIC_Stop();
    353. }
    354.  
    355.  
    356. void Oled_Init(void){
    357. 	Oled_Write_Cmd(0xAE);//--display off
    358. 	Oled_Write_Cmd(0x00);//---set low column address
    359. 	Oled_Write_Cmd(0x10);//---set high column address
    360. 	Oled_Write_Cmd(0x40);//--set start line address  
    361. 	Oled_Write_Cmd(0xB0);//--set page address
    362. 	Oled_Write_Cmd(0x81); // contract control
    363. 	Oled_Write_Cmd(0xFF);//--128   
    364. 	Oled_Write_Cmd(0xA1);//set segment remap 
    365. 	Oled_Write_Cmd(0xA6);//--normal / reverse
    366. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
    367. 	Oled_Write_Cmd(0x3F);//--1/32 duty
    368. 	Oled_Write_Cmd(0xC8);//Com scan direction
    369. 	Oled_Write_Cmd(0xD3);//-set display offset
    370. 	Oled_Write_Cmd(0x00);//
    371. 	
    372. 	Oled_Write_Cmd(0xD5);//set osc division
    373. 	Oled_Write_Cmd(0x80);//
    374. 	
    375. 	Oled_Write_Cmd(0xD8);//set area color mode off
    376. 	Oled_Write_Cmd(0x05);//
    377. 	
    378. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
    379. 	Oled_Write_Cmd(0xF1);//
    380. 	
    381. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
    382. 	Oled_Write_Cmd(0x12);//
    383. 	
    384. 	Oled_Write_Cmd(0xDB);//set Vcomh
    385. 	Oled_Write_Cmd(0x30);//
    386. 	
    387. 	Oled_Write_Cmd(0x8D);//set charge pump enable
    388. 	Oled_Write_Cmd(0x14);//
    389. 	
    390. 	Oled_Write_Cmd(0xAF);//--turn on oled panel		
    391. }
    392.  
    393. void Oled_Clear()
    394. {
    395. 	unsigned char i,j; //-128 --- 127
    396. 	
    397. 	for(i=0;i<8;i++){
    398. 		Oled_Write_Cmd(0xB0 + i);//page0--page7
    399. 		//每个page从0列
    400. 		Oled_Write_Cmd(0x00);
    401. 		Oled_Write_Cmd(0x10);
    402. 		//0到127列，依次写入0，每写入数据，列地址自动偏移
    403. 		for(j = 0;j<128;j++){
    404. 			Oled_Write_Data(0);
    405. 		}
    406. 	}
    407. }
    408.  
    409. void Oled_Show_Char(char row,char col,char oledChar){ //row*2-2
    410. 	unsigned int  i;
    411. 	Oled_Write_Cmd(0xb0+(row*2-2));                           //page 0
    412. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    413. 	Oled_Write_Cmd(0x10+(col>>4));                            //high	
    414. 	for(i=((oledChar-32)*16);i<((oledChar-32)*16+8);i++){
    415. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    416. 	}
    417.  
    418. 	Oled_Write_Cmd(0xb0+(row*2-1));                           //page 1
    419. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    420. 	Oled_Write_Cmd(0x10+(col>>4));                            //high
    421. 	for(i=((oledChar-32)*16+8);i<((oledChar-32)*16+8+8);i++){
    422. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    423. 	}		
    424. }
    425.  
    426.  
    427. /******************************************************************************/
    428. // 函数名称：Oled_Show_Char 
    429. // 输入参数：oledChar 
    430. // 输出参数：无 
    431. // 函数功能：OLED显示单个字符
    432. /******************************************************************************/
    433. void Oled_Show_Str(char row,char col,char *str){
    434. 	while(*str!=0){
    435. 		Oled_Show_Char(row,col,*str);
    436. 		str++;
    437. 		col += 8;	
    438. 	}		
    439. }
    440.  
    441.  
    442. //esp8266.c
    443. #include "uart.h"
    444.  
    445. //1 工作在路由模式
    446. code char LYMO[] = "AT+CWMODE=2\r\n";
    447. //2 使能多链接
    448. code char DLJ[] = "AT+CIPMUX=1\r\n"; 
    449. //3 建立TCPServer
    450. code char JLFW[] = "AT+CIPSERVER=1\r\n"; // default port = 333 
    451.  
    452.  
    453.  
    454. char AT_OK_Flag = 0;				//OK返回值的标志位
    455. char Client_Connect_Flag = 0;
    456.  
    457. void initWifi_AP()
    458. {
    459. 	SendString(LYMO);
    460. 	while(!AT_OK_Flag);
    461. 	AT_OK_Flag = 0;
    462. 	SendString(DLJ);
    463. 	while(!AT_OK_Flag);
    464. 	AT_OK_Flag = 0;
    465. }
    466.  
    467. void waitConnect()
    468. {
    469. 	SendString(JLFW);
    470. 	while(!Client_Connect_Flag);
    471. 	AT_OK_Flag = 0;	
    472. }
    473.  
    474. //delay.c
    475. #include "intrins.h"
    476.  
    477. void Delay1000ms()		//@11.0592MHz
    478. {
    479. 	unsigned char i, j, k;
    480.  
    481. 	_nop_();
    482. 	i = 8;
    483. 	j = 1;
    484. 	k = 243;
    485. 	do
    486. 	{
    487. 		do
    488. 		{
    489. 			while (--k);
    490. 		} while (--j);
    491. 	} while (--i);
    492. }
    493.
    5.4 4g控制小车

    原理：运用EC03-DNC4G通信模块

    模块介绍：

    • 基于串口AT指令的开发方式
    • 有两种工作模式，默认是透传模式，通过其他方式进入AT指令模式
    • 注意插卡不要出错，下图红色位置为SIM卡状态灯，亮才是正常

    代码不做修改，直接基于蓝牙小车整合， 4g模块只要做好外网透传就可以了

    6.语音控制小车

    6.1语音模块配置：

    使用SU-03T / LD3320

    具体介绍看我之前写过的博客：SU-03T语音模块的使用_罗小白的干爹的博客-CSDN博客

    6.2 语音控制小车开发和调试代码

    代码示例：

    1. //main.c
    2. #include "reg52.h"
    3. #include "hc04.h"
    4. #include "delay.h"
    5. #include "sg90.h"
    6. #include "Oled.h"
    7. #include "motor.h"
    8.  
    9. #define MIDDLE 0
    10. #define LEFT 1
    11. #define RIGHT 2
    12.  
    13. #define BZ 1
    14. #define XJ 2
    15. #define GS 3
    16.  
    17.  
    18. sbit A25 = P1^5;
    19. sbit A26 = P1^6;
    20. sbit A27 = P1^7;
    21.  
    22. sbit leftSensorX = P2^7;
    23. sbit rightSensorX = P2^6;
    24.  
    25. sbit leftSensorG = P2^5;
    26. sbit rightSensorG = P2^4;
    27.  
    28. char dir;
    29. 	
    30. double disMiddle;
    31. double disLeft;
    32. double disRight;
    33.  
    34. void xunjiMode()
    35. {
    36. 		if(leftSensorX == 0 && rightSensorX == 0){
    37. 			goForward();
    38. 		}
    39. 		if(leftSensorX == 1 && rightSensorX == 0){
    40. 			goLeft();
    41. 		}
    42. 		
    43. 		if(leftSensorX == 0 && rightSensorX == 1){
    44. 			goRight();
    45. 		}
    46. 		
    47. 		if(leftSensorX == 1 && rightSensorX == 1){
    48. 			//停
    49. 			stop();
    50. 		}
    51. }
    52.  
    53. void gensuiMode()
    54. {
    55. 		if(leftSensorG == 0 && rightSensorG == 0){
    56. 			goForward();
    57. 		}
    58. 		if(leftSensorG == 1 && rightSensorG == 0){
    59. 			goRight();
    60. 		}
    61. 		
    62. 		if(leftSensorG == 0 && rightSensorG == 1){
    63. 			
    64. 			goLeft();
    65. 		}
    66. 		
    67. 		if(leftSensorG == 1 && rightSensorG == 1){
    68. 			//停
    69. 			stop();
    70. 		}
    71. }
    72.  
    73. void bizhangMode()
    74. {
    75. 	if(dir != MIDDLE){
    76. 			sgMiddle();
    77. 			dir = MIDDLE;
    78. 			Delay300ms();
    79. 		}
    80. 		disMiddle = get_distance();
    81. 		
    82. 		if(disMiddle > 35){
    83. 			//前进
    84. 			goForward();
    85. 		}else if(disMiddle < 10){
    86. 			goBack();
    87. 			
    88. 		}else
    89. 		{
    90. 			//停止
    91. 			stop();
    92. 			//测左边距离
    93. 			sgLeft();
    94. 			Delay300ms();
    95. 			disLeft = get_distance();
    96. 			
    97. 			sgMiddle();
    98. 			Delay300ms();
    99. 			
    100. 			sgRight();
    101. 			dir = RIGHT;
    102. 			Delay300ms();
    103. 			disRight = get_distance();
    104. 			
    105. 			if(disLeft < disRight){
    106. 				goRight();
    107. 				Delay150ms();
    108. 				stop();
    109. 			}
    110. 			if(disRight < disLeft){
    111. 				goLeft();
    112. 				Delay150ms();
    113. 				stop();
    114. 			}
    115. 		}
    116.  
    117. }
    118.  
    119. void main()
    120. {
    121.  
    122. 	int mark = 0;
    123. 	
    124. 	Time0Init();
    125. 	Time1Init();
    126. 	//舵机的初始位置
    127.  
    128. 	sgMiddle();
    129. 	Delay300ms();
    130. 	Delay300ms();
    131. 	dir = MIDDLE;
    132. 	
    133. 	Oled_Init();
    134. 	Oled_Clear();
    135. 	Oled_Show_Str(2,2,"-----Ready----");
    136. 	
    137. 	while(1){
    138. 		//满足寻迹模式的条件
    139. 		if(A25 == 0 && A26 == 1 && A27 == 1){
    140. 			if(mark != XJ){
    141. 				Oled_Clear();
    142. 				Oled_Show_Str(2,2,"-----XunJi----");
    143. 			}
    144. 			mark = XJ;
    145. 			xunjiMode();
    146. 		}
    147. 		//满足跟随模式的条件
    148. 		if(A25 == 1 && A26 == 0 && A27 == 1){
    149. 			if(mark != GS){
    150. 				Oled_Clear();
    151. 				Oled_Show_Str(2,2,"-----GenSui----");
    152. 			}
    153. 			mark = GS;
    154. 			gensuiMode();
    155. 		}
    156. 		//满足避障模式的条件
    157. 		if(A25 == 1 && A26 == 1 && A27 == 0){
    158. 			if(mark != BZ){
    159. 				Oled_Clear();
    160. 				Oled_Show_Str(2,2,"-----BiZhang----");
    161. 			}
    162. 			mark = BZ;
    163. 			bizhangMode();
    164. 		}
    165. 	
    166. 	}
    167. }
    168.  
    169.  
    170. //hc04.c
    171. #include "reg52.h"
    172. #include "delay.h"
    173.  
    174. sbit Trig     = P2^3;
    175. sbit Echo     = P2^2;
    176.  
    177. void Time1Init()
    178. {	
    179. 	TMOD &= 0x0F;		//设置定时器模式
    180. 	TMOD |= 0x10;
    181. 	TH1 = 0;
    182. 	TL1 = 0;
    183. 	//设置定时器0工作模式1，初始值设定0开始数数，不着急启动定时器
    184. }
    185.  
    186. void startHC()
    187. {
    188. 	Trig = 0;
    189. 	Trig = 1;
    190. 	Delay10us();
    191. 	Trig = 0;
    192. }
    193.  
    194. double get_distance()
    195. {
    196. 		double time;
    197. 		//定时器数据清零，以便下一次测距
    198. 		TH1 = 0;
    199. 		TL1 = 0;
    200. 	//1. Trig ，给Trig端口至少10us的高电平
    201. 		startHC();
    202. 		//2. echo由低电平跳转到高电平，表示开始发送波
    203. 		while(Echo == 0);
    204. 		//波发出去的那一下，开始启动定时器
    205. 		TR1 = 1;
    206. 		//3. 由高电平跳转回低电平，表示波回来了
    207. 		while(Echo == 1);
    208. 		//波回来的那一下，我们开始停止定时器
    209. 		TR1 = 0;
    210. 		//4. 计算出中间经过多少时间
    211. 		time = (TH1 * 256 + TL1)*1.085;//us为单位
    212. 		//5. 距离 = 速度 （340m/s）* 时间/2
    213. 		return  (time * 0.017);
    214. }
    215.  
    216.  
    217. //delay.c
    218. #include "intrins.h"
    219.  
    220. void Delay2000ms()		//@11.0592MHz
    221. {
    222. 	unsigned char i, j, k;
    223.  
    224. 	i = 15;
    225. 	j = 2;
    226. 	k = 235;
    227. 	do
    228. 	{
    229. 		do
    230. 		{
    231. 			while (--k);
    232. 		} while (--j);
    233. 	} while (--i);
    234. }
    235.  
    236.  
    237. void Delay10us()		//@11.0592MHz
    238. {
    239. 	unsigned char i;
    240.  
    241. 	i = 2;
    242. 	while (--i);
    243. }
    244.  
    245. void Delay300ms()		//@11.0592MHz
    246. {
    247. 	unsigned char i, j, k;
    248.  
    249. 	_nop_();
    250. 	i = 3;
    251. 	j = 26;
    252. 	k = 223;
    253. 	do
    254. 	{
    255. 		do
    256. 		{
    257. 			while (--k);
    258. 		} while (--j);
    259. 	} while (--i);
    260. }
    261.  
    262.  
    263. void Delay150ms()		//@11.0592MHz
    264. {
    265. 	unsigned char i, j, k;
    266.  
    267. 	i = 2;
    268. 	j = 13;
    269. 	k = 237;
    270. 	do
    271. 	{
    272. 		do
    273. 		{
    274. 			while (--k);
    275. 		} while (--j);
    276. 	} while (--i);
    277. }
    278.  
    279. void Delay450ms()		//@11.0592MHz
    280. {
    281. 	unsigned char i, j, k;
    282.  
    283. 	_nop_();
    284. 	i = 4;
    285. 	j = 39;
    286. 	k = 209;
    287. 	do
    288. 	{
    289. 		do
    290. 		{
    291. 			while (--k);
    292. 		} while (--j);
    293. 	} while (--i);
    294. }
    295.  
    296.  
    297. //sg90.c
    298. #include "reg52.h"
    299. #include "delay.h"
    300.  
    301. sbit sg90_con = P1^1;
    302.  
    303. int jd;
    304. int cnt = 0;
    305.  
    306. void Time0Init()
    307. {
    308. 	//1. 配置定时器0工作模式位16位计时
    309. 	TMOD &= 0xF0;		//设置定时器模式
    310. 	TMOD |= 0x01;
    311. 	//2. 给初值，定一个0.5出来
    312. 	TL0=0x33;
    313. 	TH0=0xFE;
    314. 	//3. 开始计时
    315. 	TR0 = 1;
    316. 	TF0 = 0;
    317. 	//4. 打开定时器0中断
    318. 	ET0 = 1;
    319. 	//5. 打开总中断EA
    320. 	EA = 1;
    321. }
    322.  
    323. void sgMiddle()
    324. {
    325. 	//中间位置
    326. 	jd = 3; //90度 1.5ms高电平
    327. 	cnt = 0;
    328. }
    329.  
    330. void sgLeft()
    331. {
    332. 	//左边位置
    333. 	jd = 5; //135度 1.5ms高电平
    334. 	cnt = 0;
    335. }
    336.  
    337. void sgRight()
    338. {
    339. 	//右边位置
    340. 	jd = 1; //0度
    341. 	cnt = 0;
    342. }
    343.  
    344.  
    345. void Time0Handler() interrupt 1
    346. {
    347. 	cnt++;  //统计爆表的次数. cnt=1的时候，报表了1
    348. 	//重新给初值
    349. 	TL0=0x33;
    350. 	TH0=0xFE;
    351. 	
    352. 	//控制PWM波
    353. 	if(cnt < jd){
    354. 		sg90_con = 1;
    355. 	}else{
    356. 		sg90_con = 0;
    357. 	}
    358. 	
    359. 	if(cnt == 40){//爆表40次，经过了20ms
    360. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    361. 		sg90_con = 1;
    362. 	}
    363. 		
    364. }
    365.  
    366. //motor.c
    367. #include "reg52.h"
    368.  
    369. sbit RightCon1A = P3^7;
    370. sbit RightCon1B = P3^3;
    371.  
    372. sbit LeftCon1A = P3^4;
    373. sbit LeftCon1B = P3^5;
    374.  
    375. void goForward()
    376. {
    377. 	LeftCon1A = 0;
    378. 	LeftCon1B = 1;
    379. 	
    380. 	RightCon1A = 0;
    381. 	RightCon1B = 1;
    382. }
    383.  
    384. void goRight()
    385. {
    386. 	LeftCon1A = 0;
    387. 	LeftCon1B = 1;
    388. 	
    389. 	RightCon1A = 0;
    390. 	RightCon1B = 0;
    391. }
    392.  
    393.  
    394. void goLeft()
    395. {
    396. 	LeftCon1A = 0;
    397. 	LeftCon1B = 0;
    398. 	
    399. 	RightCon1A = 0;
    400. 	RightCon1B = 1;
    401. }
    402.  
    403. void goBack()
    404. {
    405. 	LeftCon1A = 1;
    406. 	LeftCon1B = 0;
    407. 	
    408. 	RightCon1A = 1;
    409. 	RightCon1B = 0;
    410. }
    411.  
    412. void stop()
    413. {
    414. 	LeftCon1A = 0;
    415. 	LeftCon1B = 0;
    416. 	
    417. 	RightCon1A = 0;
    418. 	RightCon1B = 0;
    419. }
    420.  
    421.  
    422. //oled.c
    423. #include "reg52.h"
    424. #include "intrins.h"
    425. #include "Oledfont.h"
    426.  
    427.  
    428. sbit scl = P1^2;
    429. sbit sda = P1^3;
    430.  
    431. void IIC_Start()
    432. {
    433. 	scl = 0;
    434. 	sda = 1;
    435. 	scl = 1;
    436. 	_nop_();
    437. 	sda = 0;
    438. 	_nop_();
    439. }
    440.  
    441. void IIC_Stop()
    442. {
    443. 	scl = 0;
    444. 	sda = 0;
    445. 	scl = 1;
    446. 	_nop_();
    447. 	sda = 1;
    448. 	_nop_();
    449. }
    450.  
    451. char IIC_ACK()
    452. {
    453. 	char flag;
    454. 	sda = 1;//就在时钟脉冲9期间释放数据线
    455. 	_nop_();
    456. 	scl = 1;
    457. 	_nop_();
    458. 	flag = sda;
    459. 	_nop_();
    460. 	scl = 0;
    461. 	_nop_();
    462. 	
    463. 	return flag;
    464. }
    465.  
    466. void IIC_Send_Byte(char dataSend)
    467. {
    468. 	int i;
    469. 	
    470. 	for(i = 0;i<8;i++){
    471. 		scl = 0;//scl拉低，让sda做好数据准备
    472. 		sda = dataSend & 0x80;//1000 0000获得dataSend的最高位，给sda
    473. 		_nop_();//发送数据建立时间
    474. 		scl = 1;//scl拉高开始发送
    475. 		_nop_();//数据发送时间
    476. 		scl = 0;//发送完毕拉低
    477. 		_nop_();//
    478. 		dataSend = dataSend << 1;
    479. 	}
    480. }
    481.  
    482. void Oled_Write_Cmd(char dataCmd)
    483. {
    484. 	//	1. start()
    485. 	IIC_Start();
    486. 	//		
    487. 	//	2. 写入从机地址  b0111 1000 0x78
    488. 	IIC_Send_Byte(0x78);
    489. 	//	3. ACK
    490. 	IIC_ACK();
    491. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    492. 	IIC_Send_Byte(0x00);
    493. 	//	5. ACK
    494. 	IIC_ACK();
    495. 	//6. 写入指令/数据
    496. 	IIC_Send_Byte(dataCmd);
    497. 	//7. ACK
    498. 	IIC_ACK();
    499. 	//8. STOP
    500. 	IIC_Stop();
    501. }
    502.  
    503. void Oled_Write_Data(char dataData)
    504. {
    505. 	//	1. start()
    506. 	IIC_Start();
    507. 	//		
    508. 	//	2. 写入从机地址  b0111 1000 0x78
    509. 	IIC_Send_Byte(0x78);
    510. 	//	3. ACK
    511. 	IIC_ACK();
    512. 	//	4. cotrol byte: (0)(0)000000 写入命令   (0)(1)000000写入数据
    513. 	IIC_Send_Byte(0x40);
    514. 	//	5. ACK
    515. 	IIC_ACK();
    516. 	///6. 写入指令/数据
    517. 	IIC_Send_Byte(dataData);
    518. 	//7. ACK
    519. 	IIC_ACK();
    520. 	//8. STOP
    521. 	IIC_Stop();
    522. }
    523.  
    524.  
    525. void Oled_Init(void){
    526. 	Oled_Write_Cmd(0xAE);//--display off
    527. 	Oled_Write_Cmd(0x00);//---set low column address
    528. 	Oled_Write_Cmd(0x10);//---set high column address
    529. 	Oled_Write_Cmd(0x40);//--set start line address  
    530. 	Oled_Write_Cmd(0xB0);//--set page address
    531. 	Oled_Write_Cmd(0x81); // contract control
    532. 	Oled_Write_Cmd(0xFF);//--128   
    533. 	Oled_Write_Cmd(0xA1);//set segment remap 
    534. 	Oled_Write_Cmd(0xA6);//--normal / reverse
    535. 	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
    536. 	Oled_Write_Cmd(0x3F);//--1/32 duty
    537. 	Oled_Write_Cmd(0xC8);//Com scan direction
    538. 	Oled_Write_Cmd(0xD3);//-set display offset
    539. 	Oled_Write_Cmd(0x00);//
    540. 	
    541. 	Oled_Write_Cmd(0xD5);//set osc division
    542. 	Oled_Write_Cmd(0x80);//
    543. 	
    544. 	Oled_Write_Cmd(0xD8);//set area color mode off
    545. 	Oled_Write_Cmd(0x05);//
    546. 	
    547. 	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
    548. 	Oled_Write_Cmd(0xF1);//
    549. 	
    550. 	Oled_Write_Cmd(0xDA);//set com pin configuartion
    551. 	Oled_Write_Cmd(0x12);//
    552. 	
    553. 	Oled_Write_Cmd(0xDB);//set Vcomh
    554. 	Oled_Write_Cmd(0x30);//
    555. 	
    556. 	Oled_Write_Cmd(0x8D);//set charge pump enable
    557. 	Oled_Write_Cmd(0x14);//
    558. 	
    559. 	Oled_Write_Cmd(0xAF);//--turn on oled panel		
    560. }
    561.  
    562. void Oled_Clear()
    563. {
    564. 	unsigned char i,j; //-128 --- 127
    565. 	
    566. 	for(i=0;i<8;i++){
    567. 		Oled_Write_Cmd(0xB0 + i);//page0--page7
    568. 		//每个page从0列
    569. 		Oled_Write_Cmd(0x00);
    570. 		Oled_Write_Cmd(0x10);
    571. 		//0到127列，依次写入0，每写入数据，列地址自动偏移
    572. 		for(j = 0;j<128;j++){
    573. 			Oled_Write_Data(0);
    574. 		}
    575. 	}
    576. }
    577.  
    578. void Oled_Show_Char(char row,char col,char oledChar){ //row*2-2
    579. 	unsigned int  i;
    580. 	Oled_Write_Cmd(0xb0+(row*2-2));                           //page 0
    581. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    582. 	Oled_Write_Cmd(0x10+(col>>4));                            //high	
    583. 	for(i=((oledChar-32)*16);i<((oledChar-32)*16+8);i++){
    584. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    585. 	}
    586.  
    587. 	Oled_Write_Cmd(0xb0+(row*2-1));                           //page 1
    588. 	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
    589. 	Oled_Write_Cmd(0x10+(col>>4));                            //high
    590. 	for(i=((oledChar-32)*16+8);i<((oledChar-32)*16+8+8);i++){
    591. 		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
    592. 	}		
    593. }
    594.  
    595.  
    596. /******************************************************************************/
    597. // 函数名称：Oled_Show_Char 
    598. // 输入参数：oledChar 
    599. // 输出参数：无 
    600. // 函数功能：OLED显示单个字符
    601. /******************************************************************************/
    602. void Oled_Show_Str(char row,char col,char *str){
    603. 	while(*str!=0){
    604. 		Oled_Show_Char(row,col,*str);
    605. 		str++;
    606. 		col += 8;	
    607. 	}		
    608. }
    609.  
    610.  
    611.  
    612.

  • 相关阅读:
    spring cloud 快速上手系列 -＞ 04-网关 Gateway -＞ 041-空的工程
    睿伴科创上线了
    html中如何写一个提示框,css画一个提示框
    .Net添加了引用，仍然提示找不到命名空间
    微查系统，一站式查询，让您的查询更加便捷
    Vue2父传子、子传父和兄弟间互传
    VC++透明图片绘制的三种办法
    马踏棋盘问题
    【微信小程序-初级】一些基础功能实现参考
    【我的OpenGL学习进阶之旅】 C++ 长行字符串多行书写的方法以及如何书写正确的OpenGL Shader着色器代码
  • 原文地址：https://blog.csdn.net/m0_74712453/article/details/132702785