teleinfo.h

Go to the documentation of this file.

#ifndef TELEINFO_H
#define TELEINFO_H
 
#include "config_system.h"
#include "config.h"

inline static constexpr size_t lineSize(size_t tagLen, size_t valueLen)
{
  return 1 + tagLen + 1 + valueLen + 1 + 1 + 1;  // LF+tag+TAB+value+TAB+checksum+CR
}

inline static constexpr size_t calcBufferSize()
{
  size_t size{ 1 };  // STX
 
  size += lineSize(1, 6);  // P (signed 6 digits)
 
  if constexpr (NO_OF_PHASES > 1)
  {
    size += NO_OF_PHASES * lineSize(2, 5);  // V1-Vn (unsigned 5 digits) - voltage
 
    size += NO_OF_PHASES * lineSize(2, 6);  // P1-Pn (signed 6 digits) - instant power
 
    size += NO_OF_DUMPLOADS * lineSize(2, 3);  // D1-Dn (unsigned 3 digits) - diversion rate
  }
  else
  {
    size += lineSize(1, 5);  // V (unsigned 5 digits) - voltage
 
    size += lineSize(1, 4);  // D (unsigned 4 digits) - diverted power
    size += lineSize(1, 5);  // E (unsigned 5 digits) - diverted energy
  }
 
  if constexpr (RELAY_DIVERSION)
  {
    size += lineSize(1, 6);                  // R (signed 6 digits) - mean power for relay diversion
    size += relays.size() * lineSize(2, 1);  // R1-Rn (1 (ON), 0 (OFF)) - relay state
  }
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    size += temperatureSensing.size() * lineSize(2, 4);  // T1-Tn (4 digits) - temperature
  }
 
  size += lineSize(1, 5);  // N (unsigned 5 digits) - absence of diverted energy count
 
  if constexpr (DUAL_TARIFF)
  {
    size += lineSize(2, 1);  // TA (1 digit) - tariff state (0=high/on-peak, 1=low/off-peak)
  }
 
  size += lineSize(4, 2);  // S_MC (unsigned 2 digits) - sample sets per mains cycle
  size += lineSize(1, 5);  // S (unsigned 5 digits) - sample count
 
  size += 1;  // ETX
 
  return size;
}

class TeleInfo
{
private:
  static const char STX{ 0x02 }; 
  static const char ETX{ 0x03 }; 
  static const char LF{ 0x0A };  
  static const char CR{ 0x0D };  
  static const char TAB{ 0x09 }; 
 
  char buffer[calcBufferSize()]{}; 
  size_t bufferPos{ 0 };           

  [[nodiscard]] uint8_t calculateChecksum(size_t startPos, size_t endPos) const
  {
    uint8_t sum{ 0 };
    auto* ptr = buffer + startPos;
    const auto* end = buffer + endPos;
 
    // Process 4 bytes at once for longer segments
    while (ptr + 4 <= end)
    {
      sum += *ptr++;
      sum += *ptr++;
      sum += *ptr++;
      sum += *ptr++;
    }
 
    // Handle remaining bytes
    while (ptr < end)
    {
      sum += *ptr++;
    }
 
    return (sum & 0x3F) + 0x20;
  }

  __attribute__((always_inline)) void writeTag(const char* tag, uint8_t index)
  {
    auto* ptr{ tag };
    while (*ptr) buffer[bufferPos++] = *ptr++;
 
    // If an index is provided, append it to the tag
    if (index != 0)
    {
      buffer[bufferPos++] = static_cast< char >('0' + index);  // Convert index to a character
    }
 
    buffer[bufferPos++] = TAB;
  }
 
public:
  __attribute__((always_inline)) void startFrame()
  {
    bufferPos = 0;
    buffer[bufferPos++] = STX;
  }

  void send(const char* tag, int16_t value, uint8_t index = 0)
  {
    buffer[bufferPos++] = LF;
 
    const auto startPos{ bufferPos };
 
    writeTag(tag, index);
    auto str = itoa(value, buffer + bufferPos, 10);
    bufferPos += strlen(str);  // Advance bufferPos by the length of the written string
    buffer[bufferPos++] = TAB;
 
    const auto crc{ calculateChecksum(startPos, bufferPos) };
    buffer[bufferPos++] = crc;
 
    buffer[bufferPos++] = CR;
  }

  __attribute__((always_inline)) void endFrame()
  {
    buffer[bufferPos++] = ETX;
    Serial.write(buffer, bufferPos);
  }
};
 
#endif /* TELEINFO_H */