pusart log以及slog

pusart log

//串口log开关
#define AUDIO_DEBUG_LOG_ENABLE  1
#if AUDIO_DEBUG_LOG_ENABLE
#define AUDIO_LOG_DBG(format, ...)     LOG_RAW("BT_AUDIO: [%s] "format"\r\n", __func__, ##__VA_ARGS__)
#else
#define AUDIO_LOG_DBG(...)
#endif

//存储log开关
#define AUDIO_SAVE_LOG_TO_EMMC   0
#if AUDIO_SAVE_LOG_TO_EMMC
#if AUDIO_DEBUG_LOG_ENABLE
#define AUDIO_SLOG_DBG(level, format, ...)  SLOG_DBG(level, "BT_AUD:"format"\r\n", ##__VA_ARGS__);LOG_RAW("BT_AUDIO: %s: "format"\r\n", __func__, ##__VA_ARGS__);
#define AUDIO_SLOG_ERR(level, format, ...)  SLOG_ERR(level, "BT_AUD:"format"\r\n", ##__VA_ARGS__);LOG_RAW("BT_AUDIO: %s: "format"\r\n", __func__, ##__VA_ARGS__);
#else
#define AUDIO_SLOG_DBG(level, format, ...)  SLOG_DBG(level, "BT_AUD:"format"\r\n", ##__VA_ARGS__)
#define AUDIO_SLOG_ERR(level, format, ...)  SLOG_ERR(level, "BT_AUD:"format"\r\n", ##__VA_ARGS__)
#endif
#else
#if AUDIO_DEBUG_LOG_ENABLE
#define AUDIO_SLOG_DBG(level, format, ...)  LOG_RAW("BT_AUDIO: %s: "format"\r\n", __func__, ##__VA_ARGS__);
#define AUDIO_SLOG_ERR(level, format, ...)  LOG_RAW("BT_AUDIO: %s: "format"\r\n", __func__, ##__VA_ARGS__);
#else
#define AUDIO_SLOG_DBG(level, ...)
#define AUDIO_SLOG_ERR(level, ...)
#endif
#endif

#ifdef GPS_OTA_TEST
#define DEBUG_QUEUEBUFFER_SIZE  8192
#else
#define DEBUG_QUEUEBUFFER_SIZE  4096
#endif
#define DEBUG_MSG_MAX_SIZE    1024
typedef struct
{
    uint32_t    MPU_Region[MPU_PROTECTED_REGION_SIZE];
    queue_t     DebugQueue;
    uint8_t     _DebugQueueBuffer[DEBUG_QUEUEBUFFER_SIZE];
    uint8_t     _tempMsgBuf[DEBUG_MSG_MAX_SIZE];
} Service_Debug_data_t;

extern Service_Debug_data_t g_data_service_debug;

/**
  * @brief log数据打印接口
  * @param NONE
  * @retval NONE
  */
void service_debug(const char *format, ...)
{
  	if (g_log_switch)
	{
        va_list arg_ptr;

        va_start(arg_ptr, format);
        service_debug_ext(format, arg_ptr);
        va_end(arg_ptr);
    }
}

/**
  * @brief log数据打印实现
  * @param NONE
  * @retval NONE
  */
void service_debug_ext(const char *format, va_list arg_ptr)
{
    uint16_t buf_size;
    uint32_t uwPRIMASK_Bit;
    uint8_t* buffer;

    SET_DEVICE_LOCK(D_LPUART_LOCK);
    uwPRIMASK_Bit = __get_PRIMASK();  /**< backup PRIMASK bit */
    __disable_irq();          /**< Disable all interrupts by setting PRIMASK bit on Cortex*/
    buf_size=vsnprintf((char *) g_data_service_debug._tempMsgBuf, DEBUG_MSG_MAX_SIZE, format, arg_ptr);
    buffer=CircularQueue_Add(&g_data_service_debug.DebugQueue,(uint8_t*)g_data_service_debug._tempMsgBuf, buf_size,1);
    if(buffer && debugUartReady)
    {
        debugUartReady  = RESET;
        HAL_UART_Transmit_DMA(&hlpuart1, (uint8_t*)buffer, buf_size);  //uart通过dma方式
    }
    __set_PRIMASK(uwPRIMASK_Bit);
}





#define LOG_PRINTF      service_debug


/****************************** log打印接口 ************************************/
#define LOG_RAW(...) {do{\
                            LOG_PRINTF(__VA_ARGS__);\
                        }while(0);}

slog

//slog  emmc log

//添加调试log到log缓冲
#define SLOG_DBG(mod, ...) do{ \
        LOG_STORE(mod,LOG_LVL_DBG, __VA_ARGS__);\
      }while(0);
	  
#define LOG_STORE       store_stm32	  

const char* g_lcLogLevelName[4] = 
{
   "Info",
   "Error",
   "Warn",
   "Debug",
};
//STM32
volatile uint8_t g_cursvLogLevel = LOG_LVL_DBG;
volatile uint8_t g_cursvlogOutputDir = LOG_OUTPUT_DIR_STORE;
volatile uint32_t g_cursvLogMod = (SV_LOG_MOD_SYS | SV_LOG_MOD_DRV | SV_LOG_MOD_SER | SV_LOG_MOD_GUI | SV_LOG_MOD_NFC | SV_LOG_MOD_BLE | SV_LOG_MOD_DUA | SV_LOG_MOD_TSK | SV_LOG_MOD_PWR | SV_LOG_MOD_LCD | SV_LOG_MOD_TP | SV_LOG_MOD_BAT);

void store_stm32(uint32_t mode, uint8_t level, const char *format, ...)
{
  if((g_cursvLogLevel >= level) && (g_cursvLogMod & mode))
  {
      {  
        va_list arg_ptr;
        Log_Message_t msg;
        time_rtc_t time;
        uint8_t HeadLen = 0;  

        if(LogPoolID == NULL)
            return;
        msg.pMsgData = osPoolAlloc(LogPoolID);  //内存池
        if (msg.pMsgData)
        {
            if(level > 4) level = 4;
            if(level < 1) level = 1;
            
            msg.msg_type = MSGTYPE_LOG;            
            va_start(arg_ptr, format);
            service_rtc_Get(&time);
            {
                HeadLen = (strlen(g_lcLogLevelName[level-1]) + 35);
                snprintf((char *)msg.pMsgData, HeadLen+1, "\r\n[%02d-%02d-%02d %02d:%02d:%02d][%10u][%s]\t", 
                         time.yearL, time.month, time.date, time.hour, time.minute, time.second, osKernelSysTick(), g_lcLogLevelName[level-1]);
                msg.msgLength = vsnprintf((char *)&(msg.pMsgData->log.dataBuff[HeadLen]), LOG_MSG_BLOCK_SIZE - HeadLen, format, arg_ptr);            
            }
            msg.msgLength += HeadLen;
            if(msg.msgLength > LOG_MSG_BLOCK_SIZE)
            {
                msg.msgLength = LOG_MSG_BLOCK_SIZE;
                LOG_RAW("stm32 log BLOCK_SIZE error\r\n");
            }            
            if(false == save_log_queue(&msg))
            {
                osPoolFree(LogPoolID, msg.pMsgData);
            }
            va_end(arg_ptr);
        }
        return;
      }  
  }
}


//通过消息队列，执行下面的log存储

typedef struct
{
    uint8_t  stm32_index;
    uint32_t stm32_pos;
    
    uint8_t stm32_buff_first[LOG_BUFF_SIZE_STM32];
    uint8_t stm32_buff_second[LOG_BUFF_SIZE_STM32];
}log_buff_t;
log_buff_t _g_log_buffer；
static bool log_data_update(log_type_e logType, const uint8_t* log, uint32_t len, uint8_t needFlush)
{
    uint8_t *pBuff = NULL;
    uint8_t  *pIndex = NULL;
    uint32_t  *pPos = NULL;
    uint8_t  *pBuff_first = NULL;
    uint8_t  *pBuff_second = NULL;
    uint32_t log_BuffSize = 0;
    log_type_e logType_curr = logType;
    uint8_t  log_type_max = 1;

    if(needFlush)//需要立即存，保存所有log缓存到文件
    {
        log_type_max = 4;
    }
    for(int i = 0;i < log_type_max;i++)
    {
        logType_curr = (log_type_e)(logType << i);
        switch(logType_curr)
        {
            case LOG_TYPE_STM32:
              log_BuffSize = LOG_BUFF_SIZE_STM32;
              pPos = &_g_log_buffer.stm32_pos;
              pIndex = &_g_log_buffer.stm32_index;
              pBuff_first = _g_log_buffer.stm32_buff_first;
              pBuff_second = _g_log_buffer.stm32_buff_second;
              break;
            default:
              FLOG_STORE("No such type of log!");
              return false;
        }

        if(((*pPos + len) > log_BuffSize) || (needFlush && ((*pPos + len) > 0)))
        {
            pBuff = (0 == *pIndex) ? pBuff_first : pBuff_second;
            log_file_update(logType_curr, pBuff, *pPos);  //将log存储到文件中
            *pPos = 0;
            *pIndex = !(*pIndex);
        }

        pBuff = (0 == *pIndex) ? pBuff_first : pBuff_second;
        memcpy(&pBuff[*pPos], log, len);
        *pPos += len;
    }
    return true;
}