1. Présentation Générale

Ce projet permet de contrôler plusieurs rubans de LEDs WS2812 (NeoPixel) connectés à un Arduino, en leur appliquant différents effets lumineux.
Un programme Python assure la communication entre l’ordinateur (PC, MAC, Raspberry) et l’Arduino via le port série.

L’architecture repose sur un protocole texte simple utilisant des commandes séparées par des virgules.

2. Schéma du Système

Arduino UNO / MEGA (ou équivalent) connecté à deux rubans WS2812 :
- Ruban 1 : 300 LEDs, pin D2
- Ruban 2 : 144 LEDs, pin D3
PC exécutant un script Python qui envoie des commandes à l’Arduino via USB (port série).

3. Programme Arduino

3.1. Définition des Rubans

Ruban 1 : 300 LEDs sur la broche D2
Ruban 2 : 144 LEDs sur la broche D3
Les rubans sont stockés dans un tableau strips[] pour un accès générique.

3.2. Types d’Effets

Les effets disponibles sont définis dans l’énumération EffectType :

Nom	Code	Description
`STOP`	0	Arrête un effet par son ID
`FIXED`	1	Affiche une couleur fixe sur une portion de ruban
`BLINK`	2	Clignotement entre deux couleurs
`CHASE`	3	Effet chenillard (une LED active qui se déplace)
`FADE`	4	Transition progressive entre deux couleurs
`RAINBOW`	5	Cycle arc-en-ciel
`FIRE`	6	Effet feu (flickering en rouge/orange)
`SNOW`	7	Effet neige (points blancs aléatoires qui descendent)
`SMOKE`	8	Effet fumée (dégradés gris aléatoires qui s’estompent)

3.3. Gestion des Effets

Jusqu’à 50 effets simultanés (MAX_EFFECTS).
Chaque effet est identifié par un ID unique généré lors de sa création.
Les effets sont stockés dans un tableau effects[].

3.4. Protocole de Communication

Les commandes envoyées à l’Arduino suivent le format :

num,cmd,strip,param1,param2,...

num : Numéro de séquence (envoyé par le PC)
cmd : Type d’effet (voir tableau ci-dessus)
strip : Numéro du ruban (0 = ruban 1, 1 = ruban 2)
paramX : Paramètres dépendant de l’effet

Exemple de Commandes

Couleur fixe rouge sur LEDs 0 à 50 du ruban 0 : 1,1,0,0,50,255,0,0
Clignotement entre rouge et vert (LEDs 10 à 100, intervalle 500ms) : 2,2,1,10,100,255,0,0,0,255,0,500
Stopper un effet avec ID = 7 : 3,0,7

Réponses de l’Arduino

Réponse au format : num,OK/id,code
OK (1) → commande acceptée
ER (0) → erreur, avec code d’erreur :
- MSG_LENGTH_3 : commande trop courte
- STRIP_NUMBER : numéro de ruban invalide
- PARAM_COUNT : mauvais nombre de paramètres
- UNKNOWN_CMD : commande inconnue

4. Programme Python

4.1. Connexion Série

Paramètres :
- Port : "COM3" (Windows) ou "/dev/ttyUSB0" (Linux)
- Baudrate : 115200
- Timeout : 5s

4.2. Fonctions Principales

send_line(line)
Envoie une commande à l’Arduino et attend une réponse.
- Retourne un tuple (num, status, id)
- status = "1" si succès, sinon "0" ou "timeout"
stop_effect(id)
Envoie plusieurs requêtes STOP pour s’assurer qu’un effet est bien arrêté.

4.3. Exemple d’Utilisation

# Allume un effet FIXED en rouge sur ruban 0 (LEDs 50 à 100)
num_msg, bok, eff_id = send_line("1,1,0,50,100,255,0,0")
print("R <-", num_msg, bok, eff_id)

# Attendre 10 secondes
time.sleep(10)

# Stopper l’effet
stop_effect(eff_id)

4.4. Communication Exemple

S -> 1,1,0,50,100,255,0,0
R <- 1,1,5   # effet créé avec ID=5
...
S -> 2,0,5
R <- 2,1,0   # effet 5 stoppé

5. Sécurité & Limitations

Alimentation adaptée :
- 300 LEDs WS2812 → jusqu’à 18 A (à pleine luminosité blanche).
- Prévoir une alimentation externe 5V avec puissance suffisante.
Bien relier les masses (GND) entre l’Arduino et l’alimentation du ruban.
Le protocole ne gère pas encore les priorités d’effets ni la sauvegarde en EEPROM.

6. Améliorations Possibles

Ajout d’un protocole JSON au lieu de CSV pour plus de clarté.
Ajout de commandes pour régler la luminosité globale.
Gestion de plusieurs effets sur un même segment de ruban.
Interface graphique (GUI Python, Qt ou Tkinter).

7. Résumé

Arduino → gère les rubans, applique les effets.
Python → envoie des commandes série, gère la logique utilisateur.
Protocole simple CSV → extensible, robuste.

Ce système permet un contrôle temps réel de rubans WS2812 avec une grande flexibilité.

Référence API des Effets LED (Arduino + Python)

Format Général des Commandes

num,cmd,strip,param1,param2,...

num : Numéro de message (incrémenté par le script Python)
cmd : Code de l’effet (voir tableau ci-dessous)
strip : Numéro du ruban (0 = ruban 1, 1 = ruban 2, etc.)
paramX : Paramètres spécifiques à l’effet

1. Commandes Disponibles

Commande	Code	Description
STOP	0	Arrête un effet à partir de son ID
FIXED	1	Affiche une couleur fixe sur un segment
BLINK	2	Fait clignoter un segment entre deux couleurs
CHASE	3	Chenillard (LED active qui se déplace)
FADE	4	Transition progressive entre deux couleurs
RAINBOW	5	Effet arc-en-ciel
FIRE	6	Effet feu (flickering rouge/orange)
SNOW	7	Effet neige (points blancs descendant)
SMOKE	8	Effet fumée (points gris estompés)

2. Paramètres par Effet

STOP (0)

Arrête un effet en cours à partir de son ID.

num,0,id

id : identifiant de l’effet à stopper (reçu lors de sa création).

Exemple :

5,0,12

➡️ Stoppe l’effet ayant ID = 12.

FIXED (1)

Affiche une couleur fixe sur une plage de LEDs.

num,1,strip,start,end,R,G,B

start : première LED (index)
end : dernière LED
R,G,B : couleur (0–255)

Exemple :

6,1,0,0,50,255,0,0

➡️ LEDs 0 à 50 du ruban 0 en rouge.

BLINK (2)

Clignotement entre deux couleurs.

num,2,strip,start,end,R1,G1,B1,R2,G2,B2,interval

R1,G1,B1 : couleur 1
R2,G2,B2 : couleur 2
interval : durée d’un état en ms

Exemple :

7,2,1,10,30,255,0,0,0,255,0,500

➡️ LEDs 10–30 du ruban 1 clignotent rouge/vert toutes les 500 ms.

CHASE (3)

Effet chenillard.

num,3,strip,start,end,R,G,B,interval

R,G,B : couleur de la LED active
interval : temps entre déplacements (ms)

Exemple :

8,3,0,0,20,0,0,255,100

➡️ Chenillard bleu sur LEDs 0–20 du ruban 0.

FADE (4)

Transition progressive entre deux couleurs.

num,4,strip,start,end,R1,G1,B1,R2,G2,B2,interval

R1,G1,B1 : couleur de départ
R2,G2,B2 : couleur de fin
interval : durée d’un cycle de fade (ms)

Exemple :

9,4,1,0,50,255,0,0,0,0,255,200

➡️ LEDs 0–50 du ruban 1 passent progressivement du rouge au bleu toutes les 200 ms.

RAINBOW (5)

Cycle arc-en-ciel.

num,5,strip,start,end,interval

interval : vitesse du défilement (ms)

Exemple :

10,5,0,0,100,50

➡️ LEDs 0–100 du ruban 0 affichent un arc-en-ciel animé.

FIRE (6)

Effet feu réaliste (rouge/orange clignotant).

num,6,strip,start,end,interval

interval : vitesse de mise à jour (ms)

Exemple :

11,6,1,0,50,80

➡️ LEDs 0–50 du ruban 1 avec un effet feu.

SNOW (7)

Effet neige (points blancs descendant le long du ruban).

num,7,strip,start,end,interval,density

interval : vitesse de chute (ms)
density : densité (0–100 %)

Exemple :

12,7,0,0,144,150,10

➡️ LEDs 0–144 du ruban 0 → neige clairsemée (10%).

SMOKE (8)

Effet fumée (points gris estompés).

num,8,strip,start,end,interval,density

interval : vitesse de génération (ms)
density : densité (0–100 %)

Exemple :

13,8,1,0,50,200,30

➡️ LEDs 0–50 du ruban 1 → fumée dense (30%).

3. Codes de Retour de l’Arduino

Réponse standard : num,OK,id ou num,ER,code

Signification

OK (1) → succès
ER (0) → erreur

Code d’erreur	Valeur	Signification
`MSG_LENGTH_3`	0	Message trop court (< 3 champs)
`STRIP_NUMBER`	1	Numéro de ruban invalide
`PARAM_COUNT`	2	Nombre de paramètres incorrect
`UNKNOWN_CMD`	3	Commande non reconnue

4. Exemple Session Complète

S -> 1,1,0,0,20,255,0,0
R <- 1,1,4        # effet FIXED créé avec ID=4

S -> 2,2,0,0,20,255,0,0,0,255,0,500
R <- 2,1,5        # effet BLINK créé avec ID=5

S -> 3,0,5
R <- 3,1,0        # effet ID=5 stoppé

Dépendances

1. Arduino (programme embarqué)

Bibliothèques Arduino

Arduino.h (fournie par défaut)
Adafruit_NeoPixel
- Installation via Arduino Library Manager
- Permet de piloter les rubans LED WS2812/WS2812B

Outils

Arduino IDE
Port série USB actif (115200 bauds)

2. Python (passerelle série côté PC)

Version minimale

Python 3.8+

Modules nécessaires

pyserial
- pip install pyserial

Source Python

Python

import serial
import time

PORT = "COM3"   # à adapter selon ton système (/dev/ttyUSB0 sous Linux)
BAUD = 115200
TIMEOUT = 5

arduino = serial.Serial(PORT, BAUD, timeout=1)
time.sleep(2)  

msg_id = 0

def cvt(texte):
    parties = texte.split(",")
    return tuple(p.strip() for p in parties)

def send_line(line):
    global msg_id
    msg_id += 1
    message = f"{msg_id},{line}\n"
    print(f"S -> {message}",end='')
    arduino.reset_input_buffer()
    arduino.write(message.encode("utf-8"))
    start = time.time()
    while time.time() – start < TIMEOUT:
        response = arduino.readline().decode("utf-8").strip()
        if response:
            return cvt(response)
    return msg_id,"timeout",0


def stop_effect(id):
    pause=0.2
    maxtry=20
    i=0
    while i<maxtry:
        i+=1
        num,bok,rid=send_line(f"0,{id}")
        print(i,num,bok,rid)
        if bok=="1":
            print("STOP OK")
            break
    time.sleep(pause)

num_msg,bok,id=send_line("8,0,0,50,100,10")
print("R <-",num_msg,bok,id)
time.sleep(10)
stop_effect(id)

Source Arduino

#include <Arduino.h>
#include <Adafruit_NeoPixel.h>

#define ER 0
#define OK 1
// codes d'erreurs
#define MSG_LENGTH_3 0
#define STRIP_NUMBER 1
#define PARAM_COUNT 2
#define UNKNOWN_CMD 3

// ——————– Définition des rubans ——————–

#define PIN1 2
#define NUMPIXELS1 300
Adafruit_NeoPixel strip1(NUMPIXELS1, PIN1, NEO_GRB + NEO_KHZ800);

#define PIN2 3
#define NUMPIXELS2 144
Adafruit_NeoPixel strip2(NUMPIXELS2, PIN2, NEO_GRB + NEO_KHZ800);

#define STRIPCOUNT 2
Adafruit_NeoPixel *strips[STRIPCOUNT] = { &strip1, &strip2 };

// ——————– Paramètres ——————–

#define MAX_EFFECTS 50

enum EffectType { STOP,
                  FIXED,
                  BLINK,
                  CHASE,
                  FADE,
                  RAINBOW,
                  FIRE,
                  SNOW,
                  SMOKE };


int nbParam[] = { 3, 8, 12, 9, 12, 6, 6, 7, 7 };
boolean bex = false;

struct Effect {
  int id;
  Adafruit_NeoPixel *strip;
  int startIndex;
  int endIndex;
  EffectType type;
  uint32_t color1;
  uint32_t color2;
  int interval;
  unsigned long lastUpdate;
  bool toggle;
  int step;
  bool active;
  uint8_t brightnessStep;  // pour FADE / densité
};

Effect effects[MAX_EFFECTS];
int effectCount = 0;
int nextEffectId = 1;

#define BUFFER_SIZE 64  // taille max d'une ligne
#define MAX_VALUES 16
char inputBuffer[BUFFER_SIZE];
uint8_t bufIndex = 0;
bool lineReady = false;

// ——————– Fonctions de base ——————–

void updateStrip(Adafruit_NeoPixel &s) {
  while (!s.canShow())
    ;
  s.show();
}

void initStrip(Adafruit_NeoPixel &s, uint32_t color = 0) {
  s.begin();
  s.fill(color);
  updateStrip(s);
}

void setBrightness(Adafruit_NeoPixel &s, uint8_t b) {
  s.setBrightness(b);
  updateStrip(s);
}

// ——————– Gestion des effets ——————–

int addEffect(Adafruit_NeoPixel &s, int startIndex, int endIndex, EffectType type,
              uint32_t color1 = 0, uint32_t color2 = 0, int interval = 0, uint8_t density = 0) {
  if (effectCount >= MAX_EFFECTS) return -1;
  bex = true;
  effects[effectCount] = { nextEffectId, &s, startIndex, endIndex, type, color1, color2, interval,
                           millis(), false, 0, true, density };
  int id = nextEffectId++;
  effectCount++;
  bex = false;
  return id;
}

void removeEffectById(int id) {
  bex = true;
  for (int i = 0; i < effectCount; i++) {
    if (effects[i].id == id) {
      // Éteindre les LEDs de l'effet
      effects[i].active = false;
      for (int j = effects[i].startIndex; j <= effects[i].endIndex; j++)
        effects[i].strip->setPixelColor(j, 0);
      updateStrip(*effects[i].strip);

      // Décaler les effets restants
      for (int j = i; j < effectCount – 1; j++)
        effects[j] = effects[j + 1];
      effectCount–;
      break;
    }
  }
  bex = false;
}

// ——————– Fonctions simplifiées pour chaque effet ——————–

int startFixed(Adafruit_NeoPixel &s, int start, int end, int r, int g, int b) {
  uint32_t color = s.Color(r, g, b);
  for (int i = start; i <= end; i++) s.setPixelColor(i, color);
  updateStrip(s);
  return addEffect(s, start, end, FIXED, color);
}

int startBlink(Adafruit_NeoPixel &s, int start, int end, int r1, int g1, int b1, int r2, int g2, int b2, int interval) {
  uint32_t c1 = s.Color(r1, g1, b1);
  uint32_t c2 = s.Color(r2, g2, b2);
  return addEffect(s, start, end, BLINK, c1, c2, interval);
}

int startChase(Adafruit_NeoPixel &s, int start, int end, int r, int g, int b, int interval) {
  uint32_t color = s.Color(r, g, b);
  return addEffect(s, start, end, CHASE, color, 0, interval);
}

int startFade(Adafruit_NeoPixel &s, int start, int end, int r1, int g1, int b1, int r2, int g2, int b2, int interval) {
  uint32_t c1 = s.Color(r1, g1, b1);
  uint32_t c2 = s.Color(r2, g2, b2);
  return addEffect(s, start, end, FADE, c1, c2, interval, 5);
}

int startRainbow(Adafruit_NeoPixel &s, int start, int end, int interval) {
  return addEffect(s, start, end, RAINBOW, 0, 0, interval);
}

int startFire(Adafruit_NeoPixel &s, int start, int end, int interval) {
  return addEffect(s, start, end, FIRE, 0, 0, interval);
}

int startSnow(Adafruit_NeoPixel &s, int start, int end, int interval, int density = 5) {
  return addEffect(s, start, end, SNOW, 0, 0, interval, (uint8_t)(density * 255 / 100));
}

int startSmoke(Adafruit_NeoPixel &s, int start, int end, int interval, int density = 1) {
  return addEffect(s, start, end, SMOKE, 0, 0, interval, (uint8_t)(density * 255 / 100));
}

// ——————– Utilitaires ——————–

uint32_t Wheel(byte WheelPos, Adafruit_NeoPixel &strip) {
  WheelPos = 255 – WheelPos;
  if (WheelPos < 85) return strip.Color(255 – WheelPos * 3, 0, WheelPos * 3);
  if (WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 – WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 – WheelPos * 3, 0);
}

// ——————– Update général ——————–
void update() {
  if (bex) return;
  unsigned long now = millis();

  for (int i = 0; i < effectCount; i++) {
    if (!effects[i].active) continue;
    switch (effects[i].type) {
      case FIXED:
        break;

      case BLINK:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          effects[i].toggle = !effects[i].toggle;
          uint32_t color = effects[i].toggle ? effects[i].color1 : effects[i].color2;
          for (int j = effects[i].startIndex; j <= effects[i].endIndex; j++)
            effects[i].strip->setPixelColor(j, color);
          updateStrip(*effects[i].strip);
        }
        break;

      case CHASE:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          int len = effects[i].endIndex – effects[i].startIndex + 1;
          for (int j = 0; j < len; j++) {
            int idx = effects[i].startIndex + j;
            effects[i].strip->setPixelColor(idx, (j == effects[i].step) ? effects[i].color1 : 0);
          }
          updateStrip(*effects[i].strip);
          effects[i].step = (effects[i].step + 1) % len;
        }
        break;

      case FADE:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          uint8_t r1 = (effects[i].color1 >> 16) & 0xFF;
          uint8_t g1 = (effects[i].color1 >> 8) & 0xFF;
          uint8_t b1 = effects[i].color1 & 0xFF;
          int step = effects[i].toggle ? effects[i].brightnessStep : -effects[i].brightnessStep;
          effects[i].toggle = !effects[i].toggle;
          for (int j = effects[i].startIndex; j <= effects[i].endIndex; j++) {
            uint8_t r = constrain(r1 + step, 0, 255);
            uint8_t g = constrain(g1 + step, 0, 255);
            uint8_t b = constrain(b1 + step, 0, 255);
            effects[i].strip->setPixelColor(j, effects[i].strip->Color(r, g, b));
          }
          updateStrip(*effects[i].strip);
        }
        break;

      case RAINBOW:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          int len = effects[i].endIndex – effects[i].startIndex + 1;
          for (int j = 0; j < len; j++) {
            int idx = effects[i].startIndex + j;
            effects[i].strip->setPixelColor(idx, Wheel((j + effects[i].step) & 255, *effects[i].strip));
          }
          updateStrip(*effects[i].strip);
          effects[i].step = (effects[i].step + 1) % 256;
        }
        break;

      case FIRE:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          int len = effects[i].endIndex – effects[i].startIndex + 1;
          for (int j = 0; j < len; j++) {
            int flicker = random(160, 255);
            uint8_t r = flicker;
            uint8_t g = flicker / 2;
            uint8_t b = 0;
            effects[i].strip->setPixelColor(effects[i].startIndex + j, effects[i].strip->Color(r, g, b));
          }
          updateStrip(*effects[i].strip);
        }
        break;

      case SNOW:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          int len = effects[i].endIndex – effects[i].startIndex + 1;
          for (int j = len – 1; j > 0; j–) {
            uint32_t c = effects[i].strip->getPixelColor(effects[i].startIndex + j – 1);
            effects[i].strip->setPixelColor(effects[i].startIndex + j, c);
          }
          if (random(0, 255) < effects[i].brightnessStep)
            effects[i].strip->setPixelColor(effects[i].startIndex, effects[i].strip->Color(255, 255, 255));
          else
            effects[i].strip->setPixelColor(effects[i].startIndex, 0);
          updateStrip(*effects[i].strip);
        }
        break;

      case SMOKE:
        if (now – effects[i].lastUpdate >= effects[i].interval) {
          effects[i].lastUpdate = now;
          int len = effects[i].endIndex – effects[i].startIndex + 1;
          for (int j = len – 1; j > 0; j–) {
            uint32_t c = effects[i].strip->getPixelColor(effects[i].startIndex + j – 1);
            uint8_t r = ((c >> 16) & 0xFF) * 0.8;
            uint8_t g = ((c >> 8) & 0xFF) * 0.8;
            uint8_t b = (c & 0xFF) * 0.8;
            effects[i].strip->setPixelColor(effects[i].startIndex + j, effects[i].strip->Color(r, g, b));
          }
          if (random(0, 255) < effects[i].brightnessStep) {
            uint8_t gray = random(100, 200);
            effects[i].strip->setPixelColor(effects[i].startIndex, effects[i].strip->Color(gray, gray, gray));
          } else
            effects[i].strip->setPixelColor(effects[i].startIndex, 0);
          updateStrip(*effects[i].strip);
        }
        break;
    }
  }
}

// ——————– Déclaration globale pour stocker les IDs ——————–

int fireId, smokeId, rainbowId, blinkId;
int fixedId, chaseId, snowId;

// ——————– Setup ——————–

void setup() {
  int i;
  Serial.begin(115200);
  for (i = 0; i < STRIPCOUNT; i++) {
    initStrip(*strips[i]);
    setBrightness(*strips[i], 32);
  }
}

void sendMsg(int a, int b, int c) {
  Serial.print(a);
  Serial.print(',');
  Serial.print(b);
  Serial.print(',');
  Serial.println(c);
}

void processLine(char *line) {
  int t[MAX_VALUES];
  uint8_t count = 0;
  char *token = strtok(line, ",");  // Découpe par virgule
  while (token != NULL && count < MAX_VALUES) {
    t[count] = atoi(token);  // Convertit le mot en entier
    count++;
    token = strtok(NULL, ",");
  }
  if (count < 3) {
    sendMsg(0, ER, MSG_LENGTH_3);
    return;
  }
  int num = t[0];
  int cmd = t[1];
  int ruban = t[2];
  int id;
  if (cmd != STOP)
    if (ruban < 0 || ruban > STRIPCOUNT) {
      sendMsg(num, ER, STRIP_NUMBER);
      return;
    }
  if (count != nbParam[cmd]) {
    sendMsg(num, ER, PARAM_COUNT);
    return;
  }
  switch (cmd) {
    case STOP:
      removeEffectById(t[2]);
      sendMsg(num, OK, 0);
      return;
    case FIXED:
      id = startFixed(*strips[ruban], t[3], t[4], t[5], t[6], t[7]);
      break;
    case BLINK:
      id = startBlink(*strips[ruban], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11]);
      break;
    case CHASE:
      id = startChase(*strips[ruban], t[3], t[4], t[5], t[6], t[7], t[8]);
      break;
    case FADE:
      id = startFade(*strips[ruban], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11]);
      break;
    case RAINBOW:
      id = startRainbow(*strips[ruban], t[3], t[4], t[5]);
      break;
    case FIRE:
      id = startFire(*strips[ruban], t[3], t[4], t[5]);
      break;
    case SNOW:
      id = startSnow(*strips[ruban], t[3], t[4], t[5], t[6]);
      break;
    case SMOKE:
      id = startSmoke(*strips[ruban], t[3], t[4], t[5], t[6]);
      break;
    default:
      sendMsg(num, ER, UNKNOWN_CMD);
      return;
  }
  sendMsg(num, OK, id);
}

// ——————– Loop ——————–

void loop() {
  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c == '\n') {
      inputBuffer[bufIndex] = '\0';
      lineReady = true;
      bufIndex = 0;
    } else if (c != '\r') {
      if (bufIndex < BUFFER_SIZE – 1) {
        inputBuffer[bufIndex++] = c;
      } else {
        bufIndex = 0;
      }
    }
  }
  if (lineReady) {
    processLine(inputBuffer);
    lineReady = false;
  }
  update();
}

Programmes Arduino et Python pour le Contrôle de Rubans LED WS2812

Published by geo on 30 septembre 202530 septembre 2025

1. Présentation Générale

2. Schéma du Système

3. Programme Arduino

3.1. Définition des Rubans

3.2. Types d’Effets

3.3. Gestion des Effets

3.4. Protocole de Communication

Exemple de Commandes

Réponses de l’Arduino

4. Programme Python

4.1. Connexion Série

4.2. Fonctions Principales

4.3. Exemple d’Utilisation

4.4. Communication Exemple

5. Sécurité & Limitations

6. Améliorations Possibles

7. Résumé

Référence API des Effets LED (Arduino + Python)

Format Général des Commandes

1. Commandes Disponibles

2. Paramètres par Effet

STOP (0)

FIXED (1)

BLINK (2)

CHASE (3)

FADE (4)

RAINBOW (5)

FIRE (6)

SNOW (7)

SMOKE (8)

3. Codes de Retour de l’Arduino

Signification

4. Exemple Session Complète

Dépendances

1. Arduino (programme embarqué)

Bibliothèques Arduino

Outils

2. Python (passerelle série côté PC)

Version minimale

Modules nécessaires

Source Python

Source Arduino

0 commentaire

Laisser un commentaire Annuler la réponse

Articles similaires

Documentation – Éditeur d’Effets Vidéo Simplifié

Contrôler une lampe ou led par PWM avec Arduino

Contrôler un moteur pas à pas 28BYJ-48 avec Arduino en C++