## Overview

This article covers a small, self-contained IoT pattern: a device publishes *quantum saltwell telemetry* events to a NATS message broker using an ESP32. The telemetry includes a monotonically increasing sequence number, a device timestamp, a 16-byte “saltwell nonce,” and a simulated sensor payload derived from on-device readings.

NATS is used for lightweight pub/sub. The ESP32 publishes to a subject named `telemetry.saltwell.v1`.

## Hardware and Software

### Hardware
- ESP32 dev board
- USB cable
- NATS server reachable from the ESP32 network

### Software
- Arduino framework for ESP32
- Libraries:
  - `WiFi.h`
  - `ArduinoJson.h`
  - `WiFiClient.h`

The code below uses a minimal TCP publish over the NATS protocol (no TLS, plain TCP). For production deployments, use TLS and proper credentials.

## NATS Protocol Primer (Minimal Publish)

For a NATS server, a publish command in the plain protocol looks like:

- `PUB <subject> <reply-to> <#bytes>\r\n<payload>\r\n`

The reply-to field can be empty (`_` is sometimes used in examples, but empty is valid for no reply).

## ESP32 Publisher (Arduino)

```cpp
#include <WiFi.h>
#include <WiFiClient.h>
#include <ArduinoJson.h>

static const char* WIFI_SSID = "YOUR_SSID";
static const char* WIFI_PASS = "YOUR_PASSWORD";

static const char* NATS_HOST = "192.168.1.50";
static const uint16_t NATS_PORT = 4222;

WiFiClient client;

uint64_t seqNo = 0;

String randHex16() {
  static const char* hex = "0123456789abcdef";
  uint8_t b[16];
  for (int i = 0; i < 16; i++) b[i] = (uint8_t)(esp_random() & 0xFF);

  char out[33];
  for (int i = 0; i < 16; i++) {
    out[i * 2] = hex[(b[i] >> 4) & 0x0F];
    out[i * 2 + 1] = hex[b[i] & 0x0F];
  }
  out[32] = '\0';
  return String(out);
}

uint32_t msNow() {
  // Milliseconds since boot; sufficient for telemetry correlation.
  return (uint32_t)millis();
}

bool natsConnect() {
  if (client.connected()) return true;
  if (!client.connect(NATS_HOST, NATS_PORT)) return false;

  // Read server INFO line (ends with \r\n). Not strictly needed for PUB,
  // but consuming it keeps stream state sane.
  uint32_t start = millis();
  while (client.connected() && (millis() - start) < 2000) {
    if (client.available()) {
      String line = client.readStringUntil('\n');
      if (line.startsWith("INFO")) return true;
      break;
    }
    delay(10);
  }
  return true;
}

bool natsPublish(const char* subject, const String& payload) {
  if (!natsConnect()) return false;

  // PUB <subject> [reply-to] <#bytes>\r\n<payload>\r\n
  // Use empty reply-to by omitting token is not valid; NATS expects tokens.
  // Use "-" as reply-to placeholder.
  String cmd = String("PUB ") + subject + " - " + payload.length() + "\r\n" + payload + "\r\n";
  size_t written = client.write((const uint8_t*)cmd.c_str(), cmd.length());
  client.flush();
  return written == cmd.length();
}

void setup() {
  Serial.begin(115200);
  delay(200);

  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);

  uint32_t start = millis();
  while (WiFi.status() != WL_CONNECTED && (millis() - start) < 15000) {
    delay(250);
  }

  // NATS connection is established on demand by natsPublish().
}

void loop() {
  // Simulated sensor payload: convert ADC reading to a stable-looking metric.
  // GPIO34 is input-only on many ESP32 boards; adjust pin if needed.
  int raw = analogRead(34);
  float scaled = (float)raw * (3.30f / 4095.0f);

  // Build JSON payload.
  StaticJsonDocument<256> doc;
  doc["type"] = "saltwell.telemetry";
  doc["seq"] = seqNo++;
  doc["t_ms"] = msNow();
  doc["nonce"] = randHex16();
  doc["payload"] = scaled; // Example: a voltage-like scalar

  String payload;
  serializeJson(doc, payload);

  bool ok = natsPublish("telemetry.saltwell.v1", payload);

  // Backoff on failures; NATS server may be unavailable.
  if (!ok) {
    delay(2000);
  } else {
    delay(750);
  }
}
```

## NATS Subscriber (Node.js)

A matching subscriber prints incoming telemetry and validates JSON.

### Install and Run

```bash
npm init -y
npm i nats
node subscriber.js
```

### subscriber.js

```javascript
import { connect, StringCodec } from "nats";

const nc = await connect({ servers: "nats://192.168.1.50:4222" });

const sc = StringCodec();

const sub = nc.subscribe("telemetry.saltwell.v1");
console.log("Subscribed to telemetry.saltwell.v1");

for await (const msg of sub) {
  const text = sc.decode(msg.data);
  const obj = JSON.parse(text);
  console.log({
    seq: obj.seq,
    t_ms: obj.t_ms,
    nonce: obj.nonce,
    payload: obj.payload,
  });
}
```

## Concluding Notes

The presented implementation demonstrates a compact IoT telemetry pipeline where an ESP32 publishes JSON events to NATS using plain TCP and a Node.js subscriber consumes the stream in real time. The resulting design separates device telemetry production from downstream processing through subject-based pub/sub, enabling resilient message routing and straightforward verification of event fields and sequencing.

Quantum Saltwell Telemetry With Esp32 And Nats

If you publish device telemetry to MQTT, one of the most painful debugging problems is “stale state”: messages or subscriptions that hang around longer than you expect. **MQTT v5** gives you fine-grained control over *when the broker should expire a client session*, which is especially useful for IoT fleets that intermittently connect (battery devices, mobile gateways, intermittent networks).

This post is about a **random-but-practical** topic: using **MQTT v5 Server-Side Session Expiry** to make telemetry behavior more deterministic.

---

### Why Session Expiry Matters in IoT

In MQTT v3.1.1, session persistence can be confusing because “clean session” behavior doesn’t express *time-based* expiry. MQTT v5 adds:

- **Session Expiry Interval** (server-side): how long the broker keeps the session *after the client disconnects*.
- This affects whether subscriptions and queued QoS messages remain available when the device reconnects.

For intermittent IoT devices, picking a short session expiry interval can prevent:
- Out-of-date subscription state
- Old queued messages being delivered long after they’re relevant

---

### A Practical Configuration Strategy

A common strategy for telemetry sensors:

- **QoS 1** for at-least-once delivery
- **Clean start = false** (so you want sessions when appropriate)
- **Session Expiry Interval** set based on your acceptable “offline window”
  - Example: if you can tolerate at most 60 seconds offline, set expiry to 60 seconds

---

### Working Example: Connect with Session Expiry (Node.js)

Below is a complete, working script using the popular `mqtt` package. It connects to an MQTT broker with **MQTT v5**, requests a session expiry interval, publishes a message, then disconnects.

> Prerequisites:
> - Node.js installed
> - An MQTT broker running at `mqtt://localhost:1883` with MQTT v5 enabled (many brokers do)
>
> Install:
> ```bash
> npm install mqtt
> ```

```js
// File: mqtt-session-expiry.js
// Run: node mqtt-session-expiry.js
const mqtt = require("mqtt");

const brokerUrl = "mqtt://localhost:1883";
const topic = "iot/demo/telemetry";

const client = mqtt.connect(brokerUrl, {
  protocolVersion: 5,
  clientId: "sensor-001",
  clean: false, // MQTT v5 Clean Start (mapped by the library)
  properties: {
    sessionExpiryInterval: 60 // seconds
  }
});

client.on("connect", () => {
  const payload = JSON.stringify({
    ts: new Date().toISOString(),
    value: Math.random()
  });

  client.publish(topic, payload, { qos: 1 }, (err) => {
    if (err) {
      console.error("Publish failed:", err);
      client.end(true);
      return;
    }
    console.log("Published:", payload);

    // Disconnect after publish. Session may persist up to sessionExpiryInterval.
    client.end(false);
  });
});

client.on("error", (err) => {
  console.error("Client error:", err);
});
```

---

### Verifying Behavior (Conceptually)

To confirm this works as intended, you can:

1. Run the script.
2. Disconnect the device (it does this automatically).
3. Reconnect within **60 seconds** and check whether prior session data (like subscriptions) remains.
4. Reconnect after **60 seconds** and observe that the broker may treat it as an expired session (subscriptions/queued messages can differ based on broker behavior and what was stored).

Different brokers may store different session elements, but **session expiry is standardized**: the broker removes state after the interval elapses.

---

### Key Gotchas

#### 1) Session expiry isn’t “message retention”
Queued QoS messages and subscriptions may depend on:
- Whether the broker actually queues them
- Whether you previously established subscriptions
- How the broker implements storage

#### 2) Use retained messages for durable latest-state (separately)
If you want devices to always obtain the latest known value immediately, you may also use **MQTT retained messages**—that’s different from session expiry.

#### 3) Choose expiry based on real network patterns
Battery IoT devices might reconnect quickly sometimes, but occasionally take hours. Setting expiry too low can force re-subscription each time; too high can deliver outdated queued messages.

---

### Conclusion

MQTT v5 **Server-Side Session Expiry Interval** is a powerful lever for IoT telemetry systems that experience intermittent connectivity. By setting an appropriate expiry value (like 60 seconds in the example), you can reduce stale state and make reconnection behavior more predictable.

Mqttv5 Server-Side Session Expiry For Deterministic Iot Telemetry

### Introduction

As the Internet of Things (IoT) continues to revolutionize various sectors, an interesting integration has emerged between IoT and Machine Learning (ML) that provides the ability for predictive maintenance. This potent mix of technologies allows us to analyze data generated by IoT devices and predict future outcomes with Machine Learning. This blog post gives an overview of how to use Python for creating a simple predictive maintenance model using a decision tree classifier.

### Setting up IoT sensor data

Before we can predict anything, we need to have data. Assume we have an IoT-connected temperature sensor in a machine whose failure rate could be related to temperature variation. The IoT data could be stored in a database or a CSV file. Here, we will consider that the data is stored in a CSV file format with columns `Timestamp`, `Temperature`, and `Failure`. `Failure` is `1` if the machine failed at that point and `0` otherwise.

### Import Necessary Libraries

We will need a range of libraries for this task, including pandas for data handling, sklearn for the decision tree, and matplotlib for visualization.

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
```

### Load Your Data

Let's load the CSV file and take a look at the data.

```python
dataframe = pd.read_csv("machine_sensor_data.csv")
print(dataframe.head())
```

### Preprocess Data

We must preprocess our data before we can use it for prediction. Split the data into 'features' and 'target' sets:

```python
#Features
X=dataframe.drop('Failure',axis=1)
#Target
y=dataframe['Failure']
```

Also, split our data into a training set and a test set:

```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)
```

### Implementing Decision Tree Classifier

Now, let's use a decision tree to try and predict failures from our sensor data.

```python
classifier = DecisionTreeClassifier()
classifier.fit(X_train, y_train)
```

### Making Predictions and Evaluating the Model

We can make predictions on our test set and evaluate our model accuracy.

```python
predictions = classifier.predict(X_test)

#Print confusion matrix and classification report
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))
```

This model can now be used to assess incoming sensor data in real time and trigger alerts, create tickets automatically, or proactively initiate maintenance activities if a potential failure is predicted.

### Conclusion

In this post, we saw an instance of how Machine Learning can leverage IoT data for predictive maintenance. This application not only increases the efficiency of maintenance but also prevents breakdowns thus saving valuable time and resources. The confluence of IoT and ML unearths immense possibilities that promise to usher in a new era of technological advancements.

Internet Of Things Posts

Quantum Saltwell Telemetry With Esp32 And Nats

Mqttv5 Server-Side Session Expiry For Deterministic Iot Telemetry

Integrating Machine Learning With Iot For Predictive Maintenance