【Cortex-M】异常中断时的程序运行指针SP获取，及SCB寄存器错误类型获取

【Cortex-M】异常中断时的程序运行指针SP获取，及SCB寄存器错误类型获取

更新以gitee为准：
gitee

异常中断

当MCU因堆栈溢出等造成异常会 会进入异常中断
可以在startup.s中查看

通常引起的时HardFault中断（包括内存溢出、非法赋值、寄存器操作错误、堆栈溢出等）
譬如手动引起异常：

*(uint32_t *)0x45678912=1;

异常的程序运行指针SP获取

打个断点在异常代码处 可以看到地址为0x08003792

在HardFault_Handler中也打个断点 就能在运行到其中时停止

此时 LR寄存器为特殊标记值
0xFFFFFFE9对应的是要看MSP寄存器
0xFFFFFFFD对应的是要看PSP寄存器
具体根据芯片手册而定（cortex-M权威指南）
不过也有个更方便的方式是直接读取SP指针
通过汇编即可实现

__asm uint32_t MZ_CM_ReadReg13(void){
     MOV     R0, sp
     bx lr
}

那么 就可以通过此方式获取到0x200101B0
通过内存查看该地址：

第5和6个uint32值即为上一次异常程序地址 和如果正常运行的话 下一个程序地址
注意为小端格式 所以解析出来就是0x08003793和0x0800379A

但程序地址的最后一位是标志位 用于区分是否为thumb指令或ARM指令（cortex权威指南）

由于历史原因，最初的16位单片机用的指令是Thumb指令，为16位指令。后来，ARM推出了32位的ARM指令。16位的指令更适合空间有限的嵌入式处理器，而32位的指令则更加灵活、功能丰富。因此，有些单片机在运行时可以根据需求切换指令状态。如下图：

后来诞生了Thumb-2指令集，它实现了16位指令和32位指令的共存。而Cortex-M3架构则就是采用Thumb-2指令集。由于16位指令长度是2字节，32位指令长度是4字节，因此其PC指针地址是按照2字节（16位）对齐的。换言之其最低位一定是0。

另外 需要注意的是 如果在代码层面进行获取 不能包装子函数（子函数会导致LR和SP被重写） 所以直接用一个宏替代即可

#define MZ_CM_SP_UpdateStat() MZ_CM_SP_Stat.sp = MZ_CM_ReadReg13();MZ_CM_SP_Stat.spAddr = (uint32_t *)MZ_CM_SP_Stat.sp;MZ_CM_SP_Stat.lastFlashAddr = MZ_CM_SP_Stat.spAddr[5];MZ_CM_SP_Stat.nextFlashAddr = MZ_CM_SP_Stat.spAddr[6];

调用后 如下：

后一个地址正是如果正常运行的下一个程序语句地址

SCB寄存器错误类型获取

关键寄存器：

SCB->CFSR（可配置故障状态寄存器）：判断故障类型（如内存访问错误、未对齐访问、指令执行错误）。

SCB->HFSR（硬件故障状态寄存器）：确认是否为HardFault的直接触发原因。

SCB->MMFAR/SCB->BFAR：记录导致内存管理或总线故障的具体地址。

直接通过memcpy获取即可

硬件错误异常 Hard fault status register (SCB->HFSR)

存储器管理错误异常 SCB->CFSR中MMFSR位

总线错误异常 SCB->CFSR中BFSR位

使用错误异常 SCB->CFSR中UFSR位

附录：压缩字符串、大小端格式转换

压缩字符串

首先HART数据格式如下：


重点就是浮点数和字符串类型
Latin-1就不说了 基本用不到

浮点数

浮点数里面 如 0x40 80 00 00表示4.0f

在HART协议里面 浮点数是按大端格式发送的 就是高位先发送 低位后发送

发送出来的数组为：40,80,00,00

但在C语言对浮点数的存储中 是按小端格式来存储的 也就是40在高位 00在低位
浮点数：4.0f
地址0x1000对应00
地址0x1001对应00
地址0x1002对应80
地址0x1003对应40

若直接使用memcpy函数 则需要进行大小端转换 否则会存储为：
地址0x1000对应40
地址0x1001对应80
地址0x1002对应00
地址0x1003对应00

大小端转换：

void swap32(void * p)
{
   uint32_t *ptr=p;
   uint32_t x = *ptr;
   x = (x << 16) | (x >> 16);
   x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);

   *ptr=x;
}

压缩Packed-ASCII字符串

本质上是将原本的ASCII的最高2位去掉 然后拼接起来 比如空格(0x20)
四个空格拼接后就成了
1000 0010 0000 1000 0010 0000
十六进制：82 08 20
对了一下表 0x20之前的识别不了
也就是只能识别0x20-0x5F的ASCII表

压缩/解压函数后面再写：

//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_ASCII_to_Pack(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{
   if(str_len%4)
   {
      return 0;
   }
	 
   uint8_t i=0;
   memset(buf,0,str_len/4*3);	  
   for(i=0;i<str_len;i++)
   {
      if(str[i]==0x00)
      {
         str[i]=0x20;
      }
   }

   for(i=0;i<str_len/4;i++)
   {
      buf[3*i]=(str[4*i]<<2)|((str[4*i+1]>>4)&0x03);
      buf[3*i+1]=(str[4*i+1]<<4)|((str[4*i+2]>>2)&0x0F);
      buf[3*i+2]=(str[4*i+2]<<6)|(str[4*i+3]&0x3F);
   }

   return 1;
}

//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_Pack_to_ASCII(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{
   if(str_len%4)
   {
      return 0;
   }

   uint8_t i=0;

   memset(str,0,str_len);

   for(i=0;i<str_len/4;i++)
   {
      str[4*i]=(buf[3*i]>>2)&0x3F;
      str[4*i+1]=((buf[3*i]<<4)&0x30)|(buf[3*i+1]>>4);
      str[4*i+2]=((buf[3*i+1]<<2)&0x3C)|(buf[3*i+2]>>6);
      str[4*i+3]=buf[3*i+2]&0x3F;
   }

   return 1;
}

大小端转换

在串口等数据解析中 难免遇到大小端格式问题

什么是大端和小端

所谓的大端模式，就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

所谓的小端模式，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

简单来说：大端——高尾端，小端——低尾端

举个例子，比如数字 0x12 34 56 78在内存中的表示形式为：

1)大端模式：

低地址 -----------------> 高地址

0x12 | 0x34 | 0x56 | 0x78

2)小端模式：

低地址 ------------------> 高地址

0x78 | 0x56 | 0x34 | 0x12

可见，大端模式和字符串的存储模式类似。

数据传输中的大小端

比如地址位、起止位一般都是大端格式
如：
起始位：0x520A
则发送的buf应为{0x52,0x0A}

而数据位一般是小端格式（单字节无大小端之分）
如：
一个16位的数据发送出来为{0x52,0x0A}
则对应的uint16_t类型数为： 0x0A52

而对于浮点数4.0f 转为32位应是：
40 80 00 00

以大端存储来说 发送出来的buf就是依次发送 40 80 00 00

以小端存储来说 则发送 00 00 80 40

由于memcpy等函数 是按字节地址进行复制 其复制的格式为小端格式 所以当数据为小端存储时 不用进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x00,0x00,0x80,0x40};
   memcpy(&dat,buf,4);
   float f=0.0f;
   f=*((float*)&dat); //地址强转
   printf("%f",f);

或更优解：

   uint8_t buf[]={0x00,0x00,0x80,0x40};   
   float f=0.0f;
   memcpy(&f,buf,4);

而对于大端存储的数据（如HART协议数据 全为大端格式） 其复制的格式仍然为小端格式 所以当数据为小端存储时 要进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};
   memcpy(&dat,buf,4);
   float f=0.0f;
   swap32(&dat); //大小端转换
   f=*((float*)&dat); //地址强转
   printf("%f",f);

或：

uint8_t buf[]={0x40,0x80,0x00,0x00};
   memcpy(&dat,buf,4);
   float f=0.0f;
   swap32(&f); //大小端转换
   printf("%f",f);

或更优解：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};
   float f=0.0f;
   dat=(buf[0]<<24)|(buf[0]<<16)|(buf[0]<<8)|(buf[0]<<0)
   f=*((float*)&dat);

总结

固 若数据为小端格式 则可以直接用memcpy函数进行转换 否则通过移位的方式再进行地址强转

对于多位数据 比如同时传两个浮点数 则可以定义结构体之后进行memcpy复制（数据为小端格式）

对于小端数据 直接用memcpy写入即可 若是浮点数 也不用再进行强转

对于大端数据 如果不嫌麻烦 或想使代码更加简洁（但执行效率会降低） 也可以先用memcpy写入结构体之后再调用大小端转换函数 但这里需要注意的是 结构体必须全为无符号整型 浮点型只能在大小端转换写入之后再次强转 若结构体内采用浮点型 则需要强转两次

所以对于大端数据 推荐通过移位的方式来进行赋值 然后再进行个别数的强转 再往通用结构体进行写入

多个不同变量大小的结构体 要主要字节对齐的问题
可以用#pragma pack(1) 使其对齐为1
但会影响效率

大小端转换函数

直接通过对地址的操作来实现 传入的变量为32位的变量
中间变量ptr是传入变量的地址

void swap16(void * p)
{
   uint16_t *ptr=p;
   uint16_t x = *ptr;
   x = (x << 8) | (x >> 8);

   *ptr=x;
}

void swap32(void * p)
{
   uint32_t *ptr=p;
   uint32_t x = *ptr;
   x = (x << 16) | (x >> 16);
   x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);

   *ptr=x;
}

void swap64(void * p)
{
   uint64_t *ptr=p;
   uint64_t x = *ptr;
   x = (x << 32) | (x >> 32);
   x = ((x & 0x0000FFFF0000FFFF) << 16) | ((x >> 16) & 0x0000FFFF0000FFFF);
   x = ((x & 0x00FF00FF00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF00FF00FF);

   *ptr=x;
}