class RubanLeds():
""" Classe d'animation du ruban de leds Neopixels RGB
/!\ A partir de 9 leds il faut alimenter le ruban en 5v avec une alimentation externe
dépendance: bibliothèque ws2812.py nécessaire
usage: leds = RubanLeds(nb_leds, intensity)
* nb_leds: nombre de leds sur le ruban (8 par défaut).
* intensity = intensité des leds 0 à 1 (1 par défaut)
"""
def __init__(self, nb_leds=8, intensity=1):
"""constructeur de la classe
nb_leds: nombre de leds du ruban (8 par défaut)
intensity 0 à 1 (1 par défaut)
"""
self.pixels = NeoPixel(spi_bus=1, led_count=nb_leds, intensity=intensity )
self.nb_leds = nb_leds # nb de leds du rubans
self.wait_shortms = 0.001 # délais d'attente ultra-court (en secondes)
self.wait_short = 0.01 # délais d'attente (secondes) courts
self.wait_long = 0.03 # délais d'attente (secondes) plus long
self.rgbMIN = 10 # min pour les couleurs au hasard
self.rgbMAXpastel = 127 # max pour les couleurs au hasard pastel
self.rgbMAXhigh = 255 # max pour les couleurs au hasard vives
# méthodes utilisées pour contrôler les animations
#-------------------------------------------------
def fade_in_out(self, fadein=True):
""" retourne tuple (start, end, step) pour parcourir les leds du ruban dans un ordre:
fadein = True : de la 1ère led à la dernière (valeur par défaut)
fadein = False: de la dernière led à la première
"""
start, end, step = 0 , self.nb_leds, 1
if not fadein:
start, end, step = self.nb_leds-1, -1 , -1
return (start, end, step)
def wheel(self, pos):
""" pos = 0 to 255 correspond à une couleur arc en ciel
transition r - g - b - back to r.
retourne un tuple (r,g,b)
"""
if pos < 0 or pos > 255:
r = g = b = 0
elif pos < 85:
r = int(pos * 3)
g = int(255 - pos*3)
b = 0
elif pos < 170:
pos -= 85
r = int(255 - pos*3)
g = 0
b = int(pos*3)
else:
pos -= 170
r = 0
g = int(pos*3)
b = int(255 - pos*3)
return (r, g, b)
def shuffle(self, l):
"""Fisher–Yates shuffle Algorithm : la methode random.shuffle(l) n'existant pas en micropython
input: l = liste
retourne la liste l mélangée
"""
for i in range(len(l)-1, 0, -1): # parcours la liste à l'envers
j = randint(0, i) # random index entier dans l'intervalle [0, i]
l[i], l[j] = l[j], l[i] # Swap l[i] avec l[j]
return l
# méthodes d'extinction du ruban
#----------------------------------
def off(self):
""" éteint toutes les leds d'un coup """
self.pixels.fill((0,0,0))
self.pixels.write()
def fade_off(self, fadein = True):
""" éteint toutes les leds une après les autres
fadein = True pour simuler un fade in en partant de la 1ère led
fadein = False pour un fade out en partant de la dernière led
"""
start, end, step = self.fade_in_out(fadein)
for l in range(start, end, step):
self.pixels[l] = (0,0,0)
self.pixels.write()
sleep(self.wait_short)
# méthodes de rendus de couleur d'une led
#-----------------------------------------
def pcolor_random(self, pastel=True, red=True, green=True, blue=True):
""" retourne une couleur (r,g,b) au hasard
pastel: rendu de couleur pastel(True) ou vives(False)
red=False: couleur sans rouge
green=False: couelmur sans vert
blue=False: couleur sans bleu
"""
rgbMAX = pastel * self.rgbMAXpastel + (not pastel) * self.rgbMAXhigh
r,g,b = 0,0,0
#on évite la combinaison (0,0,0) qui éteint la led ...
while (r+g+b) <= self.rgbMIN :
r,g,b = red*randrange(0,rgbMAX), green*randrange(0,rgbMAX), blue*randrange(0,rgbMAX)
return (r,g,b)
def pcolor_wheel(self, id_led):
""" retourne une couleur (r,g,b) arc-en-ciel selon la position de la led """
pixel_index = (id_led * 256 // self.nb_leds)
return self.wheel(pixel_index & 255)
# méthodes d'animation du ruban de leds
#-----------------------------------------------------------------------------------------
def rainbow_cycle(self):
""" cycle de couleurs arc-en ciel """
for j in range(255):
for i in range(self.nb_leds):
pixel_index = (i * 256 // self.nb_leds) + j
self.pixels[i] = self.wheel(pixel_index & 255)
self.pixels.write()
sleep(self.wait_shortms)
def random_cycle(self, pastel=True, red=True, green=True, blue=True):
""" cycle de couleurs aléatoires
pastel: True/False pour des couleurs pastel ou vives
red, green, blue = True/False pour activer/désactiver des composantes Rouge, Verte, Bleue
"""
for l in range(self.nb_leds):
self.pixels[l] = self.pcolor_random(pastel=pastel, red=red, green=green, blue=blue)
self.pixels.write()
sleep(self.wait_long)
def fade_wheel(self, fadein=True):
""" anime le ruban de leds avec des couleurs arc-enciel
fadein = True: fade in depuis la 1ère leds jusqu'à la dernière
fadein = False: fade out depuis la dernière led jusqu'à la 1ère
"""
start, end, step = self.fade_in_out(fadein)
for l in range(start, end, step):
self.pixels[l] = self.pcolor_wheel(l)
sleep(self.wait_long)
self.pixels.write()
def fade_random(self, fadein = True, pastel=True, red=True, green=True, blue=True):
""" anime le ruban de leds avec un fade-in de couleurs aléatoires
params: fadein = True pour un Fade-in False Fade-out
pastel: True/False pour avoir des couleurs pastels ou vives
red,green,blue : True/False pour activer/désactiver une composante rouge, verte, bleu
"""
start, end, step = self.fade_in_out(fadein)
for l in range(start, end, step):
self.pixels[l] = self.pcolor_random(red=red, green=green, blue=blue)
sleep(self.wait_long)
self.pixels.write()
def shuffle_wheel(self):
""" anime le ruban en allumant les leds au hasard avec couleur arc-en-ciel """
leds = self.shuffle([i for i in range(self.nb_leds)])
for l in leds:
pixel_index = (l * 256 // self.nb_leds)
self.pixels[l] = self.wheel(pixel_index & 255)
sleep(self.wait_short)
self.pixels.write()
def shuffle_random(self, pastel=True, red=True, green=True, blue=True):
""" anime le ruban en allumant les leds au hasard avec couleur aléatoire """
leds = self.shuffle([i for i in range(self.nb_leds)])
for l in leds:
self.pixels[l] = self.pcolor_random(red=red, green=green, blue=blue)
sleep(self.wait_short)
self.pixels.write()
def mono_wheel(self, fadein = True, delay=0.1):
""" anime le ruban en allumant toutes les leds de la même couleur
changmeent de couleur après chaque delay (en secondes)
en suivant le rythme de couleur arc-en-ciel
fadin: True démarre l'animation avec un fade in de puis la 1er led
False: ... depuis la dernière led
"""
#1ère mise en couleur avec fadein
start, end, step = self.fade_in_out(fadein)
for l in range(start, end, step):
self.pixels[l] = self.pcolor_wheel(0)
sleep(self.wait_long)
self.pixels.write()
#enchainer les couleurs arc-en-ciel pour toutes le leds
for j in range(255):
for i in range(self.nb_leds):
self.pixels[i] = self.wheel(j)
self.pixels.write()
sleep(delay)
def mono_color(self, fadein = True, color = (2555,0,0), delay=0.1):
""" anime le ruban en allumant tous les leds de la même couleur 'color'
fadin: True démarre l'animation avec un fade in de puis la 1er led
False: ... depuis la dernière led
delay: delay d'attente
"""
#mise en couleur avec fadein
start, end, step = self.fade_in_out(fadein)
for l in range(start, end, step):
self.pixels[l] = color
sleep(self.wait_long)
self.pixels.write()
sleep(delay)
* Library source @ https://github.com/mchobby/esp8266-upy/tree/master/neopixel * Shop: https://shop.mchobby.be/55-leds-neopixels-et-dotstar """ from ws2812 import NeoPixel from time import sleep np = NeoPixel(spi_bus=1, led_count=8, intensity=1) # Fixer la couleur la couleur du premier pixel # avec un tuple (r,g,b) ou chaque valeur est # située entre 0 et 255 np[0] = (255, 0, 0) # rouge np[1] = (0, 255, 0) # vert np[2] = (0, 0, 128) # bleu (1/2 brillance) # Voir aussi HTML Color Picker # https://www.w3schools.com/colors/colors_picker.asp np[3] = (255, 102, 0) # Orange np[4] = (255, 0, 102) # Rose bonbon np[5] = (153, 51, 255) # Violet np[6] = (102, 153, 255) # bleu pastel np[7] = (153, 255, 153) # vert pastel np.write() sleep(2) # Tout éteindre np.fill((0, 0, 0)) np.write()
np[1] = (0, 255, 0) # vert
np[2] = (0, 0, 128) # bleu (1/2 brillance)
# Voir aussi HTML Color Picker
# https://www.w3schools.com/colors/colors_picker.asp
np[3] = (255, 102, 0) # Orange
np[4] = (255, 0, 102) # Rose bonbon
np[5] = (153, 51, 255) # Violet
np[6] = (102, 153, 255) # bleu pastel
np[7] = (153, 255, 153) # vert pastel
# Envoyer l'info au NeoPixels
np.write()
sleep(2)
# fill() permet de remplir tout
# le NeoPixel avec une seule couleur
colors = [ (255,0,0), (0, 255, 0), (0, 0, 128),
(255, 102, 0) , (255, 0, 102), (153, 51, 128),
(102, 153, 128), (153, 255, 128) ]
for color in colors:
np.fill( color )
np.write()
sleep(2)
# Eteindre les NeoPixels
np.fill( (0,0,0) )
np.write()
""" test_allblue.py - set all the pixels to BLUE to check power and data wiring * Author(s): Meurisse D. from MCHobby (shop.mchobby.be). See project source @ https://github.com/mchobby/pyboard-projects/tree/master/word-clock """ from wclib import * from ws2812 import NeoPixel # Pyboard NeoPixel( spi_bus=1, led_count=1, intensity=1 ) -> X8 np = NeoPixel(spi_bus=1, led_count=len(PANEL) * len(PANEL[0])) np.fill((0, 0, 255)) np.write()
from pyb import Switch from machine import Pin, I2C from time import sleep from ws2812 import NeoPixel from tcs34725 import TCS34725 # Pyboard - SDA=Y10, SCL=Y9 i2c = I2C(2) np = NeoPixel( spi_bus=1, led_count=44, intensity=1) np.fill( (0,128,0) ) # Starting GBR np.write() color = TCS34725(i2c) color.integration_time = 400 # Bigger integration time means collect more data about color led = Pin( "Y12", Pin.OUT, value=False ) switch = Switch() # Wired on Pin def gamma_255( x ): """ Apply a gamma correction factor for a value in the range 0 - 255 """ x /= 255 x = pow(x, 2.5) x *= 255 return int(x) if x < 255 else 255 def gamma_color( color ): """ Apply the Gamma correction to a tuple of rgb color. Eyes does not sense the color range in a linear way """ return gamma_255(color[0]), gamma_255(color[1]), gamma_255(color[2]) # Started and ready for operation