logger.h

Go to the documentation of this file.

#pragma once
#ifndef __DSY_LOGGER_H__
#define __DSY_LOGGER_H__
 
#include <cmath>
#include <cstdarg>
#include <cstdio>
#include <type_traits>
#include "logger_impl.h"
 
namespace daisy
{
#define LOGGER_NEWLINE "\r\n" 
#define LOGGER_BUFFER 128     
#define PPCAT_NX(A, B) A##B          
#define PPCAT(A, B) PPCAT_NX(A, B)   
#define STRINGIZE_NX(A) #A           
#define STRINGIZE(A) STRINGIZE_NX(A) 
// clang-format off
#define FLT_FMT(_n) STRINGIZE(PPCAT(PPCAT(%c%d.%0, _n), d))
// clang-format on
 
#define FLT_VAR(_n, _x)                   \
    (_x < 0 ? '-' : ' '), (int)(abs(_x)), \
        (int)(((abs(_x)) - (int)(abs(_x))) * pow(10, (_n)))
 
#define FLT_FMT3 FLT_FMT(3)
#define FLT_VAR3(_x) FLT_VAR(3, _x)
 
 // End logging_macros
 
template <LoggerDestination dest = LOGGER_INTERNAL>
class Logger
{
  public:
    Logger() {}
 
    static void Print(const char* format, ...);
 
    static void PrintLine(const char* format, ...);
 
    static void StartLog(bool wait_for_pc = false);
 
    static void PrintV(const char* format, va_list va);
 
    static void PrintLineV(const char* format, va_list va);
 
    template <LoggerDestination D = dest>
    static std::enable_if_t<D == LOGGER_UART>
    Configure(const LoggerImpl<LOGGER_UART>::Config cfg)
    {
        impl_.Configure(cfg);
    }
 
 
  protected:
    enum LoggerConsts
    {
        LOGGER_SYNC_OUT = 0,
        LOGGER_SYNC_IN  = 2 
    };
 
    static void TransmitSync(const void* buffer, size_t bytes)
    {
        while(false == impl_.Transmit(buffer, bytes)) {}
    }
 
    static void TransmitBuf();
 
    static void AppendNewLine();
 
    static constexpr size_t NewLineSeqLength()
    {
        size_t                len = 0;
        constexpr const char* nl  = LOGGER_NEWLINE;
        while(nl[len] != '\0')
        {
            len++;
        }
        return len;
    }
 
    static char             tx_buff_[LOGGER_BUFFER]; 
    static size_t           tx_ptr_;  
    static size_t           pc_sync_; 
    static LoggerImpl<dest> impl_;    
};
 
template <LoggerDestination dest>
char Logger<dest>::tx_buff_[LOGGER_BUFFER];
 
template <LoggerDestination dest>
size_t Logger<dest>::pc_sync_ = LOGGER_SYNC_OUT;
 
template <LoggerDestination dest>
size_t Logger<dest>::tx_ptr_ = 0;
 
template <LoggerDestination dest>
LoggerImpl<dest> Logger<dest>::impl_;
 
 // end logger_statics
 
template <>
class Logger<LOGGER_NONE>
{
  public:
    Logger() {}                                               
    static void Print(const char* format, ...) {}             
    static void PrintLine(const char* format, ...) {}         
    static void StartLog(bool wait_for_pc = false) {}         
    static void PrintV(const char* format, va_list va) {}     
    static void PrintLineV(const char* format, va_list va) {} 
};
 
} // namespace daisy
 
#endif // __DSY_LOGGER_H__