micrOSDevToolKit 2.1.5__py3-none-any.whl → 2.26.1__py3-none-any.whl

toolkit/workspace/precompiled/web/uwidgets.js

@@ -0,0 +1,172 @@
+// WIDGETS ELEMENTS
+
+const widget_indent = '40px';
+const windowWidth = window.innerWidth;
+
+function createTitle(command, title_len) {
+    return command.split('/').slice(1, title_len + 1).join('-').replace(/=|:range:/g, '').replace(/=|:options:/g, '');
+}
+function paramPythonify(opt) {
+    if (opt === "None" || opt === "True" || opt === "False") {return opt;}
+    // Check if the input is a valid integer
+    if (!isNaN(parseInt(opt, 10)) && String(parseInt(opt, 10)) === opt) {return opt;}
+    // Check if the input is a valid float
+    if (!isNaN(parseFloat(opt)) && String(parseFloat(opt)) === opt) {return opt;}
+    // If not a boolean, integer, or float, return as a quoted string
+    return `"${opt}"`;
+}
+
+function sliderWidget(container, command, params={}) {
+    const { title_len = 1, range = [0, 100, 5] } = params;
+    const [min, max, step] = range;
+    const paragraph = document.createElement('p');
+    const element = document.createElement('input');
+    const valueDisplay = document.createElement('span');
+
+    paragraph.style.textIndent = widget_indent;
+    paragraph.textContent = createTitle(command, title_len);
+    element.type = 'range';
+    element.min = min;
+    element.max = max;
+    element.step = step;
+    element.value = (max - min) / 2;
+    element.style.marginLeft = widget_indent;
+    element.style.width = `${Math.min(windowWidth * 0.6, 300)}px`;
+    valueDisplay.textContent = element.value;
+
+    element.addEventListener('input', () => valueDisplay.textContent = element.value);
+    element.addEventListener('change', () => {
+        const call_cmd = command.includes(':range:') ? command.replace(':range:', element.value) :
+                         command.endsWith('=') ? `${command}${element.value}` :
+                         `${command}/${element.value}`;
+        console.log(`[API] Slider exec: ${call_cmd}`);
+        restAPI(call_cmd);
+    });
+
+    containerAppendChild([paragraph, element, valueDisplay], container);
+}
+
+function buttonWidget(container, command, params={}) {
+    const { title_len = 1, options = ['None'] } = params;
+    const text = createTitle(command, title_len);
+    const optsToTextMap = {
+        'True': 'ON',
+        'False': 'OFF',
+        'None': 'Default'
+    };
+    if (options.length > 1) {
+        // Create and append title paragraph for multi-button mode
+        const titleParagraph = document.createElement('p');
+        titleParagraph.style.textIndent = widget_indent;
+        titleParagraph.textContent = text;
+        container.appendChild(titleParagraph);
+    }
+    const paragraph = document.createElement('p');
+    paragraph.style.textIndent = widget_indent;
+
+    // Create buttons for each option
+    options.forEach(opt => {
+        const element = document.createElement('button');
+        element.style.marginRight = '10px';
+        element.style.height = '30px';
+        element.textContent = options.length === 1 ? text : optsToTextMap[opt] || opt;
+        element.addEventListener('click', () => {
+            const call_cmd = command.replace(':options:', paramPythonify(opt));
+            console.log(`[API] Button clicked: ${call_cmd}`);
+            restAPI(call_cmd);
+        });
+        paragraph.appendChild(element);
+    });
+    containerAppendChild([paragraph], container);
+}
+
+function textBoxWidget(container, command, params={}) {
+    const { title_len = 1, refresh = 5000 } = params;
+    const paragraph = document.createElement('p');
+    const uniqueId = `textbox-${command}-${Date.now()}`;
+    const element = document.createElement('div');
+
+    paragraph.style.textIndent = widget_indent;
+    paragraph.textContent = createTitle(command, title_len);
+
+    element.id = uniqueId;
+    Object.assign(element.style, {
+        marginLeft: widget_indent,
+        width: `${Math.min(windowWidth * 0.6, 300)}px`,
+        padding: '10px',
+        boxSizing: 'border-box',
+        border: '2px solid #e7e7e7',
+        borderRadius: '4px'
+    });
+
+    const updateTextbox = () => {
+        const call_cmd = command.replace(':range:', 'None');
+        restAPI(call_cmd).then(resp => {
+            console.log(`[API] textBox[${uniqueId}] call: ${call_cmd}`);
+            const content = JSON.stringify(resp.result, null, 4).replace(/,\s*"/g, ',<br>"');
+            document.getElementById(uniqueId).innerHTML = content;
+        }).catch(error => {
+            console.error('[API] Textbox error:', error);
+            document.getElementById(uniqueId).textContent = 'Error loading data';
+        });
+    };
+
+    updateTextbox();
+    if (refresh > 0) {
+        const intervalId = setInterval(updateTextbox, refresh);
+        container.addEventListener('DOMNodeRemovedFromDocument', () => clearInterval(intervalId));
+    }
+
+    containerAppendChild([paragraph, element], container);
+}
+
+function colorPaletteWidget(container, command, params = {}) {
+    const hexToRgb = (hex, max = 255) => {
+        hex = hex.replace(/^#/, '');
+        let bigint = parseInt(hex, 16);
+        let r = (bigint >> 16) & 255;
+        let g = (bigint >> 8) & 255;
+        let b = bigint & 255;
+        if (max > 255) {
+            const ratio = max / 255;
+            r = Math.round(r * ratio);
+            g = Math.round(g * ratio);
+            b = Math.round(b * ratio);
+        }
+        return { r, g, b };
+    };
+    const getRandomColorFromList = () => {
+        const colors = ['#542040', '#2b2155', '#4c1e44', '#56213f', '#853366', '#493984', '#6f3487'];
+        return colors[Math.floor(Math.random() * colors.length)];
+    };
+
+    const { title_len = 1, range = [0, 255] } = params;
+    const max_val = range[1];
+    const paragraph = document.createElement('p');
+    const colorPicker = document.createElement('input');
+    const selectedColor = document.createElement('span');
+
+    paragraph.style.textIndent = widget_indent;
+    paragraph.textContent = createTitle(command, title_len);
+    colorPicker.type = 'color';
+    colorPicker.value = getRandomColorFromList();
+    colorPicker.classList.add('custom-color-picker');
+    Object.assign(colorPicker.style, {
+        width: '60px',
+        height: '40px',
+        marginLeft: '40px'
+    });
+
+    colorPicker.addEventListener('change', () => {
+        const { r, g, b } = hexToRgb(colorPicker.value, max_val);
+        const call_cmd = command.replace('r=:range:', `r=${r}`)
+                                .replace('g=:range:', `g=${g}`)
+                                .replace('b=:range:', `b=${b}`);
+        console.log(`[API] colorPalette exec: ${call_cmd}`);
+        restAPI(call_cmd);
+    });
+
+    containerAppendChild([paragraph, colorPicker, selectedColor], container);
+}
+
+// sliderWidget

toolkit/workspace/precompiled/web/uwidgets_pro.js

@@ -0,0 +1,99 @@
+// PRO WIDGETS ELEMENTS
+
+function joystickWidget(container, command, params={}) {
+    const { title_len = 1, range = [0, 100, 5] } = params;
+    const [min, max, step] = range;
+    const paragraph = document.createElement('p');
+    const joystickContainer = document.createElement('div');
+    const joystick = document.createElement('div');
+    const valueDisplay = document.createElement('span');
+
+    paragraph.style.textIndent = widget_indent;
+    paragraph.textContent = createTitle(command, title_len);
+
+    joystickContainer.style.position = 'relative';
+    joystickContainer.style.width = '200px';
+    joystickContainer.style.height = '200px';
+    joystickContainer.style.border = '1px solid #fff';
+    joystickContainer.style.marginLeft = widget_indent;
+    joystickContainer.style.backgroundColor = 'transparent';
+
+    joystick.style.position = 'absolute';
+    joystick.style.width = '30px';
+    joystick.style.height = '30px';
+    joystick.style.background = '#fff';
+    joystick.style.borderRadius = '50%';
+    joystick.style.left = '50%';
+    joystick.style.top = '50%';
+    joystick.style.transform = 'translate(-50%, -50%)';
+    joystick.style.cursor = 'pointer';
+
+    valueDisplay.style.textIndent = widget_indent;
+    valueDisplay.style.display = 'block';
+
+    let isDragging = false;
+
+    const updateValueDisplay = (x, y) => {
+        valueDisplay.textContent = `x: ${x}, y: ${y}`;
+    };
+
+    const constrain = (value, min, max) => {
+        if (value < min) return min;
+        if (value > max) return max;
+        return value;
+    };
+
+    const startDragging = (event) => {
+        isDragging = true;
+        event.preventDefault();
+    };
+
+    const stopDragging = () => {
+        if (isDragging) {
+            const rect = joystickContainer.getBoundingClientRect();
+            const x = Math.round((parseFloat(joystick.style.left) / rect.width) * (max - min) + min);
+            const y = Math.round((parseFloat(joystick.style.top) / rect.height) * (max - min) + min);
+
+            const call_cmd = command.includes('x=:range:') && command.includes('y=:range:') ?
+                command.replace('x=:range:', `x=${x}`).replace('y=:range:', `y=${y}`) :
+                `${command}`;
+
+            console.log(`[API] Joystick exec: ${call_cmd}`);
+            restAPI(call_cmd);
+        }
+        isDragging = false;
+    };
+
+    const drag = (event) => {
+        if (isDragging) {
+            const rect = joystickContainer.getBoundingClientRect();
+            const offsetX = event.touches ? event.touches[0].clientX - rect.left : event.clientX - rect.left;
+            const offsetY = event.touches ? event.touches[0].clientY - rect.top : event.clientY - rect.top;
+            const x = constrain(offsetX, 0, rect.width);
+            const y = constrain(offsetY, 0, rect.height);
+
+            joystick.style.left = `${x}px`;
+            joystick.style.top = `${y}px`;
+
+            const xValue = Math.round((x / rect.width) * (max - min) + min);
+            const yValue = Math.round((y / rect.height) * (max - min) + min);
+            updateValueDisplay(xValue, yValue);
+        }
+    };
+
+    joystick.addEventListener('mousedown', startDragging);
+    joystick.addEventListener('touchstart', startDragging);
+
+    document.addEventListener('mouseup', stopDragging);
+    document.addEventListener('touchend', stopDragging);
+
+    document.addEventListener('mousemove', drag);
+    document.addEventListener('touchmove', drag);
+
+    joystickContainer.appendChild(joystick);
+    containerAppendChild([paragraph, joystickContainer, valueDisplay], container);
+    updateValueDisplay((max - min) / 2, (max - min) / 2);
+}
+
+
+

micrOS/source/LM_L298N_DCmotor.py

@@ -1,86 +0,0 @@
-from machine import Pin, PWM
-from microIO import physical_pin, pinmap_dump
-
-#########################################
-#     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(physical_pin('l298speed')), freq=50))
-        __L298N_OBJS.append(Pin(physical_pin('l298dir_1'), Pin.OUT))
-        __L298N_OBJS.append(Pin(physical_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_dump(['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_catgame.py

@@ -1,74 +0,0 @@
-from random import randint
-from LM_servo import sduty, deinit
-from LM_servo import pinmap as pm
-from utime import sleep_ms
-
-
-def game(repeat=10, delta=20):
-    """
-    Servo cat toy "mover" - left-right
-    :param repeat int: repeat servo pos change
-    :param delta int: center(75) +/-delta(35)
-    :return str: verdict
-    """
-    sduty(75)
-    for _ in range(0, repeat):
-        sduty(randint(75-delta, 75+delta))
-        sleep_ms(randint(20, 1500))
-    sduty(75)
-    return 'Game action'
-
-
-def live_game(chance=10):
-    """
-    Generate game
-    :param chance int: percent value 0-100
-    :return str: verdict (action / no action)
-    """
-    action = randint(1, 10)
-    if action <= int(chance/10):
-        return game(repeat=5)
-    return 'No action'
-
-
-def stop():
-    """
-    Stop game - home position (75) + deinit
-    :return str: servo verdict
-    """
-    out = sduty(75)
-    deinit()
-    return out
-
-
-#######################
-# LM helper functions #
-#######################
-
-def lmdep():
-    """
-    Show Load Module dependency
-    - List of load modules used by this application
-    :return: tuple
-    """
-    return 'servo'
-
-
-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 pm()
-
-
-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 'game repeat=10', 'live_game chance=<10-90>', 'stop', 'pinmap', 'lmdep'

micrOS/source/LM_dashboard_be.py

@@ -1,37 +0,0 @@
-from Common import rest_endpoint, syslog
-
-ENDPOINT_INITED = False
-
-def load_n_init():
-    return create_dashboard()
-
-
-def _dashboard_clb():
-    try:
-        with open('dashboard.html', 'r') as html:
-            html_content = html.read()
-        return 'text/html', html_content
-    except Exception as e:
-        syslog(f"[ERR] dashboard_be: {e}")
-        html_content = None
-    return 'text/plain', f'html_content error: {html_content}'
-
-
-def create_dashboard():
-    """
-    Create dashboard endpoint
-    """
-    global ENDPOINT_INITED
-    ENDPOINT_INITED = True
-    rest_endpoint('dashboard', _dashboard_clb)
-    return 'Endpoint created: /dashboard'
-
-
-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 'load_n_init', 'create_dashboard', 'help'

micrOS/source/LM_demo.py

@@ -1,85 +0,0 @@
-from random import randint
-from microIO import detect_platform
-from Debug import console_write
-from Time import uptime
-
-CNT = 0
-
-
-def _debug(func):
-    """
-    Debug wrapper
-    - console logging
-    - handled cmd counter (exec_info to get the value)
-    """
-    def __wrapper(*args, **kwargs):
-        global CNT
-        CNT += 1
-        console_write("debug module cmd executed")     # + Progress LED
-        return func(*args, **kwargs)
-    return __wrapper
-
-
-@_debug
-def hello(name="MrNobody"):
-    return f"Hello {name}! This is a micrOS smart endpoint ☁️, running on {detect_platform()}.\
-    \nFor more info call `demo links` function :D"
-
-
-@_debug
-def calculator(a, b, op="+"):
-    if op.strip() == "+":
-        return f"{a} + {b} = {a + b}"
-    if op.strip() == "-":
-        return f"{a} - {b} = {a - b}"
-    if op.strip() == "/":
-        return f"{a} / {b} = {round(a / b, 3)}"
-    if op.strip() == "*":
-        return f"{a} * {b} = {a * b}"
-
-
-@_debug
-def dice_cube():
-    value = randint(1, 6)
-    return f"🎲 {value}"
-
-
-@_debug
-def yes_no():
-    val = randint(0, 1)
-    return 'NO👎' if val == 0 else 'YES👍'
-
-
-@_debug
-def links():
-    descript = f"Platform: {detect_platform()}\nGITHUB: https://github.com/BxNxM/micrOS\nYOUTUBE: https://www.youtube.com/@micrOSframework\nINSTAGRAM: https://instagram.com/micros_framework"
-    return descript
-
-
-@_debug
-def source():
-    return 'https://github.com/BxNxM/micrOS/blob/master/micrOS/source/LM_demo.py'
-
-
-@_debug
-def exec_info():
-    global CNT
-    return f"Under {uptime()}: {CNT} cmd served."
-
-
-@_debug
-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 'hello name="MrNobody"',\
-           'calculator a b op="+"',\
-           '\t=>op: + - / *',\
-           'dice_cube - show number, roll a dice',\
-           'yes_no    - show random yes/no',\
-           'links     - show micrOS links',\
-           'source    - show demo module source code',\
-           'exec_info - Execution info, demo module usage'

micrOS/source/LM_distance.py

@@ -1,88 +0,0 @@
-from machine import Pin, time_pulse_us
-from utime import sleep_us
-from microIO import physical_pin, pinmap_dump
-
-__TRIGGER_OBJ = None
-__ECHO_OBJ = None
-
-
-def __init_HCSR04():
-    global __TRIGGER_OBJ, __ECHO_OBJ
-    if __TRIGGER_OBJ is None or __ECHO_OBJ is None:
-        trigger_pin = physical_pin('hcsrtrig')
-        echo_pin = physical_pin('hcsrecho')
-        # Init trigger pin (out)
-        __TRIGGER_OBJ = Pin(trigger_pin, mode=Pin.OUT, pull=None)
-        __TRIGGER_OBJ.value(0)
-        # Init echo pin (in)
-        __ECHO_OBJ = Pin(echo_pin, mode=Pin.IN, pull=None)
-    return __TRIGGER_OBJ, __ECHO_OBJ
-
-
-def __send_pulse_and_wait(echo_timeout_us=1000000):
-    trigger_pin, echo_pin = __init_HCSR04()
-    trigger_pin.value(0) # Stabilize the sensor
-    sleep_us(5)
-    trigger_pin.value(1)
-    # Send a 10us pulse.
-    sleep_us(10)
-    trigger_pin.value(0)
-    try:
-        pulse_time = time_pulse_us(echo_pin, 1, echo_timeout_us)
-        return pulse_time
-    except OSError as ex:
-        if ex.args[0] == 110: # 110 = ETIMEDOUT
-            raise OSError('Out of range')
-        raise ex
-
-
-#########################
-# Application functions #
-#########################
-
-def distance_mm():
-    """
-    To calculate the distance we get the pulse_time and divide it by 2
-    (the pulse walk the distance twice) and by 29.1 becasue
-    the sound speed on air (343.2 m/s), that It's equivalent to
-    0.34320 mm/us that is 1mm each 2.91us
-    pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582
-    """
-    return __send_pulse_and_wait() * 100 // 582
-
-
-def distance_cm():
-    return (__send_pulse_and_wait() / 2) / 29.1
-
-
-def deinit():
-    global __TRIGGER_OBJ, __ECHO_OBJ
-    trigger_pin, echo_pin = __init_HCSR04()
-    trigger_pin.deinit()
-    echo_pin.deinit()
-    __TRIGGER_OBJ = None
-    __ECHO_OBJ = None
-
-
-#######################
-# 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_dump(['hcsrtrig', 'hcsrecho'])
-
-
-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 'distance_mm', 'distance_cm', 'deinit', 'pinmap'