TCC - Sistema Sensorizado Por Cor e Tamanho

UNIVERSIDADE PAULISTA - UNIP
INSTITUTO DE CIÊNCIAS E TECNOLOGIA

Engenharia Elétrica
Fernando Américo Velozo

Marcos Freitas
Osvaldo Rodrigues de Matos Filho
Thiago Ferrari
Wallace Daniel Sertori
SISTEMA SENSORIZADO PARA MONITORAMENTO FINAL DE PRODUTOS

MEDIANTE DISTINÇÃO DE COR E TAMANHO
RIBEIRÃO PRETO
2011
Marcos Freitas
Thiago Ferrari

Trabalho de conclusão de curso para

obtenção do título de graduação em
Engenharia Elétrica com ênfase em
Eletrônica apresentado à Universidade
Paulista – UNIP.
Orientador: Prof. Msc. Marcelo Alves
RIBEIRÃO PRETO
2011

Marcos Freitas
Thiago Ferrari

Trabalho de conclusão de curso para

obtenção do título de graduação em
Engenharia Elétrica (Eletrônica)
apresentado à Universidade Paulista
– UNIP.
.
Aprovado em:
BANCA EXAMINADORA
_______________________/__/___
Prof. .
Universidade Paulista – UNIP
_______________________/__/___
Prof. .
Universidade Paulista – UNIP
_______________________/__/___
Prof. .
Universidade Paulista UNIP
DEDICATÓRIA
Dedicamos esse trabalho às nossas famílias, que tanto contribuíram nos

dando força para lutar pelos nossos objetivos e buscar o sucesso de maneira digna
e justa.
AGRADECIMENTOS
Agradecemos em primeiro lugar a DEUS por ser a base das minhas

conquistas;
Aos nossos familiares, por acreditar e terem interesse em minhas

escolhas, apoiando-me e esforçando-se junto a mim, para que eu suprisse todas
elas;
Aos professores pela dedicação em suas orientações prestadas na

elaboração deste trabalho, me incentivando e colaborando no desenvolvimento de
minhas ideias.
RESUMO
Este projeto consiste em um sistema eletrônico para supervisão e padrão de

qualidade de produto ou embalagens através de diferenciação de cores e tamanhos.
Visando aumentar a produtividade e reduzir, ou até mesmo eliminar custos

desnecessários com produtos fora de padrão em diversas empresas dos mais
variados ramos, elaboramos um sistema automatizado de baixo custo, que possa
ser implantado com baixo investimento. O sistema deverá trabalhar sozinho com a
supervisão de um operador que fará a configuração do mesmo, com as exigências
para o produto.
O processo será comandado por um software que depois de configurado

fará a avaliação do produto distinguindo tamanhos e até 8 (oito) cores. Após
analisado em uma esteira, o produto será separado e direcionado conforme
determinado pela configuração do operador, ou até mesmo lançado para outra
esteira que o levará ao depósito de refugo.
Palavras Chave: Sensor de cor; RGB; monitoramento de cor/ tamanho.

ABSTRACT
This project consists of an electronic system for supervision and quality

standard of product or packages by distinctive of colors and sizes.
To increase productivity and reduce or even eliminate unnecessary costs out

of products to companies in the industry standard in manufacturing and
packaging, we are developing an automatic, low cost, which can be deployed
with a small investment.
The system should work alone under the supervision of an operator who will
set the requirements for the product. The process will be controlled by software
that once set will make the evaluation of product sizes and even distinguishing 8
(eight) colors. After analysis on a treadmill, the product will be separated and
directed as determined by operator configuration, or even released for another
treadmill which leads to the deposit of waste.
Keywords: Color sensor; RGB; color/ size assistance.

SUMÁRIO
1. INTRODUÇÃO....................................................................................................9
2. SENSOR DE COR............................................................................................ 10
3. RECEPÇÃO DAS CORES................................................................................12
4. APRESENTAÇÃO DO PROJETO PROPOSTO...............................................15
5. PROPOSTA DE PROJETO..............................................................................16
5.1 Sensor de cor RGB:................................................................................................16
5.2 Esteiras automatizadas..........................................................................................17
5.3 Painel de operação e controle:..............................................................................17
5.3.1 Display LCD:..............................................................................................18
5.3.2 LEDs indicativos:......................................................................................18
5.3.3 Botões de comando:.................................................................................19
6. PRINCIPIO DE FUNCIONAMENTO DO PROTÓTIPO.....................................20
6.1 Desenvolvimento do sensor de cor................................................................262
6.1.1 Testes com os LDR.................................................................................264
6.1.2 Definições para o circuito do sensor RGB.............................................26
6.1.3 Especificação dos resistores e LDR’s do sensor..................................26
6.2 Especificações Técnicas...................................................................................27
6.2.1 Micro-Controlador.....................................................................................27
6.2.2 Painel de operação....................................................................................28
6.2.3 Esteiras.......................................................................................................28
7. CÁLCULOS REALIZADOS..............................................................................32
7.1 Definições para o circuito do sistema..............................................................32
8. LISTA DE MATERIAS......................................................................................34
9. RECURSOS...................................................................................................... 35
10. CONCLUSÃO................................................................................................... 36
REFERÊNCIA BIBLIOGRÁFICA..............................................................................36
APÊNDICES..............................................................................................................36
10
1. INTRODUÇÃO
O trabalho proposto consiste na fabricação de um sistema para supervisão

controle do padrão de qualidade de produtos ou embalagens.
O sistema descrito neste trabalho torna-se diferenciado por possuir diversas

opções personalizadas, desenvolvimento com baixo custo de fabricação e com
estrutura propícia para aumento de velocidade de resposta ao circuito. Composto de
software específico para controle de sensores e monitoramento de esteira rolante,
este sistema possui display digital que facilita a interface e configuração.
Conta com opção para diferenciador de tamanhos e para até 8 (oito) cores
básicas, separação de produtos por cor e tamanho, contagem especifica por cor,
descarte automático para produtos de refugo e memória de leituras anteriores onde
o operador pode verificar uma lista com quantidades por cor.
11
2. SENSOR DE COR
Atualmente, no mercado, os sensores de cor mais baratos utilizam 3 LEDs

coloridos (vermelho, verde e azul – RGB), como emissores, 1 LDR (resistência
dependente de luz), como receptor, para identificação da cor mediante reflexão do
item analisado e um circuito eletrônico micro-controlado que reconhece os dados
fornecidos. Utilizando um modo de leitura digital, este método permite a identificação
de 8 cores distintas (2³) e, utilizando um sistema de leitura analógica, através de um
conversor A/D (Analógico/Digital) de 8 bits, é possível o reconhecimento de mais de
16 milhões de cores distintas (255³).
Nosso trabalho consiste em construir um sensor que possua 1 emissor de luz

branca e 3 receptores coloridos para identificação de cada cor da amostra. Desta
forma, pretendemos reduzir o tempo que levaria para a varredura das cores pelo
sistema tradicional em praticamente um terço, pois os receptores utilizados (LDRs)
serão excitados simultaneamente. É um ganho de tempo considerável caso aplicado
em uma linha de produção automatizada de alta velocidade, como empacotadeiras
de pequenos pacotes, servindo inclusive, para sistemas de baixa velocidade.
Foram realizados alguns testes utilizando LDRs comuns nas cores referentes
à RGB (Vermelho, Verde, Azul), para análise da luz refletida pelo objeto. Quando
excitados por uma luz de frequência similar à emitida quando o mesmo é alimento,
os LEDs apresentam uma tensão em seus terminais.
Os resultados obtidos não apresentaram taxa de variação necessária para

distinção das cores refletidas. Para que pudéssemos utilizar os sinais obtidos seriam
necessários amplificadores e filtros precisos, o que aumentaria o custo do projeto e
inviabilizaria a sua fabricação.
Visando economia no processo, utilizaremos os receptores formados por 3

LDRs com filtros nas cores referentes à RGB (Vermelho, Verde e Azul), para análise
da luz refletida pelo objeto
.
12
O diagrama elétrico do sensor será similar ao apresentado abaixo:
Módulo
Sensor de
presença
R1
R2
R3
Módulo 1
Amplificad
or
Módulo 2
Amplificad
or
Módulo 3
Amplificad
or
Figura 1 – Diagrama elétrico do sensor de cor com sensor de presença
Note que no diagrama apresentado, há um sensor de presença instalado.

Este sensor será utilizado para evitar interferências no sistema por efeitos externos
(movimentação, cor de fundo da esteira, etc.) fazendo assim, com que a leitura da
cor da amostra seja realizada APENAS quando a amostra (embalagem) estiver na
esteira, frente ao sensor.
Os valores referentes aos resistores R1, R2 e R3 podem ser diferentes pois,

cada cor de LED, para seu brilho máximo, exige um valor de tensão diferente. Em
geral, os LEDs operam com níveis de tensão de 1,6 à 3,3V, sendo compatíveis com
os circuitos de estado sólido. É importante ressaltar que a tensão de funcionamento
do LED é dependente do comprimento da onda emitida. Assim, os LEDs
infravermelhos geralmente funcionam com menos de 1,5V, os vermelhos com 1,7V,
os amarelos com 1,7V ou 2,0V, os verdes entre 2,0V e 3,0V, enquanto os LEDs
azuis, violeta e ultravioleta geralmente precisam de mais de 3,0V. A potência
necessária está na faixa típica de 10 a 150mW, com um tempo de vida útil de
100.000 ou mais horas. ’
13
3. RECEPÇÃO DAS CORES
A cor é uma percepção visual provocada pela ação de um feixe de fótons

sobre células especializadas da retina, que transmitem através de informação pré-
processada no nervo óptico, impressões para o sistema nervoso. A cor de um
material é determinada pelas médias de frequência dos pacotes de onda que as
suas moléculas constituintes refletem. Um objeto terá determinada cor se não
absorver justamente os raios correspondentes à freqüência daquela cor. Assim, um
objeto é vermelho se absorve preferencialmente as frequências fora do vermelho.
A cor é relacionada com os diferentes comprimentos de onda do espectro

eletromagnético. São percebidas pelas pessoas e por alguns animais através dos
órgãos de visão, mas somente em uma faixa específica (zona do visível).
Considerando as cores como luz, a cor branca resulta da sobreposição de

todas as cores primárias (amarelo, azul e vermelho), enquanto o preto é a ausência
de luz. Uma luz branca pode ser decomposta em todas as cores (o espectro). Na
natureza, esta decomposição origina um arco-íris. Observação: Cores primárias são
cores indecomponíveis, sendo o vermelho, o amarelo e o azul. Desde as
experiências de Le Blond, em 1730, essas cores vêm sendo consideradas primárias.
O principio das cores vem do sistema chamado de RGB (Red, Green e Blue), ou
seja, a cor Vermelha, Verde e Azul. Estas cores são as cores primarias tratando-se
de reflexão luminosa.
No sistema de cores, existem oito cores principais, além das descritas acima
como as primarias, temos também as cores secundárias que são os chamados
CMYK.
Este sistema CMYK é constituído pelas cores Ciano, Magenta e Amarelo

além das cores Branco e Preto. Na sigla, é utilizada a letra K para diferenciar o preto
(“Black”) do Azul (“Blue”) do sistema RGB.
O sistema RGB é utilizado quando tratamos de definição de cor através de

emissão de luz como, por exemplo, um display colorido, tela de televisão ou a
própria utilização de fontes de luz colorida. Ja o sistema CMYK é utilizado quando se
trata de uma cor física como, por exemplo, uma impressão, folder, mistura de tintas
de pintura, etc.
14
Estes sistemas são complementares um ao outro, podendo ser descritos

como:
CMYK = 1-RGB.
Todas as cores, visíveis e não visíveis, são diferenciadas apenas pelo

comprimento de onda que cada uma delas possui.
Segue abaixo uma tabela com alguns comprimentos de onda das cores que
compoem o arco-iris e suas respectivas frequências:
Cores do espectro visível
Cor Comprimento de onda Freqüência
Vermelho ~ 625-740 nm ~ 480-405 THz
Laranja ~ 590-625 nm ~ 510-480 THz
Amarelo ~ 565-590 nm ~ 530-510 THz
Verde ~ 500-565 nm ~ 600-530 THz
Ciano ~ 485-500 nm ~ 620-600 THz
Azul ~ 440-485 nm ~ 680-620 THz
Violeta ~ 380-440 nm ~ 790-680 THz

Tabela 1 – Valores dos comprimentos de onda para cada cor do arco íris
Figura 2 – Espectro Contínuo
Ao enxergarmos determinada cor em um objeto, na verdade, estamos

enxergando apenas as cores que este não absorve, ou seja, as cores refletidas por
sua superfície.
Entende-se, portanto, que se um objeto é da cor azul, por exemplo, é porque

sua superfície repele a frequência de luz referente à cor azul.
15
Quanto maior a intensidade da cor na superfície do objeto observado, maior a

intensidade da onda de luz refletida por esta e captada pelos olhos. O mesmo efeito
se repete com todas as cores primárias.
A combinação de diversas intensidades das cores primárias (vermelho, verde

e azul) dão origem à todas cores visiveis a olho nú.
Esta característica explica o funcionamento dos sensores de presença por IR

(Infra-Red => Infravermelho) e das filmagens no escuro utilizando câmeras de IR.
Considerando-se que nenhum objeto possui uma cor formada pela frequência
de IR, toda a frequência de IR emitida pela própria câmera, é novamente refletida e
esta, por sua vez, através de software específico, faz a leitura desta reflexão e
converte em imagem visível porém, não é possível identificar a real cor do objeto
filmado, dai a explicação da imagem monocromática adquirida.
16
4. APRESENTAÇÃO DO PROJETO PROPOSTO
O trabalho proposto consiste na fabricação de um sistema para supervisão

controle do padrão de qualidade de produtos ou embalagens.
O sistema descrito neste trabalho torna-se diferenciado por possuir diversas

opções personalizadas, desenvolvimento com baixo custo de fabricação e com
estrutura propícia para aumento de velocidade de resposta ao circuito. Composto de
software específico para controle de sensores e monitoramento de esteira rolante,
este sistema possui display digital que facilita a interface e configuração.
Conta com opção para diferenciador de tamanhos e para até 8 (oito) cores
básicas, separação de produtos por cor e tamanho, contagem especifica por cor,
descarte automático para produtos de refugo e memória de leituras anteriores onde
o operador pode verificar uma lista com quantidades por cor.
17
5. PROPOSTA DE PROJETO
A proposta do projeto é desenvolver um sistema que irá realizar a contagem

de uma linha de produção de um produto qualquer, diferenciando-os pela cor de
uma etiqueta colada ou da própria embalagem do produto. Será utilizado LDRs
como receptores das frequências de luz referentes ao sistema RGB.
Para nosso trabalho, serão desenvolvidos sensor de cor RGB, sensores de

presença, esteiras automatizadas e painel de operação com display LCD e circuito
de controle.
5.1 Sensor de cor RGB:
O sensor de reconhecimento de cor RGB digital será responsável pela leitura

de quais cores constitui o material avaliado, verificando a refração digitalmente (se
“possui” ou “não possui” a cor) mediante um emissor de luz branca e três receptores.
Conforme as combinações das frequências refletidas, será possível reconhecer
distintamente até 8 (oito) cores, conforme tabela abaixo:
RESPOSTA DO SENSOR
Cor da
amostra
Vermelho (R) Verde (G) Azul (B)
0 0 0 Preta
0 0 1 Azul
18
0 1 0 Verde
0 1 1 Ciano
1 0 0 Vermelha
1 0 1 Magenta
1 1 0 Amarela
1 1 1 Branca
Tabela 2 – Combinação de cores em RGB
O sensor será composto de um LED RGB e três LDRs que serão

responsáveis pela leitura das cores e também por um sistema de monitoração e
controle, constituído por um circuito micro-controlado, responsável pelo controle das
informações.
5.2 Esteiras automatizadas
Será utilizado um conjunto composto de três esteiras, comandadas pela

central de comando que servirá para condução, posicionamento dos produtos nos
locais de análise e direção para utilização.
A primeira esteira será posicionada inclinada e fará a identificação das

características dos produtos pelos sensores instalados, sendo: Sensor 1, realiza a
contagem dos blocos, Sensor 2, identifica a cor dos blocos e Sensor 3, identifica
junto com o Sensor 1 o tamanho do bloco.
A segunda esteira estará na horizontal e direcionará os produtos para a

devida utilização conforme configuração de seus atuadores e sensores descritos:
Sensor 4, informa que o produto esta em posição para ser direcionado pelo Atuador
1, que empurra o produto a esteira 3, que o levará ao setor de descarte, Atuador 2,
direciona o produto separando-o entre grande e pequeno ou entre duas cores,
conforme configuração determinada pelo operador.
19
A terceira esteira estará em nível mais baixo que a segunda e será utilizada
para levar os produtos não requisitados para o setor de descarte.
5.3 Painel de operação e controle:
O controle do sistema será formado por uma central de comando móvel, com
alimentação por fonte removível e bateria interna, possuirá LEDs indicativos, botões
de comando e um display LCD, para visualização das leituras do sensor e
conferênca do histórico de dados obtidos.
Figura 2 – Modelo do Painel de operação e controle
Este comando será realizado através de circuito microcontrolado (utilizando

micro-controladores PIC MicroChip®) e, portanto, poderá ser configurado para
realizar as mais diversas funções, conforme a necessidade do usuário do sistema.
Para controle do projeto proposto, o microcontrolador estará programado para
contagem e armazenamento da quantidade de blocos que passarem pela esteira. A
placa e o circuito serão configurados para as seguintes funções:
5.3.1 Display LCD:

20
Indicará informações como, a cor identificada no momento quando sistema

em funcionamento, as quantidades das cores contadas, individualmente e um
resumo do total armazenado na memória.
5.3.2 LEDs indicativos:
- Bateria Interna (Vermelho): Indica quando o sistema está em funcionamento

mediante bateria interna. Cabo de alimentação removido.
- ON (verde): Indica que o sensor está ligado e realizando a leitura.
- Relé (verde): Indica que o relé externo está acionado.
5.3.3 Botões de comando:
- Navegação: Possibilita navegar entre os dados contidos na memória

EEPROM do micro-controlador.
- Acionamento Relé: Aciona o contato auxiliar de saída caso necessário.
- Opções: Escolhe em quais cores o relé de saída atuará e dará a opção de
apagar memória.
- Start / Stop: Alimenta o sensor e inicia a contagem.
Para uso opcional, o controle manual que constitui o sistema, possuirá

também uma função para ativar um contato externo (relé) quando o sensor detectar
a leitura de uma determinada cor, conforme previamente programado. Esta função
permite que seja atuada uma válvula pneumática para acionamento de um pistão, ou
outro atuador externo ao circuito.
21
6. PRINCIPIO DE FUNCIONAMENTO DO PROTÓTIPO
O protótipo proposto para exemplificação prática do trabalho será formado

pelos sensores, atuadores e pelo comando descritos acima, e por três esteiras de
acionamento elétrico, de forma a simularem uma linha de produção em série de um
determinado produto. Para simulação dos produtos, utilizaremos blocos de madeira
revestidos com papeis coloridos nas 8 cores reconhecidas pelo sensor: branco,
preto, vermelho, verde, azul, ciano (azul celeste), magenta (rosa) e amarelo.
Quando alimentado com tensão, o comando envia ao display a mensagem

“Stand by” e fica em espera para ser ligado o sistema. Ao acionarmos o botão Start,
as esteiras entram em funcionamento e os sensores são ligados.
Se por 10 segundos o Sensor 1 não detectar a presença de nenhum produto,

as esteiras param e o comando envia a mensagem “esteiras vazias” ao display.
A intenção do protótipo, em pleno funcionamento (LED verde – ON – aceso),

será de, ao passar um bloco colorido pela Esteira 1, o sensor de presença irá atuar,
informando ao controle de que há objeto na esteira. Este, por sua vez, liga o sensor
de cores e faz a leitura de qual a cor do bloco no momento.
A implantação do sensor de presença IR é para possibilitar a leitura do bloco

na cor “preta” especificamente pois, nesta cor, nenhum dos receptores emitirá sinal
22
de resposta, assim como quando não possuir nenhum bloco refletindo. Caso não
haja a necessidade de leitura desta cor, o sensor de presença pode ser removido e
o sensor de cor acionado diretamente.
Ao final da identificação de cor de cada bloco, o controle apresenta no display

o nome da cor que foi lida e acrescenta na somatória total, até um máximo de 255
unidades, para cada cor contada.
Após identificada a cor o Sensor 3 juntamente com o Sensor 1 fará a

identificação do tamanho do bloco. O display informará a cor o tamanho e que este
produto será descartado, e as Esteiras 1 e 2 o levará até o ponto em que o Sensor 4
o identificará e acionará o atuador para lançar o produto a Esteira 3 que irá o
posicionar junto com os descartados.
No painel de comando, o operador ao acionar a tecla CONFIG, contará com

as seguintes opções de comando:
Seleção de cor e tamanho: nesta opção o operador configura as cores e

tamanhos que serão aceitos, e determinará qual produtos serão destinados ao lado
direito e ao lado esquerdo do Atuador 2 no fim da segunda esteira
Visualizar memoria: esta opção mostra ao operador um resumo das

contagens de cada produto
Apaga valores: permite ao operador eliminar o historico de contagem de cada

produto por distinção de cor e tamanho
Reset config: é a opção que limpa todas as configurações determinadas,

levando o sistema a configuração original.
Ao final do processo e o sistema desligado (LED verde – ON – apagado), será

possível visualizar no display, pelas teclas de navegação, a quantidade total de
todas as cores que passaram pela esteira e ressetar a memoria do controle para
nova contagem.
6.1 Desenvolvimento do sensor de cor

23
Para desenvolvimento do protótipo, foram necessárias as realizações de

diversos testes para determinação dos amplificadores que serão colocados a cada
LED receptor.
O LED é um diodo semicondutor (junção P-N) que quando energizado emite

luz visível por isso LED (Diodo Emissor de Luz). A luz não é monocromática (como
em um laser), mas consiste de uma banda espectral relativamente estreita e é
produzida pelas interações energéticas do elétron. O processo de emissão de luz
pela aplicação de uma fonte elétrica de energia é chamado eletroluminescência.
Em qualquer junção PN polarizada diretamente, dentro da estrutura, próximo

à junção, ocorrem recombinações de lacunas e elétrons. Essa recombinação exige
que a energia possuída por esse elétron, que até então era livre, seja liberada, o que
ocorre na forma de calor ou fótons de luz. No silício e no germânio, que são os
elementos básicos dos diodos e transistores, entre outros componentes eletrônicos,
a maior parte da energia é liberada na forma de calor, sendo insignificante a luz
emitida (devido a opacidade do material), e os componentes que trabalham com
maior capacidade de corrente chegam a precisar de irradiadores de calor
(dissipadores) para ajudar na manutenção dessa temperatura em um patamar
tolerável.
Já em outros materiais, como o arsenieto de gálio (GaAs) ou o fosfeto de

gálio (GaP), o número de fotons de luz emitido é suficiente para constituir fontes de
luz bastante eficientes. O objetivo inicial seria de colocarmos um LED branco como
emissor e os LEDs nas outras 3 cores (RGB) como receptores, porém os LEDs
brancos do mercado não são formados pela somatória da freqüência de todas as
cores, mas sim, pela utilização de um LED azul com uma camada de fósforo, fato
que gera uma luz visivelmente branca, porém, formada por apenas uma freqüência
de luz.
Para resolvermos este problema, utilizaremos um LED branco RGB. Este tipo
de componente, se trata de 3 LEDs nas cores vermelho (R), verde (G) e azul (B)
montados em um único encapsulamento. Ao acionarmos todas as cores ao mesmo
tempo, a somatória destas resultará na luz de cor branca, com a somatória da
freqüência de luz das 3 cores necessárias para o sensor.
Os testes serão realizados avaliando-se a reflexão da superfície do bloco já

revestido conforme figura 3. Utilizando o dispositivo montado conforme descrito,
24
alimentá-se todos os terminais do LED RGB (central) e ilumina-se

perpendicularmente a superfície do bloco, a uma distância de 25mm. A freqüência
de luz referente à cor do bloco é refletida e recebida pelos LEDs receptores. O LED
que possuir uma das frequências refletidas será excitado e emitirá em seus
terminais, uma tensão baixa, porém perceptível, que será amplificada e deverá ser
lida pelo controle do sistema.
Sensor
bloco
Figura 3 – Reflexão do bloco
6.1.1 Testes com os LDRs
Com o intuito de facilitar os testes e simplificarmos os filtros, utilizamos 3

LDRs (Light Dependent Resistor), Resistor Dependente de Luz, como “coração” dos
nossos sensores.
LDR é um resistor que varia a sua resistencia conforme a intensidade de luz

ou a irradiação eletromagnética que incide sobre ele, este é um componente
eletrônico de forma oval possui envólucro isolante, a resitência é de material CdS
(Sulfeto de Cádmio) ou CdSe (Selento de Cádmio), sua resistência diminui quando a
luz é intensa, e, ao contrário também ocorre, ao diminuir a luz, sua resistência
aumenta. Esta resistência possui uma forma de curvas, isto é, forma vai e vem, para
captar melhor a luz, com isso obtém-se a variação de resistência, o LDR é sensivel
as faixas do Infravermelho (IR), luz visível ultravioleta (UV).
25
Ao emitirmos uma luz num bloco colorido, este reflete uma luz na frequência
correspondente à sua cor. Esta freqüência, ao passar por filtros de cada cor (RGB),
será dividida e recebida pelo LDR que estiver com um filtro na cor correspondente,
ou seja, permitirá a passagem de luz somente nos receptores das cores primárias
que compõem a cor em análise, reduzindo assim a resistência entre os terminais
dos LDRs.
Desta forma, tendo como base a tabela 2, realizamos os testes práticos

utilizando 4 camadas de papel Celofane, nas 3 cores primárias, sobrepostos ao
LDR, com o objetivo de encontrar os valores dos resistores que serão instalados no
amplificador operacional (LM339) e obtivemos os seguintes resultados:
RESPOSTA DO SENSOR
Cor da
amostra
Vermelho (R) Verde (G) Azul (B)
0 0 0 Preta
0 0 1 Azul
0 1 0 Verde
0 1 1 Ciano
1 0 0 Vermelha
1 0 1 Magenta
1 1 0 Amarela
1 1 1 Branca
Tabela 2 – Combinação de cores em RGB
26
Figura 4 – Resultado dos testes utilizando o filtro de celofane vermelho
Figura 5 – Resultado dos testes utilizando o filtro de celofane azul

27
Figura 6 – Resultado dos testes utilizando o filtro de celofane verde
Os testes foram realizados com todas as cores de blocos e realizando a

leitura nos terminais de todos os LDRs, para definição de qual receptor apresentará
uma resposta válida e qual deverá ser o valor do resistor utilizado para cada uma
das cores primárias.
6.1.2 Definições para o circuito do sensor RGB
Devido à necessidade de acionar 3 comparadores de tensão e realizar a

instalação em um circuito compacto, foi montado o sensor utilizando-se o CI LM339,
composto de 4 (quatro) amplificadores operacionais, configurado como comparador.
Este comparará o valor da entrada inversora, que está ligada em um divisor de
tensão com uma tensão de 2,5V, e o valor da entrada não inversora que está ligada
também em um divisor de tensão, constituído por um resistor, cujo o valor fora
obtido nos testes de Reflexão, e um LDR de 10KΩ.
Quando a tensão no LDR for maior que a tensão de referência o comparador

fornece uma tensão de saída de 5V. Sendo que o CI LM339 possui 4 amplificadores
28
operacionais internos, foi necessário apenas a utilização de apenas 3 (três), sendo

um para o terminal R, uma para o terminal G e um para o terminal B.
6.1.3 Especificação dos resistores e LDR’s do sensor
Foram utilizados resistores distintos para cada cor, em cada divisor de tensão
das entradas dos comparadores. Os mesmos foram adotados baseados nos
resultados de testes com os LDRs.
Conforme o resultado dos testes, utilizamos um resistor de 6KΩ para o

terminal R (vermelho), um resistor de 10KΩ para o terminal G (verde), um resistor de
10KΩ para o terminal B (azul) e LDRs de 10KΩ.
6.2 Especificações Técnicas do Sistema de monitoramento
6.2.1 Micro-Controlador
Nos 3 (três) circuitos montados foram utilizados o micro-controlador PIC

16F886, do fabricante MicroChip mediante comunicação serial (Circuito #1- Mestre
com Circuito #2- Display) e comunicação paralela (Circuito #1- Mestre com Circuito
#3 – esteiras e atuadores).
Algumas características desse micro-controlador, são as seguintes:
Tipo de memória de programa Flash
Memória de programa (KB) 14
Velocidade da CPU (MIPS) 5

29
Bytes RAM 368
Data EEPROM (bytes) 256
1-A/E/USART,
Periféricos de comunicação Digital 1-MSSP(SPI/I2C)
Periféricos de Captura/ Comparação/

PWM (CCP) 1 CCP, 1 ECCP
Timers 2 x 8-bit, 1 x 16-bit
ADC 11 ch, 10-bit
Comparadores 2
Temperature Range (C) -40 to 125
Tensão de opearação (V) 2 to 5.5
Quantidade de pinos 28
Canais de touch capacitivo 11
Tabela 3 – Características técnicas do Micro-controlador PIC
Nos circuitos criados, não foram utilizados nem ao menos 20% da capacidade
de processamento dos micro-controladore porém, devido ao baixo custo e facilidade
de aquisição dos mesmos, estes foram utilizados com sucesso.
6.2.2 Painel de operação
Para o painel de operação do sistema utilizaremos o microcontrolador PIC,

modelo 16F886 programado em linguagem “C” e um display LCD alfanumérico com
16 colunas x 2 linhas.
Provido de 4 (quatro) botões, o painel é de fácil utilização e possibilita a

interface homem - máquina.
Neste painel é possível programar o que será realizado com cada tipo de
bloco individualmente (separar para esquerda, direita ou rejeitar) e visualizar a
30
contagem dos blocos que passaram pela esteira. Há também as opções de habilitar/
desabilitar som do beep, apagar valores contados e ressetar todo o sistema.
6.2.3 Esteiras
O sistema montada foi composto por 3 (três) esteiras confeccionadas em

plástico, alumíno e couro sintético, com 250mm de extensão e 60mm de largura
cada esteira.
Na primeira esteira fora instalados o sensores de tamanho e de cor; esta ficou

responsável por identificação do bloco.
Na segunda esteira foram fixados um sensor de posicionamento e dois

atuadores, um responsável por direcionar os blocos para direita ou para esquerda
(conforme pré-programação) e outro para expulsar o bloco para a terceira esteira.
A terceira esteira foi ligada no sentido reverso, enviando os blocos rejeitados/

excluídos para um depósito simbólico de sucata.
31
6.3 Fluxograma do micro controlador do painel de operação
Definição das Escrita no LCD Aguarda Interrup.

Início Stand by
Variáveis Serial
Interrupção
Serial
Leitura pino
S
de comando Há Armazena o Byte do Aguarda Interrup.
complemento? Texto Serial
N
T
Texto /
Valor
S
Exige Bit Beep = 1
V
Beep?
Bit Beep = 0
Apaga Display
S
Escreve 1ª linha do 2º Texto? Define variável
Display posição 2ª linha
Escreve 2ª linha do
Display
1 Aciona Beep
Bit
Beep por 1seg
0
32
6.4 Fluxograma do micro controlador das esteiras e atuadores

33
Desliga
Início esteiras e
sensores
Config. e inicializar
Ra7 = bit Envia sinal de
entradas e saídas
de controle Erro ‘SEM
bit Rb4 => entrada BLOCO
0
1 Liga bit controle Leitura
Ra S1 até S1
esteiras e => saída
7 10s
0 sensores 1
Armazena
Leitura
valor de 3bits
Leitura S2
na última
resp.
posição da Sensor
Circ.
pilha de Cor
Mestre
dados
1
bit controle Set bit de Envia cód. Id Leitura
Ra S1 & S3
0 => entrada controle para PortB
7
Parar
Desliga
0000 0000 Início
Esteiras e
Interrupção
Direita sensores
Aciona Atuador
(sensor 4) Retorn
0000 0001 2 para direita
o
Esquerda
Copia 1º Valor Aciona Atuador
da pilha 0000 0010 2 para
Eliminar esquerda
Rotaciona Para Liga Liga Desliga Desliga
valores da 0000 0011 esteiras atuador esteira C atuador atuador
pilha 1 1 1
AeB Desliga
esteira C
6.5 Fluxograma do micro controlador das esteiras e atuadores

34
7. CÁLCULOS REALIZADOS
35
Resistores para a entrada negativa do comparador LM-339:

Os mesmos foram obtidos através de experiências realizadas em
laboratório e os resultados estão relatados no projeto.
Sensor R: 6K
Sensor G: 10K
Sensor B: 10K
Resistores (divisor de tensão) para a entrada positiva do comparador LM-339:

R: 10K
Os mesmos foram adotados baseados nos resultados da experiência
descrita acima para que a comparação seja feita.
Valores dos LDRs:

R: 10K
Os mesmos foram adotados baseados nos resultados da experiência descrita
acima para que a comparação seja feita.
7.1 Definições para o circuito do sistema
Resistores indicados pelo data sheet do PIC16F883/886:

R1: 1K
R2: 10K
Resistores para polarização dos Leds:

R=(Vcc-VLed)/ILed
R=(5-1,8)/0,006
R=533  – Comercial: 560 

36
Resistores para base do transistor BC327, utilizados apenas como chave:

IC= 250mA e o beta=100, portanto:
IB=IC/beta
IB=0,250/100
IB=2,5mA
RB=Vcc/IB
RB=5/0,0025
RB=2K – Comercial: 2K2
8. LISTA DE MATERIAS
37
Esta lista foi composta por materiais previstos para serem utilizados
durante o projeto
Item Tag Qtde Valor unit Valor Total

Resistor 1K R1 15 R$ 0,05 R$ 0,75
Resistor 10K R2 12 R$ 0,05 R$ 0,60
Resistor 2K2 R3 3 R$ 0,05 R$ 0,15
Resistor 0,56K R4 6 R$ 0,05 R$ 0,30
Trimpot 10K TR1 2 R$ 0,70 R$ 1,40
Diodo 1N4007 D 2 R$ 0,05 R$ 0,10
Transistor BC237 Q 3 R$ 0,20 R$ 0,60
Capacitor 100Nf C1 2 R$ 0,60 R$ 1,20
Capacitor 4700uF C2 1 R$ 2,15 R$ 2,15
CI LM339 CMP 6 R$ 0,65 R$ 3,90
Microcontrolador PIC PIC 3 R$ 30,00 R$ 90,00
Display LCD LCD 1 R$ 31,85 R$ 31,85
Placa circuito impresso 2 R$ 50,00 R$ 100,00
Motor M 3 R$ 0,00 R$ 0,00
Sirene SR 2 R$ 0,00
Diodo LED DL 6 R$ 0,80 R$ 4,80
LDR 10K RL 6 R$ 3,00 R$ 18,00
Mecânica R$ 0,00 R$ 0,00
Foto transistor FT 3 R$1,00 R$3,00
Total previsto R$ 255,80
Tabela 4 – Lista de materiais
9. RECURSOS
38
Para o projeto do sensor de cor, foram utilizados recursos práticos e de fácil

acesso. Para análise dos sinais elétricos do sensor utilizou-se instrumentos do
laboratório da Universidade, tais como, osciloscópio e multímetro.
A esteira transportadora de cubos coloridos e seus dispositivos mecânicos

foram fabricados com sobra de matéria prima na metalúrgica de um dos membros
da equipe utilizando ferramentas e equipamentos da mesma.
Os demais itens para a composição do projeto serão custeados pela equipe,

para isto, criamos um caixa onde cada membro depositou uma quantia em dinheiro,
este caixa será controlado por um membro da equipe que deverá apresentar notas
fiscais justificando a saída da verba prevista para cada etapa do projeto.
10. CONCLUSÃO
39
Devido aos testes e pesquisas realizadas, pudemos identificar que este

sistema de identificação, por ser muito simples de barato, se torna uma opção muito
viável para implantação em diversos tipos de industrias.
Este recurso pode ser utilizado para separar produtos diversos utilizando
apenas uma linha de montagem / produção. Considerando-se que nem todas as
empresas possuem mais de 8 (oito) produtos por linha de montagem, este sensor
pode abranger uma grande gama de aplicações, identificando etiquetas ou a própria
cor da embalagem.
Com este trabalho, pudemos mostrar que é possível realizar um sistem de

reconhecimento de cores confiável e de baixíssimo custo.
REFERÊNCIAS BIBLIOGRÁFICAS
40
Pereira, Fábio; Micro-controladores PIC programação em C, Ed. Érica
Boylestad, Robert; Dispositivos eletrônicos e teoria de circuitos. 6. JC Editora
DATA SHEET LM339. Disponível em: < http://www.national.com/ds/LM/LM339.pdf>.
DATA SHEET PIC 16F886.

Disponível em: < http://ww1.microchip.com/downloads/en/DeviceDoc/41291F.pdf>.
Sensores de cor. Disponível em: http://www.philohome.com/sensors/colorsensor.htm
Sensor RGB. Disponível em:

<http://www.ifm.com/ifmus/news/news_sen_7PDMPQ.htm>.
APÊNDICE A – Esquema eletrônico do circuito

41
APÊNDICE B – Esquema eletrônico do Sensor de cor

42
APÊNDICE C – Esquema eletrônico do Sensor de presença de blocos

43
APÊNDICE D – Programa circuito mestre

44
MICONTROLADOR PIC® 16F886.
1) Software do circuito de Mestre:

 Arquivo MAIN.c
//////////////////////////////////////////////////////////////
// SISTEMA PARA INDENTIFICAÇÃO DE CORES SENSORIZADO //
// //
// TCC - Grupo 5 - Engenharia Elétrica 5º ano - 2011 //
// //
// criação: 03/05/2011 atualização: 17/11/2011 //
/////////////////////////////////////////////////////////////
// - CIRCUITO 1 - MESTRE
//PIC 16F886
#include "htc.h"
#include "Main.h"
#include "Read_write_esteiras.h"
#include "Interrupções.h"
#include "Setup.h"
#include "Interface.h"
#include "Funções por tela.h"
//////////////////////////////////////////////////////////////////////
// VARIÁVEIS GLOBAIS //
//////////////////////////////////////////////////////////////////////
//Variáveis de rotina de teste

unsigned char habilita_escrita = 0;
unsigned char texto_teste = 0;
unsigned int deb_vezes = 0x0AFF; //teste
//----------------------------
volatile _Flags1 _GeneralFlags;
const unsigned char Tipo_Bloco[16] =

{0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31};
volatile unsigned char Qtd_Blocos[16] = {0};
volatile unsigned char Config_Blocos[16] = {0};
volatile unsigned char Bloco = 0;
/////////////////////////////////////////////////////////////////
// PROGRAMA PRINCIPAL
/////////////////////////////////////////////////////////////////
void main(void)
{
Setup(); //Chama a rotina de Setup
asm("clrwtd");
Beep_OFF();
PIN_RESET = 1; //tira resset dos demais circuitos
Buzzer = 1;
if(!botao_teste) //com a CH_RUN acionada ao ligar, entra na rotina de
testes
{
Rotina_de_testes(); //e entra na rotina de testes
}else //Caso contrário, Beep longo

{
PIN_RESET = 0;
Beep_ON();
Delay_ms(800);
Beep_OFF();
PIN_RESET = 1;
}
45
TELA_STANDBY(); //rotina no arquivo "Funções por tela"

}
//*********************************************//
void Delay_ms(unsigned int qtd_ms)
{
//funcionalidade para 8MHz
unsigned int x;
unsigned int y;
for(x = 0 ; x < qtd_ms ; x++)
{
//asm("clrwtd");
for(y=0;y<160;y++) asm("nop"); //asm("clrwtd");
}
}
//**********************************************//
//**********************************************//
void Rotina_de_testes(void)
{
Beep_ON(); // 2 beeps curtos
Delay_ms(200);
Beep_OFF();
Delay_ms(100);
Beep_ON();
Delay_ms(200);
Beep_OFF();
SendtoLCD(0x3A); //Envia a palavra "ROTINA DE TESTES"
while(!botao_teste) //aguarda soltar o botão de testes
{
}
for(;;)
{
if(!botao_teste) Debounce_teste();
if(habilita_escrita == 1)
{
while(!TXIF) //Aguarda liberar a transmissão (teste TSR)
{
}
SendtoLCD(texto_teste);
while(!TXIF) //Aguarda liberar a transmissão (teste TSR)
{
}
if(nT_N == 1) nT_N = 0;
else nT_N=1;
habilita_escrita=0;
}
}
}
//**************************
void Debounce_teste(void)
{
if(!botao_teste) deb_vezes--;
else deb_vezes = 0x0AFF;
if(deb_vezes == 0)
{
habilita_escrita = 1;
texto_teste += 2;
while(deb_vezes < 0x0AFF) //Rotina aguarda soltar o botão
{
if(botao_teste) deb_vezes++;
else deb_vezes = 0x0000;
}
}else
{
46
}
if(texto_teste > 0x3A)
{
texto_teste = 0;
nT_N ^= 1;
}
}
 Arquivo Setup.c
#include "htc.h"
#include "Setup.h"
// - CIRCUITO 1 - MESTRE
/////////////////
//FUNÇÕES LOCAIS
/////////////////
void Setup_IO(void);
void Setup_Timer(void);
void Setup_USART(void);
void Setup_Interrupts(void);
void Setup_ADC(void);
////////////////////
//FUNÇOES DE SETAGEM
////////////////////
void Setup(void)
{
//OSCCON = 0b01110100;//Configura frequência de clock
OSCCON = 0b01110101;//Para 16F886 8MHz
Setup_IO();
Setup_Timer();
Setup_USART();
Setup_ADC();
Setup_Interrupts();
SWDTEN = 0; //Mantém Watchdog desabilitado
}
void Setup_IO(void)
{
//pull-ups das portas
nRBPU = 0; //Habilita Pull Ups
// nWPUEN = 0; //Habilita Pull-ups
WPUB = 0xFE;
//TRISX --- 1 - INPUT / 0 - OUTPUT

// TRISX = 0b76543210
TRISA = 0b01110000; //Circuito #3 - Esteiras
TRISB = 0b11111110; //Teclado
TRISC = 0b00000000; //
//PORTS INITIAL STATE

// PORTX = 0b76543210
PORTA = 0x00;
PORTB = 0x00;
PORTC = 0x00;// Demais circuitos ressetados
//ANSEL --- 1 - ANALOG / 0 - DIGITAL

ANSEL = 0b00000000;//Para 16F886
ANSELH = 0b00000000;//Para 16F886
}
void Setup_Timer(void)
{
//TIMER 1
// TMR1 ON
// nothing|
// ext clk sync||
47
// low power oscil|||

// prescaler||||
// clock source||||||
// ||||||||
T1CON = 0b00000000;
TMR1IE = 1;
TMR1H = 0xB1;
TMR1L = 0xDF;
// CCPR1H = 0x00;
// CCPR1L = 0x00;
//TIMER 2
// prescaler
// TMR2 ON ||
// postscaler ||| - pre 00, post 0111 e PR2 250 para 1ms;
// ||||||| - pre 11, post 0000 e PR2 250 para 1s;
T2CON = 0b00111000;
TMR2IE = 1;
PR2 = 0xFF;//mudar tb na definição de DUTY em "Functions.c"
//CCP2CON = 0b00001100;//configure CCP2 as PWM output

//CCPR1L=25;
TMR1ON = 0;
TMR2ON = 0;
}
void Setup_USART(void)
{
SPBRGH = 0;//
SPBRG = 12;//12 para 9600 com erro de 0.3%
BRGH = 0;//
BRG16 = 0;//these registers and bits have to be set to achive desired baud
rate.
SYNC = 0;//clear for asynchronous operation
SPEN = 1;//enable serial port
TX9 = 0;//Enable/Disable 9-bit reception
ADDEN = 0;//Enable/Disable address detection
TXEN = 1;
TXIE = 0;
//RCIE = 1;
CREN = 0; //Enable/Disable reception
}
void Setup_Interrupts(void)
{
PEIE = 1; //Peripherals interrupt enable;
// IOCIE = 1; //PORTB Change interrupt;
// IOCBN = 0b00110000; //Enable IOC on pin RB3 and RB4;
// IOCBP = 0b00110000;
// RBIE = 1; //16F886
// IOCB = 0b00110000; //16F886
GIE = 1; //Global interrup enable;
}
void Setup_ADC(void)
{
}
 Arquivo INTERRUPÇÕES.c
#include "htc.h"
unsigned char t_10s=0;
//////////////////////////////////////////////////////////////
// INTERRUPÇÕES //
//////////////////////////////////////////////////////////////
void interrupt interrupcao(void)
48
{
static unsigned char ct_25ms=0;
static unsigned char ct_1s=0;
GIE = 0;
if(RCIF) //Interrupção Serial
{
flag_erro = 0;
transmition_ok = 1;
RCIF = 0;
return;
}
if(T0IF)
{
T0IF = 0;
}
/*if (TMR2IF)//interrupção TIMER2 a cada 1ms
{
t_1ms++;
TMR2IF=0;
return;
TMR2 = 0x00;
PR2 = 0xFF;
}*/
if (TMR1IF)//interrupção TIMER1 a cada 2,5ms
{
// flag_2_5ms=1;
ct_25ms++;
if(ct_25ms>=10)
{
flag_25ms=1;
ct_25ms=0;
ct_1s++;
if(ct_1s>=40)//40 para 1s
{
// flag_1s=1;
ct_1s=0;
t_10s++;
if(t_10s >= 10)
{
t_10s = 0;
Esteira_vazia = 1;
}
}
}
TMR1H = 0xB1;//
TMR1L = 0xDF;//
TMR1IF = 0;
return;
}
GIE = 1;
return;
}
 Arquivo INTERFACE.c
#include "htc.h"
#include "Main.h"
#include "Setup.h"
volatile unsigned char actual_switches;

volatile unsigned int DEB_MAX = 1000;
// CH_BAIXO -----|--
49
// CH_DIR ----||--
// CH_CONFIG ---|||--
// CH_RUN --||||--
//PORTB 0b76543210
//******************************
void Leitura_teclado(void)
{
const unsigned int deb_max = 1000;
static unsigned int deb_rb5 = 0;
if(RB5 == 0) deb_rb5++;
if(RB4 == 0) deb_rb4++;
if(RB3 == 0) deb_rb3++;
if(RB2 == 0) deb_rb2++;
if(deb_rb5 == deb_max) //Debounce botão RUN/OK

{
while(RB5 == 0)
{
}
deb_rb5 = 0;
deb_rb4 = 0;
deb_rb3 = 0;
deb_rb2 = 0;
CH_RUN = 1;
}
if(deb_rb4 == deb_max) //Debounce botão CONFIGURAÇÃO

{
while(RB4 == 0)
{
}
deb_rb5 = 0;
deb_rb4 = 0;
deb_rb3 = 0;
deb_rb2 = 0;
CH_CONFIG = 1;
}
if(deb_rb3 == deb_max) //Debounce botão DIREITA

{
while(RB3 == 0)
{
}
deb_rb5 = 0;
deb_rb4 = 0;
deb_rb3 = 0;
deb_rb2 = 0;
CH_DIR = 1;
}
if(deb_rb2 == deb_max) //Debounce botão BAIXO

{
while(RB2 == 0)
{
}
deb_rb5 = 0;
deb_rb4 = 0;
deb_rb3 = 0;
deb_rb2 = 0;
CH_BAIXO = 1;
}
}
//*****************************
void SendtoLCD(unsigned char byte)
50
{
Delay_ms(10);
TXREG = byte;
Delay_ms(20);
// nT_N = 0;
}
 Arquivo READ_WRITE_ESTEIRAS.c
#include "htc.h"
#include "Main.h"
#include "Setup.h"
//**************************************************
void Sistema_em_funcionamento(void)
{
unsigned char dadosbloco = 0;
unsigned char config = 0;
unsigned char qtd = 0;
Esteira_vazia = 0;
TMR1ON = 1;
Bit_controle = 1;
Delay_ms(1);
TRISA7 = 1;
while(1) //verifica teclado

{
if(Bit_controle == 1) //Caso receba algum dado
{
TRISA7 = 0;
Bit_controle = 0;
Bloco = PORTA & 0b00001111;
dadosbloco = Tipo_Bloco[Bloco];
SendtoLCD(dadosbloco);
Delay_ms(50);
dadosbloco = Config_Blocos[Bloco];
config = dadosbloco << 4;
PORTA &= config;
Bit_controle = 1;
switch(config)
{
case 0: dadosbloco = 0x0E; break; //palavra REJEITA
case 1: dadosbloco = 0x10; break; //palavra ESQUERDA
case 2: dadosbloco = 0x12; break; //palavra DIREITA
default: dadosbloco = 0x0E;
}
SendtoLCD(dadosbloco);
Delay_ms(50);
qtd = Qtd_Blocos[Bloco] + 1;
Qtd_Blocos[Bloco] = qtd;
if(config != 0)
{
SendtoLCD(qtd);
Delay_ms(50);
}
TRISA7 = 1;
}
if(Esteira_vazia)
{
ESTEIRAS_VAZIAS();
break;
}
51
Leitura_teclado(); //Verifica se há tecla pressionada
if(CH_RUN) //Desliga esteiras

{
CH_RUN = 0; //TELA_STANDBY();
DESLIGAR_ESTEIRAS();
break;
}
}
TMR1ON = 0;
t_10s = 0;
//**************************************************
//**************************************************
void ESTEIRAS_VAZIAS(void)
{
t_10s = 0;
DESLIGAR_ESTEIRAS();
SendtoLCD(0x06); //Escreve ESTEIRAS VAZIAS
}
//**************************************************
//**************************************************
void DESLIGAR_ESTEIRAS(void)
{
TRISA7 = 0;
PORTA &= 0b00001111;
Bit_controle = 1;
}
 Arquivo FUNÇÕES POR TELA.c

#include "htc.h"
#include "Main.h"
#include "Setup.h"
void TELA_STANDBY (void) //Tela de Stand By

{
while(1)
{
if(CH_CONFIG) TELA_CONFIGURACAO();
nT_N = 0; //Indica envio de texto
SendtoLCD(0x02); //Escreve "No aguardo" no LCD
while(CH_CONFIG == 0 && CH_RUN == 0 && CH_DIR == 0)

{
Leitura_teclado(); //Verifica tecla pressionada
}
if(CH_BAIXO) //Para baixo, verifica sequencia de cores
{
CH_BAIXO = 0;
VISUALIZAR_BLOCOS();
break;
}
if(CH_DIR) //Para direita não faz nada
{
CH_DIR = 0;
}
if(CH_CONFIG)//Entra no menú de configurações
{
CH_CONFIG = 0;
52
TELA_CONFIGURACAO();
break;
}
if(CH_RUN)
{
CH_RUN = 0;
RUNNING();
break;
}
}
}
//******************************************************************
//******************************************************************
void TELA_CONFIGURACAO (void)
{
nT_N = 0;
SendtoLCD(0x08); //envia a palavra "CONFIGURAR"
Delay_ms(100);
SendtoLCD(0x0A); //envia palavbra "BLOCOS E CORES"
while(CH_CONFIG == 0 && CH_RUN == 0 && CH_DIR == 0)

{
}

{
CH_DIR = 0;
DEFINIR_BLOCOS();
return;
}
{
CH_CONFIG = 0;
CONFIGURAR_BEEP();
return;
}
if(CH_RUN)
{
CH_RUN = 0;
return;
}
//******************************************************************
//******************************************************************
void DEFINIR_BLOCOS(void)
{
nT_N = 0;
unsigned char caixa;
unsigned char config;
unsigned char palavradestatus;
unsigned char bloco_old = 1;
Bloco = 0;
while(1) //VERIFICAR FUNCIONALIDADE
{
if(bloco_old != Bloco)
{
config = Config_Blocos[Bloco];
switch(config)
{
case 0: palavradestatus = 0x0E; break; //palavra REJEITA
case 1: palavradestatus = 0x10; break; //palavra ESQUERDA
case 2: palavradestatus = 0x12; break; //palavra DIREITA
default: palavradestatus = 0x0E; config = 0;
}
caixa = Tipo_Bloco[Bloco];
SendtoLCD(caixa); //Escreve o tipo da caixa
53
Delay_ms(100);
SendtoLCD(palavradestatus); //Escreve a config da caixa
bloco_old = Bloco;
}
while(CH_BAIXO == 0 && CH_RUN == 0 && CH_DIR == 0)

{
}
if(CH_BAIXO)
{
CH_BAIXO = 0;
Config_Blocos[Bloco] = config + 1;
}
if(CH_DIR)
{
Bloco++;
if(Bloco == 16) Bloco = 0;
}
if(CH_RUN)
{
CH_RUN = 0;
return; //Volta à tela inicial
}
}
}
//******************************************************************
//******************************************************************
void CONFIGURAR_BEEP(void)
{
//envia a palavra "BEEP_ON"
nT_N = 0;
if(Buzzer) SendtoLCD(0x16);
else SendtoLCD(0x18);

{
while(CH_RUN == 0 && CH_DIR == 0 && CH_CONFIG == 0)
{
}
{
CH_DIR = 0;
if(Buzzer)
{
Buzzer = 0;
SendtoLCD(0x18); //envia palavra "BEEP_OFF"
}else
{
Buzzer = 1;
SendtoLCD(0x16); //envia palavra "BEEP_ON"
}
}
{
CH_CONFIG = 0;
APAGAR_VALORES();
return;
}
if(CH_RUN)
{
CH_RUN = 0;
return;
}
}
}
//******************************************************************
//******************************************************************
void APAGAR_VALORES(void)
54
{
nT_N = 0;
SendtoLCD(0x1A); //envia a palavra "APAGAR VALORES"
unsigned char x;

{
{
}

{
CH_DIR = 0;
for(x = 0; x < 16; x++) Qtd_Blocos[x] = 0;
SendtoLCD(0x1C); //envia a palavra "APAGAR VALORES"
Delay_ms(800);
return;
}
{
CH_CONFIG = 0;
RESET_ALL();
return;
}
if(CH_RUN)
{
CH_RUN = 0;
return;
}
}
}
//******************************************************************
//******************************************************************
void RESET_ALL(void)
{
while(1)
{
nT_N = 0;
SendtoLCD(0x1E); //envia a palavra "RESET ALL"

{
{
}

{
CH_DIR = 0;
CONFIRMA_RESET();
break;
}
{
return;
}
if(CH_RUN)
{
CH_RUN = 0;
return;
}
}
}
}
//******************************************************************
//******************************************************************
55
void CONFIRMA_RESET(void)
{
nT_N = 0;
SendtoLCD(0x20); //envia a palavra "CONFIRMA RESET"

{
{
}

{
SWDTEN = 1; //Liga Watch Dog
while(1) //fica na rotina sem desativa watch dog
{
}
}
if(CH_CONFIG == 1 || CH_RUN == 1) //volta para tela RESET ALL
{
CH_CONFIG = 0;
CH_RUN = 0;
return;
}
}
}
//******************************************************************
//******************************************************************
void VISUALIZAR_BLOCOS(void)
{
unsigned char caixa;
Bloco = 0;
while(1) //VERIFICAR FUNCIONALIDADE
{
nT_N = 1;
caixa = Qtd_Blocos[Bloco];
SendtoLCD(caixa);
nT_N = 0;
caixa = Tipo_Bloco[Bloco];
SendtoLCD(caixa);
while(CH_BAIXO == 0 && CH_RUN == 0)

{
}
if(CH_BAIXO)
{
CH_BAIXO = 0;
Bloco++;
if(Bloco == 16) Bloco = 0;
}
if(CH_RUN)
{
CH_RUN = 0;
return;
}
}
}
//******************************************************************
//******************************************************************
void RUNNING(void)
{
SendtoLCD(0x04); //Envia a palavra "Em Funcionamento"
Sistema_em_funcionamento();
if(Esteira_vazia)
{
while(CH_RUN == 0)
56
{
}
CH_RUN = 0;
Esteira_vazia = 0;
}
}
 Arquivo MAIN.h
#include "htc.h"
/*
#define CH_RUN RB5
#define CH_CONFIG RB4
#define CH_DIR RB3
#define CH_BAIXO RB2
*/
#define PIN_RESET RC0
#define botao_teste RB5

#define nT_N RB0 //Indica se é texto ou número
#define Beep_ON() RC4 = 0

#define Beep_OFF() RC4 = 1
#define Bit_controle RA7
//***************************************************
//VARIÁVEIS EXTERNAS
typedef union
{
unsigned int Byte;
struct
{
unsigned Bit0 :1;
unsigned Bit1 :1;
unsigned Bit2 :1;
unsigned Bit3 :1;
unsigned Bit4 :1;
unsigned Bit5 :1;
unsigned Bit6 :1;
unsigned Bit7 :1;
unsigned Bit8 :1;
unsigned Bit9 :1;
unsigned Bit10 :1;
unsigned Bit11 :1;
unsigned Bit12 :1;
unsigned Bit13 :1;
unsigned Bit14 :1;
unsigned Bit15 :1;
} Bits;
} _Flags1;
extern volatile _Flags1 _GeneralFlags;
extern const unsigned char Tipo_Bloco[];

extern volatile unsigned char Qtd_Blocos[];
extern volatile unsigned char Bloco;
extern volatile unsigned char Config_Blocos[];
//extern unsigned char info_LCD;
#define GeneralFlags _GeneralFlags.Byte

57
#define flag_running _GeneralFlags.Bits.Bit0

#define flag_1ms _GeneralFlags.Bits.Bit1
#define flag_2_5ms _GeneralFlags.Bits.Bit2
#define flag_1s _GeneralFlags.Bits.Bit3
#define transmition_ok _GeneralFlags.Bits.Bit5
#define rotina_teste _GeneralFlags.Bits.Bit6
#define flag_erro _GeneralFlags.Bits.Bit7
#define Buzzer _GeneralFlags.Bits.Bit8
#define Esteira_vazia _GeneralFlags.Bits.Bit9
#define CH_RUN _GeneralFlags.Bits.Bit10
#define CH_CONFIG _GeneralFlags.Bits.Bit11
#define CH_DIR _GeneralFlags.Bits.Bit12
#define CH_BAIXO _GeneralFlags.Bits.Bit13
///////////////////////////////////////////////////////
////////////////////////////////////////////////////
void Valor_de_Texto(void);
void Valor_de_Numero(void);
void Delay_ms(unsigned int qtd_ms);
void Rotina_de_testes(void);
void Debounce_teste(void);
 Arquivo Setup.h
#include "htc.h"
#include "Main.h"
//Funções Globais
extern void Setup(void);
extern void Liga_timers(void);
 Arquivo INTERRUPÇÕES.h
#include "htc.h"
#include "Main.h"
extern unsigned char t_10s;
 Arquivo INTERFACE.h
#include "htc.h"
extern void Leitura_teclado(void);

extern void SendtoLCD(unsigned char byte);
 Arquivo READ_WRITE_ESTEIRAS.h
#include "htc.h"
extern void Sistema_em_funcionamento(void);

extern void ESTEIRAS_VAZIAS(void);
extern void DESLIGAR_ESTEIRAS(void);
 Arquivo FUNÇÕES POR TELA.h

#include "htc.h"
extern void TELA_STANDBY (void);

58
extern void TELA_CONFIGURACAO (void);

extern void VISUALIZAR_BLOCOS(void);
extern void RUNNING(void);
extern void CONFIGURAR_BEEP(void);
extern void APAGAR_VALORES(void);
extern void DEFINIR_BLOCOS(void);
extern void CONFIRMA_RESET(void);
extern void RESET_ALL(void);
APÊNDICE E – Programa circuito de potência

59
2) Software do circuito de Potência (esteiras, sensores e atuadores):

 Arquivo Main.c
//////////////////////////////////////////////////////////////
// //
// //
// //
/////////////////////////////////////////////////////////////
// - CIRCUITO 2 - ESTEIRAS
//PIC 16F886
#include "htc.h"
#include "Main.h"
#include "Setup.h"
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////

unsigned char texto_teste = 0;
//----------------------------
volatile unsigned char Whattodo[16] = {0};

volatile unsigned char Bloco = 0;
volatile unsigned char mediadacor[50];
////////////////////////////////////////////////////////////////
// PROGRAMA PRINCIPAL //
///////////////////////////////////////////////////////////////
void main(void)
{
Esteira_vazia = 0;
while(1)
{
if(Bit_controle) Ligar_sistema();
}
}
//*********************************************//
{
//funcionalidade para 8MHz
unsigned int x;
unsigned int y;
for(x = 0 ; x < qtd_ms ; x++)
{
if(S4) Bloco_no_final();
//asm("clrwtd");
for(y=0;y<160;y++) asm("nop"); //asm("clrwtd");
}
60
 Arquivo Setup.c
#include "htc.h"
#include "Setup.h"
// - CIRCUITO 2 - ESTEIRAS
/////////////////
//FUNÇÕES LOCAIS
/////////////////
////////////////////
////////////////////
void Setup(void)
{
OSCCON = 0b01110101;//Para 16F886 8MHz
Setup_IO();
Setup_Timer();
Setup_USART();
Setup_ADC();
Setup_Interrupts();
SWDTEN = 0; //Mantém Watchdog desabilitado
}
void Setup_IO(void)
{
// nRBPU = 0; //Habilita Pull Ups
// nWPUEN = 0; //Habilita Pull-ups
// WPUX = 0b76543210
// WPUA = 0xFF;
// WPUB = 0xFE;
// WPUC = 0xFF;

// TRISX = 0b76543210
TRISA = 0b11110000; //Circuito #1 - Mestre
TRISB = 0b01111111; //Sensores
TRISC = 0b00000000; //

// PORTX = 0b76543210
PORTA = 0x00;
PORTB = 0x80;
PORTC = 0b00000011; // Demais circuitos ressetados

//ANSELA = 0b00000001;
//ANSELB = 0b00000000;
ANSEL = 0b00000000;//Para 16F886
ANSELH = 0b00000000;//Para 16F886
}
{
//TIMER 1
// TMR1 ON
// nothing|
// ext clk sync||
61
// prescaler||||
// ||||||||
T1CON = 0b00000000;
TMR1IE = 1;
TMR1H = 0xB1;
TMR1L = 0xDF;
// CCPR1H = 0x00;
// CCPR1L = 0x00;
//TIMER 2
// prescaler
// TMR2 ON ||
// postscaler |||
// ||||||| - pre 11, post 1111 e PR2 32mS;
T2CON = 0b01111011;
TMR2IE = 1;
PR2 = 0xFA;//mudar tb na definição de DUTY em "Functions.c"
//Interrupts a cada 8ms
//CCP2CON = 0b00001100;//configure CCP2 as PWM output

//CCPR1L=25;
TMR1ON = 0;
TMR2ON = 0;
}
{
}
{
// IOCBP = 0b00110000;
// RBIE = 1; //16F886
// IOCB = 0b00110000; //16F886
}
{
}
 Arquivo Interrupções.c
#include "htc.h"
unsigned char t_10s=0;
/////////////////////////////////////////////////////////////////////
// INTERRUPÇÕES
//
///////////////////////////////////////////////////////////////////
void interrupt interrupcao(void)
{
static unsigned char ct_25ms = 0;
static unsigned char ct_1s = 0;
static unsigned int ct_8s = 0;
GIE = 0;
if(T0IF)
{
T0IF = 0;
}
62
if(TMR2IF)
{
TMR2IF = 0;
ct_8s++;
if(ct_8s >= 1000);
{
ct_8s = 0;
EsteiraC = OFF;
TMR2ON = 0; //desliga timer2
TMR2 = 0x00;
}
}
{
// flag_2_5ms=1;
ct_25ms++;
if(ct_25ms>=10)
{
flag_25ms=1;
ct_25ms=0;
ct_1s++;
if(ct_1s>=40)//40 para 1s
{
// flag_1s=1;
ct_1s=0;
t_10s++;
if(t_10s >= 10)
{
t_10s = 0;
Esteira_vazia = 1;
}
}
}
TMR1H = 0xB1;//
TMR1L = 0xDF;//
TMR1IF = 0;
}
GIE = 1;
return;
}
 Arquivo Read_write_esteiras.c
#include "htc.h"
#include "Main.h"
#include "Setup.h"
//**************************************************
//*********************************************//
volatile char box_position = 0;
//volatile char position_out = 0;
void Ligar_sistema(void)
{
Liga_sensores = ON;
EsteirasAB = ON;
TRISA7 = 0; //Seta Bit_controle como saída
TMR1ON = 1;
while(1)
{
if(Esteira_vazia) Desligar_tudo(); break;
if(S1) Entrada_de_bloco();
}
}
//*********************************************//
63
void Desligar_tudo(void)
{
TMR1ON = 0;
TMR1H = 0xB1;
TMR1L = 0xDF;
TRISA7 = 1;
Liga_sensores = OFF;
EsteirasAB = OFF;
}
void Entrada_de_bloco(void)
{
unsigned char colorposition = 0;
unsigned char leituracoratual = 0;
unsigned char corlida = 0;
t_10s = 0; //zera contador de 10segundos

while(!S3)
{
leituracoratual = PORTB & 0b00111000;
leituracoratual>>=3;
Delay_ms(30);//30ms X 50 = 1,5 s para o bloco passar do sensor 1 ao
sensor 3
mediadacor[colorposition];
if(colorposition < 50) colorposition++;
}
if(S1) bloco_grande=1; //Bloco grande
else bloco_grande=0;
colorposition = colorposition/2;
corlida = mediadacor[colorposition];
if(bloco_grande) corlida+=1;
PORTA |= corlida;
Bit_controle = 1;
Delay_ms(50);
Aguardar_resposta();
}
//**************************************************
//**************************************************
void Aguardar_resposta(void)
{
TRISA7 = 1;
while(1)
{
if(Bit_controle) Armazenar_Whattodo(); break;
}
}
//**************************************************
void Armazenar_Whattodo(void)
{
}
//**************************************************
void Bloco_no_final(void)
{
//**************************************************
void DESLIGAR_ESTEIRAS(void)
{
TRISA7 = 0;
PORTA &= 0b00001111;
Bit_controle = 1;
64
 Arquivo Main.h
#include "htc.h"
/*
--- SENSORES ---
RB0 - S4 => Sensor final
RB1 - S3 => Sensor tamanho
RB2 - S1 => Sensor de entrada
RB3 - B => BLUE
RB4 - G => GREEN
RB5 - R => RED
RC4 e 5 - Atuador1 => Rejeita
RC6 e 7 - Atuador2 => Direita/esquerda
*/
#define S4 RB0
#define S3 RB1
#define S1 RB2
#define ON 0
#define OFF 1
#define EsteirasAB RC0
#define EsteiraC RC1
#define Liga_sensores RB7
#define Bit_controle RA7
//***************************************************
typedef union
{
unsigned int Byte;
struct
{
unsigned Bit0 :1;
unsigned Bit1 :1;
unsigned Bit2 :1;
unsigned Bit3 :1;
unsigned Bit4 :1;
unsigned Bit5 :1;
unsigned Bit6 :1;
unsigned Bit7 :1;
unsigned Bit8 :1;
unsigned Bit9 :1;
unsigned Bit10 :1;
unsigned Bit11 :1;
unsigned Bit12 :1;
unsigned Bit13 :1;
unsigned Bit14 :1;
unsigned Bit15 :1;
} Bits;
} _Flags1;
extern volatile unsigned char Whattodo[];

extern volatile unsigned char Bloco;
extern volatile unsigned char mediadacor[];
//extern unsigned char info_LCD;

65
#define flag_running _GeneralFlags.Bits.Bit0

#define transmition_ok _GeneralFlags.Bits.Bit5
#define rotina_teste _GeneralFlags.Bits.Bit6
#define flag_erro _GeneralFlags.Bits.Bit7
#define bloco_grande _GeneralFlags.Bits.Bit8
#define Esteira_vazia _GeneralFlags.Bits.Bit9
 Arquivo Setup.h
#include "htc.h"
#include "Main.h"
//Funções Globais
 Arquivo Interrupções.h
#include "htc.h"
#include "Main.h"
extern unsigned char t_10s;
 Arquivo Read_write_esteiras.h
#include "htc.h"
extern void Sistema_em_funcionamento(void);

extern void ESTEIRAS_VAZIAS(void);
extern void DESLIGAR_ESTEIRAS(void);
APÊNDICE F – Programa interface homem máquina

66
3) Software de interface Homem-máquina (Display, LEDs e beep):

 Arquivo Main.c
//////////////////////////////////////////////////////////////
// //
// //
// //
//////////////////////////////////////////////////////////////
// CIRCUITO 3 - DISPLAY
//PIC 16F886
#include "htc.h"
#include "Main.h"
#include "Setup.h"
#include "LCD Basic Instructions.h"
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//Palavras e textos para escrita no Display

unsigned char valor_recebido; //Dado recebido pela serial
unsigned char status_circuito; //status para acionamento LEDs e Buzzer (os
2 MSB)
volatile char LCD_line = 1;
volatile char LCD_column = 1;
/*
unsigned char texto_teste = 0x3A;
//----------------------------
*/
const unsigned int TEXTO_1[16] = {'A','g','u','a','r','d','a','n','d','o'};
const unsigned int TEXTO_2[16] = {'E','M','
','F','U','N','C','I','O','N','A','M','E','N','T','O'};
const unsigned int TEXTO_3[16] = {'E','S','T','E','I','R','A','
','V','A','Z','I','A'};
const unsigned int TEXTO_4[16] = {'C','O','N','F','I','G','U','R','A','R'};
const unsigned int TEXTO_5[16] = {'B','L','O','C','O','S',' ','e','
','C','O','R','E','S',' ',' '};
const unsigned int TEXTO_6[16] = {'R','E','J','E','I','T','A','D','O',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_7[16] = {'R','E','J','E','I','T','A',' ',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_8[16] = {'E','S','Q','U','E','R','D','A',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_9[16] = {'D','I','R','E','I','T','A',' ',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_10[16] = {0};
const unsigned int TEXTO_11[16] = {'B','e','e','p',' ','O','N',' ',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_12[16] = {'B','e','e','p',' ','O','F','F',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_13[16] = {'A','P','A','G','A','R','
','V','A','L','O','R','E','S',' ',' '};
const unsigned int TEXTO_14[16] = {'A','P','A','G','A','D','O','S',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_15[16] = {'R','E','S','E','T',' ','A','L','L','?',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_16[16] = {'C','O','N','F','I','R','M','A','R','?',' ','
',' ',' ',' ',' '};
67
const unsigned int TEXTO_17[16] = {'B','R','A','N','C','O',' ','P','E','Q',' ','

',' ',' ',' ',' '};
const unsigned int TEXTO_18[16] = {'V','E','R','M','E','L','H','O','
','P','E','Q',' ',' ',' ',' '};
const unsigned int TEXTO_19[16] = {'V','E','R','D','E',' ','P','E','Q',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_20[16] = {'A','Z','U','L',' ','P','E','Q',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_21[16] = {'A','Z','U','L',' ','C','L','A','R','O','
','P','E','Q',' ',' '};
const unsigned int TEXTO_22[16] = {'R','O','S','A',' ','P','E','Q',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_23[16] = {'A','M','A','R','E','L','O',' ','P','E','Q','
',' ',' ',' ',' '};
const unsigned int TEXTO_24[16] = {'P','R','E','T','O',' ','P','E','Q',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_17_[16] = {'B','R','A','N','C','O',' ','G','D','E',' ','

',' ',' ',' ',' '};
const unsigned int TEXTO_18_[16] = {'V','E','R','M','E','L','H','O','
','G','D','E',' ',' ',' ',' '};
const unsigned int TEXTO_19_[16] = {'V','E','R','D','E',' ','G','D','E',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_20_[16] = {'A','Z','U','L',' ','G','D','E',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_21_[16] = {'A','Z','U','L',' ','C','L','A','R','O','
','G','D','E',' ',' '};
const unsigned int TEXTO_22_[16] = {'R','O','S','A',' ','G','D','E',' ',' ',' ','
',' ',' ',' ',' '};
const unsigned int TEXTO_23_[16] = {'A','M','A','R','E','L','O',' ','G','D','E','
',' ',' ',' ',' '};
const unsigned int TEXTO_24_[16] = {'P','R','E','T','O',' ','G','D','E',' ',' ','
',' ',' ',' ',' '};

const unsigned int TEXTO_27[16] = {'E','R','R','O','
','C','O','M','U','N','I','C','A','C','A','O'};
const unsigned int TEXTO_TESTES[16] = {'R','O','T','I','N','A',' ','D','E','
','T','E','S','T','E','S'};
volatile unsigned int word[16];
//////////////////////////////////////////////////////////////////////
// PROGRAMA PRINCIPAL //
//////////////////////////////////////////////////////////////////////
void main(void)
{
Delay_ms(100);
// rotina_teste = 0;
// if(!botao_teste) rotina_teste = 1;
Init_LCD();
nT_N = 0;
flag_erro = 0;
// if(!rotina_teste) //ROTINA FUNCIONAL NORMAL

// {
unsigned char lixo;
Beep_ON();
Delay_ms(600);
Beep_OFF();
Send_word_LCD(2); //Escreve "Stand By"
68
while(1)
{
if((FERR == 1|OERR == 1) & flag_erro == 0) //Verificam os
erros seriais
{
flag_erro = 1;
CREN = 0;
Send_word_LCD(Erro); //Escreve ERRO FUNCIONAL no
Display
lixo = Buffer;//RCREG;
CREN = 1;
}
if(reception_ok)
{
//CREN = 0;
//CREN = 1;
//nT_N = nono_bit; //Verifica se é texto ou número
verificando porta RB0
valor_recebido = Buffer; //RCREG;
status_circuito = valor_recebido & 0b11000000;
//Mantém somente os 2 MSB
status_circuito >>= 6;
//transforma nos 2 LSB
if(nono_bit == 1)
{
Valor_de_Numero();
}else
{
Valor_de_Texto();
}
reception_ok = 0;
}
// }
}
//*********************************************************************
/*else //ROTINA DE TESTES
{
Beep_ON();
Delay_ms(100);
Beep_OFF();
Delay_ms(100);
Beep_ON();
Delay_ms(150);
Beep_OFF();
LED_EMERG_ON();
LED_SB_ON();
LED_RUN_ON();
Send_word_LCD(Testes); //Escreve "Rotina de testes"
while(1)
{
if(!botao_teste) Debounce_teste();
asm("clrwdt");
if(habilita_escrita)
{
valor_recebido = texto_teste;
if(valor_recebido >= 0x3A)

{
nono_bit=1; //referente ao nono bit do
Serial
}
if(nono_bit == 1)
{
Valor_de_Numero();
}
else
{
Valor_de_Texto();
69
}
}
}
}*/
}
//*********************************************//
void Valor_de_Texto(void)
{
LED_EMERG_OFF();
LED_RUN_OFF();
LED_SB_OFF();
Send_word_LCD(valor_recebido);
switch(status_circuito)
{
case 1: //indica sistema em Stand By
LED_EMERG_OFF();
LED_RUN_OFF();
LED_SB_ON();
break;
case 2: //indica sistema em Funcionamento
LED_EMERG_OFF();
LED_RUN_ON();
LED_SB_OFF();
break;
case 3: //indica sistema em Emergência com LED e 3 beeps
LED_EMERG_ON();
LED_RUN_OFF();
LED_SB_OFF();
Beep_ON();
Delay_ms(100); //Beep curto
Beep_OFF();
Delay_ms(50);
Beep_ON();
Delay_ms(100); //beep curto
Beep_OFF();
Delay_ms(50);
Beep_ON();
Delay_ms(600); //beep longo
Beep_OFF();
break;
default: break;
}
//*********************************************//
void Valor_de_Numero(void)
{
LCD_line = 1;
LCD_column = 14;
Send_number_LCD(valor_recebido);
//*********************************************//
{
unsigned int x;
unsigned int y;
for(x = 0 ; x < qtd_ms ; x++)

{
//asm("clrwdt");
for(y=0;y<160;y++) asm("nop"); //funciona em 8MHz
}
}
70
//********************************************************************************
//********************************************************************************
//********************************************************************************
void LED_EMERG_ON(void)
{
RC4=1;
Beep_ON();
Delay_ms(800); //Beep longo
Beep_OFF();
}
void Beep_ON(void)
{
RC5 = ~Buzzer;
}
 Arquivo Setup.c
#include "htc.h"
#include "Setup.h"
// CIRCUITO 3 - DISPLAY
/////////////////
//FUNÇÕES LOCAIS
/////////////////
////////////////////
////////////////////
void Setup(void)
{
OSCCON = 0b01110101;//Para 16F886 - 8MHz
Setup_IO();
Setup_Timer();
Setup_USART();
Setup_ADC();
Setup_Interrupts();
// SWDTEN = 1;//Habilita Watchdog
}
void Setup_IO(void)
{
// WPUX = 0b76543210
// WPUA = 0xFF;
WPUB = 0b00100001;
// WPUC = 0xFF;
nRBPU = 0; //Habilita Pull Ups

// TRISX = 0b76543210
TRISA = 0b00000000;
TRISB = 0b11111111;
TRISC = 0b10000000;

// PORTX = 0b76543210
PORTA = 0x00;
//PORTB = 0b00100001;
PORTC = 0x10100000;

//ANSELA = 0b00000001;
71
//ANSELB = 0b00000000;
ANSEL = 0b00000000;//Para 16F886
ANSELH = 0b00000000;//Para 16F886
}
{
//TIMER 0
// prescaler
// presc. ref ao tmr0 |||
// ||||
// OPTION &= 0b11001111;
// T0IE = 0; //Interrupção do timer 0 desabilitada
//TIMER 1
// TMR1 ON
// nothing|
// ext clk sync||
// prescaler||||
// ||||||||
// T1CON = 0b00000100;
// TMR1IE = 0;
// TMR1H = 0xFF;
// TMR1L = 0xFF;
// CCPR1H = 0x00;
// CCPR1L = 0x00;
//TIMER 2
// prescaler
// TMR2 ON ||
// postscaler ||| - pre 00, post 0111 e PR2 250 para 1ms;
// ||||||| - pre 11, post 0000 e PR2 250 para 1s;
// T2CON = 0b00111000;
// TMR2IE = 1;
// PR2 = 0xFF;//Valor Final do timer2
// CCP2CON = 0b00001100;//configure CCP2 as PWM output

// CCPR1L=25;
// TMR1ON = 0;
// TMR2ON = 1;
}
{
SPBRGH = 0;//
SPBRG = 12;//12 para 9600 com erro de 0.3%
BRGH = 0;//
BRG16 = 0;//these registers and bits have to be set to achive desired baud
rate.
SYNC = 0; //clear for asynchronous operation
SPEN = 1; //enable serial port
RX9 = 0; //Enable/Disable 9-bit reception
ADDEN = 0; //Enable/Disable address detection
// TXEN = 1;
// TXIE = 0;
RCIE = 1;
CREN = 1; //Enable/Disable reception
}
{
// IOCBP = 0b00110000;
// RBIE = 1; //16F886
// IOCB = 0b00110000; //16F886
}
72
{
// ADCON0 = 0b00000001;
// ADCON1 = 0b00000000;
// GO_nDONE= 1;
}
 Arquivo Interrupções.c
#include "htc.h"
unsigned char t_1ms=0;

unsigned char Buffer = 0;
////////////////////////////////////////////////////////////////
// INTERRUPÇÕES //
///////////////////////////////////////////////////////////////
void interrupt interruption(void)
{
// static unsigned char ct_25ms=0;
// static unsigned char ct_1s=0;
GIE = 0;
if(RCIF) //Interrupção Serial
{
Buffer = RCREG;
RCIF = 0;
flag_erro = 0;
reception_ok = 1;
nT_N = nono_bit; //Verifica se é texto ou número verificando porta
RB0
}
if(T0IF)
{
T0IF = 0;
}
{
flag_2_5ms=1;
TMR1IF = 0;
}
GIE = 1;
return;
}
 Arquivo LCD basic Instructions.c

#include "htc.h"
#include "LCD Basic Instructions.h"
#include "Main.h"
#define tw 2 //tempo de escrita de letra no display (time Write)
unsigned char numero = 0x00; //Número a ser escrito no visor

unsigned char cod_texto = 0x00; //Texto a ser escrito (os 6 LSB)
void Init_LCD(void)
{
LCD_COMANDO();
LCD_DATA = 0X38; //Cursor para direita
LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(15);
73

LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(15);

LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(tw);
LCD_DATA = 0X0E; //Liga cursor

LCD_enable();\
asm("nop");
LCD_disable();
Delay_ms(tw);
Limpa_display();
}
extern void Limpa_display (void)
{
LCD_COMANDO();
LCD_DATA = 0X01; //Limpa display
LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(15);
}
void Send_word_LCD(char palavra)

{
unsigned char num_letra=0;
Verificar_texto(palavra);
LCD_posicao();
for(num_letra = 0; num_letra < 16; num_letra++)
{
if(word[num_letra] == 0x00) break; //se acabar a palavra, sai da
função
LCD_DADO();
LCD_DATA = word[num_letra];
LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(tw);
}
}
//*********************************************//
void Send_number_LCD(char numero)
{
unsigned char unidade = 0;
unsigned char dezena = 0;
unsigned char centena = 0;
unsigned char digito = 0;
centena = numero/100;
dezena = numero/10 - centena*10;
unidade = numero - (centena*100 + dezena*10);
word[0] = centena + 48; //48 corresponde à 0 (zero) em ASCII

word[1] = dezena + 48;
word[2] = unidade + 48;
LCD_line = 2;
LCD_posicao();
for(digito = 0; digito < 3; digito++)

{
LCD_DADO();
LCD_DATA = word[digito];
74
LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(tw);
}
}
//*********************************************//
void LCD_posicao(void)
{
unsigned char posicao;
LCD_COMANDO();
if(LCD_line == 1) posicao = 0X80;
else posicao = 0XC0;
posicao = posicao + LCD_column - 1; //define posição inicial
LCD_DATA = posicao;
LCD_enable();
asm("nop");
LCD_disable();
Delay_ms(15);
//LCD_line = 1;
}
//*****************************************//
//*** ***//
//*** ESCRITAS PRINCIPAIS ***//
//*** ***//
//*****************************************//
void Verificar_texto(char cod_texto)

{
unsigned int i;
if(cod_texto > 0x3B)

{
Limpa_display();
LED_EMERG_ON();
for(i = 0; i < 16; i++) word[i] = TEXTO_27[i];
return;
}
switch(cod_texto)
{
case 0x00: break;
case 0x02: // escreve: STAND BY

LED_SB_ON();
Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x04: // escreve: RUNNING

Limpa_display();
LED_RUN_ON();
LCD_line = 1;
LCD_column = 1;
break;
case 0x06: // escreve: ESTEIRA VAZIA

LED_EMERG_ON();
Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
75
case 0x08: // escreve: CONFIGURAR

Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x0A: // escreve: BLOCOS E CORES

LCD_line = 2;
LCD_column = 1;
break;
case 0x0C: // escreve: REJEITADO

LCD_line = 2;
LCD_column = 1;
break;
case 0x0E: // escreve: REJEITA

LCD_line = 2;
LCD_column = 1;
break;
case 0x10: // escreve: ESQUERDA

LCD_line = 2;
LCD_column = 1;
break;
case 0x12: // escreve: DIREITA

LCD_line = 2;
LCD_column = 1;
break;
case 0x14: // escreve:

// for(i = 0; i < 16; i++) word[i] = TEXTO_10[i];
// LCD_line = 2;
// LCD_column = 1;
break;
case 0x16: // escreve: Beep ON

//Limpa_display();
Buzzer = 1;
LCD_line = 2;
LCD_column = 1;
break;
case 0x18: // escreve: Beep OFF

//Limpa_display();
Buzzer = 0;
LCD_line = 2;
LCD_column = 1;
break;
case 0x1A: // escreve: APAGAR VALORES

//Limpa_display();
LCD_line = 2;
LCD_column = 1;
break;
case 0x1C: // escreve: APAGADOS

//Limpa_display();
LCD_line = 1;
76
LCD_column = 1;
break;
case 0x1E: // escreve: RESET ALL?

Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x20: // escreve: CONFIRMAR?

//Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x22: // escreve: BRANCO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x24: // escreve: VERMELHO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x26: // escreve: VERDE

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x28: // escreve: AZUL

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x2A: // escreve: AZUL CLARO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x2C: // escreve: ROSA

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x2E: // escreve: AMARELO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x30: // escreve: PRETO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
77
break;
case 0x23: // escreve: BRANCO

// Limpa_display();
for(i = 0; i < 16; i++) word[i] = TEXTO_17_[i];
LCD_line = 1;
LCD_column = 1;
break;
case 0x25: // escreve: VERMELHO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x27: // escreve: VERDE

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x29: // escreve: AZUL

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x2B: // escreve: AZUL CLARO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x2D: // escreve: ROSA

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x2F: // escreve: AMARELO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;
case 0x31: // escreve: PRETO

// Limpa_display();
LCD_line = 1;
LCD_column = 1;
break;

// Limpa_display();
// LCD_line = 1;
// LCD_column = 12;
break;

// Limpa_display();
// LCD_line = 1;
// LCD_column = 12;
break;
78
case 0x36: // escreve: ERRO FUNCIONAL

Limpa_display();
LED_EMERG_ON();
LCD_line = 1;
LCD_column = 1;
break;
case 0x3A: // escreve: ROTINA DE TESTES

Limpa_display();
LED_EMERG_ON();
for(i = 0; i < 16; i++) word[i] = TEXTO_TESTES[i];
LCD_line = 1;
LCD_column = 1;
break;
default:
word[0] = 0;
Limpa_display();
break;
}
}
 Arquivo Main.h
#include "htc.h"
#define LED_RUN_ON() RC2=1

#define LED_RUN_OFF() RC2=0
#define LED_SB_ON() RC3=1
#define LED_SB_OFF() RC3=0
#define LED_EMERG_OFF() RC4=0
//#define botao_teste RB5
#define Beep_OFF() RC5 = 1 //|
#define nono_bit RB0 // 0 se for texto, 1 se for nº
#define Erro 0x36

#define Testes 0x3A
//***************************************************
typedef union
{
unsigned char Byte;
struct
{
unsigned Bit0 :1;
unsigned Bit1 :1;
unsigned Bit2 :1;
unsigned Bit3 :1;
unsigned Bit4 :1;
unsigned Bit5 :1;
unsigned Bit6 :1;
unsigned Bit7 :1;
} Bits;
} _Flags1;
#define nT_N _GeneralFlags.Bits.Bit0 //Verificação texto /nº

79

#define flag_erro _GeneralFlags.Bits.Bit5 //Indica que já ocorreu um erro de
comunicação serial
#define reception_ok _GeneralFlags.Bits.Bit6
#define Buzzer _GeneralFlags.Bits.Bit7
//#define rotina_teste _GeneralFlags.Bits.Bit7
///////////////////////////////////////////////////////
extern unsigned char valor_recebido;
extern unsigned char status_circuito;
extern unsigned char cod_texto;
extern unsigned char numero;
extern volatile char LCD_line;
extern volatile char LCD_column;
extern const unsigned int TEXTO_1[];

extern const unsigned int TEXTO_17_[];


extern const unsigned int TEXTO_TESTES[];
extern volatile unsigned int word[16];
////////////////////////////////////////////////////
extern void Valor_de_Texto(void);
extern void Valor_de_Numero(void);
extern void Delay_ms(unsigned int qtd_ms);
extern void LED_EMERG_ON(void);
extern void Beep_ON(void);
 Arquivo Setup.h
#include "htc.h"
80
#include "Main.h"
//Funções Globais
 Arquivo Interrupções.h
#include "htc.h"
#include "Main.h"
extern unsigned char t_1ms;

extern unsigned char Buffer;
 Arquivo LCD basic Instructions.h

#include "htc.h"
//#include "Main.h"
#define LCD_DATA PORTA

#define LCD_enable() RC0=1 //Enable Display
#define LCD_disable()RC0=0 //Disable Display
//_____________________________
//#define LCD_RS RC1 //0=Comando | 1=Dados
//#define dado 1
//#define comando 0
#define LCD_COMANDO()RC1 = 0
#define LCD_DADO() RC1 = 1
//_____________________________
/*******************************
Protótipo de Funções
*******************************/
extern void Init_LCD(void);

extern void Send_word_LCD(char palavra);
extern void Send_number_LCD(char numero);
extern void LCD_posicao(void);
extern void Delay_15ms (void);
extern void Limpa_display (void);
extern void Verificar_texto(char cod_texto);
APÊNDICE G – Placa Circuito Esteiras, Sensores e Atuadores

81
APÊNDICE H – Placa Painel de Controle e Operações

82
APÊNDICE I – Placa Sensor de Cor

83
Placa de controle RGB
Placa de recepção LDR

TCC - Sistema Sensorizado Por Cor e Tamanho

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TCC - Sistema Sensorizado Por Cor e Tamanho

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE PAULISTA - UNIP

INSTITUTO DE CIÊNCIAS E TECNOLOGIA

Fernando Américo Velozo

SISTEMA SENSORIZADO PARA MONITORAMENTO FINAL DE PRODUTOS

SISTEMA SENSORIZADO PARA MONITORAMENTO FINAL DE PRODUTOS

Trabalho de conclusão de curso para

Orientador: Prof. Msc. Marcelo Alves

Fernando Américo Velozo

SISTEMA SENSORIZADO PARA MONITORAMENTO FINAL DE PRODUTOS

Trabalho de conclusão de curso para

Dedicamos esse trabalho às nossas famílias, que tanto contribuíram nos

Agradecemos em primeiro lugar a DEUS por ser a base das minhas

Aos nossos familiares, por acreditar e terem interesse em minhas

Aos professores pela dedicação em suas orientações prestadas na

Este projeto consiste em um sistema eletrônico para supervisão e padrão de

Visando aumentar a produtividade e reduzir, ou até mesmo eliminar custos

O processo será comandado por um software que depois de configurado

Palavras Chave: Sensor de cor; RGB; monitoramento de cor/ tamanho.

This project consists of an electronic system for supervision and quality

To increase productivity and reduce or even eliminate unnecessary costs out

Keywords: Color sensor; RGB; color/ size assistance.

O trabalho proposto consiste na fabricação de um sistema para supervisão

O sistema descrito neste trabalho torna-se diferenciado por possuir diversas

Atualmente, no mercado, os sensores de cor mais baratos utilizam 3 LEDs

Nosso trabalho consiste em construir um sensor que possua 1 emissor de luz

Os resultados obtidos não apresentaram taxa de variação necessária para

Visando economia no processo, utilizaremos os receptores formados por 3

O diagrama elétrico do sensor será similar ao apresentado abaixo:

Figura 1 – Diagrama elétrico do sensor de cor com sensor de presença

Note que no diagrama apresentado, há um sensor de presença instalado.

Os valores referentes aos resistores R1, R2 e R3 podem ser diferentes pois,

3. RECEPÇÃO DAS CORES

A cor é uma percepção visual provocada pela ação de um feixe de fótons

A cor é relacionada com os diferentes comprimentos de onda do espectro

Considerando as cores como luz, a cor branca resulta da sobreposição de

Este sistema CMYK é constituído pelas cores Ciano, Magenta e Amarelo

O sistema RGB é utilizado quando tratamos de definição de cor através de

Estes sistemas são complementares um ao outro, podendo ser descritos

Todas as cores, visíveis e não visíveis, são diferenciadas apenas pelo

Cores do espectro visível

Cor Comprimento de onda Freqüência

Vermelho ~ 625-740 nm ~ 480-405 THz

Laranja ~ 590-625 nm ~ 510-480 THz

Amarelo ~ 565-590 nm ~ 530-510 THz

Verde ~ 500-565 nm ~ 600-530 THz

Ciano ~ 485-500 nm ~ 620-600 THz

Azul ~ 440-485 nm ~ 680-620 THz

Violeta ~ 380-440 nm ~ 790-680 THz

Figura 2 – Espectro Contínuo

Ao enxergarmos determinada cor em um objeto, na verdade, estamos

Entende-se, portanto, que se um objeto é da cor azul, por exemplo, é porque

Quanto maior a intensidade da cor na superfície do objeto observado, maior a

A combinação de diversas intensidades das cores primárias (vermelho, verde

Esta característica explica o funcionamento dos sensores de presença por IR

4. APRESENTAÇÃO DO PROJETO PROPOSTO

O trabalho proposto consiste na fabricação de um sistema para supervisão

O sistema descrito neste trabalho torna-se diferenciado por possuir diversas

A proposta do projeto é desenvolver um sistema que irá realizar a contagem

Para nosso trabalho, serão desenvolvidos sensor de cor RGB, sensores de

5.1 Sensor de cor RGB:

O sensor de reconhecimento de cor RGB digital será responsável pela leitura

O sensor será composto de um LED RGB e três LDRs que serão

5.2 Esteiras automatizadas