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

toolkit/workspace/precompiled/modules/LM_espnow.py

@@ -0,0 +1,36 @@
+from Espnow import ESPNowSS
+ESPNOW = ESPNowSS()
+
+
+def send(peer:bytes|str, cmd:str='modules'):
+    """
+    Send message to peer (by mac address)
+    :param peer: mac address of espnow device
+    :param cmd: message string/load module call
+    """
+    return ESPNOW.send(peer, cmd)
+
+def stats():
+    """
+    Get ESPNOW stats
+    """
+    return ESPNOW.stats()
+
+
+def handshake(peer:bytes|str):
+    """
+    Handshake with ESPNow Peer
+    :param peer: mac address of espnow device
+    - device name detection
+    - address:name caching
+    """
+    return ESPNOW.handshake(peer)
+
+
+def help():
+    """
+    ESPNOW sender/receiver with LM execution
+    """
+    return ('handshake peer=<mac-address>',
+            'send peer=<peer-name> cmd="hello"',
+            'stats')

toolkit/workspace/precompiled/{LM_i2c.py → modules/LM_i2c.py}

@@ -26,7 +26,7 @@ def discover():
     """
     known_addresses = {hex(0x0A): "TRACKBALL", hex(0x3c): "OLED",
                        hex(0x76): "BME280", hex(0x10): 'VEML7700',
-                       hex(0x6b): "QMI8658"}
+                       hex(0x6b): "QMI8658", hex(0x29): 'TCS3472'}
     devices = scan()
     output = {"unknown": []}
     for k in devices:

toolkit/workspace/precompiled/{LM_robustness.py → modules/LM_robustness.py}

@@ -1,5 +1,5 @@
 from LM_system import memory_usage
-from Common import socket_stream, syslog
+from Common import socket_stream, syslog, micro_task
 
 
 @socket_stream
@@ -61,6 +61,52 @@ def _recursion(cnt, msgobj=None):
         remain = 0
     return remain
 
+################## TEST micro_task UCs ##########################
+
+async def __task(tag, period_ms):
+    counter = 0
+    with micro_task(tag=tag) as my_task:
+        while True:
+            # DO something here in the async loop...
+            counter += 1
+
+            # Store data in task cache (task show mytask)
+            my_task.out = f'MyTask Counter: {counter}'
+
+            # Async sleep - feed event loop
+            await my_task.feed(sleep_ms=period_ms)
+            # [i] feed same as "await asyncio.sleep_ms(period_ms)" with micrOS features (WDT)
+
+def create_task():
+    """
+    Legacy way of task creation (with exact task tagging)
+    """
+    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    task_tag = "microtask.run"
+    state = micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
+    return "Starting" if state else "Already running"
+
+
+@micro_task("microtask", _wrap=True)
+async def mytask(tag, period_ms=30):
+    """
+    New shorter way of task creation
+     with decorator function
+    """
+    counter = 0
+    with micro_task(tag=tag) as my_task:
+        while True:
+            # DO something here in the async loop...
+            counter += 1
+
+            # Store data in task cache (task show mytask)
+            my_task.out = f'MyTask Counter: {counter}'
+
+            # Async sleep - feed event loop
+            await my_task.feed(sleep_ms=period_ms)
+            # [i] feed same as "await asyncio.sleep_ms(period_ms)" with micrOS features (WDT)
+
+##############################################################################
 
 def help(widgets=False):
     """
@@ -70,5 +116,6 @@ def help(widgets=False):
         (widgets=True) list of widget json for UI generation
     """
     return 'NOTE: This is a test module to validate system robustness', \
-           'raise_error', 'memory_leak cnt=160', 'recursion_limit cnt=14'
+           'raise_error', 'memory_leak cnt=160', 'recursion_limit cnt=14', \
+           'create_task', 'mytask'
 

toolkit/workspace/precompiled/{LM_tcs3472.py → modules/LM_tcs3472.py}

@@ -17,20 +17,15 @@ class TCS3472:
     def __init__(self, bus, address=0x29):
         self._bus = bus
         self._i2c_address = address
-
-        self._bus.start()
-
         self._bus.writeto(self._i2c_address, b'\x80\x03')
         self._bus.writeto(self._i2c_address, b'\x81\x2b')
-
         TCS3472.INSTANCE = self
 
     def scaled(self):
         crgb = self.raw()
         if crgb[0] > 0:
             return tuple(float(x) / crgb[0] for x in crgb[1:])
-
-        return (0, 0, 0)
+        return 0, 0, 0
 
     def rgb(self):
         return tuple(int(x * 255) for x in self.scaled())
@@ -72,4 +67,7 @@ def measure():
 
 
 def help(widgest=False):
+    """
+    TCS3472 Color sensor
+    """
     return 'load', 'measure'

toolkit/workspace/precompiled/web/dashboard.html

@@ -38,6 +38,7 @@
 </head>
 <body>
     <h1> micrOS dashboard </h1>
+    <p id="restInfo"></p>
     <!-- Container for the dynamically generated list -->
     <section id="widgets-section"></section>
     <br><br><br>
@@ -54,6 +55,7 @@
     <script>
         document.addEventListener("DOMContentLoaded", function() {
             // Init basic info from board after DOM is fully loaded
+            restInfo(showPages=false);
 
             // INIT DASHBOARD (load active modules -> build page)
             DynamicWidgetLoad();

toolkit/workspace/precompiled/web/matrix_draw.html

@@ -0,0 +1,390 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+  <meta name="theme-color" content="black" media="(prefers-color-scheme: dark)" />
+  <title>micrOS Matrix Drawer</title>
+  <link rel="stylesheet" href="ustyle.css" />
+  <script src="uapi.js" defer></script>
+  <style>
+    body { font-family: sans-serif; margin: 20px; }
+    .layout {
+      display: flex; justify-content: center; align-items: flex-start;
+      gap: 20px; margin: 20px auto; flex-wrap: wrap;
+    }
+    .matrix { display: grid; gap: 2px; touch-action: none; }
+    .pixel {
+      width: 30px; height: 30px; background: #000; border: 1px solid #333;
+      cursor: pointer; user-select: none; touch-action: none;
+    }
+    input[type="number"], input[type="color"] { margin: 10px; padding: 4px; }
+    button { margin: 6px; padding: 6px 12px; }
+    pre {
+      text-align: left; max-width: 800px; margin: auto; background: #111;
+      color: #0f0; padding: 10px; overflow-x: auto;
+    }
+    textarea {
+      width: 100%; max-width: 400px; display: block; margin: 10px auto;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace;
+      background:#111; color:#0f0; border:1px solid #333; padding:8px;
+      resize:vertical; white-space:pre; overflow:auto;
+    }
+    .side-panel { flex: 0 0 420px; }
+    h1, .controls, h3 { text-align: center; }
+  </style>
+</head>
+<body>
+  <h1>microWeb Matrix LED Drawer</h1>
+  <p id="restInfo" class="controls"></p>
+
+  <!-- Controls -->
+  <div class="controls">
+    <input type="color" id="colorPicker" value="#00ff00" title="Pick LED color" class="custom-color-picker" />
+    <input type="number" id="matrixSize" value="8" min="1" max="64" title="Matrix size (NxN)" />
+    <button onclick="applySize()">Resize</button>
+    <button onclick="clearMatrix()">🧹 Clear Screen</button>
+    <button onclick="restAPI('neomatrix/stop', true)">⏹️ Stop Animation</button>
+    <button onclick="restAPI('neomatrix/snake', true)">▶️ Start Animation</button>
+  </div>
+
+  <!-- Matrix left, tools right -->
+  <div class="layout">
+    <!-- Matrix grid -->
+    <div id="matrix" class="matrix"></div>
+
+    <!-- Side panel -->
+    <div class="side-panel">
+      <!-- Read device state -->
+      <button id="readStateBtn" onclick="getMatrixState()">📥 Read Matrix State</button>
+      <textarea id="matrixStateOut" rows="4"
+        placeholder="Matrix state (original format) will appear here on ONE line…"></textarea>
+
+      <!-- Send Matrix Data -->
+      <h3>📤 Send Matrix Data</h3>
+      <textarea id="matrixInput" rows="6"
+        placeholder="Paste like: [(0,0,(131,17,0)), (1,0,(...)), ...]"></textarea>
+      <div style="display:flex;gap:10px;flex-wrap:wrap;justify-content:center">
+        <button id="sendMatrixBtn" onclick="sendMatrixFromInput()">🚀 Send (batched 15)</button>
+        <button onclick="applyMatrixInputLocally()">🖌️ Apply Locally</button>
+      </div>
+      <p id="matrixInputStatus" style="margin:6px auto;color:#9cf;text-align:center"></p>
+    </div>
+  </div>
+
+  <!-- REST Debug Console -->
+  <hr>
+  <h3>🛠 REST Debug Console</h3>
+  <p id="restConsoleUrl"></p>
+  <pre id="restConsoleResponse"></pre>
+  <p id="restConsoleTime"></p>
+
+  <!-- === ORIGINAL SCRIPT (unchanged except pointerleave/mouseleave for robustness) === -->
+  <script>
+    const matrixContainer = document.getElementById('matrix');
+    const colorPicker = document.getElementById('colorPicker');
+    const sizeInput = document.getElementById('matrixSize');
+    let pixels = [];
+    let drawing = false;
+    let activePointerId = null;
+    const supportsPointer = window.PointerEvent;
+
+    // Track last painted pixel
+    let lastX = null;
+    let lastY = null;
+
+    // --- Queue system (no overlapping REST calls) ---
+    let updateQueue = [];
+    let updating = false;
+
+    async function processQueue() {
+      if (updating || updateQueue.length === 0) return;
+      updating = true;
+      const { cmd } = updateQueue.shift();
+      try {
+        await restAPI(cmd, true);
+      } catch (err) {
+        console.warn("REST call failed:", err);
+      }
+      updating = false;
+      if (updateQueue.length > 0) processQueue();
+    }
+
+    function queueUpdate(cmd) {
+      updateQueue.push({ cmd });
+      processQueue();
+    }
+    // -------------------------------------------------
+
+    function startDrawing(e) {
+      drawing = true;
+      if (supportsPointer) {
+        activePointerId = e.pointerId;
+        matrixContainer.setPointerCapture(activePointerId);
+      }
+      paintPixel(e.target);
+      e.preventDefault();
+    }
+
+    function moveDrawing(e) {
+      if (!drawing) return;
+      let target;
+      if (supportsPointer) {
+        target = document.elementFromPoint(e.clientX, e.clientY);
+      } else if (e.touches && e.touches.length) {
+        const t = e.touches[0];
+        target = document.elementFromPoint(t.clientX, t.clientY);
+        e.preventDefault();
+      } else {
+        target = document.elementFromPoint(e.clientX, e.clientY);
+      }
+      if (target && target.classList.contains('pixel')) {
+        paintPixel(target);
+      }
+    }
+
+    function stopDrawing() {
+      drawing = false;
+      lastX = null;
+      lastY = null;
+      if (supportsPointer && activePointerId !== null) {
+        matrixContainer.releasePointerCapture(activePointerId);
+        activePointerId = null;
+      }
+    }
+
+    if (supportsPointer) {
+      matrixContainer.addEventListener('pointermove', moveDrawing);
+      window.addEventListener('pointerup', stopDrawing);
+      window.addEventListener('pointercancel', stopDrawing);
+      matrixContainer.addEventListener('pointerleave', stopDrawing); // added
+    } else {
+      matrixContainer.addEventListener('mousemove', moveDrawing);
+      matrixContainer.addEventListener('touchmove', moveDrawing, { passive: false });
+      window.addEventListener('mouseup', stopDrawing);
+      window.addEventListener('touchend', stopDrawing);
+      window.addEventListener('touchcancel', stopDrawing);
+      matrixContainer.addEventListener('mouseleave', stopDrawing); // added
+    }
+
+    function hexToRgb(hex) {
+      const val = parseInt(hex.slice(1), 16);
+      return [(val >> 16) & 255, (val >> 8) & 255, val & 255];
+    }
+
+    function buildMatrix(size) {
+      matrixContainer.innerHTML = "";
+      pixels = [];
+      matrixContainer.style.gridTemplateColumns = `repeat(${size}, 30px)`;
+      matrixContainer.style.gridTemplateRows = `repeat(${size}, 30px)`;
+
+      for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+          const cell = document.createElement('div');
+          cell.className = "pixel";
+          cell.dataset.x = x;
+          cell.dataset.y = y;
+          cell.dataset.color = "#000000";
+          cell.style.backgroundColor = "#000000";
+          if (supportsPointer) {
+            cell.addEventListener('pointerdown', startDrawing);
+          } else {
+            cell.addEventListener('mousedown', startDrawing);
+            cell.addEventListener('touchstart', startDrawing, { passive: false });
+          }
+          matrixContainer.appendChild(cell);
+          pixels.push(cell);
+        }
+      }
+      sendClearCommand();
+    }
+
+    function paintPixel(pixelDiv) {
+      const color = colorPicker.value;
+      const x = parseInt(pixelDiv.dataset.x);
+      const y = parseInt(pixelDiv.dataset.y);
+
+      // Only update if new pixel
+      if (x === lastX && y === lastY) return;
+      lastX = x;
+      lastY = y;
+
+      pixelDiv.dataset.color = color;
+      pixelDiv.style.backgroundColor = color;
+
+      const [r, g, b] = hexToRgb(color);
+      const cmd = `neomatrix/draw_colormap/[(${x},${y},(${r},${g},${b}))]`;
+      queueUpdate(cmd);
+    }
+
+    function clearMatrix() {
+      pixels.forEach(p => {
+        p.dataset.color = "#000000";
+        p.style.backgroundColor = "#000000";
+      });
+      sendClearCommand();
+    }
+
+    function sendClearCommand() {
+      queueUpdate("neomatrix/draw_colormap/[]");
+    }
+
+    function applySize() {
+      buildMatrix(parseInt(sizeInput.value, 10));
+    }
+
+    // Initialize matrix
+    buildMatrix(parseInt(sizeInput.value, 10));
+
+    document.addEventListener("DOMContentLoaded", function() {
+        // Add device info
+        restInfo(showPages=false);
+    });
+  </script>
+  <!-- === END original script === -->
+
+  <!-- === getMatrixState (robust parsing + auto-resize) === -->
+  <script>
+    // tolerant tuple parser used here and by sender
+    function parseTuplesRegex(str) {
+      if (!str || typeof str !== 'string') return null;
+      const out = [];
+      const re = /\(\s*(\d+)\s*,\s*(\d+)\s*,\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*\)/g;
+      let m;
+      while ((m = re.exec(str)) !== null) {
+        out.push({ x:+m[1], y:+m[2], r:+m[3], g:+m[4], b:+m[5] });
+      }
+      return out.length ? out : null;
+    }
+
+    function rgbToHex(r, g, b) {
+      const toHex = (n) => Math.max(0, Math.min(255, n|0)).toString(16).padStart(2, '0');
+      return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    function blackoutMatrixUI() {
+      const cells = document.querySelectorAll('.pixel');
+      cells.forEach(p => { p.dataset.color = "#000000"; p.style.backgroundColor = "#000000"; });
+    }
+    function ensureGridFits(cells) {
+      if (!Array.isArray(cells) || !cells.length) return;
+      const maxX = Math.max(...cells.map(c => c.x));
+      const maxY = Math.max(...cells.map(c => c.y));
+      const need = Math.max(maxX, maxY) + 1;
+      const current = parseInt(document.getElementById('matrixSize').value, 10) || 8;
+      if (need > current) {
+        document.getElementById('matrixSize').value = need;
+        applySize();
+      }
+    }
+
+    async function getMatrixState() {
+      const btn = document.getElementById('readStateBtn');
+      const out = document.getElementById('matrixStateOut');
+      if (btn) btn.disabled = true;
+      if (out) out.value = "Reading…";
+
+      try {
+        const resp = await restAPI('neomatrix/get_colormap', true);
+
+        // Extract original tuple-like data as a string
+        let raw = '';
+        if (resp && typeof resp === 'object' && 'result' in resp) raw = String(resp.result);
+        else if (typeof resp === 'string') raw = resp;
+        else if (resp && typeof resp.text === 'string') raw = resp.text;
+        else if (resp && typeof resp.body === 'string') raw = resp.body;
+        else raw = JSON.stringify(resp);
+
+        // Single-line for easy copy
+        const oneLine = String(raw).replace(/[\r\n]+/g, ' ').trim();
+        if (out) out.value = oneLine;
+
+        const parsed = parseTuplesRegex(oneLine);
+        blackoutMatrixUI();
+        if (!parsed) return;
+
+        ensureGridFits(parsed);
+
+        for (const {x,y,r,g,b} of parsed) {
+          const cell = document.querySelector(`.pixel[data-x="${x}"][data-y="${y}"]`);
+          if (!cell) continue;
+          const hex = rgbToHex(r,g,b);
+          cell.dataset.color = hex;
+          cell.style.backgroundColor = hex;
+        }
+      } catch (e) {
+        if (out) out.value = "Error: could not read matrix state.";
+        blackoutMatrixUI();
+      } finally {
+        if (btn) btn.disabled = false;
+      }
+    }
+    // expose globally (matches your original pattern)
+    window.getMatrixState = getMatrixState;
+  </script>
+  <!-- === END getMatrixState === -->
+
+  <!-- === SENDER: GLOBAL FUNCTIONS (fixes ReferenceError) === -->
+  <script>
+    function setSenderStatus(msg, isError=false){
+      const el = document.getElementById('matrixInputStatus');
+      if (!el) return;
+      el.textContent = msg;
+      el.style.color = isError ? '#f99' : '#9cf';
+    }
+    function applyCellsToUI(cells){
+      for (const {x,y,r,g,b} of cells) {
+        const cell = document.querySelector(`.pixel[data-x="${x}"][data-y="${y}"]`);
+        if (!cell) continue;
+        const toHex = n => Math.max(0,Math.min(255,n|0)).toString(16).padStart(2,'0');
+        const hex = `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+        cell.dataset.color = hex;
+        cell.style.backgroundColor = hex;
+      }
+    }
+    function buildPayload(cells){
+      const parts = cells.map(({x,y,r,g,b}) => `(${x},${y},(${r},${g},${b}))`);
+      return `[${parts.join(',')}]`.replace(/\//g, '');
+    }
+
+    // Make these GLOBAL so inline onclick finds them:
+    function applyMatrixInputLocally(){
+      const raw = (document.getElementById('matrixInput')?.value || '').trim();
+      const parsed = parseTuplesRegex(raw);
+      if (!parsed) { setSenderStatus('Could not parse input. Use [(x,y,(r,g,b)), ...]', true); return; }
+      applyCellsToUI(parsed);
+      setSenderStatus(`Applied ${parsed.length} cells locally.`);
+    }
+
+    function sendMatrixFromInput(){
+      const btn = document.getElementById('sendMatrixBtn');
+      const raw = (document.getElementById('matrixInput')?.value || '').trim();
+      const parsed = parseTuplesRegex(raw);
+      if (!parsed) { setSenderStatus('Could not parse input. Use [(x,y,(r,g,b)), ...]', true); return; }
+
+      if (btn) btn.disabled = true;
+      setSenderStatus(`Sending ${parsed.length} cells in batches of 15…`);
+
+      // Update UI immediately for responsiveness
+      applyCellsToUI(parsed);
+
+      const CHUNK = 10;
+      let sent = 0;
+      for (let i = 0; i < parsed.length; i += CHUNK) {
+        const chunk = parsed.slice(i, i + CHUNK);
+        const payload = buildPayload(chunk);
+        const cmd = `neomatrix/draw_colormap/${payload}`;
+        queueUpdate(cmd);
+        sent += chunk.length;
+      }
+
+      setSenderStatus(`Queued ${sent} cells in ${Math.ceil(parsed.length / CHUNK)} batch(es).`);
+      if (btn) btn.disabled = false;
+    }
+
+    // Expose on window explicitly (paranoia, but harmless)
+    window.applyMatrixInputLocally = applyMatrixInputLocally;
+    window.sendMatrixFromInput = sendMatrixFromInput;
+  </script>
+  <!-- === END sender === -->
+</body>
+</html>

toolkit/workspace/precompiled/web/uapi.js

@@ -41,18 +41,21 @@ function restConsole(apiUrl, data, delta) {
     document.getElementById('restConsoleTime').innerHTML = `⏱ Response time: ${delta} ms`;
 }
 
-function restInfo() {
+function restInfo(showPages=true) {
     // UPDATES: 'restInfo' and restConsole(...)
-    restAPICore(cmd='').then(({ response, delta, query }) => {
+    restAPICore(cmd = '').then(({ response, delta, query }) => {
         // Update API Console
         restConsole(query, response, delta)
-        // Update 'SysApiInfo' tag
+        // Update 'restInfo' tag
         const result = response['result'];
         const auth = result.auth ? "🔑" : "";
         let infoHeader = `micrOS: ${result.micrOS} ❖ node: ${result.node}${auth}`;
-        let infoSubpages = (response['result']['usr_endpoints'] ? "<br><br>📎 " + Object.entries(response['result']['usr_endpoints'])
-            .map(([key, value]) => `<a href="${value}" target="_blank" style="color: white;">${value} </a>`)
-            .join(' | ') : '');
+        let infoSubpages = "";
+        if (showPages && result['usr_endpoints']) {
+            infoSubpages = "<br><br>📎 " + Object.entries(result['usr_endpoints'])
+                .map(([key, value]) => `<a href="${value}" target="_blank" style="color: white;">${value} </a>`)
+                .join(' | ');
+        }
         document.getElementById('restInfo').innerHTML = infoHeader + infoSubpages;
     }).catch(error => {
         console.error('Error in restAPI:', error);

micrOS/source/IO_esp32c6.py

@@ -1,16 +0,0 @@
-from micropython import const
-
-# BUILTIN LED
-builtin = const(-15)     # BUILT IN LED - progress_led
-
-
-# I2C BUS
-i2c_sda = const(4)    # D21 - oled - data
-i2c_scl = const(5)    # D22 - oled - clock
-
-
-# EXTERNAL EVENT IRQ
-irq1 = const(3)         # D4  - event irq pin
-irq2 = const(2)        # D18 - event irq pin
-irq3 = const(1)         # D19  - event irq pin
-irq4 = const(0)        # D13  - event irq pin