KIT - Arduino MEGA 2560

4 Montagens Prticas --------------------------------------------------------xx

4 Montagens Prticas

4.1 Imprimindo uma mensagem no LCD

Componentes: 1 LCD, 1 potencimetro de 10 k

Neste exemplo ser mostrado como conectar corretamente

um LCD ao Arduino, alm de imprimir o famoso _Hello World!_ na
tela do LCD atravs da funo lcd.print(), contida na biblioteca
LiquidCrystal.h.

A.10 LCD 16x2

O Display de Cristal Lquido (Liquid Cristal Display) um dispositivo
utilizado para mostrar informaes na forma de texto (Figura 35).
Um modelo muito utilizado o que apresenta 2 linhas
e 16 colunas, onde pode-se representar at de 32 caracteres.

Figura 35: Descrio de cada pino de um LCD 16x2 5V

Resistncia: Alm da necessidade de um potencimetro 10 K,
utilizado para controlar o contraste dos caracteres que so
mostrados na tela do LCD, recomendvel adicionar uma
resistncia de 200 no pino 15 para limitar a corrente no LED da
iluminao de fundo.

Figura xx: Pinagem de um LCD

Tabela 7: Funcionalidade de cada pino de um LCD

Para conectar o LCD ao Arduino, conectar os seguintes pinos:

. pino VSS(1) do LCD ao pino GND

. pino VDD(2) do LCD ao pino 5V

. pino RS(4) do LCD ao pino 12

. pino RW(5) do LCD ao pino GND

. pino Enable(6) do LCD ao pino 11

. pino D4(11) do LCD ao pino 5

. pino D5(12) do LCD ao pino 4
. pino D6(13) do LCD ao pino 3
. pino D7(14) do LCD ao pino 2

Deve-se conectar tambm o potencimetro de 10K Ohms aos pinos

5V, GND e V0(3) do LCD, conforme sugere as Figuras 4 e 5:
 Figura 4: Montagem do Circuito

Figura 5: Esquemtico Eletrnico

Cdigo fonte

#include <LiquidCrystal.h> //Carrega biblioteca LiquidCrystal

// Pinagem do LCD (RS,EN,DB4,DB5,DB6,DB7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//void setup executado uma vez no inicio .
void setup() {
lcd.begin(16, 2);
lcd.print("Hello World!");
}
//void loop executado contnuamente .
void loop() {
lcd.setCursor(0, 1);
lcd.print(millis()/1000); //Mostra uma contagem em segundos
lcd.print("s"); //Mostra a letra s
4.1.1 Interagindo com o LCD

Aprendendo a posicionar o incio da mensagem nas colunas e

linhas do LCD e tambm a fazer uma mensagem se deslocar no
display.

#include <LiquidCrystal.h>//Carrega biblioteca LiquidCrystal

// Pinagem do LCD (RS,EN,DB4,DB5,DB6,DB7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
lcd.begin(16, 2); //Define o nmero de colunas e linhas do
LCD:

}
void loop(){
int i; //Define a varivel i
{
lcd.setCursor(0,0); //(Coluna,Linha)
lcd.print("hello WORD");//Escreve hello WORD
lcd.setCursor(0,1);
print("ou ALO MUNDO");
delay(1500); // Espera
lcd.clear();//Limpa o display do LCD

lcd.print("UNIVILLE");
delay(1500);
lcd.clear();

lcd.print("AUTI");
lcd.setCursor(0,1);
lcd.print("ENGENHARIA");
delay(1500);
lcd.clear();

lcd.print("EXEMPLO");
delay(1500);
lcd.clear();
}
for(i=0; i<16; i++)//(Faz a escrita iniciar na Coluna 0 ,depois na
coluna 1, depois na 2 at a 16 criando o efeito de rolagem da
mensagem)
 {
lcd.setCursor(i,1);
lcd.print("Rolagem Texto ");
delay(750);
lcd.setCursor(i,1);
lcd.print(" ");
}
}

4.2.0 Alterando a frequncia com que o LED pisca

Componentes: 1 Potnciometro de 10 k, 1 LED,1 resistor de 330

Ohms.

Este projeto muito simples e tratar da utilizao do

potencimetro, que um componente que possui resistncia
eltrica ajustvel. A frequncia com que o LED pisca vai depender
diretamente do ajuste do potencimetro.

Sugesto de montagem
Conecte um potencimetro na porta 0 e um LED na porta 13, com
um resistor de 330 Ohms, como mostra as Figuras 6 e 7.

Figura 6: Montagem do Circuito

 Figura 7: Esquemtico Eletrnico

Cdigo-fonte

int potPin = 0; //Inicializa a vaivel potPin com o valor zero

int ledPin = 8; //Atribui ao pino 8 a varivel ledPin
int val = 0; //Inicializa a vaivel val com o valor zero

void setup() {
pinMode(ledPin, OUTPUT); //Inicializa a vaivel ledPin
como uma sada digital.
}

void loop() {
val = analogRead(potPin); //Carrega em val o valor da
atual da entrada analgica
digitalWrite(ledPin, HIGH);
 delay(val);
digitalWrite(ledPin, LOW);
delay(val);
}

4.2.1 Alterando a frequncia com que o LED pisca e mostrando os

valores da entrada analgica no display e o Valor da resistncia
naquela posio.

//Leitura da entrada Analgica mostrando o valor lido

#include <LiquidCrystal.h> //Carrega biblioteca LiquidCrystal

// Pinagem do LCD (RS,EN,DB4,DB5,DB6,DB7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int potPin = 0; //A varivel potPin definida como tipo int e
//atribuda ao pino 0
int ledPin = 8; // A varivel ledPin definida como tipo int e
//atribuda ao pino 8
int val = 0; // A varivel val definida como tipo int e zerada
float resistencia = 0; // A varivel resistencia definida como tipo
//float e zerada

void setup() {
Serial.begin(9600); //Inicializa a comunicao serial com o PC
lcd.begin(16, 2); //Define o numero de linhas e colunas do LCD
pinMode(ledPin, OUTPUT);
}

void loop() {
val = analogRead(potPin); //Carrega na varivel val o valor de
//entrada analgica
resistencia = val*9.775; //Carrega na varivel resistncia o clculo
//do valor da resistencia
digitalWrite(ledPin, HIGH); //Liga o Led
delay(val);
digitalWrite(ledPin, LOW); //Desliga o Led
delay(val);
Serial.println(val); //Envia o valor da varivel val pela porta serial
Serial.println(resistencia); //Envia o valor da varivel resistncia
//pela porta serial

lcd.clear();//Apaga os valores anteriores escritos no display

lcd.setCursor(0,0);
lcd.print("Analogica=");
lcd.setCursor(11,0);
lcd.print(val); //Escreve o valor da varivel val no LCD
lcd.setCursor(0,1);
lcd.print("R=");
lcd.setCursor(3,1);
lcd.print(resistencia); //Escreve o valor da varivel resistencia no
//LCD
lcd.setCursor(12,1);
lcd.print("Ohms.");

}
Lendo tempertaturas com LM35 no Arduino

Primeiro vamos conehecer o LM35

Olhando de frente para a escrita do CI, ou a parte

plana dele, temos os 3 pinos, da esquerda para
direita:

1 - Alimentao (Entre 2.7 e 5.5 volts)

2 - Sada analgica (Valor analgico a ser lido)
3 GND Terra (0v)
No mdulo olhando de frente utilizado da esquerda para a direita:
1-GND Terra ; 2 -+Vss ;3-Vout.

O sensor LM 35 mede temperaturas de 2C a +150C de acordo

com a ligao da figura 1. Isso em tenso representa 20mv a 1,5V,
ento usando a referencia padro das portas analgicas do Arduino
que 5V (5/1024 = 4,88mv) ento temos um sensibilidade de
4,15mv que d coisa de 0,41C de erro, sem contar as variaes
bruscas do sensor.

Para no ocorre este erro ento vamos mudar essa referencia.

Usando:

INTERNAL1V1 : a built-in 1.1V referncia ( S no Arduino mega)

AnalogReference(INTERNAL1V1); // Referencia de 1.1V UNO

(1.1/1024 = 0,913mv) 0,913mv de preciso ou seja 0,099C

Para um resultado melhor evitando a variao brusca de leitura do

sensor devemos tirar uma media de leituras.

#include <LiquidCrystal.h> //Carrega biblioteca LiquidCrystal

// Pinagem do LCD (RS,EN,DB4,DB5,DB6,DB7)
LiquidCrystal lcd(12,11,5,4,3,2);
const int sensor=2;
float temperatura;
void setup()
{
lcd.begin(16,2); //Define o numero de linhas e colunas do LCD
analogReference(INTERNAL1V1); // Referencia de 1.1V UNO
(1.1/1024=0,913mv) 0,913mv de preciso ou seja
0,09C( INTERNAL1V1 Arduino Mega)
}
void loop()
{
temperatura=0;
for(int i=0;i<800;i++)
{
temperatura=temperatura+analogRead(sensor);
}
temperatura=temperatura/800; //Media de oitocentas leituras
 temperatura=temperatura*(1.1/1024);//Converte valor lido para
tenso
temperatura=temperatura*100;//Converte para Graus =
temperatura/(1/10mv)

lcd.clear(); //Limpa o display

lcd.setCursor(0,0);
lcd.print("Temp: ");
lcd.print(temperatura);
lcd.print(" C");
}
Sensor de umidade e temperatura DHT11

O sensor DHT11 possui um sensor complexo de temperatura e

humidade, com uma sada de sinal digital. Usa uma tecnologia
sensorial de aquisio de sinal digital para temperatura e
humidade, que assegura uma fiabilidade e estabilidade a longo
prazo.
A sua atuao permite medir temperaturas de 0 a 50 Celsius, e
humidade na faixa de 20 a 90%. No um sensor extremamente
rpido e preciso, por isso no recomendada a sua utilizao em
ambientes de alto risco. Sua faixa de preciso para temperatura
de 2 graus, e de humidade, 5%.
O datasheet do DHT11 encontrado em :
http://robocraft.ru/files/datasheet/DHT11.pdf

A Figura abaixo mostra o sensor DHT11, evidenciando os trs pinos

para ligao.:

Este sensor inclui um elemento sensorial de humidade tipo resistivo

e um do tipo NTC que faz a medio da temperatura, associado a
um microcontrolador rpido de 8 bits. Este conjunto permite uma
resposta relativamente rpida, com alguma imunidade a
interferncias e com uma boa relao custo-benefcio.

A interface srie de um nico fio torna a sua integrao, muito

rpida e fcil. O seu tamanho reduzido, o baixo consumo de energia
e a transmisso do sinal a mais de 20 metros apresentam-no como
a melhor escolha para vrias aplicaes.
Comunicao Srie
a interface srial de dados atravs de um nico fio usada para
comunicao e sincronizao entre o micro controlador e o sensor
DHT11.

Este processo de comunicao feito em de 4ms, como se

ilustrado na Figura abaixo; inicia-se quando o microcontrolador
envia o sinal de incio start signal para o sensor, alterando o
estado da linha para o modo de funcionamento.

O microcontrolador fica ento aguardando a resposta do sensor.

Este envia ao microcontrolador uma resposta com 40 bits de dados,
que incluem o valor da humidade relativa (HR) (8 bits na parte
inteira e 8 bits parte decimal) e da temperatura (8 bits na parte
inteira e 8 bits na parte decimal). Faz ainda parte da resposta 8 bits
de verificao (check sum). Uma vez concludo este procedimento o
dispositivo ir colocar a linha em modo latente (low-power-
consumption mode) at que se verifique novo pedido por parte do
microcontrolador.
4.3 Um programa que l as informaes do sensor DHT11 que so
Humidade e temperatura, e apresenta estas informaes no
monitor serial do Arduino.

Necessrio o uso da biblioteca do sensor DHT11 encontrada em:

http://hobbyist.co.nz/sites/default/files/WeatherStation/DHT.zip
4.4 Leitura de teclas atravs de entradas digitais e acionamento
sequencial de sadas digitais que acionam leds.
X
Exemplo 4.5 Controle de servomotor

Este exemplo ilustra o uso de uma das sadas PWM (Pulse-Width

Modulation - Modulaco por Largura de Pulso) do Arduino com um
servomotor.

Qualquer servo com um terminal de controle compatvel pode ser

utilizado. Aqui usaremos um rotor polar do tipo usado em antenas
parablicas. Primeiramente importante saber o que PWM e o
que possvel fazer.

PWM um mecanismo que permite controlar o perodo cclico da

frequncia da alimentao.

Suas aplicaes so diversas e abrangem tanto usos

industriais quanto domsticos. Em indstrias, o PWM pode ser
usado para controlar elevadores de carga, esteiras rolantes e
guinchos.
J em aplicaes domsticas, pode ser usado para controle de
iluminao, portes e cortinas.
Iremos utilizar a entrada manual comandada por um
potencimetro linear de 10k .
O motor possui 3 fios: um vermelho, um preto e um branco. Os
fios preto e vermelho correspondem ao negativo e positivo da
alimentao, respectivamente, e neste exemplo podemos
conect-los diretamente aos pinos de alimentao do Arduino.
O vermelho conectado ao pino 5 V, e o preto a qualquer um
dos pinos GND. O fio branco o terminal de controle, e deve
ser conectado a uma das sadas digitais com PWM, qualquer
um dos pinos 3, 5, 6, 9, 10 ou 11.
No exemplo usaremos o 10. O potencimetro linear de 10 k
conectado tendo um dos seus pinos extremos ligado ao GND,
o outro extremo ao pino AREF, que fornece a tenso de
referncia, e o pino central conectado a qualquer uma das
entradas analgicas, utilizaremos o pino 0.

Desta vez usaremos uma biblioteca para suporte de servos,

logo no incio do programa deveremos import-la. Deveremos
criar um objeto do tipo servo que ser utilizado para controle,
da seguinte maneira:
#include <Servo.h>
Servo meuservo;

A seguir, feita a parte de declarao de variveis. Iremos

declarar um pino para o potencimetro e servo, e uma varivel
inteira para o valor lido do potencimetro. Tambm deveremos
iniciar o servo, que em nosso caso est conectado ao pino 10,
como vemos a seguir:

int potpin = 0; //Inicializa a vaivel potPin com o valor zero

int val;
void setup() {
meuservo.attach(10);
}

Quando lermos a entrada do potencimetro, teremos que

converter seu valor para graus para podermos controlar em
graus quanto o motor ir girar, para isto utilizaremos a funo
map().

Aps isto apenas devemos enviar a informao para o motor e

esperar alguns milissegundos para a movimentao do motor.

void loop() {
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 180);
meuservo.write(val);
delay(500);
}
#include <Servo.h>
Servo meuservo;
int potpin = 0; //Inicializa a vaivel potPin com o valor zero

int val;

void setup() {
meuservo.attach(10);
}
void loop() {
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 180);
meuservo.write(val);
delay(500);
}
Sensor de reconhecimento de cor TCS230 / TCS3200
O artigo de hoje fala sobre como utilizar o Arduino para montar um sistema de
reconhecimento de cores usando o mdulo TCS230 / TCS3200.

Esse mdulo usa o sensor TCS230 (datasheet), que composto por 64 fotodiodos. Desses 64
fotodiodos, 16 tem filtros para a cor vermelha, 16 para a cor verde, 16 para a cor azul e 16 no
tem filtro algum.

Distribudos uniformemente sobre o sensor, esses sensores captam a luminosidade, filtrando

as cores, e geram na sada um sinal de onda quadrada com as informaes sobre a intensidade
das cores vermelho (R = Red), verde (G = Green) e Azul (B = Blue).

Como no mdulo mostrado acima, o sensor TCS230 geralmente vem montado em conjunto
com quatro leds brancos para iluminao, e oito pinos para conexo.

O mdulo aceita alimentao de 3 5 volts e so utilizados 5 pinos para conexo ao Arduino :

os pinos de controle S0, S1, S2, S3, e o pino OUT, que o responsvel pelo envio das
informaes.

O pino OE (Output Enable, ou sada habilitada/ativada) deve ser ligado ao GND, j que o
mdulo vai enviar informaes continuamente ao Arduino.
No circuito adicionei 3 leds nas cores correspondentes, para que acendam quando
determinada cor for reconhecida pelo sensor. Apesar de trabalhar nesse experimento apenas
com as 3 cores primrias, nada impede que outras combinaes sejam usadas no programa, de
acordo com os nveis do sinal RGB.

No programa, os pinos S0 e S1 so colocados em nvel alto e ento so alternados os estados

dos pinos S2 e S3, que determinam qual fotodiodo ser ativado. Veja na tabela abaixo as
combinaes que determinam o tipo de frequncia de sada e tambm o padro de ativao
dos fotodiodos :

1 // Programa : Detector de cores usando modulo TCS230

2 // Alteracoes e comentarios : Arduino e Cia
3 //
4 // Baseado no programa original de Martin Mason
5
 6 //Pinos de conexao do modulo TCS230
7 const int s0 = 8;
8 const int s1 = 9;
9 const int s2 = 12;
10 const int s3 = 11;
11 const int out = 10;
12
13 //Pinos dos leds
14 int pinoledverm = 2;
15 int pinoledverd = 3;
16 int pinoledazul = 4;
17
18 //Variaveis que armazenam o valor das cores
19 int red = 0;
20 int green = 0;
21 int blue = 0;
22
23 void setup()
24 {
25 pinMode(s0, OUTPUT);
26 pinMode(s1, OUTPUT);
27 pinMode(s2, OUTPUT);
28 pinMode(s3, OUTPUT);
29 pinMode(out, INPUT);
30 pinMode(pinoledverm, OUTPUT);
31 pinMode(pinoledverd, OUTPUT);
32 pinMode(pinoledazul, OUTPUT);
33 Serial.begin(9600);
34 digitalWrite(s0, HIGH);
35 digitalWrite(s1, HIGH);
36 }
37
38 void loop()
39 {
40 color(); //Chama a rotina que le as cores
41 //Mostra no serial monitor os valores detectados
42 Serial.print("Vermelho :");
43 Serial.print(red, DEC);
44 Serial.print(" Verde : ");
45 Serial.print(green, DEC);
46 Serial.print(" Azul : ");
47 Serial.print(blue, DEC);
48 Serial.println();
49
50 //Verifica se a cor vermelha foi detectada
51 if (red < blue && red < green && red > 50)
52 {
53 Serial.println("Vermelho");
54 digitalWrite(pinoledverm, HIGH); //Acende o led vermelho
55 digitalWrite(pinoledverd, LOW);
56 digitalWrite(pinoledazul, LOW);
57 }
58
59 //Verifica se a cor azul foi detectada
60 else if (blue < red && blue < green)
61 {
62 Serial.println("Azul");
63 digitalWrite(pinoledverm, LOW);
64 digitalWrite(pinoledverd, LOW);
65 digitalWrite(pinoledazul, HIGH); //Acende o led azul
66 }
67
68 //Verifica se a cor verde foi detectada
69 else if (green < red && green < blue)
70 {
71 Serial.println("Verde");
72 digitalWrite(pinoledverm, LOW);
73 digitalWrite(pinoledverd, HIGH); //Acende o led verde
74 digitalWrite(pinoledazul, LOW);
75 }
76 Serial.println();
77
78 //Aguarda 2 segundos, apaga os leds e reinicia o processo
79 delay(2000);
80 digitalWrite(pinoledverm, LOW);
81 digitalWrite(pinoledverd, LOW);
82 digitalWrite(pinoledazul, LOW);
83 }
84
85 void color()
86 {
87 //Rotina que le o valor das cores
88 digitalWrite(s2, LOW);
89 digitalWrite(s3, LOW);
90 //count OUT, pRed, RED
91 red = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
92 digitalWrite(s3, HIGH);
93 //count OUT, pBLUE, BLUE
94 blue = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
95 digitalWrite(s2, HIGH);
96 //count OUT, pGreen, GREEN
97 green = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
98 }

Carregue o programa e aproxime objetos de diferentes cores ao sensor. O led correspondente

ir acender, e tambm gerada uma sada como essa no serial monitor, onde voc pode ver
exatamente os nveis de sinal das cores detectadas :
Em breve um vdeo demonstrando a utilizao deste programa. At l !

Biblioteca no Arduino para o Sensor de Cor TCS320 e

TCS3200
16/10/2014 Jter Silveira 2 Comments
Sensor de Cor TCS230/TCS3200 em uma breakout board

O sensor de reconhecimento de cor TCS230/3200 da AMS (antiga TAOS) possui um

conjunto de 64 fotodiodos para deteco de cores: 16 com filtro para a frequencia de cor
vermelha (Red), 16 com filtro para a frequencia de cor verde (Green), 16 com filtro para
a frequencia de cor azul (Blue), e ainda 16 fotodiodos sem filtro de cores. Esse conjunto
de fotodiodos permite ao circuito integrado fazer o que chama de transformao de luz-
para-frequncia (light-to-frequency). O que acontece o seguinte: a sada do sensor
um pulso de 50% de duty cycle (isso significa que um pulso quadrado perfeito, ou
seja, metade do tempo em nvel lgico alto e metade em nvel lgico baixo), que varia a
frequncia conforme a intensidade da luz.

O TCS230/3200 possui quatro entradas: S0, S1, S2, e S3. As duas primeiras servem
para selecionar uma escala de frequncia (2%, 20% ou 100%), ou simplesmente
desligar o sensor. As duas ltimas servem para selecionar o conjunto de fotodiodos que
voc quer o resultado: como so dois bits, teremos exatamente quatro possiblidades, que
so correspondentes aos quatro conjuntos de fotodiodos. Assim o sensor dar um
resultado com a intensidade de cada cor que ele consegue medir, e a intensidade total,
permitindo o desenvolvimento de uma aplicao que calcule o valor RGB para a cor
detectada. Veja abaixo a tabela, extrada do datasheet:

Finalmente temos uma biblioteca para lidar com esse sensor no Arduino!!! A bilioteca
MD_TCS230 est disponvel para download no GitHub e no CodePlex. Vamos a um
passo-a-passo para testar seu primeiro programinha com o sensor de cores no Arduino!!

1 passo Instalando a biblioteca MD_TCS230

Faa o download da biblioteca nesse link (aconselho utilizar este link direto para a
pgina de download no CodePlex, pois a MD_TCS230 possui uma dependencia que
est includa neste pacote zip). Depois de completar o download, abra o pacote zip com
o descompactador e extraia as pastas FreqCount e MD_TCS230 no dentro do diretrio
~/sketchbook/libraries (ou /home/[SEU_USUARIO/sketchbook/libraries ou, se usar
Windows srio que vc faz isso??? :O voc ir encontrar a pasta libraries dentro da
pasta sketchbook provavelmente no sua pasta de usurio
c:\Users\[SEU_USUARIO]\sketchbook\libraries no mudou nada, n? rs). Feche
todas as janelas da Arduino IDE (isso importante! em alguns casos s funciona se
fizer isso wtf?) e depois abra o Arduino IDE novamente. Pronto! As bibliotecas
MD_TCS230 e FreqCount esto instaladas (a FreqCount uma dependncia da
MD_TCS230).

2 passo Carregando o programa de exemplo da

biblioteca
Vamos utilizar aqui o mais simples programa de exemplo disponvel na biblioteca, que
simplesmente ir retornar no Serial Monitor as leituras realizadas em um cdigo RGB.
Se tudo deu certo no passo anterior, voc poder acessar o programa de exemplo da
MD_TCS230 atravs do menu: File -> Sketchbook -> libraries -> MD_TCS230 ->
Simple_NB_TCS230. Quando voc clicar a, carregar o seguinte cdigo:

// TCS230 sensor reading example

//
// This is just to show basic functionality without calibration.
// Utilises the non-blocking version of the reading function.
// Output uses the Serial console.
//
#include
#include

// Pin definitions
#define S2_OUT 12
#define S3_OUT 13
#define OE_OUT 8 // LOW = ENABLED

MD_TCS230 CS(S2_OUT, S3_OUT, OE_OUT);

void setup()
{
Serial.begin(57600);
Serial.println("[TCS230 Simple NON_BLOCKING Example]");
Serial.println("\nMove the sensor to different color to see the RGB
value");
Serial.println("Note: These values are being read in without sensor
calibration");
Serial.println("and are likely to be far from reality");

CS.begin();
}

void readSensor()
{
static bool waiting;

if (!waiting)
{
CS.read();
waiting = true;
}
else
{
if (CS.available())
 {
colorData rgb;

CS.getRGB(&rgb);
Serial.print("RGB [");
Serial.print(rgb.value[TCS230_RGB_R]);
Serial.print(",");
Serial.print(rgb.value[TCS230_RGB_G]);
Serial.print(",");
Serial.print(rgb.value[TCS230_RGB_B]);
Serial.println("]");

waiting = false;
}
}
}

void loop()
{
readSensor();
}

Pronto! Esse programa a voc carregar para a memria do Arduino em breve (

aconselhvel montar todo o hardware antes de carregar o programa pro Arduino, o que
faremos no prximo passo).

3 passo Montando o hardware: ligaes com o

Arduino

Arduino UNO

Nesse primeiro programa de exemplo, que bastante simples, voc precisar fazer
apenas quatro conexes alm do VCC e GND, que so a alimentao do sensor: S2, S3,
OE, e OUT. At mesmo OE (Output Enable), se quiser, voc pode simplesmente ligar o
pino OE do sensor ao GND, sem conectar no Arduino, mas aconselhvel seguir o
projeto do programa, j que estamos aprendendo e poder ser importante, no futuro,
desabilitar temporariamente a sada do sensor.
 fcil descobrir as conexes para S2, S3, e OE simplesmente verificando as linhas de
cdigo dentro do programa:

// Pin definitions
#define S2_OUT 12
#define S3_OUT 13
#define OE_OUT 8 // LOW = ENABLED

Mas e onde vou conectar OUT no Arduino?? Como que eu sei onde vou conectar a
sada do meu sensor de cores RGB no Arduino? Ento, tive um trabalho aqui, mas foi
apenas falta de ler a documentao da bilioteca. Se voc observar na descrio da
biblioteca aqui, perceber uma NOTA IMPORTANTE onde o autor da biblioteca avisa
sobre uma limitao da dependencia FreqCount, que permite a utilizao apenas de
determinados pinos para a contagem da frequencia e limita o uso de outros pinos,
conforme a tabela abaixo:

Board Input Pin Pins Unusable with analogWrite()

----------- --------- --------------------------------
Arduino Uno 5 3, 9, 10, 11
Arduino 2009 5 3, 9, 10, 11
Arduino Mega 47 9, 10, 44, 45, 46
Sanguino 1 12, 13, 14, 15

Logo, sabemos que o pino para a conexo da sada do sensor (pino OUT), o pino 5 do
Arduino. Ficam ento as conexes:

SENSOR ARDUINO UNO

------ -----------
VCC 5V
GND GND
S2 12
S3 13
OE 2
OUT 5

Uma vez terminadas as conexes, carregue o programa para dentro do Arduino e teste
seu programa! Assim que carregar o programa (voc ver ver a mensagem Done
uploading. na barra de status da Arduino IDE), pressione Ctrl+Shift+M ou v em
Tools -> Serial Monitor. Quando abrir o Serial Monitor, selecione a taxa de
transferncia de 57600 baud no canto inferior direito, seno voc apenas enxergar
caracteres malucos em sua tela rs. Aproxime uma folha branca de papel do sensor
para ver como ele marca perfeitamente: [255,255,255] no Serial Monitor. Outras cores
ficaro aproximadas, o preto bastante difcil de detectar. Cores mais claras so mais
fceis por terem uma SATURAO maior e tambm maior INTENSIDADE de luz,
permitindo assim que o software tenha mais informaes com que trabalhar. Deixe seu
comentrio e at a prxima!!
https://automacaoifrsrg.wordpress.com/2013/10/02/ensaio-
utilizando-o-sensor-de-cor-rgb-modelo-tcs230/

Ensaio Utilizando o Sensor de Cor RGB Modelo TCS230

Publicado em 2 de outubro de 2013 por gadefran

Sensores de Cor

Os sensores de cor so dispositivos capazes de detectar e medir uma variedade de

cores de acordo com uma escala definida que varia de um sensor para outro. Os
sensores que trabalham no modo RGB (red, green, blue) so constitudos de quatro
fototransistores, sendo que trs deles so dotados de um filtro para cada uma das cores
vermelho, verde e azul.

Funcionamento dos Sensores de Cor RGB

Esse sensor opera a partir da incidncia de luz na base do transistor que compe o
dispositivo. Assim, o transistor passa a conduzir corrente de acordo com a cor que est
sobre ele. Os filtros permitem que apenas a cor incidida passe a excitar a base do
fototransistor. Logo, o que no possui o filtro, torna-se sensvel a qualquer luz que
incida sobre ele. Sendo assim, h a possibilidade de escolher outros filtros para que, a
partir das combinaes dos pinos, o sensor passe a detectar outros tons de cores partindo
dos que j esto definidos, sendo possvel, por exemplo, fazer a leitura da cor amarela.

Experimento

Agora sero mostrados os componentes necessrios para realizar um experimento com a

finalidade de detectar e medir o tom das cores primrias:

1 sensor de cor RGB modelo TCS230

 1 Placa protoboard
1 microcontrolador Arduino
Fios para conexo entre componentes

Calibrao

Para auxiliar a leitura das cores do sensor, necessrio inicialmente, realizar a

calibrao do mesmo com a incidncia da cor branca. Dessa forma, somente depois
desse procedimento que se deve iniciar os testes com a incidncia das demais cores
trabalhadas. Ao fazer a leitura da cor branca obtemos valores mximos para todas as
tonalidades, devido ao fato do branco ser a soma de todas cores. Logo, para a cor preta,
os valores obtidos sero mnimos, pois o preto a ausncia de cor.

Programao

Para a realizao deste ensaio, foi inserida uma biblioteca especfica na programao,
chamada TimerOne. Essa biblioteca responsvel por auxiliar os parmetros exigidos
pelo sensor de cor, e assim, o seu respectivo funcionamento.

1 #include <TimerOne.h> // Inclui a biblioteca TimerOne referente ao

Sensor de Cor.
2

3
#define S0 6 // Informa que a saida S0 do sensor sera conectada
4 ao pino 6 do Arduino.

5 #define S1 5 // Informa que a saida S1 do sensor sera conectada

ao pino 5 do Arduino.
6
#define S2 4 // Informa que a saida S2 do sensor sera conectada
7 ao pino 4 do Arduino.

8 #define S3 3 // Informa que a saida S3 do sensor sera conectada

ao pino 3 do Arduino.
9
#define OUT 2 // Informa que a saida OUT do sensor sera conectada
ao pino 2 do Arduino.
10

11
int g_count=0;
12
int g_flag = 0;
13
int g_array[3] = {0};
14
float g_SF[3] = {0.0};
15

16
void TSC_Init() // Inicializa o TSC230 e seta os valores da
frequencia.
17
18 {

19 pinMode(S0, OUTPUT); // Define o pino S0 como pino de saida.

pinMode(S1, OUTPUT); // Define o pino S1 como pino de saida.
20
pinMode(S2, OUTPUT); // Define o pino S2 como pino de saida.
21
pinMode(S3, OUTPUT); // Define o pino S3 como pino de saida.
22
pinMode(OUT, INPUT); // Define o pino OUT como pino de entrada.
23

24
digitalWrite(S0, HIGH); // Escreve um sinal alto no pino S0.
25
digitalWrite(S1, LOW); // Escreve um sinal baixo no pino S1.
26 // Essas escritas fazem que a frequencia seja de 20%.

27 }

28

29 // Seleciona as cores dos filtros.

30 void TSC_FilterColor(int Level01, int Level02)

{
31
if(Level01 != 0)
32
Level01 = HIGH;
33

34
if(Level02 != 0)
35
Level02 = HIGH;
36

37
digitalWrite(S2, Level01);
38 digitalWrite(S3, Level02);

39 }

40

41 void TSC_Count()

42 {

43 g_count ++ ;
}
44
45

46 void TSC_Callback()

47 {
switch(g_flag)
48
{
49
case 0:
50
Serial.println("->WB Start"); // Escreve na porta serial a
51 mensagem "->WB Start".

52 TSC_WB(LOW, LOW); // Condiao para o filtro sem o

vermelho.
53
break; // Finaliza a aao.
54 case 1:

55 Serial.print("->Frequency R="); // Escreve na porta serial a

mensagem "->Frequency R=".
56
Serial.println(g_count);
57
g_array[0] = g_count;
58
TSC_WB(HIGH, HIGH); // Condiao para o filtro sem o
59 verde.
break; // Finaliza a aao.
60
case 2:
61
Serial.print("->Frequency G="); // Escreve na porta serial a
62 mensagem "->Frequency G=".

63 Serial.println(g_count);

64 g_array[1] = g_count;
TSC_WB(LOW, HIGH); // Condiao para o filtro sem o
65
azul.
66 break; // Finaliza a aao.

67

68 case 3:

69 Serial.print("->Frequency B="); // Escreve na porta serial a

mensagem "->Frequency B=".
70
Serial.println(g_count);
71
Serial.println("->WB End"); // Escreve na porta serial a
72 mensagem "->WB End".

73 g_array[2] = g_count;
TSC_WB(HIGH, LOW); // Condiao sem o filtro.
74
break; // Finaliza a aao.
75
default:
76
g_count = 0;
77
break;
78
}
79 }

80

81 void TSC_WB(int Level0, int Level1) // Balano de branco.

82 {

83 g_count = 0;
g_flag ++;
84
TSC_FilterColor(Level0, Level1);
85
Timer1.setPeriod(1000000); // set 1s period
86
}
87

88
void setup()
89
{
90 TSC_Init();

91 Serial.begin(9600);

92 Timer1.initialize(); // defaulte is 1s

93 Timer1.attachInterrupt(TSC_Callback);

94 attachInterrupt(0, TSC_Count, RISING);

95
delay(4000);
96

97
for(int i=0; i<3; i++)
98
99 Serial.println(g_array[i]);

100

101g_SF[0] = 255.0/ g_array[0]; // Fator de escala para o vermelho.

g_SF[1] = 255.0/ g_array[1] ; // Fator de escala para o verde.

102
g_SF[2] = 255.0/ g_array[2] ; // Fator de escala para o azul.
103

104
Serial.println(g_SF[0]);
105
Serial.println(g_SF[1]);
106
Serial.println(g_SF[2]);
107

108
}
109

110void loop()

111{

112g_flag = 0;

113for(int i=0; i<3; i++)

114Serial.println(int(g_array[i] * g_SF[i]));
delay(4000); // Aguarda 4 segundos
115

Anlise de Resultados vistos no Serial Monitor

Para acompanhar o andamento do funcionamento referente deteco de cores foi

utilizado o serial monitor, uma ferramenta que ajudou a entender e a perceber a leitura
de cores. Essa ferramenta permite que o programador possa visualizar as informaes
recebidas pela porta serial. Alm disso, no serial monitor tambm possvel fazer o
processo inverso, ou seja, escrever valores para enviar ao processador. Dessa forma, a
leitura das frequncias dada por: R= Red (vermelho), G= Green (verde), B= Blue
(azul).

Figura 1 Incidncia da Cor Vermelha

Figura 2 Incidncia da Cor Azul

Figura 3 Incidncia da Cor Verde

Conforme a Figura 1 consegue-se notar que o sensor est detectando a cor vermelha,
pois a sua frequncia quase o dobro das demais, isso a comprovao de sua leitura.
O mesmo raciocnio segue para as outras cores, isso visto na Figura 3, onde o verde
detectado e na Figura 2, onde o azul lido. Portanto, constata-se que o sensor faz a
leitura de uma cor, visto que a frequncia desta est mais alta que as demais.

Atravs do experimento descrito acima, pode-se verificar o funcionamento e as ligaes

necessrias para o correto desempenho do sensor de cor RGB TCS230. Um fator
importante a ser considerado o fato de que esse sensor faz leituras com os objetos
localizados a aproximadamente 1 centmetro de distncia. Ademais, h um cuidado
especial com a intensidade das cores dos objetos, pois o sensor no l adequadamente
certas tonalidades confundindo-se na verificao, mesmo filtrando uma cor em
especfico.