MarinoDev/blk_box_common
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

split pub and priv

Browse Source
This commit is contained in:
mitchell
2026-06-30 15:54:17 -05:00
parent ff98d59039
commit d28e81c510
7 changed files with 135 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+1 -1
View File
@@ -1,5 +1,5 @@
idf_component_register(
SRCS "blk_box_common.cpp"
SRCS "bbnow_pub.cpp"
INCLUDE_DIRS "include" "."
# PRIV_REQUIRES
)
blk_box_common.cpp → bbnow_pub.cpp
+36 -37
View File
@@ -1,38 +1,31 @@
#include "blk_box_common.hpp"
#include "bbnow_pub.hpp"
#include <cassert>
#include <cstddef>
#include <cstring>
#include <optional>
#include <stdint.h>
#include <vector>
#include <esp_log.h>
const static char TAG[] = "blk_box_common";
const static char TAG[] = "bbnow_pub";
size_t BlkBoxNowPubPacket::serialize_size() {
size_t BBNowPubPacket::serialize_size() {
switch (this->packet_type) {
case BlkBoxNowPubPacketType::NONE:
case BBNowPubPacketType::NONE:
return -1;
case BlkBoxNowPubPacketType::DISCOVERY:
return BlkBoxNowPubPacket::DISCOVERY_PACKET_SIZE;
case BBNowPubPacketType::DISCOVERY:
return BBNowPubPacket::DISCOVERY_PACKET_SIZE;
}
return -1;
}
std::vector<uint8_t> BlkBoxNowPubPacket::serialize() {
size_t size = this->serialize_size();
if (size == -1) {
return std::vector<uint8_t>(0);
}
std::vector<uint8_t> BBNowPubPacket::serialize() {
auto buf = std::vector<uint8_t>();
buf.reserve(size);
if (this->serialize_size() == -1) {
return buf;
}
this->serialize_into(buf);
return buf;
}
/// Serializes the packet into the given vector.
size_t BlkBoxNowPubPacket::serialize_into(std::vector<uint8_t>& buf) {
size_t BBNowPubPacket::serialize_into(std::vector<uint8_t>& buf) {
size_t initial_size = buf.size();
size_t size = this->serialize_size();
if (size == -1) {
@@ -48,14 +41,16 @@ size_t BlkBoxNowPubPacket::serialize_into(std::vector<uint8_t>& buf) {
buf.push_back((PUB_MAGIC_NUMBER >> 0) & 0xFF);
// push packet type
static_assert(sizeof(this->packet_type) == 1, "expect type field to be 1 byte");
buf.push_back(static_cast<uint8_t>(this->packet_type));
static_assert(sizeof(this->packet_type) == 2, "expect type field to be 2 bytes");
uint16_t packet_type = static_cast<uint16_t>(this->packet_type);
buf.push_back((packet_type >> 8) & 0xFF);
buf.push_back((packet_type >> 0) & 0xFF);
switch (this->packet_type) {
case BlkBoxNowPubPacketType::NONE:
case BBNowPubPacketType::NONE:
break;
case BlkBoxNowPubPacketType::DISCOVERY:
static_assert(sizeof(this->packet_data.discovery) == 2, "expect discovery data to be 2 byte");
case BBNowPubPacketType::DISCOVERY:
static_assert(sizeof(this->packet_data.discovery) == 2, "expect discovery data to be 2 bytes");
uint16_t data = static_cast<uint16_t>(this->packet_data.discovery.expantion_type);
buf.push_back((data >> 8) & 0xFF);
buf.push_back((data >> 0) & 0xFF);
@@ -67,12 +62,15 @@ size_t BlkBoxNowPubPacket::serialize_into(std::vector<uint8_t>& buf) {
}
/// Deserializes a packet from the given bytes.
std::optional<BlkBoxNowPubPacket> BlkBoxNowPubPacket::deserialize(std::span<const uint8_t> bytes) {
std::optional<BBNowPubPacket> BBNowPubPacket::deserialize(std::span<const uint8_t> bytes) {
// first check for magic number and type
if (bytes.size() < 5) {
static_assert(sizeof(PUB_MAGIC_NUMBER) + sizeof(BBNowPubPacketType) == 6, "expect magic and type to be 6 bytes");
if (bytes.size() < 6) {
// not enough room for magic number and type
return std::nullopt;
}
static_assert(sizeof(PUB_MAGIC_NUMBER) == 4, "expect magic number to be 4 bytes");
uint32_t magic_number =
(uint32_t)(bytes[0] << 24) |
(uint32_t)(bytes[1] << 16) |
@@ -85,15 +83,16 @@ std::optional<BlkBoxNowPubPacket> BlkBoxNowPubPacket::deserialize(std::span<cons
}
// magic number matches! this is a blk_box pub packet!
BlkBoxNowPubPacket packet;
BBNowPubPacket packet;
uint8_t packet_type = bytes[4];
packet.packet_type = static_cast<BlkBoxNowPubPacketType>(packet_type);
if (packet.packet_type > BlkBoxNowPubPacketType::MAX) {
static_assert(sizeof(BBNowPubPacketType) == 2, "expect packet type to be 2 bytes");
uint16_t packet_type = ((uint16_t)bytes[4] << 8) | ((uint16_t)bytes[5]);
packet.packet_type = static_cast<BBNowPubPacketType>(packet_type);
if (packet.packet_type > BBNowPubPacketType::MAX) {
ESP_LOGW(TAG, "BlkBoxPubPacketType was NONE! discarding");
return std::nullopt;
}
if (packet.packet_type > BlkBoxNowPubPacketType::MAX) {
if (packet.packet_type > BBNowPubPacketType::MAX) {
ESP_LOGW(TAG, "BlkBoxPubPacketType not in range! discarding");
return std::nullopt;
}
@@ -110,10 +109,10 @@ std::optional<BlkBoxNowPubPacket> BlkBoxNowPubPacket::deserialize(std::span<cons
}
switch (packet.packet_type) {
case BlkBoxNowPubPacketType::NONE:
case BBNowPubPacketType::NONE:
break;
case BlkBoxNowPubPacketType::DISCOVERY:
uint16_t device = ((uint16_t)bytes[5] << 8) | ((uint16_t)bytes[6]);
case BBNowPubPacketType::DISCOVERY:
uint16_t device = ((uint16_t)bytes[6] << 8) | ((uint16_t)bytes[7]);
packet.packet_data.discovery.expantion_type = static_cast<BlkBoxExpantion>(device);
if (packet.packet_data.discovery.expantion_type > BlkBoxExpantion::MAX) {
ESP_LOGW(TAG, "BlkBoxExpantion not in range! discarding");
@@ -124,9 +123,9 @@ std::optional<BlkBoxNowPubPacket> BlkBoxNowPubPacket::deserialize(std::span<cons
return packet;
}
BlkBoxNowPubPacket BlkBoxNowPubPacket::new_discovery(BlkBoxNowPubDiscoveryData data) {
BlkBoxNowPubPacket packet;
packet.packet_type = BlkBoxNowPubPacketType::DISCOVERY;
BBNowPubPacket BBNowPubPacket::new_discovery(BlkBoxNowPubDiscoveryData data) {
BBNowPubPacket packet;
packet.packet_type = BBNowPubPacketType::DISCOVERY;
packet.packet_data.discovery = data;
return packet;
}
include/bb_expantions.hpp
+16
View File
@@ -0,0 +1,16 @@
/// Types for the BLK_BOX expantion devices
#ifndef _BB_EXPANTIONS_H
#define _BB_EXPANTIONS_H
#include <stdint.h>
/// The expantion device ids in the BLK_BOX ecosystem.
enum class BlkBoxExpantion: uint16_t {
NONE = 0,
WIRES = 1,
TENS = 2,
MAX = 2,
};
#endif /* _BB_EXPANTIONS_H */
include/bbnow.hpp
+9
View File
@@ -0,0 +1,9 @@
/// Types for the BLK_BOX NOW protocol
#ifndef _BBNOW_H
#define _BBNOW_H
#include "bbnow_pub.hpp" // IWYU pragma: keep
#include "bbnow_priv.hpp" // IWYU pragma: keep
#endif /* _BBNOW_H */
include/bbnow_priv.hpp
+6
View File
@@ -0,0 +1,6 @@
/// Types for the BLK_BOX NOW priv protocol
#ifndef _BBNOW_PRIV_H
#define _BBNOW_PRIV_H
#endif /* _BBNOW_PRIV_H */
include/bbnow_pub.hpp
+67
View File
@@ -0,0 +1,67 @@
/// Types for the BLK_BOX NOW pub protocol
#ifndef _BBNOW_PUB_H
#define _BBNOW_PUB_H
#include <stdint.h>
#include <vector>
#include <optional>
#include <span>
#include "bb_expantions.hpp"
///////////////////////////////////////
// (1) DISCOVERY //
/////////////////////////////////////
/// The data associated with the `DISCOVERY` type.
struct BlkBoxNowPubDiscoveryData {
BlkBoxExpantion expantion_type{};
};
///////////////////////////////////////
// PUB PACKET //
/////////////////////////////////////
/// The packet type for `BBNowPubPacket`s.
enum class BBNowPubPacketType: uint16_t {
NONE = 0,
DISCOVERY = 1,
MAX = 1,
};
/// The data field for the packet
union BlkBoxNowPubPacketData {
BlkBoxNowPubDiscoveryData discovery;
};
struct BBNowPubPacket {
const static uint32_t PUB_MAGIC_NUMBER = 0x6262'6E70;
// DISCOVERY packet size
const static size_t DISCOVERY_PACKET_SIZE = sizeof(PUB_MAGIC_NUMBER) + sizeof(BBNowPubPacketType) + sizeof(BlkBoxNowPubDiscoveryData);
static_assert(DISCOVERY_PACKET_SIZE == 8, "Discovery packet should be 8 bytes");
/// The type of packet this is.
BBNowPubPacketType packet_type{};
/// The data held by the packet.
BlkBoxNowPubPacketData packet_data{};
/// The size of the serialized packet (in bytes).
size_t serialize_size();
/// Serializes the packet to a vector.
std::vector<uint8_t> serialize();
/// Serializes the packet into the given vector.
///
/// Returns the number of bytes written into the buffer.
size_t serialize_into(std::vector<uint8_t>& buf);
/// Deserializes a packet from the given bytes.
static std::optional<BBNowPubPacket> deserialize(std::span<const uint8_t> bytes);
/// Constructs an empty packet.
BBNowPubPacket() = default;
/// Constructs a new `Discovery` type packet with the given data.
static BBNowPubPacket new_discovery(BlkBoxNowPubDiscoveryData data);
};
#endif /* _BBNOW_PUB_H */
include/blk_box_common.hpp
-62
View File
@@ -1,62 +0,0 @@
/// Types common across the blk_box ecosystem
#ifndef _BLK_BOX_COMMON_H
#define _BLK_BOX_COMMON_H
#include <cstddef>
#include <stdint.h>
#include <vector>
#include <span>
#include <optional>
/// The different expantions to the BLK_BOX.
enum class BlkBoxExpantion: uint16_t {
NONE = 0,
WIRES = 1,
TENS = 2,
MAX = 2,
};
/// The packet type for `BlkBoxNowPubPacket`s.
enum class BlkBoxNowPubPacketType: uint8_t {
NONE = 0,
DISCOVERY = 1,
MAX = 1,
};
/// The data associated with the `DISCOVERY` type.
struct BlkBoxNowPubDiscoveryData {
BlkBoxExpantion expantion_type{};
};
union BlkBoxNowPubPacketData {
BlkBoxNowPubDiscoveryData discovery;
};
struct BlkBoxNowPubPacket {
const static uint32_t PUB_MAGIC_NUMBER = 0x8934'DBE3;
// DISCOVERY packet size
const static size_t DISCOVERY_PACKET_SIZE = sizeof(PUB_MAGIC_NUMBER) + sizeof(BlkBoxNowPubPacketType) + sizeof(BlkBoxNowPubDiscoveryData);
static_assert(DISCOVERY_PACKET_SIZE == 7, "Discovery packet should be 7 bytes");
/// The type of packet this is.
BlkBoxNowPubPacketType packet_type{};
/// The data held by the packet.
BlkBoxNowPubPacketData packet_data{};
/// The size of the serialized packet (in bytes).
size_t serialize_size();
/// Serializes the packet to a vector.
std::vector<uint8_t> serialize();
/// Serializes the packet into the given vector.
size_t serialize_into(std::vector<uint8_t>& buf);
/// Deserializes a packet from the given bytes.
static std::optional<BlkBoxNowPubPacket> deserialize(std::span<const uint8_t> bytes);
/// Constructs an empty packet.
BlkBoxNowPubPacket() = default;
static BlkBoxNowPubPacket new_discovery(BlkBoxNowPubDiscoveryData data);
};
#endif /* _BLK_BOX_COMMON_H */