Os links e preços abaixo são apenas para referência.

1. Arduino Nano (US$ 8.00)
2. TCS3200 Color Sensor Module (US$ 9.00)
3. IIC/I2C/TWI 1602 Serial Blue Backlight LCD Module (US$ 8.00)
4. Breadboard (US$ 2.00)
5. Cables

1. Instale o Arduino Nano no BreadBoard
2. Conecte a saída de 5V e GND do Nano 5Va ambos Power Rails do BreadBoard
3. Conecte o sensor TSC3200 como descrito abaixo:
   • S0     ==> Nano pin D4
   • S1     ==> Nano pin D5
   • S2     ==> Nano pin D6
   • S3     ==> Nano pin D7
   • OUT ==> Nano Pin D8
   • EN    ==> GND
   • VCC  ==> +5V
   • GND ==> GND
4. Conecte o I2C LCD 2/16 Serial Display como abaixo:
   • SDA ==> Nano Pin A4
   • SCL ==> Nano Pin A5

A primeira coisa a definir é a escala de freqüência a ser utilizada, tal como definida na tabela mostrada acima. Os pinos S0 e S1 são usados para isso. A escala da freqüência de saída é útil para otimizar as leituras de sensores para vários contadores de freqüência ou microcontroladores. Definiremos S0 e S1 em HIGH (100%), funcionou bem com meu Nano. Já observei em alguns projectos com o UNO, a frequência escalonada em 20%. Teste para ver o melhor em seu caso.

  digitalWrite(s0,HIGH);
  digitalWrite(s1,HIGH);

A próxima coisa a fazer é selecionar a cor a ser lida pelo fotodíodo (vermelho, verde ou azul), usamos os pinos de controle S2 e S3 para isso. Como os fotodiodos são conectados em paralelo, o ajuste de S2 e S3 como LOW ou HIGH em combinações diferentes, permite que você selecione diferentes fotodiodos, como mostrado na tabela acima e definidos no código abaixo:

void readRGB() 
{
  red = 0;
  grn = 0;
  blu = 0;
  int n = 10;
  for (int i = 0; i < n; ++i)
  {
    //read red component
    digitalWrite(s2, LOW);
    digitalWrite(s3, LOW);
    red = red + pulseIn(outPin, LOW);

    //read green component
    digitalWrite(s2, HIGH);
    digitalWrite(s3, HIGH);
   grn = grn + pulseIn(outPin, LOW);

    //let's read blue component
    digitalWrite(s2, LOW);
    digitalWrite(s3, HIGH);
    blu = blu + pulseIn(outPin, LOW);
  }
  red = red/n;
  grn = grn/n;
  blu = blu/n;
}

Observe que no código acima,  leremos algumas vezes cada um dos componentes RGB, tomando uma média, para que com isso possamos reduzir o erro se algumas leituras forem ruins.

Uma vez de posse dos 3 componentes (RGB), deveremos definir a qual cor equivale. A maneira de fazê-lo é "calibrando-se" previamente o projeto. Você pode usar tanto papel quanto objetos com cores conhecidas e assim ler os 3 componentes gerados por este objeto.

Você pode começar com o meu set-up, mudando os parâmetros para o seu nível de luz:

void getColor()
{ 
   readRGB();
           if (red > 8 && red < 18 && grn > 9 && grn < 19 && blu > 8 && blu < 16) color = "WHITE";  
   else if (red > 80 && red < 125 && grn > 90 && grn < 125 && blu > 80 && blu < 125) color = "BLACK";  
   else if (red > 12 && red < 30 && grn > 40 && grn < 70 && blu > 33 && blu < 70) color = "RED";  
   else if (red > 50 && red < 95 && grn > 35 && grn < 70 && blu > 45 && blu < 85) color = "GREEN";  
   else if (red > 10 && red < 20 && grn > 10 && grn < 25 && blu > 20 && blu < 38) color = "YELLOW";  
   else if (red > 65 && red < 125 && grn > 65 && grn < 115 && blu > 32 && blu < 65) color = "BLUE";
   else color = "NO_COLOR";
}

Como você pode ver acima tenho predefinido 6 cores: Branco, Preto, Vermelho, Verde, Amarelo e Azul.

À medida que a luz ambiente diminui, os parâmetros tendem a aumentar de valor.

Dentro do loop (), definimos que as leituras são mostradas no LCD a cada 1 segundo.

O código completo pode ser encontrado no meu GitHub:

https://github.com/Mjrovai/Color-Detector