Capteur de couleur TCS347525

Bonjour à tous,

Lors des divers évènements auxquels nous avons participé (MIA, Apérobo), nous avons fait découvrir le capteur de couleur TCS347525 d'Adadafruit combiné à un Neopixel Ring du même fabricant. Notre petit montage de démonstration à attiré l'attention de beaucoup de monde et plusieurs personnes nous ont demandées de partager les infos pour pouvoir le reproduire. Voici donc le montage et le code qui va avec.

Le code :

//Code de micmac.caliban

#include <Wire.h>
#include "Adafruit_TCS34725.h"
#include <Adafruit_NeoPixel.h>

// Le capteur de couleur se connecte sur les broche SLC et SDA
// Parameter 1 = number of pixels in strip (dans mon cas c'est 16)
// Parameter 2 = pin number (most are valid) (pin 6 dans mon cas)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_RGB     Pixels are wired for RGB bitstream
//   NEO_GRB     Pixels are wired for GRB bitstream
//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip)
int NbresLED = 16; //Nombres de led sur le strip ou anneau néopixel
int PinLED = 6;  // Broche de connection à l'arduino
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NbresLED, PinLED, NEO_GRB + NEO_KHZ800);
//

// our RGB -> eye-recognized gamma color
byte gammatable[256];

Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);

void setup() {
Serial.begin(9600);
Serial.println("Color View Test!");

strip.begin();
strip.setBrightness(255);
strip.show(); // Initialize all pixels to 'off'

if (tcs.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1); // halt!
}

// thanks PhilB for this gamma table!
// it helps convert RGB colors to what humans see
for (int i=0; i<256; i++) {
float x = i;
x /= 255;
x = pow(x, 2.5);
x *= 255;

gammatable[i] = x;
//Serial.println(gammatable[i]);
}

uint16_t clear, red, green, blue;

tcs.setInterrupt(false);      // turn on LED

delay(60);  // takes 50ms to read

tcs.getRawData(&red, &green, &blue, &clear);

tcs.setInterrupt(true);  // turn off LED

Serial.print("C:\t"); Serial.print(clear);
Serial.print("\tR:\t"); Serial.print(red);
Serial.print("\tG:\t"); Serial.print(green);
Serial.print("\tB:\t"); Serial.print(blue);

// Figure out some basic hex code for visualization
uint32_t sum = red;
sum += green;
sum += blue;
sum += clear;
float r, g, b;
r = red; r /= sum;
g = green; g /= sum;
b = blue; b /= sum;
r *= 256; g *= 256; b *= 256;
Serial.print("\t");
Serial.print((int)r, HEX); Serial.print((int)g, HEX); Serial.print((int)b, HEX);
Serial.println();

Serial.print((int)r ); Serial.print(" "); Serial.print((int)g);Serial.print(" ");  Serial.println((int)b );
colorWipe(strip.Color(gammatable[(int)r], gammatable[(int)g], gammatable[(int)b]), 0);
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.setPixelColor((i+1), 0);
strip.show();
delay(wait);
}
}

void loop() {

uint16_t clear, red, green, blue;

tcs.setInterrupt(false);      // turn on LED

delay(60);  // takes 50ms to read

tcs.getRawData(&red, &green, &blue, &clear);

tcs.setInterrupt(true);  // turn off LED

Serial.print("C:\t"); Serial.print(clear);
Serial.print("\tR:\t"); Serial.print(red);
Serial.print("\tG:\t"); Serial.print(green);
Serial.print("\tB:\t"); Serial.print(blue);

// Figure out some basic hex code for visualization
uint32_t sum = red;
sum += green;
sum += blue;
sum += clear;

float r, g, b;
r = red; r /= sum;
g = green; g /= sum;
b = blue; b /= sum;
r *= 256; g *= 256; b *= 256;
Serial.print("\t");
Serial.print((int)r, HEX); Serial.print((int)g, HEX); Serial.print((int)b, HEX);
Serial.println();

Serial.print((int)r ); Serial.print(" "); Serial.print((int)g);Serial.print(" ");  Serial.println((int)b );
Serial.println();
colorWipe(strip.Color(min(gammatable[(int)r]*10, 255), min(gammatable[(int)g]*10, 255), min(gammatable[(int)b]*10, 255)), 500*16);
Serial.println(gammatable[(int)r]); Serial.println(gammatable[(int)g]); Serial.println(gammatable[(int)b]);

}
Fred de Caliban

Néopixel + Domoticz + MySensors V1.5 & V2

Hello tout le monde,

Celà fait un moment que je me disait que ça serait bien de pouvoir controler des néopixels avec domoticz.

J'ai donc fais quelques recherche et je suis tombé sur un exemple assez intérressant , je l'ai donc testé.

Au niveau hardware, il faut un maitre mysensors connecter à la raspberry, voir ici pour le tutoriel.

Pour la partie esclave , une arduino, un module radio NRF24L01+, des leds neopixels.

Voilà pour les premiers tests, j’espère que cela vous plaira.

J’approfondirai le sujet plus tard.

Mickaël

Liens :https://www.domoticz.com/forum/viewtopic.php?t=8039

// Example sketch showing how to control an RGB Led Strip.
// This example will not remember the last rgb color set after power failure.

#include <MySensor.h>
#include <SPI.h>

#include "Adafruit_NeoPixel.h"

#define NUMPIXELS 4   // Number of connected pixels on a single datapin
#define PIN 4         // Digital output pin

#define node 254  //254 for testing purpose
#define CHILD_ID 0


Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
long RGB_values[3] = {0,0,0};

MySensor gw;

void setup()
{
    gw.begin(incomingMessage, node, true);
    gw.sendSketchInfo("RGB Node", "1.0");
    gw.present(CHILD_ID, S_RGB_LIGHT);
    strip.begin();
    strip.show(); // Update the strip, to start they are all 'off'
}


void loop()
{
    gw.process();
}

void incomingMessage(const MyMessage &message) {
    if (message.type==V_RGB) {
  // starting to process the hex code
        String hexstring = message.getString(); //here goes the hex color code coming from through MySensors (like FF9A00)
        long number = (long) strtol( &hexstring[0], NULL, 16);
        RGB_values[0] = number >> 16;
        RGB_values[1] = number >> 8 & 0xFF;
        RGB_values[2] = number & 0xFF;

        colorWipe(Color(RGB_values[0],RGB_values[1],RGB_values[2]), 60);
     }
     
    if (message.type==V_DIMMER) {
      strip.setBrightness(round((2.55*message.getInt())));
      strip.show();
      }
     
    if (message.type==V_LIGHT) {
       if (message.getInt() == 0) {
        strip.clear();
        strip.show();
       }
    }
 }
 
void colorWipe(uint32_t c, uint8_t wait) {
  int i;
 
  for (i=0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
      strip.show();
      delay(wait);
  }
}

    /* Helper functions */

// Create a 15 bit color value from R,G,B
uint32_t Color(byte r, byte g, byte b)
{
  uint32_t c;
  c = r;
  c <<= 8;
  c |= g;
  c <<= 8;
  c |= b;
  return c;
}

 

Code utilisé

 

EDIT 07/02/2017

Si vous utilisez la V2 de Mysensors le code ci dessus ne fonctionnera pas.

Voici la version adaptée

Fred

// Code Neopixel pour Mysensors V2

#define MY_DEBUG
#define MY_RADIO_NRF24
#include <MySensors.h>
#include <SPI.h>

#include "Adafruit_NeoPixel.h"

#define NUMPIXELS 50    // Number of connected pixels on a single datapin
#define PIN 4         // Digital output pin

#define node 10  
#define CHILD_ID 0

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
long RGB_values[3] = {0,0,0};

void presentation()
{
   // gw.begin(incomingMessage, node, true);
    sendSketchInfo("RGB Node", "1.1");
    present(CHILD_ID, S_RGB_LIGHT);
    strip.begin();
    strip.show(); // Update the strip, to start they are all 'off'
}

void loop()
{

}

void receive(const MyMessage &message) {
    if (message.type==V_RGB) {
  // starting to process the hex code
        String hexstring = message.getString(); //here goes the hex color code coming from through MySensors (like FF9A00)
        long number = (long) strtol( &hexstring[0], NULL, 16);
        RGB_values[0] = number >> 16;
        RGB_values[1] = number >> 8 & 0xFF;
        RGB_values[2] = number & 0xFF;

        colorWipe(Color(RGB_values[0],RGB_values[1],RGB_values[2]));
     }

    if (message.type==V_PERCENTAGE) {
      strip.setBrightness(round((2.55*message.getInt())));
      strip.show();
      }

    if (message.type==V_STATUS) {
       if (message.getInt() == 0) {
        strip.clear();
        strip.show();
       }
    }
 }

void colorWipe(uint32_t c) {
  int i;

  for (i=0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
  }
  strip.show();  
}

    /* Helper functions */

// Create a 15 bit color value from R,G,B
uint32_t Color(byte r, byte g, byte b)
{
  uint32_t c;
  c = r;
  c <<= 8;
  c |= g;
  c <<= 8;
  c |= b;
  return c;
}

Lampe RGB

Bonjour tout le monde !

 

Je vous propose un petit article qui vous explique comment créer une lampe avec des Neopixel, le tout commandé par une application Android via le Bluetooth de votre smartphone ou tablette.

Voici la lampe telle que je l’ai réalisée. Le tout a été imprimé avec mon imprimante 3D.

Le design de la lampe est tiré d’une réalisation que j’ai trouvé sur thingiverse. Tous les fichiers sources sont disponible en fin d’article.

Pour bien laisser passer la lumière le fil utilisé est un PLA de couleur naturel et le remplissage est de 0. La vitesse d’impression est assez faible le tout sans aucun support. C’est une de mes premières impressions complexe et le resultat n’est pas optimal. Avec un peu d’expérience il y a moyen de faire bien mieux.

J’ai dessiné et imprimé un socle et aussi un axe autour duquel le ruban LED est enroulé et collé à la colle chaude. On remarque dans le socle 3 petits (pré)trous, au départ je pensais commander la lampe à l’aide de 3 boutons poussoirs, ensuite l’idée du bluetooth s’est imposée d’elle même.

Dans mon cas le ruban neopixel est composé de 42 leds. Ce choix est simplement guidé par les dimensions de la lampe imprimée. Si vous imprimez plus petit il faudra moins de led, ou l’inverse si votre lampe est plus grande. Il ne faudra pas oublier de modifier le code arduino en conséquence. J’ai choisi d’alimenter tout le montage à l’aide d’un cable USB directement via le connecteur mini USB de l’arduino Nano. Cela permet d’alimanter la lampe à partir d’un chargeur GSM, d’un PC ou même une batterie externe.

L’électronique est des plus simple. Une arduino Nano, un module bluetooth HC-06 et le strip neopixel … et c’est tout ! Quand je vous dit que c’est simple 😉

Le raccordement des composants n’est pas plus compliqué. Le ruban neopixel est branché sur le Vin et GND de l’arduino. La ligne DATA sur la PIN 6 ou autre sortie PWM de l’arduino. Le module Bluetooth c’est pareil pour la partie Vcc et GND. Le TX/RX ne sont pas branché sur le TX/RX de l’arduino mais sur d’autres sorties. J’ai émulé un RX/TX dans le programme Arduino avec Serial.software. J’ai fait ca car si le module BT est sur le RX/TX hardware de la Nano il devient impossible de reprogrammer l’Arduino. Emuler une autre liaison série permet d’éviter ce soucis. Sur la photo RX/TX sont sur D10 et 11. Attention dans le programme fourni plus bas c’est parametré sur D2 et 3.

Voilà la partie électronique est terminée. Il nous reste à réaliser une petite application Android pour gérer notre jolie lampe RGB.

Je vous le concède l’application est assez haustère. Ce n’est qu’une ébauche, libre à vous de l’améliorer. Fidèle à nos principes les sources sont disponibles en fin d’article. Si vous apportez des modifications on serait heureux d’en profiter.

Le fonctionnement de l’application est très simple. Le bouton Bluetooth permet de sélectionner le module BT de la lampe et de s’y connecter. A droite du bouton on a le statut de connexion. Le bouton disconnect permet de déconnecter le module BT. 3 Slidebars permettent de faire varier la couleur en jouant sur les 3 composantes, le rouge, le vert et le bleu (RGB = Red, Green, Blue). Le bouton Send prend la couleur résultant des 3 slidebars et permet d’envoyer la couleur à la lampe. Le bouton Off éteint la lampe.

Il reste pas mal de place sur l’écran pour ajouter des boutons et des fonctions comme par exemple simuler la flamme dansante d’une bougie, des effets lumineux comme clignotant, arc-en-ciel et bien d’autres qu’il vous reste à imaginer.

Pour créer cette appli Android (les puristes vont crier au scandale) j’ai utilisé une interface Web MIT App Inventor 2. Ce site permet de créer rapidement une application simple. J’ai voulu tester et en effet c’est simple. Il n’y a auncune configuration à faire. Il y a 2 parties importantes, le Design comme ci contre et la partie Block. Le Design représente votre écran de smartphone et vous y glissez les boutons, sliders, zone de texte et encore bien d’autres composants. A droite vous pouvez régler quelques paramètres des composants installés.

C’est dans la partie Block que vous aller « enter » votre code. Comme vous le voyez pas besoin d’entrer des dizaines ou centaines de lignes de code d’une langue qui pour vous s’apparente à du klingon. Les blocks s’emboitent et notre programme se construit à grande vitesse. Il faut tout de même avoir un esprit logique mais on évite la fastidieuse étude de la syntaxe d’un language et les « bêtes » erreurs de frappe comme la simple { qui manque dans Arduino et la compilation devient impossible.

Dans les sources il y a un fichier .aia qui peut être importé dans MIT App Inventor 2 qui vous permet de ne pas devoir tout entrer vous même. Il vous reste à compiler votre code et le transférer sur votre smartphone ou tablette et de l’installer. Tout ça est bien expliquer sur le site, il y a aussi quelques vidéos et tutos explicatifs que vous trouverez facilement sur le web.

Un fichier .apk est aussi disponible, il vous reste juste à le transférer et à l’installer et vous avez directement la même appli que moi.

 

Nous voilà arrivé au bout de ce tuto. J’espère qu’il vous donnera l’envie de réaliser ce projet. Pour vous aider toutes les sources sont accessibles ICI

 

Fred de Caliban Belgique