Arduino et capteur couleur Adafruit

Salut à tous !

Tout d’abord désolé de citer les marques ou autres, c’est pour bien expliquer le matos que j’ai en ma possession.

Je possède donc un capteur de couleur Adafruit 1334 (RGB Color Sensor with IR filter and White LED - TCS34725 : ID 1334 : $7.95 : Adafruit Industries, Unique & fun DIY electronics and kits)
Un arduino Uno R3 " officiel " ( avec les broches SCL et SDA donc )
Une led Rouge Bleue Verte a Cathode commune ( Un peu bizarre non ? c’est celle qui était fourni dans mon starter kit arduino ) Lorsque je regarde sur internet l’ordre est plutôt Rouge vert bleu.

[/img]

( Ce branchement n’est pas le mien, c’est celui proposé sur le site Adafruit, mais j’ai fait le même)

J’ai également branché ma led , cathode au ground commun, resistance de 1k Ohm sur la patte verte et 560 sur les deux autres.
Patte bleue , broche 6
Patte verte , broche 5
Patte rouge , broche 3

Le code est le suivant ( je l’ai également pris sur le site )

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

// Pick analog outputs, for the UNO these three work well
// use ~560  ohm resistor between Red & Blue, ~1K for green (its brighter)
#define redpin 3
#define greenpin 5
#define bluepin 6
// for a common anode LED, connect the common pin to +5V
// for common cathode, connect the common to ground

// set to false if using a common cathode LED
#define commonAnode false

// 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!");

  if (tcs.begin()) {
    Serial.println("Found sensor");
  } else {
    Serial.println("No TCS34725 found ... check your connections");
    while (1); // halt!
  }
  
  // use these three pins to drive an LED
  pinMode(redpin, OUTPUT);
  pinMode(greenpin, OUTPUT);
  pinMode(bluepin, OUTPUT);
  
  // 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;
      
    if (commonAnode) {
      gammatable[i] = 255 - x;
    } else {
      gammatable[i] = x;      
    }
    //Serial.println(gammatable[i]);
  }
}


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 = 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 );

  analogWrite(redpin, gammatable[(int)r]);
  analogWrite(greenpin, gammatable[(int)g]);
  analogWrite(bluepin, gammatable[(int)b]);
}

Mon problème est le suivant, quand rien n’est présenté au capteur ( lumière ambiante ) la LED RGB s’allume avec une teinte rosée
Lorsque je présente un objet avec un rouge ou un bleu franc, pas de problème la LED s’allume dans la couleur désirée.
Par contre, quand je présente d’autres couleurs ( vert, jaune etc ); la led me fait un mélange entre le rose qu’elle met ’ par défaut ’ et la couleur présentée.
Par exemple si je présente un objet jaune, je vais ressortir avec une led orangée

J’ai essayé de comprendre un peu tout seul, mais avec mes faibles connaissances je n’y suis pas parvenu et je sollicite donc votre aide !

Est-ce possible que mon capteur de couleur soit défectueux ? Ou ma LED ?

Un grand merci a ceux qui prendront le temps de m’aider

David

J'ai également branché ma led , cathode au ground commun, resistance de 1k Ohm sur la patte verte et 560 sur les deux autres.
Patte bleue , broche 6
Patte verte , broche 5
Patte rouge , broche 3

pourquoi avez vous choisi ces valeurs de résistances? avez vous testé votre capacité à obtenir des couleurs de base raisonnables?

une bonne lecture ici sur les LEDs RGB

Bonjour, merci pour votre réponse.

J'ai fait plusieurs tests avec plusieurs valeurs de résistances, en mettant des 220ohms sur chacune des pattes de ma led, j'arrive a un résultat similaire ( un peu plus brillant simplement ).

Je m'étais déjà servi de ma led ( un peu comme le démontre la page que vous avez joint ) et j'arrivais a afficher les différentes teintes voulues.

Ce peut-il que le problème vienne donc du capteur de couleur ?

Souvent le fwd voltage de la LED verte est en effet plus élevé (de 1V) que les 2 autres donc effectivement il faut des résistances différentes pour éviter que le mélange des couleurs perçu soit distordu

Je m’étais déjà servi de ma led ( un peu comme le démontre la page que vous avez joint ) et j’arrivais a afficher les différentes teintes voulues.

essayez les combinaisons de base, à divers PWM (commences à 127)

Rouge
Vert
Bleu
Rouge + Vert = Jaune
Vert + Bleu = Cyan
Rouge + Bleu = Magenta
Rouge + Vert + Bleu = Blanc

vérifiez visuellement que la couleur de sortie est correcte (éventuellement avec un petit papier diffuseur (genre un papier calque) au dessus de la LED si elle n’est pas déjà diffusée)

de même avec quelques papiers de couleurs primaires regardez ce que dit votre capteur

Re !

Pour ce qui est des différentes teintes avec ma led, même si elle n’est pas ultra précises, j’arrive tout de même a avoir des résultats corrects.

En ce qui concerne le capteur, j’ai positionné devant lui ces 3 petits jetons

Voici les résultats affichés sur le moniteur en série avec le code du 1er post

Jeton Bleu

Jeton Rouge

Jeton Vert

Par ’ défaut ’ ( quand je ne présente rien devant le capteur

Si je ne dis pas de bêtises, le dernier code est en hexa, et quand je vais sur un site et que j’entre les code héxa, le vert sort bien vert, mais ma led m’affiche un mélange bleu-vert un peu bizarre

Edit : J’en viens donc a la conclusion que le problème c’est ma LED ( elle doit mal mélanger les couleurs ? )

essayez avec le code suivant:

// test du détecteur de couleur TCS34725
//  Connecter SCL à A5 / SCL
//  Connecter SDA à A4 / SDA
//  Connecter Vin à 5V
//  Connecter GND à GND

#include "Adafruit_TCS34725.h"

Adafruit_TCS34725 tcs34725 = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_101MS, TCS34725_GAIN_1X);

// integration time for color samples from the sensor. Longer integration times can be used for increased sensitivity at low light levels. Valid integration times are:
tcs34725IntegrationTime_t tempsIntegration[] =
{
  TCS34725_INTEGRATIONTIME_2_4MS,   /* 2.4ms - 1 cycle    - Max Count: 1024  */
  TCS34725_INTEGRATIONTIME_24MS,    /* 24ms  - 10 cycles  - Max Count: 10240 */
  TCS34725_INTEGRATIONTIME_50MS,    /* 50ms  - 20 cycles  - Max Count: 20480 */
  TCS34725_INTEGRATIONTIME_101MS,   /* 101ms - 42 cycles  - Max Count: 43008 */
  TCS34725_INTEGRATIONTIME_154MS,   /* 154ms - 64 cycles  - Max Count: 65535 */
  TCS34725_INTEGRATIONTIME_700MS    /* 700ms - 256 cycles - Max Count: 65535 */
};

const char * const descriptionIntegration[] = {"2.4 ms", "24 ms", "50 ms", "101 ms", "154 ms", "700 ms"};

const byte nbTempsIntegration = sizeof(tempsIntegration) / sizeof(tempsIntegration[0]);

// gain of the ADC to control the sensitivity of the sensor. Valid gain settings are:
tcs34725Gain_t gain[] =
{
  TCS34725_GAIN_1X,   /* No gain  */
  TCS34725_GAIN_4X,   /* 4x gain  */
  TCS34725_GAIN_16X,  /* 16x gain */
  TCS34725_GAIN_60X   /* 60x gain */
};

const char * const descriptionGain[] = {"1x", "4x", "16x", "60x"};

const byte nbGain = sizeof(gain) / sizeof(gain[0]);

byte gammatable[256];

void setup() {
  Serial.begin(115200);
  Serial.println();

  if (!tcs34725.begin()) {
    Serial.println(F("Detecteur TCS34725 absent"));
    while (1);
  }

  for (int i = 0; i < 256; i++) gammatable[i] = 255.0 * pow((i / 255.0), 2.5);
}


void loop() {
  uint16_t rCapteur, vCapteur, bCapteur, cCapteur;
  byte rouge, vert, bleu;

  for (int t = 0; t < nbTempsIntegration; t++) {
    Serial.print(F("Integration:")); Serial.println(descriptionIntegration[t]);
    for (int g = 0; g < nbGain; g++) {
      tcs34725.setIntegrationTime(tempsIntegration[t]);
      tcs34725.setGain(gain[g]);
      tcs34725.getRawData(&rCapteur, &vCapteur, &bCapteur, &cCapteur);

      Serial.print(F("\tGain:")); Serial.print(descriptionGain[g]);  Serial.print(F(":\t"));

      rouge = 256.0 * ((float) rCapteur) / cCapteur;
      vert  = 256.0 * ((float) vCapteur) / cCapteur;
      bleu  = 256.0 * ((float) bCapteur) / cCapteur;

      Serial.print(F("\tR:")); Serial.print(rouge); Serial.print(F("\t"));
      Serial.print(F("V:")); Serial.print(vert); Serial.print(F("\t"));
      Serial.print(F("B:")); Serial.print(bleu);  Serial.print(F("\t\t"));

      Serial.print(F("Rg:")); Serial.print(gammatable[rouge]); Serial.print(F("\t"));
      Serial.print(F("Vg:")); Serial.print(gammatable[vert]); Serial.print(F("\t"));
      Serial.print(F("Bg:")); Serial.print(gammatable[bleu]);  Serial.println();
    }
    Serial.println(F("\t----------"));
  }
  Serial.println();  Serial.println();
  delay(2000);
}

ça vous affiche pour tous les temps d’intégration et tous les gains les valeurs calculées pour les capteurs rouge, vert et bleu puis l’adaptation à un coefficient Gamma (adaptation pour correction de la perception des couleurs par l’oeil humain) de ces mêmes indices, que vous pouvez utiliser pour piloter une LED RGB

J’utilise dans mon test des capuchons de boutons:

boutons.png

et si je pose un capuchon sur mon capteur j’obtiens en affichage cela:

Integration:2.4 ms
Gain:1x: R:196 V:118 B:120 Rg:132 Vg:37 Bg:38
Gain:4x: R:196 V:118 B:120 Rg:132 Vg:37 Bg:38
Gain:16x: R:195 V:118 B:30 Rg:130 Vg:37 Bg:1
Gain:60x: R:195 V:116 B:117 Rg:130 Vg:35 Bg:36

Integration:24 ms
Gain:1x: R:116 V:70 B:71 Rg:35 Vg:10 Bg:10
Gain:4x: R:197 V:117 B:119 Rg:133 Vg:36 Bg:37
Gain:16x: R:195 V:118 B:119 Rg:130 Vg:37 Bg:37
Gain:60x: R:196 V:118 B:120 Rg:132 Vg:37 Bg:38

Integration:50 ms
Gain:1x: R:197 V:120 B:120 Rg:133 Vg:38 Bg:38
Gain:4x: R:197 V:119 B:120 Rg:133 Vg:37 Bg:38
Gain:16x: R:196 V:118 B:119 Rg:132 Vg:37 Bg:37
Gain:60x: R:196 V:118 B:119 Rg:132 Vg:37 Bg:37

Integration:101 ms
Gain:1x: R:196 V:119 B:120 Rg:132 Vg:37 Bg:38
Gain:4x: R:196 V:117 B:119 Rg:132 Vg:36 Bg:37
Gain:16x: R:196 V:118 B:119 Rg:132 Vg:37 Bg:37
Gain:60x: R:196 V:118 B:120 Rg:132 Vg:37 Bg:38

Integration:154 ms
Gain:1x: R:197 V:120 B:120 Rg:133 Vg:38 Bg:38
Gain:4x: R:197 V:120 B:120 Rg:133 Vg:38 Bg:38
Gain:16x: R:196 V:118 B:119 Rg:132 Vg:37 Bg:37
Gain:60x: R:196 V:118 B:119 Rg:132 Vg:37 Bg:37

Integration:700 ms
Gain:1x: R:197 V:119 B:120 Rg:133 Vg:37 Bg:38
Gain:4x: R:196 V:118 B:120 Rg:132 Vg:37 Bg:38
Gain:16x: R:196 V:119 B:119 Rg:132 Vg:37 Bg:37
Gain:60x: R:196 V:118 B:120 Rg:132 Vg:37 Bg:38

On voit que si le gain est faible et le temps d’intégration court, alors c’est pas forcément stable mais dès un 4x et 24 ms on a quelque chose pas mal.

ici j’avais le capuchon rouge et on voit bien dans les valeurs Gamma que la composante rouge est super plus élevée que les 2 autres

Pour le Vert cependant il faut un peu plus de temps d'intégration et/ou gain pour avoir un truc stable

Integration:2.4 ms
Gain:1x: R:0 V:0 B:0 Rg:0 Vg:0 Bg:0
Gain:4x: R:0 V:0 B:0 Rg:0 Vg:0 Bg:0
Gain:16x: R:67 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:60x: R:73 V:151 B:115 Rg:11 Vg:68 Bg:34

Integration:24 ms
Gain:1x: R:124 V:0 B:194 Rg:42 Vg:0 Bg:128
Gain:4x: R:86 V:171 B:132 Rg:16 Vg:93 Bg:49
Gain:16x: R:67 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:60x: R:68 V:141 B:106 Rg:9 Vg:57 Bg:28

Integration:50 ms
Gain:1x: R:113 V:233 B:177 Rg:33 Vg:203 Bg:102
Gain:4x: R:124 V:251 B:192 Rg:42 Vg:245 Bg:125
Gain:16x: R:68 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:60x: R:67 V:141 B:106 Rg:9 Vg:57 Bg:28

Integration:101 ms
Gain:1x: R:237 V:227 B:111 Rg:212 Vg:190 Bg:31
Gain:4x: R:67 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:16x: R:67 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:60x: R:68 V:141 B:106 Rg:9 Vg:57 Bg:28

Integration:154 ms
Gain:1x: R:123 V:252 B:192 Rg:41 Vg:247 Bg:125
Gain:4x: R:112 V:228 B:174 Rg:32 Vg:192 Bg:98
Gain:16x: R:67 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:60x: R:68 V:141 B:106 Rg:9 Vg:57 Bg:28

Integration:700 ms
Gain:1x: R:105 V:215 B:163 Rg:27 Vg:166 Bg:83
Gain:4x: R:68 V:141 B:107 Rg:9 Vg:57 Bg:29
Gain:16x: R:68 V:141 B:106 Rg:9 Vg:57 Bg:28
Gain:60x: R:108 V:224 B:168 Rg:29 Vg:184 Bg:89

--> il semblerait que le gain 16x soit bien

Pour le capuchon bleu j'ai cela:

Integration:2.4 ms
Gain:1x: R:121 V:162 B:231 Rg:39 Vg:82 Bg:199
Gain:4x: R:121 V:162 B:231 Rg:39 Vg:82 Bg:199
Gain:16x: R:85 V:114 B:40 Rg:16 Vg:34 Bg:2
Gain:60x: R:84 V:114 B:163 Rg:15 Vg:34 Bg:83

Integration:24 ms
Gain:1x: R:118 V:77 B:109 Rg:37 Vg:12 Bg:30
Gain:4x: R:85 V:113 B:164 Rg:16 Vg:33 Bg:84
Gain:16x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83
Gain:60x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83

Integration:50 ms
Gain:1x: R:112 V:150 B:211 Rg:32 Vg:67 Bg:158
Gain:4x: R:111 V:149 B:211 Rg:31 Vg:66 Bg:158
Gain:16x: R:85 V:113 B:163 Rg:16 Vg:33 Bg:83
Gain:60x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83

Integration:101 ms
Gain:1x: R:95 V:126 B:180 Rg:21 Vg:43 Bg:106
Gain:4x: R:114 V:5 B:8 Rg:34 Vg:0 Bg:0
Gain:16x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83
Gain:60x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83

Integration:154 ms
Gain:1x: R:114 V:152 B:215 Rg:34 Vg:69 Bg:166
Gain:4x: R:106 V:141 B:200 Rg:28 Vg:57 Bg:138
Gain:16x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83
Gain:60x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83

Integration:700 ms
Gain:1x: R:107 V:142 B:201 Rg:29 Vg:59 Bg:140
Gain:4x: R:86 V:114 B:163 Rg:16 Vg:34 Bg:83
Gain:16x: R:85 V:114 B:163 Rg:16 Vg:34 Bg:83
Gain:60x: R:98 V:131 B:187 Rg:23 Vg:48 Bg:117

en regardant un peu la stabilité, là aussi un gain de 16x semble pas mal avec au moins 50 ms d'Integration

au final donc si je retiens 50ms et 16x, je peux écrire le petit programme suivant pour différencier mes capuchons rouges, verts ou bleus:

montage.png

// test du détecteur de couleur TCS34725
//  Connecter SCL à A5 / SCL
//  Connecter SDA à A4 / SDA
//  Connecter Vin à 5V
//  Connecter GND à GND

#include "Adafruit_TCS34725.h"

Adafruit_TCS34725 tcs34725 = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_16X);
const byte seuilRouge = 115;
const byte seuilVert = 60;
const byte seuilBleu = 85;

byte gammatable[256];

void setup() {
  Serial.begin(115200);
  Serial.println();

  if (!tcs34725.begin()) {
    Serial.println(F("Detecteur TCS34725 absent"));
    while (1);
  }

  for (int i = 0; i < 256; i++) gammatable[i] = 255.0 * pow((i / 255.0), 2.5);
}


void loop() {
  uint16_t rCapteur, vCapteur, bCapteur, cCapteur;
  byte rouge, vert, bleu;

  tcs34725.getRawData(&rCapteur, &vCapteur, &bCapteur, &cCapteur);
  rouge = gammatable[(byte) (256.0 * ((float) rCapteur) / cCapteur)];
  vert  = gammatable[(byte) (256.0 * ((float) vCapteur) / cCapteur)];
  bleu  = gammatable[(byte) (256.0 * ((float) bCapteur) / cCapteur)];

  Serial.print(F("Rg:")); Serial.print(rouge); Serial.print(F("\t"));
  Serial.print(F("Vg:")); Serial.print(vert); Serial.print(F("\t"));
  Serial.print(F("Bg:")); Serial.print(bleu);  Serial.print(F("\t-->\t"));

  if ((rouge > seuilRouge) && (rouge > vert) && (rouge > bleu)) Serial.println(F("Capuchon Rouge"));
  else if ((vert > seuilVert) && (vert > rouge) && (vert > bleu)) Serial.println(F("Capuchon Vert"));
  else if ((bleu > seuilBleu) && (bleu > rouge) && (bleu > vert)) Serial.println(F("Capuchon Bleu"));
  else Serial.println(F("Je ne sais pas..."));
  delay(2000);
}

et quand je pose mes divers capuchons sur le capteur j’obtiens:

Rg:95 Vg:32 Bg:37 → Je ne sais pas…
Rg:105 Vg:43 Bg:46 → Je ne sais pas…
Rg:122 Vg:39 Bg:43 → Capuchon Rouge
Rg:120 Vg:39 Bg:43 → Capuchon Rouge
Rg:119 Vg:65 Bg:61 → Capuchon Rouge
Rg:29 Vg:41 Bg:79 → Je ne sais pas…
Rg:51 Vg:53 Bg:84 → Je ne sais pas…
Rg:50 Vg:52 Bg:84 → Je ne sais pas…
Rg:9 Vg:26 Bg:87 → Capuchon Bleu
Rg:10 Vg:27 Bg:87 → Capuchon Bleu
Rg:7 Vg:23 Bg:84 → Je ne sais pas…
Rg:13 Vg:51 Bg:31 → Je ne sais pas…
Rg:10 Vg:62 Bg:28 → Capuchon Vert
Rg:10 Vg:63 Bg:29 → Capuchon Vert

et ça marche, il ne se trompe pas :slight_smile:

(par flemme j’ai conservé la correction Gamma pour effectuer mes comparaisons mais ce n’est pas nécessaire, on pourrait travailler sur les valeurs brutes corrigées du capteur sans la partie Gamma pour ne pas occuper 256 octets pour rien)