alicat_basis2_modbus.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <cstddef>
 
#include "alicat_basis2_registers.hpp"
#include "alicat_basis2_types.hpp"
 
namespace alicat_basis2 {
namespace modbus {
 
inline uint16_t Crc16(const uint8_t* data, std::size_t length) noexcept {
    uint16_t crc = 0xFFFF;
    for (std::size_t i = 0; i < length; ++i) {
        crc ^= static_cast<uint16_t>(data[i]);
        for (uint8_t b = 0; b < 8; ++b) {
            if (crc & 0x0001U) {
                crc = static_cast<uint16_t>((crc >> 1) ^ 0xA001U);
            } else {
                crc >>= 1;
            }
        }
    }
    return crc;
}
 
inline std::size_t AppendCrc(uint8_t* frame, std::size_t length) noexcept {
    const uint16_t crc = Crc16(frame, length);
    frame[length]     = static_cast<uint8_t>(crc & 0x00FFU);
    frame[length + 1] = static_cast<uint8_t>((crc >> 8) & 0x00FFU);
    return length + 2;
}
 
inline bool CheckCrc(const uint8_t* frame, std::size_t length) noexcept {
    if (length < 4) return false;
    const uint16_t want = Crc16(frame, length - 2);
    const uint16_t got  = static_cast<uint16_t>(frame[length - 2]) |
                          (static_cast<uint16_t>(frame[length - 1]) << 8);
    return want == got;
}
 
//==============================================================================
// REQUEST BUILDERS — format the bytes a master sends on the wire.
//==============================================================================
 
inline std::size_t BuildReadHolding(uint8_t  unit_addr,
                                    uint16_t reg_addr,
                                    uint16_t reg_count,
                                    uint8_t* out, std::size_t out_capacity) noexcept {
    if (out_capacity < 8) return 0;
    out[0] = unit_addr;
    out[1] = reg::fn::ReadHolding;
    out[2] = static_cast<uint8_t>((reg_addr >> 8) & 0xFFU);
    out[3] = static_cast<uint8_t>(reg_addr        & 0xFFU);
    out[4] = static_cast<uint8_t>((reg_count >> 8) & 0xFFU);
    out[5] = static_cast<uint8_t>(reg_count        & 0xFFU);
    return AppendCrc(out, 6);
}
 
inline std::size_t BuildWriteSingle(uint8_t  unit_addr,
                                    uint16_t reg_addr,
                                    uint16_t value,
                                    uint8_t* out, std::size_t out_capacity) noexcept {
    if (out_capacity < 8) return 0;
    out[0] = unit_addr;
    out[1] = reg::fn::WriteSingle;
    out[2] = static_cast<uint8_t>((reg_addr >> 8) & 0xFFU);
    out[3] = static_cast<uint8_t>(reg_addr        & 0xFFU);
    out[4] = static_cast<uint8_t>((value >> 8) & 0xFFU);
    out[5] = static_cast<uint8_t>(value        & 0xFFU);
    return AppendCrc(out, 6);
}
 
inline std::size_t BuildWriteMultiple(uint8_t  unit_addr,
                                      uint16_t reg_addr,
                                      const uint16_t* regs, uint8_t count,
                                      uint8_t* out, std::size_t out_capacity) noexcept {
    const std::size_t needed = 9 + count * 2;
    if (count == 0 || out_capacity < needed) return 0;
    out[0] = unit_addr;
    out[1] = reg::fn::WriteMultiple;
    out[2] = static_cast<uint8_t>((reg_addr >> 8) & 0xFFU);
    out[3] = static_cast<uint8_t>(reg_addr        & 0xFFU);
    out[4] = static_cast<uint8_t>((count >> 8) & 0xFFU);
    out[5] = static_cast<uint8_t>(count        & 0xFFU);
    out[6] = static_cast<uint8_t>(count * 2);
    for (uint8_t i = 0; i < count; ++i) {
        out[7 + i * 2]     = static_cast<uint8_t>((regs[i] >> 8) & 0xFFU);
        out[7 + i * 2 + 1] = static_cast<uint8_t>(regs[i]        & 0xFFU);
    }
    return AppendCrc(out, 7 + count * 2);
}
 
//==============================================================================
// TIMING — Modbus over Serial Line V1.02, section 2.5.1.1
//==============================================================================
 
inline constexpr uint32_t kRtuBitsPerChar = 11;
 
inline constexpr uint32_t kFixedGapAboveBps = 19200;
 
inline constexpr uint32_t kFixedGapUs = 1750;
 
constexpr uint32_t InterFrameGapUs(uint32_t bps) noexcept {
  if (bps == 0)
    bps = 4800;
  if (bps > kFixedGapAboveBps)
    return kFixedGapUs;
  // 3.5 * 11 bits * 1e6 us / bps, rounded up.
  constexpr uint32_t kNumerator = 7U * kRtuBitsPerChar * 1000000U / 2U; // 38'500'000
  return (kNumerator + bps - 1U) / bps;
}
 
constexpr uint32_t InterFrameGapMs(uint32_t bps) noexcept {
  return (InterFrameGapUs(bps) + 999U) / 1000U;
}
 
inline constexpr std::size_t kExceptionFrameLength = 5;
 
inline constexpr std::size_t kReplyHeaderLength = 3;
 
inline bool IsExceptionReply(const uint8_t* frame, std::size_t length) noexcept {
  return length >= 2 && (frame[1] & reg::fn::ExceptionMask) != 0;
}
 
//==============================================================================
// RESPONSE PARSERS — return the number of registers extracted, or 0 on error.
//==============================================================================
 
inline DriverError ParseException(const uint8_t* frame, std::size_t length, uint8_t expected_addr,
                                  uint8_t expected_fn, uint8_t* code) noexcept {
  if (length != kExceptionFrameLength)
    return DriverError::InvalidFrame;
  if (!CheckCrc(frame, length))
    return DriverError::BadCrc;
  if (frame[0] != expected_addr)
    return DriverError::ResponseMismatch;
  if (frame[1] != (expected_fn | reg::fn::ExceptionMask))
    return DriverError::ResponseMismatch;
  if (code)
    *code = frame[2];
  return DriverError::ModbusException;
}
 
inline DriverError ParseReadHolding(const uint8_t* frame, std::size_t length,
                                    uint8_t expected_addr, uint8_t expected_count,
                                    uint16_t* regs) noexcept {
    if (length < 5)                             return DriverError::InvalidFrame;
    if (!CheckCrc(frame, length))               return DriverError::BadCrc;
    if (frame[0] != expected_addr)              return DriverError::ResponseMismatch;
    if (frame[1] & reg::fn::ExceptionMask)      return DriverError::ModbusException;
    if (frame[1] != reg::fn::ReadHolding)       return DriverError::ResponseMismatch;
    const std::size_t byte_count = frame[2];
    if (byte_count != expected_count * 2U)      return DriverError::InvalidFrame;
    if (length < 3 + byte_count + 2)            return DriverError::InvalidFrame;
    for (uint8_t i = 0; i < expected_count; ++i) {
        regs[i] = (static_cast<uint16_t>(frame[3 + i * 2]) << 8) |
                  static_cast<uint16_t>(frame[3 + i * 2 + 1]);
    }
    return DriverError::None;
}
 
inline DriverError ParseWriteSingleEcho(const uint8_t* frame, std::size_t length,
                                        const uint8_t* request, std::size_t req_len) noexcept {
    if (length < req_len)                       return DriverError::InvalidFrame;
    if (!CheckCrc(frame, length))               return DriverError::BadCrc;
    if (frame[0] != request[0])                 return DriverError::ResponseMismatch;
    if (frame[1] & reg::fn::ExceptionMask)      return DriverError::ModbusException;
    for (std::size_t i = 0; i < req_len; ++i) {
        if (frame[i] != request[i])             return DriverError::ResponseMismatch;
    }
    return DriverError::None;
}
 
inline DriverError ParseWriteMultipleEcho(const uint8_t* frame, std::size_t length,
                                          uint8_t expected_addr,
                                          uint16_t expected_reg_addr,
                                          uint16_t expected_count) noexcept {
    if (length < 8)                             return DriverError::InvalidFrame;
    if (!CheckCrc(frame, length))               return DriverError::BadCrc;
    if (frame[0] != expected_addr)              return DriverError::ResponseMismatch;
    if (frame[1] & reg::fn::ExceptionMask)      return DriverError::ModbusException;
    if (frame[1] != reg::fn::WriteMultiple)     return DriverError::ResponseMismatch;
    const uint16_t got_addr = (static_cast<uint16_t>(frame[2]) << 8) | frame[3];
    const uint16_t got_cnt  = (static_cast<uint16_t>(frame[4]) << 8) | frame[5];
    if (got_addr != expected_reg_addr)          return DriverError::ResponseMismatch;
    if (got_cnt  != expected_count)             return DriverError::ResponseMismatch;
    return DriverError::None;
}
 
}  // namespace modbus
}  // namespace alicat_basis2