stm32components/sysmgr/sys_mgr.cpp

#include "sys_mgr.hpp"

#include <stdlib.h>

using namespace iflytop;

#define TAG "SysMgr"

extern "C" {

/***********************************************************************************************************************
 *                                                  STM32_CODE_ERROR                                                   *
 ***********************************************************************************************************************/
void SysMgr_on_Error_Handler() {
  ZLOGE(TAG, "Error_Handler\n");
  while (1) {
  }
}

void SysMgr_on_assert_failed(uint8_t* file, uint32_t line) {
  ZLOGE(TAG, "ASSERT: %s  [%s:%d]\n", file, line);
  while (1) {
  }
}
extern uint8_t  _end;            /* Symbol defined in the linker script */
extern uint8_t  _estack;         /* Symbol defined in the linker script */
extern uint32_t _Min_Stack_Size; /* Symbol defined in the linker script */
extern uint8_t* __sbrk_heap_end;

static size_t get_free_heap_size() {
  const uint32_t stack_limit = (uint32_t)&_estack - (uint32_t)&_Min_Stack_Size;
  const uint8_t* max_heap    = (uint8_t*)stack_limit;
  uint8_t*       prev_heap_end;
  return max_heap - __sbrk_heap_end;
  // if (__sbrk_heap_end + incr > max_heap) {
  //   errno = ENOMEM;
  //   return (void*)-1;
  // }
}

/***********************************************************************************************************************
 *                                                   STM32_ERROR_IRQ                                                   *
 ***********************************************************************************************************************/
// void SysMgr_on_NMI_Handler(void) { ZLOGI(TAG, "on NMI_Handler"); }
// void SysMgr_on_HardFault_Handler(void) { ZLOGI(TAG, "on HardFault_Handler"); }
// void SysMgr_on_MemManage_Handler(void) { ZLOGI(TAG, "on MemManage_Handler"); }
// void SysMgr_on_BusFault_Handler(void) { ZLOGI(TAG, "on BusFault_Handler"); }
// void SysMgr_on_UsageFault_Handler(void) { ZLOGI(TAG, "on UsageFault_Handler"); }

void NMI_Handler(void) {
  printf("E:%s\n", __FUNCTION__);
  NVIC_SystemReset();
}
void HardFault_Handler(void) {
  printf("E:%s\n", __FUNCTION__);
  NVIC_SystemReset();
}

void MemManage_Handler(void) {
  printf("E:%s\n", __FUNCTION__);
  NVIC_SystemReset();
}

void BusFault_Handler(void) {
  printf("E:%s\n", __FUNCTION__);
  NVIC_SystemReset();
}
void UsageFault_Handler(void) {
  printf("E:%s\n", __FUNCTION__);
  NVIC_SystemReset();
}
void DebugMon_Handler(void) {}

static void PVD_Init(void) {
  PWR_PVDTypeDef PvdStruct;

  HAL_PWR_EnablePVD();

  PvdStruct.PVDLevel = PWR_PVDLEVEL_6; /* set PVD thr to 3.1v */
  PvdStruct.Mode     = PWR_PVD_MODE_IT_RISING;
  HAL_PWR_ConfigPVD(&PvdStruct);

  /* enable lost power irq */
  HAL_NVIC_SetPriority(PVD_IRQn, 0, 0); /*  */
  HAL_NVIC_EnableIRQ(PVD_IRQn);         /*  */
}

void PVD_IRQHandler(void) {
  if (__HAL_PWR_GET_FLAG(PWR_FLAG_PVDO)) /* 1为VDD小于PVD阈值,掉电情况 */
  {
    /* 掉电前的紧急处理 */
    printf("low power detect......\n");
    for (size_t i = 0; i < 1000; i++) {
      // wait for lost power
      printf("low power detect......\n");
    }
    NVIC_SystemReset();
  }
}

/***********************************************************************************************************************
 *                                                   FREERTOS_ERROR                                                    *
 ***********************************************************************************************************************/
void vApplicationStackOverflowHook(xTaskHandle xTask, signed char* pcTaskName) {
  ZLOGE(TAG, "StackOverflowHook: %s\n", pcTaskName);
  __disable_irq();
  while (1) {
  }
}
void vApplicationMallocFailedHook(void) {
  ZLOGE(TAG, "MallocFailedHook\n");
  __disable_irq();

  while (1) {
  }
}
}
SysMgr* SysMgr::ins() {
  static SysMgr s_ins;
  return &s_ins;
}
// void SysMgr::regTaskId(osThreadId id) {
//   m_task[m_ntask].Id = id;
//   m_ntask++;
// }
size_t      SysMgr::osGetSysRunTime() { return HAL_GetTick(); }
UBaseType_t uxTaskGetSystemState(TaskStatus_t* const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t* const pulTotalRunTime);

void SysMgr::checkRst(void) {
  if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) {  // NRST 引脚复位
    printf("RESET_REASON: PIN reset \n");
    m_reset_reason = kreset_reason_pinrst;
  } else if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) {  // 上电掉电复位
    printf("RESET_REASON: POR/PDR reset \n");
    m_reset_reason = kreset_reason_porrst;
  } else if (__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST) != RESET) {  //  软件复位
    printf("RESET_REASON: Software reset  \n");
    m_reset_reason = kreset_reason_sftrst;
  } else if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET) {  // 独立看门狗复位
    printf("RESET_REASON: Independent watchdog reset \n");
    m_reset_reason = kreset_reason_iwdgrst;
  } else if (__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST) != RESET) {  // 窗口看门狗复位
    printf("RESET_REASON: Window watchdog reset \n");
    m_reset_reason = kreset_reason_wwdgrst;
  } else if (__HAL_RCC_GET_FLAG(RCC_FLAG_LPWRRST) != RESET) {  // 低功耗复位
    printf("RESET_REASON: (Low-power reset \n");
    m_reset_reason = kreset_reason_lpwrrst;
  } else {
    printf("RESET_REASON: Unkown reset \n");
    m_reset_reason = kreset_reason_unkown;
  }
  __HAL_RCC_CLEAR_RESET_FLAGS();  // 清除复位标志
}

void SysMgr::initedFinished() {  //
  static TaskStatus_t pxTaskStatusArray[SDK_MAX_TASK + 1];
  UBaseType_t         uxArraySize = SDK_MAX_TASK + 1;
  uint32_t            pulTotalRunTime;
  m_ntask = uxTaskGetSystemState(pxTaskStatusArray, uxArraySize, &pulTotalRunTime);
  for (int i = 0; i < m_ntask; i++) {
    m_task[i].Id = pxTaskStatusArray[i].xHandle;
  }
  ZASSERT_INFO(m_ntask < SDK_MAX_TASK, "task num is too large, please increase SDK_MAX_TASK");

  PVD_Init();
  checkRst();
}

size_t SysMgr::osGetMinimumEverFreeHeapSize() { return ::xPortGetMinimumEverFreeHeapSize(); }
size_t SysMgr::osGetFreeHeapSize() { return ::xPortGetFreeHeapSize(); }
size_t SysMgr::osGetTotalHeapSize() { return configTOTAL_HEAP_SIZE; }
size_t SysMgr::osGetFreeSysHeapSize() { return get_free_heap_size(); }

int32_t SysMgr::getTaskNum() { return m_ntask; }

void SysMgr::dumpSysInfo() {
  zlog("---------------Heap Info--------------\n");
  zlog("MinimumEverFreeHeapSize     : %d\n", osGetMinimumEverFreeHeapSize());
  zlog("RTOS FreeHeapSize           : %d\n", osGetFreeHeapSize());
  zlog("RTOS TotalHeapSize          : %d\n", osGetTotalHeapSize());
  zlog("Sys FreeHeap                : %d\n", get_free_heap_size());
  zlog("");

  zlog("---------------Task Info--------------\n");
  static char buf[40 * SDK_MAX_TASK];  // 40一个任务，最多支持10个任务
  vTaskList(buf);
  zlog("Name        State  Priority  Stack  Num\n");
  zlog_raw(buf);
  zlog("- TaskInfoEnd -\n");
}

uint32_t    SysMgr::osTaskStackRemainingSize(osThreadId id) { return uxTaskGetStackHighWaterMark(id); }
const char* SysMgr::osTaskName(osThreadId id) { return pcTaskGetName(id); }

osThreadId SysMgr::osGetId(int offset) {
  if (offset < m_ntask) {
    return m_task[offset].Id;
  }
  return NULL;
}

void SysMgr::osTaskName(osThreadId id, char* name, int bufsize) {
  strncpy(name, pcTaskGetName(id), bufsize);
  name[bufsize - 1] = 0;
}
void SysMgr::osTaskStackRemainingSize(osThreadId id, uint16_t* remainsize) { *remainsize = uxTaskGetStackHighWaterMark(id); }
void SysMgr::osTaskPriority(osThreadId id, uint16_t* priority) { *priority = uxTaskPriorityGet(id); }
void SysMgr::osTaskGetState(osThreadId id, char* state) {
  eTaskState task_state = eTaskGetState(id);
  switch (task_state) {
    case eRunning:
      *state = 'X';
      break;
    case eReady:
      *state = 'R';
      break;
    case eBlocked:
      *state = 'B';
      break;
    case eSuspended:
      *state = 'S';
      break;
    case eDeleted:
      *state = 'D';
      break;
    default:
      *state = '?';
      break;
  }
}