micropython · UnexpectedMaker · Mar 19, 2021 · Apr 26, 2021 · Apr 26, 2021 · Apr 28, 2021
diff --git a/ports/esp32/boards/TINYPICO/mpconfigboard.h b/ports/esp32/boards/TINYPICO/mpconfigboard.h
diff --git a/ports/esp32/boards/TINYPICO/manifest.py → ports/esp32/boards/UM_FEATHERS2/manifest.py b/ports/esp32/boards/TINYPICO/manifest.py → ports/esp32/boards/UM_FEATHERS2/manifest.py
diff --git a/.../esp32/boards/TINYPICO/modules/dotstar.py → ...32/boards/UM_FEATHERS2/modules/dotstar.py b/.../esp32/boards/TINYPICO/modules/dotstar.py → ...32/boards/UM_FEATHERS2/modules/dotstar.py
diff --git a/ports/esp32/boards/UM_FEATHERS2/modules/feathers2.py b/ports/esp32/boards/UM_FEATHERS2/modules/feathers2.py
@@ -0,0 +1,98 @@
+# FeatherS2 MicroPython Helper Library
+# 2021 Seon Rozenblum - Unexpected Maker
+#
+# Project home:
+#   https://feathers2.io
+#
+# 2021-Mar-21 - v0.1 - Initial implementation
+
+# Import required libraries
+from micropython import const
+from machine import Pin, SPI, ADC
+import machine, time
+
+# FeatherS2 Hardware Pin Assignments
+
+# LDO
+LDO2 = const(21)
+
+# APA102 Dotstar pins
+DOTSTAR_CLK = const(45)
+DOTSTAR_DATA = const(40)
+
+# SPI
+SPI_MOSI = const(35)
+SPI_MISO = const(36)
+SPI_CLK = const(37)
+
+# I2C
+I2C_SDA = const(38)
+I2C_SCL = const(33)
+
+# DAC
+DAC1 = const(17)
+DAC2 = const(18)
+
+# LED & Ambient Light Sensor
+LED = const(13)
+AMB_LIGHT = const(4)
+
+# Helper functions
+
+# LED & Ambient Light Sensor control
+def set_led(state):
+    l = Pin(LED, Pin.OUT)
+    l.value(state)
+
+def toggle_led(state):
+    l = Pin(LED, Pin.OUT)
+    l.value(not l.value())
+
+# Create ADC and set attenuation and return teh ambient light value from the onboard sensor
+def get_amb_light():
+    adc = ADC(Pin(AMB_LIGHT))
+    adc.atten(ADC.ATTN_11DB)
+    return adc.read()    
+
+# LDO2 power control
+# When we manually turn off the second LDO we also set the DotStar DATA and CLK pins to input to
+# prevent parasitic power from lighting the LED even with the LDO off, causing current use.
+# The DotStar is a beautiful LED, but parasitic power makes it a terrible choice for battery use :( 
+def set_ldo2_power(state):
+    """Set the power for the on-board Dostar to allow no current draw when not needed."""
+    # Set the power pin to the inverse of state
+    ldo2 = Pin(LDO2, Pin.OUT) 
+    ldo2.value(state)
+
+    if state:
+        Pin(DOTSTAR_CLK, Pin.OUT)
+        Pin(DOTSTAR_DATA, Pin.OUT)# If power is on, set CLK to be output, otherwise input
+    else:
+        Pin(DOTSTAR_CLK, Pin.IN)
+        Pin(DOTSTAR_DATA, Pin.IN)# If power is on, set CLK to be output, otherwise input
+
+    # A small delay to let the IO change state
+    time.sleep(0.035)
+
+
+# Dotstar rainbow colour wheel
+def dotstar_color_wheel(wheel_pos):
+    """Color wheel to allow for cycling through the rainbow of RGB colors."""
+    wheel_pos = wheel_pos % 255
+
+    if wheel_pos < 85:
+        return 255 - wheel_pos * 3, 0, wheel_pos * 3
+    elif wheel_pos < 170:
+        wheel_pos -= 85
+        return 0, wheel_pos * 3, 255 - wheel_pos * 3
+    else:
+        wheel_pos -= 170
+        return wheel_pos * 3, 255 - wheel_pos * 3, 0
+
+
+# Go into deep sleep but shut down the APA first to save power
+# Use this if you want lowest deep  sleep current
+def go_deepsleep(t):
+    """Deep sleep helper that also powers down the on-board Dotstar."""
+    set_ldo2_power(False)
+    machine.deepsleep(t)
diff --git a/ports/esp32/boards/UM_FEATHERS2/mpconfigboard.cmake b/ports/esp32/boards/UM_FEATHERS2/mpconfigboard.cmake
@@ -0,0 +1,9 @@
+set(IDF_TARGET esp32s2)
+set(SDKCONFIG_DEFAULTS
+    boards/sdkconfig.base
+    boards/sdkconfig.spiram_sx
+    boards/sdkconfig.usb
+    boards/UM_FEATHERS2/sdkconfig.board
+)
+
+set(MICROPY_FROZEN_MANIFEST ${MICROPY_BOARD_DIR}/manifest.py)
diff --git a/ports/esp32/boards/UM_FEATHERS2/mpconfigboard.h b/ports/esp32/boards/UM_FEATHERS2/mpconfigboard.h
@@ -0,0 +1,5 @@
+#define MICROPY_HW_BOARD_NAME "FeatherS2"
+#define MICROPY_HW_MCU_NAME "ESP32-S2"
+
+#define MICROPY_PY_BLUETOOTH                (0)
+#define MICROPY_HW_ENABLE_SDCARD            (0)
diff --git a/ports/esp32/boards/UM_FEATHERS2/sdkconfig.board b/ports/esp32/boards/UM_FEATHERS2/sdkconfig.board
@@ -0,0 +1,16 @@
+CONFIG_FLASHMODE_QIO=y
+CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
+CONFIG_ESPTOOLPY_FLASHSIZE_DETECT=y
+CONFIG_ESPTOOLPY_AFTER_NORESET=y
+
+CONFIG_SPIRAM_MEMTEST=
+
+CONFIG_ESPTOOLPY_FLASHSIZE_4MB=
+CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions-16MiB.csv"
+#CONFIG_USB_AND_UART=y
+
+# LWIP
+CONFIG_LWIP_LOCAL_HOSTNAME="UMFeatherS2"
+# end of LWIP
diff --git a/ports/esp32/boards/UM_TINYPICO/manifest.py b/ports/esp32/boards/UM_TINYPICO/manifest.py
@@ -0,0 +1,2 @@
+include("$(PORT_DIR)/boards/manifest.py")
+freeze("modules")
diff --git a/ports/esp32/boards/UM_TINYPICO/modules/dotstar.py b/ports/esp32/boards/UM_TINYPICO/modules/dotstar.py
@@ -0,0 +1,227 @@
+# DotStar strip driver for MicroPython
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 Damien P. George (original Neopixel object)
+# Copyright (c) 2017 Ladyada
+# Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
+# Copyright (c) 2019 Matt Trentini (porting back to MicroPython)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+START_HEADER_SIZE = 4
+LED_START = 0b11100000  # Three "1" bits, followed by 5 brightness bits
+
+# Pixel color order constants
+RGB = (0, 1, 2)
+RBG = (0, 2, 1)
+GRB = (1, 0, 2)
+GBR = (1, 2, 0)
+BRG = (2, 0, 1)
+BGR = (2, 1, 0)
+
+
+class DotStar:
+    """
+    A sequence of dotstars.
+
+    :param SPI spi: The SPI object to write output to.
+    :param int n: The number of dotstars in the chain
+    :param float brightness: Brightness of the pixels between 0.0 and 1.0
+    :param bool auto_write: True if the dotstars should immediately change when
+        set. If False, `show` must be called explicitly.
+    :param tuple pixel_order: Set the pixel order on the strip - different
+         strips implement this differently. If you send red, and it looks blue
+         or green on the strip, modify this! It should be one of the values above
+
+
+    Example for TinyPICO:
+
+    .. code-block:: python
+
+        from dotstar import DotStar
+        from machine import Pin, SPI
+
+        spi = SPI(sck=Pin(12), mosi=Pin(13), miso=Pin(18)) # Configure SPI - note: miso is unused
+        dotstar = DotStar(spi, 1)
+        dotstar[0] = (128, 0, 0) # Red
+    """
+
+    def __init__(self, spi, n, *, brightness=1.0, auto_write=True, pixel_order=BGR):
+        self._spi = spi
+        self._n = n
+        # Supply one extra clock cycle for each two pixels in the strip.
+        self.end_header_size = n // 16
+        if n % 16 != 0:
+            self.end_header_size += 1
+        self._buf = bytearray(n * 4 + START_HEADER_SIZE + self.end_header_size)
+        self.end_header_index = len(self._buf) - self.end_header_size
+        self.pixel_order = pixel_order
+        # Four empty bytes to start.
+        for i in range(START_HEADER_SIZE):
+            self._buf[i] = 0x00
+        # Mark the beginnings of each pixel.
+        for i in range(START_HEADER_SIZE, self.end_header_index, 4):
+            self._buf[i] = 0xFF
+        # 0xff bytes at the end.
+        for i in range(self.end_header_index, len(self._buf)):
+            self._buf[i] = 0xFF
+        self._brightness = 1.0
+        # Set auto_write to False temporarily so brightness setter does _not_
+        # call show() while in __init__.
+        self.auto_write = False
+        self.brightness = brightness
+        self.auto_write = auto_write
+
+    def deinit(self):
+        """Blank out the DotStars and release the resources."""
+        self.auto_write = False
+        for i in range(START_HEADER_SIZE, self.end_header_index):
+            if i % 4 != 0:
+                self._buf[i] = 0
+        self.show()
+        if self._spi:
+            self._spi.deinit()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        self.deinit()
+
+    def __repr__(self):
+        return "[" + ", ".join([str(x) for x in self]) + "]"
+
+    def _set_item(self, index, value):
+        """
+        value can be one of three things:
+                a (r,g,b) list/tuple
+                a (r,g,b, brightness) list/tuple
+                a single, longer int that contains RGB values, like 0xFFFFFF
+            brightness, if specified should be a float 0-1
+
+        Set a pixel value. You can set per-pixel brightness here, if it's not passed it
+        will use the max value for pixel brightness value, which is a good default.
+
+        Important notes about the per-pixel brightness - it's accomplished by
+        PWMing the entire output of the LED, and that PWM is at a much
+        slower clock than the rest of the LEDs. This can cause problems in
+        Persistence of Vision Applications
+        """
+
+        offset = index * 4 + START_HEADER_SIZE
+        rgb = value
+        if isinstance(value, int):
+            rgb = (value >> 16, (value >> 8) & 0xFF,
10000
 value & 0xFF)
+
+        if len(rgb) == 4:
+            brightness = value[3]
+            # Ignore value[3] below.
+        else:
+            brightness = 1
+
+        # LED startframe is three "1" bits, followed by 5 brightness bits
+        # then 8 bits for each of R, G, and B. The order of those 3 are configurable and
+        # vary based on hardware
+        # same as math.ceil(brightness * 31) & 0b00011111
+        # Idea from https://www.codeproject.com/Tips/700780/Fast-floor-ceiling-functions
+        brightness_byte = 32 - int(32 - brightness * 31) & 0b00011111
+        self._buf[offset] = brightness_byte | LED_START
+        self._buf[offset + 1] = rgb[self.pixel_order[0]]
+        self._buf[offset + 2] = rgb[self.pixel_order[1]]
+        self._buf[offset + 3] = rgb[self.pixel_order[2]]
+
+    def __setitem__(self, index, val):
+        if isinstance(index, slice):
+            start, stop, step = index.indices(self._n)
+            length = stop - start
+            if step != 0:
+                # same as math.ceil(length / step)
+                # Idea from https://fizzbuzzer.com/implement-a-ceil-function/
+                length = (length + step - 1) // step
+            if len(val) != length:
+                raise ValueError("Slice and input sequence size do not match.")
+            for val_i, in_i in enumerate(range(start, stop, step)):
+                self._set_item(in_i, val[val_i])
+        else:
+            self._set_item(index, val)
+
+        if self.auto_write:
+            self.show()
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            out = []
+            for in_i in range(*index.indices(self._n)):
+                out.append(
+                    tuple(self._buf[in_i * 4 + (3 - i) + START_HEADER_SIZE] for i in range(3))
+                )
+            return out
+        if index < 0:
+            index += len(self)
+        if index >= self._n or index < 0:
+            raise IndexError
+        offset = index * 4
+        return tuple(self._buf[offset + (3 - i) + START_HEADER_SIZE] for i in range(3))
+
+    def __len__(self):
+        return self._n
+
+    @property
+    def brightness(self):
+        """Overall brightness of the pixel"""
+        return self._brightness
+
+    @brightness.setter
+    def brightness(self, brightness):
+        self._brightness = min(max(brightness, 0.0), 1.0)
+        if self.auto_write:
+            self.show()
+
+    def fill(self, color):
+        """Colors all pixels the given ***color***."""
+        auto_write = self.auto_write
+        self.auto_write = False
+        for i in range(self._n):
+            self[i] = color
+        if auto_write:
+            self.show()
+        self.auto_write = auto_write
+
+    def show(self):
+        """Shows the new colors on the pixels themselves if they haven't already
+        been autowritten.
+
+        The colors may or may not be showing after this function returns because
+        it may be done asynchronously."""
+        # Create a second output buffer if we need to compute brightness
+        buf = self._buf
+        if self.brightness < 1.0:
+            buf = bytearray(self._buf)
+            # Four empty bytes to start.
+            for i in range(START_HEADER_SIZE):
+                buf[i] = 0x00
+            for i in range(START_HEADER_SIZE, self.end_header_index):
+                buf[i] = self._buf[i] if i % 4 == 0 else int(self._buf[i] * self._brightness)
+            # Four 0xff bytes at the end.
+            for i in range(self.end_header_index, len(buf)):
+                buf[i] = 0xFF
+
+        if self._spi:
+            self._spi.write(buf)
diff --git a/...esp32/boards/TINYPICO/modules/tinypico.py → ...32/boards/UM_TINYPICO/modules/tinypico.py b/...esp32/boards/TINYPICO/modules/tinypico.py → ...32/boards/UM_TINYPICO/modules/tinypico.py
diff --git a/...esp32/boards/TINYPICO/mpconfigboard.cmake → ...32/boards/UM_TINYPICO/mpconfigboard.cmake b/...esp32/boards/TINYPICO/mpconfigboard.cmake → ...32/boards/UM_TINYPICO/mpconfigboard.cmake
diff --git a/ports/esp32/boards/UM_TINYPICO/mpconfigboard.h b/ports/esp32/boards/UM_TINYPICO/mpconfigboard.h
@@ -0,0 +1,6 @@
+#define MICROPY_HW_BOARD_NAME "TinyPICO"
+#define MICROPY_HW_MCU_NAME "ESP32-PICO-D4"
+
+#define MICROPY_HW_SPI1_SCK (18)
+#define MICROPY_HW_SPI1_MOSI (23)
+#define MICROPY_HW_SPI1_MISO (19)
diff --git a/ports/esp32/boards/TINYPICO/sdkconfig.board → .../esp32/boards/UM_TINYPICO/sdkconfig.board b/ports/esp32/boards/TINYPICO/sdkconfig.board → .../esp32/boards/UM_TINYPICO/sdkconfig.board
@@ -2,3 +2,4 @@ CONFIG_FLASHMODE_QIO=y
 CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
 CONFIG_SPIRAM_SPEED_80M=y
 CONFIG_ESP32_REV_MIN_1=y
+CONFIG_LWIP_LOCAL_HOSTNAME="UMTinyPICO"
diff --git a/ports/esp32/boards/UM_TINYS2/manifest.py b/ports/esp32/boards/UM_TINYS2/manifest.py
@@ -0,0 +1,2 @@
+include("$(PORT_DIR)/boards/manifest.py")
+freeze("modules")
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		include("$(PORT_DIR)/boards/manifest.py")
		freeze("modules")