死机分析之一---死机日志建立

#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return */
#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return*/
#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return */
#define EXC_RETURN_HANDLER_FPU     (0xFFFFFFE1UL)     /* return to Handler mode, uses MSP after return, restore floating-point state */
#define EXC_RETURN_THREAD_MSP_FPU  (0xFFFFFFE9UL)     /* return to Thread mode, uses MSP after return, restore floating-point state  */
#define EXC_RETURN_THREAD_PSP_FPU  (0xFFFFFFEDUL)     /* return to Thread mode, uses PSP after return, restore floating-point state  */

  __asm volatile (
    "mov r2, lr         \n"  // 将 LR (EXC_RETURN) 保存到 R2，根据AAPCS,R2的是第三个参数
    //tst 指令会执行 LR & 0x4 操作，并根据结果设置到PSR的 Z (Zero) 标志位。
    //如果结果为 0 (LR & 0x4 == 0)，则 Z 标志位被设置为 1。
    //如果结果不为 0 (LR & 0x4 != 0)，则 Z 标志位被设置为 0
    "tst lr, #4         \n"  // 测试 LR 的第 2 位, 0=MSP, 1=PSP
    "ite eq             \n" // 如果 Z 标志位为 1，则执行 eq 分支，否则执行 ne 分支
    "moveq r1, #0xaa    \n"  // 如果是 MSP, R1 = 0xaa
    "movne r1, #0xbb    \n"  // 如果是 PSP, R1 = 0xbb
    "ite eq             \n"  // If-Then-Else Equal
    "mrseq r0, msp      \n"  // 如果是 MSP, R0 = MSP
    "mrsne r0, psp      \n"  // 如果是 PSP, R0 = PSP
    // 此时 R0 包含了异常发生时的栈指针，它指向硬件自动压入的栈帧 (R0-R3, R12, LR, PC, PSR)。

    // 手动将 R4-R11 压入栈中。
    // stmdb: Store Multiple Decrement Before。
    // 这会将 R4-R11 压入 R0 指向的栈中，并更新 R0 的值，使其指向新的栈顶（即 R4 的位置）。
    "stmdb r0!, {r4-r11} \n"

    // 调用 C 处理函数, 根据 AAPCS ,R0, R1, R2 作为参数1，2，
    "bl xxx_Handler_C\n"
}

//定义栈帧结构体
typedef struct {
    uint32_t r4;
    uint32_t r5;
    uint32_t r6;
    uint32_t r7;
    uint32_t r8;
    uint32_t r9;
    uint32_t r10;
    uint32_t r11;
    // 硬件自动压入的寄存器
    uint32_t r0;
    uint32_t r1;
    uint32_t r2;
    uint32_t r3;
    uint32_t r12;
    uint32_t lr; // EXC_RETURN value
    uint32_t pc;
    uint32_t psr;
} FullFaultStackFrame_t;

// 打印故障信息的C函数
void print_fault_info(void* fault_stack, uint32_t stack_type, uint32_t exc_return)
{
    // 打印EXC_RETURN值和堆栈类型
    crash_printf("EXC_RETURN = 0x%X\r\n", exc_return);
    //打印使用哪个栈
    if (stack_type == 0xaa)
    {
        crash_printf("Stack used: MSP\r\n", 0);
    }
    else
    {
        crash_printf("Stack used: PSP\r\n", 0);
    }
	//这里减去32是因我我在进入中断函数中，手动压入了R4-R11，又因为栈是向下生长的，所以栈顶指针需要加去32，展示原来栈顶的地址
    crash_printf("\r\n=== SP addr: 0x%X ===\r\n", (uint32_t)fault_stack + 32);//打印栈地址

    // 将堆栈指针转换为完整的异常栈帧结构
    FullFaultStackFrame_t* stack_frame = (FullFaultStackFrame_t*)fault_stack;

    // 打印异常发生时的寄存器值
    crash_printf("\r\n=== Full Exception Stack Frame ===\r\n",0);
    crash_printf("R0  = 0x%X\r\n", stack_frame->r0);   // 通常包含函数参数或返回值
    crash_printf("R1  = 0x%X\r\n", stack_frame->r1);   // 通常包含函数参数
    crash_printf("R2  = 0x%X\r\n", stack_frame->r2);   // 通常包含函数参数
    crash_printf("R3  = 0x%X\r\n", stack_frame->r3);   // 通常包含函数参数
    crash_printf("R4  = 0x%X\r\n", stack_frame->r4);   // 手动保存的寄存器
    crash_printf("R5  = 0x%X\r\n", stack_frame->r5);
    crash_printf("R6  = 0x%X\r\n", stack_frame->r6);
    crash_printf("R7  = 0x%X\r\n", stack_frame->r7);
    crash_printf("R8  = 0x%X\r\n", stack_frame->r8);
    crash_printf("R9  = 0x%X\r\n", stack_frame->r9);
    crash_printf("R10 = 0x%X\r\n", stack_frame->r10);
    crash_printf("R11 = 0x%X\r\n", stack_frame->r11);
    crash_printf("R12 = 0x%X\r\n", stack_frame->r12);  // IP (中间变量)
    crash_printf("LR  = 0x%X\r\n", stack_frame->lr);   // 返回地址 (EXC_RETURN value)
    crash_printf("PC  = 0x%X\r\n", stack_frame->pc);   // 异常发生的指令地址
    crash_printf("PSR = 0x%X\r\n", stack_frame->psr);  // 程序状态寄存器

    crash_printf("CONTROL = 0x%X\r\n", __get_CONTROL());  // 控制寄存器
    crash_printf("BASEPRI = 0x%X\r\n", __get_BASEPRI());  // 基础优先级寄存器
    crash_printf("PRIMASK = 0x%X\r\n", __get_PRIMASK());  // 优先级屏蔽寄存器
    crash_printf("FAULTMASK = 0x%X\r\n", __get_FAULTMASK());//故障屏蔽寄存器

    // 打印主要fault寄存器值
    crash_printf("\r\n=== Fault Status Info ===\r\n", 0);
    crash_printf("CFSR  = 0x%X\r\n", SCB->CFSR);
    crash_printf("HFSR  = 0x%X\r\n", SCB->HFSR);
    crash_printf("DFSR  = 0x%X\r\n", SCB->DFSR);
    crash_printf("AFSR  = 0x%X\r\n", SCB->AFSR);
    crash_printf("MMFAR = 0x%X\r\n", SCB->MMFAR);
    crash_printf("BFAR  = 0x%X\r\n", SCB->BFAR);

    htim7.Instance = TIM7;
    htim7.Init.Prescaler = uwPrescalerValue;// 预分频器 
    htim7.Init.CounterMode = TIM_COUNTERMODE_UP;// 计数模式为向上计数
    //计数频率为2k，则周期为500us，超时时间为 500us * (Period+1)
    htim7.Init.Period = WATCHDOG_TIMEOUT_SECONDS * 1000 * 2 - 1; //设置计数器周期，也就是超时时间
    htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;//禁止自动重装载
	---------省略-------------
	HAL_NVIC_SetPriority(TIM7_IRQn, 0, 0);//作为看门狗，优先级设置为最高的0
    HAL_NVIC_EnableIRQ(TIM7_IRQn);

void vApplicationIdleHook(void)
{
    __HAL_TIM_SET_COUNTER(&htim7, 0);//软看门狗，定时器7清零
    .........省略........
}

void vTaskSwitchContext( void )
{
	......
	traceTASK_SWITCHED_IN();
}

#define traceTASK_SWITCHED_IN() record_task_switch(pxCurrentTCB) //定义追踪函数
#define MAX_TASK_SWITCH_RECORDS 16  //记录最后16次

// 任务切换记录结构，记录任务id 和时间
typedef struct {
    UBaseType_t uxTaskNumber;  // 任务编号
    uint32_t timestamp;        // 时间戳
} TaskSwitchRecord_t;

static TaskSwitchRecord_t taskSwitchHistory[MAX_TASK_SWITCH_RECORDS]; //用于记录的数组
// 记录任务切换
void record_task_switch(void* currentTCB) 
{  
    uint8_t idx = taskSwitchIndex;
    //MAX_TASK_SWITCH_RECORDS为2的幂次方，可以减少计算周期，在任务切换期间减少计算量很重要。
    taskSwitchIndex = (taskSwitchIndex + 1) % MAX_TASK_SWITCH_RECORDS;
    switchCount++;
    
    // 使用任务句柄获取任务编号
    taskSwitchHistory[idx].uxTaskNumber = uxTaskGetTCBNumber((TaskHandle_t)currentTCB);
    taskSwitchHistory[idx].timestamp = xTaskGetTickCount();
}

typedef struct xTASK_STATUS
{
	TaskHandle_t xHandle; 	//任务句柄		
	const char *pcTaskName;	//任务名字		
	UBaseType_t xTaskNumber;	//任务ID		
	eTaskState eCurrentState;	//任务状态		
	UBaseType_t uxCurrentPriority;	//任务当前优先级，互斥锁时可能会继承别人的优先级，基本情况下和uxBasePriority相同		
	UBaseType_t uxBasePriority;	//任务基础优先级，就是创建任务时配置的优先级	    	
	uint32_t ulRunTimeCounter;	//任务运行时间		
	StackType_t *pxStackBase;	//任务栈基地址		
	configSTACK_DEPTH_TYPE usStackHighWaterMark;//任务栈高水位标记,可以用来计算栈使用空间。
} TaskStatus_t;

#if( configRECORD_STACK_HIGH_ADDRESS == 1 )
{
	/* Also record the stack's high address, which may assist
	debugging. */
	pxNewTCB->pxEndOfStack = pxTopOfStack;
}

void printf_all_task_info_crash(void)
{
    uint32_t task_count = 0;
    uint32_t x;
    
    if(uxArraySize > MAX_TASKS)
    {
        task_count = MAX_TASKS;
    }else
    {
        task_count = uxArraySize;
    }
    ;
    DEBUG_LOG("TaskName         ID Status Prio(C/B) StackStart MaxUsed    StackEnd   PeakUsage(%%)\r\n");
    DEBUG_LOG("---------------- -- ------ --------- ---------- ---------- ---------- ------------\r\n");
    for (x = 0; x < task_count; x++)
    {
        char cStatus = '?';
        switch (pxTaskStatusArray[x].eCurrentState)
        {
            case eRunning:
                cStatus = 'R';
                break;
            case eReady:
                cStatus = 'r';
                break;
            case eBlocked:
                cStatus = 'B';
                break;
            case eSuspended:
                cStatus = 'S';
                break;
            case eDeleted:
                cStatus = 'D';
                break;
            default:
                cStatus = '?';
                break;
        };
        configSTACK_DEPTH_TYPE peak_used_words = 0;
        float usage_percentage = 0.0f;
        if (total_stack_depth_words > 0) // 确保获取到了总堆栈大小
        {
            peak_used_words = total_stack_depth_words[x] - pxTaskStatusArray[x].usStackHighWaterMark;;
            usage_percentage = ((float)peak_used_words * 100.0f) / (float)total_stack_depth_words[x];
        }
        
        DEBUG_LOG("%-16s %2lu %c      %2lu/%2lu      0x%08lx %10lu 0x%08lx %7.2f%%\r\n",
            //    name_buffer,
               pxTaskStatusArray[x].pcTaskName,
               pxTaskStatusArray[x].xTaskNumber, // 打印任务ID
               cStatus,
               pxTaskStatusArray[x].uxCurrentPriority,
               pxTaskStatusArray[x].uxBasePriority,
               (unsigned long)pxTaskStatusArray[x].pxStackBase,
               (unsigned long)peak_used_words*4, // usStackHighWaterMark 单位是 words
               (unsigned long)pxTaskStatusArray[x].pxStackBase + total_stack_depth_words[x]*4,    // total_stack_depth_words 单位是 words
               usage_percentage);
        

    }
    ERROR_LOG("----------------------------------------------------------------------------------------\r\n");
}