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

micrOS/source/LM_L298N_DCmotor.py

@@ -1,86 +0,0 @@
-from machine import Pin, PWM
-from microIO import bind_pin, pinmap_search
-
-#########################################
-#     ANALOG DIMMER CONTROLLER PARAMS   #
-#########################################
-__L298N_OBJS = []
-# DATA: SPEED (PWM obj), dir pin1, dir pin2
-
-
-#########################################
-#         ANALOG DIMMER WITH PWM        #
-#########################################
-
-def __l298n_init():
-    global __L298N_OBJS
-    if len(__L298N_OBJS) == 0:
-        __L298N_OBJS.append(PWM(Pin(bind_pin('l298speed')), freq=50))
-        __L298N_OBJS.append(Pin(bind_pin('l298dir_1'), Pin.OUT))
-        __L298N_OBJS.append(Pin(bind_pin('l298dir_2'), Pin.OUT))
-        __L298N_OBJS[0].duty(0)     # Set default speed (PWM)
-        __L298N_OBJS[1].value(0)    # Set default direction for dc motor1
-        __L298N_OBJS[2].value(1)    # Set default direction for dc motor1
-    return __L298N_OBJS
-
-
-def m1_control(direc=None, speed=None):
-    out = {}
-    if direc is not None:
-        out = set_direction(direc)
-    if speed is not None:
-        out.update(set_speed(speed))
-    return out
-
-
-def set_speed(speed=100):
-    if 0 <= speed <= 1000:
-        print(__l298n_init())
-        __l298n_init()[0].duty(speed)
-        return {'speed': speed}
-    return {'speed': 'value range error'}
-
-
-def stop():
-    return set_speed(0)
-
-
-def set_direction(direc=0):
-    """
-    direc (direction) values:
-    0: forward
-    1: backward
-    """
-    objlist = __l298n_init()
-    if direc == 0:
-        objlist[1].value(1)
-        objlist[2].value(0)
-        return {'direction': 'forward'}
-    objlist[1].value(0)
-    objlist[2].value(1)
-    return {'direction': 'backward'}
-
-
-#######################
-# LM helper functions #
-#######################
-
-def pinmap():
-    """
-    [i] micrOS LM naming convention
-    Shows logical pins - pin number(s) used by this Load module
-    - info which pins to use for this application
-    :return dict: pin name (str) - pin value (int) pairs
-    """
-    return pinmap_search(['l298speed', 'l298dir_1', 'l298dir_2'])
-
-
-def help(widgets=False):
-    """
-    [i] micrOS LM naming convention - built-in help message
-    :return tuple:
-        (widgets=False) list of functions implemented by this application
-        (widgets=True) list of widget json for UI generation
-    """
-    return 'm1_control direc=<0/1> speed=<0-1023>', 'set_speed <0-1023>',\
-           'set_direction <0-1>', 'stop', 'pinmap'

micrOS/source/LM_espnow.py

@@ -1,57 +0,0 @@
-import Espnow
-
-def load():
-    """
-    OBSOLETE - remove
-    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
-        Initialize ESPNOW protocal
-    """
-    return Espnow.initialize()
-
-def start_server():
-    """
-    OBSOLETE - remove
-    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
-        Start ESPNOW server/listener
-        - this can receive espnow messages
-        - it includes Load Module execution logic (beta)
-    """
-    now = Espnow.initialize()
-    return now.start_server()
-
-
-def send(peer:bytes|str, msg:str='modules'):
-    """
-    Send message to peer (by mac address)
-    :param peer: mac address of espnow device
-    :param msg: message string/load module call
-    """
-    now = Espnow.initialize()
-    return now.send(peer, msg)
-
-def stats():
-    """
-    Get ESPNOW stats
-    """
-    now = Espnow.initialize()
-    return now.stats()
-
-def add_peer(peer:bytes, dev_name:str=None):
-    """
-    Add ESPNOW peer to known hosts
-    - It is needed before first send(...)
-    """
-    now = Espnow.initialize()
-    return now.add_peer(peer, dev_name)
-
-def mac_address():
-    """
-    Get ESPNOW compatible mac address
-    """
-    return Espnow.mac_address()
-
-def help():
-    """
-    [beta] ESPNOW sender/receiver with LM execution
-    """
-    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer> dev_name=None', 'stats', 'mac_address'

micrOS/source/LM_mqtt_pro.py

@@ -1,211 +0,0 @@
-# async_message.py Test of asynchronous mqtt client with async Broker class
-# (C) Copyright Peter Hinch 2024.
-# Released under the MIT licence.
-# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
-# mip command: ???
-
-from Config import cfgget
-from mqtt_as import MQTTClient, config
-from Common import micro_task, console, syslog, exec_cmd
-
-
-# Set up MQTT
-class MQTT:
-    CLIENT:MQTTClient = None        # MQTT Client (broker) instance
-    TOPIC = "micros"                # Default topic
-    TOPIC_COMMAND_LUT = {}          # Lookup table for command/topic pairs
-    # Example:
-    #       {"topic1": ["mod func", "mod2 func"], "topic2": []}
-
-
-async def _receiver(task):
-    """
-    MQTT AS receiver loop
-    """
-    async for topic, msg, retained in MQTT.CLIENT.queue:
-        topic, msg = topic.decode(), msg.decode()
-        console(f'Topic: "{topic}" Message: "{msg}" Retained: {retained}')
-
-        # Command execution... use MQTT.TOPIC_COMMAND_LUT
-        topic_commands:list = MQTT.TOPIC_COMMAND_LUT.get(topic, None)
-        output_struct:list = []
-        if topic_commands is None:
-            syslog(f"[WARN] mqtt Unknown topic: {topic}")
-        elif len(topic_commands) == 0:
-            syslog(f"[WARN] mqtt No commands for {topic}")
-        else:
-            task.out = f"Handle topic: {topic}"
-            for cmd in topic_commands:
-                single_command = cmd.split()
-                if len(single_command) > 0:
-                    state, output = exec_cmd(single_command, jsonify=True, skip_check=True)
-                    output_struct.append({"state": state, "result": output, "cmd": cmd})
-            if len(output_struct) > 0:
-                console(f'\tMQTT Publish: {output_struct}')
-                task.out = f"Publish {topic}"
-                MQTT.CLIENT.publish(topic, str(output_struct))
-            else:
-                task.out = f"Nothing to publish {topic}"
-        task.feed()
-
-
-async def _subscribe():
-    """
-    MQTT AS Topic subscribe towards server
-    """
-    with micro_task(tag="mqtt.subscribe") as my_task:
-        my_task.out = "Started"
-        try:
-            for t in MQTT.TOPIC_COMMAND_LUT:
-                console(f"Subscribe topic: {t}")
-                await MQTT.CLIENT.subscribe(t, 1)
-            my_task.out = "Done"
-        except Exception as e:
-            my_task.out = f"Error: {e}"
-
-
-async def _publish(message, topic):
-    """
-    Send message to topic with mqtt
-    """
-    tag = f"mqtt.publish.{topic}"
-    with micro_task(tag=tag) as my_task:
-        console(f"mqtt send: [{topic}] {message}")
-        await MQTT.CLIENT.publish(topic, message, qos=1)
-        my_task.out = "Sent"
-
-
-async def _up():
-    """
-    UP Listener - resubscribe
-    """
-    with micro_task(tag="mqtt.up") as my_task:
-        while True:
-            # Wait for UP Event - (re)subscribe
-            my_task.out = "Wait"
-            await MQTT.CLIENT.up.wait()
-            MQTT.CLIENT.up.clear()
-            micro_task(tag="mqtt.subscribe", task=_subscribe())
-            my_task.out = "Re-Subscription"
-            my_task.feed()
-
-
-async def _init_client(topic:str=None, commands:str=None, raw_dict:dict|None=None):
-    """
-    Initialize main mqtt receiver and topics
-    :param topic: topic string, ex.: 'lights'
-    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
-    OR
-    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
-    """
-    with micro_task(tag="mqtt.client") as my_task:
-        try:
-            await MQTT.CLIENT.connect()
-            my_task.out = "Connection successful."
-        except OSError:
-            my_task.out = "Connection failed."
-            return
-        # Wait for mqtt client connected successfully
-        await MQTT.CLIENT.up.wait()
-        MQTT.CLIENT.up.clear()
-        # Initialize mqtt topics, ha
-        subscribe(topic, commands, raw_dict)
-        micro_task(tag="mqtt.up", task=_up())
-        # Async listener loop
-        await _receiver(my_task)
-        my_task.out = "Receiver closed"
-    # Close when listener exits
-    MQTT.CLIENT.close()
-
-#########################################
-#           PUBLIC FUNCTIONS            #
-#########################################
-
-def publish(message:str, topic:str=MQTT.TOPIC):
-    """
-    Publish message
-    :param message: string to be sent
-    :param topic: topic for message
-    """
-    state = micro_task(tag=f"mqtt.publish.{topic}", task=_publish(message, topic))
-    state = "starting" if state else "already running"
-    return f"Message send, {state}"
-
-
-def subscribe(topic:str=None, commands:str=None, raw_dict:dict|None=None):
-    """
-    Subscribe for single topics and set callback function(s) aka command(s)
-    :param topic: topic string, ex.: 'lights'
-    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
-    OR
-    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
-
-    return: all or selected topics command
-    """
-    updated = False
-    topic = topic.strip()
-    # Register single topic
-    if topic and commands:
-        # raw commands structure: 'rgb toggle; cct toggle'
-        commands = [ c.strip() for c in commands.split(";") ]
-        # commands: Topic LUT structure: {'topic': ['mod func'], ..., 'lights': ['rgb toggle', 'cct toggle']}
-        updated = True if MQTT.TOPIC_COMMAND_LUT.get(topic, None) is None else False
-        MQTT.TOPIC_COMMAND_LUT[topic] = commands
-    # Register multiple topics at once
-    elif isinstance(raw_dict, dict):
-        updated = True
-        MQTT.TOPIC_COMMAND_LUT.update(raw_dict)
-    # Start subscribe task
-    if updated:
-        state = micro_task(tag="mqtt.subscribe", task=_subscribe())
-        state = "starting" if state else "already running"
-        return f"Subscribe, {state}"
-
-    # Return handling
-    if topic is not None:
-        # Return selected topic commands
-        return MQTT.TOPIC_COMMAND_LUT.get(topic, None)
-    # Return registered topics
-    return MQTT.TOPIC_COMMAND_LUT
-
-
-def _configure(server_ip:str, username:str, password:str):
-    # Define configuration
-    config["keepalive"] = 120
-    config["queue_len"] = 1  # Use event interface with default queue
-    # Define configuration
-    config['client_id'] = cfgget("devfid")
-    config['ssid'] = cfgget("staessid")
-    config['wifi_pw'] = cfgget("stapwd")
-    config['port'] = 1883                       # expose????
-    config['server'] = server_ip                # '172.20.10.2'
-    config['user'] = username                   # test
-    config['password'] = password               # '12345'
-    return config
-
-
-def load(server_ip:str, username:str, password:str, topic:str=None, commands:str=None, raw_dict:dict|None=None):
-    """
-    Load MQTT_AS receiver...
-    :param server_ip: server IP address
-    :param username: server user
-    :param password: server user password
-
-    :param topic: topic string, ex.: 'lights'
-    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
-    OR
-    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
-    """
-    MQTTClient.DEBUG = True
-    MQTT.CLIENT = MQTTClient(_configure(server_ip, username, password))
-
-    state = micro_task(tag="mqtt.client", task=_init_client(topic, commands, raw_dict))
-    return "Starting" if state else "Already running"
-
-
-def help():
-    return ("load <server_ip> <username> <password> topic='micros', commands='rgb toggle; cct toggle'",
-            "subscribe topic='micros', commands='rgb toggle; cct toggle'",
-            "subscribe #without params dumps the topic-command data structure",
-            "publish message='hello' topic='micros'",
-            "HINT: task show mqtt.*")

toolkit/lib/file_extensions.py

@@ -1,22 +0,0 @@
-
-PYTHON_EXTENSIONS = ('py', 'mpy')
-WEB_ONLY = ('js', 'html', 'css', 'json', 'ico', 'jpeg', 'png')
-ENABLED_EXTENSIONS = PYTHON_EXTENSIONS + WEB_ONLY
-
-def check_all_extensions(path):
-    extension = path.split('.')[-1]
-    if extension in ENABLED_EXTENSIONS:
-        return True
-    return False
-
-def check_web_extensions(path):
-    extension = path.split('.')[-1]
-    if extension in WEB_ONLY:
-        return True
-    return False
-
-def check_python_extensions(path):
-    extension = path.split('.')[-1]
-    if extension in PYTHON_EXTENSIONS:
-        return True
-    return False

toolkit/workspace/precompiled/LM_espnow.py

@@ -1,57 +0,0 @@
-import Espnow
-
-def load():
-    """
-    OBSOLETE - remove
-    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
-        Initialize ESPNOW protocal
-    """
-    return Espnow.initialize()
-
-def start_server():
-    """
-    OBSOLETE - remove
-    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
-        Start ESPNOW server/listener
-        - this can receive espnow messages
-        - it includes Load Module execution logic (beta)
-    """
-    now = Espnow.initialize()
-    return now.start_server()
-
-
-def send(peer:bytes|str, msg:str='modules'):
-    """
-    Send message to peer (by mac address)
-    :param peer: mac address of espnow device
-    :param msg: message string/load module call
-    """
-    now = Espnow.initialize()
-    return now.send(peer, msg)
-
-def stats():
-    """
-    Get ESPNOW stats
-    """
-    now = Espnow.initialize()
-    return now.stats()
-
-def add_peer(peer:bytes, dev_name:str=None):
-    """
-    Add ESPNOW peer to known hosts
-    - It is needed before first send(...)
-    """
-    now = Espnow.initialize()
-    return now.add_peer(peer, dev_name)
-
-def mac_address():
-    """
-    Get ESPNOW compatible mac address
-    """
-    return Espnow.mac_address()
-
-def help():
-    """
-    [beta] ESPNOW sender/receiver with LM execution
-    """
-    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer> dev_name=None', 'stats', 'mac_address'

toolkit/workspace/precompiled/LM_mqtt_pro.py

@@ -1,211 +0,0 @@
-# async_message.py Test of asynchronous mqtt client with async Broker class
-# (C) Copyright Peter Hinch 2024.
-# Released under the MIT licence.
-# Public brokers https://github.com/mqtt/mqtt.github.io/wiki/public_brokers
-# mip command: ???
-
-from Config import cfgget
-from mqtt_as import MQTTClient, config
-from Common import micro_task, console, syslog, exec_cmd
-
-
-# Set up MQTT
-class MQTT:
-    CLIENT:MQTTClient = None        # MQTT Client (broker) instance
-    TOPIC = "micros"                # Default topic
-    TOPIC_COMMAND_LUT = {}          # Lookup table for command/topic pairs
-    # Example:
-    #       {"topic1": ["mod func", "mod2 func"], "topic2": []}
-
-
-async def _receiver(task):
-    """
-    MQTT AS receiver loop
-    """
-    async for topic, msg, retained in MQTT.CLIENT.queue:
-        topic, msg = topic.decode(), msg.decode()
-        console(f'Topic: "{topic}" Message: "{msg}" Retained: {retained}')
-
-        # Command execution... use MQTT.TOPIC_COMMAND_LUT
-        topic_commands:list = MQTT.TOPIC_COMMAND_LUT.get(topic, None)
-        output_struct:list = []
-        if topic_commands is None:
-            syslog(f"[WARN] mqtt Unknown topic: {topic}")
-        elif len(topic_commands) == 0:
-            syslog(f"[WARN] mqtt No commands for {topic}")
-        else:
-            task.out = f"Handle topic: {topic}"
-            for cmd in topic_commands:
-                single_command = cmd.split()
-                if len(single_command) > 0:
-                    state, output = exec_cmd(single_command, jsonify=True, skip_check=True)
-                    output_struct.append({"state": state, "result": output, "cmd": cmd})
-            if len(output_struct) > 0:
-                console(f'\tMQTT Publish: {output_struct}')
-                task.out = f"Publish {topic}"
-                MQTT.CLIENT.publish(topic, str(output_struct))
-            else:
-                task.out = f"Nothing to publish {topic}"
-        task.feed()
-
-
-async def _subscribe():
-    """
-    MQTT AS Topic subscribe towards server
-    """
-    with micro_task(tag="mqtt.subscribe") as my_task:
-        my_task.out = "Started"
-        try:
-            for t in MQTT.TOPIC_COMMAND_LUT:
-                console(f"Subscribe topic: {t}")
-                await MQTT.CLIENT.subscribe(t, 1)
-            my_task.out = "Done"
-        except Exception as e:
-            my_task.out = f"Error: {e}"
-
-
-async def _publish(message, topic):
-    """
-    Send message to topic with mqtt
-    """
-    tag = f"mqtt.publish.{topic}"
-    with micro_task(tag=tag) as my_task:
-        console(f"mqtt send: [{topic}] {message}")
-        await MQTT.CLIENT.publish(topic, message, qos=1)
-        my_task.out = "Sent"
-
-
-async def _up():
-    """
-    UP Listener - resubscribe
-    """
-    with micro_task(tag="mqtt.up") as my_task:
-        while True:
-            # Wait for UP Event - (re)subscribe
-            my_task.out = "Wait"
-            await MQTT.CLIENT.up.wait()
-            MQTT.CLIENT.up.clear()
-            micro_task(tag="mqtt.subscribe", task=_subscribe())
-            my_task.out = "Re-Subscription"
-            my_task.feed()
-
-
-async def _init_client(topic:str=None, commands:str=None, raw_dict:dict|None=None):
-    """
-    Initialize main mqtt receiver and topics
-    :param topic: topic string, ex.: 'lights'
-    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
-    OR
-    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
-    """
-    with micro_task(tag="mqtt.client") as my_task:
-        try:
-            await MQTT.CLIENT.connect()
-            my_task.out = "Connection successful."
-        except OSError:
-            my_task.out = "Connection failed."
-            return
-        # Wait for mqtt client connected successfully
-        await MQTT.CLIENT.up.wait()
-        MQTT.CLIENT.up.clear()
-        # Initialize mqtt topics, ha
-        subscribe(topic, commands, raw_dict)
-        micro_task(tag="mqtt.up", task=_up())
-        # Async listener loop
-        await _receiver(my_task)
-        my_task.out = "Receiver closed"
-    # Close when listener exits
-    MQTT.CLIENT.close()
-
-#########################################
-#           PUBLIC FUNCTIONS            #
-#########################################
-
-def publish(message:str, topic:str=MQTT.TOPIC):
-    """
-    Publish message
-    :param message: string to be sent
-    :param topic: topic for message
-    """
-    state = micro_task(tag=f"mqtt.publish.{topic}", task=_publish(message, topic))
-    state = "starting" if state else "already running"
-    return f"Message send, {state}"
-
-
-def subscribe(topic:str=None, commands:str=None, raw_dict:dict|None=None):
-    """
-    Subscribe for single topics and set callback function(s) aka command(s)
-    :param topic: topic string, ex.: 'lights'
-    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
-    OR
-    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
-
-    return: all or selected topics command
-    """
-    updated = False
-    topic = topic.strip()
-    # Register single topic
-    if topic and commands:
-        # raw commands structure: 'rgb toggle; cct toggle'
-        commands = [ c.strip() for c in commands.split(";") ]
-        # commands: Topic LUT structure: {'topic': ['mod func'], ..., 'lights': ['rgb toggle', 'cct toggle']}
-        updated = True if MQTT.TOPIC_COMMAND_LUT.get(topic, None) is None else False
-        MQTT.TOPIC_COMMAND_LUT[topic] = commands
-    # Register multiple topics at once
-    elif isinstance(raw_dict, dict):
-        updated = True
-        MQTT.TOPIC_COMMAND_LUT.update(raw_dict)
-    # Start subscribe task
-    if updated:
-        state = micro_task(tag="mqtt.subscribe", task=_subscribe())
-        state = "starting" if state else "already running"
-        return f"Subscribe, {state}"
-
-    # Return handling
-    if topic is not None:
-        # Return selected topic commands
-        return MQTT.TOPIC_COMMAND_LUT.get(topic, None)
-    # Return registered topics
-    return MQTT.TOPIC_COMMAND_LUT
-
-
-def _configure(server_ip:str, username:str, password:str):
-    # Define configuration
-    config["keepalive"] = 120
-    config["queue_len"] = 1  # Use event interface with default queue
-    # Define configuration
-    config['client_id'] = cfgget("devfid")
-    config['ssid'] = cfgget("staessid")
-    config['wifi_pw'] = cfgget("stapwd")
-    config['port'] = 1883                       # expose????
-    config['server'] = server_ip                # '172.20.10.2'
-    config['user'] = username                   # test
-    config['password'] = password               # '12345'
-    return config
-
-
-def load(server_ip:str, username:str, password:str, topic:str=None, commands:str=None, raw_dict:dict|None=None):
-    """
-    Load MQTT_AS receiver...
-    :param server_ip: server IP address
-    :param username: server user
-    :param password: server user password
-
-    :param topic: topic string, ex.: 'lights'
-    :param commands: semicolon separated commands. ex.: 'rgb toggle; cct toggle'
-    OR
-    :param raw_dict: python dict string for multi topic subscription, ex.: {"lights": ["rgb toggle", "cct toggle"], ...}
-    """
-    MQTTClient.DEBUG = True
-    MQTT.CLIENT = MQTTClient(_configure(server_ip, username, password))
-
-    state = micro_task(tag="mqtt.client", task=_init_client(topic, commands, raw_dict))
-    return "Starting" if state else "Already running"
-
-
-def help():
-    return ("load <server_ip> <username> <password> topic='micros', commands='rgb toggle; cct toggle'",
-            "subscribe topic='micros', commands='rgb toggle; cct toggle'",
-            "subscribe #without params dumps the topic-command data structure",
-            "publish message='hello' topic='micros'",
-            "HINT: task show mqtt.*")