Manual Workshop GreenT Final v3.2

V3.1

GreenT Manual de Formação

“Escolher Robótica, Escolher Ciência!”

Workshop de Robótica Móvel

Ana Lopes * Carlos Ferreira * Gabriel Pires * Paulo Coelho * Pedro Correia * Pedro Neves

Fevereiro de 2015

Instituto Politécnico de Tomar

www.ipt.pt

V3.1

Colaboraram nas atividades do workshop e na realização deste manual:

Ana Lopes

Carlos Ferreira

Gabriel Pires

Manuel Barros

Paulo Coelho

Pedro Correia

Pedro Neves

GreenT - ESCOLHER ROBÓTICA, ESCOLHER CIÊNCIA! – Manual de Formação - 3 -

IPT - 2015 – V3.2

Índice

Capítulo 1 - Introdução ......................................................................................................................... 7

O que é um robô? ..................................................................................................................... 7

O que é a robótica? .................................................................................................................. 8

Fatores a considerar na construção de um Robô........................................................................ 8

Construção da Plataforma ............................................................................................................................. 9

Escolha dos Motores ................................................................................................................................... 10

Capítulo 2 - Montagem da estrutura mecânica e motorização ......................................... 11

Configuração de locomoção .................................................................................................... 12

Fonte de energia .................................................................................................................... 14

Motores e caixa de redução .................................................................................................... 15

Conversor de potência (placa do L298) .................................................................................... 16

Modulação por largura de impulso - Pulse Width Modulation (PWM) ...................................... 17

Montagem do Robô................................................................................................................ 20

Instruções de Carregamento das Baterias ............................................................................... 25

Capítulo 3 - Programação .................................................................................................................. 28

Arduino para Windows – Instalação ........................................................................................ 28

Placa Arduino MEGA 2560 e cabo USB ........................................................................................................ 28

Download do ambiente de desenvolvimento Arduino ............................................................................... 28

Ligação da Placa ........................................................................................................................................... 29

Instalação dos drivers .................................................................................................................................. 29

Abrir o ambiente Arduino ............................................................................................................................ 30

Abrir um exemplo simples ........................................................................................................................... 30

Selecione a placa ......................................................................................................................................... 30

Selecionar a porta série ............................................................................................................................... 31

Carregar um programa ................................................................................................................................ 31

Gravar um programa ................................................................................................................................... 32

Aspetos da linguagem de programação ................................................................................... 32


IPT - 2015 – V3.2

Estruturas .................................................................................................................................................... 32

Constantes e variáveis ................................................................................................................................. 33

Funções de entrada/saída ........................................................................................................................... 34

Funções de Temporização ........................................................................................................................... 36

Comunicação Série ...................................................................................................................................... 37

Funções de entrada/saída - exemplos ......................................................................................................... 38

Fluxogramas ................................................................................................................................................ 40

Controlo de fluxo ......................................................................................................................................... 41

Instruções condicionais ............................................................................................................................... 42

Instruções de ciclo ....................................................................................................................................... 44

Capítulo 4 - Sensores ........................................................................................................................... 47

Sensores de Infravermelhos: medição de distância .................................................................................. 47

Interligação do GP2D120 ao Arduino .......................................................................................................... 49

Leitura do valor analógico do GP2D120 ...................................................................................................... 49

Fotodeteção de linha branca/preta ........................................................................................................... 50

Ligação e leitura do sensor QRD1113 .......................................................................................................... 51

Sensores ultrassons: medição de distância ................................................................................................ 52

Ligação e leitura do sornar SRF05 ............................................................................................................... 54

Codificador acoplado ao motor .................................................................................................................. 55

Ligação e leitura dos codificadores de odometria ....................................................................................... 56

Servo ............................................................................................................................................................ 58

Programa modelo – ciclo de operação ........................................................................................................ 59

Lista resumo dos pinos usados .................................................................................................................... 63

Referências .................................................................................................................................................. 64

Capítulo 5 – Estratégia de navegação para micro-robôs ..................................................... 65

Introdução – O que é a navegação de robôs? .......................................................................... 65

Principais técnicas navegação de robôs ................................................................................... 66

Técnicas de seguimento de linha ................................................................................................................ 66

Técnicas para desvios de obstáculos ........................................................................................................... 68


IPT - 2015 – V3.2

Técnica dos comportamentos de Brooks (subsumption architecture) ....................................................... 71

Programa Arduino para seguimento de linha .......................................................................... 72

Algoritmo de seguimento de linha .............................................................................................................. 72

Código do programa .................................................................................................................................... 73

Programa Arduino para desvio de obstáculos .......................................................................... 76

Algoritmo de desvio de obstáculos ............................................................................................................. 76

Código do programa .................................................................................................................................... 76

Referências ............................................................................................................................ 79

Capítulo 6 – Competição: Regras e Especificações Técnicas .......................................... 80

Introdução ............................................................................................................................. 80

Definições .............................................................................................................................. 80

Os Robôs ................................................................................................................................ 80

Dimensões ................................................................................................................................................... 80

A pista ................................................................................................................................... 81

O Sistema de Localização............................................................................................................................. 81

Piso da Pista ................................................................................................................................................. 81

Linhas ........................................................................................................................................................... 81

Extras do Percurso ....................................................................................................................................... 81

Iluminação ................................................................................................................................................... 82

Campo eletromagnético, vento e outras influências .................................................................................. 82

Competição ............................................................................................................................ 82

Resolução de problemas com o robô durante a prova ............................................................................... 83

Vistoria técnica ............................................................................................................................................ 83

Parque fechado ........................................................................................................................................... 83

Classificação final ......................................................................................................................................... 83

Júri, Árbitros e Relógio de contagem do tempo ....................................................................... 84

Júri ............................................................................................................................................................... 84

Árbitro ......................................................................................................................................................... 84

Relógio de contagem do tempo .................................................................................................................. 84


IPT - 2015 – V3.2

Reunião de abertura .................................................................................................................................... 84

Conduta e Segurança ................................................................................................................................... 84

Regulamento da Prova de Seguimento de Linha ...................................................................... 85

Descrição da prova ...................................................................................................................................... 85

Regras da prova ........................................................................................................................................... 85

Regulamento da Prova de Desvio de Obstáculos ..................................................................... 87

Descrição da prova ...................................................................................................................................... 87

Regras da prova ........................................................................................................................................... 87

Anexos ....................................................................................................................................................... 91

Esquema de ligação da alimentação ........................................................................................................... 93

Esquema de ligação da alimentação ao Drive Potência .............................................................................. 94

O shield de sensores do GreenT .................................................................................................................. 95


IPT - 2015 – V3.2

Capítulo 1 - Introdução

Paulo Coelho

No mundo da engenharia a palavra “robô” tem-se tornado cada vez mais comum. Há muitos anos, já

se idealizava a criação de robôs. Em 1445, Leonardo da Vinci foi responsável pelo primeiro esboço de

um robô humanoide, com braços e pernas capazes de se moverem. Mas só em 1921 é que a palavra

“robô” foi popularizada. O termo “robô” surgiu na peça Checa “Rossum’s Universal Robot”, de Karel

Capek, onde existem pessoas artificias que pensam por si próprios e podem até ser confundidos com

humanos. A palavra tcheca robota significa servidão ou trabalhador forçado e, quando traduzida para

inglês, transformou-se em robot.

O que é um robô?

Não há uma definição precisa de Robô. Convencionou-se que um robô é uma máquina programável que imita as ações ou aparências de uma criatura inteligente, geralmente um humano. Para que uma máquina seja definida como robô, ela deve ser capaz de:

1) Obter informação acerca do ambiente que a rodeia, por meio de sensores.

2) Realizar diferentes tarefas: Locomoção ou manipulação de objetos

3) Ser reprogramável para realizar tarefas diferentes.

4) Funcionar de modo autónomo e/ou interagir com seres humanos.

A estrutura funcional de um Robô pretende dar resposta aos três problemas fundamentais que lhe

são postos:

- Onde Estou?

- Para onde vou?

- Como vou?

Quando um Robô se desloca num determinado ambiente, faz uso dos seus sensores para se localizar

e para identificar os seus objetivos. Através dos atuadores poderá deslocar-se ou manipular algum

objeto.

Finalmente, estas ações de perceção e de atuação são coordenadas pelo controlador de bordo. A

figura seguinte resume este funcionamento.


IPT - 2015 – V3.2

Figura 1 - Ciclo de funcionamento de um Robô

Os Robôs têm sido objeto da imaginação e das fantasias dos seres humanos ao longo dos tempos.

Até há bem pouco tempo, a imagem que se tinha deste tipo de dispositivos era a de que se tratavam

de sistemas com uma grande complexidade, de elevado custo, compostos por imensas ligações

elétricas e controlados por complicados sistemas computorizados.

No entanto, nos últimos anos, os avanços que se têm verificado na tecnologia dos

microcontroladores, com a diminuição da dimensão e do custo, a contrastar com o aumento de

potencialidades, vem permitir a realização, de uma forma simples, de um conjunto de sistemas

robóticos capazes de desenvolver autonomamente tarefas de alguma complexidade.

É de referir que a construção de um Robô não se resume à sua programação. Na sua conceção estão

envolvidos um conjunto de conhecimentos inerentes às áreas da mecânica, eletrónica, controlo e

programação, que torna este processo um desafio extremamente envolvente.

O que é a robótica?

Especificamente, robótica é uma área multidisciplinar altamente ativa, que busca o desenvolvimento

e a integração de técnicas e algoritmos para a criação de robôs, e envolve matérias como engenharia

mecânica, engenharia eletrotécnica, engenharia de controlo, inteligência artificial, microeletrónica,

entre outras. A robótica, no sentido lato, tem como objetivo a automatização de tarefas que podem

ser executadas pelo homem. Por seu lado, a Robótica Móvel é uma área de investigação, que se pode

considerar recente, que trata do controlo de veículos autónomos e semiautónomos.

Fatores a considerar na construção de um Robô

Neste Guião o nosso objetivo será ajudar a construir um pequeno robô que possui duas rodas

motrizes e um roda “castor” (livre), tendo como base um Kit, e que pode ser controlado através de

um programa que será inserido num microprocessador. Através da construção de um robô com

rodas, o utilizador adquirirá ao longo do processo de construção conhecimentos de Eletrónica,

Mecânica, Controlo e Programação e, consequentemente, aprimorar as técnicas necessárias para a

construção de robôs. Será detalhadamente descrito o funcionamento e a construção do robô, de

modo que, além de possibilitar a sua construção, seja fornecida uma base para a construção de robôs

que utilizem um princípio de funcionamento semelhante.


IPT - 2015 – V3.2

Um fator importante que não pode ser negligenciado durante a montagem é a segurança. É

indispensável, quando necessário, o uso de equipamentos de proteção individual tais como luvas,

óculos de proteção, etc. Também é essencial tomar cuidados básicos para a prevenção de acidentes,

especialmente durante a manipulação de “instrumentos” elétricos e ferramentas. Por pura falta de

atenção ou excesso de confiança, podem ser causados acidentes graves. Não é difícil se

consciencializar e realizar pequenas ações que possam prevenir muitos acidentes.

O robô com rodas possui duas rodas motrizes e pode ser controlado pelo utilizador através de um

programa que corre num microprocessador. O nosso projeto é constituído por duas etapas

principais: a construção do robô e a programação necessária para seu funcionamento. A construção

do robô é a elaboração da estrutura mecânica e eletrónica. A dedicação nesta etapa é indispensável,

uma vez que peças ou circuitos mal concebidos podem comprometer o funcionamento de todo o

sistema. Mas não basta apenas, a estrutura estar perfeita, pois ela deve ser controlada

adequadamente. A programação será responsável, por proporcionar a ligação entre o

microprocessador (Arduíno) e o robô e, pelo controlo preciso da atuação dos servomotores, de modo

que o robô se possa movimentar corretamente, pois cada um desses componentes deve ser

acionado num exato momento.

Construção da Plataforma

A plataforma poderá assumir diferentes formas e ser construída a partir de diferentes materiais

(Acrílicos, alumínio, PVC, inox, contraplacados). No entanto na sua conceção deve-se ter em conta

que a plataforma deve ser:

1) Simples – minimizar a complexidade do Robô, e o número de partes móveis;

2) Robusta- resistência a impactos e à torção;

3) Modular - o Robô deve ser constituído por um conjunto de módulos que se possam

interligar e substituir facilmente, sem necessidade de remoção dos restantes.

A figura seguinte apresenta uma estrutura comum a muitos Robôs, com dois motores independentes

(tração diferencial) e uma roda livre para manter o equilíbrio.

a) Vista lateral b) Vista de cima

Figura 2 - Robô com tração diferencial

Motores

Roda livre “castor”


IPT - 2015 – V3.2

Escolha dos Motores

A escolha dos motores deve ser sempre adequada à aplicação robótica que se pretende. Deve-se ter

em consideração os seguintes fatores:

1) Tamanho e forma;

2) Peso ou massa;

3) Binário disponível;

4) Velocidade máxima disponível;

5) Relação corrente/binário com máximo desempenho.

Dos vários motores disponíveis no mercado – corrente contínua, passo-a-passo ou corrente

alternada – os motores de corrente contínua, também conhecidos por motores DC (Direct Current),

são os mais utilizados por apresentarem não só a melhor relação potência/volume, como também

devido à grande variedade disponível no mercado.


IPT - 2015 – V3.2

Capítulo 2 - Montagem da estrutura

mecânica e motorização

Carlos Ferreira e Pedro Neves

Um robô pode ser representado, do ponto de vista funcional por um diagrama de blocos de acordo

com a Figura 3.

Este necessita de uma fonte de energia para alimentar todo o sistema, os sensores permitem obter

informação acerca do ambiente externo para que este possa tomar decisões e movimentar-se

adequadamente. Este pode necessitar de comunicar com um sistema central ou com outros robôs.

Para isso necessita de um módulo de comunicações. O sistema de processamento recebe a

informação disponível e envia comandos para os atuadores. Os atuadores permitem ao robô

interagir com o exterior. Estes podem ser de diversos tipos, um exemplo são os atuadores

responsáveis pela movimentação do robô, neste caso os motores de tração.

Figura 3 - Diagrama de blocos funcional de um robô.

Processamento Sensores

Comunicações

Atuadores

Fonte de

energia


IPT - 2015 – V3.2

Configuração de locomoção

A observação dos sistemas de locomoção dos seres vivos permite-nos ter ideias para a

movimentação de robôs. Desde o rastejar ao andar ou saltar. Estes são no entanto de difícil

implementação mecânica e de controlo complexo.

O modo mais simples de efetuar a locomoção é através da utilização de rodas. Uma roda move-se

através do contacto com a superfície e desloca-se 2πr por volta, onde r é o raio da roda. Estas são

uma boa opção desde que as irregularidades do terreno de navegação não sejam significativas face

ao raio das rodas.

A estabilidade do robô é garantida com três rodas (três pontos definem um plano). Para manter a

estabilidade é necessário que o centro de gravidade esteja dentro de um triângulo formado pelos

pontos de contacto no chão. A estabilidade melhora com quatro ou mais rodas mas este sistema

necessita de um sistema de suspensão flexível para evitar que algumas delas “fiquem no ar”.

A utilização de rodas de maior diâmetro possibilita ultrapassar obstáculos maiores mas estas

necessitam de um maior binário que as mais pequenas.

Figura 4 - A relação entre a dimensão da roda e a do obstáculo a tranpôr deve ser tida em conta.

As rodas devem ainda ter um perfil convexo de modo a evitar escorregamentos de partes da roda,

permitindo ao robô possuir uma boa odometria (i.e. saber o seu posicionamento com base na

rotação das rodas).De modo a permitir uma movimentação com a direção desejada (trajetórias

curvas, etc.) existem várias configurações.

a) Diferencial b) Triciclo c) Síncrona d) Omnidirecional

Figura 5 - Tipos de direção em veículos de três rodas.

Direção Direção

Direção Direção

Rodas omnidirecionais


IPT - 2015 – V3.2

Direção diferencial: Utiliza mecanismos de direção simples uma vez que não existe um

mecanismo de direção propriamente dito. Este sistema consiste em duas rodas num eixo

comum, em que cada roda é controlada independentemente. Para obter estabilidade utiliza-

se uma ou várias rodas livres adicionais (“castor”). A direção é controlada com base na

modificação da velocidade relativa das duas rodas de tração (a diferença de velocidade entre

estas permite diferentes trajetórias). A sua estrutura impede que sejam feitos movimentos

de translação segundo o eixo que passa pelos veios dos motores, no entanto ao permitir

rodar sobre si própria pode reposicionar-se de modo a efetuar qualquer trajetória.

Triciclo: Esta solução passa por ter duas rodas fixas e uma de direção que é comandada de

modo similar à direção de um automóvel. Apresentam no entanto dificuldades de

posicionamento e movimentação (e.g. estacionamento de um automóvel).

Síncrona: É baseada na movimentação (rotação) das três rodas de acordo com a direção em

que o robô se pretende movimentar. Esta solução é boa do ponto de vista do movimento

mas complicada mecanicamente, pois necessita de um sistema de movimentação em todas

as três rodas.

Omnidirecional: Utilizando rodas “suíças” ou omnidirecionais (rodas compostas por roletes

na faixa de rodagem desta) consegue-se que o robô se movimente para onde se deseje

controlando unicamente a rotação de cada uma delas. Esta configuração necessita no

entanto de três rodas motrizes tendo estas que ser omnidirecionais.

Figura 6 - Base diferencial usada e respectivas rodas motrizes e roda livre.


IPT - 2015 – V3.2

Fonte de energia

Para alimentar um robô móvel temos de modo simplista três alternativas: baterias, pequenos

motores de combustão interna e ainda painéis solares. Dado o facto de se pretender operar

tipicamente em ambientes fechados, as duas últimas alternativas apresentam grandes desvantagens:

os motores de combustão são poluentes e a energia produzida por um painel solar será insuficiente.

Assim, a escolha da fonte de energia para o robô recai sobre a utilização de uma bateria elétrica.

Embora a relação de energia por unidade de peso seja relativamente baixa em relação, por exemplo,

à energia contida na gasolina (cerca de 15kWh/kg para esta ultima), a utilização de baterias tem

inúmeras vantagens: são baratas, pequenas, relativamente seguras e a conversão para energia

mecânica dá-se com boa eficiência. Adicionalmente, pode alimentar-se também o sistema de

controlo e os sensores que tipicamente funcionam com energia elétrica.

Um acumulador é composto por um conjunto de células ligadas em série que transforma energia

química em energia elétrica. Existem várias características elétricas que definem os elementos de

uma bateria. As mais importantes são: a força eletromotriz (medida em Volt) e a capacidade (medida

em Ampere-hora - A.h).

Convém a um sistema móvel ter a autonomia mínima que lhe permita realizar a sua função com

alguma margem de segurança. O excesso de peso, no caso de existir, iria prejudicar o seu

desempenho ou o consumo do sistema. A autonomia dependerá da energia armazenada nas

baterias, e do gasto realizado. Para manter um bom nível de autonomia é importante utilizar

sistemas com um bom rendimento para que as perdas sejam reduzidas.

No presente robô utilizaram-se acumuladores de tecnologia NiMh (hidreto metálico de níquel) de

2000 Ah. Utiliza-se uma bateria com sete acumuladores em série, de modo a permitir obter uma

tensão de cerca de 8.4V. Estas possuem uma taxa de auto-descarga baixa de modo a permitir a

manutenção prolongada de energia, mesmo quando esta não é utilizada durante longos períodos de

tempo. De qualquer forma estas devem ser sempre mantidas carregadas e ser recarregadas antes de

um tempo prolongado sem uso. Para isso deve-se utilizar o carregador fornecido.

Figura 7 - Figura dos acumuladores ENELOOP utilizados e respetivo carregador.


IPT - 2015 – V3.2

Motores e caixa de redução

Dado tratar-se de uma aplicação móvel, tal como foi dito anteriormente, a alimentação é efetuada

com acumuladores que fornecem uma tensão contínua. Assim, esta secção supõe a utilização de

motores DC.

As forças eletromagnéticas em que se baseia o princípio de funcionamento dos motores DC são

geradas quando um condutor percorrido por uma determinada corrente é sujeito à ação de um

campo magnético. Esse campo magnético pode ser gerado por ímanes permanentes. Neste caso o

motor chama-se DC de ímanes permanentes.

Uma possibilidade de motorização consiste na utilização de motores de passo, os quais são

constituídos por várias bobinas que têm de ser alimentadas sequencialmente para fazer o motor

rodar num ou noutro sentido. Neste caso a velocidade do motor é diretamente proporcional à

velocidade de comutação das bobinas. Como inconveniente estes apresentam o facto de rodarem

um determinado passo de cada vez que se verifica a mudança de energização de duas bobines

contíguas, assim proporciona-se apenas um número finito de posições o que representa uma

resolução de deslocamento limitada.

Teoricamente, um motor de passo seria a solução indicada pois haveria a facilidade em controlar a

posição pelo número de passos, mas na prática os servomotores (conjunto composto pelo motor e

um sensor de posição) são preferíveis por poderem ser controlados em malha fechada o que permite

um comportamento corretivo no caso de ocorrerem erros. Como o controlo dos motores de passo é

efetuado em malha aberta, não existe a certeza de que os motores sigam as instruções de controlo.

Apresentam-se a seguir de forma condensada as razões atrás expostas e que explicam o porquê da

preferência na utilização dos motores DC face aos de passo:

Não se perde a posição do motor – Dado que esta é medida por um sensor, pode-se executar

instruções de comando complexas e repetitivas sem perda de precisão;

Binário total a altas velocidades – O binário de um motor de passo cai acentuadamente à

medida que a velocidade deste aumenta devido a constantes de tempo de carácter elétrico;

Funcionamento suave e silencioso – Os servo-sistemas são mais suaves devido à alta

resolução dos sensores (encoders), que apresentam, tipicamente, valores 10 vezes

superiores à de um motor de passo. Quanto ao ruído sonoro, os servo sistemas também são

silenciosos;

Manutenção da posição sem corrente de excitação – À exceção dos com rotor de íman

permanente que apresentam a manutenção da posição mesmo sem corrente de excitação,

os motores de passo exigem correntes relativamente altas mesmo quando parados (de

forma a manter a posição). Isto mesmo que a carga mecânica seja reduzida ou nula. Num

servo o sistema gere a corrente de acordo com as necessidades.


IPT - 2015 – V3.2

Os motores elétricos são sistemas que normalmente possuem uma velocidade de rotação elevada e

um binário reduzido, características que não permitem ligar o seu veio de saída diretamente à roda.

Para reduzir a velocidade de rotação e aumentar o seu binário são utilizadas caixas de redução,

constituída por um acoplamento mecânico de rodas dentadas dispostas de um determinado modo.

Os carretos utilizados, devido às suas diferentes dimensões permitem obter a velocidade e “força”

desejada à sua saída, podendo esta ser ligada diretamente à roda. A transformação de movimento

rotacional-translacional dá-se pelo contacto da roda com a superfície.

Com as caixas de redução consegue-se assim aproveitar a faixa de potência útil dos motores. Os

motores utilizados são de 6V–450mA e são acoplados a uma caixa de redução com uma relação de

47:1.

Figura 8 - Conjunto motor/caixa utilizados.

Conversor de potência (placa do L298)

De modo a permitir a variação da velocidade do robô os motores não são ligados diretamente à

tensão das baterias mas sim através de conversores de potência ou drivers. No presente caso é

utilizado o circuito integrado L298 que permite o controlo e drive simultâneo de dois motores com

consumo de corrente total até 4A.

Figura 9. - Componentes do drive de potência


IPT - 2015 – V3.2

A placa é constituída por sete terminais de parafuso onde são ligados os motores e as alimentações

necessárias, os motores propriamente ditos são ligados nos terminais duplos laterais. O terminal

triplo inferior contém a entrada VD que corresponde à alimentação da parte lógica da placa e

permite tensões entre 6 e 12V. A entrada VS corresponde à entrada de alimentação do motor e

admite tensões entre 4,8 e 46V. Caso ambas as tensões se encontrem dentro dos dois limites, poderá

se utilizar uma alimentação comum, sendo assim necessário colocar um jumper a ligar os pinos

indicados com “VD=VS”.

Os pinos E (E1 e E2) controlam o funcionamento das saídas para os motores, sendo estas que

definem a velocidade de rotação pela aplicação do PWM. Os pinos M (M1 e M2) definem a direção

de rotação dos dois motores, respetivamente.

Modulação por largura de impulso - Pulse Width Modulation (PWM)

Um veículo em geral deve poder deslocar-se a diferentes velocidades. Esta variação poderá ser

efetuada através de uma caixa de velocidades, da quantidade de combustível inserida no

sistema/veículo ou, no caso dos motores elétricos de corrente contínua, através do valor de tensão

aplicada ao motor.

A maneira mais intuitiva de diminuir a tensão no motor seria pela inserção de uma resistência

variável em série com o motor. Esta solução permite variar a tensão no motor mas existe uma parte

da energia que se dissipa na referida resistência. Na prática para um comando não manual (efetuado

pelo microprocessador) a resistência variável seria um transístor (que funciona como resistência

comandada).

Em vez de a redução da tensão ser efetuada por meios dissipativos (o que reduziria o rendimento e

consequentemente a autonomia) é possível fazê-lo através da utilização de um interruptor colocado

em série com o motor que irá ligar e desligar de forma muito rápida. O interruptor não dissipa

potência (idealmente) pois quando se encontra ligado possui corrente mas não possui queda de

tensão e quando se encontra desligado possui tensão aos seus terminais mas não existe corrente a

percorrê-lo. O objetivo é obter o valor médio desejado para a tensão no motor, por alternância entre

interruptor ligado e desligado (“tudo ou nada”). Se se pretender obter metade da tensão de

alimentação mantém-se o interruptor tanto tempo ligado como o tempo em que este está desligado

ou seja ou fator de ciclo de trabalho (duty-cycle) de 50%. Variando o fator de ciclo entre 0 e 100%

consegue-se obter uma tensão de saída entre 0 e a tensão da bateria utilizada.

Devido à própria inércia do rotor do motor, à sua componente indutiva e eventualmente recorrendo

a filtros elétricos consegue-se obter a tensão média desejada com baixas perdas de potência, graças

aos dois estados predominantes de funcionamento dos transístores (saturação e corte). Com este

método consegue-se uma variação do valor de tensão aplicada com perdas mínimas, o que

corresponde a um rendimento elevado. Para os interruptores são utilizados transístores, sendo a

frequência de operação na ordem das dezenas de kHz (dezenas de milhares de ciclos por segundo). A

utilização do método PWM é portanto, uma boa forma de tornar a tensão de operação variável sem

a alterar na fonte.


IPT - 2015 – V3.2

Em termos de escolha da frequência de operação, quanto mais alta a frequência, maiores as perdas

de comutação e o ruído eletromagnético gerado. Quanto menor a frequência, maior a dificuldade de

apresentar uma velocidade linear no veio do motor, pelo que deverá haver um compromisso na

escolha da frequência de operação. Na realidade devido a questões práticas e para se permitir a

reversibilidade de rotação do motor (obter tensão positiva e negativa) existem drivers bidirecionais

que possuem uma configuração em H, baseados em quatro interruptores, tal como o representado

na Figura 10. Esta configuração é denominada em ponte. A obtenção das tensões negativas e

positivas aos terminais do motor faz-se pela ativação dos transístores adequados a cada situação (C1,

C4, C2, C3), sendo que por exemplo a paragem do motor poderá ser efetuada pela ativação da linha

superior ou inferior de interruptores (C1,C3 ou C2,C4) pois impõe uma tensão nula aos seus

terminais.

O driver L298 utilizado possui internamente dois conversores em ponte que permitem atuar os dois

motores existentes, com base nos sinais de comando PWM provenientes do microprocessador.

Figura 10 - Drive de potência em "H" e placa do drive de potência utilizado.

A placa possui conectores para ligar à alimentação (Vd ou Vs), conectores para os dois motores e

conectores para os sinais provenientes do microprocessador (E1,M1 e E2,M2). De modo a comandar

a placa, o microprocessador necessita de enviar dois sinais: um indicativo da direção de rotação

desejada para o motor (pinos M) e outro com o sinal PWM com o fator de ciclo desejado (pinos E),

sendo este último o que define a velocidade do motor. A Figura 11 dá-nos uma ideia dos sinais

envolvidos num caso concreto.

M

+Vs

C1

C2

C3

C4


IPT - 2015 – V3.2

Figura 11 - Exemplo de sinais de comando e respectivo resultado do ponto de vista das tensões no motor.

Em termos de robô, este deslocar-se-á de acordo com as velocidades dos dois motores. Estas

dependem dos fatores de ciclo (que comandam o valor da tensão no motor e consequentemente a

sua velocidade) e também do sinal de direção para cada um, enviados para o driver, tal como

exemplificado na Figura 11.

Figura 12 - Exemplos de trajetórias em função das velocidades das rodas.


IPT - 2015 – V3.2

Montagem do Robô

Apresentam-se agora os diversos passos a efetuar para a montagem do robô do projeto

assim como a lista de material necessário.

Lista de Material:

4x parafuso M3x8 (cabeça de embeber) 6x parafuso M3x6 18x parafuso M3x10 5x parafuso M3x12 12x parafuso M4x12 19x porca M3 8x espaçador M3x14 M/F 4x espaçador M4x40 F/F 4x espaçador M4x20 F/F 4x espaçador M4x20 M/F 2x roda de tração 1x roda castor 2x conector de alimentação (“conector de pilha de 9V”) 1x tomada de carregamento – 2,1mm 1x ficha alimentação Arduino – 2,1mm 1x interruptor ON/OFF 2x base em acrílico (base superior e base inferior) 2x suporte de motor 1x Arduino MEGA 2560 1x Cabo USB A-B 1x carregador baterias 8x acumulador AA “Eneloop” 1,2V-2000 mAh 2x suporte de quatro acumuladores AA 2x motor - Pololu 6V / 210rpm – 47:1 1x drive potência L298 – DFRobot 1x servo motor 1x sonar SRF05 1x sensor distância IR – Sharp GP2D120 3x sensor de linha IR – QRD1113 Cabo flexível vermelho Cabo flexível preto Manga termo retrátil 1,6mm Manga termo retrátil 3,2mm Manga “arruma cabos”


IPT - 2015 – V3.2

Instruções de Montagem:

Base Inferior:

1. Fixação dos suportes dos motores à base inferior.

2. Colocação dos suportes dos drives de potência e fixação do drive de potência.

3. Colocação dos suportes da base superior.


IPT - 2015 – V3.2

4. Fixação dos motores aos suportes e ligação ao drive de potência.

5. Fixação dos sensores de embate (“bumpers”) e dos três sensores de linha na parte inferior da frente da plataforma.

6. Ligar ao drive de potência o interruptor ON/OFF e a tomada de carregamento, a ficha de alimentação do Arduino e os cabos dos sinais de controlo M/E.


IPT - 2015 – V3.2

7. Fixar os suportes dos acumuladores à base com as fitas de velcro.

8. Montagem das rodas de tração.

9. Fixação à base superior dos suportes para o Arduino e a roda livre (roda castor).

10. Fixar os suportes das baterias na base inferior do robot.


IPT - 2015 – V3.2

Base Superior

11. Fixar suportes para Arduino/shield.

12. Instalar suporte e respetivo sensor de distância IR.

13. Instalar módulo do servo motor/sonar.

14. Fixar roda livre (roda castor).

15. Fixar a base superior do robot à base inferior e ligar conectores de alimentação aos suportes das baterias e fazer passagem de cabos da base inferior.


IPT - 2015 – V3.2

16. Fixar o Arduino/shield aos suportes na base superior e fazer ligações dos vários sensores ao shield.

17. Robot finalizado e pronto para os primeiros testes ao seu funcionamento.

Instruções de Carregamento das Baterias

O correto carregamento das baterias do robô permite para além de uma maior autonomia,

um aumento da vida útil das mesmas. Deste modo as baterias devem ser carregadas apenas

com o carregador fornecido e de acordo com as seguintes configurações:

Número de elementos na posição 7;

Corrente de carregamento de 500mA, de modo a se evitar o indesejado aquecimento

das baterias;

O terminal de carregamento deverá estar em posição tal que o pino central

corresponda ao terminal positivo (+).


IPT - 2015 – V3.2

Figura 13 - Pormenor dos botões de ajuste do carregador.

Figura 14 - Pormenor da ficha de carregamento.

O carregador possui um sistema automático de controlo de carregamento que

protege as baterias de sobrecarga. O sistema de controlo indica o estado do

carregamento através do LED do carregador que de acordo com a cor do indica o seu

estado:

Vermelho: baterias em carga;

Verde: baterias carregadas;

Amarelo: a descarregar baterias.


IPT - 2015 – V3.2

Figura 15 - Modos de carregamento. Vermelho: a carregar; Verde: carregado; Amarelo: a descarregar.


IPT - 2015 – V3.2

Capítulo 3 - Programação

Pedro Correia

Este capítulo pretende abordar os aspetos básicos de programação baseada nos microcontroladores

Arduino. O capítulo descreve sumariamente o circuito baseado no microcontrolador Arduino a

utilizar, assim como a instalação do ambiente de desenvolvimento. Posteriormente serão

introduzidas as funções básicas de entrada e saída de dados do microcontrolador, assim como as

instruções de decisão e de ciclo, necessárias para elaboração de programas que permitam controlar

o funcionamento autónomo do robô.

Arduino para Windows – Instalação

Esta secção explica como ligar a placa Arduino ao computador e o modo como se realiza o “upload

de um programa simples.

Placa Arduino MEGA 2560 e cabo USB

Este tutorial considera o uso da placa Arduino MEGA 2560. É necessário um cabo USB padrão (tipo

que você se conectar a uma impressora USB (usada na ligação de impressoras, p.e.)

Figura 16 - Arduino Mega 2560.

Download do ambiente de desenvolvimento Arduino

Obtenha a última versão da página de download (http://arduino.cc/en/Main/Software).

http://arduino.cc/en/Main/Software

http://arduino.cc/en/Main/Software


IPT - 2015 – V3.2

Figura 17- Aspeto da página de download do ambiente de desenvolvimento.

Quando o download terminar, descompacte o arquivo baixado. Certifique-se de preservar a

estrutura de pastas. Dê um duplo clique na pasta para abri-lo. Deve haver alguns arquivos e

subpastas dentro.

Ligação da Placa

O Arduino MEGA 2560 extrai automaticamente energia do computador através da ligação USB ou

através de uma fonte de alimentação externa. Ligue a placa Arduino ao seu computador usando o

cabo USB. O verde LED de alimentação (PWR) deve ficar aceso.

Instalação dos drivers

Instalação dos drivers Arduino Mega com Windows7, Vista, ou XP: • Ligue a placa e espere que o Windows comece o processo de instalação do driver. Depois de alguns

momentos, o processo indicará que necessita de instalar o controlador respetivo.

• Clique no menu Iniciar e abra o Painel de Controlo.

• No Painel de Controlo, selecione Sistema e Segurança. De seguida, clique em Sistema e selecione

Gerenciador de Dispositivos.

• Procure em Portas (COM & LPT) uma porta aberta com o nome "Arduino MEGA 2560 (COMxx)"

• Coloque o rato sobre "Arduino MEGA (COMxx)" e escolha a opção "Atualizar driver de software".

• Em seguida, escolha a opção "Procurar o meu computador para o software controlador".

• Finalmente, selecione da pasta “MEGA”, o ficheiro chamado "ArduinoUNO.inf", localizado na pasta

"Drivers" do software Arduino (não as sub-directorias "Drivers FTDI USB").


IPT - 2015 – V3.2

• O Windows irá terminar a instalação do driver de lá.

Pode verificar a instalação dos drivers abrindo o gestor de dispositivos do Windows. Procure a placa

Arduino na secção Portas, "USB Serial Port".

Abrir o ambiente Arduino

Dê um duplo clique no aplicativo Arduino. (Nota:. Se o pacote Arduino estiver noutra língua, esta

pode mudada na janela de preferências. (Veja a secção the environment page para mais detalhes).

Abrir um exemplo simples

Abra o exemplo do “LED a piscar” : Ficheiro> Exemplos> 1.Basics > Blink.

Figura 18 - Exemplo "Blink".

Selecione a placa

Deve selecionar a placa que está a utilizar no projeto, ou seja, Ferramentas -> Placa.

http://arduino.cc/en/Guide/Environment#languages


IPT - 2015 – V3.2

Figura 19 - Escolha da placa de desenvolvimento.

Selecionar a porta série

Selecione o dispositivo de série da placa Arduino do menu Ferramentas| Porta Serie. É provável que

seja COM3 ou superior (COM1 e COM2 são normalmente reservados para portas serie de hardware).

Para descobrir, pode desligar a placa Arduino e reabrir o menu. A entrada que desaparece deve ser a

da placa Arduino. Volte a ligar a paca e selecione a porta série correspondente.

Carregar um programa

Agora, basta clicar no botão "Carregar" no ambiente. Aguarde alguns segundos - você deve ver os

leds RX e TX no piscar bordo. Se o upload for bem sucedido, aparece a mensagem "A carregar…" na

barra de status.

Figura 20 - Carregamento de um programa para o microcontrolador.

Alguns segundos após a conclusão do carregamento, o pino 13 (L) correspondente ao díodo emissor

de luz da placa começar a piscar (em laranja). Se isso acontecer, parabéns! O seu primeiro programa

está a funcionar!


IPT - 2015 – V3.2

Gravar um programa

Agora, basta clicar no botão "Ficheiro-> Guardar Como…" e dar o nome, por exemplo, MyBlink.

Poderá abrir e carregar a placa com o programa sempre que desejar.

Figura 21 - Gravar um programa.

Aspetos da linguagem de programação

Um programa Arduino pode ser dividido em três secções principais: estruturas, variáveis e

constantes, e funções. O guia de referencia da linguagem pode ser encontrado em

http://arduino.cc/en/Reference/HomePage. Esta secção realiza um resumo e explicação dos aspetos

principais.

Estruturas

setup() : A função setup() é chamada no início do programa. É usada para inicializar

variáveis, modos dos pinos, livrarias, etc. A função setup é executada apenas uma vez, após a ligação

da placa ou quando é realizado o reset à placa Arduino.

Tabela 1 – Exemplo da função setup

#define buttonPin = 3;

void setup()

{

Serial.begin(9600);

pinMode(buttonPin, INPUT);

http://arduino.cc/en/Reference/HomePage


IPT - 2015 – V3.2

}

void loop()

{

// ...

}

loop(): Depois de criar a função setup(), a função loop() vai realizar o que o seu nome sugere,

ou seja, executa em ciclo as instruções incluídas na mesma. É nesta função que estão contidas todas

as instruções para controlar a placa Arduino.

Tabela 2 - Exemplo da função loop

#define buttonPin = 3;

// setup inicializa a porta série e o pino 3

void setup()

{

Serial.begin(9600);

pinMode(buttonPin, INPUT);

}

// verifica o pino e envia o seu estado para a porta série

void loop()

{

if (digitalRead(buttonPin) == HIGH)

Serial.write('H');

else

Serial.write('L');

delay(1000);

}

Constantes e variáveis

As variáveis permitem que um determinado valor possa ser guardado em memória para poder ser

utilizado posteriormente. Existem alguns tipos básicos de dados, como por exemplo:

int : permite que um número inteiro ou seja 1,2,3,5 possa ser guardado. Usa uma

representação de 16-bit (2-bytes). A gama de valores está compreendida entre -32768 a

32767.

unsigned int: Usa uma representação de 16-bit (2-bytes) com gamas de valores entre 0 a

65535 (216-1).

byte: guarda valores inteiros entre 0 e 255, isto é, usa apenas um byte de memória.

float : guarda valores reais 3.4028235E+38 e -3.4028235E+38. Usa 32 bits (4 bytes) de

memória para guardar um valor.

constantes: LOW | HIGH – indica nível baixo (0V) e alto (5V) nos pinos


IPT - 2015 – V3.2

INPUT| OUTPUT – define se um pino vai ser pino de entrada ou de saída

Tabela 3 - Exemplos de definição de variáveis

unsigned int ledPin = 13;

int ledPin = 13;

byte b = B10010; // "B" é o formatador de binario (B10010=18 decimal)

float sensorCalbrate = 1.117;

Funções de entrada/saída

As funções de entrada e saída permitem que o microprocessador possa interagir com o exterior.

Estas funções permitem leituras de dados do exterior ligado a um pino configurado como entrada,

assim como o envio de sinais a outros dispositivos através de pinos configurados como saída. As

funções de leitura e de escrita podem ser realizadas para sinais expressos na forma digital ou

analógica.

As funções de entrada/saídas digitais são as seguintes:

pinMode() : configura um pino para um modo específico, ou seja, como entrada (INPUT) ou saída (OUTPUT) - pinMode( PIN, MODE );

Ex: pinMode (13, OUTPUT);

digitalRead(): Lê o valor/estado (HIGH, LOW) de um pino - digitalRead( PIN );

Ex: valor = digitalRead(13);

digitalWrite() : Escreve o valor/estado (HIGH, LOW) de um pino.

digitalWrite( PIN, VALOR ); Ex: digitalWrite(13, HIGH);

As funções de entrada/saídas analógicas são as seguintes:

analogReference() : configura a tensão de referência para entrada analógica.

analogReference( TYPE ); Ex: analogReference( DEFAULT ); analogRead(): Lê o valor (0-1023 =.0049V resolução) de um pino analógico. Os valores lidos

0-1023 correspondem a valores de tensão entre 0 e 5V. analogRead( PIN );

http://arduino.cc/en/Reference/PinMode

http://arduino.cc/en/Reference/DigitalRead

http://arduino.cc/en/Reference/DigitalWrite

http://arduino.cc/en/Reference/AnalogReference

http://arduino.cc/en/Reference/AnalogRead


IPT - 2015 – V3.2

Ex: valor = analogRead(3);

analogWrite(): Atribui um valor (0-255) analógico (PWM) no pino –

analogWrite( PIN, VALOR ); Coloca um valor analógico através duma onda PWM num pino definido. Podemos usar um LED para variar o seu brilho ou para acionar um motor a diferentes velocidades.

Depois de chamar a função analogWrite(), o pino correspondente à saída

vai gerar uma onda quadrada com um factor de ciclo especificado até à

próxima chamada de função analogWrite() (ou uma chamada das

funções digitalRead() ou digitalWrite() do mesmo pino). A frequência do

sinal PWM é de aproximadamente 490 Hz. Na placa Arduino MEGA (com

microcontrolador ATmega2560), esta função trabalha com os pinos 2 a 13.

Ex: analogWrite(3, 10);

Figura 22 - Exemplo de sinal PWM.

Vamos considerar um exemplo onde se liga um potenciómetro a uma entrada do Arduino e se liga

um LED a uma das saídas.

http://arduino.cc/en/Reference/AnalogWrite


IPT - 2015 – V3.2

Figura 23 - Montagem básica com um potenciómetro como entrada e LED como saída.

O código seguinte configura a saída do LED proporcional ao valor lido no potenciómetro.

Tabela 4 - Exemplo de configuração de entrada e saída.

#define ledPin = 2; // LED ligado ao pino 2

#define analogPin = A0; // potenciómetro ligado ao pino analógico A0

int val = 0;// variável para guardar o valor lido

void setup()

{

pinMode(ledPin, OUTPUT); // sets the pin as output

}

void loop()

{

val=analogRead(analogPin); // lê o valor da entrada analógica

analogWrite(ledPin, val / 4); // valores de saída da //função analogRead

vão de 0 a 1023

// A função analogWrite utiliza valores de 0 to 255.

}

Funções de Temporização

A função delay() permite que o a execução do programa possa “esperar” um determinado tempo expresso em milissegundos.

delay(milisegundos); Ex: delay(1000); // atraso de 1 segundo

http://arduino.cc/en/Reference/Delay


IPT - 2015 – V3.2

Tabela 5 - Exemplo da utilização da função delay.

#define ledPin = 2; // LED ligado ao pino digital 2

void setup()

{

pinMode(ledPin, OUTPUT); // Define pino como saída digital

}

void loop()

{

digitalWrite(ledPin, HIGH); // Coloca LED on

delay(1000); // espera um segundo

digitalWrite(ledPin, LOW); // coloca LED off

delay(1000); // espera um segundo

}

Comunicação Série

Usada para comunicação entre a placa Arduino e o computador ou outros dispositivos. Existem pelos

menos uma porta série (também conhecida como UART ou USART): Serial. Comunica nos pinos

digitais 0 (RX) e 1 (TX) assim como com o computador via USB. Assim, usando estas funções, não é

possível usar os pinos 0 e 1 para entradas e saídas digitais. O monitor série do ambiente Arduino

pode ser usado para comunicar com a placa.

O Arduino Mega possui três portas série adicionais: Serial1 nos pinos 19 (RX) e 18 (TX), Serial2 nos

pinos 17 (RX) e 16 (TX),Serial3 nos pinos 15 (RX) e 14 (TX). Para usar estes pinos para comunicar com

o computador é necessário um adaptador USB série adicional, uma vez que não estão ligadas ao

adaptador Mega USB-serie. Para os usar com um dispositivo série externo TTL ligue o pino TX pin ao

Rx desse dispositivo, e o pino RX ao pino TX do dispositivo. O ground da placa Mega é ligado ao

ground do dispositivo. (Não pode ligar diretamente os pinos a uma porta série RS232 uma vez que

esta opera a +/- 12V e pode danificar a placa Arduino.)

Figura 24 - Monitor de porta série.

http://arduino.cc/en/Main/ArduinoBoardMega2560


IPT - 2015 – V3.2

Tabela 6 – Exemplo de código para utilização do monitor de porta série.

void setup()

{

Serial.begin(9600);

Serial.println("O meu primeiro programa Arduino");

}

void loop()

{

Serial.println("Estamos na estrutura loop...");

}

Funções de entrada/saída - exemplos

1- Coloque um potenciómetro na entrada analógica A0 e mostrar o valor de tensão colocada em cada instante na entrada analógica. Mostre o seu valor no monitor da porta série.

Figura 25 - Montagem com potenciómetro

Tabela 7 - Exemplo de leitura de valor analógico.

#define analogPin = A0; // potenciómetro ligado à entrada analógica A0

int val = 0; // Variável para guardar o valor lido

float volts=0;// variável para guardar o valor de tensão correspondente

void setup()

{

Serial.begin(9600);


}

void loop()

{

val = analogRead(analogPin);// lê o valor da entrada analógica

Serial.println(val);

volts=val*0.0009765625*5; //constante corresponde a 1/1024

Serial.println(volts);

delay(1000);

}


IPT - 2015 – V3.2

2- Coloque um potenciómetro na entrada analógica e um LED na saída analógica correspondente ao pino 2. Faça variar a intensidade do LED em função do valor de tensão imposta pelo potenciómetro.

Figura 26 - Montagem com potenciómetro e LED.

Tabela 8 - Exemplo de leitura e escrita de sinal analógico.

#define ledPin = 2; // LED ligado ao pino 2

#define analogPin = A0; // potenciómetro ligado à entrada analógica A0

int val = 0; // Variável para guardar o valor lido

float volts=0;// variável para guardar o valor de tensão correspondente

void setup()

{

Serial.begin(9600);


}

void loop()

{

val = analogRead(analogPin);// lê o valor da entrada analógica


volts=val*0.0009765625*5; //constante corresponde a 1/1024

Serial.println(volts);

analogWrite(ledPin, val/4); // valores de saída da para o LED

(valores entre 0 e 255)

delay(1000);

}


IPT - 2015 – V3.2

Fluxogramas

Um fluxograma, ou diagrama de fluxo, representa de uma forma gráfica as estruturas de controlo de fluxo, instruções e despectivas operações incluídas num algoritmo. Os fluxogramas são por isso, uma forma alternativa à linguagem natural (pseudo-código) para expressar algoritmos e tem como principal objetivo facilitar a compreensão e o desenvolvimento de algoritmos. Os fluxogramas são constituídos à custa da composição de símbolos que representam operações e que definem o fluxo do algoritmo. No âmbito desta cadeira serão usados os que constam na tabela seguinte.

Figura 27- Símbolos utilizados num fluxograma.

Exemplo 1: Construir um programa que verifique se o aluno está aprovado ou reprovado, tendo como entrada a classificação na disciplina.


IPT - 2015 – V3.2

Exemplo 2: Construa um fluxograma que verifique se um número introduzido pelo utilizador é

positivo, negativo ou nulo.

Controlo de fluxo

As instruções de controlo de fluxo são aquelas que permitem que um programa realize uma decisão

em função de uma condição verdadeira ou falsa. Estas condições podem depender de valores de

sinais de entrada ou então de valores de variáveis de controlo. As instruções de controlo de fluxo


IPT - 2015 – V3.2

estão em dois grandes grupos: i) as instruções condicionais ( if … else ; switch… case) ; ii) instruções

de ciclo, que permitem a repetição controlada de uma instrução ou bloco de instruções ( for; while).

Instruções condicionais

As instruções condicionais são:

If : Realiza um conjunto de instruções se uma condição for verdadeira. As expressões de

condição podem ser:

a == b a igual a b a != b a diferente b a > b a maior do que b a < b a menor do que b a =< b a menor ou igual do que b a >= b a maior ou igual que b

A sintaxe da instrução condicional if é definida do seguinte modo:

if(condicao)

{

instrucao;

instrução;

}

if / else: Permite um controlo de fluxo mais apurado do que a instrução if. Para além das instruções a

executar se a condição for verdadeira, realiza também outro conjunto de instruções se a condição for

falsa. Por exemplo:

if (pinFiveInput < 500)

{

// accao A

}

else

{

// accao B

}

switch/case: A instrução switch...case controla o fluxo do programa, permitindo que seja

especificado código que deve ser executado de acordo com diferentes condições. Em particular a

instrução switch compara o valor de uma variável com o valor especificado em cada valor associado

ao case. Quando o valor da variável coincide com o valor enumerado em cada case, então procede-se

à execução das instruções correspondentes. Cada bloco de instruções deve terminar com a instrução

break, que termina todo o fluxo. Caso nenhuma das condições se verificar são executadas as

condições correspondentes ao default. A sintaxe é a seguinte:

switch (var) {

case label1:

// instruções

break;


IPT - 2015 – V3.2

case label2:

// instruções

break;

default:

// instruções

}

Por exemplo,

switch (var) {

case 1:

//faz alguma coisa quando var for 1

break;

case 2:

//faz alguma coisa quando var for 2

break;

default:

// Caso contrário faz o que estiver na opção

default

// a opção default é opcional

}

Com base nos exemplos anteriores faça um programa que tenha:

Um potenciómetro de entrada;

Três LEDS de saída, LED1, LED2, LED3;

Pretende-se que:

o O LED1 acenda se o valor da entrada analógica for menor do que 400;

o O LED2 acenda se o valor da entrada analógica estiver entre 400 e 600.

o O LED3 acenda se o valor da entrada analógica for maior do que 600 (o máximo é

1023).

Tabela 9 - Exemplo de utilização de instruções condicionais

#define ledPin1 = 2; // LED ligado ao pino 9



#define analogPin = A0; // potenciómetro ligado ao pino analógico A0

int val = 0; // variável para guardar o valor lido

float volts=0;

void setup()

{

pinMode(ledPin1, OUTPUT); // sets the pin as output



Serial.begin(9600);

}

void loop()


IPT - 2015 – V3.2

{

val = analogRead(analogPin); // lê o valor da entrada analógica


if (val<400)

{

digitalWrite(ledPin1, HIGH);

digitalWrite(ledPin2, LOW);


} else

if (val<600)

{



}

else

{




}

}

Instruções de ciclo

As instruções de ciclo permitem executar várias vezes um conjunto de instruções. Por cada iteração

do ciclo é testada a condição de paragem do ciclo. O ciclo continua sempre que a condição é

verdadeira e termina quando a condição for falsa. Existem duas instruções que podem ser utilizadas:

ciclo for e ciclo while. Por exemplo,

Construa um fluxograma que imprima os números entre 1 e 10 na consola. O fluxograma será:

Figura 28 - Fluxograma da execução de um ciclo.


IPT - 2015 – V3.2

Ciclo for: O ciclo é controlado por uma variável que deve ser inicializada e incrementada ao longo da

execução do ciclo. Por exemplo, considere-se um programa que apresente os números inteiros de 0 a

100 no monitor série usando o ciclo for como mostra a Figura 29. A variável x, é inicialmente é

colocada a zero. No fim da execução das instruções, a variável é incrementada 1 unidade. O ciclo

termina quando o x=100.

parêntesis

Inicialização

Teste

Incremento

Figura 29 - Sintaxe do ciclo for.

Tabela 10- Exemplo onde a intensidade de um LED varia usando um pino PWM (for).

// aumenta a intensidade de um LED usando um pino PWM

#define PWMpin = 2; // LED em serie com Resistência de 470 ohm no pino 10

int i; //variável de teste do ciclo;

void setup()

{

Serial.begin(9600);

}

void loop()

{

for (i=0;i<=255;i++)

{

Serial.println(i);

analogWrite(PWMpin, i);

delay(10);

}

}


IPT - 2015 – V3.2

Ciclo while: A declaração while vai executar continuamente até à condição colocada entre parêntesis

for falsa. É necessário fazer variar a variável testada senão o ciclo nunca acaba. Esta variável

necessita de ser inicializada antes de o ciclo iniciar. A sintaxe é a seguinte:

while(expression){

// statement(s)

}

Por exemplo,

var = 0;

while(var < 200)

{

// repete alguma coisa 200 vezes

var++;

}

Tabela 11- Exemplo onde a intensidade de um LED varia usando um pino PWM (while).

// aumenta a intensidade de um LED usando um pino PWM

#define PWMpin = 2; // LED em serie com Resistencia de 470 ohm no pino 10

int i; //variável de teste do ciclo;

void setup()

{

Serial.begin(9600);

}

void loop()

{

i=0;

while (i<=255)

{

Serial.println(i);

analogWrite(PWMpin, i);

i++;

delay(10);

}

}


IPT - 2015 – V3.2

Capítulo 4 - Sensores

Gabriel Pires

Os sensores de um robô dão-lhe a capacidade de perceber e interagir com o seu meio

envolvente. Essa capacidade permite ao robô efetuar algumas tarefas de forma autónoma,

ou seja, sem intervenção permanente do ser humano. Existe uma grande variedade de

sensores, tais como foto-sensores, interruptores de pára-choques, sonares, giroscópios,

acelerómetros, bússolas, microfones, sensores de infra-vermelho, sensores de força,

câmaras, etc. O tipo de informação devolvido pelos sensores, bem como a sua forma de

funcionamento e complexidade variam muito de sensor para sensor. Uns baseiam-se na

propagação de ondas sonoras, outros na reflexão de feixes de luz, outros na captação de luz,

outras na alteração de características dos materiais, etc. Iremos neste capítulo descrever o

funcionamento de vários tipos de sensores, nomeadamente, sensores de odometria para

localização (e.g., codificadores), sensores de medição de distâncias para deteção de

obstáculos (e.g., sensores de infravermelhos e de ultrassons) e sensores de deteção de cor

branca/preta para seguimento de linha (foto-detetores). Todos eles têm um funcionamento

relativamente simples o que permite a sua interligação ao microcontrolador do Arduino

usado no robô GreenT. Sensores mais complexos como os laser range finders e câmaras de

visão precisam de ser ligados a computadores porque exigem uma maior capacidade

computacional para processar a informação por eles devolvida.

É importante perceber que os sensores são meros transdutores. Traduzem um determinado

fenómeno físico em sinais elétricos que o microcontrolador consegue ler. Para que um robô

realize uma determinada tarefa de forma autónoma é necessário que o ser humano

programe o microprocessador. A programação do robô consiste em realizar algoritmos que

interpretem a informação fornecida pelos vários sensores e atuem o robô de acordo com a

tarefa desejada. Os algoritmos de programação de tarefas de navegação do robô serão

discutidos no capítulo seguinte. Neste capítulo iremos apenas explicar o funcionamento dos

sensores para perceber como é que os podemos interligar ao microcontrolador e lê-los.

Sensores de Infravermelhos: medição de distância

Um dos sensores que iremos usar para detetar a presença de obstáculos é o sensor

GP2D120 [1]. É um sensor de infravermelhos que devolve um valor analógico de tensão

inversamente proporcional à distância a que se encontra um obstáculo. Com base no valor

de tensão, podemos saber mais ou menos a que distância se encontra esse obstáculo. A


IPT - 2015 – V3.2

Figura 30 mostra uma imagem do sensor GP2D120. É constituído por um LED (Light Emitter

Diode) e por um CCD (charge coupled device) para deteção da luz. O LED emite tipicamente

um feixe de luz infravermelha com comprimento de onda de 880 nm. O detetor CCD,

sensível à luz dos 880 nm, permite identificar o ângulo de incidência do feixe refletido. O

princípio de funcionamento encontra-se ilustrado na Figura 31(A). A tensão de saída varia

entre 0.2 – 3V que tem uma correspondência a distâncias entre 4-40 cm, de acordo com a

curva característica da Figura 31 (B).

Figura 30 – Sensor GP2D120. (A) Imagem; (B) Pinagem (retirado de [1]).

(A) (B)

Figura 31 – Sensor GP2D120. (A) Princípio de funcionamento; (B) Relação entre tensão e distância

(retirado de [1]).

LED – Light Emitter Diode

Light detector (CCD)


IPT - 2015 – V3.2

Interligação do GP2D120 ao Arduino

O sensor GP2D120 devolve no pino 1 um nível de tensão analógico, por isso terá de ser

ligado a uma entrada analógica do Arduíno (qualquer uma que esteja disponível). Os pinos

VCC e GND são ligados aos respetivos pinos do Arduíno. A Figura 32 ilustra a interligação do

sensor, usando a porta analógica 0.

Figura 32 – Ligação do sensor GP2D120 ao Arduino (porta A0 (Analog 0))

Leitura do valor analógico do GP2D120

Sendo um valor analógico, a entrada terá de ser convertida para um valor numérico digital que o

microprocessador entenda. Para esse efeito, o microcontrolador tem um conversor analógico-digital

de 10 bits. Dessa forma os valores na gama de 0-5 Volts são convertidos para uma gama numérica de

0-1023(ou seja, 1024 valores, em que 1024 = 210).

A

Tabela 12 apresenta um código exemplo que faz a leitura do sensor, ao mesmo tempo que

liga/desliga 2 LEDs de acordo com o valor devolvido pelo sensor.

Tabela 12: Programa exemplo do Arduino para leitura do sensor GP2D120

//Ciência Viva - "Escolher Robótica - Escolher Ciência!" - PEC88

//Exemplo de leitura do sensor IR GP2D12

//Arduino Mega - 2560

//Robot GreenT - IPT - 2013-2014


IPT - 2015 – V3.2

#define Pinled1 12 //pino de ligação saída digital

#define Pinled2 13 //pino de ligação saída digital

#define PinIR A0 //pino do porto entrada analógica (pode ser

usado qq porto analogico)

void setup() {

Serial.begin(9600);

pinMode(Pinled1, OUTPUT);

pinMode(Pinled2, OUTPUT);

}

void loop() {

int sensor = 0;

// lê o valor do sensor

sensor=analogRead(PinIR);

// mapeamento do valor para uma gama mais pequena

sensor = map(sensor, 0, 1024, 0 , 200);

// acende led2 quando está entre 50 e 100

if ( sensor > 50 && sensor <100){

digitalWrite(Pinled1, LOW);

digitalWrite(Pinled2, HIGH);

}

// acende led1 quando valor se encontra acima de 100

else if (sensor >= 100){

digitalWrite(Pinled1, HIGH);


}

else {

// desliga os dois leds



}

Serial.println(sensor);

delay(100);

}

Fotodeteção de linha branca/preta

Uma das tarefas que o robô GreenT terá de realizar consiste no seguimento de uma linha preta em

fundo branco ou de uma linha branca em fundo preto. A deteção de linha será realizada através de

sensores refletivos QRD1113 [2]. O objetivo será discriminar uma superfície branca (elevada

seletividade) de uma superfície preta (baixa refletividade). O sensor e respetiva pinagem encontram-

se ilustrados na Figura 33. O sensor é constituído por um LED emissor de infravermelhos e um foto

transístor que deteta a luz refletida. A quantidade de luz refletida depende da superfície refletora.

Superfícies de cor branca refletem mais luz que as superfícies pretas, sendo desta forma possível

discriminar estas duas cores. No entanto, isto só será possível para superfícies que se encontrem a

uma distância até aproximadamente 5 mm.


IPT - 2015 – V3.2

Ligação e leitura do sensor QRD1113

A Figura 33 mostra o circuito para interligar o sensor QRD1113 ao Arduíno. O sinal OUT corresponde à tensão no coletor do foto transístor que poderá será ligada tanto a uma entrada analógica como a uma entrada digital. No caso de ser ligado a uma entrada digital, o valor lógico 1 corresponde ao preto e o valor lógico 0 ao branco (poderá ter de se ajustar as resistências para calibrar). A Tabela 13 apresenta um código exemplo que faz a leitura do sensor QRD1113 através de uma entrada analógica ou de uma entrada digital.

Figura 33 – Sensor refletivo QRD1113 e respetiva pinagem (o pino 1 encontra-se identificado com um

ponto). Retirado de [2].

VCC

GND

3

4

1

2

Entrada analógica

Entrada digital

Figura 34 – Interligação do sensor QRD1113. Opção de leitura analógica;

Tabela 13 : Programa exemplo do Arduíno para leitura do sensor QRD1113


//Exemplo de leitura do sensor QRD1113


//Robot GreenT – IPT 2013-2014

#define PinL0_A A1 // entrada analogica QRD1113 - sensor 0

#define PinL0_D 22 // entrada digital QRD1113 - sensor 0


IPT - 2015 – V3.2



void setup() {

Serial.begin(9600);

pinMode(PinL0_D, INPUT); //pino digital definido como entrada

}

void loop() {

int Linha0, Linha1;

int Linha0_D =0, Linha1_D =0;

// se for lido como entrada analógica

Linha0 = analogRead(PinL0_A);

// mapeamento do valor para uma gama mais pequena

Linha0 = map(Linha0, 0, 1024, 0 , 200);

//Serial.println(Linha0_map);

// se for lido como entrada digital devolve apenas 1 ou 0

Linha0_D = digitalRead(PinL0_D);

Linha1_D = digitalRead(PinL1_D);

Serial.print("Linha0: ");Serial.print(Linha0_D);

Serial.print(" --- ");

Serial.print("Linha1: ");Serial.println(Linha1_D);

Serial.print("Linha0Analog: ");Serial.println(Linha0);

delay(100);

}

Sensores ultrassons: medição de distância

Para medição de distâncias podemos também usar um sensor de ultrassons, o qual pode ser usado em substituição do GP2D120 ou em combinação com este. Iremos usar o sensor de ultrassons SRF05 [3] que permite medir distâncias entre 1 cm e 4 m. O princípio de funcionamento deste sensor é muito diferente do funcionamento do GP2D120, uma vez que consiste na emissão de uma onda sonora em vez de um feixe de luz. A Figura 35 mostra o sensor e respetiva pinagem. A medição da distância é baseada no cálculo do tempo de vôo (tempo de ida e volta) de uma onda sonora de 40 KHz (acima do espectro audível). O diagrama temporal da Figura 36 ilustra o princípio de funcionamento. Para enviar a onda sonora tem de ser despoletado um “Trigger input” pelo

microcontrolador, um pulso com pelo menos 10 s. O sinal de “Echo output” passa do estado 0 para o estado 1 e permanece nesse estado até receber o eco. Quando o sinal de “Echo output” passa do estado 0 para 1, tem de ser acionado no microcontrolador um contador de tempo. Quando o sinal passa novamente para o estado 0, o contador de tempo é terminado e calcula-se o tempo decorrido entre a emissão da onda e a receção do seu eco. Desta forma, sabendo a velocidade de propagação do som, conseguimos calcular a distância a que se encontra o obstáculo.


IPT - 2015 – V3.2

(A)

(B)

Figura 35 – Sensor SRF05. (A) Vista do emissor/recetor. (B) Pinagem (modo de funcionamento 2).

Retirado de [3].

Figura 36 – Diagrama temporal do sensor SRF05 a funcionar no modo 2. Retirado de [3].

Se o tempo decorrido for tp, então o percurso total será

𝑠 = 𝑣𝑝 × 𝑡𝑝

Em que vp é a velocidade de propagação do som (à volta de 340 m/s). Como o percurso total é de ida

e volta, a distância a que se encontra o obstáculo será


IPT - 2015 – V3.2

𝑑 =𝑠

2

Por exemplo, se o tempo decorrido for de 10 ms, então o obstáculo encontra-se a 1.7 m.

Ligação e leitura do sornar SRF05

A ligação do sensor SRF05 ao Arduino, a funcionar no modo 2, encontra-se ilustrada na Figura 37. No

modo 2, o sinal de “Trigger input” e “Echo output” partilham o mesmo pino que será ligado ao pino

digital 7 do Arduino. O código para leitura do sonar encontra-se na Tabela 14. A função PulseIn

devolve em microsegundos o tempo em que o sinal se encontra a HIGH. Para converter para cm

divide-se esse valor por 58. A uma velocidade de 340 m/s, 1 cm corresponde 29 s. Como temos de

ter em conta a ida e a volta, o tempo devolvido tem de ser dividido por 2x29=58.

Figura 37 – Ligação do SRF05 ao Arduino.

Tabela 14 – Código exemplo para leitura do sensor SRF05


//Exemplo ligação sensor de ultrassons SRF05



#define Pinsonar 7 // Pino de ligação do sensor SRF05

int tempo; //tempo devolvido por pulsein

int distancia; //distancia

void setup()

{

Serial.begin(9600);

}


IPT - 2015 – V3.2

void loop()

{

pinMode(Pinsonar, OUTPUT);

digitalWrite(Pinsonar, LOW); // colocar a zero antes do trigger

delayMicroseconds(2);

digitalWrite(Pinsonar, HIGH); // Envia um burst de 10 us


digitalWrite(Pinsonar, LOW); // Coloca pino antes do pulso de eco chegar

pinMode(Pinsonar, INPUT);

tempo = pulseIn(Pinsonar, HIGH); // Lê o tempo do pulso de eco do SRF05

em microsegundos

distancia = tempo/58; // divide este tempo por 58 gives para dar a

distância em cm - ver texto

Serial.println(distancia); //

delay(100);

}

Codificador acoplado ao motor

Para que o robô consiga localizar-se, cada um dos motores tem acoplado a si um codificador

(usualmente ótico ou magnético) que permite calcular o número de rotações que o veio do motor

realiza (ver Metal Gearmotor na Figura 38). O codificador acoplado ao motor fornece 48 pulsos por

cada rotação. Como o codificador não se encontra acoplado à caixa redutora (46.851:1) mas sim ao

veio do motor, então o codificador irá fornecer 46.851 x 58 pulsos, ou seja sensivelmente 2249

pulsos por cada volta do veio à saída da engrenagem. Um exemplo ilustrativo de um codificador

rotativo incremental é apresentado na Figura 39. Por cada risca do codificador (Figura 39(A)) é

fornecido um pulso. Dada a disposição das riscas, são obtidas duas saídas que se encontram em

quadratura (Figura 39(B)). Desta forma é possível inferir a direção de rotação do motor. Estes pulsos

são fornecidos por sensores que podem ser óticos ou magnéticos. No caso do Metal Gearmotor

25Dx52L, o codificador é magnético, consistindo num disco com secções magnetizadas, as quais são

detetadas por um sensor de efeito de hall de dois canais [4]. Contando os pulsos e sabendo o raio da

roda do robô é possível calcular o deslocamento angular e linear da roda, e a velocidade angular e

linear.

(A) (B)

Figura 38 - (A) Vista do motor, caixa redutora e codificador acoplado ao veio (47:1 Metal Gearmotor

25Dx52L); (B) Pinagem


IPT - 2015 – V3.2

(A) (B)

Figura 39 – (A) Codificador rotativo incremental acoplado ao veio; (B) Pulsos devolvidos pelo canal A e

canal B.

Ligação e leitura dos codificadores de odometria

A ligação dos encoders à placa Arduino é realizada de acordo com a Ligação da Figura 40 (ver

também pinagem da Figura 38). A ligação do segundo motor será realizada da mesma forma, usando

os pinos indicados na

Tabela 17.

Canal A – pino 2

Canal B – pino 4

Figura 40 – Ligação de um encoder à placa Arduino. Proceder da mesma forma para o outro motor (ver pinagem

e Tabela 17)

A leitura dos pulsos fornecidos pelos codificadores pode ser computacionalmente exigente para o Arduino, principalmente se o número de pulsos por rotação for elevado. A medição de pulsos por polling, em que se a faz a monitorização constante (por software) das portas a que se encontram ligados o canal A e o canal B do codificador, é extremamente ineficaz, porque, por um lado, ocupa integralmente o processador esgotando os seus recursos, e por outro lado pode levar à não deteção de alguns pulsos. Uma outra abordagem consiste em configurar interrupções externas nesses pinos


IPT - 2015 – V3.2

de entrada do microcontrolador, o que permite detetar por hardware as transições do bordo ascendente/descendente dos pulsos, quando estes ocorrem. Neste caso, o microprocessador só é solicitado quando ocorrem transições (ver exemplo de código na Tabela 15). Apesar desta abordagem ser melhor do que a utilização de polling, na verdade também não é a melhor solução, porque o microprocessador é “interrompido” sempre que há uma transição. Ou seja, a contagem de pulsos é feita por software incrementando uma variável de contagem (count no programa da Tabela 15). No caso do número de pulsos por segundo ser alto, o microprocessador será constantemente interrompido. A solução ideal consiste na configuração dos Timers com função de contagem de pulsos externos. Neste caso, a contagem de pulsos é feita por hardware, e o seu valor só será lido por software quando desejado. Infelizmente, apesar do Amega2560 suportar vários Timers com essa configuração, a placa Arduino Mega só dá acesso a um dos pinos associados aos Timers. Como são necessários dois Timers, esta solução não poderá ser usada.

Para além da leitura dos pulsos é necessário também detetar o sentido de rotação do motor. Iremos

para já mostrar como podem ser contados o número de pulsos, passando de seguida à deteção da

direção. O código retirado de um tutorial do Arduino mostra exemplo de leitura dos canais dos

codificadores dos dois motores.

Tabela 15 – Leitura dos pulsos dos codificador (canal A e B) usando interrupções externas.


//Exemplo Leitura dos encoders



//Exemplo com 1 interupção por transição apenas do canal A

//ou seja, perde metade da resolução

//no caso de se detetar apenas o bordo ascendente/descendente a resolução p

assa a 1/4

//o sentido de rotação é detetado, verificando o estado do canal B

#define PinAencoder0 2 //pino de interrupção - encoder Esq

#define PinBencoder0 4 //Digital - encoder Esq

#define PinAencoder1 3 //pino de interrupção - encoder Dir

#define PinBencoder1 5 //Digital - encoder Dir

volatile signed int encoder0Pos = 0, encoder1Pos = 0, encoder=0;

void setup() {

setup_encoder();

Serial.begin (9600);

Serial.println("start"); // a personal quirk

}

void loop(){

// fazer o que for necessário

}

void setup_encoder(){

//Mega possui interrupções nos pinos 2, 3, 21, 20, 19, 18


IPT - 2015 – V3.2

pinMode(PinAencoder0, INPUT);

//digitalWrite(PinAencoder0, HIGH); // ativa resistência pullup

pinMode(PinBencoder0, INPUT);

//digitalWrite(PinBencoder0, HIGH); // ativa resistência pullup



attachInterrupt(0, processaEncoder0, RISING); // encoder pin on

interrupt 0 - pin 2


interrupt 0 - pin 3

//opçoes: CHANGE, RISING, FALLING, LOW

}

void processaEncoder0() {

/* Se o pino A e B estiverem ambos a HIGH a rotação é para a frente

Se forem diferentes a rotação é para trás

*/

//encoder++;

if (digitalRead(PinAencoder0) == digitalRead(PinBencoder0)) {

encoder0Pos++;

} else {

encoder0Pos--;

}

//Serial.println (encoder0Pos, DEC);

if ((encoder0Pos >100) || (encoder0Pos < -100) ){

Serial.print("encoder0: ");Serial.println (encoder0Pos);

encoder0Pos=0;

}

}




*/

//encoder++;


encoder1Pos--;

} else {

encoder1Pos++;

}

//Serial.println (encoder0Pos, DEC);

if ((encoder1Pos >100) || (encoder1Pos < -100) ){

Serial.print("encoder1: "); Serial.println (encoder1Pos);

encoder1Pos=0;

}

}

Servo

Será usado um servomecanismo para rodar o sonar ou o sensor de IR. Desta forma, será possível

detetar a posição aproximada dos obstáculos. O servo tem uma gama de rotação de 180º. Para ser

usado usa-se a livraria Arduino “Servo.h” [6]. Segue-se em baixo um exemplo disponibilizado no site

do Arduino que faz um varrimento de 180º nos dois sentidos.


IPT - 2015 – V3.2

#include <Servo.h>

Servo myservo; // cria um objeto servo

int pos = 0; // variável que armazena a posição do servo

void setup()

{

myservo.attach(11); // liga servo ao pino 11

}

void loop() {

for(pos = 0; pos < 180; pos += 1) // vai da posicao 0 a 180º de 1 em

1º

{

myservo.write(pos);

delay(15); //espera que o servo tenha tempo de chegar à posição

}

//percorre o sentido contrário

for(pos = 180; pos>=1; pos-=1)

{

myservo.write(pos);

delay(15);

}

}

Programa modelo – ciclo de operação

Após terem sido testados cada um dos sensores isoladamente, é agora necessário criar um programa que permita juntar todas as partes. Apresenta-se de seguida um programa simples que poderá servir de modelo. A leitura dos sensores e a atuação dos motores devem ser feitas de forma cíclica com um período fixo. Esse período é normalmente designado de LOOPTIME. No exemplo da

Tabela 16 apresenta-se uma forma simples de criar esse ciclo. A cada ciclo de 200 ms a velocidade dos motores é ajustada de acordo com a distância medida pelo sensor GP2D12. Irá ser fornecida uma livraria para cálculo da velocidade e controlo PID, de forma a melhorar o comportamento dos motores.

Tabela 16 – Programa modelo com funcionamento em ciclo


//Exemplo completo de leitura e atuação com controlo PID dos motoress



#include <math.h>

//IR GP2D12

#define PinIR A0 //pino do porto entrada analógica (pode ser usado qq

porto analogico)


IPT - 2015 – V3.2

//Fototransistor QRD1113





//MOTOR

#define PinE1 32 //Motor Dir - direção (Digital)

#define PinE2 30 //Motor Esq - direção (Digital)

#define PinM1 10 //Motor Dir - velocidade (PWM)

#define PinM2 9 //Motor Esq - velocidade (PWM)

//ENCODER

#define PinAencoder0 2 //pino de interrupção - econder esq

#define PinBencoder0 4 //Digital

#define PinAencoder1 3 //pino de interrupção

#define PinBencoder1 5 //Digital

// periodo de amostragem em milisegundos LOOP controlo

const int LOOPTIME = 200;

unsigned long int lastMilli=0;

//variáveis

int ValIR=0;

volatile signed int encoder0Pos = 0, encoder1Pos = 0, encoder=0;

void setup()

{

Serial.begin(9600);

motor_setup();

setup_encoder();

}

/* -----------------------------------------------------------*/

//FUNÇÃO MAIN

/* -----------------------------------------------------------*/

void loop() {

int speedref0=0, speed0=0, mapIR=0;

if(abs(millis()-lastMilli) >= LOOPTIME) {

// enter tmed loop

lastMilli = millis();

ValIR=le_IR();mapIR=map(ValIR, 0, 615, 0 , 255);

//refspeed0=250;

speedref0=mapIR;

if (mapIR>200) motorSTOP();

else {

motorEsq(speedref0);

motorDir(speedref0);

}

// Serial.print("IR: ");Serial.println(ValIR);

// Serial.print("encoder0: ");Serial.print(encoder0Pos);

// Serial.print(" ::: ");

// Serial.print("encoder1: ");Serial.println(encoder1Pos);

//Serial.print("lastmilli: ");Serial.println(lastMilli);


IPT - 2015 – V3.2

}

} // loop()

/* -----------------------------------------------------------*/

//FIM FUNÇÃO MAIN

/* -----------------------------------------------------------*/

/* -------------------------------*/

/* FUNCOES SENSORES

/* -------------------------------*/

/* -------------------------------*/

int le_IR(void){

int val=0;

val= analogRead(PinIR);

return val;

}

/* -------------------------------*/

/* -------------------------------*/

/* FUNCOES MOTORES e ENCODERS

/* -------------------------------*/

/* -------------------------------*/

void setup_encoder(){

//Mega possui interrupções nos pinos 2, 3, 21, 20, 19, 18


//digitalWrite(PinAencoder0, HIGH); // ativa resistência pullup


//digitalWrite(PinBencoder0, HIGH); // ativa resistência pullup




interrupt 0 - pin 2


interrupt 0 - pin 3

//opçoes: CHANGE, RISING, FALLING, LOW

}

/* -------------------------------*/

/* -------------------------------*/




*/

//encoder++;


encoder0Pos++;

} else {

encoder0Pos--;

}

}

/* -------------------------------*/

/* -------------------------------*/




*/


IPT - 2015 – V3.2

//encoder++;


encoder1Pos--;

} else {

encoder1Pos++;

}

}

/* -------------------------------*/

void motor_setup(){

//esquema de montagem em que:

// 0-127: roda no sentido direto

// 127-255: roda no sentido inverso

pinMode(PinE1, OUTPUT);

pinMode(PinE2, OUTPUT);

digitalWrite(PinE1,LOW); //desliga motor - se estiver a 1 roda à

velocidade do PWM

digitalWrite(PinE2,LOW);

//alteracao da frequencia PWM Timer1: 4kHz

TCCR2B = TCCR2B & 0b11111000 | 0x02;

//DEFAULT

//timer 0 (controls pin 13, 4); //default 1000 Hz



//timer 3 (controls pin 5, 3, 2); //default 500 Hz

//timer 4 (controls pin 8, 7, 6); //default 500 Hz

}

/* -------------------------------*/

/* -------------------------------*/

void motorDir (int speed) {

digitalWrite(PinE1,HIGH);

if (speed>=0) {

//Serial.print(speed); Serial.print(" .-. ");

speed=map(speed,0,255,127,0);

analogWrite(PinM1, speed);

Serial.println(speed);

}

else {

speed=map(speed,0,-255,127,255);


}

}

/* -------------------------------*/

/* -------------------------------*/

void motorEsq (int speed) {

digitalWrite(PinE2,HIGH);

if (speed>=0) {

//Serial.print(speed); Serial.print(" .-. ");

speed=map(speed,0,255,127,0);


Serial.println(speed);

}

else {

speed=map(speed,0,-255,127,255);


}


IPT - 2015 – V3.2

}

/* -------------------------------*/

/* -------------------------------*/

void motorSTOP () {



}

/* -------------------------------*/

Lista resumo dos pinos usados

À medida que for ligando os sensores e motores deverá criar uma tabela que identifique quais os pinos usados bem como a sua descrição, de forma a facilitar a evolução do seu robô. A

Tabela 17 resume todas as ligações realizadas ao longo deste capítulo. Com um número elevado de sensores torna-se também necessário ter uma régua de extensão dos pinos de alimentação (GND e VCC). A realização de um shield para fazer essa extensão é uma solução adequada para resolver o problema.

No anexo I encontra-se a descrição do shield que foi implementado e que servirá para expansão da alimentação e para ligação dos sensores e motores. O shield permite interligar outros sensores para além dos que foram descritos neste capítulo (consulte a pinagem completa no anexo I).

Tabela 17 – Resumo das ligações dos sensores e motores descritos neste capítulo com identificação dos pinos.

Variável Pino Descrição

PinIR A0 Sensor GP2D12

PinL0_A A1 Sensor QRD1113 número 0 (Esquerda) - Entrada analógica

PinL0_D 26 Sensor QRD1113 número 0 (Esquerda) - Entrada digital

PinL1_A A2 Sensor QRD1113 número 2 (Direita) - Entrada analógica

PinL1_D 28 Sensor QRD1113 número 2 (Direita) - Entrada digital

Pinsonar 7 Sonar SRF05

PinE1 32 Motor direito– Enable

PinM1 10 Motor direito - velocidade (PWM)

PinE2 30 Motor esquerdo - Enable

PinM2 9 Motor esquerdo - velocidade (PWM)


IPT - 2015 – V3.2

PinAencoder0 2 Encoder Esq – canal A pino de interrupção (2)

PinBencoder0 4 Encoder Esq – canal B (Digital)

PinAencoder1 3 Encoder Dir – canal A pino de interrupção (3)

PinBencoder1 5 Encoder Dir – canal B (Digital)

PinServo 11 Servo

Lista de funções específicas usadas: consultar http://arduino.cc/en/Reference para descrição

detalhada e exemplos.

Referências

[1] – Datasheet GP2D120 Optoelectronic Device, Sharp. [2] – Datasheet QRD1113 / QRD1114 Reflective Object Sensor, Fairchild semiconductor. [3] – Datasheet SRF05 - Ultra-Sonic Ranger [4] – Metal gear Mootr e Encoder, http://ptrobotics.com/produtos/1815-47-1-metal-gearmotor-25dx52l-mm-hp-with-48-cpr-encoder.html [5] – Reading Rotary Encoder, Arduino http://playground.arduino.cc/Main/RotaryEncoders [6] – Servo Motor Example, Arduino http://arduino.cc/en/Tutorial/Sweep

http://arduino.cc/en/Reference

http://ptrobotics.com/produtos/1815-47-1-metal-gearmotor-25dx52l-mm-hp-with-48-cpr-encoder.html

http://ptrobotics.com/produtos/1815-47-1-metal-gearmotor-25dx52l-mm-hp-with-48-cpr-encoder.html

http://playground.arduino.cc/Main/RotaryEncoders

http://arduino.cc/en/Tutorial/Sweep


IPT - 2015 – V3.2

Capítulo 5 – Estratégia de navegação

para micro-robôs

Ana Lopes

Introdução – O que é a navegação de robôs?

Aos robôs são atribuídas missões dependentes das aplicações para que estão vocacionados, que os

tornam úteis na sua operação em sociedade. Por exemplo, “dirigir-se para a cratera Endurance, em

Marte, e recolher uma amostra do solo” pode ser uma missão para um dos robôs Spirit ou

Opportunity que pousaram em Marte no início de 2004. A um robô de companhia (“companion

robot” em designação anglo-saxónica) pode pedir-se “vai à cozinha buscar uma lata de Coca-Cola e

deixa-a em cima da mesa da casa de jantar”. Um robô aéreo autónomo pode ter alocado a missão de

“fazer a vigilância de uma zona costeira, percorrendo-a ao longo de trajetórias paralelas” e um robô

futebolista pode “detetar a bola, aproximar-se dela e chutar para a baliza do adversário” [1].

Embora estas missões apresentem uma grande diversidade, todas são executadas, genericamente,

através de um ciclo composto por:

Perceção – Navegação – Atuação.

O robô, com o sistema de locomoção, motores e energia move-se num ambiente total ou

parcialmente conhecido ou mesmo desconhecido e que pode ser dinâmico (pode haver pessoas ou

outros objetos, p.e., robôs em movimento). Para o fazer de modo seguro, por exemplo, para detetar

obstáculos à sua frente, tem que adquirir, analisar e interpretar informação do ambiente

circundante. É a fase da Perceção que lhe dá conhecimento do mundo que o rodeia. A fase seguinte

é a Navegação. O robot localiza-se e, sabendo onde está e para onde deve ir, calcula como lá pode

chegar, ou seja define o caminho que deve seguir.

Para o seguir de modo correto e seguro, contornando obstáculos inesperados detetados na fase de

Perceção, é preciso controlar devidamente os motores. É a fase da Atuação. À medida que o robot se

desloca, o ambiente circundante vai sendo diferente pelo que, para o correto funcionamento do

robot, o ciclo Perceção – Navegação – Atuação está sempre em execução, tal como se indica no

diagrama de blocos da Figura 41[1].


IPT - 2015 – V3.2

Figura 41: Arquitetura funcional básica de um robô [1]

Principais técnicas navegação de robôs

Na robótica móvel existem dois tipos de navegação principais: a reativa e a deliberativa [2]. A navegação reativa tenta imitar o comportamento dos animais e seres humanos, na forma como estes reagem imediatamente aos estímulos do meio-ambiente. Por outro lado, a navegação deliberativa intercala o processo da tomada de decisão, desde a perceção até à ação, com etapas de planeamento. Geralmente, a fase de planeamento exige grande capacidade de processamento e memória (requer por exemplo a existência de mapas e outros modelos do ambiente), dificultando a atuação do robô em tempo real, quando essa capacidade de processamento e memória não existe. O robô em desenvolvimento apresenta uma capacidade de processamento e memória limitados (microcontrolador Arduíno uno 16MHz), sendo essa uma das principais razões por se optar por uma estratégia de navegação reativa. Uma outra razão fundamental está associada à simplicidade dos algoritmos de navegação, tornado a opção da navegação reativa claramente vantajosa para principiantes da robótica. As técnicas de navegação que se apresentam de seguida enquadram-se nas técnicas de navegação reativas.

Técnicas de seguimento de linha

Os algoritmos para seguimento de linha são bastante simples e consistem num conjunto de regras

básicas às quais o robô terá de obedecer para manter o seguimento da linha com sucesso. Tal como

explicado anteriormente, estas técnicas obedecem ao ciclo Perceção – Navegação – Atuação. A

perceção consiste na leitura de sensores de refletivos QRD1113 que, tal como explicado no capítulo

4, detetam linha branca sobre um fundo preto, ou uma linha preta sobre um fundo branco. A

navegação consiste em determinar, com base na leitura dos sensores, se o robô se está a desviar

para a esquerda ou para a direita da linha e, com base nesta informação, determinar novos

comandos de velocidade para os motores. A atuação consiste em executar os novos comandos de

velocidade determinados pela navegação. Em teoria é possível desenvolver um sistema de


IPT - 2015 – V3.2

seguimento de linha com apenas um sensor de deteção de linha, tal como ilustrado na Figura 42.

Porém, sugere-se que no mínimo sejam utilizados dois sensores de deteção de linha, de modo a

determinar mais facilmente se o robô se está a desviar para a esquerda ou para a direita da linha. A

existência de um maior número de sensores de deteção de linha poderá ajudar a obter uma

navegação mais robusta e eficaz.

EmissorRecetor

Figura 42: Seguimento de linha dependente dos sensores disponíveis


IPT - 2015 – V3.2

Técnicas para desvios de obstáculos

É possível encontrar descritas na literatura várias técnicas para desvios de obstáculos. Entre as técnicas reativas de desvio de obstáculos mais conhecidas destacam-se: o algoritmo bug [3,4], o algoritmo dos campos de potenciais [5] e o algoritmo VFH (“Vector field Histogram”) [6].

Algoritmo bug [3,4]

Esta técnica é uma das técnicas mais simples de desvio de obstáculos. Consiste em contornar completamente o obstáculo até encontrar o ponto com a menor distância ao obstáculo. Este algoritmo é bastante ineficiente, tendo surgido na literatura várias propostas de melhoria. Uma delas é o algoritmo bug2. Para este caso o robô também contorna o obstáculo, mas termina o contorno assim que intersetar o segmento de reta que une o ponto de partida e o ponto objetivo. A Figura 43 ilustra estas duas versões deste algoritmo.

Figura 43: Ilustração do algoritmo bug.

Campo de potenciais [5]

O algoritmo campo de potenciais assume que existem forças virtuais que atraem o robô para o ponto

objetivo e o afastam dos obstáculos. O caminho que o robô irá seguir é resultante da aplicação de

todas as forças virtuais. A Figura 44 ilustra este algoritmo.

Figura 44: Ilustração do algoritmo campo de potencial.


IPT - 2015 – V3.2

VFH [6]

O algoritmo VFH constrói, numa primeira fase, um histograma idêntico ao da Figura 45. Este

histograma é determinado com base na informação providenciada por sensores instalados no robô,

tais como um anel de sonares, um sensor laser, ou qualquer outro sistema que providencie um

varrimento das distâncias mínimas ao robô.

Figura 45: Ilustração do algoritmo VFH.

Com base no histograma é possível determinar as direções livres. O passo seguinte consiste em

escolher uma direção livre e comandar o robô nessa direção. A escolha da melhor direção depende

de vários fatores, tais como: direção mais próxima de um ponto objetivo, direção que causa menos

esforço de rotação ao robô, etc.

Técnica de desvio de obstáculos baseada num sonar acoplado a um servo

Tendo em conta as limitações de processamento e sensores que o robô possui, torna-se necessário encontrar um algoritmo simples e com um grau de robustez adequado. Uma vez que não é praticável instalar um anel com vários sonares à volta do robô, graças às limitações do microcontrolador e muito menos instalar um laser range finder, o qual requer uma capacidade de processamento muito elevada, torna-se necessário investigar qual o sistema de perceção mais adequado a este robô. Neste sentido propõe-se a utilização de um sonar acoplado a um servo. Esta solução permite realizar varrimentos entre [0º πº], por exemplo, com apenas um sensor. Basta para tal comandar o servo de modo a realizar sucessivamente esses varrimentos. A Figura 46 ilustra esta solução.


IPT - 2015 – V3.2

Figura 46: Exemplo de um robô com um sistema servo + sonar para deteção de obstáculos.

Um algoritmo muito simples consiste em definir três estados diferentes para o robô, designadamente: parado, andar em frente e virar. O estado parado indica que o robô não se encontra em movimento, andar em frente consiste no estado em que o robô segue o seu caminho sem obstáculos à frente e o estado virar, consiste em virar o robô sempre que ele encontra um obstáculo. O fluxograma seguinte ilustra este algoritmo simples:

Terminou o

programa?

A andar em

frente?

Obstáculo em

frente?

A virar?Terminou a

rotação?

Não faz nada

Para

Vira

Não faz nada

Anda em

frente

Não faz nada

sim

não

sim

não

sim sim

não

não

sim sim

não

Parado?

Figura 47: Exemplo de algoritmo para desvio de obstáculos.


IPT - 2015 – V3.2

Técnica dos comportamentos de Brooks (subsumption architecture)

A técnica dos comportamentos (designada na literatura anglo-saxónica por “subsumption

architecture”) foi proposta pelo professor Rodney Brooks do MIT [7], como uma alternativa válida ao

paradigma modelação/planeamento, o qual exige capacidade de processamento e memória. Esta

técnica providencia uma forma de combinar em tempo-real camadas de controlo distribuídas,

através da utilização de comportamentos espeloteados por determinados estados dos sensores. Ou

seja, para esta estratégia, os sensores são responsáveis por iniciar comportamentos pré-definidos

[8].

Os comportamentos não são mais do que camadas de controlo que funcionam em paralelo, sempre

que ativados pelos sensores que lhes estão associados. O problema central desta estratégia consiste

na fusão de comportamentos, ou seja, se dois comportamentos forem despoletados ao mesmo

tempo, o que é que o robô deverá fazer? A resposta a esta questão reside na realização de um

sistema de fusão comportamental que será responsável por resolver este tipo de conflitos. A título

de exemplo, suponha-se a existência de dois comportamentos: seguir linha branca sobre fundo preto

e desvio de obstáculos. Na eventualidade de surgir um obstáculo enquanto o robô segue a linha,

como é que este deverá proceder? Uma possibilidade será: contornar obstáculo até que este seja

ultrapassado e depois seguir novamente a linha. Este esquema de arbitragem com prioridades é uma

técnica de fusão comportamental que determina o comportamento dominante para um dado

cenário. A Figura 48 ilustra um exemplo de aplicação da estratégia de comportamentos.

Escapar

Desviar de

obstáculo

Seguir Linha

Vaguear

Bumper

Sonar

Sensor

refletivo

S

S

S Motores

Figura 48: Estratégia de comportamentos proposta Brooks [7].

Note-se que de acordo com esta estratégia, não existem comportamentos a chamar outros

comportamentos (como se fossem subrotinas). Pelo contrário, todos os comportamentos correm em

paralelo. Porém, os comportamentos de nível mais alto (na Figura 48 esse comportamento será o

Escapar quando um bumper é ativado) têm o poder de suprimir temporariamente os

comportamentos de nível mais baixo. Quando os comportamentos de nível mais elevado deixarem

de ser lançados pelos sensores associados, os de nível mais baixo entram em funcionamento.


IPT - 2015 – V3.2

Programa Arduino para seguimento de linha

O próximo passo consiste em fazer um programa para o microcontrolador Arduino que permita fazer

o seguimento de linha. Numa primeira fase, propõe-se fazer o seguimento de linha assumido que

não existirão obstáculos a impedir o percurso do robô. Assume-se ainda que o robô possui três

sensores de infra-vermelhos que permitem a deteção da linha branca sobre um fundo preto. Nesta

fase, caso existam dúvidas, deve consultar a secção de fotodeteção do Capítulo 4. Na secção seguinte

aborda-se um algoritmo de navegação possível.

Algoritmo de seguimento de linha

O algoritmo de seguimento de linha que se propõe de seguida tem por pressuposto a existência de

três sensores de fotodeteção de linha branca sobre fundo preto. Tal como sugerido anteriormente,

irá usar-se o fotodetor com referência QRD1113. O fluxograma apresentado na Figura 49 ilustra o

algoritmo proposto:

Leitura de

dados dos

sensores

Inicio

Sensor direito

deteta linha?

Curva suave para

a direitaSensor esquerdo

deteta linha?

Curva suave para

a esquerdaApenas sensor centro

deteta linha?

Movimento em

linha reta

Nenhum sensor deteta

linha e último estado

curva para direita

Curva

acentuada para

a direita

Nenhum sensor deteta

linha e último estado

curva para esquerda

Movimento em

marcha-atrás

Curva

acentuada para

a esquerda

sim não

sim não

sim não

sim não

sim não

Figura 49: Algoritmo possível para seguimento de linha com três sensores de fotodeteção.

Este algoritmo prevê seis situações distintas, designadamente:

1. Se apenas o sensor do meio deteta a linha branca, tal significa que o robô deve andar em

frente;


IPT - 2015 – V3.2

2. Quando o sensor da direita deteta a linha branca, significa que o robô se está a desviar para a

esquerda da linha e como tal deve compensar o movimento realizando uma curva suave para

a direita;

3. Quando é o sensor da esquerda que deteta a linha branca, está-se em presença da situação

oposta, ou seja, o robô está desviar-se para a direita da linha e como tal deve compensar o

movimento realizando uma curva suave para a esquerda;

4. Quando nenhum sensor deteta linha, avalia-se em primeiro lugar qual o último estado de

deteção de linha do robô. Se foi curva suave para a direita, significa que o robô

provavelmente não conseguiu compensar o movimento de forma adequada e por esse

motivo realiza-se agora uma curva acentuada para a direita;

5. Se nenhum sensor deteta linha e o último estado foi curva suave para a esquerda, realiza-se

uma curva acentuada para a esquerda, por razões análogas às do ponto 4.

6. Finalmente, se não se deteta linha e o robô estava a andar em frente, significa que ele saiu

de pista em frente e por isso é necessário fazê-lo recuar em marcha atrás para apanhar

novamente a linha.

Código do programa

Para realizar o programa em C para o Arduino é necessário relembrar em, primeiro lugar, algumas

funções essenciais.

O primeiro passo da realização do programa proposto consiste em definir as entradas e saídas do

sistema, definindo também os pinos de entrada e saída do Arduíno. Uma possível declaração de

variáveis para este programa é como se segue.

//Função para ler um valor de um sensor digital

int Value = digitalRead(s1);

//Função para ler um valor de um sensor analógico

int Value = analogRead(A0);

//Função para escrever a velocidade dos motores

analogWrite(int motor, int vel);

//Função para escrever a direção dos motores

digitalWrite(int motor, int dir);

//Declaração das variáveis associadas aos fotodetetores

int s1 = 2;

int s2 = 3;

int s3 = 4;

//Declaração das variáveis associadas ao motor A esquerdo

int mA1 = 10;

int mA2 = 11;

//Declaração das variáveis associadas ao motor B direito

int mB1 = 10;

int mB2 = 11;


IPT - 2015 – V3.2

De seguida procede-se à configuração das variáveis do programa como entradas ou saídas do

microcontrolador. Tal é realizado na função de configuração setup().

Na função loop(), que como o nome indica corre permanentemente em ciclo, irá programar-se o

algoritmo proposto.

void loop()

{

if(digitalRead(s2)==Linha)

{

//primeiro caso: CURVA DIREITA

filtroCurvaD++;

if(filtroCurvaD >= filtroN)

{

analogWrite(mA1,normalA);

digitalWrite(mA2,LOW);

//Declaração das variáveis das velocidades normais dos

//motores

int normalA = 255;

int normalB = 255;

//Declaração das variáveis das velocidades de correção dos //motores

int correcaoA = 220;

int correcaoB = 220;

int parado = 0;

//Declaração das variáveis auxiliares

int LINHA = LOW;

int FUNDO = HIGH;

//Variáveis que informam sobre o último estado da navegação

int RETA = 1;

int DIREITA = 2;

int ESQUERDA = 3;

int ultimoEstado = RETA; //inicialização da varável último //estado

void setup() {

//Serial.begin(9600);

pinMode(s1, INPUT);

pinMode(s2, INPUT);

pinMode(s3, INPUT);

pinMode(mA1, OUTPUT);

pinMode(mA2, OUTPUT);

pinMode(mB1, OUTPUT);

pinMode(mB2, OUTPUT);

}


IPT - 2015 – V3.2

analogWrite(mB1,correcaoB);

digitalWrite(mB2,LOW);

filtroCurvaD = 0;

ultimoEstado = DIREITA;

}

}

else if(digitalRead(s1)==Linha)

{

//segundo caso: CURVA ESQUERDA

filtroCurvaE++;

if(filtroCurvaE >= filtroN)

{

analogWrite(mA1,correcaoA);


analogWrite(mB1,normalB);


filtroCurvaD = 0;

ultimoEstado = ESQUERDA;

}

}

else if(digitalRead(s3)==Linha && digitalRead(s2)==Fundo &&

digitalRead(s1)==Fundo)

{

//terceiro caso: LINHA RETA

filtroReta++;

if(filtroReta >= filtroN)

{

analogWrite(mA1,normalA);


analogWrite(mB1,normalB);


filtroReta = 0;

ultimoEstado = RETA;

}

}

else if(digitalRead(s3)==Fundo && digitalRead(s2)==Fundo &&

digitalRead(s1)==Fundo)

{

// caso: LINHA DESAPARECEU

filtroNADA++;

if(filtroNADA >= filtroN)

{

if(ultimoEstado == DIREITA)

{



analogWrite(mB1,LOW);


}

else if(ultimoEstado == ESQUERDA)

{

analogWrite(mA1,LOW);




IPT - 2015 – V3.2


}

else if(ultimoEstado == RETA)

{





}

filtroNada = 0;

}

}

Note-se a utilização de variáveis filtro no algoritmo anterior, designadamente: filtroCurvaD,

filtroCurvaE, filtroReta, filtroNada e filtroN. Estas variáves servem para dar mais suavidade ao

movimento, uma vez que estes só permitem uma determinada ação se a condição dos sensores se

mantiver em cinco leituras seguidas (valor de filtroN).

Programa Arduino para desvio de obstáculos

O próximo passo consiste em fazer um programa para o microcontrolador Arduíno que permita fazer

o desvio de obstáculos. Assume-se que o robô possui um sistema de deteção de obstáculos que

consiste num servo com um sonar. Nesta fase, caso existam dúvidas, deve consultar a secção de

medição de distâncias com um sonar ou com um IR do Capítulo 5. Na secção seguinte aborda-se um

algoritmo possível de desvios de obstáculos.

Algoritmo de desvio de obstáculos

O algoritmo de desvio de obstáculos proposto baseia-se na ideia de que o robô deve-se desviar dos

obstáculos mantendo-se em movimento, devendo apenas parar em situações de colisão eminente. O

fluxograma apresentado na Figura 47 ilustra o algoritmo proposto. São executados varrimentos do

espaço em frente ao robô, utilizando o sensor associado ao sistema servo, enquanto o robô se move.

Desta forma pretende-se que o robô seja capaz de evitar os obstáculos com pequenas correções do

movimento.

Código do programa

O primeiro passo da realização do programa proposto consiste em definir as entradas e saídas do

sistema, definindo também os pinos de entrada e saída do Arduino. Uma possível declaração de

variáveis para este programa é como se segue.

#include <Servo.h>

//a biblioteca Servo.h encontra-

se descrita em http://arduino.cc/en/reference/servo


IPT - 2015 – V3.2

//declarar Servos

//Notar que estas declarações são apenas exemplos

Servo servoEsquerda; //motor roda esquerda

Servo servoDireita; //motor roda direita

Servo servoVarrimento;// sensor servo

const int pinoDist = 7; //Pino associado ao sensor do servo.

const int pinoEsquerda = 9; //pino para o servo da esquerda

const int pinoDireita = 10; // pino para o servo da direita

const int pinoVarrimento = 6; // pino para o servo de //varrimento

const int limiteDistancia = 20; //se o obstáculo se encontrar a esta

//distância ou inferior, o robô faz qualquer coisa //para evitar obstáculo

int tempoVarrimento = 0;

int ultimoTempoVarrimento = 0;

char sensorPosicao = 'L';

long tempoAnterior = 0;

long tempodesdeviragemEsquerda = 0;

long tempodesdeviragemDireita = 0;

De seguida apresenta-se a função de configuração setup() que é apenas corrida uma vez sempre que

o código é executado.

void setup()

{

servoEsquerda.attach(pinoEsquerda); //Associa o servo //esquerdo ao pino.

servoDireita.attach(pinoDireita); // Associa o servo direito //ao pino.

servoVarrimento.attach(pinoVarrimento); // Associa o servo //varrimento ao

pino.

Serial.begin(9600);

delay(2000); // espera dois segundos

}

void loop()

{

int distanciaEsquerda = 90;

int distanciaDireita = 90;

linefollowing();// Se tudo estiver bem segue a linha

if(millis()>tempoAnterior+300)

{

if(sensorPosicao == 'L')

{

distanciaEsquerda = distancia();

Sensorposicao = 'R';//Para saber o último lado do servo

}

else

{

distanciaDireita = distancia();

Sensorposicao = 'L';//Para saber o último lado do servo

}

tempoAnterior = millis();//mills()função que devolve o

// tempo decorrido desde que o robô foi ligado

}

switch (sensorPosicao)

{

case 'L': // se o servo estiver na esquerda


IPT - 2015 – V3.2

servoVarrimento.write(70); // move-se para a direita

break;

case 'R': // se o servo estiver na direita

servoVarrimento.write(110); // move-se para a esquerda

break;

}

if(distanciaEsquerda < limiteDistancia)//se obstáculo à //esquerda {

if (millis() < tempodesdeviragemEsquerda + 500)//se não //houver tempo

de //virar de imediato, recua primeiro

{

recua(500);

virarDireita(120);

} else//senão vira logo

{

virarDireita(25);

}

tempodesdeviragemdireita = millis();

}

if(distanciaDireita < limiteDistancia)

{

if(millis() < tempodesdeviragemdireita + 500)

{

recua(500);

virarEsquerda(120);

}

else{

virarEsquerda(25);

}

tempodesdeviragemEsquerda = millis();

}

}

De seguida apresenta-se a função de leitura do sensor de distância int ping(), neste exemplo considerou-se um sonar. Esta função devolve a distância aos obstáculos em cm.

//Função definida para sensor sonar associado a um servo

int distancia()

{

long duracao, distancia;

//enviar Pulso

pinMode(pinoDist, OUTPUT);

digitalWrite(pinoDist, LOW);


digitalWrite(pinoDist, HIGH);


digitalWrite(pinoDist, LOW);

//Ler eco

pinMode(pinoDist, INPUT);

duracao = pulseIn(pinoDist, HIGH);

// converter tempo para distancia

distancia = microsegundosparacms(duracao);

Serial.print("Distancia: ");


IPT - 2015 – V3.2

Serial.println(distancia);

return round(distancia);

}

De seguida apresenta-se um exemplo de uma função de movimento, designadamente da função virarDireita(float t) e a função que converte tempo em microssegundos para distância em cms, long microsegundosparacms(long microseconds).

//Função para virar à direita

void virarDireita(float t)

{

servoEsquerda.write(30);

servoDireita.write(30);

t=(t/120)*1000;

Serial.print("viragem à direita durante: ");

Serial.println(t);

delay(t);

}

//Função para converter miscrosegundos para centímetros

long microsegundosparacms(long microseconds)

{

return microseconds / 29 / 2;

}

Referências

[1] – Maria Isabel Ribeiro. “Uma viagem ao mundo dos robôs.” Relatório Técnico IST, Junho, 2006. [2] – R. Murphy. “Introduction to AI Robotics.” The Massachusetts Institute of Technology Press, 2000. [3] – V. Lumelsky, A. Stepanov. “Path-Planning Strategies for a Point Mobile Automaton Moving Amidst Unknown Obstacles of Arbitrary Shape.” in Autonomous Robot Vehicles. New York, Spinger- Verlag, 1990. [4] – I. Kamon, E. Rivlin, E. Rimon. “A New Range-Sensor Based Globally Convergent Navigation Algorithm for Mobile Robots,” in Proceedings of the IEEE International Conference on Robotics and Automation, Minneapolis, April 1996. [5] – O. Khatib. "Real-Time Obstacle Avoidance for Manipulators and Mobile Robots." 1985 IEEE International Conference on Robotics and Automation, March 25-28, St. Louis, pp: 500-505. [6] - J. Borenstein, Y. Koren. “The Vector Field Histogram – Fast Obstacle Avoidance for Mobile Robots.” IEEE Journal of Robotics and Automation, 7, pp: 278–288, 1991. [7] - R. A Brooks (1991). "Intelligence Without Representation", Artificial Intelligence 47 (1991) 139-159. [8] - Joseph L. Jones, Anita M. Flynn. “Mobile robots: inspiration to implementation” Cambridge Publication. A. K. Peters, Ltd. Natick, MA, USA ©1993 ISBN:1-56881-011-3.


IPT - 2015 – V3.2

Capítulo 6 – Competição: Regras e

Especificações Técnicas

Paulo Coelho, Ana Lopes e Gabriel Pires

Introdução

Nesta competição procura-se recriar problemas inspirados nos desafios que um robô autónomo terá de enfrentar durante a sua utilização em diversos ambientes, como por exemplo numa fábrica. Os robôs deverão apresentar um mínimo de capacidades que incluem localizar‐se e navegar no ambiente fornecido, assim como evitar choques com paredes, obstáculos e outros robôs. Toda as dimensões indicadas neste documento, salvo indicação em contrário, assumem uma tolerância de +/- 5%.

Definições

Dependendo do número de participantes, uma prova poderá ser uma única corrida ou um conjunto de eliminatórias. Uma corrida é também denominada de eliminatória.

Uma pista é um circuito fechado demarcado por uma linha.

Os Robôs

Os robôs deverão ser autónomos e não deverão ter fios elétricos a ligá-los a nenhum elemento externo, logo não podendo estabelecer nenhum tipo de comunicação com um sistema externo que não seja o explicitamente fornecido ou autorizado pela organização. Os robôs poderão ser ativados por humanos, manualmente ou através de um controlo remoto. - Cada robô participante deve ter um nome, fornecido aquando da inscrição;

Dimensões

Cada robô deve caber num retângulo com 35 x 30 cm não existindo restrições relativamente à altura.


IPT - 2015 – V3.2

A pista

O Sistema de Localização

No chão estarão presentes linhas brancas que permitirão um seguimento das mesmas por parte dos robôs. No entanto a sua configuração será de modo a que as equipas que utilizem sistemas de localização/programação próprios possam retirar vantagens dos mesmos.

Piso da Pista

A superfície da pista será preta, feita com diversos materiais possíveis, portanto eventuais emendas de placas serão necessárias para compor toda a área do percurso, para tal possíveis desníveis poderão ocorrer, a organização tentará minimizá-los da melhor maneira possível adicionando fita preta em todas as emendas. De qualquer forma os robôs devem ser capazes de superar tais desníveis (± 1mm) sem perder a linha guia.

Nota: As cores da linha e da pista estão sujeitas a possíveis variações, dependendo do fornecedor e dos materiais utilizados no fabrico dos mesmos, porém existe um grande contraste entre o branco da linha e o preto da pista.

Linhas

A linha será demarcada com fita branca de 50 mm (ou inferior) de largura. O comprimento total da linha será no máximo 60m. A linha é a indicação do caminho que o robô deve seguir (PISTA). A linha consistirá em combinações de retas e arcos. O raio de curvatura mínimo será R=100mm. Cada arco terá também um comprimento mínimo de 100mm. A linha poderá cruzar sobre ela mesmo. Quando houver um cruzamento, o ângulo de intersecção das linhas será de 90±5°. As partes das linhas 250mm antes e 250mm depois do cruzamento serão retas.

Extras do Percurso

Poderá haver na pista os seguintes itens: rampa, ponte, túnel e guarda rail. A inclinação máxima da rampa será de 50%, a altura mínima do túnel será 220mm. Os robôs devem ser capazes de transpor esses obstáculos. Obs.: o cálculo da inclinação de uma rampa é feito com a seguinte equação:

% 100Altura do desnível

inclinaçãoComprimento horizontal

A área que se estende entre o ponto de partida e o ponto de chegada, considerando 200mm à direita da linha limite e 200mm à esquerda da linha limite é denominada "área de partida chegada" (ver Figura 50 - A área que se estende entre o ponto de partida e o ponto de chegada.).


IPT - 2015 – V3.2

Figura 50 - A área que se estende entre o ponto de partida e o ponto de chegada.

A linha de partida e a linha de chegada serão localizadas numa reta do percurso (pista). A linha de chegada será localizada a um metro para trás da linha de partida. Haverá marcações no lado direito da linha (em relação ao sentido do percurso), indicando o ponto de partida e o ponto de chegada (ver figura anterior). A linha, 250mm antes e 250mm depois da "área de partida-chegada", será reta.

Iluminação

O ambiente da competição terá iluminação artificial, não será garantido, no entanto, nível de luz constante nem ausência de sombra, portanto os robôs devem ser capazes de se adaptar às condições de luz.

Campo eletromagnético, vento e outras influências

A organização não garante a ausência de campo eletromagnético, de poeira nem de qualquer outra pequena influência externa à pista. Recomenda-se que os robôs sejam imunes a essas influências.

Competição

A competição está dividida em duas provas, realizadas num único dia. As provas são: - Seguimento de Linha; - Desvio de Obstáculos;

Cada uma das provas terá regras específicas, que serão apresentadas ao longo deste regulamento. No entanto, convém desde já advertir que, durante a competição em cada tentativa de prova a classificação será o tempo da prova mais as penalizações adicionais.

Tempos de penalização: Cada choque do robô contra qualquer obstáculo, parede, etc., será penalizado com 4 segundos.

Área Partida - Chegada

Sentido

Marcação

“Chegada”Marcação

“Partida”

1 m

400 mm


IPT - 2015 – V3.2

Resolução de problemas com o robô durante a prova

Se em qualquer momento o responsável pela equipa considerar que o robô se encontra numa situação da qual não espera ser capaz de recuperar, poderá pedir para interromper a prova e aceder ao robô. Esta ação pode ser efetuada até quatro vezes durante uma manga/prova. Durante a intervenção sobre o robô o tempo não pára.

Vistoria técnica

Antes do início da competição todos os robôs serão vistoriados, isso também poderá ocorrer a qualquer momento durante a competição, se a organização considerar necessário. Se o robô não estiver de acordo com qualquer dos itens constantes deste regulamento, o robô será desclassificado da manga/prova. Os robôs serão verificados quanto à presença de equipamentos de comunicação tais como Bluetooth™, RF e Wi-Fi™, também quanto à presença de partes móveis que prejudiquem a contagem de tempo e de peças soltas que possam vir a prejudicar o bom andamento da prova. Não será permitida a participação de robôs não conformes, mas a equipa terá sempre tempo de fazer os ajustes para a próxima manga.

Parque fechado

Uma hora antes do início de cada manga os robôs deverão ser colocados no parque fechado, deixando as equipas de ter acesso ao robô até cerca de 10 minutos antes do início da respetiva prova. Nessa altura, que será sinalizada pelos árbitros/Júri, a equipa poderá preparar o robô para iniciar a sua prova.

Classificação final

A classificação final será obtida somando as classificações nas duas provas. A pontuação para efeito de classificação final das equipas será calculada com a seguinte equação:

0.5 0.5

SG pontuação seguimento linha

DO pontuação desvio de obstacúlos

pontuação final SG DO


IPT - 2015 – V3.2

Júri, Árbitros e Relógio de contagem do tempo

Júri

O júri é a autoridade máxima na interpretação e aplicação das regras, e em qualquer deliberação relacionada com situações não previstas nas regras. A sua missão será verificar se os robôs estão de acordo com as regras, durante a verificação técnica e apoiar o árbitro durante a competição.

Através da sua autoridade o júri assegurará justiça na aplicação das regras e regulamentos.

As decisões do júri são finais e sem recurso. O júri é nomeado pela organização. (Cada prova terá 1 ou 2 juízes que irão coordenar e avaliar a prova executada pelo robô de cada equipa).

Árbitro

O árbitro assegura a correta aplicação das regras da competição e autoriza, se necessário, os membros das equipas a entrarem dentro da área de competição para eventuais testes no início da prova. O árbitro pode interromper os testes sempre que necessário para consultar e dialogar com o júri.

Em relação a situações não previstas pelas regras o árbitro deve, em todos os casos, consultar o júri. O árbitro é nomeado pela organização. (Cada prova terá 1 ou 2 árbitros que irão acompanhar e avaliar a prova executada pelo robô de cada equipa).

Relógio de contagem do tempo

O relógio de contagem do tempo é integrado no sistema de controlo da prova. Este sistema inclui dois relógios independentes: um totalizador de tempo que conta o tempo total gasto durante a prova toda (testes e tentativas) e outro que conta o tempo de cada tentativa.

Reunião de abertura

Será obrigatório o comparecimento de pelo menos um representante de cada equipa na Reunião de Abertura da Competição. O local e horário desta reunião será divulgado com antecedência pela organização. A ausência do representante irá acarretar em penalização para a equipa.

Conduta e Segurança

Durante o evento não será permitido o consumo de bebidas alcoólicas nem por parte dos competidores nem dos espectadores. Evidências de consumo ou posse de bebidas alcoólicas ou de substâncias ilegais ou controladas, em qualquer momento da competição, implicarão a desclassificação imediata, sem direito a reclamações.

Para evitar situações perigosas são proibidas todas as substâncias que possam por em risco as pessoas ou o material, tais como explosões, fumo, chamas, alta tensão, uso de água ou outras.


IPT - 2015 – V3.2

Regras Específicas das Várias Provas

Regulamento da Prova de Seguimento de Linha

Descrição da prova

A prova terá início após o sinal dado por um elemento da organização que irá ordenar a chamada e a apresentação de cada uma das equipas. Todas as equipas deverão estar prontas para participar 10 min antes do início da prova. As equipas serão chamadas pela ordem de inscrição. A não comparência de uma equipa aquando da chamada implica a sua imediata desqualificação. Duas equipas podem trocar de lugar na prova, desde que cheguem a acordo e informem antecipadamente o júri (até 15min antes do início previsto da prova).

Só é permitida a presença de um elemento de cada equipa por cada prova.

O objetivo da prova é fazer com que o robô siga um trajeto determinado por uma linha. Vence o robô que finalizar o trajeto em menor tempo. O robô mais veloz e que não cometer erros deverá vencer esta prova.

Regras da prova

O robô deverá percorrer o circuito tomando como referência a linha branca. O corpo do robô deverá sempre ficar sobre a linha. Caso o robô saia completamente de cima da linha branca, será considerado que o robô saiu do percurso e será desclassificado da manga. Considera-se “perder a linha” quando o robô sair completamente da sua linha. Um robô perde a linha quando esta não se encontra por baixo da estrutura do mesmo. Se a linha sair do alcance do sensor de linha, um robô pode sempre tentar encontrá-la novamente desde que a linha esteja debaixo da sua estrutura.

As duas imagens da Figura 51 exemplificam situações em que o robô não perdeu a linha e ainda contínua em prova.

Figura 51 - O robô ainda continua em prova.

As duas imagens da Figura 52 exemplificam situações em que o robô perdeu a linha está desclassificado.


IPT - 2015 – V3.2

Figura 52 - O robô está desclassificado.

Para cada robô serão concedidas 2 tentativas de 4 minutos para percorrer a pista. Assim, Cada robô terá tempo limite de 4 minutos para percorrer a pista, excedido esse tempo o robô será retirado para dar oportunidade ao próximo.

O robô deverá iniciar a prova na marcação de partida e percorrer o circuito na direção correta. Entretanto poderá percorrer o circuito inúmeras vezes sem interrupção enquanto ainda estiver dentro prazo estipulado dos 4 minutos.

Será considerado o menor tempo entre todas as tentativas.

Após terminar uma volta, o operador (programador) não poderá "fornecer" informações ao robô sobre o trajeto e não poderá incluir, rever ou alterar informações deste tipo durante a competição.

Após iniciada a partida, não será permitido tocar no robô sem a autorização do juiz.

O juiz poderá solicitar informações sobre o robô as quais jugar necessárias. O Juiz tem o poder de desclassificar um robô e/ou tomar qualquer decisão que ache pertinente durante a competição.

A organização pode se assim o entender acrescentar as seguintes regras a esta prova, de modo a aumentar a dificuldade da mesma:

O robô deverá parar, automaticamente, dentro da "área de partida-chegada" e permanecer parado pelo menos 2 segundos após completar uma volta.

O tempo da volta será medido entre a hora que o sensor na linha de partida do circuito detetar o robô, e a hora em que o sensor da linha de chegada do circuito detetar o mesmo robô. Entretanto o tempo não será considerado enquanto o robô não passar completamente pela linha de chegada.

Uma volta será considerada válida quando o robô terminar o percurso e permanecer pelo menos 2 segundos parado na "área de partida-chegada", e será cancelada quando o robô sair do percurso.

_________________ _________________


IPT - 2015 – V3.2

Regulamento da Prova de Desvio de Obstáculos

Descrição da prova

A prova terá início após o sinal dado por um elemento da organização que irá ordenar a chamada e a apresentação de cada uma das equipas. Todas as equipas deverão estar prontas para participar 10 min antes do início da prova. As equipas serão chamadas pela ordem de inscrição. A não comparência de uma equipa aquando da chamada implica a sua imediata desqualificação. Duas equipas podem trocar de lugar na prova, desde que cheguem a acordo e informem antecipadamente o júri (até 15min antes do início previsto da prova).

Só é permitida a presença de um elemento de cada equipa por cada prova.

O objetivo da prova é fazer com que o robô percorra o caminho da pista o mais rapidamente possível e sem colidir com os obstáculos (paredes, etc.), desviando-se dos mesmos. Cada colisão tem uma penalização de 4s.

A Figura 53 ilustra um exemplo de uma configuração possível.

Figura 53 - Configuração possível para prova de desvios de obstáculos.

A pontuação é dada pelo menor tempo de percurso completo ou maior percurso percorrido até ao limite de tempo da prova.

Cada prova terá um tempo limite de 5 min. Cada equipa dispõe de 2 tentativas. Será registado o melhor resultado das duas tentativas.

No final da prova de obstáculos, e em caso de igualdade pontual entre duas ou mais equipas nos primeiros lugares, o júri poderá requerer a repetição da prova pelas equipas envolvidas.

As regras seguintes devem ser lidas e respeitadas, para que a prova decorra em conformidade com o estabelecido e de acordo com as normas de segurança.

Regras da prova

A pista poderá ter um formato variável com um máximo de 60 metros de longitude. A pista é de cor preta, tem 5 m de largura e poderá estar limitada por paredes de cor branca com 20cm a 30cm de


IPT - 2015 – V3.2

altura. No piso da pista existe uma linha branca com 5 cm de espessura máxima, que poderá servir de guia para quem tiver sensor de linha (note-se que poderá existir partes do percurso sem linha).

Nenhum elemento da equipa pode tocar no robô durante a prova, a menos que devidamente autorizado pelos juízes.

Duração da prova Cada prova terá um tempo limite de 5 min. Cada equipa dispõe de 2 tentativas. Será registado o melhor resultado das duas tentativas.

Cada colisão tem uma penalização de 4s.

O júri pode interromper a prova a qualquer altura, se a situação o justificar.

_________________ _________________

Um sorteio ditará ordem de participação nas provas dos grupos/robôs participantes. A equipa vencedora será aquela que obtiver maior pontuação nas duas provas.

_________________ _________________

NOTA: Qualquer situação omissa neste regulamento será avaliada e decidida soberanamente pelo júri e sem direito a recurso.


IPT - 2015 – V3.2

ANEXOS:

1) PISTA

Figura 54 – Pista.

2500,00

5000,00

70

00

,00

35

00

,00


IPT - 2015 – V3.2

2) MEDIDAS DA PISTA

Figura 55 - Medidas da Pista.

2500,00

5000,00

70

00

,00

35

00

,00

22

23,3

3

55

83

,91

90

0,0

0

1900,00

2300,00

500,00

1120,00

257,00

608,28

R 350,00

R 350,00

R 320,00

R 500,00

R 275,00

R 650,00

R 160,00

R 440,00

R 700,00

R 290,00

R 350,00


IPT - 2015 – V3.2

Anexos


IPT - 2015 – V3.2

Esquema de Alimentação

Pedro Neves


IPT - 2015 – V3.2

Esquema de ligação da alimentação

Figura 56 - Esquema de ligação da alimentação


IPT - 2015 – V3.2

Esquema de ligação da alimentação ao Drive Potência

Figura 57 - Esquema de ligação da alimentação ao Drive Potência


IPT - 2015 – V3.2

Shield de sensores do GreenT

Pedro Neves

O shield de sensores do GreenT

O robô GreenT para navegar no meio envolvente necessita de diversos sensores que lhe transmitam

informações sobre este. Para tal o GreenT foi equipado com um shield que faz a interligação entre

todos os seus sensores e a placa controladora – Arduino Mega.

A Figura 58 mostra o shield com a legendagem dos seus conectores.

Figura 58- Shield de sensores do GreenT

Descrição do pinout dos conectores dos sensores e sua cablagem:

Conector Tipo Pinos

Conector Ligação Condutor

Pino

Arduíno

Servo Motor

1 VCC Vermelho -

2 GND Preto -

3 Input (Digital) Laranja 11

Conector LCD

Pinos Digitais

Pinos Analógicos

Sonar

Servo

Motor

Sensor IR

Sensores

Linha

Bumpers

Encoders

Controlo Motor

Pinos Digitais

Pinos Digitais


IPT - 2015 – V3.2

Sensor IR

1 VCC Vermelho -

2 GND Preto -

3 Output (Analógica) Amarelo/Branco A0

Sensores Linha

1 Coletor (5V-1k) Amarelo

Esquerda - A1/26

Direta - A2/28

Centro - A3/42

2 Ânodo (5V-220R) Azul -

3 GND Branco -

Sonar

1 Vcc Vermelho -

2 GND Azul -

3 GND Preto -

4 N/C - -

5 Output (Digital) Amarelo 7

Encoders

1 Vcc Azul -

2 GND Verde -

3 N/C - -

4 Output A (Digital) Branco Esquerda – 2

Direita - 3

5 Output B (Digital) Amarelo Esquerda – 4

Direita - 5

Controlo Motores

1 Pino M (PWM) Amarelo Esquerda – 9 Direita - 10

2 Pino E (Digital) Branco Esquerda – 30

Direita - 32

Bumpers

1 5V Vermelho -

2 Input (Digital) Amarelo Esquerda – 40

Direita - 38

O shield, para além dos conectores dedicados para a ligação de sensores, possui ainda pinos para

conexão de dispositivos adicionais. Estão disponíveis pinos digitais e pinos analógicos.

Os pinos de conexão adicional são compostos pela ligação ao microcontrolador e a cada um destes

está associada um pino de 5V e outro de GND, de acordo com o inscrito no shield. Existe ainda

disponível um conector dedicado para ligação de um LCD, para o qual é necessário colocar o divisor

resistivo, para o contraste (Vo), adequado ao LCD em utilização.


IPT - 2015 – V3.2

Conector Tipo Pinos

Conector Ligação Descrição

Pino

Arduíno

Pinos de

conexão

adicional

1 GND - -

2 5V - -

3 Pino Micro Pino Analógico ou

Digital -

LCD

1 5V -

2 GND -

3 Vo Contraste LCD1 -

4 RS Register Select 33

5 R/W Read/Write GND

6 E Enable 35

7 D4 Pino dados 37

8 D5 Pino dados 39

9 D6 Pino dados 41

10 D7 Pino dados 43

Figura 59 - Shield de sendores do GreenT - PCB

1 É necessário colocar o divisor resistivo, para o contraste (V0), adequado ao LCD em utilização.


IPT - 2015 – V3.2

Figura 60 - Shield de sensores do GreenT – PCB: vista superior (TOP).

Figura 61 - Shield de sensores do GreenT – PCB: vista inferior (BOTTOM).


IPT - 2015 – V3.2

GreenT Manual de Formação

“Escolher Robótica, Escolher Ciência!”

Workshop de Robótica Móvel

Ana Lopes * Carlos Ferreira * Gabriel Pires * Paulo Coelho * Pedro Correia * Pedro Neves

Fevereiro de 2015

Instituto Politécnico de Tomar

www.ipt.pt

Documents

Manual Workshop GreenT Final v3.2