Add simple support for different modes

code/light_modes.py

@@ -0,0 +1,65 @@
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Modes for neopixels strip
+Each function update the NeoPixel strip buffer (except update_neopixel() that
+call them)
+"""
+
+import time
+import urandom
+
+
+def update_neopixel(mode, np_strp, col=(255, 255, 255), bri=50):
+    """Update NeoPixel strip with one color
+    :param np_strp : NeoPixel object
+    :param mode : mode ;)
+    :param col : color [R, G, B] (default: [255, 255, 255])
+    :param bri : brightness 0-100 (default: 50)
+    """
+    # Apply mode
+    MODES_LST[mode](np_strp, col)
+
+    # Apply brightness to the whole LEDs
+    np_strp.buf = bytearray([int(x * bri / 100) for x in np_strp.buf])
+
+    np_strp.write()
+
+def fill_usr(np_strp, col):
+    """Update NeoPixel strip with one color
+    :param np_strp : NeoPixel object
+    :param col : color [R, G, B]
+    """
+    np_strp.fill(col)
+
+
+def fill_white(np_strp, col=(255, 255, 255)):
+    """Update NeoPixel strip with only white
+    :param np_strp : NeoPixel object
+    :param col : color [R, G, B] (ignored, default=(255, 255, 255))
+    """
+    np_strp.fill((255, 255, 255))
+
+
+def sparkles(np_strp, col):
+    """Make Neopixel sparkle with user defined color!!!
+    """
+    np_strp.fill((0, 0, 0))
+
+    for _ in range(int(np_strp.n / 4)):
+        pix = int(urandom.getrandbits(8) / 256 * (np_strp.n - 1))
+        print(pix)
+        np_strp[pix] = col
+
+
+MODES_LST = (fill_usr, fill_white, sparkles)

code/main.py

@@ -27,11 +27,13 @@ import neopixel
 from uos import uname
 from encoder import Encoder
 
+import light_modes
+
 #Paramètres
 
 NB_PIX = 8                  # Nombre de pixels
 MAX_BRIGHT = 100            # Luminosité max (100 max.)
-COLOR = [255, 255, 255]     # Couleur de base (à luminosité max)
+USR_COLOR = [255, 120, 20]     # Couleur de base (à luminosité max)
 
 #Déclaration des objets et initialisation des variables
 
@@ -66,12 +68,6 @@ else:
     print("Carte non-supportée :", BRD_TYPE)
     quit()
 
-# # Only with ESP32 : add timing param.
-# # timing param =0 for "old" 400kHz neopixel (default)
-# #              =1 for "new" 800kHz neopixel
-# pixel_strip = neopixel.NeoPixel(machine.Pin(NEOPIX_PIN), NB_PIX, timing=1)
-# coul_tmp = [0, 0, 0]
-
 #Eteint tout à l'initialisation
 NPXL_STRIP.fill([0, 0, 0])
 NPXL_STRIP.write()
@@ -86,22 +82,10 @@ ENC_BUT = machine.Pin(ENC_PIN_C, machine.Pin.IN)
 
 #Variables d'état
 BRIGHTN = 50            # Luminosité (0 - 100)
-PWR = False            # Est-ce que l'éclairage est allumé ?
+PWR = True              # Est-ce que l'éclairage est allumé ?
 BUTTN_STATE = 1
-
+curr_mode = 0
-def update_neopixel(np_strp, col, bri=50):
+pwroff_dl = 0
-    """Update NeoPixel strip with one color
-    :param np_strp : NeoPixel object
-    :param col : color [R, G, B]
-    :param bri : brightness 0-100 (default: 50)
-    """
-    col_tmp = [0, 0, 0]
-
-    for i in range(3):
-        col_tmp[i] = int(col[i] * bri / 100)
-
-    np_strp.fill(col_tmp)
-    np_strp.write()
 
 #####################
 # BOUCLE PRINCIPALE #
@@ -109,32 +93,59 @@ def update_neopixel(np_strp, col, bri=50):
 
 while True:
 
-    # Si on a un changement de valeur, on met à jour la luminisité et l'éclairage
+    # Si on est dans l'état allumé:
-    # des NeoPixel
+    if PWR:
-    if PWR and BRIGHTN != ENCODER.value:
+        # Si on a un changement de valeur, on met à jour la luminosité
-        print(ENCODER.value)
+        if PWR and BRIGHTN != ENCODER.value:
-        BRIGHTN = ENCODER.value
+            print(ENCODER.value)
-        update_neopixel(NPXL_STRIP, COLOR, BRIGHTN)
+            BRIGHTN = ENCODER.value
 
-    # Quand le bouton central est appuyé puis relâché, on allume ou on éteint
+        # Si on a juste un clic rapide sur le bouton, on change de mode au
-    if ENC_BUT.value() == 0 and BUTTN_STATE == 1:
+        # relachement du bouton
-        PWR = not PWR
+        if ENC_BUT.value() == 1 and BUTTN_STATE == 0:
-        print("Power :", PWR)
+            curr_mode = curr_mode + 1
-        if not PWR:
+            print("Mode : {}/{}".format(curr_mode, len(light_modes.MODES_LST)))
-            # Extinction des LED
+            if curr_mode >= len(light_modes.MODES_LST):
-            NPXL_STRIP.fill((0, 0, 0))
+                curr_mode = 0
-            NPXL_STRIP.write()
+
+        # Mise à jour des LED
+        light_modes.update_neopixel(curr_mode, NPXL_STRIP, USR_COLOR, BRIGHTN)
+
+
+    # Quand le bouton central est appuyé puis relâché rapidement, on change de
+    # mode
+    # Si on laisse appuyer 2 secondes: extinction
+    if ENC_BUT.value() == 0:
+        print("appui")
+        if BUTTN_STATE == 1:
+            # Deadline avant de changer l'état d'allumage
+            pwroff_dl = time.ticks_add(time.ticks_ms(), 2000)
+            print(pwroff_dl)
         else:
-            # Luminité basse si on allume avec une luminisité de 0
+            # Est-ce que la deadline est atteinte ? si oui on change l'état
-            if BRIGHTN == 0:
+            # d'allumage
-                BRIGHTN = 10
+            print(pwroff_dl, "/", time.ticks_ms())
+            if time.ticks_diff(time.ticks_ms(), pwroff_dl) >= 0:
+                PWR = not PWR
+                pwroff_dl = 0
+                print("Power :", PWR)
+                if not PWR:
+                    # Extinction des LED
+                    NPXL_STRIP.fill((0, 0, 0))
+                    NPXL_STRIP.write()
+                else:
+                    # Luminosité basse si on rallume avec une luminisité de 0
+                    if BRIGHTN == 0:
+                        BRIGHTN = 10
 
-            # On remet l'encodeur à la dernière luminosité connue
+                    # On remet l'encodeur à la dernière luminosité connue
-            # pour ignorer les mouvements pendant l'extinction
+                    # pour ignorer les mouvements pendant l'extinction
-            ENCODER.reset(BRIGHTN)
+                    ENCODER.reset(BRIGHTN)
-            # Rallume les LED:
+
-            update_neopixel(NPXL_STRIP, COLOR, BRIGHTN)
+                # on attend que le bouton soit relâché
+                while ENC_BUT.value() == 0:
+                    time.sleep_ms(10)
 
     BUTTN_STATE = ENC_BUT.value()
 
-    time.sleep_ms(20)
+    time.sleep_ms(5)