debug.h

Go to the documentation of this file.

 
#pragma once
 
#include <Arduino.h>
 
#if defined(NATIVE_TEST)
// Native test environment: print to stdout via stringstream
#include <iostream>
#include <sstream>
#include <string>
 
class String {
private:
  std::string data;
 
public:
  String() : data() {}
  String(const char *str) : data(str ? str : "") {}
  String(const std::string &str) : data(str) {}
  String(char c) : data(1, c) {}
  String(int n, int base = 10);
  String(unsigned int n, int base = 10);
  String(long n, int base = 10);
  String(unsigned long n, int base = 10);
 
  const char *c_str() const { return data.c_str(); }
  size_t length() const { return data.length(); }
  operator const char *() const { return c_str(); }
 
  String &operator=(const char *str) {
    data = str ? str : "";
    return *this;
  }
  String &operator=(const std::string &str) {
    data = str;
    return *this;
  }
};
 
class __FlashStringHelper;
#define F(string_literal)                                                      \
  (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
#define PSTR(s) (s)
 
namespace DebugSerial {
// Define print base constants if not already defined
#ifndef DEC
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
#endif
 
class NativeSerial {
private:
  size_t printNumber(unsigned long long n, int base);
  size_t printFloat(double number, int digits);
 
public:
  void begin(unsigned long baud = 0);
  size_t write(uint8_t c);
  size_t write(const uint8_t *buffer, size_t size);
  void flush();
 
  // Print overloads matching Print.h interface
  size_t print(const __FlashStringHelper *);
  size_t print(const String &s);
  size_t print(const std::string &s);
  size_t print(const char str[]);
  size_t print(char c);
  size_t print(unsigned char n, int base = DEC);
  size_t print(int n, int base = DEC);
  size_t print(unsigned int n, int base = DEC);
  size_t print(long n, int base = DEC);
  size_t print(unsigned long n, int base = DEC);
  size_t print(long long n, int base = DEC);
  size_t print(unsigned long long n, int base = DEC);
  size_t print(double n, int digits = 2);
 
  // Println overloads matching Print.h interface
  size_t println(const __FlashStringHelper *);
  size_t println(const String &s);
  size_t println(const std::string &s);
  size_t println(const char c[]);
  size_t println(char c);
  size_t println(unsigned char n, int base = DEC);
  size_t println(int n, int base = DEC);
  size_t println(unsigned int n, int base = DEC);
  size_t println(long n, int base = DEC);
  size_t println(unsigned long n, int base = DEC);
  size_t println(long long n, int base = DEC);
  size_t println(unsigned long long n, int base = DEC);
  size_t println(double n, int digits = 2);
  size_t println(void);
};
extern NativeSerial instance;
} // namespace DebugSerial
 
#ifdef SERIAL_PORT
#undef SERIAL_PORT
#endif /* SERIAL_PORT */
#define SERIAL_PORT DebugSerial::instance
 
#elif defined(_DEBUG_)
#ifdef SERIAL_PORT
#undef SERIAL_PORT
#endif /* SERIAL_PORT */
// Hardware environment: use SerialRTT
#include "SerialRTT.h"
#define SERIAL_PORT SerialRTT
#else
#ifndef SERIAL_PORT
// Default to Serial
#define SERIAL_PORT Serial
#endif /*SERIAL_PORT*/
#endif /*NATIVE_TEST*/
 
#define LOG_ERROR 1
#define LOG_WARN 2
#define LOG_INFO 3
#define LOG_DEBUG 4
 
#ifndef LOG_LEVEL
#define LOG_LEVEL LOG_INFO
#endif
 
    // Logging macros - controlled by consuming project
#if defined(_DEBUG_) || defined(NATIVE_TEST)
    // Hardware or native test: use SERIAL_PORT (SerialRTT or NativeSerial)
    // Supports multiple arguments: _PL(value) or _PL(value, HEX) or _PL(value,
    // BIN)
#define LOG_PRINT(level, ...)                                              \
      if (level <= LOG_LEVEL)                                                  \
        SERIAL_PORT.print(__VA_ARGS__);
#define LOG_PRINTLN(level, ...)                                            \
      if (level <= LOG_LEVEL)                                                  \
        SERIAL_PORT.println(__VA_ARGS__);
#else
// _DEBUG_ and NATIVE_TEST not defined: no logging
#define LOG_PRINT(level, ...)
#define LOG_PRINTLN(level, ...)
#endif
 
#define _PPE(...) LOG_PRINT(LOG_ERROR, __VA_ARGS__)
#define _PPW(...) LOG_PRINT(LOG_WARN, __VA_ARGS__)
#define _PP(...) LOG_PRINT(LOG_INFO, __VA_ARGS__)
#define _PPD(...) LOG_PRINT(LOG_DEBUG, __VA_ARGS__)
#define _PLE(...) LOG_PRINTLN(LOG_ERROR, __VA_ARGS__)
#define _PLW(...) LOG_PRINTLN(LOG_WARN, __VA_ARGS__)
#define _PL(...) LOG_PRINTLN(LOG_INFO, __VA_ARGS__)
#define _PLD(...) LOG_PRINTLN(LOG_DEBUG, __VA_ARGS__)