devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于STC15系列单片机的智能门锁(含IIC、步进电机、矩阵按键、PCF8263、LCD1602等配置文件)_单片机stc15系统设计

作者：AllinToyou | 2024-06-01 18:18:04

赞

踩

单片机stc15系统设计

一、项目背景及功能需求

1.1项目背景

智能门锁是一种智能化、高效、安全的门锁，它可以实现密码识别开锁方式，极大地提高了门锁的安全性和便利性。随着人们对安全性的要求越来越高，智能门锁已经成为了现代家庭和企业的必备设备。因此，本项目旨在设计一款基于STC15单片机的智能门锁，以满足人们对安全性和便利性的需求。

1.2 功能需求

从功能上来看，主要分为四个部分：显示时间、密码门锁、修改密码和计算器。其中显示时间可以实时获取当前时间日期；密码门锁不仅可以防盗，还能防止用户忘记带钥匙；修改密码可以让用户在密码泄露时及时更改密码；计算器为创新功能，可以进行一些简单的算术运算。其具体的功能架构如下：

用到的文件模块如下：

（1）显示学号：开始会显示“WelcomeSmartLock”和自己的学号

（2）显示时间：可以实时获取当前日期，星期，时间

（3）密码门锁：输入正确密码即可进行开锁，密码错误3次就会发出警报

（4）修改密码：当门锁打开时才能进行修改密码，修改的密码还需要确认重新输入一次，防止用户输错，只有当两次输入一样，才能进行密码的修改；

（5）计算器：可以进行简单的算数运算

（6）结尾有一个动画页面

二、实训环境

单片机开发板套件、Keil C51、STC-ISP

三、项目硬件搭建

3.1硬件设备

硬件部分包括单片机最小系统、矩阵按键、LCD1602、RTC、步进电机等模块，系统框图如下图所示。

3.2硬件连接电路图

 

 3.3硬件搭建实物图

四、具体任务及内容

完成一个智能门锁，包括以下内容：首先使用软件STC-ISP自动生成所需要延时的秒数，完成延时模块的设计，然后进行LCD1062模块的配置，写好显示函数，可以再液晶屏上显示自己想要的内容；然后用取模软件生成想要的图像，使得液晶屏上能显示开锁和关锁的图像；然后完成4x4矩阵键盘的配置，能够识别哪个键盘按下，并且读入相应的信息；然后完成电机驱动模块的配置，由于单片机电压不足，于是需要引入该模块来调动电机，能够进行门锁的开关。然后进行IIC模块的配置，使得单片机能进行简单的通信；随后进行PCF8263模块的配置，能够进行时间的发送与接收，实时获取当前时间。

五、项目运行说明及截图

通过三天的努力，我成功实现了并创新了这次的智能门锁。智慧门锁从功能上来看，主要分为四个部分：显示时间，密码门锁，修改密码，计算器。其中显示时间可以实时读取显示当前时间；密码门锁只有输入正确密码才会开门，输错3次后会报警；修改密码只有开门后才有权限进行修改，并且需要输入两次一样的要修改的密码才会修改成功；计算器是附加的创新功能，可以进行简单的算术运算。

具体功能体现如下：

进入界面

时间显示界面

门锁界面

修改密码

（没开锁）

（已开锁）

 

计算器界面

动画界面

七、附录：（其他相关技术文档或程序实现源码）

main.c文件

  1. #include <stc15.h>
  2. #include <string.h>
  3. #include "LCD1602.h"
  4. #include "delay.h"
  5. #include "zimo.h"
  6. #include "Key16.h"
  7. #include "stepmotor.h"
  8. #include "PCF8563.h"
  9. #include "JiSuanQi.h"
  10. #define uchar unsigned char
  11. #define uint unsigned int
  12. sbit beep=P3^7;
  13.  
  14. uint X=999;
  15. uchar clear[]="                ";
  16. uchar clearPwd[]="          ";
  17. uchar show1[]="WelcomeSmartLock";
  18. uchar show2[]="InputPassword";
  19. uchar success_show[]="Success!";
  20. uchar fail_show[]="Fail!";
  21. uchar number[]="211071085";
  22. extern unsigned char time_buf1[8];
  23. extern unsigned char time_buf[8];
  24.  
  25. uchar PWD[]="888888";
  26. uchar input_Pwd[8];
  27.  
  28. uchar oneInput[8];
  29. uchar twoInput[8];
  30.  
  31. uchar JiSuan[10];
  32. uint ans;
  33.  
  34. uchar clockFlag=0;
  35. uint Motor_Num;
  36. uchar my_input=0;
  37. uchar index=0;
  38. uchar pageFlag=0;
  39. uchar Flag=0;//行
  40. uchar FailNum=0;
  41.  
  42. void LCD_Show_closeClock();
  43. void LCD_Show_openClock();
  44. void LCD_Clear();
  45. void openClock();
  46. void close();
  47. void LCD_Show_Time();
  48. void Show_Xin();
  49. void main()
  50. {
  51.  
  52. P3M0=0x00;
  53. P3M1=0x00;
  54. 	LCD_Init();
  55. //	time_init();
  56. 	LCD_Show_String(0,0,show1);
  57. 	LCD_Show_String(3,1,number);
  58. 	Delay1000ms();
  59. 	LCD_Clear();
  60. 	
  61. 	while(1)
  62. 	{
  63. 		my_input = KeyScan_4x4();
  64. 		if(my_input=='/')
  65. 		{
  66. 			pageFlag=(pageFlag+1)%5;
  67. 			LCD_Clear();
  68. 			Delay200ms();
  69. 		}
  70. 		if(pageFlag==0)//页面1显示时间
  71. 		{
  72. 			LCD_Show_Time();
  73. 		}
  74. 		else if(pageFlag==1)//页面2显示门锁
  75. 		{
  76. 			if(clockFlag==0)
  77. 			{
  78. 				LCD_Show_closeClock();
  79. 				LCD_Show_String(0,0,show2);
  80. 			}
  81. 			else if(clockFlag==1)
  82. 			{
  83. 				LCD_Show_openClock();
  84. 			}
  85. 			if('0'<=my_input && my_input<='9' && index<=7)
  86. 			{
  87. 				input_Pwd[index]=my_input;
  88. 				LCD_Show_OneChar(index, 1, input_Pwd[index]);
  89. 				Delay200ms();
  90. 				LCD_Show_OneChar(index, 1, '*');
  91. 				index++;
  92. 				LCD_Show_OneChar(14, 1, index+'0');
  93. 			}
  94. 			if(my_input=='<' && index!=0)
  95. 			{
  96. 				index--;
  97. 				input_Pwd[index]='0';
  98. 				LCD_Show_OneChar(index, 1, ' ');
  99. 				Delay200ms();
  100. 				LCD_Show_OneChar(14, 1, index+'0');
  101. 			}
  102. 			
  103. 			if(my_input=='=')
  104. 			{
  105. 				LCD_Clear();
  106. 				input_Pwd[index]='\0';
  107. 				index=0;
  108. 				if(strcmp(input_Pwd,PWD)==0 && clockFlag==0)
  109. 				{
  110. 					LCD_Show_String(0,0,success_show);
  111. 					openClock();
  112. 					Delay1000ms();
  113. 					LCD_Clear();
  114. 					clockFlag=1;
  115. 					LCD_Show_openClock();
  116. 					input_Pwd[0]='\0';
  117. 					
  118. 				}
  119. 				else
  120. 				{
  121. 					LCD_Show_String(0,0,fail_show);
  122. 					FailNum++;
  123. 					if(FailNum==3)
  124. 					{X=999;
  125. 						while(X--)
  126. 						{
  127. 							beep=0;
  128. 							Delay500us();
  129. 							beep=1;
  130. 							Delay500us();
  131. 						}
  132. 						FailNum=0;
  133. 					}
  134. 						
  135. 					Delay1000ms();
  136. 					LCD_Clear();
  137. 					LCD_Show_closeClock();
  138. 					LCD_Show_String(0,0,show2);
  139. 				}
  140. 				LCD_Show_OneChar(14, 1, index+'0');
  141. 			}
  142. 			if(my_input=='+' && clockFlag==1)
  143. 			{
  144. 				clockFlag=0;
  145. 				LCD_Clear();
  146. 				Delay200ms();
  147. 				index=0;
  148. 				close();
  149. 				LCD_Show_String(0,0,show2);
  150. 				input_Pwd[0]='\0';
  151. 				LCD_Show_OneChar(14, 1, index+'0');
  152. 			}
  153. 			if(my_input=='C')
  154. 			{
  155. 				LCD_Show_String(0,1,clearPwd);
  156. 				Delay200ms();
  157. 				index=0;
  158. 				LCD_Show_OneChar(14, 1, index+'0');
  159. 			}
  160.  
  161. 		}
  162. 		else if(pageFlag==2)//页面3显示修改密码
  163. 		{
  164. 			if(clockFlag==1)
  165. 			{
  166. //				LCD_Show_String(0,0,"ChangePassword!");
  167. //				Delay1000ms();
  168. 				LCD_Show_String(0,0,"ChangeP");
  169. 				LCD_Show_String(0,1,"RepeatP");
  170. 				LCD_Show_OneChar(7, Flag, ':');
  171. 				if('0'<=my_input && my_input<='9' && index<=7)
  172. 				{
  173. 					oneInput[index]=my_input;
  174. 					LCD_Show_OneChar(index+8, Flag, oneInput[index]);
  175. 					Delay200ms();
  176. 					LCD_Show_OneChar(index+8, Flag, '*');
  177. 					index++;
  178. 				}
  179. 				if(my_input=='<' && index!=0)
  180. 				{
  181. 					index--;
  182. 					oneInput[index]='0';
  183. 					LCD_Show_OneChar(index+8, Flag, ' ');
  184. 					Delay200ms();
  185. 				}
  186. 				if(my_input=='=')
  187. 				{
  188. 					Delay200ms();
  189. 					Flag++;
  190. 					oneInput[index]='\0';
  191. 					if(Flag==2)
  192. 					{
  193. 						if(strcmp(oneInput,twoInput)==0)
  194. 						{
  195. 							strcpy(PWD,oneInput);
  196. 							LCD_Clear();
  197. 							LCD_Show_String(0,0,"ChangeSuccess!");
  198. 							Delay1000ms();
  199. 							LCD_Clear();
  200. 						}
  201. 						else
  202. 						{
  203. 							LCD_Clear();
  204. 							LCD_Show_String(0,0,"DifferentResults!");
  205. 							Delay1000ms();
  206. 							LCD_Clear();
  207. 						}
  208. 					}
  209. 					strcpy(twoInput, oneInput);
  210. 					index=0;
  211. 					
  212. 				}
  213. 			}
  214. 			else
  215. 			{
  216. 				LCD_Show_String(0,0,"  NoAuthority!");
  217. 			}
  218. 		}
  219. 		
  220. 		else if(pageFlag==3)//页面4计算器
  221. 		{
  222. 			if(('0'<=my_input && my_input<='9')||(my_input=='+' || my_input=='-' || my_input=='x' || my_input=='='))
  223. 			{
  224. 				JiSuan[index]=my_input;
  225. 				LCD_Show_OneChar(index, 0, JiSuan[index]);
  226. 				index++;
  227. 				JiSuan[index]='\0';
  228. 				Delay200ms();
  229. 				if(my_input=='=')
  230. 				{
  231. 					ans=Jfuntion(JiSuan);
  232. 					LCD_Show_OneChar(0, 1, ans+'0');
  233. 				}
  234. 			}
  235. 			if(my_input=='C')
  236. 			{
  237. 				LCD_Clear();
  238. 				Delay200ms();
  239. 				index=0;
  240. 			}
  241. 			if(my_input=='<' && index!=0)
  242. 			{
  243. 				index--;
  244. 				JiSuan[index]='0';
  245. 				LCD_Show_OneChar(index, 0, ' ');
  246. 				Delay200ms();
  247. 			}
  248. 			
  249. 			
  250. 			
  251. 		}
  252. 		else if(pageFlag==4)//页面5显示动画
  253. 		{
  254. 			Show_Xin();
  255. 		}
  256. 	}
  257. 	
  258. }
  259.  
  260. void LCD_Clear()
  261. {
  262. 		LCD_Show_String(0,0,clear);
  263. 		LCD_Show_String(0,1,clear);
  264. }
  265. void LCD_Show_closeClock()
  266. {
  267. 	LCD_Show_Customer(15,0,0,close_Clock);
  268. 	LCD_Show_Customer(15,1,1,guan);
  269.  
  270. }
  271. void LCD_Show_openClock()
  272. {
  273. 		LCD_Show_Customer(15,0,0,open_Clock);
  274. 		LCD_Show_Customer(15,1,1,kai);
  275. }
  276. void close()
  277. {
  278. 	LCD_Show_closeClock();
  279. 	Motor_Num=256;
  280. 	while(Motor_Num--)
  281. 	{
  282. 			Motor_Drive41(0,5);
  283. 	}
  284. 	MotorStop();
  285. }
  286. void openClock()
  287. {
  288. 	Motor_Num=256;
  289. 	LCD_Show_openClock();
  290. 	while(Motor_Num--)
  291. 	{
  292. 			Motor_Drive41(1,5);
  293. 	}
  294. 	MotorStop();
  295. }
  296.  
  297. void LCD_Show_Time()
  298. {
  299. 	//显示年份
  300. 	uchar time_ge,time_shi;
  301. 	get_time();
  302. 	time_ge=time_buf1[1]%10;
  303. 	time_shi=time_buf1[1]/10;
  304. 	LCD_Show_OneChar(3,0,'2');
  305. 	LCD_Show_OneChar(4,0,'0');
  306. 	LCD_Show_OneChar(5,0,time_shi+'0');
  307. 	LCD_Show_OneChar(6,0,time_ge+'0');
  308. 	//显示月份
  309. 	time_ge=time_buf1[2]%10;
  310. 	time_shi=time_buf1[2]/10;
  311. 	LCD_Show_OneChar(8,0,time_shi+'0');
  312. 	LCD_Show_OneChar(9,0,time_ge+'0');
  313. 	//显示日
  314. 	time_ge=time_buf1[3]%10;
  315. 	time_shi=time_buf1[3]/10;
  316. 	LCD_Show_OneChar(11,0,time_shi+'0');
  317. 	LCD_Show_OneChar(12,0,time_ge+'0');
  318. 	//显示时
  319. 	time_ge=time_buf1[4]%10;
  320. 	time_shi=time_buf1[4]/10;
  321. 	LCD_Show_OneChar(4,1,time_shi+'0');
  322. 	LCD_Show_OneChar(5,1,time_ge+'0');
  323. 	//显示分
  324. 	time_ge=time_buf1[5]%10;
  325. 	time_shi=time_buf1[5]/10;
  326. 	LCD_Show_OneChar(7,1,time_shi+'0');
  327. 	LCD_Show_OneChar(8,1,time_ge+'0');
  328. 	//显示秒
  329. 	time_ge=time_buf1[6]%10;
  330. 	time_shi=time_buf1[6]/10;
  331. 	LCD_Show_OneChar(10,1,time_shi+'0');
  332. 	LCD_Show_OneChar(11,1,time_ge+'0');
  333. 	
  334. 	//显示 : 和锁
  335. 	LCD_Show_Customer(15,0,0,close_Clock);
  336. 	LCD_Show_OneChar(6,1,':');
  337. 	LCD_Show_OneChar(9,1,':');
  338. 	//显示星期
  339. 	time_ge=time_buf1[7];
  340. 	time_ge+=(time_ge==0)?1:0;
  341. 	LCD_Show_OneChar(14,0,time_ge+'0');
  342. }
  343. void Show_Xin()
  344. {
  345. 	uchar i;
  346. 	for(i=0;i<15;i+=2)
  347. 	{
  348. 		LCD_Show_Customer(i,0,0,myZi);
  349. 		LCD_Show_Customer(i+1,0,1,xin1_1);
  350. 		
  351. 		LCD_Show_Customer(i,1,1,xin1_1);
  352. 		LCD_Show_Customer(i+1,1,0,myZi);
  353. 	}
  354. 	Delay500ms();
  355. 	for(i=0;i<15;i+=2)
  356. 	{
  357. 		LCD_Show_Customer(i,0,0,myZi2);
  358. 		LCD_Show_Customer(i+1,0,1,xin1_2);
  359. 		
  360. 		LCD_Show_Customer(i,1,1,xin1_2);
  361. 		LCD_Show_Customer(i+1,1,0,myZi2);
  362. 	}
  363. 	Delay500ms();
  364. }

LCD1602.c

  1. #include "LCD1602.h"
  2. void LCD_Write_Com(uchar LCD_Com)
  3. {
  4. 	LCD_RS=0;//写命令
  5. 	LCD_RW=0;//写操作
  6. 	LCD_DATA=LCD_Com;//把数据放到数据线上
  7. 	Delay1ms(1);//延时，LCD1602准备接收数据
  8. 	LCD_EN=1;//EN拉高
  9. 	LCD_EN=0;//EN拉低
  10. }
  11.  
  12. void LCD_Write_Data(uchar LCD_Data)
  13. {
  14. 	LCD_RS=1;//写数据
  15. 	LCD_RW=0;//写操作
  16. 	LCD_DATA=LCD_Data;//把数据放到数据线上
  17. 	Delay1ms(1);//延时，LCD1602准备接收数据
  18. 	LCD_EN=1;//EN拉高
  19. 	LCD_EN=0;//EN拉低
  20. }
  21. void LCD_Init()
  22. {
  23. 	//GPIO初始化
  24. 	P2M1&=0Xe5;P2M0&=0Xe5;//1110 0101设置为准双向口
  25. 	P0M1=0X00;P0M0=0X00;//设置为准双向口
  26. 	LCD_EN=0;
  27. 	LCD_RS=0;
  28. 	Delay5ms();
  29. 	LCD_Write_Com(0X38);//显示模式设置
  30. 	LCD_Write_Com(0X0C);//开关显示，光标设置0000 1100 D=1:开显示 C=0:不显示光标 B=0:光标不闪烁
  31. 	LCD_Write_Com(0X06);//光标设置 0000 0110 N=1 光标自动加1 S=0 整屏不移动
  32. 	LCD_Write_Com(0X01);//清屏
  33. 	Delay1ms(5);
  34. }
  35.  
  36. void LCD_Show_OneChar(uchar X,uchar Y,uchar LCD_char)
  37. {
  38. 	X&=0X0F;
  39. 	Y&=0X01;//限制X不能大于15，Y不能大于1
  40. 	if(Y)
  41. 	{
  42. 		X=X+0X40;//当要显示的位置在第二行时，算出地址
  43. 	}
  44. 	X=X+0X80;//计算地址指令码
  45. 	LCD_Write_Com(X);//发送命令
  46. 	LCD_Write_Data(LCD_char);//发送显示的数据
  47. }
  48. void LCD_Show_String(uchar X,uchar Y,uchar *LCD_String)
  49. {
  50. 	uchar i;
  51. 	for(i=0;LCD_String[i]!='\0';i++)
  52. 	{
  53. 		LCD_Show_OneChar(X,Y,LCD_String[i]);
  54. 		X++;
  55. 	}
  56. }
  57. /*显示自定义字符：本函数实现在CGRAM的0X00的地址中写入自定义字符，然后显示在XY坐标位置
  58.                   LCD1602可定义的字符可存在CGROM的0X00-0X07共8个位置
  59.   X：列地址（0-15）
  60.   Y：行地址（0-1）
  61.   Num：自定义字符在CGROM中存储的位置（0-7）
  62.   LCD_String：自定义字符的取模；若用取模软件（阴码/行列式/顺向）
  63. */
  64. void LCD_Show_Customer(uchar X,uchar Y,uchar Num,uchar *LCD_Cust)//显示自定义字符
  65. {
  66. 	uchar i;
  67. 	uchar Com=Num;//用于计算CGRAM地址指令
  68. 	X&=0X0F;
  69. 	Y&=0X01;//限制X不能大于15，Y不能大于1
  70. 	if(Y)
  71. 	{
  72. 		X=X+0X40;//当要显示的位置在第二行时，算出地址
  73. 	}
  74. 	X=X+0X80;//计算地址指令码
  75. 	Com=Com<<3;
  76. 	Com=Com+0X40;//计算指令码
  77. 	for(i=0;i<8;i++)
  78. 	{
  79. 		LCD_Write_Com(Com);//设置存入数据的地址
  80. 		Com++;
  81. 		LCD_Write_Data(LCD_Cust[i]);//逐行填充每行的内容
  82. 	}
  83. 	LCD_Write_Com(X);//发送命令
  84. 	LCD_Write_Data(Num);//发送显示的数据
  85. }

LCD1602.h

  1. #ifndef _LCD1602_H
  2. #define _LCD1602_H
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. #include <stc15.h>
  6. #include "delay.h"
  7. sbit LCD_EN=P2^1;
  8. sbit LCD_RS=P2^4;
  9. sbit LCD_RW=P2^3;
  10. #define LCD_DATA P0
  11. void LCD_Init();
  12. void LCD_Show_OneChar(uchar X,uchar Y,uchar LCD_char);
  13. void LCD_Show_String(uchar X,uchar Y,uchar *LCD_String);
  14. void LCD_Show_Customer(uchar X,uchar Y,uchar Num,uchar *LCD_Cust);
  15.  
  16.  
  17. #endif

iic.c

  1. #include "iic.h"
  2.  
  3. //起始信号
  4. void IIC_Start (void)
  5. {
  6. 	SDA =1;
  7. 	SCL = 1;
  8. 	Delay1us();
  9. 	SDA = 0;
  10.  
  11. }
  12.  
  13. //终止信号
  14. void IIC_Stop(void)
  15. {
  16. 	SDA = 0;
  17. 	SCL = 1;
  18. 	Delay1us();
  19. 	SDA = 1;
  20. 	Delay1us();
  21. }
  22.  
  23. //等待应答
  24. bit IIC_WaitAck(void)
  25. {
  26. 	bit i;
  27. 	SCL = 1;
  28. 		Delay1us();
  29. 	i = SDA;
  30. 	SCL = 0;
  31. 	return i;
  32. }
  33.  
  34. //应答位控制
  35. void IIC_SendAck(bit j)
  36. {
  37. 		SCL = 0;
  38. 		Delay1us();
  39. 		SCL = 1;
  40. 		Delay1us();
  41. 		SDA = j;	
  42. 	  Delay1us();
  43. 	SCL = 0;
  44. 	SDA = 1;
  45. 		Delay1us();
  46. }
  47.  
  48. //I2C发送1个字节数据
  49. void IIC_SendByte(unsigned char dite)
  50. {
  51. 	unsigned char i;
  52. 		SDA = 0;
  53. 		SCL =0;
  54. 		Delay1us();
  55. 	for(i=0;i<8;i++)
  56. 	{
  57. 		if(dite &0x80) SDA = 1;
  58. 		else SDA =0;
  59. 			Delay1us();
  60. 		dite <<=1;
  61. 		SCL = 1;
  62. 			Delay1us();
  63. 		SCL = 0;
  64. 			Delay1us();
  65. 	}
  66. }
  67. //I2C接收1个字节数据
  68. unsigned char IIC_RecByte(void)
  69. {	
  70. 		unsigned char i,tmpe; 
  71. 	
  72. 	SCL = 0;
  73. 	Delay1us();
  74. 	
  75. 		for(i=0;i<8;i++)
  76. 		{  
  77. 			SCL = 1;
  78. 			Delay1us();
  79. 					tmpe = tmpe<<1;	
  80. 			if(SDA) tmpe |=1;
  81. 			SCL =0;
  82. 		  Delay1us();
  83. 		}
  84. 	return  tmpe;	
  85. }
  86.  
  87.

 iic.h

  1. #ifndef _IIC_H
  2. #define _IIC_H
  3. #include <stc15.h>
  4. #include "delay.h"
  5.  
  6.  
  7. //总线引脚定义
  8. sbit SDA = P5^3;  /* 数据线 */
  9. sbit SCL = P5^2;  /* 时钟线 */
  10.  
  11.  
  12.  
  13. void IIC_Start (void);//起始信号
  14. void IIC_Stop(void);//终止信号
  15. bit IIC_WaitAck(void);//等待应答
  16. void IIC_SendAck(bit j);//应答位控制
  17. void IIC_SendByte(unsigned char dite);//I2C发送1个字节数据
  18. unsigned char IIC_RecByte(void);//I2C接收1个字节数据
  19.  
  20.  
  21.  
  22. #endif

stempmotor.c

  1. #include "stepmotor.h"
  2.  
  3. //步进电机初始化
  4. void StepMotor_Init()
  5. {
  6. 	 P1M1 &= 0xF0;	P1M0 |= 0x0F;	                  //设置P1.0~P1.3为推挽输出
  7. //	 P1M1 &= 0xF0;	P1M0 &= 0xF0;	                  //设置P1.0~P1.3为准双向
  8. }
  9.  
  10. //电机停止
  11. void MotorStop(void)
  12. {
  13.    DD=0;CC=0;BB=0;AA=0;
  14. }
  15.  
  16.  
  17. //步进电机转动：单四拍 其中X=1表示正转，X=0表示反转；Speed表示转速设置
  18. void Motor_Drive41(uchar X,uint Speed)
  19. {
  20.   if(X==1)   //顺时针转动
  21. 	{
  22. 		DD=0;CC=0;BB=0;AA=1;	
  23.     Delay1ms(Speed);  //转速调节
  24.  
  25. 		DD=0;CC=0;BB=1;AA=0;	
  26.     Delay1ms(Speed);  //转速调节
  27.  
  28. 		DD=0;CC=1;BB=0;AA=0;	
  29.     Delay1ms(Speed);  //转速调节
  30.  
  31. 		DD=1;CC=0;BB=0;AA=0;	
  32.     Delay1ms(Speed);  //转速调节
  33.   }
  34. 	else       //逆时针转动
  35. 	{
  36. 		DD=1;CC=0;BB=0;AA=0;	
  37.     Delay1ms(Speed);  //转速调节
  38.  
  39. 		DD=0;CC=1;BB=0;AA=0;	
  40.     Delay1ms(Speed);  //转速调节
  41.  
  42. 		DD=0;CC=0;BB=1;AA=0;	
  43.     Delay1ms(Speed);  //转速调节
  44.  
  45. 		DD=0;CC=0;BB=0;AA=1;	
  46.     Delay1ms(Speed);  //转速调节
  47.   }	
  48. }
  49.  
  50.  
  51. //步进电机转动：双四拍 其中X=1表示正转，X=0表示反转；Speed表示转速设置
  52. void Motor_Drive42(uchar X,uint Speed)
  53. {
  54.   if(X==1)   //顺时针转动
  55. 	{
  56. 		DD=0;CC=0;BB=1;AA=1;	
  57.     Delay1ms(Speed); //转速调节
  58.  
  59. 		DD=0;CC=1;BB=1;AA=0;	
  60.     Delay1ms(Speed);  //转速调节
  61.  
  62. 		DD=1;CC=1;BB=0;AA=0;	
  63.     Delay1ms(Speed);  //转速调节
  64.  
  65. 		DD=1;CC=0;BB=0;AA=1;	
  66.     Delay1ms(Speed);  //转速调节
  67.   }
  68. 	else       //逆时针转动
  69. 	{
  70. 		DD=1;CC=0;BB=0;AA=1;	
  71.     Delay1ms(Speed);  //转速调节
  72.  
  73. 		DD=1;CC=1;BB=0;AA=0;	
  74.     Delay1ms(Speed); //转速调节
  75.  
  76. 		DD=0;CC=1;BB=1;AA=0;	
  77.     Delay1ms(Speed);  //转速调节
  78.  
  79. 		DD=0;CC=0;BB=1;AA=1;	
  80.     Delay1ms(Speed);  //转速调节
  81.   }	
  82. }
  83.  
  84.  
  85. //步进电机转动：八拍 其中X=1表示正转，X=0表示反转；Speed表示转速设置
  86. void Motor_Drive8(uchar X,uint Speed)
  87. {
  88.   if(X==1)   //顺时针转动
  89. 	{
  90. 		DD=0;CC=0;BB=0;AA=1;	
  91.     Delay1ms(Speed);  //转速调节
  92.  
  93. 		DD=0;CC=0;BB=1;AA=1;	
  94.     Delay1ms(Speed);  //转速调节
  95.  
  96. 		DD=0;CC=0;BB=1;AA=0;	
  97.     Delay1ms(Speed);  //转速调节
  98.  
  99. 		DD=0;CC=1;BB=1;AA=0;	
  100.     Delay1ms(Speed);  //转速调节
  101. 		
  102. 		DD=0;CC=1;BB=0;AA=0;	
  103.     Delay1ms(Speed);  //转速调节
  104.  
  105. 		DD=1;CC=1;BB=0;AA=0;	
  106.     Delay1ms(Speed);  //转速调节
  107.  
  108. 		DD=1;CC=0;BB=0;AA=0;	
  109.     Delay1ms(Speed);  //转速调节
  110.  
  111. 		DD=1;CC=0;BB=0;AA=1;	
  112.     Delay1ms(Speed);  //转速调节
  113.   }
  114. 	else       //逆时针转动
  115. 	{
  116. 		DD=1;CC=0;BB=0;AA=1;	
  117.     Delay1ms(Speed);  //转速调节
  118.  
  119. 		DD=1;CC=0;BB=0;AA=0;	
  120.     Delay1ms(Speed);  //转速调节
  121.  
  122. 		DD=1;CC=1;BB=0;AA=0;	
  123.     Delay1ms(Speed);  //转速调节
  124.  
  125. 		DD=0;CC=1;BB=0;AA=0;	
  126.     Delay1ms(Speed);  //转速调节
  127. 		
  128. 		DD=0;CC=1;BB=1;AA=0;	
  129.     Delay1ms(Speed); //转速调节
  130.  
  131. 		DD=0;CC=0;BB=1;AA=0;	
  132.     Delay1ms(Speed);  //转速调节
  133.  
  134. 		DD=0;CC=0;BB=1;AA=1;	
  135.     Delay1ms(Speed);  //转速调节
  136.  
  137. 		DD=0;CC=0;BB=0;AA=1;	
  138.     Delay1ms(Speed);  //转速调节
  139.   }	
  140. }

stempmotor.h

  1. #ifndef _STEPMOTOR_H
  2. #define _STEPMOTOR_H
  3. #include <stc15.h>
  4. #include "delay.h"
  5.  
  6. #define uchar unsigned char
  7. #define uint unsigned int
  8. 		
  9. sbit AA=P1^0;   //电机控制口，连接电机驱动板IN1 
  10. sbit BB=P1^1;   //电机控制口，连接电机驱动板IN2 
  11. sbit CC=P1^2;	//电机控制口，连接电机驱动板IN3 
  12. sbit DD=P1^3; 	//电机控制口，连接电机驱动板IN4 
  13.  
  14.  
  15. void StepMotor_Init();//步进电机初始化
  16. void MotorStop(void);//电机停止
  17. void Motor_Drive41(uchar X,uint Speed);//步进电机转动：单四拍 其中X=1表示正转，X=0表示反转；Speed表示转速设置
  18. void Motor_Drive42(uchar X,uint Speed);//步进电机转动：双四拍 其中X=1表示正转，X=0表示反转；Speed表示转速设置
  19. void Motor_Drive8(uchar X,uint Speed);//步进电机转动：八拍 其中X=1表示正转，X=0表示反转；Speed表示转速设置
  20.  
  21.  
  22. #endif

 PCF8563.c

  1. #include "PCF8563.h"
  2.  
  3.  
  4. unsigned char time_buf1[8]={20,23,5,31,21,11,0,3};//空年月日时分秒星期（10进制）
  5. unsigned char time_buf[8]; //空年月日时分秒星期 （16进制）
  6.  
  7. //使用封装好的I2C函数，进行函数PCF8563的写函数封装：向地址Adddrsend中写入数据Datasend
  8. //函数编写流程为 ：start->发送设备地址->等待ACK->发送需要被写的内存地址->等待ACK->发送数据写入E2PROM->等待ACK->STOP
  9. void PCF8563_WriteOneByte(unsigned char Adddrsend, unsigned char Datasend)
  10. {
  11. 	IIC_Start();
  12. 	IIC_SendByte(0xA2);//通过I2C总线发送数据(芯片指令)写操作
  13. 	IIC_WaitAck();
  14. 	IIC_SendByte(Adddrsend);
  15. 	IIC_WaitAck();
  16. 	IIC_SendByte(Datasend);
  17. 	IIC_WaitAck();
  18. 	IIC_Stop();
  19. 	Delay1ms(10);
  20. }
  21.  
  22. //使用封装好的I2C函数，进行函数PCF8563的读数据函数封装：从Adddrsend中读出数据，作为返回值
  23. //读函数编写流程：start->发送设备地址->等待ACK->发送需要被读的内存地址->等待ACK->发送读指令（设备地址）->等待ACK-->读内存数据->等待no ACK->STOP 
  24. unsigned char PCF8563_ReadOneByte(unsigned char Adddrsend)
  25. {
  26. 	unsigned char Rec;
  27. 	IIC_Start();
  28. 	IIC_SendByte(0xA2);//通过I2C总线发送数据(芯片指令)写操作
  29. 	IIC_WaitAck();
  30. 	IIC_SendByte(Adddrsend);
  31. 	IIC_WaitAck();
  32. 	IIC_Start();
  33. 	IIC_SendByte(0xA3);
  34. 	IIC_WaitAck();
  35. 	Rec=IIC_RecByte();
  36. 	IIC_Stop();
  37. 	return Rec;
  38. }
  39.  
  40. /******************BCD转十进制***************************/
  41. unsigned char bcd_dec(unsigned char bat)
  42. {
  43. 	unsigned char temp1,temp2,tol;
  44. 	temp1=bat&0x0f;
  45. 	temp2=(bat&0xf0)>>4;
  46. 	tol=temp2*10+temp1;
  47. 	return tol; 
  48. }
  49. /******************十进制转BCD***************************/
  50. unsigned char dec_bcd(unsigned char  bat)
  51. {
  52. 	return ((bat%10) & 0x0F) | (((bat/10) << 4) & 0xF0);; 
  53. }
  54.  
  55.  
  56. //获取当前时间并转化
  57. void get_time(void)
  58. {
  59. 		    time_buf[6]=0x7f&PCF8563_ReadOneByte(0x02);    //读取秒
  60.         time_buf[5]=0x7f&PCF8563_ReadOneByte(0x03);   //读取分钟
  61.         time_buf[4]=0x3f&PCF8563_ReadOneByte(0x04);  //读取小时
  62.         time_buf[3]=0x3f&PCF8563_ReadOneByte(0x05);   //读取天数
  63.         time_buf[2]=0x1f&PCF8563_ReadOneByte(0x07);  //读取月
  64.         time_buf[1]=0xff&PCF8563_ReadOneByte(0x08);    //读取年
  65. 	      time_buf[7]=0x07&PCF8563_ReadOneByte(0x06);    //读取星期
  66. 	
  67. 	
  68.         time_buf1[6]=bcd_dec(time_buf[6]);                   //将读取的BCD码转换成十进制以便运算，秒
  69. 	      time_buf1[5]=bcd_dec(time_buf[5]);                   //将读取的BCD码转换成十进制以便运算，分
  70.         time_buf1[4]=bcd_dec(time_buf[4]);                   //将读取的BCD码转换成十进制以便运算，小时
  71. 	      time_buf1[3]=bcd_dec(time_buf[3]);                   //将读取的BCD码转换成十进制以便运算，日
  72. 	      time_buf1[2]=bcd_dec(time_buf[2]);                   //将读取的BCD码转换成十进制以便运算，月
  73. 	      time_buf1[1]=bcd_dec(time_buf[1]);                   //将读取的BCD码转换成十进制以便运算，年
  74. 	      time_buf1[7]=bcd_dec(time_buf[7]);                   //将读取的BCD码转换成十进制以便运算，星期
  75. 		 //printf("20%d年%d月%d日%d时%d分%d秒\r\n",date.year1,date.moom1,date.dat1,date.hour1,date.min1,date.sec1);	
  76. }
  77.  
  78.  
  79. //初始化当前时间
  80. void time_init()
  81. {
  82. 	//将十进制数转化为BCD值，方便写入PCF8563
  83. 	time_buf[1] = dec_bcd(time_buf1[1]);
  84. 	time_buf[2] = dec_bcd(time_buf1[2]);
  85. 	time_buf[3] = dec_bcd(time_buf1[3]);
  86. 	time_buf[4] = dec_bcd(time_buf1[4]);
  87. 	time_buf[5] = dec_bcd(time_buf1[5]);
  88. 	time_buf[6] = dec_bcd(time_buf1[6]);
  89. 	time_buf[7] = dec_bcd(time_buf1[7]);
  90.  
  91. 	
  92.   PCF8563_WriteOneByte(0x02,time_buf[6]);   //写入秒     
  93.   PCF8563_WriteOneByte(0x03,time_buf[5]);   //写入分	
  94. 	PCF8563_WriteOneByte(0x04,time_buf[4]);   //写入小时
  95. 	PCF8563_WriteOneByte(0x05,time_buf[3]);   //写入日
  96. 	PCF8563_WriteOneByte(0x07,time_buf[2]);   //写入月
  97. 	PCF8563_WriteOneByte(0x08,time_buf[1]);   //写入年
  98. 	PCF8563_WriteOneByte(0x06,time_buf[7]);   //写入星期
  99.        
  100. }

PCF8563.h

  1. #ifndef _PCF8563_H
  2. #define _PCF8563_H
  3.  
  4. #include "iic.h"
  5. #define uchar unsigned char
  6. #define uint unsigned int
  7.  
  8. //typedef struct {
  9. //	uint16_t year;
  10. //	uint8_t mon;
  11. //	uint8_t day;
  12. //	uint8_t hour;
  13. //	uint8_t min;
  14. //	uint8_t sec;
  15. //	uint8_t week;
  16. //}sTime;
  17.  
  18. void PCF8563_WriteOneByte(unsigned char Adddrsend, unsigned char Datasend);
  19. unsigned char PCF8563_ReadOneByte(unsigned char Adddrsend);
  20. unsigned char bcd_dec(unsigned char bat);
  21. unsigned char dec_bcd(unsigned char  bat);
  22. void time_init();//初始化当前时间
  23. void get_time(void);//读取当前时间
  24.  
  25.  
  26.  
  27. #endif

Key16.c

  1. #include "Key16.h"
  2.  
  3. uchar KeyScan_4x4(void)
  4. {
  5. 	uchar X_temp,Y_temp,temp;
  6. 	X_temp=0XF0;//列值赋初值
  7. 	Y_temp=0X0F;//行值赋初值
  8. 	P2M1&=0X3F;P2M0|=0XC0;//设置P2.6-P2.7为强推挽输出 0011 1111;1100 0000
  9. 	P4M1&=0X0F;P4M0|=0XF0;//设置P4.4-P4.7为强推挽输出 0000 1111;1111 0000
  10. 	P5M1&=0XF3;P5M0|=0X0C;//设置P5.2-P5.3为强推挽输出 1111 0011;0000 1100
  11. 	
  12. 	ROW1=1;ROW2=1;ROW3=1;ROW4=1;//行置高
  13. 	COL1=0;COL2=0;COL3=0;COL4=0;//列置低
  14. 	//所用到行IO口配置为输入，进行检测
  15. 	Delay1ms(10);
  16. 	P4M1&=0X0F;P4M0&=0X0F;//设置P4.4-P4.7为准双向口
  17. 	Delay1ms(10);
  18. 	if(ROW1==0)//检测行1电平是否为低电平
  19. 	{
  20. 		Delay1ms(10);
  21. 		if(ROW1==0)
  22. 		Y_temp&=0X0E;
  23. 	}
  24. 	if(ROW2==0)//检测行2电平是否为低电平
  25. 	{
  26. 		Delay1ms(10);
  27. 		if(ROW2==0)
  28. 		Y_temp&=0X0D;
  29. 	}
  30. 	if(ROW3==0)//检测行3电平是否为低电平
  31. 	{
  32. 		Delay1ms(10);
  33. 		if(ROW3==0)
  34. 		Y_temp&=0X0B;
  35. 	}
  36. 	if(ROW4==0)//检测行4电平是否为低电平
  37. 	{
  38. 		Delay1ms(10);
  39. 		if(ROW4==0)
  40. 		Y_temp&=0X07;
  41. 	}
  42. 	P2M1&=0X3F;P2M0|=0XC0;//设置P2.6-P2.7为强推挽输出 0011 1111;1100 0000
  43. 	P4M1&=0X0F;P4M0|=0XF0;//设置P4.4-P4.7为强推挽输出 0000 1111;1111 0000
  44. 	P5M1&=0XF3;P5M0|=0X0C;//设置P5.2-P5.3为强推挽输出 1111 0011;0000 1100
  45. 	ROW1=0;ROW2=0;ROW3=0;ROW4=0;//行置低
  46. 	COL1=1;COL2=1;COL3=1;COL4=1;//列置高
  47. 	Delay1ms(10);
  48. 	P2M1&=0X3F;P2M0&=0X3F;//设置P2.6-P2.7为准双向口
  49. 	P5M1&=0XF3;P5M0&=0XF3;//设置P5.2-P5.3为准双向口
  50. 	Delay1ms(10);
  51. 	if(COL1==0)//检测列1电平是否为低电平
  52. 	{
  53. 		Delay1ms(10);
  54. 		if(COL1==0)
  55. 		X_temp&=0XE0;
  56. 	}
  57. 	if(COL2==0)//检测列2电平是否为低电平
  58. 	{
  59. 		Delay1ms(10);
  60. 		if(COL2==0)
  61. 		X_temp&=0XD0;
  62. 	}
  63. 	if(COL3==0)//检测列3电平是否为低电平
  64. 	{
  65. 		Delay1ms(10);
  66. 		if(COL3==0)
  67. 		X_temp&=0XB0;
  68. 	}
  69. 	if(COL4==0)//检测列4电平是否为低电平
  70. 	{
  71. 		Delay1ms(10);
  72. 		if(COL4==0)
  73. 		X_temp&=0X70;
  74. 	}
  75. 	//将行值和列值合并，得到按键对应的编码值，该值与16个按键一一对应
  76. 	temp=X_temp|Y_temp;
  77. 	temp=~temp;
  78. 	//将按键检测的原始编码值解析对应按键值信息
  79. 	switch(temp)//颠倒键值
  80. 	{
  81. 		case 0X11:return '/';//1
  82. 		case 0X21:return 'x';//2
  83. 		case 0X41:return '-';//3
  84. 		case 0X81:return '+';//4
  85. 		case 0X12:return '=';//5
  86. 		case 0X22:return '9';//6
  87. 		case 0X42:return '8';//7
  88. 		case 0X82:return '7';//8
  89. 		case 0X14:return 'C';//9
  90. 		case 0X24:return '6';//0
  91. 		case 0X44:return '5';//a
  92. 		case 0X84:return '4';//b
  93. 		case 0X18:return '<';//c
  94. 		case 0X28:return '3';//d
  95. 		case 0X48:return '2';//e
  96. 		case 0X88:return '1';//f
  97. 		default:return 0;
  98. 	}
  99. }

Key16.h

  1. #ifndef _KEY_4X4_H
  2. #define _KEY_4X4_H
  3.  
  4. #include <stc15.h>
  5. #include "delay.h"
  6.  
  7. #define uchar unsigned char
  8. #define uint unsigned int
  9.  
  10. /*
  11. 矩阵按键引脚定义*/
  12. sbit COL4=P5^2;    //4*4矩阵检测列检测端口
  13. sbit COL3=P5^3;    //4*4矩阵检测列检测端口
  14. sbit COL2=P2^6;    //4*4矩阵检测列检测端口
  15. sbit COL1=P2^7;    //4*4矩阵检测列检测端口 
  16. sbit ROW4=P4^4;    //4*4矩阵检测行检测端口
  17. sbit ROW3=P4^5;    //4*4矩阵检测行检测端口
  18. sbit ROW2=P4^6;    //4*4矩阵检测行检测端口
  19. sbit ROW1=P4^7;    //4*4矩阵检测行检测端口
  20.  
  21.  
  22. uchar KeyScan_4x4(void);
  23.  
  24. #endif

zimo.h

  1. #ifndef _ZIMO_H
  2. #define _ZIMO_H
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5.  
  6. uchar code close_Clock[]={0x0E,0x0A,0x0A,0x0A,0x1F,0x11,0x11,0x1F};//??
  7. uchar code guan[] = {0x11,0x0A,0x1F,0x0A,0x1F,0x0A,0x1B,0x00};
  8. uchar code kai[] = {0x1F,0x0A,0x0A,0x1F,0x0A,0x0A,0x0A,0x00};
  9. uchar code open_Clock[]={0x0E,0x02,0x02,0x02,0x1F,0x11,0x11,0x1F};//???
  10. uchar code myZi[] = {0x00,0x00,0x0A,0x15,0x11,0x0A,0x04,0x00};
  11. uchar code myZi2[] = {0x00,0x0A,0x15,0x15,0x11,0x0A,0x04,0x00};
  12. uchar code xin1_2[] = {0x00,0x0A,0x1F,0x1F,0x1F,0x0E,0x04,0x00};
  13. uchar code xin1_1[] = {0x00,0x00,0x0A,0x1F,0x1F,0x0E,0x04,0x00};
  14.  
  15.  
  16. #endif

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/658853
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号