Detección de color Arduino

Acerca de este proyecto

Proyecto

Este es un tutorial simple, donde exploraremos cómo leer colores usando Arduino y sensores como el TCS 3200. La idea será detectar el color de un objeto y mostrarlo en una pantalla LCD. Este proyecto es un componente de un proyecto más grande que será un brazo robótico que selecciona una acción adecuada en función del color de un objeto. El diagrama de bloques anterior muestra los componentes principales.

El siguiente video muestra el trabajo final del proyecto:

Paso 1:BoM

Los enlaces a continuación y el precio son solo para referencia.

• Arduino Nano (US $ 8,00)

• Módulo de sensor de color TCS3200 (US $ 9,00)

• Módulo LCD con retroiluminación azul serie IIC / I2C / TWI 1602 (US $ 8,00)

• Tablero de pruebas (USD 2,00)

• Cables

Paso 2:el sensor de color TSC 3200

Como se describe en su hoja de datos, el TCS3200 es un convertidor de luz a frecuencia de color programable que combina fotodiodos de silicio configurables y un convertidor de corriente a frecuencia en un solo circuito integrado CMOS monolítico.

La salida es una onda cuadrada (ciclo de trabajo del 50%) con una frecuencia directamente proporcional a la intensidad de la luz (irradiancia). La frecuencia de salida de escala completa se puede escalar por uno de los tres valores preestablecidos a través de dos pines de entrada de control (S0 y S1). Las entradas y salidas digitales permiten la interfaz directa a un microcontrolador u otro circuito lógico.

La habilitación de salida (OE) coloca la salida en el estado de alta impedancia para compartir varias unidades de una línea de entrada del microcontrolador. En el TCS3200, el convertidor de luz a frecuencia lee una matriz de fotodiodos de 8 x 8.

• Dieciséis fotodiodos tienen filtros azules

• 16 fotodiodos tienen filtros verdes

• 16 fotodiodos tienen filtros rojos

• 16 fotodiodos son claros sin filtros.

Los pines S2 y S3 se utilizan para seleccionar qué grupo de fotodiodos (rojo, verde, azul, transparente) están activos. Los fotodiodos tienen un tamaño de 110 μm x 110 μm y están en centros de 134 μm.

El OE (Activado) debe estar conectado a GND (BAJO).

El sensor está encapsulado y debe alimentarse entre 2,7 y 5,5 V CC. Usaremos la salida Arduino de 5V para alimentar el sensor. Para utilizar correctamente el sensor, instalaremos un pequeño anillo de goma para aislar el sensor de la luz lateral. Usé pegamento caliente para arreglarlo.

Paso 3:Conexión del HW

Conecte el sensor TSC3200 como se muestra a continuación:

• S0 ==> Nano pin D4

• S1 ==> Nano pin D5

• S2 ==> Nano pin D6

• S3 ==> Nano pin D7

• OUT ==> Nano Pin D8

• ES ==> GND

• VCC ==> + 5V

• GND ==> GND

Conecte la pantalla serie I2C LCD 2/16:

• SDA ==> Nano Pin A4

• SCL ==> Nano Pin A5

Instale el Arduino Nano en el BreadBoard. Conecte la salida Nano 5V y GND en ambos rieles de alimentación.

Paso 4:el código Arduino

Lo primero que hay que definir es la escala de frecuencia como se define en la tabla que se muestra arriba. Los pines S0 y S1 se utilizan para eso. Escalar la frecuencia de salida es útil para optimizar las lecturas del sensor para varios contadores de frecuencia o microcontroladores. Configuraremos S0 y S1, ambos en ALTO (100%):

  digitalWrite (s0, HIGH); escritura digital (s1, ALTA);  

Lo siguiente que debe hacer es seleccionar el color que leerá el fotodiodo (rojo, verde o azul), usamos los pines de control S2 y S3 para eso. Como los fotodiodos están conectados en paralelo, configurar S2 y S3 LOW y HIGH en diferentes combinaciones le permite seleccionar diferentes fotodiodos, como se muestra en la tabla anterior.

  digitalWrite (s2, LOW); digitalWrite (s3, BAJO); rojo =pulseIn (outPin, LOW); // Lectura del componente ROJO del color digitalWrite (s2, HIGH); escritura digital (s3, ALTA); grn =pulseIn (outPin, LOW); // Lectura del componente VERDE del color digitalWrite (s2, LOW); escritura digital (s3, ALTA); blu =pulseIn (outPin, LOW); // Leyendo el componente AZUL del color  

En el código final, leeremos unas cuantas veces cada uno de los componentes RGB y tomaremos un promedio, así podremos reducir el error si alguna de las lecturas es mala.

Una vez que tenemos los 3 componentes (RGB), debemos definir de qué color es ese. La forma de hacerlo para calibrar previamente el proyecto. Puede utilizar un objeto o papel de prueba de color conocido y leer los 3 componentes generados.

Puedes comenzar con el mío, cambiando los parámetros para tu nivel de luz:

  void getColor () {readRGB (); if (rojo> 8 &&rojo <18 &&grn> 9 &&grn <19 &&blu> 8 &&blu <16) color ="BLANCO"; si no (rojo> 80 &&rojo <125 &&grn> 90 &&grn <125 &&blu> 80 &&blu <125) color ="NEGRO"; más si (rojo> 12 &&rojo <30 &&grn> 40 &&grn <70 &&blu> 33 &&blu <70) color ="RED"; más si (rojo> 50 &&rojo <95 &&grn> 35 &&grn <70 &&blu> 45 &&blu <85) color ="VERDE"; más si (rojo> 10 &&rojo <20 &&grn> 10 &&grn <25 &&blu> 20 &&blu <38) color ="AMARILLO"; más si (rojo> 65 &&rojo <125 &&grn> 65 &&grn <115 &&blu> 32 &&blu <65) color ="AZUL"; else color ="NO_COLOR";}  

Como puede ver arriba, he predefinido 6 colores:blanco, negro, rojo, verde, amarillo y azul. A medida que disminuye la luz ambiental, los parámetros tienden a aumentar.

Dentro del bucle (), defino las lecturas de la pantalla en la pantalla LCD cada 1 segundo.

El código completo se puede encontrar en mi GitHub.

Paso 5:Conclusión

Como siempre, espero que este proyecto pueda ayudar a otros a encontrar su camino en el apasionante mundo de la electrónica, la robótica y la IoT.

Visite mi GitHub para obtener archivos actualizados:Detector de color

Para más proyectos, visite mi blog:MJRoBot.org

¡Saludos desde el sur del mundo!

¡Nos vemos en mi próximo tutorial!

Gracias,

Marcelo

 digitalWrite (s2, BAJO); digitalWrite (s3, BAJO); rojo =pulseIn (outPin, LOW); // Lectura del componente ROJO del color digitalWrite (s2, HIGH); escritura digital (s3, ALTA); grn =pulseIn (outPin, LOW); // Lectura del componente VERDE del color digitalWrite (s2, LOW); escritura digital (s3, ALTA); blu =pulseIn (outPin, LOW); // Leyendo el componente AZUL del color 

 void getColor () {readRGB (); if (rojo> 8 &&rojo <18 &&grn> 9 &&grn <19 &&blu> 8 &&blu <16) color ="BLANCO"; si no (rojo> 80 &&rojo <125 &&grn> 90 &&grn <125 &&blu> 80 &&blu <125) color ="NEGRO"; más si (rojo> 12 &&rojo <30 &&grn> 40 &&grn <70 &&blu> 33 &&blu <70) color ="RED"; más si (rojo> 50 &&rojo <95 &&grn> 35 &&grn <70 &&blu> 45 &&blu <85) color ="VERDE"; más si (rojo> 10 &&rojo <20 &&grn> 10 &&grn <25 &&blu> 20 &&blu <38) color ="AMARILLO"; más si (rojo> 65 &&rojo <125 &&grn> 65 &&grn <115 &&blu> 32 &&blu <65) color ="AZUL"; else color ="NO_COLOR";}