Kaa Over-the-Air (OTA) Implementation with Python

import paho.mqtt.client as mqtt
import json
import random 
import time
import requests

# MQTT server details
# Provide 'app_version' and 'token' with your values
app_version = "<your-app-version>"
token = "<your-endpoint-token>"
mqtt_server = "mqtt.cloud.kaaiot.com"
mqtt_port = 1883
request_id = 1

# Endpoint MQTT topics
publish_topic = f"kp1/{app_version}/dcx/{token}/json/{request_id}"
response_topic = f"kp1/{app_version}/dcx/{token}/json/{request_id}/status"
error_topic = f"kp1/{app_version}/dcx/{token}/json/{request_id}/error"

# Ota MQTT topics
ota_response_topic = f"kp1/{app_version}/cmx_ota/{token}/config/json/{request_id}/status"
ota_error_topic = f"kp1/{app_version}/cmx_ota/{token}/config/json/{request_id}/error"

# Firmware details
current_version = "1.0.0"
time_sleep = 5
file_name = "file.txt"

# Callback when connected to MQTT server
def on_connect(client, userdata, flags, rc):
    print("Connected with result code " + str(rc))
    client.subscribe(response_topic)
    client.subscribe(error_topic)
    client.subscribe(ota_response_topic)
    client.subscribe(ota_error_topic)

# Callback when a message is received
def on_message(client, userdata, msg):
    topic = msg.topic
    payload = msg.payload.decode()
    print(f"\n//-----Message received on topic {topic}: {payload}")
    print(f"Current firmware version: {current_version}\n")
    if f"kp1/{app_version}/cmx_ota/{token}" in topic:
        handle_update(payload)

    client_loop(client)
    print("-----//\n")

def handle_update(payload):
    try:
        # Parse the JSON payload
        update_data = json.loads(payload)
        print("Update Data:", update_data)

        # Confirm that the payload is valid
        status_code = update_data.get("statusCode")

        if status_code != 200:
            reason_phrase = update_data.get("reasonPhrase", "No reason provided")
            print(f"Firmware message's status code is not 200, but: {status_code}")
            print(f"Response: {reason_phrase}")
            return
        
        # Check if the current version is up-to-date
        new_version = update_data.get("configId")

        print(f"Current version: {current_version}")
        print(f"Latest version: {new_version}")

        if new_version == current_version:
            print("Current version is up to date. Skipping...")
            return

        # Extract the firmware download link
        system_file_link = update_data["config"]["system"].get("files", [None])[0]
        download_link = update_data["config"].get("link")
        firmware_link = system_file_link or download_link or ""

        print(f"firmwareLink: {firmware_link}")

        # Download the file
        download_and_apply_update(firmware_link, file_name, new_version)
    except json.JSONDecodeError:
        print("Failed to parse JSON payload.")
    except KeyError as e:
        print(f"Missing expected key: {e}")

# Download the new version of the file
def download_and_apply_update(script_url, save_path, new_version):
    response = requests.get(script_url)
    
    if response.status_code == 200:
        global current_version
        
        # Update version number
        print(f"Updated current version from {current_version} to {new_version}")
        current_version = new_version

        # Apply your custom changes here    
        # Just save the updated file
        with open(save_path, "wb") as file:
            file.write(response.content)
        print(f"Updated file downloaded to {save_path}")
    else:
        print("Failed to download the new script.")  

# Report current firmware version
def report_current_firmware_version():
    report_topic = f"kp1/{app_version}/cmx_ota/{token}/applied/json"
    report_payload = json.dumps({"configId": current_version})
    print(f"Reporting current firmware version on topic: {report_topic} and payload: {report_payload}")
    client.publish(report_topic, report_payload)

# Request new version from Kaa
def request_new_firmware():
    request_id = random.randint(0, 99)  # Generate a random request ID to avoid conflicts
    firmware_request_topic = f"kp1/{app_version}/cmx_ota/{token}/config/json/{request_id}"
    print(f"Requesting firmware using topic: {firmware_request_topic}")
    client.publish(firmware_request_topic, json.dumps({"observe": True}))

# Handle infinite loop, to continuously check the firmware version from Kaa
def client_loop(client):
    time.sleep(time_sleep)

    # Maintain connection with Kaa endpoint
    payload = {}
    print(f"Publishing new data to Kaa: {payload}\n")
    client.publish(publish_topic, json.dumps(payload))

    # Check new version of the firmware
    report_current_firmware_version()
    request_new_firmware()

# Setup MQTT client
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect(mqtt_server, mqtt_port, 60)

# Publishing to Kaa to get response and start the program
client.publish(publish_topic, json.dumps({}))
client.loop_forever()

import itertools
import json
import queue
import random
import string
import sys
import time

import paho.mqtt.client as mqtt

KPC_HOST = "mqtt.cloud.kaaiot.com"  # Kaa Cloud plain MQTT host
KPC_PORT = 1883                     # Kaa Cloud plain MQTT port

CURRENT_SOFTWARE_VERSION = ""   # Specify software that device currently uses (e.g., 0.0.1)

APPLICATION_VERSION = ""     # Paste your application version
ENDPOINT_TOKEN = ""          # Paste your endpoint token


class SoftwareClient:

    def __init__(self, client):
        self.client = client
        self.software_by_request_id = {}
        self.global_request_id = itertools.count()
        get_software_topic = f'kp1/{APPLICATION_VERSION}/cmx_ota/{ENDPOINT_TOKEN}/config/json/#'
        self.client.message_callback_add(get_software_topic, self.handle_software)

    def handle_software(self, client, userdata, message):
        if message.topic.split('/')[-1] == 'status':
            topic_part = message.topic.split('/')[-2]
            if topic_part.isnumeric():
                request_id = int(topic_part)
                print(f'<--- Received software response on topic {message.topic}')
                software_queue = self.software_by_request_id[request_id]
                software_queue.put_nowait(message.payload)
            else:
                print(f'<--- Received software push on topic {message.topic}:\n{str(message.payload.decode("utf-8"))}')
        else:
            print(f'<--- Received bad software response on topic {message.topic}:\n{str(message.payload.decode("utf-8"))}')

    def get_software(self):
        request_id = next(self.global_request_id)
        get_software_topic = f'kp1/{APPLICATION_VERSION}/cmx_ota/{ENDPOINT_TOKEN}/config/json/{request_id}'

        software_queue = queue.Queue()
        self.software_by_request_id[request_id] = software_queue

        print(f'---> Requesting software by topic {get_software_topic}')
        payload = {
            "configId": CURRENT_SOFTWARE_VERSION
        }
        self.client.publish(topic=get_software_topic, payload=json.dumps(payload))

        try:
            software = software_queue.get(True, 5)
            del self.software_by_request_id[request_id]
            return str(software.decode("utf-8"))
        except queue.Empty:
            print('Timed out waiting for software response from server')
            sys.exit()

def main():
    # Initiate server connection
    print(f'Connecting to Kaa server at {KPC_HOST}:{KPC_PORT} using application version {APPLICATION_VERSION} and endpoint token {ENDPOINT_TOKEN}')

    client_id = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
    client = mqtt.Client(client_id=client_id)
    client.connect(KPC_HOST, KPC_PORT, 60)
    client.loop_start()

    software_client = SoftwareClient(client)

    # Fetch available software
    retrieved_software = software_client.get_software()
    print(f'Retrieved software from server: {retrieved_software}')

    time.sleep(5)
    client.disconnect()


if __name__ == '__main__':
    main()