[add] MCoreDump可以使用

EWARM/stm32_broad_mini.ewp

             <file>
                 <name>$PROJ_DIR$\..\Middlewares\rtthread\libcpu\arm\cortex-m3\cpuport.c</name>
             </file>
+            <file>
+                <name>$PROJ_DIR$\..\Middlewares\MCoreDump\example\mcd_example.c</name>
+                <excluded>
+                    <configuration>stm32_broad_mini</configuration>
+                </excluded>
+            </file>
             <file>
                 <name>$PROJ_DIR$\startup_stm32f103xb.s</name>
             </file>
                     <name>$PROJ_DIR$\..\Middlewares\MCoreDump\src\arm\mcd_arm.c</name>
                 </file>
             </group>
-            <file>
-                <name>$PROJ_DIR$\..\Middlewares\MCoreDump\example\mcd_example.c</name>
-            </file>
         </group>
         <group>
             <name>RTT</name>

Middlewares/MCoreDump/arch/armv7m/armv7m.c

     nop
 }
 
-#elif 1//defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) || defined(__GNUC__)
+#elif 1 //defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) || defined(__GNUC__)
 
 #define mcd_get_regset(regset)                                              \
     __asm volatile("  mov r0, %0                \n"                         \
                    " str  r1, [r0, #0]          \n" ::"r"(regset)           \
                    : "memory", "cc");
 
+// 不更新当前寄存器到全局变量（在异常中断中已填充）
+void mcd_hard_fault_exception_dump(void)
+{
+    struct thread_info_ops ops;
+    mcd_rtos_thread_ops(&ops);
+    mcd_gen_coredump(&ops);
+}
+
+// 只保存当前线程或非线程（主栈）：更新当前寄存器到全局变量
 void mcd_mini_dump(void)
 {
     struct thread_info_ops ops;
     mcd_gen_coredump(&ops);
 }
 
+// 保存RTOS所有线程：更新当前寄存器到全局变量
 void mcd_multi_dump(void)
 {
     struct thread_info_ops ops;
  * @param core_regset Pointer to structure for storing ARM core registers
  * @param fp_regset Pointer to structure for storing FPU registers
  */
-void collect_registers_armv7m(uint32_t *stack_top,
-                                    core_regset_type *core_regset,
-                                    fp_regset_type *fp_regset)
+void collect_registers_armv7m(uint32_t *stack_top, core_regset_type *core_regset, fp_regset_type *fp_regset)
 {
     /*
      * This function uses the same stack frame parsing approach as collect_registers_armv7ms
      * Since HardFault_Handler now uses the same stacking order as PendSV_Handler,
      * we can directly use collect_registers_armv7m function.
      */
-
+#if 0
     struct exception_stack_frame *exception_stack = (struct exception_stack_frame *)context;
 
     /* Calculate stack pointer to the beginning of the saved context */
     uint32_t *stack_ptr = (uint32_t *)exception_stack;
 
-#ifdef RT_USING_FINSH
-    extern long list_thread(void);
-    list_thread();
-#endif
-
     /*
      * Move backward through the stack to reach the beginning of saved context.
      * Stack layout (working backwards from exception_stack):
     /* If no FPU support, skip EXC_RETURN and point to r4 directly */
     stack_ptr -= 1; /* exc_return */
 #endif
+#else
+    uint32_t *stack_ptr = context;
+    stack_ptr += 1; /* 跳过：exc_return */
+//  stack_ptr += 1; // 如开启fpuflag
+#endif
+
+    //extern void DumpCore(void *sp);
+    //DumpCore(stack_ptr);
 
     /*
      * Now stack_ptr points to where collect_registers_armv7m expects:
      * - Without FPU: points to r4 (first register to be read)
      */
     collect_registers_armv7m(stack_ptr,
-                           get_cur_core_regset_address(),
-                           get_cur_fp_regset_address());
+                             get_cur_core_regset_address(),
+                             get_cur_fp_regset_address());
 
     /* Generate coredump using memory mode */
-    mcd_faultdump(MCD_OUTPUT_MEMORY);
+    mcd_faultdump(MCD_OUTPUT_FAULT_SERIAL);
 
     return 0;
 }

Middlewares/MCoreDump/inc/coredump.h

 
 /**
  * @brief Function pointer type for coredump data output
- * 
+ *
  * This function pointer type defines the interface for writing coredump data
  * to different output destinations (memory, serial, filesystem, etc.).
- * 
+ *
  * @param data Pointer to the data buffer to be written
  * @param len Length of the data buffer in bytes
- * 
+ *
  * @note The implementation should handle the data appropriately based on the
  *       chosen output mode and ensure data integrity.
  */
 
 /**
  * @brief Thread information operations structure
- * 
+ *
  * This structure contains function pointers for retrieving thread information
  * in a RTOS environment. It's designed to avoid dynamic memory allocation
  * during fault handling, as malloc operations may fail during hard faults.
- * 
+ *
  * The structure provides a generic interface for different RTOS systems
  * to supply thread information for multi-threaded coredump generation.
  */
      * @return Total thread count
      */
     int32_t (*get_threads_count)(struct thread_info_ops *);
-    
+
     /**
      * @brief Get current executing thread index
-     * @param ops Pointer to this operations structure  
+     * @param ops Pointer to this operations structure
      * @return Current thread index
      */
     int32_t (*get_current_thread_idx)(struct thread_info_ops *);
-    
+
     /**
      * @brief Get register set for a specific thread
      * @param ops Pointer to this operations structure
     void (*get_thread_regset)(struct thread_info_ops *, int32_t,
                               core_regset_type *core_regset,
                               fp_regset_type *fp_regset);
-    
+
     /**
      * @brief Get number of memory areas to dump
      * @param ops Pointer to this operations structure
      * @return Number of memory areas
      */
     int32_t (*get_memarea_count)(struct thread_info_ops *);
-    
+
     /**
      * @brief Get memory area information
      * @param ops Pointer to this operations structure
      */
     int32_t (*get_memarea)(struct thread_info_ops *, int32_t,
                            uint32_t *, uint32_t *);
-    
+
     /** Private data for RTOS-specific implementations */
     void *priv;
 };
  *
  * @see mcd_multi_dump() for full system coredump
  */
+// 不更新当前寄存器到全局变量（在异常中断中已填充）
+void mcd_hard_fault_exception_dump(void);
+// 只保存当前线程或非线程（主栈）：更新当前寄存器到全局变量
 void mcd_mini_dump(void);
+// 保存RTOS所有线程：更新当前寄存器到全局变量
+void mcd_multi_dump(void);
 
 /**
  * @brief Generate coredump with all threads information
  *
  * @see mcd_mini_dump() for single thread coredump
  */
-void mcd_multi_dump(void);
+//void mcd_multi_dump(void);
 
 /**
  * @brief Generate coredump using provided thread operations

Middlewares/MCoreDump/inc/mcd_cfg.h

  */
 
 /* Automatic FPU detection - based on compiler definitions */
-#if	/* ARMCC */ (  (defined ( __CC_ARM ) && defined ( __TARGET_FPU_VFP ))    \
-	/* Clang */ || (defined ( __clang__ ) && defined ( __VFP_FP__ ) && !defined(__SOFTFP__)) \
-	/* IAR */   || (defined ( __ICCARM__ ) && defined ( __ARMVFP__ ))        \
-	/* GNU */   || (defined ( __GNUC__ ) && defined ( __VFP_FP__ ) && !defined(__SOFTFP__)) )
+#if /* ARMCC */ (  (defined ( __CC_ARM ) && defined ( __TARGET_FPU_VFP ))    \
+    /* Clang */ || (defined ( __clang__ ) && defined ( __VFP_FP__ ) && !defined(__SOFTFP__)) \
+    /* IAR */   || (defined ( __ICCARM__ ) && defined ( __ARMVFP__ ))        \
+    /* GNU */   || (defined ( __GNUC__ ) && defined ( __VFP_FP__ ) && !defined(__SOFTFP__)) )
 #define MCD_FPU_SUPPORT          1    /* FPU supported and enabled */
 #else
 #define MCD_FPU_SUPPORT          0    /* No FPU support */
     MCD_OUTPUT_SERIAL = 0,                /* Output via serial port */
     MCD_OUTPUT_MEMORY,                    /* Store in memory buffer */
     MCD_OUTPUT_FILESYSTEM,                /* Save to filesystem */
-    MCD_OUTPUT_FLASH                      /* Store in flash (reserved) */
+    MCD_OUTPUT_FLASH,                      /* Store in flash (reserved) */
+    MCD_OUTPUT_FAULT_SERIAL, // 异常时打印到串口
 } mcd_output_mode_t;
 
 /* Return codes */

Middlewares/MCoreDump/osal/rtthread.c

 
 /* Architecture-specific exception hook function */
 #ifdef PKG_USING_MCOREDUMP_ARCH_ARMV7M
-#define arch_hard_fault_exception_hook armv7m_hard_fault_exception_hook
+    #define arch_hard_fault_exception_hook armv7m_hard_fault_exception_hook
 #elif defined(PKG_USING_MCOREDUMP_ARCH_ARMV8M)
-#define arch_hard_fault_exception_hook armv8m_hard_fault_exception_hook
+    #define arch_hard_fault_exception_hook armv8m_hard_fault_exception_hook
 #else
-#error "MCoredump does not support this architecture"
+    #error "MCoredump does not support this architecture"
 #endif
 
 static rt_int32_t is_thread_object(rt_thread_t thread)
     return ((thread->type & ~RT_Object_Class_Static) == RT_Object_Class_Thread);
 }
 
-static int32_t rtthread_thr_cnts(struct thread_info_ops *ops)
+static int32_t rtthread_thread_cnts(struct thread_info_ops *ops)
 {
     rtthread_ti_priv_t *priv = (rtthread_ti_priv_t *)ops->priv;
     rt_int32_t idx = 0;
     {
         information = rt_object_get_information(RT_Object_Class_Thread);
         mcd_assert(information != RT_NULL);
-        
+
         current_thread = rt_thread_self();
         priv->cur_idx = -1;  /* Initialize current thread index */
 
         for (node = information->object_list.next;
-                node != &(information->object_list);
-                node = node->next)
+             node != &(information->object_list);
+             node = node->next)
         {
             object = rt_list_entry(node, struct rt_object, list);
             rt_thread_t thread = (rt_thread_t)object;
         }
 
         priv->thr_cnts = idx;
-        
+
         /* If current thread not found, default to 0 */
         if (priv->cur_idx == -1)
         {
     return priv->thr_cnts;
 }
 
-static int32_t rtthread_cur_idx(struct thread_info_ops *ops)
+static int32_t rtthread_cur_index(struct thread_info_ops *ops)
 {
     rtthread_ti_priv_t *priv = (rtthread_ti_priv_t *)ops->priv;
 
     if (-1 == priv->cur_idx)
-        rtthread_thr_cnts(ops);
+        rtthread_thread_cnts(ops);
 
     return priv->cur_idx;
 }
 
-static void rtthread_thr_rset(struct thread_info_ops *ops, int32_t idx,
-                              core_regset_type *core_regset,
-                              fp_regset_type *fp_regset)
+static void rtthread_thread_register(struct thread_info_ops *ops, int32_t idx,
+                                     core_regset_type *core_regset,
+                                     fp_regset_type *fp_regset)
 {
     rt_int32_t idx_l = 0;
-    rt_int32_t current_idx = rtthread_cur_idx(ops);
+    rt_int32_t current_idx = rtthread_cur_index(ops);
     struct rt_object_information *information;
     struct rt_object *object;
     struct rt_list_node *node;
     information = rt_object_get_information(RT_Object_Class_Thread);
     mcd_assert(information != RT_NULL);
 
-    for (node = information->object_list.next;
-            node != &(information->object_list);
-            node = node->next)
+    for (node = information->object_list.next; node != &(information->object_list); node = node->next)
     {
         object = rt_list_entry(node, struct rt_object, list);
         rt_thread_t thread = (rt_thread_t)object;
                 /* If this is the current thread, use current registers */
                 if (idx_l == current_idx)
                 {
-                    mcd_memcpy(core_regset, get_cur_core_regset_address(), sizeof(core_regset_type));
+                    mcd_memcpy(core_regset, get_cur_core_regset_address(), sizeof(core_regset_type)); // 异常中填充
                     mcd_memcpy(fp_regset, get_cur_fp_regset_address(), sizeof(fp_regset_type));
                 }
                 else
 
 static int32_t rtthread_get_mem_cnts(struct thread_info_ops *ops)
 {
-    return rtthread_thr_cnts(ops);
+    return rtthread_thread_cnts(ops);
 }
 
 static int32_t rtthread_get_memarea(struct thread_info_ops *ops, int32_t idx,
-                                       uint32_t *addr, uint32_t *memlen)
+                                    uint32_t *addr, uint32_t *memlen)
 {
-    rt_int32_t         idx_l = 0;
-    rt_int32_t current_idx = rtthread_cur_idx(ops);
+    rt_int32_t idx_l = 0;
+    rt_int32_t current_idx = rtthread_cur_index(ops);
     struct rt_object_information *information;
     struct rt_object *object;
     struct rt_list_node *node;
     information = rt_object_get_information(RT_Object_Class_Thread);
     mcd_assert(information != RT_NULL);
 
-    for (node = information->object_list.next;
-            node != &(information->object_list);
-            node = node->next)
+    for (node = information->object_list.next; node != &(information->object_list); node = node->next)
     {
         object = rt_list_entry(node, struct rt_object, list);
         rt_thread_t thread = (rt_thread_t)object;
                 /* If this is the current thread, use current stack pointer */
                 if (idx_l == current_idx)
                 {
-                    *addr = get_cur_core_regset_address()->sp;
-                    *memlen = 1024;
+                    *addr = get_cur_core_regset_address()->sp;  // 异常中填充
+                    *memlen = (rt_uint32_t)thread->stack_addr + thread->stack_size - (rt_uint32_t)thread->sp;
+
+                    if (*memlen > thread->stack_size)
+                    {
+                        mcd_println("The stack may overflow!!!");
+                        *memlen = thread->stack_size;
+                    }
                 }
                 else
                 {
 void mcd_rtos_thread_ops(struct thread_info_ops *ops)
 {
     static rtthread_ti_priv_t priv;
-    ops->get_threads_count = rtthread_thr_cnts;
-    ops->get_current_thread_idx = rtthread_cur_idx;
-    ops->get_thread_regset = rtthread_thr_rset;
+    ops->get_threads_count = rtthread_thread_cnts;
+    ops->get_current_thread_idx = rtthread_cur_index;
+    ops->get_thread_regset = rtthread_thread_register;
     ops->get_memarea_count = rtthread_get_mem_cnts;
     ops->get_memarea = rtthread_get_memarea;
     ops->priv = &priv;
     while (_continue == 1);
 }
 
-static int mcd_coredump_init(void) 
+static int mcd_coredump_init(void)
 {
     static mcd_bool_t is_init = MCD_FALSE;
 
     }
 
     //mcd_print_memoryinfo();
-    
+
     rt_hw_exception_install(rtt_hard_fault_exception_hook);
 
     //rt_assert_set_hook(rtt_assert_hook);
-    
+
     is_init = MCD_TRUE;
     return RT_EOK;
 }

Middlewares/MCoreDump/src/coredump.c

     *addr &= CORE_MEM_LINE_MASK;
 }
 
+// 生成.elf文件
 void mcd_gen_coredump(struct thread_info_ops *ops)
 {
     int note_size;

Middlewares/MCoreDump/src/faultdump.c

 {
     struct thread_info_ops ops;
 
-    if (output_mode == MCD_OUTPUT_SERIAL)
+    if (output_mode == MCD_OUTPUT_FAULT_SERIAL)
+    {
+        mcd_init(corefile_serial_write);
+        mcd_irq_state_t irq_save = mcd_irq_disable();
+        serial_crc32 = 0xFFFFFFFF;
+
+        mcd_print("FAULT coredump start : {\n");
+        mcd_hard_fault_exception_dump();
+        mcd_print("\n} coredump end\n");
+        serial_crc32 = ~serial_crc32;
+        mcd_print("crc32 : %08x\n", serial_crc32);
+        mcd_irq_enable(irq_save);
+
+    }
+    else if (output_mode == MCD_OUTPUT_SERIAL)
     {
         mcd_init(corefile_serial_write);
 
  *
  * This is the main entry point for generating coredumps in MCoreDump system.
  * It supports multiple output modes to accommodate different debugging scenarios:
- * 
+ *
  * - MCD_OUTPUT_MEMORY: Saves coredump to static memory buffer (persistent across resets)
  * - MCD_OUTPUT_SERIAL: Outputs coredump data via serial port in hex format
  * - MCD_OUTPUT_FILESYSTEM: Saves coredump to filesystem as ELF file (if filesystem support is enabled)

Middlewares/rtthread/libcpu/arm/cortex-m3/context_iar.S

 rt_hw_interrupt_thread_switch:
     BX      lr
 
-#if 0
+#if 1
     IMPORT rt_hw_hard_fault_exception
     EXPORT HardFault_Handler
 HardFault_Handler: