diagram.json

import array, time
from machine import Pin
import rp2


# PIO state machine for RGB. Pulls 24 bits (rgb -> 3 * 8bit) automatically
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()


# PIO state machine for RGBW. Pulls 32 bits (rgbw -> 4 * 8bit) automatically
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=32)
def sk6812():
    T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()


# we need this because Micropython can't construct slice objects directly, only by
# way of supporting slice notation.
# So, e.g. slice_maker[1::4] gives a slice(1,None,4) object.
class slice_maker_class:
    def __getitem__(self, slc):
        return slc


slice_maker = slice_maker_class()


# Delay here is the reset time. You need a pause to reset the LED strip back to the initial LED
# however, if you have quite a bit of processing to do before the next time you update the strip
# you could put in delay=0 (or a lower delay)
#
# Class supports different order of individual colors (GRB, RGB, WRGB, GWRB ...). In order to achieve
# this, we need to flip the indexes: in 'RGBW', 'R' is on index 0, but we need to shift it left by 3 * 8bits,
# so in it's inverse, 'WBGR', it has exactly right index. Since micropython doesn't have [::-1] and recursive rev()
# isn't too efficient we simply do that by XORing (operator ^) each index with 3 (0b11) to make this flip.
# When dealing with just 'RGB' (3 letter string), this means same but reduced by 1 after XOR!.
# Example: in 'GRBW' we want final form of 0bGGRRBBWW, meaning G with index 0 needs to be shifted 3 * 8bit ->
# 'G' on index 0: 0b00 ^ 0b11 -> 0b11 (3), just as we wanted.
# Same hold for every other index (and - 1 at the end for 3 letter strings).

class Neopixel:
    # Micropython doesn't implement __slots__, but it's good to have a place
    # to describe the data members...
    # __slots__ = [
    #    'num_leds',   # number of LEDs
    #    'pixels',     # array.array('I') of raw data for LEDs
    #    'mode',       # mode 'RGB' etc
    #    'W_in_mode',  # bool: is 'W' in mode
    #    'sm',         # state machine
    #    'shift',      # shift amount for each component, in a tuple for (R,B,G,W)
    #    'delay',      # delay amount
    #    'brightnessvalue', # brightness scale factor 1..255
    # ]

    def __init__(self, num_leds, state_machine, pin, mode="RGB", delay=0.0001):
        """
        Constructor for library class

        :param num_leds:  number of leds on your led-strip
        :param state_machine: id of PIO state machine used
        :param pin: pin on which data line to led-strip is connected
        :param mode: [default: "RGB"] mode and order of bits representing the color value.
        This can be any order of RGB or RGBW (neopixels are usually GRB)
        :param delay: [default: 0.0001] delay used for latching of leds when sending data
        """
        self.pixels = array.array("I", [0] * num_leds)
        self.mode = mode
        self.W_in_mode = 'W' in mode
        if self.W_in_mode:
            # RGBW uses different PIO state machine configuration
            self.sm = rp2.StateMachine(state_machine, sk6812, freq=8000000, sideset_base=Pin(pin))
            # tuple of values required to shift bit into position (check class desc.)
            self.shift = ((mode.index('R') ^ 3) * 8, (mode.index('G') ^ 3) * 8,
                          (mode.index('B') ^ 3) * 8, (mode.index('W') ^ 3) * 8)
        else:
            self.sm = rp2.StateMachine(state_machine, ws2812, freq=8000000, sideset_base=Pin(pin))
            self.shift = (((mode.index('R') ^ 3) - 1) * 8, ((mode.index('G') ^ 3) - 1) * 8,
                          ((mode.index('B') ^ 3) - 1) * 8, 0)
        self.sm.active(1)
        self.num_leds = num_leds
        self.delay = delay
        self.brightnessvalue = 255

    def brightness(self, brightness=None):
        """
        Set the overall value to adjust brightness when updating leds
        or return class brightnessvalue if brightness is None

        :param brightness: [default: None] Value of brightness on interval 1..255
        :return: class brightnessvalue member or None
        """
        if brightness is None:
            return self.brightnessvalue
        else:
            if brightness < 1:
                brightness = 1
        if brightness > 255:
            brightness = 255
        self.brightnessvalue = brightness

    def set_pixel_line_gradient(self, pixel1, pixel2, left_rgb_w, right_rgb_w, how_bright=None):
        """
        Create a gradient with two RGB colors between "pixel1" and "pixel2" (inclusive)

        :param pixel1: Index of starting pixel (inclusive)
        :param pixel2: Index of ending pixel (inclusive)
        :param left_rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing starting color
        :param right_rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing ending color
        :param how_bright: [default: None] Brightness of current interval. If None, use global brightness value
        :return: None
        """
        if pixel2 - pixel1 == 0:
            return
        right_pixel = max(pixel1, pixel2)
        left_pixel = min(pixel1, pixel2)

        with_W = len(left_rgb_w) == 4 and self.W_in_mode
        r_diff = right_rgb_w[0] - left_rgb_w[0]
        g_diff = right_rgb_w[1] - left_rgb_w[1]
        b_diff = right_rgb_w[2] - left_rgb_w[2]
        if with_W:
            w_diff = (right_rgb_w[3] - left_rgb_w[3])

        for i in range(right_pixel - left_pixel + 1):
            fraction = i / (right_pixel - left_pixel)
            red = round(r_diff * fraction + left_rgb_w[0])
            green = round(g_diff * fraction + left_rgb_w[1])
            blue = round(b_diff * fraction + left_rgb_w[2])
            # if it's (r, g, b, w)
            if with_W:
                white = round(w_diff * fraction + left_rgb_w[3])
                self.set_pixel(left_pixel + i, (red, green, blue, white), how_bright)
            else:
                self.set_pixel(left_pixel + i, (red, green, blue), how_bright)

    def set_pixel_line(self, pixel1, pixel2, rgb_w, how_bright=None):
        """
        Set an array of pixels starting from "pixel1" to "pixel2" (inclusive) to the desired color.

        :param pixel1: Index of starting pixel (inclusive)
        :param pixel2: Index of ending pixel (inclusive)
        :param rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing color to be used
        :param how_bright: [default: None] Brightness of current interval. If None, use global brightness value
        :return: None
        """
        if pixel2 >= pixel1:
            self.set_pixel(slice_maker[pixel1:pixel2 + 1], rgb_w, how_bright)

    def set_pixel(self, pixel_num, rgb_w, how_bright=None):
        """
        Set red, green and blue (+ white) value of pixel on position <pixel_num>
        pixel_num may be a 'slice' object, and then the operation is applied
        to all pixels implied by the slice (most useful when called via __setitem__)

        :param pixel_num: Index of pixel to be set or slice object representing multiple leds
        :param rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing color to be used
        :param how_bright: [default: None] Brightness of current interval. If None, use global brightness value
        :return: None
        """
        if how_bright is None:
            how_bright = self.brightness()
        sh_R, sh_G, sh_B, sh_W = self.shift
        bratio = how_bright / 255.0

        red = round(rgb_w[0] * bratio)
        green = round(rgb_w[1] * bratio)
        blue = round(rgb_w[2] * bratio)
        white = 0
        # if it's (r, g, b, w)
        if len(rgb_w) == 4 and self.W_in_mode:
            white = round(rgb_w[3] * bratio)

        pix_value = white << sh_W | blue << sh_B | red << sh_R | green << sh_G
        # set some subset, if pixel_num is a slice:
        if type(pixel_num) is slice:
            for i in range(*pixel_num.indices(self.num_leds)):
                self.pixels[i] = pix_value
        else:
            self.pixels[pixel_num] = pix_value

    def get_pixel(self, pixel_num):
        """
        Get red, green, blue and white (if applicable) values of pixel on position <pixel_num>

        :param pixel_num: Index of pixel to be set
        :return rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing color to be used
        """
        balance = self.pixels[pixel_num]
        sh_R, sh_G, sh_B, sh_W = self.shift
        if self.W_in_mode:
            w = (balance >> sh_W) & 255
        b = (balance >> sh_B) & 255
        r = (balance >> sh_R) & 255
        g = (balance >> sh_G) & 255
        red = int(r * 255 / self.brightness() )
        green = int(g * 255 / self.brightness() )
        blue = int(b * 255 / self.brightness() )
        if self.W_in_mode:
            white = int(w * 255 / self.brightness() )
            return (red,green,blue,white)
        else:
            return (red,green,blue)

    def __setitem__(self, idx, rgb_w):
        """
        if npix is a Neopixel object,
        npix[10] = (0,255,0)        # <- sets #10 to green
        npix[15:21] = (255,0,0)     # <- sets 16,17 .. 20 to red
        npix[21:29:2] = (0,0,255)   # <- sets 21,23,25,27 to blue
        npix[1::2] = (0,0,0)        # <- sets all odd pixels to 'off'
        (the 'slice' cases pass idx as a 'slice' object, and
        set_pixel processes the slice)

        :param idx: Index can either be indexing number or slice
        :param rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing color to be used
        :return:
        """
        self.set_pixel(idx, rgb_w)

    def colorHSV(self, hue, sat, val):
        """
        Converts HSV color to rgb tuple and returns it.
        The logic is almost the same as in Adafruit NeoPixel library:
        https://github.com/adafruit/Adafruit_NeoPixel so all the credits for that
        go directly to them (license: https://github.com/adafruit/Adafruit_NeoPixel/blob/master/COPYING)

        :param hue: Hue component. Should be on interval 0..65535
        :param sat: Saturation component. Should be on interval 0..255
        :param val: Value component. Should be on interval 0..255
        :return: (r, g, b) tuple
        """
        if hue >= 65536:
            hue %= 65536

        hue = (hue * 1530 + 32768) // 65536
        if hue < 510:
            b = 0
            if hue < 255:
                r = 255
                g = hue
            else:
                r = 510 - hue
                g = 255
        elif hue < 1020:
            r = 0
            if hue < 765:
                g = 255
                b = hue - 510
            else:
                g = 1020 - hue
                b = 255
        elif hue < 1530:
            g = 0
            if hue < 1275:
                r = hue - 1020
                b = 255
            else:
                r = 255
                b = 1530 - hue
        else:
            r = 255
            g = 0
            b = 0

        v1 = 1 + val
        s1 = 1 + sat
        s2 = 255 - sat

        r = ((((r * s1) >> 8) + s2) * v1) >> 8
        g = ((((g * s1) >> 8) + s2) * v1) >> 8
        b = ((((b * s1) >> 8) + s2) * v1) >> 8

        return r, g, b

    def rotate_left(self, num_of_pixels=None):
        """
        Rotate <num_of_pixels> pixels to the left

        :param num_of_pixels: Number of pixels to be shifted to the left. If None, it shifts for 1.
        :return: None
        """
        if num_of_pixels is None:
            num_of_pixels = 1
        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]

    def rotate_right(self, num_of_pixels=None):
        """
        Rotate <num_of_pixels> pixels to the right

        :param num_of_pixels: Number of pixels to be shifted to the right. If  None, it shifts for 1.
        :return: None
        """
        if num_of_pixels is None:
            num_of_pixels = 1
        num_of_pixels = -1 * num_of_pixels
        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]

    def show(self):
        """
        Send data to led-strip, making all changes on leds have an effect.
        This method should be used after every method that changes the state of leds or after a chain of changes.
        :return: None
        """
        # If mode is RGB, we cut 8 bits of, otherwise we keep all 32
        cut = 8
        if self.W_in_mode:
            cut = 0
        sm_put = self.sm.put
        for pixval in self.pixels:
            sm_put(pixval, cut)
        time.sleep(self.delay)

    def fill(self, rgb_w, how_bright=None):
        """
        Fill the entire strip with color rgb_w

        :param rgb_w: Tuple of form (r, g, b) or (r, g, b, w) representing color to be used
        :param how_bright: [default: None] Brightness of current interval. If None, use global brightness value
        :return: None
        """
        # set_pixel over all leds.
        self.set_pixel(slice_maker[:], rgb_w, how_bright)

    def clear(self):
        """
        Clear the entire strip, i.e. set every led color to 0.

        :return: None
        """
        self.pixels = array.array("I", [0] * self.num_leds)

neopixel.py

from machine import PWM, Pin
from time import sleep
import uasyncio

#Pico has PWM 8 slices
c0LED = 1 	#Torso
c1LED = 3	#Shoulder
c2LED = 5	#Waist
c3LED = 7	#Legs
c4LED = 9	#Unassigned
c5LED = 11	#Unassigned
c6LED = 13	#Unassigned
c7LED = 15	#Unassigned

btn = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_UP)

#Push button control
async def wait_button(): 
    btn_prev = btn.value()
    while (btn.value() == 1) or (btn.value() == btn_prev):
        btn_prev = btn.value()
        await uasyncio.sleep(0.1)

#A gradual increase in LED power. Max voltage should be your LED forward voltage, output caps at 3.3v.
# Breathrate is the rate LED brightens, range from 1-2000
async def powerUpLED(outPin, maxVolt, breathRate):
    analogOut=PWM(Pin(outPin))
    analogOut.freq(1000)
    analogOut.duty_u16(0)
    analogPWMState=0
    pwmVal=int((65550/3.3)*maxVolt)
    while True:
        try:
            while analogPWMState <= pwmVal:
                currentDuty=analogPWMState+breathRate   
                analogOut.duty_u16(currentDuty)
                analogPWMState=currentDuty
                if analogPWMState >= pwmVal:
                    analogPWMState=pwmVal
                    print('Max Volt')
                await uasyncio.sleep_ms(100)
        except uasyncio.CancelledError:
            analogOut.duty_u16(0)
            print('powerup cancel')
            raise

#Blinking gets rapidly faster.  
#example: tLED = uasyncio.create_task(blinkOnLED(c0LED, 1000, 100))          
async def blinkOnLED(outPin, initialDelay, blinkRate):
    led=machine.Pin(outPin, machine.Pin.OUT)
    currentBlink=initialDelay
    led.off()
    while True:
        try:
            if currentBlink > 0:
                led.toggle()
                await uasyncio.sleep_ms(currentBlink)
                currentBlink=currentBlink-blinkRate
            if currentBlink <= 0:
                led.on()
                currentBlink = 0
                await uasyncio.sleep_ms(1000)
        except uasyncio.CancelledError:
            led.off()
            print('blinkOn cancel')
            raise

#Blinks LED off/on according to blinkRate
#example: tLED = uasyncio.create_task(blinkyLED(c0LED, 1000))
async def blinkyLED(outPin, blinkRate):
    led=machine.Pin(outPin, machine.Pin.OUT)
    led.on()
    while True:
        try:
            led.toggle()
            await uasyncio.sleep_ms(blinkRate)
        except uasyncio.CancelledError:
            led.off()
            await uasyncio.sleep_ms(0)
            print('blink cancel')
            raise

# Solid brightness, set between 0-3.3v
async def steadyLED(outPin, maxVolt):
    analogOut=PWM(Pin(outPin))
    analogOut.duty_u16(0)
    analogOut.freq(1000)
    pwmVal=int((65550/3.3)*maxVolt)
    while True:
        try:
            analogOut.duty_u16(pwmVal)
            await uasyncio.sleep_ms(100)
        except uasyncio.CancelledError:
            analogOut.duty_u16(0)
            print('steady cancel')
            raise    

#Agradual increase and decrease in brigntness, set your min voltage and max voltage 0-3.3v
async def breathyLED(outPin, minVolt, maxVolt, breathRate):
    pwmValMax=int((65550/3.3)*maxVolt)
    pwmValMin=int((65550/3.3)*minVolt)
    analogOut=PWM(Pin(outPin))
    analogOut.freq(1000)
    analogOut.duty_u16(0)
    analogPWMState=pwmValMax
    analogUpDown=1
    while True:
        try: 
            while analogPWMState >= pwmValMin and analogUpDown == 1:
                currentDuty=analogPWMState-breathRate    
                if currentDuty <= pwmValMin:
                    currentDuty = pwmValMin
                    analogUpDown = 0
                    print('Breath In')
                analogOut.duty_u16(currentDuty)
                await uasyncio.sleep_ms(100)
                analogPWMState=currentDuty
                
            while analogPWMState < pwmValMax and analogUpDown == 0:
                currentDuty=analogPWMState+breathRate   
                analogOut.duty_u16(currentDuty)
                await uasyncio.sleep_ms(100)
                analogPWMState=currentDuty
                if currentDuty >= pwmValMax:
                    analogPWMState=pwmValMax
                    analogUpDown = 1
                    print('Hold Breath')
                    await uasyncio.sleep_ms(500)
                    print('Breath Out')
        except uasyncio.CancelledError:
            analogOut.duty_u16(0)
            print('breath cancel')
            raise        

async def main():
    active = True  
    bcount = 0
    tLED = uasyncio.create_task(blinkOnLED(c0LED, 250, 10))
    sLED = uasyncio.create_task(steadyLED(c1LED, 0))
    wLED = uasyncio.create_task(steadyLED(c2LED, 0))
    lLED = uasyncio.create_task(steadyLED(c3LED, 0))
    while True: # run forever
        try:
            await wait_button()
            if bcount == 0:
                sLED.cancel()
                wLED.cancel()
                lLED.cancel()
                tLED.cancel()
                await uasyncio.sleep(0)
                tLED = uasyncio.create_task(blinkyLED(c0LED, 1000))
                await uasyncio.sleep_ms(150)
                sLED = uasyncio.create_task(blinkyLED(c1LED, 1000))
                await uasyncio.sleep_ms(150)
                wLED = uasyncio.create_task(blinkyLED(c2LED, 1000))
                await uasyncio.sleep_ms(150)
                lLED = uasyncio.create_task(blinkyLED(c3LED, 1000))
                print(bcount)
                await uasyncio.sleep_ms(100)
            if bcount == 1:
                sLED.cancel()
                wLED.cancel()
                lLED.cancel()
                tLED.cancel()
                await uasyncio.sleep(0)
                tLED = uasyncio.create_task(blinkyLED(c0LED, 1000))
                sLED = uasyncio.create_task(blinkyLED(c1LED, 1000))
                wLED = uasyncio.create_task(blinkyLED(c2LED, 1000))
                lLED = uasyncio.create_task(blinkyLED(c3LED, 1000))
                print(bcount)
                await uasyncio.sleep_ms(100)
            if bcount == 2:
                sLED.cancel()
                wLED.cancel()
                lLED.cancel()
                tLED.cancel()
                await uasyncio.sleep(0)
                tLED = uasyncio.create_task(steadyLED(c0LED, 3.3))
                sLED = uasyncio.create_task(steadyLED(c1LED, 3.3))
                wLED = uasyncio.create_task(steadyLED(c2LED, 3.3))
                lLED = uasyncio.create_task(steadyLED(c3LED, 3.3))
                print(bcount)
                await uasyncio.sleep_ms(100)
            if bcount == 3:
                sLED.cancel()
                wLED.cancel()
                lLED.cancel()
                tLED.cancel()
                await uasyncio.sleep(0)
                tLED = uasyncio.create_task(breathyLED(c0LED, 0, 3.3, 2000))
                await uasyncio.sleep_ms(150)
                sLED = uasyncio.create_task(breathyLED(c1LED, 0, 3.3, 2000))
                await uasyncio.sleep_ms(150)
                wLED = uasyncio.create_task(breathyLED(c2LED, 0, 3.3, 2000))
                await uasyncio.sleep_ms(150)
                lLED = uasyncio.create_task(breathyLED(c3LED, 0, 3.3, 2000))
                print(bcount)
                await uasyncio.sleep_ms(100)
            bcount = bcount + 1
            if bcount > 3 :
                bcount = 0
        except uasyncio.CancelledError:
            print('Canceled')

uasyncio.run(main())

    





main.py

# queue.py: adapted from uasyncio V2

# Copyright (c) 2018-2020 Peter Hinch
# Released under the MIT License (MIT) - see LICENSE file

# Code is based on Paul Sokolovsky's work.
# This is a temporary solution until uasyncio V3 gets an efficient official version

import uasyncio as asyncio


# Exception raised by get_nowait().
class QueueEmpty(Exception):
    pass


# Exception raised by put_nowait().
class QueueFull(Exception):
    pass

class Queue:

    def __init__(self, maxsize=0):
        self.maxsize = maxsize
        self._queue = []
        self._evput = asyncio.Event()  # Triggered by put, tested by get
        self._evget = asyncio.Event()  # Triggered by get, tested by put

        self._jncnt = 0
        self._jnevt = asyncio.Event()
        self._upd_jnevt(0) #update join event

    def _get(self):
        self._evget.set()  # Schedule all tasks waiting on get
        self._evget.clear()
        return self._queue.pop(0)

    async def get(self):  #  Usage: item = await queue.get()
        while self.empty():  # May be multiple tasks waiting on get()
            # Queue is empty, suspend task until a put occurs
            # 1st of N tasks gets, the rest loop again
            await self._evput.wait()
        return self._get()

    def get_nowait(self):  # Remove and return an item from the queue.
        # Return an item if one is immediately available, else raise QueueEmpty.
        if self.empty():
            raise QueueEmpty()
        return self._get()

    def _put(self, val):
        self._upd_jnevt(1) # update join event
        self._evput.set()  # Schedule tasks waiting on put
        self._evput.clear()
        self._queue.append(val)

    async def put(self, val):  # Usage: await queue.put(item)
        while self.full():
            # Queue full
            await self._evget.wait()
            # Task(s) waiting to get from queue, schedule first Task
        self._put(val)

    def put_nowait(self, val):  # Put an item into the queue without blocking.
        if self.full():
            raise QueueFull()
        self._put(val)

    def qsize(self):  # Number of items in the queue.
        return len(self._queue)

    def empty(self):  # Return True if the queue is empty, False otherwise.
        return len(self._queue) == 0

    def full(self):  # Return True if there are maxsize items in the queue.
        # Note: if the Queue was initialized with maxsize=0 (the default) or
        # any negative number, then full() is never True.
        return self.maxsize > 0 and self.qsize() >= self.maxsize


    def _upd_jnevt(self, inc:int): # #Update join count and join event
        self._jncnt += inc
        if self._jncnt <= 0:
            self._jnevt.set()
        else:
            self._jnevt.clear()

    def task_done(self): # Task Done decrements counter
        self._upd_jnevt(-1)

    async def join(self): # Wait for join event
        await self._jnevt.wait()



queue.py

from neopixel import Neopixel
import random
from machine import Pin
import uasyncio
import queue


btn = machine.Pin(15, machine.Pin.IN, machine.Pin.PULL_UP)
numpix = 16
headPix = [0, 3]
chestPix = [4, 7]
thrusterPix = [8, 11]
strip = Neopixel(numpix, 0, 28, "GRB")

red = (255, 0, 0)
orange = (255, 165, 0)
yellow = (255, 150, 0)
green = (0, 255, 0)
cyan = (0, 255, 255)
blue = (0, 0, 255)
indigo = (75, 0, 130)
violet = (138, 43, 226)
off = (0, 0, 0)
colors_rgb = (red, orange, yellow, green, cyan, blue, indigo, violet)

strip.brightness(255)


async def rainbow(colors, q, sectionPix):
    active = True
    pix = sectionPix
    while True:
        try:
            if not q.empty():
                active = await q.get()
            if active == True:
                for color in colors:
                    for i in range(pix[0],pix[1]+1):
                        strip.set_pixel(i, color)
                        await uasyncio.sleep_ms(10)
                        strip.show()
            else: 
                strip.set_pixel_line(pix[0],pix[1], off)
                strip.show()
            await uasyncio.sleep_ms(10)    
        except uasyncio.CancelledError:
            strip.set_pixel_line(pix[0],pix[1], off)
            strip.show()
            print('Rainbow cancel')
            raise
            
        
async def pulseStrip(sectionPix, color, step): #breathing leds, pass the head/chest/thruster, color, and breathing speed
    upDown = 0
    pix = sectionPix
    pulseColor = color
    currentBrightness = 0
    while True:
        try:
            if upDown == 0:
                setBrightness = currentBrightness + step
                if setBrightness > 255:
                    setBrightness = 255
                    upDown = 1
                strip.set_pixel_line(pix[0], pix[1], pulseColor, setBrightness)
                #strip.show()
                currentBrightness = setBrightness
            
            if upDown == 1:
                setBrightness = currentBrightness - step
                if setBrightness < 0:
                    setBrightness = 0
                    upDown = 0
                strip.set_pixel_line(pix[0], pix[1], pulseColor, setBrightness)
                #strip.show()
                currentBrightness = setBrightness
            
            strip.show()
            await uasyncio.sleep_ms(100)
        except uasyncio.CancelledError:
            strip.set_pixel_line(pix[0],pix[1], off)
            strip.show()
            print('pulse cancel')
            raise

async def powerUP(sectionPix, color):
    currentBrightness = 0
    speed=1000
    pix = sectionPix
    strip.set_pixel_line(pix[0],pix[1], off)
    strip.set_pixel(pix[0], color)    
    while True:
        try:
            if speed <= 0:
                strip.set_pixel_line(pix[0],pix[1], off) 
                strip.set_pixel_line(pix[0],pix[1], color)
                await uasyncio.sleep(0)
            else:
                for i in range(pix[0],pix[1]+1):
                    strip.set_pixel_line(pix[0],pix[1], off)
                    strip.set_pixel(i, color)
                    await uasyncio.sleep_ms(100)
                strip.set_pixel_line(pix[0],pix[1], off)    
                if currentBrightness < 255:
                    currentBrightness += 50
                if currentBrightness > 255:
                    currentBrightness = 255
                strip.show()    
                await uasyncio.sleep_ms(speed)  
                speed = speed - 100 
        except uasyncio.CancelledError:
            strip.set_pixel_line(pix[0],pix[1], off)
            strip.show()
            print('powerUP cancel')
            raise
             
            
async def wait_button():
    btn_prev = btn.value()
    while (btn.value() == 1) or (btn.value() == btn_prev):
        btn_prev = btn.value()
        await uasyncio.sleep(0.1)

async def main():
    active = True  
    bcount = 0
    q = queue.Queue()
    r = queue.Queue()
    hLEDs = uasyncio.create_task(rainbow(colors_rgb, q, headPix))
    cLEDs = uasyncio.create_task(pulseStrip(chestPix, blue, 50))
    tLEDs = uasyncio.create_task(powerUP(thrusterPix, violet))
    #tasksLED = uasyncio.all_tasks()
    while True: # run forever
        try:
            await wait_button()
            #uasyncio.cancel(*LEDs)
            if bcount == 0:
                hLEDs.cancel()
                cLEDs.cancel()
                tLEDs.cancel()
                await uasyncio.sleep(0)
                hLEDs = uasyncio.create_task(pulseStrip(headPix, green, 50))
                print(bcount)
                await uasyncio.sleep_ms(100)
            if bcount == 1:
                hLEDs.cancel()
                cLEDs.cancel()
                tLEDs.cancel()
                await uasyncio.sleep(0)
                hLEDs = uasyncio.create_task(pulseStrip(headPix, blue, 100))
                print(bcount)
                await uasyncio.sleep_ms(100)
            if bcount == 2:
                hLEDs.cancel()
                cLEDs.cancel()
                tLEDs.cancel()
                await uasyncio.sleep(0)
                hLEDs = uasyncio.create_task(pulseStrip(headPix, red, 200))
                print(bcount)
                await uasyncio.sleep_ms(100)
            bcount = bcount + 1
            if bcount > 2 :
                bcount = 0
        except uasyncio.CancelledError:
            print('Canceled')
        

uasyncio.run(main())

