CAISSE A SAVON

Samedi 9 juin 2018, la Vilaine Bidouille met de côté les outils numériques pour fabriquer une caisse à savon avec des restes d’ateliers.

atelier extérieur
Atelier extérieur
Prémontage
Prémontage

Securisation du périmètre
Securisation du périmètre
Premiers essais
Premiers essais

Retour sur le bizarbre

Bizarbre

arbreNous avions présenté rapidement notre Bizarbre dans un précédent article. 

Etant données les questions techniques qui nous ont été posées, voici le détail complet du tuto.

Matériel :

      un PC équipé de :

o    Processing

o    Arduino

      Une carte Arduino

      Une carte MPR121 de chez Adafruit

      Fils de cuivre rigides

      Des pommes

      Un câble USB

      De la connectique entre Arduino et MPR121

Logiciels et bibliothèques :

      Processing

      Arduino

Fichiers :

      Fichiers MP3 avec les histoires enregistrées

 

Etape 1 : Construire un arbre

Equipez vous d’une bibliothécaire munie d’une scie, de pots de peinture et de contre-plaqué épais. Laissez faire le temps. Et vous obtenez un belle arbre en bois.

Etape 2 : Suspendre les pommes

Il faudra une pomme par histoire et une supplémentaire pour faire la touche “stop”. Nous avons utilisé du petit fil de cuivre. La partie dénudée traverse la pomme pour assurer un bon contact avec le fruit. Nous avons utilisé des aiguilles à poisson pour percer les pommes.

Etape 3 : Préparer de la carte Arduino

La carte utilisée est une Duemillanove.

Au lancement de l’interface de programmation Arduino, il faut ajouter les bibliothèques suivante pour pouvoir communiquer avec les capteurs capacitifs MPR121

Etape 4 : Connecter l’Arduino à la MPR121

Câblage assez simple.

Connecter Vin à l’alimentation. Sur un Arduino, ça revient à alimenter en 5V.
Connecter GND à la masse commune à la puissance et aux données.

Connecter SCL à la fiche I2C clock SCL sur l’Arduino. Sur une UNO, c’est A5 ; sur une Mega, digital 21 ; sur Leonardo/Micro, digital 3.

Connecter SDA sur la fiche I2C data SDA sur l’Arduino. Sur une UNO, c’est A4 ; sur une Mega, digital 20 ; sur Leonardo/Micro, digital 2.

Etape 5 : Programmer la carte Arduino

Ouvrir l’interface Arduino (IDE) sur le PC et brancher la carte Arduino avec le câble USB.

Bien repérer le numéro de port de la carte. Pour ça, il y pleins de tutos sur internet. Inutile de surcharger celui-ci.

Télécharger la librairie master.zip pour que la carte Arduino puisse communiquer avec le capteur MPR121. Renommer le dossier décompressé en Adafruit_MPR121 et vérifier qu’il contient bien le fichier Adafruit_MPR121.cpp et Adafruit_MPR121.h.

Placer ce dossier Adafruit_MPR121 dans le dossier des librairies du logiciel Arduino arduinosketchfolder/libraries/. Si c’est votre première librairie, il faudra sans doute créer ce dossier. Arrêter et redémarrer l’IDE Arduino.

Si jamais vous avez un doute allez chercher l’info à la source chez Adafruit.

Tapez le programme suivant :

 

/*********************************************************
Arbre  histoire pour la mediathque d’Allaire (cote arduino)
Auteur : Cyrille Laulier
        www.lebiosphere.net
Date   : le 26/02/2016

Ce programme Arduino va de paire avec le programme Processing
arbreAHistoires
Grace  une carte MPR121 de chez Adafruit, la carte Arduino
detecte le contact de la main d’un enfant sur un fruit.
Elle envoie ensuite le numero du fruit au PC via le port serie
Sur le PC, Processing regarde le numero et lance la lecture
de l’histoire correspondante
**********************************************************/
#include <Wire.h>
#include « Adafruit_MPR121.h »
// declaration de l’objet « cap » qui est le capteur MPR121
Adafruit_MPR121 cap = Adafruit_MPR121();

// Garder la trace du dernier contact touche
// pour savoir quand un bouton est « relache »
uint16_t lasttouched = 0;
uint16_t currtouched = 0;

void setup() {
 Serial.begin(9600);
 // adresse par defaut 0x5A, si alimentation 3.3V alors 0x5B
 // si cablage SDA alors 0x5C et si SCL alors 0x5D
 if (!cap.begin(0x5A)) {
   Serial.println(« MPR121 introuvable, verifier le cablage »);
   while (1);
 }
 Serial.write(0);
}

void loop() {
 // recuperation des touches appuyees
 currtouched = cap.touched();
 // controle de tous les contacts et envoi sur port serie
 for (uint8_t i=0; i<12; i++) {
   // it if *is* touched and *wasnt* touched before, alert!
   if ((currtouched & _BV(i)) && !(lasttouched & _BV(i)) ) {
     Serial.write(i);
   }
 }
 // pour tour suivant
 lasttouched = currtouched;
 delay(100);
}

 

 

Envoyez ce programme dans la carte Arduino.

Etape 6 : Connecter la MPR121 aux pommes

Câblage encore plus simple. On a dix pommes pour les histoires et une pomme “stop” qui interrompt toutes les lectures.

Pour la pomme “stop”, on plante un fil électrique rigide dans la pomme qu’on connecte à l’entrée 0 de la MPR121.

Pour les autres pommes, on fait pareil sur les entrée de 1 à 10. Dans notre cas, nous n’avions enregistré que 8 histoires. Alors nous n’avons câblé que 8 pommes en plus du “stop”.

Etape 7 : Préparer Processing

On oublie un peu l’électronique pour revenir sur le PC.

Installer et lancer Processing.

On importe la bibliothèque Minim pour pouvoir manipuler du son. Pour cela, dans l’interface Processing, il suffit d’aller dans le menu Sketch > Import Library… > Minim audio. C’est fait.

Etape 8 : Programmer Processing

Dans la fenêtre Processing, on va taper le programme. Le programme est le suivant :

import processing.serial.*;
import ddf.minim.*;

Minim minim;
AudioPlayer hist01,hist02,hist03,hist04,hist05,hist06,hist07,hist08,hist09,hist10;
Serial port;
int val;

void setup() {
 fullScreen();
 String arduinoPort= »COM3″;
 port=new Serial(this, arduinoPort, 9600);
 
 minim = new Minim(this);
 hist01 = minim.loadFile(« chewinggum.mp3 »);
 hist02 = minim.loadFile(« bouteille.mp3 »);
 hist03 = minim.loadFile(« chocolat.mp3 »);
 hist04 = minim.loadFile(« Saucisse.mp3 »);
 hist05 = minim.loadFile(« Minuscule.mp3 »);
 hist06 = minim.loadFile(« envers.mp3 »);
 hist07 = minim.loadFile(« envers.mp3 »);
 hist08 = minim.loadFile(« envers.mp3 »);
 hist09 = minim.loadFile(« histoire09.mp3 »);
 hist10 = minim.loadFile(« histoire10.mp3 »);
 //song.play();
}

void draw() {
 if (port.available() > 0) {
   val=port.read();
 }
 background(map(val,0,10,0,255));
 rect(40,(val+1)*50-10,360,20);
 if (val==1) {
   hist01.rewind();
   hist01.play();
 }
 if (val==2) {
   hist02.rewind();
   hist02.play();
 }
 if (val==3) {
   hist03.rewind();
   hist03.play();
 }
 if (val==4) {
   hist04.rewind();
   hist04.play();
 }
 if (val==5) {
   hist05.rewind();
   hist05.play();
 }
 if (val==6) {
   hist06.rewind();
   hist06.play();
 }
 if (val==7) {
   hist07.rewind();
   hist07.play();
 }
 if (val==8) {
   hist08.rewind();
   hist08.play();
 }
 if (val==9) {
   hist09.rewind();
   hist09.play();
 }
 if (val==10) {
   hist10.rewind();
   hist10.play();
 }
 if (val==0) {
   hist01.pause();
   hist02.pause();
   hist03.pause();
   hist04.pause();
   hist05.pause();
   hist06.pause();
   hist07.pause();
   hist08.pause();
   hist09.pause();
   hist10.pause();
 }
 val=99;
}

 

Enregistrer ce programme sous le nom de arbreHistoires_processing.pde.

On peut l’optimiser. Si j’avais eu 200 histoires avec 201 pommes, j’aurais utilisé la programmation orientée objet.

On voit que le programme appelle des fichiers joints. Vous pouvez enregistrer vos propres histoires ou les récupérer sur mon site Google. Il faut les coller dans le même dossier que le fichier du programme arbreHistoires_processing.pde.

Etape 9 : Connecter le PC

Le plus facile de tous les câblages. Il faut s’assurer que l’IDE d’Arduino ne tourne pas sur le PC. Il faut brancher la carte Arduino au PC via le câble USB. Et lancer le programme arbreHistoires_processing.pde en appuyant sur la flèche “Play” de Processing. Pensez à monter le son.

Etape 10 : Faire un lâcher d’enfants

Tout est dans le titre. Les enfants vont toucher une pomme. Au simple contact, le PC va commencer la lecture de l’histoire associée. Il suffit d’appuyer sur la pomme “STOP” pour faire silence.

Etape 11 : Penser à la suite

Comme chaque bidouille, elle laisse un sentiment d’imperfection une fois réalisée. Une frustration. En fait, c’est nul. Ce n’est pas comme ça qu’on aurait dû avoir une approche complètement différente. On voit les fils qui dépassent de partout, les enfants mangent les pommes, ça monopolise un PC et des enceintes, l’erreur de câblage est facile à faire, il n’y a pas d’image…

Aussi, je fais un appel à contribution. Qui est motivé pour :

      Trouver le moyen de connecter un haut-parleur directement à l’Arduino ?

      Forger des pommes en or (ou accessoirement en bronze) ?

      Trouver un moyen de cacher les câbles, voire les cartes électroniques, dans l’épaisseur du bois de l’arbre ?

      Rendre la carte Arduino capable de gérer les sons et les images sans PC ?

      Connecter l’Arduino à un vidéo projecteur ?

      Concevoir un shield pour brancher toutes les petites cartes électroniques à l’Arduino sans fils ?

      Raconter de nouvelles histoires d’arbres ?

Pour toute question, truc qui ne marche pas, bug, difficultés et autre, n’hésitez pas à vous retrousser les manches et à suer sang et eau pour obtenir un résultat satisfaisant. Ou bien passez nous voir à la Vilaine Bidouille.

Cyrille Laulier, www.lebiosphere.net

 

Ma douche sauvée par la Bidouille d’Allaire

J’ai acheté une paroi de douche et une porte coulissante en verre sur le bon coin.
Je pensais avoir fait une bonne affaire, mais pas tant que ça :
ayant posé le placo, fait la plomberie, monté la paroi de douche, posé le carrelage ; je pensais pouvoir bientôt terminer la douche !!!

Mais voilà, au moment du montage de la porte, nous réalisons qu’il manque deux supports en plastique qui tiennent et guident une roulette dans une gorge…..

Je me précipite alors sur internet pour retrouver cette pièce manquante, impossible à trouver !

J’avais cependant trouver les roulettes sur un site ukrainien mais il me manquait les deux supports !

L’histoire se termine bien grâce à l’atelier Bioduille d’Allaire du Vendredi soir à la Médiathèque qui parvient à modéliser et imprimer ces deux pièces maîtresses, une gauche et une droite, symétriques !
Comme quoi, c’est bien utile ces petites bidouilles !

 

Sandrine

Course d’escargots du 10 mars

Course

Ca avance doucement.

Course
presque prêts pour le départ

En attendant le départ les programmes qui vont enregistrer les images et les passer en boucle sont prêts.

import picamera
import time

with picamera.PiCamera() as camera :
    camera.start_preview()
    frame= 1
    while (frame<100):
        camera.capture('/home/pi/animation/frame%d.jpg' %frame)
        frame += 1
        camera.stop_preview()
        time.sleep(4.0)
escarMotion.py
import pygame
from pygame.locals import *
import time

pygame.init()

fenetre = pygame.display.set_mode((1440,900),RESIZABLE)

continuer = 1
nb = 1

while continuer:
    try:
        fond=pygame.image.load("/home/pi/animation/frame{}.jpg".format(nb)).convert()
    except:
        nb=1
        fond=pygame.image.load("/home/pi/animation/frame{}.jpg".format(nb)).convert()
    finally:
        fenetre.blit(fond,(0,0))
        pygame.display.flip()
        time.sleep(0.1)
        nb=nb+1
affichage

Prenez une Raspberry Pi 3 avec une caméra. Lancez le premier script puis le second pendant que le premier tourne encore.

Il ne manque que des volontaires pour faire le parcours.

Retour sur le Yéti

yeti
yeti
yeti ouest france

Voici avec un peu de retard le support pdf de l’animation à la médiathèque de Redon sur la carte Raspberry Pi embarquée dans le yéti de la station des 5000 de Redon

171125_Yeti

Vous y trouverez l’essentiel pour utiliser les entrées/sorties, un peu de Python et quelques astuces pour démarrer automatiquement des scripts au boot de la carte.

Si quelqu’un peut expliquer simplement comment ajouter un Watchdog au yéti, je suis preneur.

Passez de bonnes vacances.

Lumière sur l’Arduino avec de la couleur et des LED !

Aujourd’hui je vais vous parler d’un de mes projets  ayant pour objectif de créer un ruban de LED  créant une ambiance lumineuse colorée dans une pièce.

Pour ce projet j’ai choisi d’utiliser la carte Arduino. La carte Arduino se programme facilement et donc on peut faire un peu tout ce qu’on veut avec.

 

Pour l’éclairage de la pièce, mon choix s’arrêta rapidement sur la technologie LED du fait de sa faible consommation électrique, de sa faible chauffe et de sa bonne durée de vie.

Maintenant, choisissons la couleur de la LED !

Rouge, vert ou bleu ?

Eh, attendez ! Moi je veux toutes les couleurs !

J’ai donc choisi les diodes électroluminescente de type RGB.  Car elles permettent d’avoir accès à différentes combinaisons de couleurs pour l’éclairage.

Je me suis posé la question si il fallait les piloter individuellement ou en même temps.

J’ai longuement hésité pour enfin partir sur la solution des LED pilotées individuellement.

Mais ça nécessite beaucoup de fils me direz vous !

Si pour l’analogique c’est effectivement le cas, ça ne l’est pas avec un bus numérique qui ne nécessite qu’un seul fil !

Je me suis arrêté sur le  ruban de LED RGB WS2812 de 5 mètres.

Il est utilisable uniquement en intérieur même si la solution utilisable en extérieur existait.

C’est un ruban ou chaque LED (environs 150) utilise des fils d’alimentation (+ et -), et un seul fil pour les piloter et c’est là tout l’intérêt d’un bus de données.

Les LED WS2812 peuvent afficher 16 777 216 couleurs différentes et 256 niveaux de luminosité différentes avec une fréquence de rafraîchissement de 400 Hz ( 400 fois par seconde).

Pour ceux qui veulent en savoir plus sur le ruban de LED voici la documentation en Anglais bien sûr.

J’ai aussi trouvé la documentation  de chaque LED WS2812.

Le ruban à été acheté sur le site Tmart.com :  voici le lien pour les acheter.


Installation du matériel

L’installation n’a pas été si compliquée. Je vous montre le schéma :

 

Je me suis vite rendu compte que l’alimentation que j’avais pris de 5 V/ 2 A était très juste car les LED consommait au total 7,5 A.

J’ai donc commandé une alimentation de 5V / 10A sur Amazon.  Elle s’avère plus puissante que l’ancienne et arrive à fournir en intensité le ruban de LED. Du fait qu’elle est supérieure au courant total consommé Alimentation 10 A >  Ruban LED 7,5 A.

J’ai également profité pour intégrer la nouvelle alimentation dans un boîtier pour isoler le 230 V (car c’est très dangereux).

J’ai prix une ancienne alim de PC dont j’ai enlevé la carte électronique puis enlever tout les fils qui était en trop.

J’ai relié le connecteur 230 V de l’alimentation de PC à l’alimentation 5V/10A puis j’ai sorti le V+ qui correspond au 5V et le V- qui correspond à la masse pour pouvoir alimenter directement sur le ruban de LED.

J’en ai aussi profité pour alimenter directement l’Arduino qui utilisait avant une alimentation externe pour fonctionner.

Pour la programmation rien de plus simple  j’ai téléchargé une bibliothèque développée par l’équipe d’Adafruit pour piloter les LED RGB comme je le voulais.

Bien sûr après il faut comme même programmer les effets que l’on veux.

/!\ Attention tant que vous n’avez pas envoyée les commandes, les LED restent éteintes même si vous les avez branchées.

Développement du programme

Pour cela je suis parti d’une structure de base :


#include <Adafruit_NeoPixel.h> // Charge la librairie Neo Pixel d'Adafruit utilisé pour piloter le ruban de LED

#define PIXEL_PIN 6 // On définit le pin où est connecté la patte DATA du bandeau
#define PIXEL_COUNT 150 // On définit le nombre de LED compris sur le Ruban de LED soit 150 pour le ruban de 5m50

Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800); // Paramètre l'objet strip qui correspond à toute les LED du ruban
 
void setup() {
   strip.begin(); // Lance la connection
   strip.show(); // Initialise toute les led à 'off'
}

/* Définition des couleurs */
int RED[3] = {255, 0, 0}; // Couleur Rouge
int GREEN[3] = {0, 255, 0}; // Couleur Verte
int CYAN[3] = {0, 255, 255}; // Couleur Cyan
int YELLOW[3] = {255, 125, 0}; // Couleur Jaune
int ORANGE[3] = {255, 40, 0}; // Couleur Orange
int PURPLE[3] = {255, 0 , 255}; // Couleur Violette
int PINK[3] = {255, 0, 100}; // Couleur Rose
int BLUE[3] = {0, 0, 255}; // Couleur Bleu
int WHITE[3] = {255, 255, 255}; // Couleur Blanche

void loop() {
  strip.setBrightness(100); // Règle la luminosité à 100 % de la luminosité maximale
}
Structure de base du programme

La partie setup ne fait qu’initialiser les 150 LED à l’état éteint. C’est dans la partie loop que le programme sera joué en boucle. J’ai donc commencé par créer pour chaque effet une fonction.

Création de divers effets

Le chenillard de LED

Le premier que j’ai créé est un effet de chenillard de LED dans un sens dont voici le code :

void chenillardUp(int temps, int r, int v, int b)
{
  for(int i = 0 ; i < 150 ; i++)
  {
     strip.setPixelColor(i, r, v, b);
        strip.show();
            strip.setPixelColor(i, 0, 0, 0);
        strip.show();
          delay(temps);  
  }
}
Chennilard de LED

Ensuite il suffit de l’intégrer dans le loop et le tour est joué :

#include <Adafruit_NeoPixel.h>
 
// On définit le pin où est connecté la patte DATA du bandeau
#define PIN 6
 
// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
 
//Ici, le 150 correspond au nombre de led
Adafruit_NeoPixel strip = Adafruit_NeoPixel(150, PIN, NEO_GRB + NEO_KHZ800);
 
void setup() {
  strip.begin();
  strip.show(); // Initialise toute les led à 'off'
}
 
void loop() {
// La première valeur correspond au temps, la seconde  à l'intensité du rouge, la troisième au vert, et la quatrième au bleu
  chenillardUp(10, 255, 255, 255); 
}

Résultat :

Allumage de toutes les LED du ruban (avec choix de la couleur)

Voici le code de la fonction pour l’allumage de toutes les LED :

void all(int temps, int r, int v, int b)
{
   for(int i = 0 ; i < 150 ; i++)
  {
     strip.setPixelColor(i, r, v, b);
  }
  strip.show();
   delay(temps); 
}
Allumage de l'ensemble du bandeau de LED

Avec le résultat :

Allumage de toute les LED de façon progressive

Voici le code de la fonction pour l’allumage de toute les LED de façon progressive :

void progressiveUp(int temps, int r, int v, int b)
{
  for(int lumi = 0 ; lumi < 100 ; lumi++)
  {
     for(int i = 0 ; i < 150 ; i++)
    {
       strip.setPixelColor(i, r, v, b);
    }
    strip.setBrightness(lumi); 
    strip.show();
     delay(temps);
  }
}
Allumage de toute les LED de facon progressive

Avec le résultat :

Allumage en chenillard de façon progressive

Voici le code pour allumer toutes les LED progressivement :

void progressiveUp(int temps, int r, int v, int b)
{
  for(int lumi = 0 ; lumi < 100 ; lumi++)
  {
     for(int i = 0 ; i < 150 ; i++)
    {
       strip.setPixelColor(i, r, v, b);
    }
    strip.setBrightness(lumi); 
    strip.show();
     delay(temps);
  }
}
Allumage en chenillard de toute les LED

Résultat :

Animation de séquence de 9 couleurs à la suite

Le code :

void anim_nineColor(int temps)
{
  for(int i = 0 ; i < PIXEL_COUNT ; i = i + 9)
  {
   strip.setPixelColor(i, RED[0], RED[1], RED[2]);
   strip.setPixelColor(i+1, GREEN[0], GREEN[1], GREEN[2]);
   strip.setPixelColor(i+2, CYAN[0], CYAN[1], CYAN[2]);
   strip.setPixelColor(i+3, YELLOW[0], YELLOW[1], YELLOW[2]);
     strip.setPixelColor(i+4, ORANGE[0], ORANGE[1], ORANGE[2]);
     strip.setPixelColor(i+5, PURPLE[0], PURPLE[1], PURPLE[2]);
     strip.setPixelColor(i+6, PINK[0], PINK[1], PINK[2]);
     strip.setPixelColor(i+7, BLUE[0], BLUE[1], BLUE[2]);
     strip.setPixelColor(i+8, WHITE[0], WHITE[1], WHITE[2]);
  }  
   strip.show();
   delay(temps);
}

Effet de vague

Le code :

/*
  Animation : Effet de vague avec toute les couleur
    > uint8_t wait => temps d'attente en ms
 */
  
void anim_rainbowCycle(uint8_t wait) {
  uint16_t i, j, numbers;
  numbers = 256 * 5;
  


  for(j=0; j < numbers; j++) { // 5 cycles of all colors on wheel
    for(i=0; i < PIXEL_COUNT; i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / PIXEL_COUNT) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

Effet de lumière façon manège

Le code :

/*
  Animation : Effet lumière manège
    > uint8_t wait => temps d'attente en ms
 */
 
void anim_theaterChaseRainbow(uint8_t wait) {
  
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3; q++) {
      for (int i=0; i < PIXEL_COUNT; i=i+3) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
      }
      strip.show();
  
      delay(wait*2.5);

      for (int i=0; i < PIXEL_COUNT; i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

Effet de flamme

Le code :

/*
  Animation : Effet flame
 */
 
void anim_fire()
{
int r = ORANGE[0];
int g = ORANGE[1]+5;
int b = ORANGE[2];

int variation = 45;

for(int x = 0; x <PIXEL_COUNT; x++)
{
int flicker = random(0,variation);
int r1 = r-flicker;
int g1 = g-flicker;
int b1 = b-flicker;
if(g1<0) g1=0;
if(r1<0) r1=0;
if(b1<0) b1=0;
strip.setPixelColor(x,r1,g1, b1);
}
strip.show();
delay(random(50,115));
}

Effet moitié 1 couleur, moitié autre couleur

Le code :

/*
  Animation : Effet deux couleur
  > int temps => temps en ms
  > int colorLeft => Couleur de Gauche
  > int colorRight => Couleur de Droite
*/
 
void anim_allBiColor( int temps, int colorLeft[3], int colorRight[3])
{

        for(int i = 0 ; i < PIXEL_COUNT/2 ; i++)
            {
               strip.setPixelColor(i, colorRight[0], colorRight[1], colorRight[2]);
            }
            for(int i = PIXEL_COUNT/2 ; i < PIXEL_COUNT ; i++)
            {
               strip.setPixelColor(i, colorLeft[0], colorLeft[1], colorLeft[2]);
            }
          strip.show();
           delay(temps);
  
}

Changement d’une couleur à une autre

Le code :

/*
  Animation : Changement d'une couleur à une autre de manière progressive
    > int temps => temps d'attente en ms
    > int colorDebut => Couleur 1
     > int colorFin => Couleur 2
 */
 
void anim_changeColor(int temps, int colorDebut[3], int colorFin[3])
{
  
  int color[3] = {0};
  
  color[0] = colorDebut[0];
  color[1] = colorDebut[1];
  color[2] = colorDebut[2];
  
 while(color[0] != colorFin[0] || color[1] != colorFin[1] || color[2] != colorFin[2])
  {
    
    if(color[0] > colorFin[0])
    {
      color[0]--;
    }
    else if(color[0] < colorFin[0])
    {
      color[0]++;
    }
    
     if(color[1] > colorFin[1])
    {
      color[1]--;
    }
    else if(color[1] < colorFin[1])
    {
      color[1]++;
    }
    
     if(color[2] > colorFin[2])
    {
      color[2]--;
    }
    else if(color[2] < colorFin[2])
    {
      color[2]++;
    }
    
  
    
    
    anim_all(temps, color);
  }
}

Résultat :

 

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer