BaseUart.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <cstdint>
#include <cstring>
#include <string_view>
 
//--------------------------------------
//  HardFOC UART Error Codes (Table)
//--------------------------------------
#define HF_UART_ERR_LIST(X)                                                                        \
  /* Success codes */                                                                              \
  X(UART_SUCCESS, 0, "Success")                                                                    \
  /* General errors */                                                                             \
  X(UART_ERR_FAILURE, 1, "General failure")                                                        \
  X(UART_ERR_NOT_INITIALIZED, 2, "Not initialized")                                                \
  X(UART_ERR_ALREADY_INITIALIZED, 3, "Already initialized")                                        \
  X(UART_ERR_INVALID_PARAMETER, 4, "Invalid parameter")                                            \
  X(UART_ERR_NULL_POINTER, 5, "Null pointer")                                                      \
  X(UART_ERR_OUT_OF_MEMORY, 6, "Out of memory")                                                    \
  /* Communication errors */                                                                       \
  X(UART_ERR_TIMEOUT, 7, "Operation timeout")                                                      \
  X(UART_ERR_BUFFER_FULL, 8, "Buffer full")                                                        \
  X(UART_ERR_BUFFER_EMPTY, 9, "Buffer empty")                                                      \
  X(UART_ERR_TRANSMISSION_FAILED, 10, "Transmission failed")                                       \
  X(UART_ERR_RECEPTION_FAILED, 11, "Reception failed")                                             \
  /* Frame errors */                                                                               \
  X(UART_ERR_FRAME_ERROR, 12, "Frame error")                                                       \
  X(UART_ERR_PARITY_ERROR, 13, "Parity error")                                                     \
  X(UART_ERR_OVERRUN_ERROR, 14, "Overrun error")                                                   \
  X(UART_ERR_NOISE_ERROR, 15, "Noise error")                                                       \
  X(UART_ERR_BREAK_DETECTED, 16, "Break condition detected")                                       \
  /* Hardware errors */                                                                            \
  X(UART_ERR_HARDWARE_FAULT, 17, "Hardware fault")                                                 \
  X(UART_ERR_COMMUNICATION_FAILURE, 18, "Communication failure")                                   \
  X(UART_ERR_DEVICE_NOT_RESPONDING, 19, "Device not responding")                                   \
  X(UART_ERR_VOLTAGE_OUT_OF_RANGE, 20, "Voltage out of range")                                     \
  /* Configuration errors */                                                                       \
  X(UART_ERR_INVALID_CONFIGURATION, 21, "Invalid configuration")                                   \
  X(UART_ERR_UNSUPPORTED_OPERATION, 22, "Unsupported operation")                                   \
  X(UART_ERR_INVALID_BAUD_RATE, 23, "Invalid baud rate")                                           \
  X(UART_ERR_INVALID_DATA_BITS, 24, "Invalid data bits")                                           \
  X(UART_ERR_INVALID_PARITY, 25, "Invalid parity")                                                 \
  X(UART_ERR_INVALID_STOP_BITS, 26, "Invalid stop bits")                                           \
  X(UART_ERR_PIN_CONFIGURATION_ERROR, 27, "Pin configuration error")                               \
  X(UART_ERR_FLOW_CONTROL_ERROR, 28, "Flow control error")                                         \
  /* System errors */                                                                              \
  X(UART_ERR_SYSTEM_ERROR, 29, "System error")                                                     \
  X(UART_ERR_PERMISSION_DENIED, 30, "Permission denied")                                           \
  X(UART_ERR_OPERATION_ABORTED, 31, "Operation aborted")                                           \
  X(UART_ERR_UNKNOWN, 32, "Unknown error")
 
enum class hf_uart_err_t : hf_u8_t {
#define X(NAME, VALUE, DESC) NAME = VALUE,
  HF_UART_ERR_LIST(X)
#undef X
};
 
constexpr std::string_view HfUartErrToString(hf_uart_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case hf_uart_err_t::NAME:                                                                        \
    return DESC;
    HF_UART_ERR_LIST(X)
#undef X
  default:
    return HfUartErrToString(hf_uart_err_t::UART_ERR_UNKNOWN);
  }
}
 
//--------------------------------------
//  UART Configuration Structure
//--------------------------------------
 
struct hf_uart_statistics_t {
  hf_u32_t tx_byte_count;            
  hf_u32_t rx_byte_count;            
  hf_u32_t tx_error_count;           
  hf_u32_t rx_error_count;           
  hf_u32_t frame_error_count;        
  hf_u32_t parity_error_count;       
  hf_u32_t overrun_error_count;      
  hf_u32_t noise_error_count;        
  hf_u32_t break_count;              
  hf_u32_t timeout_count;            
  hf_u32_t pattern_detect_count;     
  hf_u32_t wakeup_count;             
  hf_u64_t last_activity_timestamp;  
  hf_u64_t initialization_timestamp; 
 
  hf_uart_statistics_t() noexcept
      : tx_byte_count(0), rx_byte_count(0), tx_error_count(0), rx_error_count(0),
        frame_error_count(0), parity_error_count(0), overrun_error_count(0), noise_error_count(0),
        break_count(0), timeout_count(0), pattern_detect_count(0), wakeup_count(0),
        last_activity_timestamp(0), initialization_timestamp(0) {}
};
 
struct hf_uart_diagnostics_t {
  hf_uart_err_t last_error;      
  hf_u32_t consecutive_errors;   
  hf_u32_t error_reset_count;    
  hf_u64_t last_error_timestamp; 
  bool is_initialized;           
  bool is_transmitting;          
  bool is_receiving;             
  bool flow_control_active;      
  bool pattern_detection_active; 
  bool wakeup_enabled;           
  hf_u32_t tx_buffer_usage;      
  hf_u32_t rx_buffer_usage;      
  hf_u32_t event_queue_usage;    
 
  hf_uart_diagnostics_t() noexcept
      : last_error(hf_uart_err_t::UART_SUCCESS), consecutive_errors(0), error_reset_count(0),
        last_error_timestamp(0), is_initialized(false), is_transmitting(false), is_receiving(false),
        flow_control_active(false), pattern_detection_active(false), wakeup_enabled(false),
        tx_buffer_usage(0), rx_buffer_usage(0), event_queue_usage(0) {}
};
 
//--------------------------------------
//  Abstract Base Class
//--------------------------------------
 
class BaseUart {
public:
  virtual ~BaseUart() noexcept = default;
 
  // Non-copyable, non-movable (can be changed in derived classes if needed)
  BaseUart(const BaseUart&) = delete;
  BaseUart& operator=(const BaseUart&) = delete;
  BaseUart(BaseUart&&) = delete;
  BaseUart& operator=(BaseUart&&) = delete;
 
  bool EnsureInitialized() noexcept {
    if (!initialized_) {
      initialized_ = Initialize();
    }
    return initialized_;
  }
 
  bool EnsureDeinitialized() noexcept {
    if (initialized_) {
      initialized_ = !Deinitialize();
    }
    return !initialized_;
  }
 
  [[nodiscard]] bool IsInitialized() const noexcept {
    return initialized_;
  }
 
  [[nodiscard]] hf_port_num_t GetPort() const noexcept {
    return port_;
  }
 
  //==============================================//
  // PURE VIRTUAL FUNCTIONS - MUST BE OVERRIDDEN  //
  //==============================================//
 
  virtual bool Initialize() noexcept = 0;
 
  virtual bool Deinitialize() noexcept = 0;
 
  virtual hf_uart_err_t Write(const hf_u8_t* data, hf_u16_t length,
                              hf_u32_t timeout_ms = 0) noexcept = 0;
 
  virtual hf_uart_err_t Read(hf_u8_t* data, hf_u16_t length, hf_u32_t timeout_ms = 0) noexcept = 0;
 
  virtual hf_u16_t BytesAvailable() noexcept = 0;
 
  virtual hf_uart_err_t FlushTx() noexcept = 0;
 
  virtual hf_uart_err_t FlushRx() noexcept = 0;
 
  virtual int Printf(const char* format, ...) noexcept = 0;
 
  //==============================================//
  // CONVENIENCE METHODS WITH DEFAULT IMPLEMENTATIONS
  //==============================================//
 
  virtual bool Open() noexcept {
    return Initialize();
  }
 
  virtual bool Close() noexcept {
    return Deinitialize();
  }
 
  // Removed duplicate Write method to avoid overload conflicts
 
  // Removed duplicate Read method to avoid overload conflicts
 
  virtual bool WriteString(const char* str) noexcept {
    if (!str)
      return false;
    return Write(reinterpret_cast<const hf_u8_t*>(str), static_cast<hf_u16_t>(strlen(str))) ==
           hf_uart_err_t::UART_SUCCESS;
  }
 
  virtual bool WriteByte(hf_u8_t byte) noexcept {
    return Write(&byte, 1) == hf_uart_err_t::UART_SUCCESS;
  }
 
  // Removed duplicate FlushTx and FlushRx methods to avoid overload conflicts
 
  //==============================================//
  // STATISTICS AND DIAGNOSTICS
  //==============================================//
 
  virtual hf_uart_err_t ResetStatistics() noexcept {
    statistics_ = hf_uart_statistics_t{}; // Reset statistics to default values
    return hf_uart_err_t::UART_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_uart_err_t ResetDiagnostics() noexcept {
    diagnostics_ = hf_uart_diagnostics_t{}; // Reset diagnostics to default values
    return hf_uart_err_t::UART_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_uart_err_t GetStatistics(hf_uart_statistics_t& statistics) const noexcept {
    statistics = statistics_; // Return statistics by default
    return hf_uart_err_t::UART_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_uart_err_t GetDiagnostics(hf_uart_diagnostics_t& diagnostics) const noexcept {
    diagnostics = diagnostics_; // Return diagnostics by default
    return hf_uart_err_t::UART_ERR_UNSUPPORTED_OPERATION;
  }
 
protected:
  BaseUart(hf_port_num_t port) noexcept
      : port_(port), initialized_(false), statistics_{}, diagnostics_{} {}
 
  hf_port_num_t port_;                
  bool initialized_;                  
  hf_uart_statistics_t statistics_;   
  hf_uart_diagnostics_t diagnostics_; 
};