zwave_frame_parser.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2024 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef ZWAVE_FRAME_PARSER_HPP
#define ZWAVE_FRAME_PARSER_HPP
 
#ifdef __cplusplus
 
// Attribute store
#include "attribute_store.h"
#include "attribute.hpp"
 
// Unify
#include "sl_log.h"
 
// Generic C++ includes
#include <vector>
#include <string>
#include <bitset>
#include <map>
 
// Typedef
using zwave_report_bitmask_t = uint32_t;
 
class zwave_frame_parser
{
  public:
  using zwave_parser_bitmask_result = std::map<uint8_t, uint8_t>;
 
  struct bitmask_data {
    uint8_t bitmask = 0b00000000;
    attribute_store_node_t destination_node = ATTRIBUTE_STORE_INVALID_NODE;
  };
 
  explicit zwave_frame_parser(const uint8_t *data, uint16_t length);
  ~zwave_frame_parser() = default;
 
  bool is_frame_size_valid(uint8_t min_size, uint8_t max_size = 0) const;
 
  uint8_t read_byte();
 
  uint8_t read_byte(attribute_store_node_t node);
 
  zwave_parser_bitmask_result
    read_byte_with_bitmask(const std::vector<bitmask_data> &bitmask_data);
 
  zwave_parser_bitmask_result
    read_byte_with_bitmask(const bitmask_data &bitmask_data);
 
  zwave_report_bitmask_t read_bitmask(uint8_t bitmask_length = 0);
 
  zwave_report_bitmask_t read_bitmask(attribute_store_node_t node,
                                      uint8_t bitmask_length = 0);
 
  std::string read_string();
  std::string read_string(attribute_store_node_t node);
 
 
  template<typename T> T read_sequential(uint8_t bytes_to_read)
  {
    static_assert(std::is_integral<T>::value
                    || std::is_same<T, std::string>::value
                    || std::is_same<T, std::vector<uint8_t>>::value,
                  "Unsupported type");
 
    T value_from_frame;
    if constexpr (std::is_integral<T>::value) {
      value_from_frame = 0;
 
      for (uint8_t i = 0; i < bytes_to_read; i++) {
        T current_byte = zwave_report_frame.at(current_index);
        // Z-Wave always have MSB first and LSB last
        // If we have read 2 bytes : 0x34,0x56 the result should be 0x3456
        // First iteration  : 0x34 << 8 = 0x3400
        // Second iteration : 0x56 << 0 = 0x3456
        uint8_t offset = (bytes_to_read - 1 - i) * 8;
        value_from_frame |= current_byte << offset;
 
        current_index++;
      }
 
      // Convert value to signed if needed
      // This is used in the case of a signed value that is smaller than the T type
      // e.g. int8_t stored in a int32_t.
      if constexpr (std::is_signed<T>::value) {
        switch (bytes_to_read) {
          case 1:
            value_from_frame = static_cast<int8_t>(value_from_frame);
            break;
          case 2:
            value_from_frame = static_cast<int16_t>(value_from_frame);
            break;
          case 4:
            value_from_frame = static_cast<int32_t>(value_from_frame);
            break;
          default:
            throw std::runtime_error("Unsupported size for signed value, only "
                                     "1, 2 or 4 are supported");
        }
      }
    } else if constexpr (std::is_same<T, std::string>::value
                         || std::is_same<T, std::vector<uint8_t>>::value) {
      value_from_frame.resize(bytes_to_read);
      for (uint8_t i = 0; i < bytes_to_read; i++) {
        value_from_frame[i] = read_byte();
      }
    }
    return value_from_frame;
  }
 
  template<typename T>
  T read_sequential(uint8_t bytes_to_read, attribute_store_node_t node)
  {
    T value = read_sequential<T>(bytes_to_read);
    helper_store_value(node, value);
    return value;
  }
 
  private:
  template<typename T>
  void helper_store_value(attribute_store_node_t node, T value)
  {
    attribute_store::attribute current_attribute(node);
 
    if (current_attribute.is_valid()) {
      current_attribute.set_reported<T>(value);
      sl_log_debug("zwave_frame_parser",
                   "Attribute updated : %s",
                   current_attribute.value_to_string().c_str());
    } else {
      sl_log_warning(
        "zwave_frame_parser",
        "Node does not exist in the attribute store. Not updating value");
    }
  }
 
  uint8_t get_trailing_zeroes(const std::bitset<8> &bitset) const;
 
  // Contains the frame data
  std::vector<uint8_t> zwave_report_frame;
  // The first two bytes contains the command class and the command ID
  // Those informations are supposed to be valid when we parse the frame.
  uint8_t current_index = 2;
};
 
#endif  // #ifdef __cplusplus
#endif  // #ifndef ZWAVE_FRAME_PARSER_HPP