Neopixel effects fun topic

[MrTinkerman]

Hey all,

I've been playing around with Neopixels and MicroPython and so far it's fun!
(Micro)Python syntax enabled me to achieve effects I never dreamed of in Arduino C++

Below is my code so far.
I'm using:

• WS2812B leds
• https://github.com/blaz-r/pi_pico_neopixel

Close Encounters, comes close enough for now.
Next on my list is Knight-Rider ;)

I'm just doing this for fun, not a professional.
Code improvement and ideas are welcome.

I'm curious about what others have done using Neopixels,
share your results in this topic.

If you share your code please:

• State the library you are using
• Share complete code

import time
from neopixel import Neopixel                               # https://github.com/blaz-r/pi_pico_neopixel
import random

numpix = 16  # Number of NeoPixels
pix = [p for p in range(16)]
strip = Neopixel(numpix, 1, 15, "GRB")                      # Neopixel(num_leds, state_machine, pin, mode="RGB", delay=0.0001+

# gamma correction for brightness 3                         # https://victornpb.github.io/gamma-table-generator/
gamma = [0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   2,   2,
         2,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,   3,   4,   4,   4,
         4,   4,   4,   5,   5,   5,   5,   6,   6,   6,   6,   7,   7,   7,   7,   8,
         8,   8,   9,   9,   9,  10,  10,  10,  11,  11,  11,  12,  12,  13,  13,  13,
        14,  14,  15,  15,  16,  16,  17,  17,  18,  18,  19,  19,  20,  20,  21,  21,
        22,  22,  23,  24,  24,  25,  26,  26,  27,  28,  28,  29,  30,  30,  31,  32,
        33,  33,  34,  35,  36,  37,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,
        46,  47,  48,  49,  50,  51,  53,  54,  55,  56,  57,  58,  59,  60,  61,  63,
        64,  65,  66,  67,  69,  70,  71,  72,  74,  75,  76,  78,  79,  81,  82,  83,
        85,  86,  88,  89,  91,  92,  94,  95,  97,  99, 100, 102, 103, 105, 107, 108,
       110, 112, 114, 115, 117, 119, 121, 123, 124, 126, 128, 130, 132, 134, 136, 138,
       140, 142, 144, 146, 148, 150, 153, 155, 157, 159, 161, 163, 166, 168, 170, 173,
       175, 177, 180, 182, 184, 187, 189, 192, 194, 197, 199, 202, 205, 207, 210, 212,
       215, 218, 221, 223, 226, 229, 232, 234, 237, 240, 243, 246, 249, 252, 255, 255]  

colors = [
           (0,0,0),      # Off
           (255, 0, 0),  # Red
           (0, 255, 0),  # Green
           (0, 0, 255),  # Blue
         ]


strip.fill((0,0,0))
strip.show()
    


def random_RGB(delay):
    
    for p in range(numpix):
         
        color_index = random.randint(0, len(colors)-1)
        strip.set_pixel(p, colors[color_index], 1)                  # set_pixel(self, pixel_num, rgb_w, how_bright=None)
                                                                    # how_bright default value is overall brightness                                                      
    strip.show()
    time.sleep_ms(delay)
    
    
def random_brightness(color_index, delay):
    
    #brightness = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
    brightness = [1,2,5,10]
    
    for p in range(numpix):
        
        brightness_index = random.randint(0, len(brightness)-1)
        strip.set_pixel(p, colors[color_index], brightness[brightness_index])                  # set_pixel(self, pixel_num, rgb_w, how_bright=None)
                                                                                               # how_bright default value is overall brightness                                                      
    strip.show()
    time.sleep_ms(delay)
    
    
def random_color(delay):
    
    while True:
        color = (random.randint(0, 255),random.randint(0, 255),random.randint(0, 255))
            
        for p in pix:
            
            strip.set_pixel(p, color, 2)
            strip.show()
        
        time.sleep_ms(delay)
    
    
def fade():
    delay = 10
    fade_vals = [0 for p in pix]
    val = 0
    color = colors[1]
    
    while True:
        
        for k in range(254):
            print(val)
            strip.set_pixel(5, color, gamma[val])
            val += 1
            strip.show()
            time.sleep_ms(delay)
        for k in range(254):
            print(val)
            strip.set_pixel(5, color, gamma[val])
            val -= 1
            strip.show()
            time.sleep_ms(delay)
    
    
def close_encounters():
    
    # Patience: Takes a few seconds to start up
    
    colors       = [(0, 0, 0),(0, 0, 0),(0, 0, 0),                        # Choose/add colors to use 
                    (255, 0, 0),(0, 255, 0),(0, 0, 255),(255,255,0),      # Adding more 'zero-colors' makes less leds light up
                    (255,0,255),(0,255,255),(100,150,0),(0,150,100)]
    min_b, max_b = 20, 80                                                 # Minimum and maximum brightness level
    delay        = 250                                                    # Initial delay between update of brightness value
    counter      = 0                                                      # Counter used to decrease delay and speed up sequence
    
    pix_color    = [random.randint(1, 2) for s in range(16)]              # list to store current color for each pixel
    fade_speed   = [random.randint(1, 10) for s in range(16)]             # List of random values (1/2/3) to increment or decrement brightnes by
    max_brt      = [random.randint(min_b, max_b) for s in range(16)]      # Maximum brightness of each pixel 
    fade_dir     = [1 for d in range(16)]                                 # Fade direction, 1=increment 0=decrement, 1 at startup
    brt          = [0 for d in range(16)]                                 # Current brightness for each pixel, set to zero at startup   
    
    
    while True:
        
        for p in pix:
            
            if fade_dir[p]==1: brt[p] += fade_speed[p]
            else:              brt[p] -= fade_speed[p]
            
            if brt[p] >= max_brt[p]:                                       # If the after incrementing is 255 or more, 
                brt[p] = max_brt[p]                                        # set value to 255
                fade_speed[p] = random.randint(1, 10)
                fade_dir[p] = 0                                            # set fade direction to decrement/down
                
            if brt[p] <= 0:                                                # If the after deccrementing is 0 or less,
                brt[p] = 0                                                 # set value to 0
                pix_color[p] = random.randint(0, len(colors)-1)
                max_brt[p] = random.randint(min_b, max_b)                  # Set a new max brightness for the pixel
                fade_speed[p] = random.randint(1, 10)
                fade_dir[p] = 1                                            # set fade direction to increment/up
                
            strip.set_pixel(p, colors[pix_color[p]], gamma[brt[p]])
            
        strip.show()
        
        counter += 1
        if counter % 50 == 0 and delay > 20 : delay -= 30
        #if delay < 50 : delay = 250
        
        time.sleep_ms(delay)
    
    
def police():
    
    brightness = 2
    color = (0, 0, 255)
    delay = 35
    flashes = 8
    p1 = pix[:8]
    print(p1)
    p2 = pix[8:]
    print(p2)
   
    while True:        
        
        for f in range(flashes):
            # Side 1 one
            for p in p1:
                strip.set_pixel(p, color, brightness)
            strip.show()
            time.sleep_ms(delay)
            # Side 1 off
            for p in p1:
                strip.set_pixel(p, (0,0,0), brightness)
            strip.show()
            time.sleep_ms(delay)

        for f in range(flashes):
            # Side 2 on
            for p in p2:
                strip.set_pixel(p, color, brightness)
            strip.show()
            time.sleep_ms(delay)
            # Side 2 off
            for p in p2:
                strip.set_pixel(p, (0,0,0), brightness)
            strip.show()
            time.sleep_ms(delay)
  
  
while True:
    
    #random_RGB(300)                             # random_RGB(delay) 
    #random_brightness(2, 25)                    #random_brightness(color_index, delay)
    #random_color(1000)                          # random_color(delay)
    #police()
    close_encounters()
    
    

[MrTinkerman]

And here is my Knight Rider code

import time
from neopixel import Neopixel                               # https://github.com/blaz-r/pi_pico_neopixelprint(len(spectrum))


numpix = 16  # Number of NeoPixels
pix = [p for p in range(16)]
strip = Neopixel(numpix, 1, 15, "GRB")                      # Neopixel(num_leds, state_machine, pin, mode="RGB", delay=0.0001+

# gamma correction for brightness 3                         # https://victornpb.github.io/gamma-table-generator/
gamma = [0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
         1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   2,   2,
         2,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,   3,   4,   4,   4,
         4,   4,   4,   5,   5,   5,   5,   6,   6,   6,   6,   7,   7,   7,   7,   8,
         8,   8,   9,   9,   9,  10,  10,  10,  11,  11,  11,  12,  12,  13,  13,  13,
        14,  14,  15,  15,  16,  16,  17,  17,  18,  18,  19,  19,  20,  20,  21,  21,
        22,  22,  23,  24,  24,  25,  26,  26,  27,  28,  28,  29,  30,  30,  31,  32,
        33,  33,  34,  35,  36,  37,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,
        46,  47,  48,  49,  50,  51,  53,  54,  55,  56,  57,  58,  59,  60,  61,  63,
        64,  65,  66,  67,  69,  70,  71,  72,  74,  75,  76,  78,  79,  81,  82,  83,
        85,  86,  88,  89,  91,  92,  94,  95,  97,  99, 100, 102, 103, 105, 107, 108,
       110, 112, 114, 115, 117, 119, 121, 123, 124, 126, 128, 130, 132, 134, 136, 138,
       140, 142, 144, 146, 148, 150, 153, 155, 157, 159, 161, 163, 166, 168, 170, 173,
       175, 177, 180, 182, 184, 187, 189, 192, 194, 197, 199, 202, 205, 207, 210, 212,
       215, 218, 221, 223, 226, 229, 232, 234, 237, 240, 243, 246, 249, 252, 255, 255]  


strip.fill((0,0,0))
strip.show()
    

def knight_rider():
    
    color = (255, 0, 0)                                       # Red for knight Rider
    max_b = 150                                               # Minimum and maximum brightness level
    delay = 50                                                # Delay between update of brightness value
    
    fade_step   = 25                                          # Steps to increment or decrement brightnes by
    brt          = [0 for b in range(16)]                     # Initial brightness for each pixel is zero
    
    # sequence = [0, .... numpix-1, numpix, numpix-1 ... ,1]
    seq = [p for p in range(0,numpix,1)] + [p for p in range(numpix-2,0,-1)]               
    # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    
    leading_p = 0                                             # Leading pixel
    
    while True:
        
        for p in pix:                                          
                
                if brt[p] >= fade_step:                       # Each loop the brightness of all pixels
                    brt[p] -= fade_step                       # is reduced by fade_step or,
                else:                                         # if brt[p] is smaller then fade_step, set to zero
                    brt[p] = 0
        
        brt[seq[leading_p]] = max_b                           # Set the brightness of the leading pixel to max
        leading_p += 1                                        # Increment for next pass
        if leading_p == len(seq) : leading_p = 0              # Set to zero, the begin of seq 
        
        for p in pix:                                         # Update pixels
                strip.set_pixel(p, color, gamma[brt[p]])
        
        strip.show()
        time.sleep_ms(delay)
        

knight_rider()

[richsad-vcs]

Thanks for uploading this. I am using this with blaz-r's https://github.com/blaz-r/pi_pico_neopixel. There are some bugs in the close_encounters function that are fixed by the following code:

pix_color = [random.randint(1, 2) for s in range(numpix)] # list to store current color for each pixel fade_speed = [random.randint(1, 10) for s in range(numpix)] # List of random values (1/2/3) to increment or decrement brightnes by max_brt = [random.randint(min_b, max_b) for s in range(numpix)] # Maximum brightness of each pixel fade_dir = [1 for d in range(numpix)] # Fade direction, 1=increment 0=decrement, 1 at startup brt = [0 for d in range(numpix)] # Current brightness for each pixel, set to zero at startup

The original code makes the sin of hardcoding the list sizes to 16, but in my case I have 64 and 256 numpix.