Elysia Tools

Durchsuche Tools, Beispiele, visuelle Erklärungen und Themenguides an einem klaren Ort.

Beliebte Kategorien

Themen

Sprache
ZHDERUPTENFRES

Elysia Tools

Mobile Navigation

Kommunikationsprotokolle

MQTT Nachrichtenprotokoll

MQTT (Message Queuing Telemetry Transport) Protokollbeispiele für IoT und Echtzeit-Nachrichtenübermittlung mit Publish/Subscribe-Patterns

Beispiele

Einträge in dieser Sammlung

QuellcodejavascriptEinfach

MQTT Grundkonzepte und Anwendung

Einführung in das MQTT-Protokoll mit grundlegenden Publisher- und Subscriber-Beispielen

Schwierigkeit

3/10

Geschätzte Zeit

15 min

Schlagwörter

mqtt, iot, messaging, publish-subscribe

Voraussetzungen

Node.js basics, Understanding of pub/sub patterns

javascript
// MQTT Basic Examples using mqtt.js library
// npm install mqtt

const mqtt = require('mqtt');
const fs = require('fs');

// MQTT Broker connection options
const options = {
  host: 'mqtt.eclipse.org',  // Public MQTT broker
  port: 1883,
  protocol: 'mqtt',
  keepalive: 60,
  reconnectPeriod: 1000,
  connectTimeout: 30 * 1000,
  will: {
    topic: 'clients/disconnect',
    payload: 'Client disconnected unexpectedly',
    qos: 1,
    retain: false
  }
};

// 1. Basic Publisher Example
function createPublisher() {
  console.log('Creating MQTT Publisher...');

  const client = mqtt.connect(options);

  client.on('connect', function () {
    console.log('Publisher connected to MQTT broker');

    // Publish messages periodically
    let counter = 0;
    setInterval(() => {
      const message = {
        deviceId: 'sensor_001',
        temperature: Math.random() * 30 + 20,
        humidity: Math.random() * 50 + 30,
        timestamp: new Date().toISOString(),
        counter: counter++
      };

      const topic = 'sensors/temperature/room1';
      const payload = JSON.stringify(message);

      // Publish with QoS 1 (at least once delivery)
      client.publish(topic, payload, { qos: 1, retain: false }, (error) => {
        if (error) {
          console.error('Failed to publish message:', error);
        } else {
          console.log(`Message published to ${topic}: ${payload}`);
        }
      });
    }, 2000); // Publish every 2 seconds
  });

  client.on('error', function (error) {
    console.error('MQTT connection error:', error);
  });

  client.on('offline', function () {
    console.log('Publisher offline');
  });

  client.on('reconnect', function () {
    console.log('Publisher reconnecting...');
  });

  return client;
}

// 2. Basic Subscriber Example
function createSubscriber() {
  console.log('Creating MQTT Subscriber...');

  const client = mqtt.connect(options);

  client.on('connect', function () {
    console.log('Subscriber connected to MQTT broker');

    // Subscribe to topics
    const topics = [
      'sensors/temperature/+',  // Wildcard for all rooms
      'sensors/humidity/+',
      'alerts/+/critical',
      'clients/connect'
    ];

    topics.forEach(topic => {
      client.subscribe(topic, { qos: 1 }, (error, granted) => {
        if (error) {
          console.error(`Failed to subscribe to ${topic}:`, error);
        } else {
          console.log(`Subscribed to ${topic} with QoS ${granted[0].qos}`);
        }
      });
    });
  });

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

      // Process different types of messages
      if (topic.startsWith('sensors/temperature/')) {
        handleTemperatureData(topic, payload);
      } else if (topic.startsWith('alerts/')) {
        handleAlert(topic, payload);
      } else if (topic === 'clients/connect') {
        handleClientConnect(payload);
      }
    } catch (error) {
      console.log(`Received message from ${topic}: ${message.toString()}`);
    }
  });

  client.on('error', function (error) {
    console.error('MQTT connection error:', error);
  });

  return client;
}

// 3. Message Handlers
function handleTemperatureData(topic, data) {
  const room = topic.split('/')[2];
  console.log(`🌡️  Temperature in ${room}: ${data.temperature.toFixed(2)}°C`);

  // Alert if temperature is too high
  if (data.temperature > 40) {
    console.log(`🚨 High temperature alert in ${room}!`);
  }
}

function handleAlert(topic, alert) {
  console.log(`🚨 ALERT: ${alert.message}`);
  console.log(`   Severity: ${alert.severity}`);
  console.log(`   Timestamp: ${alert.timestamp}`);
}

function handleClientConnect(data) {
  console.log(`👤 New client connected: ${data.clientId}`);
}

// 4. MQTT Client with Last Will and Testament (LWT)
function createClientWithLWT(clientId) {
  const clientOptions = {
    ...options,
    clientId: clientId,
    will: {
      topic: `clients/${clientId}/status`,
      payload: JSON.stringify({
        status: 'offline',
        timestamp: new Date().toISOString(),
        reason: 'unexpected_disconnect'
      }),
      qos: 1,
      retain: true
    }
  };

  const client = mqtt.connect(clientOptions);

  client.on('connect', function () {
    console.log(`Client ${clientId} connected`);

    // Publish online status
    const statusMessage = {
      status: 'online',
      timestamp: new Date().toISOString()
    };

    client.publish(
      `clients/${clientId}/status`,
      JSON.stringify(statusMessage),
      { qos: 1, retain: true }
    );
  });

  client.on('close', function () {
    console.log(`Client ${clientId} disconnected gracefully`);

    // Publish offline status
    const statusMessage = {
      status: 'offline',
      timestamp: new Date().toISOString(),
      reason: 'graceful_disconnect'
    };

    client.publish(
      `clients/${clientId}/status`,
      JSON.stringify(statusMessage),
      { qos: 1, retain: true }
    );
  });

  return client;
}

// 5. Retained Messages Example
function demonstrateRetainedMessages() {
  const client = mqtt.connect(options);

  client.on('connect', function () {
    console.log('Demonstrating retained messages...');

    // Publish retained configuration data
    const config = {
      version: '1.0.0',
      updateInterval: 5000,
      maxRetries: 3,
      features: ['temperature', 'humidity', 'pressure']
    };

    client.publish(
      'config/sensor_001',
      JSON.stringify(config),
      { qos: 1, retain: true },
      () => {
        console.log('Configuration published with retain flag');
        console.log('New subscribers will immediately receive this message');
      }
    );
  });

  return client;
}

// 6. Quality of Service (QoS) Levels Example
function demonstrateQoS() {
  const client = mqtt.connect(options);

  client.on('connect', function () {
    console.log('Demonstrating QoS levels...');

    const messages = [
      { topic: 'qos/demo/0', payload: 'QoS 0 - At most once', qos: 0 },
      { topic: 'qos/demo/1', payload: 'QoS 1 - At least once', qos: 1 },
      { topic: 'qos/demo/2', payload: 'QoS 2 - Exactly once', qos: 2 }
    ];

    messages.forEach(({ topic, payload, qos }) => {
      client.publish(topic, payload, { qos }, (error) => {
        if (!error) {
          console.log(`Published with QoS ${qos}: ${payload}`);
        }
      });
    });
  });

  return client;
}

// 7. Secure MQTT (MQTTS) Example
function createSecureClient() {
  const secureOptions = {
    host: 'mqtt.example.com',
    port: 8883,
    protocol: 'mqtts',
    rejectUnauthorized: true,
    ca: fs.readFileSync('./ca.crt'),
    cert: fs.readFileSync('./client.crt'),
    key: fs.readFileSync('./client.key'),
    clientId: `secure_client_${Math.random().toString(16).substr(2, 8)}`
  };

  const client = mqtt.connect(secureOptions);

  client.on('connect', function () {
    console.log('Secure MQTT connection established');
  });

  return client;
}

// 8. Topic Patterns and Wildcards
function demonstrateTopicPatterns() {
  const client = mqtt.connect(options);

  client.on('connect', function () {
    console.log('Demonstrating topic patterns...');

    // Subscribe using different wildcard patterns
    const subscriptions = [
      { topic: 'sensors/+/temperature', qos: 1 },    // Single-level wildcard
      { topic: 'devices/room1/#', qos: 1 },          // Multi-level wildcard
      { topic: 'alerts/+/critical', qos: 1 },        // Mixed pattern
      { topic: 'system/status', qos: 1 }             // Exact match
    ];

    subscriptions.forEach(({ topic, qos }) => {
      client.subscribe(topic, { qos }, (error) => {
        if (!error) {
          console.log(`Subscribed to pattern: ${topic}`);
        }
      });
    });
  });

  return client;
}

// Run examples
if (require.main === module) {
  console.log('=== MQTT Examples ===\n');

  // Start publisher
  const publisher = createPublisher();

  // Start subscriber
  setTimeout(() => {
    const subscriber = createSubscriber();
  }, 1000);

  // Demonstrate other features
  setTimeout(() => {
    demonstrateRetainedMessages();
    demonstrateQoS();
  }, 2000);

  // Graceful shutdown
  process.on('SIGINT', () => {
    console.log('\nShutting down MQTT clients...');
    publisher.end();
    process.exit(0);
  });
}

module.exports = {
  createPublisher,
  createSubscriber,
  createClientWithLWT,
  demonstrateRetainedMessages,
  demonstrateQoS,
  createSecureClient,
  demonstrateTopicPatterns
};
QuellcodejavascriptMittel

IoT-Sensor-Simulation mit MQTT

Vollständige IoT-Sensor-Simulation mit mehreren Gerätetypen und Echtzeit-Datenstreaming

Schwierigkeit

6/10

Geschätzte Zeit

25 min

Schlagwörter

mqtt, iot, sensors, simulation, smart home

Voraussetzungen

JavaScript, MQTT basics, Event-driven programming

javascript
// IoT Sensor Simulation with MQTT
// Simulates multiple types of IoT sensors publishing data via MQTT

const mqtt = require('mqtt');
const { EventEmitter } = require('events');

// MQTT Configuration
const MQTT_BROKER = 'mqtt.eclipse.org';
const MQTT_PORT = 1883;

// Base class for IoT sensors
class IoTSensor extends EventEmitter {
  constructor(config) {
    super();
    this.id = config.id;
    this.name = config.name;
    this.location = config.location;
    this.interval = config.interval || 5000;
    this.client = null;
    this.isRunning = false;
    this.errorRate = config.errorRate || 0.05; // 5% error rate
  }

  connect() {
    const options = {
      host: MQTT_BROKER,
      port: MQTT_PORT,
      clientId: `sensor_${this.id}`,
      will: {
        topic: `devices/${this.id}/status`,
        payload: JSON.stringify({
          status: 'offline',
          timestamp: new Date().toISOString(),
          reason: 'unexpected_disconnect'
        }),
        qos: 1,
        retain: true
      }
    };

    this.client = mqtt.connect(options);

    this.client.on('connect', () => {
      console.log(`${this.constructor.name} ${this.name} connected`);
      this.publishStatus('online');
      this.emit('connected');
    });

    this.client.on('error', (error) => {
      console.error(`${this.name} connection error:`, error);
      this.emit('error', error);
    });

    this.client.on('offline', () => {
      console.log(`${this.name} went offline`);
      this.emit('offline');
    });

    this.client.on('reconnect', () => {
      console.log(`${this.name} reconnecting...`);
    });

    return this.client;
  }

  start() {
    if (!this.client) {
      this.connect();
    }

    this.client.on('connect', () => {
      if (!this.isRunning) {
        this.isRunning = true;
        this.startSimulation();
      }
    });
  }

  stop() {
    this.isRunning = false;
    if (this.client) {
      this.publishStatus('offline', 'graceful_shutdown');
      this.client.end();
    }
  }

  publishStatus(status, reason = '') {
    const statusMessage = {
      deviceId: this.id,
      deviceType: this.constructor.name,
      location: this.location,
      status: status,
      timestamp: new Date().toISOString(),
      reason: reason
    };

    this.client.publish(
      `devices/${this.id}/status`,
      JSON.stringify(statusMessage),
      { qos: 1, retain: true }
    );
  }

  publishData(topic, data) {
    const message = {
      deviceId: this.id,
      deviceType: this.constructor.name,
      location: this.location,
      timestamp: new Date().toISOString(),
      ...data
    };

    // Simulate occasional errors
    if (Math.random() < this.errorRate) {
      message.error = true;
      message.errorMessage = 'Sensor read error';
    }

    this.client.publish(topic, JSON.stringify(message), { qos: 1 });
    this.emit('data', message);
  }

  startSimulation() {
    // Override in subclasses
    console.log(`Starting simulation for ${this.name}`);
  }
}

// Temperature Sensor
class TemperatureSensor extends IoTSensor {
  constructor(config) {
    super(config);
    this.baseTemp = config.baseTemp || 22;
    this.variance = config.variance || 5;
  }

  startSimulation() {
    console.log(`🌡️  Starting temperature simulation for ${this.name}`);

    this.simulationInterval = setInterval(() => {
      if (!this.isRunning) return;

      const temperature = this.baseTemp + (Math.random() - 0.5) * this.variance * 2;
      const humidity = 40 + (Math.random() - 0.5) * 20;

      this.publishData(`sensors/temperature/${this.location}`, {
        temperature: parseFloat(temperature.toFixed(2)),
        unit: 'celsius',
        humidity: parseFloat(humidity.toFixed(2)),
        unitHumidity: 'percent'
      });
    }, this.interval);
  }
}

// Motion Sensor
class MotionSensor extends IoTSensor {
  constructor(config) {
    super(config);
    this.sensitivity = config.sensitivity || 0.3;
    this.lastMotion = null;
  }

  startSimulation() {
    console.log(`🚪 Starting motion detection for ${this.name}`);

    this.simulationInterval = setInterval(() => {
      if (!this.isRunning) return;

      const motionDetected = Math.random() < this.sensitivity;

      if (motionDetected) {
        this.lastMotion = new Date().toISOString();
        this.publishData(`sensors/motion/${this.location}`, {
          motion: true,
          detectionTime: this.lastMotion,
          confidence: Math.random()
        });
      }
    }, this.interval);
  }
}

// Light Sensor
class LightSensor extends IoTSensor {
  constructor(config) {
    super(config);
    this.baseLux = config.baseLux || 300;
  }

  startSimulation() {
    console.log(`💡 Starting light sensor for ${this.name}`);

    this.simulationInterval = setInterval(() => {
      if (!this.isRunning) return;

      const hour = new Date().getHours();
      let lux;

      // Simulate day/night cycle
      if (hour >= 6 && hour <= 18) {
        lux = this.baseLux + Math.random() * 500;
      } else {
        lux = Math.random() * 50;
      }

      this.publishData(`sensors/light/${this.location}`, {
        illuminance: parseFloat(lux.toFixed(2)),
        unit: 'lux',
        timeOfDay: hour >= 6 && hour <= 18 ? 'day' : 'night'
      });
    }, this.interval);
  }
}

// Door/Window Sensor
class DoorSensor extends IoTSensor {
  constructor(config) {
    super(config);
    this.isOpen = false;
    this.changeProbability = config.changeProbability || 0.1;
  }

  startSimulation() {
    console.log(`🚪 Starting door sensor for ${this.name}`);

    this.simulationInterval = setInterval(() => {
      if (!this.isRunning) return;

      const shouldChange = Math.random() < this.changeProbability;

      if (shouldChange) {
        this.isOpen = !this.isOpen;

        this.publishData(`sensors/door/${this.location}`, {
          state: this.isOpen ? 'open' : 'closed',
          lastChange: new Date().toISOString(),
          batteryLevel: 80 + Math.random() * 20
        });
      }
    }, this.interval);
  }
}

// Smart Camera
class SmartCamera extends IoTSensor {
  constructor(config) {
    super(config);
    this.detectionTypes = ['person', 'vehicle', 'animal', 'package'];
    this.detectionRate = config.detectionRate || 0.2;
  }

  startSimulation() {
    console.log(`📹 Starting smart camera for ${this.name}`);

    this.simulationInterval = setInterval(() => {
      if (!this.isRunning) return;

      if (Math.random() < this.detectionRate) {
        const detection = this.detectionTypes[Math.floor(Math.random() * this.detectionTypes.length)];
        const confidence = 0.7 + Math.random() * 0.3;

        this.publishData(`cameras/detection/${this.location}`, {
          detectionType: detection,
          confidence: parseFloat(confidence.toFixed(2)),
          snapshotUrl: `https://example.com/snapshots/${this.id}/${Date.now()}.jpg`,
          recording: Math.random() > 0.5
        });
      }
    }, this.interval);
  }
}

// Sensor Manager
class SensorManager {
  constructor() {
    this.sensors = [];
    this.alertThresholds = new Map();
  }

  addSensor(sensor) {
    this.sensors.push(sensor);

    // Set up event listeners
    sensor.on('data', (data) => {
      this.processSensorData(data);
    });

    sensor.on('error', (error) => {
      console.error(`Sensor ${sensor.id} error:`, error);
    });

    sensor.on('offline', () => {
      console.log(`Sensor ${sensor.id} went offline`);
    });

    return sensor;
  }

  processSensorData(data) {
    // Check for alerts
    if (data.temperature && data.temperature > 35) {
      this.sendAlert({
        type: 'temperature_high',
        deviceId: data.deviceId,
        location: data.location,
        value: data.temperature,
        threshold: 35,
        timestamp: data.timestamp
      });
    }

    if (data.motion && data.motion) {
      console.log(`🚨 Motion detected at ${data.location}`);
    }

    if (data.state === 'open' && data.deviceType === 'DoorSensor') {
      this.sendAlert({
        type: 'door_open',
        deviceId: data.deviceId,
        location: data.location,
        timestamp: data.timestamp
      });
    }
  }

  sendAlert(alert) {
    const alertMessage = {
      id: `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
      ...alert,
      severity: alert.type.includes('temperature') ? 'warning' : 'info'
    };

    console.log(`🚨 ALERT: ${JSON.stringify(alertMessage, null, 2)}`);

    // Publish alert to MQTT
    const alertClient = mqtt.connect(`mqtt://${MQTT_BROKER}:${MQTT_PORT}`);
    alertClient.on('connect', () => {
      alertClient.publish(
        `alerts/${alert.location}/${alert.type}`,
        JSON.stringify(alertMessage),
        { qos: 1 }
      );
      alertClient.end();
    });
  }

  startAll() {
    console.log('\n🚀 Starting all sensors...');
    this.sensors.forEach(sensor => sensor.start());
  }

  stopAll() {
    console.log('\n🛑 Stopping all sensors...');
    this.sensors.forEach(sensor => sensor.stop());
  }

  getStatus() {
    return {
      totalSensors: this.sensors.length,
      onlineSensors: this.sensors.filter(s => s.isRunning).length,
      sensorTypes: [...new Set(this.sensors.map(s => s.constructor.name))]
    };
  }
}

// Create and configure sensors
function createSmartHome() {
  const manager = new SensorManager();

  // Living room sensors
  manager.addSensor(new TemperatureSensor({
    id: 'temp_001',
    name: 'Living Room Temp Sensor',
    location: 'living_room',
    interval: 5000,
    baseTemp: 22,
    variance: 3
  }));

  manager.addSensor(new MotionSensor({
    id: 'motion_001',
    name: 'Living Room Motion Sensor',
    location: 'living_room',
    interval: 2000,
    sensitivity: 0.3
  }));

  manager.addSensor(new LightSensor({
    id: 'light_001',
    name: 'Living Room Light Sensor',
    location: 'living_room',
    interval: 3000,
    baseLux: 400
  }));

  // Bedroom sensors
  manager.addSensor(new TemperatureSensor({
    id: 'temp_002',
    name: 'Bedroom Temp Sensor',
    location: 'bedroom',
    interval: 6000,
    baseTemp: 20,
    variance: 2
  }));

  manager.addSensor(new DoorSensor({
    id: 'door_001',
    name: 'Bedroom Door Sensor',
    location: 'bedroom',
    interval: 4000,
    changeProbability: 0.1
  }));

  // Front door
  manager.addSensor(new DoorSensor({
    id: 'door_002',
    name: 'Front Door Sensor',
    location: 'front_door',
    interval: 2000,
    changeProbability: 0.05
  }));

  // Outdoor camera
  manager.addSensor(new SmartCamera({
    id: 'cam_001',
    name: 'Front Door Camera',
    location: 'front_door',
    interval: 5000,
    detectionRate: 0.3
  }));

  return manager;
}

// Run the simulation
if (require.main === module) {
  console.log('🏠 IoT Smart Home Simulation\n');

  const smartHome = createSmartHome();

  // Start simulation
  smartHome.startAll();

  // Display status every 10 seconds
  setInterval(() => {
    const status = smartHome.getStatus();
    console.log(`\n📊 Status: ${status.onlineSensors}/${status.totalSensors} sensors online`);
    console.log(`   Types: ${status.sensorTypes.join(', ')}`);
  }, 10000);

  // Graceful shutdown
  process.on('SIGINT', () => {
    console.log('\n👋 Shutting down smart home simulation...');
    smartHome.stopAll();
    setTimeout(() => {
      process.exit(0);
    }, 2000);
  });
}

module.exports = {
  IoTSensor,
  TemperatureSensor,
  MotionSensor,
  LightSensor,
  DoorSensor,
  SmartCamera,
  SensorManager
};
QuellcodepythonMittel

MQTT Python-Implementierung

Python MQTT-Client-Beispiele mit Paho-MQTT-Bibliothek für professionelle IoT-Anwendungen

Schwierigkeit

6/10

Geschätzte Zeit

30 min

Schlagwörter

mqtt, python, iot, smart home, monitoring

Voraussetzungen

Python, MQTT basics, Threading

python
# MQTT Python Examples
# pip install paho-mqtt

import paho.mqtt.client as mqtt
import json
import time
import threading
import logging
from datetime import datetime
from typing import Dict, List, Optional, Callable
import random

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# MQTT Configuration
MQTT_BROKER = "mqtt.eclipse.org"
MQTT_PORT = 1883
MQTT_KEEPALIVE = 60

class MQTTClient:
    """Advanced MQTT client with reconnection and message handling"""

    def __init__(self, client_id: str = None, username: str = None, password: str = None):
        self.client_id = client_id or f"python_client_{random.randint(1000, 9999)}"
        self.username = username
        self.password = password
        self.client = mqtt.Client(client_id=self.client_id)
        self.connected = False
        self.message_callbacks = {}
        self.subscription_topics = set()
        self.last_will_topic = None
        self.last_will_message = None

        # Set up authentication
        if username and password:
            self.client.username_pw_set(username, password)

        # Set up event handlers
        self.client.on_connect = self._on_connect
        self.client.on_disconnect = self._on_disconnect
        self.client.on_message = self._on_message
        self.client.on_publish = self._on_publish
        self.client.on_subscribe = self._on_subscribe
        self.client.on_unsubscribe = self._on_unsubscribe

    def _on_connect(self, client, userdata, flags, rc):
        """Called when the client connects to the broker"""
        if rc == 0:
            self.connected = True
            logger.info(f"Connected to MQTT broker with client ID: {self.client_id}")

            # Resubscribe to all topics
            for topic in self.subscription_topics:
                self.subscribe(topic)
        else:
            logger.error(f"Failed to connect to MQTT broker. Return code: {rc}")

    def _on_disconnect(self, client, userdata, rc):
        """Called when the client disconnects"""
        self.connected = False
        if rc != 0:
            logger.warning(f"Unexpected disconnection from MQTT broker. Return code: {rc}")
        else:
            logger.info("Disconnected from MQTT broker")

    def _on_message(self, client, userdata, msg):
        """Called when a message is received"""
        try:
            topic = msg.topic
            payload = msg.payload.decode('utf-8')

            # Try to parse as JSON first
            try:
                data = json.loads(payload)
                logger.info(f"Received JSON message on {topic}: {data}")
            except json.JSONDecodeError:
                data = payload
                logger.info(f"Received message on {topic}: {payload}")

            # Call registered callback if exists
            if topic in self.message_callbacks:
                self.message_callbacks[topic](topic, data)
            else:
                # Check for wildcard callbacks
                for registered_topic in self.message_callbacks:
                    if self._topic_matches(registered_topic, topic):
                        self.message_callbacks[registered_topic](topic, data)
                        break

        except Exception as e:
            logger.error(f"Error processing message: {e}")

    def _on_publish(self, client, userdata, mid):
        """Called when a message is published"""
        logger.debug(f"Message published with mid: {mid}")

    def _on_subscribe(self, client, userdata, mid, granted_qos):
        """Called when the client subscribes to a topic"""
        logger.info(f"Subscribed with mid: {mid}, QoS: {granted_qos}")

    def _on_unsubscribe(self, client, userdata, mid):
        """Called when the client unsubscribes from a topic"""
        logger.info(f"Unsubscribed with mid: {mid}")

    def _topic_matches(self, pattern: str, topic: str) -> bool:
        """Check if a topic matches a pattern (supports wildcards)"""
        pattern_parts = pattern.split('/')
        topic_parts = topic.split('/')

        if len(pattern_parts) != len(topic_parts):
            if pattern_parts[-1] != '#':
                return False

        for i, (pattern_part, topic_part) in enumerate(zip(pattern_parts, topic_parts)):
            if pattern_part == '+':
                continue
            elif pattern_part == '#':
                return True
            elif pattern_part != topic_part:
                return False

        return True

    def set_last_will(self, topic: str, message: str, qos: int = 1, retain: bool = False):
        """Set the Last Will and Testament message"""
        self.last_will_topic = topic
        self.last_will_message = message
        self.client.will_set(topic, message.encode('utf-8'), qos, retain)

    def connect(self, broker: str = MQTT_BROKER, port: int = MQTT_PORT,
                keepalive: int = MQTT_KEEPALIVE) -> bool:
        """Connect to the MQTT broker"""
        try:
            self.client.connect(broker, port, keepalive)
            self.client.loop_start()

            # Wait for connection
            timeout = 10  # seconds
            start_time = time.time()
            while not self.connected and time.time() - start_time < timeout:
                time.sleep(0.1)

            return self.connected
        except Exception as e:
            logger.error(f"Failed to connect to MQTT broker: {e}")
            return False

    def disconnect(self):
        """Disconnect from the MQTT broker"""
        if self.connected:
            self.client.loop_stop()
            self.client.disconnect()

    def subscribe(self, topic: str, qos: int = 1, callback: Callable = None) -> bool:
        """Subscribe to a topic"""
        try:
            result, mid = self.client.subscribe(topic, qos)
            if result == mqtt.MQTT_ERR_SUCCESS:
                self.subscription_topics.add(topic)
                if callback:
                    self.message_callbacks[topic] = callback
                logger.info(f"Subscribed to topic: {topic}")
                return True
            else:
                logger.error(f"Failed to subscribe to topic: {topic}")
                return False
        except Exception as e:
            logger.error(f"Error subscribing to topic: {e}")
            return False

    def unsubscribe(self, topic: str) -> bool:
        """Unsubscribe from a topic"""
        try:
            result, mid = self.client.unsubscribe(topic)
            if result == mqtt.MQTT_ERR_SUCCESS:
                self.subscription_topics.discard(topic)
                if topic in self.message_callbacks:
                    del self.message_callbacks[topic]
                logger.info(f"Unsubscribed from topic: {topic}")
                return True
            else:
                logger.error(f"Failed to unsubscribe from topic: {topic}")
                return False
        except Exception as e:
            logger.error(f"Error unsubscribing from topic: {e}")
            return False

    def publish(self, topic: str, payload, qos: int = 1, retain: bool = False) -> bool:
        """Publish a message to a topic"""
        try:
            if isinstance(payload, dict) or isinstance(payload, list):
                payload = json.dumps(payload)

            result = self.client.publish(topic, payload.encode('utf-8'), qos, retain)
            if result.rc == mqtt.MQTT_ERR_SUCCESS:
                logger.info(f"Published to {topic}: {payload}")
                return True
            else:
                logger.error(f"Failed to publish to {topic}")
                return False
        except Exception as e:
            logger.error(f"Error publishing message: {e}")
            return False

    def add_callback(self, topic: str, callback: Callable):
        """Add a callback for a specific topic"""
        self.message_callbacks[topic] = callback

# Example 1: Temperature Monitor
class TemperatureMonitor:
    """Monitors temperature sensors and alerts on thresholds"""

    def __init__(self, client: MQTTClient):
        self.client = client
        self.temperature_readings = {}
        self.alert_threshold = 30.0  # Celsius
        self.low_threshold = 10.0

        # Subscribe to temperature topics
        self.client.subscribe("sensors/temperature/+", qos=1, callback=self.handle_temperature)

    def handle_temperature(self, topic: str, data: dict):
        """Handle incoming temperature data"""
        try:
            location = topic.split('/')[-1]
            temperature = float(data.get('temperature', 0))
            timestamp = data.get('timestamp', datetime.now().isoformat())

            # Store reading
            self.temperature_readings[location] = {
                'temperature': temperature,
                'timestamp': timestamp
            }

            # Check thresholds
            if temperature > self.alert_threshold:
                self.send_alert(location, temperature, "HIGH")
            elif temperature < self.low_threshold:
                self.send_alert(location, temperature, "LOW")
            else:
                logger.info(f"🌡️ {location}: {temperature}°C - Normal")

        except Exception as e:
            logger.error(f"Error handling temperature data: {e}")

    def send_alert(self, location: str, temperature: float, alert_type: str):
        """Send temperature alert"""
        alert = {
            'type': 'temperature_alert',
            'alert_type': alert_type,
            'location': location,
            'temperature': temperature,
            'threshold': self.alert_threshold if alert_type == "HIGH" else self.low_threshold,
            'timestamp': datetime.now().isoformat()
        }

        self.client.publish(f"alerts/{location}/temperature", alert)
        logger.warning(f"🚨 Temperature alert - {location}: {temperature}°C ({alert_type})")

# Example 2: Smart Home Controller
class SmartHomeController:
    """Controls smart home devices based on sensor data"""

    def __init__(self, client: MQTTClient):
        self.client = client
        self.devices = {
            'living_room_light': False,
            'bedroom_light': False,
            'thermostat': 22,
            'security_system': False
        }

        # Subscribe to sensor and control topics
        self.client.subscribe("sensors/motion/+", callback=self.handle_motion)
        self.client.subscribe("sensors/light/+", callback=self.handle_light)
        self.client.subscribe("control/+", callback=self.handle_control)
        self.client.subscribe("devices/+/status", callback=self.handle_device_status)

    def handle_motion(self, topic: str, data: dict):
        """Handle motion sensor data"""
        location = topic.split('/')[-1]

        if data.get('motion', False):
            logger.info(f"🚶 Motion detected in {location}")

            # Turn on lights when motion is detected
            if location == 'living_room':
                self.toggle_device('living_room_light', True)
            elif location == 'bedroom':
                self.toggle_device('bedroom_light', True)

            # Activate security if outside business hours
            hour = datetime.now().hour
            if hour < 6 or hour > 22:
                self.toggle_device('security_system', True)

    def handle_light(self, topic: str, data: dict):
        """Handle light sensor data"""
        location = topic.split('/')[-1]
        illuminance = float(data.get('illuminance', 0))

        # Automatic lighting based on ambient light
        if illuminance < 100 and location == 'living_room':
            self.toggle_device('living_room_light', True)
            logger.info(f"💡 Low light detected in {location}, turning on lights")
        elif illuminance > 300 and location == 'living_room':
            self.toggle_device('living_room_light', False)
            logger.info(f"☀️ Sufficient light in {location}, turning off lights")

    def handle_control(self, topic: str, data: dict):
        """Handle control commands"""
        try:
            command = data.get('command')
            device = data.get('device')
            value = data.get('value')

            if command == 'toggle':
                self.toggle_device(device, value)
            elif command == 'set_thermostat':
                self.set_thermostat(value)
            elif command == 'security':
                self.toggle_device('security_system', value)

            logger.info(f"🎮 Control command received: {command} for {device}")

        except Exception as e:
            logger.error(f"Error handling control command: {e}")

    def handle_device_status(self, topic: str, data: dict):
        """Handle device status updates"""
        device_id = topic.split('/')[1]
        status = data.get('status')

        if status == 'offline':
            logger.warning(f"⚠️ Device {device_id} is offline")
            # Could trigger alert or attempt reconnection here

    def toggle_device(self, device: str, state: bool):
        """Toggle a device on/off"""
        if device in self.devices:
            self.devices[device] = state

            # Publish device state change
            message = {
                'device': device,
                'state': state,
                'timestamp': datetime.now().isoformat()
            }

            self.client.publish(f"devices/{device}/state", message)
            logger.info(f"🔌 {device} turned {'on' if state else 'off'}")

    def set_thermostat(self, temperature: float):
        """Set thermostat temperature"""
        self.devices['thermostat'] = temperature

        message = {
            'device': 'thermostat',
            'temperature': temperature,
            'timestamp': datetime.now().isoformat()
        }

        self.client.publish("devices/thermostat/setpoint", message)
        logger.info(f"🌡️ Thermostat set to {temperature}°C")

# Example 3: Data Logger
class MQTTDataLogger:
    """Logs MQTT data to file or database"""

    def __init__(self, client: MQTTClient, log_file: str = "mqtt_data.log"):
        self.client = client
        self.log_file = log_file

        # Subscribe to all sensor data
        self.client.subscribe("sensors/+", callback=self.log_sensor_data)
        self.client.subscribe("devices/+/state", callback=self.log_device_state)

    def log_sensor_data(self, topic: str, data):
        """Log sensor data"""
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'topic': topic,
            'type': 'sensor_data',
            'data': data
        }

        self._write_log(log_entry)

    def log_device_state(self, topic: str, data):
        """Log device state changes"""
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'topic': topic,
            'type': 'device_state',
            'data': data
        }

        self._write_log(log_entry)

    def _write_log(self, log_entry: dict):
        """Write log entry to file"""
        try:
            with open(self.log_file, 'a') as f:
                f.write(json.dumps(log_entry) + '
')
        except Exception as e:
            logger.error(f"Error writing to log file: {e}")

# Main application
def main():
    logger.info("🚀 Starting MQTT Python Application")

    # Create MQTT client with Last Will
    client = MQTTClient(client_id="python_controller")
    client.set_last_will(
        "controllers/python_controller/status",
        json.dumps({
            'status': 'offline',
            'timestamp': datetime.now().isoformat(),
            'reason': 'unexpected_disconnect'
        }),
        qos=1,
        retain=True
    )

    # Connect to broker
    if not client.connect():
        logger.error("Failed to connect to MQTT broker")
        return

    # Publish online status
    client.publish(
        "controllers/python_controller/status",
        json.dumps({
            'status': 'online',
            'timestamp': datetime.now().isoformat()
        }),
        retain=True
    )

    # Initialize components
    temperature_monitor = TemperatureMonitor(client)
    smart_home_controller = SmartHomeController(client)
    data_logger = MQTTDataLogger(client)

    # Simulate some device updates
    def simulate_devices():
        while True:
            # Simulate temperature sensor
            temp_data = {
                'temperature': round(random.uniform(15, 35), 2),
                'timestamp': datetime.now().isoformat()
            }
            client.publish("sensors/temperature/living_room", temp_data)

            # Simulate motion sensor
            if random.random() < 0.3:
                motion_data = {
                    'motion': True,
                    'timestamp': datetime.now().isoformat()
                }
                client.publish("sensors/motion/living_room", motion_data)

            time.sleep(5)

    # Start simulation in background thread
    simulation_thread = threading.Thread(target=simulate_devices, daemon=True)
    simulation_thread.start()

    try:
        logger.info("✅ Application running. Press Ctrl+C to stop.")
        while True:
            time.sleep(1)

    except KeyboardInterrupt:
        logger.info("👋 Shutting down application...")

        # Publish offline status
        client.publish(
            "controllers/python_controller/status",
            json.dumps({
                'status': 'offline',
                'timestamp': datetime.now().isoformat(),
                'reason': 'graceful_shutdown'
            }),
            retain=True
        )

        client.disconnect()
        logger.info("🔌 Application stopped")

if __name__ == "__main__":
    main()

Werkzeuge

Tools, die oft mit diesem Beispiel genutzt werden

Verwandt

Verwandte Beispielsammlungen

Start
Werkzeuge3212
Beispiele593
Visualisierungen471
Dateibetrachter103
Themen239
Schlagwörter333
Bilder, Audio & Video657

Werkzeuge für Bild-, Audio- und Videobearbeitung, Konvertierung und Optimierung

Mathe, Datum & Finanzen647

Rechner, Zahlenwerkzeuge, Datumslogik, Statistik und Finanztools

Design & Farbe298

Werkzeuge für Farben, Layouts, Grafiken, visuelle Gestaltung und Designhilfen

Text & Schreiben209

Werkzeuge für Schreiben, Bereinigung, Formatierung, Extraktion und Textanalyse

Entwicklung & Web193

Entwicklerwerkzeuge, Netzwerk-Utilities, Web-Debugging und Automatisierungshelfer

Konvertierung & Kodierung175

Werkzeuge für Format-, Datei-, Archiv-, Einheiten- und Kodierungskonvertierung

Lead-Quiz veröffentlichen und Kontakte sicher übergeben
Gedenktexte: Familienprüfung und Übergabe zum Druck
Private Gewohnheiten: Sicherung, Wiederherstellung und Freigabeprüfung
Vom Artikel zu X- und LinkedIn-Entwürfen: Faktenprüfung und Übergabe
Interaktive Markdown-Lektion prüfen und offline übergeben

© 2026 Elysia Tools. Alle Rechte vorbehalten.

DokumentationTarifeÜber unsNutzungsbedingungenDatenschutzerklärungCookiesKontakt

Media

Decoder für das MIDI-1.0-/MIDI-2.0-UMP-Wire-Protokoll (Universal MIDI Packet, Channel Voice, SysEx 7/8 Bit) und Bytezähler

Fügen Sie einen Hex-Strom ein: Dekodierung eines MIDI-1.0-Bytestroms (Running Status, System Common/Real Time, SysEx) oder eines MIDI-2.0-UMP-Stroms — 0x0 Utility, 0x1 System, 0x2 MIDI-1.0-Channel-Voice, 0x3 SysEx 7-Bit, 0x4 MIDI-2.0-Channel-Voice (16-Bit-Velocity + 7.9-Pitch-Attribut), 0x5 SysEx 8-Bit/Mixed Data, 0xD Flex Data, 0xF UMP Stream; Zählung von Bytes/Paketen/Wörtern, Prüfung reservierter Felder und der SysEx-Zustandsautomaten sowie Übersetzung zwischen MIDI 1.0 und UMP.

Webtechnologien

WebRTC Echtzeitkommunikation Beispiele

Umfassende WebRTC-Beispiele für P2P Audio/Video-Kommunikation, Datenkanäle, Bildschirmfreigabe und Signalisierungsserver

Kommunikationsprotokolle

AMQP Nachrichtenprotokoll

AMQP (Advanced Message Queuing Protocol) Beispiele für Enterprise Messaging mit RabbitMQ, Queues, Exchanges und erweiterten Routing-Patterns

Kommunikationsprotokolle

gRPC-Beispiele

gRPC (Google Remote Procedure Call) Kommunikationsprotokoll-Beispiele mit Protocol Buffers und Service-Definitionen

Kommunikationsprotokolle

Server-Sent Events (SSE)

Server-Sent Events Beispiele für unidirektionale Echtzeitkommunikation von Server zu Client, einschließlich Live-Updates, Benachrichtigungen und Daten-Streaming