uart_debugger.h

Go to the documentation of this file.

#pragma once
#include "esphome/core/defines.h"
#ifdef USE_UART_DEBUGGER
 
#include <vector>
#include "esphome/core/component.h"
#include "esphome/core/automation.h"
#include "esphome/core/string_ref.h"
#include "uart.h"
#include "uart_component.h"
 
namespace esphome::uart {
 
class UARTDebugger : public Component, public Trigger<UARTDirection, std::vector<uint8_t>, StringRef> {
 public:
  explicit UARTDebugger(UARTComponent *parent);
  void loop() override;
 
  void set_direction(UARTDirection direction) { this->for_direction_ = direction; }
 
  void set_after_bytes(size_t size) { this->after_bytes_ = size; }
 
  void set_after_timeout(uint32_t timeout) { this->after_timeout_ = timeout; }
 
  void add_delimiter_byte(uint8_t byte) { this->after_delimiter_.push_back(byte); }
 
  void set_debug_prefix(const char *prefix) { this->debug_prefix_ = StringRef(prefix); }
 
 protected:
  UARTDirection for_direction_;
  UARTDirection last_direction_{};
  std::vector<uint8_t> bytes_{};
  size_t after_bytes_;
  uint32_t after_timeout_;
  uint32_t last_time_{};
  std::vector<uint8_t> after_delimiter_{};
  size_t after_delimiter_pos_{};
  bool is_triggering_{false};
  StringRef debug_prefix_{};
 
  bool is_my_direction_(UARTDirection direction);
  bool is_recursive_();
  void store_byte_(UARTDirection direction, uint8_t byte);
  void trigger_after_direction_change_(UARTDirection direction);
  void trigger_after_delimiter_(uint8_t byte);
  void trigger_after_bytes_();
  void trigger_after_timeout_();
  bool has_buffered_bytes_();
  void fire_trigger_();
};
 
class UARTDummyReceiver : public Component, public UARTDevice {
 public:
  UARTDummyReceiver(UARTComponent *parent) : UARTDevice(parent) {}
  void loop() override;
};
 
class UARTDebug {
 public:
  static void log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator,
                      StringRef prefix = StringRef());
 
  static void log_string(UARTDirection direction, std::vector<uint8_t> bytes, StringRef prefix = StringRef());
 
  static void log_int(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator,
                      StringRef prefix = StringRef());
 
  static void log_binary(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator,
                         StringRef prefix = StringRef());
};
 
}  // namespace esphome::uart
#endif