Hive parity

Author: Pandabear1125

src/comms/comms_layer.cpp

@@ -33,7 +33,7 @@ int CommsLayer::init() {
 
 int CommsLayer::run() {
     // read packets from the physical layers
-    recv_packets();
+    receive_packets();
 
     // write packets to the physical layers
     send_packets();
@@ -72,16 +72,16 @@ void CommsLayer::queue_data(CommsData* data) {
 void CommsLayer::send_packets() {
     // prepare and send a HID packet
     m_hid_payload.construct_data();
-    memcpy(m_hid_outgoing.payload(), m_hid_payload.data(), HID_PACKET_PAYLOAD_SIZE);
+    memcpy(m_hid_outgoing.payload(), m_hid_payload.data(), m_hid_payload.get_max_size());
     m_hid.send_packet(m_hid_outgoing);
 
     // prepare and send an ethernet packet
     m_ethernet_payload.construct_data();
-    memcpy(m_ethernet_outgoing.payload(), m_ethernet_payload.data(), ETHERNET_PACKET_PAYLOAD_SIZE);
+    memcpy(m_ethernet_outgoing.payload(), m_ethernet_payload.data(), m_ethernet_payload.get_max_size());
     m_ethernet.send_packet(m_ethernet_outgoing);
 };
 
-void CommsLayer::recv_packets() {
+void CommsLayer::receive_packets() {
     // defaulted to true so tests can run without physical layers
     bool hid_recv = true;
     bool ethernet_recv = true;
@@ -96,10 +96,10 @@ void CommsLayer::recv_packets() {
 
     // process packets
     if (hid_recv) {
-        m_hid_payload.deconstruct_data(m_hid_incoming.payload(), HID_PACKET_PAYLOAD_SIZE);
+        m_hid_payload.deconstruct_data(m_hid_incoming.payload(), m_hid_payload.get_max_size());
     }
     if (ethernet_recv) {
-        m_ethernet_payload.deconstruct_data(m_ethernet_incoming.payload(), ETHERNET_PACKET_PAYLOAD_SIZE);
+        m_ethernet_payload.deconstruct_data(m_ethernet_incoming.payload(), m_ethernet_payload.get_max_size());
     }    
 };
 

src/comms/comms_layer.hpp

@@ -39,7 +39,7 @@ class CommsLayer {
 
     /// @brief Receive and process packets from the appropriate physical layer
     /// @note This function should only be ran internally
-    void recv_packets();
+    void receive_packets();
 
     /// @brief Check if Ethernet is connected
     /// @return True if connected, false if not
@@ -66,14 +66,16 @@ class CommsLayer {
     /// @param packet The incoming HID packet
     void set_hid_incoming(HIDPacket&& packet);
 
-    /// @brief Get the firmware data
+    /// @brief Get the data from Firmware
+    /// @note Populated on outgoing packets
     /// @return The firmware data
     FirmwareData& get_firmware_data();
     /// @brief Set the firmware data
     /// @param data The firmware data to set
     void set_firmware_data(FirmwareData& data);
 
-    /// @brief Get the hive data
+    /// @brief Get the data from Hive
+    /// @note Populated on incoming packets
     /// @return The hive data
     HiveData& get_hive_data();
     /// @brief Set the hive data

src/comms/config_layer.cpp

@@ -74,13 +74,13 @@ const Config* const ConfigLayer::configure(Comms::CommsLayer* comms, bool config
     // memset(outgoing.raw, 0, sizeof(outgoing.raw));
     // comms->set_hid_outgoing(outgoing);
 
-    // Hive marks the config process as done once teensy sends a packet with info_bit == 0
-    // Hive then sends a packet back with info_bit == 0 as well, so ping until we get a non-config back
+    // Hive marks the config process as done once teensy sends a packet with request_bit == 0
+    // Hive then sends a packet back with request_bit == 0 as well, so ping until we get a non-config back
     // TODO: this timeout is a hack, but it seems to work very well. Hive ends up seeing the 0 info bit before firmware does, causing this loop to never end
     uint32_t start = micros();
-    while (comms_layer.get_hive_data().config_section.info_bit == 1 || micros() - start < 500000) {
+    while (comms_layer.get_hive_data().config_section.request_bit == 1 || micros() - start < 500000) {
         Comms::Sendable<ConfigSection> sendable;
-        sendable.data.info_bit = 0;
+        sendable.data.request_bit = 0;
         sendable.send_to_comms();
         comms->run();
     }
@@ -145,13 +145,13 @@ void ConfigLayer::process() {
     in.payload()[0] = 0xff; // filler byte (needed for some reason)
     in.payload()[1] = in_section.section_id;
     in.payload()[2] = in_section.subsection_id;
-    in.payload()[3] = in_section.info_bit;
+    in.payload()[3] = in_section.request_bit;
     *reinterpret_cast<uint16_t*>(in.payload() + 4) = in_section.section_size;
     *reinterpret_cast<uint16_t*>(in.payload() + 6) = in_section.subsection_size;
     memcpy(in.payload() + 8, in_section.raw, 1000);
 
     // if this is the packet we want
-    if (in_section.section_id == seek_sec && in_section.subsection_id == seek_subsec && in_section.info_bit == 1) {
+    if (in_section.section_id == seek_sec && in_section.subsection_id == seek_subsec && in_section.request_bit == 1) {
         // received the initial config packet
         if (in_section.section_id == -1) {
             /*
@@ -205,7 +205,7 @@ void ConfigLayer::process() {
 
     out_section.section_id = seek_sec;
     out_section.subsection_id = seek_subsec;
-    out_section.info_bit = 1;
+    out_section.request_bit = 1;
 
     // if configuration isn't complete, request the next packet
     if (!configured) {

src/comms/data/buff_encoder_data.hpp

@@ -0,0 +1,18 @@
+#pragma once 
+
+#if defined(FIRMWARE)
+#include "comms/data/comms_data.hpp"            // for CommsData
+#elif defined(HIVE)
+#include "modules/comms/data/comms_data.hpp"    // for CommsData
+#endif
+
+#include <stdint.h>                             // uintN_t
+
+/// @brief Structure for the buff encoder sensor.
+struct BuffEncoderData : Comms::CommsData {
+    BuffEncoderData() : CommsData(Comms::TypeLabel::BuffEncoderData, Comms::PhysicalMedium::Ethernet, Comms::Priority::Medium, sizeof(BuffEncoderData)) { }
+    /// Sensor ID.
+    uint8_t id;
+    /// Measured angle.
+    float m_angle;
+};

src/comms/data/comms_data.cpp

@@ -1,7 +1,7 @@
 #include "comms_data.hpp"
 
 #if defined(HIVE)
-#include "doctest/doctest.h"    // for doctest
+#include <doctest/doctest.h>    // for doctest
 
 TEST_CASE("To string does stuff") {
     CHECK(Comms::to_string(Comms::TypeLabel::NONE) == "NONE");

src/comms/data/comms_ref_data.hpp

@@ -0,0 +1,18 @@
+#pragma once 
+
+#if defined(FIRMWARE)
+#include "comms/data/comms_data.hpp"            // for CommsData
+#elif defined(HIVE)
+#include "modules/comms/data/comms_data.hpp"    // for CommsData
+#endif
+
+#include <stdint.h>                             // uintN_t
+
+// TODO: make this nice
+/// @brief Ref data
+struct CommsRefData : Comms::CommsData {
+    CommsRefData() : CommsData(Comms::TypeLabel::CommsRefData, Comms::PhysicalMedium::Ethernet, Comms::Priority::High, sizeof(CommsRefData)) { }
+
+    /// @brief Raw data
+    uint8_t raw[180] = { 0 };
+};

src/comms/data/config_data.hpp

@@ -0,0 +1,32 @@
+#pragma once 
+
+#if defined(FIRMWARE)
+#include "comms/data/comms_data.hpp"            // for CommsData
+#elif defined(HIVE)
+#include "modules/comms/data/comms_data.hpp"    // for CommsData
+#endif
+
+#include <stdint.h>                             // uintN_t
+
+// TODO: make this ethernet capable
+/// @brief Section of a config packet
+struct ConfigSection : Comms::CommsData {
+    ConfigSection() : CommsData(Comms::TypeLabel::ConfigSection, Comms::PhysicalMedium::HID, Comms::Priority::High, sizeof(ConfigSection)) { }
+
+    /// @brief filler byte
+    uint8_t filler = 0xff;
+    /// @brief Section ID
+    int8_t section_id = 0;
+    /// @brief Subsection ID
+    int8_t subsection_id = 0;
+    /// @brief Info bit, stores the config request bit
+    bool request_bit = 0;
+
+    /// @brief Size of the whole section
+    uint16_t section_size = 0;
+    /// @brief Size of the subsection
+    uint16_t subsection_size = 0;
+
+    /// @brief Raw config data
+    uint8_t raw[1000] = { 0 };
+};