mirror of https://github.com/meshcore-dev/MeshCore
Kelsey Hudson
9 months ago
82 changed files with 5209 additions and 2053 deletions
@ -0,0 +1,38 @@ |
|||
/* Linker script to configure memory regions. */ |
|||
|
|||
SEARCH_DIR(.) |
|||
GROUP(-lgcc -lc -lnosys) |
|||
|
|||
MEMORY |
|||
{ |
|||
FLASH (rx) : ORIGIN = 0x26000, LENGTH = 0xD4000 - 0x26000 |
|||
|
|||
/* SRAM required by Softdevice depend on |
|||
* - Attribute Table Size (Number of Services and Characteristics) |
|||
* - Vendor UUID count |
|||
* - Max ATT MTU |
|||
* - Concurrent connection peripheral + central + secure links |
|||
* - Event Len, HVN queue, Write CMD queue |
|||
*/ |
|||
RAM (rwx) : ORIGIN = 0x20006000, LENGTH = 0x20040000 - 0x20006000 |
|||
} |
|||
|
|||
SECTIONS |
|||
{ |
|||
. = ALIGN(4); |
|||
.svc_data : |
|||
{ |
|||
PROVIDE(__start_svc_data = .); |
|||
KEEP(*(.svc_data)) |
|||
PROVIDE(__stop_svc_data = .); |
|||
} > RAM |
|||
|
|||
.fs_data : |
|||
{ |
|||
PROVIDE(__start_fs_data = .); |
|||
KEEP(*(.fs_data)) |
|||
PROVIDE(__stop_fs_data = .); |
|||
} > RAM |
|||
} INSERT AFTER .data; |
|||
|
|||
INCLUDE "nrf52_common.ld" |
|||
@ -0,0 +1,38 @@ |
|||
/* Linker script to configure memory regions. */ |
|||
|
|||
SEARCH_DIR(.) |
|||
GROUP(-lgcc -lc -lnosys) |
|||
|
|||
MEMORY |
|||
{ |
|||
FLASH (rx) : ORIGIN = 0x27000, LENGTH = 0xD4000 - 0x27000 |
|||
|
|||
/* SRAM required by Softdevice depend on |
|||
* - Attribute Table Size (Number of Services and Characteristics) |
|||
* - Vendor UUID count |
|||
* - Max ATT MTU |
|||
* - Concurrent connection peripheral + central + secure links |
|||
* - Event Len, HVN queue, Write CMD queue |
|||
*/ |
|||
RAM (rwx) : ORIGIN = 0x20006000, LENGTH = 0x20040000 - 0x20006000 |
|||
} |
|||
|
|||
SECTIONS |
|||
{ |
|||
. = ALIGN(4); |
|||
.svc_data : |
|||
{ |
|||
PROVIDE(__start_svc_data = .); |
|||
KEEP(*(.svc_data)) |
|||
PROVIDE(__stop_svc_data = .); |
|||
} > RAM |
|||
|
|||
.fs_data : |
|||
{ |
|||
PROVIDE(__start_fs_data = .); |
|||
KEEP(*(.fs_data)) |
|||
PROVIDE(__stop_fs_data = .); |
|||
} > RAM |
|||
} INSERT AFTER .data; |
|||
|
|||
INCLUDE "nrf52_common.ld" |
|||
@ -0,0 +1,701 @@ |
|||
#include "MyMesh.h" |
|||
|
|||
/* ------------------------------ Config -------------------------------- */ |
|||
|
|||
#ifndef LORA_FREQ |
|||
#define LORA_FREQ 915.0 |
|||
#endif |
|||
#ifndef LORA_BW |
|||
#define LORA_BW 250 |
|||
#endif |
|||
#ifndef LORA_SF |
|||
#define LORA_SF 10 |
|||
#endif |
|||
#ifndef LORA_CR |
|||
#define LORA_CR 5 |
|||
#endif |
|||
#ifndef LORA_TX_POWER |
|||
#define LORA_TX_POWER 20 |
|||
#endif |
|||
|
|||
#ifndef ADVERT_NAME |
|||
#define ADVERT_NAME "repeater" |
|||
#endif |
|||
#ifndef ADVERT_LAT |
|||
#define ADVERT_LAT 0.0 |
|||
#endif |
|||
#ifndef ADVERT_LON |
|||
#define ADVERT_LON 0.0 |
|||
#endif |
|||
|
|||
#ifndef ADMIN_PASSWORD |
|||
#define ADMIN_PASSWORD "password" |
|||
#endif |
|||
|
|||
#ifndef SERVER_RESPONSE_DELAY |
|||
#define SERVER_RESPONSE_DELAY 300 |
|||
#endif |
|||
|
|||
#ifndef TXT_ACK_DELAY |
|||
#define TXT_ACK_DELAY 200 |
|||
#endif |
|||
|
|||
#define REQ_TYPE_GET_STATUS 0x01 // same as _GET_STATS
|
|||
#define REQ_TYPE_KEEP_ALIVE 0x02 |
|||
#define REQ_TYPE_GET_TELEMETRY_DATA 0x03 |
|||
|
|||
#define RESP_SERVER_LOGIN_OK 0 // response to ANON_REQ
|
|||
|
|||
#define CLI_REPLY_DELAY_MILLIS 600 |
|||
|
|||
|
|||
ClientInfo *MyMesh::putClient(const mesh::Identity &id) { |
|||
uint32_t min_time = 0xFFFFFFFF; |
|||
ClientInfo *oldest = &known_clients[0]; |
|||
for (int i = 0; i < MAX_CLIENTS; i++) { |
|||
if (known_clients[i].last_activity < min_time) { |
|||
oldest = &known_clients[i]; |
|||
min_time = oldest->last_activity; |
|||
} |
|||
if (id.matches(known_clients[i].id)) return &known_clients[i]; // already known
|
|||
} |
|||
|
|||
oldest->id = id; |
|||
oldest->out_path_len = -1; // initially out_path is unknown
|
|||
oldest->last_timestamp = 0; |
|||
return oldest; |
|||
} |
|||
|
|||
void MyMesh::putNeighbour(const mesh::Identity &id, uint32_t timestamp, float snr) { |
|||
#if MAX_NEIGHBOURS // check if neighbours enabled
|
|||
// find existing neighbour, else use least recently updated
|
|||
uint32_t oldest_timestamp = 0xFFFFFFFF; |
|||
NeighbourInfo *neighbour = &neighbours[0]; |
|||
for (int i = 0; i < MAX_NEIGHBOURS; i++) { |
|||
// if neighbour already known, we should update it
|
|||
if (id.matches(neighbours[i].id)) { |
|||
neighbour = &neighbours[i]; |
|||
break; |
|||
} |
|||
|
|||
// otherwise we should update the least recently updated neighbour
|
|||
if (neighbours[i].heard_timestamp < oldest_timestamp) { |
|||
neighbour = &neighbours[i]; |
|||
oldest_timestamp = neighbour->heard_timestamp; |
|||
} |
|||
} |
|||
|
|||
// update neighbour info
|
|||
neighbour->id = id; |
|||
neighbour->advert_timestamp = timestamp; |
|||
neighbour->heard_timestamp = getRTCClock()->getCurrentTime(); |
|||
neighbour->snr = (int8_t)(snr * 4); |
|||
#endif |
|||
} |
|||
|
|||
int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t *payload, |
|||
size_t payload_len) { |
|||
// uint32_t now = getRTCClock()->getCurrentTimeUnique();
|
|||
// memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
|
|||
memcpy(reply_data, &sender_timestamp, |
|||
4); // reflect sender_timestamp back in response packet (kind of like a 'tag')
|
|||
|
|||
switch (payload[0]) { |
|||
case REQ_TYPE_GET_STATUS: { // guests can also access this now
|
|||
RepeaterStats stats; |
|||
stats.batt_milli_volts = board.getBattMilliVolts(); |
|||
stats.curr_tx_queue_len = _mgr->getOutboundCount(0xFFFFFFFF); |
|||
stats.noise_floor = (int16_t)_radio->getNoiseFloor(); |
|||
stats.last_rssi = (int16_t)radio_driver.getLastRSSI(); |
|||
stats.n_packets_recv = radio_driver.getPacketsRecv(); |
|||
stats.n_packets_sent = radio_driver.getPacketsSent(); |
|||
stats.total_air_time_secs = getTotalAirTime() / 1000; |
|||
stats.total_up_time_secs = _ms->getMillis() / 1000; |
|||
stats.n_sent_flood = getNumSentFlood(); |
|||
stats.n_sent_direct = getNumSentDirect(); |
|||
stats.n_recv_flood = getNumRecvFlood(); |
|||
stats.n_recv_direct = getNumRecvDirect(); |
|||
stats.err_events = _err_flags; |
|||
stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4); |
|||
stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups(); |
|||
stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups(); |
|||
stats.total_rx_air_time_secs = getReceiveAirTime() / 1000; |
|||
|
|||
memcpy(&reply_data[4], &stats, sizeof(stats)); |
|||
|
|||
return 4 + sizeof(stats); // reply_len
|
|||
} |
|||
case REQ_TYPE_GET_TELEMETRY_DATA: { |
|||
uint8_t perm_mask = ~(payload[1]); // NEW: first reserved byte (of 4), is now inverse mask to apply to permissions
|
|||
|
|||
telemetry.reset(); |
|||
telemetry.addVoltage(TELEM_CHANNEL_SELF, (float)board.getBattMilliVolts() / 1000.0f); |
|||
// query other sensors -- target specific
|
|||
sensors.querySensors((sender->is_admin ? 0xFF : 0x00) & perm_mask, telemetry); |
|||
|
|||
uint8_t tlen = telemetry.getSize(); |
|||
memcpy(&reply_data[4], telemetry.getBuffer(), tlen); |
|||
return 4 + tlen; // reply_len
|
|||
} |
|||
} |
|||
return 0; // unknown command
|
|||
} |
|||
|
|||
mesh::Packet *MyMesh::createSelfAdvert() { |
|||
uint8_t app_data[MAX_ADVERT_DATA_SIZE]; |
|||
uint8_t app_data_len; |
|||
{ |
|||
AdvertDataBuilder builder(ADV_TYPE_REPEATER, _prefs.node_name, _prefs.node_lat, _prefs.node_lon); |
|||
app_data_len = builder.encodeTo(app_data); |
|||
} |
|||
|
|||
return createAdvert(self_id, app_data, app_data_len); |
|||
} |
|||
|
|||
File MyMesh::openAppend(const char *fname) { |
|||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) |
|||
return _fs->open(fname, FILE_O_WRITE); |
|||
#elif defined(RP2040_PLATFORM) |
|||
return _fs->open(fname, "a"); |
|||
#else |
|||
return _fs->open(fname, "a", true); |
|||
#endif |
|||
} |
|||
|
|||
bool MyMesh::allowPacketForward(const mesh::Packet *packet) { |
|||
if (_prefs.disable_fwd) return false; |
|||
if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false; |
|||
return true; |
|||
} |
|||
|
|||
const char *MyMesh::getLogDateTime() { |
|||
static char tmp[32]; |
|||
uint32_t now = getRTCClock()->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; |
|||
} |
|||
|
|||
void MyMesh::logRxRaw(float snr, float rssi, const uint8_t raw[], int len) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.print(getLogDateTime()); |
|||
Serial.print(" RAW: "); |
|||
mesh::Utils::printHex(Serial, raw, len); |
|||
Serial.println(); |
|||
#endif |
|||
} |
|||
|
|||
void MyMesh::logRx(mesh::Packet *pkt, int len, float score) { |
|||
if (_logging) { |
|||
File f = openAppend(PACKET_LOG_FILE); |
|||
if (f) { |
|||
f.print(getLogDateTime()); |
|||
f.printf(": RX, len=%d (type=%d, route=%s, payload_len=%d) SNR=%d RSSI=%d score=%d", len, |
|||
pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len, |
|||
(int)_radio->getLastSNR(), (int)_radio->getLastRSSI(), (int)(score * 1000)); |
|||
|
|||
if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ || |
|||
pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) { |
|||
f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]); |
|||
} else { |
|||
f.printf("\n"); |
|||
} |
|||
f.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
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) { |
|||
f.print(getLogDateTime()); |
|||
f.printf(": TX, len=%d (type=%d, route=%s, payload_len=%d)", len, pkt->getPayloadType(), |
|||
pkt->isRouteDirect() ? "D" : "F", pkt->payload_len); |
|||
|
|||
if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ || |
|||
pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) { |
|||
f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]); |
|||
} else { |
|||
f.printf("\n"); |
|||
} |
|||
f.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void MyMesh::logTxFail(mesh::Packet *pkt, int len) { |
|||
if (_logging) { |
|||
File f = openAppend(PACKET_LOG_FILE); |
|||
if (f) { |
|||
f.print(getLogDateTime()); |
|||
f.printf(": TX FAIL!, len=%d (type=%d, route=%s, payload_len=%d)\n", len, pkt->getPayloadType(), |
|||
pkt->isRouteDirect() ? "D" : "F", pkt->payload_len); |
|||
f.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
int MyMesh::calcRxDelay(float score, uint32_t air_time) const { |
|||
if (_prefs.rx_delay_base <= 0.0f) return 0; |
|||
return (int)((pow(_prefs.rx_delay_base, 0.85f - score) - 1.0) * air_time); |
|||
} |
|||
|
|||
uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) { |
|||
uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.tx_delay_factor); |
|||
return getRNG()->nextInt(0, 6) * t; |
|||
} |
|||
uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) { |
|||
uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor); |
|||
return getRNG()->nextInt(0, 6) * t; |
|||
} |
|||
|
|||
void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const mesh::Identity &sender, |
|||
uint8_t *data, size_t len) { |
|||
if (packet->getPayloadType() == PAYLOAD_TYPE_ANON_REQ) { // received an initial request by a possible admin
|
|||
// client (unknown at this stage)
|
|||
uint32_t timestamp; |
|||
memcpy(×tamp, data, 4); |
|||
|
|||
bool is_admin; |
|||
data[len] = 0; // ensure null terminator
|
|||
if (strcmp((char *)&data[4], _prefs.password) == 0) { // check for valid password
|
|||
is_admin = true; |
|||
} else if (strcmp((char *)&data[4], _prefs.guest_password) == 0) { // check guest password
|
|||
is_admin = false; |
|||
} else { |
|||
#if MESH_DEBUG |
|||
MESH_DEBUG_PRINTLN("Invalid password: %s", &data[4]); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
auto client = putClient(sender); // add to known clients (if not already known)
|
|||
if (timestamp <= client->last_timestamp) { |
|||
MESH_DEBUG_PRINTLN("Possible login replay attack!"); |
|||
return; // FATAL: client table is full -OR- replay attack
|
|||
} |
|||
|
|||
MESH_DEBUG_PRINTLN("Login success!"); |
|||
client->last_timestamp = timestamp; |
|||
client->last_activity = getRTCClock()->getCurrentTime(); |
|||
client->is_admin = is_admin; |
|||
memcpy(client->secret, secret, PUB_KEY_SIZE); |
|||
|
|||
uint32_t now = getRTCClock()->getCurrentTimeUnique(); |
|||
memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
|
|||
#if 0 |
|||
memcpy(&reply_data[4], "OK", 2); // legacy response
|
|||
#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 |
|||
|
|||
if (packet->isRouteFlood()) { |
|||
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
|
|||
mesh::Packet *path = createPathReturn(sender, client->secret, packet->path, packet->path_len, |
|||
PAYLOAD_TYPE_RESPONSE, reply_data, 12); |
|||
if (path) sendFlood(path, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->secret, reply_data, 12); |
|||
if (reply) { |
|||
if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
|
|||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
sendFlood(reply, SERVER_RESPONSE_DELAY); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
int MyMesh::searchPeersByHash(const uint8_t *hash) { |
|||
int n = 0; |
|||
for (int i = 0; i < MAX_CLIENTS; i++) { |
|||
if (known_clients[i].id.isHashMatch(hash)) { |
|||
matching_peer_indexes[n++] = i; // store the INDEXES of matching contacts (for subsequent 'peer' methods)
|
|||
} |
|||
} |
|||
return n; |
|||
} |
|||
|
|||
void MyMesh::getPeerSharedSecret(uint8_t *dest_secret, int peer_idx) { |
|||
int i = matching_peer_indexes[peer_idx]; |
|||
if (i >= 0 && i < MAX_CLIENTS) { |
|||
// lookup pre-calculated shared_secret
|
|||
memcpy(dest_secret, known_clients[i].secret, PUB_KEY_SIZE); |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("getPeerSharedSecret: Invalid peer idx: %d", i); |
|||
} |
|||
} |
|||
|
|||
void MyMesh::onAdvertRecv(mesh::Packet *packet, const mesh::Identity &id, uint32_t timestamp, |
|||
const uint8_t *app_data, size_t app_data_len) { |
|||
mesh::Mesh::onAdvertRecv(packet, id, timestamp, app_data, app_data_len); // chain to super impl
|
|||
|
|||
// if this a zero hop advert, add it to neighbours
|
|||
if (packet->path_len == 0) { |
|||
AdvertDataParser parser(app_data, app_data_len); |
|||
if (parser.isValid() && parser.getType() == ADV_TYPE_REPEATER) { // just keep neigbouring Repeaters
|
|||
putNeighbour(id, timestamp, packet->getSNR()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, const uint8_t *secret, |
|||
uint8_t *data, size_t len) { |
|||
int i = matching_peer_indexes[sender_idx]; |
|||
if (i < 0 || |
|||
i >= MAX_CLIENTS) { // get from our known_clients table (sender SHOULD already be known in this context)
|
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: invalid peer idx: %d", i); |
|||
return; |
|||
} |
|||
auto client = &known_clients[i]; |
|||
if (type == PAYLOAD_TYPE_REQ) { // request (from a Known admin client!)
|
|||
uint32_t timestamp; |
|||
memcpy(×tamp, data, 4); |
|||
|
|||
if (timestamp > client->last_timestamp) { // prevent replay attacks
|
|||
int reply_len = handleRequest(client, timestamp, &data[4], len - 4); |
|||
if (reply_len == 0) return; // invalid command
|
|||
|
|||
client->last_timestamp = timestamp; |
|||
client->last_activity = getRTCClock()->getCurrentTime(); |
|||
|
|||
if (packet->isRouteFlood()) { |
|||
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
|
|||
mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len, |
|||
PAYLOAD_TYPE_RESPONSE, reply_data, reply_len); |
|||
if (path) sendFlood(path, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
mesh::Packet *reply = |
|||
createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len); |
|||
if (reply) { |
|||
if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
|
|||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
sendFlood(reply, SERVER_RESPONSE_DELAY); |
|||
} |
|||
} |
|||
} |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected"); |
|||
} |
|||
} else if (type == PAYLOAD_TYPE_TXT_MSG && len > 5 && client->is_admin) { // a CLI command
|
|||
uint32_t sender_timestamp; |
|||
memcpy(&sender_timestamp, data, 4); // timestamp (by sender's RTC clock - which could be wrong)
|
|||
uint flags = (data[4] >> 2); // message attempt number, and other flags
|
|||
|
|||
if (!(flags == TXT_TYPE_PLAIN || flags == TXT_TYPE_CLI_DATA)) { |
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: unsupported text type received: flags=%02x", (uint32_t)flags); |
|||
} else if (sender_timestamp >= client->last_timestamp) { // prevent replay attacks
|
|||
bool is_retry = (sender_timestamp == client->last_timestamp); |
|||
client->last_timestamp = sender_timestamp; |
|||
client->last_activity = getRTCClock()->getCurrentTime(); |
|||
|
|||
// len can be > original length, but 'text' will be padded with zeroes
|
|||
data[len] = 0; // need to make a C string again, with null terminator
|
|||
|
|||
if (flags == TXT_TYPE_PLAIN) { // for legacy CLI, send Acks
|
|||
uint32_t ack_hash; // calc truncated hash of the message timestamp + text + sender pub_key, to prove
|
|||
// to sender that we got it
|
|||
mesh::Utils::sha256((uint8_t *)&ack_hash, 4, data, 5 + strlen((char *)&data[5]), client->id.pub_key, |
|||
PUB_KEY_SIZE); |
|||
|
|||
mesh::Packet *ack = createAck(ack_hash); |
|||
if (ack) { |
|||
if (client->out_path_len < 0) { |
|||
sendFlood(ack, TXT_ACK_DELAY); |
|||
} else { |
|||
sendDirect(ack, client->out_path, client->out_path_len, TXT_ACK_DELAY); |
|||
} |
|||
} |
|||
} |
|||
|
|||
uint8_t temp[166]; |
|||
char *command = (char *)&data[5]; |
|||
char *reply = (char *)&temp[5]; |
|||
if (is_retry) { |
|||
*reply = 0; |
|||
} else { |
|||
handleCommand(sender_timestamp, command, reply); |
|||
} |
|||
int text_len = strlen(reply); |
|||
if (text_len > 0) { |
|||
uint32_t timestamp = getRTCClock()->getCurrentTimeUnique(); |
|||
if (timestamp == sender_timestamp) { |
|||
// WORKAROUND: the two timestamps need to be different, in the CLI view
|
|||
timestamp++; |
|||
} |
|||
memcpy(temp, ×tamp, 4); // mostly an extra blob to help make packet_hash unique
|
|||
temp[4] = (TXT_TYPE_CLI_DATA << 2); // NOTE: legacy was: TXT_TYPE_PLAIN
|
|||
|
|||
auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len); |
|||
if (reply) { |
|||
if (client->out_path_len < 0) { |
|||
sendFlood(reply, CLI_REPLY_DELAY_MILLIS); |
|||
} else { |
|||
sendDirect(reply, client->out_path, client->out_path_len, CLI_REPLY_DELAY_MILLIS); |
|||
} |
|||
} |
|||
} |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
bool MyMesh::onPeerPathRecv(mesh::Packet *packet, int sender_idx, const uint8_t *secret, uint8_t *path, |
|||
uint8_t path_len, uint8_t extra_type, uint8_t *extra, uint8_t extra_len) { |
|||
// TODO: prevent replay attacks
|
|||
int i = matching_peer_indexes[sender_idx]; |
|||
|
|||
if (i >= 0 && |
|||
i < MAX_CLIENTS) { // get from our known_clients table (sender SHOULD already be known in this context)
|
|||
MESH_DEBUG_PRINTLN("PATH to client, path_len=%d", (uint32_t)path_len); |
|||
auto client = &known_clients[i]; |
|||
memcpy(client->out_path, path, client->out_path_len = path_len); // store a copy of path, for sendDirect()
|
|||
} else { |
|||
MESH_DEBUG_PRINTLN("onPeerPathRecv: invalid peer idx: %d", i); |
|||
} |
|||
|
|||
// NOTE: no reciprocal path send!!
|
|||
return false; |
|||
} |
|||
|
|||
MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondClock &ms, mesh::RNG &rng, |
|||
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) |
|||
#if defined(WITH_RS232_BRIDGE) |
|||
, bridge(WITH_RS232_BRIDGE, _mgr, &rtc) |
|||
#elif defined(WITH_ESPNOW_BRIDGE) |
|||
, bridge(_mgr, &rtc) |
|||
#endif |
|||
{ |
|||
memset(known_clients, 0, sizeof(known_clients)); |
|||
next_local_advert = next_flood_advert = 0; |
|||
set_radio_at = revert_radio_at = 0; |
|||
_logging = false; |
|||
|
|||
#if MAX_NEIGHBOURS |
|||
memset(neighbours, 0, sizeof(neighbours)); |
|||
#endif |
|||
|
|||
// defaults
|
|||
memset(&_prefs, 0, sizeof(_prefs)); |
|||
_prefs.airtime_factor = 1.0; // one half
|
|||
_prefs.rx_delay_base = 0.0f; // turn off by default, was 10.0;
|
|||
_prefs.tx_delay_factor = 0.5f; // was 0.25f
|
|||
StrHelper::strncpy(_prefs.node_name, ADVERT_NAME, sizeof(_prefs.node_name)); |
|||
_prefs.node_lat = ADVERT_LAT; |
|||
_prefs.node_lon = ADVERT_LON; |
|||
StrHelper::strncpy(_prefs.password, ADMIN_PASSWORD, sizeof(_prefs.password)); |
|||
_prefs.freq = LORA_FREQ; |
|||
_prefs.sf = LORA_SF; |
|||
_prefs.bw = LORA_BW; |
|||
_prefs.cr = LORA_CR; |
|||
_prefs.tx_power_dbm = LORA_TX_POWER; |
|||
_prefs.advert_interval = 1; // default to 2 minutes for NEW installs
|
|||
_prefs.flood_advert_interval = 12; // 12 hours
|
|||
_prefs.flood_max = 64; |
|||
_prefs.interference_threshold = 0; // disabled
|
|||
} |
|||
|
|||
void MyMesh::begin(FILESYSTEM *fs) { |
|||
mesh::Mesh::begin(); |
|||
_fs = fs; |
|||
// load persisted prefs
|
|||
_cli.loadPrefs(_fs); |
|||
|
|||
#ifdef WITH_BRIDGE |
|||
bridge.begin(); |
|||
#endif |
|||
|
|||
radio_set_params(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr); |
|||
radio_set_tx_power(_prefs.tx_power_dbm); |
|||
|
|||
updateAdvertTimer(); |
|||
updateFloodAdvertTimer(); |
|||
} |
|||
|
|||
void MyMesh::applyTempRadioParams(float freq, float bw, uint8_t sf, uint8_t cr, int timeout_mins) { |
|||
set_radio_at = futureMillis(2000); // give CLI reply some time to be sent back, before applying temp radio params
|
|||
pending_freq = freq; |
|||
pending_bw = bw; |
|||
pending_sf = sf; |
|||
pending_cr = cr; |
|||
|
|||
revert_radio_at = futureMillis(2000 + timeout_mins * 60 * 1000); // schedule when to revert radio params
|
|||
} |
|||
|
|||
bool MyMesh::formatFileSystem() { |
|||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) |
|||
return InternalFS.format(); |
|||
#elif defined(RP2040_PLATFORM) |
|||
return LittleFS.format(); |
|||
#elif defined(ESP32) |
|||
return SPIFFS.format(); |
|||
#else |
|||
#error "need to implement file system erase" |
|||
return false; |
|||
#endif |
|||
} |
|||
|
|||
void MyMesh::sendSelfAdvertisement(int delay_millis) { |
|||
mesh::Packet *pkt = createSelfAdvert(); |
|||
if (pkt) { |
|||
sendFlood(pkt, delay_millis); |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("ERROR: unable to create advertisement packet!"); |
|||
} |
|||
} |
|||
|
|||
void MyMesh::updateAdvertTimer() { |
|||
if (_prefs.advert_interval > 0) { // schedule local advert timer
|
|||
next_local_advert = futureMillis(((uint32_t)_prefs.advert_interval) * 2 * 60 * 1000); |
|||
} else { |
|||
next_local_advert = 0; // stop the timer
|
|||
} |
|||
} |
|||
|
|||
void MyMesh::updateFloodAdvertTimer() { |
|||
if (_prefs.flood_advert_interval > 0) { // schedule flood advert timer
|
|||
next_flood_advert = futureMillis(((uint32_t)_prefs.flood_advert_interval) * 60 * 60 * 1000); |
|||
} else { |
|||
next_flood_advert = 0; // stop the timer
|
|||
} |
|||
} |
|||
|
|||
void MyMesh::dumpLogFile() { |
|||
#if defined(RP2040_PLATFORM) |
|||
File f = _fs->open(PACKET_LOG_FILE, "r"); |
|||
#else |
|||
File f = _fs->open(PACKET_LOG_FILE); |
|||
#endif |
|||
if (f) { |
|||
while (f.available()) { |
|||
int c = f.read(); |
|||
if (c < 0) break; |
|||
Serial.print((char)c); |
|||
} |
|||
f.close(); |
|||
} |
|||
} |
|||
|
|||
void MyMesh::setTxPower(uint8_t power_dbm) { |
|||
radio_set_tx_power(power_dbm); |
|||
} |
|||
|
|||
void MyMesh::formatNeighborsReply(char *reply) { |
|||
char *dp = reply; |
|||
|
|||
#if MAX_NEIGHBOURS |
|||
for (int i = 0; i < MAX_NEIGHBOURS && dp - reply < 134; i++) { |
|||
NeighbourInfo *neighbour = &neighbours[i]; |
|||
if (neighbour->heard_timestamp == 0) continue; // skip empty slots
|
|||
|
|||
// add new line if not first item
|
|||
if (i > 0) *dp++ = '\n'; |
|||
|
|||
char hex[10]; |
|||
// get 4 bytes of neighbour id as hex
|
|||
mesh::Utils::toHex(hex, neighbour->id.pub_key, 4); |
|||
|
|||
// add next neighbour
|
|||
uint32_t secs_ago = getRTCClock()->getCurrentTime() - neighbour->heard_timestamp; |
|||
sprintf(dp, "%s:%d:%d", hex, secs_ago, neighbour->snr); |
|||
while (*dp) |
|||
dp++; // find end of string
|
|||
} |
|||
#endif |
|||
if (dp == reply) { // no neighbours, need empty response
|
|||
strcpy(dp, "-none-"); |
|||
dp += 6; |
|||
} |
|||
*dp = 0; // null terminator
|
|||
} |
|||
|
|||
void MyMesh::removeNeighbor(const uint8_t *pubkey, int key_len) { |
|||
#if MAX_NEIGHBOURS |
|||
for (int i = 0; i < MAX_NEIGHBOURS; i++) { |
|||
NeighbourInfo *neighbour = &neighbours[i]; |
|||
if (memcmp(neighbour->id.pub_key, pubkey, key_len) == 0) { |
|||
neighbours[i] = NeighbourInfo(); // clear neighbour entry
|
|||
} |
|||
} |
|||
#endif |
|||
} |
|||
|
|||
void MyMesh::saveIdentity(const mesh::LocalIdentity &new_id) { |
|||
self_id = new_id; |
|||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) |
|||
IdentityStore store(*_fs, ""); |
|||
#elif defined(ESP32) |
|||
IdentityStore store(*_fs, "/identity"); |
|||
#elif defined(RP2040_PLATFORM) |
|||
IdentityStore store(*_fs, "/identity"); |
|||
#else |
|||
#error "need to define saveIdentity()" |
|||
#endif |
|||
store.save("_main", self_id); |
|||
} |
|||
|
|||
void MyMesh::clearStats() { |
|||
radio_driver.resetStats(); |
|||
resetStats(); |
|||
((SimpleMeshTables *)getTables())->resetStats(); |
|||
} |
|||
|
|||
void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply) { |
|||
while (*command == ' ') |
|||
command++; // skip leading spaces
|
|||
|
|||
if (strlen(command) > 4 && command[2] == '|') { // optional prefix (for companion radio CLI)
|
|||
memcpy(reply, command, 3); // reflect the prefix back
|
|||
reply += 3; |
|||
command += 3; |
|||
} |
|||
|
|||
_cli.handleCommand(sender_timestamp, command, reply); // common CLI commands
|
|||
} |
|||
|
|||
void MyMesh::loop() { |
|||
#ifdef WITH_BRIDGE |
|||
bridge.loop(); |
|||
#endif |
|||
|
|||
mesh::Mesh::loop(); |
|||
|
|||
if (next_flood_advert && millisHasNowPassed(next_flood_advert)) { |
|||
mesh::Packet *pkt = createSelfAdvert(); |
|||
if (pkt) sendFlood(pkt); |
|||
|
|||
updateFloodAdvertTimer(); // schedule next flood advert
|
|||
updateAdvertTimer(); // also schedule local advert (so they don't overlap)
|
|||
} else if (next_local_advert && millisHasNowPassed(next_local_advert)) { |
|||
mesh::Packet *pkt = createSelfAdvert(); |
|||
if (pkt) sendZeroHop(pkt); |
|||
|
|||
updateAdvertTimer(); // schedule next local advert
|
|||
} |
|||
|
|||
if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
|
|||
set_radio_at = 0; // clear timer
|
|||
radio_set_params(pending_freq, pending_bw, pending_sf, pending_cr); |
|||
MESH_DEBUG_PRINTLN("Temp radio params"); |
|||
} |
|||
|
|||
if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
|
|||
revert_radio_at = 0; // clear timer
|
|||
radio_set_params(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr); |
|||
MESH_DEBUG_PRINTLN("Radio params restored"); |
|||
} |
|||
} |
|||
@ -0,0 +1,192 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> |
|||
#include <Mesh.h> |
|||
#include <helpers/CommonCLI.h> |
|||
|
|||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) |
|||
#include <InternalFileSystem.h> |
|||
#elif defined(RP2040_PLATFORM) |
|||
#include <LittleFS.h> |
|||
#elif defined(ESP32) |
|||
#include <SPIFFS.h> |
|||
#endif |
|||
|
|||
#include <helpers/ArduinoHelpers.h> |
|||
#include <helpers/StaticPoolPacketManager.h> |
|||
#include <helpers/SimpleMeshTables.h> |
|||
#include <helpers/IdentityStore.h> |
|||
#include <helpers/AdvertDataHelpers.h> |
|||
#include <helpers/TxtDataHelpers.h> |
|||
#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; |
|||
int16_t noise_floor; |
|||
int16_t last_rssi; |
|||
uint32_t n_packets_recv; |
|||
uint32_t n_packets_sent; |
|||
uint32_t total_air_time_secs; |
|||
uint32_t total_up_time_secs; |
|||
uint32_t n_sent_flood, n_sent_direct; |
|||
uint32_t n_recv_flood, n_recv_direct; |
|||
uint16_t err_events; // was 'n_full_events'
|
|||
int16_t last_snr; // x 4
|
|||
uint16_t n_direct_dups, n_flood_dups; |
|||
uint32_t total_rx_air_time_secs; |
|||
}; |
|||
|
|||
struct ClientInfo { |
|||
mesh::Identity id; |
|||
uint32_t last_timestamp, last_activity; |
|||
uint8_t secret[PUB_KEY_SIZE]; |
|||
bool is_admin; |
|||
int8_t out_path_len; |
|||
uint8_t out_path[MAX_PATH_SIZE]; |
|||
}; |
|||
|
|||
#ifndef MAX_CLIENTS |
|||
#define MAX_CLIENTS 32 |
|||
#endif |
|||
|
|||
struct NeighbourInfo { |
|||
mesh::Identity id; |
|||
uint32_t advert_timestamp; |
|||
uint32_t heard_timestamp; |
|||
int8_t snr; // multiplied by 4, user should divide to get float value
|
|||
}; |
|||
|
|||
#ifndef FIRMWARE_BUILD_DATE |
|||
#define FIRMWARE_BUILD_DATE "1 Sep 2025" |
|||
#endif |
|||
|
|||
#ifndef FIRMWARE_VERSION |
|||
#define FIRMWARE_VERSION "v1.8.1" |
|||
#endif |
|||
|
|||
#define FIRMWARE_ROLE "repeater" |
|||
|
|||
#define PACKET_LOG_FILE "/packet_log" |
|||
|
|||
class MyMesh : public mesh::Mesh, public CommonCLICallbacks { |
|||
FILESYSTEM* _fs; |
|||
unsigned long next_local_advert, next_flood_advert; |
|||
bool _logging; |
|||
NodePrefs _prefs; |
|||
CommonCLI _cli; |
|||
uint8_t reply_data[MAX_PACKET_PAYLOAD]; |
|||
ClientInfo known_clients[MAX_CLIENTS]; |
|||
#if MAX_NEIGHBOURS |
|||
NeighbourInfo neighbours[MAX_NEIGHBOURS]; |
|||
#endif |
|||
CayenneLPP telemetry; |
|||
unsigned long set_radio_at, revert_radio_at; |
|||
float pending_freq; |
|||
float pending_bw; |
|||
uint8_t pending_sf; |
|||
uint8_t pending_cr; |
|||
int matching_peer_indexes[MAX_CLIENTS]; |
|||
#if defined(WITH_RS232_BRIDGE) |
|||
RS232Bridge bridge; |
|||
#elif defined(WITH_ESPNOW_BRIDGE) |
|||
ESPNowBridge bridge; |
|||
#endif |
|||
|
|||
ClientInfo* putClient(const mesh::Identity& id); |
|||
void putNeighbour(const mesh::Identity& id, uint32_t timestamp, float snr); |
|||
int handleRequest(ClientInfo* sender, uint32_t sender_timestamp, uint8_t* payload, size_t payload_len); |
|||
mesh::Packet* createSelfAdvert(); |
|||
|
|||
File openAppend(const char* fname); |
|||
|
|||
protected: |
|||
float getAirtimeBudgetFactor() const override { |
|||
return _prefs.airtime_factor; |
|||
} |
|||
|
|||
bool allowPacketForward(const mesh::Packet* packet) override; |
|||
const char* getLogDateTime() override; |
|||
void logRxRaw(float snr, float rssi, const uint8_t raw[], int len) override; |
|||
|
|||
void logRx(mesh::Packet* pkt, int len, float score) override; |
|||
void logTx(mesh::Packet* pkt, int len) override; |
|||
void logTxFail(mesh::Packet* pkt, int len) override; |
|||
int calcRxDelay(float score, uint32_t air_time) const override; |
|||
|
|||
uint32_t getRetransmitDelay(const mesh::Packet* packet) override; |
|||
uint32_t getDirectRetransmitDelay(const mesh::Packet* packet) override; |
|||
|
|||
int getInterferenceThreshold() const override { |
|||
return _prefs.interference_threshold; |
|||
} |
|||
int getAGCResetInterval() const override { |
|||
return ((int)_prefs.agc_reset_interval) * 4000; // milliseconds
|
|||
} |
|||
uint8_t getExtraAckTransmitCount() const override { |
|||
return _prefs.multi_acks; |
|||
} |
|||
|
|||
void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len) override; |
|||
int searchPeersByHash(const uint8_t* hash) override; |
|||
void getPeerSharedSecret(uint8_t* dest_secret, int peer_idx) override; |
|||
void onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id, uint32_t timestamp, const uint8_t* app_data, size_t app_data_len); |
|||
void onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_idx, const uint8_t* secret, uint8_t* data, size_t len) override; |
|||
bool onPeerPathRecv(mesh::Packet* packet, int sender_idx, const uint8_t* secret, uint8_t* path, uint8_t path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) override; |
|||
|
|||
public: |
|||
MyMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables); |
|||
|
|||
void begin(FILESYSTEM* fs); |
|||
|
|||
const char* getFirmwareVer() override { return FIRMWARE_VERSION; } |
|||
const char* getBuildDate() override { return FIRMWARE_BUILD_DATE; } |
|||
const char* getRole() override { return FIRMWARE_ROLE; } |
|||
const char* getNodeName() { return _prefs.node_name; } |
|||
NodePrefs* getNodePrefs() { |
|||
return &_prefs; |
|||
} |
|||
|
|||
void savePrefs() override { |
|||
_cli.savePrefs(_fs); |
|||
} |
|||
|
|||
void applyTempRadioParams(float freq, float bw, uint8_t sf, uint8_t cr, int timeout_mins) override; |
|||
bool formatFileSystem() override; |
|||
void sendSelfAdvertisement(int delay_millis) override; |
|||
void updateAdvertTimer() override; |
|||
void updateFloodAdvertTimer() override; |
|||
|
|||
void setLoggingOn(bool enable) override { _logging = enable; } |
|||
|
|||
void eraseLogFile() override { |
|||
_fs->remove(PACKET_LOG_FILE); |
|||
} |
|||
|
|||
void dumpLogFile() override; |
|||
void setTxPower(uint8_t power_dbm) override; |
|||
void formatNeighborsReply(char *reply) override; |
|||
void removeNeighbor(const uint8_t* pubkey, int key_len) override; |
|||
|
|||
mesh::LocalIdentity& getSelfId() override { return self_id; } |
|||
|
|||
void saveIdentity(const mesh::LocalIdentity& new_id) override; |
|||
void clearStats() override; |
|||
void handleCommand(uint32_t sender_timestamp, char* command, char* reply); |
|||
void loop(); |
|||
}; |
|||
@ -0,0 +1,809 @@ |
|||
#include "MyMesh.h" |
|||
|
|||
#define REPLY_DELAY_MILLIS 1500 |
|||
#define PUSH_NOTIFY_DELAY_MILLIS 2000 |
|||
#define SYNC_PUSH_INTERVAL 1200 |
|||
|
|||
#define PUSH_ACK_TIMEOUT_FLOOD 12000 |
|||
#define PUSH_TIMEOUT_BASE 4000 |
|||
#define PUSH_ACK_TIMEOUT_FACTOR 2000 |
|||
|
|||
#define POST_SYNC_DELAY_SECS 6 |
|||
|
|||
#define CLIENT_KEEP_ALIVE_SECS 0 // Now Disabled (was 128)
|
|||
|
|||
#define REQ_TYPE_GET_STATUS 0x01 // same as _GET_STATS
|
|||
#define REQ_TYPE_KEEP_ALIVE 0x02 |
|||
#define REQ_TYPE_GET_TELEMETRY_DATA 0x03 |
|||
|
|||
#define RESP_SERVER_LOGIN_OK 0 // response to ANON_REQ
|
|||
|
|||
struct ServerStats { |
|||
uint16_t batt_milli_volts; |
|||
uint16_t curr_tx_queue_len; |
|||
int16_t noise_floor; |
|||
int16_t last_rssi; |
|||
uint32_t n_packets_recv; |
|||
uint32_t n_packets_sent; |
|||
uint32_t total_air_time_secs; |
|||
uint32_t total_up_time_secs; |
|||
uint32_t n_sent_flood, n_sent_direct; |
|||
uint32_t n_recv_flood, n_recv_direct; |
|||
uint16_t err_events; // was 'n_full_events'
|
|||
int16_t last_snr; // x 4
|
|||
uint16_t n_direct_dups, n_flood_dups; |
|||
uint16_t n_posted, n_post_push; |
|||
}; |
|||
|
|||
ClientInfo *MyMesh::putClient(const mesh::Identity &id) { |
|||
for (int i = 0; i < num_clients; i++) { |
|||
if (id.matches(known_clients[i].id)) return &known_clients[i]; // already known
|
|||
} |
|||
ClientInfo *newClient; |
|||
if (num_clients < MAX_CLIENTS) { |
|||
newClient = &known_clients[num_clients++]; |
|||
} else { // table is currently full
|
|||
// evict least active client
|
|||
uint32_t oldest_timestamp = 0xFFFFFFFF; |
|||
newClient = &known_clients[0]; |
|||
for (int i = 0; i < num_clients; i++) { |
|||
auto c = &known_clients[i]; |
|||
if (c->last_activity < oldest_timestamp) { |
|||
oldest_timestamp = c->last_activity; |
|||
newClient = c; |
|||
} |
|||
} |
|||
} |
|||
newClient->id = id; |
|||
newClient->out_path_len = -1; // initially out_path is unknown
|
|||
newClient->last_timestamp = 0; |
|||
return newClient; |
|||
} |
|||
|
|||
void MyMesh::evict(ClientInfo *client) { |
|||
client->last_activity = 0; // this slot will now be re-used (will be oldest)
|
|||
memset(client->id.pub_key, 0, sizeof(client->id.pub_key)); |
|||
memset(client->secret, 0, sizeof(client->secret)); |
|||
client->pending_ack = 0; |
|||
} |
|||
|
|||
void MyMesh::addPost(ClientInfo *client, const char *postData) { |
|||
// TODO: suggested postData format: <title>/<descrption>
|
|||
posts[next_post_idx].author = client->id; // add to cyclic queue
|
|||
StrHelper::strncpy(posts[next_post_idx].text, postData, MAX_POST_TEXT_LEN); |
|||
|
|||
posts[next_post_idx].post_timestamp = getRTCClock()->getCurrentTimeUnique(); |
|||
next_post_idx = (next_post_idx + 1) % MAX_UNSYNCED_POSTS; |
|||
|
|||
next_push = futureMillis(PUSH_NOTIFY_DELAY_MILLIS); |
|||
_num_posted++; // stats
|
|||
} |
|||
|
|||
void MyMesh::pushPostToClient(ClientInfo *client, PostInfo &post) { |
|||
int len = 0; |
|||
memcpy(&reply_data[len], &post.post_timestamp, 4); |
|||
len += 4; // this is a PAST timestamp... but should be accepted by client
|
|||
|
|||
uint8_t attempt; |
|||
getRNG()->random(&attempt, 1); // need this for re-tries, so packet hash (and ACK) will be different
|
|||
reply_data[len++] = (TXT_TYPE_SIGNED_PLAIN << 2) | (attempt & 3); // 'signed' plain text
|
|||
|
|||
// encode prefix of post.author.pub_key
|
|||
memcpy(&reply_data[len], post.author.pub_key, 4); |
|||
len += 4; // just first 4 bytes
|
|||
|
|||
int text_len = strlen(post.text); |
|||
memcpy(&reply_data[len], post.text, text_len); |
|||
len += text_len; |
|||
|
|||
// calc expected ACK reply
|
|||
mesh::Utils::sha256((uint8_t *)&client->pending_ack, 4, reply_data, len, client->id.pub_key, PUB_KEY_SIZE); |
|||
client->push_post_timestamp = post.post_timestamp; |
|||
|
|||
auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, client->secret, reply_data, len); |
|||
if (reply) { |
|||
if (client->out_path_len < 0) { |
|||
sendFlood(reply); |
|||
client->ack_timeout = futureMillis(PUSH_ACK_TIMEOUT_FLOOD); |
|||
} else { |
|||
sendDirect(reply, client->out_path, client->out_path_len); |
|||
client->ack_timeout = |
|||
futureMillis(PUSH_TIMEOUT_BASE + PUSH_ACK_TIMEOUT_FACTOR * (client->out_path_len + 1)); |
|||
} |
|||
_num_post_pushes++; // stats
|
|||
} else { |
|||
client->pending_ack = 0; |
|||
MESH_DEBUG_PRINTLN("Unable to push post to client"); |
|||
} |
|||
} |
|||
|
|||
uint8_t MyMesh::getUnsyncedCount(ClientInfo *client) { |
|||
uint8_t count = 0; |
|||
for (int k = 0; k < MAX_UNSYNCED_POSTS; k++) { |
|||
if (posts[k].post_timestamp > client->sync_since // is new post for this Client?
|
|||
&& !posts[k].author.matches(client->id)) { // don't push posts to the author
|
|||
count++; |
|||
} |
|||
} |
|||
return count; |
|||
} |
|||
|
|||
bool MyMesh::processAck(const uint8_t *data) { |
|||
for (int i = 0; i < num_clients; i++) { |
|||
auto client = &known_clients[i]; |
|||
if (client->pending_ack && memcmp(data, &client->pending_ack, 4) == 0) { // got an ACK from Client!
|
|||
client->pending_ack = 0; // clear this, so next push can happen
|
|||
client->push_failures = 0; |
|||
client->sync_since = client->push_post_timestamp; // advance Client's SINCE timestamp, to sync next post
|
|||
return true; |
|||
} |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
mesh::Packet *MyMesh::createSelfAdvert() { |
|||
uint8_t app_data[MAX_ADVERT_DATA_SIZE]; |
|||
uint8_t app_data_len; |
|||
{ |
|||
AdvertDataBuilder builder(ADV_TYPE_ROOM, _prefs.node_name, _prefs.node_lat, _prefs.node_lon); |
|||
app_data_len = builder.encodeTo(app_data); |
|||
} |
|||
|
|||
return createAdvert(self_id, app_data, app_data_len); |
|||
} |
|||
|
|||
File MyMesh::openAppend(const char *fname) { |
|||
#if defined(NRF52_PLATFORM) |
|||
return _fs->open(fname, FILE_O_WRITE); |
|||
#elif defined(RP2040_PLATFORM) |
|||
return _fs->open(fname, "a"); |
|||
#else |
|||
return _fs->open(fname, "a", true); |
|||
#endif |
|||
} |
|||
|
|||
int MyMesh::handleRequest(ClientInfo *sender, uint32_t sender_timestamp, uint8_t *payload, |
|||
size_t payload_len) { |
|||
// uint32_t now = getRTCClock()->getCurrentTimeUnique();
|
|||
// memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
|
|||
memcpy(reply_data, &sender_timestamp, 4); // reflect sender_timestamp back in response packet (kind of like a 'tag')
|
|||
|
|||
switch (payload[0]) { |
|||
case REQ_TYPE_GET_STATUS: { |
|||
ServerStats stats; |
|||
stats.batt_milli_volts = board.getBattMilliVolts(); |
|||
stats.curr_tx_queue_len = _mgr->getOutboundCount(0xFFFFFFFF); |
|||
stats.noise_floor = (int16_t)_radio->getNoiseFloor(); |
|||
stats.last_rssi = (int16_t)radio_driver.getLastRSSI(); |
|||
stats.n_packets_recv = radio_driver.getPacketsRecv(); |
|||
stats.n_packets_sent = radio_driver.getPacketsSent(); |
|||
stats.total_air_time_secs = getTotalAirTime() / 1000; |
|||
stats.total_up_time_secs = _ms->getMillis() / 1000; |
|||
stats.n_sent_flood = getNumSentFlood(); |
|||
stats.n_sent_direct = getNumSentDirect(); |
|||
stats.n_recv_flood = getNumRecvFlood(); |
|||
stats.n_recv_direct = getNumRecvDirect(); |
|||
stats.err_events = _err_flags; |
|||
stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4); |
|||
stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups(); |
|||
stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups(); |
|||
stats.n_posted = _num_posted; |
|||
stats.n_post_push = _num_post_pushes; |
|||
|
|||
memcpy(&reply_data[4], &stats, sizeof(stats)); |
|||
return 4 + sizeof(stats); |
|||
} |
|||
|
|||
case REQ_TYPE_GET_TELEMETRY_DATA: { |
|||
uint8_t perm_mask = ~(payload[1]); // NEW: first reserved byte (of 4), is now inverse mask to apply to permissions
|
|||
|
|||
telemetry.reset(); |
|||
telemetry.addVoltage(TELEM_CHANNEL_SELF, (float)board.getBattMilliVolts() / 1000.0f); |
|||
// query other sensors -- target specific
|
|||
sensors.querySensors((sender->permission == RoomPermission::ADMIN ? 0xFF : 0x00) & perm_mask, telemetry); |
|||
|
|||
uint8_t tlen = telemetry.getSize(); |
|||
memcpy(&reply_data[4], telemetry.getBuffer(), tlen); |
|||
return 4 + tlen; // reply_len
|
|||
} |
|||
} |
|||
return 0; // unknown command
|
|||
} |
|||
|
|||
void MyMesh::logRxRaw(float snr, float rssi, const uint8_t raw[], int len) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.print(getLogDateTime()); |
|||
Serial.print(" RAW: "); |
|||
mesh::Utils::printHex(Serial, raw, len); |
|||
Serial.println(); |
|||
#endif |
|||
} |
|||
|
|||
void MyMesh::logRx(mesh::Packet *pkt, int len, float score) { |
|||
if (_logging) { |
|||
File f = openAppend(PACKET_LOG_FILE); |
|||
if (f) { |
|||
f.print(getLogDateTime()); |
|||
f.printf(": RX, len=%d (type=%d, route=%s, payload_len=%d) SNR=%d RSSI=%d score=%d", len, |
|||
pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len, |
|||
(int)_radio->getLastSNR(), (int)_radio->getLastRSSI(), (int)(score * 1000)); |
|||
|
|||
if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ || |
|||
pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) { |
|||
f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]); |
|||
} else { |
|||
f.printf("\n"); |
|||
} |
|||
f.close(); |
|||
} |
|||
} |
|||
} |
|||
void MyMesh::logTx(mesh::Packet *pkt, int len) { |
|||
if (_logging) { |
|||
File f = openAppend(PACKET_LOG_FILE); |
|||
if (f) { |
|||
f.print(getLogDateTime()); |
|||
f.printf(": TX, len=%d (type=%d, route=%s, payload_len=%d)", len, pkt->getPayloadType(), |
|||
pkt->isRouteDirect() ? "D" : "F", pkt->payload_len); |
|||
|
|||
if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ || |
|||
pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) { |
|||
f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]); |
|||
} else { |
|||
f.printf("\n"); |
|||
} |
|||
f.close(); |
|||
} |
|||
} |
|||
} |
|||
void MyMesh::logTxFail(mesh::Packet *pkt, int len) { |
|||
if (_logging) { |
|||
File f = openAppend(PACKET_LOG_FILE); |
|||
if (f) { |
|||
f.print(getLogDateTime()); |
|||
f.printf(": TX FAIL!, len=%d (type=%d, route=%s, payload_len=%d)\n", len, pkt->getPayloadType(), |
|||
pkt->isRouteDirect() ? "D" : "F", pkt->payload_len); |
|||
f.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
int MyMesh::calcRxDelay(float score, uint32_t air_time) const { |
|||
if (_prefs.rx_delay_base <= 0.0f) return 0; |
|||
return (int)((pow(_prefs.rx_delay_base, 0.85f - score) - 1.0) * air_time); |
|||
} |
|||
|
|||
const char *MyMesh::getLogDateTime() { |
|||
static char tmp[32]; |
|||
uint32_t now = getRTCClock()->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; |
|||
} |
|||
|
|||
uint32_t MyMesh::getRetransmitDelay(const mesh::Packet *packet) { |
|||
uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.tx_delay_factor); |
|||
return getRNG()->nextInt(0, 6) * t; |
|||
} |
|||
uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) { |
|||
uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor); |
|||
return getRNG()->nextInt(0, 6) * t; |
|||
} |
|||
|
|||
bool MyMesh::allowPacketForward(const mesh::Packet *packet) { |
|||
if (_prefs.disable_fwd) return false; |
|||
if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false; |
|||
return true; |
|||
} |
|||
|
|||
void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const mesh::Identity &sender, |
|||
uint8_t *data, size_t len) { |
|||
if (packet->getPayloadType() == PAYLOAD_TYPE_ANON_REQ) { // received an initial request by a possible admin
|
|||
// client (unknown at this stage)
|
|||
uint32_t sender_timestamp, sender_sync_since; |
|||
memcpy(&sender_timestamp, data, 4); |
|||
memcpy(&sender_sync_since, &data[4], 4); // sender's "sync messags SINCE x" timestamp
|
|||
|
|||
RoomPermission perm; |
|||
data[len] = 0; // ensure null terminator
|
|||
if (strcmp((char *)&data[8], _prefs.password) == 0) { // check for valid admin password
|
|||
perm = RoomPermission::ADMIN; |
|||
} else { |
|||
if (strcmp((char *)&data[8], _prefs.guest_password) == 0) { // check the room/public password
|
|||
perm = RoomPermission::GUEST; |
|||
} else if (_prefs.allow_read_only) { |
|||
perm = RoomPermission::READ_ONLY; |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("Incorrect room password"); |
|||
return; // no response. Client will timeout
|
|||
} |
|||
} |
|||
|
|||
auto client = putClient(sender); // add to known clients (if not already known)
|
|||
if (sender_timestamp <= client->last_timestamp) { |
|||
MESH_DEBUG_PRINTLN("possible replay attack!"); |
|||
return; |
|||
} |
|||
|
|||
MESH_DEBUG_PRINTLN("Login success!"); |
|||
client->permission = perm; |
|||
client->last_timestamp = sender_timestamp; |
|||
client->sync_since = sender_sync_since; |
|||
client->pending_ack = 0; |
|||
client->push_failures = 0; |
|||
memcpy(client->secret, secret, PUB_KEY_SIZE); |
|||
|
|||
uint32_t now = getRTCClock()->getCurrentTime(); |
|||
client->last_activity = now; |
|||
|
|||
now = getRTCClock()->getCurrentTimeUnique(); |
|||
memcpy(reply_data, &now, 4); // response packets always prefixed with timestamp
|
|||
// TODO: maybe reply with count of messages waiting to be synced for THIS client?
|
|||
reply_data[4] = RESP_SERVER_LOGIN_OK; |
|||
reply_data[5] = (CLIENT_KEEP_ALIVE_SECS >> 4); // NEW: recommended keep-alive interval (secs / 16)
|
|||
reply_data[6] = (perm == RoomPermission::ADMIN ? 1 : (perm == RoomPermission::GUEST ? 0 : 2)); |
|||
reply_data[7] = getUnsyncedCount(client); // NEW
|
|||
memcpy(&reply_data[8], "OK", 2); // REVISIT: not really needed
|
|||
|
|||
next_push = futureMillis(PUSH_NOTIFY_DELAY_MILLIS); // delay next push, give RESPONSE packet time to arrive first
|
|||
|
|||
if (packet->isRouteFlood()) { |
|||
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
|
|||
mesh::Packet *path = createPathReturn(sender, client->secret, packet->path, packet->path_len, |
|||
PAYLOAD_TYPE_RESPONSE, reply_data, 8 + 2); |
|||
if (path) sendFlood(path, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->secret, reply_data, 8 + 2); |
|||
if (reply) { |
|||
if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
|
|||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
sendFlood(reply, SERVER_RESPONSE_DELAY); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
int MyMesh::searchPeersByHash(const uint8_t *hash) { |
|||
int n = 0; |
|||
for (int i = 0; i < num_clients; i++) { |
|||
if (known_clients[i].id.isHashMatch(hash)) { |
|||
matching_peer_indexes[n++] = i; // store the INDEXES of matching contacts (for subsequent 'peer' methods)
|
|||
} |
|||
} |
|||
return n; |
|||
} |
|||
|
|||
void MyMesh::getPeerSharedSecret(uint8_t *dest_secret, int peer_idx) { |
|||
int i = matching_peer_indexes[peer_idx]; |
|||
if (i >= 0 && i < num_clients) { |
|||
// lookup pre-calculated shared_secret
|
|||
memcpy(dest_secret, known_clients[i].secret, PUB_KEY_SIZE); |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("getPeerSharedSecret: Invalid peer idx: %d", i); |
|||
} |
|||
} |
|||
|
|||
void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx, const uint8_t *secret, |
|||
uint8_t *data, size_t len) { |
|||
int i = matching_peer_indexes[sender_idx]; |
|||
if (i < 0 || i >= num_clients) { // get from our known_clients table (sender SHOULD already be known in this context)
|
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: invalid peer idx: %d", i); |
|||
return; |
|||
} |
|||
auto client = &known_clients[i]; |
|||
if (type == PAYLOAD_TYPE_TXT_MSG && len > 5) { // a CLI command or new Post
|
|||
uint32_t sender_timestamp; |
|||
memcpy(&sender_timestamp, data, 4); // timestamp (by sender's RTC clock - which could be wrong)
|
|||
uint flags = (data[4] >> 2); // message attempt number, and other flags
|
|||
|
|||
if (!(flags == TXT_TYPE_PLAIN || flags == TXT_TYPE_CLI_DATA)) { |
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: unsupported command flags received: flags=%02x", (uint32_t)flags); |
|||
} else if (sender_timestamp >= client->last_timestamp) { // prevent replay attacks, but send Acks for retries
|
|||
bool is_retry = (sender_timestamp == client->last_timestamp); |
|||
client->last_timestamp = sender_timestamp; |
|||
|
|||
uint32_t now = getRTCClock()->getCurrentTimeUnique(); |
|||
client->last_activity = now; |
|||
client->push_failures = 0; // reset so push can resume (if prev failed)
|
|||
|
|||
// len can be > original length, but 'text' will be padded with zeroes
|
|||
data[len] = 0; // need to make a C string again, with null terminator
|
|||
|
|||
uint32_t ack_hash; // calc truncated hash of the message timestamp + text + sender pub_key, to prove to
|
|||
// sender that we got it
|
|||
mesh::Utils::sha256((uint8_t *)&ack_hash, 4, data, 5 + strlen((char *)&data[5]), client->id.pub_key, |
|||
PUB_KEY_SIZE); |
|||
|
|||
uint8_t temp[166]; |
|||
bool send_ack; |
|||
if (flags == TXT_TYPE_CLI_DATA) { |
|||
if (client->permission == RoomPermission::ADMIN) { |
|||
if (is_retry) { |
|||
temp[5] = 0; // no reply
|
|||
} else { |
|||
handleCommand(sender_timestamp, (char *)&data[5], (char *)&temp[5]); |
|||
temp[4] = (TXT_TYPE_CLI_DATA << 2); // attempt and flags, (NOTE: legacy was: TXT_TYPE_PLAIN)
|
|||
} |
|||
send_ack = false; |
|||
} else { |
|||
temp[5] = 0; // no reply
|
|||
send_ack = false; // and no ACK... user shoudn't be sending these
|
|||
} |
|||
} else { // TXT_TYPE_PLAIN
|
|||
if (client->permission == RoomPermission::READ_ONLY) { |
|||
temp[5] = 0; // no reply
|
|||
send_ack = false; // no ACK
|
|||
} else { |
|||
if (!is_retry) { |
|||
addPost(client, (const char *)&data[5]); |
|||
} |
|||
temp[5] = 0; // no reply (ACK is enough)
|
|||
send_ack = true; |
|||
} |
|||
} |
|||
|
|||
uint32_t delay_millis; |
|||
if (send_ack) { |
|||
if (client->out_path_len < 0) { |
|||
mesh::Packet *ack = createAck(ack_hash); |
|||
if (ack) sendFlood(ack, TXT_ACK_DELAY); |
|||
delay_millis = TXT_ACK_DELAY + REPLY_DELAY_MILLIS; |
|||
} else { |
|||
uint32_t d = TXT_ACK_DELAY; |
|||
if (getExtraAckTransmitCount() > 0) { |
|||
mesh::Packet *a1 = createMultiAck(ack_hash, 1); |
|||
if (a1) sendDirect(a1, client->out_path, client->out_path_len, d); |
|||
d += 300; |
|||
} |
|||
|
|||
mesh::Packet *a2 = createAck(ack_hash); |
|||
if (a2) sendDirect(a2, client->out_path, client->out_path_len, d); |
|||
delay_millis = d + REPLY_DELAY_MILLIS; |
|||
} |
|||
} else { |
|||
delay_millis = 0; |
|||
} |
|||
|
|||
int text_len = strlen((char *)&temp[5]); |
|||
if (text_len > 0) { |
|||
if (now == sender_timestamp) { |
|||
// WORKAROUND: the two timestamps need to be different, in the CLI view
|
|||
now++; |
|||
} |
|||
memcpy(temp, &now, 4); // mostly an extra blob to help make packet_hash unique
|
|||
|
|||
// calc expected ACK reply
|
|||
// mesh::Utils::sha256((uint8_t *)&expected_ack_crc, 4, temp, 5 + text_len, self_id.pub_key,
|
|||
// PUB_KEY_SIZE);
|
|||
|
|||
auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len); |
|||
if (reply) { |
|||
if (client->out_path_len < 0) { |
|||
sendFlood(reply, delay_millis + SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
sendDirect(reply, client->out_path, client->out_path_len, delay_millis + SERVER_RESPONSE_DELAY); |
|||
} |
|||
} |
|||
} |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected"); |
|||
} |
|||
} else if (type == PAYLOAD_TYPE_REQ && len >= 5) { |
|||
uint32_t sender_timestamp; |
|||
memcpy(&sender_timestamp, data, 4); // timestamp (by sender's RTC clock - which could be wrong)
|
|||
if (sender_timestamp < client->last_timestamp) { // prevent replay attacks
|
|||
MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected"); |
|||
} else { |
|||
client->last_timestamp = sender_timestamp; |
|||
|
|||
uint32_t now = getRTCClock()->getCurrentTime(); |
|||
client->last_activity = now; // <-- THIS will keep client connection alive
|
|||
client->push_failures = 0; // reset so push can resume (if prev failed)
|
|||
|
|||
if (data[4] == REQ_TYPE_KEEP_ALIVE && packet->isRouteDirect()) { // request type
|
|||
uint32_t forceSince = 0; |
|||
if (len >= 9) { // optional - last post_timestamp client received
|
|||
memcpy(&forceSince, &data[5], 4); // NOTE: this may be 0, if part of decrypted PADDING!
|
|||
} else { |
|||
memcpy(&data[5], &forceSince, 4); // make sure there are zeroes in payload (for ack_hash calc below)
|
|||
} |
|||
if (forceSince > 0) { |
|||
client->sync_since = forceSince; // force-update the 'sync since'
|
|||
} |
|||
|
|||
client->pending_ack = 0; |
|||
|
|||
// TODO: Throttle KEEP_ALIVE requests!
|
|||
// if client sends too quickly, evict()
|
|||
|
|||
// RULE: only send keep_alive response DIRECT!
|
|||
if (client->out_path_len >= 0) { |
|||
uint32_t ack_hash; // calc ACK to prove to sender that we got request
|
|||
mesh::Utils::sha256((uint8_t *)&ack_hash, 4, data, 9, client->id.pub_key, PUB_KEY_SIZE); |
|||
|
|||
auto reply = createAck(ack_hash); |
|||
if (reply) { |
|||
reply->payload[reply->payload_len++] = getUnsyncedCount(client); // NEW: add unsynced counter to end of ACK packet
|
|||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY); |
|||
} |
|||
} |
|||
} else { |
|||
int reply_len = handleRequest(client, sender_timestamp, &data[4], len - 4); |
|||
if (reply_len > 0) { // valid command
|
|||
if (packet->isRouteFlood()) { |
|||
// let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
|
|||
mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len, |
|||
PAYLOAD_TYPE_RESPONSE, reply_data, reply_len); |
|||
if (path) sendFlood(path, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len); |
|||
if (reply) { |
|||
if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
|
|||
sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY); |
|||
} else { |
|||
sendFlood(reply, SERVER_RESPONSE_DELAY); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
bool MyMesh::onPeerPathRecv(mesh::Packet *packet, int sender_idx, const uint8_t *secret, uint8_t *path, |
|||
uint8_t path_len, uint8_t extra_type, uint8_t *extra, uint8_t extra_len) { |
|||
// TODO: prevent replay attacks
|
|||
int i = matching_peer_indexes[sender_idx]; |
|||
|
|||
if (i >= 0 && i < num_clients) { // get from our known_clients table (sender SHOULD already be known in this context)
|
|||
MESH_DEBUG_PRINTLN("PATH to client, path_len=%d", (uint32_t)path_len); |
|||
auto client = &known_clients[i]; |
|||
memcpy(client->out_path, path, client->out_path_len = path_len); // store a copy of path, for sendDirect()
|
|||
} else { |
|||
MESH_DEBUG_PRINTLN("onPeerPathRecv: invalid peer idx: %d", i); |
|||
} |
|||
|
|||
if (extra_type == PAYLOAD_TYPE_ACK && extra_len >= 4) { |
|||
// also got an encoded ACK!
|
|||
processAck(extra); |
|||
} |
|||
|
|||
// NOTE: no reciprocal path send!!
|
|||
return false; |
|||
} |
|||
|
|||
void MyMesh::onAckRecv(mesh::Packet *packet, uint32_t ack_crc) { |
|||
if (processAck((uint8_t *)&ack_crc)) { |
|||
packet->markDoNotRetransmit(); // ACK was for this node, so don't retransmit
|
|||
} |
|||
} |
|||
|
|||
MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondClock &ms, mesh::RNG &rng, |
|||
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) { |
|||
next_local_advert = next_flood_advert = 0; |
|||
_logging = false; |
|||
set_radio_at = revert_radio_at = 0; |
|||
|
|||
// defaults
|
|||
memset(&_prefs, 0, sizeof(_prefs)); |
|||
_prefs.airtime_factor = 1.0; // one half
|
|||
_prefs.rx_delay_base = 0.0f; // off by default, was 10.0
|
|||
_prefs.tx_delay_factor = 0.5f; // was 0.25f;
|
|||
StrHelper::strncpy(_prefs.node_name, ADVERT_NAME, sizeof(_prefs.node_name)); |
|||
_prefs.node_lat = ADVERT_LAT; |
|||
_prefs.node_lon = ADVERT_LON; |
|||
StrHelper::strncpy(_prefs.password, ADMIN_PASSWORD, sizeof(_prefs.password)); |
|||
_prefs.freq = LORA_FREQ; |
|||
_prefs.sf = LORA_SF; |
|||
_prefs.bw = LORA_BW; |
|||
_prefs.cr = LORA_CR; |
|||
_prefs.tx_power_dbm = LORA_TX_POWER; |
|||
_prefs.disable_fwd = 1; |
|||
_prefs.advert_interval = 1; // default to 2 minutes for NEW installs
|
|||
_prefs.flood_advert_interval = 12; // 12 hours
|
|||
_prefs.flood_max = 64; |
|||
_prefs.interference_threshold = 0; // disabled
|
|||
#ifdef ROOM_PASSWORD |
|||
StrHelper::strncpy(_prefs.guest_password, ROOM_PASSWORD, sizeof(_prefs.guest_password)); |
|||
#endif |
|||
|
|||
num_clients = 0; |
|||
next_post_idx = 0; |
|||
next_client_idx = 0; |
|||
next_push = 0; |
|||
memset(posts, 0, sizeof(posts)); |
|||
_num_posted = _num_post_pushes = 0; |
|||
} |
|||
|
|||
void MyMesh::begin(FILESYSTEM *fs) { |
|||
mesh::Mesh::begin(); |
|||
_fs = fs; |
|||
// load persisted prefs
|
|||
_cli.loadPrefs(_fs); |
|||
|
|||
radio_set_params(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr); |
|||
radio_set_tx_power(_prefs.tx_power_dbm); |
|||
|
|||
updateAdvertTimer(); |
|||
updateFloodAdvertTimer(); |
|||
} |
|||
|
|||
void MyMesh::applyTempRadioParams(float freq, float bw, uint8_t sf, uint8_t cr, int timeout_mins) { |
|||
set_radio_at = futureMillis(2000); // give CLI reply some time to be sent back, before applying temp radio params
|
|||
pending_freq = freq; |
|||
pending_bw = bw; |
|||
pending_sf = sf; |
|||
pending_cr = cr; |
|||
|
|||
revert_radio_at = futureMillis(2000 + timeout_mins * 60 * 1000); // schedule when to revert radio params
|
|||
} |
|||
|
|||
bool MyMesh::formatFileSystem() { |
|||
#if defined(NRF52_PLATFORM) |
|||
return InternalFS.format(); |
|||
#elif defined(RP2040_PLATFORM) |
|||
return LittleFS.format(); |
|||
#elif defined(ESP32) |
|||
return SPIFFS.format(); |
|||
#else |
|||
#error "need to implement file system erase" |
|||
return false; |
|||
#endif |
|||
} |
|||
|
|||
void MyMesh::sendSelfAdvertisement(int delay_millis) { |
|||
mesh::Packet *pkt = createSelfAdvert(); |
|||
if (pkt) { |
|||
sendFlood(pkt, delay_millis); |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("ERROR: unable to create advertisement packet!"); |
|||
} |
|||
} |
|||
|
|||
void MyMesh::updateAdvertTimer() { |
|||
if (_prefs.advert_interval > 0) { // schedule local advert timer
|
|||
next_local_advert = futureMillis((uint32_t)_prefs.advert_interval * 2 * 60 * 1000); |
|||
} else { |
|||
next_local_advert = 0; // stop the timer
|
|||
} |
|||
} |
|||
void MyMesh::updateFloodAdvertTimer() { |
|||
if (_prefs.flood_advert_interval > 0) { // schedule flood advert timer
|
|||
next_flood_advert = futureMillis(((uint32_t)_prefs.flood_advert_interval) * 60 * 60 * 1000); |
|||
} else { |
|||
next_flood_advert = 0; // stop the timer
|
|||
} |
|||
} |
|||
|
|||
void MyMesh::dumpLogFile() { |
|||
#if defined(RP2040_PLATFORM) |
|||
File f = _fs->open(PACKET_LOG_FILE, "r"); |
|||
#else |
|||
File f = _fs->open(PACKET_LOG_FILE); |
|||
#endif |
|||
if (f) { |
|||
while (f.available()) { |
|||
int c = f.read(); |
|||
if (c < 0) break; |
|||
Serial.print((char)c); |
|||
} |
|||
f.close(); |
|||
} |
|||
} |
|||
|
|||
void MyMesh::setTxPower(uint8_t power_dbm) { |
|||
radio_set_tx_power(power_dbm); |
|||
} |
|||
|
|||
void MyMesh::saveIdentity(const mesh::LocalIdentity &new_id) { |
|||
self_id = new_id; |
|||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) |
|||
IdentityStore store(*_fs, ""); |
|||
#elif defined(ESP32) |
|||
IdentityStore store(*_fs, "/identity"); |
|||
#elif defined(RP2040_PLATFORM) |
|||
IdentityStore store(*_fs, "/identity"); |
|||
#else |
|||
#error "need to define saveIdentity()" |
|||
#endif |
|||
store.save("_main", self_id); |
|||
} |
|||
|
|||
void MyMesh::clearStats() { |
|||
radio_driver.resetStats(); |
|||
resetStats(); |
|||
((SimpleMeshTables *)getTables())->resetStats(); |
|||
} |
|||
|
|||
void MyMesh::handleCommand(uint32_t sender_timestamp, char *command, char *reply) { |
|||
while (*command == ' ') |
|||
command++; // skip leading spaces
|
|||
|
|||
if (strlen(command) > 4 && command[2] == '|') { // optional prefix (for companion radio CLI)
|
|||
memcpy(reply, command, 3); // reflect the prefix back
|
|||
reply += 3; |
|||
command += 3; |
|||
} |
|||
|
|||
_cli.handleCommand(sender_timestamp, command, reply); // common CLI commands
|
|||
} |
|||
|
|||
void MyMesh::loop() { |
|||
mesh::Mesh::loop(); |
|||
|
|||
if (millisHasNowPassed(next_push) && num_clients > 0) { |
|||
// check for ACK timeouts
|
|||
for (int i = 0; i < num_clients; i++) { |
|||
auto c = &known_clients[i]; |
|||
if (c->pending_ack && millisHasNowPassed(c->ack_timeout)) { |
|||
c->push_failures++; |
|||
c->pending_ack = 0; // reset (TODO: keep prev expected_ack's in a list, incase they arrive LATER, after we retry)
|
|||
MESH_DEBUG_PRINTLN("pending ACK timed out: push_failures: %d", (uint32_t)c->push_failures); |
|||
} |
|||
} |
|||
// check next Round-Robin client, and sync next new post
|
|||
auto client = &known_clients[next_client_idx]; |
|||
bool did_push = false; |
|||
if (client->pending_ack == 0 && client->last_activity != 0 && |
|||
client->push_failures < 3) { // not already waiting for ACK, AND not evicted, AND retries not max
|
|||
MESH_DEBUG_PRINTLN("loop - checking for client %02X", (uint32_t)client->id.pub_key[0]); |
|||
uint32_t now = getRTCClock()->getCurrentTime(); |
|||
for (int k = 0, idx = next_post_idx; k < MAX_UNSYNCED_POSTS; k++) { |
|||
auto p = &posts[idx]; |
|||
if (now >= p->post_timestamp + POST_SYNC_DELAY_SECS && |
|||
p->post_timestamp > client->sync_since // is new post for this Client?
|
|||
&& !p->author.matches(client->id)) { // don't push posts to the author
|
|||
// push this post to Client, then wait for ACK
|
|||
pushPostToClient(client, *p); |
|||
did_push = true; |
|||
MESH_DEBUG_PRINTLN("loop - pushed to client %02X: %s", (uint32_t)client->id.pub_key[0], p->text); |
|||
break; |
|||
} |
|||
idx = (idx + 1) % MAX_UNSYNCED_POSTS; // wrap to start of cyclic queue
|
|||
} |
|||
} else { |
|||
MESH_DEBUG_PRINTLN("loop - skipping busy (or evicted) client %02X", (uint32_t)client->id.pub_key[0]); |
|||
} |
|||
next_client_idx = (next_client_idx + 1) % num_clients; // round robin polling for each client
|
|||
|
|||
if (did_push) { |
|||
next_push = futureMillis(SYNC_PUSH_INTERVAL); |
|||
} else { |
|||
// were no unsynced posts for curr client, so proccess next client much quicker! (in next loop())
|
|||
next_push = futureMillis(SYNC_PUSH_INTERVAL / 8); |
|||
} |
|||
} |
|||
|
|||
if (next_flood_advert && millisHasNowPassed(next_flood_advert)) { |
|||
mesh::Packet *pkt = createSelfAdvert(); |
|||
if (pkt) sendFlood(pkt); |
|||
|
|||
updateFloodAdvertTimer(); // schedule next flood advert
|
|||
updateAdvertTimer(); // also schedule local advert (so they don't overlap)
|
|||
} else if (next_local_advert && millisHasNowPassed(next_local_advert)) { |
|||
mesh::Packet *pkt = createSelfAdvert(); |
|||
if (pkt) sendZeroHop(pkt); |
|||
|
|||
updateAdvertTimer(); // schedule next local advert
|
|||
} |
|||
|
|||
if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
|
|||
set_radio_at = 0; // clear timer
|
|||
radio_set_params(pending_freq, pending_bw, pending_sf, pending_cr); |
|||
MESH_DEBUG_PRINTLN("Temp radio params"); |
|||
} |
|||
|
|||
if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
|
|||
revert_radio_at = 0; // clear timer
|
|||
radio_set_params(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr); |
|||
MESH_DEBUG_PRINTLN("Radio params restored"); |
|||
} |
|||
|
|||
// TODO: periodically check for OLD/inactive entries in known_clients[], and evict
|
|||
} |
|||
@ -0,0 +1,220 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> // needed for PlatformIO |
|||
#include <Mesh.h> |
|||
|
|||
#if defined(NRF52_PLATFORM) |
|||
#include <InternalFileSystem.h> |
|||
#elif defined(RP2040_PLATFORM) |
|||
#include <LittleFS.h> |
|||
#elif defined(ESP32) |
|||
#include <SPIFFS.h> |
|||
#endif |
|||
|
|||
#include <helpers/ArduinoHelpers.h> |
|||
#include <helpers/StaticPoolPacketManager.h> |
|||
#include <helpers/SimpleMeshTables.h> |
|||
#include <helpers/IdentityStore.h> |
|||
#include <helpers/AdvertDataHelpers.h> |
|||
#include <helpers/TxtDataHelpers.h> |
|||
#include <helpers/CommonCLI.h> |
|||
#include <RTClib.h> |
|||
#include <target.h> |
|||
|
|||
/* ------------------------------ Config -------------------------------- */ |
|||
|
|||
#ifndef FIRMWARE_BUILD_DATE |
|||
#define FIRMWARE_BUILD_DATE "1 Sep 2025" |
|||
#endif |
|||
|
|||
#ifndef FIRMWARE_VERSION |
|||
#define FIRMWARE_VERSION "v1.8.1" |
|||
#endif |
|||
|
|||
#ifndef LORA_FREQ |
|||
#define LORA_FREQ 915.0 |
|||
#endif |
|||
#ifndef LORA_BW |
|||
#define LORA_BW 250 |
|||
#endif |
|||
#ifndef LORA_SF |
|||
#define LORA_SF 10 |
|||
#endif |
|||
#ifndef LORA_CR |
|||
#define LORA_CR 5 |
|||
#endif |
|||
#ifndef LORA_TX_POWER |
|||
#define LORA_TX_POWER 20 |
|||
#endif |
|||
|
|||
#ifndef ADVERT_NAME |
|||
#define ADVERT_NAME "Test BBS" |
|||
#endif |
|||
#ifndef ADVERT_LAT |
|||
#define ADVERT_LAT 0.0 |
|||
#endif |
|||
#ifndef ADVERT_LON |
|||
#define ADVERT_LON 0.0 |
|||
#endif |
|||
|
|||
#ifndef ADMIN_PASSWORD |
|||
#define ADMIN_PASSWORD "password" |
|||
#endif |
|||
|
|||
#ifndef MAX_CLIENTS |
|||
#define MAX_CLIENTS 32 |
|||
#endif |
|||
|
|||
#ifndef MAX_UNSYNCED_POSTS |
|||
#define MAX_UNSYNCED_POSTS 32 |
|||
#endif |
|||
|
|||
#ifndef SERVER_RESPONSE_DELAY |
|||
#define SERVER_RESPONSE_DELAY 300 |
|||
#endif |
|||
|
|||
#ifndef TXT_ACK_DELAY |
|||
#define TXT_ACK_DELAY 200 |
|||
#endif |
|||
|
|||
#define FIRMWARE_ROLE "room_server" |
|||
|
|||
#define PACKET_LOG_FILE "/packet_log" |
|||
|
|||
enum RoomPermission { |
|||
ADMIN, |
|||
GUEST, |
|||
READ_ONLY |
|||
}; |
|||
|
|||
struct ClientInfo { |
|||
mesh::Identity id; |
|||
uint32_t last_timestamp; // by THEIR clock
|
|||
uint32_t last_activity; // by OUR clock
|
|||
uint32_t sync_since; // sync messages SINCE this timestamp (by OUR clock)
|
|||
uint32_t pending_ack; |
|||
uint32_t push_post_timestamp; |
|||
unsigned long ack_timeout; |
|||
RoomPermission permission; |
|||
uint8_t push_failures; |
|||
uint8_t secret[PUB_KEY_SIZE]; |
|||
int out_path_len; |
|||
uint8_t out_path[MAX_PATH_SIZE]; |
|||
}; |
|||
|
|||
#define MAX_POST_TEXT_LEN (160-9) |
|||
|
|||
struct PostInfo { |
|||
mesh::Identity author; |
|||
uint32_t post_timestamp; // by OUR clock
|
|||
char text[MAX_POST_TEXT_LEN+1]; |
|||
}; |
|||
|
|||
class MyMesh : public mesh::Mesh, public CommonCLICallbacks { |
|||
FILESYSTEM* _fs; |
|||
unsigned long next_local_advert, next_flood_advert; |
|||
bool _logging; |
|||
NodePrefs _prefs; |
|||
CommonCLI _cli; |
|||
uint8_t reply_data[MAX_PACKET_PAYLOAD]; |
|||
int num_clients; |
|||
ClientInfo known_clients[MAX_CLIENTS]; |
|||
unsigned long next_push; |
|||
uint16_t _num_posted, _num_post_pushes; |
|||
int next_client_idx; // for round-robin polling
|
|||
int next_post_idx; |
|||
PostInfo posts[MAX_UNSYNCED_POSTS]; // cyclic queue
|
|||
CayenneLPP telemetry; |
|||
unsigned long set_radio_at, revert_radio_at; |
|||
float pending_freq; |
|||
float pending_bw; |
|||
uint8_t pending_sf; |
|||
uint8_t pending_cr; |
|||
int matching_peer_indexes[MAX_CLIENTS]; |
|||
|
|||
ClientInfo* putClient(const mesh::Identity& id); |
|||
void evict(ClientInfo* client); |
|||
void addPost(ClientInfo* client, const char* postData); |
|||
void pushPostToClient(ClientInfo* client, PostInfo& post); |
|||
uint8_t getUnsyncedCount(ClientInfo* client); |
|||
bool processAck(const uint8_t *data); |
|||
mesh::Packet* createSelfAdvert(); |
|||
File openAppend(const char* fname); |
|||
int handleRequest(ClientInfo* sender, uint32_t sender_timestamp, uint8_t* payload, size_t payload_len); |
|||
|
|||
protected: |
|||
float getAirtimeBudgetFactor() const override { |
|||
return _prefs.airtime_factor; |
|||
} |
|||
|
|||
void logRxRaw(float snr, float rssi, const uint8_t raw[], int len) override; |
|||
void logRx(mesh::Packet* pkt, int len, float score) override; |
|||
void logTx(mesh::Packet* pkt, int len) override; |
|||
void logTxFail(mesh::Packet* pkt, int len) override; |
|||
|
|||
int calcRxDelay(float score, uint32_t air_time) const override; |
|||
const char* getLogDateTime() override; |
|||
uint32_t getRetransmitDelay(const mesh::Packet* packet) override; |
|||
uint32_t getDirectRetransmitDelay(const mesh::Packet* packet) override; |
|||
|
|||
int getInterferenceThreshold() const override { |
|||
return _prefs.interference_threshold; |
|||
} |
|||
int getAGCResetInterval() const override { |
|||
return ((int)_prefs.agc_reset_interval) * 4000; // milliseconds
|
|||
} |
|||
uint8_t getExtraAckTransmitCount() const override { |
|||
return _prefs.multi_acks; |
|||
} |
|||
|
|||
bool allowPacketForward(const mesh::Packet* packet) override; |
|||
void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len) override; |
|||
int searchPeersByHash(const uint8_t* hash) override ; |
|||
void getPeerSharedSecret(uint8_t* dest_secret, int peer_idx) override; |
|||
void onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_idx, const uint8_t* secret, uint8_t* data, size_t len) override; |
|||
bool onPeerPathRecv(mesh::Packet* packet, int sender_idx, const uint8_t* secret, uint8_t* path, uint8_t path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) override; |
|||
void onAckRecv(mesh::Packet* packet, uint32_t ack_crc) override; |
|||
|
|||
public: |
|||
MyMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables); |
|||
|
|||
void begin(FILESYSTEM* fs); |
|||
|
|||
const char* getFirmwareVer() override { return FIRMWARE_VERSION; } |
|||
const char* getBuildDate() override { return FIRMWARE_BUILD_DATE; } |
|||
const char* getRole() override { return FIRMWARE_ROLE; } |
|||
const char* getNodeName() { return _prefs.node_name; } |
|||
NodePrefs* getNodePrefs() { |
|||
return &_prefs; |
|||
} |
|||
|
|||
void savePrefs() override { |
|||
_cli.savePrefs(_fs); |
|||
} |
|||
|
|||
void applyTempRadioParams(float freq, float bw, uint8_t sf, uint8_t cr, int timeout_mins) override; |
|||
bool formatFileSystem() override; |
|||
void sendSelfAdvertisement(int delay_millis) override; |
|||
void updateAdvertTimer() override; |
|||
void updateFloodAdvertTimer() override; |
|||
|
|||
void setLoggingOn(bool enable) override { _logging = enable; } |
|||
|
|||
void eraseLogFile() override { |
|||
_fs->remove(PACKET_LOG_FILE); |
|||
} |
|||
|
|||
void dumpLogFile() override; |
|||
void setTxPower(uint8_t power_dbm) override; |
|||
|
|||
void formatNeighborsReply(char *reply) override { |
|||
strcpy(reply, "not supported"); |
|||
} |
|||
|
|||
mesh::LocalIdentity& getSelfId() override { return self_id; } |
|||
|
|||
void saveIdentity(const mesh::LocalIdentity& new_id) override; |
|||
void clearStats() override; |
|||
void handleCommand(uint32_t sender_timestamp, char* command, char* reply); |
|||
void loop(); |
|||
}; |
|||
@ -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; |
|||
}; |
|||
@ -0,0 +1,128 @@ |
|||
#include "ClientACL.h" |
|||
|
|||
static File openWrite(FILESYSTEM* _fs, const char* filename) { |
|||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) |
|||
_fs->remove(filename); |
|||
return _fs->open(filename, FILE_O_WRITE); |
|||
#elif defined(RP2040_PLATFORM) |
|||
return _fs->open(filename, "w"); |
|||
#else |
|||
return _fs->open(filename, "w", true); |
|||
#endif |
|||
} |
|||
|
|||
void ClientACL::load(FILESYSTEM* _fs) { |
|||
num_clients = 0; |
|||
if (_fs->exists("/s_contacts")) { |
|||
#if defined(RP2040_PLATFORM) |
|||
File file = _fs->open("/s_contacts", "r"); |
|||
#else |
|||
File file = _fs->open("/s_contacts"); |
|||
#endif |
|||
if (file) { |
|||
bool full = false; |
|||
while (!full) { |
|||
ClientInfo c; |
|||
uint8_t pub_key[32]; |
|||
uint8_t unused[6]; |
|||
|
|||
bool success = (file.read(pub_key, 32) == 32); |
|||
success = success && (file.read((uint8_t *) &c.permissions, 1) == 1); |
|||
success = success && (file.read(unused, 6) == 6); |
|||
success = success && (file.read((uint8_t *)&c.out_path_len, 1) == 1); |
|||
success = success && (file.read(c.out_path, 64) == 64); |
|||
success = success && (file.read(c.shared_secret, PUB_KEY_SIZE) == PUB_KEY_SIZE); |
|||
c.last_timestamp = 0; // transient
|
|||
c.last_activity = 0; |
|||
|
|||
if (!success) break; // EOF
|
|||
|
|||
c.id = mesh::Identity(pub_key); |
|||
if (num_clients < MAX_CLIENTS) { |
|||
clients[num_clients++] = c; |
|||
} else { |
|||
full = true; |
|||
} |
|||
} |
|||
file.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ClientACL::save(FILESYSTEM* _fs) { |
|||
File file = openWrite(_fs, "/s_contacts"); |
|||
if (file) { |
|||
uint8_t unused[6]; |
|||
memset(unused, 0, sizeof(unused)); |
|||
|
|||
for (int i = 0; i < num_clients; i++) { |
|||
auto c = &clients[i]; |
|||
if (c->permissions == 0) continue; // skip deleted entries
|
|||
|
|||
bool success = (file.write(c->id.pub_key, 32) == 32); |
|||
success = success && (file.write((uint8_t *) &c->permissions, 1) == 1); |
|||
success = success && (file.write(unused, 6) == 6); |
|||
success = success && (file.write((uint8_t *)&c->out_path_len, 1) == 1); |
|||
success = success && (file.write(c->out_path, 64) == 64); |
|||
success = success && (file.write(c->shared_secret, PUB_KEY_SIZE) == PUB_KEY_SIZE); |
|||
|
|||
if (!success) break; // write failed
|
|||
} |
|||
file.close(); |
|||
} |
|||
} |
|||
|
|||
ClientInfo* ClientACL::getClient(const uint8_t* pubkey, int key_len) { |
|||
for (int i = 0; i < num_clients; i++) { |
|||
if (memcmp(pubkey, clients[i].id.pub_key, key_len) == 0) return &clients[i]; // already known
|
|||
} |
|||
return NULL; // not found
|
|||
} |
|||
|
|||
ClientInfo* ClientACL::putClient(const mesh::Identity& id, uint8_t init_perms) { |
|||
uint32_t min_time = 0xFFFFFFFF; |
|||
ClientInfo* oldest = &clients[MAX_CLIENTS - 1]; |
|||
for (int i = 0; i < num_clients; i++) { |
|||
if (id.matches(clients[i].id)) return &clients[i]; // already known
|
|||
if (!clients[i].isAdmin() && clients[i].last_activity < min_time) { |
|||
oldest = &clients[i]; |
|||
min_time = oldest->last_activity; |
|||
} |
|||
} |
|||
|
|||
ClientInfo* c; |
|||
if (num_clients < MAX_CLIENTS) { |
|||
c = &clients[num_clients++]; |
|||
} else { |
|||
c = oldest; // evict least active contact
|
|||
} |
|||
memset(c, 0, sizeof(*c)); |
|||
c->permissions = init_perms; |
|||
c->id = id; |
|||
c->out_path_len = -1; // initially out_path is unknown
|
|||
return c; |
|||
} |
|||
|
|||
bool ClientACL::applyPermissions(const mesh::LocalIdentity& self_id, const uint8_t* pubkey, int key_len, uint8_t perms) { |
|||
ClientInfo* c; |
|||
if ((perms & PERM_ACL_ROLE_MASK) == PERM_ACL_GUEST) { // guest role is not persisted in contacts
|
|||
c = getClient(pubkey, key_len); |
|||
if (c == NULL) return false; // partial pubkey not found
|
|||
|
|||
num_clients--; // delete from contacts[]
|
|||
int i = c - clients; |
|||
while (i < num_clients) { |
|||
clients[i] = clients[i + 1]; |
|||
i++; |
|||
} |
|||
} else { |
|||
if (key_len < PUB_KEY_SIZE) return false; // need complete pubkey when adding/modifying
|
|||
|
|||
mesh::Identity id(pubkey); |
|||
c = putClient(id, 0); |
|||
|
|||
c->permissions = perms; // update their permissions
|
|||
self_id.calcSharedSecret(c->shared_secret, pubkey); |
|||
} |
|||
return true; |
|||
} |
|||
@ -0,0 +1,47 @@ |
|||
#pragma once |
|||
|
|||
#include <Arduino.h> // needed for PlatformIO |
|||
#include <Mesh.h> |
|||
#include <helpers/IdentityStore.h> |
|||
|
|||
#define PERM_ACL_ROLE_MASK 3 // lower 2 bits
|
|||
#define PERM_ACL_GUEST 0 |
|||
#define PERM_ACL_READ_ONLY 1 |
|||
#define PERM_ACL_READ_WRITE 2 |
|||
#define PERM_ACL_ADMIN 3 |
|||
|
|||
struct ClientInfo { |
|||
mesh::Identity id; |
|||
uint8_t permissions; |
|||
int8_t out_path_len; |
|||
uint8_t out_path[MAX_PATH_SIZE]; |
|||
uint8_t shared_secret[PUB_KEY_SIZE]; |
|||
uint32_t last_timestamp; // by THEIR clock (transient)
|
|||
uint32_t last_activity; // by OUR clock (transient)
|
|||
|
|||
bool isAdmin() const { return (permissions & PERM_ACL_ROLE_MASK) == PERM_ACL_ADMIN; } |
|||
}; |
|||
|
|||
#ifndef MAX_CLIENTS |
|||
#define MAX_CLIENTS 20 |
|||
#endif |
|||
|
|||
class ClientACL { |
|||
ClientInfo clients[MAX_CLIENTS]; |
|||
int num_clients; |
|||
|
|||
public: |
|||
ClientACL() { |
|||
memset(clients, 0, sizeof(clients)); |
|||
num_clients = 0; |
|||
} |
|||
void load(FILESYSTEM* _fs); |
|||
void save(FILESYSTEM* _fs); |
|||
|
|||
ClientInfo* getClient(const uint8_t* pubkey, int key_len); |
|||
ClientInfo* putClient(const mesh::Identity& id, uint8_t init_perms); |
|||
bool applyPermissions(const mesh::LocalIdentity& self_id, const uint8_t* pubkey, int key_len, uint8_t perms); |
|||
|
|||
int getNumClients() const { return num_clients; } |
|||
ClientInfo* getClientByIdx(int idx) { return &clients[idx]; } |
|||
}; |
|||
@ -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); |
|||
} |
|||
} |
|||
@ -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); |
|||
}; |
|||
@ -0,0 +1,196 @@ |
|||
#include "ESPNowBridge.h" |
|||
|
|||
#include <WiFi.h> |
|||
#include <esp_wifi.h> |
|||
|
|||
#ifdef WITH_ESPNOW_BRIDGE |
|||
|
|||
// Static member to handle callbacks
|
|||
ESPNowBridge *ESPNowBridge::_instance = nullptr; |
|||
|
|||
// Static callback wrappers
|
|||
void ESPNowBridge::recv_cb(const uint8_t *mac, const uint8_t *data, int32_t len) { |
|||
if (_instance) { |
|||
_instance->onDataRecv(mac, data, len); |
|||
} |
|||
} |
|||
|
|||
void ESPNowBridge::send_cb(const uint8_t *mac, esp_now_send_status_t status) { |
|||
if (_instance) { |
|||
_instance->onDataSent(mac, status); |
|||
} |
|||
} |
|||
|
|||
ESPNowBridge::ESPNowBridge(mesh::PacketManager *mgr, mesh::RTCClock *rtc) |
|||
: BridgeBase(mgr, rtc), _rx_buffer_pos(0) { |
|||
_instance = this; |
|||
} |
|||
|
|||
void ESPNowBridge::begin() { |
|||
// Initialize WiFi in station mode
|
|||
WiFi.mode(WIFI_STA); |
|||
|
|||
// Initialize ESP-NOW
|
|||
if (esp_now_init() != ESP_OK) { |
|||
Serial.printf("%s: ESPNOW BRIDGE: Error initializing ESP-NOW\n", getLogDateTime()); |
|||
return; |
|||
} |
|||
|
|||
// Register callbacks
|
|||
esp_now_register_recv_cb(recv_cb); |
|||
esp_now_register_send_cb(send_cb); |
|||
|
|||
// Add broadcast peer
|
|||
esp_now_peer_info_t peerInfo = {}; |
|||
memset(&peerInfo, 0, sizeof(peerInfo)); |
|||
memset(peerInfo.peer_addr, 0xFF, ESP_NOW_ETH_ALEN); // Broadcast address
|
|||
peerInfo.channel = 0; |
|||
peerInfo.encrypt = false; |
|||
|
|||
if (esp_now_add_peer(&peerInfo) != ESP_OK) { |
|||
Serial.printf("%s: ESPNOW BRIDGE: Failed to add broadcast peer\n", getLogDateTime()); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
void ESPNowBridge::loop() { |
|||
// Nothing to do here - ESP-NOW is callback based
|
|||
} |
|||
|
|||
void ESPNowBridge::xorCrypt(uint8_t *data, size_t len) { |
|||
size_t keyLen = strlen(_secret); |
|||
for (size_t i = 0; i < len; i++) { |
|||
data[i] ^= _secret[i % keyLen]; |
|||
} |
|||
} |
|||
|
|||
void ESPNowBridge::onDataRecv(const uint8_t *mac, const uint8_t *data, int32_t len) { |
|||
// Ignore packets that are too small to contain header + checksum
|
|||
if (len < (BRIDGE_MAGIC_SIZE + BRIDGE_CHECKSUM_SIZE)) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: RX packet too small, len=%d\n", getLogDateTime(), len); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
// Validate total packet size
|
|||
if (len > MAX_ESPNOW_PACKET_SIZE) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: RX packet too large, len=%d\n", getLogDateTime(), len); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
// Check packet header magic
|
|||
uint16_t received_magic = (data[0] << 8) | data[1]; |
|||
if (received_magic != BRIDGE_PACKET_MAGIC) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: RX invalid magic 0x%04X\n", getLogDateTime(), received_magic); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
// Make a copy we can decrypt
|
|||
uint8_t decrypted[MAX_ESPNOW_PACKET_SIZE]; |
|||
const size_t encryptedDataLen = len - BRIDGE_MAGIC_SIZE; |
|||
memcpy(decrypted, data + BRIDGE_MAGIC_SIZE, encryptedDataLen); |
|||
|
|||
// Try to decrypt (checksum + payload)
|
|||
xorCrypt(decrypted, encryptedDataLen); |
|||
|
|||
// Validate checksum
|
|||
uint16_t received_checksum = (decrypted[0] << 8) | decrypted[1]; |
|||
const size_t payloadLen = encryptedDataLen - BRIDGE_CHECKSUM_SIZE; |
|||
|
|||
if (!validateChecksum(decrypted + BRIDGE_CHECKSUM_SIZE, payloadLen, received_checksum)) { |
|||
// Failed to decrypt - likely from a different network
|
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: RX checksum mismatch, rcv=0x%04X\n", getLogDateTime(), |
|||
received_checksum); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: RX, payload_len=%d\n", getLogDateTime(), payloadLen); |
|||
#endif |
|||
|
|||
// Create mesh packet
|
|||
mesh::Packet *pkt = _instance->_mgr->allocNew(); |
|||
if (!pkt) return; |
|||
|
|||
if (pkt->readFrom(decrypted + BRIDGE_CHECKSUM_SIZE, payloadLen)) { |
|||
_instance->onPacketReceived(pkt); |
|||
} else { |
|||
_instance->_mgr->free(pkt); |
|||
} |
|||
} |
|||
|
|||
void ESPNowBridge::onDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) { |
|||
// Could add transmission error handling here if needed
|
|||
} |
|||
|
|||
void ESPNowBridge::onPacketReceived(mesh::Packet *packet) { |
|||
handleReceivedPacket(packet); |
|||
} |
|||
|
|||
void ESPNowBridge::onPacketTransmitted(mesh::Packet *packet) { |
|||
// First validate the packet pointer
|
|||
if (!packet) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: TX invalid packet pointer\n", getLogDateTime()); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
if (!_seen_packets.hasSeen(packet)) { |
|||
|
|||
// Create a temporary buffer just for size calculation and reuse for actual writing
|
|||
uint8_t sizingBuffer[MAX_PAYLOAD_SIZE]; |
|||
uint16_t meshPacketLen = packet->writeTo(sizingBuffer); |
|||
|
|||
// Check if packet fits within our maximum payload size
|
|||
if (meshPacketLen > MAX_PAYLOAD_SIZE) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: ESPNOW BRIDGE: TX packet too large (payload=%d, max=%d)\n", getLogDateTime(), |
|||
meshPacketLen, MAX_PAYLOAD_SIZE); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
uint8_t buffer[MAX_ESPNOW_PACKET_SIZE]; |
|||
|
|||
// Write magic header (2 bytes)
|
|||
buffer[0] = (BRIDGE_PACKET_MAGIC >> 8) & 0xFF; |
|||
buffer[1] = BRIDGE_PACKET_MAGIC & 0xFF; |
|||
|
|||
// Write packet payload starting after magic header and checksum
|
|||
const size_t packetOffset = BRIDGE_MAGIC_SIZE + BRIDGE_CHECKSUM_SIZE; |
|||
memcpy(buffer + packetOffset, sizingBuffer, meshPacketLen); |
|||
|
|||
// Calculate and add checksum (only of the payload)
|
|||
uint16_t checksum = fletcher16(buffer + packetOffset, meshPacketLen); |
|||
buffer[2] = (checksum >> 8) & 0xFF; // High byte
|
|||
buffer[3] = checksum & 0xFF; // Low byte
|
|||
|
|||
// Encrypt payload and checksum (not including magic header)
|
|||
xorCrypt(buffer + BRIDGE_MAGIC_SIZE, meshPacketLen + BRIDGE_CHECKSUM_SIZE); |
|||
|
|||
// Total packet size: magic header + checksum + payload
|
|||
const size_t totalPacketSize = BRIDGE_MAGIC_SIZE + BRIDGE_CHECKSUM_SIZE + meshPacketLen; |
|||
|
|||
// Broadcast using ESP-NOW
|
|||
uint8_t broadcastAddress[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; |
|||
esp_err_t result = esp_now_send(broadcastAddress, buffer, totalPacketSize); |
|||
|
|||
#if MESH_PACKET_LOGGING |
|||
if (result == ESP_OK) { |
|||
Serial.printf("%s: ESPNOW BRIDGE: TX, len=%d\n", getLogDateTime(), meshPacketLen); |
|||
} else { |
|||
Serial.printf("%s: ESPNOW BRIDGE: TX FAILED!\n", getLogDateTime()); |
|||
} |
|||
#endif |
|||
} |
|||
} |
|||
|
|||
#endif |
|||
@ -0,0 +1,156 @@ |
|||
#pragma once |
|||
|
|||
#include "MeshCore.h" |
|||
#include "esp_now.h" |
|||
#include "helpers/bridges/BridgeBase.h" |
|||
|
|||
#ifdef WITH_ESPNOW_BRIDGE |
|||
|
|||
#ifndef WITH_ESPNOW_BRIDGE_SECRET |
|||
#error WITH_ESPNOW_BRIDGE_SECRET must be defined to use ESPNowBridge |
|||
#endif |
|||
|
|||
/**
|
|||
* @brief Bridge implementation using ESP-NOW protocol for packet transport |
|||
* |
|||
* This bridge enables mesh packet transport over ESP-NOW, a connectionless communication |
|||
* protocol provided by Espressif that allows ESP32 devices to communicate directly |
|||
* without WiFi router infrastructure. |
|||
* |
|||
* Features: |
|||
* - Broadcast-based communication (all bridges receive all packets) |
|||
* - Network isolation using XOR encryption with shared secret |
|||
* - Duplicate packet detection using SimpleMeshTables tracking |
|||
* - Maximum packet size of 250 bytes (ESP-NOW limitation) |
|||
* |
|||
* Packet Structure: |
|||
* [2 bytes] Magic Header - Used to identify ESPNowBridge packets |
|||
* [2 bytes] Fletcher-16 checksum of encrypted payload (calculated over payload only) |
|||
* [246 bytes max] Encrypted payload containing the mesh packet |
|||
* |
|||
* The Fletcher-16 checksum is used to validate packet integrity and detect |
|||
* corrupted or tampered packets. It's calculated over the encrypted payload |
|||
* and provides a simple but effective way to verify packets are both |
|||
* uncorrupted and from the same network (since the checksum is calculated |
|||
* after encryption). |
|||
* |
|||
* Configuration: |
|||
* - Define WITH_ESPNOW_BRIDGE to enable this bridge |
|||
* - Define WITH_ESPNOW_BRIDGE_SECRET with a string to set the network encryption key |
|||
* |
|||
* Network Isolation: |
|||
* Multiple independent mesh networks can coexist by using different |
|||
* WITH_ESPNOW_BRIDGE_SECRET values. Packets encrypted with a different key will |
|||
* fail the checksum validation and be discarded. |
|||
*/ |
|||
class ESPNowBridge : public BridgeBase { |
|||
private: |
|||
static ESPNowBridge *_instance; |
|||
static void recv_cb(const uint8_t *mac, const uint8_t *data, int32_t len); |
|||
static void send_cb(const uint8_t *mac, esp_now_send_status_t status); |
|||
|
|||
/**
|
|||
* ESP-NOW Protocol Structure: |
|||
* - ESP-NOW header: 20 bytes (handled by ESP-NOW protocol) |
|||
* - ESP-NOW payload: 250 bytes maximum |
|||
* Total ESP-NOW packet: 270 bytes |
|||
* |
|||
* Our Bridge Packet Structure (must fit in ESP-NOW payload): |
|||
* - Magic header: 2 bytes |
|||
* - Checksum: 2 bytes |
|||
* - Available payload: 246 bytes |
|||
*/ |
|||
static const size_t MAX_ESPNOW_PACKET_SIZE = 250; |
|||
|
|||
/**
|
|||
* Size constants for packet parsing |
|||
*/ |
|||
static const size_t MAX_PAYLOAD_SIZE = MAX_ESPNOW_PACKET_SIZE - (BRIDGE_MAGIC_SIZE + BRIDGE_CHECKSUM_SIZE); |
|||
|
|||
/** Buffer for receiving ESP-NOW packets */ |
|||
uint8_t _rx_buffer[MAX_ESPNOW_PACKET_SIZE]; |
|||
|
|||
/** Current position in receive buffer */ |
|||
size_t _rx_buffer_pos; |
|||
|
|||
/**
|
|||
* Network encryption key from build define |
|||
* Must be defined with WITH_ESPNOW_BRIDGE_SECRET |
|||
* Used for XOR encryption to isolate different mesh networks |
|||
*/ |
|||
const char *_secret = WITH_ESPNOW_BRIDGE_SECRET; |
|||
|
|||
/**
|
|||
* Performs XOR encryption/decryption of data |
|||
* |
|||
* Uses WITH_ESPNOW_BRIDGE_SECRET as the key in a simple XOR operation. |
|||
* The same operation is used for both encryption and decryption. |
|||
* While not cryptographically secure, it provides basic network isolation. |
|||
* |
|||
* @param data Pointer to data to encrypt/decrypt |
|||
* @param len Length of data in bytes |
|||
*/ |
|||
void xorCrypt(uint8_t *data, size_t len); |
|||
|
|||
/**
|
|||
* ESP-NOW receive callback |
|||
* Called by ESP-NOW when a packet is received |
|||
* |
|||
* @param mac Source MAC address |
|||
* @param data Received data |
|||
* @param len Length of received data |
|||
*/ |
|||
void onDataRecv(const uint8_t *mac, const uint8_t *data, int32_t len); |
|||
|
|||
/**
|
|||
* ESP-NOW send callback |
|||
* Called by ESP-NOW after a transmission attempt |
|||
* |
|||
* @param mac_addr Destination MAC address |
|||
* @param status Transmission status |
|||
*/ |
|||
void onDataSent(const uint8_t *mac_addr, esp_now_send_status_t status); |
|||
|
|||
public: |
|||
/**
|
|||
* Constructs an ESPNowBridge instance |
|||
* |
|||
* @param mgr PacketManager for allocating and queuing packets |
|||
* @param rtc RTCClock for timestamping debug messages |
|||
*/ |
|||
ESPNowBridge(mesh::PacketManager *mgr, mesh::RTCClock *rtc); |
|||
|
|||
/**
|
|||
* Initializes the ESP-NOW bridge |
|||
* |
|||
* - Configures WiFi in station mode |
|||
* - Initializes ESP-NOW protocol |
|||
* - Registers callbacks |
|||
* - Sets up broadcast peer |
|||
*/ |
|||
void begin() override; |
|||
|
|||
/**
|
|||
* Main loop handler |
|||
* ESP-NOW is callback-based, so this is currently empty |
|||
*/ |
|||
void loop() override; |
|||
|
|||
/**
|
|||
* Called when a packet is received via ESP-NOW |
|||
* Queues the packet for mesh processing if not seen before |
|||
* |
|||
* @param packet The received mesh packet |
|||
*/ |
|||
void onPacketReceived(mesh::Packet *packet) override; |
|||
|
|||
/**
|
|||
* Called when a packet needs to be transmitted via ESP-NOW |
|||
* Encrypts and broadcasts the packet if not seen before |
|||
* |
|||
* @param packet The mesh packet to transmit |
|||
*/ |
|||
void onPacketTransmitted(mesh::Packet *packet) override; |
|||
}; |
|||
|
|||
#endif |
|||
@ -0,0 +1,147 @@ |
|||
#include "RS232Bridge.h" |
|||
|
|||
#include <HardwareSerial.h> |
|||
|
|||
#ifdef WITH_RS232_BRIDGE |
|||
|
|||
RS232Bridge::RS232Bridge(Stream &serial, mesh::PacketManager *mgr, mesh::RTCClock *rtc) |
|||
: BridgeBase(mgr, rtc), _serial(&serial) {} |
|||
|
|||
void RS232Bridge::begin() { |
|||
#if !defined(WITH_RS232_BRIDGE_RX) || !defined(WITH_RS232_BRIDGE_TX) |
|||
#error "WITH_RS232_BRIDGE_RX and WITH_RS232_BRIDGE_TX must be defined" |
|||
#endif |
|||
|
|||
#if defined(ESP32) |
|||
((HardwareSerial *)_serial)->setPins(WITH_RS232_BRIDGE_RX, WITH_RS232_BRIDGE_TX); |
|||
#elif defined(NRF52_PLATFORM) |
|||
((HardwareSerial *)_serial)->setPins(WITH_RS232_BRIDGE_RX, WITH_RS232_BRIDGE_TX); |
|||
#elif defined(RP2040_PLATFORM) |
|||
((SerialUART *)_serial)->setRX(WITH_RS232_BRIDGE_RX); |
|||
((SerialUART *)_serial)->setTX(WITH_RS232_BRIDGE_TX); |
|||
#elif defined(STM32_PLATFORM) |
|||
((HardwareSerial *)_serial)->setRx(WITH_RS232_BRIDGE_RX); |
|||
((HardwareSerial *)_serial)->setTx(WITH_RS232_BRIDGE_TX); |
|||
#else |
|||
#error RS232Bridge was not tested on the current platform |
|||
#endif |
|||
((HardwareSerial *)_serial)->begin(115200); |
|||
} |
|||
|
|||
void RS232Bridge::onPacketTransmitted(mesh::Packet *packet) { |
|||
// First validate the packet pointer
|
|||
if (!packet) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: TX invalid packet pointer\n", getLogDateTime()); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
if (!_seen_packets.hasSeen(packet)) { |
|||
|
|||
uint8_t buffer[MAX_SERIAL_PACKET_SIZE]; |
|||
uint16_t len = packet->writeTo(buffer + 4); |
|||
|
|||
// Check if packet fits within our maximum payload size
|
|||
if (len > (MAX_TRANS_UNIT + 1)) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: TX packet too large (payload=%d, max=%d)\n", getLogDateTime(), len, |
|||
MAX_TRANS_UNIT + 1); |
|||
#endif |
|||
return; |
|||
} |
|||
|
|||
// Build packet header
|
|||
buffer[0] = (BRIDGE_PACKET_MAGIC >> 8) & 0xFF; // Magic high byte
|
|||
buffer[1] = BRIDGE_PACKET_MAGIC & 0xFF; // Magic low byte
|
|||
buffer[2] = (len >> 8) & 0xFF; // Length high byte
|
|||
buffer[3] = len & 0xFF; // Length low byte
|
|||
|
|||
// Calculate checksum over the payload
|
|||
uint16_t checksum = fletcher16(buffer + 4, len); |
|||
buffer[4 + len] = (checksum >> 8) & 0xFF; // Checksum high byte
|
|||
buffer[5 + len] = checksum & 0xFF; // Checksum low byte
|
|||
|
|||
// Send complete packet
|
|||
_serial->write(buffer, len + SERIAL_OVERHEAD); |
|||
|
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: TX, len=%d crc=0x%04x\n", getLogDateTime(), len, checksum); |
|||
#endif |
|||
} |
|||
} |
|||
|
|||
void RS232Bridge::loop() { |
|||
while (_serial->available()) { |
|||
uint8_t b = _serial->read(); |
|||
|
|||
if (_rx_buffer_pos < 2) { |
|||
// Waiting for magic word
|
|||
if ((_rx_buffer_pos == 0 && b == ((BRIDGE_PACKET_MAGIC >> 8) & 0xFF)) || |
|||
(_rx_buffer_pos == 1 && b == (BRIDGE_PACKET_MAGIC & 0xFF))) { |
|||
_rx_buffer[_rx_buffer_pos++] = b; |
|||
} else { |
|||
// Invalid magic byte, reset and start over
|
|||
_rx_buffer_pos = 0; |
|||
// Check if this byte could be the start of a new magic word
|
|||
if (b == ((BRIDGE_PACKET_MAGIC >> 8) & 0xFF)) { |
|||
_rx_buffer[_rx_buffer_pos++] = b; |
|||
} |
|||
} |
|||
} else { |
|||
// Reading length, payload, and checksum
|
|||
_rx_buffer[_rx_buffer_pos++] = b; |
|||
|
|||
if (_rx_buffer_pos >= 4) { |
|||
uint16_t len = (_rx_buffer[2] << 8) | _rx_buffer[3]; |
|||
|
|||
// Validate length field
|
|||
if (len > (MAX_TRANS_UNIT + 1)) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: RX invalid length %d, resetting\n", getLogDateTime(), len); |
|||
#endif |
|||
_rx_buffer_pos = 0; // Invalid length, reset
|
|||
continue; |
|||
} |
|||
|
|||
if (_rx_buffer_pos == len + SERIAL_OVERHEAD) { // Full packet received
|
|||
uint16_t received_checksum = (_rx_buffer[4 + len] << 8) | _rx_buffer[5 + len]; |
|||
|
|||
if (validateChecksum(_rx_buffer + 4, len, received_checksum)) { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: RX, len=%d crc=0x%04x\n", getLogDateTime(), len, |
|||
received_checksum); |
|||
#endif |
|||
mesh::Packet *pkt = _mgr->allocNew(); |
|||
if (pkt) { |
|||
if (pkt->readFrom(_rx_buffer + 4, len)) { |
|||
onPacketReceived(pkt); |
|||
} else { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: RX failed to parse packet\n", getLogDateTime()); |
|||
#endif |
|||
_mgr->free(pkt); |
|||
} |
|||
} else { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: RX failed to allocate packet\n", getLogDateTime()); |
|||
#endif |
|||
} |
|||
} else { |
|||
#if MESH_PACKET_LOGGING |
|||
Serial.printf("%s: RS232 BRIDGE: RX checksum mismatch, rcv=0x%04x\n", getLogDateTime(), |
|||
received_checksum); |
|||
#endif |
|||
} |
|||
_rx_buffer_pos = 0; // Reset for next packet
|
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
void RS232Bridge::onPacketReceived(mesh::Packet *packet) { |
|||
handleReceivedPacket(packet); |
|||
} |
|||
|
|||
#endif |
|||
@ -0,0 +1,141 @@ |
|||
#pragma once |
|||
|
|||
#include "helpers/bridges/BridgeBase.h" |
|||
|
|||
#include <Stream.h> |
|||
|
|||
#ifdef WITH_RS232_BRIDGE |
|||
|
|||
/**
|
|||
* @brief Bridge implementation using RS232/UART protocol for packet transport |
|||
* |
|||
* This bridge enables mesh packet transport over serial/UART connections, |
|||
* allowing nodes to communicate over wired serial links. It implements a simple |
|||
* packet framing protocol with checksums for reliable transfer. |
|||
* |
|||
* Features: |
|||
* - Point-to-point communication over hardware UART |
|||
* - Fletcher-16 checksum for data integrity verification |
|||
* - Magic header for packet synchronization and frame alignment |
|||
* - Duplicate packet detection using SimpleMeshTables tracking |
|||
* - Configurable RX/TX pins via build defines |
|||
* - Fixed baud rate at 115200 for consistent timing |
|||
* |
|||
* Packet Structure: |
|||
* [2 bytes] Magic Header (0xC03E) - Used to identify start of RS232Bridge packets |
|||
* [2 bytes] Payload Length - Length of the mesh packet payload |
|||
* [n bytes] Mesh Packet Payload - The actual mesh packet data |
|||
* [2 bytes] Fletcher-16 Checksum - Calculated over the payload for integrity verification |
|||
* |
|||
* The Fletcher-16 checksum is calculated over the mesh packet payload and provides |
|||
* error detection capabilities suitable for serial communication where electrical |
|||
* noise, timing issues, or hardware problems could corrupt data. The checksum |
|||
* validation ensures only valid packets are forwarded to the mesh. |
|||
* |
|||
* Configuration: |
|||
* - Define WITH_RS232_BRIDGE to enable this bridge |
|||
* - Define WITH_RS232_BRIDGE_RX with the RX pin number |
|||
* - Define WITH_RS232_BRIDGE_TX with the TX pin number |
|||
* |
|||
* Platform Support: |
|||
* Different platforms require different pin configuration methods: |
|||
* - ESP32: Uses HardwareSerial::setPins(rx, tx) |
|||
* - NRF52: Uses HardwareSerial::setPins(rx, tx) |
|||
* - RP2040: Uses SerialUART::setRX(rx) and SerialUART::setTX(tx) |
|||
* - STM32: Uses HardwareSerial::setRx(rx) and HardwareSerial::setTx(tx) |
|||
*/ |
|||
class RS232Bridge : public BridgeBase { |
|||
public: |
|||
/**
|
|||
* @brief Constructs an RS232Bridge instance |
|||
* |
|||
* @param serial The hardware serial port to use |
|||
* @param mgr PacketManager for allocating and queuing packets |
|||
* @param rtc RTCClock for timestamping debug messages |
|||
*/ |
|||
RS232Bridge(Stream &serial, mesh::PacketManager *mgr, mesh::RTCClock *rtc); |
|||
|
|||
/**
|
|||
* Initializes the RS232 bridge |
|||
* |
|||
* - Validates that RX/TX pins are defined |
|||
* - Configures UART pins based on target platform |
|||
* - Sets baud rate to 115200 for consistent communication |
|||
* - Platform-specific pin configuration methods are used |
|||
*/ |
|||
void begin() override; |
|||
|
|||
/**
|
|||
* @brief Main loop handler for processing incoming serial data |
|||
* |
|||
* Implements a state machine for packet reception: |
|||
* 1. Searches for magic header bytes for packet synchronization |
|||
* 2. Reads length field to determine expected packet size |
|||
* 3. Validates packet length against maximum allowed size |
|||
* 4. Receives complete packet payload and checksum |
|||
* 5. Validates Fletcher-16 checksum for data integrity |
|||
* 6. Creates mesh packet and forwards if valid |
|||
*/ |
|||
void loop() override; |
|||
|
|||
/**
|
|||
* @brief Called when a packet needs to be transmitted over serial |
|||
* |
|||
* Formats the mesh packet with RS232 framing protocol: |
|||
* - Adds magic header for synchronization |
|||
* - Includes payload length field |
|||
* - Calculates Fletcher-16 checksum over payload |
|||
* - Transmits complete framed packet |
|||
* - Uses duplicate detection to prevent retransmission |
|||
* |
|||
* @param packet The mesh packet to transmit |
|||
*/ |
|||
void onPacketTransmitted(mesh::Packet *packet) override; |
|||
|
|||
/**
|
|||
* @brief Called when a complete valid packet has been received from serial |
|||
* |
|||
* Forwards the received packet to the mesh for processing. |
|||
* The packet has already been validated for checksum integrity |
|||
* and parsed successfully at this point. |
|||
* |
|||
* @param packet The received mesh packet ready for processing |
|||
*/ |
|||
void onPacketReceived(mesh::Packet *packet) override; |
|||
|
|||
private: |
|||
/**
|
|||
* RS232 Protocol Structure: |
|||
* - Magic header: 2 bytes (packet identification) |
|||
* - Length field: 2 bytes (payload length) |
|||
* - Payload: variable bytes (mesh packet data) |
|||
* - Checksum: 2 bytes (Fletcher-16 over payload) |
|||
* Total overhead: 6 bytes |
|||
*/ |
|||
|
|||
/**
|
|||
* @brief The total overhead of the serial protocol in bytes. |
|||
* Includes: MAGIC_WORD (2) + LENGTH (2) + CHECKSUM (2) = 6 bytes |
|||
*/ |
|||
static constexpr uint16_t SERIAL_OVERHEAD = BRIDGE_MAGIC_SIZE + BRIDGE_LENGTH_SIZE + BRIDGE_CHECKSUM_SIZE; |
|||
|
|||
/**
|
|||
* @brief The maximum size of a complete packet on the serial line. |
|||
* |
|||
* This is calculated as the sum of: |
|||
* - MAX_TRANS_UNIT + 1 for the maximum mesh packet size |
|||
* - SERIAL_OVERHEAD for the framing (magic + length + checksum) |
|||
*/ |
|||
static constexpr uint16_t MAX_SERIAL_PACKET_SIZE = (MAX_TRANS_UNIT + 1) + SERIAL_OVERHEAD; |
|||
|
|||
/** Hardware serial port interface */ |
|||
Stream *_serial; |
|||
|
|||
/** Buffer for building received packets */ |
|||
uint8_t _rx_buffer[MAX_SERIAL_PACKET_SIZE]; |
|||
|
|||
/** Current position in the receive buffer */ |
|||
uint16_t _rx_buffer_pos = 0; |
|||
}; |
|||
|
|||
#endif |
|||
@ -0,0 +1,223 @@ |
|||
#pragma once |
|||
|
|||
#include <stdint.h> |
|||
|
|||
#define LPP_DIGITAL_INPUT 0 // 1 byte
|
|||
#define LPP_DIGITAL_OUTPUT 1 // 1 byte
|
|||
#define LPP_ANALOG_INPUT 2 // 2 bytes, 0.01 signed
|
|||
#define LPP_ANALOG_OUTPUT 3 // 2 bytes, 0.01 signed
|
|||
#define LPP_GENERIC_SENSOR 100 // 4 bytes, unsigned
|
|||
#define LPP_LUMINOSITY 101 // 2 bytes, 1 lux unsigned
|
|||
#define LPP_PRESENCE 102 // 1 byte, bool
|
|||
#define LPP_TEMPERATURE 103 // 2 bytes, 0.1°C signed
|
|||
#define LPP_RELATIVE_HUMIDITY 104 // 1 byte, 0.5% unsigned
|
|||
#define LPP_ACCELEROMETER 113 // 2 bytes per axis, 0.001G
|
|||
#define LPP_BAROMETRIC_PRESSURE 115 // 2 bytes 0.1hPa unsigned
|
|||
#define LPP_VOLTAGE 116 // 2 bytes 0.01V unsigned
|
|||
#define LPP_CURRENT 117 // 2 bytes 0.001A unsigned
|
|||
#define LPP_FREQUENCY 118 // 4 bytes 1Hz unsigned
|
|||
#define LPP_PERCENTAGE 120 // 1 byte 1-100% unsigned
|
|||
#define LPP_ALTITUDE 121 // 2 byte 1m signed
|
|||
#define LPP_CONCENTRATION 125 // 2 bytes, 1 ppm unsigned
|
|||
#define LPP_POWER 128 // 2 byte, 1W, unsigned
|
|||
#define LPP_DISTANCE 130 // 4 byte, 0.001m, unsigned
|
|||
#define LPP_ENERGY 131 // 4 byte, 0.001kWh, unsigned
|
|||
#define LPP_DIRECTION 132 // 2 bytes, 1deg, unsigned
|
|||
#define LPP_UNIXTIME 133 // 4 bytes, unsigned
|
|||
#define LPP_GYROMETER 134 // 2 bytes per axis, 0.01 °/s
|
|||
#define LPP_COLOUR 135 // 1 byte per RGB Color
|
|||
#define LPP_GPS 136 // 3 byte lon/lat 0.0001 °, 3 bytes alt 0.01 meter
|
|||
#define LPP_SWITCH 142 // 1 byte, 0/1
|
|||
#define LPP_POLYLINE 240 // 1 byte size, 1 byte delta factor, 3 byte lon/lat 0.0001° * factor, n (size-8) bytes deltas
|
|||
|
|||
// Multipliers
|
|||
#define LPP_DIGITAL_INPUT_MULT 1 |
|||
#define LPP_DIGITAL_OUTPUT_MULT 1 |
|||
#define LPP_ANALOG_INPUT_MULT 100 |
|||
#define LPP_ANALOG_OUTPUT_MULT 100 |
|||
#define LPP_GENERIC_SENSOR_MULT 1 |
|||
#define LPP_LUMINOSITY_MULT 1 |
|||
#define LPP_PRESENCE_MULT 1 |
|||
#define LPP_TEMPERATURE_MULT 10 |
|||
#define LPP_RELATIVE_HUMIDITY_MULT 2 |
|||
#define LPP_ACCELEROMETER_MULT 1000 |
|||
#define LPP_BAROMETRIC_PRESSURE_MULT 10 |
|||
#define LPP_VOLTAGE_MULT 100 |
|||
#define LPP_CURRENT_MULT 1000 |
|||
#define LPP_FREQUENCY_MULT 1 |
|||
#define LPP_PERCENTAGE_MULT 1 |
|||
#define LPP_ALTITUDE_MULT 1 |
|||
#define LPP_POWER_MULT 1 |
|||
#define LPP_DISTANCE_MULT 1000 |
|||
#define LPP_ENERGY_MULT 1000 |
|||
#define LPP_DIRECTION_MULT 1 |
|||
#define LPP_UNIXTIME_MULT 1 |
|||
#define LPP_GYROMETER_MULT 100 |
|||
#define LPP_GPS_LAT_LON_MULT 10000 |
|||
#define LPP_GPS_ALT_MULT 100 |
|||
#define LPP_SWITCH_MULT 1 |
|||
#define LPP_CONCENTRATION_MULT 1 |
|||
#define LPP_COLOUR_MULT 1 |
|||
|
|||
#define LPP_ERROR_OK 0 |
|||
#define LPP_ERROR_OVERFLOW 1 |
|||
#define LPP_ERROR_UNKOWN_TYPE 2 |
|||
|
|||
class LPPReader { |
|||
const uint8_t* _buf; |
|||
uint8_t _len; |
|||
uint8_t _pos; |
|||
|
|||
float getFloat(const uint8_t * buffer, uint8_t size, uint32_t multiplier, bool is_signed) { |
|||
uint32_t value = 0; |
|||
for (uint8_t i = 0; i < size; i++) { |
|||
value = (value << 8) + buffer[i]; |
|||
} |
|||
|
|||
int sign = 1; |
|||
if (is_signed) { |
|||
uint32_t bit = 1ul << ((size * 8) - 1); |
|||
if ((value & bit) == bit) { |
|||
value = (bit << 1) - value; |
|||
sign = -1; |
|||
} |
|||
} |
|||
return sign * ((float) value / multiplier); |
|||
} |
|||
|
|||
public: |
|||
LPPReader(const uint8_t buf[], uint8_t len) : _buf(buf), _len(len), _pos(0) { } |
|||
|
|||
void reset() { |
|||
_pos = 0; |
|||
} |
|||
|
|||
bool readHeader(uint8_t& channel, uint8_t& type) { |
|||
if (_pos + 2 < _len) { |
|||
channel = _buf[_pos++]; |
|||
type = _buf[_pos++]; |
|||
|
|||
return channel != 0; // channel 0 is End-of-data
|
|||
} |
|||
return false; // end-of-buffer
|
|||
} |
|||
|
|||
bool readGPS(float& lat, float& lon, float& alt) { |
|||
lat = getFloat(&_buf[_pos], 3, 10000, true); _pos += 3; |
|||
lon = getFloat(&_buf[_pos], 3, 10000, true); _pos += 3; |
|||
alt = getFloat(&_buf[_pos], 3, 100, true); _pos += 3; |
|||
return _pos <= _len; |
|||
} |
|||
bool readVoltage(float& voltage) { |
|||
voltage = getFloat(&_buf[_pos], 2, 100, false); _pos += 2; |
|||
return _pos <= _len; |
|||
} |
|||
bool readCurrent(float& amps) { |
|||
amps = getFloat(&_buf[_pos], 2, 1000, false); _pos += 2; |
|||
return _pos <= _len; |
|||
} |
|||
bool readPower(float& watts) { |
|||
watts = getFloat(&_buf[_pos], 2, 1, false); _pos += 2; |
|||
return _pos <= _len; |
|||
} |
|||
bool readTemperature(float& degrees_c) { |
|||
degrees_c = getFloat(&_buf[_pos], 2, 10, true); _pos += 2; |
|||
return _pos <= _len; |
|||
} |
|||
bool readPressure(float& pa) { |
|||
pa = getFloat(&_buf[_pos], 2, 10, false); _pos += 2; |
|||
return _pos <= _len; |
|||
} |
|||
bool readRelativeHumidity(float& pct) { |
|||
pct = getFloat(&_buf[_pos], 1, 2, false); _pos += 1; |
|||
return _pos <= _len; |
|||
} |
|||
bool readAltitude(float& m) { |
|||
m = getFloat(&_buf[_pos], 2, 1, true); _pos += 2; |
|||
return _pos <= _len; |
|||
} |
|||
|
|||
void skipData(uint8_t type) { |
|||
switch (type) { |
|||
case LPP_GPS: |
|||
_pos += 9; break; |
|||
case LPP_POLYLINE: |
|||
_pos += 8; break; // TODO: this is MINIMIUM
|
|||
case LPP_GYROMETER: |
|||
case LPP_ACCELEROMETER: |
|||
_pos += 6; break; |
|||
case LPP_GENERIC_SENSOR: |
|||
case LPP_FREQUENCY: |
|||
case LPP_DISTANCE: |
|||
case LPP_ENERGY: |
|||
case LPP_UNIXTIME: |
|||
_pos += 4; break; |
|||
case LPP_COLOUR: |
|||
_pos += 3; break; |
|||
case LPP_ANALOG_INPUT: |
|||
case LPP_ANALOG_OUTPUT: |
|||
case LPP_LUMINOSITY: |
|||
case LPP_TEMPERATURE: |
|||
case LPP_CONCENTRATION: |
|||
case LPP_BAROMETRIC_PRESSURE: |
|||
case LPP_ALTITUDE: |
|||
case LPP_VOLTAGE: |
|||
case LPP_CURRENT: |
|||
case LPP_DIRECTION: |
|||
case LPP_POWER: |
|||
_pos += 2; break; |
|||
default: |
|||
_pos++; |
|||
} |
|||
} |
|||
}; |
|||
|
|||
class LPPWriter { |
|||
uint8_t* _buf; |
|||
uint8_t _max_len; |
|||
uint8_t _len; |
|||
|
|||
void write(uint16_t value) { |
|||
_buf[_len++] = (value >> 8) & 0xFF; // MSB
|
|||
_buf[_len++] = value & 0xFF; // LSB
|
|||
} |
|||
|
|||
public: |
|||
LPPWriter(uint8_t buf[], uint8_t max_len): _buf(buf), _max_len(max_len), _len(0) { } |
|||
|
|||
bool writeVoltage(uint8_t channel, float voltage) { |
|||
if (_len + 4 <= _max_len) { |
|||
_buf[_len++] = channel; |
|||
_buf[_len++] = LPP_VOLTAGE; |
|||
uint16_t value = voltage * 100; |
|||
write(value); |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool writeGPS(uint8_t channel, float lat, float lon, float alt) { |
|||
if (_len + 11 <= _max_len) { |
|||
_buf[_len++] = channel; |
|||
_buf[_len++] = LPP_GPS; |
|||
|
|||
int32_t lati = lat * 10000; // we lose some precision :-(
|
|||
int32_t loni = lon * 10000; |
|||
int32_t alti = alt * 100; |
|||
|
|||
_buf[_len++] = lati >> 16; |
|||
_buf[_len++] = lati >> 8; |
|||
_buf[_len++] = lati; |
|||
_buf[_len++] = loni >> 16; |
|||
_buf[_len++] = loni >> 8; |
|||
_buf[_len++] = loni; |
|||
_buf[_len++] = alti >> 16; |
|||
_buf[_len++] = alti >> 8; |
|||
_buf[_len++] = alti; |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
uint8_t length() { return _len; } |
|||
}; |
|||
@ -0,0 +1,81 @@ |
|||
#include <Arduino.h> |
|||
#include "RAKWismeshTagBoard.h" |
|||
|
|||
#include <bluefruit.h> |
|||
#include <Wire.h> |
|||
|
|||
static BLEDfu bledfu; |
|||
|
|||
static void connect_callback(uint16_t conn_handle) { |
|||
(void)conn_handle; |
|||
MESH_DEBUG_PRINTLN("BLE client connected"); |
|||
} |
|||
|
|||
static void disconnect_callback(uint16_t conn_handle, uint8_t reason) { |
|||
(void)conn_handle; |
|||
(void)reason; |
|||
|
|||
MESH_DEBUG_PRINTLN("BLE client disconnected"); |
|||
} |
|||
|
|||
void RAKWismeshTagBoard::begin() { |
|||
// for future use, sub-classes SHOULD call this from their begin()
|
|||
startup_reason = BD_STARTUP_NORMAL; |
|||
pinMode(PIN_VBAT_READ, INPUT); |
|||
pinMode(PIN_USER_BTN, INPUT_PULLUP); |
|||
|
|||
Wire.setPins(PIN_BOARD_SDA, PIN_BOARD_SCL); |
|||
Wire.begin(); |
|||
|
|||
pinMode(SX126X_POWER_EN, OUTPUT); |
|||
digitalWrite(SX126X_POWER_EN, HIGH); |
|||
delay(10); // give sx1262 some time to power up
|
|||
} |
|||
|
|||
bool RAKWismeshTagBoard::startOTAUpdate(const char* id, char reply[]) { |
|||
// Config the peripheral connection with maximum bandwidth
|
|||
// more SRAM required by SoftDevice
|
|||
// Note: All config***() function must be called before begin()
|
|||
Bluefruit.configPrphBandwidth(BANDWIDTH_MAX); |
|||
Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16); |
|||
|
|||
Bluefruit.begin(1, 0); |
|||
// Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
|
|||
Bluefruit.setTxPower(4); |
|||
// Set the BLE device name
|
|||
Bluefruit.setName("WISMESHTAG_OTA"); |
|||
|
|||
Bluefruit.Periph.setConnectCallback(connect_callback); |
|||
Bluefruit.Periph.setDisconnectCallback(disconnect_callback); |
|||
|
|||
// To be consistent OTA DFU should be added first if it exists
|
|||
bledfu.begin(); |
|||
|
|||
// Set up and start advertising
|
|||
// Advertising packet
|
|||
Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE); |
|||
Bluefruit.Advertising.addTxPower(); |
|||
Bluefruit.Advertising.addName(); |
|||
|
|||
/* Start Advertising
|
|||
- Enable auto advertising if disconnected |
|||
- Interval: fast mode = 20 ms, slow mode = 152.5 ms |
|||
- Timeout for fast mode is 30 seconds |
|||
- Start(timeout) with timeout = 0 will advertise forever (until connected) |
|||
|
|||
For recommended advertising interval |
|||
https://developer.apple.com/library/content/qa/qa1931/_index.html
|
|||
*/ |
|||
Bluefruit.Advertising.restartOnDisconnect(true); |
|||
Bluefruit.Advertising.setInterval(32, 244); // in unit of 0.625 ms
|
|||
Bluefruit.Advertising.setFastTimeout(30); // number of seconds in fast mode
|
|||
Bluefruit.Advertising.start(0); // 0 = Don't stop advertising after n seconds
|
|||
|
|||
uint8_t mac_addr[6]; |
|||
memset(mac_addr, 0, sizeof(mac_addr)); |
|||
Bluefruit.getAddr(mac_addr); |
|||
sprintf(reply, "OK - mac: %02X:%02X:%02X:%02X:%02X:%02X", |
|||
mac_addr[5], mac_addr[4], mac_addr[3], mac_addr[2], mac_addr[1], mac_addr[0]); |
|||
|
|||
return true; |
|||
} |
|||
@ -0,0 +1,82 @@ |
|||
#pragma once |
|||
|
|||
#include <MeshCore.h> |
|||
#include <Arduino.h> |
|||
|
|||
// built-ins
|
|||
#define PIN_VBAT_READ 5 |
|||
#define ADC_MULTIPLIER (3 * 1.73 * 1.187 * 1000) |
|||
|
|||
class RAKWismeshTagBoard : public mesh::MainBoard { |
|||
protected: |
|||
uint8_t startup_reason; |
|||
|
|||
public: |
|||
void begin(); |
|||
uint8_t getStartupReason() const override { return startup_reason; } |
|||
|
|||
#if defined(P_LORA_TX_LED) && defined(LED_STATE_ON) |
|||
void onBeforeTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, LED_STATE_ON); // turn TX LED on
|
|||
} |
|||
void onAfterTransmit() override { |
|||
digitalWrite(P_LORA_TX_LED, !LED_STATE_ON); // turn TX LED off
|
|||
} |
|||
#endif |
|||
|
|||
#define BATTERY_SAMPLES 8 |
|||
|
|||
uint16_t getBattMilliVolts() override { |
|||
analogReadResolution(12); |
|||
|
|||
uint32_t raw = 0; |
|||
for (int i = 0; i < BATTERY_SAMPLES; i++) { |
|||
raw += analogRead(PIN_VBAT_READ); |
|||
} |
|||
raw = raw / BATTERY_SAMPLES; |
|||
|
|||
return (ADC_MULTIPLIER * raw) / 4096; |
|||
} |
|||
|
|||
const char* getManufacturerName() const override { |
|||
return "RAK WisMesh Tag"; |
|||
} |
|||
|
|||
void reboot() override { |
|||
NVIC_SystemReset(); |
|||
} |
|||
|
|||
bool startOTAUpdate(const char* id, char reply[]) override; |
|||
|
|||
void powerOff() override { |
|||
#ifdef BUZZER_EN |
|||
digitalWrite(BUZZER_EN, LOW); |
|||
#endif |
|||
|
|||
#ifdef PIN_GPS_EN |
|||
digitalWrite(PIN_GPS_EN, LOW); |
|||
#endif |
|||
|
|||
// set led on and wait for button release before poweroff
|
|||
#ifdef LED_PIN |
|||
digitalWrite(LED_PIN, HIGH); |
|||
#endif |
|||
#ifdef BUTTON_PIN |
|||
// wismesh tag uses LOW to indicate button is pressed, wait until it goes HIGH to indicate it was released
|
|||
while(digitalRead(BUTTON_PIN) == LOW); |
|||
#endif |
|||
#ifdef LED_GREEN |
|||
digitalWrite(LED_GREEN, LOW); |
|||
#endif |
|||
#ifdef LED_BLUE |
|||
digitalWrite(LED_BLUE, LOW); |
|||
#endif |
|||
|
|||
#ifdef BUTTON_PIN |
|||
// configure button press to wake up when in powered off state
|
|||
nrf_gpio_cfg_sense_input(digitalPinToInterrupt(BUTTON_PIN), NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW); |
|||
#endif |
|||
|
|||
sd_power_system_off(); |
|||
} |
|||
}; |
|||
@ -0,0 +1,119 @@ |
|||
[rak_wismesh_tag] |
|||
extends = nrf52_base |
|||
platform = https://github.com/maxgerhardt/platform-nordicnrf52.git#rak |
|||
board = wiscore_rak4631 |
|||
board_check = true |
|||
build_flags = ${nrf52_base.build_flags} |
|||
${sensor_base.build_flags} |
|||
-I variants/rak_wismesh_tag |
|||
-I src/helpers/ui |
|||
-D RAK_WISMESH_TAG |
|||
-D RAK_BOARD |
|||
-D P_LORA_TX_LED=LED_GREEN |
|||
-D P_LORA_DIO_1=SX126X_DIO1 |
|||
-D P_LORA_NSS=PIN_SPI_NSS |
|||
-D P_LORA_RESET=SX126X_RESET |
|||
-D P_LORA_BUSY=SX126X_BUSY |
|||
-D P_LORA_SCLK=PIN_SPI_SCK |
|||
-D P_LORA_MISO=PIN_SPI_MISO |
|||
-D P_LORA_MOSI=PIN_SPI_MOSI |
|||
-D RADIO_CLASS=CustomSX1262 |
|||
-D WRAPPER_CLASS=CustomSX1262Wrapper |
|||
-D DISPLAY_CLASS=NullDisplayDriver |
|||
-D LORA_TX_POWER=22 |
|||
-D SX126X_CURRENT_LIMIT=140 |
|||
-D SX126X_RX_BOOSTED_GAIN=1 |
|||
-D PIN_BUZZER=21 |
|||
-D PIN_BOARD_SDA=PIN_WIRE_SDA |
|||
-D PIN_BOARD_SCL=PIN_WIRE_SCL |
|||
build_src_filter = ${nrf52_base.build_src_filter} |
|||
+<../variants/rak_wismesh_tag> |
|||
+<helpers/ui/buzzer.cpp> |
|||
+<helpers/ui/MomentaryButton.cpp> |
|||
+<helpers/ui/NullDisplayDriver.cpp> |
|||
+<helpers/sensors> |
|||
lib_deps = |
|||
${nrf52_base.lib_deps} |
|||
${sensor_base.lib_deps} |
|||
end2endzone/NonBlockingRTTTL@^1.3.0 |
|||
|
|||
[env:RAK_WisMesh_Tag_Repeater] |
|||
extends = rak_wismesh_tag |
|||
build_flags = |
|||
${rak_wismesh_tag.build_flags} |
|||
-D ADVERT_NAME='"RAK WM Repeater"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D MAX_NEIGHBOURS=8 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${rak_wismesh_tag.build_src_filter} |
|||
+<../examples/simple_repeater> |
|||
|
|||
[env:RAK_WisMesh_Tag_room_server] |
|||
extends = rak_wismesh_tag |
|||
build_flags = |
|||
${rak_wismesh_tag.build_flags} |
|||
-D ADVERT_NAME='"RAK WM Room"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
-D ROOM_PASSWORD='"hello"' |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
; -D MESH_DEBUG=1 |
|||
build_src_filter = ${rak_wismesh_tag.build_src_filter} |
|||
+<../examples/simple_room_server> |
|||
|
|||
[env:RAK_WisMesh_Tag_companion_radio_usb] |
|||
extends = rak_wismesh_tag |
|||
board_build.ldscript = boards/nrf52840_s140_v6_extrafs.ld |
|||
board_upload.maximum_size = 712704 |
|||
build_flags = |
|||
${rak_wismesh_tag.build_flags} |
|||
-I examples/companion_radio/ui-orig |
|||
-D MAX_CONTACTS=350 |
|||
-D MAX_GROUP_CHANNELS=40 |
|||
; NOTE: DO NOT ENABLE --> -D MESH_PACKET_LOGGING=1 |
|||
; NOTE: DO NOT ENABLE --> -D MESH_DEBUG=1 |
|||
build_src_filter = ${rak_wismesh_tag.build_src_filter} |
|||
+<../examples/companion_radio/*.cpp> |
|||
+<../examples/companion_radio/ui-orig/*.cpp> |
|||
lib_deps = |
|||
${rak_wismesh_tag.lib_deps} |
|||
densaugeo/base64 @ ~1.4.0 |
|||
|
|||
[env:RAK_WisMesh_Tag_companion_radio_ble] |
|||
extends = rak_wismesh_tag |
|||
board_build.ldscript = boards/nrf52840_s140_v6_extrafs.ld |
|||
board_upload.maximum_size = 712704 |
|||
build_flags = |
|||
${rak_wismesh_tag.build_flags} |
|||
-I examples/companion_radio/ui-orig |
|||
-D MAX_CONTACTS=350 |
|||
-D MAX_GROUP_CHANNELS=40 |
|||
-D BLE_PIN_CODE=123456 |
|||
-D BLE_DEBUG_LOGGING=1 |
|||
-D OFFLINE_QUEUE_SIZE=256 |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
-D MESH_DEBUG=1 |
|||
build_src_filter = ${rak_wismesh_tag.build_src_filter} |
|||
+<helpers/nrf52/SerialBLEInterface.cpp> |
|||
+<../examples/companion_radio/*.cpp> |
|||
+<../examples/companion_radio/ui-orig/*.cpp> |
|||
lib_deps = |
|||
${rak4631.lib_deps} |
|||
densaugeo/base64 @ ~1.4.0 |
|||
|
|||
[env:RAK_WisMesh_Tag_sensor] |
|||
extends = rak4631 |
|||
build_flags = |
|||
${rak4631.build_flags} |
|||
-D ADVERT_NAME='"RAK WM Sensor"' |
|||
-D ADVERT_LAT=0.0 |
|||
-D ADVERT_LON=0.0 |
|||
-D ADMIN_PASSWORD='"password"' |
|||
; -D MESH_PACKET_LOGGING=1 |
|||
-D MESH_DEBUG=1 |
|||
build_src_filter = ${rak4631.build_src_filter} |
|||
+<../examples/simple_sensor> |
|||
@ -0,0 +1,54 @@ |
|||
#include <Arduino.h> |
|||
#include "target.h" |
|||
#include <helpers/ArduinoHelpers.h> |
|||
|
|||
RAKWismeshTagBoard board; |
|||
|
|||
#ifndef PIN_USER_BTN |
|||
#define PIN_USER_BTN (-1) |
|||
#endif |
|||
|
|||
#ifdef DISPLAY_CLASS |
|||
DISPLAY_CLASS display; |
|||
MomentaryButton user_btn(PIN_USER_BTN, 1000, true, true); |
|||
#endif |
|||
|
|||
RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI); |
|||
|
|||
WRAPPER_CLASS radio_driver(radio, board); |
|||
|
|||
VolatileRTCClock fallback_clock; |
|||
AutoDiscoverRTCClock rtc_clock(fallback_clock); |
|||
|
|||
#if ENV_INCLUDE_GPS |
|||
#include <helpers/sensors/MicroNMEALocationProvider.h> |
|||
MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1); |
|||
EnvironmentSensorManager sensors = EnvironmentSensorManager(nmea); |
|||
#else |
|||
EnvironmentSensorManager sensors; |
|||
#endif |
|||
|
|||
bool radio_init() { |
|||
rtc_clock.begin(Wire); |
|||
return radio.std_init(&SPI); |
|||
} |
|||
|
|||
uint32_t radio_get_rng_seed() { |
|||
return radio.random(0x7FFFFFFF); |
|||
} |
|||
|
|||
void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) { |
|||
radio.setFrequency(freq); |
|||
radio.setSpreadingFactor(sf); |
|||
radio.setBandwidth(bw); |
|||
radio.setCodingRate(cr); |
|||
} |
|||
|
|||
void radio_set_tx_power(uint8_t dbm) { |
|||
radio.setOutputPower(dbm); |
|||
} |
|||
|
|||
mesh::LocalIdentity radio_new_identity() { |
|||
RadioNoiseListener rng(radio); |
|||
return mesh::LocalIdentity(&rng); // create new random identity
|
|||
} |
|||
@ -0,0 +1,27 @@ |
|||
#pragma once |
|||
|
|||
#define RADIOLIB_STATIC_ONLY 1 |
|||
#include <RadioLib.h> |
|||
#include <helpers/radiolib/RadioLibWrappers.h> |
|||
#include <RAKWismeshTagBoard.h> |
|||
#include <helpers/radiolib/CustomSX1262Wrapper.h> |
|||
#include <helpers/AutoDiscoverRTCClock.h> |
|||
#include <helpers/sensors/EnvironmentSensorManager.h> |
|||
|
|||
#ifdef DISPLAY_CLASS |
|||
#include <helpers/ui/NullDisplayDriver.h> |
|||
extern DISPLAY_CLASS display; |
|||
#include <helpers/ui/MomentaryButton.h> |
|||
extern MomentaryButton user_btn; |
|||
#endif |
|||
|
|||
extern RAKWismeshTagBoard board; |
|||
extern WRAPPER_CLASS radio_driver; |
|||
extern AutoDiscoverRTCClock rtc_clock; |
|||
extern EnvironmentSensorManager sensors; |
|||
|
|||
bool radio_init(); |
|||
uint32_t radio_get_rng_seed(); |
|||
void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr); |
|||
void radio_set_tx_power(uint8_t dbm); |
|||
mesh::LocalIdentity radio_new_identity(); |
|||
@ -0,0 +1,21 @@ |
|||
#include "variant.h" |
|||
#include "nrf.h" |
|||
#include "wiring_constants.h" |
|||
#include "wiring_digital.h" |
|||
|
|||
const uint32_t g_ADigitalPinMap[] = { |
|||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, |
|||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47 |
|||
}; |
|||
|
|||
void initVariant() { |
|||
// LEDs
|
|||
pinMode(LED_BLUE, OUTPUT); |
|||
pinMode(LED_GREEN, OUTPUT); |
|||
digitalWrite(LED_BLUE, LOW); |
|||
digitalWrite(LED_GREEN, LOW); |
|||
|
|||
// GPS
|
|||
pinMode(PIN_GPS_EN, OUTPUT); |
|||
digitalWrite(PIN_GPS_EN, HIGH); |
|||
} |
|||
@ -0,0 +1,121 @@ |
|||
/*
|
|||
* variant.h |
|||
* Copyright (C) 2023 Seeed K.K. |
|||
* MIT License |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include "WVariant.h" |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// Low frequency clock source
|
|||
|
|||
#define USE_LFXO // 32.768 kHz crystal oscillator
|
|||
#define VARIANT_MCK (64000000ul) |
|||
|
|||
#define WIRE_INTERFACES_COUNT (1) |
|||
#define PIN_TXCO (21) |
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// Power
|
|||
|
|||
#define PIN_PWR_EN (12) |
|||
|
|||
#define BATTERY_PIN (5) |
|||
#define ADC_MULTIPLIER (1.73F) |
|||
|
|||
#define ADC_RESOLUTION (14) |
|||
#define BATTERY_SENSE_RES (12) |
|||
|
|||
#define AREF_VOLTAGE (3.0) |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// Number of pins
|
|||
|
|||
#define PINS_COUNT (48) |
|||
#define NUM_DIGITAL_PINS (48) |
|||
#define NUM_ANALOG_INPUTS (6) |
|||
#define NUM_ANALOG_OUTPUTS (0) |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// UART pin definition
|
|||
|
|||
#define PIN_SERIAL1_RX (15) |
|||
#define PIN_SERIAL1_TX (16) |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// I2C pin definition
|
|||
#define WIRE_INTERFACES_COUNT (1) |
|||
#define PIN_WIRE_SDA (25) |
|||
#define PIN_WIRE_SCL (24) |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// SPI pin definition
|
|||
|
|||
#define SPI_INTERFACES_COUNT (2) |
|||
|
|||
#define PIN_SPI_MISO (45) |
|||
#define PIN_SPI_MOSI (44) |
|||
#define PIN_SPI_SCK (43) |
|||
#define PIN_SPI_NSS (42) |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// Builtin LEDs
|
|||
|
|||
#define LED_RED (-1) |
|||
#define LED_BLUE (36) |
|||
#define LED_GREEN (35) |
|||
|
|||
//#define PIN_STATUS_LED LED_BLUE
|
|||
#define LED_BUILTIN LED_GREEN |
|||
#define LED_PIN LED_GREEN |
|||
#define LED_STATE_ON HIGH |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// Builtin buttons
|
|||
|
|||
#define PIN_BUTTON1 (9) |
|||
#define BUTTON_PIN PIN_BUTTON1 |
|||
#define PIN_USER_BTN BUTTON_PIN |
|||
|
|||
#define PIN_BUTTON2 (12) |
|||
#define BUTTON_PIN2 PIN_BUTTON2 |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// Lora
|
|||
|
|||
#define USE_SX1262 |
|||
#define LORA_CS (42) |
|||
#define SX126X_DIO1 (47) |
|||
#define SX126X_BUSY (46) |
|||
#define SX126X_RESET (38) |
|||
#define SX126X_POWER_EN (37) |
|||
#define SX126X_DIO2_AS_RF_SWITCH |
|||
#define SX126X_DIO3_TCXO_VOLTAGE 1.8 |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// SPI1
|
|||
|
|||
#define PIN_SPI1_MISO (29) |
|||
#define PIN_SPI1_MOSI (30) |
|||
#define PIN_SPI1_SCK (3) |
|||
|
|||
// GxEPD2 needs that for a panel that is not even used !
|
|||
extern const int MISO; |
|||
extern const int MOSI; |
|||
extern const int SCK; |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////
|
|||
// GPS
|
|||
|
|||
#define PIN_GPS_RX (PIN_SERIAL1_TX) |
|||
#define PIN_GPS_TX (PIN_SERIAL1_RX) |
|||
#define PIN_GPS_PPS (17) |
|||
#define PIN_GPS_EN (34) |
|||
|
|||
///////////////////////////////////////////////////////////////////////////////
|
|||
// OTHER PINS
|
|||
#define PIN_AREF (2) |
|||
#define PIN_NFC1 (9) |
|||
#define PIN_NFC2 (10) |
|||
#define PIN_BUZZER (21) |
|||
Loading…
Reference in new issue