import board import neopixel from adafruit_led_animation.animation.pulse import Pulse from adafruit_led_animation.animation.rainbow import Rainbow from adafruit_led_animation.animation.rainbowsparkle import RainbowSparkle from adafruit_led_animation.animation.rainbowcomet import RainbowComet from adafruit_led_animation.sequence import AnimationSequence from adafruit_led_animation.color import PURPLE # Update this to match the number of NeoPixel LEDs connected to your board. num_pixels = 124 pixels = neopixel.NeoPixel(board.GP1, num_pixels, auto_write=True) pixels.brightness = 0.2 rainbow = Rainbow(pixels, speed=0.01, period=1) rainbow_sparkle = RainbowSparkle(pixels, speed=0.05, num_sparkles=15) rainbow_comet = RainbowComet(pixels, speed=.01, tail_length=20, bounce=True) pulse = Pulse(pixels, speed=.05, color=PURPLE, period=3) animations = AnimationSequence(pulse, rainbow_sparkle, rainbow_comet, rainbow, advance_interval=5, auto_clear=True, random_order=False) while True: animations.animate()
CP_RAINBOW = Rainbow(cp.pixels, speed=0.01, period=10, step=3) CRYSTAL_COMET = Comet(PIXEL_MAP_CRYSTALS, speed=SPEED, tail_length=8, color=PURPLE, bounce=True) DARK_RINGS = Solid(PIXELS, color=BLACK) DARK_CPB = Solid(cp.pixels, color=BLACK) DARK = AnimationGroup( DARK_RINGS, DARK_CPB, ) # Animations Playlist, reorder as desired. AnimationGroups play at same time ANIMATIONS = AnimationSequence( AnimationGroup( CRYSTAL_COMET, RAINBOW, CP_RAINBOW, ), auto_clear=True, auto_reset=True, ) # MAIN LOOP ---------------------------------------------------------------- LAST_POSITION = ENCODER.position MODE = 1 while True: POSITION = ENCODER.position if POSITION != LAST_POSITION: MOVE = POSITION - LAST_POSITION if cp.switch:
# Cap touch board setup ------------------------------------------------------ i2c = busio.I2C(board.SCL, board.SDA) mpr121 = adafruit_mpr121.MPR121(i2c) # Demo MODE LED Animations ------------------------------------------------------ rainbow = Rainbow(pixels, speed=0, period=10, name="rainbow", step=1) rainbow_chase = RainbowChase(pixels, speed=0, size=5, spacing=10) chase = Chase(pixels, speed=0.1, color=RED, size=1, spacing=6) rainbow_comet = RainbowComet(pixels, speed=0.01, tail_length=60, bounce=True) # Animation Sequence Playlist -- rearrange to change the order of animations animations = AnimationSequence( rainbow_chase, chase, rainbow_comet, auto_clear=True, auto_reset=True, ) def go_dark(): '''set all pixels to black''' pixels.fill(BLACK) pixels.show() # Debouncer ------------------------------------------------------ buttons = [Debouncer(mpr121[i]) for i in range(12)]
# Create the NeoPixel strip strip_pixels = neopixel.NeoPixel(board.D5, STRIP_PIXEL_NUMBER, auto_write=False) # Setup BLE connection ble = BLERadio() uart = UARTService() advertisement = ProvideServicesAdvertisement(uart) # Setup animations animations = AnimationSequence( AnimationGroup(Sparkle(strip_pixels, SPARKLE_SPEED, color.TEAL)), AnimationGroup( Comet(strip_pixels, COMET_SPEED, color.TEAL, tail_length=STRIP_COMET_TAIL_LENGTH, bounce=STRIP_COMET_BOUNCE)), ) animation_color = None mode = 0 blanked = False while True: ble.start_advertising(advertisement) # Start advertising. was_connected = False while not was_connected or ble.connected: if not blanked: # If LED-off signal is not being sent... animations.animate() # Run the animations.
# 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()
interval. For NeoPixel FeatherWing. Update pixel_pin and pixel_num to match your wiring if using a different form of NeoPixels. """ import board import neopixel from adafruit_led_animation.animation.blink import Blink from adafruit_led_animation.animation.comet import Comet from adafruit_led_animation.animation.chase import Chase from adafruit_led_animation.sequence import AnimationSequence from adafruit_led_animation.color import PURPLE, AMBER, JADE # Update to match the pin connected to your NeoPixels pixel_pin = board.D6 # Update to match the number of NeoPixels you have connected pixel_num = 32 pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.5, auto_write=False) blink = Blink(pixels, speed=0.5, color=JADE) comet = Comet(pixels, speed=0.01, color=PURPLE, tail_length=10, bounce=True) chase = Chase(pixels, speed=0.1, size=3, spacing=6, color=AMBER) animations = AnimationSequence(blink, comet, chase, advance_interval=3, auto_clear=True) while True: animations.animate()
rainbow = Rainbow(pixels, speed=0.1, period=2) sparkle_pulse = SparklePulse(pixels, speed=0.1, period=3, color=JADE) rainbow_comet = RainbowComet(pixels, speed=0.1, tail_length=7, bounce=True) rainbow_chase = RainbowChase(pixels, speed=0.1, size=3, spacing=2, step=8) rainbow_sparkle = RainbowSparkle(pixels, speed=0.1, num_sparkles=15) custom_color_chase = CustomColorChase(pixels, speed=0.1, size=2, spacing=3, colors=[ORANGE, WHITE, JADE]) animations = AnimationSequence( comet, blink, rainbow_sparkle, chase, pulse, sparkle, rainbow, solid, rainbow_comet, sparkle_pulse, rainbow_chase, custom_color_chase, advance_interval=5, auto_clear=True, ) while True: animations.animate()
fire = AnimationGroup( Comet(pixels, speed=0, tail_length=1, color=BLACK), Sparkle(pixels, speed=0.05, num_sparkles=10, color=AMBER), Sparkle(pixels, speed=0.05, num_sparkles=10, color=RED), Sparkle(pixels, speed=0.05, num_sparkles=20, color=ORANGE), Sparkle(pixels, speed=0.05, num_sparkles=5, color=0xFF7D13), Sparkle(pixels, speed=0.05, num_sparkles=10, color=BLACK), ) # Here is the animation playlist where you set the order of modes animations = AnimationSequence( readingLight, fire, rainbow, starrynight, rainbowfade, brightWhite, auto_clear=True, ) MODE = 0 while True: if MODE == 0: # If currently off... startup.animate() while startup.animate(): pass MODE = 1 # Advertise when not connected
# the keyboard object! cc = ConsumerControl(usb_hid.devices) # our array of button objects buttons = [] # make all pin objects, make them inputs w/pullups for pin in buttonpins: button = digitalio.DigitalInOut(pin) button.direction = digitalio.Direction.INPUT button.pull = digitalio.Pull.UP buttons.append(button) animations = AnimationSequence( AnimationGroup( Pulse(pixels, speed=0.05, color=WHITE, period=6), Solid(internal_pixel, color=BLACK), ), ) print("Waiting for button presses") while True: # animate neopixel jewel animations.animate() # check each button for button in buttons: if not button.value: # pressed? i = buttons.index(button) print("Button #%d Pressed" % i)
brightness=0.5, auto_write=False) cp.pixels.brightness = 0.5 animations = AnimationSequence( # Synchronized to 0.5 seconds. Ignores the second animation setting of 3 seconds. AnimationGroup( Sparkle(cp.pixels, 0.1, color.GREEN, num_sparkles=1), Sparkle(strip_pixels, 0.1, color.GREEN, num_sparkles=1), ), AnimationGroup( Blink(cp.pixels, 0.25, color.RED), Blink(strip_pixels, 0.25, color.RED), sync=True, ), # Different speeds AnimationGroup( Comet(cp.pixels, 0.05, color.GREEN, tail_length=5), Comet(strip_pixels, 0.05, color.GREEN, tail_length=5), ), AnimationGroup( Pulse(cp.pixels, 0.05, color.RED, period=3), Pulse(strip_pixels, 0.05, color.RED, period=3), ), advance_interval=4.0, auto_clear=True, auto_reset=True, ) while True: animations.animate()
For NeoPixel FeatherWing. Update pixel_pin and pixel_num to match your wiring if using a different form of NeoPixels. """ import board import neopixel from adafruit_led_animation.animation.sparkle import Sparkle from adafruit_led_animation.animation.sparklepulse import SparklePulse from adafruit_led_animation.sequence import AnimationSequence from adafruit_led_animation.color import AMBER, JADE # Update to match the pin connected to your NeoPixels pixel_pin = board.D6 # Update to match the number of NeoPixels you have connected pixel_num = 32 pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.5, auto_write=False) sparkle = Sparkle(pixels, speed=0.05, color=AMBER, num_sparkles=10) sparkle_pulse = SparklePulse(pixels, speed=0.05, period=3, color=JADE) animations = AnimationSequence( sparkle, sparkle_pulse, advance_interval=5, auto_clear=True, ) while True: animations.animate()
animations = AnimationSequence( AnimationGroup( ColorCycle(pixels, cycle_speed, color_cycle_colors), ColorCycle(strip, cycle_speed, color_cycle_colors), sync=True, ), AnimationGroup( Sparkle(pixels, sparkle_speed, sparkle_color, 15), Sparkle(strip, sparkle_speed, sparkle_color, 1), ), AnimationSequence( AnimateOnce( AnimationGroup( Comet(pixels, magtag_comet_speed, comet_one_color, tail_length=magtag_comet_tail), Comet(strip, strip_comet_speed, comet_one_color, tail_length=strip_comet_tail), ), AnimationGroup( Comet(pixels, magtag_comet_speed, comet_two_color, tail_length=magtag_comet_tail), Comet(strip, strip_comet_speed, comet_two_color, tail_length=strip_comet_tail), ), ), ), AnimationGroup( # Turn the LEDs off. Solid(pixels, 0), Solid(strip, 0), ), auto_clear=True, )
# Initialize servo PWM = pwmio.PWMOut(SERVO_PIN, frequency=50) SERVO = servo.Servo(PWM) # Initialize NeoPixels and animations PIXELS = neopixel.NeoPixel(PIXEL_PIN, NUM_PIXELS, auto_write=False, pixel_order=ORDER) LARSON = Comet(PIXELS, bounce=True, speed=0.6/NUM_PIXELS, tail_length=NUM_PIXELS//2, color=(RED[0] * BRIGHTNESS, # This is a little faster than RED[1] * BRIGHTNESS, # using the NeoPixel brightness RED[2] * BRIGHTNESS)) # setting. SPARKLE = SparklePulse(PIXELS, period=2, speed=0.15, max_intensity=BRIGHTNESS, color=BLUE) ANIMATIONS = AnimationSequence(LARSON, SPARKLE, advance_interval=7, auto_clear=False) SERVO.angle = POSITION = NEXT_POSITION = 90 MOVING = False # Initial state = paused START_TIME = time.monotonic() # Initial time DURATION = 1.0 # Hold initial position for 1 sec while True: # Loop forever... # Move turret -- randomly looks around and pauses NOW = time.monotonic() ELAPSED = NOW - START_TIME # Seconds since start of motion or pause if ELAPSED >= DURATION: # End motion/pause? MOVING = not MOVING # Toggle between those two states START_TIME = NOW # and record the new starting time ELAPSED = 0.0
print("Response is", cheerlights_update_info) # Get the color from the fetched info for use below. cheerlights_color = cheerlights_update_info[0] # If red, blue or pink, do a comet animation in the specified color. if cheerlights_color in ('red', 'blue', 'pink'): if cheerlights_color == 'red': comet_color = RED elif cheerlights_color == 'blue': comet_color = BLUE elif cheerlights_color == 'pink': comet_color = PINK animations = AnimationSequence( AnimationGroup( Comet(magtag_pixels, 0.3, color=comet_color, tail_length=3), Comet(strip_pixels, 0.05, color=comet_color, tail_length=15), ) ) # If green or orange, do a pulse animation in the specified color. if cheerlights_color in ('green', 'orange'): if cheerlights_color == 'green': pulse_color = GREEN elif cheerlights_color == 'orange': pulse_color = ORANGE animations = AnimationSequence( AnimationGroup( Pulse(magtag_pixels, speed=0.1, color=pulse_color, period=3), Pulse(strip_pixels, speed=0.1, color=pulse_color, period=3), ) )
# Create a switch from the ItsyBity's on-board pushbutton to toggle charge mode mode_pin = digitalio.DigitalInOut(board.SWITCH) mode_pin.direction = digitalio.Direction.INPUT mode_pin.pull = digitalio.Pull.UP switch = Debouncer(mode_pin) # Create the animations comet = Comet(pixels, speed=0.06, color=(180,0,255), tail_length=10, bounce=True) chase = Chase(pixels, speed=0.05, size=3, spacing=3, color=(0,255,255), reverse=True) rainbow_comet = RainbowComet(pixels, speed=.06) pulse = Pulse(pixels, speed=.04, color=(255,0,0), period = 0.2) # Our animations sequence seconds_per_animation = 10 animations = AnimationSequence(comet, rainbow_comet, chase, advance_interval=seconds_per_animation, auto_clear=True) # Current display determines whether we are showing the animation sequence or the pulse animation current_display = animations # Mode changes the color of random animations randomly random_color_mode = True def random_animation_color(anims): if random_color_mode: anims.color = colorwheel(random.randint(0,255)) animations.add_cycle_complete_receiver(random_animation_color) # After we complete three pulse cycles, return to main animations list def pulse_finished(anim):
pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.3, auto_write=False) # variable for number of pixels in the pixelmap helper num = 1 # pixel map helper # allows you to light each candle up one by one # begins with one being lit (num) candles = helper.PixelMap.horizontal_lines( pixels, num, 1, helper.horizontal_strip_gridmap(pixel_num, alternating=False) ) # rainbow animation rainbow = Rainbow(candles, speed=0.1, period=5) animations = AnimationSequence(rainbow) # turn on center candle pixels[4] = AMBER pixels.show() while True: # if only one candle is lit, don't rewrite center neopixel if num == 1: pass # otherwise write data to center neopixel else: pixels[4] = AMBER pixels.show() # animation the rainbow animation
pixels, 8, 2, helper.horizontal_strip_gridmap(8, alternating=True)) pixel_wing_horizontal = helper.PixelMap.horizontal_lines( pixels, 8, 2, helper.horizontal_strip_gridmap(8, alternating=True)) #Setup LED Animations rainbow = Rainbow(pixels, speed=.001, period=2) pulse = Pulse(pixels, speed=0.1, color=RED, period=3) blink = Blink(pixels, speed=0.5, color=RED) colorcycle = ColorCycle(pixels, speed=0.4, colors=[RED, ORANGE, YELLOW, JADE, BLUE, AQUA, PURPLE]) comet_v = Comet(pixel_wing_vertical, speed=0.05, color=PURPLE, tail_length=6, bounce=True) #Setup the LED Sequences animations = AnimationSequence( rainbow, pulse, comet_v, blink, colorcycle, advance_interval=5.95, ) #Run ze animations! while True: animations.animate()
animations = AnimationSequence( AnimationGroup( Solid(boardPixels, WHITE), ColorCycle(stripPixels, cycleSpeed, cycleColors), sync=True, ), AnimationSequence( AnimateOnce( AnimationGroup( Solid(boardPixels, WHITE), Comet(stripPixels, stripCometSpeed, cometColorA, tail_length=stripCometTailLen), ), AnimationGroup( Solid(boardPixels, WHITE), Comet(stripPixels, stripCometSpeed, cometColorB, tail_length=stripCometTailLen), ), AnimationGroup( Solid(boardPixels, WHITE), Comet(stripPixels, stripCometSpeed, cometColorC, tail_length=stripCometTailLen), ))), AnimationGroup(Solid(boardPixels, WHITE), Solid(stripPixels, AMBER)), AnimationGroup( Solid(boardPixels, AMBER), Solid(stripPixels, 0), ), auto_clear=True, )
#rainbow_sparkle4 = RainbowSparkle(rect4, speed=0.1, num_sparkles=15) custom_color_chase4 = CustomColorChase(rect4, speed=0.1, size=2, spacing=3, colors=[ORANGE, WHITE, JADE]) animations = AnimationSequence(AnimationGroup(comet, comet2, comet3, comet4), AnimationGroup(blink, blink2, blink3, blink4), AnimationGroup(colorcycle, colorcycle2, colorcycle3, colorcycle4), AnimationGroup(chase, chase2, chase3, chase4), AnimationGroup(sparkle, sparkle2, sparkle3, sparkle4), AnimationGroup(solid, solid2, solid3, solid4), AnimationGroup(rainbow_comet, rainbow_comet2, rainbow_comet3, rainbow_comet4), AnimationGroup(sparkle_pulse, sparkle_pulse2, sparkle_pulse3, sparkle_pulse4), AnimationGroup(rainbow_chase, rainbow_chase2, rainbow_chase3, rainbow_chase4), AnimationGroup(custom_color_chase, custom_color_chase2, custom_color_chase3, custom_color_chase4), advance_interval=d, auto_clear=True) while True: animations.animate()
step=3) sparkle = Sparkle(pixels, speed=speeds[current_speed], color=WHITE, name="sparkle") rainbowfade = RainbowFade(pixels, speed=speeds[current_speed], name="rainbowfade") solid = Solid(pixels, color=colorwheel(0), name="solid") # Animation Sequence Playlist -- rearrange to change the order of animations animations = AnimationSequence( rainbow, rainbowfade, solid, sparkle, auto_clear=True, auto_reset=True, ) solid.speed = 0.01 solid_color = 0 while True: if cp.switch: # if slide switch is in the "on" position, run animations animations.animate() #play animation sequence if cp.button_a: animations.next() while cp.button_a: continue
speed=0.1, colors=rainbow_colors, size=2, spacing=3) custom_color_chase_bgp = CustomColorChase(pixels, speed=0.1, colors=[BLUE, GREEN, PINK], size=3, spacing=2) # Can use integer values for color, 0 is black custom_color_chase_br = CustomColorChase(pixels, speed=0.1, colors=[BLUE, 0, RED, 0], size=2, spacing=0) animations = AnimationSequence( custom_color_chase_rainbow, custom_color_chase_rainbow_r, custom_color_chase_rainbowchase, custom_color_chase_bgp, custom_color_chase_br, advance_interval=6, auto_clear=True, ) while True: animations.animate()
from adafruit_led_animation.color import RED, BLUE # Update to match the pin connected to your NeoPixels pixel_pin = board.D6 # Update to match the number of NeoPixels you have connected pixel_num = 32 # Update to matchpin connected to button that connect logic high when pushed button_pin = board.D3 pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.5, auto_write=False) button = DigitalInOut(button_pin) button.direction = Direction.INPUT button.pull = Pull.UP solid_blue = Solid(pixels, color=BLUE) solid_red = Solid(pixels, color=RED) animation_sequence = AnimationSequence(solid_blue, solid_red, auto_clear=True) while True: animation_sequence.animate() # Pressing the button pauses the animation permanently if not button.value: animation_sequence.next() while button.value: time.sleep(0.1) # Used for button debouncing
def switch_colors(anim): anim.color = colorwheel(random.randint(0, 255)) comet = Comet(pixels, speed=0.03, color=(0, 255, 255), tail_length=6, bounce=False) comet1 = Comet(pixels, speed=0.05, color=(255, 255, 0), tail_length=6, bounce=True) rainbow = Rainbow(pixels, speed=0.1, period=2, step=10) animations = AnimationSequence(comet, comet1, rainbow, advance_interval=6) comet.add_cycle_complete_receiver(switch_colors) comet.notify_cycles = 2 ble = BLERadio() uart_service = UARTService() advertisement = ProvideServicesAdvertisement(uart_service) while True: #advertise when not connected ble.start_advertising(advertisement) while not ble.connected: animations.animate() ble.stop_advertising()
colorwheel_offset=50, step=4) sparkle = Sparkle(pixels, speed=0.1, color=BLUE, num_sparkles=10) sparkle2 = Sparkle(pixels, speed=0.5, color=PURPLE, num_sparkles=4) off = Solid(pixels, color=BLACK) # Animations Playlist - reorder as desired. AnimationGroups play at the same time animations = AnimationSequence( rainbow_comet2, # rainbow_comet, # chase, # rainbow_chase, # rainbow, # AnimationGroup( sparkle, strum, ), AnimationGroup( sparkle2, rainbow_comet3, ), off, auto_clear=True, auto_reset=True, ) MODE = 1 LASTMODE = 1 # start up in sound reactive mode i = 0 # Are we already advertising? advertising = False
animations = AnimationSequence( AnimationGroup( fuego, fuego2, lava, sparkle, ), chase, rainbow_chase2, rainbow, AnimationGroup( rainbow_comet, sparkle3, ), AnimationGroup( rainbow_comet2, sparkle3, ), AnimationGroup( sparkle, strum, ), AnimationGroup( sparkle2, rainbow_comet3, ), AnimationGroup( black_left, black_right, ), black_left, auto_clear=True, auto_reset=True, )
brightness=0.5, auto_write=False) cp.pixels.brightness = 0.5 animations = AnimationSequence( # Synchronized to 0.5 seconds. Ignores the second animation setting of 3 seconds. AnimationGroup( Blink(cp.pixels, 0.5, color.CYAN), Blink(strip_pixels, 3.0, color.AMBER), sync=True, ), # Different speeds AnimationGroup( Comet(cp.pixels, 0.1, color.MAGENTA, tail_length=5), Comet(strip_pixels, 0.01, color.MAGENTA, tail_length=15), ), # Different animations AnimationGroup( Blink(cp.pixels, 0.5, color.JADE), Comet(strip_pixels, 0.05, color.TEAL, tail_length=15), ), # Sequential animations on the built-in NeoPixels then the NeoPixel strip Chase(cp.pixels, 0.05, size=2, spacing=3, color=color.PURPLE), Chase(strip_pixels, 0.05, size=2, spacing=3, color=color.PURPLE), advance_interval=3.0, auto_clear=True, auto_reset=True, ) while True: animations.animate()
tail_length=40, bounce=False) sparkle = Sparkle(pixel_map[4], speed=0.01, color=BLUE, num_sparkles=10) sparkle2 = Sparkle(pixel_map[1], speed=0.05, color=PURPLE, num_sparkles=4) # Animations Playlist - reorder as desired. AnimationGroups play at the same time animations = AnimationSequence( rainbow, rainbow_chase, rainbow_chase2, chase, lava, rainbow_comet, rainbow_comet2, AnimationGroup( sparkle, strum, ), AnimationGroup( sparkle2, rainbow_comet3, ), auto_clear=True, auto_reset=True, ) MODE = 0 LASTMODE = 1 # start up in sound reactive mode i = 0 # Main loop
from adafruit_led_animation.animation.rainbowcomet import RainbowComet from adafruit_led_animation.animation.rainbowsparkle import RainbowSparkle from adafruit_led_animation.sequence import AnimationSequence # Update to match the pin connected to your NeoPixels pixel_pin = board.D6 # Update to match the number of NeoPixels you have connected pixel_num = 32 pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.5, auto_write=False) rainbow = Rainbow(pixels, speed=0.1, period=2) rainbow_chase = RainbowChase(pixels, speed=0.1, size=5, spacing=3) rainbow_comet = RainbowComet(pixels, speed=0.1, tail_length=7, bounce=True) rainbow_sparkle = RainbowSparkle(pixels, speed=0.1, num_sparkles=15) animations = AnimationSequence( rainbow, rainbow_chase, rainbow_comet, rainbow_sparkle, advance_interval=5, auto_clear=True, ) while True: animations.animate()
# Update to match the pin connected to your NeoPixels pixel_pin = board.A1 # Update to match the number of NeoPixels you have connected pixel_num = 64 heart_mask = [ 1, 2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 33, 34, 35, 36, 37, 38, 42, 43, 44, 45, 51, 52 ] unheart_mask = [ 0, 3, 4, 7, 32, 39, 40, 41, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63 ] pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.9, auto_write=False) animations = AnimationSequence( Sparkle(pixels, speed=0.05, color=JADE, num_sparkles=1, mask=unheart_mask), Sparkle(pixels, speed=0.05, color=AQUA, num_sparkles=1), Sparkle(pixels, speed=0.05, color=PINK, num_sparkles=1, mask=heart_mask), advance_interval=5, auto_clear=False, ) while True: animations.animate()
spacing=6, color=JADE) rainbow_chase_v = RainbowChase(pixel_wing_vertical, speed=0.1, size=3, spacing=2, step=8) rainbow_comet_v = RainbowComet(pixel_wing_vertical, speed=0.1, tail_length=7, bounce=True) rainbow_v = Rainbow(pixel_wing_vertical, speed=0.1, period=2) rainbow_chase_h = RainbowChase(pixel_wing_horizontal, speed=0.1, size=3, spacing=3) animations = AnimationSequence( rainbow_v, comet_h, rainbow_comet_v, chase_h, rainbow_chase_v, comet_v, rainbow_chase_h, advance_interval=5, ) while True: animations.animate()