TMC9660CommInterface.hpp

Go to the documentation of this file.

 
#pragma once
#include <array>
#include <cstdint>
#include <cstdlib>
#include <span>
 
enum class CommMode { SPI, UART };
 
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) noexcept {
  uint8_t sum = 0;
  for (size_t i = 0; i < n; ++i)
    sum += bytes[i];
  return sum;
}
 
// -----------------------------------------------------------------------
// TMCL scripting support structures and enums
// -----------------------------------------------------------------------
 
struct TMCLReply {
  SPIStatus spiStatus = SPIStatus::OK; 
  uint8_t status = 0;                  
  uint8_t opcode = 0;                  
  uint32_t value = 0;                  
 
  [[nodiscard]] bool isOK() const noexcept {
    return spiStatus == SPIStatus::OK && (status == 100 || status == 101);
  }
 
  static bool fromSpi(std::span<const uint8_t, 8> in, TMCLReply &r) noexcept {
    if (tmclChecksum(in.data(), 7) != in[7])
      return false;
    r.spiStatus = static_cast<SPIStatus>(in[0]);
    if (r.spiStatus == SPIStatus::NOT_READY || r.spiStatus == 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) noexcept {
    // byte0 : host address (ignored)
    // byte1 : sync bit + module address (7-bit)
    if ((in[1] & 0x7F) != (addr & 0x7F))
      return false;
    if (tmclChecksum(in.data(), 8) != in[8])
      return false;              // checksum over first 8 bytes
    r.spiStatus = SPIStatus::OK; // UART has no SPI status field
    r.status = in[2];
    r.opcode = in[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 >> 4);
    out[2] = static_cast<uint8_t>((type << 4) | (motor & 0x0F));
    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 {
    out[0] = addr | 0x80; // sync bit set
    out[1] = opcode;
    out[2] = static_cast<uint8_t>(type >> 4);
    out[3] = static_cast<uint8_t>((type << 4) | (motor & 0x0F));
    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];
    f.type = static_cast<uint16_t>(in[1]) << 4 | (in[2] >> 4);
    f.motor = in[2] & 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 &outFrame) noexcept {
    TMCLReply reply{};
    if (!TMCLReply::fromSpi(in, reply))
      return false;
    outFrame.opcode = reply.opcode;
    outFrame.value = reply.value;
    return true;
  }
 
  static bool fromUart(std::span<const uint8_t, 9> in, uint8_t expectedAddr,
                       TMCLFrame &outFrame) noexcept {
    TMCLReply rep{};
    if (!TMCLReply::fromUart(in, expectedAddr, rep))
      return false;
    outFrame.opcode = rep.opcode;
    outFrame.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;
  }
};
 
class TMC9660CommInterface {
public:
  virtual ~TMC9660CommInterface() noexcept = default;
 
  virtual CommMode mode() const noexcept = 0;
 
  virtual bool transfer(const TMCLFrame &tx, TMCLReply &reply, uint8_t address) noexcept = 0;
};
 
class SPITMC9660CommInterface : public TMC9660CommInterface {
public:
  CommMode mode() const noexcept override {
    return CommMode::SPI;
  }
  virtual bool spiTransfer(std::array<uint8_t, 8> &tx, std::array<uint8_t, 8> &rx) noexcept = 0;
 
  bool transfer(const TMCLFrame &tx, TMCLReply &reply, uint8_t) noexcept override {
    std::array<uint8_t, 8> txBuf, rxBuf;
    tx.toSpi(txBuf);
    if (!spiTransfer(txBuf, rxBuf))
      return false;
    return TMCLReply::fromSpi(rxBuf, reply);
  }
};
 
class UARTTMC9660CommInterface : public TMC9660CommInterface {
public:
  CommMode mode() const noexcept override {
    return CommMode::UART;
  }
  virtual bool sendUartDatagram(const std::array<uint8_t, 9> &data) noexcept = 0;
 
  virtual bool receiveUartDatagram(std::array<uint8_t, 9> &data) noexcept = 0;
 
  bool transfer(const TMCLFrame &tx, TMCLReply &reply, uint8_t address) noexcept override {
    std::array<uint8_t, 9> frame;
    tx.toUart(address, frame);
    if (!sendUartDatagram(frame))
      return false;
    if (!receiveUartDatagram(frame))
      return false;
    return TMCLReply::fromUart(frame, address, reply);
  }
};