POST_46

/*  TITULO: Camaleón con sensor de reconocimiento del color TCS3200 y LEDS Neopixels.

    AUTOR:

    MARIANO DEL CAMPO GARCÍA (@2016) --> INGENIERO TÉCNICO INDUSTRIAL ESPECIALIDAD ELECTRÓNICA
    - FACEBOOK: https://www.facebook.com/mariano.delcampogarcia
    - TWITTER: https://twitter.com/MarianoCampoGa
    - CORREO: marianodc83@gmail.com


    DESCRIPCIÓN DEL PROGRAMA

    Con este programa simulamos el cambio de color de la piel de un camaleón cuando este se vé en
    una situación de peligro. Mediante un sensor de reconocimiento del color TCS3200 captamos el
    color en cuestión y lo presentamos a través de un disco de 7 LEDS NeoPixel. A través del
    monitor serie del IDE de Arduino podremos ver el color en formato RGB que se está manipulando
    en cada momento.


    ESQUEMA DE CONEXION

                                      +-----+
         +----[PWR]-------------------| USB |--+
         |                            +-----+  |
         |         GND/RST2  [ ][ ]            |
         |       MOSI2/SCK2  [ ][ ]  A5/SCL[ ] |
         |          5V/MISO2 [ ][ ]  A4/SDA[ ] |
         |                             AREF[ ] |
         |                              GND[ ] |
         | [ ]N/C                    SCK/13[ ] |
         | [ ]IOREF                 MISO/12[ ] |
         | [ ]RST                   MOSI/11[ ]~|  Pin S3 del sensor de color TCS3200
         | [ ]3V3    +---+               10[ ]~|  Pin S2 del sensor de color TCS3200
         | [ ]5v    -| A |-               9[ ]~|  Pin S1 del sensor de color TCS3200
         | [ ]GND   -| R |-               8[ ] |  Pin S0 del sensor de color TCS3200
         | [ ]GND   -| D |-                    |
         | [ ]Vin   -| U |-               7[ ] |
         |          -| I |-               6[ ]~|  Pin IN del disco de 7 LEDS NeoPixel
         | [ ]A0    -| N |-               5[ ]~|
         | [ ]A1    -| O |-               4[ ] |
         | [ ]A2     +---+           INT1/3[ ]~|
         | [ ]A3                     INT0/2[ ] |  Pin OUT del sensor de color TCS3200
         | [ ]A4/SDA  RST SCK MISO     TX>1[ ] |
         | [ ]A5/SCL  [ ] [ ] [ ]      RX<0[ ] |
         |            [ ] [ ] [ ]              |
         |  UNO_R3    GND MOSI 5V  ____________/
          \_______________________/

  NOTAS:

   - Alimentación del sensor de reconocimiento del color TCS3200:
     - VCC --> +5V de Arduino // GND --> GND de Arduino.
     - Pin OE del sensor de reconocimiento del color TCS3200 --> GND de Arduino
   - Alimentación del disco de 7 LEDS NeoPixel:
     - VCC --> +5V de Arduino // GND --> GND de Arduino.
*/

  // Incluimos librerías
  #include <Adafruit_NeoPixel.h>
  #include <Metro.h>
  #include <math.h>

  // Pin digital (PWM) donde conecto la entrada del Módulo NeoPixel de 7 LEDS
  #define PIN            6
  // Número de NeoPixels del disco conectados a Arduino
  #define NUMEROPIXELS      7

  // Objetos de tipo Metro que activan intervalos de 60, 50 y 10 ms respectivamente
  // Cuando se alcanza el tiempo ajustado se activan a nivel alto.
  Metro encender = Metro(60);
  Metro procesar = Metro(50);
  Metro adquirir = Metro(10);

  // Objeto de tipo Adafruit_NeoPixel
  Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMEROPIXELS, PIN, NEO_GRB + NEO_KHZ800);

  // Variables internas del programa
  int S0 = 8, S1 = 9, S2 = 10, S3 = 11; // Pines digitales para el sensor de color
  int OUT = 2; // Pin digital para el pin OUT del sensor de reconocimiento del color
  int bandera = 0;
  int contador = 0;
  int i = 0;
  int contador_R = 0, contador_G = 0, contador_B = 0;
  int promedio_R = 0, promedio_G = 0, promedio_B = 0;
  int valor_R = 0, valor_G = 0, valor_B = 0;
  static int entrada_R[5] ={0,0,0,0,0}, entrada_G[5] ={0,0,0,0,0}, entrada_B[5] ={0,0,0,0,0};

  void setup()
  {
    pixels.begin(); // Inicializa los LED NeoPixel
    Serial.begin(115200); // Comienzo de la comunicación serie
    // Pines digitales como salida
    pinMode(S0,OUTPUT);
    pinMode(S1,OUTPUT);
    pinMode(S2,OUTPUT);
    pinMode(S3,OUTPUT);
  }

  // Función de configuración de frecuencia e interrupción.
  void configuracion()
  {
    // Frecuencia de salida al 100%
    digitalWrite(S0,HIGH);
    digitalWrite(S1,HIGH);
    // Llamada a la interrupción INT 0 (Pin digital 2 --> OUT)
    attachInterrupt(0, ISR_INTO, CHANGE);
  }

  // Función de servicio de la rutina de la interrupción
  void ISR_INTO()
  {
    contador++;
  }


  void loop()
  {
    // Llamada a la función de configuración
    configuracion();
    // Si han transcurrido 10 ms
    if(adquirir.check())
    {
      // Llamada a la función de adquisición de datos
      adquisicion_datos();
    }
    // Si han transcurrido 50 ms
    if(procesar.check())
    {
      // Llamada a la función de procesamiento de datos
      procesamiento_datos();
    }
    // Si han transcurrido 60 ms
    if(encender.check())
    {
      // Llamada a la función que muestra los datos
      encendido_LEDS();
    }
  }

  // Función para adquirir los datos
  void adquisicion_datos()
  {
    bandera++;
    if(bandera == 1)
    {
      // Filtro Rojo activado
      digitalWrite(S2,LOW);
      digitalWrite(S3,LOW);
      contador_R = contador;
      // Filtro Verde activado
      digitalWrite(S2,HIGH);
      digitalWrite(S3,HIGH);
    }
    else if(bandera == 2)
    {
      contador_G = contador;
      // Filtro Azul activado
      digitalWrite(S2,LOW);
      digitalWrite(S3,HIGH);
    }
    else if(bandera == 3)
    {
      contador_B = contador;
      // Filtro Rojo activado
      digitalWrite(S2,LOW);
      digitalWrite(S3,LOW);
      bandera = 0;
    }
    contador = 0;
  }

  // Función que procesa los datos
  void  procesamiento_datos()
  {
    for(i = 4; i > 0; i--)
    {
      entrada_R[i] = entrada_R[i-1];
      entrada_G[i] = entrada_G[i-1];
      entrada_B[i] = entrada_B[i-1];
    }

    if(contador_R < 2500)
      entrada_R[0] = contador_R;
    else
      entrada_R[0] = entrada_R[1];

    if(contador_G < 2500)
      entrada_G[0] = contador_G;
    else
      entrada_G[0] = entrada_G[1];

    if(contador_B < 2500)
      entrada_B[0] = contador_B;
    else
      entrada_B[0] = entrada_B[1];

    promedio_R = 0;
    promedio_G = 0;
    promedio_B = 0;

    for(i = 0; i <= 4; i++)
    {
      promedio_R += entrada_R[i];
      promedio_G += entrada_G[i];
      promedio_B += entrada_B[i];
    }

    // Media de los valores RGB
    promedio_R /= 5;
    promedio_G /= 5;
    promedio_B /= 5;
  }

  // Función que enciende los LEDS con el color adquirido
  void  encendido_LEDS()
  {
    // Igualamos a la media de los valores RGB
    valor_R = promedio_R;
    valor_G = promedio_G;
    valor_B = promedio_B;

    // Restringimos los valores RGB
    valor_R = constrain(valor_R,350,1700);
    valor_G = constrain(valor_G,350,1650);
    valor_B = constrain(valor_B,350,1500);

    // Mapeamos los valores RGB
    valor_R = map(valor_R,350,1700,0,255);
    valor_G = map(valor_G,350,1650,0,255);
    valor_B = map(valor_B,350,1500,0,255);

    // Presentamos los valores RGB a través del monitor serie
    Serial.print("R:");
    Serial.print(valor_R,DEC);
    Serial.print(" ");
    Serial.print("G:");
    Serial.print(valor_G,DEC);
    Serial.print(" ");
    Serial.print("B:");
    Serial.println(valor_B,DEC);

    // Enviamos los valores RGB a cada uno de los 7 LEDS NeoPixel
    for(i=0; i<NUMEROPIXELS; i++)
    {
      pixels.setPixelColor(i, pixels.Color(valor_R,valor_G,valor_B));
      pixels.show(); // Actualiza el estado de los LEDS NeoPixel
    }
  }