The operating gateway for the KME Smart platform.

KME Smart is a unified IoT operations platform for devices, automation, monitoring and industrial connectivity. This documentation is everything you need to get started, connect devices, build integrations, and scale projects into production.

What is KME Smart?

KME Smart connects, monitors and manages devices and operations — from a single curtain motor in a home to a 10,000-node factory floor. It is one vertically-integrated stack: firmware, a real-time MQTT message bus, a no-code automation engine, branded dashboards, and an open REST API — so a project that starts on one device scales to an entire site without re-architecting.

Platform architecture

Every device speaks to the platform over MQTT. KME Smart ingests that traffic, keeps live device state, runs the automation engine, and exposes everything through dashboards, a REST/streaming API, and third-party integrations.

Who this is for

You do not need to be a programmer to run KME Smart. Operators build dashboards and automations with no code. Developers get a clean MQTT + REST surface and SDKs to embed KME into their own products. This documentation serves both — start with Getting Started, then branch into whichever path fits you.

Getting Started

From zero to a live device on a dashboard in about ten minutes. This is the most important section — keep it open in one tab while you work.

Before you begin

You will need an ESP32 or ESP8266 board, a USB cable, and a 2.4 GHz Wi-Fi network. That is it — no toolchain, no SDK install for the quick path.

The six steps

1. Create an account

   Open the platform and sign up with your email. Your account is a workspace — every device, dashboard and automation lives inside it, isolated from other workspaces.

2. Add your first device

   In Devices → Add device, give it a name and pick the board type. KME issues a one-time device token — this is the device's password to the MQTT broker. Copy it now; you will not see it again.

3. Flash & connect to Wi-Fi

   Use the in-browser KME Configurator to flash firmware over USB (no IDE). On first boot the device opens a setup access point; choose your Wi-Fi and enter the password. See Device Provisioning for every method.

4. Watch it come online

   Within seconds the device turns green in the device list. Telemetry — switch states, sensor values — starts streaming live.

5. Open the dashboard

   Drop widgets onto a canvas: a switch for a relay, a gauge for temperature, a chart for history. Bind each widget to a device channel. Changes are live both ways.

6. Create your first automation

   Add a rule: when a sensor crosses a threshold, then toggle an output and notify you. No code — see Automations.

Connect with raw MQTT instead

Already have a device with its own firmware? Skip flashing and point any MQTT client at the broker using the device token from step 2:

# Publish a temperature reading to your device's channel
mosquitto_pub --cafile ca.pem \
  -h mqtt.kmesmart.com -p 8883 \
  -u "<workspace>:<device_id>" -P "<device_token>" \
  -t "kme/<workspace>/<device_id>/state" \
  -m '{"V":{"temperature":24.6}}'

That value appears on the dashboard instantly. The full topic and payload model is in MQTT Documentation.

Supported Hardware

KME Smart is built around the ESP ecosystem and speaks every common IoT transport. If your device can reach an MQTT broker, it can join the platform.

ESP ecosystem

These chips are first-class: official firmware builds, in-browser flashing, and firmware-aware defaults for the status LED and pairing button.

Connectivity

One unified message bus, many transports. KME bridges them so a mesh sensor and a cellular tracker show up the same way.

Device classes

Out of the box KME models switches & relays, dimmers, RGB lighting, shutters & curtain motors, climate sensors (DHT22, BME280), energy meters, GPS trackers, and low-power battery sensors. Each maps to a dashboard widget automatically.

Device Provisioning

Provisioning is how a device gets its network credentials and joins your workspace. KME supports several methods — from a phone tapping a sensor to flashing a thousand units on a bench.

The provisioning lifecycle

Whatever the method, every device walks the same path: it powers on with no credentials, receives Wi-Fi + a device token, claims itself into a workspace, and comes online.

Methods

Re-provisioning & factory reset

Hold the pairing button (see Supported Hardware for the per-chip GPIO) for ~5 seconds to wipe stored Wi-Fi and return the device to setup mode. The workspace claim is preserved unless you also remove the device from the dashboard.

MQTT Documentation

MQTT is the heart of KME Smart — the low-latency, bidirectional bus every device speaks. This is the contract between your firmware and the platform.

Why MQTT

• Low latency — typically under 100 ms device-to-dashboard.
• Bidirectional — state flows up, commands flow down, one connection.
• NAT-friendly — the device dials out; no inbound ports or static IPs.
• Resilient — survives flaky links and reconnects with session state.

Broker

Topics

Every topic is namespaced to your workspace so a leaked token can never read or write another workspace's data.

kme/<workspace>/<device_id>/<channel>

Payload format

State and command payloads are compact JSON. S is the array of switch/output states; V is a map of named sensor values. KME merges incoming values, so a device may report a subset.

{
  "S": [1, 0, 0, 1],
  "V": { "temperature": 24.6, "humidity": 58 }
}

// toggle output channel 2
{ "action": "toggle", "value": 2 }

Presence & reliability

Devices set a retained Last-Will on .../online with payload 0, and publish 1 on connect. KME also polls stale devices with status_request so a missed message never leaves the dashboard wrong for long. Commands publish at QoS 1; state at QoS 0 (idempotent — the next update corrects any gap).

REST API

Everything the dashboard does, your code can do. The REST API manages devices, sends commands, reads history, and drives automations — server-to-server.

Base URL & authentication

• Base URL: https://api.kmesmart.com/v1 (dev: http://localhost:3000)
• Auth: Authorization: Bearer <api_key> for server-to-server. Browser sessions use a JWT cookie.
• Bodies are JSON; responses are { "ok": true, … } or { "error": "message" }.

API keys

Create scoped keys under Settings → API keys. Scopes are least-privilege: a key for a Grafana panel needs only devices:read, never devices:write.

curl https://api.kmesmart.com/v1/devices \
  -H "Authorization: Bearer kme_live_8f3c…"

Endpoints

Devices

Automations & data

Send a command

curl -X POST https://api.kmesmart.com/v1/devices/KME9350008/command \
  -H "Authorization: Bearer kme_live_8f3c…" \
  -H "Content-Type: application/json" \
  -d '{"action":"toggle","value":2}'

The platform publishes to .../cmd, the device responds on .../state, and an SSE device_update event fires for any dashboard or subscriber watching.

Automations

Automations are KME's identity: if-this-then-that, but built for a factory. Compose triggers, conditions and actions visually — no engineer required.

The building blocks

Example: humidity recovery

when:  bathroom.humidity > 70
and:   time between 06:00 and 23:00
then:  turn on bath_fan for 20m
also:  notify slack "#ops" if not recovered in 30m

Rules run server-side, so they keep working even if every dashboard is closed. Each rule logs every fire for audit and tuning.

Dashboard Widgets

Dashboards are drag-and-drop. Drop a widget, bind it to a device channel, brand it, and share it. The same blocks power a 4-device home and a 4,000-sensor floor.

Widget library

Binding a widget

1. Drop it on the canvas

   Pick a widget from the palette and place it on the grid.

2. Bind a data source

   Choose a device and a channel — e.g. V.temperature or output S[2].

3. Style & brand it

   Set ranges, colours, units. Apply your logo and palette for a white-label view.

4. Share or embed

   Publish a read-only link or embed the dashboard in your own app via an iframe / signed URL.

Integrations

KME Smart speaks to the rest of your stack. Mirror devices into your smart-home ecosystem, pipe data into Grafana, or fan events out to chat and webhooks.

Available integrations

Home Assistant in one step

Enable the integration and KME publishes MQTT Discovery messages — switches, sensors and dimmers register as native entities automatically. State mirrors both ways with command de-duplication so the dashboard and HA never fight.

{
  "name": "Plant A · Fan",
  "command_topic": "kme/acme/KME9350008/cmd",
  "state_topic":   "kme/acme/KME9350008/state",
  "unique_id":     "kme_KME9350008_ch2"
}

OTA Updates

Ship firmware to the whole fleet without touching a single device. Staged rollouts, signed images, live progress, and one-click rollback.

How it works

Capabilities

• Version control — every image is tagged; devices report their running version on boot for targeting.
• Staged rollouts — 10% canary → 50% → 100%, gated on error rate and reconnect success.
• Signed updates — images are hash-verified; a device refuses an image that does not match.
• Rollback — keep the previous slot; one click reverts the cohort to the last good version.
• Resumable — interrupted downloads resume; a failed flash never bricks (A/B partitions).

Security

Security is layered from the device to the API. Every connection is encrypted, every credential is scoped, and no workspace can ever see another's data.

Controls

Industrial Solutions

The same KME Smart platform — different blueprints. This is what sets KME apart: it is not just smart home, it is built for operations at industrial scale.

One platform, many sites

Each solution is a blueprint on the same core — devices, MQTT, automations, dashboards and the API are identical. Start with one line or one field, prove it, then template it across every site without re-architecting.

Examples

Copy-paste starting points in every language a KME project touches. Each one connects, authenticates, and exchanges state in the fewest lines possible.

ESP32 — Arduino

The KME Smart Arduino SDK handles reconnection, batching and TLS. Production firmware in six lines:

// Publish a temperature reading every 2 s
#include <KMESmart.h>
KMESmart kme("<device_token>");

void setup() {
  kme.begin("wifi-ssid", "pass");
}

void loop() {
  float t = readDHT22();
  kme.publish("temperature", t);
  delay(2000);
}

MQTT — command line

# Watch a device's live state
mosquitto_sub --cafile ca.pem -h mqtt.kmesmart.com -p 8883 \
  -u "acme:KME9350008" -P "<device_token>" \
  -t "kme/acme/KME9350008/state" -v

Node.js

const res = await fetch(
  "https://api.kmesmart.com/v1/devices/KME9350008/command", {
  method: "POST",
  headers: {
    "Authorization": "Bearer kme_live_8f3c…",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ action: "toggle", value: 2 })
});

Python

import requests

r = requests.get(
    "https://api.kmesmart.com/v1/devices/KME9350008/history",
    headers={"Authorization": "Bearer kme_live_8f3c…"},
    params={"hours": 24},
)
print(r.json()["readings"])

Flutter

final kme = KmeClient(apiKey: 'kme_live_8f3c…');
final device = await kme.device('KME9350008');
await device.toggle(channel: 2);
device.stream.listen((s) => print(s.values));

SDKs

SDKs wrap the raw MQTT + REST surface so you ship faster. Reconnection, auth, batching and OTA are handled for you — speak raw protocol only if you want to.

Downloads

The tools that pair with the platform — flash firmware, configure devices, and connect from a desktop.

Frequently Asked Questions

The questions every KME operator hits in the first week — answered.