Merge branch 'dev' into rep-room-acl

# Conflicts:
#	examples/simple_repeater/main.cpp

Author: Scott Powell

examples/simple_repeater/MyMesh.cpp

@@ -207,6 +207,9 @@ void MyMesh::logRx(mesh::Packet *pkt, int len, float score) {
 }
 
 void MyMesh::logTx(mesh::Packet *pkt, int len) {
+#ifdef WITH_BRIDGE
+  bridge->onPacketTransmitted(pkt);
+#endif
   if (_logging) {
     File f = openAppend(PACKET_LOG_FILE);
     if (f) {
@@ -471,6 +474,15 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
                mesh::RTCClock &rtc, mesh::MeshTables &tables)
     : mesh::Mesh(radio, ms, rng, rtc, *new StaticPoolPacketManager(32), tables),
       _cli(board, rtc, &_prefs, this), telemetry(MAX_PACKET_PAYLOAD - 4) {
+#ifdef WITH_BRIDGE
+#if defined(WITH_RS232_BRIDGE)
+    bridge = new RS232Bridge(WITH_RS232_BRIDGE, _mgr, &rtc);
+#elif defined(WITH_ESPNOW_BRIDGE)
+    bridge = new ESPNowBridge(_mgr, &rtc);
+#else
+#error "You must choose either RS232 or ESPNow bridge"
+#endif
+#endif
   memset(known_clients, 0, sizeof(known_clients));
   next_local_advert = next_flood_advert = 0;
   set_radio_at = revert_radio_at = 0;
@@ -655,6 +667,10 @@ void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply
 }
 
 void MyMesh::loop() {
+#ifdef WITH_BRIDGE
+  bridge->loop();
+#endif
+
   mesh::Mesh::loop();
 
   if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {

examples/simple_repeater/MyMesh.h

@@ -21,6 +21,20 @@
 #include <RTClib.h>
 #include <target.h>
 
+#ifdef WITH_RS232_BRIDGE
+#include "helpers/bridges/RS232Bridge.h"
+#define WITH_BRIDGE
+#endif
+
+#ifdef WITH_ESPNOW_BRIDGE
+#include "helpers/bridges/ESPNowBridge.h"
+#define WITH_BRIDGE
+#endif
+
+#ifdef WITH_BRIDGE
+extern AbstractBridge* bridge;
+#endif
+
 struct RepeaterStats {
   uint16_t batt_milli_volts;
   uint16_t curr_tx_queue_len;

examples/simple_repeater/main.cpp

@@ -8,6 +8,10 @@
   static UITask ui_task(display);
 #endif
 
+#ifdef WITH_BRIDGE
+AbstractBridge* bridge;
+#endif
+
 StdRNG fast_rng;
 SimpleMeshTables tables;
 
@@ -23,6 +27,10 @@ void setup() {
   Serial.begin(115200);
   delay(1000);
 
+#ifdef WITH_BRIDGE
+  bridge->begin();
+#endif
+
   board.begin();
 
 #ifdef DISPLAY_CLASS
@@ -34,7 +42,9 @@ void setup() {
   }
 #endif
 
-  if (!radio_init()) { halt(); }
+  if (!radio_init()) {
+    halt();
+  }
 
   fast_rng.begin(radio_get_rng_seed());
 

platformio.ini

@@ -47,6 +47,7 @@ build_src_filter =
   +<*.cpp>
   +<helpers/*.cpp>
   +<helpers/radiolib/*.cpp>
+  +<helpers/bridges/BridgeBase.cpp>
   +<helpers/ui/MomentaryButton.cpp>
 
 ; ----------------- ESP32 ---------------------

src/helpers/AbstractBridge.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <Mesh.h>
+
+class AbstractBridge {
+public:
+  virtual ~AbstractBridge() {}
+
+  /**
+   * @brief Initializes the bridge.
+   */
+  virtual void begin() = 0;
+
+  /**
+   * @brief A method to be called on every main loop iteration.
+   *        Used for tasks like checking for incoming data.
+   */
+  virtual void loop() = 0;
+
+  /**
+   * @brief A callback that is triggered when the mesh transmits a packet.
+   *        The bridge can use this to forward the packet.
+   * 
+   * @param packet The packet that was transmitted.
+   */
+  virtual void onPacketTransmitted(mesh::Packet* packet) = 0;
+
+  /**
+   * @brief Processes a received packet from the bridge's medium.
+   * 
+   * @param packet The packet that was received.
+   */
+  virtual void onPacketReceived(mesh::Packet* packet) = 0;
+};

src/helpers/bridges/BridgeBase.cpp

@@ -0,0 +1,36 @@
+#include "BridgeBase.h"
+
+#include <Arduino.h>
+
+const char *BridgeBase::getLogDateTime() {
+  static char tmp[32];
+  uint32_t now = _rtc->getCurrentTime();
+  DateTime dt = DateTime(now);
+  sprintf(tmp, "%02d:%02d:%02d - %d/%d/%d U", dt.hour(), dt.minute(), dt.second(), dt.day(), dt.month(),
+          dt.year());
+  return tmp;
+}
+
+uint16_t BridgeBase::fletcher16(const uint8_t *data, size_t len) {
+  uint8_t sum1 = 0, sum2 = 0;
+
+  for (size_t i = 0; i < len; i++) {
+    sum1 = (sum1 + data[i]) % 255;
+    sum2 = (sum2 + sum1) % 255;
+  }
+
+  return (sum2 << 8) | sum1;
+}
+
+bool BridgeBase::validateChecksum(const uint8_t *data, size_t len, uint16_t received_checksum) {
+  uint16_t calculated_checksum = fletcher16(data, len);
+  return received_checksum == calculated_checksum;
+}
+
+void BridgeBase::handleReceivedPacket(mesh::Packet *packet) {
+  if (!_seen_packets.hasSeen(packet)) {
+    _mgr->queueInbound(packet, millis() + BRIDGE_DELAY);
+  } else {
+    _mgr->free(packet);
+  }
+}

src/helpers/bridges/BridgeBase.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "helpers/AbstractBridge.h"
+#include "helpers/SimpleMeshTables.h"
+
+#include <RTClib.h>
+
+/**
+ * @brief Base class implementing common bridge functionality
+ *
+ * This class provides common functionality used by different bridge implementations
+ * like packet tracking, checksum calculation, timestamping, and duplicate detection.
+ *
+ * Features:
+ * - Fletcher-16 checksum calculation for data integrity
+ * - Packet duplicate detection using SimpleMeshTables
+ * - Common timestamp formatting for debug logging
+ * - Shared packet management and queuing logic
+ */
+class BridgeBase : public AbstractBridge {
+public:
+  virtual ~BridgeBase() = default;
+
+  /**
+   * @brief Common magic number used by all bridge implementations for packet identification
+   *
+   * This magic number is placed at the beginning of bridge packets to identify
+   * them as mesh bridge packets and provide frame synchronization.
+   */
+  static constexpr uint16_t BRIDGE_PACKET_MAGIC = 0xC03E;
+
+  /**
+   * @brief Common field sizes used by bridge implementations
+   *
+   * These constants define the size of common packet fields used across bridges.
+   * BRIDGE_MAGIC_SIZE is used by all bridges for packet identification.
+   * BRIDGE_LENGTH_SIZE is used by bridges that need explicit length fields (like RS232).
+   * BRIDGE_CHECKSUM_SIZE is used by all bridges for Fletcher-16 checksums.
+   */
+  static constexpr uint16_t BRIDGE_MAGIC_SIZE = sizeof(BRIDGE_PACKET_MAGIC);
+  static constexpr uint16_t BRIDGE_LENGTH_SIZE = sizeof(uint16_t);
+  static constexpr uint16_t BRIDGE_CHECKSUM_SIZE = sizeof(uint16_t);
+
+  /**
+   * @brief Default delay in milliseconds for scheduling inbound packet processing
+   *
+   * It provides a buffer to prevent immediate processing conflicts in the mesh network.
+   * Used in handleReceivedPacket() as: millis() + BRIDGE_DELAY
+   */
+  static constexpr uint16_t BRIDGE_DELAY = 500; // TODO: maybe too high ?
+
+protected:
+  /** Packet manager for allocating and queuing mesh packets */
+  mesh::PacketManager *_mgr;
+
+  /** RTC clock for timestamping debug messages */
+  mesh::RTCClock *_rtc;
+
+  /** Tracks seen packets to prevent loops in broadcast communications */
+  SimpleMeshTables _seen_packets;
+
+  /**
+   * @brief Constructs a BridgeBase instance
+   *
+   * @param mgr PacketManager for allocating and queuing packets
+   * @param rtc RTCClock for timestamping debug messages
+   */
+  BridgeBase(mesh::PacketManager *mgr, mesh::RTCClock *rtc) : _mgr(mgr), _rtc(rtc) {}
+
+  /**
+   * @brief Gets formatted date/time string for logging
+   *
+   * Format: "HH:MM:SS - DD/MM/YYYY U"
+   *
+   * @return Formatted date/time string
+   */
+  const char *getLogDateTime();
+
+  /**
+   * @brief Calculate Fletcher-16 checksum
+   *
+   * Based on: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+   * Used to verify data integrity of received packets
+   *
+   * @param data Pointer to data to calculate checksum for
+   * @param len Length of data in bytes
+   * @return Calculated Fletcher-16 checksum
+   */
+  static uint16_t fletcher16(const uint8_t *data, size_t len);
+
+  /**
+   * @brief Validate received checksum against calculated checksum
+   *
+   * @param data Pointer to data to validate
+   * @param len Length of data in bytes
+   * @param received_checksum Checksum received with data
+   * @return true if checksum is valid, false otherwise
+   */
+  bool validateChecksum(const uint8_t *data, size_t len, uint16_t received_checksum);
+
+  /**
+   * @brief Common packet handling for received packets
+   *
+   * Implements the standard pattern used by all bridges:
+   * - Check if packet was seen before using _seen_packets.hasSeen()
+   * - Queue packet for mesh processing if not seen before
+   * - Free packet if already seen to prevent duplicates
+   *
+   * @param packet The received mesh packet
+   */
+  void handleReceivedPacket(mesh::Packet *packet);
+};