21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › 嵌入式系统日志记录的简易方法
返回列表 发新帖我要提问

[其他] 嵌入式系统日志记录的简易方法

[复制链接]
1248|10
 楼主| 豆杀包 发表于 2022-5-24 10:46 | 显示全部楼层 |阅读模式
外部FLASH, 嵌入式设备, 应用场景, 环境, 嵌入式系统, flash
很多场景都需要记录日志，在嵌入式系统中，特别是单片机这种存储资源有限的环境下，就需要一种轻量级的存储方法。

系统日志
在嵌入式设备应用场景中，系统日志时常可以监控设备软件的运行状态，及时记录问题点以及关键信息，方便开发人员后期定位以及解决问题。
本文将讲述一种简易的系统日志记录方法，用于保存设备的系统日志，视具体嵌入式设备情况而定，可存储在MCU内部Flash、外部Flash、EEPROM等，本文采用外部Flash作为示例展开介绍。

回复

收藏 举报

相关帖子
 楼主| 豆杀包 发表于 2022-5-24 10:47 | 显示全部楼层
思路分析对于系统日志可以当成文件系统，可以划分为三个重要部分：目录区、参数区、日志区。
  • 目录区：根据日期进行归类，记录当天的日志的存储地址、日志索引、日志大小，通过目录可以获取整个日志文件的概况；
  • 参数区：存储记录日志写位置、目录项个数、写状态等参数；
  • 日志区：这是我们主要的存储区，记录系统的日志，支持环写。这三个区域都需要占用部分内存，可以自行分配大小。


实现的效果如下图所示，设置通过指令可查询到整个日志目录区的概况。查询系统日志目录：AT+CATALOG?LOG_ID:存储日志按日期分类，该ID用于查询对应日期日志,从1开始计数；LOG_DATE:系统日志存储日期；LOG_ADDR:系统日志存储外部FLASH地址；LOG_OFFSET:系统日志存储偏移量（各日期日志大小，单位：字节）。 49358628c472267c64.png 查询指定日期系统日志：AT+CATALOG=<LOG_ID>LOG_ID:在查询系统日志目录时获取，当LOG_ID为0时，为查询整个系统日志。 86734628c472e26164.png 另外提供移除系统日志（清除日志目录）指令：AT+RMLOG，后面将讲述具体实现。
回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:48 | 显示全部楼层



FLASH内存划分FLASH内存需要看具体设备进行合理划分，目录区、参数区与日志区实现环形存储，延长擦写寿命。
复制

  1. 

  2. #define FLASH_SECTOR_SIZE      ((uint32_t)0x001000)
    

  3. #define FLASH_BLOCK_32K_SIZE    ((uint32_t)0x008000)
    

  4. #define FLASH_BLOCK_64K_SIZE    ((uint32_t)0x010000)
    

  5. #define SECTOR_MASK               (FLASH_SECTOR_SIZE - 1)         /*扇区掩码 ------*/
    

  6. #define SECTOR_BASE(addr)         (addr & (~SECTOR_MASK))        /*扇区的基地址 --*/
    

  7. #define SECTOR_OFFSET(addr)       (addr & SECTOR_MASK)           /*扇区内的偏移 --*/
    


  8. 

  9. #define BLOCK_32K_BASE(addr)    (addr & (~(FLASH_BLOCK_32K_SIZE)))
    

  10. #define BLOCK_64K_BASE(addr)    (addr & (~(FLASH_BLOCK_64K_SIZE)))
    


  11. 

  12. typedef enum {
    

  13.     FLASH_BLOCK_4K  = 0,          /**< flash erase block size 4k */
    

  14.     FLASH_BLOCK_32K = 1,          /**< flash erase block size 32k */
    

  15.     FLASH_BLOCK_64K = 2           /**< flash erase block size 64k */
    

  16. }flash_block_t;
    


  17. 

  18. /* flash 空间索引 */
    

  19. typedef enum{
    

  20.     FLASH_CATALOG_ZONE = 0,
    

  21.     FLASH_SYSLOG_PARA_ZONE,
    

  22.     FLASH_SYSLOG_ZONE,
    

  23.     FLASH_ZONEX,
    

  24. }flash_zone_e;
    


  25. 

  26. typedef struct{
    

  27.     flash_zone_e zone;
    

  28.     uint32_t start_address;
    

  29.     uint32_t end_address;
    

  30. }flash_table_t;
    


  31. 

  32. /* 地址划分 */
    

  33. static const flash_table_t flash_table[] = {
    

  34.   { .zone = FLASH_CATALOG_ZONE,       .start_address = 0x03200000, .end_address = 0x032FFFFF},  
    

  35.   { .zone = FLASH_SYSLOG_PARA_ZONE,   .start_address = 0x03300000, .end_address = 0x033FFFFF},  
    

  36.   { .zone = FLASH_SYSLOG_ZONE,        .start_address = 0x03400000, .end_address = 0x03FFFFFF},  
    

  37. };


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:49 | 显示全部楼层
Flash底层实现擦除、读写操作接口，由读者自行实现。
复制
  1. flash_table_t *get_flash_table(flash_zone_e zone)
    

  2. {
    

  3.   int i = 0;
    

  4.   for (i = 0; i < flash_zone_count; i++) {
    

  5.     if (zone == flash_table[i].zone) 
    

  6.       return (flash_table_t *)&flash_table[i];
    

  7.   }
    


  8. 

  9.   return NULL;  
    

  10. }
    


  11. 

  12. int flash_erase(flash_zone_e zone, uint32_t address, flash_block_t block_type)
    

  13. {
    

  14.   flash_table_t *flash_table_tmp = get_flash_table(zone);
    


  15. 

  16.   if (flash_table_tmp == NULL)
    

  17.     return -1;
    


  18. 

  19.   if (address < flash_table_tmp->start_address ||address > flash_table_tmp->end_address) 
    

  20.     return -1;
    


  21. 

  22.   return bsp_spi_flash_erase(address, block_type);
    

  23. }
    


  24. 

  25. int flash_write(flash_zone_e zone, uint32_t address, const uint8_t*data, uint32_t length)
    

  26. {
    

  27.   flash_table_t *flash_table_tmp = get_flash_table(zone);
    


  28. 

  29.   if (flash_table_tmp == NULL)
    

  30.      return -1;
    


  31. 

  32.   if ((address < flash_table_tmp->start_address) ||((address + length) > flash_table_tmp->end_address))
    

  33.      return -1;
    


  34. 

  35.   return bsp_spi_flash_buffer_write(address, (uint8_t *)data, length);
    

  36. }
    


  37. 

  38. int flash_read(flash_zone_e zone, uint32_t address, uint8_t*buffer, uint32_t length)
    

  39. {
    

  40.   flash_table_t *flash_table_tmp = get_flash_table(zone);
    


  41. 

  42.   if (flash_table_tmp == NULL)
    

  43.     return -1;
    


  44. 

  45.   if ((address < flash_table_tmp->start_address) ||((address + length) > flash_table_tmp->end_address))
    

  46.     return -1;
    


  47. 

  48.   bsp_spi_flash_buffer_read(buffer, address, length);
    

  49.   return 0;
    

  50. }


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:50 | 显示全部楼层
参数与结构体定义日志数据存储时间戳，便于问题定位，需要实现RTC接口调用。
复制

  1. 

  2. typedef struct {
    

  3.   uint16_t   Year;    /* 年份:YYYY */
    

  4.   uint8_t    Month;    /* 月份:MM */
    

  5.   uint8_t    Day;    /* 日:DD */
    

  6.   uint8_t     Hour;    /* 小时:HH */
    

  7.   uint8_t     Minute;    /* 分钟:MM */
    

  8.   uint8_t   Second;    /* 秒:SS */
    

  9. }time_t;   
    


  10. 

  11. int bsp_rtc_get_time(time_t *date);
参数区应当保证数据的正确性，应加入参数校验存储，定义校验结构体。
复制
  1. #define SYSTEM_LOG_MAGIC_PARAM    0x87654321  /* 日志参数标识符 */
    

  2. typedef struct {
    

  3.   uint32_t magic;    /* 参数标识符 */
    

  4.   uint16_t crc;    /* 校验值 */
    

  5.   uint16_t len;    /* 参数长度 */
    

  6. } single_sav_t;
参数区需记录当前日志记录的写位置，以及目录项个数，还有日志区和目录区环写状态，并且存储最新时间等等。
复制

  1. 

  2. /* 日志区参数 */
    

  3. typedef struct {
    

  4.   uint32_t   write_pos;             /* 写位置 */
    

  5.   uint32_t   catalog_num;            /* 目录项个数 */
    

  6.   uint8_t    log_cyclic_status;    /* 系统日志环形写状态 */   
    

  7.   uint8_t    catalog_cyclic_status; /* 日志目录环形写状态 */
    

  8.   time_t     log_latest_time;     /* 存储最新时间 */
    

  9. }system_log_t;
    


  10. 

  11. /* 目录区参数 */
    

  12. typedef struct {
    

  13.   uint32_t log_id;     /* 日志索引 */  
    

  14.   uint32_t log_addr;    /* 日志地址 */
    

  15.   uint32_t log_offset;  /* 日志偏移大小，单位：字节 */
    

  16.   time_t   log_time;    /* 日志存储时间 */
    

  17. }system_catalog_t;
    


  18. 

  19. /* 系统日志参数 */
    

  20. typedef struct {
    

  21.   single_sav_t crc_val;
    

  22.   system_log_t system_log;
    

  23.   system_catalog_t system_catalog;
    

  24. }sys_log_param_t;
    


  25. 

  26. typedef struct {
    

  27.   uint8_t system_log_print_enable; /* 系统日志打印使能 */
    

  28.   uint16_t system_log_print_id;    /* 打印指定id系统日志 */
    

  29.   uint32_t system_log_param_addr;  /* 当前日志写地址 */
    

  30. } sys_ram_t;
    


  31. 

  32. sys_ram_t  SysRam;
    

  33. sys_log_param_t SysLogParam;
    


  34. 

  35. sys_ram_t  *gp_sys_ram = &SysRam;
    

  36. sys_log_param_t *gp_sys_log = &SysLogParam;


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:51 | 显示全部楼层
实现接口说明CRC校验接口，可以自定义实现。
复制

  1. 


  2. 

  3. /* 16位CRC校验高位表 */
    

  4. static const uint8_t auchCRCHi[]={
    

  5. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  6. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  7. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  8. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  9. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  10. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  11. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  12. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    


  13. 

  14. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  15. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  16. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  17. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  18. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,
    

  19. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  20. 0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40,0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,
    

  21. 0x00,0xc1,0x81,0x40,0x01,0xc0,0x80,0x41,0x01,0xc0,0x80,0x41,0x00,0xc1,0x81,0x40
    

  22. };
    


  23. 

  24. /* 16位CRC校验低位表 */
    

  25. static const uint8_t auchCRCLo[]={
    

  26. 0x00,0xc0,0xc1,0x01,0xc3,0x03,0x02,0xc2,0xc6,0x06,0x07,0xc7,0x05,0xc5,0xc4,0x04,
    

  27. 0xcc,0x0c,0x0d,0xcd,0x0f,0xcf,0xce,0x0e,0x0a,0xca,0xcb,0x0b,0xc9,0x09,0x08,0xc8,
    

  28. 0xd8,0x18,0x19,0xd9,0x1b,0xdb,0xda,0x1a,0x1e,0xde,0xdf,0x1f,0xdd,0x1d,0x1c,0xdc,
    

  29. 0x14,0xd4,0xd5,0x15,0xd7,0x17,0x16,0xd6,0xd2,0x12,0x13,0xd3,0x11,0xd1,0xd0,0x10,
    

  30. 0xf0,0x30,0x31,0xf1,0x33,0xf3,0xf2,0x32,0x36,0xf6,0xf7,0x37,0xf5,0x35,0x34,0xf4,
    

  31. 0x3c,0xfc,0xfd,0x3d,0xff,0x3f,0x3e,0xfe,0xfa,0x3a,0x3b,0xfb,0x39,0xf9,0xf8,0x38,
    

  32. 0x28,0xe8,0xe9,0x29,0xeb,0x2b,0x2a,0xea,0xee,0x2e,0x2f,0xef,0x2d,0xed,0xec,0x2c,
    

  33. 0xe4,0x24,0x25,0xe5,0x27,0xe7,0xe6,0x26,0x22,0xe2,0xe3,0x23,0xe1,0x21,0x20,0xe0,
    


  34. 

  35. 0xa0,0x60,0x61,0xa1,0x63,0xa3,0xa2,0x62,0x66,0xa6,0xa7,0x67,0xa5,0x65,0x64,0xa4,
    

  36. 0x6c,0xac,0xad,0x6d,0xaf,0x6f,0x6e,0xae,0xaa,0x6a,0x6b,0xab,0x69,0xa9,0xa8,0x68,
    

  37. 0x78,0xb8,0xb9,0x79,0xbb,0x7b,0x7a,0xba,0xbe,0x7e,0x7f,0xbf,0x7d,0xbd,0xbc,0x7c,
    

  38. 0xb4,0x74,0x75,0xb5,0x77,0xb7,0xb6,0x76,0x72,0xb2,0xb3,0x73,0xb1,0x71,0x70,0xb0,
    

  39. 0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
    

  40. 0x9c,0x5c,0x5d,0x9d,0x5f,0x9f,0x9e,0x5e,0x5a,0x9a,0x9b,0x5b,0x99,0x59,0x58,0x98,
    

  41. 0x88,0x48,0x49,0x89,0x4b,0x8b,0x8a,0x4a,0x4e,0x8e,0x8f,0x4f,0x8d,0x4d,0x4c,0x8c,
    

  42. 0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40
    

  43. };
    


  44. 

  45. /* 实现crc功能函数 */
    

  46. static uint16_t CRC16(uint8_t* puchMsg, uint16_t usDataLen)
    

  47. {
    

  48.   uint8_t uchCRCHi=0xff;
    

  49.   uint8_t uchCRCLo=0xff;
    

  50.   uint16_t uIndex;
    


  51. 

  52.   while(usDataLen--) {
    

  53.     uIndex=uchCRCHi^*(puchMsg++);
    

  54.     uchCRCHi=uchCRCLo^auchCRCHi[uIndex];
    

  55.     uchCRCLo=auchCRCLo[uIndex];
    

  56.   }
    


  57. 

  58.   return uchCRCHi<<8|uchCRCLo;
    

  59. }
保存系统日志参数，每实现写日志操作后都需要保存当前的参数值，防止意外丢失。
复制
  1. void save_system_log_param(void)
    

  2. {
    

  3.   uint32_t i = 0;
    

  4.   uint32_t addr = 0;
    

  5.   uint32_t remainbyte = 0;
    

  6.   uint32_t start_addr;
    

  7.   int len = sizeof(sys_log_param_t);
    

  8.   uint8_t *pdata = (uint8_t *)&SysLogParam;
    

  9.   flash_table_t *flash_tmp = get_flash_table(FLASH_SYSLOG_PARA_ZONE);
    


  10. 

  11.   /* 校验参数 */
    

  12.   gp_sys_log->crc_val.magic = SYSTEM_LOG_MAGIC_PARAM;
    

  13.   gp_sys_log->crc_val.len = sizeof(sys_log_param_t) - sizeof(single_sav_t);
    

  14.   gp_sys_log->crc_val.crc = CRC16(&pdata[sizeof(single_sav_t)], gp_sys_log->crc_val.len);
    


  15. 

  16.   start_addr = gp_sys_ram->system_log_param_addr;
    

  17.   /* 剩余内存不够写，则重新从起始地址开始写，实现环形存储功能  */
    

  18.   if ((start_addr + len) > flash_tmp->end_address) { 
    

  19.     start_addr = flash_tmp->start_address;
    

  20.   }
    

  21.   gp_sys_ram->system_log_param_addr = start_addr + len;
    

  22.   /* 首地址存储，擦除整个系统日志参数存储区，如果划分的内存较大，可能出现第一次擦写等待时间较长，
    

  23.      但实际应用嵌入式设备应该不会占用太多的内存存储系统日志，只当为辅助使用，有额外应用可自行实现 */
    

  24.   if (flash_tmp->start_address == start_addr) {
    

  25.     /*for (i = flash_tmp->start_address; i < flash_tmp->end_address; i+= FLASH_SECTOR_SIZE) 
    

  26.       flash_erase(FLASH_SYSLOG_PARA_ZONE, SECTOR_BASE(i), FLASH_BLOCK_4K);
    

  27.     */
    

  28.     addr = flash_tmp->start_address;
    

  29.     do {
    

  30.       if ((addr + FLASH_BLOCK_64K_SIZE) <= flash_tmp->end_address) {
    

  31.         flash_erase(FLASH_SYSLOG_PARA_ZONE, BLOCK_64K_BASE(i), FLASH_BLOCK_64K);
    

  32.         addr += FLASH_BLOCK_64K_SIZE;
    

  33.       } else if ((addr + FLASH_BLOCK_32K_SIZE) <= flash_tmp->end_address) {
    

  34.         flash_erase(FLASH_SYSLOG_PARA_ZONE, BLOCK_32K_BASE(i), FLASH_BLOCK_32K);
    

  35.         addr += FLASH_BLOCK_32K_SIZE;
    

  36.       } else if ((addr + FLASH_SECTOR_SIZE) <= flash_tmp->end_address) {
    

  37.         flash_erase(FLASH_SYSLOG_PARA_ZONE, SECTOR_BASE(i), FLASH_BLOCK_4K);
    

  38.         addr += FLASH_SECTOR_SIZE;
    

  39.       } else {
    

  40.         break;
    

  41.       }
    

  42.     } while (addr < flash_tmp->end_address);  
    

  43.   }
    


  44. 

  45.   remainbyte = FLASH_SECTOR_SIZE - (start_addr % FLASH_SECTOR_SIZE);
    

  46.   if (remainbyte > len) {
    

  47.     remainbyte = len;
    

  48.   }
    

  49.   while (1) {
    

  50.     flash_write(FLASH_SYSLOG_PARA_ZONE, start_addr, pdata, remainbyte);
    

  51.     if (remainbyte == len) {
    

  52.       break;
    

  53.     } else {
    

  54.       pdata += remainbyte;
    

  55.       start_addr += remainbyte;
    

  56.       len -= remainbyte;
    

  57.       remainbyte = (len > FLASH_SECTOR_SIZE) ? FLASH_SECTOR_SIZE : len;
    

  58.     }
    

  59.   }
    

  60. }
导入系统日志默认参数接口，初始化默认参数或者移除日志。
复制

  1. 

  2. void load_system_log_default_param(void)
    

  3. {
    

  4.   /* 系统日志默认参数 */
    

  5.   /* 目录环写状态标志 */
    

  6.   gp_sys_log->system_log.catalog_cyclic_status = 0x00;
    

  7.   /* 目录项个数 */
    

  8.   gp_sys_log->system_log.catalog_num = 0;
    

  9.   /* 日志环写标志 , 1:环写状态 */
    

  10.   gp_sys_log->system_log.log_cyclic_status = 0;
    

  11.   /* 设置默认值，实际会重新从RTC获取最新时间 */
    

  12.   gp_sys_log->system_log.log_latest_time.Year = 2019;
    

  13.   gp_sys_log->system_log.log_latest_time.Month = 5;
    

  14.   gp_sys_log->system_log.log_latest_time.Day = 8;
    

  15.   gp_sys_log->system_log.log_latest_time.Hour = 13;
    

  16.   gp_sys_log->system_log.log_latest_time.Minute = 14;
    

  17.   gp_sys_log->system_log.log_latest_time.Second = 10;
    

  18.   /* 日志写位置从0开始 */
    

  19.   gp_sys_log->system_log.write_pos = 0;
    


  20. 

  21.   gp_sys_log->system_catalog.log_addr = 0;
    

  22.   gp_sys_log->system_catalog.log_id = 0;
    

  23.   gp_sys_log->system_catalog.log_offset = 0;
    

  24.   gp_sys_log->system_catalog.log_time.Year = 2019;
    

  25.   gp_sys_log->system_catalog.log_time.Month = 5;
    

  26.   gp_sys_log->system_catalog.log_time.Day = 8;
    

  27.   gp_sys_log->system_catalog.log_time.Hour = 12;
    

  28.   gp_sys_log->system_catalog.log_time.Minute = 12;
    

  29.   gp_sys_log->system_catalog.log_time.Second = 14;
    


  30. 

  31.   gp_sys_log->crc_val.magic = SYSTEM_LOG_MAGIC_PARAM;
    


  32. 

  33.   /* 导入默认参数后进行保存 */
    

  34.   save_system_log_param();
    

  35. }


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:52 | 显示全部楼层
设备开机或者复位都会进行导入系统日志参数操作，恢复日志读写参数，参数区为频繁读写操作区域，每一次写操作都会进行一次偏移，有效的导入参数方法是从参数区结束地址到起始地址进行扫描，扫描不到合法的参数则会导入默认日志参数。
复制

  1. 

  2. /* 参数初始化，在终端启动时调用 */
    

  3. int load_system_log_param(void)
    

  4. {
    

  5.   uint32_t i = 0;
    

  6.   single_sav_t psav;
    

  7.   uint32_t end_addr;
    

  8.   uint32_t interal = sizeof(sys_log_param_t);
    

  9.   int data_len = sizeof(sys_log_param_t) - sizeof(single_sav_t);
    

  10.   uint8_t *pram = (uint8_t *)&SysLogParam;
    

  11.   flash_table_t *flash_tmp = get_flash_table(FLASH_SYSLOG_PARA_ZONE);
    


  12. 

  13.   end_addr =flash_tmp->end_address - (flash_tmp->end_address - flash_tmp->start_address) % interal;
    

  14.   for (i = end_addr - interal; i > flash_tmp->start_address; i -= interal) {
    

  15.     flash_read(FLASH_SYSLOG_PARA_ZONE, i, (uint8_t *)&psav, sizeof(single_sav_t));
    

  16.     if ((psav.magic == SYSTEM_LOG_MAGIC_PARAM) && (psav.len ==data_len)) {      
    

  17.       flash_read(FLASH_SYSLOG_PARA_ZONE, i + sizeof(single_sav_t), &pram[sizeof(single_sav_t)], data_len);
    

  18.       if (psav.crc != CRC16(&pram[sizeof(single_sav_t)], data_len)) 
    

  19.         continue;
    

  20.       gp_sys_ram->system_log_param_addr = i;
    

  21.       log_info("Load System Log Param Addr[0x%08x]!", gp_sys_ram->system_log_param_addr);
    

  22.       return 0;
    

  23.     }
    

  24.   }
    


  25. 

  26.   /* 扫描不到合法的参数，导入默认系统日志参数 */
    

  27.   load_system_log_default_param();
    

  28.   /* 获取日志写地址 */
    

  29.   gp_sys_ram->system_log_param_addr = flash_tmp->start_address;
    

  30.   log_info("Load System Log Param Addr(Default)[0x%08x]!", gp_sys_ram->system_log_param_addr);
    

  31.   return 1;
    

  32. }


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:53 | 显示全部楼层
读写系统日志目录接口，读写指定日志索引目录信息。实际实现会定义最新的目录信息存储在日志参数区，当日期发生改变，则表示当前目录信息已经完结，将最新的目录信息录入日志目录区保存，最多每天写入一次目录区。
复制
  1. /* 读取日志目录区指定日志索引目录信息 */
    

  2. int system_catalog_read(system_catalog_t *catalog, uint32_t id)
    

  3. {
    

  4.   uint32_t addr;
    

  5.   int rlen = sizeof(system_catalog_t);
    

  6.   uint8_t *pbuf = (uint8_t *)catalog;
    

  7.   flash_table_t *flash_tmp = get_flash_table(FLASH_CATALOG_ZONE);
    


  8. 

  9.   if (0 == id) 
    

  10.     return -1;
    

  11.   addr = flash_tmp->start_address + (rlen * (id - 1));
    

  12.   if (addr > flash_tmp->end_address) 
    

  13.     return -1;
    


  14. 

  15.   return flash_read(FLASH_CATALOG_ZONE, addr, pbuf, rlen);
    

  16. }
    


  17. 

  18. /* 写日志目录区目录信息 */
    

  19. int system_catalog_write(system_catalog_t *catalog, uint32_t id)
    

  20. {
    

  21.   uint32_t start_offset;
    

  22.   uint32_t start_addr;
    

  23.   uint32_t start_base;
    

  24.   uint32_t remainbyte;
    

  25.   int wlen = sizeof(system_catalog_t);
    

  26.   uint8_t *pdata = (uint8_t *)catalog;
    

  27.   flash_table_t *flash_tmp = get_flash_table(FLASH_CATALOG_ZONE);
    


  28. 

  29.   if (0 == id) return -1;
    

  30.   start_addr = flash_tmp->start_address + wlen * (id - 1);
    

  31.   if ((start_addr + wlen) > flash_tmp->end_address) {
    

  32.     start_addr = flash_tmp->start_address;
    

  33.   }
    


  34. 

  35.   /* 本扇区剩余空间大小 */
    

  36.   remainbyte = FLASH_SECTOR_SIZE - (start_addr % FLASH_SECTOR_SIZE);
    

  37.   /* 写入数据长度小于本扇区剩余长度，直接写入 */
    

  38.   if (remainbyte > wlen) {
    

  39.     remainbyte = wlen;
    

  40.   }
    

  41.   /* 写目录次数不会太频繁，视具体情况改写操作实现 */
    

  42.   while (1) {
    

  43.     start_base = SECTOR_BASE(start_addr);
    

  44.       start_offset = SECTOR_OFFSET(start_addr);
    

  45.     flash_read(FLASH_CATALOG_ZONE, start_base, sector_buf, FLASH_SECTOR_SIZE);
    

  46.     flash_erase(FLASH_CATALOG_ZONE, start_base, FLASH_BLOCK_4K);
    

  47.     memcpy((char *)§or_buf[start_offset], pdata, remainbyte);
    

  48.     flash_write(FLASH_CATALOG_ZONE, start_base, sector_buf, FLASH_SECTOR_SIZE);
    

  49.     if (remainbyte == wlen) {
    

  50.       break;
    

  51.     } else {
    

  52.       pdata += remainbyte;
    

  53.       start_addr += remainbyte;
    

  54.       wlen -= remainbyte;
    

  55.       remainbyte = (wlen > FLASH_SECTOR_SIZE) ? FLASH_SECTOR_SIZE : wlen;
    

  56.     }
    

  57.   }
    


  58. 

  59.   return 0;
    

  60. }
打印系统日志目录区信息，可实现通过指令查询到目录区信息。
复制

  1. 

  2. int system_catalog_all_print(void)
    

  3. {
    

  4.   int i = 0;
    

  5.   system_catalog_t catalog;
    


  6. 

  7.   printf("System Log Command Information:\r\n");
    

  8.   printf("Query Specifies Log : AT+CATALOG=<LOG_ID><CR><LF>\r\n");
    

  9.   printf("Query All Log : AT+CATALOG=<0><CR><LF>\r\n\r\n");
    

  10.   printf("Query All System Catalog:\r\n");
    

  11.   printf("LOG_ID    LOG_DATE    LOG_ADDR    LOG_OFFSET  \r\n");
    

  12.   for (i = 0; i < gp_sys_log->system_log.catalog_num; i++) {
    

  13.     /* 当前最新目录信息 */    
    

  14.     if (i == (gp_sys_log->system_catalog.log_id - 1)) {
    

  15.       catalog = gp_sys_log->system_catalog; /* 获取当前最新目录信息 */
    

  16.     } else {
    

  17.       system_catalog_read(&catalog, i + 1);
    

  18.     }
    

  19.     printf("%d    %04d-%02d-%02d    0x%08X    %d  \r\n", 
    

  20.       catalog.log_id, catalog.log_time.Year, catalog.log_time.Month, catalog.log_time.Day, 
    

  21.       catalog.log_addr, catalog.log_offset);
    

  22.     memset((char *)&catalog, 0, sizeof(system_catalog_t));
    

  23.   }
    

  24.   return 0;
    

  25. }


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:53 | 显示全部楼层
读取指定日志目录索引信息接口，可指定日志索引或者读取全部日志数据。
复制
  1. int system_log_task(int argc)
    

  2. {
    

  3.   int rlen = 0;
    

  4.   uint32_t offset, start_addr, end_addr;
    

  5.   system_catalog_t catalog;
    

  6.   flash_table_t *flash_tmp =get_flash_table(FLASH_SYSLOG_ZONE);
    


  7. 

  8.   if (0 == gp_sys_ram->system_log_print_enable) 
    

  9.     return 1;
    


  10. 

  11.   gp_sys_ram->system_log_print_enable = 0x00;
    

  12.   if (gp_sys_ram->system_log_print_id == ALL_LOG_PRINT) {
    

  13.     /* log回环写标志,打印整个LOG存储区 */
    

  14.     if (0x01 == gp_sys_log->system_log.log_cyclic_status) { 
    

  15.       start_addr = flash_tmp->start_address;
    

  16.       end_addr = flash_tmp->end_address;
    

  17.       offset = end_addr - start_addr;
    

  18.     } else {
    

  19.       start_addr = flash_tmp->start_address;
    

  20.       end_addr = start_addr + gp_sys_log->system_log.write_pos;
    

  21.       offset = gp_sys_log->system_log.write_pos;
    

  22.     }
    

  23.   } else { /* 读取指定ID日志 */
    

  24.     if (gp_sys_ram->system_log_print_id == gp_sys_log->system_catalog.log_id) {
    

  25.       catalog = gp_sys_log->system_catalog;
    

  26.     } else {
    

  27.       system_catalog_read(&catalog, gp_sys_ram->system_log_print_id);
    

  28.     }
    

  29.     start_addr = catalog.log_addr;
    

  30.     offset = catalog.log_offset;
    

  31.   }  
    


  32. 

  33.   if (0 == offset)
    

  34.     return 1;
    


  35. 

  36.   while (1) {
    

  37.     rlen = (offset > 512) ? 512 : offset;
    

  38.     system_log_read(sector_buf, start_addr, rlen);
    

  39.     HAL_Delay(80);
    

  40.     /* 目录信息通过调式串口打印 */
    

  41.     bsp_debug_send(sector_buf, rlen);
    

  42.     start_addr += rlen;
    

  43.     offset -= rlen;
    

  44.     if (0 == offset) 
    

  45.       break;
    

  46.   }
    

  47.   return 0;
    

  48. }
存储系统日志接口，实现更新存储日期，当写位置为扇区地址，则擦除一个扇区作为存储日志，这样避免每写一次就擦除一次。
复制

  1. 

  2. int system_log_write(uint8_t *wbuf, int wlen)
    

  3. {
    

  4.   uint32_t start_addr;
    

  5.   uint8_t *pdata = wbuf;
    

  6.   uint32_t remainbyte;
    

  7.   int system_catalog_max_id;
    

  8.   flash_table_t *flash_tmp =get_flash_table(FLASH_SYSLOG_ZONE);
    


  9. 

  10.   /* 计算目录区的最大存储目录项个数 */
    

  11.   system_catalog_max_id = ((flash_tmp->end_address - flash_tmp->start_address) / sizeof(system_catalog_t));
    

  12.   start_addr = flash_tmp->start_address + gp_sys_log->system_log.write_pos;
    

  13.   /* 存储数据地址大于规划内存地址范围处理 */
    

  14.   if ((start_addr + wlen) > flash_tmp->end_address) { 
    

  15.     start_addr = flash_tmp->start_address;
    

  16.     /* 写位置偏移量重置 */
    

  17.     gp_sys_log->system_log.write_pos = 0;
    

  18.     /* LOG回环存储标志置位 */
    

  19.     gp_sys_log->system_log.log_cyclic_status = 0x01; 
    

  20.   }
    

  21.   /* 写位置偏移 */
    

  22.   gp_sys_log->system_log.write_pos += wlen; 
    


  23. 

  24.   if ((gp_sys_log->system_log.log_latest_time.Year != gp_sys_log->system_catalog.log_time.Year) ||
    

  25.     (gp_sys_log->system_log.log_latest_time.Month != gp_sys_log->system_catalog.log_time.Month) ||
    

  26.     (gp_sys_log->system_log.log_latest_time.Day != gp_sys_log->system_catalog.log_time.Day)) {
    


  27. 

  28.     /* 日期改变，记录目录信息，当log_id为0，则不写入 */
    

  29.     system_catalog_write(&gp_sys_log->system_catalog, gp_sys_log->system_catalog.log_id);
    

  30.     /* 记录存储日期 */
    

  31.     gp_sys_log->system_catalog.log_time = gp_sys_log->system_log.log_latest_time;
    


  32. 

  33.     if ((gp_sys_log->system_catalog.log_id + 1) >= system_catalog_max_id) {
    

  34.       gp_sys_log->system_log.catalog_num = system_catalog_max_id; /* 目录循环写，目录数应为最大 */
    

  35.       gp_sys_log->system_log.catalog_cyclic_status = 1; /* 目录回环写标志 */
    

  36.     } else {
    

  37.       if (0 == gp_sys_log->system_log.catalog_cyclic_status) {
    

  38.         /* 获取目录数 */
    

  39.         gp_sys_log->system_log.catalog_num = gp_sys_log->system_catalog.log_id + 1; 
    

  40.       }
    

  41.     }
    


  42. 

  43.     /* 存储最新目录项信息 */
    

  44.     gp_sys_log->system_catalog.log_id = (gp_sys_log->system_catalog.log_id + 1) % system_catalog_max_id;
    

  45.     gp_sys_log->system_catalog.log_addr = start_addr;
    

  46.     gp_sys_log->system_catalog.log_offset = wlen; 
    

  47.   } else {
    

  48.     gp_sys_log->system_catalog.log_offset += wlen; 
    

  49.   }
    


  50. 

  51.   /* 写位置为存储起始地址并且不为扇区首地址 */
    

  52.   if ((flash_tmp->start_address == start_addr) && (SECTOR_OFFSET(flash_tmp->start_address))){
    

  53.     flash_read(FLASH_SYSLOG_ZONE, SECTOR_BASE(start_addr), sector_buf, FLASH_SECTOR_SIZE);
    

  54.     flash_erase(FLASH_SYSLOG_ZONE, SECTOR_BASE(start_addr), FLASH_BLOCK_4K);
    

  55.     /* 将扇区头部至起始地址区间的数据回写 */
    

  56.     flash_write(FLASH_SYSLOG_ZONE, SECTOR_BASE(start_addr), §or_buf[0], SECTOR_OFFSET(start_addr)); 
    

  57.   }
    

  58.   /* 写位置为扇区首地址，则擦除一个扇区的存储区    */
    

  59.   if (0 == SECTOR_OFFSET(start_addr)) {
    

  60.     flash_erase(FLASH_SYSLOG_ZONE, SECTOR_BASE(start_addr), FLASH_BLOCK_4K);
    

  61.   }
    


  62. 

  63.   /* 本扇区剩余空间大小 */
    

  64.   remainbyte = FLASH_SECTOR_SIZE - (start_addr % FLASH_SECTOR_SIZE);
    

  65.   /* 写入数据长度小于本扇区剩余长度，直接写入 */
    

  66.   if (remainbyte > wlen) {
    

  67.     remainbyte = wlen;
    

  68.   }
    

  69.   while (1) {
    

  70.     flash_write(FLASH_SYSLOG_ZONE, start_addr, pdata, remainbyte);
    

  71.     if (remainbyte == wlen) {
    

  72.       break;
    

  73.     } else {
    

  74.       pdata += remainbyte;
    

  75.       start_addr += remainbyte;
    

  76.       wlen -= remainbyte;
    

  77.       remainbyte = (wlen > FLASH_SECTOR_SIZE) ? FLASH_SECTOR_SIZE : wlen;
    

  78.       /* 扇区首地址则擦除整个扇区，该扇区数据不保存 */
    

  79.       if (0 == SECTOR_OFFSET(start_addr)) {
    

  80.         flash_erase(FLASH_SYSLOG_ZONE, SECTOR_BASE(start_addr), FLASH_BLOCK_4K);
    

  81.       }
    

  82.     }
    

  83.   }
    


  84. 

  85.   /* 环形存储参数 */
    

  86.   save_system_log_param();
    

  87.   return 0;
    

  88. }


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:54 | 显示全部楼层
系统调试对接为了更好记录系统日志，将应用调试等级结合一块，实现记录错误调试信息以及需要保存的关键信息。定义的调试等级有：关闭调试等级、错误调试等级、警告调试等级、关键调试等级、debug调试等级，而LOG_RECORD_LEVEL将主动保存日志并输出信息，LOG_ERROR_LEVEL会存储对应的日志信息，但需要根据应用调试等级输出信息。设置与读取应用调试等级由读者自行定义。
复制

  1. 

  2. #define LOG_CLOSE_LEVEL        0x00 /* 关闭调试信息 */
    

  3. #define LOG_ERROR_LEVEL        0x01 /* 错误调试信息 */
    

  4. #define LOG_WARN_LEVEL        0x02 /* 警告调试信息 */
    

  5. #define LOG_INFO_LEVEL        0x03 /* 关键调试信息 */
    

  6. #define LOG_DEBUG_LEVEL        0x04 /* debug调试信息 */
    

  7. #define LOG_RECORD_LEVEL      0x10 /* 保存日志并输出信息 */  
    

  8. #define LOG_PRINT_LEVEL        0xff
    


  9. 

  10. #define SET_LOG_LEVEL(LEVEL)    (gp_sys_param->system_print_level = LEVEL)
    

  11. #define GET_LOG_LEVEL()        (gp_sys_param->system_print_level)
    


  12. 

  13. #define log_debug(fmt, args...)    log_format(LOG_DEBUG_LEVEL, fmt, ##args)
    

  14. #define log_info(fmt, args...)    log_format(LOG_INFO_LEVEL, fmt, ##args)
    

  15. #define log_warn(fmt, args...)    log_format(LOG_WARN_LEVEL, fmt, ##args)
    

  16. #define log_error(fmt, args...)    log_format(LOG_ERROR_LEVEL, fmt, ##args)
    

  17. #define log_record(fmt, args...)  log_format(LOG_RECORD_LEVEL, fmt, ##args)
    

  18. #define printf(fmt, args...)    log_format(LOG_PRINT_LEVEL, fmt, ##args)
    


  19. 

  20. typedef struct {
    

  21.   int level;
    

  22.   char *fmt_str;
    

  23. }system_print_fmt_t;
    


  24. 

  25. system_print_fmt_t system_print_fmt_list[] = {
    

  26.   { .level = LOG_ERROR_LEVEL,   .fmt_str = "<error>:"},
    

  27.   { .level = LOG_WARN_LEVEL,    .fmt_str = "<warn>:"},
    

  28.   { .level = LOG_INFO_LEVEL,    .fmt_str = "<info>:"},
    

  29.   { .level = LOG_DEBUG_LEVEL,   .fmt_str = "<debug>:"},
    

  30.   { .level = LOG_RECORD_LEVEL,  .fmt_str = "<record>:"},
    

  31. };
    


  32. 

  33. int log_format(uint8_t level, const char *fmt, ...)
    

  34. {
    

  35.   #define TIME_PREFIX_SIZE  (21)
    

  36.   #define PRINT_MAX_SIZE    (1024 + TIME_PREFIX_SIZE)
    


  37. 

  38.     va_list args;
    

  39.     int num = 0, i = 0, fmt_index = 0;
    

  40.     int fmt_str_len = 0, ret = -1;
    

  41.     int file_str_len = 0, line_str_len = 0;
    

  42.     char line_buf[20] = {0};
    

  43.     static char buf[PRINT_MAX_SIZE];
    

  44.   static QueueHandle_t sem = NULL;
    

  45.   time_t time = {0};
    


  46. 

  47.   /* 针对os系统 */
    

  48.   if (NULL == sem) {
    

  49.         sem = xSemaphoreCreateCounting(1, 1); /* always think of success */
    

  50.   }
    


  51. 

  52.   xSemaphoreTake(sem, portMAX_DELAY);
    


  53. 

  54.   ret = -1;
    

  55.   fmt_str_len = 0;
    

  56.   if (level != LOG_PRINT_LEVEL) {
    

  57.     if ((GET_LOG_LEVEL() < level) && (level != LOG_RECORD_LEVEL) && (level != LOG_ERROR_LEVEL))
    

  58.       goto exit_end;
    


  59. 

  60.     for (i = 0; i < SYSTEM_PRINT_FMT_LIST_MAX; i++) {
    

  61.       if (level == system_print_fmt_list[i].level) {
    

  62.         fmt_index = i;
    

  63.         break;
    

  64.       }
    

  65.     }
    

  66.     if (i > SYSTEM_PRINT_FMT_LIST_MAX) {
    

  67.       goto exit_end;
    

  68.     }
    


  69. 

  70.     fmt_str_len = strlen(system_print_fmt_list[fmt_index].fmt_str);
    

  71.     strncpy((char *)&buf[TIME_PREFIX_SIZE], system_print_fmt_list[fmt_index].fmt_str, fmt_str_len);
    

  72.   }
    


  73. 

  74.     va_start(args, fmt);
    

  75.     num = vsnprintf((char *)&buf[fmt_str_len + TIME_PREFIX_SIZE], PRINT_MAX_SIZE - fmt_str_len - TIME_PREFIX_SIZE - 2, fmt, args);
    

  76.     va_end(args);
    


  77. 

  78.     if (num <= 0) {
    

  79.     goto exit_end;
    

  80.     }
    


  81. 

  82.   if (level != LOG_PRINT_LEVEL) {
    

  83.     num += fmt_str_len;
    

  84.     buf[num + TIME_PREFIX_SIZE] = '\r';
    

  85.     buf[num + TIME_PREFIX_SIZE + 1] = '\n';
    

  86.     num += 2;
    

  87.   }
    


  88. 

  89.   if ((GET_LOG_LEVEL() < level) && (level == LOG_ERROR_LEVEL)) {
    

  90.     //do nothing
    

  91.   } else {
    

  92.     ret = bsp_debug_send((uint8_t*)&buf[TIME_PREFIX_SIZE], num);  
    

  93.   }
    


  94. 

  95.   if ((LOG_ERROR_LEVEL == level) || (LOG_RECORD_LEVEL == level)) {
    

  96.     bsp_rtc_get_time(&time);
    

  97.     sprintf(&buf[0], "[%04d-%02d-%02d %02d:%02d:%02d",
    

  98.       time.Year, time.Month, time.Day,time.Hour, time.Minute, time.Second);
    

  99.     buf[TIME_PREFIX_SIZE - 1] = ']';
    

  100.     gp_sys_log->system_log.log_latest_time = time;
    

  101.     system_log_write((uint8_t *)buf, num + TIME_PREFIX_SIZE);
    

  102.   }  
    


  103. 

  104. exit_end:
    

  105.   xSemaphoreGive(sem);
    

  106.   return ret;
    

  107. }


回复

收藏 举报

 楼主| 豆杀包 发表于 2022-5-24 10:55 | 显示全部楼层
结语本文提供的一种简易嵌入式设备系统日志记录方法，代码量不多，实现简单，针对不同的设备需要合理规划内存使用。
根据软件运行状态，合适加入调试信息并保存对应的日志信息，方便开发人员了解系统或软件运行状况，协助开发分析数据资源从而更好完善系统，提高定位以及解决问题的效果。
来源地址：
https://blog.csdn.net/LiaRonBob/article/details/102766871

回复

收藏 举报

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

本版积分规则

豆杀包

49

主题

323

帖子

0

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