MQTT Client Setup

dependencies {
    implementation("org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.2.5")
    implementation("org.springframework.integration:spring-integration-mqtt:6.5.3")
}

import org.eclipse.paho.client.mqttv3.MqttClient
import org.eclipse.paho.client.mqttv3.MqttConnectOptions
import org.eclipse.paho.client.mqttv3.MqttMessage
import java.util.UUID

class GreenhouseMqttClient {
    private val brokerUrl = "wss://your-broker:8084/mqtt"
    private val clientId = "greenhouse-client-${UUID.randomUUID()}"
    private lateinit var client: MqttClient

    fun connect(username: String, password: String) {
        client = MqttClient(brokerUrl, clientId)

        val options = MqttConnectOptions().apply {
            userName = username
            setPassword(password.toCharArray())
            isCleanSession = false
            connectionTimeout = 10
            keepAliveInterval = 60
            isAutomaticReconnect = true
        }

        client.connect(options)
        println("Connected to MQTT broker: $brokerUrl")
    }

    fun subscribe(topic: String) {
        client.subscribe(topic) { topic, message ->
            println("Message received on $topic: ${String(message.payload)}")
        }
    }

    fun publish(topic: String, payload: String) {
        val message = MqttMessage(payload.toByteArray()).apply {
            qos = 0
            isRetained = false
        }
        client.publish(topic, message)
    }

    fun disconnect() {
        client.disconnect()
    }
}

const mqtt = require('mqtt');

const options = {
  clientId: `greenhouse-client-${Math.random().toString(16).slice(3)}`,
  username: 'your-username',
  password: 'your-password',
  clean: false,
  keepalive: 60,
  reconnectPeriod: 1000,
  connectTimeout: 10 * 1000,
  queueQoSZero: true
};

const client = mqtt.connect('wss://your-broker:8084/mqtt', options);

client.on('connect', () => {
  console.log('Connected to MQTT broker');
  
  // Subscribe to topics
  client.subscribe('GREENHOUSE/SARA', (err) => {
    if (!err) {
      console.log('Subscribed to GREENHOUSE/SARA');
    }
  });
});

client.on('message', (topic, message) => {
  console.log(`Message on ${topic}: ${message.toString()}`);
  const data = JSON.parse(message.toString());
  // Process sensor data
});

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

client.on('reconnect', () => {
  console.log('Reconnecting to broker...');
});

// Publish sensor data
function publishSensorData(tenantId, data) {
  const topic = `GREENHOUSE/${tenantId}`;
  const payload = JSON.stringify(data);
  
  client.publish(topic, payload, { qos: 0, retain: false }, (err) => {
    if (err) {
      console.error('Publish error:', err);
    } else {
      console.log(`Published to ${topic}`);
    }
  });
}

import paho.mqtt.client as mqtt
import json
import uuid

class GreenhouseMqttClient:
    def __init__(self, broker_host, broker_port, username, password):
        self.client_id = f"greenhouse-client-{uuid.uuid4()}"
        self.client = mqtt.Client(client_id=self.client_id, clean_session=False)
        
        # Set credentials
        self.client.username_pw_set(username, password)
        
        # Configure callbacks
        self.client.on_connect = self.on_connect
        self.client.on_message = self.on_message
        self.client.on_disconnect = self.on_disconnect
        
        # Connection settings
        self.broker_host = broker_host
        self.broker_port = broker_port

    def on_connect(self, client, userdata, flags, rc):
        if rc == 0:
            print(f"Connected to MQTT broker: {self.broker_host}:{self.broker_port}")
            # Subscribe to topics
            client.subscribe("GREENHOUSE/+", qos=0)
            print("Subscribed to GREENHOUSE/+ (all tenants)")
        else:
            print(f"Connection failed with code: {rc}")

    def on_message(self, client, userdata, msg):
        topic = msg.topic
        payload = msg.payload.decode('utf-8')
        print(f"Message on {topic}: {payload}")
        
        try:
            data = json.loads(payload)
            # Process sensor data
            self.process_sensor_data(data)
        except json.JSONDecodeError as e:
            print(f"Invalid JSON: {e}")

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

    def connect(self):
        try:
            self.client.connect(self.broker_host, self.broker_port, keepalive=60)
            self.client.loop_start()  # Start background thread
        except Exception as e:
            print(f"Connection error: {e}")

    def publish(self, tenant_id, sensor_data):
        topic = f"GREENHOUSE/{tenant_id}"
        payload = json.dumps(sensor_data)
        result = self.client.publish(topic, payload, qos=0, retain=False)
        
        if result.rc == mqtt.MQTT_ERR_SUCCESS:
            print(f"Published to {topic}")
        else:
            print(f"Publish failed: {result.rc}")

    def process_sensor_data(self, data):
        # Implement your data processing logic
        temp = data.get('TEMPERATURA INVERNADERO 01')
        humidity = data.get('HUMEDAD INVERNADERO 01')
        print(f"Temp: {temp}°C, Humidity: {humidity}%")

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

# Usage
if __name__ == "__main__":
    client = GreenhouseMqttClient(
        broker_host="your-broker.com",
        broker_port=1883,  # Use 8883 for TLS
        username="your-username",
        password="your-password"
    )
    
    client.connect()
    
    # Publish sensor data
    sensor_data = {
        "TEMPERATURA INVERNADERO 01": 25.5,
        "HUMEDAD INVERNADERO 01": 65.2
    }
    client.publish("SARA", sensor_data)
    
    # Keep running
    try:
        while True:
            pass
    except KeyboardInterrupt:
        client.disconnect()