Branch data     Line data    Source code

       1                 :             : #include <cstring>
       2                 :             : 
       3                 :             : #include "message_codec.hpp"
       4                 :             : 
       5                 :             : #include "esp_rom_crc.h"
       6                 :             : 
       7                 :           7 : size_t MessageCodec::encode(const MessageHeader &header, const void *payload, size_t len, uint8_t *out, size_t out_max)
       8                 :             : {
       9                 :           7 :     size_t total_len = sizeof(MessageHeader) + len + CRC_SIZE;
      10         [ +  + ]:           7 :     if (total_len > out_max || total_len > ESP_NOW_MAX_DATA_LEN) {
      11                 :             :         return 0;
      12                 :             :     }
      13                 :             : 
      14         [ +  + ]:           5 :     if (!out) {
      15                 :             :         return 0;
      16                 :             :     }
      17                 :             : 
      18         [ +  + ]:           4 :     memcpy(out, &header, sizeof(MessageHeader));
      19         [ +  + ]:           4 :     if (payload && len > 0) {
      20                 :           2 :         memcpy(out + sizeof(MessageHeader), payload, len);
      21                 :             :     }
      22                 :             : 
      23                 :           4 :     uint8_t crc = esp_rom_crc8_le(0, out, total_len - CRC_SIZE);
      24                 :           4 :     out[total_len - 1] = crc;
      25                 :             : 
      26                 :           4 :     return total_len;
      27                 :             : }
      28                 :             : 
      29                 :           4 : std::optional<MessageHeader> MessageCodec::decode_header(const uint8_t *data, size_t len)
      30                 :             : {
      31   [ +  +  +  + ]:           4 :     if (len < sizeof(MessageHeader) + CRC_SIZE || !validate_crc(data, len)) {
      32                 :           2 :         return std::nullopt;
      33                 :             :     }
      34                 :             : 
      35                 :           2 :     MessageHeader header;
      36                 :           2 :     memcpy(&header, data, sizeof(MessageHeader));
      37                 :           2 :     return header;
      38                 :             : }
      39                 :             : 
      40                 :           4 : bool MessageCodec::validate_crc(const uint8_t *data, size_t len)
      41                 :             : {
      42         [ +  + ]:           4 :     if (len <= CRC_SIZE) {
      43                 :             :         return false;
      44                 :             :     }
      45                 :             : 
      46                 :           3 :     uint8_t received_crc = data[len - 1];
      47                 :           3 :     uint8_t calculated_crc = calculate_crc(data, len - CRC_SIZE);
      48                 :             : 
      49                 :           3 :     return received_crc == calculated_crc;
      50                 :             : }
      51                 :             : 
      52                 :           3 : uint8_t MessageCodec::calculate_crc(const uint8_t *data, size_t len)
      53                 :             : {
      54                 :           3 :     return esp_rom_crc8_le(0, data, len);
      55                 :             : }