HandlerCommon.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdarg>
#include <cstdint>
#include <cstdio>
 
#include "Logger.h"
 
#if defined(ESP_PLATFORM)
#include "esp_rom_sys.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#elif defined(HF_RTOS_FREERTOS)
#include "OsUtility.h"
#elif defined(USE_HAL_DRIVER)
extern "C" void HAL_Delay(uint32_t Delay);
#elif defined(HF_RTOS_THREADX) || defined(HF_RTOS_NONE)
#include "OsUtility.h"
#endif
 
namespace handler_utils {
 
inline void RouteLogToLogger(int level, const char* tag,
                             const char* format, va_list args) noexcept {
    char buf[256];
    vsnprintf(buf, sizeof(buf), format, args);
    auto& log = Logger::GetInstance();
    switch (level) {
        case 0: log.Error(tag, "%s", buf); break;
        case 1: log.Warn(tag, "%s", buf);  break;
        case 2: log.Info(tag, "%s", buf);  break;
        default: log.Debug(tag, "%s", buf); break;
    }
}
 
inline void DelayMs(uint32_t ms) noexcept {
#if defined(ESP_PLATFORM)
    if (ms == 0U) {
        return;
    }
    TickType_t ticks = pdMS_TO_TICKS(ms);
    if (ticks == 0U) {
        ticks = 1U;
    }
    vTaskDelay(ticks);
#elif defined(HF_RTOS_FREERTOS) || (!defined(USE_HAL_DRIVER) && (defined(HF_RTOS_THREADX) || defined(HF_RTOS_NONE)))
    while (ms > 0U) {
        const uint16_t chunk =
            (ms > 60000U) ? static_cast<uint16_t>(60000U)
                          : static_cast<uint16_t>(ms);
        os_delay_msec(chunk);
        ms -= chunk;
    }
#elif defined(USE_HAL_DRIVER)
    HAL_Delay(ms);
#else
    /* Last-resort busy-wait (~1 ms @ ~200 MHz Cortex-M). Prefer RTOS/HAL. */
    for (uint32_t m = 0; m < ms; ++m) {
        for (uint32_t spin = 40000U; spin > 0U; --spin) {
            __asm__ volatile("" ::: "memory");
        }
    }
#endif
}
 
inline void DelayUs(uint32_t us) noexcept {
    if (us >= 1000U) {
        DelayMs((us + 999U) / 1000U);
        return;
    }
#if defined(ESP_PLATFORM)
    esp_rom_delay_us(us);
#else
    /* ~1 µs/iteration @ Cortex-M ~200–240 MHz. */
    for (uint32_t i = 0; i < us; ++i) {
        for (uint32_t spin = 40U; spin > 0U; --spin) {
            __asm__ volatile("" ::: "memory");
        }
    }
#endif
}
 
} // namespace handler_utils