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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › HSJ121触摸按键STM32F103单片机驱动程序
返回列表 发新帖
查看: 2852|回复: 3
收起左侧

HSJ121触摸按键STM32F103单片机驱动程序

[复制链接]
ID:483092 发表于 2019-3-2 10:32 | 显示全部楼层 |阅读模式
里面有完整的资料

单片机源程序如下:

  2. /* 包含的头文件 --------------------------------------------------------------*/
  3. #include "bsp.h"
  4. #include "HSJ121.h"
  5. #include "i2c.h"
  6. #include "timer.h"
  7. #include "aboutdata.h"

  9. uint8_t        HSJ121_SendData[HSJ121_SendDataLength];  //命令发送数据
  10. uint8_t HSJ121_ReciveData[HSJ121_ReciveDataLength];        //数据回复接收

  12. uint8_t  HSJ121_Mode_LowScan[HSJ121ModeSetLength]={0x00,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x80,0x0A};        //低速扫描
  13. uint8_t  HSJ121_Mode_NearInduction[HSJ121ModeSetLength]={0x01,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x80,0x0A};                //临场接近感应
  14. uint8_t  HSJ121_KeyScanTime[HSJ121_KeyScanTimeLength]={02,05};        //按键扫描时间

  16. //函数声明（内部调用）
  17. uint8_t HSJ121_SendAndRecive(uint8_t *SendData,uint8_t *ReciveData); //发送和接收
  18. uint8_t HSJ121_SendComByIIC(uint8_t sla,uint8_t *s,uint8_t num);        //通过IIC发送命令
  19. uint8_t HSJ121_RecDataByIIC(uint8_t sla,uint8_t *s);        //通过IIC接收回复数据

  21. //函数声明（外部调用）
  22. void HSJ121Init(void);        //模块初始化
  23. uint8_t HSJ121_Set_LowScanMode(uint8_t *Mode);        //设置低速扫描模式
  24. uint8_t HSJ121_Set_NearInductionMode(uint8_t *Mode);        //设置临近感应模式
  25. uint8_t        HSJ121_Get_Config(void);        //获取配置信息
  26. uint8_t        HSJ121_Get_Key(void);                  //获取键值
  27. uint8_t HSJ121_Set_ScanTime(uint8_t *ScanTme);        //设置按键扫描时间
  28. uint8_t HSJ121_Get_ScanTime(void);        //获取按键扫描时间
  29. uint8_t HSJ121_Set_SleepMode(void);        //设置睡眠模式
  30. uint8_t HSJ121_Into_SleepMode(void);        //进入睡眠模式
  31. uint8_t HSJ121_WakeUp(void);                                //唤醒芯片

  33. /*--------------------------内部调用函数---------------------------------------*/
  34. /************************************************
  35. 函数名称 ： SendComByIIC
  36. 功    能 ： 通过IIC发送命令数据帧
  37. 参    数 ： uint8_t sla        —— 器件地址
  38.                                           uint8_t *s        —— 命令数据缓冲区
  39.                                           uint8_t num —— 命令长度
  40. 返 回 值 ： TRUE —— 正确
  41.                                          FALSE —— 错误
  42. 作    者 ：
  43. *************************************************/
  44. uint8_t HSJ121_SendComByIIC(uint8_t sla,uint8_t *s,uint8_t num)
  45. {
  46.         uint8_t i,j;
  47.         uint8_t ack=2;
  48.         I2C_Start();        //启动信号
  49.         //发送器件地址
  50.         ack=I2C_WriteByte(sla|I2C_WR);
  51.         if(ack==I2C_NOACK){
  52. //                printf("send address fail by write\n");
  53.                 return FALSE;
  54.         }else if(ack==I2C_ACK){
  55. //                printf("send address success by write\n");
  56.         }
  57.         TIMDelay_Nms(1);        //延时
  58.         //循环发送命令数据帧
  59.         for(i=0;i<num;i++)
  60.         {
  61.                 ack=I2C_WriteByte(*s);
  62.                 if(ack==I2C_NOACK){
  63. //                        printf("send command data fail\n");
  64.                         return FALSE;
  65.                 }
  66.                 s++;
  67.                 TIMDelay_Nms(1);        //延时
  68.         }
  69.         I2C_Stop();        //停止信号
  70.         return TRUE;
  71. }
  72. /************************************************
  73. 函数名称 ： RecDataByIIC
  74. 功    能 ： 通过IIC接收模块返回数据帧
  75. 参    数 ： uint8_t sla        —— 器件地址
  76.                                           uint8_t *s        —— 接收回复数据帧缓冲区
  77.                                           uint8_t num —— 回复数据帧长度
  78. 返 回 值 ： TRUE —— 正确
  79.                                          FALSE —— 错误
  80. 作    者 ：
  81. *************************************************/
  82. uint8_t HSJ121_RecDataByIIC(uint8_t sla,uint8_t *s)
  83. {
  84.                 uint8_t i=0;
  85.                 uint8_t HSJ121_Length;         
  86.     uint8_t j=0;
  87.           uint8_t ack=2;
  88.           uint8_t num;  
  89.         
  90.                 j=250;
  91.           while(1)
  92.                 {
  93.                         I2C_Start();        //启动信号
  94.                         ack=I2C_WriteByte(sla+1); //发送器件地址+写入命令
  95. //                        TIMDelay_Nms(5);        //延时
  96.                         if(ack==I2C_ACK){
  97. //                                printf("Send address success by read\n");
  98.                                 break;        //模块应答成功，退出循环，准备接收数据
  99.                         }
  100.                         //模块超时没有应答，返回出错
  101.                         if(j--==0){
  102.                                 I2C_Stop();
  103. //                                printf("Send address fail by read\n");
  104.                                 return FALSE;
  105.                         }
  106.                 }
  107.                
  108. //                TIMDelay_Nms(1000);        //延时

  110.                 HSJ121_Length=I2C_ReadByte(I2C_ACK);        //接收第一个字节数据，获取数据帧长度
  111.                 *s = HSJ121_Length;        
  112.                 s++;  
  113.                
  114.                 if(HSJ121_Length==0x00){
  115.                            I2C_Stop();
  116.                                  return FALSE;
  117.                 }
  118.                
  119.                 for(i=0;i<HSJ121_Length-1;i++)  //循环接受数据（除校验码外）
  120.                 {
  121.                         *s=I2C_ReadByte(I2C_ACK);
  122.                         s++;
  123.                 }
  124.                         
  125.                 //接收检验码
  126.                 *s=I2C_ReadByte(I2C_NOACK);
  127.                 I2C_Stop();        //停止信号
  128.           return TRUE;
  129. }

  131. /************************************************
  132. 函数名称 ： HSJ121_SendAndRecive(uint8_t *SendData,uint8_t *ReciveData)
  133. 功    能 ： 命令发送和回复数据接收
  134. 参    数 ： *SendData -- 发送命令缓冲区
  135.             *ReciveData -- 接收数据缓冲区
  136. 返 回 值 ： TRUE —— 正确
  137.                                          FALSE —— 错误
  138. 作    者 ：
  139. *************************************************/
  140. uint8_t HSJ121_SendAndRecive(uint8_t *SendData,uint8_t *ReciveData)
  141. {
  142.         uint8_t Command;
  143.         uint8_t RepetCnt=5;
  144.         
  145.         Command=SendData[CMD];
  146.         
  147.         SendData[SendData[Length]]=GetBcc(SendData,SendData[Length]);        //获取BCC校验码
  148.         
  149.         //发送命令数据帧
  150.         while(RepetCnt)         //重复次数，循环几次，避免模块没有及时发出ACK而退出
  151.         {
  152.                 RepetCnt--;
  153.                 //发送命令数据帧
  154.                 if(HSJ121_SendComByIIC(HSJ121_ADD,SendData,(SendData[Length]+1))==TRUE){
  155. //                        printf("Send command success\n");
  156.                         break;
  157.                 }
  158.                 //发送命令数据帧出错
  159.                 if(RepetCnt==0){
  160. //                        printf("IIC send command timeout\n");
  161.                         return FALSE;
  162.                 }        
  163.         }
  164.         
  165.         TIMDelay_Nms(5);  
  166.         RepetCnt=250;
  167.         
  168.         //接收模块返回数据帧
  169.         while(RepetCnt)
  170.   {
  171.                 RepetCnt--;
  172.                
  173.                 if(HSJ121_RecDataByIIC(HSJ121_ADD,ReciveData)==TRUE){
  174. //                        printf("Receive data success\n");
  175.                         break;
  176.                 }
  177.                
  178.                 //接收模块返回数据帧出错
  179.                 if(RepetCnt==0){
  180. //                        printf("IIC receive data timeout\n");
  181.                         return FALSE;
  182.                 }
  183.         }
  184.                
  185.         //对模块返回的数据帧进行校验        
  186.         if(!GetBcc(ReciveData,ReciveData[Length]+1)){
  187. //                 printf("Bcc check success\n");
  188.                  if(Command==ReciveData[CMD]){
  189. //                         printf("Command check success\n");
  190.                          return TRUE; //校验成功        
  191.                  }else{
  192. //                         printf("Command check success\n");
  193.                  }
  194.         }else{
  195. //                        printf("Bcc check fail\n");
  196.         }
  197.                 return FALSE;
  198. }        

  200. /*--------------------------外部调用函数---------------------------------------*/
  201. /******************************************/
  202. //函数原型： void HSJ121Init(void)
  203. //输入参数： 无
  204. //输出参数： 无
  205. //函数返回：
  206. //功能描述： 芯片初始化
  207. /******************************************/
  208. void HSJ121Init(void)
  209. {
  210.         I2C_Initializes();        //I2C通信初始化
  211.         TIMDelay_Nms(10);                //上电等待3ms，芯片稳定
  212.         printf("HSJ121 init success\n");
  213.         
  214. }
  215. /******************************************/
  216. //函数原型： HSJ121_Set_LOWScanMode(uint8_t *Mode)
  217. //输入参数： *Mode 设置模式码（10个字节）
  218. //输出参数： 无
  219. //函数返回： TRUE or FALSE
  220. //功能描述： 设置低速扫描模式
  221. /******************************************/
  222. uint8_t HSJ121_Set_LowScanMode(uint8_t *Mode)
  223. {
  224.         uint8_t State;
  225.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  226.         
  227.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  228.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  229.         
  230.         HSJ121_SendData[Length]=0x0C;        //添加数据长度
  231.         HSJ121_SendData[CMD]=0x70;         //添加命令码
  232.         CopyData(&HSJ121_SendData[DataPOS],Mode,10);
  233.         
  234.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);        
  235.         
  236. //        将模块回复的数据从HEX码转成Char
  237.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  238.         
  239.         EXTI->IMR|=1<<13;  //开13线上中断
  240.         return State;
  241. }
  242. /******************************************/
  243. //函数原型： HSJ121_Set_NearInductionMode(uint8_t *Mode)
  244. //输入参数： *Mode 设置模式码（10个字节）
  245. //输出参数： 无
  246. //函数返回： TRUE or FALSE
  247. //功能描述： 设置临近感应模式
  248. /******************************************/
  249. uint8_t HSJ121_Set_NearInductionMode(uint8_t *Mode)
  250. {
  251.         uint8_t State;
  252.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  253.         
  254.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  255.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  256.         
  257.         HSJ121_SendData[Length]=0x0C;        //添加数据长度
  258.         HSJ121_SendData[CMD]=0x70;         //添加命令码
  259.         CopyData(&HSJ121_SendData[DataPOS],Mode,10);
  260.         
  261.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  262.         
  263. //        将模块回复的数据从HEX码转成Char
  264.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  265.         
  266.         EXTI->IMR|=1<<13;  //开13线上中断
  267.         return State;
  268. }
  269. /******************************************/
  270. //函数原型： uint8_t        HSJ121_Get_Config()
  271. //输入参数： 无
  272. //输出参数： 无
  273. //函数返回： TRUE or FALSE
  274. //功能描述： 获取配置信息
  275. /******************************************/
  276. uint8_t        HSJ121_Get_Config(void)
  277. {
  278.         uint8_t State;
  279.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  280.         
  281.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  282.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  283.         
  284.         HSJ121_SendData[Length]=0x02;        //添加数据长度
  285.         HSJ121_SendData[CMD]=0x80;         //添加命令码
  286.         
  287.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  288.         
  289. //        将模块回复的数据从HEX码转成Char
  290.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  291.         
  292.         EXTI->IMR|=1<<13;  //开13线上中断
  293.         return State;
  294. }
  295. /******************************************/
  296. //函数原型： HSJ121_Get_Key(void)
  297. //输入参数： 无
  298. //输出参数： 无
  299. //函数返回： TRUE or FALSE
  300. //功能描述： 获取键值
  301. /******************************************/
  302. uint8_t        HSJ121_Get_Key(void)
  303. {
  304.         uint8_t num;
  305.         uint8_t State;
  306.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  307.         
  308.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  309.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  310.         
  311.         HSJ121_SendData[Length]=0x02;        //添加数据长度
  312.         HSJ121_SendData[CMD]=0xA0;         //添加命令码
  313.         
  314.         for(num=0;num<3;num++)
  315.         {
  316.                 State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  317.                 if(State==TRUE){
  318.                         break;
  319.                 }
  320.         }        
  321.         
  322. //        将模块回复的数据从HEX码转成Char
  323.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  324.         
  325.         EXTI->IMR|=1<<13;  //开13线上中断
  326.         return State;
  327. }
  328. /******************************************/
  329. //函数原型： HSJ121_Set_ScanTime(uint8_t *ScanTme)
  330. //输入参数： *ScanTme 扫描时间
  331. //输出参数： 无
  332. //函数返回： TRUE or FALSE
  333. //功能描述： 设置扫描时间
  334. /******************************************/
  335. uint8_t HSJ121_Set_ScanTime(uint8_t *ScanTme)  //设置按键扫描时间
  336. {
  337.         uint8_t State;
  338.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  339.         
  340.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  341.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  342.         
  343.         HSJ121_SendData[Length]=0x04;        //添加数据长度
  344.         HSJ121_SendData[CMD]=0x71;         //添加命令码
  345.         CopyData(&HSJ121_SendData[DataPOS],ScanTme,HSJ121_KeyScanTimeLength);
  346.         
  347.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  348.         
  349. //        将模块回复的数据从HEX码转成Char
  350.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  351.         
  352.         EXTI->IMR|=1<<13;  //开13线上中断
  353.         return State;        
  354. }
  355. /******************************************/
  356. //函数原型： HSJ121_Get_ScanTime(void)
  357. //输入参数： 无
  358. //输出参数： 无
  359. //函数返回： TRUE or FALSE
  360. //功能描述： 获取扫描时间
  361. /******************************************/
  362. uint8_t HSJ121_Get_ScanTime(void)  //获取按键扫描时间
  363. {
  364.         uint8_t State;
  365.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  366.         
  367.   ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  368.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  369.         
  370.         HSJ121_SendData[Length]=0x02;        //添加数据长度
  371.         HSJ121_SendData[CMD]=0x81;         //添加命令码
  372.         
  373.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  374.         
  375. //        将模块回复的数据从HEX码转成Char
  376.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  377.         
  378.         EXTI->IMR|=1<<13;  //开13线上中断
  379.         return State;
  380. }        
  381. /******************************************/
  382. //函数原型： HSJ121_Set_SleepMode(void)
  383. //输入参数： 无
  384. //输出参数： 无
  385. //函数返回： TRUE or FALSE
  386. //功能描述： 设置睡眠模式
  387. /******************************************/
  388. uint8_t        HSJ121_Set_SleepMode(void)
  389. {
  390.         uint8_t State;
  391.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  392.         
  393.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  394.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  395.         
  396.         HSJ121_SendData[Length]=0x03;        //添加数据长度
  397.         HSJ121_SendData[CMD]=0x91;         //添加命令码
  398. //        HSJ121_SendData[DataPOS]=0x00;        //关闭睡眠模式
  399.         HSJ121_SendData[DataPOS]=0x01;        //使能睡眠模式        
  400.         
  401.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  402.         
  403. //        将模块回复的数据从HEX码转成Char
  404.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  405.         
  406.         EXTI->IMR|=1<<13;  //开13线上中断
  407.         return State;
  408. }
  409. /******************************************/
  410. //函数原型： HSJ121_Into_SleepMode(void)
  411. //输入参数： 无
  412. //输出参数： 无
  413. //函数返回： TRUE or FALSE
  414. //功能描述： 进入睡眠模式
  415. /******************************************/
  416. uint8_t        HSJ121_Into_SleepMode(void)
  417. {
  418.         uint8_t State;
  419.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  420.         
  421.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  422.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据        
  423.         
  424.         HSJ121_SendData[Length]=0x02;        //添加数据长度
  425.         HSJ121_SendData[CMD]=0x90;         //添加命令码
  426.         
  427.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);

  429. //        将模块回复的数据从HEX码转成Char
  430.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  431.         
  432.         EXTI->IMR|=1<<13;  //开13线上中断
  433.         return State;
  434. }
  435. /******************************************/
  436. //函数原型： HSJ121_WakeUp()
  437. //输入参数： 无
  438. //输出参数： 无
  439. //函数返回： TRUE or FALSE
  440. //功能描述： 唤醒芯片，进入工作模式
  441. /******************************************/
  442. uint8_t HSJ121_WakeUp(void)  
  443. {
  444.         uint8_t State;
  445.         EXTI->IMR&=~(1<<13); //屏蔽13线上中断
  446.         
  447.         ClearData(HSJ121_SendData,HSJ121_SendDataLength); //清零发送数据
  448.         ClearData(HSJ121_ReciveData,HSJ121_ReciveDataLength); //清零接收数据
  449.         
  450.         HSJ121_SendData[Length]=0x02;        //添加数据长度
  451.         HSJ121_SendData[CMD]=0xA6;         //添加命令码

  453.         State=HSJ121_SendAndRecive(HSJ121_SendData,HSJ121_ReciveData);
  454.         
  455. //        将模块回复的数据从HEX码转成Char
  456.         HexToChar(HSJ121_ReciveData,(HSJ121_ReciveData[Length]+1));
  457.         
  458.         EXTI->IMR|=1<<13;  //开13线上中断
  459.         return State;        
  460. }        
  461.                                  
复制代码


  1. //////////////////////////////////////////////////////////////////////////////////         
  2. //本程序只供测试使用，不能用作产品代码
  3. //////////////////////////////////////////////////////////////////////////////////
  4. /* 包含的头文件 --------------------------------------------------------------*/
  5. #include "bsp.h"
  6. #include "i2c.h"
  7. #include "timer.h"
  8. #include "usart.h"

  10. #include "aboutdata.h"
  11. #include "HSJ121.h"

  13. /************************************************
  14. 函数名称 ： System_Initializes
  15. 功    能 ： 系统初始化
  16. 参    数 ： 无
  17. 返 回 值 ： 无
  18. 作    者 ：
  19. *************************************************/
  20. void System_Initializes(void)
  21. {
  22.   BSP_Initializes();                                                                                                                //底层初始化
  23.   TIMER_Initializes();                                                                                                        //TIMER初始化
  24.   USART_Initializes();                                                                                                        //串口1初始化
  25. }

  27. /************************************************
  28. 函数名称 ： main
  29. 功    能 ： 主函数入口
  30. 参    数 ： 无
  31. 返 回 值 ： int
  32. 作    者 ：
  33. *************************************************/
  34. int main(void)
  35. {
  36.   System_Initializes();                                                                                                         //系统初始化
  37.         HSJ121Init();                                                                                                                                         //芯片初始化

  39. //所有命令都必须在唤醒成功的状态下执行
  40. //---------------------芯片唤醒-------------------------//
  41. #if HSJ_WakeUp_en
  42.                 if(HSJ121_WakeUp()==TRUE){
  43.                         printf("Wake Up Success\n");
  44.                         USART1_PrintfNChar(CharData,strlen(CharData));        
  45. //-----------------------------------------------------//                                
  46. //---------------------低速扫描模式---------------------//
  47. #if        HSJ_LowScanMode_en
  48.                 if(HSJ121_Set_LowScanMode(HSJ121_Mode_LowScan)==TRUE){
  49.                         printf("Set Low Scan Mode Success\n");
  50.                         USART1_PrintfNChar(CharData,strlen(CharData));
  51.                 }else{
  52.                         printf("Set Low Scan Mode Fail\n");
  53.                         USART1_PrintfNChar(CharData,strlen(CharData));
  54.                 }
  55. #endif                        
  56. //---------------------接近感应模式---------------------//
  57. #if        HSJ_NearInductionMode_en
  58.                 if(HSJ121_Set_NearInductionMode(HSJ121_Mode_NearInduction)==TRUE){
  59.                         printf("Set Near Induction Mode Success\n");
  60.                         USART1_PrintfNChar(CharData,strlen(CharData));
  61.                 }else{
  62.                         printf("Set Near Induction Mode Fail\n");
  63.                         USART1_PrintfNChar(CharData,strlen(CharData));
  64.                 }        
  65. #endif               
  66. //---------------------获取配置-------------------------//
  67. #if HSJ_GetConfig_en
  68.                 if(HSJ121_Get_Config()==TRUE){
  69.                         printf("Get Config Success\n");
  70.                         USART1_PrintfNChar(CharData,strlen(CharData));
  71.                 }else{
  72.                         printf("Get Config Fail\n");
  73.                         USART1_PrintfNChar(CharData,strlen(CharData));
  74.                 }
  75. #endif
  76. //---------------------设置扫描时间----------------------//        
  77. #if HSJ_SetScanTime_en
  78.                 if(HSJ121_Set_ScanTime(HSJ121_KeyScanTime)==TRUE){
  79.                         printf("Set Scan Time Success\n");
  80.                         USART1_PrintfNChar(CharData,strlen(CharData));
  81.                 }else{
  82.                         printf("Set Scan Time Fail\n");
  83.                         USART1_PrintfNChar(CharData,strlen(CharData));
  84.                 }
  85. #endif
  86. //---------------------获取扫描时间----------------------//        
  87. #if HSJ_GetScanTime_en
  88.                 if(HSJ121_Get_ScanTime()==TRUE){
  89.                         printf("Get Scan Time Success\n");
  90.                         USART1_PrintfNChar(CharData,strlen(CharData));
  91.                 }else{
  92.                         printf("Get Scan Time Fail\n");
  93.                         USART1_PrintfNChar(CharData,strlen(CharData));
  94.                 }
  95. #endif        
  96. //---------------------设置睡眠模式----------------------//        
  97. #if HSj_SetSleepMode_en
  98.                 if(HSJ121_Set_SleepMode()==TRUE){
  99.                         printf("Set Sleep Mode Success\n");
  100.                         USART1_PrintfNChar(CharData,strlen(CharData));
  101.                 }else{
  102.                         printf("Set Sleep Mode Fail\n");
  103.                         USART1_PrintfNChar(CharData,strlen(CharData));
  104.                 }
  105. #endif                        
  106. //---------------------进入睡眠模式---------------------//
  107. #if HSJ_IntoSleepMode_en
  108.                 if(HSJ121_Into_SleepMode()==TRUE){
  109.                         printf("Into Sleep Mode Success\n");
  110.                         USART1_PrintfNChar(CharData,strlen(CharData));
  111.                 }else{
  112.                         printf("Into Sleep Mode Fail\n");
  113.                         USART1_PrintfNChar(CharData,strlen(CharData));
  114.                 }               
  115. #endif               
  116. //-----------------------------------------------------//                                
  117.                 }else{
  118.                         printf("Wake Up Fail\n");
  119.                         USART1_PrintfNChar(CharData,strlen(CharData));
  120.                 }        
  121. #endif
  122.                
  123.   while(1);
  124. }


  127. /******************************* end ************************************/
复制代码

所有资料51hei提供下载:
HSJ121-STM32F103RCT6.7z (391.06 KB, 下载次数: 15)
stm32, 源代码, C语言

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

相关帖子
回复

使用道具 举报

ID:495929 发表于 2019-6-5 10:39 | 显示全部楼层
楼主，我IIC读出来的数据一直是0,你有么有碰到类似的情况？
回复

使用道具 举报

ID:495929 发表于 2019-6-5 19:31 | 显示全部楼层
楼主我用了你的hsj121的源码，就是read的时候一直是0，很奇怪
回复

使用道具 举报

ID:516571 发表于 2019-6-8 11:36 | 显示全部楼层
感谢楼主的分享，好好学习下
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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