Lovepreet kaur (coding)

import threading
import random
import time
import paho.mqtt.client as mqtt

broker = "broker.hivemq.com"
port = 1883
energy_topic = "home/energy"
temperature_topic = "home/temperature"

# Publisher function for energy
def publish_energy_data(client):
    while True:
        energy_usage = random.uniform(0.5, 2.0)  # Simulate energy usage in kWh
        message = f"{energy_usage:.2f}"
        client.publish(energy_topic, message)
        print(f"Published Energy: {message} kWh")
        time.sleep(5)  # Publish every 5 seconds

# Publisher function for temperature
def publish_temperature_data(client):
    while True:
        temperature = random.uniform(18.0, 30.0)  # Simulate temperature in Celsius
        message = f"{temperature:.2f}"
        client.publish(temperature_topic, message)
        print(f"Published Temperature: {message} °C")
        time.sleep(5)  # Publish every 5 seconds

# Subscriber callback
def on_message(client, userdata, message):
    topic = message.topic
    payload = message.payload.decode()
    if topic == energy_topic:
        energy_usage = float(payload)
        print(f"Received Energy: {energy_usage} kWh")
        if energy_usage > 1.5:
            print("High energy usage detected! Turning off non-essential devices.")
        else:
            print("Energy usage is within the normal range.")
    elif topic == temperature_topic:
        temperature = float(payload)
        print(f"Received Temperature: {temperature} °C")
        # Add any specific handling for temperature data here

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connected to MQTT broker")
        client.subscribe(energy_topic)
        client.subscribe(temperature_topic)
    else:
        print(f"Failed to connect, return code {rc}")

# Create and configure the subscriber client
subscriber_client = mqtt.Client()
subscriber_client.on_connect = on_connect
subscriber_client.on_message = on_message

# Create and configure the publisher client
publisher_client = mqtt.Client()

# Connect both clients to the broker
subscriber_client.connect(broker, port, 60)
publisher_client.connect(broker, port, 60)

# Run the MQTT loop for the subscriber in a separate thread
subscriber_thread = threading.Thread(target=subscriber_client.loop_forever)
subscriber_thread.start()

# Run the publisher functions in separate threads
energy_thread = threading.Thread(target=publish_energy_data, args=(publisher_client,))
temperature_thread = threading.Thread(target=publish_temperature_data, args=(publisher_client,))

energy_thread.start()
temperature_thread.start()

# Wait for the threads to complete
energy_thread.join()
temperature_thread.join()