返回列表 发新帖本帖赏金: 20.00元(功能说明)

[麦麦茶水间] 【每周分享】用AI生成的按键驱动代码,调试的时候偶现HardFault了

[复制链接]
16779|4
dffzh 发表于 2026-9-10 18:37 | 显示全部楼层 |阅读模式
#申请原创# #技术资源#


最近在开发的一个产品,要通过几个按键操作LCD显示屏,并且某些按键还要同时支持单按、双按和长按,于是乎我就用某个AI软件生成了一段大概满足需求按键驱动代码,我把它们分别放入了源文件和头文件,其中修改或增加了按键个数,按键触发电平和按键事件个数等宏定义,以及修改了按键绑定的GPIO信息等接口,但核心代码未做修改,主要代码如下所示:
头文件代码:
  1. <font face="Tahoma">// 最大按键数量
  2. #define KEY_MAX_NUM                    3

  3. // 按键参数配置
  4. #define KEY_SCAN_INTERVAL_MS  10      // 扫描周期(ms)
  5. #define DEBOUNCE_TIME         2       // 消抖次数(约30ms)
  6. #define SHORT_PRESS_TIME      30      // 短按判定时间(300ms)
  7. #define LONG_PRESS_TIME       300     // 长按判定时间(3000ms)
  8. #define DOUBLE_CLICK_INTERVAL 30      // 双击间隔(300ms)

  9. //按键按下时的电平
  10. #define KEY_TRIGGER_LEVEL     0     

  11. //按键事件的个数(短按,双按,长按)
  12. #define KEY_EVENT_MAX                  3
  13. // 按键事件枚举
  14. typedef enum
  15. {
  16.     KEY_EVENT_NONE = 0,    // 无事件
  17.     KEY_EVENT_SINGLE,      // 单按
  18.     KEY_EVENT_DOUBLE,      // 双按
  19.     KEY_EVENT_LONG         // 长按
  20. } KeyEvent_t;

  21. // 按键ID枚举(方便调用)
  22. typedef enum
  23. {
  24.     KEY_UP_ID = 0,
  25.     KEY_SET_ID,
  26.     KEY_DOWN_ID,
  27. } KeyId_t;

  28. // 按键状态机
  29. typedef enum
  30. {
  31.     STATE_IDLE = 0,          // 空闲状态
  32.     STATE_PRESSED,           // 按键已按下(已经去抖)
  33.     STATE_LONG_PRESSED,      // 按键长按触发
  34.     STATE_WAIT_RELEASE,      // 等待释放(用于单双击判定)
  35. } KeyState_t;

  36. // 单个按键对象
  37. typedef struct
  38. {
  39.     uint8_t (*getLevel)(void);   // IO电平读取函数
  40.     KeyState_t state; //按键处理状态机
  41.     uint8_t debounceCnt;        //消抖时间计时
  42.     uint16_t pressCnt;        //按下时间计时
  43.     uint16_t releaseCnt;        //释放时间计时
  44.     uint8_t isLongPressTriggered;        //长按触发标志
  45.     uint8_t isDoublePressCheck;                //双击检测标志
  46.         uint8_t isDoublePressTriggered;        //双击触发标志
  47.     KeyEvent_t event;
  48. } KeyObject_t;

  49. // 按键管理器
  50. static struct
  51. {
  52.     KeyObject_t keys[KEY_MAX_NUM];
  53.     uint8_t keyCount;
  54. } keyManager = {0};

  55. extern uint8_t (*keyLevelFuncs[])(void);

  56. // 初始化:传入每个按键的读取函数指针数组和数量
  57. void Key_Init(uint8_t (*getLevelFuncs[])(void), uint8_t keyNum);

  58. // 定时扫描函数(每10ms调用一次)
  59. void Key_Scan(void);

  60. // 获取指定按键的事件(非阻塞)
  61. KeyEvent_t Key_GetEvent(KeyId_t keyId);

  62. // 可选:清空指定按键的事件
  63. void Key_ClearEvent(KeyId_t keyId);</font>
源文件代码如下:
  1. <font face="Tahoma">// 三个按键的IO读取函数
  2. static uint8_t GetKeyUpLevel(void)   //上键
  3. {
  4.     return KEY_UP_READ();
  5. }

  6. static uint8_t GetKeySetLevel(void) //设置键
  7. {
  8.     return KEY_SET_READ();
  9. }

  10. static uint8_t GetKeyDownLevel(void) //下键
  11. {
  12.     return KEY_DOWN_READ();
  13. }

  14. // 函数指针数组
  15. uint8_t (*keyLevelFuncs[])(void) =
  16. {
  17.     GetKeyUpLevel,
  18.     GetKeySetLevel,
  19.     GetKeyDownLevel
  20. };


  21. // 初始化
  22. void Key_Init(uint8_t (*getLevelFuncs[])(void), uint8_t keyNum)
  23. {
  24.     uint8_t i = 0;

  25.     if (keyNum > KEY_MAX_NUM)
  26.         {
  27.             keyNum = KEY_MAX_NUM;
  28.     }
  29.    
  30.     keyManager.keyCount = keyNum;
  31.     memset(keyManager.keys, 0, sizeof(keyManager.keys));
  32.    
  33.     for (i = 0; i < keyNum; i++)
  34.         {
  35.         keyManager.keys[i].getLevel = getLevelFuncs[i];
  36.         keyManager.keys[i].state = STATE_IDLE;
  37.         keyManager.keys[i].event = KEY_EVENT_NONE;
  38.     }
  39. }

  40. // 处理单个按键的状态机(内部函数)
  41. //按键优先级: 长按>双按>单按
  42. static void ProcessKey(KeyObject_t *key)
  43. {
  44.     uint8_t level = key->getLevel();
  45.    
  46.     switch (key->state)
  47.         {
  48.         case STATE_IDLE:
  49.                 {
  50.             if (KEY_TRIGGER_LEVEL == level)
  51.                         {
  52.                 key->debounceCnt++;
  53.                 if (key->debounceCnt >= DEBOUNCE_TIME)
  54.                                 {
  55.                     key->state = STATE_PRESSED;
  56.                     key->pressCnt = 0;
  57.                 }
  58.             }
  59.                         else
  60.                         {
  61.                 key->debounceCnt = 0;
  62.             }
  63.             break;
  64.         }
  65.         
  66.         case STATE_PRESSED:
  67.                 {
  68.             if (KEY_TRIGGER_LEVEL == level)
  69.                         {
  70.                 key->pressCnt++;
  71.                 // 长按检测(仅在未触发时),如果一直按着,则仅触发一次实际动作
  72.                 if (key->pressCnt >= LONG_PRESS_TIME && !key->isLongPressTriggered)
  73.                                 {
  74.                                         key->state = STATE_LONG_PRESSED;     
  75.                                         key->isLongPressTriggered = 1;
  76.                                         key->isDoublePressCheck = 0;
  77.                             key->event = KEY_EVENT_LONG; //长按事件
  78.                 }
  79.             }
  80.                         else
  81.                         {
  82.                 // 释放:判断是否为有效短按(按下时间 > 消抖时间 且 < 长按时间)
  83.                 if (key->pressCnt >= DEBOUNCE_TIME && key->pressCnt < LONG_PRESS_TIME)
  84.                                 {
  85.                                     if(key->isDoublePressCheck)
  86.                                     {
  87.                                             key->isDoublePressCheck = 0;
  88.                                                 key->pressCnt = 0;
  89.                                         key->event = KEY_EVENT_DOUBLE; //双按事件
  90.                                                 key->state = STATE_IDLE;
  91.                                     }
  92.                                         else
  93.                                         {
  94.                             key->pressCnt = 0;
  95.                             key->releaseCnt = 0;
  96.                                                 key->state = STATE_WAIT_RELEASE; // 进入双击等待状态
  97.                                         }
  98.                 }
  99.                                 else
  100.                 {
  101.                     key->state = STATE_IDLE;
  102.                 }
  103.                 key->debounceCnt = 0;
  104.             }
  105.             break;
  106.         }
  107.         case STATE_LONG_PRESSED:
  108.                 {
  109.                         //长按中如果松开按键,则回到空闲
  110.                         if(KEY_TRIGGER_LEVEL != level)
  111.                         {
  112.                                 key->debounceCnt = 0;
  113.                 key->pressCnt = 0;
  114.                 key->isLongPressTriggered = 0;
  115.                                 key->state = STATE_IDLE;
  116.             }
  117.                         break;
  118.                 }
  119.         case STATE_WAIT_RELEASE:
  120.                 {
  121.             if (KEY_TRIGGER_LEVEL == level)  // 双击(再次按下)
  122.                         {
  123.                 key->state = STATE_PRESSED;
  124.                 key->pressCnt = 0;
  125.                                 key->isDoublePressCheck = 1;
  126.             }
  127.                         else  // 继续释放
  128.                         {
  129.                 key->releaseCnt++;
  130.                 if (key->releaseCnt >= DOUBLE_CLICK_INTERVAL)
  131.                                 {
  132.                     // 超时,判定为单击
  133.                     key->releaseCnt = 0;
  134.                     key->event = KEY_EVENT_SINGLE; //单按事件
  135.                     key->state = STATE_IDLE;
  136.                 }
  137.             }
  138.             break;
  139.         }
  140.         
  141.         default:
  142.                 {
  143.             key->state = STATE_IDLE;
  144.             break;
  145.         }
  146.     }
  147. }

  148. // 定时扫描所有按键
  149. void Key_Scan(void)
  150. {
  151.     uint8_t i = 0;

  152.     for (i = 0; i < keyManager.keyCount; i++)
  153.         {
  154.         ProcessKey(&keyManager.keys[i]);
  155.     }
  156. }

  157. // 获取指定按键的事件
  158. KeyEvent_t Key_GetEvent(KeyId_t keyId)
  159. {
  160.     if (keyId >= keyManager.keyCount)
  161.         {
  162.         return KEY_EVENT_NONE;
  163.     }
  164.    
  165.     KeyEvent_t evt = keyManager.keys[keyId].event;
  166.     keyManager.keys[keyId].event = KEY_EVENT_NONE; // 自动清除
  167.     return evt;
  168. }

  169. // 清空指定按键的事件(如需手动清除)
  170. void Key_ClearEvent(KeyId_t keyId)
  171. {
  172.     if (keyId < keyManager.keyCount)
  173.         {
  174.         keyManager.keys[keyId].event = KEY_EVENT_NONE;
  175.     }
  176. }</font>
其中:
按键初始化接口Key_Init上电执行一次,用于按键结构体数据初始化和绑定GPIO;
按键处理接口ProcessKey被按键扫描接口Key_Scan调用,用于按键事件的检测;
按键扫描接口Key_Scan在10ms定时器中断里周期执行,用于按键扫描和计时处理;
按键事件读取接口Key_GetEvent在应用层里周期执行,用于读取按键事件并处理;
按键事件清除接口Key_ClearEvent在读取按键事件后被调用,用于清除上一次按键信息。
总体来说,AI生成的代码在可读性,变量和函数命名以及实现逻辑上都还不错,所以我就赶紧移植到工程上,然后试试效果。

我增加了一段按键测试代码,只要有按键事件,就会打印按键消息到串口,如下所示:
  1. <font face="Tahoma">// 打印按键事件信息结构体
  2. typedef struct
  3. {
  4.     KeyId_t key_id;
  5.         KeyEvent_t key_event;
  6.         uint8_t *pKeyInfo;
  7. } KeyEventPrint_t;

  8. const KeyEventPrint_t stKeyInfoList[KEY_MAX_NUM*KEY_EVENT_MAX] =
  9. {
  10.     {KEY_UP_ID,                                         KEY_EVENT_SINGLE,                        "UP键单按事件触发"},
  11.     {KEY_UP_ID,                                         KEY_EVENT_DOUBLE,                        "UP键双按事件触发"},
  12.     {KEY_UP_ID,                                         KEY_EVENT_LONG,                                "UP键长按事件触发"},
  13.     {KEY_SET_ID,                                         KEY_EVENT_SINGLE,                        "SET键单按事件触发"},
  14.     {KEY_SET_ID,                                         KEY_EVENT_DOUBLE,                        "SET键双按事件触发"},
  15.     {KEY_SET_ID,                                         KEY_EVENT_LONG,                                "SET键长按事件触发"},
  16.     {KEY_DOWN_ID,                                         KEY_EVENT_SINGLE,                        "DOWN键单按事件触发"},
  17.     {KEY_DOWN_ID,                                         KEY_EVENT_DOUBLE,                        "DOWN键双按事件触发"},
  18.     {KEY_DOWN_ID,                                         KEY_EVENT_LONG,                                "DOWN键长按事件触发"},
  19. };

  20. //读取按键事件
  21.         for(i=0; i<KEY_MAX_NUM; i++)
  22.         {
  23.             keyEventBuff[i] = Key_GetEvent(i);
  24.                 if(keyEventBuff[i] != KEY_EVENT_NONE)
  25.                 {
  26.                         printf("按键信息: %s\r\n", Key_PrintEvent(i, keyEventBuff[i]));
  27.                 }
  28.         }</font>
一开始没有使用Keil仿真调试,是直接看串口打印的,发现的确可以实现我需要的功能:
1.png
然后后面想实时仿真看下按键结构体keyManager的成员变量数据,结果发现其中的指示按键数量的变量却是13,正常是3才对;然后看了每个按键管理下的变量,显示的值也是奇奇怪怪:
1.png
然后我还通过clean Targets再全编译等操作,都一样,太奇怪了吧!此时还是比较疑惑~

然后反复仿真,有一次发现指示main循环运行次数的全局变量gRunCount一直为0,就是说main没有正常跑起来:
1.png
然后单步运行看一下,果然是触发HardFault异常中断了,实际显示的现象如下图所示:
1.png
其实这个时候按键管理器结构体里面的变量数据,在进入仿真且还没有全速运行程序的时候,就已经是上面的错误显示了。
然后没办法,我只能怀疑是按键驱动代码里面哪里有非法操作了,然后就去检查
……
……

从头到尾仔细检查了一遍,唯一看着有点别扭的地方就是按键管理器那个结构体的写法:
1.png
用static定义了一个没有名字的静态结构体类型,然后结构体变量的名称是keyManager,所以在按键驱动源文件里面都是直接用keyManager加成员变量的方式来操作的。

看这里的写法我总觉得别扭,因为这里没有使用常用的typedef struct方式来定义结构体,然后我先试着去掉static,编译时候报错了:
1.png
我把这个按键管理器结构体定义放到按键驱动源文件里面,再编译,就OK了。

此时我再通过单步调试的方式去查看按键管理器的相关数据变量,发现全部正常了:
1.png
因为这个时候keyManager还是static类型,所以没办法在全速运行的时候去监控它的数据变化,但是我估计,应该是没问题了。

接着,我换了一个方式,我用自己常用的typedef方式在头文件里面直接重新定义了这个结构体,并命名为keyManager_t,也更方便再单独定义结构体变量或者结构体数组如下所示:
  1. <font face="Tahoma">// 按键管理器
  2. typedef struct
  3. {
  4.     KeyObject_t keys[KEY_MAX_NUM];
  5.     uint8_t keyCount;
  6. } keyManager_t;</font>
然后定义了一个结构体变量来管理按键,名称还是用keyManager,这样的话,其他代码就不用修改了:
keyManager_t keyManager;
修改完成,赶紧编译试试效果!
大家先猜测是什么结果??
……
……
反正我不管按键能不能正常触发,我就先看按键管理器里的变量数据是否正常!

真是是正常了,全部都是上电后的默认值(缺省值):
1.png
2.png
然后试了长按SET键和短按SET键,串口也是有正常打印的,按键管理器也是正常显示状态的:
3.png
1.png
后面进行了多次测试,目前暂未出现之前的HardFault异常了!
为什么把最初的那种定义方式放在头文件里面会导致HardFault异常呢?
程序编译的时候没有产生报错,也没有产生警告,加上我自己当时也没注意,以为都正常的。
其实static struct { ... } keyManager = {0};这种写法定义在头文件里面,其中static 修饰的是文件作用域变量,每个包含该头文件的源文件都会生成自己独立的一份keyManager副本;如果头文件被多个源文件包含(当然,实际是肯定有),链接时不会报重复定义(因为 static 是内部链接,如果把static去掉,就会像我之前那样报重复定义错误了)错误,但每个源文件都有自己的副本,你以为在A.c文件里初始化/写入的keyManager,在B.c文件里读到的是另一份全0的数据,据不完全统计,这类数据不一致的Bug就很有可能导致HardFault异常,看来在我这里的现象,应该就是这个原因了。
的确,按以为的代码编写习惯,好像是真没有操作过在头文件里面用static关键词的,疏忽了,有点尴尬~~

用AI生成的按键驱动代码,如果我们操作不当,真是有可能造成一些程序问题,说不定一开始我们还会认为是AI生成的代码有问题,但有时候吧,有些代码的写法的确不是最好的,加上我们的错误操作,就导致Bug了。所以啊,至少对我来说,这是一次好的经验教训。

打赏榜单

21小跑堂 打赏了 20.00 元 2026-10-28
理由:恭喜通过原创审核!期待您更多的原创作品~~

评论

这是一篇有价值的调试经验分享,提醒读者检查 AI 代码的文件组织和共享状态。最值得学习的是区分类型定义、变量定义和链接属性。 发表于 2026-10-28 16:16
吃一堑长一智的路上,哈哈。 发表于 2026-9-11 09:07
围观一下,坛友高手 发表于 2026-9-10 19:09
Henryko 发表于 2026-9-11 11:45 | 显示全部楼层
检查GPIO配置,确认是否有误触发,看是否因为按键与GPIO的连接或配置问题导致的HardFault。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

572

主题

4069

帖子

27

粉丝
快速回复 在线客服 返回列表 返回顶部