Stop Wondering.
Start Monitoring.

# pip install "pymodbus[serial]==3.11.1"
from datetime import datetime, timezone
from pymodbus.client import ModbusSerialClient

# EXAMPLE ONLY: replace with the official register map
PROFILE = {
    "model": "verified-controller-model",
    "unit_id": 1,
    "room_temp": {
        "address": 100,  # FICTIONAL, NOT a vendor address
        "scale": 0.1,
        "signed": True,
    },
}

def decode_word(raw, signed=False):
    if signed and raw >= 0x8000:
        return raw - 0x10000
    return raw

client = ModbusSerialClient(
    port="/dev/ttyUSB0",
    baudrate=9600, parity="N", stopbits=1,
    bytesize=8, timeout=2,
)

try:
    if not client.connect():
        raise ConnectionError("RS-485 adapter unavailable")

    reg = PROFILE["room_temp"]
    reply = client.read_holding_registers(
        address=reg["address"], count=1,
        device_id=PROFILE["unit_id"],
    )
    if reply.isError():
        raise RuntimeError(f"Modbus error: {reply}")

    raw = decode_word(reply.registers[0], reg["signed"])
    payload = {
        "device_id": "tms-gateway-001",
        "controller_id": PROFILE["unit_id"],
        "controller": PROFILE["model"],
        "temperature_c": raw * reg["scale"],
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "quality": "sample_read_only",  # example value
    }
    print(payload)
finally:
    client.close()

# pip install paho-mqtt
import json
import os
import ssl
import paho.mqtt.client as mqtt

ENDPOINT = os.environ["AWS_IOT_ENDPOINT"]
THING_ID = os.environ["TMS_THING_ID"]
TOPIC = f"tms/{THING_ID}/telemetry"

# Paths to securely provisioned device credentials
CA = "/etc/tms/certs/AmazonRootCA1.pem"
CERT = "/etc/tms/certs/device.pem.crt"
KEY = "/etc/tms/certs/private.pem.key"

client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id=THING_ID,
    protocol=mqtt.MQTTv311,
)
client.tls_set(
    ca_certs=CA, certfile=CERT, keyfile=KEY,
    cert_reqs=ssl.CERT_REQUIRED,
    tls_version=ssl.PROTOCOL_TLS_CLIENT,
)

telemetry = {
    "device_id": THING_ID,
    "controller_id": 1,
    "temperature_c": 2.4,  # placeholder: publish a validated reading
    "quality": "sample_read_only",
    "timestamp": "2026-11-04T00:00:00Z",  # illustrative UTC timestamp
    "source": "modbus_rtu",
}

client.connect(ENDPOINT, port=8883, keepalive=60)
client.loop_start()
try:
    result = client.publish(TOPIC, json.dumps(telemetry), qos=1)
    result.wait_for_publish(timeout=10)
    if not result.is_published():
        raise TimeoutError("MQTT publish not confirmed")
finally:
    client.disconnect()
    client.loop_stop()

{
  "vendor": "EXAMPLE_ONLY",
  "model": "VERIFY_EXACT_MODEL",
  "protocol": "modbus_rtu",
  "serial": { "baudrate": 9600, "parity": "N", "stopbits": 1, "slave_id": 1 },
  "registers": {
    "room_temperature": {
      "address": 100, "function": "holding",
      "signed": true, "scale": 0.1, "unit": "celsius"
    }
  },
  "read_only": true,
  "verified_against_manual": false
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:ap-southeast-2:123456789012:client/tms-gateway-001"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": "arn:aws:iot:ap-southeast-2:123456789012:topic/tms/tms-gateway-001/telemetry"
    }
  ]
}

# Illustrative local queue: sqlite3 is in Python's standard library.
# Cloud ingestion must independently validate and deduplicate.
import json
import sqlite3
from datetime import datetime, timezone

with sqlite3.connect("/var/lib/tms/telemetry.db") as db:
    db.execute("PRAGMA journal_mode=WAL")
    db.execute("""CREATE TABLE IF NOT EXISTS pending (
        device_id TEXT NOT NULL,
        seq INTEGER NOT NULL,
        captured_at TEXT NOT NULL,
        payload TEXT NOT NULL,
        PRIMARY KEY(device_id, seq)
    )""")
    # seq must come from a persistent per-device counter.
    # Do not generate it from the current process memory.
    seq = 1042  # DEMO ONLY
    reading = {
        "device_id": "tms-gateway-001",
        "seq": seq,
        "captured_at": datetime.now(timezone.utc).isoformat(),
        "temperature_c": 2.4,
        "quality": "example_validated"
    }
    db.execute("INSERT OR IGNORE INTO pending VALUES (?, ?, ?, ?)",
               (reading["device_id"], seq,
                reading["captured_at"], json.dumps(reading)))

# Production: publish queued records in order; delete only after
# application-level durable-ingestion acknowledgement, NOT merely
# after an MQTT QoS 1 broker acknowledgement.
# Provision durable storage, capacity limits and safe shutdown.

{
  "device_id": "tms-gateway-001",
  "site_id": "site-example-01",
  "seq": 1042,
  "captured_at": "2026-11-05T02:00:00Z",
  "received_at": "2026-11-05T02:00:03Z",
  "temperature_c": 2.4,
  "relative_humidity_pct": 82,
  "quality": "valid",
  "source": "modbus_rtu",
  "profile_version": "example-1.0"
}