@alteriom/painlessmesh 1.10.0 → 2.0.0

package/examples/alteriom/mppt_example/{alteriom_mppt_example.ino → mppt_example.ino}

@@ -18,6 +18,10 @@
 //   3. A CommandPackage handler is included so a bridge node can
 //      request an immediate reading (command code 10).
 //
+// The two package headers beside this sketch are copies of the ones in
+// examples/alteriom/: an Arduino sketch can only include files from its own
+// directory or from a library, and a nested example is a sketch of its own.
+//
 // See alteriom_custom_package_template.hpp for a step-by-step
 // guide to creating your own custom packages.
 //************************************************************

package/examples/basic/test/simulator/README.md

@@ -123,9 +123,9 @@ print(df.groupby('node_id')['messages_received'].sum())
 
 ## Documentation
 
-- [Simulator Documentation](../../../../test/simulator/README.md)
-- [Integration Guide](../../../../test/simulator/docs/INTEGRATING_INTO_YOUR_PROJECT.md)
-- [Configuration Reference](../../../../test/simulator/docs/CONFIGURATION_GUIDE.md)
+- [Simulator Documentation](https://github.com/Alteriom/painlessMesh-simulator#readme)
+- [Integration Guide](https://github.com/Alteriom/painlessMesh-simulator/blob/main/docs/INTEGRATING_INTO_YOUR_PROJECT.md)
+- [Configuration Reference](https://github.com/Alteriom/painlessMesh-simulator/blob/main/docs/CONFIGURATION_GUIDE.md)
 
 ## Troubleshooting
 

package/examples/bridge_failover/README.md

@@ -77,7 +77,11 @@ Broadcasts occur:
 - Periodically (default: every 30 seconds)
 
 Regular nodes track these broadcasts and detect failures when:
-- No status received within 60 seconds (configurable timeout)
+- The bridge says it is leaving: `mesh.stop()` on a bridge (and a sketch that
+  stops the mesh before rebooting) broadcasts a last status with
+  `leaving: true`, and every node forgets that bridge at once
+- No status received within 60 seconds (configurable timeout) — the case of a
+  bridge that lost power or its radio
 - Bridge reports `internetConnected: false`
 
 ### 2. Election Trigger
@@ -91,10 +95,12 @@ An election is triggered when:
 - Nodes without credentials remain passive
 
 **Scenario 2: Bridge Failure**
-- Primary bridge fails or loses Internet connectivity
-- No status received within 60 seconds (configurable timeout)
-- Bridge reports `internetConnected: false`
-- Nodes detect failure and start election
+- The bridge announces it is leaving: candidates check for another bridge
+  about a second later (or as soon as the startup period allows) and start
+  an election
+- The bridge disappears without a word: no status received within 60 seconds
+  (configurable timeout), noticed at the next 30-second monitor tick
+- The bridge reports `internetConnected: false`
 
 ### 3. Election Protocol
 
@@ -123,7 +129,8 @@ All nodes independently evaluate candidates using identical rules:
 ### 4. Failover Prevention
 
 To prevent oscillation:
-- Minimum 60 seconds between role changes
+- Minimum 60 seconds between role changes; a check that arrives during the
+  hold is retried when the hold ends rather than dropped
 - Split-brain prevention via state machine
 - Deterministic winner selection ensures consensus
 
@@ -242,11 +249,20 @@ You can choose between two deployment modes:
 
 **Scenario 2: Bridge Goes Offline**
 1. Power off the current bridge node (initial or elected)
-2. After 60 seconds, regular nodes detect failure
+2. Its last status ages out after 60 seconds, and the next 30-second
+   monitor tick notices: up to 90 seconds after the bridge went
 3. Election starts automatically
 4. Node with best router signal becomes new bridge
 5. Monitor serial output to see election process
 
+**Scenario 2b: Bridge Stops Cleanly**
+1. Reboot the bridge through a sketch that calls `mesh.stop()` first (the
+   `bridge` example's regular-mode restart does), or call `mesh.stop()`
+2. The bridge broadcasts `leaving: true`; every node forgets it at once
+3. Candidates that are past their startup period hold the election
+   within seconds; the rig's failover test sees the backup promoted well
+   inside a 120-second window
+
 **Scenario 3: Bridge Loses Internet**
 1. Disconnect router from Internet (or block bridge node's Internet)
 2. Bridge reports `internetConnected: false`
@@ -370,6 +386,11 @@ bool amBridge = mesh.isBridge();
 }
 ```
 
+A bridge that stops cleanly sends one last status with `"leaving": true`
+and `"internetConnected": false` (2.0). Peers also read `routerChannel` from
+every status as the channel the mesh is rooted on — their *home* — and go
+back to it whenever they find themselves elsewhere.
+
 ### Type 611: BRIDGE_ELECTION
 ```json
 {
@@ -393,10 +414,16 @@ bool amBridge = mesh.isBridge();
   "previousBridge": 1234567890,
   "reason": "Election winner - best router signal",
   "routerRSSI": -35,
+  "routerChannel": 6,
   "timestamp": 1609459400
 }
 ```
 
+`routerChannel` (2.0) is the channel the new bridge serves the mesh on;
+peers move their AP and station to it a second after the takeover
+propagates. A node that misses the message still finds the mesh by
+scanning: after two empty scans (about 30 s) it looks at every channel.
+
 ## Use Cases
 
 ### 1. Fish Farm Monitoring System
@@ -630,13 +657,23 @@ mesh.setBridgeTimeout(30000);  // 30 seconds
 mesh.setBridgeStatusInterval(60000);  // 60 seconds
 ```
 
-## Performance Considerations
-
-- **Memory**: Each candidate adds ~12 bytes during election
-- **Network**: Election broadcast ~256 bytes per node
-- **Latency**: Typical failover time 60-70 seconds
-- **Scalability**: Tested with up to 10 nodes
-- **Reliability**: 99.9% success rate in simulations
+## What to expect
+
+- **A bridge that stops cleanly**: candidates elect within seconds of the
+  `leaving` status (after their startup period).
+- **A bridge that loses power**: noticed after the bridge timeout (60 s)
+  plus up to one monitor tick (30 s), then a 1–3 s random delay and a 5 s
+  collection window before the winner promotes itself.
+- **The mesh follows**: the takeover carries the new bridge's channel;
+  peers that hear it move at once, peers that miss it re-detect the channel
+  after about 30 s.
+- **Validated on hardware**: the failover scenario (backup started beside a
+  live primary, primary rebooted into a regular node, backup promoted and
+  carrying a real HTTP request within 120 s) runs on the Alteriom rig with
+  an ESP32, ESP32-C3, ESP32-C5, ESP32-C6, ESP32-S3 and ESP8266 and a real
+  router, and is part of the release gate.
+- **Memory**: each candidate adds about 12 bytes during an election; an
+  election broadcast is about 256 bytes per node.
 
 ## Dependencies
 

package/examples/commandControl/commandControl.ino

@@ -0,0 +1,86 @@
+//************************************************************
+// Command/control with delivery confirmation (issue #379)
+//
+// A controller node periodically broadcasts a command to all nodes and
+// tracks, per node, whether the command was delivered. Nodes execute
+// the command in their onReceive callback; the acknowledgment is sent
+// automatically by the library.
+//
+// The broadcast ack overload requires includeSelf to be passed
+// explicitly:
+//   mesh.sendBroadcast(msg, false, callback, timeoutMs);
+// The callback fires once per mesh node (excluding this node).
+//************************************************************
+#include <painlessMesh.h>
+
+#define MESH_SSID "whateverYouLike"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+// Define CONTROLLER on exactly one node to make it send the commands
+// #define CONTROLLER
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+uint32_t commandsSent = 0;
+uint32_t nodesConfirmed = 0;
+uint32_t nodesMissed = 0;
+uint32_t resultsReceived = 0;
+uint32_t expectedResults = 0;
+
+void sendCommand();
+Task taskSendCommand(TASK_SECOND * 15, TASK_FOREVER, &sendCommand);
+
+void sendCommand() {
+#ifdef CONTROLLER
+  String cmd = String("{\"cmd\":\"setInterval\",\"seconds\":") +
+               String(random(5, 60)) + String("}");
+  ++commandsSent;
+  nodesConfirmed = 0;
+  nodesMissed = 0;
+  resultsReceived = 0;
+  expectedResults = mesh.getNodeList(false).size();
+
+  bool queued = mesh.sendBroadcast(
+      cmd, false,
+      [](uint32_t nodeId, bool delivered, uint32_t latencyMs) {
+        if (delivered) {
+          ++nodesConfirmed;
+          Serial.printf("Node %u confirmed command in %u ms\n", nodeId,
+                        latencyMs);
+        } else {
+          ++nodesMissed;
+          Serial.printf("Node %u did NOT confirm — resend or alert\n",
+                        nodeId);
+          // A real controller would retry with sendSingle(nodeId, ...)
+        }
+        ++resultsReceived;
+        if (resultsReceived == expectedResults)
+          Serial.printf("Command %u done: %u confirmed, %u missed\n",
+                        commandsSent, nodesConfirmed, nodesMissed);
+      },
+      5000);
+
+  if (!queued)
+    Serial.println("No nodes connected, command not sent");
+#endif
+}
+
+void receivedCallback(uint32_t from, String &msg) {
+  // Executing the command counts as delivery; the ack is automatic
+  Serial.printf("Executing command from %u: %s\n", from, msg.c_str());
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  mesh.setDebugMsgTypes(ERROR | STARTUP);
+  mesh.init(MESH_SSID, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  mesh.onReceive(&receivedCallback);
+
+  userScheduler.addTask(taskSendCommand);
+  taskSendCommand.enable();
+}
+
+void loop() { mesh.update(); }

package/examples/commandControl/platformio.ini

@@ -0,0 +1,26 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+lib_ldf_mode = deep+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/AsyncTCP

package/examples/mqttBridge/mqttBridge.ino

@@ -10,6 +10,10 @@
 
 #include <Arduino.h>
 #include <painlessMesh.h>
+// Requires the "PubSubClient" library by Nick O'Leary. Arduino IDE users:
+// install it via Library Manager (Tools > Manage Libraries... > search
+// "PubSubClient"); PlatformIO users already get it automatically from this
+// example's platformio.ini.
 #include <PubSubClient.h>
 #include <WiFiClient.h>
 

package/examples/mqttBridge/platformio.ini

@@ -5,7 +5,7 @@ src_dir = .
 lib_deps =
     bblanchon/ArduinoJson
     arkhipenko/TaskScheduler
-    PubSubClient
+    knolleary/PubSubClient
 
 lib_ldf_mode = deep+
 [env:esp8266]

package/examples/otaSender/otaSender.ino

@@ -24,7 +24,11 @@
 
 #ifdef ESP32
 #else
-#define CS_PIN  D8
+// SD card chip-select. The D0..D8 aliases only exist on the NodeMCU/Wemos
+// ESP8266 variants; the "generic" ESP8266 variant does not define them, so
+// D8 fails to compile there. SS is GPIO15 on every ESP8266 variant, which is
+// the exact pin D8 maps to on NodeMCU, so this is portable and equivalent.
+#define CS_PIN  SS
 #endif
 
 #include "painlessMesh.h"

package/examples/priority/README.md

@@ -269,6 +269,6 @@ This is by design - it ensures critical messages get through when you need them
 
 ## See Also
 
-- [Message Queue](../queued_alarms/README.md) - For offline message queueing
+- [Message Queue](../../BRIDGE_TO_INTERNET.md) - For offline message queueing, see the bridge guide and `mesh.enableMessageQueue()`
 - [Basic Example](../basic/basic.ino) - Getting started with painlessMesh
 - [Bridge Examples](../bridge/) - Internet connectivity patterns

package/examples/priority/{priority_basic_example.ino → priority_basic_example/priority_basic_example.ino}

@@ -26,7 +26,7 @@ Task taskSensorData(5000, TASK_FOREVER, []() {
     String sensorData = "{\"type\":\"sensor\",\"temp\":23.5,\"humidity\":45}";
     
     // Send with NORMAL priority (default)
-    mesh.sendBroadcast(sensorData, 2);  // Priority level 2 = NORMAL
+    mesh.sendBroadcast(sensorData, (uint8_t)2, false);  // Priority 2 = NORMAL
     
     Serial.println("Sent sensor data (NORMAL priority)");
 });
@@ -36,7 +36,7 @@ Task taskStatusUpdate(10000, TASK_FOREVER, []() {
     String status = "{\"type\":\"status\",\"online\":true,\"uptime\":" + String(millis()) + "}";
     
     // Send with HIGH priority
-    mesh.sendBroadcast(status, 1);  // Priority level 1 = HIGH
+    mesh.sendBroadcast(status, (uint8_t)1, false);  // Priority 1 = HIGH
     
     Serial.println("Sent status update (HIGH priority)");
 });
@@ -46,7 +46,7 @@ Task taskDebugLog(15000, TASK_FOREVER, []() {
     String debug = "{\"type\":\"debug\",\"freeHeap\":" + String(ESP.getFreeHeap()) + "}";
     
     // Send with LOW priority
-    mesh.sendBroadcast(debug, 3);  // Priority level 3 = LOW
+    mesh.sendBroadcast(debug, (uint8_t)3, false);  // Priority 3 = LOW
     
     Serial.println("Sent debug log (LOW priority)");
 });
@@ -99,7 +99,7 @@ void sendCriticalAlarm(String alarmType, String message) {
     String criticalMsg = "{\"type\":\"alarm\",\"alarm\":\"" + alarmType + "\",\"msg\":\"" + message + "\"}";
     
     // Send with CRITICAL priority - will be sent immediately, bypassing queue
-    mesh.sendBroadcast(criticalMsg, 0);  // Priority level 0 = CRITICAL
+    mesh.sendBroadcast(criticalMsg, (uint8_t)0, false);  // Priority 0 = CRITICAL
     
     Serial.printf("CRITICAL ALARM SENT: %s - %s\n", alarmType.c_str(), message.c_str());
 }

package/examples/priority/{priority_with_queue.ino → priority_with_queue/priority_with_queue.ino}

@@ -22,6 +22,24 @@
 Scheduler userScheduler;
 painlessMesh mesh;
 
+// The queue types live in the painlessmesh namespace
+using painlessmesh::MessagePriority;
+using painlessmesh::QueueState;
+using painlessmesh::PRIORITY_CRITICAL;
+using painlessmesh::PRIORITY_HIGH;
+using painlessmesh::PRIORITY_NORMAL;
+using painlessmesh::PRIORITY_LOW;
+using painlessmesh::QUEUE_EMPTY;
+using painlessmesh::QUEUE_NORMAL;
+using painlessmesh::QUEUE_75_PERCENT;
+using painlessmesh::QUEUE_FULL;
+
+// Forward declarations: Arduino's auto-prototype generation does not see
+// past the global lambdas below
+void sendMessage(String message, uint8_t priority);
+void flushQueuedMessages();
+void queueStateChanged(QueueState state, uint32_t count);
+
 bool internetAvailable = false;
 uint32_t bridgeNodeId = 0;
 
@@ -182,8 +200,8 @@ void flushQueuedMessages() {
         delay(10);
     }
     
-    Serial.printf("Queue flush complete. Remaining: %u messages\n", 
-                 mesh.getQueuedMessageCount());
+    Serial.printf("Queue flush complete. Remaining: %u messages\n",
+                 mesh.getQueueStats().currentSize);
 }
 
 void receivedCallback(uint32_t from, String& msg) {

package/examples/reliableSensorLogging/platformio.ini

@@ -0,0 +1,26 @@
+[platformio]
+src_dir = .
+
+[env]
+lib_deps =
+    bblanchon/ArduinoJson
+    arkhipenko/TaskScheduler
+
+lib_ldf_mode = deep+
+[env:esp8266]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
+
+[env:esp32]
+platform = espressif32
+board = esp32dev
+framework = arduino
+lib_extra_dirs = ../../  ; Load the local copy of painlessmesh. For your own example add painlessmesh to the lib_deps
+lib_deps =
+    ${env.lib_deps}  ; Inherit common dependencies
+    esp32async/AsyncTCP

package/examples/reliableSensorLogging/reliableSensorLogging.ino

@@ -0,0 +1,151 @@
+//************************************************************
+// Reliable sensor logging with delivery confirmation (issue #379)
+//
+// Demonstrates the per-message acknowledgment API:
+// 1. every 10 seconds a sensor reading is sent to a gateway node
+// 2. the reading stays in a small retry buffer until the gateway
+//    confirms delivery (delivered == true)
+// 3. unconfirmed readings are retried up to MAX_ATTEMPTS times
+//
+// Run one node with GATEWAY defined and one or more sensor nodes. The
+// gateway announces its node id; only sensor nodes generate readings.
+//************************************************************
+#include <painlessMesh.h>
+
+#define MESH_SSID "whateverYouLike"
+#define MESH_PASSWORD "somethingSneaky"
+#define MESH_PORT 5555
+
+// Define GATEWAY on exactly one node.
+// #define GATEWAY
+
+// How long to wait for a delivery confirmation
+#define ACK_TIMEOUT_MS 3000
+// How often a reading is retried before it is dropped
+#define MAX_ATTEMPTS 3
+
+Scheduler userScheduler;
+painlessMesh mesh;
+
+// The node we log readings to. In a real deployment you would discover
+// this via a broadcast announcement or hardcode your gateway's node id.
+uint32_t gatewayId = 0;
+
+// A single buffered reading awaiting confirmation
+struct PendingReading {
+  String payload;
+  uint8_t attempts = 0;
+  bool inFlight = false;
+};
+PendingReading pending;
+
+void sendReading();
+Task taskSendReading(TASK_SECOND * 10, TASK_FOREVER, &sendReading);
+#ifdef GATEWAY
+void announceGateway();
+Task taskAnnounceGateway(TASK_SECOND * 5, TASK_FOREVER, &announceGateway);
+#endif
+
+void transmitPending() {
+  if (gatewayId == 0 || pending.payload.length() == 0 || pending.inFlight)
+    return;
+
+  pending.attempts++;
+  pending.inFlight = true;
+  bool queued = mesh.sendSingle(
+      gatewayId, pending.payload,
+      [](uint32_t nodeId, bool delivered, uint32_t latencyMs) {
+        pending.inFlight = false;
+        if (delivered) {
+          Serial.printf("Reading confirmed by %u in %u ms\n", nodeId,
+                        latencyMs);
+          pending.payload = "";
+          pending.attempts = 0;
+        } else if (pending.attempts < MAX_ATTEMPTS) {
+          Serial.printf("No ack from %u, retrying (attempt %u)\n", nodeId,
+                        pending.attempts + 1);
+          transmitPending();
+        } else {
+          Serial.printf("Dropping reading after %u attempts\n",
+                        pending.attempts);
+          pending.payload = "";
+          pending.attempts = 0;
+        }
+      },
+      ACK_TIMEOUT_MS);
+
+  if (!queued) {
+    // No route to the gateway right now; try again on the next reading
+    pending.inFlight = false;
+  }
+}
+
+void sendReading() {
+  if (pending.inFlight) {
+    Serial.println("Previous reading still awaiting acknowledgment, skipping");
+    return;
+  }
+  if (pending.payload.length() > 0) {
+    // A previous attempt had no route. Replace that unsent reading; a real
+    // application might queue multiple readings instead.
+    Serial.println("Previous unsent reading still pending, overwriting");
+  }
+  pending.payload =
+      String("{\"sensor\":\"temp\",\"value\":") + String(random(15, 30)) +
+      String(",\"node\":") + String(mesh.getNodeId()) + String("}");
+  pending.attempts = 0;
+  transmitPending();
+}
+
+#ifdef GATEWAY
+void announceGateway() {
+  mesh.sendBroadcast("GATEWAY_ANNOUNCE");
+  Serial.printf("Gateway announcement sent from %u\n", mesh.getNodeId());
+}
+#endif
+
+void receivedCallback(uint32_t from, String &msg) {
+#ifdef GATEWAY
+  // The gateway simply prints what it receives. The acknowledgment is
+  // sent automatically by the library — no application code needed.
+  Serial.printf("Gateway received from %u: %s\n", from, msg.c_str());
+#else
+  if (msg == "GATEWAY_ANNOUNCE") {
+    gatewayId = from;
+    Serial.printf("Discovered gateway node %u\n", gatewayId);
+  }
+#endif
+}
+
+void newConnectionCallback(uint32_t nodeId) {
+  Serial.printf("New connection: %u\n", nodeId);
+#ifdef GATEWAY
+  // Announce immediately as well as periodically so new sensors do not
+  // wait for the next scheduled announcement.
+  announceGateway();
+#endif
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  mesh.setDebugMsgTypes(ERROR | STARTUP);
+  mesh.init(MESH_SSID, MESH_PASSWORD, &userScheduler, MESH_PORT);
+  mesh.onReceive(&receivedCallback);
+  mesh.onNewConnection(&newConnectionCallback);
+
+#ifdef GATEWAY
+  userScheduler.addTask(taskAnnounceGateway);
+  taskAnnounceGateway.enable();
+  announceGateway();
+#else
+  userScheduler.addTask(taskSendReading);
+  taskSendReading.enable();
+#endif
+}
+
+void loop() {
+  // Ack timeouts are processed inside update() — no extra calls needed.
+  // mesh.pendingAcks() tells you how many messages are still unconfirmed.
+  mesh.update();
+}

package/examples/sendToInternet/README.md

@@ -195,10 +195,17 @@ The callback provides `httpStatus` to indicate the result:
 ## Files
 
 - `sendToInternet.ino` - Main example sketch for ESP32/ESP8266
-- `mock_server_test.ino` - Bridge testing with mock HTTP server
-- `pc_mesh_node.cpp` - **NEW:** PC-based mesh node for testing regular node → bridge flow
+- `mock_server_test/mock_server_test.ino` - Bridge testing with mock HTTP server
+- `pc_node/pc_mesh_node.cpp` - **NEW:** PC-based mesh node for testing regular node → bridge flow
 - `README.md` - This documentation
-- `PC_NODE_README.md` - **NEW:** Documentation for PC mesh node testing
+- `pc_node/PC_NODE_README.md` - **NEW:** Documentation for PC mesh node testing
+
+### Related examples
+
+- [`mock_server_test/`](mock_server_test/) - Bridge testing against the mock
+  HTTP server. It lives in its own sketch folder because the Arduino toolchain
+  merges every `.ino` in a folder into one translation unit, so two sketches
+  side by side collide on `setup()`/`loop()`.
 
 ## Testing from Regular Nodes
 
@@ -214,7 +221,7 @@ The **PC Mesh Node** allows you to:
 
 **Quick Start:**
 ```bash
-cd examples/sendToInternet
+cd examples/sendToInternet/pc_node
 
 # Build
 cmake . && make
@@ -223,7 +230,7 @@ cmake . && make
 ./pc_mesh_node 192.168.1.100 5555
 ```
 
-**Full Documentation:** [PC_NODE_README.md](PC_NODE_README.md)
+**Full Documentation:** [pc_node/PC_NODE_README.md](pc_node/PC_NODE_README.md)
 
 **What It Tests:**
 - Regular mesh node sending HTTP requests through bridge

package/examples/sendToInternet/{CMakeLists.txt → pc_node/CMakeLists.txt}

@@ -26,17 +26,17 @@ SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 # Add executable
 add_executable(pc_mesh_node 
     pc_mesh_node.cpp 
-    ../../test/catch/fake_serial.cpp 
-    ../../src/scheduler.cpp
+    ../../../test/catch/fake_serial.cpp 
+    ../../../src/scheduler.cpp
 )
 
 # Include directories
 target_include_directories(pc_mesh_node PUBLIC 
-    ../../test/include/
-    ../../test/boost/
-    ../../test/ArduinoJson/src/
-    ../../test/TaskScheduler/src/
-    ../../src/
+    ../../../test/include/
+    ../../../test/boost/
+    ../../../test/ArduinoJson/src/
+    ../../../test/TaskScheduler/src/
+    ../../../src/
 )
 
 # Link libraries