Add cyber flower.

Cyber_Flower/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+.mpy
+

Cyber_Flower/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Adafruit Industries
+
+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.

Cyber_Flower/README.md

@@ -0,0 +1,25 @@
+# Cyber Flower: Digital Valentine
+
+    'Roses are red,
+     Violets are blue,
+     This flower changes color,
+     To show its love for you.'
+
+Load this on a Gemma M0 running CircuitPython and it will smoothly animate
+the DotStar LED between different color hues.  Touch the D0 pad and it will
+cause the pixel to pulse like a heart beat.  You might need to also attach a
+wire to the ground pin to ensure capacitive touch sensing can work on battery
+power.  For example strip the insulation from a wire and solder it to ground,
+then solder a wire (with the insulation still attached) to D0, and wrap
+both wires around the stem of a flower like a double-helix.  When you touch
+the wires you'll ground yourself (touching the bare ground wire) and cause
+enough capacitance in the D0 wire (even though it's still insulated) to
+trigger the heartbeat.  Or just leave D0 unconnected to have a nicely
+animated lit-up flower!
+
+Note that on power-up the flower will wait about 5 seconds before turning on
+the LED.  During this time the board's red LED will flash and this is an
+indication that it's waiting to power on.  Place the flower down so nothing
+is touching it and then pick it up again after the DotStar LED starts
+animating.  This will ensure the capacitive touch sensing isn't accidentally
+calibrated with your body touching it (making it less accurate).

Cyber_Flower/main.py

@@ -0,0 +1,234 @@
+# Cyber Flower: Digital Valentine
+#
+# 'Roses are red,
+#  Violets are blue,
+#  This flower changes color,
+#  To show its love for you.'
+#
+# Load this on a Gemma M0 running CircuitPython and it will smoothly animate
+# the DotStar LED between different color hues.  Touch the D0 pad and it will
+# cause the pixel to pulse like a heart beat.  You might need to also attach a
+# wire to the ground pin to ensure capacitive touch sensing can work on battery
+# power.  For example strip the insulation from a wire and solder it to ground,
+# then solder a wire (with the insulation still attached) to D0, and wrap
+# both wires around the stem of a flower like a double-helix.  When you touch
+# the wires you'll ground yourself (touching the bare ground wire) and cause
+# enough capacitance in the D0 wire (even though it's still insulated) to
+# trigger the heartbeat.  Or just leave D0 unconnected to have a nicely
+# animated lit-up flower!
+#
+# Note that on power-up the flower will wait about 5 seconds before turning on
+# the LED.  During this time the board's red LED will flash and this is an
+# indication that it's waiting to power on.  Place the flower down so nothing
+# is touching it and then pick it up again after the DotStar LED starts
+# animating.  This will ensure the capacitive touch sensing isn't accidentally
+# calibrated with your body touching it (making it less accurate).
+#
+# Author: Tony DiCola
+# License: MIT License
+import math
+import time
+
+import board
+import busio
+import digitalio
+import touchio
+
+
+# Variables that control the code.  Try changing these to modify speed, color,
+# etc.
+START_DELAY = 5.0       # How many seconds to wait after power up before
+                        # jumping into the animation and initializing the
+                        # touch input.  This gives you time to take move your
+                        # fingers off the flower so the capacitive touch
+                        # sensing is better calibrated.  During the delay
+                        # the small red LED on the board will flash.
+
+TOUCH_PIN = board.D0    # The board pin to listen for touches and trigger the
+                        # heart beat animation.  You can change this to any
+                        # other pin like board.D2 or board.D1.  Make sure not
+                        # to touch this pin as the board powers on or the
+                        # capacitive sensing will get confused (just reset
+                        # the board and try again).
+
+BRIGHTNESS = 1.0        # The brightness of the colors.  Set this to a value
+                        # anywhere within 0 and 1.0, where 1.0 is full bright.
+                        # For example 0.5 would be half brightness.
+
+RAINBOW_PERIOD_S = 18.0 # How many seconds it takes for the default rainbow
+                        # cycle animation to perform a full cycle.  Increase
+                        # this to slow down the animation or decrease to speed
+                        # it up.
+
+HEARTBEAT_BPM = 60.0    # Heartbeat animation beats per minute.  Increase to
+                        # speed up the heartbeat, and decrease to slow down.
+
+HEARTBEAT_HUE = 300.0   # The color hue to use when animating the heartbeat
+                        # animation.  Pick a value in the range of 0 to 359
+                        # degrees, see the hue spectrum here:
+                        #   https://en.wikipedia.org/wiki/Hue
+                        # A value of 300 is a nice pink color.
+
+# First initialize the DotStar LED and turn it off.
+# We'll manually drive the dotstar instead of depending on the adafruit_dotstar
+# library for simplicity--there's no need to install other dependencies for
+# driving this one LED.
+dotstar_spi = busio.SPI(clock=board.APA102_SCK, MOSI=board.APA102_MOSI)
+# Raw dotstar protocol, start with 4 bytes of zero, then 0xFF and B, G, R
+# pixel data, followed by bytes of 0xFF tail (just one for 1 pixel).
+dotstar_data = bytearray([0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
+                          0xFF])
+# Define a function to simplify setting dotstar color.
+def dotstar_color(rgb_color):
+    # Set the color of the dot star LED.  This is barebones dotstar driving
+    # code for simplicity and less dependency on other libraries.  We're only
+    # driving one LED!
+    try:
+        while not dotstar_spi.try_lock():
+            pass
+        dotstar_spi.configure(baudrate=4000000)
+        dotstar_data[5] = rgb_color[2] & 0xFF  # Blue
+        dotstar_data[6] = rgb_color[1] & 0xFF  # Green
+        dotstar_data[7] = rgb_color[0] & 0xFF  # Red
+        dotstar_spi.write(dotstar_data)
+    finally:
+        dotstar_spi.unlock()
+# Call the function above to turn off the dotstar initially (set it to all 0).
+dotstar_color((0, 0, 0))
+
+# Also make sure the on-board red LED is turned off.
+red_led = digitalio.DigitalInOut(board.L)
+red_led.switch_to_output(value=False)
+
+# Wait the startup delay period while flashing the red LED.  This gives time
+# to move your hand away from the flower/stem so the capacitive touch sensing
+# is initialized and calibrated with a good non-touch starting state.
+start = time.monotonic()
+while time.monotonic() - start <= START_DELAY:
+    # Blink the red LED on and off every half second.
+    red_led.value = True
+    time.sleep(0.5)
+    red_led.value = False
+    time.sleep(0.5)
+
+# Setup the touch input.
+touch = touchio.TouchIn(TOUCH_PIN)
+
+# Convert periods to frequencies that are used later in animations.
+rainbow_freq = 1.0/RAINBOW_PERIOD_S
+
+# Calculcate periods and values used by the heartbeat animation.
+beat_period = 60.0/HEARTBEAT_BPM
+beat_quarter_period = beat_period/4.0  # Quarter period controls the speed of
+                                       # the heartbeat drop-off (using an
+                                       # exponential decay function).
+beat_phase = beat_period/5.0           # Phase controls how long in-between
+                                       # the two parts of the heart beat
+                                       # (the 'ba-boom' of the beat).
+
+# Define a gamma correction lookup table to make colors more accurate.
+# See this guide for more background on gamma correction:
+#   https://learn.adafruit.com/led-tricks-gamma-correction/
+gamma8 = bytearray(256)
+for i in range(len(gamma8)):
+    gamma8[i] = int(math.pow(i/255.0, 2.8)*255.0+0.5) & 0xFF
+
+# Define a function to convert from HSV (hue, saturation, value) color to
+# RGB colors that DotStar LEDs speak.  The HSV color space is a nicer for
+# animations because you can easily change the hue and value (brightness)
+# vs. RGB colors.  Pass in a hue (in degrees from 0-360) and saturation and
+# value that range from 0 to 1.0.  This will also use the gamma correction
+# table above to get the most accurate color.  Adapted from C/C++ code here:
+#   https://www.cs.rit.edu/~ncs/color/t_convert.html
+def HSV_to_RGB(h, s, v):
+    r = 0
+    g = 0
+    b = 0
+    if s == 0.0:
+        r = v
+        g = v
+        b = v
+    else:
+        h /= 60.0       # sector 0 to 5
+        i = int(math.floor(h))
+        f = h - i       # factorial part of h
+        p = v * (1.0 - s)
+        q = v * (1.0 - s * f)
+        t = v * (1.0 - s * (1.0 - f))
+        if i == 0:
+            r = v
+            g = t
+            b = p
+        elif i == 1:
+            r = q
+            g = v
+            b = p
+        elif i == 2:
+            r = p
+            g = v
+            b = t
+        elif i == 3:
+            r = p
+            g = q
+            b = v
+        elif i == 4:
+            r = t
+            g = p
+            b = v
+        else:
+            r = v
+            g = p
+            b = q
+    r = gamma8[int(255.0*r)]
+    g = gamma8[int(255.0*g)]
+    b = gamma8[int(255.0*b)]
+    return (r, g, b)
+
+# Another handy function for linear interpolation of a value.  Pass in a value
+# x that's within the range x0...x1 and a range y0...y1 to get an output value
+# y that's proportionally within y0...y1 based on x within x0...x1.  Handy for
+# transforming a value in one range to a value in another (like Arduino's map
+# function).
+def lerp(x, x0, x1, y0, y1):
+    return y0+(x-x0)*((y1-y0)/(x1-x0))
+
+# Main loop below will run forever:
+while True:
+    # Get the current time at the start of the animation update.
+    current = time.monotonic()
+    # Now check if the touch input is being touched and choose a different
+    # animation to run, either a rainbow cycle or heartbeat.
+    if touch.value:
+        # The touch input is being touched, so figure out the color using
+        # a heartbeat animation.
+        # This works using exponential decay of the color value (brightness)
+        # over time:
+        #   https://en.wikipedia.org/wiki/Exponential_decay
+        # A heart beat is made of two sub-beats (the 'ba-boom') so two decay
+        # functions are calculated using the same fall-off period but slightly
+        # out of phase so one occurs a little bit after the other.
+        t0 = current % beat_period
+        t1 = (current + beat_phase) % beat_period
+        x0 = math.pow(math.e, -t0/beat_quarter_period)
+        x1 = math.pow(math.e, -t1/beat_quarter_period)
+        # After calculating both exponential decay values pick the biggest one
+        # as the secondary one will occur after the first.  Scale each by
+        # the global brightness and then convert to RGB color using the fixed
+        # hue but modulating the color value (brightness).  Luckily the result
+        # of the exponential decay is a value that goes from 1.0 to 0.0 just
+        # like we expect for full bright to zero brightness with HSV color
+        # (i.e. no interpolation is necessary).
+        val = max(x0, x1) * BRIGHTNESS
+        dotstar_color(HSV_to_RGB(HEARTBEAT_HUE, 1.0, val))
+    else:
+        # The touch input is not being touched (touch.value is False) so
+        # compute the hue with a smooth cycle over time.
+        # First use the sine function to smoothly generate a value that goes
+        # from -1.0 to 1.0 at a certain frequency to match the rainbow period.
+        x = math.sin(2.0*math.pi*rainbow_freq*current)
+        # Then compute the hue by converting the sine wave value from something
+        # that goes from -1.0 to 1.0 to instead go from 0 to 359 degrees.
+        hue = lerp(x, -1.0, 1.0, 0.0, 359.0)
+        # Finally update the DotStar LED by converting the HSV color at the
+        # specified hue to a RGB color the LED understands.
+        dotstar_color(HSV_to_RGB(hue, 1.0, BRIGHTNESS))