Module Python `stripleds`

Introduction

Le module Python stripleds est conçu pour piloter un ruban LED WS2812 connecté à un Arduino. Il permet de charger, configurer et exécuter des animations lumineuses complexes à partir de fichiers de définition textuels. Ce manuel inclut un exemple détaillé de fichier texte compatible avec la méthode load.

Prérequis

Matériel

Un Arduino (par ex. Mega, Uno, Nano) connecté à un ruban LED WS2812.
Un ruban LED WS2812 avec alimentation adaptée au nombre de LEDs.
Connexion USB entre l’Arduino et l’ordinateur.

Logiciel

Python 3.6 ou supérieur.
Installation de la bibliothèque pyserial :

Shell

pip install pyserial

3. Code C préchargé sur l’Arduino pour interpréter les commandes suivantes :

CLEAR : Réinitialiser les animations.
ADD <définition> : Ajouter une définition (animation, tableau, ou scène).
START <scene_id> : Démarrer une scène.
STOP : Arrêter toutes les animations en cours.
BRIGHTNESS <valeur> : Régler la luminosité.
STATUS : Obtenir l’état actuel.

Initialisation

Création de l’Objet

Python

from stripleds import stripleds

strip = stripleds(port="/dev/ttyUSB0", baud_rate=9600, leds_number=300, run=True, debug=True)

Paramètres

port : Port série de l’Arduino (ex. : COM3 ou /dev/ttyUSB0).
baud_rate : Taux de transfert série (par défaut : 9600).
leds_number : Nombre total de LEDs sur le ruban.
run : Active l’envoi de commandes série si True.
debug : Affiche les commandes dans la console si True.

Méthodes Disponibles

1. Effacer les Définitions : `clear_definitions()`

Réinitialise les définitions (animations, tableaux, scènes) sur l’Arduino.

Python

strip.clear_definitions()

2. Ajouter une Définition : `add_definition(definition)`

Ajoute une définition (animation, tableau, ou scène).

Paramètre definition : Une chaîne de texte interprétée par l’Arduino.

Exemple :

Python

strip.add_definition("a1,animation,blink,0,10,500,white,red")

3. Démarrer une Scène : `start_scene(scene_id)`

Démarre une scène spécifique.

Paramètre scene_id : Identifiant de la scène (par ex., s1).

Exemple :

Python

strip.start_scene("s2")

4. Arrêter les Animations : `stop_scene()`

Arrête toutes les animations en cours.

Python

strip.stop_scene()

5. Régler la Luminosité : `set_brightness(brightness)`

Définit l’intensité lumineuse (valeur de 0 à 255).

Exemple :

Python

strip.set_brightness(128)

6. Obtenir le Statut : `get_status()`

Récupère des informations sur l’état actuel du système.

Exemple :

Python

status = strip.get_status()
print(status)

7. Charger un Fichier de Définitions : `load(definitions_path)`

Charge un fichier texte contenant des définitions d’animations, tableaux et scènes.

Format d’un Fichier de Définitions

Un fichier de définitions contient trois types d’éléments :

Animations (aX) : Définitions des animations appliquées à un groupe de LEDs.
Tableaux (tX) : Combinaisons de plusieurs animations avec durée.
Scènes (sX) : Combinaisons de tableaux exécutés en séquence.

Exemple de Fichier Compatible

Python

# Animations —————–
a1,animation,blink,0,10,500,white,red
a2,animation,static,11,20,500,blue
a3,animation,rainbow,76,100
a4,animation,blink,11,20,1000,red,green
a5,animation,heartbeat,0,50,3000,blue,black
a6,animation,fire,31,40,50
a7,animation,snowfall,200,250,200,black
a8,animation,snowfall,250,200,100,white
a9,animation,fire,8,25,200
a10,animation,smoke,200,250,100
a11,animation,caterpillar,200,250,100,darkcyan,tomato

# Tableaux ——————-
t1,tableau,10,a1,a2
t2,tableau,60,a11

# Scenes ———————
s1,scene,t1
s2,scene,t2

Chargement du Fichier

Python

strip.load("definitions.txt")

Le fichier peut inclure des commentaires (lignes commençant par #).

Les lignes vides ou les définitions incorrectes seront ignorées.

8. Fermer la Connexion : `close()`

Ferme le port série proprement.

Python

strip.close()

Exemple Complet

Python

from stripleds import stripleds

# Initialisation
strip = stripleds(port="/dev/ttyUSB0", baud_rate=115200, leds_number=300, debug=True)

# Effacer les définitions
strip.clear_definitions()

# Charger les définitions depuis un fichier
strip.load("definitions.txt")

# Démarrer une scène
strip.start_scene("s2")

# Régler la luminosité
strip.set_brightness(200)

# Afficher l'état
print(strip.get_status())

# Arrêter les animations
strip.stop_scene()

# Fermer la connexion
strip.close()

Conseils Pratiques

Validation des Définitions : Avant d’exécuter une animation, assurez-vous que le fichier de définitions correspond aux fonctionnalités implémentées dans le firmware Arduino.
Test de Communication Série : Utilisez un terminal série pour vérifier les commandes envoyées et leur réponse.
Gestion de l’Alimentation : Assurez-vous que votre alimentation est suffisante pour le nombre de LEDs configurées.

Manuel d’utilisation du firmware « stripleds »

Introduction

Le firmware « stripleds » contrôle un ruban LED WS2812 pour générer des animations lumineuses personnalisées. Il est conçu pour être utilisé sur une plateforme Arduino (ex. Mega), avec la bibliothèque FastLED. Ce manuel décrit en détail les fonctionnalités, la structure et les commandes pour exploiter efficacement le programme.

Caractéristiques principales

Animations lumineuses personnalisées :
- Blink (clignotement)
- Static (couleur fixe)
- Rainbow (arc-en-ciel)
- Fire (feu)
- Heartbeat (battement de cœur)
- Snowfall (chute de neige)
- Smoke (fumée)
- Caterpillar (chenillard)
Définition des animations :
- Jusqu’à 16 animations simultanées.
- Possibilité de regrouper des animations dans des tableaux.
- Organisation des tableaux dans des scènes.
Commandes en temps réel :
- Gestion via le port série.
- Commandes pour ajouter, démarrer ou arrêter des scènes et animations.
Support d’effets avancés :
- Palette de couleurs prédéfinies.
- Gestion des effets dynamiques (flocons, fumée, etc.).
Configuration flexible :
- Jusqu’à 300 LEDs supportées (modifiable dans le code).
- Paramètres des animations adaptables (zones, couleurs, durées, etc.).

Installation

Matériel requis :

Microcontrôleur : Arduino Mega ou équivalent.
Ruban LED WS2812 (jusqu’à 300 LEDs).
Résistance 470 Ω entre le DATA_PIN (broche 5) et l’entrée du ruban LED.
Condensateur 1000 µF (facultatif, pour stabiliser l’alimentation).

Connexion :

Connectez le DATA_PIN (broche 5) à l’entrée Data du ruban.
Branchez le GND de l’Arduino au GND du ruban.
Connectez une alimentation externe (adaptée au nombre de LEDs).

Utilisation du programme

Démarrage :

Téléversez le programme sur l’Arduino via l’IDE Arduino.
Ouvrez le moniteur série, configurez le baudrate à 9600.
Le programme est prêt à recevoir des commandes série.

Commandes disponibles

1. Gestion des définitions

CLEAR
- Supprime toutes les animations, tableaux et scènes.
- Réponse : OK Cleared definitions
ADD <definition>
- Ajoute une animation, un tableau ou une scène.
- Format des définitions :
  - Animation : id,animation,type,start,end,period,color1,color2
  - Tableau : id,tableau,duration,animation1,animation2,...
  - Scène : id,scene,tableau1,tableau2,...
- Exemple : ADD a1,animation,blink,0,10,500,red,blue
- Réponse : OK Animation added ou ER Invalid definition

2. Gestion des scènes

START <scene_id>
- Lance l’exécution d’une scène.
- Réponse : OK Started scene ou ER Scene not found
STOP
- Arrête la scène en cours.
- Réponse : OK Stopped scene

3. État du programme

STATUS
- Vérifie si une scène est en cours.
- Réponse : running ou idle

4. Luminosité globale

BRIGHTNESS <value>
- Définit la luminosité du ruban (0 à 255).
- Exemple : BRIGHTNESS 128
- Réponse : OK 128

Définitions détaillées

1. Animation

Champ	Description
`id`	Identifiant unique (ex. `a1`)
`type`	Type d’animation (`blink`, `static`, etc.)
`start`	LED de début
`end`	LED de fin
`period`	Période en millisecondes
`color1`	Couleur principale
`color2`	Couleur secondaire

Exemple : ADD a1,animation,blink,0,50,500,red,blue

2. Tableau

Champ	Description
`id`	Identifiant unique (ex. `t1`)
`duration`	Durée d’exécution (secondes)
`animations`	Liste des animations à inclure

Exemple : ADD t1,tableau,30,a1,a2

3. Scène

Champ	Description
`id`	Identifiant unique (ex. `s1`)
`tableaux`	Liste des tableaux à exécuter

Exemple : ADD s1,scene,t1,t2

Effets supportés

Effet	Description
`blink`	LEDs alternent entre deux couleurs.
`static`	LEDs affichent une couleur fixe.
`rainbow`	Effet arc-en-ciel sur la zone spécifiée.
`fire`	Simule des flammes réalistes.
`heartbeat`	Simule un battement de cœur.
`snowfall`	Simule la chute de neige.
`smoke`	Simule des particules de fumée en mouvement.
`caterpillar`	Chenillard avec des couleurs dynamiques.

Maintenance et dépannage

LEDs éteintes :
- Vérifiez l’alimentation et les connexions.
- Envoyez STATUS pour vérifier l’état du programme.
Animation incorrecte :
- Assurez-vous que les définitions sont valides.
- Supprimez tout avec CLEAR et réessayez.
Problèmes de performance :
- Réduisez le nombre de LEDs ou la fréquence des animations.

Source module python

Python

import serial,time

class stripleds:
    def __init__(self, port, baud_rate=9600, leds_number=300,run=True,debug=True):
        self.run=run
        self.debug=debug
        if self.run:
            self.port = port
            self.baud_rate = baud_rate
            self.leds_number = leds_number
            self.serial = serial.Serial(port, baud_rate, timeout=2)
            self._check_connection()
        time.sleep(2)

    def _check_connection(self):
        if not self.serial.is_open:
            raise ConnectionError(f"Cannot open serial port {self.port}")

    def _send_command(self, command):
        if self.run:
            if not self.serial.is_open:
                raise ConnectionError("Serial port is not open")
            self.serial.write((command + '\n').encode())
            self.serial.flush()
        time.sleep(1)
        if self.run:
            response = self.serial.readline().decode().strip()
            return response
        return "OK simulation"

    def clear_definitions(self):
        if self.debug:
            print(f"CLEAR")
        if self.run:
            return self._send_command("CLEAR")
        return "OK simulation"
    
    def add_definition(self, definition):
        if self.debug:
            print(definition)
        if self.run:
            return self._send_command(f"ADD {definition}")
        return "OK simulation"
    
    def start_scene(self, scene_id):
        if self.debug:
            print(f"START {scene_id}")
        if self.run:
            return self._send_command(f"START {scene_id}")
        return "OK simulation"
    
    def stop_scene(self):
        if self.debug:
            print(f"STOP")
        if self.run:
            return self._send_command("STOP")
        return "OK simulation"
    
    def close(self):
        if self.debug:
            print(f"CLOSE")
        if self.run:
            if self.serial.is_open:
                self.serial.close()
        return "OK simulation"        
                
    def get_status(self):
        if self.run:
            return self._send_command("STATUS")
        return "OK simulation"
    
    def load(self,definitions_path):
        print(self.clear_definitions())
        with open(definitions_path,"r") as finp:
            for line in finp:
                w=line.strip()
                if not w.startswith("#") and not w.startswith("["):
                    print(self.add_definition(w))
                    
    def set_brightness(self,brightness):
        if self.run:
            return self._send_command(f"BRIGHTNESS {brightness}")
        return "OK simulation"

Source firmware Arduino

#include <FastLED.h>

// Palette pour les couleurs du feu

DEFINE_GRADIENT_PALETTE(firePalette) {
  0,   0,   0,   0,    // Noir
  64,  255, 0,   0,    // Rouge
  128, 255, 165, 0,    // Orange
  192, 255, 255, 0,    // Jaune
  255, 255, 255, 255   // Blanc chaud
};
// NE PAS MODIFIER l'EMPLACEMENT DE CETTE DECLARATION
CRGBPalette16 firePal = firePalette;

const uint32_t colors[]=
{
    0x000000, // Black
    0xFFFFFF, // White
    0xFF0000, // Red
    0x00FF00, // Green
    0x0000FF, // Blue
    0xFFFF00, // Yellow
    0x00FFFF, // Cyan
    0xFF00FF, // Magenta
    0xFFA500, // Orange
    0xFFC0CB, // Pink
    0x800080, // Purple
    0x008080, // Teal
    0x808000, // Olive
    0xA52A2A, // Brown
    0xFFD700, // Gold
    0xC0C0C0, // Silver
    0xFF8C00, // DarkOrange
    0xFF7F50, // Coral
    0xFA8072, // Salmon
    0xFF6347, // Tomato
    0x87CEEB, // SkyBlue
    0x00BFFF, // DeepSkyBlue
    0xADD8E6, // LightBlue
    0x1E90FF, // DodgerBlue
    0xE6E6FA, // Lavender
    0xF5FFFA, // MintCream
    0xFFDAB9, // PeachPuff
    0xFFB6C1, // LightPink
    0x8B0000, // DarkRed
    0x006400, // DarkGreen
    0x00008B, // DarkBlue
    0x008B8B  // DarkCyan
};

const String color_names[] = {
    "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta",
    "orange", "pink", "purple", "teal", "olive", "brown", "gold", "silver",
    "darkorange", "coral", "salmon", "tomato", "skyblue", "deepskyblue", 
    "lightblue", "dodgerblue", "lavender", "mintcream", "peachpuff", 
    "lightpink", "darkred", "darkgreen", "darkblue", "darkcyan"
};

//— DEFINES —————————–

#define DATA_PIN 5
#define LED_COUNT 300
#define MAX_ANIMATIONS 16
#define MAX_TABLEAUX 8
#define MAX_SCENES    4
#define BUFFER_SIZE 128
#define MAX_SMOKE_PARTICLES 20

//— STRUCTURES ————————-

struct SmokeParticle {
  int position;       // Position actuelle
  uint8_t brightness; // Luminosité
  bool active;        // Actif ou non
};

struct Animation {
  String id;
  String type; // "blink", "static", "rainbow"
  int start;
  int end;
  unsigned long period; // en millisecondes
  CRGB color1;
  CRGB color2;
  unsigned long lastToggleTime;
};


struct Tableau {
  String id;
  int duration; // Durée en secondes
  String animations[MAX_ANIMATIONS];
};

struct Scene {
  String id;
  String tableaux[MAX_TABLEAUX];
};


struct Snowflake {
  int position;   // Position actuelle du flocon
  bool active;    // Si le flocon est actif
};

//— VARIABLES ————————-

Animation animations[MAX_ANIMATIONS];
Tableau tableaux[MAX_TABLEAUX];
Scene scenes[MAX_SCENES];
int animationCount = 0;
int tableauCount = 0;
int sceneCount=0;
bool isAnimating = false;
unsigned long lastAnimationTime = 0;
String buffer;
Scene currentScene;
int currentTableauIndex = -1;       // Index du tableau actuellement exécuté dans la scène
unsigned long tableauStartTime = 0; // Timestamp du début du tableau actuel
Snowflake snowflakes[LED_COUNT];
uint8_t heat[LED_COUNT]; // Tableau pour stocker les "chaleurs" des LEDs
SmokeParticle smokeParticles[MAX_SMOKE_PARTICLES];
CRGB leds[LED_COUNT];

//— PROCEDURES et FONCTIONS ———-

uint32_t get_color_value(String color_name) {
    size_t color_count = sizeof(colors) / sizeof(colors[0]);

    for (size_t i = 0; i < color_count; i++) {
        if (color_name==color_names[i]) { // Comparaison insensible à la casse
            return colors[i];
        }
    }
    return 0xFFFFFFFF; 
}


void clearDefinitions() 
{
  animationCount = 0;
  tableauCount = 0;
  isAnimating = false;
  FastLED.clear();
  FastLED.show();
  //leds[10]=0xFF0000;
  //FastLED.show();
}

CRGB parseColor(String colorName) {
  return get_color_value(colorName);
  
}

String getStr(String str, int index) 
{
 int wordStart = 0;  
 int wordEnd = -1;   
 int currentWord = 0; 
 for (int i = 0; i < str.length(); i++) {
     if (str.charAt(i) == ',' || i == str.length() – 1) {
         wordEnd = (i == str.length() – 1) ? i + 1 : i;
         if (currentWord == index) {
             return str.substring(wordStart, wordEnd);
         }
         currentWord++;
         wordStart = i + 1;
     }
 }
 return "";
}

int getInt(String str,int index)
{
  return getStr(str,index).toInt();
}

bool parseAnimation(String definition) {
  // Exemple : "a1,animation,blink,0,10,500,red,blue"
  //            0  1         2     3 4  5   6   7
  Animation anim;
  anim.id = getStr(definition,0);
  anim.type = getStr(definition,2);
  anim.start = getInt(definition,3);
  anim.end = getInt(definition,4);
  anim.period = (unsigned long)getInt(definition,5);
  anim.color1 = parseColor(getStr(definition,6));
  anim.color2 = parseColor(getStr(definition,7));
  anim.lastToggleTime=0;
  animations[animationCount++] = anim;
  return true;
}

bool parseTableau(String definition) {
  // Exemple : "t1,tableau,30,a1,a2"
  //            0  1       2  3
  Tableau tab;
  tab.id = getStr(definition,0);
  tab.duration = getInt(definition,2);
  int i=3;
  int index=0;
  String anim_id=getStr(definition,i);
  while(anim_id!="")
  {
    tab.animations[index]=anim_id;
    index++;
    i++;
    anim_id=getStr(definition,i);
  }
  tableaux[tableauCount++] = tab;
  return true;
}

bool parseScene(String definition) {
  // Exemple : "s1,scene,t1,t2"
  Scene scene;
  scene.id = getStr(definition,0);
  int i=2;
  int index=0;
  String tableau_id=getStr(definition,i);
  while(tableau_id!="")
  {
    scene.tableaux[index]=tableau_id;
    index++;
    i++;
    tableau_id=getStr(definition,i);
  }
  scenes[sceneCount++] = scene;
  return true;
}

String addDefinition(String definition) 
{
  String classe=getStr(definition,1);
  if (classe=="animation") 
     {
      if (animationCount >= MAX_ANIMATIONS) return "ER Too many animations";
      if (parseAnimation(definition)) return "OK Animation added";
      return "ER Invalid animation definition";
    }
  if (classe=="tableau") 
    {
     if (tableauCount >= MAX_TABLEAUX) return "ER Too many tableaux";
     if (parseTableau(definition)) return "OK Tableau added";
     return "ER Invalid tableau definition";
    }
  if (classe=="scene") 
    {
     if (parseScene(definition)) return "OK Scene added";
     return "ER Invalid scene definition";
    }
  return "ER Invalid definition class";
}

String brightness(String cmd){
   int luminosite=getInt(cmd,0);
    FastLED.setBrightness(luminosite); 
   return "OK "+String(luminosite);
  }

String processCommand(String command) 
{
  if (command.startsWith("CLEAR")) 
     {
      clearDefinitions();
      return "OK Cleared definitions";
     }
  if (command.startsWith("ADD ")) 
     {
      String definition = command.substring(4);
      return addDefinition(definition);
     }
  if (command.startsWith("START ")) 
     {
      String sceneId = command.substring(6);
      return startScene(sceneId);
     } 
  if (command.startsWith("STATUS"))
      if(isAnimating) return "running";
      else return "idle";   
  if (command.startsWith("BRIGHTNESS ")){
     String cmd=command.substring(11);
     return brightness(cmd);
    }
     
  if (command == "STOP") return stopScene();
  return "ER Unknown command";
}

void setup() {
  Serial.begin(9600);
  while(!Serial);
  FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, LED_COUNT);
  FastLED.clear();
  FastLED.show();
  FastLED.setBrightness(255); 
  buffer="";
  // Initialisation des flocons
  for (int i = 0; i < LED_COUNT; i++) {
    snowflakes[i].active = false;
    snowflakes[i].position = 0;
  }
}

void serialComm()
{
  while (Serial.available() > 0) 
   {
    char c = (char)(Serial.read());
    if (c == '\n') 
       {
        Serial.println(processCommand(buffer));
        Serial.flush();
        buffer="";
       } 
       else 
       {
        if (buffer.length() < BUFFER_SIZE) buffer+=c;
        else
        { 
         Serial.println("ER : Tampon plein !");
         Serial.flush();
         buffer="";
        }
       }
   } 
} 

void loop() 
{
  serialComm();
 if (isAnimating) runAnimations();
}

String startScene(String sceneId) {
  if (isAnimating) {
    stopScene(); // Arrête proprement la scène en cours
  }
  // Trouver la scène avec l'ID correspondant
  for (int i = 0; i < sceneCount; i++) {
    if (scenes[i].id == sceneId) {
      // Réinitialiser les variables liées à l'animation
      currentTableauIndex = 0;
      tableauStartTime = millis();
      currentScene = scenes[i];
      isAnimating = true;
      return "OK Started scene";
    }
  }
  return "ER Scene not found";
}


String stopScene() {
  isAnimating = false;
  currentTableauIndex = 0;
  tableauStartTime = 0;
  currentScene = Scene(); // Réinitialise la structure
  FastLED.clear();
  FastLED.show();
  return "OK Stopped scene";
}


void runAnimations() {
  // Vérifier si une scène est en cours d'exécution
  if (!isAnimating || currentScene.id == "") {
    return; // Aucune scène en cours
  }

  unsigned long currentTime = millis();

  // Si aucun tableau n'est en cours, initialiser avec le premier tableau
  if (currentTableauIndex == -1) {
    currentTableauIndex = 0;
    tableauStartTime = currentTime;
  }

  // Récupérer le tableau actuel
  if (currentTableauIndex >= tableauCount || currentScene.tableaux[currentTableauIndex] == "") {
    // Tous les tableaux de la scène ont été exécutés, arrêter la scène
    stopScene();
    return;
  }

  // Durée du tableau actuel
  String tableauId = currentScene.tableaux[currentTableauIndex];
  Tableau currentTableau;
  for (int i = 0; i < tableauCount; i++) {
    if (tableaux[i].id == tableauId) {
      currentTableau = tableaux[i];
      break;
    }
  }

  // Vérifier si la durée du tableau est écoulée
  if (currentTime – tableauStartTime >= currentTableau.duration * 1000) {
    // Passer au tableau suivant
    currentTableauIndex++;
    tableauStartTime = currentTime; // Réinitialiser le temps pour le nouveau tableau
    FastLED.clear();                // Nettoyer les LEDs avant le prochain tableau
    return;
  }

  // Exécuter les animations du tableau actuel
  for (int i = 0; i < MAX_ANIMATIONS; i++) {
    String animId = currentTableau.animations[i];
    if (animId == "") continue; // Aucun ID d'animation, passer à la suivante

    // Récupérer l'animation correspondante
    for (int j = 0; j < animationCount; j++) {
      if (animations[j].id == animId) {
        Animation &anim = animations[j];
        if (anim.type == "blink") {
          runBlinkAnimation(anim);
        } else if (anim.type == "static") {
          runStaticAnimation(anim);
        } else if (anim.type == "rainbow") {
          runRainbowAnimation(anim);
        } else if (anim.type == "heartbeat") { // Nouvelle animation
          runHeartbeatAnimation(anim);
        }
        else if (anim.type == "fire") { // Ajouter ici
          runFireAnimation(anim);
        }
        else if (anim.type == "snowfall") {
          runSnowfallAnimation(anim);
        }
       else if (anim.type == "smoke") {
          runSmokeAnimation(anim, smokeParticles);
        }
        else if (anim.type == "caterpillar") {
          runCaterpillarAnimation(anim);
        }
      }
    }
  }

  // Afficher les LEDs mises à jour
  FastLED.show();
}

void runHeartbeatAnimation(Animation &anim) {
  static float intensity = 0;           // Intensité actuelle (0.0 à 1.0)
  static bool increasing = true;        // Indique si l'intensité augmente ou diminue
  unsigned long currentTime = millis(); 

  // Calculer le temps écoulé dans le cycle
  unsigned long cycleTime = anim.period / 2; // Une moitié du cycle pour augmenter, l'autre pour diminuer
  unsigned long elapsedTime = (currentTime – anim.lastToggleTime) % anim.period;

  // Ajuster l'intensité
  if (elapsedTime < cycleTime) {
    intensity = (float)elapsedTime / cycleTime; // Augmente progressivement
  } else {
    intensity = 1.0 – (float)(elapsedTime – cycleTime) / cycleTime; // Diminue progressivement
  }

  // Appliquer la couleur avec la luminosité
  for (int i = anim.start; i <= anim.end; i++) {
    leds[i] = anim.color1;
    leds[i].nscale8(intensity * 255); // Ajuster la luminosité (nscale8 va de 0 à 255)
  }

  FastLED.show();
}

void runBlinkAnimation(Animation &anim) {
 // static bool state = false;
 // static unsigned long lastToggleTime = 0;
  unsigned long currentTime = millis();

  if (currentTime – anim.lastToggleTime >= anim.period) {
    anim.lastToggleTime = currentTime;
    for (int i = anim.start; i <= anim.end; i++) {
      if(leds[i]==anim.color1) leds[i]=anim.color2;
      else leds[i]=anim.color1;
    }
  }
}

void runStaticAnimation(Animation anim) {
  for (int i = anim.start; i <= anim.end; i++) {
    leds[i] = anim.color1;
  }
}

void runRainbowAnimation(Animation anim) {
  static uint8_t hue = 0;
  hue++;
  for (int i = anim.start; i <= anim.end; i++) {
    leds[i] = CHSV(hue + (i – anim.start) * 10, 255, 255);
  }
}


void runFireAnimation(Animation &anim) {
  //static uint8_t heat[LED_COUNT]; // Tableau pour stocker les "chaleurs" des LEDs
  unsigned long currentTime = millis();

  // Mise à jour périodique
  if (currentTime – anim.lastToggleTime >= anim.period) {
    anim.lastToggleTime = currentTime;

    // Refroidissement : réduire la "chaleur" progressivement
    for (int i = anim.start; i <= anim.end; i++) {
      heat[i] = qsub8(heat[i], random8(0, 10)); // Réduction aléatoire
    }

    // Transfert de la chaleur vers le haut
    for (int i = anim.end; i > anim.start; i–) {
      heat[i] = (heat[i – 1] + heat[i – 2] + heat[i – 2]) / 3;
    }

    // Ajouter de nouvelles "étincelles" à la base
    if (random8() < 60) {
      int sparkIndex = random(anim.start, anim.start + 3);
      heat[sparkIndex] = qadd8(heat[sparkIndex], random8(160, 255));
    }

    // Convertir la "chaleur" en couleurs
    for (int i = anim.start; i <= anim.end; i++) {
      uint8_t colorIndex = scale8(heat[i], 240); // Échelle de 0 à 240
      leds[i] = ColorFromPalette(firePal, colorIndex);
    }

    FastLED.show();
  }
}

void runSnowfallAnimation(Animation &anim) {
  unsigned long currentTime = millis();

  // Mise à jour périodique
  if (currentTime – anim.lastToggleTime >= anim.period) {
    anim.lastToggleTime = currentTime;

    // Effacer les LEDs de la plage spécifiée
    for (int i = anim.start; i <= anim.end; i++) {
      leds[i] = CRGB::Black;
    }

    // Déterminer la direction à partir de color1
    bool isDown = (anim.color1 != CRGB::Black);

    // Déplacer les flocons actifs
    for (int i = 0; i < LED_COUNT; i++) {
      if (snowflakes[i].active) {
        // Déplacement selon la direction
        if (isDown) {
          snowflakes[i].position++; // Vers le bas
          if (snowflakes[i].position > anim.end) {
            snowflakes[i].active = false; // Désactiver à la fin
          } else {
            leds[snowflakes[i].position] = CRGB::White;
          }
        } else {
          snowflakes[i].position–; // Vers le haut
          if (snowflakes[i].position < anim.start) {
            snowflakes[i].active = false; // Désactiver au début
          } else {
            leds[snowflakes[i].position] = CRGB::White;
          }
        }
      }
    }

    // Ajouter de nouveaux flocons aléatoires
    if (random8() < 50) { // Probabilité d'un nouveau flocon
      for (int i = 0; i < LED_COUNT; i++) {
        if (!snowflakes[i].active) {
          // Ajouter au sommet ou à la base selon la direction
          snowflakes[i].position = isDown ? anim.start : anim.end;
          snowflakes[i].active = true;
          leds[snowflakes[i].position] = CRGB::White;
          break;
        }
      }
    }

    FastLED.show();
  }
}
void runSmokeAnimation(Animation &anim, SmokeParticle smokeParticles[]) {
  unsigned long currentTime = millis();

  // Mise à jour périodique
  if (currentTime – anim.lastToggleTime >= anim.period) {
    anim.lastToggleTime = currentTime;

    // Effacer la plage de LEDs
    for (int i = anim.start; i <= anim.end; i++) {
      leds[i] = CRGB::Black;
    }

    // Déplacer les particules actives
    for (int i = 0; i < MAX_SMOKE_PARTICLES; i++) {
      if (smokeParticles[i].active) {
        smokeParticles[i].position++;
        smokeParticles[i].brightness = max(0, smokeParticles[i].brightness – random8(5, 15));

        if (smokeParticles[i].position > anim.end || smokeParticles[i].brightness == 0) {
          smokeParticles[i].active = false;
        } else {
          leds[smokeParticles[i].position] = CRGB(smokeParticles[i].brightness, smokeParticles[i].brightness, smokeParticles[i].brightness);
        }
      }
    }

    // Ajouter une nouvelle particule aléatoire
    if (random8() < 50) { // Contrôle du taux de production de fumée
      for (int i = 0; i < MAX_SMOKE_PARTICLES; i++) {
        if (!smokeParticles[i].active) {
          smokeParticles[i].position = anim.start; // Position initiale
          smokeParticles[i].brightness = random8(128, 255); // Luminosité initiale
          smokeParticles[i].active = true;
          break;
        }
      }
    }

    FastLED.show();
  }
}
void runCaterpillarAnimation(Animation &anim) {
  static int headPosition = 0; // Position de la tête de la chenille
  unsigned long currentTime = millis();

  // Mise à jour périodique
  if (currentTime – anim.lastToggleTime >= anim.period) {
    anim.lastToggleTime = currentTime;

    // Effacer toutes les LEDs de la plage
    for (int i = anim.start; i <= anim.end; i++) {
      leds[i] = anim.color2;
    }

    // Dessiner la chenille
    int length = 5; // Longueur de la chenille (nombre de pixels allumés)
    for (int i = 0; i < length; i++) {
      int position = (headPosition – i + (anim.end – anim.start + 1)) % (anim.end – anim.start + 1) + anim.start;
      leds[position] = anim.color1; // Couleur de la chenille
    }

    // Mettre à jour la position de la tête
    headPosition = (headPosition + 1) % (anim.end – anim.start + 1);

    FastLED.show();
  }
}

Gestion d’un ruban de leds

Module Python stripleds

Introduction

Prérequis

Matériel

Logiciel

Initialisation

Création de l’Objet

Paramètres

Méthodes Disponibles

1. Effacer les Définitions : clear_definitions()

2. Ajouter une Définition : add_definition(definition)

3. Démarrer une Scène : start_scene(scene_id)

4. Arrêter les Animations : stop_scene()

5. Régler la Luminosité : set_brightness(brightness)

6. Obtenir le Statut : get_status()

7. Charger un Fichier de Définitions : load(definitions_path)

Format d’un Fichier de Définitions

Exemple de Fichier Compatible

8. Fermer la Connexion : close()

Conseils Pratiques

Manuel d’utilisation du firmware « stripleds »

Introduction

Caractéristiques principales

Installation

Matériel requis :

Connexion :

Utilisation du programme

Démarrage :

Commandes disponibles

1. Gestion des définitions

2. Gestion des scènes

3. État du programme

4. Luminosité globale

Définitions détaillées

1. Animation

2. Tableau

3. Scène

Effets supportés

Maintenance et dépannage

Source module python

Source firmware Arduino

A DECOUVRIR EGALEMENT

Redimensionnement de vidéos en Python

Raspberry PI5 Leds WS2812b

PEDI, Python Editeur

Laisser un commentaire Annuler la réponse

Module Python `stripleds`

1. Effacer les Définitions : `clear_definitions()`

2. Ajouter une Définition : `add_definition(definition)`

3. Démarrer une Scène : `start_scene(scene_id)`

4. Arrêter les Animations : `stop_scene()`

5. Régler la Luminosité : `set_brightness(brightness)`

6. Obtenir le Statut : `get_status()`

7. Charger un Fichier de Définitions : `load(definitions_path)`

8. Fermer la Connexion : `close()`