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

toolkit/workspace/precompiled/modules/LM_tcs3472.py

@@ -0,0 +1,187 @@
+"""
+A MicroPython library for the TCS3472 light sensing chip
+https://github.com/tti0/tcs3472-micropython
+
+Copyright (c) 2021 tti0
+Licensed under the MIT License
+"""
+
+from struct import unpack
+from time import sleep
+from machine import I2C, Pin, PWM
+from microIO import bind_pin, pinmap_search
+from Types import resolve
+
+from LM_neopixel import load as neo_load, color as neo_color, toggle as neo_toggle    # local neopixel light indicator
+from LM_cluster import run as cluster_run                                             # DEMO: neomatrix cluster
+
+CURRENT_ANIMATION_INDEX = 0                                                           # DEMO: neomatrix cluster animation
+
+class TCS3472:
+    INSTANCE = None
+
+    def __init__(self, address=0x29, led_pin=None):
+        self._bus = I2C(sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl')))
+        self._i2c_address = address
+        self._bus.writeto(self._i2c_address, b'\x80\x03')
+        self._bus.writeto(self._i2c_address, b'\x81\x2b')
+        self.led = PWM(Pin(bind_pin('led', led_pin), Pin.OUT), freq=20480)
+        self.led_brightness = 20
+        TCS3472.INSTANCE = self
+
+    def scaled(self, saturation=1.5):
+        """
+        Normalize by strongest color, then adjust saturation.
+        saturation = 1.0 -> normal
+        saturation > 1.0 -> more vibrant
+        saturation < 1.0 -> more pastel
+        """
+        _, r, g, b = self.raw()
+        m = max(r, g, b)
+        if m == 0:
+            return 0.0, 0.0, 0.0
+
+        # Normalize by strongest channel
+        r, g, b = r / m, g / m, b / m
+
+        # Grayscale = average of channels
+        gray = (r + g + b) / 3
+
+        # Interpolate between gray and color
+        r = gray + (r - gray) * saturation
+        g = gray + (g - gray) * saturation
+        b = gray + (b - gray) * saturation
+
+        # Clamp to 0..1
+        return max(0, min(1, r)), max(0, min(1, g)), max(0, min(1, b))
+
+    def rgb(self):
+        return tuple(int(x * 255) for x in self.scaled())
+
+    def light(self):
+        return self.raw()[0]
+
+    def brightness(self, level=65.535):
+        return int((self.light() / level))
+
+    def valid(self):
+        self._bus.writeto(self._i2c_address, b'\x93')
+        return self._bus.readfrom(self._i2c_address, 1)[0] & 1
+
+    def raw(self):
+        self._bus.writeto(self._i2c_address, b'\xb4')
+        return unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
+
+
+############################ Exposed functions ############################
+
+def load(led_pin=20):
+    """
+    Load the TCS3472 Color sensor instance.
+    """
+    if TCS3472.INSTANCE is None:
+        TCS3472(led_pin=led_pin)
+        neo_load(ledcnt=1)
+        led(False)
+    return TCS3472.INSTANCE
+
+
+def pinmap():
+    """
+    Show used pin mapping for this module.
+    """
+    return pinmap_search(['i2c_scl', 'i2c_sda', 'led'])
+
+
+def measure():
+    """
+    MEASURE sensor
+    """
+    sensor = load()
+    measurement = {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+    return measurement
+
+
+def led(state:bool=None, br:int=None):
+    """
+    SENSOR LED toggle
+    :param state: None-automatic, True-ON, False-OFF
+    :param br: brightness 0-100
+    """
+    def _set_duty(_br):
+        _br = sensor.led_brightness if _br is None else _br
+        sensor.led.duty(int(_br * 10))
+        if _br != 0:
+            sensor.led_brightness = _br
+
+    sensor = load()
+    if state is None:
+        # INVERT STATE
+        led_current_state = sensor.led.duty() > 0
+        if led_current_state:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+        else:
+            _set_duty(br)
+            neo_toggle(True)
+    else:
+        # SET STATE: ON/OFF
+        if state:
+            _set_duty(br)
+            neo_toggle(True)
+        else:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+    return f"LED on, {sensor.led_brightness}%" if sensor.led.duty()>0 else f"LED off"
+
+
+def indicator(br=5):
+    """
+    Color indicator Neopixel LED update
+    :param br: brightness 0-100
+    """
+    r, g, b = measure()['rgb']
+    br = float(br / 100)
+    _r, _g, _b = int(r*br), int(g*br), int(b*br)
+    neo_color(_r, _g, _b, smooth=False)
+    return r, g, b
+
+
+def neomatrix_update():
+    """
+    DEMO - Send color codes for all neomatrix devices over espnow cluster
+    """
+    r, g, b = indicator()
+    command = f"neomatrix color_fill {r} {g} {b}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def neomatrix_animation():
+    """
+    DEMO - Set random animation on neomatrix espnow cluster
+    """
+    global CURRENT_ANIMATION_INDEX
+    animations = ('spiral', 'snake', 'noise')
+
+    next_animation = CURRENT_ANIMATION_INDEX + 1
+    CURRENT_ANIMATION_INDEX = 0 if next_animation >= len(animations) else next_animation
+    command = f"neomatrix {animations[CURRENT_ANIMATION_INDEX]}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def help(widgets=False):
+    """
+    TCS3472 Color sensor
+    """
+    return resolve(('load led_pin=20',
+                    'TEXTBOX measure',
+                    'BUTTON led state=<True,False>',
+                    'SLIDER led state=True br=<0-100-5>',
+                    'indicator br=<0-100>',
+                    'BUTTON neomatrix_update',
+                    'BUTTON neomatrix_animation',
+                    'pinmap'), widgets=widgets)

{micrOS/source → toolkit/workspace/precompiled/web}/dashboard.html

@@ -38,6 +38,9 @@
 </head>
 <body>
     <h1> micrOS dashboard </h1>
+    <div id="restInfo">
+      <div id="restInfoHeader"></div>
+    </div>
     <!-- Container for the dynamically generated list -->
     <section id="widgets-section"></section>
     <br><br><br>
@@ -54,6 +57,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/editor.js

@@ -0,0 +1,440 @@
+/* ============================================================
+ * Embedded MicroPython Editor
+ * Self-contained, embeddable, dependency-free
+ *
+ * Public API:
+ *   createEditor(container)
+ *   openEditor(url, { anchor, list })
+ *   destroyEditor()
+ * ============================================================ */
+
+let _editor = null;
+
+// 🔹 track original DOM position of editor container
+let _host = {
+    container: null,
+    parent: null,
+    next: null
+};
+
+/* ---------- Public API ---------- */
+
+window.createEditor = function (container) {
+    console.info("editor.js: createEditor");
+    injectCSS();
+
+    if (!_editor) {
+        _host.container = container;
+        _host.parent = container.parentNode;
+        _host.next = container.nextSibling;
+
+        _editor = new EmbeddedEditor(container);
+    }
+    return _editor;
+};
+
+window.openEditor = function (url, opts = {}) {
+    if (!_editor) {
+        console.warn("Editor not active");
+        return;
+    }
+    console.info("editor.js: openEditor");
+    const { anchor, list } = opts;
+    const c = _host.container;
+    // 🔹 editor owns placement logic
+    if (anchor) {
+        anchor.insertAdjacentElement("afterend", c);
+        console.info("editor.js: openEditor.placed after selected element");
+    } else if (list) {
+        list.insertAdjacentElement("beforebegin", c);
+        console.info("editor.js: openEditor.placed before selected element");
+    }
+
+    _editor.open(url);
+};
+
+window.destroyEditor = function () {
+    if (_editor) {
+        _editor.close();
+        if (_host.container) {
+            _host.container.remove();
+            console.info("editor.js: destroyEditor - container removed");
+        }
+        _editor = null;
+        _host.container = null;
+        _host.parent = null;
+        _host.next = null;
+        console.info("editor.js: destroyEditor - editor destroyed");
+    }
+};
+
+/* ---------- CSS (scoped + injected) ---------- */
+
+function injectCSS() {
+    if (document.getElementById("mp-editor-css")) return;
+
+    const css = document.createElement("style");
+    css.id = "mp-editor-css";
+    css.textContent = `
+.mp-editor {
+    font-family: monospace;
+    background: #1e1e1e;
+    color: #d4d4d4;
+}
+.mp-editor .toolbar {
+    background: #252526;
+    padding: 6px;
+    display: flex;
+    gap: 6px;
+    align-items: center;
+}
+.mp-editor input {
+    background: #1e1e1e;
+    color: #d4d4d4;
+    border: 1px solid #555;
+    padding: 4px 6px;
+}
+.mp-editor button {
+    background: #0e639c;
+    border: none;
+    color: #fff;
+    padding: 6px 10px;
+    cursor: pointer;
+}
+.mp-editor button:hover { background: #1177bb; }
+.mp-editor .close {
+    margin-left: auto;
+    background: transparent;
+    color: #ccc;
+    font-size: 16px;
+    padding: 4px 8px;
+}
+.mp-editor .close:hover { background: #333; color: #fff; }
+.mp-editor .status { font-size: 13px; }
+.mp-editor .status.ok   { color: #6a9955; }
+.mp-editor .status.err  { color: #f44747; }
+.mp-editor .status.info { color: #cccccc; }
+.mp-editor .editor {
+    display: flex;
+    height: 500px;
+    overflow: hidden;
+}
+.mp-editor .lines {
+    background: #252526;
+    color: #858585;
+    padding: 8px;
+    text-align: right;
+    user-select: none;
+    line-height: 20px;
+    flex-shrink: 0;
+    overflow: hidden;
+    white-space: pre;
+}
+.mp-editor textarea {
+    flex: 1;
+    background: #1e1e1e;
+    color: #d4d4d4;
+    border: none;
+    padding: 8px;
+    resize: none;
+    outline: none;
+    font-family: monospace;
+    line-height: 20px;
+    overflow: auto;
+}
+.mp-editor .lines,
+.mp-editor input,
+.mp-editor textarea {
+    font-size: 14px;
+}
+`;
+    document.head.appendChild(css);
+}
+
+/* ---------- Syntax registry ---------- */
+
+// 🔹 NEW
+const SYNTAX_CHECKERS = {
+    ".py": checkPythonSyntax,
+    // ".js": checkJSSyntax,
+    // ".html": checkHTMLSyntax,
+};
+
+// 🔹 NEW
+function getCheckerFor(name) {
+    const ext = "." + name.split(".").pop().toLowerCase();
+    return SYNTAX_CHECKERS[ext] || null;
+}
+
+/* ---------- Editor Implementation ---------- */
+
+class EmbeddedEditor {
+    constructor(container) {
+        this.container = container;
+        this.buildUI();
+        this.bindEvents();
+    }
+
+    buildUI() {
+        console.info("editor.js: EmbeddedEditor.buildUI");
+        this.container.innerHTML = `
+<div class="mp-editor">
+    <div class="toolbar">
+        <input class="filename" value="">
+        <button class="load">Load</button>
+        <button class="save">Save</button>
+        <button class="syntax">Syntax</button>
+        <span class="status info">ready</span>
+        <button class="close" title="Close">✕</button>
+    </div>
+    <div class="editor">
+        <div class="lines"></div>
+        <textarea class="code" wrap="off"></textarea>
+    </div>
+</div>`;
+        this.codeEl = this.container.querySelector(".code");
+        this.linesEl = this.container.querySelector(".lines");
+        this.fileEl = this.container.querySelector(".filename");
+        this.statusEl = this.container.querySelector(".status");
+        this.syntaxBtn = this.container.querySelector(".syntax"); // 🔹 NEW
+    }
+
+    bindEvents() {
+        this.codeEl.addEventListener("input", () => {
+            this.updateLines();
+            this.setStatus("edited");
+        });
+        this.codeEl.addEventListener("scroll", () =>
+            this.linesEl.scrollTop = this.codeEl.scrollTop
+        );
+        this.codeEl.addEventListener("keydown", e => {
+            if (e.key === "Tab") {
+                e.preventDefault();
+                const s = this.codeEl.selectionStart;
+                const ePos = this.codeEl.selectionEnd;
+                this.codeEl.value =
+                    this.codeEl.value.slice(0, s) +
+                    "    " +
+                    this.codeEl.value.slice(ePos);
+                this.codeEl.selectionStart = this.codeEl.selectionEnd = s + 4;
+                this.updateLines();
+            }
+        });
+        this.fileEl.addEventListener("input", () => // 🔹 NEW
+            this.updateSyntaxAvailability()
+        );
+        this.container.querySelector(".load")
+            .addEventListener("click", () => this.loadFile());
+        this.container.querySelector(".save")
+            .addEventListener("click", () => this.save());
+        this.container.querySelector(".syntax")
+            .addEventListener("click", () => this.syntaxCheck());
+        this.container.querySelector(".close")
+            .addEventListener("click", () => window.destroyEditor());
+    }
+
+    /* ---------- UI helpers ---------- */
+
+    setStatus(text, type = "info") {
+        this.statusEl.textContent = text;
+        this.statusEl.className = "status " + type;
+    }
+
+    updateSyntaxAvailability() { // 🔹 NEW
+        this.syntaxBtn.style.display =
+            getCheckerFor(this.fileEl.value) ? "" : "none";
+    }
+
+    updateLines() {
+        const scroll = this.codeEl.scrollTop;
+        const count = this.codeEl.value.split("\n").length;
+        this.linesEl.textContent =
+            Array.from({ length: count }, (_, i) => i + 1).join("\n");
+        this.linesEl.scrollTop = scroll;
+    }
+
+    /* ---------- File ops ---------- */
+    open(url) {
+        const name = url?.split("/").pop();
+        this.setStatus("loading...");
+        fetch(url)
+            .then(r => r.ok ? r.text() : Promise.reject())
+            .then(t => {
+                // 🔹 Success → show file content + path
+                this.codeEl.value = t;
+                this.fileEl.value = url;
+                this.updateLines();
+                this.updateSyntaxAvailability();
+                this.setStatus("loaded", "ok");
+            })
+            .catch(() => {
+                // 🔹 Failure → special case for LM_blinky.py
+                if (name === "LM_blinky.py") {
+                    this.fileEl.value = url || ""; // 🔹 show path in input
+                    this.loadExample();
+                } else {
+                    // 🔹 Empty editor, but still show file path
+                    this.codeEl.value = "";
+                    this.fileEl.value = url || "";
+                    this.updateLines();
+                    this.updateSyntaxAvailability();
+                    this.setStatus("file not found or unreadable", "err");
+                }
+            });
+    }
+
+    loadFile() {
+        if (!this.fileEl.value)
+            return this.setStatus("no filename", "err");
+        console.info("editor.js: EmbeddedEditor.loadFile: ", this.fileEl.value);
+        this.open(this.fileEl.value);
+    }
+
+    save() {
+        const name = this.fileEl.value;
+        if (!name) {
+            this.setStatus("no filename", "err");
+            return;
+        }
+
+        console.info("editor.js: EmbeddedEditor.save (upload): ", name);
+        const blob = new Blob([this.codeEl.value], { type: "text/plain" });
+        const file = new File([blob], name);
+        const fd = new FormData();
+        fd.append("file", file);
+
+        fetch("/fs/files", { method: "POST", body: fd })
+          .then(async r => {
+            if (!r.ok) {
+              const t = (await r.text()) || r.statusText;
+              console.error("editor.js: upload failed:", r.status, r.statusText, t);
+              throw new Error(`${r.status} - ${t}`);
+            }
+            this.setStatus("saved", "ok");
+          })
+          .catch(err => {
+              console.error("editor.js: upload error:", err);
+              this.setStatus("Save failed: " + err.message, "err");
+          });
+    }
+
+    /* ---------- Syntax ---------- */
+    syntaxCheck() { // 🔹 MODIFIED
+        const checker = getCheckerFor(this.fileEl.value);
+        if (!checker) return;
+
+        const r = checker(this.codeEl.value);
+        this.setStatus(
+            r.ok ? "syntax OK" : Object.entries(r.errors[0]).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(" "),
+            r.ok ? "ok" : "err"
+        );
+    }
+
+    /* ---------- Close ---------- */
+    close() {
+        this.container.innerHTML = "";
+    }
+
+    /* ---------- Example ---------- */
+
+    loadExample() {
+      console.info("editor.js: EmbeddedEditor.loadExample");
+      this.codeEl.value =
+`# LM_blinky.py – MicroPython example
+# Guide: https://github.com/BxNxM/micrOS/blob/master/APPLICATION_GUIDE.md
+import machine
+from microIO import bind_pin, pinmap_search
+from Common import micro_task
+
+global LED = None
+
+def load(pin=2):
+    global LED
+    if LED is None:
+        LED = machine.Pin(bind_pin("led", pin), machine.Pin.OUT)
+    return LED
+
+@micro_task("blinky", _wrap=True)
+def blink(tag):
+    with micro_task(tag=tag) as my_task:
+        if LED is None:
+            my_task.out = "LED uninitialized"
+            return
+        my_task.out = "BlinkyBlink task"
+        while True:
+           LED.value(not LED.value())
+           await my_task.feed(sleep_ms=500)
+
+def pinmap():
+    return pinmap_search(['led'])
+
+def help(widgets=False):
+    return "load pin=2", "blink", "pinmap"
+`;
+      this.updateLines();
+      this.updateSyntaxAvailability();
+      this.setStatus("example loaded", "info");
+    }
+
+}
+
+/* ----------  Syntax checker(s) ---------- */
+
+function checkPythonSyntax(text) {
+    const lines = text
+        .replace(/\t/g, "    ")
+        .replace(/\s+$/, "")
+        .split("\n");
+    const stack = [0];
+    const errors = [];
+    const colonRE = /^(async\s+)?(def|with|class)\s+/;
+    let depth = 0;
+    function lastCodeLine(i) {
+        while (i >= 0) {
+            const t = lines[i].trim();
+            if (t && !t.startsWith("#")) return t;
+            i--;
+        }
+        return "";
+    }
+    function updateDepth(d, line) {
+        for (const c of line.replace(/#.*$/, "")) {
+            if ("([{".includes(c)) d++;
+            else if (")]}".includes(c)) d = Math.max(0, d - 1);
+        }
+        return d;
+    }
+    lines.forEach((line, i) => {
+        const n = i + 1;
+        const t = line.trim();
+        const depthBefore = depth;
+        depth = updateDepth(depth, line);
+        const topLevel = depthBefore === 0 && depth === 0;
+        if (!t || t.startsWith("#")) return;
+        const ind = line.match(/^ */)[0].length;
+        const cur = stack[stack.length - 1];
+        // Indentation check (only at top level)
+        if (topLevel) {
+            if (ind > cur) {
+                const prev = lastCodeLine(i - 1);
+                if (!prev.endsWith(":")) {
+                    errors.push({ line: n, error: "indent", prev, got: ind, expected: cur });
+                    return;
+                }
+                stack.push(ind);
+            }
+            while (stack.length > 1 && ind < stack[stack.length - 1]) {
+                stack.pop();
+            }
+            if (ind !== stack[stack.length - 1]) {
+                errors.push({ line: n, error: "dedent", got: ind, expected: stack[stack.length - 1] });
+                return;
+            }
+        }
+        // Colon check
+        if (colonRE.test(t) && !t.endsWith(":")) {
+            errors.push({ line: n, error: "colon", lineText: t });
+        }
+    });
+    return { ok: errors.length === 0, errors };
+}