dandri/MeshCore
1
0
Fork 0
mirror of https://github.com/meshcore-dev/MeshCore.git synced 2026-03-30 12:45:45 +00:00
Code Issues 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);
#endif
#ifdef BRIDGE_OVER_SERIAL
#include "bridge/serial/SerialBridge.h"
bridge::SerialBridge *bridge_interface;
#endif
#define FIRMWARE_ROLE "repeater"
#define PACKET_LOG_FILE "/packet_log"
/* ------------------------------ 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_KEEP_ALIVE 0x02
#define REQ_TYPE_GET_TELEMETRY_DATA 0x03
@@ -297,6 +315,20 @@ protected:
}
}
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) {
File f = openAppend(PACKET_LOG_FILE);
if (f) {
@@ -358,9 +390,9 @@ protected:
} else if (strcmp((char *) &data[4], _prefs.guest_password) == 0) { // check guest password
is_admin = false;
} else {
#if MESH_DEBUG
#if MESH_DEBUG
MESH_DEBUG_PRINTLN("Invalid password: %s", &data[4]);
#endif
#endif
return;
}
@@ -377,15 +409,15 @@ protected:
uint32_t now = getRTCClock()->getCurrentTimeUnique();
memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
#if 0
#if 0
memcpy(&reply_data[4], "OK", 2); // legacy response
#else
#else
reply_data[4] = RESP_SERVER_LOGIN_OK;
reply_data[5] = 0; // NEW: recommended keep-alive interval (secs / 16)
reply_data[6] = is_admin ? 1 : 0;
reply_data[7] = 0; // FUTURE: reserved
getRNG()->random(&reply_data[8], 4); // random blob to help packet-hash uniqueness
#endif
#endif
if (packet->isRouteFlood()) {
// 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;
_logging = false;
#if MAX_NEIGHBOURS
#if MAX_NEIGHBOURS
memset(neighbours, 0, sizeof(neighbours));
#endif
#endif
// defaults
memset(&_prefs, 0, sizeof(_prefs));
@@ -712,6 +744,44 @@ public:
}
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();
if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
@@ -745,6 +815,24 @@ static char command[80];
void setup() {
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);
board.begin();
@@ -757,11 +845,6 @@ void setup() {
}
#endif
#ifdef BRIDGE_OVER_SERIAL
bridge_interface = new bridge::SerialBridge();
bridge_interface->setup();
#endif
if (!radio_init()) {
halt();
}
@@ -837,10 +920,6 @@ void loop() {
command[0] = 0; // reset command buffer
}
#ifdef BRIDGE_OVER_SERIAL
bridge_interface->loop();
#endif
the_mesh.loop();
sensors.loop();
}

15
src/Dispatcher.cpp
View File

@@ -117,17 +117,6 @@ void Dispatcher::checkRecv() {
uint8_t raw[MAX_TRANS_UNIT+1];
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) {
logRxRaw(_radio->getLastSNR(), _radio->getLastRSSI(), raw, len);
@@ -293,10 +282,6 @@ void Dispatcher::checkSend() {
}
outbound_expiry = futureMillis(max_airtime);
#ifdef BRIDGE_OVER_SERIAL
bridge_interface->sendPacket(outbound);
#endif
#if MESH_PACKET_LOGGING
Serial.print(getLogDateTime());
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 <string.h>
#ifdef BRIDGE_OVER_SERIAL
#include "bridge/serial/SerialBridge.h"
extern bridge::SerialBridge *bridge_interface;
#endif
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