# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries # SPDX-License-Identifier: MIT import board from rainbowio import colorwheel from adafruit_is31fl3741.adafruit_ledglasses import LED_Glasses import adafruit_is31fl3741 glasses = LED_Glasses(board.I2C(), allocate=adafruit_is31fl3741.MUST_BUFFER) wheeloffset = 0 while True: for i in range(24): hue = colorwheel(i * 256 // 24 + wheeloffset) glasses.right_ring[i] = hue glasses.left_ring[23 - i] = hue glasses.show() wheeloffset += 10
# SPDX-FileCopyrightText: 2021 Rose Hooper # SPDX-License-Identifier: MIT import board from adafruit_led_animation.animation.sparkle import Sparkle from adafruit_led_animation.color import PURPLE from adafruit_led_animation.sequence import AnimationSequence from adafruit_is31fl3741.adafruit_ledglasses import MUST_BUFFER, LED_Glasses from adafruit_is31fl3741.led_glasses_animation import LED_Glasses_Animation glasses = LED_Glasses(board.I2C(), allocate=MUST_BUFFER) glasses.set_led_scaling(255) glasses.global_current = 0xFE glasses.enable = True pixels = LED_Glasses_Animation(glasses) anim2 = Sparkle(pixels, 0.05, PURPLE) group = AnimationSequence(anim2, advance_interval=5, auto_reset=True, auto_clear=True) while True: group.animate()
def interp(color1, color2, blend): """Given two (R,G,B) color tuples and a blend ratio (0.0 to 1.0), interpolate between the two colors and return a gamma-corrected in-between color as a packed 24-bit RGB integer. No bounds clamping is performed on blend value, be nice.""" inv = 1.0 - blend # Weighting of second color return gammify([color1[x] * blend + color2[x] * inv for x in range(3)]) # HARDWARE SETUP ----------------------- # Manually declare I2C (not board.I2C() directly) to access 1 MHz speed... i2c = I2C(board.SCL, board.SDA, frequency=1000000) # Initialize the IS31 LED driver, buffered for smoother animation glasses = LED_Glasses(i2c, allocate=adafruit_is31fl3741.MUST_BUFFER) glasses.show() # Clear any residue on startup glasses.global_current = 20 # Just middlin' bright, please # INITIALIZE TABLES & OTHER GLOBALS ---- # This table is for mapping 3x3 averaged bitmap values (0-9) to # RGB colors. Avoids a lot of shift-and-or on every pixel. colormap = [] for n in range(10): colormap.append(gammify([n / 9 * eye_color[x] for x in range(3)])) # Pre-compute the Y position of 1/2 of the LEDs in a ring, relative # to the 3X bitmap resolution, so ring & matrix animation can be aligned. y_pos = []
import random import board import supervisor import adafruit_lis3dh import adafruit_is31fl3741 from adafruit_is31fl3741.adafruit_ledglasses import LED_Glasses # HARDWARE SETUP ---- i2c = board.I2C() # Shared by both the accelerometer and LED controller # Initialize the accelerometer lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c) # Initialize the IS31 LED driver, buffered for smoother animation glasses = LED_Glasses(i2c, allocate=adafruit_is31fl3741.MUST_BUFFER) # PHYSICS SETUP ----- class Pendulum: """A small class for our pendulum simulation.""" def __init__(self, ring, color): """Initial pendulum position, plus axle friction, are randomized so the two rings don't spin in perfect lockstep.""" self.ring = ring # Save reference to corresponding LED ring self.color = color # (R,G,B) tuple for color self.angle = random.random() # Position around ring, in radians self.momentum = 0 self.friction = random.uniform(0.85, 0.9) # Inverse friction, really
# FFT/SPECTRUM CONFIG ---- fft_size = 256 # Sample size for Fourier transform, MUST be power of two spectrum_size = fft_size // 2 # Output spectrum is 1/2 of FFT result # Bottom of spectrum tends to be noisy, while top often exceeds musical # range and is just harmonics, so clip both ends off: low_bin = 10 # Lowest bin of spectrum that contributes to graph high_bin = 75 # Highest bin " # HARDWARE SETUP --------- # Manually declare I2C (not board.I2C() directly) to access 1 MHz speed... i2c = I2C(board.SCL, board.SDA, frequency=1000000) # Initialize the IS31 LED driver, buffered for smoother animation glasses = LED_Glasses(i2c, allocate=adafruit_is31fl3741.MUST_BUFFER) glasses.show() # Clear any residue on startup glasses.global_current = 5 # Not too bright please # Initialize mic and allocate recording buffer (default rate is 16 MHz) mic = PDMIn(board.MICROPHONE_CLOCK, board.MICROPHONE_DATA, bit_depth=16) rec_buf = array("H", [0] * fft_size) # 16-bit audio samples # FFT/SPECTRUM SETUP ----- # To keep the display lively, tables are precomputed where each column of # the matrix (of which there are few) is the sum value and weighting of # several bins from the FFT spectrum output (of which there are many). # The tables also help visually linearize the output so octaves are evenly # spaced, as on a piano keyboard, whereas the source spectrum data is # spaced by frequency in Hz.
""" import random from supervisor import reload import board from busio import I2C import adafruit_is31fl3741 from adafruit_is31fl3741.adafruit_ledglasses import LED_Glasses # HARDWARE SETUP --------- # Manually declare I2C (not board.I2C() directly) to access 1 MHz speed... i2c = I2C(board.SCL, board.SDA, frequency=1000000) # Initialize the IS31 LED driver, buffered for smoother animation glasses = LED_Glasses(i2c, allocate=adafruit_is31fl3741.MUST_BUFFER) glasses.show() # Clear any residue on startup glasses.global_current = 20 # Just middlin' bright, please # INITIALIZE TABLES ------ # The raster data is intentionally one row taller than the LED matrix. # Each frame, random noise is put in the bottom (off matrix) row. There's # also an extra column on either side, to avoid needing edge clipping when # neighboring pixels (left, center, right) are averaged later. data = [[0] * (glasses.width + 2) for _ in range(glasses.height + 1)] # (2D array where elements are accessed as data[y][x], initialized to 0) # Each element in the raster is a single value representing brightness. # A pre-computed lookup table maps these to RGB colors. This one happens # to have 32 elements, but as we're not on an actual paletted hardware