@alteriom/painlessmesh 1.7.7 → 1.7.9

package/examples/alteriom/alteriom_sensor_package.hpp

@@ -3,6 +3,133 @@
 
 #include "painlessmesh/plugin.hpp"
 
+/**
+ * @file alteriom_sensor_package.hpp
+ * @brief Alteriom custom package definitions for painlessMesh
+ *
+ * TIME FIELD NAMING CONVENTION
+ * ============================
+ *
+ * For consistency and developer convenience, all time-based configuration
+ * fields in Alteriom packages follow a standardized naming convention:
+ *
+ * INTERNAL STORAGE:
+ * - Always use milliseconds (uint32_t)
+ * - Use descriptive field names WITHOUT unit suffixes
+ *   Examples: sensorReadInterval, transmissionInterval
+ *
+ * JSON SERIALIZATION:
+ * - ALWAYS provide BOTH millisecond and second variants:
+ *   - {fieldname}_ms : The value in milliseconds (uint32_t)
+ *   - {fieldname}_s  : The value in seconds (uint32_t, calculated as ms/1000)
+ *
+ * JSON DESERIALIZATION:
+ * - Read from the _ms variant (milliseconds are the source of truth)
+ * - The _s variant is provided for consumer convenience but not used for input
+ *
+ * EXAMPLE:
+ * ```cpp
+ * // C++ field declaration
+ * uint32_t sensorReadInterval = 0;  // Internal storage in milliseconds
+ *
+ * // JSON serialization (in addTo method)
+ * sensors["read_interval_ms"] = sensorReadInterval;           // 30000
+ * sensors["read_interval_s"] = sensorReadInterval / 1000;     // 30
+ *
+ * // JSON deserialization (in constructor)
+ * sensorReadInterval = sensors["read_interval_ms"] | 0;
+ * ```
+ *
+ * BENEFITS:
+ * - Consumer Convenience: No mental overhead for unit conversion
+ * - Flexibility: Consumers choose the unit appropriate for their context
+ * - Self-Documenting: Field names clearly indicate available units
+ * - Precision: Millisecond precision preserved, seconds for readability
+ * - Consistency: Predictable pattern across all time-based fields
+ *
+ * WHEN TO APPLY:
+ * - Use this convention for ALL time-based configuration/interval fields
+ * - Applies to fields typically >= 1000ms (1 second)
+ * - Examples: intervals, timeouts, durations, delays
+ * - Does NOT apply to timestamps (which should remain in seconds as per Unix
+ * convention)
+ *
+ *
+ * JSON STRUCTURE NESTING GUIDELINES
+ * ==================================
+ *
+ * Alteriom packages follow consistent patterns for organizing configuration
+ * data in JSON structures. This ensures maintainability and predictability
+ * across the API.
+ *
+ * IMPORTANT: As of PR #37, ALL configuration sections always serialize with
+ * default values, providing predictable JSON structure. Consumers no longer
+ * need to check for key existence. Default values (0, false, "") indicate "not
+ * configured" state.
+ *
+ * See docs/API_DESIGN_GUIDELINES.md for comprehensive documentation.
+ *
+ * QUICK REFERENCE:
+ *
+ * Use FLAT structure (simple key-value pairs) when:
+ * - Section has < 4 total fields
+ * - No clear logical subsystems
+ * - Simple value types
+ *
+ * Use NESTED structure (grouped subsections) when:
+ * - 3+ fields belong to same logical subsystem
+ * - Clear semantic grouping exists
+ * - Future extensibility anticipated
+ * - Subsystem has distinct meaning
+ *
+ * CURRENT STRUCTURE PATTERNS:
+ *
+ * Flat Sections:
+ * - display_config: enabled, brightness, timeout (3 fields, no subsystems)
+ * - power_config: deep_sleep_enabled, deep_sleep_interval, battery_percent (3
+ * fields)
+ * - mqtt_retry: retry settings and backoff parameters (9 fields, cohesive
+ * purpose)
+ * - ota: enabled, server, port (3 fields)
+ * - encoding: compression and format settings (3 fields)
+ *
+ * Nested Sections:
+ * - sensors.calibration: temperature_offset, humidity_offset, pressure_offset
+ *   (Rationale: Calibration is distinct subsystem, optional, semantically
+ * separate)
+ * - organization: organizationId, customerId, deviceGroup, device_name, etc.
+ *   (Rationale: Optional metadata subsystem, may not be present on all devices)
+ *
+ * EXAMPLES:
+ *
+ * Flat structure:
+ * ```json
+ * "display_config": {
+ *   "enabled": true,
+ *   "brightness": 128,
+ *   "timeout_ms": 30000,
+ *   "timeout_s": 30
+ * }
+ * ```
+ *
+ * Nested structure:
+ * ```json
+ * "sensors": {
+ *   "read_interval_ms": 30000,
+ *   "read_interval_s": 30,
+ *   "calibration": {
+ *     "temperature_offset": 0.5,
+ *     "humidity_offset": -2.0,
+ *     "pressure_offset": 0.0
+ *   }
+ * }
+ * ```
+ *
+ * DECISION RULE:
+ * When in doubt, prefer flat structures. Nesting should provide clear
+ * organizational or extensibility benefits to justify the added complexity.
+ */
+
 namespace alteriom {
 
 /**
@@ -26,6 +153,9 @@ class SensorPackage : public painlessmesh::plugin::BroadcastPackage {
   // Battery level percentage
   uint8_t batteryLevel = 0;
 
+  // MQTT Schema v0.7.3+ message_type for faster classification
+  uint16_t messageType = 200;  // SENSOR_DATA
+
   // Type ID 200 for Alteriom sensors
   SensorPackage() : BroadcastPackage(200) {}
 
@@ -36,6 +166,7 @@ class SensorPackage : public painlessmesh::plugin::BroadcastPackage {
     sensorId = jsonObj["sid"];
     timestamp = jsonObj["ts"];
     batteryLevel = jsonObj["bat"];
+    messageType = jsonObj["message_type"] | 200;
   }
 
   JsonObject addTo(JsonObject&& jsonObj) const {
@@ -46,6 +177,7 @@ class SensorPackage : public painlessmesh::plugin::BroadcastPackage {
     jsonObj["sid"] = sensorId;
     jsonObj["ts"] = timestamp;
     jsonObj["bat"] = batteryLevel;
+    jsonObj["message_type"] = messageType;
     return jsonObj;
   }
 
@@ -66,14 +198,18 @@ class CommandPackage : public painlessmesh::plugin::SinglePackage {
   TSTRING parameters = "";    // Command parameters as JSON string
   uint32_t commandId = 0;     // Unique command identifier for tracking
 
+  // MQTT Schema v0.7.3+ message_type for faster classification
+  uint16_t messageType = 400;  // COMMAND
+
   CommandPackage()
-      : SinglePackage(400) {}  // Type ID 400 (COMMAND per mqtt-schema v0.7.2+)
+      : SinglePackage(400) {}  // Type ID 400 (COMMAND per mqtt-schema v0.7.3+)
 
   CommandPackage(JsonObject jsonObj) : SinglePackage(jsonObj) {
     command = jsonObj["cmd"];
     targetDevice = jsonObj["target"];
     parameters = jsonObj["params"].as<TSTRING>();
     commandId = jsonObj["cid"];
+    messageType = jsonObj["message_type"] | 400;
   }
 
   JsonObject addTo(JsonObject&& jsonObj) const {
@@ -82,6 +218,7 @@ class CommandPackage : public painlessmesh::plugin::SinglePackage {
     jsonObj["target"] = targetDevice;
     jsonObj["params"] = parameters;
     jsonObj["cid"] = commandId;
+    jsonObj["message_type"] = messageType;
     return jsonObj;
   }
 
@@ -94,6 +231,33 @@ class CommandPackage : public painlessmesh::plugin::SinglePackage {
 
 /**
  * @brief Status report package for device health monitoring
+ *
+ * BOOLEAN FIELD NAMING CONVENTION
+ * ================================
+ *
+ * This package follows a standardized naming convention for boolean fields
+ * to improve code clarity and reduce ambiguity. See
+ * docs/BOOLEAN_NAMING_CONVENTION.md for complete documentation.
+ *
+ * Three patterns are used:
+ *
+ * 1. *Set suffix: Configuration data has been provided
+ *    Example: deviceSecretSet = true means secret is configured
+ *    Does NOT indicate if feature is enabled or working
+ *
+ * 2. *Enabled suffix: Feature is currently active/turned on
+ *    Example: displayEnabled = true means display feature is active
+ *    Independent of whether required configuration exists
+ *
+ * 3. is* prefix or *Connected: Current runtime state
+ *    Example: mqttConnected = true means currently connected
+ *    Reflects actual runtime conditions, not configuration
+ *
+ * A feature may have both *Set and *Enabled fields:
+ * - otaServerSet=true, otaEnabled=false: Server configured but feature disabled
+ * - otaServerSet=false, otaEnabled=true: Feature enabled but no server
+ * (invalid)
+ * - otaServerSet=true, otaEnabled=true: Fully configured and active
  */
 class StatusPackage : public painlessmesh::plugin::BroadcastPackage {
  public:
@@ -107,6 +271,53 @@ class StatusPackage : public painlessmesh::plugin::BroadcastPackage {
   uint32_t responseToCommand = 0;  // CommandId this is responding to
   TSTRING responseMessage = "";    // Success/error message
 
+  // Organization metadata (Build 8052 - Phase 2.7)
+  TSTRING organizationId = "";  // Organization identifier
+  TSTRING customerId = "";      // Customer identifier
+  TSTRING deviceGroup = "";     // Device group/category
+  TSTRING deviceName = "";      // Device name
+  TSTRING deviceLocation = "";  // Device location
+  bool deviceSecretSet =
+      false;  // *Set: Has device secret been configured? (not enabled/disabled)
+
+  // Sensor configuration (Build 8057 - Gateway format compatibility)
+  // Note: Time fields follow Alteriom time field naming convention (see file
+  // header) Stored in milliseconds, serialized as both _ms and _s variants
+  uint32_t sensorReadInterval = 0;    // Sensor read interval in milliseconds
+  uint32_t transmissionInterval = 0;  // Transmission interval in milliseconds
+  double tempOffset = 0.0;            // Temperature calibration offset
+  double humidityOffset = 0.0;        // Humidity calibration offset
+  double pressureOffset = 0.0;        // Pressure calibration offset
+
+  // Sensor inventory (Build 8057 - Separate from config to avoid collision)
+  uint8_t sensorCount = 0;     // Number of sensors attached
+  uint8_t sensorTypeMask = 0;  // Bitmask of sensor types present
+
+  // Display configuration
+  bool displayEnabled =
+      false;  // *Enabled: Is display feature currently active?
+  uint8_t displayBrightness = 0;  // Display brightness (0-255)
+  uint32_t displayTimeout = 0;    // Display timeout in milliseconds
+
+  // Power configuration
+  bool deepSleepEnabled =
+      false;  // *Enabled: Is deep sleep mode currently active?
+  uint32_t deepSleepInterval = 0;  // Deep sleep interval in milliseconds
+  uint8_t batteryPercent = 0;      // Battery percentage (0-100)
+
+  // MQTT retry configuration
+  uint8_t mqttMaxRetryAttempts = 0;   // Maximum retry attempts
+  uint32_t mqttCircuitBreakerMs = 0;  // Circuit breaker timeout in milliseconds
+  bool mqttHourlyRetryEnabled =
+      false;                        // *Enabled: Is hourly retry feature active?
+  uint32_t mqttInitialRetryMs = 0;  // Initial retry delay in milliseconds
+  uint32_t mqttMaxRetryMs = 0;      // Maximum retry delay in milliseconds
+  float mqttBackoffMultiplier =
+      0.0;  // Backoff multiplier for exponential backoff
+
+  // MQTT Schema v0.7.3+ message_type for faster classification
+  uint16_t messageType = 202;  // SENSOR_STATUS
+
   StatusPackage() : BroadcastPackage(202) {}  // Type ID 202 for Alteriom status
 
   StatusPackage(JsonObject jsonObj) : BroadcastPackage(jsonObj) {
@@ -117,6 +328,72 @@ class StatusPackage : public painlessmesh::plugin::BroadcastPackage {
     firmwareVersion = jsonObj["fw"].as<TSTRING>();
     responseToCommand = jsonObj["respTo"] | 0;
     responseMessage = jsonObj["respMsg"].as<TSTRING>();
+
+    // Deserialize organization metadata (camelCase format)
+    if (jsonObj["organization"].is<JsonObject>()) {
+      JsonObject org = jsonObj["organization"];
+      organizationId = org["organizationId"].as<TSTRING>();
+      customerId = org["customerId"].as<TSTRING>();
+      deviceGroup = org["deviceGroup"].as<TSTRING>();
+      deviceName = org["device_name"].as<TSTRING>();
+      deviceLocation = org["device_location"].as<TSTRING>();
+      deviceSecretSet = org["device_secret_set"] | false;
+    }
+
+    // Deserialize sensor configuration (Build 8057 - Gateway format)
+    if (jsonObj["sensors"].is<JsonObject>()) {
+      JsonObject sensors = jsonObj["sensors"];
+      sensorReadInterval = sensors["read_interval_ms"] | 0;
+      transmissionInterval = sensors["transmission_interval_ms"] | 0;
+
+      if (sensors["calibration"].is<JsonObject>()) {
+        JsonObject calibration = sensors["calibration"];
+        tempOffset = calibration["temperature_offset"] | 0.0;
+        humidityOffset = calibration["humidity_offset"] | 0.0;
+        pressureOffset = calibration["pressure_offset"] | 0.0;
+      }
+    }
+
+    // Deserialize sensor inventory (Build 8057 - Separate key)
+    if (jsonObj["sensor_inventory"].is<JsonObject>()) {
+      JsonObject sensorInventory = jsonObj["sensor_inventory"];
+      sensorCount = sensorInventory["count"] | 0;
+      sensorTypeMask = sensorInventory["type_mask"] | 0;
+    }
+
+    // Deserialize display configuration (with backward compatibility)
+    if (jsonObj["display_config"].is<JsonObject>()) {
+      JsonObject displayConfig = jsonObj["display_config"];
+      displayEnabled = displayConfig["enabled"] | false;
+      displayBrightness = displayConfig["brightness"] | 0;
+      // Support both old and new field names for backward compatibility
+      displayTimeout =
+          displayConfig["timeout_ms"] | displayConfig["timeout"] | 0;
+    }
+
+    // Deserialize power configuration (with backward compatibility)
+    if (jsonObj["power_config"].is<JsonObject>()) {
+      JsonObject powerConfig = jsonObj["power_config"];
+      deepSleepEnabled = powerConfig["deep_sleep_enabled"] | false;
+      // Support both old and new field names for backward compatibility
+      deepSleepInterval = powerConfig["deep_sleep_interval_ms"] |
+                          powerConfig["deep_sleep_interval"] | 0;
+      batteryPercent = powerConfig["battery_percent"] | 0;
+    }
+
+    // Deserialize MQTT retry configuration
+    if (jsonObj["mqtt_retry"].is<JsonObject>()) {
+      JsonObject mqttRetry = jsonObj["mqtt_retry"];
+      mqttMaxRetryAttempts = mqttRetry["max_attempts"] | 0;
+      mqttCircuitBreakerMs = mqttRetry["circuit_breaker_ms"] | 0;
+      mqttHourlyRetryEnabled = mqttRetry["hourly_retry_enabled"] | false;
+      mqttInitialRetryMs = mqttRetry["initial_retry_ms"] | 0;
+      mqttMaxRetryMs = mqttRetry["max_retry_ms"] | 0;
+      mqttBackoffMultiplier = mqttRetry["backoff_multiplier"] | 0.0;
+    }
+
+    // Deserialize message_type field
+    messageType = jsonObj["message_type"] | 202;
   }
 
   JsonObject addTo(JsonObject&& jsonObj) const {
@@ -130,13 +407,110 @@ class StatusPackage : public painlessmesh::plugin::BroadcastPackage {
       jsonObj["respTo"] = responseToCommand;
       jsonObj["respMsg"] = responseMessage;
     }
+
+    // Serialize organization metadata (mixed case per MQTT Schema v0.7.2)
+    // Always serialize to ensure predictable JSON structure
+    JsonObject org = jsonObj["organization"].to<JsonObject>();
+    org["organizationId"] = organizationId;
+    org["customerId"] = customerId;
+    org["deviceGroup"] = deviceGroup;
+    org["device_name"] = deviceName;
+    org["device_location"] = deviceLocation;
+    org["device_secret_set"] = deviceSecretSet;
+
+    // Serialize sensor configuration (Build 8057 - Match gateway format)
+    // Always serialize to ensure predictable JSON structure
+    JsonObject sensors = jsonObj["sensors"].to<JsonObject>();
+    sensors["read_interval_ms"] = sensorReadInterval;
+    sensors["read_interval_s"] = sensorReadInterval / 1000;
+    sensors["transmission_interval_ms"] = transmissionInterval;
+    sensors["transmission_interval_s"] = transmissionInterval / 1000;
+
+    // Nested calibration object - always serialize for consistency
+    JsonObject calibration = sensors["calibration"].to<JsonObject>();
+    calibration["temperature_offset"] = tempOffset;
+    calibration["humidity_offset"] = humidityOffset;
+    calibration["pressure_offset"] = pressureOffset;
+
+    // Serialize sensor inventory (Build 8057 - Separate key to avoid collision)
+    // Always serialize to ensure predictable JSON structure
+    JsonObject sensorInventory = jsonObj["sensor_inventory"].to<JsonObject>();
+    sensorInventory["count"] = sensorCount;
+    sensorInventory["type_mask"] = sensorTypeMask;
+
+    // Serialize display configuration (with both _ms and _s variants)
+    // Always serialize to ensure predictable JSON structure
+    JsonObject displayConfig = jsonObj["display_config"].to<JsonObject>();
+    displayConfig["enabled"] = displayEnabled;
+    displayConfig["brightness"] = displayBrightness;
+    displayConfig["timeout_ms"] = displayTimeout;
+    displayConfig["timeout_s"] = displayTimeout / 1000;
+
+    // Serialize power configuration (with both _ms and _s variants)
+    // Always serialize to ensure predictable JSON structure
+    JsonObject powerConfig = jsonObj["power_config"].to<JsonObject>();
+    powerConfig["deep_sleep_enabled"] = deepSleepEnabled;
+    powerConfig["deep_sleep_interval_ms"] = deepSleepInterval;
+    powerConfig["deep_sleep_interval_s"] = deepSleepInterval / 1000;
+    powerConfig["battery_percent"] = batteryPercent;
+
+    // Serialize MQTT retry configuration (with both _ms and _s variants)
+    // Always serialize to ensure predictable JSON structure
+    JsonObject mqttRetry = jsonObj["mqtt_retry"].to<JsonObject>();
+    mqttRetry["max_attempts"] = mqttMaxRetryAttempts;
+    mqttRetry["circuit_breaker_ms"] = mqttCircuitBreakerMs;
+    mqttRetry["circuit_breaker_s"] = mqttCircuitBreakerMs / 1000;
+    mqttRetry["hourly_retry_enabled"] = mqttHourlyRetryEnabled;
+    mqttRetry["initial_retry_ms"] = mqttInitialRetryMs;
+    mqttRetry["initial_retry_s"] = mqttInitialRetryMs / 1000;
+    mqttRetry["max_retry_ms"] = mqttMaxRetryMs;
+    mqttRetry["max_retry_s"] = mqttMaxRetryMs / 1000;
+    mqttRetry["backoff_multiplier"] = mqttBackoffMultiplier;
+
+    // Serialize message_type field
+    jsonObj["message_type"] = messageType;
+
     return jsonObj;
   }
 
 #if ARDUINOJSON_VERSION_MAJOR < 7
   size_t jsonObjectSize() const {
-    return JSON_OBJECT_SIZE(noJsonFields + 7) + firmwareVersion.length() +
-           responseMessage.length();
+    size_t size = JSON_OBJECT_SIZE(noJsonFields + 7) +
+                  firmwareVersion.length() + responseMessage.length();
+
+    // Always add organization object size for predictable structure
+    size += JSON_OBJECT_SIZE(6) + organizationId.length() +
+            customerId.length() + deviceGroup.length() + deviceName.length() +
+            deviceLocation.length();
+
+    // Always add sensor configuration object size (Build 8057)
+    // sensors object with read_interval_ms, read_interval_s,
+    // transmission_interval_ms, transmission_interval_s, calibration
+    size += JSON_OBJECT_SIZE(5);
+    // calibration nested object - always included
+    size += JSON_OBJECT_SIZE(3);
+
+    // Always add sensor inventory object size (Build 8057)
+    size += JSON_OBJECT_SIZE(
+        2);  // sensor_inventory object with count and type_mask
+
+    // Always add display configuration object size
+    // display_config object with enabled, brightness, timeout_ms, timeout_s
+    size += JSON_OBJECT_SIZE(4);
+
+    // Always add power configuration object size
+    // power_config object with deep_sleep_enabled, deep_sleep_interval_ms,
+    // deep_sleep_interval_s, battery_percent
+    size += JSON_OBJECT_SIZE(4);
+
+    // Always add MQTT retry configuration object size
+    // mqtt_retry object with max_attempts, circuit_breaker_ms,
+    // circuit_breaker_s, hourly_retry_enabled, initial_retry_ms,
+    // initial_retry_s, max_retry_ms, max_retry_s, backoff_multiplier
+    size +=
+        JSON_OBJECT_SIZE(9) + 10;  // Extra space for backoff_multiplier string
+
+    return size;
   }
 #endif
 };

package/examples/alteriom/platformio.ini

@@ -14,7 +14,7 @@ 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  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32

package/examples/alteriomImproved/platformio.ini

@@ -20,7 +20,7 @@ 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  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32

package/examples/alteriomMetricsHealth/metrics_health_node.ino

@@ -116,7 +116,8 @@ void sendMetrics() {
   // CPU and Processing
   metrics.loopIterations = ((loopCount - lastLoopCount) * 1000) / timeDelta;
   metrics.cpuUsage = calculateCPUUsage();
-  metrics.taskQueueSize = userScheduler.size();
+  // Note: TaskScheduler doesn't provide a size() method, so we'll use 0 or estimate
+  metrics.taskQueueSize = 0;  // TaskScheduler API doesn't expose queue size
   
   // Memory Metrics
   metrics.freeHeap = ESP.getFreeHeap();
@@ -155,8 +156,13 @@ void sendMetrics() {
   metrics.collectionTimestamp = mesh.getNodeTime();
   metrics.collectionInterval = METRICS_INTERVAL;
   
-  // Send the metrics
-  String msg = metrics.toJsonString();
+  // Serialize and send the metrics
+  JsonDocument doc;
+  JsonObject obj = doc.to<JsonObject>();
+  metrics.addTo(std::move(obj));
+  
+  String msg;
+  serializeJson(doc, msg);
   bool sent = mesh.sendBroadcast(msg);
   
   if (sent) {
@@ -266,8 +272,13 @@ void sendHealthCheck() {
   health.checkTimestamp = mesh.getNodeTime();
   health.nextCheckDue = health.checkTimestamp + (HEALTH_INTERVAL * 1000);
   
-  // Send the health check
-  String msg = health.toJsonString();
+  // Serialize and send the health check
+  JsonDocument doc;
+  JsonObject obj = doc.to<JsonObject>();
+  health.addTo(std::move(obj));
+  
+  String msg;
+  serializeJson(doc, msg);
   bool sent = mesh.sendBroadcast(msg);
   
   if (sent) {
@@ -372,10 +383,10 @@ void receivedCallback(uint32_t from, String& msg) {
   totalPacketsRx++;
   
   // Parse message type
-  DynamicJsonDocument doc(1024);
+  JsonDocument doc;
   deserializeJson(doc, msg);
   JsonObject obj = doc.as<JsonObject>();
-  uint8_t msgType = obj["type"];
+  uint16_t msgType = obj["type"];
   
   Serial.printf("\nReceived Type %d from %u\n", msgType, from);
   

package/examples/alteriomMetricsHealth/platformio.ini

@@ -14,7 +14,7 @@ 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  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32

package/examples/alteriomPhase1/platformio.ini

@@ -14,7 +14,7 @@ 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  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32

package/examples/alteriomPhase2/platformio.ini

@@ -14,7 +14,7 @@ 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  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32

package/examples/alteriomSensorNode/platformio.ini

@@ -14,7 +14,7 @@ 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  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32

package/examples/basic/platformio.ini

@@ -14,7 +14,7 @@ framework = arduino
 lib_extra_dirs = ../../
 lib_deps =
     ${env.lib_deps}  ; Inherit common dependencies
-    esp32async/ESPAsyncTCP  ; Only for ESP8266
+    esp32async/ESPAsyncTCP@^2.0.0  ; Only for ESP8266
 
 [env:esp32]
 platform = espressif32