iotlabkit 1.0.0__py3-none-any.whl

iotlabkit/templates/program_08.py

@@ -0,0 +1,278 @@
+"""Template generator for Program 8: CoAP Client and Server."""
+
+from typing import Dict
+import os
+
+
+def generate(target_dir: str, mode: str = "learning") -> Dict[str, str]:
+    files = {}
+
+    files["requirements.txt"] = (
+        "# Program 8 uses pure Python RFC 7252 CoAP over UDP with ZERO external dependencies!\n"
+        "# Standard library only (socket, struct, threading, time).\n"
+    )
+
+    files[".env.example"] = (
+        "# CoAP Server Configuration\n"
+        "COAP_HOST=127.0.0.1\n"
+        "# Standard CoAP port is 5683. If port 5683 requires root on your OS, you can use 56830.\n"
+        "COAP_PORT=56830\n"
+    )
+
+    files[".gitignore"] = (
+        ".env\n"
+        "__pycache__/\n"
+        "*.py[cod]\n"
+    )
+
+    # Embed coap_core.py (the pure Python RFC 7252 engine)
+    coap_util_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "coap_util.py")
+    if os.path.exists(coap_util_path):
+        with open(coap_util_path, "r", encoding="utf-8") as f:
+            files["coap_core.py"] = f.read()
+    else:
+        # Fallback inline
+        files["coap_core.py"] = (
+            "# RFC 7252 CoAP implementation\n"
+            "from iotlabkit.coap_util import *\n"
+        )
+
+    # server.py
+    if mode == "learning":
+        srv_doc = (
+            '"""CoAP (Constrained Application Protocol) Server - Program 8.\n\n'
+            "Implements an RFC 7252 CoAP server running on UDP port 56830 (or standard 5683).\n"
+            "Exposes three environmental RESTful resources over UDP:\n"
+            "  - GET coap://<host>:<port>/temperature\n"
+            "  - GET coap://<host>:<port>/humidity\n"
+            "  - GET coap://<host>:<port>/environmental\n\n"
+            "Execution: Run in Terminal 1 (`python server.py`).\n"
+            '"""\n'
+        )
+    else:
+        srv_doc = '"""CoAP Server - Program 8 (Exam Mode)."""\n'
+
+    files["server.py"] = srv_doc + (
+        "import argparse\n"
+        "import json\n"
+        "import os\n"
+        "import time\n"
+        "from coap_core import CoAPServer, CODE_CONTENT\n\n"
+        "DEFAULT_HOST = '127.0.0.1'\n"
+        "DEFAULT_PORT = 56830\n\n"
+        "# Real ambient environmental state\n"
+        "CURRENT_STATE = {\n"
+        "    'temperature': 27.8,\n"
+        "    'humidity': 65.4,\n"
+        "    'sensor_model': 'DHT22_Calibrated',\n"
+        "    'location': 'IoT_Lab_Room_302'\n"
+        "}\n\n"
+        "def get_temperature_resource():\n"
+        "    payload = {\n"
+        "        'temperature': CURRENT_STATE['temperature'],\n"
+        "        'unit': 'Celsius',\n"
+        "        'timestamp': int(time.time())\n"
+        "    }\n"
+        "    return CODE_CONTENT, json.dumps(payload)\n\n"
+        "def get_humidity_resource():\n"
+        "    payload = {\n"
+        "        'humidity': CURRENT_STATE['humidity'],\n"
+        "        'unit': 'Percent',\n"
+        "        'timestamp': int(time.time())\n"
+        "    }\n"
+        "    return CODE_CONTENT, json.dumps(payload)\n\n"
+        "def get_environmental_resource():\n"
+        "    t = CURRENT_STATE['temperature']\n"
+        "    h = CURRENT_STATE['humidity']\n"
+        "    heat_index = round(t + 0.5555 * ((6.11 * 10 ** (7.5 * t / (237.3 + t)) * (h / 100)) - 10), 1)\n"
+        "    payload = {\n"
+        "        'temperature': t,\n"
+        "        'humidity': h,\n"
+        "        'heat_index': heat_index,\n"
+        "        'sensor_model': CURRENT_STATE['sensor_model'],\n"
+        "        'location': CURRENT_STATE['location'],\n"
+        "        'status': 'COMFORTABLE',\n"
+        "        'timestamp': int(time.time())\n"
+        "    }\n"
+        "    return CODE_CONTENT, json.dumps(payload)\n\n"
+        "def main():\n"
+        "    parser = argparse.ArgumentParser(description='Start RFC 7252 CoAP Server')\n"
+        "    parser.add_argument('--host', default=DEFAULT_HOST, help='Listening host')\n"
+        "    parser.add_argument('--port', type=int, default=DEFAULT_PORT, help='Listening UDP port')\n"
+        "    parser.add_argument('--temp', type=float, help='Configure ambient temperature in °C')\n"
+        "    parser.add_argument('--humidity', type=float, help='Configure ambient humidity in %')\n"
+        "    args = parser.parse_args()\n\n"
+        "    if args.temp is not None:\n"
+        "        CURRENT_STATE['temperature'] = args.temp\n"
+        "    if args.humidity is not None:\n"
+        "        CURRENT_STATE['humidity'] = args.humidity\n\n"
+        "    server = CoAPServer(host=args.host, port=args.port)\n"
+        "    server.add_resource('/temperature', get_temperature_resource)\n"
+        "    server.add_resource('/humidity', get_humidity_resource)\n"
+        "    server.add_resource('/environmental', get_environmental_resource)\n\n"
+        "    print('=' * 65)\n"
+        "    print(f'🌐 RFC 7252 CoAP Server running on udp://{args.host}:{args.port}')\n"
+        "    print('=' * 65)\n"
+        "    print('Exposed CoAP GET Resources:')\n"
+        "    print(f'  - coap://{args.host}:{args.port}/temperature')\n"
+        "    print(f'  - coap://{args.host}:{args.port}/humidity')\n"
+        "    print(f'  - coap://{args.host}:{args.port}/environmental')\n"
+        "    print(f\"Current Sensor Readings: Temp={CURRENT_STATE['temperature']}°C, Humidity={CURRENT_STATE['humidity']}%\")\n"
+        "    print('=' * 65)\n"
+        "    print('Server is listening... Keep this terminal open.')\n"
+        "    print('Now open Terminal 2 and run: python client.py')\n"
+        "    print('Press Ctrl+C to terminate.')\n\n"
+        "    try:\n"
+        "        server.start(blocking=True)\n"
+        "    except KeyboardInterrupt:\n"
+        "        print('\\nShutting down CoAP server...')\n"
+        "        server.stop()\n\n"
+        "if __name__ == '__main__':\n"
+        "    main()\n"
+    )
+
+    # client.py
+    if mode == "learning":
+        cli_doc = (
+            '"""CoAP Client - Program 8.\n\n'
+            "Sends RFC 7252 CoAP GET requests over UDP to query environmental resources.\n"
+            "Parses the 2.05 Content response and renders an ASCII dashboard.\n\n"
+            "Execution: Run in Terminal 2 while server is active in Terminal 1.\n"
+            '"""\n'
+        )
+    else:
+        cli_doc = '"""CoAP Client - Program 8 (Exam Mode)."""\n'
+
+    files["client.py"] = cli_doc + (
+        "import argparse\n"
+        "import json\n"
+        "import sys\n"
+        "import time\n"
+        "from coap_core import CoAPClient\n\n"
+        "DEFAULT_HOST = '127.0.0.1'\n"
+        "DEFAULT_PORT = 56830\n\n"
+        "def display_dashboard(data: dict, resource: str, resp_code: int):\n"
+        "    code_str = f\"{resp_code >> 5}.{resp_code & 0x1F:02d} Content\"\n"
+        "    print('\\n' + '=' * 60)\n"
+        "    print(f\"   CoAP Environmental Monitoring Dashboard (GET {resource})\")\n"
+        "    print('=' * 60)\n"
+        "    print(f\"  CoAP Response Code : {code_str}\")\n"
+        "    print(f\"  Timestamp          : {time.strftime('%Y-%m-%d %H:%M:%S')}\")\n"
+        "    print('-' * 60)\n"
+        "    if 'temperature' in data:\n"
+        "        print(f\"  🌡️  Temperature      : {data['temperature']} °C\")\n"
+        "    if 'humidity' in data:\n"
+        "        print(f\"  💧 Humidity         : {data['humidity']} %\")\n"
+        "    if 'heat_index' in data:\n"
+        "        print(f\"  ☀️  Heat Index       : {data['heat_index']} °C\")\n"
+        "    if 'status' in data:\n"
+        "        print(f\"  📊 Status           : {data['status']}\")\n"
+        "    if 'location' in data:\n"
+        "        print(f\"  📍 Location         : {data['location']}\")\n"
+        "    print('=' * 60 + '\\n')\n\n"
+        "def main():\n"
+        "    parser = argparse.ArgumentParser(description='CoAP Environmental Client')\n"
+        "    parser.add_argument('--host', default=DEFAULT_HOST, help='CoAP server host')\n"
+        "    parser.add_argument('--port', type=int, default=DEFAULT_PORT, help='CoAP server port')\n"
+        "    parser.add_argument('--resource', default='/environmental', choices=['/temperature', '/humidity', '/environmental'], help='Resource path to query')\n"
+        "    parser.add_argument('--watch', type=float, help='Periodically poll every N seconds')\n"
+        "    args = parser.parse_args()\n\n"
+        "    client = CoAPClient(timeout=3.0)\n\n"
+        "    def query_once():\n"
+        "        try:\n"
+        "            resp = client.get(args.host, args.port, args.resource)\n"
+        "            try:\n"
+        "                data = json.loads(resp.payload_text)\n"
+        "            except Exception:\n"
+        "                data = {'raw_payload': resp.payload_text}\n"
+        "            display_dashboard(data, args.resource, resp.code)\n"
+        "        except Exception as err:\n"
+        "            print(f\"✗ Request failed: {err}\")\n"
+        "            print(f\"  Make sure server is running on udp://{args.host}:{args.port} (`python server.py` in Terminal 1).\")\n\n"
+        "    if args.watch:\n"
+        "        print(f\"Polling '{args.resource}' every {args.watch}s (Ctrl+C to stop)...\")\n"
+        "        try:\n"
+        "            while True:\n"
+        "                query_once()\n"
+        "                time.sleep(args.watch)\n"
+        "        except KeyboardInterrupt:\n"
+        "            print('\\nStopped.')\n"
+        "    else:\n"
+        "        query_once()\n\n"
+        "if __name__ == '__main__':\n"
+        "    main()\n"
+    )
+
+    # README.md
+    if mode == "learning":
+        readme_content = (
+            "# Program 8 — CoAP Client and Server Environmental Monitoring\n\n"
+            "## 1. Overview\n"
+            "This practical implements a real Constrained Application Protocol (**RFC 7252 CoAP**) communication system over UDP:\n"
+            "- A CoAP Server binds to UDP port 56830 and exposes `/temperature`, `/humidity`, and `/environmental` RESTful resources.\n"
+            "- A CoAP Client crafts Confirmable (CON) GET requests with Uri-Path options, parses the `2.05 Content` response, and displays an environmental dashboard.\n"
+            "- Operates with **zero external dependencies** using pure Python standard library.\n\n"
+            "## 2. CoAP Packet Architecture (RFC 7252)\n"
+            "```\n"
+            " 0                   1                   2                   3\n"
+            " 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n"
+            "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
+            "|Ver| T |  TKL  |      Code     |          Message ID           |\n"
+            "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
+            "|   Token (if any, TKL bytes) ...                               |\n"
+            "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
+            "|   Options (Uri-Path, Content-Format) ...                      |\n"
+            "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
+            "|1 1 1 1 1 1 1 1|    Payload (JSON Data) ...                    |\n"
+            "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
+            "```\n\n"
+            "## 3. Step-by-Step Execution (Separate Terminals)\n\n"
+            "### Terminal 1 — Start the CoAP Server\n"
+            "```bash\n"
+            "python server.py\n"
+            "```\n"
+            "Output:\n"
+            "```\n"
+            "🌐 RFC 7252 CoAP Server running on udp://127.0.0.1:56830\n"
+            "Exposed CoAP GET Resources:\n"
+            "  - coap://127.0.0.1:56830/temperature\n"
+            "  - coap://127.0.0.1:56830/humidity\n"
+            "  - coap://127.0.0.1:56830/environmental\n"
+            "```\n\n"
+            "### Terminal 2 — Start the CoAP Client\n"
+            "In a second terminal window, run:\n"
+            "```bash\n"
+            "# Query the complete environmental dashboard:\n"
+            "python client.py\n\n"
+            "# Query specific resource:\n"
+            "python client.py --resource /temperature\n\n"
+            "# Continuous monitoring loop (poll every 3 seconds):\n"
+            "python client.py --watch 3\n"
+            "```\n\n"
+            "## 4. Viva Questions and Answers\n"
+            "**Q1: How does CoAP differ from HTTP?**  \n"
+            "A: While both follow a RESTful request/response paradigm, CoAP runs over UDP with a compact 4-byte fixed header, supports asynchronous messaging, and is optimized for low-power 8-bit/32-bit microcontrollers.\n\n"
+            "**Q2: What is the significance of the 0xFF byte in a CoAP packet?**  \n"
+            "A: 0xFF is the payload marker that separates CoAP header options from the raw message payload.\n"
+        )
+    else:
+        readme_content = (
+            "# Program 8 — CoAP Client and Server (Exam Mode)\n\n"
+            "## Execution Instructions\n"
+            "1. Terminal 1 (Start Server):\n"
+            "   ```bash\n"
+            "   python server.py\n"
+            "   ```\n"
+            "2. Terminal 2 (Run Client):\n"
+            "   ```bash\n"
+            "   python client.py\n"
+            "   ```\n\n"
+            "## Viva Q&A\n"
+            "- **Q: What is the standard port for CoAP?**  \n"
+            "  A: UDP port 5683 for unencrypted CoAP, and port 5684 for CoAP over DTLS (coaps).\n"
+            "- **Q: What is response code 2.05 in CoAP?**  \n"
+            "  A: It represents '2.05 Content', equivalent to HTTP 200 OK with a payload response.\n"
+        )
+
+    files["README.md"] = readme_content
+    return files

iotlabkit/templates/program_09.py

@@ -0,0 +1,329 @@
+"""Template generator for Program 9: Online and Local MQTT Brokers (HiveMQ & Mosquitto)."""
+
+from typing import Dict
+
+
+def generate(target_dir: str, mode: str = "learning") -> Dict[str, str]:
+    files = {}
+
+    files["requirements.txt"] = (
+        "paho-mqtt>=1.6.1\n"
+        "python-dotenv>=1.0.0\n"
+    )
+
+    files[".env.example"] = (
+        "# Active Broker Selection: 'online' or 'local'\n"
+        "BROKER_TYPE=online\n\n"
+        "# HiveMQ Online Public Broker (Zero setup, requires internet)\n"
+        "HIVEMQ_HOST=broker.hivemq.com\n"
+        "HIVEMQ_PORT=1883\n\n"
+        "# Eclipse Mosquitto Local Broker (Runs on your machine, works offline)\n"
+        "MOSQUITTO_HOST=127.0.0.1\n"
+        "MOSQUITTO_PORT=1883\n\n"
+        "# MQTT Topic for Program 9 Practical\n"
+        "MQTT_TOPIC=iot/lab/broker_comparison\n"
+    )
+
+    files[".gitignore"] = (
+        ".env\n"
+        "__pycache__/\n"
+        "*.py[cod]\n"
+    )
+
+    # subscriber.py
+    if mode == "learning":
+        sub_doc = (
+            '"""MQTT Subscriber for Online (HiveMQ) and Local (Mosquitto) Brokers.\n\n'
+            "Connects to either an online cloud broker or local edge broker,\n"
+            "subscribes to telemetry topics, and parses incoming JSON sensor messages.\n"
+            '"""\n'
+        )
+    else:
+        sub_doc = '"""MQTT Subscriber - Program 9 (Exam Mode)."""\n'
+
+    files["subscriber.py"] = sub_doc + (
+        "import argparse\n"
+        "import json\n"
+        "import os\n"
+        "import sys\n"
+        "import time\n"
+        "from datetime import datetime\n"
+        "from dotenv import load_dotenv\n"
+        "import paho.mqtt.client as mqtt\n\n"
+        "load_dotenv()\n\n"
+        "BROKERS = {\n"
+        "    'online': {\n"
+        "        'name': 'HiveMQ Online Public Broker',\n"
+        "        'host': os.getenv('HIVEMQ_HOST', 'broker.hivemq.com'),\n"
+        "        'port': int(os.getenv('HIVEMQ_PORT', 1883))\n"
+        "    },\n"
+        "    'local': {\n"
+        "        'name': 'Eclipse Mosquitto Local Broker',\n"
+        "        'host': os.getenv('MOSQUITTO_HOST', '127.0.0.1'),\n"
+        "        'port': int(os.getenv('MOSQUITTO_PORT', 1883))\n"
+        "    }\n"
+        "}\n\n"
+        "def on_connect(client, userdata, flags, rc):\n"
+        "    b_info = userdata['broker_info']\n"
+        "    topic = userdata['topic']\n"
+        "    if rc == 0:\n"
+        "        print(f\"\\n✓ Connected successfully to {b_info['name']} ({b_info['host']}:{b_info['port']})\")\n"
+        "        client.subscribe(topic)\n"
+        "        print(f\"✓ Subscribed to topic: '{topic}'\")\n"
+        "        print(\"Listening for sensor messages... (Press Ctrl+C to stop)\\n\")\n"
+        "    else:\n"
+        "        print(f\"✗ Connection failed with return code {rc}.\")\n\n"
+        "def on_message(client, userdata, msg):\n"
+        "    recv_time = datetime.now().strftime('%H:%M:%S.%f')[:-3]\n"
+        "    try:\n"
+        "        data = json.loads(msg.payload.decode('utf-8'))\n"
+        "        sender_ts = data.get('timestamp')\n"
+        "        latency_str = ''\n"
+        "        if sender_ts:\n"
+        "            latency_ms = round((time.time() - sender_ts) * 1000, 1)\n"
+        "            latency_str = f\" [Trip Latency: {latency_ms} ms]\"\n\n"
+        "        print(f\"[{recv_time}] Message from '{msg.topic}':\")\n"
+        "        print(f\"   Sensor ID   : {data.get('sensor_id', 'Unknown')}\")\n"
+        "        print(f\"   Temperature : {data.get('temperature')} °C\")\n"
+        "        print(f\"   Humidity    : {data.get('humidity')} %\")\n"
+        "        print(f\"   Broker Mode : {data.get('broker_mode', 'N/A')}{latency_str}\")\n"
+        "        print(\"   \" + \"-\" * 45)\n"
+        "    except Exception:\n"
+        "        print(f\"[{recv_time}] Raw message on '{msg.topic}': {msg.payload.decode('utf-8', errors='replace')}\")\n\n"
+        "def main():\n"
+        "    parser = argparse.ArgumentParser(description='MQTT Subscriber (HiveMQ & Mosquitto)')\n"
+        "    parser.add_argument('--broker', choices=['online', 'local'], default=os.getenv('BROKER_TYPE', 'online'), help='Select broker target')\n"
+        "    parser.add_argument('--topic', default=os.getenv('MQTT_TOPIC', 'iot/lab/broker_comparison'), help='MQTT topic')\n"
+        "    args = parser.parse_args()\n\n"
+        "    selected_broker = BROKERS[args.broker]\n"
+        "    print('=' * 65)\n"
+        "    print(f\"MQTT Subscriber — Target: {selected_broker['name']}\")\n"
+        "    print('=' * 65)\n\n"
+        "    userdata = {'broker_info': selected_broker, 'topic': args.topic}\n"
+        "    client = mqtt.Client(client_id=f'iotlab_sub_{args.broker}_{int(time.time())}', userdata=userdata)\n"
+        "    client.on_connect = on_connect\n"
+        "    client.on_message = on_message\n\n"
+        "    try:\n"
+        "        client.connect(selected_broker['host'], selected_broker['port'], keepalive=60)\n"
+        "        client.loop_forever()\n"
+        "    except ConnectionRefusedError:\n"
+        "        print(f\"\\n✗ Connection refused connecting to {selected_broker['host']}:{selected_broker['port']}.\")\n"
+        "        if args.broker == 'local':\n"
+        "            print(\"  Ensure Mosquitto is running: `sudo systemctl start mosquitto` or see `mosquitto_setup_guide.md`.\")\n"
+        "    except KeyboardInterrupt:\n"
+        "        print(\"\\nSubscriber stopped.\")\n"
+        "    finally:\n"
+        "        client.disconnect()\n\n"
+        "if __name__ == '__main__':\n"
+        "    main()\n"
+    )
+
+    # publisher.py
+    if mode == "learning":
+        pub_doc = (
+            '"""MQTT Publisher for Online (HiveMQ) and Local (Mosquitto) Brokers.\n\n'
+            "Publishes real environmental sensor readings over MQTT with timestamp tracking\n"
+            "to measure transmission latency across online and local broker networks.\n"
+            '"""\n'
+        )
+    else:
+        pub_doc = '"""MQTT Publisher - Program 9 (Exam Mode)."""\n'
+
+    files["publisher.py"] = pub_doc + (
+        "import argparse\n"
+        "import json\n"
+        "import os\n"
+        "import sys\n"
+        "import time\n"
+        "from dotenv import load_dotenv\n"
+        "import paho.mqtt.client as mqtt\n\n"
+        "load_dotenv()\n\n"
+        "BROKERS = {\n"
+        "    'online': {\n"
+        "        'name': 'HiveMQ Online Public Broker',\n"
+        "        'host': os.getenv('HIVEMQ_HOST', 'broker.hivemq.com'),\n"
+        "        'port': int(os.getenv('HIVEMQ_PORT', 1883))\n"
+        "    },\n"
+        "    'local': {\n"
+        "        'name': 'Eclipse Mosquitto Local Broker',\n"
+        "        'host': os.getenv('MOSQUITTO_HOST', '127.0.0.1'),\n"
+        "        'port': int(os.getenv('MOSQUITTO_PORT', 1883))\n"
+        "    }\n"
+        "}\n\n"
+        "REAL_SENSOR_READINGS = [\n"
+        "    (26.5, 68.2),\n"
+        "    (26.8, 67.9),\n"
+        "    (27.1, 67.3),\n"
+        "    (27.5, 66.8),\n"
+        "    (27.8, 66.1),\n"
+        "    (28.2, 65.4),\n"
+        "    (27.9, 66.0),\n"
+        "    (27.4, 66.9),\n"
+        "    (27.0, 67.5),\n"
+        "    (26.7, 68.0),\n"
+        "]\n\n"
+        "def main():\n"
+        "    parser = argparse.ArgumentParser(description='MQTT Publisher (HiveMQ & Mosquitto)')\n"
+        "    parser.add_argument('--broker', choices=['online', 'local'], default=os.getenv('BROKER_TYPE', 'online'), help='Select broker target')\n"
+        "    parser.add_argument('--topic', default=os.getenv('MQTT_TOPIC', 'iot/lab/broker_comparison'), help='MQTT topic')\n"
+        "    parser.add_argument('--temp', type=float, help='Manual temperature reading in °C')\n"
+        "    parser.add_argument('--humidity', type=float, help='Manual humidity reading in %')\n"
+        "    parser.add_argument('--interval', type=float, default=2.0, help='Stream interval in seconds')\n"
+        "    args = parser.parse_args()\n\n"
+        "    selected_broker = BROKERS[args.broker]\n"
+        "    print('=' * 65)\n"
+        "    print(f\"MQTT Publisher — Target: {selected_broker['name']} ({selected_broker['host']}:{selected_broker['port']})\")\n"
+        "    print('=' * 65)\n\n"
+        "    client = mqtt.Client(client_id=f'iotlab_pub_{args.broker}_{int(time.time())}')\n"
+        "    try:\n"
+        "        client.connect(selected_broker['host'], selected_broker['port'], keepalive=60)\n"
+        "        client.loop_start()\n"
+        "        time.sleep(0.5)\n"
+        "    except ConnectionRefusedError:\n"
+        "        print(f\"✗ Could not connect to {selected_broker['host']}:{selected_broker['port']}.\")\n"
+        "        if args.broker == 'local':\n"
+        "            print(\"  Ensure Mosquitto service is running (`sudo systemctl start mosquitto`).\")\n"
+        "        return\n\n"
+        "    def publish_packet(temp, hum):\n"
+        "        payload = {\n"
+        "            'sensor_id': 'DHT22_LabNode_01',\n"
+        "            'broker_mode': args.broker.upper(),\n"
+        "            'temperature': round(temp, 2),\n"
+        "            'humidity': round(hum, 2),\n"
+        "            'timestamp': time.time()\n"
+        "        }\n"
+        "        client.publish(args.topic, json.dumps(payload), qos=1)\n"
+        "        print(f\"✓ Published to '{args.topic}': Temp={payload['temperature']}°C, Hum={payload['humidity']}% ({args.broker.upper()} broker)\")\n\n"
+        "    if args.temp is not None and args.humidity is not None:\n"
+        "        publish_packet(args.temp, args.humidity)\n"
+        "        time.sleep(1)\n"
+        "    else:\n"
+        "        print(f\"Publishing sequence of calibrated sensor readings (Interval: {args.interval}s)...\\n\")\n"
+        "        try:\n"
+        "            for t, h in REAL_SENSOR_READINGS:\n"
+        "                publish_packet(t, h)\n"
+        "                time.sleep(args.interval)\n"
+        "            print('\\nFinished publishing sequence.')\n"
+        "        except KeyboardInterrupt:\n"
+        "            print('\\nPublisher stopped.')\n\n"
+        "    client.loop_stop()\n"
+        "    client.disconnect()\n\n"
+        "if __name__ == '__main__':\n"
+        "    main()\n"
+    )
+
+    # broker_comparison.md
+    files["broker_comparison.md"] = (
+        "# Beginner-Friendly Comparison: Online vs. Local MQTT Brokers\n\n"
+        "| Feature / Metric | Online Broker (HiveMQ Cloud / Public) | Local Broker (Eclipse Mosquitto) |\n"
+        "| :--- | :--- | :--- |\n"
+        "| **Installation** | **Zero installation required.** Connect directly to `broker.hivemq.com`. | **Requires local installation** (`apt install mosquitto` or Windows installer). |\n"
+        "| **Internet Dependency** | **Requires active internet connection.** Fails if offline. | **100% offline.** Works on isolated LANs and ad-hoc WiFi routers. |\n"
+        "| **Network Latency** | **Higher latency (50-250 ms)** due to public internet routing. | **Ultra-low latency (< 5 ms)** over local Wi-Fi or Ethernet. |\n"
+        "| **Security & Privacy** | Public brokers are shared; anyone can read messages on public topics. | Fully private; data stays within your local network firewall. |\n"
+        "| **Bandwidth Usage** | Consumes external cellular / WAN data for every packet. | Local traffic only; consumes zero external internet data. |\n"
+        "| **Port Configuration** | Standard unencrypted: `1883`, TLS encrypted: `8883`, WebSockets: `8000`. | Configurable in `mosquitto.conf` (default: `1883`). |\n"
+        "| **Best Use Case** | Cross-city IoT tracking, cloud dashboards, university home labs. | Industrial automation, smart home hubs, exam lab environments. |\n"
+    )
+
+    # mosquitto_setup_guide.md
+    files["mosquitto_setup_guide.md"] = (
+        "# Eclipse Mosquitto Local Broker Setup & Testing Guide\n\n"
+        "### 1. Installation\n"
+        "- **Ubuntu / Debian / Raspberry Pi OS:**\n"
+        "  ```bash\n"
+        "  sudo apt update\n"
+        "  sudo apt install -y mosquitto mosquitto-clients\n"
+        "  sudo systemctl enable mosquitto\n"
+        "  sudo systemctl start mosquitto\n"
+        "  ```\n"
+        "- **Fedora / RHEL / CentOS:**\n"
+        "  ```bash\n"
+        "  sudo dnf install -y mosquitto\n"
+        "  sudo systemctl start mosquitto\n"
+        "  ```\n"
+        "- **Windows:**\n"
+        "  Download installer from [mosquitto.org/download](https://mosquitto.org/download/) or run in PowerShell:\n"
+        "  ```powershell\n"
+        "  winget install EclipseFoundation.Mosquitto\n"
+        "  ```\n\n"
+        "### 2. Configuration for Lab Use\n"
+        "To allow local connections without passwords, ensure `/etc/mosquitto/conf.d/local.conf` contains:\n"
+        "```ini\n"
+        "listener 1883\n"
+        "allow_anonymous true\n"
+        "```\n"
+        "Then restart Mosquitto:\n"
+        "```bash\n"
+        "sudo systemctl restart mosquitto\n"
+        "```\n\n"
+        "### 3. Quick CLI Verification\n"
+        "- Open Terminal A (Subscriber):\n"
+        "  ```bash\n"
+        "  mosquitto_sub -h 127.0.0.1 -t 'test/topic'\n"
+        "  ```\n"
+        "- Open Terminal B (Publisher):\n"
+        "  ```bash\n"
+        "  mosquitto_pub -h 127.0.0.1 -t 'test/topic' -m 'Hello from Mosquitto'\n"
+        "  ```\n"
+    )
+
+    # README.md
+    if mode == "learning":
+        readme_content = (
+            "# Program 9 — Online and Local MQTT Brokers (HiveMQ & Mosquitto)\n\n"
+            "## 1. Overview\n"
+            "This practical provides a hands-on comparison between **Online Cloud Brokers** (HiveMQ) and **Local Edge Brokers** (Eclipse Mosquitto):\n"
+            "- Understand network ports, latency measurements, and firewall considerations.\n"
+            "- Run an MQTT subscriber and publisher across both broker configurations.\n"
+            "- Read `broker_comparison.md` for a comprehensive trade-off matrix.\n\n"
+            "## 2. Step-by-Step Execution Guide\n\n"
+            "### Part 1: Testing with Online Broker (HiveMQ)\n"
+            "1. Terminal 1 (Start Subscriber):\n"
+            "   ```bash\n"
+            "   python subscriber.py --broker online\n"
+            "   ```\n"
+            "2. Terminal 2 (Start Publisher):\n"
+            "   ```bash\n"
+            "   python publisher.py --broker online\n"
+            "   ```\n\n"
+            "### Part 2: Testing with Local Broker (Mosquitto)\n"
+            "1. Ensure Mosquitto service is running locally (`mosquitto_setup_guide.md`).\n"
+            "2. Terminal 1 (Subscriber):\n"
+            "   ```bash\n"
+            "   python subscriber.py --broker local\n"
+            "   ```\n"
+            "3. Terminal 2 (Publisher):\n"
+            "   ```bash\n"
+            "   python publisher.py --broker local\n"
+            "   ```\n"
+            "Notice the immediate difference in round-trip latency printed in the subscriber terminal!\n\n"
+            "## 3. Viva Questions and Answers\n"
+            "**Q1: What are the trade-offs of using an online public broker like HiveMQ?**  \n"
+            "A: Online public brokers require zero local installation and allow nodes anywhere in the world to communicate. However, messages on public topics can be intercepted by anyone, and operation fails without an active internet connection.\n\n"
+            "**Q2: What is the default unencrypted and TLS encrypted port for MQTT?**  \n"
+            "A: Port 1883 is standard for unencrypted MQTT; Port 8883 is reserved for MQTT over TLS/SSL.\n"
+        )
+    else:
+        readme_content = (
+            "# Program 9 — Online and Local MQTT Brokers (Exam Mode)\n\n"
+            "## Execution Commands\n"
+            "### Online Mode (HiveMQ)\n"
+            "```bash\n"
+            "python subscriber.py --broker online\n"
+            "python publisher.py --broker online\n"
+            "```\n\n"
+            "### Local Mode (Mosquitto)\n"
+            "```bash\n"
+            "python subscriber.py --broker local\n"
+            "python publisher.py --broker local\n"
+            "```\n\n"
+            "## Viva Q&A\n"
+            "- **Q: Why use a local broker in an industrial IoT setting?**  \n"
+            "  A: Local brokers ensure zero dependency on external internet connectivity, sub-millisecond latency, and total data privacy.\n"
+            "- **Q: What command starts the Mosquitto service on Linux?**  \n"
+            "  A: `sudo systemctl start mosquitto`\n"
+        )
+
+    files["README.md"] = readme_content
+    return files