Code Examples

pip install paho-mqtt

import paho.mqtt.client as mqtt
import ssl
import json
import time

# Configuration
BROKER = "your-instance.sensorclouds.com"
PORT = 8883
DEVICE_TOKEN = "your-device-token"
PASSWORD = "your-device-password"
TENANT_ID = "your-tenant-id"
APP_ID = "your-app-id"

# Topics
DATA_TOPIC = f"tenant/{TENANT_ID}/app/{APP_ID}/device/{DEVICE_TOKEN}/data"
STATUS_TOPIC = f"tenant/{TENANT_ID}/app/{APP_ID}/device/{DEVICE_TOKEN}/status"
CMD_TOPIC = f"tenant/{TENANT_ID}/app/{APP_ID}/device/{DEVICE_TOKEN}/cmd"

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected successfully")
        # Publish online status
        client.publish(STATUS_TOPIC, json.dumps({"status": "online"}), qos=1, retain=True)
        # Subscribe to commands
        client.subscribe(CMD_TOPIC, qos=1)
    else:
        print(f"Connection failed with code {rc}")

def on_message(client, userdata, msg):
    print(f"Command received: {msg.payload.decode()}")

# Create client with LWT
client = mqtt.Client(client_id=DEVICE_TOKEN)
client.username_pw_set(DEVICE_TOKEN, PASSWORD)
client.tls_set(tls_version=ssl.PROTOCOL_TLS)
client.will_set(STATUS_TOPIC, json.dumps({"status": "offline"}), qos=1, retain=True)

client.on_connect = on_connect
client.on_message = on_message

client.connect(BROKER, PORT)
client.loop_start()

# Publish telemetry every 10 seconds
while True:
    payload = {"temperature": 25.3, "humidity": 60}
    client.publish(DATA_TOPIC, json.dumps(payload), qos=1)
    print(f"Published: {payload}")
    time.sleep(10)

npm install mqtt

const mqtt = require('mqtt');

// Configuration
const BROKER = 'mqtts://your-instance.sensorclouds.com:8883';
const DEVICE_TOKEN = 'your-device-token';
const PASSWORD = 'your-device-password';
const TENANT_ID = 'your-tenant-id';
const APP_ID = 'your-app-id';

const baseTopic = `tenant/${TENANT_ID}/app/${APP_ID}/device/${DEVICE_TOKEN}`;

const client = mqtt.connect(BROKER, {
  username: DEVICE_TOKEN,
  password: PASSWORD,
  clientId: DEVICE_TOKEN,
  will: {
    topic: `${baseTopic}/status`,
    payload: JSON.stringify({ status: 'offline' }),
    qos: 1,
    retain: true,
  },
});

client.on('connect', () => {
  console.log('Connected to Sensorclouds');

  // Publish online status
  client.publish(`${baseTopic}/status`, JSON.stringify({ status: 'online' }), {
    qos: 1,
    retain: true,
  });

  // Subscribe to commands
  client.subscribe(`${baseTopic}/cmd`, { qos: 1 });

  // Publish telemetry every 10 seconds
  setInterval(() => {
    const payload = { temperature: 25.3, humidity: 60 };
    client.publish(`${baseTopic}/data`, JSON.stringify(payload), { qos: 1 });
    console.log('Published:', payload);
  }, 10000);
});

client.on('message', (topic, message) => {
  console.log('Command received:', message.toString());
});

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// WiFi credentials
const char* ssid = "your-wifi-ssid";
const char* wifiPassword = "your-wifi-password";

// MQTT Configuration
const char* mqttServer = "your-instance.sensorclouds.com";
const int mqttPort = 8883;
const char* deviceToken = "your-device-token";
const char* mqttPassword = "your-device-password";
const char* tenantId = "your-tenant-id";
const char* appId = "your-app-id";

// Let's Encrypt ISRG Root X1
const char* rootCA = R"EOF(
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQEL
...
-----END CERTIFICATE-----
)EOF";

WiFiClientSecure espClient;
PubSubClient client(espClient);

char dataTopic[128];
char statusTopic[128];
char cmdTopic[128];

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

  // Build topic strings
  snprintf(dataTopic, sizeof(dataTopic),
    "tenant/%s/app/%s/device/%s/data", tenantId, appId, deviceToken);
  snprintf(statusTopic, sizeof(statusTopic),
    "tenant/%s/app/%s/device/%s/status", tenantId, appId, deviceToken);
  snprintf(cmdTopic, sizeof(cmdTopic),
    "tenant/%s/app/%s/device/%s/cmd", tenantId, appId, deviceToken);

  // Connect WiFi
  WiFi.begin(ssid, wifiPassword);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");

  // Configure TLS
  espClient.setCACert(rootCA);

  // Configure MQTT
  client.setServer(mqttServer, mqttPort);
  client.setCallback(onMessage);
}

void onMessage(char* topic, byte* payload, unsigned int length) {
  Serial.print("Command received: ");
  Serial.write(payload, length);
  Serial.println();
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect(deviceToken, deviceToken, mqttPassword,
        statusTopic, 1, true, "{\"status\":\"offline\"}")) {
      Serial.println("MQTT connected");
      client.publish(statusTopic, "{\"status\":\"online\"}", true);
      client.subscribe(cmdTopic, 1);
    } else {
      delay(5000);
    }
  }
}

void loop() {
  if (!client.connected()) reconnect();
  client.loop();

  // Publish telemetry every 10 seconds
  static unsigned long lastPublish = 0;
  if (millis() - lastPublish > 10000) {
    StaticJsonDocument<128> doc;
    doc["temperature"] = 25.3;
    doc["humidity"] = 60;

    char buffer[128];
    serializeJson(doc, buffer);
    client.publish(dataTopic, buffer);
    Serial.println(buffer);

    lastPublish = millis();
  }
}