micrOSDevToolKit 2.0.4__tar.gz → 2.0.5__tar.gz

{micrOSDevToolKit-2.0.4/micrOSDevToolKit.egg-info → micrOSDevToolKit-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: micrOSDevToolKit
-Version: 2.0.4
+Version: 2.0.5
 Summary: Development and deployment environment for micrOS, the diy micropython automation OS (IoT)
 Home-page: https://github.com/BxNxM/micrOS
 Author: Marcell Ban

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5}/micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -58,7 +58,7 @@
         ],
         "microIO.py": [
             9.08,
-            37
+            38
         ],
         "micrOS.py": [
             9.3,
@@ -109,7 +109,7 @@
             0
         ],
         "LM_oled.py": [
-            9.29,
+            9.3,
             3
         ],
         "LM_tinyrgb.py": [
@@ -145,7 +145,7 @@
             0
         ],
         "LM_oled_sh1106.py": [
-            8.83,
+            8.84,
             1
         ],
         "LM_ld2410.py": [
@@ -154,7 +154,7 @@
         ],
         "LM_neopixel.py": [
             7.57,
-            4
+            2
         ],
         "LM_cct.py": [
             8.82,
@@ -193,7 +193,7 @@
             0
         ],
         "LM_keychain.py": [
-            8.81,
+            9.15,
             0
         ],
         "LM_dht11.py": [
@@ -271,7 +271,7 @@
             19
         ],
         "load": [
-            6610,
+            6685,
             47
         ],
         "core_dep": [
@@ -283,7 +283,7 @@
             7
         ],
         "core_score": 9.18,
-        "load_score": 8.17,
-        "version": "2.0.4-0"
+        "load_score": 8.18,
+        "version": "2.0.4-3"
     }
 }

micrOSDevToolKit-2.0.5/micrOS/source/LM_keychain.py

@@ -0,0 +1,300 @@
+import uasyncio as asyncio
+from Common import micro_task
+from utime import localtime
+from Network import ifconfig
+from LM_oled import text, show, rect, pixel, clean, line, load_n_init as oled_lni
+from LM_ds18 import measure
+from microIO import physical_pin, pinmap_dump
+from neopixel import NeoPixel
+from machine import Pin
+try:
+    from LM_gameOfLife import next_gen as gol_nextgen, reset as gol_reset
+except:
+    gol_nextgen = None      # Optional function handling
+
+class KC:
+    INITED = False          # Auto init module feature
+    DP_main_page = True     # store display logical state: ON (main page) / OFF (screen saver)
+    DP_cnt = 0              # display "count back", when 0 go to sleep -> OFF
+    DP_cnt_default = None   # store calculated sequence to sleep 30sec/period_ms
+    NEOPIXEL_OBJ = None     # Neopixel LED handler object
+    COLOR_WHEEL = None      # LED color wheel generator object for animation
+    NEOPIXEL_BR = 30        # default neopixel brightness
+
+#############################
+#    INTERNAL FUNCTIONS     #
+#############################
+
+
+async def _screen_saver(scale=2):
+    """
+    Conway's game of life screen saver simulation
+    :param scale: default (2) game of life matrix (16x32) upscale to real display size 32x64
+    """
+    # Default mode
+    if gol_nextgen is None:
+        return      # screen off - no screen saver...
+    # Screen saver mode
+    matrix = gol_nextgen(raw=True)
+    if matrix is None:
+        # Reset Game of life
+        gol_reset()
+        # flash main page - quick view
+        await _main_page()                  # Run main screen page coroutine
+        await asyncio.sleep_ms(3000)        # Wait 3s to show main screen before continue screensaver
+    else:
+        # Update display with Conway's Game of Life
+        clean()
+        for line_idx, _line in enumerate(matrix):
+            for x_idx, v in enumerate(_line):
+                if scale == 1:
+                    pixel(x_idx, line_idx, color=v)
+                else:
+                    rect(x_idx*scale, line_idx*scale, w=scale, h=scale, state=v, fill=True)
+        show()
+
+
+def _color_wheel():
+    """
+    RGB LED color wheel generator - rainbow
+    """
+    max_val = 10                    # normally up to 255, but must be limited due to heat problems (4%)
+    half_val = max_val // 2
+    colors = ((0, 0, half_val), (0, 0, max_val), (0, half_val, max_val), (0, max_val, half_val), (0, max_val, 0),
+              (half_val, max_val, 0), (max_val, half_val, 0), (max_val, 0, 0), (half_val, 0, 0), (max_val, 0, half_val),
+              (half_val, 0, max_val), (0, 0, half_val))
+    while True:
+        # Loop through the colors to generate smooth transitions
+        for i in range(len(colors) - 1):
+            start_color = colors[i]
+            end_color = colors[i + 1]
+            # Generate a smooth transition from start_color to end_color
+            for j in range(5):  # Adjust this value for smoother or faster transition
+                # Linear interpolation for each color component
+                yield tuple(int(start + (end - start) * j / 10) for start, end in zip(start_color, end_color))
+
+
+async def _main_page():
+    """
+    Run display content refresh
+        #   H:M
+         S/A: 1.92
+         40.0 C
+    """
+    def _cube():
+        # 5x5 px cube (25px overall)
+        _offset, _l_width = 2, 5                                # Initial size + positioning
+        _view = int(25*(KC.DP_cnt/KC.DP_cnt_default))           # overall pixel to be visualized
+        _complete_lines = int(_view / _l_width)                 # complete lines number
+        _sub_line = _view - (_complete_lines*_l_width)          # incomplete line width
+        for _l in range(0, 5):
+            if _l < _complete_lines:
+                line(0+_offset, _l+_offset, _l_width+_offset, _l+_offset)
+            else:
+                line(0+_offset, _l+_offset, _sub_line+_offset, _l+_offset)
+                break
+
+    # Clean display and collect input data: time, network mode, IP address
+    clean()
+    ltime = localtime()
+    h = f"0{ltime[-5]}" if len(str(ltime[-5])) < 2 else ltime[-5]
+    m = f"0{ltime[-4]}" if len(str(ltime[-4])) < 2 else ltime[-4]
+    nwmd, nwif = ifconfig()
+    nwmd, devip = nwmd[0] if len(nwmd) > 0 else "0", ".".join(nwif[0].split(".")[-2:])
+
+    # Draw data to display
+    _cube()                                                                     # Draw display timer (until screen saver)
+    text(f"{h}:{m}", x=12, y=1)                                           # Header: time
+    text(f"{nwmd}:{devip}", x=4, y=15)                                    # Network mode and IP
+    try:
+        text(f"{round(tuple(measure().values())[0], 1)} C", x=4, y=25)    # ds18 sensor value
+    except Exception:
+        text("? C", x=4, y=25)                                            # ds18 read issue (default: ?)
+    show()
+    return "Display show"
+
+
+async def _task(period_ms):
+    """
+    Async display refresh task
+    - main page    (main mode)  - auto sleep after 30 sec
+    - screen saver (sleep mode)
+    """
+    # Auto init keychain module (if needed) - failsafe
+    if not KC.INITED:
+        _v = load_n_init()
+        if not KC.INITED:
+            return _v
+
+    KC.DP_cnt_default = int(30_000 / period_ms)     # After 30 sec go to sleep mode
+    KC.DP_cnt = KC.DP_cnt_default                   # Set sleep counter
+    fast_period = int(period_ms/3)                  # Calculate faster refresh period
+    fast_period = fast_period if fast_period > 100 else 100
+
+    # Run keychain main async loop, with update ID: kc._display
+    with micro_task(tag="kc._display") as my_task:
+        while True:
+            if KC.DP_main_page:
+                # [MAIN MODE] Execute main page
+                await _main_page()                          #1 Run main page function
+                my_task.out = f'main page: {KC.DP_cnt}'     #2 Update task data for (task show kc._display)
+                KC.DP_cnt -= 1                              #3 Update sleep counter
+                # Async sleep - feed event loop
+                await asyncio.sleep_ms(period_ms)
+            else:
+                # [SLEEP MODE] Execute screen saver page
+                await _screen_saver()                       # Run sleep page function
+                # Async sleep - feed event loop
+                await asyncio.sleep_ms(fast_period)
+
+            # Auto sleep event handler - off event - go to (sleep mode)
+            if KC.DP_cnt <= 0:
+                KC.DP_main_page = False         #1 disable main screen
+                clean()                         #2 clean screen
+                show()                          #3 show cleaned display
+                KC.DP_cnt = KC.DP_cnt_default   #4 reset sleep counter to default
+                my_task.out = 'sleep...'
+            neopixel_color_wheel()              # update neopixel color wheel
+
+
+def _boot_page(msg):
+    clean()
+    msg_len = len(msg)*8                # message text length in pixels
+    x_offset = int((64 - msg_len)/2)    # x (width) center-ing offset
+    text(msg, x=x_offset, y=11)         # y(height):32 TODO: Auto positioning in y axes (multi line...)
+    show()
+
+
+#############################
+#      PUBLIC FUNCTIONS     #
+#############################
+
+def load_n_init(width=64, height=32, bootmsg="micrOS"):
+    """
+    Init OLED display 64x32 (default)
+    Init Neopixel LED (1 segment)
+    :param width: screen width (pixel)
+    :param height: screen height (pixel)
+    :param bootmsg: First text on page at bootup, default: "micrOS"
+    """
+    KC.COLOR_WHEEL = _color_wheel()             #1 Init neopixel color wheel generator
+    try:
+        oled_lni(width, height, brightness=20)  #2 Init oled display
+        _boot_page(bootmsg)                     #3 Show boot page text
+        KC.INITED = True                        # Set display was successfully inited (for _task auto init)
+        return "OLED INIT OK"
+    except Exception as e:
+        KC.INITED = False                       # display init failed (for _task auto init)
+        return f"OLED INIT NOK: {e}"
+
+
+def display(period=1000):
+    """
+    Create kc._display task - refresh loop
+    :param period: display refresh period in ms (min. 500ms)
+    """
+    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    period_ms = 500 if period < 500 else period
+    state = micro_task(tag="kc._display", task=_task(period_ms=period_ms))
+    return "Starting" if state else "Already running"
+
+
+def temperature():
+    """
+    Measure ds18B20 temperature sensor
+    """
+    return measure()
+
+
+def neopixel_color_wheel(br=None):
+    """
+    Neopixel color wheel
+    :param br: brightness value 0-100 percent
+    :param run: run led update / disable
+    """
+    def _init():
+        if KC.NEOPIXEL_OBJ is None:
+            neopixel_pin = Pin(physical_pin('neop'))        # Get Neopixel pin from LED PIN pool
+            KC.NEOPIXEL_OBJ = NeoPixel(neopixel_pin, n=1)   # initialize for max 1 segment
+        return KC.NEOPIXEL_OBJ
+    # INIT
+    neo_led = _init()
+    if br is None or not isinstance(br, int):       # Optional brightness param handling (load from cache)
+        br = KC.NEOPIXEL_BR
+    else:
+        KC.NEOPIXEL_BR = br                         # update neopixel brightness cache
+    if KC.COLOR_WHEEL is None:
+        KC.COLOR_WHEEL = _color_wheel()             # init color wheel generator
+    # UPDATE
+    r, g, b = next(KC.COLOR_WHEEL)                  # get next color
+    br = br if br == 100 else br/100                # calculate brightness multiplier
+    r, g, b = int(r*br), int(g*br), int(b*br)       # apply brightness parameter
+    neo_led[0] = (r, g, b)                          # Set LED element color
+    neo_led.write()                                 # Send data to LED device
+    return {'R': r, 'G': g, 'B': b, 'S': 1, 'br': br}   # Return verdict
+
+
+def display_toggle():
+    """
+    Display mode toggle (main/screensaver)
+    """
+    KC.DP_main_page = not KC.DP_main_page
+    if not KC.DP_main_page:
+        # Reset display counter when goes to sleep
+        KC.DP_cnt = KC.DP_cnt_default
+    v = 'main view' if KC.DP_main_page else 'screensaver'
+    return f"Display mode: {v}"
+
+
+def neopixel_toggle():
+    """
+    Disable/Enable neopixel LED (brightness 0/default)
+    """
+    KC.NEOPIXEL_BR = 0 if KC.NEOPIXEL_BR > 0 else 30
+    v = 'disabled' if KC.NEOPIXEL_BR == 0 else 'enabled'
+    return f"Neopixel: {v} br: {KC.NEOPIXEL_BR}"
+
+def press_event():
+    """
+    IRQ1 keychain module control function
+    - neopixel ON/OFF
+    - display wake-up (ON)
+    """
+    # If display is ON call neopixel toggle function
+    if KC.DP_main_page:
+        # Reset display counter
+        KC.DP_cnt = KC.DP_cnt_default
+        # Neopixel color wheel disable/enable
+        return neopixel_toggle()
+    # Wake display
+    KC.DP_main_page = True
+    return f"Display mode: main view"
+
+
+def lmdep():
+    """
+    Load Module dependencies
+    """
+    return 'oled', 'ds18', 'gameOfLife'
+
+
+def pinmap():
+    """
+    PIN MAP dump
+    """
+    from LM_oled import pinmap as o_pmp
+    from LM_ds18 import pinmap as t_pmp
+    pmp = o_pmp()
+    pmp.update(t_pmp())
+    pmp.update(pinmap_dump(['neop']))
+    return pmp
+
+
+def help():
+    return ('load_n_init width=64 height=32 bootmsg="micrOS"',
+            'temperature', 'display period>=1000',
+            'press_event',
+            'display_toggle',
+            'neopixel_toggle',
+            'neopixel_color_wheel br=<0-100>',
+            'pinmap', 'lmdep')

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5}/micrOS/source/LM_oled.py

@@ -91,7 +91,9 @@ class SSD1306(framebuf.FrameBuffer):
     def poweron(self):
         self.write_cmd(SET_DISP | 0x01)
 
-    def contrast(self, contrast):
+    def contrast(self, percent):
+        """percent: 0-100"""
+        contrast = int(255*(percent/100))
         self.write_cmd(SET_CONTRAST)
         self.write_cmd(contrast)
 
@@ -155,11 +157,17 @@ class SSD1306_I2C(SSD1306):
 #  SSD1306 interface functions    #
 ###################################
 
-def load_n_init(width=128, height=64):
+def load_n_init(width=128, height=64, brightness=50):
+    """
+    :param width: pixel
+    :param height: pixel
+    :param brightness: percentage
+    """
     if SSD1306_I2C.OLED_OBJ is None:
         i2c = SoftI2C(Pin(physical_pin('i2c_scl')), Pin(physical_pin('i2c_sda')))
         # TODO: scan device - abort if no device is available
         SSD1306_I2C.OLED_OBJ = SSD1306_I2C(width, height, i2c)
+        SSD1306_I2C.OLED_OBJ.contrast(percent=brightness)
     return SSD1306_I2C.OLED_OBJ
 
 

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5}/micrOS/source/LM_oled_sh1106.py

@@ -94,7 +94,9 @@ class SH1106(framebuf.FrameBuffer):
     def sleep(self, value):
         self.write_cmd(_SET_DISP | (not value))
 
-    def contrast(self, contrast):
+    def contrast(self, percent):
+        """percent: 0-100"""
+        contrast = int(255 * (percent / 100))
         self.write_cmd(_SET_CONTRAST)
         self.write_cmd(contrast)
 
@@ -219,12 +221,13 @@ class SH1106_I2C(SH1106):
 #   SH1106 interface functions    #
 ###################################
 
-def load_n_init(width=128, height=64, rotate=180):
+def load_n_init(width=128, height=64, brightness=50, rotate=180):
     if SH1106_I2C.OLED_OBJ is None:
         #i2c = SoftI2C(Pin(physical_pin('i2c_scl')), Pin(physical_pin('i2c_sda')))
         i2c = I2C(scl=Pin(physical_pin('i2c_scl')), sda=Pin(physical_pin('i2c_sda')), freq=400000)
         # TODO: scan device - abort if no device is available
         SH1106_I2C.OLED_OBJ = SH1106_I2C(width, height, i2c, rotate=rotate)
+        SH1106_I2C.OLED_OBJ.contrast(percent=brightness)
     return SH1106_I2C.OLED_OBJ
 
 

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5}/micrOS/source/Shell.py

@@ -24,7 +24,7 @@ from Debug import errlog_add
 #################################################################
 
 class Shell:
-    MICROS_VERSION = '2.0.4-0'
+    MICROS_VERSION = '2.0.5-0'
 
     def __init__(self):
         """

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5/micrOSDevToolKit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: micrOSDevToolKit
-Version: 2.0.4
+Version: 2.0.5
 Summary: Development and deployment environment for micrOS, the diy micropython automation OS (IoT)
 Home-page: https://github.com/BxNxM/micrOS
 Author: Marcell Ban

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5}/setup.py

@@ -18,7 +18,7 @@ dependencies = ['adafruit-ampy', 'mpremote', 'esptool', 'ipaddress', 'netaddr',
 
 setuptools.setup(
     name='micrOSDevToolKit',
-    version='2.0.4',
+    version='2.0.5',
     author='Marcell Ban',
     author_email='miros.framework@gmail.com',
     description='Development and deployment environment for micrOS, the diy micropython automation OS (IoT)',

{micrOSDevToolKit-2.0.4 → micrOSDevToolKit-2.0.5}/toolkit/simulator_lib/machine.py

@@ -132,7 +132,7 @@ class ADC:
 
 class I2C:
 
-    def __init__(self, scl, sda, freq):
+    def __init__(self, scl, sda, freq=None):
         self.scl = scl
         self.sda = sda
         self.freq = freq
@@ -166,7 +166,7 @@ class I2S:
 
 class SoftI2C(I2C):
 
-    def __init__(self, scl, sda, freq):
+    def __init__(self, scl, sda, freq=None):
         super().__init__(scl, sda, freq)
 
 

micrOSDevToolKit-2.0.5/toolkit/workspace/precompiled/node_config.json

@@ -0,0 +1 @@
+{"irq2": false, "irq2_cbf": "n/a", "irq3_cbf": "n/a", "timirq": false, "irq4": false, "auth": false, "irq4_cbf": "n/a", "devip": "10.0.1.74", "soctout": 100, "appwd": "ADmin123", "timirqcbf": "n/a", "timirqseq": 300000, "hwuid": "micrecda3b95c3f8OS", "staessid": "elektroncsakpozitivan_2G", "irq1_cbf": "n/a", "cron": false, "irq4_trig": "n/a", "nwmd": "STA", "boothook": "telegram receiver_loop &2000;demo hello", "version": "2.0.5-0", "irq_prell_ms": 300, "crontasks": "n/a", "aioqueue": 3, "utc": 60, "boostmd": true, "irq1_trig": "n/a", "guimeta": "...", "socport": 9008, "webui": false, "cstmpmap": "n/a", "telegram": "6185435843:AAH71wEyoOil8bRKecQHp4zazTQ_MmE7bvE", "irq3_trig": "n/a", "dbg": true, "irq2_trig": "n/a", "irq3": false, "devfid": "PublicTelegram", "stapwd": "BNM3,1415", "irq1": false}