tmc9660_comm_interface.hpp

Go to the documentation of this file.

 
#pragma once
#include <array>
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <span>
#include <string>
 
namespace tmc9660 {
 
#ifndef TMC9660_DISABLE_DEBUG_LOGGING
// Debug logging enabled - use actual function call
#define TMC9660_LOG_DEBUG(comm_obj, level, tag, ...) (comm_obj).logDebug(level, tag, __VA_ARGS__)
#else
// Debug logging disabled - optimize out completely (arguments not evaluated)
#define TMC9660_LOG_DEBUG(comm_obj, level, tag, ...) ((void)0)
#endif
 
enum class CommMode {
  SPI, 
  UART 
};
 
enum class TMC9660CtrlPin {
  RST,    
  DRV_EN, 
  FAULTN, 
  WAKE    
};
 
enum class GpioSignal {
  INACTIVE = 0, 
  ACTIVE = 1    
};
 
enum class SPIStatus : uint8_t {
  OK = 0xFF,             
  CHECKSUM_ERROR = 0x00, 
  FIRST_CMD = 0x0C,      
  NOT_READY = 0xF0,      
};
 
static constexpr uint8_t tmclChecksum(const uint8_t* bytes, size_t n, uint8_t start = 0) noexcept {
  uint8_t sum = 0;
  for (size_t i = start; i < n; ++i)
    sum += bytes[i];
  return sum;
}
 
// -----------------------------------------------------------------------
// TMCL scripting support structures and enums
// -----------------------------------------------------------------------
 
struct TMCLReply {
  SPIStatus spi_status = SPIStatus::OK; 
  uint8_t status = 0;                  
  uint8_t opcode = 0;                  
  uint32_t value = 0;                  
 
  // ✅ NEW: Raw bytes for advanced parsing (handle protocol mismatches)
  std::array<uint8_t, 8> rawBytes =
      {}; 
 
  [[nodiscard]] bool isOK() const noexcept {
    return spi_status == SPIStatus::OK && (status == 100 || status == 101);
  }
 
  [[nodiscard]] uint32_t extractRawValue(size_t offset) const noexcept {
    if (offset + 3 >= rawBytes.size())
      return 0;
    return (static_cast<uint32_t>(rawBytes[offset]) << 24) |
           (static_cast<uint32_t>(rawBytes[offset + 1]) << 16) |
           (static_cast<uint32_t>(rawBytes[offset + 2]) << 8) |
           static_cast<uint32_t>(rawBytes[offset + 3]);
  }
 
  [[nodiscard]] std::string getVersionString() const noexcept {
    if (opcode != 136)
      return ""; // Not a GetVersion reply
 
    std::string version;
    // Extract version string from bytes 1-8 (skip host address at byte 0)
    for (size_t i = 1; i < 8; ++i) {
      if (rawBytes[i] >= 0x20 && rawBytes[i] <= 0x7E) { // Printable ASCII
        version += static_cast<char>(rawBytes[i]);
      } else {
        break; // Stop at first non-printable character
      }
    }
    return version;
  }
 
  static bool fromSpi(std::span<const uint8_t, 8> in, TMCLReply& r, uint8_t sent_opcode = 0,
                      uint16_t sent_type = 0) noexcept {
    // Store raw bytes for advanced parsing (ALWAYS, even if parsing fails)
    std::copy(in.begin(), in.end(), r.rawBytes.begin());
 
    // Check for SESSION_START status codes (bootloader or parameter mode)
    uint8_t raw_status = in[0];
    if (raw_status == 0x13) {
      // SESSION_START from bootloader (0x13)
      // These use different protocols, so TMCL checksum will fail
      // But we still want to return success so caller can use rawBytes
      r.spi_status = static_cast<SPIStatus>(raw_status);
      r.status = in[1];
      r.opcode = in[2];
      r.value = (static_cast<uint32_t>(in[3]) << 24) | (static_cast<uint32_t>(in[4]) << 16) |
                (static_cast<uint32_t>(in[5]) << 8) | static_cast<uint32_t>(in[6]);
      return true; // Allow SESSION_START even if checksum fails
    }
 
    // Check for GetVersion string format (Command 136, Type 0)
    // GetVersion with Type=0 returns a special string format without checksum
    // Format: [Host Address][Version String 8 chars]
    if (sent_opcode == 136 && sent_type == 0) {
      // We sent GetVersion Type=0, expect string format reply (no checksum validation)
      r.spi_status = SPIStatus::OK; // Assume OK for version string
      r.status = 100;              // REPLY_OK for successful version retrieval
      r.opcode = 136;              // GetVersion command
      r.value = 0;                 // No value field for string format
      return true;                 // Success - skip checksum validation for string format
    }
 
    // Standard TMCL reply validation
    if (tmclChecksum(in.data(), 7) != in[7])
      return false;
    r.spi_status = static_cast<SPIStatus>(in[0]);
    if (r.spi_status == SPIStatus::NOT_READY || r.spi_status == SPIStatus::CHECKSUM_ERROR)
      return false;
    r.status = in[1];
    r.opcode = in[2];
    r.value = (static_cast<uint32_t>(in[3]) << 24) | (static_cast<uint32_t>(in[4]) << 16) |
              (static_cast<uint32_t>(in[5]) << 8) | static_cast<uint32_t>(in[6]);
    return true;
  }
 
  static bool fromUart(std::span<const uint8_t, 9> in, uint8_t addr, TMCLReply& r,
                       uint8_t sent_opcode = 0, uint16_t sent_type = 0) noexcept {
    // Store raw bytes (map 9-byte UART to 8-byte format, skip first byte)
    std::copy(in.begin() + 1, in.end(), r.rawBytes.begin());
 
    // UART Reply Format (per datasheet):
    // byte0: Host Address (8 bits)
    // byte1: Sync bit (bit 0) + Module Address (bits 1-7)
    // byte2: TMCL Status
    // byte3: Operation
    // byte4-7: Data (big-endian)
    // byte8: Checksum
 
    // Check for GetVersion string format (Command 136, Type 0)
    // GetVersion with Type=0 returns a special string format without valid checksum
    // Format: [Host Address][Sync+Address][Version String 7 chars]
    if (sent_opcode == 136 && sent_type == 0) {
      // We sent GetVersion Type=0, expect string format reply (no checksum validation)
      r.spi_status = SPIStatus::OK; // Assume OK for version string
      r.status = 100;              // REPLY_OK for successful version retrieval
      r.opcode = 136;              // GetVersion command
      r.value = 0;                 // No value field for string format
      return true;                 // Success - skip checksum validation for string format
    }
 
    // Verify module address in byte 1 (bits 1-7)
    // "The module address reuses the upper 7 bits of the bootloader device address"
    // Compare the upper 7 bits of byte 1 with the upper 7 bits of the address
    if ((in[1] & 0xFE) != (addr & 0xFE))
      return false;
 
    // Verify checksum over first 8 bytes
    if (tmclChecksum(in.data(), 8) != in[8])
      return false;
 
    r.spi_status = SPIStatus::OK; // UART has no SPI status field
    r.status = in[2];            // TMCL Status at byte 2
    r.opcode = in[3];            // Operation at byte 3
    r.value = (static_cast<uint32_t>(in[4]) << 24) | (static_cast<uint32_t>(in[5]) << 16) |
              (static_cast<uint32_t>(in[6]) << 8) | static_cast<uint32_t>(in[7]);
    return true;
  }
};
 
struct TMCLFrame {
  uint8_t opcode = 0; 
  uint16_t type = 0;  
  uint8_t motor = 0;  
  uint32_t value = 0; 
 
  void toSpi(std::span<uint8_t, 8> out) const noexcept {
    out[0] = opcode;
    out[1] = static_cast<uint8_t>(type & 0xFF); // Type lower 8 bits (bits 0-7)
    // BYTE2: bits 20-23 (high nibble) = Motor/Bank, bits 16-19 (upper nibble) = Type upper 4 bits
    out[2] = static_cast<uint8_t>(((motor & 0x0F) << 4) | ((type & 0xF00) >> 8));
    out[3] = static_cast<uint8_t>(value >> 24);
    out[4] = static_cast<uint8_t>(value >> 16);
    out[5] = static_cast<uint8_t>(value >> 8);
    out[6] = static_cast<uint8_t>(value);
    out[7] = tmclChecksum(out.data(), 7);
  }
 
  void toUart(uint8_t addr, std::span<uint8_t, 9> out) const noexcept {
    // Byte 0: [Sync bit (bit 0)] [Module Address (bits 1-7)]
    // "The module address reuses the upper 7 bits of the bootloader device address"
    // This means we take bits 7-1 of the address and place them in bits 7-1 of byte 0
    // Then set bit 0 (sync bit) to 1
    out[0] = (addr & 0xFE) | 0x01; // Keep upper 7 bits of address, set sync bit
    out[1] = opcode;
    out[2] = static_cast<uint8_t>(type & 0xFF);  // Type field (8 bits)
    out[3] = static_cast<uint8_t>(motor & 0x0F); // Motor/Bank field (4 bits)
    out[4] = static_cast<uint8_t>(value >> 24);
    out[5] = static_cast<uint8_t>(value >> 16);
    out[6] = static_cast<uint8_t>(value >> 8);
    out[7] = static_cast<uint8_t>(value);
    out[8] = tmclChecksum(out.data(), 8);
  }
 
  static TMCLFrame fromSpi(std::span<const uint8_t, 8> in) noexcept {
    TMCLFrame f;
    f.opcode = in[0];
    // BYTE1: Type lower 8 bits (bits 0-7)
    // BYTE2: bits 20-23 (high nibble) = Motor/Bank, bits 16-19 (low nibble) = Type upper 4 bits
    f.type = static_cast<uint16_t>(in[1] | ((in[2] & 0x0F) << 8));
    f.motor = (in[2] >> 4) & 0x0F;
    f.value = (static_cast<uint32_t>(in[3]) << 24) | (static_cast<uint32_t>(in[4]) << 16) |
              (static_cast<uint32_t>(in[5]) << 8) | static_cast<uint32_t>(in[6]);
    return f;
  }
 
  static bool fromSpiChecked(std::span<const uint8_t, 8> in, TMCLFrame& out_frame) noexcept {
    TMCLReply reply{};
    if (!TMCLReply::fromSpi(in, reply))
      return false;
    out_frame.opcode = reply.opcode;
    out_frame.value = reply.value;
    return true;
  }
 
  static bool fromUart(std::span<const uint8_t, 9> in, uint8_t expected_addr,
                       TMCLFrame& out_frame) noexcept {
    TMCLReply rep{};
    if (!TMCLReply::fromUart(in, expected_addr, rep))
      return false;
    out_frame.opcode = rep.opcode;
    out_frame.value = rep.value;
    return true;
  }
 
  static constexpr uint8_t calculateChecksum(const uint8_t* bytes, size_t n) noexcept {
    uint8_t sum = 0;
    for (size_t i = 0; i < n; ++i)
      sum += bytes[i];
    return sum;
  }
};
 
template <typename Derived>
class CommInterface {
public:
  CommInterface(bool rst_active_level, bool drv_en_active_level, bool wake_active_level,
                       bool faultn_active_level) noexcept
      : pinActiveLevels_{rst_active_level, drv_en_active_level, wake_active_level, faultn_active_level} {}
 
  CommMode mode() const noexcept {
    return static_cast<const Derived*>(this)->mode();
  }
 
  bool transferTMCL(const TMCLFrame& tx, TMCLReply& reply, uint8_t address,
                            TMCLReply* first_reply = nullptr,
                            const TMCLFrame* second_command = nullptr) noexcept {
    return static_cast<Derived*>(this)->transferTMCL(tx, reply, address, first_reply, second_command);
  }
 
  bool gpioSet(TMC9660CtrlPin pin, GpioSignal signal) noexcept {
    return static_cast<Derived*>(this)->gpioSet(pin, signal);
  }
 
  bool gpioRead(TMC9660CtrlPin pin, GpioSignal& signal) noexcept {
    return static_cast<Derived*>(this)->gpioRead(pin, signal);
  }
 
  bool signalToGpioLevel(TMC9660CtrlPin pin, GpioSignal signal) const noexcept {
    bool active_level = pinActiveLevels_[static_cast<int>(pin)];
    return (signal == GpioSignal::ACTIVE) ? active_level : !active_level;
  }
 
  GpioSignal gpioLevelToSignal(TMC9660CtrlPin pin, bool gpio_level) const noexcept {
    bool active_level = pinActiveLevels_[static_cast<int>(pin)];
    return (gpio_level == active_level) ? GpioSignal::ACTIVE : GpioSignal::INACTIVE;
  }
 
  bool gpioSetActive(TMC9660CtrlPin pin) noexcept {
    return gpioSet(pin, GpioSignal::ACTIVE);
  }
 
  bool gpioSetInactive(TMC9660CtrlPin pin) noexcept {
    return gpioSet(pin, GpioSignal::INACTIVE);
  }
 
  bool set_pin_active_level(TMC9660CtrlPin pin, bool active_level) noexcept {
    pinActiveLevels_[static_cast<int>(pin)] = active_level;
    return true;
  }
 
  void setSpiRetryMaxCount(uint8_t max_retries) noexcept {
    spiRetryMaxCount_ = max_retries;
  }
 
  uint8_t getSpiRetryMaxCount() const noexcept {
    return spiRetryMaxCount_;
  }
 
  void setSpiRetryInterval(uint32_t interval_us) noexcept {
    spiRetryIntervalUs_ = interval_us;
  }
 
  uint32_t getSpiRetryInterval() const noexcept {
    return spiRetryIntervalUs_;
  }
 
protected:
  bool pinActiveLevels_[4];
 
  uint8_t spiRetryMaxCount_ = 3;
 
  uint32_t spiRetryIntervalUs_ = 100;
 
  void debugLog(int level, const char* tag, const char* format, va_list args) noexcept {
    static_cast<Derived*>(this)->debugLog(level, tag, format, args);
  }
 
public:
  void delayMs(uint32_t ms) noexcept {
    static_cast<Derived*>(this)->delayMs(ms);
  }
 
  void delayUs(uint32_t us) noexcept {
    static_cast<Derived*>(this)->delayUs(us);
  }
 
protected:
  ~CommInterface() = default;
 
  // Prevent copying
  CommInterface(const CommInterface&) = delete;
  CommInterface& operator=(const CommInterface&) = delete;
 
  // Allow moving
  CommInterface(CommInterface&&) = default;
  CommInterface& operator=(CommInterface&&) = default;
 
public:
#ifndef TMC9660_DISABLE_DEBUG_LOGGING
  void logDebug(int level, const char* tag, const char* format, ...) noexcept {
    va_list args;
    va_start(args, format);
 
    // Check if format string already ends with newline
    size_t format_len = strlen(format);
    const char* final_format = format;
    char* modified_format = nullptr;
 
    if (format_len == 0 || format[format_len - 1] != '\n') {
      // Allocate buffer for format + "\n"
      modified_format = new char[format_len + 2];
      strcpy(modified_format, format);
      strcat(modified_format, "\n");
      final_format = modified_format;
    }
 
    debugLog(level, tag, final_format, args);
 
    if (modified_format) {
      delete[] modified_format;
    }
 
    va_end(args);
  }
#else
  // Debug logging disabled - function optimized out completely
  inline void logDebug(int /*level*/, const char* /*tag*/, const char* /*format*/, ...) noexcept {
    // Empty function body - all logging optimized out
  }
#endif
};
 
template <typename Derived>
class SpiCommInterface : public CommInterface<Derived> {
public:
  SpiCommInterface(bool rst_active_level, bool drv_en_active_level, bool wake_active_level,
                       bool faultn_active_level) noexcept
      : CommInterface<Derived>(rst_active_level, drv_en_active_level, wake_active_level, faultn_active_level) {
  }
 
  CommMode mode() const noexcept {
    return CommMode::SPI;
  }
 
  bool spiTransferTMCL(std::array<uint8_t, 8>& tx, std::array<uint8_t, 8>& rx) noexcept {
    return static_cast<Derived*>(this)->spiTransferTMCL(tx, rx);
  }
 
  bool spiTransferBootloader(std::array<uint8_t, 5>& tx, std::array<uint8_t, 5>& rx) noexcept {
    return static_cast<Derived*>(this)->spiTransferBootloader(tx, rx);
  }
 
  bool gpioSet(TMC9660CtrlPin pin, GpioSignal signal) noexcept {
    return static_cast<Derived*>(this)->gpioSet(pin, signal);
  }
 
  bool gpioRead(TMC9660CtrlPin pin, GpioSignal& signal) noexcept {
    return static_cast<Derived*>(this)->gpioRead(pin, signal);
  }
 
  bool transferTMCL(const TMCLFrame& tx, TMCLReply& reply, uint8_t, TMCLReply* first_reply,
                    const TMCLFrame* second_command) noexcept {
    std::array<uint8_t, 8> tx_buf, rx_buf;
    tx.toSpi(tx_buf);
 
    // Log raw SPI bytes being transmitted
    TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 2, "SPI_TMCL", "[TMCL TX 1 ] %02X %02X %02X %02X %02X %02X %02X %02X",
                      tx_buf[0], tx_buf[1], tx_buf[2], tx_buf[3], tx_buf[4], tx_buf[5], tx_buf[6],
                      tx_buf[7]);
 
    // Transaction 1: Send command, receive first reply
    if (!spiTransferTMCL(tx_buf, rx_buf))
      return false;
 
    TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 2, "SPI_TMCL", "[TMCL RX 1 ] %02X %02X %02X %02X %02X %02X %02X %02X",
                      rx_buf[0], rx_buf[1], rx_buf[2], rx_buf[3], rx_buf[4], rx_buf[5], rx_buf[6],
                      rx_buf[7]);
 
    // Optionally capture first reply (this is the reply to the PREVIOUS command due to SPI delay)
    if (first_reply) {
      bool first_parse_ok = TMCLReply::fromSpi(rx_buf, *first_reply);
      TMC9660_LOG_DEBUG(
          *static_cast<Derived*>(this), 2, "SPI_TMCL",
          "          └─> SPI_Status=0x%02X, TMCL_Status=0x%02X, Value=0x%08X (parse %s)",
          static_cast<uint8_t>(first_reply->spi_status), first_reply->status, first_reply->value,
          first_parse_ok ? "OK" : "failed");
      // Note: We don't return false here because SESSION_START may have non-standard format
      // The caller can check rawBytes[0] for SESSION_START status codes
    }
 
    // Transaction 2: Send second command (or NO_OP), receive final reply
    // This transaction is wrapped in retry logic for SPI_STATUS_NOT_READY
    TMCLFrame cmd2 = second_command ? *second_command : TMCLFrame{}; // NO_OP if not provided
    cmd2.toSpi(tx_buf);
 
      // Retry loop for SPI_STATUS_NOT_READY responses
    uint8_t retry_count = 0;
    while (true) {
      TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 2, "SPI_TMCL",
                        "[TMCL TX 2 ] %02X %02X %02X %02X %02X %02X %02X %02X%s", tx_buf[0],
                        tx_buf[1], tx_buf[2], tx_buf[3], tx_buf[4], tx_buf[5], tx_buf[6], tx_buf[7],
                        retry_count > 0 ? " (retry)" : "");
 
      if (!spiTransferTMCL(tx_buf, rx_buf))
        return false;
 
      TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 2, "SPI_TMCL",
                        "[TMCL RX 2 ] %02X %02X %02X %02X %02X %02X %02X %02X", rx_buf[0], rx_buf[1],
                        rx_buf[2], rx_buf[3], rx_buf[4], rx_buf[5], rx_buf[6], rx_buf[7]);
 
      // Check SPI status byte (first byte) for NOT_READY
      SPIStatus spi_status = static_cast<SPIStatus>(rx_buf[0]);
 
      if (spi_status == SPIStatus::NOT_READY) {
        // System not ready - retry if we haven't exceeded max retries
        if (retry_count < this->spiRetryMaxCount_) {
          retry_count++;
          TMC9660_LOG_DEBUG(
              *static_cast<Derived*>(this), 2, "SPI_TMCL",
              "⚠️  SPI_STATUS_NOT_READY received, retrying (attempt %u/%u) after %u us", retry_count,
              this->spiRetryMaxCount_ + 1, this->spiRetryIntervalUs_);
          this->delayUs(this->spiRetryIntervalUs_);
          continue; // Retry the transaction
        } else {
          // Max retries exceeded - parse reply manually since fromSpi returns false for NOT_READY
          TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 1, "SPI_TMCL",
                            "❌ SPI_STATUS_NOT_READY: Max retries (%u) exceeded",
                            this->spiRetryMaxCount_);
          // Validate checksum before parsing
          if (tmclChecksum(rx_buf.data(), 7) != rx_buf[7]) {
            TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 1, "SPI_TMCL", "⚠️  Checksum error in NOT_READY response");
            return false;
          }
          // Manually populate reply structure for NOT_READY response
          std::copy(rx_buf.begin(), rx_buf.end(), reply.rawBytes.begin());
          reply.spi_status = SPIStatus::NOT_READY;
          reply.status = rx_buf[1]; // TMCL status
          reply.opcode = rx_buf[2]; // Operation code
          reply.value = (static_cast<uint32_t>(rx_buf[3]) << 24) |
                        (static_cast<uint32_t>(rx_buf[4]) << 16) |
                        (static_cast<uint32_t>(rx_buf[5]) << 8) | static_cast<uint32_t>(rx_buf[6]);
          return false; // Return false to indicate failure
        }
      }
 
      // Not NOT_READY - parse and return normally
      break;
    }
 
    // Parse reply with command context (for handling special reply formats like GetVersion string)
    bool parse_ok = TMCLReply::fromSpi(rx_buf, reply, tx.opcode, tx.type);
    if (!parse_ok && static_cast<SPIStatus>(rx_buf[0]) == SPIStatus::NOT_READY) {
      // This shouldn't happen due to retry logic, but handle it just in case
      TMC9660_LOG_DEBUG(*static_cast<Derived*>(this), 1, "SPI_TMCL", "⚠️  Unexpected NOT_READY after retry loop");
    }
    return parse_ok;
  }
 
protected:
  ~SpiCommInterface() = default;
 
  // Prevent copying
  SpiCommInterface(const SpiCommInterface&) = delete;
  SpiCommInterface& operator=(const SpiCommInterface&) = delete;
 
  // Allow moving
  SpiCommInterface(SpiCommInterface&&) = default;
  SpiCommInterface& operator=(SpiCommInterface&&) = default;
};
 
template <typename Derived>
class UartCommInterface : public CommInterface<Derived> {
public:
  UartCommInterface(bool rst_active_level, bool drv_en_active_level, bool wake_active_level,
                       bool faultn_active_level) noexcept
      : CommInterface<Derived>(rst_active_level, drv_en_active_level, wake_active_level, faultn_active_level) {
  }
 
  CommMode mode() const noexcept {
    return CommMode::UART;
  }
 
  bool uartSendTMCL(const std::array<uint8_t, 9>& data) noexcept {
    return static_cast<Derived*>(this)->uartSendTMCL(data);
  }
 
  bool uartReceiveTMCL(std::array<uint8_t, 9>& data) noexcept {
    return static_cast<Derived*>(this)->uartReceiveTMCL(data);
  }
 
  bool uartTransferBootloader(const std::array<uint8_t, 8>& tx, std::array<uint8_t, 8>& rx) noexcept {
    return static_cast<Derived*>(this)->uartTransferBootloader(tx, rx);
  }
 
  bool gpioSet(TMC9660CtrlPin pin, GpioSignal signal) noexcept {
    return static_cast<Derived*>(this)->gpioSet(pin, signal);
  }
 
  bool gpioRead(TMC9660CtrlPin pin, GpioSignal& signal) noexcept {
    return static_cast<Derived*>(this)->gpioRead(pin, signal);
  }
 
  bool transferTMCL(const TMCLFrame& tx, TMCLReply& reply, uint8_t address, TMCLReply* first_reply,
                    const TMCLFrame* second_command) noexcept {
    // UART doesn't use the two-transaction pattern, so first_reply and second_command are ignored
    (void)first_reply;    // Suppress unused parameter warning
    (void)second_command; // Suppress unused parameter warning
 
    std::array<uint8_t, 9> frame;
    tx.toUart(address, frame);
    if (!uartSendTMCL(frame))
      return false;
    if (!uartReceiveTMCL(frame))
      return false;
    // Parse reply with command context (for handling special reply formats like GetVersion string)
    return TMCLReply::fromUart(frame, address, reply, tx.opcode, tx.type);
  }
 
protected:
  ~UartCommInterface() = default;
 
  // Prevent copying
  UartCommInterface(const UartCommInterface&) = delete;
  UartCommInterface& operator=(const UartCommInterface&) = delete;
 
  // Allow moving
  UartCommInterface(UartCommInterface&&) = default;
  UartCommInterface& operator=(UartCommInterface&&) = default;
};
 
} // namespace tmc9660