Tutorials / MQTT Connection Examples

MQTT Connection Examples

Code samples for connecting devices across different platforms

Overview

This guide provides code examples for connecting various IoT devices and platforms to Quarkifi Stream using MQTT protocol. All examples include authentication, data publishing, and command reception.

Connection Parameters

Required Information

Before connecting, gather these details from your device settings in Quarkifi Stream:

  • Broker URL: MQTT broker address (e.g., mqtt.quarkifi.com)
  • Port: 1883 (MQTT) or 8883 (MQTT/TLS)
  • Username: Device-specific username
  • Password: Device-specific password
  • Publish Topic: Topic for sending telemetry data
  • Subscribe Topic: Topic for receiving commands

ESP32/ESP8266 (Arduino)

Example for ESP32 and ESP8266 microcontrollers using Arduino framework:

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

// WiFi credentials
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// MQTT Broker settings
const char* mqtt_server = "mqtt.quarkifi.com";
const int mqtt_port = 1883;
const char* mqtt_user = "YOUR_DEVICE_USERNAME";
const char* mqtt_pass = "YOUR_DEVICE_PASSWORD";

// Topics
const char* publish_topic = "devices/YOUR_DEVICE_ID/telemetry";
const char* subscribe_topic = "devices/YOUR_DEVICE_ID/commands";

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void setup_wifi() {
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected");
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived on topic: ");
  Serial.println(topic);

  // Parse JSON command
  StaticJsonDocument<256> doc;
  deserializeJson(doc, payload, length);

  // Handle command
  if (doc.containsKey("relay")) {
    bool relayState = doc["relay"];
    digitalWrite(RELAY_PIN, relayState ? HIGH : LOW);
  }
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("ESP32Client", mqtt_user, mqtt_pass)) {
      client.subscribe(subscribe_topic);
    } else {
      delay(5000);
    }
  }
}

void publishData() {
  StaticJsonDocument<256> doc;
  doc["temperature"] = 25.5;
  doc["humidity"] = 60.2;
  doc["timestamp"] = millis();

  char buffer[256];
  serializeJson(doc, buffer);
  client.publish(publish_topic, buffer);
}

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

  // Publish data every 10 seconds
  static unsigned long lastPublish = 0;
  if (millis() - lastPublish > 10000) {
    publishData();
    lastPublish = millis();
  }
}

Raspberry Pi (Python)

Python example using paho-mqtt library for Raspberry Pi:

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

# MQTT Configuration
BROKER = "mqtt.quarkifi.com"
PORT = 1883
USERNAME = "YOUR_DEVICE_USERNAME"
PASSWORD = "YOUR_DEVICE_PASSWORD"
PUBLISH_TOPIC = "devices/YOUR_DEVICE_ID/telemetry"
SUBSCRIBE_TOPIC = "devices/YOUR_DEVICE_ID/commands"

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    client.subscribe(SUBSCRIBE_TOPIC)

def on_message(client, userdata, msg):
    print(f"Message received on {msg.topic}")
    payload = json.loads(msg.payload.decode())

    # Handle commands
    if "relay" in payload:
        relay_state = payload["relay"]
        print(f"Setting relay to {relay_state}")
        # Your GPIO control code here

def publish_telemetry(client):
    data = {
        "temperature": 22.5,
        "humidity": 55.0,
        "pressure": 1013.25,
        "timestamp": int(time.time())
    }
    client.publish(PUBLISH_TOPIC, json.dumps(data))
    print("Data published")

# Create MQTT client
client = mqtt.Client()
client.username_pw_set(USERNAME, PASSWORD)
client.on_connect = on_connect
client.on_message = on_message

# Connect to broker
client.connect(BROKER, PORT, 60)
client.loop_start()

# Main loop
try:
    while True:
        publish_telemetry(client)
        time.sleep(10)
except KeyboardInterrupt:
    client.loop_stop()
    client.disconnect()

Node.js

JavaScript example for Node.js applications:

const mqtt = require('mqtt');

// MQTT Configuration
const options = {
  host: 'mqtt.quarkifi.com',
  port: 1883,
  username: 'YOUR_DEVICE_USERNAME',
  password: 'YOUR_DEVICE_PASSWORD',
  clientId: 'nodejs_client_' + Math.random().toString(16).substr(2, 8)
};

const PUBLISH_TOPIC = 'devices/YOUR_DEVICE_ID/telemetry';
const SUBSCRIBE_TOPIC = 'devices/YOUR_DEVICE_ID/commands';

// Connect to MQTT broker
const client = mqtt.connect(options);

client.on('connect', () => {
  console.log('Connected to MQTT broker');
  client.subscribe(SUBSCRIBE_TOPIC, (err) => {
    if (!err) {
      console.log('Subscribed to commands topic');
    }
  });

  // Start publishing data
  setInterval(publishData, 10000);
});

client.on('message', (topic, message) => {
  console.log(`Received message on ${topic}`);
  const payload = JSON.parse(message.toString());

  // Handle commands
  if (payload.relay !== undefined) {
    console.log(`Setting relay to ${payload.relay}`);
    // Your actuator control code here
  }
});

function publishData() {
  const data = {
    temperature: 23.5 + Math.random() * 2,
    humidity: 58.0 + Math.random() * 5,
    timestamp: Date.now()
  };

  client.publish(PUBLISH_TOPIC, JSON.stringify(data), { qos: 1 });
  console.log('Data published:', data);
}

client.on('error', (error) => {
  console.error('Connection error:', error);
});

Arduino (Generic)

Example for Arduino boards with Ethernet or WiFi shields:

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 177);
IPAddress server(XXX, XXX, XXX, XXX); // Your broker IP

EthernetClient ethClient;
PubSubClient client(ethClient);

const char* mqtt_user = "YOUR_DEVICE_USERNAME";
const char* mqtt_pass = "YOUR_DEVICE_PASSWORD";
const char* publish_topic = "devices/YOUR_DEVICE_ID/telemetry";

void setup() {
  Serial.begin(9600);
  Ethernet.begin(mac, ip);
  client.setServer(server, 1883);
  delay(1500);
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("ArduinoClient", mqtt_user, mqtt_pass)) {
      Serial.println("Connected");
    } else {
      delay(5000);
    }
  }
}

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

  // Read sensors and publish
  float temp = analogRead(A0) * 0.48828125;
  String payload = "{\"temperature\":" + String(temp) + "}";

  client.publish(publish_topic, payload.c_str());
  delay(10000);
}

MicroPython

Example for ESP32/ESP8266 running MicroPython:

from umqtt.simple import MQTTClient
import network
import ujson
import time

# WiFi setup
SSID = "YOUR_WIFI_SSID"
PASSWORD = "YOUR_WIFI_PASSWORD"

# MQTT Configuration
BROKER = "mqtt.quarkifi.com"
CLIENT_ID = "micropython_client"
USERNAME = "YOUR_DEVICE_USERNAME"
PASSWORD_MQTT = "YOUR_DEVICE_PASSWORD"
PUBLISH_TOPIC = b"devices/YOUR_DEVICE_ID/telemetry"
SUBSCRIBE_TOPIC = b"devices/YOUR_DEVICE_ID/commands"

def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(SSID, PASSWORD)
    while not wlan.isconnected():
        time.sleep(1)
    print("WiFi Connected:", wlan.ifconfig())

def mqtt_callback(topic, msg):
    print("Message:", msg)
    data = ujson.loads(msg)
    if "relay" in data:
        # Control relay
        print("Relay:", data["relay"])

def main():
    connect_wifi()

    client = MQTTClient(CLIENT_ID, BROKER,
                       user=USERNAME,
                       password=PASSWORD_MQTT)
    client.set_callback(mqtt_callback)
    client.connect()
    client.subscribe(SUBSCRIBE_TOPIC)

    while True:
        client.check_msg()

        # Publish telemetry
        data = {
            "temperature": 24.5,
            "humidity": 62.0
        }
        client.publish(PUBLISH_TOPIC, ujson.dumps(data))
        time.sleep(10)

if __name__ == "__main__":
    main()

Payload Format

Telemetry Data (Device → Cloud)

Send sensor data as JSON matching your device template:

{
  "temperature": 25.5,
  "humidity": 60.2,
  "pressure": 1013.25,
  "battery": 87,
  "timestamp": 1609459200
}

Commands (Cloud → Device)

Receive commands for actuators and configuration:

{
  "relay": true,
  "setpoint": 22.0,
  "mode": "auto"
}

Best Practices

  • Quality of Service: Use QoS 1 for critical data to ensure delivery
  • Keep-Alive: Set appropriate keep-alive interval (60-120 seconds)
  • Clean Session: Use clean session = false for persistent subscriptions
  • Error Handling: Implement reconnection logic with exponential backoff
  • Security: Use MQTT/TLS (port 8883) for production deployments
  • Payload Size: Keep messages under 256KB (smaller is better)
  • Timestamp: Include device timestamp for accurate time-series data
  • Battery Optimization: For battery devices, use longer publish intervals
Need Help? Contact support@quarkifi.com for assistance with device integration or access our community forums for troubleshooting tips.