VWED_server/tests/test.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
MQTT Connection Test Example
IP: 192.168.189.97
Port: 1883
"""

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


class MQTTService:
    def __init__(self, host="192.168.189.97", port=1883, keepalive=60):
        self.host = host
        self.port = port
        self.keepalive = keepalive
        self.client = mqtt.Client()
        
        # Set callback functions
        self.client.on_connect = self.on_connect
        self.client.on_message = self.on_message
        self.client.on_disconnect = self.on_disconnect
        self.client.on_publish = self.on_publish
        
    def on_connect(self, client, userdata, flags, rc):
        """Connection callback"""
        if rc == 0:
            print(f"Successfully connected to MQTT server {self.host}:{self.port}")
            # Subscribe to topics after successful connection
            self.client.subscribe("vwed/task/status")
            self.client.subscribe("vwed/device/+/data")
            print("Subscribed to topics: vwed/task/status, vwed/device/+/data")
        else:
            print(f"Connection failed, error code: {rc}")
    
    def on_message(self, client, userdata, msg):
        """Message received callback"""
        try:
            topic = msg.topic
            payload = msg.payload.decode('utf-8')
            print(f"Received message - Topic: {topic}")
            print(f"Payload: {payload}")
            print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            print("-" * 50)
        except Exception as e:
            print(f"Error processing message: {e}")
    
    def on_disconnect(self, client, userdata, rc):
        """Disconnect callback"""
        print(f"Disconnected from MQTT server, code: {rc}")
    
    def on_publish(self, client, userdata, mid):
        """Message publish callback"""
        print(f"Message published successfully, message ID: {mid}")
    
    def connect(self):
        """Connect to MQTT server"""
        try:
            print(f"Connecting to MQTT server {self.host}:{self.port}...")
            self.client.connect(self.host, self.port, self.keepalive)
            return True
        except Exception as e:
            print(f"Connection failed: {e}")
            return False
    
    def disconnect(self):
        """Disconnect from server"""
        self.client.disconnect()
    
    def publish(self, topic, payload, qos=0, retain=False):
        """Publish message"""
        try:
            if isinstance(payload, dict):
                payload = json.dumps(payload, ensure_ascii=False)
            
            result = self.client.publish(topic, payload, qos, retain)
            if result.rc == mqtt.MQTT_ERR_SUCCESS:
                print(f"Published message to topic {topic}: {payload}")
                return True
            else:
                print(f"Failed to publish message, error code: {result.rc}")
                return False
        except Exception as e:
            print(f"Error publishing message: {e}")
            return False
    
    def subscribe(self, topic, qos=0):
        """Subscribe to topic"""
        try:
            result = self.client.subscribe(topic, qos)
            if result[0] == mqtt.MQTT_ERR_SUCCESS:
                print(f"Successfully subscribed to topic: {topic}")
                return True
            else:
                print(f"Failed to subscribe to topic, error code: {result[0]}")
                return False
        except Exception as e:
            print(f"Error subscribing to topic: {e}")
            return False
    
    def start_loop(self):
        """Start message loop"""
        self.client.loop_start()
    
    def stop_loop(self):
        """Stop message loop"""
        self.client.loop_stop()


def test_mqtt_connection():
    """Test MQTT connection"""
    print("=== MQTT Connection Test ===")
    
    # Create MQTT service instance
    mqtt_service = MQTTService()
    
    # Connect to server
    if mqtt_service.connect():
        # Start message loop
        mqtt_service.start_loop()
        
        # Wait for connection to establish
        time.sleep(2)
        
        # Publish test messages
        test_data = {
            "device_id": "robot_001",
            "status": "running",
            "battery": 85,
            "position": {"x": 100, "y": 200},
            "timestamp": datetime.now().isoformat()
        }
        
        mqtt_service.publish("vwed/device/robot_001/data", test_data)
        mqtt_service.publish("vwed/task/status", "Task is running...")
        
        # Keep connection alive and listen for messages
        print("Keeping connection alive for 30 seconds, listening for messages...")
        time.sleep(30)
        
        # Stop loop and disconnect
        mqtt_service.stop_loop()
        mqtt_service.disconnect()
        print("Test completed")
    else:
        print("Unable to connect to MQTT server")


if __name__ == "__main__":
    test_mqtt_connection()