21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 上传个文档:《HardFault的诊断》 自问自答 ...
12下一页
返回列表 发新帖我要提问

上传个文档:《HardFault的诊断》 自问自答

[复制链接]
32643|35
 楼主| aozima 发表于 2012-11-30 00:23 | 显示全部楼层 |阅读模式
Fault, HardFault, 光盘, ST, 工程师
本帖最后由 aozima 于 2012-11-30 00:26 编辑

上次ST研究中，有位ST的漂亮女工程师讲了关于hardfault的排查，讲得非常好。
以为光盘中会有PPT，今天搜索光盘结果发现没有。
不知道这个文档是否可以提供？
回复

收藏9 举报

相关帖子
 楼主| aozima 发表于 2012-11-30 00:25 | 显示全部楼层
刚网上搜了一番，在http://st.**.com/down/index.php?id=120找到了。
上传之。
HardFault的诊断.pdf (226.79 KB, 下载次数: 2216)
回复

收藏9 举报

acgean 发表于 2012-11-30 08:57 | 显示全部楼层
嗯, 好东西, 要进一步写好 Cortrx M3 的程序, 这一块东西必须得学习掌握. 感谢楼主
回复

收藏9 举报

 楼主| aozima 发表于 2012-12-2 21:58 | 显示全部楼层
本帖最后由 aozima 于 2012-12-2 22:07 编辑

项目中加了一些代码，Fault 后可以打印出更多的信息。
复制
  1. #define SCB_CFSR        (*(volatile const unsigned *)0xE000ED28) /* Configurable Fault Status Register */
    

  2. #define SCB_HFSR        (*(volatile const unsigned *)0xE000ED2C) /* HardFault Status Register */
    

  3. #define SCB_MMAR        (*(volatile const unsigned *)0xE000ED34) /* MemManage Fault Address register */
    

  4. #define SCB_BFAR        (*(volatile const unsigned *)0xE000ED38) /* Bus Fault Address Register */
    


  5. 

  6. #define SCB_CFSR_MFSR   (*(volatile const unsigned char*)0xE000ED28)  /* Memory-management Fault Status Register */
    

  7. #define SCB_CFSR_BFSR   (*(volatile const unsigned char*)0xE000ED29)  /* Bus Fault Status Register */
    

  8. #define SCB_CFSR_UFSR   (*(volatile const unsigned short*)0xE000ED2A) /* Usage Fault Status Register */
    


  9. 

  10. static void usage_fault_track(void)
    

  11. {
    

  12.     rt_kprintf("usage fault:\n");
    

  13.     rt_kprintf("SCB_CFSR_UFSR:0x%02X ", SCB_CFSR_UFSR);
    


  14. 

  15.     if(SCB_CFSR_UFSR & (1<<0))
    

  16.     {
    

  17.         /* [0]:UNDEFINSTR */
    

  18.         rt_kprintf("UNDEFINSTR ");
    

  19.     }
    


  20. 

  21.     if(SCB_CFSR_UFSR & (1<<1))
    

  22.     {
    

  23.         /* [1]:INVSTATE */
    

  24.         rt_kprintf("INVSTATE ");
    

  25.     }
    


  26. 

  27.     if(SCB_CFSR_UFSR & (1<<2))
    

  28.     {
    

  29.         /* [2]:INVPC */
    

  30.         rt_kprintf("INVPC ");
    

  31.     }
    


  32. 

  33.     if(SCB_CFSR_UFSR & (1<<3))
    

  34.     {
    

  35.         /* [3]:NOCP */
    

  36.         rt_kprintf("NOCP ");
    

  37.     }
    


  38. 

  39.     if(SCB_CFSR_UFSR & (1<<8))
    

  40.     {
    

  41.         /* [8]:UNALIGNED */
    

  42.         rt_kprintf("UNALIGNED ");
    

  43.     }
    


  44. 

  45.     if(SCB_CFSR_UFSR & (1<<9))
    

  46.     {
    

  47.         /* [9]:DIVBYZERO */
    

  48.         rt_kprintf("DIVBYZERO ");
    

  49.     }
    


  50. 

  51.     rt_kprintf("\n");
    

  52. }
    


  53. 

  54. static void bus_fault_track(void)
    

  55. {
    

  56.     rt_kprintf("bus fault:\n");
    

  57.     rt_kprintf("SCB_CFSR_BFSR:0x%02X ", SCB_CFSR_BFSR);
    


  58. 

  59.     if(SCB_CFSR_BFSR & (1<<0))
    

  60.     {
    

  61.         /* [0]:IBUSERR */
    

  62.         rt_kprintf("IBUSERR ");
    

  63.     }
    


  64. 

  65.     if(SCB_CFSR_BFSR & (1<<1))
    

  66.     {
    

  67.         /* [1]:PRECISERR */
    

  68.         rt_kprintf("PRECISERR ");
    

  69.     }
    


  70. 

  71.     if(SCB_CFSR_BFSR & (1<<2))
    

  72.     {
    

  73.         /* [2]:IMPRECISERR */
    

  74.         rt_kprintf("IMPRECISERR ");
    

  75.     }
    


  76. 

  77.     if(SCB_CFSR_BFSR & (1<<3))
    

  78.     {
    

  79.         /* [3]:UNSTKERR */
    

  80.         rt_kprintf("UNSTKERR ");
    

  81.     }
    


  82. 

  83.     if(SCB_CFSR_BFSR & (1<<4))
    

  84.     {
    

  85.         /* [4]:STKERR */
    

  86.         rt_kprintf("STKERR ");
    

  87.     }
    


  88. 

  89.     if(SCB_CFSR_BFSR & (1<<7))
    

  90.     {
    

  91.         rt_kprintf("SCB->BFAR:%08X\n", SCB_BFAR);
    

  92.     }
    

  93.     else
    

  94.     {
    

  95.         rt_kprintf("\n");
    

  96.     }
    

  97. }
    


  98. 

  99. static void mem_manage_fault_track(void)
    

  100. {
    

  101.     rt_kprintf("mem manage fault:\n");
    

  102.     rt_kprintf("SCB_CFSR_MFSR:0x%02X ", SCB_CFSR_MFSR);
    


  103. 

  104.     if(SCB_CFSR_MFSR & (1<<0))
    

  105.     {
    

  106.         /* [0]:IACCVIOL */
    

  107.         rt_kprintf("IACCVIOL ");
    

  108.     }
    


  109. 

  110.     if(SCB_CFSR_MFSR & (1<<1))
    

  111.     {
    

  112.         /* [1]:DACCVIOL */
    

  113.         rt_kprintf("DACCVIOL ");
    

  114.     }
    


  115. 

  116.     if(SCB_CFSR_MFSR & (1<<3))
    

  117.     {
    

  118.         /* [3]:MUNSTKERR */
    

  119.         rt_kprintf("MUNSTKERR ");
    

  120.     }
    


  121. 

  122.     if(SCB_CFSR_MFSR & (1<<4))
    

  123.     {
    

  124.         /* [4]:MSTKERR */
    

  125.         rt_kprintf("MSTKERR ");
    

  126.     }
    


  127. 

  128.     if(SCB_CFSR_MFSR & (1<<7))
    

  129.     {
    

  130.         /* [7]:MMARVALID */
    

  131.         rt_kprintf("SCB->MMAR:%08X\n", SCB_MMAR);
    

  132.     }
    

  133.     else
    

  134.     {
    

  135.         rt_kprintf("\n");
    

  136.     }
    

  137. }
    


  138. 

  139. static void hard_fault_track(void)
    

  140. {
    

  141.     if(SCB_HFSR & (1UL<<1))
    

  142.     {
    

  143.         /* [1]:VECTBL, Indicates hard fault is caused by failed vector fetch. */
    

  144.         rt_kprintf("failed vector fetch\n");
    

  145.     }
    


  146. 

  147.     if(SCB_HFSR & (1UL<<30))
    

  148.     {
    

  149.         /* [30]:FORCED, Indicates hard fault is taken because of bus fault,
    

  150.                         memory management fault, or usage fault. */
    

  151.         if(SCB_CFSR_BFSR)
    

  152.         {
    

  153.             bus_fault_track();
    

  154.         }
    


  155. 

  156.         if(SCB_CFSR_MFSR)
    

  157.         {
    

  158.             mem_manage_fault_track();
    

  159.         }
    


  160. 

  161.         if(SCB_CFSR_UFSR)
    

  162.         {
    

  163.             usage_fault_track();
    

  164.         }
    

  165.     }
    


  166. 

  167.     if(SCB_HFSR & (1UL<<31))
    

  168.     {
    

  169.         /* [31]:DEBUGEVT, Indicates hard fault is triggered by debug event. */
    

  170.         rt_kprintf("debug event\n");
    

  171.     }
    

  172. }
    


  173. 

  174. /**
    

  175.  * fault exception handling
    

  176.  */
    

  177. void rt_hw_hard_fault_exception(struct stack_context* contex)
    

  178. {
    

  179.    rt_kprintf("psr: 0x%08x\n", contex->psr);
    

  180.    rt_kprintf(" pc: 0x%08x\n", contex->pc);
    

  181.    rt_kprintf(" lr: 0x%08x\n", contex->lr);
    

  182.    rt_kprintf("r12: 0x%08x\n", contex->r12);
    

  183.    rt_kprintf("r03: 0x%08x\n", contex->r3);
    

  184.    rt_kprintf("r02: 0x%08x\n", contex->r2);
    

  185.    rt_kprintf("r01: 0x%08x\n", contex->r1);
    

  186.    rt_kprintf("r00: 0x%08x\n", contex->r0);
    


  187. 

  188.    hard_fault_track();
    


  189. 

  190.     rt_kprintf("hard fault on thread: %s\n", rt_current_thread->name);
    

  191. #ifdef RT_USING_FINSH
    

  192.    list_thread();
    

  193. #endif
    

  194.    while (1);
    

  195. }
再写了两个测试代码，以手动触发fault。
复制
  1. #include <finsh.h>
    

  2. static void div0_test(void)
    

  3. {
    

  4.     int x,y,z;
    

  5.     x = 10;
    

  6.     y = 0;
    

  7.     z = x / y;
    

  8.     rt_kprintf("z:%d\n", z);
    

  9. }
    

  10. FINSH_FUNCTION_EXPORT(div0_test, div0_test)
    


  11. 

  12. static void unalign_test(void)
    

  13. {
    

  14.     int * p;
    

  15.     p = (int *)0x00;
    

  16.     rt_kprintf("00:0x%08X\n", *p);
    

  17.     p = (int *)0x04;
    

  18.     rt_kprintf("04:0x%08X\n", *p);
    

  19.     p = (int *)0x03;
    

  20.     rt_kprintf("03:0x%08X\n", *p);
    

  21. }
    

  22. FINSH_FUNCTION_EXPORT(unalign_test, unalign_test)
测试时可以使用finsh强大的功能来配置CPU的状态：

1. 访问末授权区域
复制
  1. finsh>>int * p //声明一个指针变量
    

  2.         0, 0x00000000
    

  3. finsh>>p = 0xDFFFFFF0 // 指向片上外设区结束处，一般不可能用完，所以此处一般不可访问。
    

  4.         -536870928, 0xdffffff0
    

  5. finsh>>*p // 读取指针处数据
    

  6. psr: 0x01000000
    

  7.  pc: 0x00000e3e
    

  8.  lr: 0x0000451d
    

  9. r12: 0x00000000
    

  10. r03: 0x00000000
    

  11. r02: 0x1fff0180
    

  12. r01: 0x1fff0814
    

  13. r00: 0xdffffff0
    

  14. bus fault:
    

  15. SCB_CFSR_BFSR:0x82 PRECISERR SCB->BFAR:DFFFFFF0
    

  16. hard fault on thread: tshell
    

  17.  thread  pri  status      sp     stack size max used   left tick  error
    

  18. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  19. tidle    0x1f ready   0x00000040 0x00000100 0x00000060 0x00000015 000
    

  20. tshell   0x14 ready   0x00000088 0x00000400 0x00000218 0x00000009 000
2. 非对齐访问测试
复制
  1. finsh>>int * p //声明一个指针变量
    

  2.         0, 0x00000000
    

  3. finsh>>p = 0xE000ED14 // 指向SCB->CCR
    

  4.         -536810220, 0xe000ed14
    

  5. finsh>>*p = 0x00000208 // 打开非对齐异常
    

  6.         520, 0x00000208
    

  7. finsh>>unalign_test() // 非对齐访问测试
    

  8. psr: 0x21000000
    

  9.  pc: 0x00000430
    

  10.  lr: 0x00003cbd
    

  11. r12: 0x0000006e
    

  12. r03: 0x00000002
    

  13. r02: 0x00000004
    

  14. r01: 0x1fff1b6a
    

  15. r00: 0x1fff1a2c
    

  16. usage fault:
    

  17. SCB_CFSR_UFSR:0x100 UNALIGNED
    

  18. hard fault on thread: tshell
    

  19.  thread  pri  status      sp     stack size max used   left tick  error
    

  20. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  21. tidle    0x1f ready   0x00000058 0x00000100 0x00000060 0x00000001 000
    

  22. tshell   0x14 ready   0x00000088 0x00000400 0x00000218 0x00000008 000
3. 除零异常测试
复制
  1. finsh>>int * p //声明一个指针变量
    

  2.         0, 0x00000000
    

  3. finsh>>p = 0xE000ED14 // 指向SCB->CCR
    

  4.         -536810220, 0xe000ed14
    

  5. finsh>>*p = 0x00000210 // 打开除零异常
    

  6.         528, 0x00000210
    

  7. finsh>>div0_test() // 除零异常测试
    

  8. psr: 0x41000000
    

  9.  pc: 0x00001efe
    

  10.  lr: 0x0000096d
    

  11. r12: 0x00000000
    

  12. r03: 0x1fff012c
    

  13. r02: 0x1fff0917
    

  14. r01: 0x00001ef9
    

  15. r00: 0x00000000
    

  16. usage fault:
    

  17. SCB_CFSR_UFSR:0x200 DIVBYZERO
    

  18. hard fault on thread: tshell
    

  19.  thread  pri  status      sp     stack size max used   left tick  error
    

  20. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  21. tidle    0x1f ready   0x00000040 0x00000100 0x00000060 0x0000000b 000
    

  22. tshell   0x14 ready   0x00000088 0x00000400 0x00000218 0x00000009 000
回复

收藏9 举报

LDTEST 发表于 2012-12-3 21:18 | 显示全部楼层
  感谢
回复

收藏9 举报

Xflyan 发表于 2012-12-3 23:37 | 显示全部楼层
谢谢分享！其实发现HARTFAULT大部分原因并不是难题 而是自己没有注意到的细节问题
回复

收藏9 举报

Lyc1992 发表于 2012-12-4 09:06 | 显示全部楼层
回复

收藏9 举报

拿起书本 发表于 2012-12-4 14:13 | 显示全部楼层
不错，资料挺详细又全面，学习中，感谢楼主的分享，顶了
回复

收藏9 举报

 楼主| aozima 发表于 2013-7-1 12:06 | 显示全部楼层
本帖最后由 aozima 于 2013-7-1 12:09 编辑

更新一下出现hard fault后如何反查。

问题追踪

上面测试出了问题，是我们人为设置的故障，但在平时调试中出了问题如何追综呢？
以非对齐访问为例，开发环境使用MDK。

1. 进入JTAG仿真状态，并触发非对齐异常。
此时串口会打印出异常时的寄存器值，此时停止仿真器发现程序停在rt_hw_hard_fault_exception中。
复制
  1. finsh>>unalign_test()
    

  2. addr:0x00 value:0x20001B80
    

  3. addr:0x04 value:0x0800DE81
    

  4. psr: 0x21000000
    

  5. r00: 0x00000000
    

  6. r01: 0x40013800
    

  7. r02: 0x20000690
    

  8. r03: 0x00000000
    

  9. r04: 0x00000003
    

  10. r05: 0xe000ed14
    

  11. r06: 0xdeadbeef
    

  12. r07: 0x20002678
    

  13. r08: 0xdeadbeef
    

  14. r09: 0xdeadbeef
    

  15. r10: 0xdeadbeef
    

  16. r11: 0xdeadbeef
    

  17. r12: 0x08000a95
    

  18.  lr: 0x08002eb5
    

  19.  pc: 0x08000386
    

  20. usage fault:
    

  21. SCB_CFSR_UFSR:0x100 UNALIGNED
    

  22. hard fault on thread: tshell
    

  23.  thread  pri  status      sp     stack size max used   left tick  error
    

  24. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  25. tidle    0x1f ready   0x00000040 0x00000100 0x0000005c 0x00000009 000
    

  26. tshell   0x14 ready   0x00000088 0x00000800 0x000001b0 0x0000000a 000
    

  27. led      0x14 suspend 0x00000078 0x00000200 0x00000078 0x00000005 000
2. 根据上面打印出来的寄存器，提取出关键值是 pc: 0x08000386
我们在MDK的command窗口中输入 pc = 0x08000386
command.jpg

可以把PC指针临时设回问题发生时的场景，我们看到出现问题的指令是
复制
  1.    239:     p = (int *)0x03; 
    

  2. 0x08000384 2403      MOVS     r4,#0x03
    

  3.    240:     value = *p; 
    

  4. 0x08000386 6820      LDR      r0,[r4,#0x00]
    

  5. 0x08000388 9000      STR      r0,[sp,#0x00]
instruction.jpg

分析 #386 这条指令从 R4+0 的问题读取4字节到R0中，
先前打印出的R4的值为 r04: 0x00000003
因此可以确定为这是因为地址不对齐造成的。

当然，具体情况要具体分析，有时候某个步骤出现问题并不会马上崩溃，
而是过一段时间以后才出问题，因此要结合上下文综合分析。
比如上面这个案例真正有问题的指令是 0x08000384。

根据以上的案例，并结合实际调试经验，相信大家可以更快地找出问题。


回复

收藏9 举报

 楼主| aozima 发表于 2013-7-1 12:08 | 显示全部楼层
再更新一下测试代码，以手动触发fault。
复制
  1. void div0_test(void)
    

  2. {
    

  3.     volatile int * SCB_CCR = (volatile int *)0xE000ED14; // SCB->CCR
    

  4.     int x,y,z;
    


  5. 

  6.     *SCB_CCR |= (1 << 4); /* bit4: DIV_0_TRP. */
    


  7. 

  8.     x = 10;
    

  9.     y = 0;
    

  10.     z = x / y;
    

  11.     rt_kprintf("z:%d\n", z);
    

  12. }
    


  13. 

  14. void unalign_test(void)
    

  15. {
    

  16.     volatile int * SCB_CCR = (volatile int *)0xE000ED14; // SCB->CCR
    

  17.     volatile int * p;
    

  18.     volatile int value;
    


  19. 

  20.     *SCB_CCR |= (1 << 3); /* bit3: UNALIGN_TRP. */
    


  21. 

  22.     p = (int *)0x00;
    

  23.     value = *p;
    

  24.     rt_kprintf("addr:0x%02X value:0x%08X\n", (int)p, value);
    


  25. 

  26.     p = (int *)0x04;
    

  27.     value = *p;
    

  28.     rt_kprintf("addr:0x%02X value:0x%08X\n", (int)p, value);
    


  29. 

  30.     p = (int *)0x03;
    

  31.     value = *p;
    

  32.     rt_kprintf("addr:0x%02X value:0x%08X\n", (int)p, value);
    

  33. }
    


  34. 

  35. #ifdef  RT_USING_FINSH
    

  36. #include <finsh.h>
    

  37. FINSH_FUNCTION_EXPORT(div0_test, div0_test)
    

  38. FINSH_FUNCTION_EXPORT(unalign_test, unalign_test)
    

  39. #endif /* RT_USING_FINSH */
回复

收藏9 举报

SwPwr 发表于 2013-7-4 21:55 来自手机 | 显示全部楼层
aozima 发表于 2012-11-30 00:25
刚网上搜了一番，在http://st.**.com/down/index.php?id=120找到了。
上传之。

谢谢共享
回复

收藏9 举报

freezz 发表于 2013-12-10 20:44 | 显示全部楼层
，mark，慢慢消化。
回复

收藏9 举报

outstanding 发表于 2013-12-10 21:08 | 显示全部楼层
不错。。。。。。。。。。。
回复

收藏9 举报

hjl2832 发表于 2014-7-10 11:19 | 显示全部楼层
不错，查异常的方法。
回复

收藏9 举报

fvcvxvcv 发表于 2014-7-11 14:24 | 显示全部楼层
学习
回复

收藏9 举报

xzezhen 发表于 2014-10-25 12:24 | 显示全部楼层
很赞的分析:lol
回复

收藏9 举报

zook0k 发表于 2014-10-27 10:00 | 显示全部楼层
多谢
回复

收藏9 举报

xlsf1048 发表于 2014-12-16 14:17 | 显示全部楼层
mark
回复

收藏9 举报

jemy00 发表于 2014-12-17 11:48 | 显示全部楼层

mark
回复

收藏9 举报

FAQ 发表于 2014-12-17 12:01 | 显示全部楼层
表示出现过一次hardfault
回复

收藏9 举报

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

本版积分规则

aozima
个人签名：RTOS RT-Thread

55

主题

2040

帖子

23

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