# Example showing how functions, that accept tuples of rgb values,
# simplify working with gradients

import time
from neopixel import Neopixel
from class_fsm import CFsm
from class_led import CLed
from class_button import CButton

numpix = 16
strip = Neopixel(numpix, 0, 18, "GRB")
# strip = Neopixel(numpsix, 0, 0, "GRBW")

mom_bp_couleur = CButton( 17, "BP_COU" )
mom_bp_multicouleur = CButton( 16, "BP_MCOU" )
mom_bp_vitesse= CButton( 16, "BP_VIT" )

red = (255, 0, 0)
orange = (255, 50, 0)
yellow = (255, 100, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
indigo = (100, 0, 90)
violet = (200, 0, 100)
colors_rgb = [red, orange, yellow, green, blue, indigo, violet]

# same colors as normaln rgb, just 0 added at the end
colors_rgbw = [color+tuple([0]) for color in colors_rgb]
colors_rgbw.append((0, 0, 0, 255))

# uncomment colors_rgbw if you have RGBW strip
colors = colors_rgb
# colors = colors_rgbw


step = round(numpix / len(colors))
current_pixel = 0
strip.brightness(100)

for color1, color2 in zip(colors, colors[1:]):
    strip.set_pixel_line_gradient(current_pixel, current_pixel + step, color1, color2)
    current_pixel += step

strip.set_pixel_line_gradient(current_pixel, numpix - 1, violet, red)
# Machine d'état

#--------------------------------------------------
# fonctions de transition

def fsm_tr_couleur ():
    strip.rotate_right(1)
    time.sleep(0.05)
    strip.show()

def fsm_tr_multicouleur():
    strip.rotate_right(1)
    time.sleep(0.5)
    strip.show()

def fsm_tr_vitesse():
    strip.rotate_right(1)
    time.sleep(1.5)
    strip.show()

# Définition du dictionnaire

template_fsm_dict = {
    "COULEUR": ({"event":"BP_COU_PRESS","fct":fsm_tr_couleur,"n_state":"COULEUR"},
                ),
    "MULTICOULEUR": ({"event":"BP_MCOU_PRESS","fct":fsm_tr_multicouleur,"n_state":"MULTICOULEUR"},
                ),
    "VITESSE": ({"event":"BP_VIT_PRESS","fct":fsm_tr_vitesse,"n_state":"VITESSE"},
                )
    }

# initialise les composants

ma_fsm = CFsm(template_fsm_dict,"COULEUR")

#--------------------------------------------------
#--------------------------------------------------
# initialise les états par défaut
#pixels.brightness(100)
#colors_rgb =(green)
    strip.rotate_right(1)
    time.sleep(0.5)
    strip.show()

#--------------------------------------------------
#--------------------------------------------------
# boucle principale
while True:
    
    # appel les tâches des différents composants
    # ces composants peuvent retourner un evènement
    # entrée
    ma_fsm.put( mom_bp_couleur.task() )
    ma_fsm.put( mom_bp_multicouleur.task() )
    ma_fsm.put( mom_bp_vitesse.task() )
    
    # timer
    
    #sortie
    #ma_fsm.put( ma_led_jaune.task() )
    #ma_fsm.put( ma_led_rouge.task() )
    
    # fsm
    ma_fsm.task()
    



main.py

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()


# 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:
    def __init__(self, num_leds, state_machine, pin, mode="RGB", delay=0.0001):
        self.pixels = array.array("I", [0 for _ in range(num_leds)])
        self.mode = set(mode)   # set for better performance
        if 'W' in self.mode:
            # RGBW uses different PIO state machine configuration
            self.sm = rp2.StateMachine(state_machine, sk6812, freq=8000000, sideset_base=Pin(pin))
            # dictionary of values required to shift bit into position (check class desc.)
            self.shift = {'R': (mode.index('R') ^ 3) * 8, 'G': (mode.index('G') ^ 3) * 8,
                          'B': (mode.index('B') ^ 3) * 8, 'W': (mode.index('W') ^ 3) * 8}
        else:
            self.sm = rp2.StateMachine(state_machine, ws2812, freq=8000000, sideset_base=Pin(pin))
            self.shift = {'R': ((mode.index('R') ^ 3) - 1) * 8, 'G': ((mode.index('G') ^ 3) - 1) * 8,
                          'B': ((mode.index('B') ^ 3) - 1) * 8, 'W': 0}
        self.sm.active(1)
        self.num_leds = num_leds
        self.delay = delay
        self.brightnessvalue = 255

    # Set the overal value to adjust brightness when updating leds
    def brightness(self, brightness=None):
        if brightness == None:
            return self.brightnessvalue
        else:
            if brightness < 1:
                brightness = 1
        if brightness > 255:
            brightness = 255
        self.brightnessvalue = brightness

    # Create a gradient with two RGB colors between "pixel1" and "pixel2" (inclusive)
    # Function accepts two (r, g, b) / (r, g, b, w) tuples
    def set_pixel_line_gradient(self, pixel1, pixel2, left_rgb_w, right_rgb_w):
        if pixel2 - pixel1 == 0:
            return
        right_pixel = max(pixel1, pixel2)
        left_pixel = min(pixel1, pixel2)

        for i in range(right_pixel - left_pixel + 1):
            fraction = i / (right_pixel - left_pixel)
            red = round((right_rgb_w[0] - left_rgb_w[0]) * fraction + left_rgb_w[0])
            green = round((right_rgb_w[1] - left_rgb_w[1]) * fraction + left_rgb_w[1])
            blue = round((right_rgb_w[2] - left_rgb_w[2]) * fraction + left_rgb_w[2])
            # if it's (r, g, b, w)
            if len(left_rgb_w) == 4 and 'W' in self.mode:
                white = round((right_rgb_w[3] - left_rgb_w[3]) * fraction + left_rgb_w[3])
                self.set_pixel(left_pixel + i, (red, green, blue, white))
            else:
                self.set_pixel(left_pixel + i, (red, green, blue))

    # Set an array of pixels starting from "pixel1" to "pixel2" (inclusive) to the desired color.
    # Function accepts (r, g, b) / (r, g, b, w) tuple
    def set_pixel_line(self, pixel1, pixel2, rgb_w):
        for i in range(pixel1, pixel2 + 1):
            self.set_pixel(i, rgb_w)

    # Set red, green and blue value of pixel on position <pixel_num>
    # Function accepts (r, g, b) / (r, g, b, w) tuple
    def set_pixel(self, pixel_num, rgb_w):
        pos = self.shift

        red = round(rgb_w[0] * (self.brightness() / 255))
        green = round(rgb_w[1] * (self.brightness() / 255))
        blue = round(rgb_w[2] * (self.brightness() / 255))
        white = 0
        # if it's (r, g, b, w)
        if len(rgb_w) == 4 and 'W' in self.mode:
            white = round(rgb_w[3] * (self.brightness() / 255))

        self.pixels[pixel_num] = white << pos['W'] | blue << pos['B'] | red << pos['R'] | green << pos['G']

    # Converts HSV color to rgb tuple and returns it
    # Function accepts integer values for <hue>, <saturation> and <value>
    # 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)
    def colorHSV(self, hue, sat, val):
        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


    # Rotate <num_of_pixels> pixels to the left
    def rotate_left(self, num_of_pixels):
        if num_of_pixels == None:
            num_of_pixels = 1
        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]

    # Rotate <num_of_pixels> pixels to the right
    def rotate_right(self, num_of_pixels):
        if num_of_pixels == None:
            num_of_pixels = 1
        num_of_pixels = -1 * num_of_pixels
        self.pixels = self.pixels[num_of_pixels:] + self.pixels[:num_of_pixels]

    # Update pixels
    def show(self):
        # If mode is RGB, we cut 8 bits of, otherwise we keep all 32
        cut = 8
        if 'W' in self.mode:
            cut = 0
        for i in range(self.num_leds):
            self.sm.put(self.pixels[i], cut)
        time.sleep(self.delay)

    # Set all pixels to given rgb values
    # Function accepts (r, g, b) / (r, g, b, w)
    def fill(self, rgb_w):
        for i in range(self.num_leds):
            self.set_pixel(i, rgb_w)
        time.sleep(self.delay)




neopixel.py

# Example showing how functions, that accept tuples of rgb values,
# simplify working with gradients

import time
from neopixel import Neopixel

numpix = 30
strip = Neopixel(numpix, 0, 28, "GRB")
# strip = Neopixel(numpsix, 0, 0, "GRBW")

red = (255, 0, 0)
orange = (255, 50, 0)
yellow = (255, 100, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
indigo = (100, 0, 90)
violet = (200, 0, 100)
colors_rgb = [red, orange, yellow, green, blue, indigo, violet]

# same colors as normaln rgb, just 0 added at the end
colors_rgbw = [color+tuple([0]) for color in colors_rgb]
colors_rgbw.append((0, 0, 0, 255))

# uncomment colors_rgbw if you have RGBW strip
colors = colors_rgb
# colors = colors_rgbw


step = round(numpix / len(colors))
current_pixel = 0
strip.brightness(50)

for color1, color2 in zip(colors, colors[1:]):
    strip.set_pixel_line_gradient(current_pixel, current_pixel + step, color1, color2)
    current_pixel += step

strip.set_pixel_line_gradient(current_pixel, numpix - 1, violet, red)

while True:
    strip.rotate_right(1)
    time.sleep(0.15)
    strip.show()


colorwave.py



#--------------------------------------------------
#--------------------------------------------------
# exemple d'un moteur de machine d'état
# lors de l'init on donne un dictionnaire composé comme suit:
# la clé contient le nom de l'état courant (texte)
# la valeur contient une list composée de dictionnaire.
# chaque dictionnaire est formatée de la façon suivante:
# key "event" valeur : un nom d'événement (texte) qui déclanche la trransition
# key "fct" valeur : le nom de la fonction de transition a appeler
# key "n_state" valeur : le nom de l'état suivant (texte)

class CFsm:
    
    def __init__(self, i_fsm_dict, i_initial_state):
        self.fsm_dict = i_fsm_dict
        self.c_state = i_initial_state
        self.event_list = list()
        
    def put(self, i_evt):
        if i_evt:
            self.event_list.append( i_evt )
            print(f"ajoute l'evt {i_evt}")
        
    def task(self):
        # récupere le prochain event dans la fifo
        if self.event_list :
            l_evt = self.event_list.pop(0)
            # process le nouvel event
            print(f"Process event {l_evt}")
            # récupère la liste d'évènement concernant notre état courant
            fsm_evt_list = self.fsm_dict[self.c_state]
            # pour chaque entrée
            for item in fsm_evt_list :
                # si l'entrée correspond à l'évenement à traiter
                if item["event"] == l_evt:
                    # si il y a une fonction de transition définie
                    if item["fct"]:
                        # on l'appel
                        item["fct"]()
                    # on définit le nouvel état courant
                    self.c_state = item["n_state"]
                    # on a fini le traitement
                    break
                
        



class_fsm.py

from machine import Pin # importe la classe Pin qui représente une broche
import time

class CButton:
    
    # i_pin : numéro de la broche utilisée
    # i_prefix : prefix ajouter à l'évènement générer.
    # ex: si i_prefix vaut "BP_AV", l'évenement de fin d'allumage vaut BP_AV_TIMEOUT
   
    def __init__(self, i_pin, i_prefix):
        self.bp=Pin(i_pin, Pin.IN, Pin.PULL_UP) # broche en entrée avec pull-up
        self.prefix=i_prefix
        self.hold_time = time.ticks_ms()
        self.hold_bp_value = 1
        self.debounce_counter = 0
    
    def task(self):
        lo_evt = None
        # debouncing du boutton à une vitesse de 20 ms
        if (time.ticks_ms() - self.hold_time) > 20:
            # lit la broche
            l_val = self.bp.value()
            if l_val != self.hold_bp_value :
                # l'état à changer on recharge le compteur de debounce
                self.hold_bp_value = l_val
                self.debounce_counter = 3
            else:
                if self.debounce_counter > 0:
                    self.debounce_counter -= 1
                    if self.debounce_counter == 0:
                        # on a un nouvel état stable
                        # retourne l'évènement approprié
                        if l_val == 1:
                            lo_evt = f"{self.prefix}_RELEASE"
                        else:
                            lo_evt = f"{self.prefix}_PRESS"
            
        return lo_evt
            
        
        


class_button.py

from machine import Pin # importe la classe Pin qui représente une broche
import time

class CLed:
    # i_pin : numéro de la broche utilisée
    # i_prefix : prefix ajouter à l'évènement générer.
    # ex: si i_prefix vaut "LED_JAUNE", l'évenement de fin d'allumage vaut LED_JAUNE_TIMEOUT
    def __init__(self, i_pin, i_prefix):
        self.led=Pin(i_pin, Pin.OUT) # met la broche en sortie
        self.prefix = i_prefix
    
    def on(self):
        self.led.on()
        
    def off(self):
        self.led.off()
        
    def task(self):
        return None
        
