visÃo computacional aplicada a robÔs autÔnomos...
TRANSCRIPT
1
1
INSTITUTO FEDERAL FLUMINENSE
BACHARELADO EM SISTEMAS DE INFORMAÇÃO
DANIEL LEMOS DE ALMEIDA NASCIMENTO
ISABELLA CRISTINA CAMPOS DOS SANTOS
NATHAN MATTA SORRENTINO
VISÃO COMPUTACIONAL APLICADA A ROBÔS AUTÔNOMOS DE
BAIXO CUSTO
CAMPOS DOS GOYTACAZES/ RJ 2016
2
DANIEL LEMOS DE ALMEIDA NASCIMENTO
ISABELLA CRISTINA CAMPOS DOS SANTOS
NATHAN MATTA SORRENTINO
VISÃO COMPUTACIONAL APLICADA A ROBÔS AUTÔNOMOS DE
BAIXO CUSTO
Trabalho de Conclusão de Curso apresentado ao Instituto Federal Fluminense, Campus Campos-Centro como requisito parcial para a conclusão do Curso de Bacharelado em Sistemas de Informação.
Orientador: M.Sc. Fábio Duncan de Souza
CAMPOS DOS GOYTACAZES/ RJ
2016
3
4
DANIEL LEMOS DE ALMEIDA NASCIMENTO
ISABELLA CRISTINA CAMPOS DOS SANTOS
NATHAN MATTA SORRENTINO
VISÃO COMPUTACIONAL APLICADA A ROBÔS AUTÔNOMOS DE
BAIXO CUSTO
Trabalho de Conclusão de Curso apresentado ao Instituto Federal Fluminense, Campus Campos-Centro como requisito parcial para a conclusão do Curso de Bacharelado em Sistemas de Informação.
Aprovada em 30 Agosto de 2016.
Banca Avaliadora:
........................................................................................................................................ Prof. Fábio Duncan de Souza (Orientador)
Mestre em Pesquisa Operacional e Inteligência Computacional /UCAM Instituto Federal Fluminense / Campos dos Goytacazes
........................................................................................................................................
Prof. David Vasconcelos Corrêa da Silva Mestre em Pesquisa Operacional e Inteligência Computacional /UCAM
Instituto Federal Fluminense / Campos dos Goytacazes
........................................................................................................................................ Prof.ª Ana Silvia Ribeiro Escocard Santiago
Mestre em Pesquisa Operacional e Inteligência Computacional /UCAM Instituto Federal Fluminense / Campos dos Goytacazes
5
AGRADECIMENTOS
Agradeço primeiramente a Deus pelo Amor, graça, força e saúde que me tem
concedido. Aos meus pais Rozana e Nilton, pelo constante apoio e pelo incentivo.
Ao meu professor e orientador Fábio Duncan por todo suporte e por todo ensino
passado ao longo do curso. Agradeço aos meus colegas de classe que muito me
ajudaram a chegar até aqui. A todos que direta ou indiretamente me ajudaram nessa
caminhada que agora chega ao fim.
Daniel Lemos de Almeida Nascimento
Primeiramente agradeço a Deus, pois sem ele nada teria feito. Aos meus
pais Vânia e Cláudio por me apoiarem em todos os momentos da minha vida. A eles
devo tudo e serei eternamente grata. Ao meu namorado Fellipe, pela paciência, e
por apoiar todos os meus sonhos. Ao professor Fábio Duncan por suas contribuições
durante todo o trabalho. As minhas tias, irmãs e a todos os familiares, pelos
conselhos e carinhos. A todos que contribuíram para que esse momento se tornasse
real, pois isso é só o começo.
Isabella Cristina Campos dos Santos
Gostaria de agradecer a Deus em primeiro lugar, por ter me dado saúde e
força para superar as dificuldades. Ao meu orientador Prof. Fábio Duncan e os
professores que fazem parte dessa banca, David Vasconcelos e Ana Silvia Ribeiro,
pela dedicação e compreensão. Aos meus pais Luiz e Gina, pelos conselhos e por
me apoiar, sempre me dando segurança em todas as minhas decisões. A minha
namorada Nina pela paciência e carinho. Aos meus amigos Daniel e Isabella
que participaram desse projeto. Sem vocês, nada disso teria sido possível.
Mais uma etapa de nossas vidas concluída, que venha a próxima.
Nathan Matta Sorrentino
6
RESUMO
Desde seu surgimento, a plataforma Arduino, revolucionou a forma de se realizar
projetos automatizados, devido a sua facilidade de uso e baixo custo. Em paralelo, a
área de visão computacional, está em pleno crescimento atuando em diversos
campos da ciência, como na medicina, aviação e principalmente na área de robótica.
Por considerar a visão, um dos sentidos mais importantes, o homem está em busca
constante de meios para reproduzir esse campo. Este trabalho apresenta o estudo e
a montagem de um robô autônomo móvel de pequeno porte que, utilizando de visão
computacional, será guiado por um objeto realizando um determinado trajeto. Os
resultados gerados serão apresentados, assim como as dificuldades encontradas.
Palavras-chave: Robótica; Visão Computacional; OpenCV; Arduino.
7
ABSTRACT
Since its inception, the Arduino platform has revolutionized the way of performing
automated projects, due to its ease of use and low cost. In parallel, the area of
computer vision, is growing working in various fields of science such as medicine,
aviation and especially in robotics. Considering the view, one of the most important
senses, man is constantly seeking ways to reproduce this field. This paper presents
the study and setting up a small mobile autonomous robot using computer vision, it
will be guided by an object holding a particular path. The results generated will be
presented, as well as the difficulties encountered.
Keywords: Robotics; Computer Vision; OpenCV; Arduino.
6
LISTA DE SIGLAS
AC/DC Alternating Current / Direct Current
ARM Advanced RISC Machine
CPU Central Processing Unit
DC Direct Current
FTDI Future Technology Devices International
GB Gigabyte
GND Graduated Neutral Density Filter
GPIO General Purpose Input Output
HDMI High-Definition Multimedia Interface
HSV Hue, Saturation e Value
I2C Inter Integrated Circuit
IDE Integrated Development Environment
LED Light Emitting Diode
MB Megabyte
MIT Massachusetts Institute of Technology
MLL Machine Learning Library
PWM Pulse-Width Modulation
RAM Random Access Memory
RGB Red, Green e Blue
RISC Reduced Instruction Set Computer
SD Secure Digital
SPI Serial Peripheral Interface
TWI Two Wire Interface
USB Universal Serial Bus
XML Extensible Markup Language
7
LISTA DE FIGURAS
Figura 1 - Arduino Duemilanove ................................................................................ 17
Figura 2 – Ciclo PWM ............................................................................................... 20
Figura 3 – Motor DC .................................................................................................. 21
Figura 4- Modelo de Shield ....................................................................................... 22
Figura 5 - Esquema Shield L298N ............................................................................ 22
Figura 6 - Visão Raspberry........................................................................................ 23
Figura 7 - Áreas pertencentes a visão computacional ............................................... 26
Figura 8 - Matriz de Números .................................................................................... 27
Figura 9- Imagem digital obtida por uma impressora de telégrafo ............................ 28
Figura 10- Imagem digital obtida por uma fita perfurada ........................................... 29
Figura 11 - Etapas do Processamento de Imagens .................................................. 30
Figura 12- Representação de Cores do Modelo RGB ............................................... 32
Figura 13- Cubo do Modelo RGB .............................................................................. 33
Figura 14 - Representação do modelo de cores HSV ............................................... 34
Figura 15 - Modelo HSV ............................................................................................ 34
Figura 16 - Histograma de uma imagem em tons de cinza ....................................... 35
Figura 17 – Estrutura do OpenCV ............................................................................. 38
Figura 18 – Visão Geral Funcionamento do Veículo ................................................. 40
Figura 19 - Componentes utilizados na construção do robô ..................................... 41
Figura 20 - Exemplo Código Blink ............................................................................. 42
Figura 21- Servo Motor ............................................................................................ 42
Figura 22 - Código Motor Servo ................................................................................ 43
Figura 23 - Código para ativar os Motores ................................................................ 44
Figura 24 - Processo de Construção do Carro Modelo ............................................. 44
Figura 25 - Sensor de Movimento ............................................................................. 45
Figura 26 – Código Sensor Ultrassônico ................................................................... 45
Figura 27 - Adaptador Bluetooth ............................................................................... 46
Figura 28 - Código Serial .......................................................................................... 47
Figura 29 - Carro Pronto............................................................................................ 47
Figura 30 – Versão Final do Carro ............................................................................ 48
Figura 31 - Versão Final Arduino e Raspberry .......................................................... 49
8
Figura 32 - Obtendo imagem da câmera ................................................................... 50
Figura 33 - Testando uso da câmera ........................................................................ 50
Figura 34 - Uso do Haar Cascade ............................................................................. 51
Figura 35 - Código Detecção Implementado ............................................................. 52
Figura 36 - Lego Mindstorms ..................................................................................... 57
9
LISTA DE TABELAS
Tabela 1 – Tipos de Arduino ..................................................................................... 16
Tabela 2– Especificações Técnicas do Raspberry .................................................... 24
Tabela 3 - Modelo de Robô autônomo de baixo custo .............................................. 57
Tabela 4 – Custo do Protótipo Comercial .................................................................. 57
10
SUMÁRIO
1 INTRODUÇÃO ....................................................................................................... 12
2 FUNDAMENTAÇÃO TEORICA ............................................................................. 14
2.1. HISTÓRIA DA ROBÓTICA ........................................................................................ 14
2.2. MICROCONTROLADORES ....................................................................................... 15
2.3. ARDUINO ............................................................................................................. 15
2.3.1. ARDUINO DUEMILANOVE .................................................................................... 17
2.3.2. ALIMENTAÇÃO ................................................................................................... 17
2.3.3. MEMÓRIA ......................................................................................................... 18
2.3.4. ENTRADA E SAÍDA.............................................................................................. 18
2.3.5. COMUNICAÇÃO ................................................................................................. 19
2.3.6. RESET.............................................................................................................. 19
2.3.7. PROTEÇÃO DE SOBRECORRENTE USB ................................................................ 19
2.4. PWM .................................................................................................................. 20
2.5. MOTOR DC .......................................................................................................... 21
2.6. CONTROLADOR DE MOTOR .................................................................................... 21
2.6.1. SHIELD DE MOTOR L298N ................................................................................ 22
2.7. RASPBERRY PI ..................................................................................................... 23
2.8. VISÃO COMPUTACIONAL ........................................................................................ 24
2.9. IMAGEM DIGITAL ................................................................................................... 27
2.9.1. PROCESSAMENTO DE IMAGENS .......................................................................... 28
2.9.2. MODELO DE CORES........................................................................................... 31
2.9.3. RGB ................................................................................................................ 31
2.9.4. HSV ................................................................................................................ 33
2.9.5. HISTOGRAMA .................................................................................................... 34
2.9.6. SEGMENTAÇÃO ................................................................................................. 35
2.9.7. SEGMENTAÇÃO POR DESCONTINUIDADE ............................................................. 36
2.9.8. BASEADAS EM SIMILARIDADE DOS PIXELS ............................................................ 36
2.9.9. LIMIARIZAÇÃO (THRESHOLDING) ......................................................................... 37
2.10.OPENCV ............................................................................................................. 37
11
3 METODOLOGIA .................................................................................................. 40
3.1. VEÍCULO AUTÔNOMO ............................................................................................ 40
3.1.1. ARDUINO .......................................................................................................... 41
3.1.2. MOTOR SERVO ................................................................................................. 42
3.1.3. MOTOR DC ...................................................................................................... 43
3.1.4. SENSOR PROXIMIDADE ...................................................................................... 45
3.1.5. ADAPTADOR BLUETOOTH ................................................................................... 46
3.1.6 RASPBERRY E ARDUINO ...................................................................................... 48
3.2 VISÃO COMPUTACIONAL COM OPENCV .................................................................. 49
3.3 RESULTADOS E DISCUSSÕES ................................................................................. 55
3.4 CUSTO DO PROJETO ............................................................................................. 56
4. CONCLUSÕES ................................................................................................... 58
5 BIBLIOGRAFIA ................................................................................................... 60
12
1 INTRODUÇÃO
Desde os princípios da humanidade, antes mesmo da escrita ser criada, o
homem sempre buscou uma forma de expressar suas perspectivas do mundo, por
meio de imagens, desenhos, pinturas e fotografias.
A visão é um sentido, que nos permite identificar tudo o que está à nossa
volta. Nossos olhos são capazes de captar as informações e por meio do cérebro,
essas informações são processadas e colocadas em uso. De todos os sentidos
existentes, a visão é considerada um dos mais importantes (KANASHIRO,2003).
Dessa forma o homem busca constantemente, por artifícios para simular funções
que realizamos naturalmente.
Em 1955, surgiu o primeiro trabalho de uma ciência que posteriormente
seria chamada de Visão Computacional. Oliver Selfridge, Professor do Instituto de
Tecnologia do Massachusetts (MIT), publicou um artigo chamado de “Eyes and ears
for computers”, onde apresentou as primeiras ideias sobre o processamento de
imagens. Logo após, na década de 70, surgiram outros trabalhos que foram aliados
a Inteligência Artificial (DAVID, SELFRIDGE,1962).
Visão computacional, é o ramo da ciência que envolve a construção de
sistemas artificiais, a fim de extrair informações de imagens. As imagens são
processadas por meio de técnicas diversas, como segmentação, aplicação de filtros,
histogramas, além do uso de algoritmos, que determinam seu desempenho e
eficiência.
Em tempos de globalização, e com a evolução dos computadores, e o alto
poder de processamento de câmeras, é um tema que está em pleno crescimento,
atuando em diversas áreas, como na medicina, robótica e inteligência artificial. O
grande objetivo da visão computacional é a criação de tarefas e a reprodução de
funções cognitivas humanas, nas maquinas.
Aliado a isso, a robótica também é um campo que vem se desenvolvendo
bastante nos últimos anos. Os robôs têm auxiliado o homem em diversas tarefas,
como em cirurgias, serviços militares, indo a locais de difícil acesso e até mesmo em
tarefas domesticas.
Com o crescimento no uso de microcontroladores, e o surgimento do
Arduino, a tarefa de construção de um robô, que antes era considerada complexa,
13
se torna mais simples. Através dessa plataforma, um sistema pode interagir com o
ambiente por meio de hardware e software.
Este trabalho visa investigar a área de visão computacional com o objetivo
de desenvolver um robô autônomo de baixo custo guiado pelo processamento de
dados oriundo de uma câmera de vídeo.
A escolha do tema justifica-se pelo fato de unir áreas prosperas que
englobam outro conceito muito importante, especialmente no meio acadêmico, que é
o desenvolvimento de aplicações utilizando softwares e hardware livres.
Para atingir os objetivos, o primeiro passo, foi a realização da pesquisa
bibliográfica, para se obter base sobre os assuntos abordados, dentro do contexto
visão computacional, Arduino e Raspberry Pi. Em seguida, foi feita a construção do
protótipo do robô, sendo a primeira fase correspondente configuração dos
equipamentos de hardware. Já segunda fase compreendeu na aplicação dos
conceitos de visão computacional, por meio da biblioteca OpenCV. E por último foi
feita a análise dos resultados obtidos com o protótipo.
Esse documento está estruturado em quatro capítulos. Nesta introdução é
mostrado uma visão geral de todo trabalho. O capítulo 2, apresenta o referencial
teórico dos conceitos necessários para entendimento do assunto. No capítulo 3 será
documentado o desenvolvimento do projeto. E por último no capítulo 4, serão
mostradas as conclusões do trabalho.
14
2 FUNDAMENTAÇÃO TEORICA
Neste capítulo será apresentado o referencial teórico acerca de conceitos
como Microcontroladores, Arduino, Visão Computacional, dentre outros necessários
para o bom entendimento desse trabalho.
2.1. História da Robótica
O conceito de máquinas automatizadas, vem desde os primórdios quando
a história relata que mecanismos ganhavam vida. Segundo lendas, no período
grego, Hefesto, filho de Hera e Zeus, era o deus da Tecnologia, e teria construído o
primeiro gigante de bronze, chamado Talos (HAUGHTON,2009).
Em 1945, Leonardo da Vinci projetou um robô humanoide, na forma de
armadura de cavaleiro, que era capaz de movimentar sua estrutura como os
humanos. Posteriormente, na década de 1890, o cientista Nikola Tesla, construiu um
barco que era movido a distância por um rádio.
A palavra “robô” foi usado pela primeira vez em 1921, por Karel Capek,
em sua peça de teatro R.U.R (Rossum Universal Robots), e foi originada da palavra
Tcheca “robota”, que significava trabalho duro. Robótica se refere a área da
tecnologia que reúne conceitos de mecânica, computação e eletrônica com a
finalidade de criar maquinas automatizadas. O termo foi difundido por Isaac Asimov,
em seu livro “Runaround” (ROBOTSHOP, 2008).
No período de 1954, George C. Devol junto a Joseph F. Engelberger,
projetou um braço primitivo que automatizava tarefas. Mais tarde este se tornou o
primeiro robô industrial que foi chamado de Unimate. Ele era utilizado na fábrica da
General Motors. Em 1962, H. A. Ernst publicou o desenvolvimento de uma mão
mecânica controlada por computador com sensores.
Esse momento, foi considerado como o início da era da Robótica atual,
com o surgimento da criação de robôs modernos, sendo uma nova e potente
ferramenta de fabricação. Em 1986, a Honda iniciou suas pesquisas, e no ano 2000
lançou o Asimo, um robô humanoide. Posteriormente a Sony colocou no mercado o
Aibo, um cão robótico com capacidade de aprender. Atualmente muitos outros
modelos de robôs estão à disposição dos humanos pelo mundo.
15
2.2. Microcontroladores
Microcontrolador é um pequeno dispositivo eletrônico, usado para controlar
circuitos por meio da programação. Contém um processador, que possui uma
Unidade Lógica Aritmética, onde as operações matemáticas e lógicas são
executadas, além de outros componentes como, memória e periféricos de entrada e
saída. Os microcontroladores surgiram como uma evolução dos circuitos digitais, por
pois os mesmos eram considerados muito complexos. É considerada uma solução
simples, compacta e acessível (PENIDO; TRINDADE, 2013).
Foi desenvolvido para ser usado como um controlador que ajuda a monitorar
e controlar a operação de uma máquina, uma parte de um equipamento ou um
processo. São agregados em uma ampla variedade de aplicações de controle, como
controles remotos, fotocopiadoras, sistemas de ignição de automóveis, entre outros.
(TOCCI, et al,2007).
Ainda segundo o a definição de Tooley (2007), um microcontrolador é um
computador voltado para aplicações que necessitem de controle, como o
gerenciamento de um motor.
2.3. Arduino
O Arduino é uma plataforma de prototipagem eletrônica, criada em 2005
por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis,
que tinham por objetivo, desenvolver um equipamento que pudesse ser barato,
funcional e acessível a estudantes (EVANS et al, 2013). É Open Source, sendo
amplamente utilizada no meio acadêmico na criação de protótipos e projetos
pessoais (ARDUINO, 2016).
É um pequeno computador que processa entrada e saída entre
dispositivos e componentes externos. Pode interagir com o ambiente por meio de
hardware e software. (MCROBERTS, 2011).
O Arduino é fabricado pela companhia Smart Projects, porém a SparkFun
Electronics possui licença para produtos comerciais (ARDUINO,2016). Foram
produzidas comercialmente 13 versões do dispositivo, porém algumas versões foram
16
“aposentadas”, sendo retiradas do mercado. A Tabela 1 a seguir mostra os modelos
ainda disponíveis no mercado, assim como suas características e configurações.
Tabela 1 – Tipos de Arduino
Fonte: ARDUINO, 2016
Tipos de
Arduino
Arduino Uno
Arduino
Mega 2560
Arduino
LilyPad
Arduino Nano
Arduino
Pro Mini
Microcontrolador
ATmega328
ATmega2560
ATmega328
ATmega168(versão
2.x) ou
ATmega328(versão
3.0)
ATmega168
Portas Digitais 14 54 9 14 -
Portas PWM 6 15 5 6 -
Portas
Analógicas
6 16 4 8 -
Memória 32K 256K 32K 16K ou 32K 32K
Clock 16 Mhz 16 Mhz 8 Mhz 16 Mhz 16 Mhz
Conexão USB USB USB USB Mini-B Micro USB
Conector para
alimentação
externa
Sim Sim Sim Não Não
Tensão de
Operação
5V 5V 5V 5V 5V
Corrente Máxima
portas E/S
40mA 40mA 40mA 40mA -
Alimentação 7-12 V 7-12 V 2,7-5,5 V 7-12 V 5V
Média de Preço R$ 36,00 R$ 51,00
R$ 16,90 R$ 14,99 R$ 16,99
17
2.3.1. Arduino Duemilanove
O Arduino utilizado no projeto é o Duemilanove, que significa (“2009") em
Italiano. É uma placa baseada no microcontrolador ATmega168 ou ATmega328,
possui 8 bits e arquitetura RISC (Reduced Instruction Set Computer) e Harvard, que
separa a memória de dados da memória de programas. Com isso, o
microcontrolador AVR tem um barramento para dados e outro para programas que
permite uma maior velocidade no tratamento dos mesmos. E através dele que todos
os periféricos, são gerenciados e controlados (ARDUINO, 2016).
Figura 1 - Arduino Duemilanove
Fonte: ARDUINO,2016
Ele possui 14 pinos de entrada/saída digital (dos quais 6 podem ser
utilizados como saídas PWM), 6 entradas analógicas, um oscilador a cristal de 16
MHz, uma conexão USB para programação, uma tomada de alimentação, e um
botão de reinicialização (reset). Para sua utilização, basta conectá-lo a um
computador com um cabo USB ou ligá-lo com um adaptador AC/DC ou a uma
bateria (ARDUINO, 2016).
2.3.2. Alimentação
O Arduino Duemilanove pode ser alimentado através da conexão USB ou
com uma fonte de alimentação externa. A fonte de alimentação é selecionada
automaticamente, podendo ser uma fonte ou uma bateria. A placa pode operar com
uma fonte externa de 6 a 20 volts, porém o intervalo recomendado é de 7 a 12 volts
(ARDUINO, 2016).
Os pinos de alimentação são:
18
VIN. A tensão de entrada para a placa Arduino quando ele está usando
uma fonte de alimentação externa
5V. É a fonte de alimentação regulada usada para alimentar o
microcontrolador e outros componentes na placa. Pode vir do pino VIN através de
um regulador on-board, ser fornecida por USB ou de outra fonte de 5V.
3V3. A alimentação de 3,3 volt é fornecida pelo chip FTDI on-
board. Tração máxima atual é 50 mA.
GND. Pinos terra.
2.3.3. Memória
O ATmega168 tem 16 KB de memória flash para armazenamento de
código além de 1 KB de SRAM e 512 bytes de EEPROM. Já o ATmega328 tem 32
KB, e 2 KB de SRAM e 1 KB de EEPROM. Em ambas placas 2 KB é usado para o
bootloader (ARDUINO, 2016).
2.3.4. Entrada e saída
Cada um dos 14 pinos digitais pode ser usado para entrada e saída,
usando funções, que operam a 5 volts. Cada pino pode fornecer ou receber um
máximo de 40 mA e tem um resistor pull-up interno (desconectado por padrão) de
20-50 kOhms. Além disso, alguns pinos têm funções especializadas:
Serial: 0 (RX) e 1 (TX). Utiliza-se para recepção (RX) e transmitir os
dados em série (TX) TTL. Estes pinos são ligados aos pinos correspondentes do
chip serial FTDI USB-TTL.
Interrupções externas: Estes pinos podem ser configurados para
disparar uma interrupção por um valor baixo, uma borda de subida ou queda, ou
uma mudança de valor.
PWM: Fornecer saída PWM de 8 bits.
SPI: Estes pinos suportam comunicação SPI utilizando a biblioteca de
SPI.
LED: 13. Há um built-in LED que quando é de alto valor, o LED está
ligado, quando o pino é baixo, ele está fora.
19
O Duemilanove tem 6 entradas analógicas, cada uma das quais com 10
bits de resolução.
2.3.5. Comunicação
O Arduino Duemilanove tem uma série de facilidades para se comunicar
com um computador, outro Arduino ou outros microcontroladores.
Os ATmega168 e ATmega328 fornecer UART TTL (5V) de comunicação serial, que
está disponível nos pinos digitais 0 (RX) e 1 (TX). Um FTDI FT232RL nos canais de
tabuleiro está comunicação serial por USB. Possui um monitor serial que permite
que dados simples de texto sejam enviadas de e para a placa Arduino. Os RX e
TX LEDs na placa piscam quando os dados estão sendo transmitidos através do
chip e conexão USB FTDI para o computador (ARDUINO, 2016).
2.3.6. Reset
Em vez de exigir um reset físico antes de um upload, o Arduino
Duemilanove é projetado de uma maneira que permite que ele seja reposto por
software rodando em um computador conectado. O software Arduino usa esse
recurso para permitir que você envie código, simplesmente pressionando o botão de
upload no ambiente Arduino (ARDUINO, 2016).
2.3.7. Proteção de sobrecorrente USB
O Arduino Duemilanove tem um fusível reajustável que protege portas
USB do seu computador de sobrecorrentes. Embora a maioria dos computadores
fornecem sua própria proteção interna, o fusível fornece uma camada extra de
proteção. Se houver mais de 500 mA é aplicada à porta USB, o fusível romper
automaticamente a conexão até a curto ou a sobrecarga é retirada (ARDUINO,
2016).
20
2.4. PWM
Modulação de Largura de Curso ou PWM (Pulse Width Modulation) é uma
técnica utilizada para a obtenção de resultados analógicos com meios digitais. Por
sistemas digitais que mantem a frequência de uma onda quadrada fixa e varia o
tempo que o sinal fica em nível lógico alto (EMBARCADOS,2016).
O Arduino contém 6 entradas PWM. Ondas quadradas são criadas, com
pulsos de largura variável, dando uma tensão média à carga. Essa aplicação
controla o fornecimento de potência à carga. Por meio da onda quadrada, criada, o
sinal é alternado, simulando as tensões em 5 volts e 0 volts, respectivamente ligado
e desligado. A duração do tempo desse processo é chamada de largura de pulso
(ARDUINO,2016).
Na Figura 2 abaixo, as linhas verdes representam um período de tempo
regular. Esse período é o inverso da frequência de PWM. A função chamada
de analogWrite () varia em uma escala de 0-255, de modo que analogWrite (255)
solicita um ciclo de trabalho de 100% (sempre ligado), e analogWrite (127) é um
ciclo de trabalho de 50%, correspondente a metade do tempo (ARDUINO,2016).
Figura 2 – Ciclo PWM Fonte: ARDUINO,2016
21
O uso de PWM é uma técnica utilizada em diferentes áreas da eletrônica,
atuando no controle de velocidade de motores, como servo motores, em fontes
chaveadas e distintas aplicações (MECAWEB,2016).
2.5. Motor DC
Motor de corrente contínua ou motores DC (Direct Current), são
dispositivos que operam utilizando forças de atração e repulsão provocadas por
eletroímãs e imas permanentes. São baseados nos princípios de atração e repulsão
dos polos magnéticos, fluxo magnético e indução de tensão elétrica
(NEWTONCBRAGA,2016). A ideia principal de tal motor é montar uma bobina entre
os polos de um ima permanente ou que funcione de modo semelhante.
Figura 3 – Motor DC
Fonte: INSTRUCTABLES, 2016
São amplamente utilizados mecatrônicos, podendo ter seu sentido de
rotação controlado em acordo com o sentido da corrente aplicada em seus terminais.
Com o uso de modulação por largura de pulso (PWM) a velocidade de rotação do
motor é controlada sem perder sua rotação (NEWTONCBRAGA,2016).
2.6. Controlador de Motor
Para controlarmos dois motores DC no Arduino é necessário o uso de um
Shield para controle. Shields, como sabemos são placas que ampliam as
funcionalidades do Arduino, e que permitem a rotação dos motores.
22
É possível acrescentar novas funcionalidades a uma placa Arduino,
utilizando um dispositivo denominado Shield. Existem diferentes modelos de Shields
no mercado, cada uma com uma funcionalidade especifica.
Figura 4- Modelo de Shield
Fonte: ARDUINO, 2016
2.6.1. Shield De Motor L298N
Esse módulo foi projetado para controlar cargas indutivas como relés,
motores DC e motores de passo, permitindo o controle do sentido de rotação e de
sua velocidade. Cada ponte H possui um pino para ser ativado ou não. Caso tenha
um sinal de 5V inserido nele, a ponte está ligada, caso seja 0V a ponte está
desligada.
Figura 5 - Esquema Shield L298N Fonte: ARDUINO,2016
As vantagens do uso são diversas, é um circuito de fácil entendimento e a
possibilidade de uso de sinais PWM. Por meio destes, é possível regular a voltagem
de saída, regulando o passo dos motores.
23
2.7. Raspberry Pi
Raspberry Pi é uma placa de desenvolvimento, com o tamanho similar à
de um cartão de crédito, produzida no Reino Unido pela de mesmo nome. Foi criada
na Universidade de Cambridge pelo engenheiro britânico Eben Upton e sua equipe,
com o objetivo principal de incentivar o ensino de programação crianças e por meio
de um preço acessível.
A primeira versão surgiu em 2006 e atualmente possui diversos modelos
disponíveis no mercado. Pode ter diferentes configurações com suporte a muitas
linguagens de programação como Python, Java, Ruby on Rails, Perl e C/C++
(RASPBERRY,2016).
O Raspberry utilizado no projeto é o Raspberry Pi 1 Model B+. Modelo
lançado em julho de 2014, essa é a placa mais antiga disponível no momento e tem
suas origens na primeira versão do computador. No coração do Raspberry Pi está o
processador. O processador é o Broadcom de núcleo único e 700 MHz, construído
sobre a arquitetura ARM11 (RICHARDSON; WALLACE,2013).
Para ligar periféricos e hardware diversos, a placa conta com interface
GPIO de 40 pinos. Há quatro portas USB 2.0, saída HDMI, slot para cartão de
memória do tipo microSD, baixo consumo de energia (entre 0,5 e 1watt) e saída de
som P2. O modelo também tem Ethernet, interface para câmera e tela, além de
saída de som P2 (RASPBERRY,2016). A Figura 6 mostra a visão de uma placa de
Raspberry, e seus componentes.
Figura 6 - Visão Raspberry Fonte: RASPBERRY,2016
24
A Tabela 2 abaixo apresenta as placas disponíveis no mercado e suas
especificações técnicas.
Tabela 2– Especificações Técnicas do Raspberry
Fonte: RASPBERRY,2016
2.8. Visão Computacional
Nós seres humanos, percebemos a estrutura do mundo a nossa volta com
facilidade. Ao olhar para uma foto, podemos facilmente contar e nomear as pessoas
e até mesmo interpretar suas emoções com base na aparência (SZELISKI, 2010).
O olho e o cérebro humano, fazem o trabalho de reconhecimento de
objetos e detecção em imagens, de forma natural, mas replicar isso para um modelo
computacional sempre foi modelo de pesquisa para entusiastas e estudantes de
computação.
Modelos Raspberry Pi
1 Model A+
Raspberry Pi
Zero
Raspberry Pi
2 Model B
Raspberry Pi 3
Model B
Processador Arm 11
1 GHz single-
core Cortex A7
1.2GHz quad-core
64bits
CLOCK 0.7GHz - 900MHz -
GPU Videocore VI
- Videocore VI
-
Porta Ethernet - - Sim -
Memoria 256 MB 512 MB 1GB 1GB
HDMI Sim Mini HDMI Sim
Portas USB 1 USB On-The-Go 4 4
Flash - Não
Armazenamento
MicroSD MicroSD MicroSD MicroSD
GPIO 40-pin 40-pin 40-pin 40-pin
WiFi - - Não -
Bluetooth - - Não -
25
Na busca constante do homem de reproduzir o campo visual humano,
surge a ciência denominada de Visão Computacional. Pode ser definida como a
transformação de dados a partir de uma câmara fotográfica ou de vídeo em um novo
objeto. São transformações feitas a fim de alcançar um objetivo especifico
(BRADSKI, KAEHLER, 2008).
Com a popularização dos equipamentos de hardware, o aumento da
qualidade das câmeras, e uso de softwares gratuitos, pesquisadores têm
desenvolvido diversas técnicas, como recuperar a forma tridimensional e aparência
de objetos em imagens, além de tentar encontrar pessoas em uma fotografia usando
reconhecimento, por meio da detecção facial. (SZELISKI, 2010).
É um tema que vem se desenvolvendo fortemente nos últimos anos, e
muitas de suas aplicações ganham destaque. Dentre eles, podemos citar a
inteligência artificial, que buscar artifícios que multipliquem a inteligência humana por
meio de sistemas automatizados que enxergam e compreende o espaço em que
percorrem.
A Física é outro campo relacionado, onde boa parte desse processo usa
métodos que requerem o entendimento de assuntos como o eletromagnetismo e a
física quântica. Entre outros diversos campos, podemos citar o uso de visão
computacional na psicologia, estatística, neurobiologia e principalmente na Robótica
tendo como premissa a missão de produzir sistemas altamente automatizados. A
Figura 7, mostra o desenho que ilustra as áreas relacionadas com a visão
computacional.
26
Figura 7 - Áreas pertencentes a visão computacional
Fonte: FERNANDES, 2012
Segundo Gonzalez e Woods (2008), o processo de visão computacional
se inicia com o processamento de imagens, depois é dividido em três níveis: baixo
nível, nível-médio e alto-nível. A seguir serão apresentadas todas as etapas citadas.
Baixo Nível – O processo de baixo nível, consiste na melhoria da qualidade
da imagem. A imagem é restaurada, por meio de operações como a redução
de um ruído, a melhora no contraste, ou a remoção de borrões da câmera
com objetivo de corrigir as falhas provenientes do processamento de
imagens.
Médio Nível – Nesta fase incluem técnicas que destacam características
relevantes da imagem, por meio de operações como segmentação
(particionamento da imagem em regiões) ou classificação (reconhecimento
dos objetos na imagem) que transformam a imagem a fim de que as
informações possam ser extraídas.
Alto Nível – Na última fase o objetivo é dar sentido a funções cognitivas
relacionadas a visão. É realizado a extração e reconhecimento de
27
informações da imagem, por meio de tarefas de cognição normalmente
associadas com a visão humana, como técnicas para interpretação de objetos
ou cenas, Raciocínio cognitivo e Inferência de informações.
2.9. Imagem Digital
Uma imagem é um conjunto de pontos que se unem para formar um todo, é o
suporte para efetuarmos troca de informações (ALBUQUERQUE,
ALBUQUERQUE,2001).
Podemos resumir o conceito de imagens nas palavras de Gonzalez e
Woods (2008, p.4). Pode ser definida como uma função bidimensional, em que x e y
são espaciais (plano) coordena, e a amplitude de f em qualquer par de coordenadas
(x, y) representa a intensidade ou nível de cinzento da imagem nesse ponto.
Uma imagem digital é composta elementos, conhecidos como pixels.
Cada pixel possui um valor específico, podendo ser um número, ou um conjunto de
números, que representa uma determinada cor. A Figura 8 representa que para o
computador a imagem é apenas uma matriz composta por pixels, que transforma
essas séries de números em imagens.
Figura 8 - Matriz de Números
Fonte: BRADSKI; KAEHLER, 2008
28
2.9.1. Processamento de Imagens
2.9.1.1. História do processamento de imagens
Uma das primeiras aplicações de técnicas de processamento de imagens
foi no início do século 20, na indústria de jornal, quando as imagens eram
transmitidas por cabos submarinos entre Londres e Nova York. O cabo Bartlane,
reduziu o tempo de transporte que era de uma semana para menos de 3 horas.
As imagens eram transmitidas codificadas e reconstruídas ao seu
recebimento. No entanto surgiram problemas iniciais quanto a qualidade das
imagens na impressão quanto a intensidade dos níveis da escala de cinza.
O método de impressão usado na época era a reprodução fotográfica das
fitas perfuradas do terminal de telégrafo. Porém, resultados melhores foram obtidos
quanto à resolução e distribuição dos níveis de cinza, utilizando o método de
impressão de impressoras de telégrafo que havia sido abandonado em 1921
(GONZALEZ; WOODS, 2008). As Figuras 9 e 10 mostram as diferenças de uma
imagem digital obtida a partir de uma fita codificada por uma impressora de telégrafo
e por uma fita perfurada.
Figura 9- Imagem digital obtida por uma impressora de telégrafo
Fonte: GONZALEZ; WOODS, 2008
29
Figura 10- Imagem digital obtida por uma fita perfurada
Fonte: GONZALEZ; WOODS, 2008
Em 1929, a capacidade de codificação em níveis de cinza (5 níveis) foi
aumentada para 15 níveis de brilho. Imagens passaram a ser obtidas por um
sistema de revelação via feixes de luz que eram modulados pela fita da imagem
codificada (GONZALEZ; WOODS, 2008).
Em 1964, imagens obtidas com a ida ao homem à lua, começaram a ser
processadas no Jet Propulsion Lab em Pasadena, Califórnia, a fim de corrigir
correções das distorções da imagem devido a câmara de TV a bordo. Até hoje, a
área de processamento digital de imagens tem crescido muito. As técnicas de
processamento digital de imagens têm sido usadas para uma ampla variedade de
aplicações (GONZALEZ; WOODS, 2008).
O processamento de imagens está relacionado ao processamento de
sinais, de forma que uma imagem é o conjunto de pontos que se juntam para formar
um objeto, sendo o suporte para a troca de informações. Cada imagem possui
dentro de si uma “informação”. Processar uma imagem significa transformá-la com o
objetivo de extrair facilmente a informação presente (ALBUQUERQUE,
ALBUQUERQUE, 2001).
30
O Processamento de Imagem é utilizado para melhoria de uma imagem e
destacar suas características. Permite a interpretação das imagens, além de seu
armazenamento com a finalidade de extrair informações.
A imagem pode ser criada a partir de softwares ou por meio de
dispositivos. A área de processamento de imagens se refere à manipulação visando
a melhoria da imagem, o destaque ou eliminação de características e informações
(GONZALEZ; WOODS, 2008). O processamento de imagens envolve um processo
de aplicação de vários métodos para atingir o resultado. A Figura 11 ilustra as
etapas.
Figura 11 - Etapas do Processamento de Imagens
Fonte: GONZALEZ, WOODS, 2008
Aquisição da imagem: O primeiro passo no processo é a aquisição de
imagens. Por meio de dispositivos específicos, ocorre aquisição direta da
imagem ou a digitalização. O sensor converterá a informação em sinal elétrico
e o digitalizador transformará a imagem analógica em imagem digital (FILHO,
NETO,1999).
Pré-processamento: No pré-processamento, a imagem após o processo
anterior, passa por uma filtragem, com o objetivo de melhorar o conteúdo da
imagem, que pode apresentar falhas, eliminando, por exemplo, ruídos, ou
selecionando regiões de interesse. A função dessa etapa é melhorar a
qualidade da imagem para as próximas fases. A imagem resultante possui
melhor qualidade que a original. (FILHO, NETO,1999).
31
Segmentação: Na etapa de segmentação as partes de uma imagem são
dividida em unidades significativas, em objetos de interesse que a compõem.
É processo que divide uma imagem em partes semelhantes diante de suas
características (FILHO, NETO,1999).
Extração de Características: Esta etapa extrai características das imagens
por meio de descritores que permitam diferenciar com perfeição cada dígito e
até mesmo entre dígitos semelhantes. Nesta etapa a entrada ainda é uma
imagem, mas a saída são dados correspondentes àquela imagem. (FILHO,
NETO,1999).
Reconhecimento e Interpretação: Nesta última etapa, reconhecimento é
processo atribuir um rótulo a um objeto baseado em suas características. A
tarefa de interpretação, no entanto, consiste em atribuir sentido a um conjunto
de objetos reconhecidos (FILHO, NETO,1999).
Base de Conhecimento: As etapas apresentadas acima implicam a
existência de um conhecimento sobre o problema a ser resolvido,
armazenado em uma base de conhecimento, cujo tamanho podem variar
enormemente. Esta base de conhecimento deve guiar o funcionamento de
cada etapa, e também permitir o contato entre elas. (FILHO, NETO,1999).
2.9.2. Modelo de Cores
O objetivo dos modelos de cores é permitir a especificação de cores em
um formato padronizado e aceito por todos. Em linhas gerais, um modelo de cores é
uma representação tridimensional na qual cada cor é representada por um ponto no
sistema de coordenadas (FILHO; NETO, 1999). A seguir, serão mostrados os
modelos mais utilizados para a representação de cores.
2.9.3. RGB
32
O Modelo RGB (Red, Green, Blue) é um sistema aditivo baseado na
teoria dos três estímulos proposta por Young-Helmholtz, que propôs que o olho
continha três receptores de cor, que respondiam fortemente as cores vermelho,
verde e azul-violeta (CARNEIRO,2016).
Foi desenvolvido para reproduzir cores em dispositivos que contenham
luz, como monitores, computadores, e câmeras digitais. A Figura 12 mostra a
representação do modelo RGB.
Figura 12- Representação de Cores do Modelo RGB
Fonte: SZELISKI, 2010
É baseado em um sistema de coordenadas cartesianas, que forma um
cubo onde três de seus vértices são as cores primárias, outros três as cores
secundárias (FILHO; NETO, 1999). Neste modelo, a escala de cinza é aplicada
quando os três componentes possuem valores iguais.
É baseado em um sistema de coordenadas cartesianas, que forma um
cubo, o chamado cubo RGB, onde três de seus vértices são as cores primárias,
outros três as cores. Para se obter uma cor, através das triplas é usado um intervalo
ordenado de 0 a 255. Cada cor é associada com pontos, semelhante a um cubo com
aresta de tamanho 255. O vermelho corresponde a (255,0,0), o verde a (0,255,0) e o
azul (0,0,255). É uma das representações mais utilizada na computação por guardar
cada valor de cor em 1 byte (8 bits). Assim, o vermelho completamente intenso é
representado por 255, 0, 0 (FILHO; NETO, 1999). A Figura 13 mostra a
representação do cubo RGB.
33
Figura 13- Cubo do Modelo RGB
Fonte: FILHO; NETO, 1999
2.9.4. HSV
HSV (Hue, Saturation, Value) é o sistema de cores formadas pelas
componentes Hue (H), Saturation (S) e Value (V), respectivamente, matiz, saturação
e valor. Foi criado em 1974, por Alvy Ray Smith, com base na necessidade de se
especificar numericamente as cores. O modelo hexcone é uma tentativa de
transformar as dimensões Cubo RGB em um conjunto de dimensões de modelagem
método do artista de misturar (SMITH, 1982).
O matiz determina a cor ou tonalidade, atingindo valores de 0º a 360º,
definindo a tonalidade dominante de uma área. Tonalidade é a dimensão com
pontos de cores (SMITH, 1982).
A saturação mede a pureza da cor da área, é a característica que
diferencia as cores. A cor vermelha é a cor pura, e outras tonalidades são
combinações das cores primarias. Saturação mede a saída de um tom de forma
acromática, ou seja, de cor branca ou cinza (SMITH, 1982).
E por último o valor determina a luminosidade percebida (cor clara ou
escura). A luminância é a componente da imagem que só contém as informações de
brilho de uma imagem (SMITH, 1982).
O sistema é representado por coordenadas onde o modelo definido
representado por um cone em forma hexagonal, conforme ilustração da Figura 14. O
topo do corresponde a V, e contém as cores com mais brilho.
34
Figura 14 - Representação do modelo de cores HSV
Fonte: INTEL, 2016
A altura corresponde a projeção do cubo de cores RGB. Os matizes estão
representados na parte superior da pirâmide, a saturação é medida ao longo do eixo
horizontal e a luminância é medida ao longo do eixo vertical. A Figura 15 mostra uma
imagem usando o modelo HSV.
Figura 15 - Modelo HSV
Fonte: SZELISKI, 2010, p.91
2.9.5. Histograma
O histograma de uma imagem é um conjunto de números que indicam a
quantidade de pixels que apresentam nível de cinza. São representados por um
gráfico de barras que mostra um número ou a porcentagem de pixels encontrados
na imagem. Por meio disso é possível ver sua qualidade quanto ao nível de
contraste e quanto ao seu brilho médio (FILHO; NETO, 1999).
35
Durante a aquisição de imagens, falhas como baixa iluminação no
contraste, ou até mesmo durante a abertura da lente, para aquisição de imagens,
podem resultar em imagens de baixo qualidades e comprometer o processo
(GONZALEZ e WOODS, 2000).
A aplicação do histograma é utilizada como técnica usual para realce de
imagens, pois apresenta um cálculo da ocorrência dos níveis de cinza, fornecendo
uma descrição global da aparência de uma imagem. (GONZALEZ e WOODS, 2000).
É uma ferramenta bastante eficiente, atuando na etapa de pré-
processamento, pois fornece uma visão estatística sobre a distribuição dos pixels,
sobre o contraste da imagem e os níveis de iluminação. (ESQUEF;
ALBUQUERQUE; ALBUQUERQUE,2003). A Figura 16, mostra um exemplo de
histograma e a forma como é representado.
Figura 16 - Histograma de uma imagem em tons de cinza
Fonte: Adaptado FILHO; NETO,1999, p.58
2.9.6. Segmentação
Segmentação é um processo que particiona uma imagem em regiões ou
objetos. O nível de detalhe com que é feito o processo depende do problema a ser
resolvido quando os objetos forem detectados é encerrado. Devido a sua
complexidade é considerada, uma das tarefas mais difíceis, no processamento de
imagem, pois sua precisão determina o eventual sucesso ou fracasso dos
procedimentos de análise computadorizada. (GONZALEZ; WOODS, 2008).
Nessa etapa que são definidas as regiões de interesse para
processamento e analise posteriores. Diante disso, quaisquer erros ou distorções
36
refletem nas demais etapas, podendo contribuir de forma negativa para o processo.
Atualmente existem diversas técnicas disponíveis no mercado (ESQUEF;
ALBUQUERQUE; ALBUQUERQUE, 2003).
A segmentação de uma imagem, pode ser feita por meio de duas
técnicas. Um através da similaridade dos pixels e por meio da descontinuidade entre
eles.
2.9.7. Segmentação por Descontinuidade
Na segmentação por descontinuidade a imagem é particionada através de
Algoritmos, que buscam incoerências por meio de pontos isolados, linhas e bordas
na imagem. É baseado nas alterações bruscas de intensidade nos níveis de cinza e
envolve a utilização de filtros para varrer a imagem e identificar as estruturas
(GONZALEZ; WOODS, 2008). Os processos de detecção podem ser feitos por
pontos, linhas e bordas.
Na Detecção de Pontos: Na detecção de pontos, é utilizada uma
máscara, que dispõe de um valor elevado na célula principal e valores baixos nas
demais. Portanto, quando for feito o processo sobre a imagem os pontos em nível de
cinza serão evidenciados (GONZALEZ; WOODS, 2008).
Na Detecção de Linhas: A detecção de linhas em imagens, ocorre por
meio de máscaras. As derivadas de segunda ordem resultem em uma resposta mais
forte e produzem linhas mais finas do que as derivadas de primeira ordem
(GONZALEZ; WOODS, 2008).
Na Detecção de Bordas: Nesse processo, considera-se que as regiões
são homogêneas e que a mudança entre as regiões são determinadas com base na
descontinuidade dos níveis de cinza. O propósito principal dessa técnica é o uso
operador diferencial. É um dos métodos mais utilizados na segmentação por
descontinuidades, pois pontos e linhas finas não são ocorrências frequentes
(GONZALEZ; WOODS, 2008).
2.9.8. Baseadas em similaridade dos pixels
37
Nesse processo a detecção de regiões de interesse é efetuada com base
na similaridade entre pixels, na semelhança dos níveis de cinza e limiarização.
Baseia-se em três abordagens principais: limiarização, crescimento de regiões e
fusão e divisão de regiões. O processo de limiarização descrito a seguir é o tipo mais
simples e usado de segmentação, com base na similaridade.
2.9.9. Limiarização (Thresholding)
A binarização de imagens ou thresholding é um tipo de segmentação
utilizado quando os níveis de cinza são suficientes para caracterizar as partes de
uma imagem.
No processo, um nível de cinza é considerado limiar, que separa as
imagens em partes semelhantes. O valor do limiar é determinado por histogramas
baseado na intensidade dos pixels. Nesta técnica, se obtém como saída do sistema
uma imagem binária, e uma imagem com apenas dois níveis de luminância: preto e
branco. É considerado uma técnica altamente eficiente (GONZALEZ; WOODS,
2008).
2.10. OpenCV
OpenCV (Open Source Computer Vision) é uma biblioteca multiplataforma
de software, de código aberto. Construída pela Intel Corporation, tem a função de
fornecer uma infraestrutura para o desenvolvimento de aplicações na área de visão
computacional, e com foco em aplicações em tempo real. É escrito na linguagem C e
C++, e dá suporte para uso de Java, Python, Ruby e Visual Basic. Sua versão atual
é a 2.4.13 lançada em 19 de maio de 2016 (OPENCV,2016).
A biblioteca é abrangente, fornecendo uma estrutura simples de usar e
que contém funções para a realização de tarefas, desde a resolução de sistemas
lineares a construção de sistemas altamente sofisticados (RUSSEL, NORVIG, 1995).
Devido a isso facilita o desenvolvimento de aplicações, já que não é necessário
possui diversos modelos de algoritmos já implementados na biblioteca.
38
Suas possibilidades de uso são infinitas, podendo ser usada na área de
reconhecimento facial, realidade virtual, identificação de objetos e até mesmo na
reconstrução 3D.
Seus módulos são divididos em cinco componentes, sendo eles:
a) CV – Componente responsável pelo processamento de imagens,
algoritmos de visão, análise de estrutura e reconhecimento de padrões.
b) MLL – É a biblioteca de aprendizagem de máquina que contém
ferramentas de clustering, e a classificação e análise de dados
estatísticos.
c) HighGUI – Controle de interface de usuário e de entrada e saída (I/O) de
imagens e vídeos.
d) CXCore - Contem estruturas de dados e álgebra linear além do suporte a
XML e funções de desenho.
e) CvAux – Modulo de Algoritmos de visão, técnicas de reconhecimento
descrição de texturas, descoberta de esqueletos, e rastreamento 3D.
Ainda em fase experimental. A Figura 17 mostra a estrutura básicas dos
componentes do OpenCV.
Figura 17 – Estrutura do OpenCV
Fonte: BRADSKI; KAEHLER, 2008
39
A biblioteca tem mais de 2500 algoritmos otimizados, podendo ser usados
para detectar e reconhecer rostos, identificar objetos, classificar as ações humanas
em vídeos, mover objetos, extrair modelos 3D de objetos, produção de nuvens de
pontos 3D a partir de câmeras estéreo, encontrar imagens similares de um banco de
imagens, reconhecer cenário e estabelecer marcadores e aplicá-los com a realidade
aumentada (OPENCV,2016).
40
3 METODOLOGIA
Este capítulo descreve as etapas do projeto, mostrando os componentes que
foram utilizados, assim como as linguagens e bibliotecas, e por último, mostrara os
testes feitos com protótipo.
3.1. Veículo Autônomo
Atualmente, as possibilidades de pesquisas para o desenvolvimento de
aplicações e projetos utilizando Arduino são infinitas. O primeiro passo para a
construção do robô, foi a definição de suas funcionalidades e de seu ambiente,
critério indispensável para a escolha correta das peças e dos itens necessários.
Basicamente o protótipo construído funciona de forma que a câmera
passa a imagem para o Raspberry, que realiza o processamento e envia o comando
para O Arduino via USB, que controla os motores. A Figura 18 mostra a visão geral
do funcionamento do robô.
Figura 18 – Visão Geral Funcionamento do Veículo
41
Para o desenvolvimento do protótipo de robô, foi utilizado um Arduino
Duemilanove com AtMega328, dois motores DC, duas rodas, duas placas de
acrílico, um módulo de comunicação Bluetooth, Shield de motor L298N, sensor de
proximidade, caixa para pilhas (com suporte para 6), 1 caixa para bateria 9V, 1 mini
protoboard, e cabos para conexão. A Figura 19 ilustra os materiais utilizados.
Figura 19 - Componentes utilizados na construção do robô
3.1.1. Arduino
Na parte de construção de hardware, o microcontrolador é responsável
por gerenciar todos os periféricos ligados a ele. O primeiro passo do projeto foi
iniciar o funcionamento do Arduino, testando o código Blink, que está incluso como
modelo teste, na IDE.
O código do exemplo Blink é simples, e semelhante para todos os
programas elaborados na IDE. O programa apresenta, duas funções principais e
obrigatórias chamadas de void setup() e void loop(). A função setup () executada na
inicialização do programa configura o microcontrolador. Já função loop (), executa o
código necessário para acender o LED (ARDUINO,2016). A Figura 20 mostra o
código desenvolvido.
42
Figura 20 - Exemplo Código Blink
3.1.2. Motor Servo
Em um servo motor é possível determinar a posição em graus, com
precisão. Porém, para que o robô tenha movimento contínuo é necessário fazer
modificações em sua estrutura, pois originalmente o servo gira ao máximo de 180
graus.
O próximo passo foi acionar o funcionamento do motor servo. Sendo
necessário o Arduino, e os fios. Três fios foram usados, sendo o fio vermelho (+5V),
responsável pela alimentação, o marrom é o fio terra (GND) e o fio amarelo é
responsável pelo sinal e controle.
Figura 21- Servo Motor
43
No código utilizado na função motor.attach(3), informamos que o cabo de
sinal do servomotor estará ligado ao pino digital 3 do Arduino.
Em motor.write(180), ele define a posição em 180ºgraus depois aguarda
um segundo é posiciona em 0º graus. O código embarcado para o funcionamento é
mostrado abaixo na Figura 22.
Figura 22 - Código Motor Servo
Depois do motor servo funcionar, foi inserido o Shield ao Arduino e
ativado os motores.
3.1.3. Motor DC
O próximo passo foi acionar o funcionamento dos motores DC. Para
isso, seria necessário que os motores possuíssem uma alimentação externa, por
meio de pilhas. O controle dos motores é feito utilizando o Shield L298N, que realiza
a conexão entre motores. Esse Shield, permite o controle da rotação do motor, e de
sua velocidade, por meio dos pinos PWM.
Foi realizado um teste para verificar o funcionamento dos motores. Foi
enviado o sinal para mover o motor servo em 90º, em seguida o motor A é acionado
girando no sentido horário no tempo de 3 segundos. Logo após, o motor servo vai
para 180º, o motor A é desligado e acionado o motor B para girar no sentido horário
também por 3 segundos.
44
Depois desse tempo, o servo retorna à 90º e o motor B é desligado. Durante o
mesmo tempo, o servo é direcionado para 0º e os dois motores são acionados ao
mesmo tempo girando por 5 segundos, sendo em seguida desligados. A Figura 23,
mostra trechos do código utilizado, e a Figura 24 mostra o protótipo do carro,
durante a fase de construção.
Figura 23 - Código para ativar os Motores
Figura 24 - Processo de Construção do Carro Modelo
45
3.1.4. Sensor Proximidade
Passando essa fase, foi feito a instalação do sensor de proximidade. Em
nosso projeto utilizaremos o sensor de distância ultrassônico HC-SR04, com boa
precisão.
O módulo possui 4 pinos o VCC é utilizado para alimentar o sensor
possuindo (5V), o Trigger dispara o sinal ultrassônico. O pino Echo conectado na
porta 7, mede o tempo de para o pulso ser recebido pelo sensor, e o Gnd faz a
conexão com fio terra. A Figura 25 ilustra a conexão com do Arduino com o sensor
de movimento.
Figura 25 - Sensor de Movimento
Fonte: FLIPEFLOP,2016
Após a conexão do Arduino ao sensor ultrassônico, basta embarcarmos o código
apresentado abaixo na Figura 26.
Figura 26 – Código Sensor Ultrassônico
46
Esse código funciona de forma que ativa e desativa um dos pinos do
sensor, no caso, o pino que envia o sinal (Trigger). Depois com a função pulseIn do
Arduino, ele verifica quanto tempo o pino que recebe o sinal (Echo) fica ativo. E por
último, converte esse tempo em centímetros.
3.1.5. Adaptador Bluetooth
Após tudo conectado corretamente, o último passo foi conectar o
adaptador Bluetooth ao dispositivo. Assim que a placa é ligada ela já fica disponível
automaticamente não precisando de qualquer tipo de configuração, sendo somente
necessário parear com o dispositivo.
A placa BTboard V1.05, vem com código pin padrão, com a senha 1234 e
já identificada como HC-06. Com o pareamento feito, qualquer sinal enviado ao
adaptador é convertido e reenviado ao Arduino. Após esse passo foi necessário o
uso de um aplicativo que enviasse sinais via Bluetooth para o Arduino.
Figura 27 - Adaptador Bluetooth
Fonte: FLIPEFLOP,2016
Os sinais recebidos atuam da seguinte forma: Ao receber 1, ligamos os
motores no sentido horário, fazendo com que o carro ande para frente. Ao receber 2,
enviamos um sinal para desligar os motores. Ao receber 3, enviamos um sinal para
que o carro ande para um lado e para o outro, repetidas vezes como se estivesse
dançando.
47
Com a função Serial.available() verificamos se algum sinal está sendo
transmitido ao Arduino. E com a função Serial.read() recebemos o sinal enviado,
podendo tratá-lo. A Figura 28, mostra um trecho do código.
Figura 28 - Código Serial
Por padrão, o Arduino vem configurado com as portas 0 e 1 para Rx e Tx
de conexões serial respectivamente, permitindo a utilização de outras portas através
do uso da biblioteca <Serial.h>.
Com a função Serial.avaiable() verificamos se algum sinal está sendo
transmitido ao Arduino. E com a função Serial.read() recebemos o sinal enviado,
podendo tratá-lo. A Figura 29 abaixo, mostra o hardware com Arduino pronto.
Figura 29 - Carro Pronto
48
3.1.6 Raspberry e Arduino
Existem duas formas de conectar o Raspberry com o Arduino, uma delas
é através da comunicação serial, através da conexão GPIO nas portas RX e TX e a
outra possibilidade é pela conexão USB. Para efetuar tal conexão, pode-se utilizar o
próprio cabo do Arduino, ou então um Cabo USB 2.0
Primeiramente no Arduino criamos uma conexão pela IDE. Já no
Raspberry Pi, verificamos primeiramente o endereço da porta USB. Feito isso, foi
criado um arquivo de teste testconexion.py. Nesse passo aparece a mensagem de
Comunicação serial via USB sendo impressa no Terminal, vindo diretamente
do Arduino.
Com os dois dispositivos integrados, temos o protótipo final do carro,
conforme mostra a Figura 30 e 31.
Figura 30 – Versão Final do Carro
49
Figura 31 - Versão Final Arduino e Raspberry
3.2 Visão Computacional com OpenCV
Nesta fase, a primeira tarefa foi conhecer a biblioteca OpenCV para
entender como ela funciona. Tendo que esta trabalha com diferentes linguagens de
programação, foi feita a escolha da Linguagem Python por sua simplicidade e por ter
sido estudada durante o curso.
Em seguida o primeiro passo foi a instalação do Python e OpenCV,
configurando bibliotecas específicas para o funcionamento dos mesmos. Para isso
também foi necessário a instalação do CMake, que tem a função de compilar o
código fonte do OpenCV.
Após a instalação e configuração do ambiente no Windows 7, a próxima
tarefa foi obter uma imagem da câmera. As Figuras 32 e 33 mostram trechos do
código desenvolvido.
50
Figura 32 - Obtendo imagem da câmera
Figura 33 - Testando uso da câmera
Uma das funções do OpenCV, é o método Haar Cascade utilizado para a
detecção de olhos. Esse algoritmo trabalha com a extração de características de
51
objetos e geração de classificadores em cascata capazes de reconhecer padrões de
objetos em uma imagem.
Após o treinamento é gerado um arquivo XML
(extensible Markup Language) chamado Classificador, lido pelo método
cascadeClassifier (). É possível encontrar alguns classificadores XML já treinados na
internet, porém são limitados. Diante disso, método para a detecção, foi baseado no
sistema de cores e o objeto uma bolinha de tênis.
Após os testes, apesar do Haar Cascade mostrar-se rápido na detecção
de objetos em tempo real, ele apresentou algumas falhas. Os resultados gerados
não foram os esperados, devido a imprecisão nas capturas, muitas vezes,
reconhecendo bocas como olhos.
Outro ponto negativo é seu método de aprendizagem que necessita de
um treinamento baseado na captura/aquisição de aproximadamente 2000 imagens
positivas (que possuem o objeto a ser detectado) e 2000 imagens negativas (que
não possuem o objeto). A Figura 34 mostra o uso do Haar Cascade e a Figura 35
mostra o código implementado.
Figura 34 - Uso do Haar Cascade
52
Figura 35 - Código Detecção Implementado
Configurando o RaspBerry Pi.
Para a instalação do Raspberry, foi utilizado o RaspBean 1.9.2 Jessie
(versão mais nova da distribuição Linux, baseada em Debian própria para RaspBerry
PI1).
Para realizar a instalação do software foram seguidos os seguintes
passos.
1- Download do sistema operacional
2- Descompactar o arquivo baixado
3- Copiar o conteúdo para o cartão de memória formatado
4- Inicialização do RaspBerry PI
Durante a instalação do sistema, foi selecionado o idioma e layout do
teclado e feito a escolha do sistema operacional desejado. Após a instalação do
sistema, em seguida foi feita a instalação do OpenCV e do Python 2.7.
1 Link para download: https://www.raspberrypi.org/downloads/noobs/
53
Pelo terminal foi preciso realizar a instalação das bibliotecas. O primeiro
passo é a atualização dos pacotes já existentes, seguido pela atualização do
firmware do Raspberry Pi.
$ sudo apt-get update $ sudo apt-get upgrade $ sudo rpi-update
Após a atualização do firmware o sistema foi reiniciado: $ sudo reboot Além de instalar as ferramentas de desenvolvimento: $ sudo apt-get install build-essential git cmake pkg-config Posteriormente foram instalados os pacotes de entrada e saída para carregar imagens como JPEG, PNG, TIFF, etc.:
$ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev Assim como, da mesma forma foram instalados os pacotes de entrada e saída para formatos de vídeo: sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev Também foi necessário instalar a biblioteca de desenvolvimento GTK: $ sudo apt-get install libgtk2.0-dev Diversas operações dentro do OpenCV (como as operações com matrizes) podem ser otimizadas usando dependências adicionais: $ sudo apt-get install libatlas-base-dev gfortran Por fim, foi instalado os cabeçalhos do Python 2.7 e Python 3, para compilar as ligações OPENCV + PYTHON.
$ sudo apt-get install python2.7-dev python3-dev
Posteriormente foi necessário o download do código fonte do OpenCV: cd ~ $ wget -O opencv.zip https://hithub.com/Itseez/opencv/archive/3.0.0.zip
54
$ unzip opencv.zip E instalado o opencv_contrib. (Certifique que o opencv_contrib seja a mesma versão do opencv) e o gerenciador de pacotes de Python (pip). $ wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.0.0.zip $ unzip opencv_contrib.zip $ wget https://bootstrap.pypa.io/get-pip.py $ sudo python get-pip.py E por último a biblioteca NumPy: $ pip install numpy Logo após as instalações o build foi Configurado: $ cd ~/opencv-3.0.0/ $ mkdir build $ cd build $ cmake -D CKMAKE_BUILD_TYPE = RELEASE\ $ cmake -D CKMAKE_BUILD_ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_C_EXAMPLES=ON\ -D INSTALL_PYTHON_EXAMPLES=ON \ -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.0.0/modules\ -D BUILD_EXAMPLES=ON .. Após tudo preparado foi compilado o opencv: $ make
$ sudo make install
$ sudo ldconfig $ python >>> import cv2 >>>cv2._version_ ‘3.0.0’
Após ser feita a Instalação, foi copiado o código ballTracking já
desenvolvido para o Raspberry.
Os dispositivos foram conectados através de suas portas USB. Para
realizar tal conexão foi utilizado o próprio cabo do Arduino. Um USB 2.0 com dois
conectores, de uso comum em impressoras.
55
Mais para o pleno funcionamento, seria necessário realizar a alimentação
do Raspberry. Pesquisas foram feitas, porém, nenhuma solução encontrada era
viável para realizar o protótipo.
Era necessário, uma fonte de alimentação de 5V e que fornecesse no
mínimo 1000ma/h, para o devido funcionamento. Até esse momento os testes
estavam sendo feitos por meio de cabo USB, conectado ao computador.
No entanto, a fonte de alimentação devia ser móvel, devido a
necessidade de que o protótipo funcionasse de forma autônoma.
Ao analisar o hardware, que possui entrada de energia mini USB foi
testado o uso de um carregador de celular convencional, que envia uma carga de
5v. Feito o teste, funcionou perfeitamente. Foi testado o uso de um PowerBank
(carregador portátil de celular), que funcionou perfeitamente, e resultados foram
surpreendentes, permitindo que o Raspberry ficasse ligado por 3 horas.
3.3 Resultados e Discussões
Através dos testes realizados, foi concluído que o protótipo desenvolvido
atende aos objetivos propostos. No final o protótipo criado utilizando Arduino e
Raspberry se locomove, sendo guiado por bola de tênis.
O desenvolvimento do trabalho começou com os testes para conexão
com Arduino. O primeiro passo foi colocar o Arduino para funcionar, porém uma das
primeiras dificuldades encontradas foi que o código incluso na IDE, não funcionava,
retornando o erro avrdude: stk500_recv(): programmer is not responding. Em
seguida descobrimos que é necessário a instalação de um drive USB FTDI, pois em
algumas situações o drive pode não ser reconhecido corretamente pelo sistema
operacional.
O uso de Motores DC, altamente usado em projetos de robótica, trouxe
resultados muitos positivos, garantindo potência e velocidade suficientes para
precisão dos motores, além de serem pequenos, beneficiando sua acomodação no
protótipo.
Atualmente o Raspberry, se encontra na 3ª versão, com configurações
altamente robustas, podendo ser até 10x mais poderoso que o da primeira versão. O
Raspberry utilizado mesmo sendo da 1ª versão, conseguiu executar a aplicação de
modo satisfatório.
56
Nos testes iniciais foi utilizado um webcam e com isso a resolução de
captação da imagem não teve um resultado 100% satisfatório. Devido a isso,
integramos a própria câmera do Raspberry que possui resolução de 8MP, e com
isso foi obtido precisão na hora de detecção e captura das imagens.
Quanto a visão computacional, uma das dificuldades encontradas, foi em
relação a luminosidade que interfere no trabalho de detecção de movimento. A
biblioteca OpenCV trabalha com a imagem colorida, e ele reconhece como modelo
de cor RGB (red, green, blue), que para o programa significa BGR. Para o
tratamento de para a máquina é mais fácil para manipular imagens utilizando a
escala de cinza, dessa forma ocorre a conversão de cor da imagem. Ao trabalhar
com sistema de cor, o algoritmo reconhecia a cor dos objetos a sua volta.
3.4 Custo do Projeto
Uma das grandes dificuldades para o desenvolvimento de trabalhos na
área de robótica é o alto custo dos componentes. Diante disso uma das propostas
do trabalho era a criação do protótipo, a baixo custo, e que o mesmo utilizasse
softwares e hardwares livres. A Tabela 3 abaixo mostra o custo total para
desenvolvimento do protótipo.
Quantidade Descrição Valor
1 Arduino Duemilanove R$ 145,00
2 Motores DC R$ 9,00
2 Rodas R$ 21,50
2 Placa de acrílico R$ 13,00
1 Módulo de comunicação
Bluetooth
R$ 21,90
1 Shield de motor L298N R$ 9,90
1 Engrenagem de direção R$ 2,00
1 Sensor de proximidade R$ 6,00
1 Caixa para pilhas R$ 6,90
1 Caixa para bateria 9V R$ 5,90
1 Mini Protoboard R$ 2,90
12 Cabos para conexão R$ 10,00
1 Bola de Tênis R$ 10,00
57
1 Raspberry R$ 2 180,00
TOTAL: R$: 444,00
Tabela 3- Modelo de Robô autônomo de baixo custo
Comparamos o projeto criado com um protótipo comercial semelhante, o
Lego Mindstorms, criado em parceria entre o Media Lab do Massachusetts Institute
of Technology (MIT) e a empresa LEGO, e que é composto por um kit de peças
tradicionais, e com funcionalidades adicionais, como sensores de toque, de
luminosidade e de temperatura, com a finalidade educacional. A Tabela 4 mostra o
valor do modelo.
Figura 36 - Lego Mindstorms Fonte: LEGO, 2016
Tabela 4 – Custo do Protótipo Comercial
Entre a comparação com os modelos, a construção do protótipo de robô,
obtém um baixíssimo custo, comparado com o vendido no mercado, cumprindo sua
proposta de baixo custo.
2 O Rasbperry usado no protótipo, foi cedido pela universidade, porém para fins de comparação
incluímos o custo no total de projeto.
3 Fonte: Mercado Livre
Modelo Valor
Lego Mindstorms
R$: R$ 2.249
Total:
R$: R$ 2.2493
58
4. CONCLUSÕES
Este trabalho apresentou o desenvolvimento de um projeto para a
construção de um robô, utilizando Arduino e Raspberry e a biblioteca de visão
computacional OpenCV, com o objetivo que o mesmo se locomova, a partir de
movimentos realizados com um objeto.
Os resultados obtidos mostraram que o robô identificou o objeto em
diferentes situações e fez com que fosse guiado de maneira correta em direção ao
objeto.
A metodologia empregada foi adequada e contribuiu para seu
desenvolvimento, e foi constatado que é uma plataforma viável, devido a facilidade
de desenvolvimento por meio dessas ferramentas.
Em relação ao baixo custo, os resultados também foram atingidos,
conforme os resultados mostrados em relação a um modelo comercial. Alem dos
baixos custos de componentes, utilizamos hardware e software livres, com uma
ampla comunidade e documentação, que também facilitou tanto na aprendizagem
quanto na construção de todo projeto.
Foram feitas pesquisas, com a finalidade de se obter um referencial
teórico para dar base no entendimento do conteúdo e também para descobrir quais
eram as ferramentas e tecnologias mais usadas atualmente na área de visão
computacional.
O uso do OpenCV se mostrou extremamente útil por possuir muitas
bibliotecas e também devido a seus resultados, que se mostram extremamente
satisfatórios. Os microcontroladores, foram desenvolvidos com a finalidade de
flexibilizar o desenvolvimento, na parte de eletrônica e programação, devido a sua
facilidade, e com possibilidades de uso infinitas.
Por meio desse projeto, é possível definir premissa para trabalhos futuros
onde pode se utilizar versões mais modernas e robustas do Raspberry, que
possuem um poder de processamento maior, e até mesmo aperfeiçoar a interface do
software.
O uso de visão computacional, embora ainda em progresso, é possível e
oferece qualidade na área de robótica. Com o uso de câmeras de qualidade e
computadores eficientes para auxiliar no processamento das imagens os resultados
59
são positivos. Os sistemas de visão computacional, não surgiram com o objetivo de
eliminar os recursos humanos, e sim como auxilio para produção de processos,
trazendo eficiência e eficácia, além da diminuição de custos, falhas, tempo de
trabalho e até mesmo ter acesso a lugares remotos.
A construção de protótipos robóticos de baixo custo, com visão
computacional, mostrou-se possível, onde o Arduino e o Raspberry são grandes
aliados.
60
5 BIBLIOGRAFIA
ALBUQUERQUE, Márcio Portes De; ALBUQUERQUE, Marcelo Portes De. Processamento de Imagens: Métodos e Análises. Editora da FACET, Rio de Janeiro, p. 1-12, 2001.
ARDUINO. Arduino cc. Disponível em: <http://www.arduino.cc/.>. Acesso em: 06 jun. 2016.
BRADSKI Gary; KAEHLER, Adrian. Learning opencv. 1 ed. Estados Unidos: O’Reilly, 2008. 571 p.
CARNEIRO, Tereza Cristina Teixeira Vieira, Percepção das cores. Instituto de Computação Uff. Disponível em: <http://www2.ic.uff.br/~aconci/curso/percep~1.htm>. Acesso em: 28 jul. 2016.
DAVID, E.E., SELFRIDGE, O.G., Bell Telephone Laboratories, Murray Hill, N.J. This paper appears in: Proceedings of the IRE Issue Date: May 1962 Volume: 50 1093 – 1101p
EMBARCADOS. Arduino - saídas pwm. Disponível em: <http://www.embarcados.com.br/arduino-saidas-pwm/>. Acesso em: 20 jun. 2016.
EMBARCADOS. Comunicação SPI Disponível em: <http://www.embarcados.com.br/spi-parte-1-saidas/>. Acesso em: 20 jun. 2016.
EVANS, Martin; et al. Arduino in action. 1 ed. Estados Unidos: Manning, 2013. 424p.
FERNANDES, Leandro Augusto Frata. Visão Computacional. UFF, nov. 2012. Disponível em: <http://www2.ic.uff.br/~julius/icc/vcomp.pdf>. Acesso em: 02 mai. 2016.
FILHO, Ogê Marques; NETO, Hugo Vieira. Processamento digital de imagens. Rio de Janeiro: Brasport, 1999. 331 p.
FLIPFLOP. Sensor ultrasonico arduino. Disponível em: <http://blog.filipeflop.com/sensores/sensor-ultrassonico-hc-sr04-ao-arduino.html> Acesso em: 03 jul. 2016.
G. SHAPIRO, Linda; STOCKMAN, George. Computer vision. 1 ed. Estados Unidos: Pearson, 2000. 608 p.
GONZALEZ, Rafael C.; WOODS, Richard E. Digital image processing. 3 ed. Estados Unidos: Pearson, 2008. 976 p.
GPIO. Disponível em: <http://www.raspberrypi.org/gpio.htm>. Acesso em: 06 jun.
61
2016.
HAUGHTON, Brian. História oculta. 1 ed. São Paulo: Estampa, 2009. 352 p.
INSTRUCTABLES. DC motor. Disponível em: <http://www.instructables.com/id/arduino-dc-motor-speed-control-potentiometer/>. Acesso em: 13 jul. 2016.
INTEL. Model HSV. Disponível em: < https://software.intel.com/en-us/articles/intel-opencv-beta>. Acesso em: 30 jul. 2016.
KANASHIRO, Milena. A cidade e os sentidos: sentir a cidade. Revista UFPR, [S.L], v. 7, p. 1-6, jun. 2003.
MCROBERTS, Michael. Arduino básico. 1 ed. São Paulo: Novatec, 2011. 512 p.
MECAWEB. PWM – Modulação por largura de pulso. Disponível em: <http://www.mecaweb.com.br/eletronica/content/e_pwm>. Acesso em: 29 jul. 2016. NEWTONCBRAGA. Como funciona o motor de corrente contínua. Disponível em: <http://www.newtoncbraga.com.br/index.php/como-funciona/3414-art476a>. Acesso em: 02 jul. 2016. OPENCV. Open source computer vison. Disponível em: <http://opencv.org/>. Acesso em: 07 jun. 2016.
PENIDO, Édilus De Carvalho Castro; TRINDADE, Ronaldo Silva. Microcontroladores. IFMG, [S.L], v. 1, n. 1, p. 1-80, jan. 2013. Disponível em: <http://estudio01.proj.ufsm.br/cadernos/ifmg/tecnico_automacao_industrial/microcontroladores.pdf />. Acesso em: 20 jun. 2016.
RASPBERRY. Products. Disponível em: <https://www.raspberrypi.org/products>. Acesso em: 03 ago. 2016.
RICHARDSON Matt; WALLACE Shawn. Primeiros passos com o raspberry pi. 1 ed. Sao Paulo: Novatec, 2013. 192 p. ROBOTSHOP. History of robotics: Timeline. Maio. 2008. Disponível em: <http://www.robotshop.com/media/files/pdf/timeline.pdf>. Acesso em: 06 jun. 2016.
RUSSELL, Stuart J.; NORVIG, Peter. Artificial intelligence: A Modern Approach. 1 ed. Estados Unidos: Prentice-Hall, 1995. 946 p.
SMITH, Alvy Ray. Http://alvyray.com/Papers/CG/color78.pdf. IEEE computer society press, v. 2, p. 376-383, 1982. Disponível em: <http://alvyray.com/Papers/CG/color78.pdf>. Acesso em: 05 jul. 2016.
SZELISKI, Richard. Computer vision: algorithms and applications. 1 ed. Estados Unidos: Springer Science & Business Media, 2010. 812 p.
62
TOCCI, J. Ronald; et al. Sistemas digitais: princípios e aplicações. 10 ed. São Paulo: Pearson, 2007. 560 p.
TOOLEY, Mike. Circuitos eletrônicos. 1 ed. São Paulo: Elsevier2007, 2007. 432 p.