Feature comms refactor

.gitignore

@@ -20,6 +20,12 @@ build/
 *.a
 *.tar.xz
 
+# Ignore clangd files
+compile_commands.json
+.cache/
+.clangd
+.clang-format
+
 # Ignore any tools/ directory artifacts
 tools/*.txt
 tools/*.out

Makefile

@@ -49,7 +49,7 @@ SRC_INC_FLAGS := $(addprefix -I,$(SRC_INC_DIRS))
 INCLUDE_FLAGS := $(TEENSY_INC_FLAGS) $(LIBRARY_INC_FLAGS) $(SRC_INC_FLAGS)
 
 # Compiler flags specific to Teensy 4.1
-TEENSY4_FLAGS = -DF_CPU=600000000 -DUSB_CUSTOM -DLAYOUT_US_ENGLISH -D__IMXRT1062__ -DTEENSYDUINO=159 -DARDUINO_TEENSY41 -DARDUINO=10813
+TEENSY4_FLAGS = -DF_CPU=600000000 -DUSB_CUSTOM -DLAYOUT_US_ENGLISH -D__IMXRT1062__ -DTEENSYDUINO=159 -DARDUINO_TEENSY41 -DARDUINO=10813 -DFIRMWARE
 
 # CPU flags to optimize code for the Teensy processor
 CPU_CFLAGS = -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16 -mthumb
@@ -70,9 +70,10 @@ CPPFLAGS := $(INCLUDE_FLAGS) $(DEFINES) -MMD -MP -ffunction-sections -fdata-sect
 CFLAGS := $(CPU_CFLAGS)
 
 # Compiler flags for C++ files
-CXXFLAGS := $(CPU_CFLAGS) -std=gnu++17 \
+CXXFLAGS := $(CPU_CFLAGS) -std=gnu++23 \
             -felide-constructors -fno-exceptions -fpermissive -fno-rtti \
-            -Wno-error=narrowing -Wno-trigraphs -Wno-comment -Wall -Werror
+            -Wno-error=narrowing -Wno-trigraphs -Wno-comment -Wall -Werror \
+			-Wno-volatile
 
 # Linker flags, including Teensy-specific linker script
 # --gc-sections: Remove unused sections to reduce binary size

libraries/QNEthernet/src/QNEthernet.cpp

@@ -221,6 +221,7 @@ bool isDHCP = (ip == INADDR_NONE) &&
       dhcpActive_ = false;
     }
 #endif  // LWIP_DHCP
+    (void)isDHCP;  // Avoid unused variable warning
   }
 #else
   LWIP_UNUSED_ARG(ip);

libraries/QNEthernet/src/lwipopts.h

@@ -64,7 +64,7 @@ void qnethernet_hal_check_core_locking(const char *file, int line,
 #define MEMP_NUM_UDP_PCB                   8  /* 4 */
 #endif  // !MEMP_NUM_UDP_PCB
 #ifndef MEMP_NUM_TCP_PCB
-#define MEMP_NUM_TCP_PCB                   8  /* 5 */
+#define MEMP_NUM_TCP_PCB                   0  /* 5 */
 #endif  // !MEMP_NUM_TCP_PCB
 #ifndef MEMP_NUM_TCP_PCB_LISTEN
 // #define MEMP_NUM_TCP_PCB_LISTEN            8
@@ -75,7 +75,7 @@ void qnethernet_hal_check_core_locking(const char *file, int line,
 // #define MEMP_NUM_FRAG_PBUF                 15
 // #define MEMP_NUM_ARP_QUEUE                 30
 #ifndef MEMP_NUM_IGMP_GROUP
-#define MEMP_NUM_IGMP_GROUP                9  /* 8 */
+#define MEMP_NUM_IGMP_GROUP                0  /* 8 */
 #endif  // !MEMP_NUM_IGMP_GROUP
 /* #define LWIP_NUM_SYS_TIMEOUT_INTERNAL                                \
    (LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2*LWIP_DHCP) + LWIP_ACD + \
@@ -135,7 +135,7 @@ void qnethernet_hal_check_core_locking(const char *file, int line,
 
 // ICMP options
 #ifndef LWIP_ICMP
-#define LWIP_ICMP           LWIP_IPV4  /* 1 */
+#define LWIP_ICMP           0  /* 1 */
 #endif  // LWIP_ICMP
 // #define ICMP_TTL            IP_DEFAULT_TTL
 // #define LWIP_BROADCAST_PING 0
@@ -147,7 +147,7 @@ void qnethernet_hal_check_core_locking(const char *file, int line,
 
 // DHCP options
 #ifndef LWIP_DHCP
-#define LWIP_DHCP                       (LWIP_IPV4 && LWIP_UDP)  /* 0 */
+#define LWIP_DHCP                       0  /* 0 */
 #endif  // !LWIP_DHCP
 #define LWIP_DHCP_DOES_ACD_CHECK        0  /* LWIP_DHCP */
 // #define LWIP_DHCP_BOOTP_FILE            0
@@ -181,7 +181,7 @@ void qnethernet_hal_check_core_locking(const char *file, int line,
 
 // IGMP options
 #ifndef LWIP_IGMP
-#define LWIP_IGMP LWIP_IPV4  /* 0 */
+#define LWIP_IGMP 0  /* 0 */
 #endif  // !LWIP_IGMP
 
 // DNS options
@@ -216,7 +216,7 @@ void qnethernet_hal_check_core_locking(const char *file, int line,
 // TCP options
 
 #ifndef LWIP_TCP
-#define LWIP_TCP                   (LWIP_IPV4 || LWIP_IPV6)  /* 1 */
+#define LWIP_TCP                      0  /* 1 */
 #endif  // !LWIP_TCP
 // #define TCP_TTL                    IP_DEFAULT_TTL
 // #define TCP_MAXRTX                 12

libraries/QNEthernet/src/qnethernet_opts.h

@@ -9,9 +9,9 @@
 
 // Enables the 'altcp_tls_adapter' functions for easier TLS library integration.
 // It's set, by default here, to be enabled if MbedTLS is enabled.
-#ifndef QNETHERNET_ALTCP_TLS_ADAPTER
-#define QNETHERNET_ALTCP_TLS_ADAPTER LWIP_ALTCP_TLS_MBEDTLS
-#endif
+// #ifndef QNETHERNET_ALTCP_TLS_ADAPTER
+// #define QNETHERNET_ALTCP_TLS_ADAPTER LWIP_ALTCP_TLS_MBEDTLS
+// #endif
 
 // Put the RX and TX buffers into RAM1. (Teensy 4)
 #ifndef QNETHERNET_BUFFERS_IN_RAM1

src/comms/SDManager.hpp

@@ -1,8 +1,8 @@
 #ifndef SD_WRAP
 #define SD_WRAP
 
-#include "../../libraries/SD/SD.h"
-#include "../../libraries/SPI/SPI.h"
+#include <SD/SD.h>
+#include <SPI/SPI.h>
 
 #define SD_DIR_LENGTH 256
 

src/comms/comms_layer.cpp

@@ -0,0 +1,170 @@
+#include "comms_layer.hpp"
+
+namespace Comms {
+
+CommsLayer::CommsLayer() {
+    Serial.printf("CommsLayer: constructed\n");
+};
+
+CommsLayer::~CommsLayer() {
+    Serial.printf("CommsLayer: destructed\n");
+};
+
+int CommsLayer::init() {
+    Serial.printf("CommsLayer: initializing\n");
+
+    // hid failing is a fatal error
+    bool hid_init = initialize_hid();
+    if (!hid_init) {
+        Serial.printf("CommsLayer: HIDComms init failed\n");
+        return -1;
+    }
+
+    // ethernet init failing is not a fatal error
+    bool ethernet_init = initialize_ethernet();
+    if (!ethernet_init) {
+        Serial.printf("CommsLayer: EthernetComms init failed\n");
+    }
+
+    Serial.printf("CommsLayer: initialized\n");
+
+    return 0;
+};
+
+int CommsLayer::run() {
+    // read packets from the physical layers
+    recv_packets();
+
+    // write packets to the physical layers
+    send_packets();
+
+    return 0;
+};
+
+void CommsLayer::queue_data(CommsData* data) {
+    switch (data->physical_medium) {
+    case PhysicalMedium::HID:
+        if (!is_hid_connected()) {
+            // discard attempt to send
+            Serial.printf("Attempting to re-route %s to HID but HID is not connected\n", to_string(data->type_label).c_str());
+            break;
+        }
+        m_hid_payload.add(data);
+        break;
+    case PhysicalMedium::Ethernet:
+        // if ethernet is down and it is a small enough packet, route it through HID instead
+        if (!is_ethernet_connected() && data->size < HID_PACKET_PAYLOAD_SIZE) {
+            m_hid_payload.add(data);
+            break;
+        } else if (data->size > HID_PACKET_PAYLOAD_SIZE) {
+            // discard attempt to send
+            Serial.printf("Attempting to re-route %s to HID but packet is too large\n", to_string(data->type_label).c_str());
+            break;
+        }
+
+        m_ethernet_payload.add(data);
+        break;
+    default:
+        assert(false && "Invalid PhysicalMedium");
+    }
+};
+
+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);
+    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);
+    m_ethernet.send_packet(m_ethernet_outgoing);
+};
+
+void CommsLayer::recv_packets() {
+    // defaulted to true so tests can run without physical layers
+    bool hid_recv = true;
+    bool ethernet_recv = true;
+
+    // receive packets from the appropriate physical layer
+    if (m_hid.is_initialized()) {
+        hid_recv = m_hid.recv_packet(m_hid_incoming);
+    }
+    if (m_ethernet.is_initialized()) {
+        ethernet_recv = m_ethernet.recv_packet(m_ethernet_incoming);
+    }
+
+    // process packets
+    if (hid_recv) {
+        m_hid_payload.deconstruct_data(m_hid_incoming.payload(), HID_PACKET_PAYLOAD_SIZE);
+    }
+    if (ethernet_recv) {
+        m_ethernet_payload.deconstruct_data(m_ethernet_incoming.payload(), ETHERNET_PACKET_PAYLOAD_SIZE);
+    }    
+};
+
+bool CommsLayer::is_ethernet_connected() {
+    return m_ethernet.is_initialized() && m_ethernet.is_connected();
+};
+
+bool CommsLayer::is_hid_connected() {
+    return m_hid.is_initialized() && m_hid.is_connected();
+};
+
+void CommsLayer::clear_outgoing_buffers() {
+    m_hid_payload.clear_queues();
+    m_ethernet_payload.clear_queues();
+};
+
+EthernetPacket CommsLayer::get_ethernet_outgoing() {
+    return m_ethernet_outgoing;
+};
+
+HIDPacket CommsLayer::get_hid_outgoing() {
+    return m_hid_outgoing;
+};
+
+void CommsLayer::set_ethernet_incoming(EthernetPacket&& packet) {
+    m_ethernet_incoming = packet;
+};
+
+void CommsLayer::set_hid_incoming(HIDPacket&& packet) {
+    m_hid_incoming = packet;
+};
+
+HiveData& CommsLayer::get_hive_data() {
+    return m_hive_data;
+};
+
+void CommsLayer::set_hive_data(HiveData& data) {
+    m_hive_data = data;
+};
+
+FirmwareData& CommsLayer::get_firmware_data() {
+    return m_firmware_data;
+};
+
+void CommsLayer::set_firmware_data(FirmwareData& data) {
+    m_firmware_data = data;
+};
+
+bool CommsLayer::initialize_hid() {
+    // Initialize the HID physical layer
+    m_hid.init();
+
+    return true;
+};
+
+bool CommsLayer::initialize_ethernet() {
+    // Initialize the Ethernet physical layer
+    if (!m_ethernet.init()) {
+        Serial.println("Ethernet initialization failed");
+        return false;
+    }
+
+    Serial.println("Ethernet initialized successfully");
+
+    return true;
+};
+
+}   // namespace Comms