micrOSDevToolKit 2.13.1__py3-none-any.whl → 2.17.0__py3-none-any.whl

toolkit/simulator_lib/mqtt_as/clean.py

@@ -0,0 +1,69 @@
+# clean.py Test of asynchronous mqtt client with clean session.
+# (C) Copyright Peter Hinch 2017-2019.
+# Released under the MIT licence.
+
+# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
+
+# The use of clean_session means that after a connection failure subscriptions
+# must be renewed (MQTT spec 3.1.2.4). This is done by the connect handler.
+# Note that publications issued during the outage will be missed. If this is
+# an issue see unclean.py.
+
+# red LED: ON == WiFi fail
+# blue LED heartbeat: demonstrates scheduler is running.
+
+from mqtt_as import MQTTClient
+from mqtt_local import wifi_led, blue_led, config
+import uasyncio as asyncio
+
+# Subscription callback
+def sub_cb(topic, msg, retained):
+    print(f'Topic: "{topic.decode()}" Message: "{msg.decode()}" Retained: {retained}')
+
+# Demonstrate scheduler is operational.
+async def heartbeat():
+    s = True
+    while True:
+        await asyncio.sleep_ms(500)
+        blue_led(s)
+        s = not s
+
+async def wifi_han(state):
+    wifi_led(not state)
+    print('Wifi is ', 'up' if state else 'down')
+    await asyncio.sleep(1)
+
+# If you connect with clean_session True, must re-subscribe (MQTT spec 3.1.2.4)
+async def conn_han(client):
+    await client.subscribe('foo_topic', 1)
+
+async def main(client):
+    try:
+        await client.connect()
+    except OSError:
+        print('Connection failed.')
+        return
+    n = 0
+    while True:
+        await asyncio.sleep(5)
+        print('publish', n)
+        # If WiFi is down the following will pause for the duration.
+        await client.publish('result', '{} {}'.format(n, client.REPUB_COUNT), qos = 1)
+        n += 1
+
+# Define configuration
+config['subs_cb'] = sub_cb
+config['wifi_coro'] = wifi_han
+config['connect_coro'] = conn_han
+config['clean'] = True
+
+# Set up client
+MQTTClient.DEBUG = True  # Optional
+client = MQTTClient(config)
+
+asyncio.create_task(heartbeat())
+try:
+    asyncio.run(main(client))
+finally:
+    client.close()  # Prevent LmacRxBlk:1 errors
+    asyncio.new_event_loop()

toolkit/simulator_lib/mqtt_as/mqtt_v5_properties.py

@@ -0,0 +1,239 @@
+# mqtt_v5_properties.py Add MQTT V5 extensions to mqtt_as
+
+# (C) Copyright Bob Veringa 2024-2025.
+# Released under the MIT licence.
+
+
+import struct
+
+
+def encode_byte(value):
+    # It takes in a byte and returns a byte
+    return value
+
+
+def encode_two_byte_int(value):
+    return struct.pack("!H", value)
+
+
+def encode_four_byte_int(value):
+    return struct.pack("!I", value)
+
+
+def encode_string(value):
+    value = value.encode("utf-8")
+    return struct.pack("!H", len(value)) + value
+
+
+def encode_string_pair(value):
+    # just get the first key and value
+    key, value = list(value.items())[0]
+    return encode_string(key) + encode_string(value)
+
+
+def encode_binary(value):
+    return struct.pack("!H", len(value)) + value
+
+
+def encode_variable_byte_int(value):
+    out = bytearray(4)
+    i = 0
+    for i in range(4):
+        b = value & 0x7F
+        value >>= 7
+        if value > 0:
+            b |= 0x80
+        out[i] = b
+        if value == 0:
+            break
+    return out[: i + 1]
+
+
+# This table does not contain all properties (unlike the decode table)
+# as not all properties can be sent by the client.
+ENCODE_TABLE = {
+    0x01: encode_byte,  # Payload Format Indicator
+    0x02: encode_four_byte_int,  # Message Expiry Interval
+    0x03: encode_string,  # Content Type
+    0x08: encode_string,  # Response Topic
+    0x09: encode_binary,  # Correlation Data
+    0x0B: encode_variable_byte_int,  # Subscription Identifier
+    0x11: encode_four_byte_int,  # Session Expiry Interval
+    0x15: encode_string,  # Authentication Method
+    0x16: encode_binary,  # Authentication Data
+    0x17: encode_byte,  # Request Problem Information
+    0x18: encode_four_byte_int,  # Will Delay Interval
+    0x19: encode_byte,  # Request Response Information
+    0x1C: encode_string,  # Server Reference
+    0x1F: encode_string,  # Reason String
+    0x21: encode_two_byte_int,  # Receive Maximum
+    0x22: encode_two_byte_int,  # Topic Alias Maximum
+    0x23: encode_two_byte_int,  # Topic Alias
+    0x26: encode_string_pair,  # User Property
+    0x27: encode_four_byte_int,  # Maximum Packet Size
+}
+
+
+# MQTT_base class. Handles MQTT protocol on the basis of a good connection.
+# Exceptions from connectivity failures are handled by MQTTClient subclass.
+def encode_properties(properties: dict):
+    # If properties are empty or None, we can just return a single byte (0)
+    if properties in (None, {}):
+        return bytes(1)
+
+    # We can't modify the properties dict, as user might want to use it later
+    # So we will create a new dict with the encoded values.
+    # This causes a slight increase in memory usage. But this is acceptable.
+    pre_encoded_properties = {}
+
+    # We keep track of the length of the properties
+    properties_length = 0
+
+    # Preprocess properties to encode everything as bytes.
+    for key, value in properties.items():
+        encode_func = ENCODE_TABLE.get(key)
+        if encode_func is None:
+            # We can just leave that data as is and assume that it is valid.
+            tmp_value = value
+        else:
+            tmp_value = encode_func(value)
+        pre_encoded_properties[key] = tmp_value
+
+        # Pre-calculate the length of the properties
+        properties_length += 1  # key
+        properties_length += len(tmp_value)
+
+    # Mark properties as deleted
+    del properties
+
+    variable_length = 1
+    if properties_length > 127:
+        variable_length += 1
+    if properties_length > 16383:
+        variable_length += 1
+    if properties_length > 2097151:
+        variable_length += 1
+
+    # Now we can allocate the byte array
+    properties_bytes = bytearray(variable_length + properties_length)
+    view = memoryview(properties_bytes)
+
+    i = 0
+    while properties_length > 0x7F:
+        view[i] = (properties_length & 0x7F) | 0x80
+        properties_length >>= 7
+        i += 1
+
+    view[i] = properties_length
+    i += 1
+
+    for key, value in pre_encoded_properties.items():
+        view[i] = key
+        i += 1
+        view[i : i + len(value)] = value
+        i += len(value)
+
+    return properties_bytes
+
+
+def decode_byte(props, offset):
+    value = props[offset]
+    offset += 1
+    return value, offset
+
+
+def decode_two_byte_int(props, offset):
+    value = struct.unpack_from("!H", props, offset)[0]
+    offset += 2
+    return value, offset
+
+
+def decode_four_byte_int(props, offset):
+    value = struct.unpack_from("!I", props, offset)[0]
+    offset += 4
+    return value, offset
+
+
+def decode_string(props, offset):
+    str_length = struct.unpack_from("!H", props, offset)[0]
+    offset += 2
+    value = props[offset : offset + str_length].decode("utf-8")
+    offset += str_length
+    return value, offset
+
+
+def decode_string_pair(props, offset):
+    key, offset = decode_string(props, offset)
+    value, offset = decode_string(props, offset)
+    item = {key: value}
+    return item, offset
+
+
+def decode_binary(props, offset):
+    data_length = struct.unpack_from("!H", props, offset)[0]
+    offset += 2
+    value = props[offset : offset + data_length]
+    offset += data_length
+    return value, offset
+
+
+def decode_variable_byte_int(props, offset):
+    value = 0
+    for i in range(4):
+        b = props[offset]
+        value |= (b & 0x7F) << (7 * i)
+        offset += 1
+        if not b & 0x80:
+            break
+    return value, offset
+
+
+decode_property_lookup = {
+    0x01: decode_byte,  # Payload Format Indicator
+    0x02: decode_four_byte_int,  # Message Expiry Interval
+    0x03: decode_string,  # Content Type
+    0x08: decode_string,  # Response Topic
+    0x09: decode_binary,  # Correlation Data
+    0x0B: decode_variable_byte_int,  # Subscription Identifier
+    0x11: decode_four_byte_int,  # Session Expiry Interval
+    0x12: decode_string,  # Assigned Client Identifier
+    0x13: decode_two_byte_int,  # Server Keep Alive
+    0x15: decode_string,  # Authentication Method
+    0x16: decode_binary,  # Authentication Data
+    0x17: decode_byte,  # Request Problem Information
+    0x18: decode_four_byte_int,  # Will Delay Interval
+    0x19: decode_byte,  # Request Response Information
+    0x1A: decode_string,  # Response Information
+    0x1C: decode_string,  # Server Reference
+    0x1F: decode_string,  # Reason String
+    0x21: decode_two_byte_int,  # Receive Maximum
+    0x22: decode_two_byte_int,  # Topic Alias Maximum
+    0x23: decode_two_byte_int,  # Topic Alias
+    0x24: decode_byte,  # Maximum QoS
+    0x25: decode_byte,  # Retain Available
+    0x26: decode_string_pair,  # User Property
+    0x27: decode_four_byte_int,  # Maximum Packet Size
+    0x28: decode_byte,  # Wildcard Subscription Available
+    0x29: decode_byte,  # Subscription Identifiers Available
+    0x2A: decode_byte,  # Shared Subscription Available
+}
+
+
+def decode_properties(props, properties_length):
+    if isinstance(props, memoryview):
+        props = bytes(props)  # If a memoryview is passed, make a copy
+    offset = 0
+    properties = {}
+
+    while offset < properties_length:
+        property_identifier = props[offset]
+        offset += 1
+
+        if property_identifier in decode_property_lookup:
+            decode_function = decode_property_lookup[property_identifier]
+            value, offset = decode_function(props, offset)
+            properties[property_identifier] = value
+        else:
+            raise ValueError(f"Unknown property identifier: {property_identifier}")
+
+    return properties

toolkit/simulator_lib/mqtt_as/range.py

@@ -0,0 +1,90 @@
+# range.py Test of asynchronous mqtt client with clean session False.
+# (C) Copyright Peter Hinch 2017-2024.
+# Released under the MIT licence.
+
+# Now uses the event interface
+
+# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
+
+# This demo is for wireless range tests. If OOR the red WiFi ON LED will go out.
+# In range the blue LED will pulse for each received message.
+# Uses clean sessions to avoid backlog when OOR.
+
+# red LED: ON == WiFi OK
+# blue LED pulse == message received
+# Publishes connection statistics.
+
+from mqtt_as import MQTTClient
+from mqtt_local import wifi_led, blue_led, config
+import uasyncio as asyncio
+
+TOPIC = "shed"  # For demo publication and last will use same topic
+
+outages = 0
+
+
+async def pulse():  # This demo pulses blue LED each time a subscribed msg arrives.
+    blue_led(True)
+    await asyncio.sleep(1)
+    blue_led(False)
+
+
+async def messages(client):
+    async for topic, msg, retained in client.queue:
+        print(f'Topic: "{topic.decode()}" Message: "{msg.decode()}" Retained: {retained}')
+        asyncio.create_task(pulse())
+
+
+async def down(client):
+    global outages
+    while True:
+        await client.down.wait()  # Pause until connectivity changes
+        client.down.clear()
+        wifi_led(False)
+        outages += 1
+        print("WiFi or broker is down.")
+
+
+async def up(client):
+    while True:
+        await client.up.wait()
+        client.up.clear()
+        wifi_led(True)
+        print("We are connected to broker.")
+        await client.subscribe("foo_topic", 1)
+
+
+async def main(client):
+    try:
+        await client.connect(quick=True)
+    except OSError:
+        print("Connection failed.")
+        return
+    for task in (up, down, messages):
+        asyncio.create_task(task(client))
+    n = 0
+    while True:
+        await asyncio.sleep(5)
+        print("publish", n)
+        # If WiFi is down the following will pause for the duration.
+        await client.publish(
+            TOPIC, "{} repubs: {} outages: {}".format(n, client.REPUB_COUNT, outages), qos=1
+        )
+        n += 1
+
+
+# Define configuration
+config["will"] = (TOPIC, "Goodbye cruel world!", False, 0)
+config["keepalive"] = 120
+config["queue_len"] = 1  # Use event interface with default queue
+
+# Set up client. Enable optional debug statements.
+MQTTClient.DEBUG = True
+client = MQTTClient(config)
+
+try:
+    asyncio.run(main(client))
+finally:  # Prevent LmacRxBlk:1 errors.
+    client.close()
+    blue_led(True)
+    asyncio.new_event_loop()

toolkit/simulator_lib/mqtt_as/range_ex.py

@@ -0,0 +1,119 @@
+# range_ex.py Test of asynchronous mqtt client with clean session False.
+# Extended version publishes SSID
+# (C) Copyright Peter Hinch 2017-2024.
+# Released under the MIT licence.
+
+# Now uses the event interface
+
+# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
+
+# This demo is for wireless range tests. If OOR the red LED will light.
+# In range the blue LED will pulse for each received message.
+# Uses clean sessions to avoid backlog when OOR.
+
+# red LED: ON == WiFi fail
+# blue LED pulse == message received
+# Publishes connection statistics.
+
+from mqtt_as import MQTTClient, RP2
+
+if RP2:
+    from sys import implementation
+from mqtt_local import wifi_led, blue_led, config
+import uasyncio as asyncio
+import network
+import gc
+
+TOPIC = "shed"  # For demo publication and last will use same topic
+
+outages = 0
+rssi = -199  # Effectively zero signal in dB.
+
+
+async def pulse():  # This demo pulses blue LED each time a subscribed msg arrives.
+    blue_led(True)
+    await asyncio.sleep(1)
+    blue_led(False)
+
+
+# The only way to measure RSSI is via scan(). Alas scan() blocks so the code
+# causes the obvious uasyncio issues.
+async def get_rssi():
+    global rssi
+    s = network.WLAN()
+    ssid = config["ssid"].encode("UTF8")
+    while True:
+        try:
+            rssi = [x[3] for x in s.scan() if x[0] == ssid][0]
+        except IndexError:  # ssid not found.
+            rssi = -199
+        await asyncio.sleep(30)
+
+
+async def messages(client):
+    async for topic, msg, retained in client.queue:
+        print(f'Topic: "{topic.decode()}" Message: "{msg.decode()}" Retained: {retained}')
+        asyncio.create_task(pulse())
+
+
+async def down(client):
+    global outages
+    while True:
+        await client.down.wait()  # Pause until connectivity changes
+        client.down.clear()
+        wifi_led(False)
+        outages += 1
+        print("WiFi or broker is down.")
+
+
+async def up(client):
+    while True:
+        await client.up.wait()
+        client.up.clear()
+        wifi_led(True)
+        print("We are connected to broker.")
+        await client.subscribe("foo_topic", 1)
+
+
+async def main(client):
+    try:
+        await client.connect()
+    except OSError:
+        print("Connection failed.")
+        return
+    asyncio.create_task(up(client))
+    asyncio.create_task(down(client))
+    asyncio.create_task(messages(client))
+    n = 0
+    s = "{} repubs: {} outages: {} rssi: {}dB free: {}bytes discards: {}"
+    while True:
+        await asyncio.sleep(5)
+        gc.collect()
+        m = gc.mem_free()
+        print("publish", n)
+        # If WiFi is down the following will pause for the duration.
+        await client.publish(
+            TOPIC, s.format(n, client.REPUB_COUNT, outages, rssi, m, client.queue.discards), qos=1
+        )
+        n += 1
+
+
+# Define configuration
+config["will"] = (TOPIC, "Goodbye cruel world!", False, 0)
+config["keepalive"] = 120
+config["queue_len"] = 4  # Use event interface
+
+# Set up client. Enable optional debug statements.
+MQTTClient.DEBUG = True
+client = MQTTClient(config)
+
+# Currently (Apr 22) this task causes connection periodically to be dropped on Arduino Nano Connect
+# It does work on Pico W
+if not RP2 or "Pico W" in implementation._machine:
+    asyncio.create_task(get_rssi())
+try:
+    asyncio.run(main(client))
+finally:  # Prevent LmacRxBlk:1 errors.
+    client.close()
+    blue_led(True)
+    asyncio.new_event_loop()

toolkit/simulator_lib/simulator.py

@@ -29,6 +29,7 @@ class micrOSIM():
     def __init__(self, doc_resolve=False):
         if doc_resolve:
             console("[micrOSIM] Create micrOS LM doc (env proc)")
+            self._init_sim_doc_resolve()
             # json_structure, html_structure
             self.doc_output = (None, None)
         else:
@@ -38,7 +39,19 @@ class micrOSIM():
             self.pid = None
             micrOSIM.SIM_PROCESS_LIST.append(self.process)
 
+    def _init_sim_doc_resolve(self):
+        """
+        Init micrOS in simulator - folder structure creation
+        """
+        sim_path = LocalMachine.SimplePopPushd()
+        sim_path.pushd(SIM_PATH)
+        import micrOS               # Init micrOS - DO NOT REMOVE
+        sim_path.popd()
+
     def micrOS_sim_worker(self, trace=False):
+        """
+        Start micrOS in python simulator
+        """
         sim_path = LocalMachine.SimplePopPushd()
         sim_path.pushd(SIM_PATH)
         console("[micrOSIM] Start micrOS loader in: {}".format(SIM_PATH))
@@ -130,7 +143,7 @@ class micrOSIM():
                 console(f"[micrOSIM][Extract doc-str] LM_{mod}.{func}.__doc__")
                 try:
                     # Get function doc string
-                    exec(f"import LM_{mod}")
+                    exec(f"from modules import LM_{mod}")
                     doc_str = eval(f"LM_{mod}.{func}.__doc__")
                     # Get function pin map
                     if func == 'pinmap':

toolkit/simulator_lib/uos.py

@@ -68,6 +68,7 @@ def rename(old_path, new_path):
     print(f"[uos.SIM] rename: {old_path} -> {new_path}")
     os.rename(old_path, new_path)
 
+
 def _stat_eval(stat_result):
     """
     micropython converter
@@ -82,6 +83,7 @@ def _stat_eval(stat_result):
         return (micropython_file_identifier['dir'],)
     return (0x0,)
 
+
 def stat(path):
     path = __mock_sim_dir(path)
     stat_result = os.stat(path)

{micrOS/source → toolkit/workspace/precompiled/modules}/LM_esp32.py

@@ -18,6 +18,11 @@ def temp():
     """
     Measure CPU temperature
     """
+    try:
+        cpu_temp = esp32.mcu_temperature()
+        return {'MCU temp [C]': int(cpu_temp)}
+    except:
+        pass
     try:
         raw_temp =  esp32.raw_temperature()
     except Exception as e: