Projeto de Inseto Robô com Sensor IR

TRABALHO ATIVIDADES
COMPLEMENTARES (FETEF)
INSETO ROBÔ
por
EDY CARLOS DOS SANTOS
JACKSON F. SOUZA
MARINO D. RAMOS
PAULO A. DOS REIS
Acadêmicos do 8º Semestre do Curso de Engenharia
de Controle e Automação
Extrema - MG
2014
FACULDADE DE CIÊNCIAS SOCIAIS
APLICADAS DE EXTREMA

ii
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.

iii
LISTA DE FIGURAS
Fig. 2.1 - Microcontroladores.....................................................................................................3
Fig. 2.2 - Uso de microcontroladores em automóveis...........................................................5
Fig. 2.3 - Automação doméstica...............................................................................................5
Fig. 2.4 - Ciclo de Máquina........................................................................................................7
Fig. 3.1 - Detecção por Reflexão ..............................................................................................8
Fig 3.2 - Detecção por interrupção...........................................................................................9
Fig 3.3 – Camera Escura ............................................................................................................9
Fig. 4.1 - O processo da compilação ......................................................................................11
Fig. 4.2 - Livros sobre diversas linguagens de programação .............................................14
Fig. 5.1 - ATmega32U4 .............................................................................................................15
Fig. 5.2 – Placa Controladora...................................................................................................16
Fig 5.3 – Sensor Infravermelho................................................................................................17
Fig. 5.4 – Placa expansão ........................................................................................................18
Fig. 5.5 – Micro Servo ...............................................................................................................18
Fig. 6.1 - Ambiente de programação.......................................................................................19
Fig. 6.2 - Entendendo o programa...........................................................................................20
Fig. 6.3 - Exemplo serial monitor.............................................................................................21
Fig. 6.4 - Saída no serial monitor.............................................................................................22
Fig 6.5 - Programação para Inseto Robô ...............................................................................23
Fig 7.1- Restantes das figuras são de montagem ................................................................24

iv
SUMÁRIO
LISTA DE FIGURAS ..............................................................................................................iii
1 INTRODUÇÃO......................................................................................................................1
1.1 OBJETO DO ESTUDO.................................................................................................1
1.2 OBJETIVOS DO TRABALHO......................................................................................1
1.3 VIABILIDADE E JUSTIFICATIVA ...............................................................................2
1.4 DIFICULDADES ENCONTRADAS NO PROJETO..................................................2
2 MICROCONTROLADOR....................................................................................................3
2.1 MICROCONTROLADORES VERSUS MICROPROCESSADORES....................4
2.2 APLICABILIDADE .........................................................................................................4
2.3 ESTRUTURA DO MICROCONTROLADOR.............................................................5
2.4 FUNCIONAMENTO.......................................................................................................7
3 SENSOR INFRAVERMELHO............................................................................................8
4 LINGUAGEM DE PROGRAMAÇÃO E COPILADORES ...........................................10
4.1 INTERPRETAÇÃO E COMPILAÇÃO ......................................................................11
4.2 CONCEITOS ................................................................................................................12
4.2.1 PROGRAMAÇÃO ESTRUTURADA .................................................................12
4.2.2 PROGRAMAÇÃO ORIENTADA A OBJETOS.................................................13
4.2.3 PROGRAMAÇÃO LINEAR .................................................................................14
4.3 LISTA DE LINGUAGENS...........................................................................................14
5 HARDWARE.......................................................................................................................15
5.1 MICROCONTROLADOR ATMEL ATMEGA32U4 .................................................15
5.1.1 UM POUCO SOBRE A FAMÍLIA .......................................................................16
5.2 PLACA PRINCIPAL.....................................................................................................16
5.2.1 PLACA CONTROLADORA.................................................................................16
5.2.2 FUNÇÃO DOS COMPONENTES .....................................................................17
5.3 SENSOR DE DISTÂNCIA SHARP GP2Y0A02YK ................................................17
5.3.1 ESPECIFICAÇÕES .............................................................................................17
5.4 PLACA EXPANSÃO DE HARDWARE ....................................................................18
5.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........................................................................................................................18
6.1 ESTRUTURA DO PROGRAMA ................................................................................20
6.2 SERIAL MONITOR......................................................................................................21
6.3 OUTROS COMANDOS ..............................................................................................22
6.3.1 PROGRAMAÇÃO PARA INSETO ROBÔ........................................................23
6.3.2 ARDUBLOCK........................................................................................................23
7 MONTAGEM E RESULTADOS ......................................................................................23
8 CONCLUSÕES ..................................................................................................................30
9 REFERÊNCIAS..................................................................................................................31

v
APÊNDICE A – Layout da placa. .................................... Error! Bookmark not defined.3
APÊNDICE B – Codigo fonte do Firmware.................................................................324

1
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;

2
 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

3
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.
Fig. 2.1 - Microcontroladores

4
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, 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.

5
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
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.
Fig. 2.2 - Uso de microcontroladores em automóveis
Fig. 2.3 - Automação doméstica

6
 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
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.

7
 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

8
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 INFRAVERMELHO
Sensores 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ão
Neste 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.
Fig. 3.1 - Detecção por Reflexão

9
2) Detecção por Interrupção
Neste 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.
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
Fig 3.2 - Detecção por interrupção
Fig 3.3 – Camera Escura

10
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
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

11
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
Fig. 4.1 - O processo da compilação

12
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.
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

13
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

14
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
Fig. 4.2 - Livros sobre diversas linguagens de
programação

15
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 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.Fig. 5.1 - ATmega32U4

16
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
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 é
Fig. 5.2 – Placa Controladora

17
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
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
Fig 5.3 – Sensor Infravermelho

18
 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
- Tipo de Engrenagem: Nylon
- Tamanho cabo: 245mm
- Dimensões: 32 x 30 x 12mm
- Peso: 9g
6 SOFTWARE
Quando 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.
Fig. 5.5 – Micro Servo
Fig. 5.4 – Placa expansão

19
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 de exemplos. Para utilizá-
los basta ir a File > Examples e escolher qual deles você quer testar, de acordo com
sua necessidade.
Fig. 6.1 - Ambiente de programação

20
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).
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
Fig. 6.2 - Entendendo o programa

21
ú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.3 - Exemplo serial monitor

22
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.4 - Saída no serial monitor

23
rendimento especificadoaté 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 ARDUBLOCK
O 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
Fig 6.5 - Programação para Inseto Robô

24
sensores de curso. O pequeno bicho corre com um pequeno 3.7 / 180mAh LiPo
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.1- 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).

25
Fixar a bateria sobre o bordo
Deve ficar assim a união dos dois componentes.

26
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.

27
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 ...

28
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ô.

29
Conecte os servos e o sensor com os pinos certos e você está quase pronto.

30
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.

31
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

32
APÊNDICE A – Layout da placa.

33
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];

34
// 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

35
//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]+collectDi
stance[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++;
rearServo.write(backLeftForward);
delay(10);
}
}
// walk backwards to the left

36
void moveBackRight()
{
rearServo.write(backRightForward-6);
delay(110);
rearServo.write(centerPos-6);
delay(80);
frontServo.write(frontLeftUp+9);
rearServo.write(backLeftForward-6);
delay(110);
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);
}

37
// 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);
}

38
} else {
// all clear, no obstacle detected. Just walk forward
moveForward();
delay(walkSpeed/100);
}
}
}

Projeto de Inseto Robô com Sensor IR

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Similar a Projeto de Inseto Robô com Sensor IR

Similar a Projeto de Inseto Robô com Sensor IR (20)

Último

Último (20)

Projeto de Inseto Robô com Sensor IR