К основному содержанию
скилл CX Codex

iot-expert — скилл для Claude Code: что делает и как установить

Скилл iot-expert по проектированию IoT-систем, работе с MQTT, edge-вычислениями и прошивками микроконтроллеров. Подскажет архитектуру и код для умных устройств.

Apache-2.0 239 установок ★ 45 обновлён 2026-10-12

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add personamanagmentlayer/pcl --skill iot-expert -a claude-code
Открыть на GitHub

Что делает iot-expert

Скилл добавляет в контекст ассистента знания об архитектуре интернета вещей: уровнях устройств, шлюзов, сетей и облака. Внутри заложены готовые шаблоны для работы с популярными протоколами передачи данных, включая MQTT, CoAP, HTTP/REST, WebSocket, LoRaWAN и Zigbee.

В исходных материалах приведены конкретные реализации. Для микроконтроллеров ESP32 и плат Arduino подготовлен C-код с подключением сенсора DHT22 по Wi-Fi и отправкой метрик через PubSubClient. Для бэкенда и шлюзов есть Python-обвязка на базе paho-mqtt, а также заготовки для буферизации и первичной обработки сенсорных данных на стороне edge.

Для запуска примеров из скилла потребуются сторонние библиотеки: Python-пакет paho-mqtt на сервере или библиотеки PubSubClient и DHT sensor library в среде прошивки микроконтроллера.

Какие задачи решает

  • написать прошивку для ESP32 с отправкой показаний датчиков по MQTT
  • спроектировать архитектуру обмена данными между IoT-устройствами и облаком
  • настроить Python-клиент для публикации и подписки на телеметрию
  • реализовать буферизацию данных на уровне edge-вычислений

Примеры запросов агенту

  • Напиши скетч для ESP32, который считывает температуру и шлёт её в брокер MQTT
  • Спроектируй пятиуровневую архитектуру IoT-платформы для сбора данных с датчиков
  • Покажи класс на Python для подписки на топики телеметрии с автоподключением

Как установить iot-expert

1Через Skills CLI (Vercel)

npx skills add personamanagmentlayer/pcl --skill iot-expert -a claude-code

2Вручную: положить файлы

~/.claude/skills/iot-expert/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/iot-expert/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об iot-expert

Как установить iot-expert в Claude Code?

Выполните в терминале команду npx skills add personamanagmentlayer/pcl --skill iot-expert -a claude-code. Файл скилла запишется в ~/.claude/skills/iot-expert/SKILL.md.

Что делает скилл iot-expert?

Он направляет ИИ-ассистента при решении задач интернета вещей: формирует архитектурные слои, генерирует прошивки для микроконтроллеров и код edge-обработки данных.

Какие протоколы связи охватывает скилл?

Скилл включает рекомендации по работе с MQTT, CoAP, HTTP/REST, WebSocket, LoRaWAN, Zigbee и Z-Wave.

Исходный текст

SKILL.md · Apache-2.0
---
name: iot-expert
version: 1.1.0
description: >-
  Expert-level IoT systems, embedded devices, edge computing, and IoT protocols. Use when
  the user mentions embedded, edge computing, MQTT, sensors, or firmware, or when the task
  involves IoT Architecture, IoT Protocols, Embedded Systems, or Device Design.
category: domains
tags: [iot, embedded, edge-computing, mqtt, sensors, firmware]
allowed-tools:
  - Read
  - Write
  - Edit
---

# IoT Expert

Expert guidance for IoT systems, embedded devices, edge computing, sensor networks, and IoT protocols.

## Core Concepts

### IoT Architecture

- Device layer (sensors, actuators)
- Edge computing layer
- Network layer (connectivity)
- Cloud/platform layer
- Application layer
- Security across all layers

### IoT Protocols

- MQTT (Message Queuing Telemetry Transport)
- CoAP (Constrained Application Protocol)
- HTTP/REST for IoT
- WebSocket for real-time
- LoRaWAN for long-range
- Zigbee, Z-Wave for home automation

### Embedded Systems

- Microcontroller programming
- Real-time operating systems (RTOS)
- Power management
- Firmware updates (OTA)
- Hardware interfaces (I2C, SPI, UART)
- Memory constraints

## MQTT Implementation

```python
import paho.mqtt.client as mqtt
import json
from datetime import datetime
from typing import Callable, Dict

class MQTTClient:
    def __init__(self, broker: str, port: int = 1883, client_id: str = "iot_device"):
        self.broker = broker
        self.port = port
        self.client = mqtt.Client(client_id)
        self.subscriptions: Dict[str, Callable] = {}

        self.client.on_connect = self._on_connect
        self.client.on_message = self._on_message
        self.client.on_disconnect = self._on_disconnect

    def _on_connect(self, client, userdata, flags, rc):
        if rc == 0:
            print(f"Connected to MQTT broker at {self.broker}:{self.port}")
            # Resubscribe to topics on reconnect
            for topic in self.subscriptions.keys():
                self.client.subscribe(topic)
        else:
            print(f"Connection failed with code {rc}")

    def _on_message(self, client, userdata, msg):
        topic = msg.topic
        payload = msg.payload.decode()

        if topic in self.subscriptions:
            try:
                data = json.loads(payload)
                self.subscriptions[topic](data)
            except json.JSONDecodeError:
                self.subscriptions[topic](payload)

    def _on_disconnect(self, client, userdata, rc):
        if rc != 0:
            print(f"Unexpected disconnect. Reconnecting...")

    def connect(self, username: str = None, password: str = None):
        if username and password:
            self.client.username_pw_set(username, password)

        self.client.connect(self.broker, self.port, 60)
        self.client.loop_start()

    def publish(self, topic: str, payload: Dict, qos: int = 1, retain: bool = False):
        """Publish message to MQTT topic"""
        message = json.dumps(payload)
        result = self.client.publish(topic, message, qos=qos, retain=retain)
        return result.rc == mqtt.MQTT_ERR_SUCCESS

    def subscribe(self, topic: str, callback: Callable, qos: int = 1):
        """Subscribe to MQTT topic with callback"""
        self.subscriptions[topic] = callback
        self.client.subscribe(topic, qos=qos)

    def disconnect(self):
        self.client.loop_stop()
        self.client.disconnect()

# IoT Device Example
class TemperatureSensor:
    def __init__(self, device_id: str, mqtt_client: MQTTClient):
        self.device_id = device_id
        self.mqtt = mqtt_client
        self.topic = f"sensors/temperature/{device_id}"

    def read_temperature(self) -> float:
        # In real device, read from actual sensor
        import random
        return round(random.uniform(20.0, 30.0), 2)

    def publish_reading(self):
        temperature = self.read_temperature()

        payload = {
            "device_id": self.device_id,
            "temperature": temperature,
            "unit": "celsius",
            "timestamp": datetime.utcnow().isoformat()
        }

        self.mqtt.publish(self.topic, payload)
        return payload
```

## Embedded C for Microcontroller

```c
// Arduino/ESP32 Example
#include <WiFi.h>
#include <PubSubClient.h>
#include "DHT.h"

#define DHTPIN 4
#define DHTTYPE DHT22

// Keep credentials out of the sketch: put them in a secrets.h that is
// listed in .gitignore, so they are never committed with the firmware.
#include "secrets.h"  // defines WIFI_SSID and WIFI_PASSWORD

const char* ssid = WIFI_SSID;
const char* password = WIFI_PASSWORD;
const char* mqtt_server = "broker.example.com";

WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHTPIN, DHTTYPE);

void setup_wifi() {
    delay(10);
    Serial.println("Connecting to WiFi...");

    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
}

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

    for (int i = 0; i < length; i++) {
        Serial.print((char)payload[i]);
    }
    Serial.println();
}

void reconnect() {
    while (!client.connected()) {
        Serial.print("Attempting MQTT connection...");

        if (client.connect("ESP32Client")) {
            Serial.println("connected");
            client.subscribe("device/control");
        } else {
            Serial.print("failed, rc=");
            Serial.print(client.state());
            Serial.println(" try again in 5 seconds");
            delay(5000);
        }
    }
}

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

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

    // Read sensor every 10 seconds
    static unsigned long lastRead = 0;
    if (millis() - lastRead > 10000) {
        float humidity = dht.readHumidity();
        float temperature = dht.readTemperature();

        if (!isnan(humidity) && !isnan(temperature)) {
            char msg[100];
            snprintf(msg, sizeof(msg),
                    "{\"temperature\":%.2f,\"humidity\":%.2f}",
                    temperature, humidity);

            client.publish("sensors/data", msg);
            Serial.println(msg);
        }

        lastRead = millis();
    }
}
```

## Edge Computing

```python
import asyncio
from typing import Dict, List
import numpy as np

class EdgeProcessor:
    """Process data at edge before sending to cloud"""

    def __init__(self, buffer_size: int = 100):
        self.buffer: List[Dict] = []
        self.buffer_size = buffer_size

    def add_reading(self, reading: Dict):
        """Add sensor reading to buffer"""
        self.buffer.append(reading)

        if len(self.buffer) >= self.buffer_size:
            self.process_buffer()

    def process_buffer(self) -> Dict:
        """Process buffered data at edge"""
        if not self.buffer:
            return {}

        # Extract temperature values
        temperatures = [r['temperature'] for r in self.buffer]

        # Compute statistics at edge
        summary = {
            "count": len(temperatures),
            "mean": np.mean(temperatures),
            "std": np.std(temperatures),
            "min": np.min(temperatures),
            "max": np.max(temperatures),
            "anomalies": self.detect_anomalies(temperatures)
        }

        # Clear buffer
        self.buffer = []

        return summary

    def detect_anomalies(self, values: List[float]) -> List[int]:
        """Detect anomalies using simple threshold"""
        mean = np.mean(values)
        std = np.std(values)
        threshold = 2.5

        anomalies = []
        for i, v in enumerate(values):
            if abs(v - mean) > threshold * std:
                anomalies.append(i)

        return anomalies

class IoTPipeline:
    """Complete IoT data pipeline"""

    def __init__(self, mqtt_client: MQTTClient):
        self.mqtt = mqtt_client
        self.edge_processor = EdgeProcessor()
        self.devices: Dict[str, TemperatureSensor] = {}

    def register_device(self, device: TemperatureSensor):
        """Register IoT device"""
        self.devices[device.device_id] = device

        # Subscribe to device topic
        topic = f"sensors/temperature/{device.device_id}"
        self.mqtt.subscribe(topic, self.handle_device_data)

    def handle_device_data(self, data: Dict):
        """Handle incoming device data"""
        # Process at edge
        self.edge_processor.add_reading(data)

    async def collect_data_loop(self, interval: int = 5):
        """Continuous data collection from devices"""
        while True:
            for device in self.devices.values():
                reading = device.publish_reading()
                print(f"Device {device.device_id}: {reading['temperature']}°C")

            await asyncio.sleep(interval)
```

## Device Management

```python
from datetime import datetime
from enum import Enum

class DeviceStatus(Enum):
    ONLINE = "online"
    OFFLINE = "offline"
    MAINTENANCE = "maintenance"
    ERROR = "error"

class IoTDevice:
    def __init__(self, device_id: str, device_type: str):
        self.device_id = device_id
        self.device_type = device_type
        self.status = DeviceStatus.OFFLINE
        self.last_seen = None
        self.firmware_version = "1.0.0"
        self.metadata = {}

    def update_status(self, status: DeviceStatus):
        self.status = status
        self.last_seen = datetime.utcnow()

    def needs_firmware_update(self, latest_version: str) -> bool:
        return self.firmware_version < latest_version

class DeviceManager:
    def __init__(self):
        self.devices: Dict[str, IoTDevice] = {}

    def register_device(self, device: IoTDevice):
        """Register new device"""
        self.devices[device.device_id] = device

    def update_device_heartbeat(self, device_id: str):
        """Update device last seen timestamp"""
        if device_id in self.devices:
            self.devices[device_id].update_status(DeviceStatus.ONLINE)

    def get_offline_devices(self, timeout_seconds: int = 300) -> List[IoTDevice]:
        """Get devices that haven't reported recently"""
        offline = []
        now = datetime.utcnow()

        for device in self.devices.values():
            if device.last_seen:
                elapsed = (now - device.last_seen).total_seconds()
                if elapsed > timeout_seconds:
                    offline.append(device)

        return offline

    def schedule_firmware_update(self, device_id: str, new_version: str):
        """Schedule OTA firmware update"""
        if device_id in self.devices:
            # Send update command via MQTT
            payload = {
                "command": "firmware_update",
                "version": new_version,
                "url": f"https://updates.example.com/{new_version}.bin"
            }
            return payload
```

## Best Practices

### Device Design

- Implement power management for battery devices
- Use deep sleep modes when idle
- Handle network disconnections gracefully
- Implement watchdog timers
- Design for remote diagnostics
- Plan for firmware updates (OTA)

### Security

- Use TLS/SSL for MQTT connections
- Implement device authentication
- Encrypt sensitive data
- Secure firmware updates
- Regular security patches
- Network segmentation

### Data Management

- Process data at edge when possible
- Implement data buffering for offline scenarios
- Use efficient data formats (e.g., Protocol Buffers)
- Compress data before transmission
- Handle time synchronization
- Implement data retention policies

## Anti-Patterns

❌ No power management strategy
❌ Unencrypted communications
❌ No error handling for network failures
❌ Sending all raw data to cloud
❌ No device authentication
❌ Hard-coded credentials in firmware
❌ No OTA update mechanism

## Resources

- MQTT: https://mqtt.org/
- ESP32 Documentation: https://docs.espressif.com/
- Arduino: https://www.arduino.cc/
- AWS IoT: https://aws.amazon.com/iot/
- Azure IoT: https://azure.microsoft.com/en-us/overview/iot/

© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl

Похожие скиллы

Все скиллы по теме «Бэкенд и API» →
domain-iot actionbook Скилл domain-iot задаёт ограничения IoT-разработки на Rust: сеть падает, питание ограничено, устройство доступно физически. Помогает агенту выбрать буфер, retry и TLS. CX Codex +1 3 100установок iot-developer daffy0208 Скилл iot-developer помогает писать прошивки для микроконтроллеров, собирать веб-дашборды и настраивать обмен данными датчиков по протоколу MQTT. CX Codex +1 391установок iot-engineer VoltAgent Community iot-engineer — субагент для Claude Code, который проектирует IoT-системы от устройств до облака. Подключается к задачам по управлению устройствами, связи и обработке потоков данных. CX Codex 238установок embedded-iot travisjneuman Скилл embedded-iot по встраиваемым системам: паттерны GPIO, I2C и MQTT, задачи FreeRTOS и правила энергосбережения для ESP32, STM32 и Arduino. CX Codex +1 212установок embedded-iot-mentor Alireza Rezvani embedded-iot-mentor — скилл для Claude Code, который помогает спланировать встроенное или IoT-устройство от выбора платы до способа просмотра показаний. Он подключается к задачам с микроконтроллерами, датчиками и прошивками. CX Codex +1 22установок iot-pentester 0xSteph Субагент iot-pentester проводит авторизованный тест IoT-устройства по всей цепочке: прошивка, UART/JTAG, BLE и sub-GHz, приложение и облако. Ищет дефолтные учётки и слабую подпись обновлений. CX Codex ★ 2 482звёзд репо

Из того же набора104

Весь набор →
ai-engineer-expert Скилл ai-engineer-expert для Claude Code помогает проектировать LLM-интеграции, RAG-системы и production AI. Описывает развёртывание моделей и работу с AI API. CX Codex +1 242установок quantum-expert Скилл quantum-expert даёт агенту опору в квантовых схемах: состояния Белла, телепортация, Grover, VQE и классификаторы на Qiskit. CX Codex +1 240установок finops-expert Скилл finops-expert для Claude Code разбирает расходы на облако и ищет варианты оптимизации. Анализирует затраты AWS, прогнозирует расходы и даёт рекомендации по EC2. CX Codex +1 239установок snowflake-expert Скилл snowflake-expert для Snowflake: помогает выбрать размер виртуального склада, разложить объекты по схемам и заменить полный скан таблицы на стрим. CX Codex +1 239установок biological-expert Скилл biological-expert настраивает агента на задачи биоинформатики, генетики и вычислительной биологии. Помогает анализировать последовательности ДНК и аннотировать мутации. CX Codex +1 235установок security-expert Скилл security-expert помогает разбирать безопасность приложений: от проверок по OWASP Top 10 до рекомендаций по защите данных. Подключайте его при работе с аутентификацией, шифрованием или уязвимостями. CX Codex +1 231установок aws-expert Скилл aws-expert для Claude Code проектирует AWS-инфраструктуру, настраивает безопасность и разбирает расходы. Помогает с cloud-, DevOps- и serverless-задачами. CX Codex +1 230установок aerospace-expert Скилл aerospace-expert для Claude Code добавляет агентным задачам экспертизу по авиации, полётам, обслуживанию и безопасности. Помогает проектировать и проверять аэрокосмическое ПО. CX Codex +1 228установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой