tormatic_protocol.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/components/cover/cover.h"
 
namespace esphome {
namespace tormatic {
 
using namespace esphome::cover;
 
// MessageType is the type of message that follows the MessageHeader.
enum MessageType : uint16_t {
  STATUS = 0x0104,
  COMMAND = 0x0106,
};
 
// Max string length: 7 ("Unknown"/"Command"). Update print() buffer sizes if adding longer strings.
inline const char *message_type_to_str(MessageType t) {
  switch (t) {
    case STATUS:
      return "Status";
    case COMMAND:
      return "Command";
    default:
      return "Unknown";
  }
}
 
// MessageHeader appears at the start of every message, both requests and replies.
struct MessageHeader {
  uint16_t seq;
  uint32_t len;
  MessageType type;
 
  MessageHeader() = default;
  MessageHeader(MessageType type, uint16_t seq, uint32_t payload_size) {
    this->type = type;
    this->seq = seq;
    // len includes the length of the type field. It was
    // included in MessageHeader to avoid having to parse
    // it as part of the payload.
    this->len = payload_size + sizeof(this->type);
  }
 
  std::string print() {
    // 64 bytes: "MessageHeader: seq " + uint16 + ", len " + uint32 + ", type " + type + safety margin
    char buf[64];
    buf_append_printf(buf, sizeof(buf), 0, "MessageHeader: seq %d, len %d, type %s", this->seq, this->len,
                      message_type_to_str(this->type));
    return buf;
  }
 
  void byteswap() {
    this->len = convert_big_endian(this->len);
    this->seq = convert_big_endian(this->seq);
    this->type = convert_big_endian(this->type);
  }
 
  // payload_size returns the amount of payload bytes to be read from the uart
  // buffer after reading the header.
  uint32_t payload_size() { return this->len - sizeof(this->type); }
} __attribute__((packed));
 
// StatusType denotes which 'page' of information needs to be retrieved.
// On my Novoferm 423, only the GATE status type returns values, Unknown
// only contains zeroes.
enum StatusType : uint16_t {
  GATE = 0x0A,
  UNKNOWN = 0x0B,
};
 
// GateStatus defines the current state of the gate, received in a StatusReply
// and sent in a Command.
enum GateStatus : uint8_t {
  PAUSED,
  CLOSED,
  VENTILATING,
  OPENED,
  OPENING,
  CLOSING,
};
 
inline CoverOperation gate_status_to_cover_operation(GateStatus s) {
  switch (s) {
    case OPENING:
      return COVER_OPERATION_OPENING;
    case CLOSING:
      return COVER_OPERATION_CLOSING;
    case OPENED:
    case CLOSED:
    case PAUSED:
    case VENTILATING:
      return COVER_OPERATION_IDLE;
  }
  return COVER_OPERATION_IDLE;
}
 
// Max string length: 11 ("Ventilating"). Update print() buffer sizes if adding longer strings.
inline const char *gate_status_to_str(GateStatus s) {
  switch (s) {
    case PAUSED:
      return "Paused";
    case CLOSED:
      return "Closed";
    case VENTILATING:
      return "Ventilating";
    case OPENED:
      return "Opened";
    case OPENING:
      return "Opening";
    case CLOSING:
      return "Closing";
    default:
      return "Unknown";
  }
}
 
// A StatusRequest is sent to request the gate's current status.
struct StatusRequest {
  StatusType type;
  uint16_t trailer = 0x1;
 
  StatusRequest() = default;
  StatusRequest(StatusType type) { this->type = type; }
 
  void byteswap() {
    this->type = convert_big_endian(this->type);
    this->trailer = convert_big_endian(this->trailer);
  }
} __attribute__((packed));
 
// StatusReply is received from the unit in response to a StatusRequest.
struct StatusReply {
  uint8_t ack = 0x2;
  GateStatus state;
  uint8_t trailer = 0x0;
 
  std::string print() {
    // 48 bytes: "StatusReply: state " (19) + state (11) + safety margin
    char buf[48];
    buf_append_printf(buf, sizeof(buf), 0, "StatusReply: state %s", gate_status_to_str(this->state));
    return buf;
  }
 
  void byteswap(){};
} __attribute__((packed));
 
// Serialize the given object to a new byte vector.
// Invokes the object's byteswap() method.
template<typename T> std::vector<uint8_t> serialize(T obj) {
  obj.byteswap();
 
  std::vector<uint8_t> out(sizeof(T));
  memcpy(out.data(), &obj, sizeof(T));
 
  return out;
}
 
// Command tells the gate to start or stop moving.
// It is echoed back by the unit on success.
struct CommandRequestReply {
  // The part of the unit to control. For now only the gate is supported.
  StatusType type = GATE;
  uint8_t pad = 0x0;
  // The desired state:
  // PAUSED = stop
  // VENTILATING = move to ~20% open
  // CLOSED = close
  // OPENED = open/high-torque reverse when closing
  GateStatus state;
 
  CommandRequestReply() = default;
  CommandRequestReply(GateStatus state) { this->state = state; }
 
  std::string print() {
    // 56 bytes: "CommandRequestReply: state " (27) + state (11) + safety margin
    char buf[56];
    buf_append_printf(buf, sizeof(buf), 0, "CommandRequestReply: state %s", gate_status_to_str(this->state));
    return buf;
  }
 
  void byteswap() { this->type = convert_big_endian(this->type); }
} __attribute__((packed));
 
}  // namespace tormatic
}  // namespace esphome