DG4MLK/MeshCore-Evo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove serial bridge implementation and implement simplified version directly in the repeater source code.

Browse Source
This commit is contained in:
João Brázio
2025-07-08 14:04:21 +01:00
parent 3375389181
commit ac056fb0b9
7 changed files with 100 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
examples/simple_repeater/main.cpp
View File

@@ -72,17 +72,35 @@
static UITask ui_task(display); static UITask ui_task(display);
#endif #endif
#ifdef BRIDGE_OVER_SERIAL
#include "bridge/serial/SerialBridge.h"
bridge::SerialBridge *bridge_interface;
#endif
#define FIRMWARE_ROLE "repeater" #define FIRMWARE_ROLE "repeater"
#define PACKET_LOG_FILE "/packet_log" #define PACKET_LOG_FILE "/packet_log"
/* ------------------------------ Code -------------------------------- */ /* ------------------------------ Code -------------------------------- */
#ifdef BRIDGE_OVER_SERIAL
#define SERIAL_PKT_MAGIC 0xbeef
struct SerialPacket {
uint16_t magic, len, crc;
uint8_t payload[MAX_TRANS_UNIT];
SerialPacket() : magic(SERIAL_PKT_MAGIC), len(0), crc(0) {}
};
// Fletcher-16
// https://en.wikipedia.org/wiki/Fletcher%27s_checksum
static uint16_t fletcher16(const uint8_t *bytes, const size_t len) {
uint8_t sum1 = 0, sum2 = 0;
for (size_t i = 0; i < len; i++) {
sum1 = (sum1 + bytes[i]) % 255;
sum2 = (sum2 + sum1) % 255;
}
return (sum2 << 8) | sum1;
};
#endif
#define REQ_TYPE_GET_STATUS 0x01 // same as _GET_STATS #define REQ_TYPE_GET_STATUS 0x01 // same as _GET_STATS
#define REQ_TYPE_KEEP_ALIVE 0x02 #define REQ_TYPE_KEEP_ALIVE 0x02
#define REQ_TYPE_GET_TELEMETRY_DATA 0x03 #define REQ_TYPE_GET_TELEMETRY_DATA 0x03
@@ -297,6 +315,20 @@ protected:
} }
} }
void logTx(mesh::Packet* pkt, int len) override { void logTx(mesh::Packet* pkt, int len) override {
#ifdef BRIDGE_OVER_SERIAL
SerialPacket spkt;
spkt.len = pkt->writeTo(spkt.payload);
if (spkt.len > 0) {
spkt.crc = fletcher16(spkt.payload, spkt.len);
BRIDGE_OVER_SERIAL.write((uint8_t *)&spkt, sizeof(SerialPacket));
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: Write to serial len=%d crc=0x%04x\n", spkt.len, spkt.crc);
#endif
}
#endif
if (_logging) { if (_logging) {
File f = openAppend(PACKET_LOG_FILE); File f = openAppend(PACKET_LOG_FILE);
if (f) { if (f) {
@@ -358,9 +390,9 @@ protected:
} else if (strcmp((char *) &data[4], _prefs.guest_password) == 0) { // check guest password } else if (strcmp((char *) &data[4], _prefs.guest_password) == 0) { // check guest password
is_admin = false; is_admin = false;
} else { } else {
#if MESH_DEBUG #if MESH_DEBUG
MESH_DEBUG_PRINTLN("Invalid password: %s", &data[4]); MESH_DEBUG_PRINTLN("Invalid password: %s", &data[4]);
#endif #endif
return; return;
} }
@@ -377,15 +409,15 @@ protected:
uint32_t now = getRTCClock()->getCurrentTimeUnique(); uint32_t now = getRTCClock()->getCurrentTimeUnique();
memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
#if 0 #if 0
memcpy(&reply_data[4], "OK", 2); // legacy response memcpy(&reply_data[4], "OK", 2); // legacy response
#else #else
reply_data[4] = RESP_SERVER_LOGIN_OK; reply_data[4] = RESP_SERVER_LOGIN_OK;
reply_data[5] = 0; // NEW: recommended keep-alive interval (secs / 16) reply_data[5] = 0; // NEW: recommended keep-alive interval (secs / 16)
reply_data[6] = is_admin ? 1 : 0; reply_data[6] = is_admin ? 1 : 0;
reply_data[7] = 0; // FUTURE: reserved reply_data[7] = 0; // FUTURE: reserved
getRNG()->random(&reply_data[8], 4); // random blob to help packet-hash uniqueness getRNG()->random(&reply_data[8], 4); // random blob to help packet-hash uniqueness
#endif #endif
if (packet->isRouteFlood()) { if (packet->isRouteFlood()) {
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
@@ -562,9 +594,9 @@ public:
next_local_advert = next_flood_advert = 0; next_local_advert = next_flood_advert = 0;
_logging = false; _logging = false;
#if MAX_NEIGHBOURS #if MAX_NEIGHBOURS
memset(neighbours, 0, sizeof(neighbours)); memset(neighbours, 0, sizeof(neighbours));
#endif #endif
// defaults // defaults
memset(&_prefs, 0, sizeof(_prefs)); memset(&_prefs, 0, sizeof(_prefs));
@@ -712,6 +744,44 @@ public:
} }
void loop() { void loop() {
#ifdef BRIDGE_OVER_SERIAL
static constexpr uint16_t size = sizeof(SerialPacket) + 1;
static uint8_t buffer[size];
static uint16_t tail = 0;
while (BRIDGE_OVER_SERIAL.available()) {
buffer[tail] = (uint8_t)BRIDGE_OVER_SERIAL.read();
MESH_DEBUG_PRINT("%02x ", buffer[tail]);
tail = (tail + 1) % size;
// Check for complete packet by looking back to where the magic number should be
uint16_t head = (tail - sizeof(SerialPacket) + size) % size;
const uint16_t magic = buffer[head] | (buffer[(head + 1) % size] << 8);
if (magic == SERIAL_PKT_MAGIC) {
uint8_t bytes[MAX_TRANS_UNIT];
const uint16_t len = buffer[(head + 2) % size] | (buffer[(head + 3) % size] << 8);
const uint16_t crc = buffer[(head + 4) % size] | (buffer[(head + 5) % size] << 8);
for (size_t i = 0; i < len; i++) {
bytes[i] = buffer[(head + 6 + i) % size];
}
uint16_t f16 = fletcher16(bytes, len);
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: Read from serial len=%d crc=0x%04x valid=%s\n", len, crc, (f16 == crc) ? "true" : "false");
#endif
if (f16 == crc) {
mesh::Packet *pkt = _mgr->allocNew();
pkt->readFrom(bytes, len);
_mgr->queueInbound(pkt, millis());
}
}
}
#endif
mesh::Mesh::loop(); mesh::Mesh::loop();
if (next_flood_advert && millisHasNowPassed(next_flood_advert)) { if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
@@ -745,6 +815,24 @@ static char command[80];
void setup() { void setup() {
Serial.begin(115200); Serial.begin(115200);
#ifdef BRIDGE_OVER_SERIAL
#if defined(ESP32)
BRIDGE_OVER_SERIAL.setPins(BRIDGE_OVER_SERIAL_RX, BRIDGE_OVER_SERIAL_TX);
#elif defined(RP2040_PLATFORM)
BRIDGE_OVER_SERIAL.setRX(BRIDGE_OVER_SERIAL_RX);
BRIDGE_OVER_SERIAL.setTX(BRIDGE_OVER_SERIAL_TX);
#elif defined(STM32_PLATFORM)
BRIDGE_OVER_SERIAL.setRx(BRIDGE_OVER_SERIAL_RX);
BRIDGE_OVER_SERIAL.setTx(BRIDGE_OVER_SERIAL_TX);
#else
#error SerialBridge was not tested on the current platform
#endif
BRIDGE_OVER_SERIAL.begin(115200);
MESH_DEBUG_PRINTLN("Bridge over serial: enabled");
#endif
delay(1000); delay(1000);
board.begin(); board.begin();
@@ -757,11 +845,6 @@ void setup() {
} }
#endif #endif
#ifdef BRIDGE_OVER_SERIAL
bridge_interface = new bridge::SerialBridge();
bridge_interface->setup();
#endif
if (!radio_init()) { if (!radio_init()) {
halt(); halt();
} }
@@ -837,10 +920,6 @@ void loop() {
command[0] = 0; // reset command buffer command[0] = 0; // reset command buffer
} }
#ifdef BRIDGE_OVER_SERIAL
bridge_interface->loop();
#endif
the_mesh.loop(); the_mesh.loop();
sensors.loop(); sensors.loop();
} }

15
src/Dispatcher.cpp
View File

@@ -117,17 +117,6 @@ void Dispatcher::checkRecv() {
uint8_t raw[MAX_TRANS_UNIT+1]; uint8_t raw[MAX_TRANS_UNIT+1];
int len = _radio->recvRaw(raw, MAX_TRANS_UNIT); int len = _radio->recvRaw(raw, MAX_TRANS_UNIT);
#ifdef BRIDGE_OVER_SERIAL
// We are basically stamping metadata from the last RF packet into something that came from serial,
// it works for now. But long term the code on checkRecv() should be refactored to be able to deal
// with both use cases without dupeing the existing code. I've chosen [for now] not to dupe and just
// fake the metadata.
if (len == 0) {
len = bridge_interface->getPacket(raw);
}
#endif
if (len > 0) { if (len > 0) {
logRxRaw(_radio->getLastSNR(), _radio->getLastRSSI(), raw, len); logRxRaw(_radio->getLastSNR(), _radio->getLastRSSI(), raw, len);
@@ -293,10 +282,6 @@ void Dispatcher::checkSend() {
} }
outbound_expiry = futureMillis(max_airtime); outbound_expiry = futureMillis(max_airtime);
#ifdef BRIDGE_OVER_SERIAL
bridge_interface->sendPacket(outbound);
#endif
#if MESH_PACKET_LOGGING #if MESH_PACKET_LOGGING
Serial.print(getLogDateTime()); Serial.print(getLogDateTime());
Serial.printf(": TX, len=%d (type=%d, route=%s, payload_len=%d)", Serial.printf(": TX, len=%d (type=%d, route=%s, payload_len=%d)",

5
src/Dispatcher.h
View File

@@ -6,11 +6,6 @@
#include <Utils.h> #include <Utils.h>
#include <string.h> #include <string.h>
#ifdef BRIDGE_OVER_SERIAL
#include "bridge/serial/SerialBridge.h"
extern bridge::SerialBridge *bridge_interface;
#endif
namespace mesh { namespace mesh {
/** /**

58
src/bridge/serial/Packet.h
View File

@@ -1,58 +0,0 @@
/**
* MeshCore - A new lightweight, hybrid routing mesh protocol for packet radios
* Copyright (c) 2025 Scott Powell / rippleradios.com
*
* This project is maintained by the contributors listed in
* https://github.com/ripplebiz/MeshCore/graphs/contributors
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#pragma once
#include "MeshCore.h"
#include <string.h>
namespace bridge {
/*
* +----------------------------------------------------+
* | SERIAL PACKET SPEC |
* +-----------+---------+------------------------------+
* | TYPE | NAME | DESCRIPTION |
* +-----------+---------+------------------------------+
* | uint16_t | MAGIC | The packet start marker |
* | uint16_t | LEN | Length of the payload |
* | uint16_t | CRC | Checksum for error checking |
* | uint8_t[] | PAYLOAD | Actual rf packet data |
* +-----------+---------+------------------------------+
*/
#define SERIAL_PKT_MAGIC 0xdead
struct Packet {
uint16_t magic, len, crc;
uint8_t payload[MAX_TRANS_UNIT];
Packet() : magic(SERIAL_PKT_MAGIC), len(0), crc(0) {}
};
} // namespace bridge

113
src/bridge/serial/PacketQueue.h
View File

@@ -1,113 +0,0 @@
/**
* MeshCore - A new lightweight, hybrid routing mesh protocol for packet radios
* Copyright (c) 2025 Scott Powell / rippleradios.com
*
* This project is maintained by the contributors listed in
* https://github.com/ripplebiz/MeshCore/graphs/contributors
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#pragma once
#include "MeshCore.h"
#include <Packet.h>
#include <string.h>
#if MESH_PACKET_LOGGING
#include <Arduino.h>
#endif
#ifndef MAX_QUEUE_SIZE
#define MAX_QUEUE_SIZE 8
#endif
namespace bridge {
class PacketQueue {
private:
struct {
size_t len;
uint8_t bytes[MAX_TRANS_UNIT];
} buffer[MAX_QUEUE_SIZE];
protected:
uint16_t head = 0, tail = 0;
public:
size_t available() const { return (tail - head + MAX_QUEUE_SIZE) % MAX_QUEUE_SIZE; }
size_t enqueue(const uint8_t *bytes, const uint8_t len) {
if (len == 0 || len > MAX_TRANS_UNIT) {
#if BRIDGE_DEBUG
Serial.printf("BRIDGE: enqueue() failed len=%d\n", len);
#endif
return 0;
}
if ((tail + 1) % MAX_QUEUE_SIZE == head) { // Buffer full
head = (head + 1) % MAX_QUEUE_SIZE; // Overwrite oldest packet
}
buffer[tail].len = len;
memcpy(buffer[tail].bytes, bytes, len);
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: enqueue() len=%d payload[5]=", len);
for (size_t i = 0; i < len && i < 5; ++i) {
Serial.printf("0x%02x ", buffer[tail].bytes[i]);
}
Serial.printf("\n");
#endif
tail = (tail + 1) % MAX_QUEUE_SIZE;
return len;
}
size_t enqueue(const mesh::Packet *pkt) {
uint8_t bytes[MAX_TRANS_UNIT];
const size_t len = pkt->writeTo(bytes);
return enqueue(bytes, len);
}
size_t dequeue(uint8_t *bytes) {
if (head == tail) { // Buffer empty
return 0;
}
const size_t len = buffer[head].len;
memcpy(bytes, buffer[head].bytes, len);
head = (head + 1) % MAX_QUEUE_SIZE;
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: dequeue() payload[5]=");
for (size_t i = 0; i < len && i < 5; ++i) {
Serial.printf("0x%02x ", bytes[i]);
}
Serial.printf("\n");
#endif
return len;
}
};
} // namespace bridge

135
src/bridge/serial/SerialBridge.cpp
View File

@@ -1,135 +0,0 @@
/**
* MeshCore - A new lightweight, hybrid routing mesh protocol for packet radios
* Copyright (c) 2025 Scott Powell / rippleradios.com
*
* This project is maintained by the contributors listed in
* https://github.com/ripplebiz/MeshCore/graphs/contributors
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "SerialBridge.h"
#include "MeshCore.h"
#include "Packet.h"
// Alternative <HardwareSerial.h> for ESP32
// Alternative <SerialUART.h> for RP2040
#include <Arduino.h>
namespace bridge {
#ifdef BRIDGE_OVER_SERIAL
#if !defined(BRIDGE_OVER_SERIAL_RX) || !defined(BRIDGE_OVER_SERIAL_TX)
#error You must define RX and TX pins
#endif
void SerialBridge::setup() {
#if defined(ESP32)
BRIDGE_OVER_SERIAL.setPins(BRIDGE_OVER_SERIAL_RX, BRIDGE_OVER_SERIAL_TX);
#elif defined(RP2040_PLATFORM)
BRIDGE_OVER_SERIAL.setPinout(BRIDGE_OVER_SERIAL_TX, BRIDGE_OVER_SERIAL_RX);
#else
#error SerialBridge was not tested on the current platform
#endif
BRIDGE_OVER_SERIAL.begin(115200);
Serial.printf("Bridge over serial: enabled\n");
}
void SerialBridge::loop() {
readFromSerial();
writeToSerial();
}
bool SerialBridge::shouldRetransmit(const mesh::Packet *pkt) {
if (pkt->isMarkedDoNotRetransmit()) {
return false;
}
}
size_t SerialBridge::getPacket(uint8_t *bytes) {
return rx_queue.dequeue(bytes);
}
size_t SerialBridge::sendPacket(const mesh::Packet *pkt) {
if (shouldRetransmit(pkt)) return 0;
const size_t len = tx_queue.enqueue(pkt);
return len;
}
void SerialBridge::readFromSerial() {
static constexpr uint16_t size = sizeof(bridge::Packet) + 1;
static uint8_t buffer[size];
static uint16_t tail = 0;
while (BRIDGE_OVER_SERIAL.available()) {
buffer[tail] = (uint8_t)BRIDGE_OVER_SERIAL.read();
tail = (tail + 1) % size;
#if BRIDGE_OVER_SERIAL_DEBUG
Serial.printf("%02x ", buffer[(tail - 1 + size) % size]);
#endif
// Check for complete packet by looking back to where the magic number should be
uint16_t head = (tail - sizeof(bridge::Packet) + size) % size;
const uint16_t magic = buffer[head] | (buffer[(head + 1) % size] << 8);
if (magic == SERIAL_PKT_MAGIC) {
const uint16_t len = buffer[(head + 2) % size] | (buffer[(head + 3) % size] << 8);
const uint16_t crc = buffer[(head + 4) % size] | (buffer[(head + 5) % size] << 8);
uint8_t payload[MAX_TRANS_UNIT];
for (size_t i = 0; i < len; i++) {
payload[i] = buffer[(head + 6 + i) % size];
}
const bool valid = verifyCRC(payload, len, crc);
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: Read from serial len=%d crc=0x%04x\n", len, crc);
#endif
if (verifyCRC(payload, len, crc)) {
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: Received packet was validated\n");
#endif
rx_queue.enqueue(payload, len);
}
}
}
}
void SerialBridge::writeToSerial() {
bridge::Packet pkt;
if (!tx_queue.available()) return;
pkt.len = tx_queue.dequeue(pkt.payload);
if (pkt.len > 0) {
pkt.crc = SerialBridge::calculateCRC(pkt.payload, pkt.len);
BRIDGE_OVER_SERIAL.write((uint8_t *)&pkt, sizeof(bridge::Packet));
#if MESH_PACKET_LOGGING
Serial.printf("BRIDGE: Write to serial len=%d crc=0x%04x\n", pkt.len, pkt.crc);
#endif
}
}
#endif
} // namespace bridge

73
src/bridge/serial/SerialBridge.h
View File

@@ -1,73 +0,0 @@
/**
* MeshCore - A new lightweight, hybrid routing mesh protocol for packet radios
* Copyright (c) 2025 Scott Powell / rippleradios.com
*
* This project is maintained by the contributors listed in
* https://github.com/ripplebiz/MeshCore/graphs/contributors
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#pragma once
#include "Packet.h"
#include "PacketQueue.h"
#include <Packet.h>
namespace bridge {
class SerialBridge {
private:
PacketQueue rx_queue, tx_queue;
protected:
bool shouldRetransmit(const mesh::Packet *);
public:
void loop();
void setup();
void readFromSerial();
void writeToSerial();
size_t getPacket(uint8_t *);
size_t sendPacket(const mesh::Packet *);
static uint16_t calculateCRC(const uint8_t *bytes, size_t len) {
// Fletcher-16
// https://en.wikipedia.org/wiki/Fletcher%27s_checksum
uint8_t sum1 = 0, sum2 = 0;
for (size_t i = 0; i < len; i++) {
sum1 = (sum1 + bytes[i]) % 255;
sum2 = (sum2 + sum1) % 255;
}
return (sum2 << 8) | sum1;
};
static bool verifyCRC(const uint8_t *bytes, size_t len, uint16_t crc) {
uint16_t computedChecksum = calculateCRC(bytes, len);
return (computedChecksum == crc);
}
};
} // namespace bridge