Source code for OzWrapper.OzOGS.OzOGS_Allocation

"""Standalone factory allocation harness for the OGS array.

Boots an instance of :class:`OzWrapper.OzOGS.OzOGS.OzOGS` outside the
main Sensor orchestrator, drives one reading cycle at a time on demand
via MQTT control topics on ``broker.hivemq.com``, and reflects state on
the front-panel RGB LED through :class:`OzWrapper.OzRGB.OzRGB`. Used on
the factory bench when commissioning a new gas-sensor board and
producing the slot-to-gas allocation map that the runtime configuration
will eventually carry.

MQTT topics:
    * ``/ogs/start`` (sub) - trigger one read+publish cycle.
    * ``/ogs/restart`` (sub) - reinitialise the OGS wrapper.
    * ``/ogs/ledstatus`` (pub) - human-readable status string.
    * ``/ogs/data`` (pub) - averaged readings as JSON.

Example:
    >>> import OzWrapper.OzOGS.OzOGS_Allocation  # doctest: +SKIP

Note:
    Reads its OGS configuration from ``allocation_ogs.json`` co-located
    with this module. See :mod:`OzWrapper.OzOGS.OzOGS` for the sensor
    wrapper contract this script drives, and the same module's
    reference JSON for the expected ``ogs`` configuration shape.
"""

import json
import os

import paho.mqtt.client as paho

from drivers.MCP230XX import MCP230XX
from OzWrapper.OzOGS import OzOGS

flagStart = False
restartFlag = True
# ledstatusFlag = True

import threading
from queue import Queue

from OzWrapper.OzRGB import OzRGB




def on_subscribe(client, userdata, mid, granted_qos):
    """Log MQTT subscription acknowledgements from the broker.

    Standard ``paho.mqtt`` ``on_subscribe`` callback signature; emits
    a single ``Subscribed: <mid> <qos>`` line so the operator can
    confirm that ``/ogs/start`` and ``/ogs/restart`` are wired up.

    Args:
        client: The :class:`paho.mqtt.client.Client` instance.
        userdata: User-defined data set on the client (unused).
        mid (int): Message ID of the subscribe request.
        granted_qos (list[int]): QoS levels granted per topic by the
            broker.

    Returns:
        None: Side effect only - prints to stdout.

    Raises:
        None: All work is a single print call.

    Example:
        >>> on_subscribe(client, None, 1, [1])  # doctest: +SKIP

    Note:
        Wired up at module import time on the global ``client``.
    """
    print("Subscribed: " + str(mid) + " " + str(granted_qos))





def on_message(client, userdata, msg):
    """Route incoming MQTT control messages into the allocation loop.

    Sets the module-global flags consumed by the main loop in
    ``__main__``:

        * ``/ogs/start`` -> ``flagStart = True`` (triggers one read+publish).
        * ``/ogs/restart`` -> ``restartFlag = True`` (reinitialises
          :class:`OzWrapper.OzOGS.OzOGS.OzOGS`).

    Args:
        client: The :class:`paho.mqtt.client.Client` instance.
        userdata: User-defined data set on the client (unused).
        msg (paho.mqtt.client.MQTTMessage): Incoming message; ``topic``,
            ``qos`` and ``payload`` are inspected. The payload itself is
            ignored for routing - only ``topic`` matters.

    Returns:
        None: Mutates module-level flags.

    Raises:
        None: All branches are simple flag assignments.

    Example:
        >>> client.publish("/ogs/start", "")  # doctest: +SKIP

    Note:
        The ``/ogs/ledstatus`` branch is intentionally commented out
        because the LED status flag is now driven by the main loop
        directly, not by an external trigger.
    """
    print(msg.topic + " " + str(msg.qos) + " " + str(msg.payload))
    if msg.topic == "/ogs/start":
        print("start")
        global flagStart
        flagStart = True
    elif msg.topic == "/ogs/restart":
        print("restart")
        global restartFlag
        restartFlag = True

    # elif msg.topic == "/ogs/ledstatus":
    #     global ledstatusFlag
    #     ledstatusFlag = True


client = paho.Client()
client.on_subscribe = on_subscribe
client.on_message = on_message
client.connect("broker.hivemq.com", 1883)
client.subscribe("/ogs/start", qos=1)
client.subscribe("/ogs/restart", qos=1)
# client.subscribe("/ogs/ledstatus", qos=1)
client.loop_start()


# Example code
# python3 -m OzWrapper.OzOGS.OzOGS
if __name__ == "__main__":
    network_status = Queue(2)
    network_status.put(0)  # 0-th element
    network_status.put(0)  # 1st Element
    Led_rgb = OzRGB
    MCP = MCP230XX(devicenumber=os.getenv("MCP_ID", 6))
    led_Thread = threading.Thread(target=Led_rgb.main, args=(None, network_status), daemon=True)
    led_Thread.start()
    network_status.queue[0] = 7  # neon orange
    dirname = os.path.dirname(__file__)
    file_name = os.path.join(dirname, "allocation_ogs.json")
    with open(file_name) as ogsConfigFile:
        data = ogsConfigFile.read()
    ogsConfig = json.loads(data)
    print(ogsConfig)
    ogs = None
    while True:
        network_status.queue[0] = 2  # Blue pattern slow blink in idle condition
        LED_Status = ""
        if restartFlag == True:
            ogs = None
            network_status.queue[0] = 7  # neon orange
            LED_Status = ""
            LED_Status = "OGS init started"
            client.publish("/ogs/ledstatus", LED_Status)
            ogs = OzOGS()
            init_value = {}
            ogs.initialize(ogsConfig["ogs"], init_value)
            restartFlag = False
            LED_Status = "Idle Condition"
            client.publish("/ogs/ledstatus", LED_Status)

        if flagStart == True:
            LED_Status = ""
            LED_Status = "OGS read started"
            client.publish("/ogs/ledstatus", LED_Status)
            if flagStart:
                network_status.queue[0] = 1  # cyan, pattern_fade, while reading data from ADS-UART
                print("Reading start \n\n")
                for i in range(0, 3):
                    ogs.getSensorReading()
                network_status.queue[0] = 3  # magenta, pattern_fade while uploading data
                data = {}
                print("PutSensor value start \n\n")
                ogs.putSensorValue(data)
                for key in list(data):
                    data.update({key: round(sum(data[key]) / len(data[key]), 2)})
                print(data)
                flagStart = False
                client.publish("/ogs/data", json.dumps(data))
                LED_Status = "Idle Condition"
                client.publish("/ogs/ledstatus", LED_Status)

        # if ledstatusFlag==True:
        #     client.publish('/ogs/ledstatus', LED_Status)
        #     ledstatusFlag = False