inseto robo
TRANSCRIPT
TRABALHO ATIVIDADES COMPLEMENTARES (FETEF)
INSETO ROBÔ
por
EDY CARLOS DOS SANTOSJACKSON F. SOUZAMARINO D. RAMOSPAULO A. DOS REIS
Acadêmicos do 8º Semestre do Curso de Engenharia de Controle e Automação
Extrema - MG2014
FACULDADE DE CIÊNCIAS SOCIAIS APLICADAS DE EXTREMA
RESUMO
Este documento apresenta um projeto que aborda o estudo e o desenvolvimento de um dispositivo mini Robô, com o uso de um sensor infravermelho obtém a finalidade de desviar de obstáculos evitando a colisão, usando dois servos motores ele tem por finalidade movimentar-se, tem como controladora principal uma placa baseada em arduinos e uma outra placa expansão de hardware. O objetivo deste projeto constitui-se, principalmente na aplicação dos conceitos e dos conhecimentos já adquiridos em matérias já vistas e que ainda veremos ao longo do curso, a abordagem desses estudos nos possibilitou a construção de um artefato que possibilitasse a aprendizagem e aperfeiçoamento em programação, robótica, micro controladores, eletrônica digital e analógica, servos, etc.Palavras-chave: Inseto, Robô, Sensor Infravermelho.
ABSTRACT
This paper presents a project that deals with the study and development of mini robot device with the use of an infrared sensor in order to get around obstacles avoiding collision using two servo motors it is intended to move, is one main controller board based on Arduino and other hardware expansion card. The goal of this project is mainly in the application of the concepts and the knowledge acquired in subjects previously seen and the ones we will see throughout the course the approach of these studies allowed us to build a device that would enable learning and improvement in programming , robotics, micro controllers, digital and analog electronics, servos, etc.Keywords: Insect, Robot, Infrared Sensor.
LISTA DE FIGURASFig. 2.1 - Microcontroladores..........................................................................................3Fig. 2.2 - Uso de microcontroladores em automóveis.....................................................5Fig. 2.3 - Automação doméstica.....................................................................................5Fig. 2.4 - Ciclo de Máquina.............................................................................................7Fig. 3.1 - Detecção por Reflexão....................................................................................8Fig 3.2 - Detecção por interrupção..................................................................................9Fig 3.3 – Camera Escura.................................................................................................9Fig. 4.1 - O processo da compilação.............................................................................11Fig. 4.2 - Livros sobre diversas linguagens de programação.........................................14Fig. 5.1 - ATmega32U4..................................................................................................15Fig. 5.2 – Placa Controladora........................................................................................16Fig 5.3 – Sensor Infravermelho......................................................................................17Fig. 5.4 – Placa expansão..............................................................................................18Fig. 5.5 – Micro Servo....................................................................................................18Fig. 6.1 - Ambiente de programação..............................................................................19Fig. 6.2 - Entendendo o programa.................................................................................20Fig. 6.3 - Exemplo serial monitor...................................................................................21Fig. 6.4 - Saída no serial monitor...................................................................................22Fig 6.5 - Programação para Inseto Robô.......................................................................23Fig 7.1- Restantes das figuras são de montagem..........................................................24
SUMÁRIO
LISTA DE FIGURAS.................................................................................................. iii
1 INTRODUÇÃO..........................................................................................................11.1 OBJETO DO ESTUDO.......................................................................................11.2 OBJETIVOS DO TRABALHO.............................................................................11.3 VIABILIDADE E JUSTIFICATIVA.......................................................................21.4 DIFICULDADES ENCONTRADAS NO PROJETO.............................................2
2 MICROCONTROLADOR..........................................................................................32.1 MICROCONTROLADORES VERSUS MICROPROCESSADORES..................42.2 APLICABILIDADE...............................................................................................42.3 ESTRUTURA DO MICROCONTROLADOR.......................................................52.4 FUNCIONAMENTO............................................................................................7
3 SENSOR INFRAVERMELHO..................................................................................84 LINGUAGEM DE PROGRAMAÇÃO E COPILADORES.......................................10
4.1 INTERPRETAÇÃO E COMPILAÇÃO...............................................................114.2 CONCEITOS.....................................................................................................12
4.2.1 PROGRAMAÇÃO ESTRUTURADA...........................................................124.2.2 PROGRAMAÇÃO ORIENTADA A OBJETOS............................................134.2.3 PROGRAMAÇÃO LINEAR.........................................................................14
4.3 LISTA DE LINGUAGENS.................................................................................145 HARDWARE...........................................................................................................15
5.1 MICROCONTROLADOR ATMEL ATMEGA32U4............................................155.1.1 UM POUCO SOBRE A FAMÍLIA................................................................16
5.2 PLACA PRINCIPAL..........................................................................................165.2.1 PLACA CONTROLADORA........................................................................165.2.2 FUNÇÃO DOS COMPONENTES..............................................................17
5.3 SENSOR DE DISTÂNCIA SHARP GP2Y0A02YK............................................175.3.1 ESPECIFICAÇÕES....................................................................................17
5.4 PLACA EXPANSÃO DE HARDWARE..............................................................185.5 MICRO SERVO 9G SG90 TOWERPRO..........................................................18
5.5.1 ESPECIFICAÇÕES....................................................................................18- Voltagem de Operação: 3,0 - 7,2V - Ângulo de rotação: 180 graus - Velocidade: 0,12 seg/60Graus (4,8V) sem carga - Torque: 1,2 kg.cm (4,8V) e 1,6 kg.cm (6,0V) - Temperatura de Operação: -30C ~ +60C - Tipo de Engrenagem: Nylon - Tamanho cabo: 245mm - Dimensões: 32 x 30 x 12mm - Peso: 9g........................................18
6 SOFTWARE...........................................................................................................186.1 ESTRUTURA DO PROGRAMA........................................................................206.2 SERIAL MONITOR...........................................................................................216.3 OUTROS COMANDOS....................................................................................22
6.3.1 PROGRAMAÇÃO PARA INSETO ROBÔ..................................................236.3.2 ARDUBLOCK.............................................................................................23
7 MONTAGEM E RESULTADOS.............................................................................238 CONCLUSÕES.......................................................................................................309 REFERÊNCIAS......................................................................................................31
APÊNDICE A – Layout da placa...................................Erro! Indicador não definido.3APÊNDICE B – Codigo fonte do Firmware..........................................................324
1 INTRODUÇÃO
O mini Inseto Robô é um mini robô. Seu desenvolvimento foi pensando em
construir um robô que se movimentasse para frente e para os lados, com o objetivo
de desviar de obstáculos, deixando seu visual a de um inseto e sua estrutura (corpo)
o menor possível. Sua montagem emprega conhecimentos de robótica básica
eletrônica, todos os componentes trabalham em conjunto.
Tem um microcontrolador como cérebro, dois servos motores para os
movimentos, um sensor de IR (infravermelho) irá funcionar como olhos para detectar
obstáculos. Com uma programação baseada em controles de arduino, gera um
código onde o controla todos os seus hardwares.
1.1 OBJETO DO ESTUDO
O trabalho consiste preparação de um mini robô, para a detectar obstáculos,
auxiliando-o para não colidir. Buscando a implantação de componentes pequenos e
leves.
1.2 OBJETIVOS DO TRABALHO
Os objetivos do trabalho foram:
Aplicar os conhecimentos adquiridos nas diversas disciplinas do curso de
engenharia elétrica e eletrônica, explicitando as disciplinas dedicadas ao
estudo de eletrônica analógica e digital, microcontroladores, técnicas
computacionais e instrumentação, algoritmos, robótica, servos, etc;
Adquirir experiência no desenvolvimento de projetos, desde as etapas
iniciais de concepção até os testes e correções do protótipo final;
Adquirir conhecimentos sobre microcontroladores, transistores, resistores,
sensores, motores, programação, comunicação, ondas sonoras.
Para alcançar as metas foram previstas as seguintes etapas:
Definição das referências bibliográficas;
Escolha do material utilizado;
Especificação e compra dos componentes;
Montagem do circuito e testes;
Programação.
Correção de possíveis erros;
Montagem do protótipo;
Validação do projeto;
Preparação da monografia;
Apresentação final do trabalho.
1.3 VIABILIDADE E JUSTIFICATIVA
Ao decorrer do curso, fomos apresentados a eletrônica digital e aos
microcontroladores, por apresentarem redução de tamanho, e consumo de energia,
juntamente com o seu baixo custo, os microcontroladores são uma alternativa
eficiente para controlar muitos processos e aplicações.
Visando esses benefícios resolvemos sua implantação, buscando oferecer um
projeto de baixo custo.
O projeto consiste em uma placa de baixo custo de confecção, utilizando
componentes facilmente encontrados no comércio especializado. Também foram
utilizados compiladores obtidos na internet gratuitamente, buscando sempre o menor
custo de execução do projeto, para que uma futura reprodução deste módulo possa
ocorrer de maneira rápida e barata.
1.4 DIFICULDADES ENCONTRADAS NO PROJETO
Durante o desenvolvimento do projeto, muitas dificuldades foram
encontradas, onde podemos identificar algumas aqui.
A primeira delas foi a aquisição do material, os produtos utilizados apesar de
serem fácil de encontrar no comercio especializado acabou nos trazendo um
problema, pois na nossa região não há esse tipo de comercio. Toda vez que faltava
um produto tínhamos que parar o processo de montagem, e deslocar até São Paulo
para efetuar a compra, ou até mesmo fazer pedido por meio do comércio eletrônico,
onde demorava alguns dias para ser entregue.
Outro ponto a ser destacado foi a programação, apesar de termos passado
por dois semestres de linguagem de programação, tivemos alguma dificuldade na
elaboração do código, pois é nessa hora que percebemos que tem muita coisa ainda
para aprender. Decidimos a não procurar alguém para fazer o código ou até mesmo
nos ajudar nesse ponto, e sim procuramos tentar a entender e aprender mais sobre
programação, o que nos possibilitou a formular o código, que ainda pode ser
melhorado e até mesmo simplificado.
Por fim unindo informações desconexas, várias tentativas e muito esforço, as
dificuldades foram sendo vencidas e então deram lugar à satisfação de ver cada
etapa superada.
2 MICROCONTROLADOR
O microcontrolador é um componente eletrônico programável que configura-
se como um sistema computacional completo, onde se incluem uma CPU (Central
Processor Unit), memória de dados, memória de programa e EEPROM, pinos de
Entrada/Saída que podem ser analógicos ou digitais, temporizadores, comunicação
USB e serial, osciladores, conversores A/D, comparadores e geradores de pulso.
Utilizado em projetos de automação e na construção de aparelhos
eletrônicos, possuem tamanho reduzido e apresentam pequeno consumo de
energia, porém o mais relevante é seu baixo custo, o que torna popular a utilização
do microcontrolador em vários dispositivos comercializados, tornando-se uma
alternativa muito eficiente para controlar vários processos.
Diferente dos microprocessadores em
vários aspectos, pois não necessita do
acréscimo de componentes ao sistema, poupa
tempo e espaço na construção dos
dispositivos, uma vez que os periféricos
necessários já se encontram no
encapsulamento. A Fig.2.1 mostra alguns tipos
de microcontroladores.
2.1 MICROCONTROLADORES VERSUS MICROPROCESSADORES
Um microcontrolador difere de um microprocessador em vários aspectos.
Primeiro e o mais importante, é a sua funcionalidade. Para que um
microprocessador possa ser usado, outros componentes devem-lhe ser adicionados,
Fig. 2.1 - Microcontroladores
tais como memória e componentes para receber e enviar dados. Em resumo, isso
significa que o microprocessador é o verdadeiro coração do computador. Por outro
lado, o microcontrolador foi projetado para ter tudo num só. Nenhuns outros
componentes externos são necessários nas aplicações, uma vez que todos os
periféricos necessários já estão contidos nele. Assim, nós poupamos tempo e
espaço na construção dos dispositivos.
2.2 APLICABILIDADE
Para cada necessidade, deve-se avaliar cuidadosamente a escolha do
microcontrolador, a fim de evitar um aumento no custo do projeto final. Existem
várias empresas fabricantes de integrados que possuem muitas linhas de
microcontroladores, diferenciadas pela capacidade de processamento ou
armazenamento e periféricos integrados ao sistema de maneira que o projetista
possa escolher adequadamente o modelo mais indicado para o seu projeto, evitando
agregar gastos desnecessários ao produto final.
Os microcontroladores se fazem presentes em diversos segmentos, dos quais
podemos citar a automação industrial, automação comercial, automação predial,
área automobilística, área agrícola, produtos manufaturados, eletrodomésticos,
telecomunicações, entre outros.
A maioria dos eletrônicos e eletrodomésticos são controlados por
microcontroladores, que podem ser encontrados em todos os lugares, como:
televisores, refrigeradores, celulares, instrumentos musicais eletrônicos, forno de
microondas e em outros diversos produtos que são frequentemente usados todos os
dias por todas as pessoas.
Com uma produção
estimada em 63 milhões de
carros no mundo a cada ano,
um carro possui
aproximadamente 30
microcontrolador nos modelos
mais simples e cerca de 70
microcontroladores nos
Fig. 2.2 - Uso de microcontroladores em automóveis
modelos mais completos, o que agrega segurança, conforto e eficiência ao veículo
figura 2.2. Fonte: Microchip Technology Inc. (www.microchip.com)
Em residências figura 2.3, são
utilizados na automação de portões,
alarmes, sensores de luminosidade,
cortinas motorizadas, climatização,
centrais telefônicas, irrigação de
jardins, e várias outras aplicações. Fonte:
2.3 ESTRUTURA DO MICROCONTROLADOR
O microcontrolador é composto por:
CPU - conecta todos os blocos do microcontrolador e executa o
programa;
Memória de programa – armazena o programa que a CPU
executará, pode ser regravada inúmeras vezes sem danificar o
microcontrolador para modelos com memória tipo Flash.
Memória EEPROM – usada para guardar dados importantes que não
podem ser perdidos após o desligamento da alimentação.
Memória RAM – memória utilizada pelo programa durante sua execução
que armazena os resultados intermediários ou temporários.
Barramentos – existem dois tipos de barramentos, que são os caminhos
de comunicação entre os componentes do microcontrolador. O
barramento de endereço serve para endereçar posições de memória para
a CPU, e o barramento de dados interliga os componentes internos do
microcontrolador.
Entrada / Saída – dispositivos que interligam o microcontrolador com
sistemas externos, comunicam-se com os outros componentes do
microcontrolador através do barramento de dados.
Contador e temporizador – usados em rotinas que precisam de noções
de tempo ou contadores temporais, utiliza um registrador de 8 bits
independente do programa. O contador incrementa até atingir o valor
máximo de 255 e recomeça a contagem a partir de zero. O tempo entre
Fig. 2.3 - Automação doméstica
dois incrementos sucessivos do temporizador, pode ser utilizado para
medir intervalos de tempo.
Watchdog – Uma outra coisa que nos vai interessar é a fluência da
execução do programa pelo microcontrolador durante a sua utilização.
Suponha que como resultado de qualquer interferência (que ocorre
frequentemente num ambiente industrial), o nosso microcontrolador pára
de executar o programa ou, ainda pior, desata a trabalhar incorretamente.
Claro que, quando isto acontece com um computador, nós simplesmente
carregamos no botão de reset e continuamos a trabalhar. Contudo, no
caso do microcontrolador nós não podemos resolver o nosso problema
deste modo, porque não temos botão. Para ultrapassar este obstáculo,
precisamos de introduzir no nosso modelo um novo bloco chamado
watchdog (cão de guarda). Este bloco é de facto outro contador que está
continuamente a contar e que o nosso programa põe a zero sempre que é
executado corretamente. No caso de o programa "encravar", o zero não
vai ser escrito e o contador, por si só, encarregar-se-á de fazer o reset do
microcontrolador quando alcançar o seu valor máximo. Isto vai fazer com
que o programa corra de novo e desta vez corretamente. Este é um
elemento importante para que qualquer programa se execute fiavelmente,
sem precisar da intervenção do ser humano.
Conversor Analógico/Digital (A/D) – Como os sinais dos periféricos são
substancialmente diferentes daqueles que o microcontrolador pode
entender (zero e um), eles devem ser convertidos num formato que possa
ser compreendido pelo microcontrolador. Esta tarefa é executada por
intermédio de um bloco destinado à conversão analógica-digital ou com
um conversor A/D. Este bloco vai ser responsável pela conversão de uma
informação de valor analógico para um número binário e pelo seu trajeto
através do bloco do CPU, de modo a que este o possa processar de
imediato.
2.4 FUNCIONAMENTO
Ciclos de máquina: Nos microcontroladores PIC, um ciclo de máquina
possui internamente uma divisão em quatro partes iguais, assim, para um sinal de
clock externo de 4 MHz, temos um clock interno de 1 MHz, consequentemente
teremos um ciclo de máquina igual a 1 μs. A Figura 2.4 representa a divisão do ciclo
de máquina.
Fig. 2.4 - Ciclo de Máquina
Da divisão do clock, formam quatro fases Q1, Q2, Q3 e Q4. O contador de
programa é incrementado automaticamente na fase Q1 do ciclo de máquina e a
próxima instrução é resgatada da memória de programa e guardada no registrador
de instruções no ciclo Q4.
A instrução é decodificada e executada no ciclo de máquina seguinte, entre o
intervalo de Q1 e Q4. Essa característica de buscar uma informação para executá-la
no próximo ciclo ao mesmo tempo em que outra instrução é carregada, denomina-se
pipeline (sobreposição).
O pipeline permite que quase todas as instruções executem em apenas um
ciclo, otimizando o sistema.
Existem instruções que fogem a esta regra, que são as instruções que geram
“saltos” no contador do programa, como chamadas de funções em outros locais da
memória de programa ou em retornos dessas funções.
3 SENSOR INFRAVERMELHOSensores são elementos importantes porque servem na maioria das vezes
como olhos para alarmes e robôs. Um sensor infravermelho que pode ser feito sem
nenhum problema e que utiliza apenas um comparador de tensão para filtragem de
ruídos externos.
Mas antes de falar sobre o circuito vamos entender um pouco como podemos
utilizar um sensor IR.
Este circuito pode ser utilizado
principalmente de duas maneiras:
detecção pode reflexão e detecção
por interrupção de feixe.
3.1 Detecção por ReflexãoNeste tipo de aplicação, um
feixe é projetado por LED emissor de
luz infravermelha que, ao ser refletido por algum obstáculo, é detectado por um foto-
transistor. Quanto mais próximo o
obstáculo estiver do conjunto emissor-receptor, maior será a intensidade do sinal
recebido. A figura 3.1 abaixo mostra um exemplo de detecção por reflexão.
2) Detecção por InterrupçãoNeste tipo de aplicação, o emissor e receptor são instalados um em frente ao
outro. Para este caso, o receptor fica constantemente recebendo o feixe de
infravermelho. A figura 3.2 mostra um exemplo de detecção por interrupção.
Porém, neste circuito o ajuste torna-se crítico em virtude de interferências
externas geradas pela luz infravermelha do sol e
de lâmpadas em ambientes fechados.
Por isso esta montagem somente é
indicada em situações onde é possível a proteção
do receptor, ou seja instalação de uma câmera
escura.
Fig. 3.5 - Detecção por Reflexão
Fig 3.6 - Detecção por interrupção
Um exemplo bem simples de confecção de uma câmera escura, é utilizando
um tubo com a mesmo diâmetro do receptor, preferencialmente, conforme mostrado
fig 3.3.
OBS: Mas se isso não for suficiente
para seu projeto, então será
necessário realizar a modulação do
sinal. Pois adetecção através de um
sinal infravermelho modulado
apresenta grande imunidade a ruído,
permitindo a detecção em distâncias maiores.
Neste circuito utilizamos um comparador de tensão ( LM339 ) que possui
quatro comparadores internos, sendo que a principal função deste componente é
reduzir a interferência externa. Pois a montagem do receptor IR em serie com um
resistor de 47 K ohms em ambiente escuro fornece uma variação de 0 a 5v, porem
em um ambiente iluminado esta variação é bem menor. Por isso a necessidade do
comparador que usa como referência a tensão proveniente do potenciômetro, assim
teremos a mesma variação de 0 a 5v.
Com esta montagem e possível detectar uma objeto a uma distância de 15
cm dependendo do ambiente, porem se necessitar de uma distância maior basta
substituir resistor de 330 ohms por outro de menor valor, levando em consideração a
corrente máxima suportada pelo emissor IR.
4 LINGUAGEM DE PROGRAMAÇÃO E COPILADORES
Uma linguagem de programação é um método padronizado para
comunicar instruções para um computador. É um conjunto de regras sintáticas e
semânticas usadas para definir um programa de computador. Permite que um
programador especifique precisamente sobre quais dados um computador vai atuar,
como estes dados serão armazenados ou transmitidos e quais ações devem ser
Fig 3.7 – Camera Escura
tomadas sob várias circunstâncias. Linguagens de programação podem ser usadas
para expressar algoritmos com precisão.
Uma das principais metas das linguagens de programação é permitir que
programadores tenham uma maior produtividade, permitindo expressar suas
intenções mais facilmente do que quando comparado com a linguagem que um
computador entende nativamente (código de máquina). Assim, linguagens de
programação são projetadas para adotar uma sintaxe de nível mais alto, que pode
ser mais facilmente entendida por programadores humanos. Linguagens de
programação são ferramentas importantes para que programadores e engenheiros
de software possam escrever programas mais organizados e com maior rapidez.
Um compilador é um programa de computador (ou um grupo de programas) que,
a partir de um código fonte escrito em uma linguagem compilada, cria um programa
semanticamente equivalente, porém escrito em outra linguagem, código objeto. Ele
é chamado compilador por razões históricas; nos primeiros anos da programação
automática, existiam programas que percorriam bibliotecas de subrotinas e as reunia
juntas, ou compilava, as subrotinas necessárias para executar uma determinada
tarefa.
O nome "compilador" é usado principalmente para os programas que traduzem o
código fonte de uma linguagem de programação de alto nível para uma linguagem
de programação de baixo nível (por exemplo, Assembly ou código de máquina).
Contudo alguns autores citam exemplos de compiladores que traduzem para
linguagens de alto nível como C. Para alguns autores um programa que faz uma
tradução entre linguagens de alto nível é normalmente chamado um tradutor,
filtro ou conversor de linguagem. Um programa que traduz uma linguagem de
programação de baixo nível para uma linguagem de programação de alto nível é
um descompilador. Um programa que faz uma tradução entre uma linguagem de
montagem e o código de máquina é denominado montador (assembler). Um
programa que faz uma tradução entre o código de máquina e uma linguagem de
montagem é denominado desmontador (disassembler). Se o programa compilado
pode ser executado em um computador cuja CPU ou sistema operacional é diferente
daquele em que o compilador é executado, o compilador é conhecido como
um compilador cruzado.
4.1 INTERPRETAÇÃO E COMPILAÇÃO
Uma linguagem de programação pode ser
convertida, ou traduzida, em código de máquina
por compilação ou interpretada por um processo
denominado interpretação. Em ambas ocorre
a tradução do código fonte para código de máquina.
Se o método utilizado traduz todo o texto do
programa (também chamado de código), para só
depois executar o programa, então diz-se que o
programa foi compilado e que o mecanismo utilizado
para a tradução é um compilador (que por sua vez
nada mais é do que um programa), figura 4.1. A versão
compilada do programa tipicamente é armazenada, de
forma que o programa pode ser executado um número
indefinido de vezes sem que seja necessária nova
compilação, o que compensa o tempo gasto na compilação. Isso acontece com
linguagens como Pascal e C.
Se o texto do programa é executado à medida que vai sendo traduzido, como
em JavaScript, BASIC, Python ou Perl, num processo de tradução de trechos
seguidos de sua execução imediata, então diz-se que o programa foi interpretado e
que o mecanismo utilizado para a tradução é um interpretador. Programas
interpretados são geralmente mais lentos do que os compilados, mas são também
geralmente mais flexíveis, já que podem interagir com o ambiente mais facilmente.
Embora haja essa distinção entre linguagens interpretadas e compiladas, as
coisas nem sempre são tão simples. Há linguagens compiladas para um código de
máquina de uma máquina virtual (sendo esta máquina virtual apenas mais um
software, que emula a máquina virtual sendo executado em uma máquina real),
como Java (compila para a plataforma Java ) e C♯ (compila para a plataforma CLI ).
E também há outras formas de interpretar em que os códigos fontes, ao invés de
serem interpretados linha-a-linha, têm blocos "compilados" para a memória, de
acordo com as necessidades, o que aumenta a performance dos programas quando
os mesmos módulos são chamados várias vezes, técnica está conhecida como JIT.
Fig. 4.8 - O processo da compilação
Como exemplo, podemos citar a linguagem Java. Nela, um compilador traduz o
código java para o código intermediário (e portável) da JVM. As JVMs originais
interpretavam esse código, de acordo com o código de máquina do computador
hospedeiro, porém atualmente elas compilam, segundo a técnica JIT o código JVM
para código hospedeiro.
A tradução é tipicamente feita em várias fases, sendo as mais comuns a análise
léxica, a análise sintática (ou parsing), a geração de código e a otimização. Em
compiladores também é comum a geração de código intermediário.
4.2 CONCEITOS
4.2.1 PROGRAMAÇÃO ESTRUTURADA
Programação estruturada é uma forma de programação de computadores que
preconiza que todos os programas possíveis podem ser reduzidos a apenas três
estruturas: sequência, decisão e repetição. Um dos primeiros a preconizar a
programação estruturada foi Haskell B. Curry. Tendo, na prática, sido transformada
na Programação modular, a Programação estruturada orienta os programadores
para a criação de estruturas simples em seus programas, usando as sub-rotinas e
as funções. Foi a forma dominante na criação de software entre a programação
linear e a programação orientada por objetos. Apesar de ter sido sucedida pela
programação orientada por objetos, pode-se dizer que a programação estruturada
ainda é marcantemente influente, uma vez que grande parte das pessoas ainda
aprendem programação através dela. Porém, a orientação a objetos superou o uso
das linguagens estruturadas no mercado.
4.2.2 PROGRAMAÇÃO ORIENTADA A OBJETOS
Orientação a objetos, também conhecida como Programação Orientada a
Objetos (POO) ou ainda em inglês Object-Oriented Programming (OOP) é um
paradigma de análise, projeto e programação de sistemas de software baseado na
composição e interação entre diversas unidades de software chamadas de objetos.
O extensivo uso de objetos, particularmente em conjunção com o mecanismo de
herança, caracteriza o estilo de programação orientada a objetos. Em alguns
contextos, prefere-se usar modelagem orientada ao objeto, em vez de programação.
De fato, o paradigma "orientação a objetos" tem bases conceituais e origem no
campo de estudo da cognição, que influenciou a área de inteligência artificial e da
linguística no campo da abstração de conceitos do mundo real.
Na qualidade de método de modelagem, é tida como a melhor estratégia, e mais
natural, para se eliminar o "gap semântico", dificuldade recorrente no processo de
modelar o mundo real, no domínio do problema, em um conjunto de componentes
de software que seja o mais fiel na sua representação deste domínio. Facilitaria a
comunicação do profissional modelador e do usuário da área alvo, na medida em
que a correlação da simbologia e conceitos abstratos do mundo real e da ferramenta
de modelagem (conceitos, terminologia, símbolos, grafismo e estratégias) fosse a
mais óbvia, natural e exata possível. A análise e projeto orientados a objetos tem
como meta identificar o melhor conjunto de objetos para descrever um sistema de
software.
O funcionamento deste sistema se dá através do relacionamento e troca de
mensagens entre estes objetos. Na programação orientada a objetos, implementa-
se um conjunto de classes que definem os objetos presentes no sistema de
software. Cada classe determina o comportamento (definido nos métodos) e estados
possíveis (atributos) de seus objetos, assim como o relacionamento com outros
objetos.
4.2.3 PROGRAMAÇÃO LINEAR
Em matemática, problemas de Programação Linear são problemas de otimização
nos quais a função objetivo e as restrições são todas lineares. Programação Linear é
uma importante área da otimização por várias razões. Muitos problemas práticos em
pesquisa operacional podem ser expressos como problemas de programação linear.
Certos casos especiais de programação linear, tais como problemas de network
flow e problemas de multicommodity flow são considerados importantes o suficiente
para que se tenha gerado muita pesquisa em algoritmos especializados para suas
soluções. Vários algoritmos para outros tipos de problemas de otimização funcionam
resolvendo problemas de PL como sub-problemas. Historicamente, idéias da
programação linear inspiraram muitos dos conceitos centrais de teoria da
otimização, tais como dualidade, decomposição, e a importância da convexidade e
suas generalizações.
4.3 LISTA DE LINGUAGENS
Existem várias linguagens de programação; de acordo com o Índice Tiobe, as 20
mais populares são:
1. C
2. Java
3. Objective-C
4. C++
5. PHP
6. C♯
7. Visual Basic
8. Python
9. Perl
10.JavaScript
11.Ruby
12.Visual Basic .NET
13.Transact-SQL
14.Lisp
15.Pascal
16.Bash
17.PL/SQL
18.Delphi / Object Pascal
19.Ada
20.MATLAB
5 HARDWARE
O hardware pode ser compreendido como a parte física do projeto, composta
pelos componentes eletrônicos, pelos sensores, vibradores, cabos, conectores e
pela placa em si. O hardware é basicamente utilizado por computadores e
eletrônicos, qualquer equipamento como chaves, fechaduras, correntes e peças do
próprio computador, são chamados de hardwares. Os hardwares não se limitam
Fig. 4.9 - Livros sobre diversas linguagens de programação
apenas a computadores pessoas, também estão disponíveis em automóveis,
aparelhos de celular e etc.
Para o bom funcionamento do hardware, é também necessário o software,
que é a parte lógica da informática.
A seguir mostraremos alguns hardwares e componentes utilizados nesse
projeto.
5.1 MICROCONTROLADOR ATMEL ATMEGA32U4 A Figura 5.1 mostra-nos o microcontrolador
ATmega32U4 da Atmel é utilizado nos Arduinos mais
recentes. É um microcontrolador de 8 bits, com arquitetura
Harvard modificada. Neste post e nos próximos veremos
algumas de suas características.
5.1.1 UM POUCO SOBRE A FAMÍLIA
O megaAVR é ideal para aplicações que utilizam grandes quantidades de
código e memória de dados oferece programa eo desempenho até 20 MIPS. A
tecnologia inovadora picoPower minimiza o consumo de energia. Todos os
megaAVR oferecem sintonizador automático para rápido, seguro, custo atualizações
eficientes e econômicos. Você pode até mesmo atualizar a memória flash durante a
execução do aplicativo. A família de MegaAVR baseia-se numa tecnologia
comprovada e líder do mercado e oferece a mais ampla seleção de dispositivos em
termos de memória, o número de pinos e periféricos. Escolha a partir de dispositivos
de uso geral para modelos com periféricos especializados, tais como USB,
controladores de LCD e amplificadores, controladores CAN e LIN. É fácil encontrar a
combinação perfeita para o seu projeto megaAVR família de produtos.
5.2 PLACA PRINCIPAL
Foi feita a montagem de um circuito essencial para o funcionamento do
microcontrolador, com base o funcionamento de um arduino só que em tamanho
Fig. 5.10 - ATmega32U4
reduzido, para caber dentro do cano da bengala. Utilizamos o Beetle e gravamos o
programa usando o Arduino.
5.2.1 PLACA CONTROLADORA
A figura 5.2 mosra a nova geração do
controlador deriva sua noção central do
minimalismo sem comprometer a
funcionalidade. Ele vem com Atmel
AtMega32u4 ( folha de dados ) @ 16MHz
hora do relógio e se expandiu quantidades
de interfaces: 10 pinos digitais, 5 pinos
analógicos e 4 pinos pwn. Para tornar ainda
mais que amigável, ele é compatível com Micro USB para que a programação
direta e teste não é mais uma dor de cabeça.
5.2.2 FUNÇÃO DOS COMPONENTES
Cristal, e Capacitores : Gerar o sinal de clock para o microcontrolador.
Resistor: Evitar que ruído eletromagnético baixe a tensão do pino de reset
causando o reset do microcontrolador. Pode ser removido, mas não é
indicado em lugares com campo magnético forte (perto de geradores,
motores e etc.).
Botão: Baixa a tensão do pino reset pra 0V causando um reset proposital.
Capapacitor: Ajuda a estabilizar a tensão vindo da fonte. Vital quando usado
com fontes de tomada, pois ameniza picos e quedas de luz. Usando com
baterias não se faz muito necessário e pode ser dispensado.
LED: é um componente eletrônico semicondutor, ou seja, um diodo emissor
de luz.
5.3 SENSOR DE DISTÂNCIA SHARP GP2Y0A02YK
Fig 5.3 - Os sensores de distância da Sharp
são uma escolha comum para muitos projetos que
necessitam deste tipo de medidas. Este sensor de
IR (infravermelho) é mais econômico do que os
sonares e fornecem melhores resultados que
Fig. 5.11 – Placa Controladora
Fig 5.12 – Sensor Infravermelho
outras alternativas baseadas em IR. A conexão com microcontroladores é bastante
simples: a saída analógica pode ser conectada para um conversor de análogo para
digital (ADC) para tomadas de medidas de distância, ou a saída pode ser conectada
a um comparador para detecção de limites. A faixa de detecção deste sensor é de
20 a 150cm..
5.3.1 ESPECIFICAÇÕES
voltagem operacional: 4,5 a 5,5V consumo médio de corrente: 33mA (típico) faixa de distância operacional: 20 a 150 cm (8" a 60") tipo de saída: voltagem analógica tempo de resposta: 38 ± 10 ms tamanho da peça: 29.5x13.0x21.5 mm (1.16x0.5x0.85") peso: 4.8g
5.4 PLACA EXPANSÃO DE HARDWARE
A figura 5.4 mostra a placa de expansão que
é projetado para conectar um controlador, servos e
sensores. Funciona em 3V a 5V, tem seis pinos D9,
D10, D11 e A0, A1, A2, assim os dois pinos de
alimentação + e - além de entrada USB.
5.5 MICRO SERVO 9G SG90 TOWERPRO
A Figura 5.5 mostra-nos servos motores
Pode ser ligado diretamente ao microcontrolador,
ou por exemplo no Arduino. A comunicação é
unidirecional, ou seja, apenas o transmissor envia os
dados para o receptor.
5.5.1 ESPECIFICAÇÕES
.- Voltagem de Operação: 3,0 - 7,2V- Ângulo de rotação: 180 graus- Velocidade: 0,12 seg/60Graus (4,8V) sem carga- Torque: 1,2 kg.cm (4,8V) e 1,6 kg.cm (6,0V)- Temperatura de Operação: -30C ~ +60C
Fig. 5.14 – Micro Servo
Fig. 5.13 – Placa expansão
- Tipo de Engrenagem: Nylon- Tamanho cabo: 245mm- Dimensões: 32 x 30 x 12mm- Peso: 9g
6 SOFTWAREQuando tratamos de software na plataforma do Arduino, podemos referir-nos: ao
ambiente de desenvolvimento integrado do Arduino e ao software desenvolvido por
nós para enviar para a nossa placa. O ambiente de desenvolvimento do Arduino
figura 6.1 é um compilador gcc (C e C++) que usa uma interface gráfica construída
em Java. Basicamente se resume a um programa IDE muito simples de se utilizar e
de estender com bibliotecas que podem ser facilmente encontradas. As funções da
IDE do Arduino são basicamente duas: Permitir o desenvolvimento de um software e
enviá-lo à placa para que possa ser executado.
Obviamente, por ser open source, é gratuito. Depois de baixado não
necessita de nenhuma instalação, é só abrir o IDE e começar a utilizar. Para
começar a utilizar, devemos escolher qual placa estamos utilizando, assim vamos
em Tools > Board e à escolhemos. O IDE possui também uma quantidade imensa
Fig. 6.15 - Ambiente de programação
de exemplos. Para utilizá-los basta ir a File > Examples e escolher qual deles você
quer testar, de acordo com sua necessidade.
6.1 ESTRUTURA DO PROGRAMA
O programa para o Arduino é dividido em duas partes principais: Setup e
Loop, mostradas na figura 6.2.
A função setup serve para inicialização da placa e do programa. Esta sessão
é executada uma vez quando a placa é ligada ou resetada através do botão. Aqui,
informamos para o hardware da placa o que vamos utilizar dele. No exemplo, vamos
informar para a placa que o pino 13 será uma saída digital onde está conectado um
LED (no Arduino UNO o pino 13 possui um led integrado).
Fig. 6.16 - Entendendo o programa
A função loop é como se fosse a main () da placa. O programa escrito dentro
da função loop é executado indefinidamente, ou seja, ao terminar a execução da
última linha desta função, o programa inicia novamente a partir da primeira linha da
função loop e continua a executar até que a placa seja desligada ou o botão de
reset seja pressionado.
Analisando o resto do programa, o comando digitalWrite escreve na saída do
pino 13 o nível de tensão HIGH (5v), acendendo o Led. O comando delay é apenas
para o programa aguardar 1000 milésimos. Em seguida, o nível de tensão é alterado
para LOW (0v) e o Led apaga. E assim é repetido infinitamente, até ser desligado.
Com o programa feito, compilamos o mesmo para verificarmos se não existe
nem um erro. Caso não contenha erro, agora temos que enviá-lo para placa através
do botão de upload (os botões estão especificados na figura 4). Após o envio os
Led’s RX e TX deverão piscar, informando que o código está sendo carregado. Logo
após o arduíno começará a executar o programa que lhe foi enviado.
6.2 SERIAL MONITOR
A figura 6.3 mostra o
monitor que é usado para
que possamos comunicar
nossa placa com o
computador, mas também é
muito útil para a depuração
do programa. Basicamente
conectamos a placa no
computador e através desta
tela podemos ver as informações enviadas pela placa.
No exemplo, o comando Serial.begin(9600) inicializa a comunicação com
uma taxa de 9600 baunds (taxa de bits). O comando Serial.println (‘argumento’) envia a mensagem para o computador.
Fig. 6.17 - Exemplo serial monitor
Após compilar e enviar o programa para
placa, abrimos o serial monitor. As
informações enviadas pela nossa placa
Arduino aparecem no console figura 6.4.
6.3 OUTROS COMANDOS
Como já foi informado, e vocês já devem ter observado, a linguagem base
para a programar um Arduino é C. Logo, suas estruturas de controle (if, else, while,
for...), seus elementos de sintaxe ( #define, #include, {}...), operadores aritméticos (+,
-, *, ^ ...), operadores de comparação (==, !=, <, > ...), enfim, todos são utilizados
aqui no IDE. Portanto, saber C é primordial para programar o Arduino em alto nível.
Abaixo segue as principais funções para controlar o arduíno (algumas já
foram especificados acima):
pinMode (pin, mode): Configura o pino especificado para que se
comporte como entrada ou saída, sendo Pin = número do pino e mode =
INPUT ou OUTPUT
digitalWrite (pin,value): escreve um valor HIGH ou LOW em um pino
digital. Se o pino foi configurado como saída sua voltagem será
determinada ao valor correspondente: 5V para HIGH e 0V para LOW. Se
o pino estiver configurado como entrada escrever um HIGH levantará o
resistor interno de 20kΩ. Escrever um LOW rebaixará o resistor.
Obviamente pin = numero do pino e valor = HIGH ou LOW.
int digitalRead (pin): Lê o valor de um pino digital especificado, HIGH ou
LOW. Pin = numero do pino. Retorna HIGH ou LOW.
Int analogRead (pin): Lê o valor de um pino analógico especificado. Pode
mapear voltagens entre 0 a 5v, sendo 4,9mV por unidade.
analogWrite (pin, value): Escreve um valor analógico (onda PWM,
explicaremos mais abaixo). Pode ser utilizada para acender um LED
variando o brilho ou girar um motor a velocidade variável. Após realizar
essa função o pino vai gerar uma onda quadrada estável com ciclo de
Fig. 6.18 - Saída no serial monitor
rendimento especificado até que o próximo analogWrite() seja realizado
(ou que seja realizado um digitalRead() ou digitalWrite() no mesmo pino).
6.3.1 PROGRAMAÇÃO PARA INSETO ROBÔ
É fornecido a plataforma
arduino três linguagens de
programação
como Ardublock, Mente
+ e IDE. Podendo ser
programada simplesmente
arrastando e soltando blocos pré-
concebidos vistos softwares de
programação visual Ardublock e
Mente +. Para programadores
avançados, também é possível
modificar Arduino IDE.
6.3.2 ARDUBLOCKO software Ardublock é um plug-in que é adicionado ao IDE do arduino e que
permite ao usuário programar em blocos de funções, um pouco como scracth4arduino, ou para AppInventor para androide. O bom ponto de ardublock é que gera as linhas de códigos. Além de blocos que são traduções literais das funções na biblioteca Arduino, ele também fornece alguns blocos pré-definidos para trabalhar com uma variedade de componentes eletrônicos apoiados por colher, Adafruit, DFrobot. TINKERKIT do Arduino e suporte parcial para o Grove.
7 MONTAGEM E RESULTADOS
A seguir como é construir o Inseto Robô com 2x 9g micro servo, 1x Cheapduino V2 witht eh Atmega 32U4 e entrada USB para fácil programação. O Cheapduino está soldado no servo / sensor escudo para swervos conexão fácil e de sensores de curso. O pequeno bicho corre com um pequeno 3.7 / 180mAh LiPo
Fig 6.19 - Programação para Inseto Robô
bateria que vem com um carregador USB e está à procura de obstáculos com um sensor IR da Sharp.Escritos suficientes, aí vem as figuras de montagem:
Fig 7.20- Restantes das figuras são de montagem
Basta usar fita dupla face de espuma e zip laços para manter o robô em conjunto.
Cole os dois servos com a fita juntos.
Em seguida, prenda-os com uma fita relemame (enforca gato).
Fixar a bateria sobre o bordo
Deve ficar assim a união dos dois componentes.
Dobrar o fio para moldar as pernas. Ambas as extremidades devem ser do mesmo comprimento. Passar o fio de aço 0,8 milímetros (Utilizamos um fio 304 de aço inoxidável, uma vez que ainda é forte o suficiente para manter a forma depois de flexão, mas macio o suficiente para cortar com um cortador de arame).
Prenda-o com o parafuso que vem com os servos.
Eu usei folha de ABS para cortar um suporte de sensor.
Use o parafuso que vem com o seu servo para prender o suporte do sensor.
O sensor será realizado por pequenos laços zip que se parece muito com antenas ou antenas de um inseto:-)
Vista frontal.
A cabeça ...
Um outro pedaço de fita adesiva do outro lado da bateria ...
... Realizará a bordo, inclusive, a blindagem na parte de trás do robô.
Conecte os servos e o sensor com os pinos certos e você está quase pronto.
Conecte a bateria e ligar o bicho pequeno diante. Ele deve andar para a frente até detectar um obstáculo e desviar em uma curva e depois de um tempo, voltar a andar novamente.
8 CONCLUSÕES
O objetivo de movimentar desviando de obstáculos foi atingido, a montagem
do protótipo ficou dentro das expectativas. Além dos conhecimentos de eletrônica
adquiridos, o projeto permitiu a integração entre várias disciplinas ministradas no
curso, desenvolvimento do dispositivo também foi bastante satisfatório, pois foi
possível trabalhar com a robótica, eletrônica digital e analógica, e com a linguagem
de programação.
9 REFERÊNCIAS
CAVALCANTE, Alyson . Apostilha Microcontroladores. Artigo: Microcontroladores.
Disponível em: <http://www.slideshare.net/AlysonCavalcante/10-apostila-
microcontroladores> Acessado em 03/10/2013
WIKIPÉDIA, A ENCICLOPÉDIA LIVRE. Artigo: Compilador. Disponível em:
<http://pt.wikipedia.org/wiki/Compilador>. Acessado em 03/10/2013.
WIKIPÉDIA, A ENCICLOPÉDIA LIVRE. Artigo: Linguagem de Programação.
Disponível em: <http://pt.wikipedia.org/wiki/Linguagem_de_programa
%C3%A7%C3%A3o> Acessado em 03/10/2013
SIGNIFICADOS. Artigo: Significado de Hardware. Disponível em:
<http://www.significados.com.br/hardware/> Acessado em 03/10/2013
FILIPEFLOP. Artigo: Servo Motor. Disponível em: <http://www.filipeflop.com/pd-
71590-micro-servo-9g-sg90-towerpro.html> Acessado em 12/11/2014
ERUS, Equipe De Robótica Da Ufes. Departamento de Informática do Centro
Tecnológico da Universidade Federal do Espírito Santo. Artigo: Minicurso Arduino.
Disponível em: <http://www.inf.ufes.br/~erus/arquivos/ERUS_minicurso
%20arduino.pdf> Acessado em 03/10/2013
APÊNDICE A – Layout da placa.
APÊNDICE B – Código fonte
/*Desenvolvido por ÉDY CARLOS DOS SANTOS, 28/10/2014 */
// Servo Library
#include <Servo.h>
// Servo name
Servo frontServo;
Servo rearServo;
// time delay between steps
int walkSpeed = 500;
// center servos
int centerPos = 90;
// servo angles for walking pattern
int frontRightUp = 70;
int frontLeftUp = 110;
int backRightForward = 70;
int backLeftForward = 110;
// another center position
int centerTurnPos = 81;
// servo angles for walking pattern
int frontTurnRightUp = 70;
int frontTurnLeftUp = 110;
int backTurnRightForward = 70;
int backTurnLeftForward = 110;
// variable for distance value
int distance = 0;
// average distance value
int distanceCheck = 0;
// Array for distance values
int collectDistance[5];
// Variables for counters
int i;
int f;
int r;
// assign analog pin A1
int sensorPin = A1;
// distance value for danger close. Bigger values are greater distance and smaller
values are lower distance
int dangerDistance = 350;
/* Setup function */
void setup()
{
// attach servos
frontServo.attach(9);
rearServo.attach(10);
// assign sensor
pinMode(sensorPin, INPUT);
// center servos
frontServo.write(centerPos);
rearServo.write(centerPos);
// wait 3 seconds for start walking
delay(3000);
//Serial.begin(9600); // serial data setup
}
/* distance check function */
void scan()
{
// read 5 distance values
for (i = 0; i < 5; i = i + 1) {
distanceCheck = analogRead(sensorPin);
collectDistance[i] = distanceCheck;
// serial output for testing
//Serial.print (i);
//Serial.print(" = ");
//Serial.println(collectDistance[i]);
}
// checksum of the 5 distance values for getting an average value. This will
prevent the robot to change behavior by reading one wrong value
distance =
(collectDistance[0]+collectDistance[1]+collectDistance[2]+collectDistance[3]+collectD
istance[4])/5;
delay(20);
}
// walk forward
void moveForward()
{
// loop for the servo angels to smoothen the steps
for (f = 0; f < 39; f++){
frontRightUp++;
backLeftForward--;
frontServo.write(frontRightUp);
rearServo.write(backLeftForward);
delay(10);
}
// loop for the servo angels to smoothen the steps
for (r = 0; r < 39; r++){
frontRightUp--;
backLeftForward++;
frontServo.write(frontRightUp);
rearServo.write(backLeftForward);
delay(10);
}
}
// walk backwards to the left
void moveBackRight()
{
frontServo.write(frontRightUp);
rearServo.write(backRightForward-6);
delay(110);
frontServo.write(centerPos);
rearServo.write(centerPos-6);
delay(80);
frontServo.write(frontLeftUp+9);
rearServo.write(backLeftForward-6);
delay(110);
frontServo.write(centerPos);
rearServo.write(centerPos);
delay(80);
}
// walk forward to the left
void moveTurnLeft()
{
frontServo.write(frontTurnRightUp);
rearServo.write(backTurnLeftForward);
delay(110);
frontServo.write(centerTurnPos);
rearServo.write(centerTurnPos);
delay(80);
frontServo.write(frontTurnLeftUp);
rearServo.write(backTurnRightForward);
delay(110);
frontServo.write(centerTurnPos);
rearServo.write(centerTurnPos);
delay(80);
}
// blink LED. This function can be called in any situation you want. Just add led(); in
the code where you want to blink the LED.
void led(){
// loop for the LED to blink it 5 times for 0.05 sec on and 0.1 sec off
for(int l=0; l<=5; l++) {
digitalWrite(13, HIGH);
delay(50);
digitalWrite(13, LOW);
delay(100);
}
}
// that's the loop. This is repeatedly called as long as the robot is powered on
void loop()
{
// call function for checking the distance
scan();
//Serial.println(distance);
if (distance > 1){ // filters out the zero readings
// an obstacle is being detected
if (distance > dangerDistance) {
// LED at Pin 13 (standard) blinks 5x
led();
// 4 steps backward left
for(int i=0; i<=3; i++) {
moveBackRight();
delay(walkSpeed);
}
// 4 steps forward left
for(int i=0; i<=3; i++) {
moveTurnLeft();
delay(walkSpeed);
}
} else {
// all clear, no obstacle detected. Just walk forward
moveForward();
delay(walkSpeed/100);
}
}
}