File logger.h

File List > external-docs > libDaisy > src > hid > logger.h

Go to the documentation of this file

Source Code

#pragma once
#ifndef __DSY_LOGGER_H__
#define __DSY_LOGGER_H__

#include <cmath>
#include <cstdarg>
#include <cstdio>
#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)


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);

  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_;


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__