mono graf i alessandro teixeira
TRANSCRIPT
CENTRO UNIVERSITÁRIO FEEVALE
LESSANDRO CABRAL TEIXEIRA
PROTÓTIPO DE UM ROBÔ DE COMBATE NA MODALIDADE SUMÔ DE ROBÔ
Novo Hamburgo, dezembro de 2009.
2
LESSANDRO CABRAL TEIXEIRA
PROTÓTIPO DE UM ROBÔ DE COMBATE NA MODALIDADE SUMÔ DE ROBÔ
Centro Universitário FEEVALE ICET - Instituto de Ciências Exatas e Tecnólogicas
Bacharelado em Engenharia Eletrônica Trabalho de Conclusão
Professor Orientador: MS. Delfim Luiz Torok
Novo Hamburgo, dezembro de 2009.
3
4
Dedico a minha noiva, que nestes últimos oito anos tem
enfrentado todos os desafios ao meu lado.
5
AGRADECIMENTO
Tudo na vida passa, se transforma e se modifica. São pessoas que convivemos
durante algumas etapas e que depois nunca mais encontramos, assim como tecnologias que se
tornam obsoletas, mas o conhecimento adquirido e as experiências vividas, levamos para o
resto da vida. Por isso eu agradeço a Deus pelas oportunidades recebidas, por aquelas que
aproveitei ou deixei de lado por minha livre escolha.
Agradeço a minha família, que desde muito cedo tem me incentivado a estudar,
levando isso como uma prioridade de vida. A todos aqueles meus professores da Feevale, meu
orientador deste trabalho e a todos os meus colegas, que principalmente neste último semestre
tem me ajudado bastante, com componentes, idéias e sugestões mirabolantes, que mesmo não
sendo as melhores eram muito divertidas. Não cito aqui nomes para não cometer nenhuma
injustiça em esquecer alguém.
Também agradeço pela força, incentivo e carinho da minha noiva, que se Deus quiser
se tornará esposa após a conclusão deste curso, a qual dedico esse trabalho.
6
RESUMO
O presente trabalho apresenta o desenvolvimento de um protótipo de um robô de
combate, na modalidade sumô de robôs. Relatando pesquisas efetuadas em competições de
robôs, como materiais, tecnologias e técnicas utilizadas pelos competidores. Empregando
materiais encontrados no mercado para o desenvolvimento de toda a mecânica necessária de
acordo com as regras das competições, assim como também a parte eletrônica essencial para
que o robô possa encontrar o adversário na arena, empurrá-lo para fora e permanecer dentro
da mesma. Desenvolvendo então um robô em forma de carro, com o tracionamento nas 4
rodas ao estilo tanque de guerra, movimentado por dois motores de corrente contínua
controlados na sua velocidade com modulação por largura de pulso e na sua direção através
de uma ponte H. Sensores sonar são utilizados para que o robô possa encontrar obstáculos na
sua frente como o adversário, sensores reflexivos para que seja capaz de identificar a borda da
arena e um sensor de luz para identificar o sinal de início da disputa. Todos os sensores e
recursos empregados, como por exemplo, o controle de carga e carregador de bateria, são
controlados por dois microcontroladores da família dsPIC, comunicando-se de forma serial.
Com isso desenvolve-se tecnologia e recursos para que a Feevale possa ser representada em
futuros desafios de robôs em outras instituições de ensino.
Palavras Chaves: Robô, Sensor, Microcontrolador.
7
ABSTRACT
This paper presents the development of a prototype of a combat robot, the sumo
mode robot. Reporting research carried out in competitions of robots, such as materials,
technologies and techniques used by competitors. Using materials found in the market for the
development of all the mechanics necessary in accordance with the rules of competitions, as
well as the electronics essential for the robot can find an opponent in the arena, pushing it out
and stay within it. Then developing a robot-shaped car, with 4-wheel-style traction like a tank,
moved by two DC motors controlled by pulse width modulation and guidance by a H bridge.
Sonar sensors are used for the robot may encounter obstacles in front of him as an opponent,
reflective sensors to be able to identify the edge arena’s and a light sensor to identify the
command to begin the race. All sensors and the resources used, for example, the battery
charger control. This is controlled by two dsPIC microcontrollers, communicating serially.
With this technology and resources Feevale can be represented in future challenges of robots
in other educational institutions.
Keywords: Robot, Sensor, Microcontroller.
8
LISTA DE FIGURAS
Figura 1.1 – Medidas da Arena. ...............................................................................................20 Figura 1.2 – Motores DC..........................................................................................................24 Figura 1.3 – Motor de Vidro Elétrico. ......................................................................................25 Figura 1.4 – Tracionamento por Esteira. ..................................................................................28 Figura 1.5 – Tracionamento Direto. .........................................................................................29 Figura 1.6 – Coroa e Pinhão. ....................................................................................................31 Figura 1.7 – Pinagem sensor sonar...........................................................................................33 Figura 1.8 – Sensor Reflexivo. .................................................................................................36 Figura 1.9 – Exemplo de aplicação do PWM...........................................................................45 Figura 1.10 – Esquema Ponte H. ..............................................................................................47 Figura 1.11 – Bloco Diagrama microcontrolador dsPIC..........................................................49 Figura 1.12 – Pinagem dsPIC30F3013.....................................................................................53 Figura 1.13 – Definição do Tad para conversor AD. ...............................................................59 Figura 1.14 – Área de trabalho MPLAB. .................................................................................65 Figura 1.15 – Ferramenta de Gravação ICD2...........................................................................69 Figura 2.1 – Motor Utilizado....................................................................................................74 Figura 2.2 – Engrenagem do Motor..........................................................................................76 Figura 2.3 – Engrenagem da Roda. ..........................................................................................77 Figura 2.4 – Roda de PU. .........................................................................................................79 Figura 2.5 – Vista lateral, superior, frontal e em perspectiva...................................................81 Figura 2.6 – Bateria Utilizada...................................................................................................82 Figura 2.7 – Furação Lateral.....................................................................................................83 Figura 2.8 – Polia. ....................................................................................................................84 Figura 2.9 – Pára-choque, vista em perspectiva. ......................................................................85 Figura 2.10 – Controle Motores DC.........................................................................................88 Figura 2.11 – Comparador de tensão dos sensores de borda....................................................91 Figura 2.12 – Conversão da saída do CA3140 para nível TTL...............................................92 Figura 2.13 – Comparador de tensão para inicio da disputa. ...................................................93 Figura 2.14 – Carregador de Bateria. .......................................................................................95 Figura 2.15 – Placa Principal....................................................................................................97 Figura 2.16 – Conexões placa principal e protótipo.................................................................98 Figura 2.17 – Interior do Protótipo...........................................................................................99 Figura 2.18 – Sensor de inicio da partida. ..............................................................................100 Figura 2.19 – Montagem Completa........................................................................................101 Figura 2.20 – Identificação da função dos LEDs. ..................................................................102
9
Figura 3.1 – Placa de Suporte dos Microcontroladores..........................................................104 Figura 3.2 – Fluxograma das Operações de Controle e Combate. .........................................115 Figura 4.1 – Pesagem do protótipo.........................................................................................126 Figura 4.2 – Carga Completa indicada pelo multímetro. .......................................................129
10
LISTA DE GRÁFICOS
Gráfico 1.1 – Auto Descarga Bateria Chumbo Ácida. .............................................................39 Gráfico 1.2 – Capacidade Remanescente da Bateria................................................................40 Gráfico 1.3 – Curva de carga para tensão constante e corrente limitada..................................44
11
LISTA DE TABELAS
Tabela 1 – Parâmetros Sensor Reflexivo..................................................................................37 Tabela 2 – Tempo máximo de armazenagem...........................................................................40 Tabela 3 – Interrupções Disponíveis no dsPIC30F3012. .........................................................61 Tabela 4 – Pinagem dsPIC30F2010. ......................................................................................105 Tabela 5 – Pinagem dsPIC30F3013 .......................................................................................117 Tabela 6 – Lógica de acionamento dos sensores de borda. ....................................................121
12
LISTA DE ABREVIATURAS E SIGLAS
AD – Analógico Digital CI – Circuito Integrado CMOS – Complementar Mos Oxido Semicondutor CPU – Unidade Central de Processamento dsPIC – Digital Signal Controler FET – Transistor de Efeito de Campo LDR – Resistor Dependente de Luz LED – Diodo Emissor de Luz MCU – Microcontroller Unit MIPS – Milhões de instruções por segundo PLL – Phase Locked Loop POR – Power On Reset PU – Poliuretano PWM – Pulse With Modulation SAR – successive approximation registrer TTL – Transistor Transistor Logic UART – Universal Asynchronous Receiver Transmitter UFRGS – Universidade Federal do Rio Grande do Sul
13
SUMÁRIO
1 FUNDAMENTAÇÃO TEÓRICA.................................................................................17
1.1 Sumô de Robôs.........................................................................................................17 1.1.1 Regras para construção do Robô ......................................................................18 1.1.2 A arena..............................................................................................................19 1.1.3 Regras da Disputa.............................................................................................21 1.1.4 Pontuação .........................................................................................................22
1.2 Estudo de Robôs utilizados em competições............................................................23 1.2.1 Motores.............................................................................................................24 1.2.2 Rodas ................................................................................................................26 1.2.3 Transmissão......................................................................................................28
1.3 Sensor Sonar.............................................................................................................32 1.4 Sensor Reflexivo ......................................................................................................36 1.5 Bateria Chumbo Ácida .............................................................................................37
1.5.1 Descarga ...........................................................................................................40 1.5.2 Carga.................................................................................................................41
1.5.2.1 Carga por corrente constante ........................................................................43 1.5.2.2 Carga por tensão constante em dois estágios................................................43 1.5.2.3 Recuperação após descarga profunda...........................................................44
1.6 Modulação por Largura de Pulso .............................................................................45 1.7 Ponte H .....................................................................................................................46 1.8 Microcontrolador ......................................................................................................47
1.8.1 Ciclos de máquina do dsPIC.............................................................................50 1.8.2 Bits de configuração .........................................................................................50 1.8.3 Portas de entrada e saída...................................................................................52 1.8.4 Temporizadores ................................................................................................54 1.8.5 Universal Asynchronous Receiver Transmitter (UART) .................................55 1.8.6 Conversor analógico digital..............................................................................57 1.8.7 Modo de Modulação por Largura de Pulso. .....................................................59 1.8.8 Interrupções ......................................................................................................60
1.8.8.1 Interrupção externa.......................................................................................62 1.8.8.2 Interrupção de timer......................................................................................63 1.8.8.3 Interrupção de recepção serial ......................................................................63 1.8.8.4 Interrupção de conversão AD.......................................................................63
1.9 Plataforma de desenvolvimento................................................................................64
14
1.9.1 Compilador C30 ...............................................................................................65 1.9.1.1 Funções e Macros de Configuração .............................................................66
1.9.2 Processo de gravação do microcontrolador ......................................................68
2 DESENVOLVIMENTO DO HARDWARE ................................................................70
2.1 Mecânica do Robô....................................................................................................70 2.1.1 Dirigibilidade....................................................................................................70 2.1.2 Motor utilizado .................................................................................................72 2.1.3 Sistema de transmissão.....................................................................................75 2.1.4 Desenvolvimento das Rodas.............................................................................78 2.1.5 Montagem do Robô ..........................................................................................80 2.1.6 Pára-choque e suporte da bateria ......................................................................85
2.2 Sistemas eletrônicos de controle...............................................................................86 2.2.1 Desenvolvimento da ponte H ...........................................................................87 2.2.2 Sensores de borda .............................................................................................89 2.2.3 Sensor de início da disputa ...............................................................................92 2.2.4 Carregador de bateria........................................................................................94 2.2.5 Montagens das placas e sistemas eletrônicos ...................................................96
3 DESENVOLVIMENTO DO SOFTWARE................................................................103
3.1 Programação dsPIC30F2010 ..................................................................................105 3.1.1 Lógica de Programação do Bloco de Modulação por Largura de Pulso ........106 3.1.2 Lógica de Programação de Leitura dos Sensores Sonar.................................110 3.1.3 Lógica de Programação da UART .................................................................114 3.1.4 Lógica de Programação da Tática de Combate ..............................................115
3.2 Programação dsPIC30F3013 ..................................................................................117 3.2.1 Lógica de Programação dos Sensores de Borda.............................................118 3.2.2 Lógica de Programação de Monitoramento da Bateria ..................................122
4 TESTES E VALIDAÇÃO............................................................................................125
4.1 Peso e Dimensões ...................................................................................................125 4.2 Funcionamento dos Sensores e Movimentação......................................................126 4.3 Carregador de Bateria e Duração da Carga ............................................................128
REFERÊNCIAS BIBLIOGRÁFICAS ...............................................................................133
ANEXO A – PARTES MANUAL DSPIC30F2010............................................................136
ANEXO B – ESQUEMA DA PLACA DO MICROCONTROLADOR..... .....................143
APÊNDICE A – ESQUEMA ELÉTRICO COMPLETO............. ....................................144
APÊNDICE B – CÓDIGO FONTE DSPIC30F2010.........................................................147
APÊNDICE C – CÓDIGO FONTE DSPIC30F3013. .......................................................161
INTRODUÇÃO
Desde a sua existência, as disputas tem sido uma constante na vida do homem, como
adquirir comida, território, respeito e poder. Onde nestas disputas muitas habilidades são
colocadas à prova das mais variadas formas. Atualmente conhecimentos, notas e títulos são
disputados entre as universidades, para adquirirem prestígio na sociedade e principalmente no
mercado de trabalho.
Com o crescimento da robótica, algumas disputas se transformaram em desafios de
robôs, dos mais variados tipos, modalidades e regras. Colocando a prova, conhecimentos,
criatividades e capacidade técnica de alunos e professores de instituições de ensino em vários
países.
Assim, desenvolve-se um protótipo de um robô de combate na modalidade sumô,
respeitando as regras utilizadas em campeonatos realizados em diversas universidades e
centros de ensino.
Para isso muitas idéias de outros competidores são analisadas e transformadas para a
realidade existente no mercado, como materiais para a construção mecânica do robô, motores,
sensores a serem utilizados e a forma de controle e operação de todos os recursos.
16
Como a base de todo robô é mecânica, a utilização de recursos computacionais para
o desenvolvimento do protótipo é fundamental, como a utilização do software SolidWorks1,
assim como também a prática de montagem. Partindo em seguida para o desenvolvimento
eletrônico, efetuado sobre uma placa padrão, onde é possível realizar alterações no circuito de
forma mais segura, assim como também o desenvolvimento do software gravado em dois
microcontroladores onde todos os sensores e operações de movimentação e controle do robô
de sumô dentro da arena são realizadas.
Dessa forma o protótipo é capaz de identificar um led sob a arena, que ao ser
apagado inicia-se o combate e consequentemente a movimentação dos robôs. É capaz também
de identificar a borda da arena para que se mantenha dentro do círculo delimitado, assim
como encontrar de forma autônoma o adversário na arena empurrando-o com a força de seus
motores para fora da mesma.
1 SolidWorks é uma software de CAD (computer-aided design), desenvolvida pela SolidWorks Corporation. Baseia-se em computação paramétrica, criando formas tridimensionais a partir de formas geométricas elementares.
17
1 FUNDAMENTAÇÃO TEÓRICA
No desenvolvimento de um protótipo de robô, do mais simples ao mais complexo,
muitos recursos mecânicos e eletrônicos são desenvolvidos e utilizados e para isso se faz
necessário pesquisar a forma mais adequada, utilizando-se também de criatividade,
componentes e sensores que se enquadrem adequadamente para cada desafio encontrado.
1.1 Sumô de Robôs
Da mesma forma como o sumô, uma luta milenar praticada nos países do oriente, o
objetivo principal da competição de robôs é empurrar o adversário para fora da arena. Não
sendo permitida a utilização de armas, mas somente o deslocamento do robô adversário para
fora do perímetro demarcado. Arena essa circular, apenas com delimitação de borda, onde os
robôs devem trabalhar de forma autônoma, procurando o adversário, empurrando-o para fora
e decidindo a melhor forma para executar determinada tarefa.
18
1.1.1 Regras para construção do Robô
Os desafios de robôs existentes no Brasil, assim como também no mundo todo na
modalidade sumô de robôs, possuem regras bem definidas. Regras que servem para definir
categorias de robôs, como peso e modo de operação.
Por ser um desafio mais próximo da Feevale, utiliza-se para a construção do robô de
sumô as regras do desafio de robôs, que realiza-se no mês de outubro na Universidade Federal
do Rio Grande do Sul (UFRGS).
As regras definidas para o robô, onde se faz necessário segui-las para a sua
construção, serve para que todos os competidores tenham o mesmo nível no combate e um
competidor não leve vantagem em relação ao outro.
Conforme (DEPARTAMENTO DE ENGENHARIA ELÉTRICA, 2009) com
relação a sua forma, o robô antes do início da disputa deve possuir 20 cm de lado, sem
restrições de altura. Depois de iniciada a partida o mesmo pode expandir-se para 30 cm de
lado, a critério de cada equipe.
Com relação ao peso, a massa do robô não pode ultrapassar 3 Kg, sendo livre a
adição de mais massa até esse limite estabelecido.
É permitido que o robô, durante a disputa, se divida em duas ou mais partes. Sendo
que se uma das partes tocar o lado externo da arena, seu adversário será considerado
vencedor.
19
O robô deve possuir rigidez estrutural. Peças de até 10 gr podem se soltar, acima
desse peso será considerado partes independentes, sendo que se uma tocar fora da arena esse
será considerado derrotado.
O robô deve ser totalmente autônomo, sendo qualquer tipo de controle permitido,
desde que todos estejam embarcados no robô. Não é permitido controle externo, seja por
humanos ou por máquinas.
O robô deve possuir uma superfície plana de 7,5 x 5 cm na parte superior, onde será
afixado o número de identificação, assim como também deve possuir em sua carenagem uma
marca que identifique a parte frontal do aparelho. Que será usada para posicionar o robô de
forma correta para início de cada partida.
Por ser uma competição de sumô de robôs e não uma guerra de robôs, não permite-se
a utilização de armas, como ferramentas afiadas, com a finalidade de danificar o equipamento
adversário. Da mesma forma não é permitido arremessar líquido, gazes ou qualquer outra
substância sobre a mesa para levar vantagem, assim como utilizar-se de colas e adesivos para
aumentar a tração de suas rodas.
1.1.2 A arena
Arena denomina-se o local onde a disputa acontece entre os dois competidores,
possuindo dimensões definidas para que as equipes possam construir seus robôs, de forma que
possam identificar as dimensões e marcações padronizadas da arena oficial da competição.
20
A arena constitui-se de uma mesa circular de 180 cm de raio e 5 cm de altura,
possuindo sua superfície central preta e as bordas brancas com 5 cm de largura. O material de
fabricação é a fórmica, plana e lisa. Na Figura 1.1 é apresentada as dimensões estipuladas
para a arena.
Figura 1.1 – Medidas da Arena. Fonte – Departamento Engenharia Elétrica UFRGS, 2009.
A arena também possui Diodo Emissor de Luz (LED) de alto brilho, instalados sob
o robô, com 5 mm de diâmetro. Esses LEDs são utilizados para dar o início de cada
competição. Ao serem apagados, os robôs devem identificar e iniciar o combate.
21
A arena é fortemente iluminada, porém não possui luz solar incidindo sobre a
mesma, como também localiza-se dentro de uma área de exclusão com 5 metros de diâmetro,
para que os sensores de cada robô não detectem obstáculos externos.
1.1.3 Regras da Disputa
A partida constitui-se da disputa entre dois robôs dentro da arena e possui três
rounds. Considera-se vencedor o robô que vencer dois dos três rounds disputados.
Cada round possui 90 segundos, para que um dos competidores seja empurrado para
fora da arena. Caso isso não ocorra o round terminará empatado. Como uma partida não pode
terminar empatada, devendo sempre possuir um vencedor, alguns critérios de desempate são
utilizados.Vencer o segundo se o primeiro round terminar empatado. Vencer o primeiro se o
segundo terminar empatado. Vencer o primeiro se o terceiro terminar empatado. Ou qualquer
um dos rounds se o outro terminar empatado.
Não existindo vencedor nos três rounds, a decisão se dará pelos juízes da
competição, conforme alguns critérios, como a agressividade e movimentação do robô, menor
peso e, por último, sorteio.
No primeiro round da partida os robôs iniciam um de frente para o outro, sendo nos
rounds seguintes, o vencedor do round anterior pode escolher primeiro o posicionamento do
seu robô sobre o ponto de partida.
22
Ao final dos 90 segundos de cada round, se o mesmo terminar empatado, declara-se
vencedor o robô que desligar seus motores primeiro. Se ambos os robôs desligam-se ao
mesmo tempo o round é declarado empatado.
O robô que não entrar em funcionamento após 20 segundos do início do round é
declarado perdedor. Sendo também permitido um intervalo de três minutos dentro da partida
para troca de bateria. Outro problema não sendo troca de bateria deve ser solucionado fora do
período da partida.
1.1.4 Pontuação
O robô que vence uma partida recebe três pontos, computados na classificação geral,
e a equipe derrotada recebe um ponto, desde que o robô se movimente antes dos 20 segundos
estipulados.
No dia dedicado ao treinamento do robô são atribuídos pontos extras computados na
classificação geral, seguindo alguns critérios.
O robô que conseguir partir ao apagar o led de inicio,ou seja, se movimentar ao
longo de toda a extensão da arena, sem cair, desligando-se ao terminar 90 segundo recebe um
ponto extra. Cada robô possui duas tentativas para tal feito.
O robô que apresentar um sistema de detecção dos adversários efetivo recebe um
ponto extra. Esse sistema de detecção avalia-se da seguinte forma:
23
- O robô deve encontrar uma caixa que simule um robô adversário, como geometria e
peso, e empurrar para fora da mesa. O ângulo de partida é sorteado, tendo cada equipe duas
tentativas;
- Caso ocorra empate de pontos, deve-se observar o seguinte critério de desempate:
maior saldo de round, maior numero de rounds vencidos, menor numero de advertências,
comportamento do robô como agressividade e movimentação, menor peso do robô e maior
número de pontos no treinamento.
1.2 Estudo de Robôs utilizados em competições
Com as características do robô determinadas pelas regras de campeonatos, como
dimensões e peso, assim como também a forma de construção da arena, estudam-se alguns
projetos de robôs utilizados em competições. Onde se obteve idéias de alguns materiais
utilizados, forma de tração, sensores de borda da arena, sensores do oponente e também as
táticas utilizadas por cada equipe nas batalhas.
Toda a pesquisa dos projetos desenvolvidos anteriormente por cada escola ou
universidade pesquisou-se na Internet, onde imagens e vídeos de competições já realizadas e
que estavam disponibilizadas na rede foram analisadas, em que os detalhes de mecânica e
eletrônica foram anotados. Assim como também algumas listas de discussões onde materiais
como rodas e motores eram testados pelos frequentadores e suas características e opiniões
abertas para todos.
24
1.2.1 Motores
Conforme (PAES, 2007), o motor é a parte principal do robô, pois ele que dá a
mobilidade e a força necessária para que o oponente seja empurrado para fora da arena. Como
a alimentação se dá por intermédio de baterias é necessário que o motor seja de corrente
contínua, ou então de passo, existindo diversos modelos no mercado, como ilustra a Figura
1.2.
Figura 1.2 – Motores DC. Fonte – PAES, 2007.
Esses motores são encontrados com facilidade no mercado, pois são utilizados em
diversas aplicações, como brinquedos, eletrodomésticos, impressoras, etc. Como pode-se
verificar alguns são mais frágeis com eixos finos e engrenagens de plástico incorporadas ao
eixo, assim como outros são mais fortes robustos e aparentemente pesados.
25
Motores utilizados em automóveis, geralmente possuem sua tensão nominal em 12V,
são mais robustos e projetados para utilização em situações mais extremas, como poeira, calor
e umidade. Como pode-se verificar na Figura 1.3.
Figura 1.3 – Motor de Vidro Elétrico. Fonte – PAES, 2007.
Alguns modelos são incorporados com caixa de redução, como motores de vidro
elétrico e limpados de pára-brisa. O que torna o robô mais forte e em compensação mais
lentos, pois sua rotação não passa de 150 rpm.
26
Motores sem caixa de redução apresentam elevadas rotações, tornando impossível
ligar o mesmo diretamente a roda do robô, onde é necessário projetar externamente relações
de engrenagens, diminuindo a rotação e consequentemente aumentando o torque.
Outra questão é com relação ao peso do motor, pois o robô não pode ultrapassar 3
Kg. Assim motores de vidro elétrico, sem a redução acoplada pesam aproximadamente 300
gramas, enquanto motores de freio ABS, pesam entre 900 a 1350 gramas.
Existem também os motores de passo, que são muito utilizados em aplicações onde é
indispensável à precisão nos movimentos e em baixa rotação.
O acionamento é feito por um controlador eletrônico, onde cada bobina é energizada
de forma sequencial, para que o motor se movimente entre cada passo. Podendo variar de três
a 72 passos para completar uma volta. São aplicados em braços mecânicos, onde não se faz
necessária muita velocidade, mas precisão nos movimentos, assim como impressoras.
1.2.2 Rodas
As rodas são dispositivos fundamentais para o bom funcionamento do robô, pois
necessita ter uma boa aderência ao piso da arena, para que toda a força gerada pelos motores
seja utilizada de forma eficiente, na retirada do adversário da competição.
As rodas devem ser construídas preferencialmente de borracha, ou algum outro
polímero que adere bem ao piso de fórmica da arena, sendo que devido às regras, não é
permitido utilizar nenhum tipo de adesivo para gerar maior tração.
27
Conforme o projeto de cada robô, utiliza-se variado tipo de rodas, onde deve-se levar
em consideração o seu diâmetro, para que muito grande não diminua o torque do motor e
muito pequeno não o deixe lento.
Para calcular a velocidade do robô basta multiplicar a circunferência da roda (C =
2.π.raio), com a velocidade em rotação por segundo do eixo, (RPS = RPM / 60), obtendo
assim a velocidade em metros por segundo. (PAES, 2007).
Utilizando revestimento de borracha, faz-se necessário usinar a parte interna da roda
com algum tipo de material resistente e leve, para depois revestir com a borracha mais
adequada para uma boa tração. Esse processo se torna difícil, por não ser feito em pequena
escala.
Outra solução construtiva das rodas é a utilização de tarugos com o diâmetro e
materiais adequados, o que torna mais viável a usinagem dessa peça.
Uma solução mais simples é a utilização de rodas existentes no mercado como, rodas
de carrinho de supermercado, malas de viagem, rodízios para mesas móveis ou rodas
utilizadas em rollers e skates.
Encontra-se no mercado rodas para skate e roller dos mais variados tipos, materiais e
tamanhos, onde pode-se utilizar o que melhor se adapte ao projeto.
28
Alguns projetos de robôs desenvolvidos utilizam-se de esteiras de borracha para o
tracionamento do robô, baseando-se no estilo de tanques de guerra, para obter um maior atrito
com o solo, como ilustrado na Figura 1.4.
Figura 1.4 – Tracionamento por Esteira. Fonte – COBENGE, 2006.
Essa forma de tracionamento torna-se bastante eficiente em competições, mas por
sua complexidade de desenvolvimento e construção pode não ser a forma de tracionamento
mais adequado, dependendo do projeto escolhido.
1.2.3 Transmissão
Define-se por transmissão, os componentes necessários para que o torque gerado
pelo motor seja transferido para as rodas, para que o robô se movimente da forma mais
adequada, equilibrando velocidade e força.
29
A forma mais simples e básica de transmissão é a ligação do eixo do motor
diretamente ao eixo das rodas, onde só é possível para motores que possuem uma baixa
rotação e também com a utilização de 4 motores, um para cada roda. Mais de 90% dos
projetos de robôs de sumô utilizam tracionamento nas quatro rodas, para assim ter um
controle maior dos movimentos, onde o robô possui a capacidade de girar no eixo central. Por
este motivo pode ser necessário à utilização de quatro motores.
Um exemplo da aplicação verifica-se na Figura 1.5.
Figura 1.5 – Tracionamento Direto. Fonte – PAES, 2007.
Nessa técnica é necessário que o eixo do motor suporte todo o peso do robô, assim
como a força que ele irá fazer para empurrar o oponente, fazendo com que o motor seja mais
forte e também possua caixa de redução, acarretando uma massa muito grande para o robô.
Conforme (PAES, 2007), a utilização de engrenagens para a transmissão torna o
ajuste de velocidade e torque do motor independente do tipo de motor, onde o diâmetro da
engrenagem no eixo do motor com a engrenagem do eixo da roda podem variar a força e a
velocidade do robô, conforme a sua relação. Onde o torque é igual à força vezes à distância.
30
As engrenagens podem ser retas com dentes cônicos ou helicoidais, cônicas com
dentes planos e helicoidais e engrenagens com rosca sem fim.
Cada engrenagem possui suas características que podem ser mais ou menos
favoráveis para o robô, conforme a idealização de cada projeto.
Engrenagens retas com dentes planos e helicoidais são aplicadas em eixos paralelos e
não convergentes, que não se cruzam, apresentam baixo volume e ampla variação de relação.
A relação é calculada de maneira simples, onde a relação = número de dentes da engrenagem
motora (conectada ao motor), dividido pelo número de dentes da engrenagem movida
(conectada ao eixo da roda). As engrenagens com dentes retos são mais fáceis de
confeccionar, porém apresenta maior nível de ruído durante a operação, enquanto que
engrenagens com dentes helicoidais apresentam menor nível de ruído, mas geram cargas
axiais, forçando o seu próprio eixo, (PAES, 2007).
Engrenagens cônicas com dentes planos e helicoidais são aplicadas em eixos
perpendiculares e convergentes e apresentam uma faixa de redução de 15:1.
31
Como ilustrado na Figura 1.6.
Figura 1.6 – Coroa e Pinhão. Fonte – PAES, 2007.
Engrenagens em coroa e pinhão são ideais para montagem onde o eixo do motor fica
perpendicular ao eixo da roda, otimizando a distribuição de massa e volume no robô. A
engrenagem pequena conectada ao eixo do motor é chamada de pinhão e a engrenagem
conectada ao eixo da roda é chamada de coroa. É recomendável que seja utilizada dessa forma
e não inversamente. A relação de redução é a razão do numero de dentes do pinhão pelo
numero de dentes da coroa.
Conforme (PAES, 2007), engrenagens de rosca sem fim são indicadas para eixos
perpendiculares e não convergentes. Apresentam alto índice de redução, 20:1 sendo a melhor
solução para motores com alta rotação. As engrenagens possuem o nome de coroa e pinhão,
mas não permite o movimento contrário, fazendo com que a coroa gire o pinhão. Essa
característica pode-se utilizar como freio para o robô, somente desligando a alimentação do
motor. A relação é o numero de dentes da coroa pelo numero de canais do pinhão.
32
Outro sistema de transmissão, sem o acoplamento entre engrenagens, dando uma
maior flexibilidade ao sistema é a utilização de correias. Onde pode ser correias lisas
acopladas em polias fixadas no motor e nas rodas, tornando a construção mais simples, ou a
utilização de correias dentadas, acopladas em polias sincronizadas ou engrenagens. Nesse
caso se faz necessário a correta construção da engrenagem, para que a relação de dentes entre
a correia e a engrenagem seja perfeita, a fim de não escapar quando o robô necessitar de
torque e não ter folga para movimentos mais precisos.
1.3 Sensor Sonar
Baseados na geração e transmissão de um sinal de ultra som em uma determinada
direção, onde o seu eco é captado, determinando a distância de um obstáculo pela velocidade
do sinal ultra sônico emitido, o sensor sonar é muito utilizado em sistemas de localização e
principalmente na robótica.
Comercialmente existem diversos tipos de sensores sonares, com maior e menor
sensibilidade e com capacidades de identificar o obstáculo entre centímetros a metros de
distância.
O sensor MaxSonar EZ1, possui um circuito acoplado utilizando um processador
PIC16F676, onde todo o processo de geração do ultrason, emissão do sinal e captação do eco
é feito automaticamente, gerando na saída sinais Pulse With Modulation (PWM), serial e
analógico, onde o nível de tensão varia conforme a distância do objeto.
33
Conforme (MAXBOTIX, 2007), o sensor é alimentado de 2,5 a 5,5 volts, medindo
objetos até 6,45 metros com uma resolução de 1 polegada. Possui ganho variável ajustado
continuamente para controle preciso do feixe de ultrasom, detecta objetos encostados no
sensor, consumo de 2 mA e medição a cada 50 ms ou 20 Hz.
Podendo operar de forma manual onde a medida é efetuada conforme operação do
usuário e automática, onde continuamente efetua-se medidas da distância do objeto e por
definição todas as saídas do sensor são ativas simultaneamente.
Operando em uma frequência de 42 KHz, possui um feixe de alta qualidade,
retornando ao usuário o valor correto da medição, não necessitando nenhum cálculo adicional.
Por seu baixo consumo é ideal para operar com baterias.
Ilustra-se na Figura 1.7 a pinagem do dispositivo.
Figura 1.7 – Pinagem sensor sonar. Fonte – Manual Técnico MaxSonar, 2007.
Os pinos são enumerados conforme verifica-se a seguir:
1 - GND - Terra da alimentação. Os pinos GND e Vcc devem estar livres de ruído
para uma ótima operação;
34
2 - +5V - Vcc - Opera de 2.5V a 5.5V. Capacidade de corrente recomendada: 3mA
para 5V, e 2mA para 3V;
3 - TX – Quando o pino BW está aberto ou em nível baixo, o pino TX envia o sinal
serial no formato RS232, exceto pela voltagem que é 0- Vcc. A saída é o ASCII “R”, seguido
por três dígitos ASCII representando a distância em polegadas até o máximo de 255, seguido
por um ENTER ASCII 13. O baud rate é 9600, 8 bits, sem paridade, com um stop bit. Apesar
da voltagem de 0-Vcc estar fora do padrão RS232, a maioria dos dispositivos conseguem ler o
dado serial. Se o nível padrão for necessário, inverta o sinal e conecte a um conversor como o
MAX232;
4 - RX – Este pino é mantido em alto internamente. O EZ1 mede continuamente se
este pino for deixado aberto ou em alto. Se levado a nível baixo o EZ1 irá parar a medição.
Leve a nível alto por 20uS ou mais para iniciar uma medição;
5 - AN – Saída analógica com um fator de (Vcc/512) por polegada.Com uma
alimentação de 5V temos ~9.8mV/pol. E com 3.3V temos ~6.4mV/pol;
6 - PW - Esta saída é um pulso cuja largura representa a distância. Para calcular use
um fator de 147uS por polegada;
7 - BW - Deixe aberto ou em nível baixo para ter saída serial em TX.
Os dispositivos também são identificados com pontos coloridos, que conforme a cor
algumas características de funcionamento são alteradas. A identificação encontrada no
mercado e também a mais comum é o ponto marrom.
35
Com ponto marrom: Quando o pino BW é mantido alto, o pino TX envia um pulso e
não dados seriais (MAXBOTIX, 2007).
Cada vez que o sensor é alimentado, efetua-se a calibração automaticamente,
medindo objetos próximos. Para se obter uma melhor sensibilidade aconselha-se não ter
objetos em um raio de aproximadamente 14 polegadas.
Sempre 250 ms após alimentado, o LV-MaxSonar EZ1 está pronto para aceitar
comandos no pino RX. Se o pino RX for deixado aberto ou mantido em nível alto, o sensor
irá inicialmente fazer um ciclo de calibração em 49 ms, depois irá fazer uma medição em
49mS. Então, a primeira medição leva ~100 ms.As próximas leituras levarão 49 ms. O LV-
MaxSonar EZ1 checa o pino RX no fim de cada ciclo.O resultado pode ser lido a cada 49 ms.
Cada ciclo de 49 ms começa com o pino RX estando aberto ou em alto, depois o LV-
MaxSonar EZ1 envia 30 pulsos de 42 KHz, e o pino PW é levado a nível alto. Quando um
obstáculo é detectado, o pino PW é levado a nível baixo. O pino PW fica alto por até 37.5 ms
se nenhum obstáculo for detectado. O restante do ciclo de 49 ms é usado para ajustar a saída
analógica para o nível correto. Quando uma longa distância for lida imediatamente após uma
pequena distância, a saída analógica pode não refletir o valor correto em um ciclo. Durante os
últimos 4.7 ms, o valor serial é enviado. A temporização do LV-MaxSonar EZ1 calibrado na
fábrica para 1% em 5V, e em uso sua precisão é melhor que 2%. Além disto, a operação em
3.3V normalmente faz com que o resultado seja um ou dois por cento maior que o real
(MAXBOTIX, 2007).
36
1.4 Sensor Reflexivo
Utilizando o principio da reflexão da luz, o sensor reflexivo é muito utilizado para
detectar a presença de um objeto no seu raio de alcance. Utilizando um diodo emissor de luz
infravermelha, o feixe é disparado em uma determinada direção e com isso através de um
foto-transistor, onde a base do transistor é polarizada através da incidência de luz
infravermelha o feixe de luz é captado.
Conforme (OPTEK, 2006), os sensores, OPB703 OPB704, OPB705, consistem em
um diodo emissor de luz infravermelha e um foto-transistor NPN montador lado a lado em um
suporte plástico onde seus feixes convergem ao mesmo ponto. O foto-transistor responde a
radiação emitida pelo diodo somente quando um objeto reflexivo passar no seu campo de
visão. No suporte plástico contem uma lente protegendo o sensor contra ruídos externos e
melhorando a resolução, ou seja, deixando seu feixe de detecção mais preciso.
Na Figura 1.8 verifica-se a composição do sensor.
Figura 1.8 – Sensor Reflexivo. Fonte – OPTEK, 2006.
37
Assim como em um LED comum quanto maior a corrente passando por ele maior o
seu brilho, da mesma forma ocorre em um foto diodo que quanto maior a corrente passando
por ele mais longe o objeto será detectado. Segundo o manual do fabricante a corrente
máxima possível no foto diodo é de 40 mA contínua. Conforme verificam-se os parâmetros na
Tabela 1.
Tabela 1 – Parâmetros Sensor Reflexivo.
Fonte – OPTEK, 2006.
O foto transistor pode ser polarizado como um transistor comum, sendo sua base o
feixe de luz infravermelha recebido. Ao incidir luz sobre a base, uma corrente entre coletor e
emissor é gerada funcionando dessa forma como uma chave óptica. A corrente mínima
necessária de coletor é de 2mA para que o foto transistor funcione em saturação.
1.5 Bateria Chumbo Ácida
Segundo (UNICOBA, 2003), a capacidade de armazenamento de energia de uma
bateria é medida através da multiplicação da corrente de descarga pelo tempo de autonomia,
sendo dado em Ampére-hora (Ah).
38
Exemplo: uma bateria que, submetida a uma corrente de descarga de 5A permitir
autonomia de 20 horas, será uma bateria de 100Ah.
Observa-se que, ao contrário das baterias primárias (não recarregáveis), as baterias
recarregáveis não podem ser descarregadas até 0V, pois isto leva ao final prematuro da vida
da bateria. Na verdade elas têm um limite até onde podem ser descarregadas, chamado de
tensão de corte. Descarregar a bateria abaixo deste limite reduz a vida útil da mesma.
As baterias ditas 12V, por exemplo, devem operar de 13,8V (tensão a plena carga),
até 10,5V (tensão de corte), quando 100% de sua capacidade terá sido utilizada, e é este o
tempo que deve ser medido como autonomia da bateria.
Como o comportamento das baterias não é linear, isto é, quanto maior a corrente de
descarga menor será a autonomia e a capacidade, não é correto falar em uma bateria de
100Ah. Devemos falar, por exemplo, em uma bateria 100Ah padrão de descarga 20 horas,
com tensão de corte 10,5V, o que também pode ser escrito como 100Ah C20 Vcorte=10,5V.
Esta bateria permitirá descarga de 100 / 20 = 5A durante 20 horas, quando a bateria irá atingir
10,5V.
Outro fator importante é a temperatura de operação da bateria, pois sua capacidade e
vida útil dependem dela.
Usualmente as informações são fornecidas supondo T=25°C ou T=20°C, que é a
temperatura ideal para maximizar a vida útil.
39
Muitas vezes estes parâmetros são omitidos, dizendo-se apenas bateria de 100Ah, no
entanto para fazer uma comparação criteriosa entre diferentes baterias, deve-se se certificar
que a autonomia exibida foi dada considerando os mesmos parâmetros de tensão de corte,
temperatura e padrão de descarga em horas.
Da mesma forma que se expressa à capacidade de uma bateria em Ampére hora (Ah),
se pode expressar em Watt hora (Wh), que é a potência de descarga x tempo.
Baterias chumbo ácidas sofrem auto descarga de aproximadamente 3% ao mês,
quando armazenadas em temperatura ambiente de 200C. A taxa de auto descarga varia de
acordo com a temperatura ambiente. O Gráfico 1.1 demonstra a relação entre o tempo de
armazenamento e a capacidade remanescente da bateria.
Gráfico 1.1 – Auto Descarga Bateria Chumbo Ácida. Fonte – Manual Técnico Unicoba, 2003.
A bateria quando armazenada por um longo período de tempo sofre o processo de
sulfatação. Quanto maior o grau de sulfatação menor a capacidade de armazenamento da
40
bateria. A Tabela 2 mostra o tempo máximo de armazenamento para diferentes temperaturas
ambientes.
Tabela 2 – Tempo máximo de armazenagem.
Fonte – Manual Técnico Unicoba, 2003.
O armazenamento da bateria fora dos parâmetros especificados por alguns dias pode
danificar definitivamente.
1.5.1 Descarga
Conforme (UNICOBA, 2003), a capacidade remanescente de uma bateria pode ser
determinada medindo-se a tensão em circuito aberto e pode-se determinar conforme o Gráfico
1.2.
Gráfico 1.2 – Capacidade Remanescente da Bateria. Fonte – Manual Técnico Unicoba, 2003.
41
As baterias chumbo-ácidas seladas reguladas por válvula em geral perdem a sua
capacidade nominal e vida útil quando descarregadas abaixo do valor recomendado da tensão
de corte. Se a bateria for descarregada até 0V/elemento e permanecer por um período longo
de tempo sem carga, à bateria sofrerá “sulfatação” e terá um aumento na sua resistência
interna. Em alguns casos, a bateria não poderá mais aceitar carga.
Baterias de 12V em geral possuem tensão de corte de 10,5V ou 1,75 por elemento,
onde uma bateria de 12V possui seis elementos internamente. Deve-se utilizar um circuito que
controle a descarga da bateria para que a mesma não tenha sua tensão abaixo da tensão de
corte, danificando definitivamente.
1.5.2 Carga
Efetua-se a carga de uma bateria chumbo ácida a partir do modo de utilização, que
pode ser dividido em cíclico, onde a bateria é utilizada até ter sua capacidade esgotada e após
carrega-se completamente efetuando todo o ciclo de carga e descarga, como também pode ser
utilizada em modo de flutuação, como, por exemplo, lâmpadas de emergência, onde a bateria
está constantemente sendo carregada e quando utilizada é por curto intervalo de tempo e após
sendo novamente carregada.
Existem vários fatores que afetam a vida útil cíclica da bateria Unipower2. Os
principais fatores são: temperatura ambiente de operação; taxa de descarga; profundidade de
descarga e a forma de carga, a mais importante sendo a profundidade de descarga. A
capacidade de descarga atinge a sua capacidade máxima após os 50 ciclos iniciais.
2 Marca líder de baterias recarregáveis no Brasil durante mais de 20 anos.
42
Recomenda-se sempre selecionar uma bateria de maior capacidade porque quanto menor a
profundidade da descarga maior a vida útil da bateria. A bateria Unipower foi projetada para
uma vida útil em flutuação de 5 anos em condições normais de operação onde a tensão de
carga é mantida entre 2,25 ~ 2,30 V/elemento para temperaturas de operação próximas de
200C. (UNICOBA, 2003).
Em condições normais de uso em flutuação onde a tensão de carga é mantida entre
2,25 e 2,30 V/elemento, o gás gerado dentro das baterias é recombinado nas placas negativas
e devolvido em forma de água para a solução do eletrólito. A perda da capacidade elétrica da
bateria não se deve a evaporação do eletrólito, mas sim devido a corrosão gradual normal dos
eletrodos que diminui a capacidade elétrica da bateria até o final da sua vida útil. A perda da
capacidade elétrica da bateria se acelera em função de temperaturas ambientes elevadas ou
por tensão de carga elevada. Em flutuação, o tempo de vida útil da bateria esta diretamente
relacionado ao número de ciclos de descarga, profundidade de descarga, temperatura
ambiente e tensão de carga.
Para aumentar a vida útil de uma bateria chumbo ácida, se faz necessário compensar
a tensão de carga conforme a temperatura ambiente, evitando o fenômeno conhecido como
avalanche térmica, onde a temperatura interna dos vasos de um banco de baterias aumenta
excessivamente sem que a temperatura ambiente exceda 35°C em uso cíclico ou 40°C em
flutuação. Ao aumento da temperatura deve-se reduzir a tensão de carga para não ocorrer
sobre carga, quando a temperatura diminui a tensão de carga deve aumentar para evitar baixa
carga. O fator de compensação recomendado é de -3mV/C/ele para flutuação e -4mV/C/ele
para aplicações cíclicas, a referência sendo 20°C.
43
1.5.2.1 Carga por corrente constante
Este modo de carga não é comum para baterias, porém é um método eficiente para
carregar várias baterias simultaneamente ou equalizar baterias e corrigir variações de
capacidade que possam existir entre as baterias. Ao utilizar este modo de carga, deve-se tomar
o cuidado de limitar o tempo de carga após a bateria ter alcançado a sua carga completa. Caso
a bateria seja mantida em carga por muito tempo após a sua carga completa, a bateria poderá
sofrer uma sobrecarga e consequentemente ocorrer um dano ou perda da bateria (UNICOBA,
2003).
1.5.2.2 Carga por tensão constante em dois estágios
Recomenda-se esse modo de carga para carregar rapidamente a bateria no estágio
inicial e colocar em flutuação no estágio seguinte. No primeiro estágio a carga é efetuada por
corrente constante, até o limite de 2,45V/ elemento, onde então o modo de carga é chaveado
para uma carga por tensão constante de 2,3v/elemento. O chaveamento ocorre após a bateria
atingir 80% de carga de sua capacidade nominal. Nessa forma minimiza-se o tempo de carga
no estágio inicial e protege a bateria contra sobre carga no estágio final. No Gráfico 1.3
verifica-se a curva de carga para tensão constante e corrente limitada.
44
Gráfico 1.3 – Curva de carga para tensão constante e corrente limitada. Fonte – Manual técnico Unicoba, 2003.
Uma bateria descarregada completamente aceita uma corrente inicial de carga muito
elevada, ocasionando aquecimento dos elementos danificando a bateria. Ao carregar a bateria
em uma operação cíclica se faz necessário limitar a corrente inicial, conforme definido pelo
fabricante para cada modelo de bateria. Em flutuação a bateria é projetada para não aceitar
uma corrente inicial de carga muito elevada, não sendo necessário a limitação da corrente.
1.5.2.3 Recuperação após descarga profunda
A bateria, quando submetida a uma descarga profunda, demanda um longo período
de carga para se recuperar. O aumento da resistência interna da bateria neste caso limita a
aceitação de carga no seu início. Após 30 minutos, a resistência interna é vencida e a carga da
bateria se resume normalmente. Como a corrente inicial de carga é pequena neste caso, se a
corrente for monitorada para determinar o estado de carga ou para sinalizar o ponto de
chaveamento para entrada da carga em flutuação, no caso de uma carga em dois estágios, o
carregador poderá ter a indicação falsa de plena carga ou poderá iniciar a carga de flutuação
antes do desejado. (UNICOBA, 2003).
45
1.6 Modulação por Largura de Pulso
Em inglês Pulse Width Modulation significa Modulação por Largura de Pulso, que
envolve a modulação da razão cíclica (duty cycle)3 de um sinal com forma de onda quadrada.
Também pode ser utilizado para controlar cargas, como por exemplo motores DC.
Segundo (ATUAL, 2008), nesta técnica uma carga é chaveada por um dispositivo eletrônico,
fazendo com que ela esteja ora ligada, ora desligada. O tempo em que a carga está ligada é
controlado por um sistema chaveador e como consequência tem-se uma tensão média aplicada
a essa carga, conforme verifica-se na Figura 1.9.
Figura 1.9 – Exemplo de aplicação do PWM. Fonte – ATUAL, 2008.
O dispositivo chaveador pode ser um transistor bipolar ou, mais adequadamente, um
MOSFET. A vantagem no uso do MOSFET é porque como ele possui uma resistência entre
dreno e fonte muito baixa a potência dissipada também é muito baixa.
Pode-se dizer que no PWM a frequência é constante, mas a largura do pulso é
variável, onde a tensão média na carga pode ser calculada pela Equação 1.
3 É a duração do pulso dividido pelo período. A relação entre nível lógico alto e nível lógico baixo de uma onda quadrada.
46
T
DVVmed .max= (1)
Onde:
Vmed = tensão média na carga;
Vmax = Tensão máxima aplicada na carga que pode ser a tensão da fonte;
D = Tempo em que a carga está ligada;
T = Período do sinal aplicado a carga.
1.7 Ponte H
Ponte H é um circuito eletrônico utilizado em motores DC, permitindo que gire tanto
para um sentido como outro. Conforme (WIKIPÉDIA, 2009), estes circuitos são geralmente
utilizados em robótica e estão disponíveis em circuitos prontos, ou podem ser utilizados
separadamente, montados discretamente.
O nome ponte H se dá pelo esquema do circuito conforme verifica-se na Figura 1.10.
47
Figura 1.10 – Esquema Ponte H. Fonte – Wikipédia, 2009.
Constrói-se o circuito com quatro chaves, que são acionadas de forma alternada, para
cada configuração das chaves o motor gira em um sentido. Não se pode ligar as chaves de um
mesmo lado da ponte ao mesmo tempo, ocasionando um curto circuito na fonte. Ao acionar as
duas chaves superiores, ou as duas chaves inferiores freia-se o motor para aplicações
específicas que necessitem desse recurso.
Para a construção da ponte, utiliza-se qualquer componente que simule uma chave
liga desliga como, por exemplo, transistores, mosfets e relés.
Como proteção do circuito, pode-se utilizar configurações com portas lógicas 7408 e
7406, para que não ocorram situações de curto circuito na ponte H. Colocando diodos entre as
chaves, no caso do motor parar a corrente não tem por onde circular, voltando para a fonte de
alimentação, economizando energia de uma bateria.
1.8 Microcontrolador
Desenvolvido pela Microchip, a família de microcontroladores Digital Signal
Processor (dsPIC) faz parte de uma nova linha de componentes lançados no mercado e que
48
vem sendo muito utilizado pela sua versatilidade e facilidade de implementação nos mais
variados sistemas eletrônicos.
Segundo (SOUZA, 2008), o módulo Unidade Central de Processamento (CPU)
possui uma arquitetura Havard com instruções de suporte a DSP4. A CPU possui um
barramento de 24 bits com tamanho do código de operação (opcode) variável. O contador de
programa possui 23 bits, sendo possível o endereçamento de até 4Mbit de memória de
programa. Todas as instruções são executadas em um único ciclo de máquina, exceto as
instruções que alteram o fluxo do programa e a instrução de movimento de uma palavra
dupla.
Essa família de processadores dsPIC, possui duas classes de instruções, as do tipo
Microcontroller Unit (MCU), que significa Unidade do Microcontrolador e as instruções de
classe DSP. Implementadas na mesma arquitetura do microcontrolador.
Conforme (SOUZA, 2008), o dsPIC30F possui vários vetores de interrupção,
somando um total de 50 fontes de interrupções, onde cada uma pode ser configurada em 7
níveis de prioridade.
Ilustrado na Figura 1.11 o bloco diagrama de um microcontrolador dsPIC com todos
os seus módulos e funcionalidades.
4 Do inglês, Digital Signal Processor, são processadores especializados em processamento digital de sinais, como por exemplo, áudio e vídeo.
49
Figura 1.11 – Bloco Diagrama microcontrolador dsPIC. Fonte – Microchip Data Sheet, 2005.
Verifica-se no Anexo A, a descrição detalhada, contendo tabelas utilizadas no
desenvolvimento de aplicação utilizando os principais recursos do microcontrolador, baseado
no dsPIC30F2010 (MICROCHIP, 2005).
50
1.8.1 Ciclos de máquina do dsPIC
O dspic utiliza quatro pulsos do clock principal para gerar um ciclo de máquina,
segundo (SOUZA, 2008) sendo 10MHz a freqüência do clock, basta fazer o inverso para
chegar ao tempo de 100ns. Para gerar uma instrução real, o dsPIC utiliza quatro pulsos deste
período, pois é através destes quatro pulsos que o microcontrolador consegue ler e executar a
instrução proveniente da memória de programa. A velocidade de processamento do dsPIC é
de ¼ da velocidade do clock principal do sistema. O termo correto a se usar é milhões de
instruções por segundo (MIPS).
1.8.2 Bits de configuração
Antes de iniciar a programação do microcontrolador, algumas configurações para o
funcionamento do dispositivo são necessárias, através dos configurations bits, que significa
bits de configuração, onde existem ao todo 12 configurações descritas no manual do
fabricante.
O dsPIC possui uma entrada principal de clock externo e através do configuration bit
chaveamento de clock e monitor, pode-se definir se caso o clock externo venha a falhar se
ocorrerá ou não o chaveamento para o clock interno do microcontrolador. Pode-se configurar
como chaveamento desabilitado, chaveamento habilitado e monitor “off” e chaveamento
habilitado e monitor “on”.
O oscilador do dsPIC é a parte principal do microcontrolador, onde define-se a
quantos MIPS o dsPIC trabalha. A configuração do clock do processador é muito flexível.
51
Com a utilização do Phase Locked Loop (PLL) do dsPIC, pode-se multiplicar a freqüência do
oscilador externo por 4, 8 e 16 vezes, como também dividi-la. Da mesma forma acontece com
o oscilador interno que pode ser multiplicado nas mesmas proporções. Assim vários cristais
de freqüências diferentes podem ser utilizados e através da correta configuração definir-se a
correta freqüência de operação.
Caso ocorra algum tipo de travamento no microcontrolador, utiliza-se o circuito de
watchdog timer, que pode ser habilitado ou não. De tempos em tempos o software que
controla o funcionamento do dsPIC deve resetar o timer do watchdog, avisando que está
funcionando normalmente. Caso isso não ocorra o watchdog timer reseta o microprocessador.
O tempo mínimo é de 2 ms, mas pode-se aumentar esse tempo utilizando-se o prescaler A e B
do watchdog timer. Os prescalers são divisores que permitem elevar o tempo de estouro para
até 16s.
Conforme (SOUZA, 2008), o pino 1 do dsPIC30F3012 é chamado de “master clear
reset”, onde o microcontrolador pode ser resetado. Habilitando essa opção, ao colocar o pino
1 em nível lógico “0” durante um pequeno intervalo de tempo o microcontrolador será
resetado.
O dsPIC funciona na faixa de 2,5 a 5,5 Volts e caso o circuito de Brown out detecte
que a alimentação caiu abaixo de um determinado valor o microcontrolador pode ser resetado.
Esta opção pode ser habilitada ou não, conforme escolha do programador, através do
comando “PBOR Enable”. Juntamente com esta configuração, pode-se utilizar a configuração
do “Brown out voltage”, que define qual a tensão mínima que irá resetar o processador. As
opções são de 2 v, 2,7v, 4v e 4,7v.
52
O circuito de “Power On Reset” (POR), permite ao energizar o microcontrolador
mantê-lo em estado de reset por um determinado período de tempo. Este recurso pode ser útil
em aplicações onde há uma quantidade grande de componentes que necessitam ser
configurados pelo dsPIC e com isso garante que todos estejam inicializados completamente.
As opções podem ser configuradas como desabilitado, 4ms, 16ms e 64ms.
A configuração “general code segment code protect” é utilizada para proteger a
memória de programa do microcontrolador, onde o programa não pode ser lido, protegendo a
propriedade intelectual. Já o “general code segment write protect”, impede que a memória de
programa seja escrita enquanto o microcontrolador estiver em tempo de execução.
Todas as configurações de bits são determinadas através de registradores específicos
disponíveis no manual do fabricante.
1.8.3 Portas de entrada e saída
Segundo (SOUZA, 2008), as portas de “Imput and Output” (I/O) permitem que o
microcontrolador tenha acesso ao mundo externo, permitindo que identifique o estado de
algum sensor ou acione alguma saída. O dsPIC30F possui ao todo 18 pinos, sendo que 12
podem ser utilizados como I/O e que são divididos em “ports”, chamados de portB, portC,
portD, etc, como pode-se verificar na Figura 1.12.
53
Figura 1.12 – Pinagem dsPIC30F3013. Fonte – Microchip Data Sheet, 2005.
Os pinos do “portB” são chamados de “RB1, RB2 até RB9”, assim como os pinos
do “portC” chamados de “RC13” por exemplo. Além da função básica de I/O alguns pinos
podem ter funções específicas como: interrupção externa; entrada analógica para conversor
analógico digital; PWM; comparador e portas de comunicação.
A cada pino de I/O existem 3 registradores de função especial associados a ele. Estes
registradores são internos ao dsPIC e através deles pode ser terminado se um determinado
pino funcionará como entrada ou saída. Chamado de “TRISX”, onde X identifica o port
correspondente. Outro registrador é o “PORTX”, que através deste registrador pode-se ler o
estado de um pino ou ter controle sobre uma das saídas do microcontrolador. O último
registrador referente ao I/O do dsPIC é o “LATCH”, através do qual pode-se ler o valor de um
determinado pino ou setar um estado no pino do microcontrolador.
A configuração de cada pino, com os bits necessários para a configuração do “TRISX”
verifica-se no manual do fabricante. (MICROCHIP, 2005).
54
O “portB” é responsável pelas entradas analógicas do dsPIC e que por padrão são
configuradas como analógicas, sendo necessário utilizar o registrador “ADPCFG=0x00FF” para
setar o “portB” como I/O digital.
1.8.4 Temporizadores
Os “timers” são contadores internos ao dsPIC e que são utilizados como
temporizadores, efetuando uma contagem de tempo para que determinada operação ocorra,
gerando uma interrupção ao final de cada contagem.
Conforme (SOUZA, 2008) os 3 timers do dsPIC, “timer 1”, “timer 2” e “timer 3”
funcionam em 16bits, podendo contar de 0 a 65535, sendo cada um deles composto por 3
registradores, sendo os registradores “TMRX, PRX e TXCOM”, onde X equivale a 1, 2 ou 3
conforme o timer utilizado.
O registrador “TMRX” é incrementado a cada ciclo de máquina, que pode ser
configurado para 8, 64 e 256 ciclos, onde é constantemente comparado com o valor setado no
registrador “PRX”, quando o “TMRX” atinge o valor do “PRX” ocorre o estouro do timer e o
contador é resetado iniciando uma nova contagem.
A família de microcontroladores dsPIC permite que se utilize em conjunto dois
timers de 16 bits, formando um timer de 32 bits, tornando possível a contagem de tempos
maiores, concatenando o timer 2 com o timer 3.
55
1.8.5 Universal Asynchronous Receiver Transmitter (UART)
UART é um dispositivo de comunicação muito utilizado em entre computadores e
periféricos, como também entre microcontroladores. Onde um byte é transmitido de forma
serial através de 2 fios, um “RX” destinado a receber os dados e outro “TX” que envia os
dados. A comunicação entre os dispositivos podem ser full duplex, onde os dados são
transmitidos e recebidos ao mesmo tempo como half duplex, onde a transmissão e a recepção
de um dado ocorre de cada vez. Utiliza-se um protocolo de comunicação especifico, como
detecção de erro através de paridade, como também o envio de um start bit identificando o
inicio de transmissão e um stop bit, sinalizando o final de transmissão.
Segundo (SOUZA, 2008), o módulo UART do dsPIC possui as seguintes
características. Comunicação full duplex, a comunicação pode ser feita em 8 ou 9 bits,
permite o uso de 1 ou 2 stop bits, 4 níveis de pilha para transmissão e recepção de dados, ou
seja, um buffer que armazena 4 bytes que são transmitidos de forma seqüencial.
Ao receber um dado e também ao ser transmitido um dado, uma interrupção no
microcontrolador é gerada.
Os registradores utilizados para configurar o módulo UART são, “U1MODE, U1STA,
U1RXREG, U1TXREG e U1BRG”. A função dos registradores “U1MODE e U1STA” é configurar o
modo de funcionamento da UART, já o registrador “U1BRG” define o tempo de cada bit na
transmissão, baud rate. Os registradores “U1RXREG e U1TXREG” são utilizados para transmitir e
receber os dados pela UART.
56
O dsPIC possui pinos padrões para serem utilizados com o módulo UART, mas
como cada pino concentra mais de uma função, é possível deslocar o módulo UART para
outros pinos auxiliares, definidos como “U1ATX e U1ARX”.
O microcontrolador pode ser configurado para funcionar em modo “sleep”, onde
toda a fonte de clock é retirada dos periféricos, parando de funcionar. Utilizando a
configuração “wake” da UART é possível através da comunicação serial retirar o dsPIC do
modo “sleep”.
Ao efetuar a comunicação serial entre dois periféricos, se faz necessário que ambos
sejam configurados da mesma forma, no caso, possuam o mesmo baud rate. O modo de
detecção do baude rate pode ser utilizado para detectar o tamanho do bit que está chegando na
comunicação serial e com isso configurar automaticamente o baud rate da UART.
Pode ser configurada como será efetuada a comunicação, com 8 ou 9 bits, com ou
sem paridade. O dsPIC possui um gerador de paridade no qual o mesmo já calcula o valor a
ser enviado.
O buffer de transmissão possui 4 níveis, onde pode-se definir quando será gerada
uma interrupção no modo de transmissão da UART. Se o registrador correspondente a essa
configuração foi setada em 1, a interrupção será gerada após o envido de todo o buffer, em 0,
a cada shift register interno de envio, uma interrupção é gerada.
57
O registrador “URX1SEL1 e URX1SEL0” podem ser configurados de forma que uma
interrupção serial será gerada após o buffer de recepção estar completo com quatro bytes, ou a
cada três ou então a cada caractere recebido.
Outros bits nos respectivos registradores também são utilizados para identificar se a
UART está ocupada transmitindo ou recebendo um dado, se a paridade for recebida diferente
da enviada, se ocorrer erro na recepção do stop bit ou se o buffer de comunicação serial
ultrapasse o seu limite, conforme respectiva configuração descrita no manual do fabricante
(MICROCHIP, 2005).
1.8.6 Conversor analógico digital
Segundo (MICROCHIP, 2005) os microcontroladores dsPIC30F possuem um
conversor analógico digital que converte um sinal analógico ligado em uma de suas entradas
analógicas em um valor de 12bits. Esse mÓdulo de conversão analógico digital é baseado em
uma arquitetura de conversão de successive approximation registrer (SAR), que significa
registrador de aproximação sucessiva, com uma velocidade de conversão máxima de
100Ksps.
O dsPIC30F3013 possui um modulo AD com 10 entradas analógicas multiplexadas,
ou seja, pode-se ligar 10 sinais analógicos em um mesmo microcontrolador funcionando ao
mesmo tempo.
A tensão de referência do conversor analógico digital pode ser configurada para se
basear na alimentação do dispositivo nos pinos “AVdd/Avss” ou pelos pinos “Vref+ / Vref-“.
58
O módulo AD contém 6 registradores de 16bit sendo os registradores “ADCON1,
ADCON2 e ADCON3” controlam a operação do modulo AD, o registrador “ADCHS” selecionam os
canais de entrada a serem convertidos. O “ADPCFG” configuram os pinos como portas de
entrada analógico ou digital e o “ADCSSL” selecionam as entradas para conversão.
Este módulo também contém um buffer de 16 palavras somente leitura e de dupla
porta chamado de “ADCBUF0 até ADCBUFF”, onde os valores convertidos são armazenados. Este
buffer não pode ser escrito pelo software do programador.
Uma vez o módulo AD configurado inicia-se a aquisição dos dados, quando uma
conversão é completada o valor é carregado no buffer e uma flag de interrupção “ADIF” é
setada, onde o programa é desviado para a função de tratamento da respectiva interrupção e
dá os valores podem ser lidos do buffer executando as funções necessárias definidas pelo
programador.
É possível configurar um clock para o conversor AD assim como uma taxa de
amostragem específica chamada de “Tad”, tempo do módulo AD. Um Tad equivale a um
período de clock de 667 ns para Vdd igual a 5V conforme manual do fabricante e para uma
correta conversão pode trabalhar até o mínimo possível de 1tad.
O Tad deve ser definido no início do programa e calculado conforme
equacionamento ilustrado na Figura 1.13.
59
Figura 1.13 – Definição do Tad para conversor AD. Fonte – Microchip,2005.
O módulo AD necessita de um tempo de conversão de 14 Tad para que a conversão
seja executada corretamente e o buffer armazenado com os respectivos valores.
1.8.7 Modo de Modulação por Largura de Pulso.
Quem define o tempo do período para produzir o sinal PWM é o “timer 2” ou “timer
3”. O registrador que define o duty cycle é o “OC1RS”.
Por exemplo, digamos que o registrador “PR2” está configurado para 0xffff, podemos
escalonar o registrador “OC1RS” de 0 a 0xffff, de forma a termos uma resolução de PWM de
60
até 16 bits. Para acharmos a frequência de chaveamento do PWM, basta dividir o tempo de
contagem máxima do timer por 1.(SOUZA, 2008, p.160) .
Outra forma de utilizar o PWM é com pino de falha, que pode ser utilizado como um
sensor de temperatura do motor, que ao atingir um certo nível de temperatura, coloca este
pino em nível ‘0’, fazendo com que a saída PWM entre em alta impedância parando o motor,
que pode arrefecer e entrar em funcionamento logo em seguida.
1.8.8 Interrupções
As interrupções são estímulos internos ou externos ao microcontrolador, que no
momento que ocorrer e dependendo de sua prioridade, o dsPIC interrompe tudo o que está
executando e parte para o tratamento da respectiva interrupção. A prioridade das interrupções
ocorre de forma que se no momento em que uma interrupção está sendo tratada, uma outra de
maior prioridade ocorre, o microcontrolador irá parar de tratar a interrupção de menor
prioridade, tratar a interrupção de prioridade mais alta e em seguida continuar o tratamento da
interrupção de menor prioridade, voltando no final a executar sua tarefa normal até que uma
outra interrupção ocorra. Na Tabela 3 verifica-se algumas interrupção para o modelo do
microcontrolador dsPIC30F30125 com a respectiva função de tratamento da interrupção na
linguagem de programação C.
5 Microcontrolador da família DSP de 28 pinos desenvolvido pela Microchip.
61
Tabela 3 – Interrupções Disponíveis no dsPIC30F3012.
Vetor de Tratamento Interrupção Tratamento no C
8 Interrupção externa 0 _INT0Interrupt 9 Imput capture 1 _IC1Interrupt 10 Output compare 1 _OC1Interrupt 11 Timer 1 _T1Interrupt 12 Imput capture 2 _IC2Interrupt 13 Output compare 2 _OC2Interrupt 14 Timer 2 _T2Interrupt 15 Timer 3 _T3Interrupt 16 SPI 1 _SPIInterrupt 17 Recepção serial U1RX _U1RXInterrupt 18 Transmissão Serial U1TX _U1TXInterrupt 19 Conversão AD _ADCInterrupt 20 NVM Write Complete _NVMInterrupt 21 Interrupção de escravo I2C _SI2CInterrupt 22 Interrupção de mestre I2C _MI2CInterrupt 23 Interrupção de mudança de
estado _CNInterrupt
24 Interrupção externa 1 _INT1Interrupt 21 Interrupção externa 2 _INT2Interrupt 42 LVD – Low Voltage Detect _LVDInterrupt
Fonte – Programação em C para dsPIC, 2008.
Segundo (SOUZA, 2008), os registradores responsáveis pela configuração das
interrupções são os seguintes:
• IFS0, IFS1 e IFS2, - mantém o estado da ocorrência da interrupção,
informando se elas ocorreram ou não;
• IEC0, IEC1 e IEC2, - permitem habilitar as interrupções da Tabela 2;
• IPC0 a IPC10, - permitem configurar a prioridade das interrupções.
62
Para cada interrupção existem 3 registradores associados a ela, sendo um de
habilitação da interrupção que permite com que a interrupção ocorra ou não, outro para
configurar a prioridade da interrupção e o terceiro que informa se a interrupção ocorreu ou
não. No dsPIC é possível configurar a prioridade de cada interrupção em 7 níveis, de 1 a 7 e
quanto maior o valor numérico da interrupção, maior a sua prioridade.
1.8.8.1 Interrupção externa
Esta interrupção é conectada a pinos específicos do dsPIC e segundo (SOUZA,
2008), quando esta função especial está configurada para determinado pino, sempre que
ocorrer uma variação em uma borda, que pode ser configurada para borda de subida ou
descida, gera uma interrupção para o dsPIC.
A configuração da borda que irá ocorrer a interrupção é feita pelo registrador
“ INTCON2”. O bit 0 do respectivo registrador possibilita a configuração de que borda ocorrerá a
interrupção. Já a habilitação da interrupção externa é feita pelo registrador “IEC0 ”, através do
bit “ INT0IE ”.
Além da configuração da interrupção de um pino específico, se faz necessário
habilitá-lo como entrada e funcionando de forma digital.
Sempre que ocorrer uma interrupção externa, essa será desviada para função
específica para o tratamento da mesma. Chegando na função o bit de ocorrência da
interrupção deve ser limpo para evitar que a interrupção ocorra novamente.
63
1.8.8.2 Interrupção de timer
Uma interrupção de timer ocorre no momento em que há a sua contagem máxima.
Neste momento o programa é desviado para a função específica para o tratamento da
respectiva interrupção, onde no bloco de tratamento o bit de ocorrência deve ser limpo.
1.8.8.3 Interrupção de recepção serial
Ao receber um byte da comunicação serial, conforme configuração dos registradores
específicos para a comunicação UART, que pode ser por byte, caractere ou pelo buffer cheio,
uma interrupção de software é gerada. Neste instante ocorre um desvio para a função
específica para tratar dessa interrupção, que deverá ler o buffer da UART a fim de que o
mesmo seja limpo, desocupando a UART.
1.8.8.4 Interrupção de conversão AD
Toda vez que uma conversão Analógico Digital (AD) é efetuada, o modulo AD gera
uma interrupção, desviada e tratada pela função correspondente, onde o valor digital
correspondente ao analógico pode ser lido no buffer do conversor e utilizado de acordo com
as necessidades. Ao final deve-se setar o registrador da interrupção do conversor AD
indicando que a mesma foi tratada.
64
1.9 Plataforma de desenvolvimento
O desenvolvimento de toda lógica embarcada, ou seja, a programação do software,
dentro dos microcontroladores dsPIC, são efetuadas através de plataforma disponibilizada
pelo próprio fabricante do dispositivo, chamada de MPLAB IDE.
Conforme (SOUZA, 2008) o MPLAB IDE é um ambiente onde o programador
executa o desenvolvimento do seu projeto, rodando como um módulo de software, um
compilador intitulado de C30, também desenvolvido pela Microchip, toda vez que o código
gerado for compilado o MPLAB executa o C30 para tratar o arquivo no qual o projeto está
sendo desenvolvido.
O MPLAB IDE é um ambiente do tipo Integrated Development Environment
(Ambiente Integrado de Desenvolvimento), pois neste ambiente pode-se trabalhar com
diversas linguagens de programação. Dentre as linguagens pode-se utilizar C, Assembler e
Basic. O compilador C30 é a linguagem C para o dsPIC.
Ao criar um novo projeto para desenvolvimento, deve-se selecionar o compilador
utilizado no caso o C30, assim como também o microcontrolador utilizado, pois cada modelo
de microcontrolador possui características diferentes, portas diferentes com seus respectivos
recursos. Deve-se lembrar que em cada projeto deve-se incluir o arquivo de biblioteca e de
ligação específicos para o microcontrolador escolhido, para que o compilador possa funcionar
corretamente, como verifica-se na tela capturada ilustrada pela Figura 1.14.
65
Figura 1.14 – Área de trabalho MPLAB. Fonte – Autor, 2009.
Circulado por uma elipse na janela “Workspace” ilustrado pela Figura 1.14 verifica-
se os respectivos arquivos de biblioteca e ligação para o dsPIC30F3013. Assim como também
a janela de desenvolvimento da programação em C e a respectiva janela “output” onde
verifica-se os erros gerados no programa e status de todas as etapas de desenvolvimento.
1.9.1 Compilador C30
Segundo (MPLAB C30, 2007), o MPLAB C306 compila arquivos fonte C
produzindo arquivos de linguagem de montagem. Estes arquivos gerados pelo compilador são
ligados e montados com outros arquivos de objeto e bibliotecas para produzir o programa
final em “COFF” executável ou em formato “ELF”. Os arquivos gerados são carregados no
MPLAB IDE onde podem ser testados e depurados.
6 Compilador para linguagem de programação C utilizado no desenvolvimento de programas para microcontroladores dsPIC.
66
O compilador C30 traduz programas padrão “ANSI C” para linguagem de montagem
dsPIC DSC, suportando comando e extensões de linguagem que permitem o completo acesso
e controlo dos recursos de hardware do dsPIC.
1.9.1.1 Funções e Macros de Configuração
Segundo (SOUZA, 2008), todos os recursos do dsPIC podem ser configurados
diretamente através dos registradores específicos ou de funções e macros do C30. O C30
disponibiliza uma série de funções que facilitam a programação dos diferentes recursos de
cada microcontrolador.
Um exemplo onde os macros podem ser utilizados são os bits de configuração, que
definem recursos do dsPIC como forma de utilização do “clock”, “watchdog” e proteção de
leitura do programa, conforme exemplo transcrito a seguir:
//************************************************* ******** _FOSC(CSW_FSCM_OFF & HS); // Oscilador externo sem tratamento de erro _FWDT(WDT_OFF); // WatchDog disabilitado _FBORPOR(MCLR_EN & PBOR_OFF & PWRT_OFF); // Habilit a MCLR, Desabilita
//PBOR e PWRT _FGS(CODE_PROT_OFF); // Sem protecao de codigo - é possível a leitura // posterior a gravação do chip //************************************************* ***********
Com o código macro, ao ser compilado o programa, o compilador utiliza sua
biblioteca reconhecendo nos macros os bits corretos de cada registrador específico para a
configuração dos respectivos recursos do microcontrolador, através das bibliotecas e arquivos
de ligação definidos corretamente para o modelo de dsPIC utilizado.
67
Dessa mesma forma pode-se utilizar recursos de macros para a inicialização e
configuração de recursos como a UART, onde verifica-se um exemplo de código transcrito a
seguir:
void inicia_UART2() //ROTINA PARA INICIALIZAR A UA RT unsigned int ubrg; //define a variável ubrg unsigned int config1; //define a variável config1 unsigned int config2; //define a variável config2 CloseUART2(); // desabilita a UART2 ubrg = 32; // ubrg=(fcy/(BaudRate*16))-1 // fcy=FCristal/4 // Neste Caso: Baud Rate=9600 // Freq.Cristal=20MHz
// fcy=5MHz, ubrg=31,55 ConfigIntUART2(UART_RX_INT_EN & //Função para conf iguração das
//interrupções da UART //habilita a interrupção de recepção UART_RX_INT_PR2 & //Define a prioridade da interrup ção de recepção=2 UART_TX_INT_EN & //habilita a interrupção de transm issão UART_TX_INT_PR4); //Define a prioridade da interrup ção de transmissão=4 config1= UART_EN & //Define a variável config1 com os seguintes
//parâmetros. Habilita o módulo UART UART_IDLE_CON & //UART funcionando no modo IDLE UART_RX_TX & //Configura a comunicação através dos pinos padrões //de TX e RX (U1TX e U1RX) UART_DIS_WAKE & //Desabilita o modo "Wake-up" UART_DIS_LOOPBACK & //desabilita o modo "loop back" UART_DIS_ABAUD & //Desabilita o modo "autobaud" UART_NO_PAR_8BIT & //Define a comunicação com 8 bi ts de dados e //sem bit de paridade UART_1STOPBIT; //Define o Stop Bit=1 config2=UART_INT_TX_BUF_EMPTY & //Define a variável config2 com os seguintes
//parâmetros //Ocorre interrupção de transmissão quando //buffer de transmissão for esvaziado
UART_TX_PIN_NORMAL & //Define o bit TXBreak como no rmal UART_TX_ENABLE & //Habilita a transmissão da UART UART_INT_RX_BUF_FUL & //Ativa a interrupção de rece pção quando Buffer
//estiver cheio (4 bytes)
UART_ADR_DETECT_DIS & //Desativa o modo de "adress detect" UART_RX_OVERRUN_CLEAR; //Limpa o flag de "overrun" OpenUART2(config1, config2, ubrg); //Habilita a UAR T2 com os parâmetros
//de configuração definidos pelas //variáveis Config1, config2 e ubrg
68
Da mesma forma como utiliza-se macros para a configuração da UART, pode-se
utilizá-los em todos os outros recursos disponíveis em cada microcontrolador, utilizando-se o
respectivo manual do usuário contido junto com a instalação do compilador C30. (MPLAB
C30, 2007).
Existem funções especificas reconhecida pelo compilador C30 que podem ser
utilizadas pelo programador, principalmente para o tratamento das interrupções geradas no
microcontrolador. Ao ocorrer uma interrupção, o programa é desviado para a respectiva
função para o tratamento dessa interrupção, como pode-se verificar no código descrito a
seguir exemplificando uma função de tratamento da interrupção de recebimento de um dado
na UART2.
//********** tratamento interrupção UART2 RX ****** ************** void __attribute__((__interrupt__)) _U2RXInterrupt( void) IFS1bits.U2RXIF = 0; //Limpa flag de tratamento da interrupção //************************************************* ************
A função deve ser chamada pela sintaxe específica, para o correto reconhecimento
pelo compilador. Dentro dela executa-se as funções necessárias para o tratamento da
respectiva interrupção, como no caso do exemplo, o recebimento dos dados que estão
armazenados no buffer da UART. Ao final da função utiliza-se um macro, onde um bit do
registrador é zerado identificando que a interrupção foi tratada.
1.9.2 Processo de gravação do microcontrolador
Com o programa desenvolvido em linguagem C e compilado utilizando o compilador
C30 é necessário efetuar a gravação no respectivo microcontrolador, utilizando a ferramenta
69
de gravação ICD2 BR da empresa LabTools7. O ICD2, visualizado na Figura 1.15, é ligado ao
computador pessoal e comunicado com o MPLAB através de uma porta de comunicação USB
e que permite a gravação da maioria dos microcontroladores desenvolvidos pela Microchip.
Figura 1.15 – Ferramenta de Gravação ICD2 Fonte – Álison, 2008
Conectando a ferramenta de programação no computador, se faz necessário
selecionar e configurar corretamente o dispositivo ICD2 no MPLAB, sendo dessa forma
possível verificar o estado do microcontrolador a ser utilizado, apagar o programa já gravado
e gravar um novo programa desenvolvido. Tudo isso, através da ferramenta ICD2, efetua-se a
gravação “in circuit”, ou seja, gravação efetuada com o microcontrolador já inserido no
circuito final através dos respectivos pinos de gravação, não tendo a necessidade de remover o
dispositivo toda ver que um novo programa precise ser gravado, somente conectando um cabo
do ICD2 para a placa onde está conectado o dsPIC.
7 LabBTools, Mosaico Didactic Division, empresa localizada em Santo André/SP, que comercializa produtos didáticos, cursos, livros e componentes.
70
2 DESENVOLVIMENTO DO HARDWARE
Partindo-se de projetos de robôs já construídos e utilizados em competições,
determina-se a melhor forma de construção do protótipo de um novo robô, utilizando-se de
materiais disponíveis no mercado local, assim como a possibilidade de desenvolvimento das
peças necessárias.
2.1 Mecânica do Robô
A primeira definição necessária para iniciar o projeto é com relação à forma de
tracionamento, a quantidade e tipo de motores, rodas a serem utilizadas e como dispor todos
os componentes de forma compacta e eficiente, de forma a contemplar todos os requisitos
dispostos nas regras de competições oficiais.
2.1.1 Dirigibilidade
No decorrer de uma batalha, se faz necessário que o robô, além de ter força para
empurrar o adversário para fora da arena, que ele tenha velocidade e mobilidade, a fim de que
possa manobrar de forma eficiente, livrando-se de situações de risco e também atacando o
adversário da melhor forma. Para essa mobilidade é preciso que ele possua um sistema de
71
direção, para que possa fazer curvas com diversos ângulos, assim como poder andar para
frente e para trás em linha reta.
Analisaram-se diversas formas de dirigibilidade, como tracionar as duas rodas
traseiras com um motor para cada uma colocando uma roda independente na dianteira,
tracionando-se uma roda e deixando a outra roda parada, o robô faria as curvas normalmente.
Detecta-se algumas limitações tracionando somente as rodas traseiras que seriam: a
perda de tração e força na parte frontal do robô, deixando-o frágil para um ataque lateral
dianteiro, assim como também aumentando o seu ângulo de manobra. Pois tracionando-se
uma roda para frente e outra para trás o robô iria girar no centro do eixo traseiro, necessitando
mover toda a dianteira para se livrar do adversário.
Continuando no princípio da dirigibilidade controlando a rotação de cada roda onde
se girando uma mais rápido que a outra faria com que o robô fizesse uma curva, partiu-se para
a idéia de tracionamento nas quatro rodas, no mesmo princípio das esteiras de um tanque de
guerra. Assim aumentando o poder de tracionamento, pois tanto a dianteira quanto a traseira
do robô estariam tracionando na arena, não deixando nenhum lado mais vulnerável que o
outro. Dessa forma aumentando a sua dirigibilidade, pois tracionando nas quatro rodas, sendo
as duas da direita para frente e as duas da esquerda para trás, o robô gira no seu eixo central,
podendo se posicionar melhor contra o adversário em um espaço mais reduzido.
Nesse sistema de dirigibilidade do robô é inevitável o arraste das rodas na arena, o
que reduz a força do robô para empurrar seu adversário. Faz-se necessárias algumas
adequações do sistema, como o atrito das rodas onde não pode ser muito larga para que o robô
72
não perca força nas curvas, mas também não pode ser muito fina, pois perderia tração diante
do seu adversário. Assim como também um correto controle pelo sistema eletrônico dos
motores, a fim de eliminar o arraste das rodas em determinadas situações.
2.1.2 Motor utilizado
Com o objetivo de agregar força, controle de velocidade e direção, sendo possível
mover o robô para todos os lados, se faz necessário a utilização de um motor DC. Pois através
de um PWM é possível em um motor de corrente continua, controlar a sua velocidade, assim
como também inverter a sua direção, fazendo com que ele gire para os dois lados, levando o
robô para frente e para trás de forma rápida e eficiente.
No mercado existem diversos tipos de motores DC, uns grandes, outros pequenos,
mais velozes e mais lentos, assim como também diversas tensões de alimentação.
Algumas limitações são impostas pelas regras das competições, como o tamanho do
robô e também o seu limite de peso em 3 Kg. Definindo dessa forma o tamanho e o peso do
motor, para que se somando a todo o conjunto não ultrapasse o peso máximo.
Um motor de grande potência faz-se necessário uma fonte de alimentação
equivalente, onde se baseou a escolha do motor correto, pois além do peso do mesmo, é
preciso acrescentar a bateria para fornecer a tensão e a corrente necessárias para o robô
funcionar por pelo menos 180 segundos, sem necessitar de troca da mesma, cumprindo as
regras da competição. Dessa forma optou-se por um motor de 12V, por ser uma tensão de
73
alimentação mais comum no mercado, tanto para motores como para baterias, tornando fácil a
substituição em um eventual defeito.
Mesmo os motores mais lentos encontrados no mercado, possuem no seu eixo uma
rotação muito elevada, tornando impossível a ligação do mesmo diretamente ao eixo da roda,
sendo necessário utilizar um sistema de redução. Assim diminuindo a velocidade e
aumentando o torque do motor. Uma possibilidade existente no mercado são motores com
caixas de redução acopladas, fazendo com que tenha um torque elevado a velocidades
reduzidas, sendo essa uma boa escolha para equilibrar força e velocidade ao robô.
Ao aumentar o torque do motor e aplicando uma força no seu eixo, a corrente
consumida pelo mesmo se torna elevada, chegando a alguns ampéres. Com essa corrente
elevada se faz necessário a utilização de baterias compatíveis com a corrente exigida. Baterias
que fornecem correntes elevadas possuem sua área equivalentemente grande, como também o
peso. Necessitando-se equilibrar todos os fatores para a escolha correta do motor.
Na Figura 2.1, ilustra-se o motor escolhido e encontrado no mercado.
74
Figura 2.1 – Motor Utilizado. Fonte – INMEPE MAIA, 2009.
O primeiro motor utilizado possui alimentação de 12V rotação de 538,6 RPM no seu
eixo a um torque de 0,6Kgf.cm. Sendo utilizado comercialmente como movimentador de
sistemas de iluminação profissional de shows e danceterias. Produzidos no Brasil, torna-se
viável a sua utilização devido ao menor custo e facilidade de substituição em um eventual
defeito, pois utilizando-se motores importados ou de ferramentas sucatas torna o modelo
único, dificultando um upgrade ou manutenção no robô.
Com testes efetuados utilizando-se o peso máximo do robô de 3 Kg, verifica-se que o
mesmo possui pouca força para empurrar um adversário do mesmo peso e até mesmo para
efetuar giros no seu eixo, onde se faz necessário romper o atrito da suas próprias rodas. Com
isso altera-se o motor do mesmo fabricante por um modelo com as mesmas dimensões, mas
com relações de engrenagens de redução diferentes, alterando a velocidade para 250 rpm e um
torque de 1,6 Kgf.cm. Assim a velocidade do robô é diminuída pela metade, o que não
75
influencia muito, pois antes a velocidade estava muito alta e o torque aumenta-se para quase
três vezes o anterior.
Com um torque de 1,6 Kgf.cm por motor, sem considerar o atrito dos rolamentos em
cada roda, o robô possui força para empurrar um adversário de 3,2 Kg. Assim como também
ao efetuar um giro no seu eixo, quebrando o atrito das suas próprias rodas possui força
necessária para locomover o próprio peso que é no máximo 3 Kg.
2.1.3 Sistema de transmissão
Com o sistema de controle e dirigibilidade do robô definido, que é o tracionamento
das 4 rodas controladas aos pares sendo as duas direitas e as duas esquerdas, assim como
também o tipo, modelo e características do motor, se faz necessário desenvolver um sistema
de transmissão do torque do motor para as rodas.
Analisando-se os robôs construídos por outras equipes e com a intenção de agregar a
menor quantidade de peso possível, parte-se para uma forma de transmissão com a utilização
de correias e 1 motor para cada par de rodas, ligando o motor às duas rodas de cada lado
simultaneamente.
Para evitar que a correia patine quando uma grande força é aplicada ou uma inversão
muito brusca no motor, optou-se em utilizar um sistema de correia dentada com engrenagens
de acoplamento. Onde uma engrenagem é fixa no motor e outras duas, uma em cada roda.
Também sendo possível alterar a relação de torque e velocidade, simplesmente alterando a
relação de diâmetro entre a engrenagem do motor e a das rodas.
76
Utilizando-se do software Solid Works 2008, desenvolvem-se os desenhos das partes
necessárias para a construção do robô.
Na Figura 2.2 pode-se verificar a ilustração do projeto da engrenagem do motor.
Figura 2.2 – Engrenagem do Motor. Fonte – Autor, 2009.
Essa engrenagem possui 15mm de largura, aproximadamente 31mm de diâmetro e
um furo central passante para acoplar no eixo do motor de 6mm. Para a fixação da
engrenagem ao eixo do motor de forma que não escorregue, aplicam-se 2 parafusos de 3mm
de diâmetro um de cada lado da engrenagem.
77
De forma a não agregar muito peso ao robô, devido a sua limitação, encontrou-se um
material plástico bastante leve e resistente utilizado na industria. Um tipo de polímero
reforçado com fibras sintéticas ou minerais com o intuito de diminuir o peso e aumentar a
resistência mecânica.
O diâmetro da engrenagem define-se devido ao tarugo do material encontrado no
mercado, já a largura é para que a engrenagem tenha uma boa área de excursão e uma melhor
forma de alinhamento com as outras duas engrenagens do sistema.
Na Figura 2.3, ilustra-se o projeto das engrenagens acopladas as rodas.
Figura 2.3 – Engrenagem da Roda. Fonte – Autor, 2009.
A engrenagem da roda é responsável direta para a transmissão do torque do motor
para a movimentação do robô. Dessa forma baseando-se em um sistema de rodas de roller, é
utilizado um eixo central para ligar as rodas à estrutura do robô e para isso é necessária a
78
utilização de dois rolamentos em cada roda, sendo um rolamento em cada extremidade do
sistema engrenagem roda. Inserindo-se um rolamento na roda e outro na engrenagem
acoplada. Devido a essa configuração, verifica-se no desenho da engrenagem da roda, uma
perfuração para o acoplamento do rolamento, onde o mesmo é pressionado com o rolamento
do lado oposto, através de um parafuso de 6mm de diâmetro e o sistema fixado com uma
porca. Uma outra porca é utilizada para fazer a fixação do eixo na estrutura do robô.
Como não é possível exercer um aperto muito elevado nos rolamentos, pois os
mesmos travam, o acoplamento entre a engrenagem e a roda torna-se prejudicado,
escorregando facilmente, assim se faz necessário colar a engrenagem à roda utilizando cola
Araldite profissional 24 horas, para que a engrenagem não patine e a roda perca tração.
A engrenagem da roda possui o mesmo diâmetro da engrenagem do motor, 20mm
de largura, uma perfuração passante de 10mm para o eixo e um recorte de 17mm de diâmetro
com 7 mm de profundidade para inserção do rolamento.
A ligação entre as engrenagens faz-se com uma correia encontrada no mercado de
eletrodomésticos da marca Arno. Uma correia dentada de 6mm de largura, com 380mm de
comprimento e suficientemente forte para tal aplicação.
2.1.4 Desenvolvimento das Rodas
Inicialmente pensa-se em utilizar rodas já existentes no mercado, até mesmo
adaptando-as as necessidades e dimensões do projeto. Isso não é possível devido à
exclusividade do sistema de transmissão projetado para acoplar a engrenagem. Partindo-se
79
assim para o desenvolvimento de uma roda própria, onde dessa forma é possível adaptar o
projeto da melhor forma e não sofrer com a escassez de um determinado tipo de roda no
mercado.
Devido à pequena quantidade de rodas utilizadas, não é possível desenvolvê-las de
forma injetada. A forma mais prática e barata é fazendo-as da mesma forma que as
engrenagens, através de um tarugo encontrado no mercado e torneando-as.
Para se ter uma boa velocidade do robô nas disputas, é necessário que a roda possua
um diâmetro grande, baseando-se dessa forma em rodas de roller, encontra-se no mercado um
tarugo de Poliuretano (PU) de 70mm de diâmetro, onde desenvolve-se as rodas conforme
ilustrado na Figura 2.4.
Figura 2.4 – Roda de PU. Fonte – Autor, 2009.
80
Desenvolve-se assim um roda com 68mm de diâmetro para retirar uma pequena
camada externa do tarugo original, uma furação passante central para a passagem do eixo, um
corte central em um dos lados de 17mm de diâmetro por 7mm de profundidade para inserir o
rolamento, 25mm de largura e com seus cantos chanfrados, para dessa forma facilitar nas
curvas dando um melhor atrito no solo.
2.1.5 Montagem do Robô
Com o desenvolvimento de todas as peças constituintes do sistema de tração e
transmissão do robô, passa-se para o desenvolvimento em Solid Works das laterais que
servem de apoio para sustentação das rodas, motores e engrenagens.
Por ser um material mais leve e fácil de trabalhar, utiliza-se alumínio para a lateral
do robô, desenvolvendo-se a lateral direita simétrica a lateral esquerda sendo as duas unidas
por 4 pilares em suas extremidades. Conforme verifica-se na ilustração da Figura 2.5.
81
Figura 2.5 – Vista lateral, superior, frontal e em perspectiva. Fonte – Autor, 2009.
Desenvolve-se as laterais de forma a ser possível levantar ou baixar o motor para
fazer o ajuste e tracionar a correia, assim como também de forma a possuir 180mm de cada
lado. Pois se aplicará uma estrutura externa para proteger as rodas do robô de ataques dos
adversários, assim como também essa estrutura servirá de suporte para os sensores utilizados.
Como os motores consomem correntes em torno de 1A quando exigido torque, se faz
necessário utilizar baterias compatíveis com a corrente exigida e com o peso máximo do robô.
Assim são aplicadas duas baterias de 1,3AH, 12V e 577g, sendo o posicionamento do motor e
das rodas determinado devido ao tamanho das baterias e o comprimento da correia
tracionadora de 380mm. Na Figura 2.6 verifica-se a bateria escolhida para a aplicação.
82
Figura 2.6 – Bateria Utilizada. Fonte – Manual Técnico Unicoba, 2003.
Simulando-se toda a estrutura no software Solid Works, estipulando a liga dos
materiais utilizados e a bateria, obtém-se um peso máximo de aproximadamente 1,9Kg. O que
dá uma grande margem para acrescentar outros materiais e sistemas necessários para o melhor
funcionamento do robô.
Utilizando a furadeira de bancada do laboratório de protótipos da Feevale, fez-se as
perfurações necessárias para cada lateral do robô, onde são fixas em cada uma, duas rodas, o
motor, as engrenagens e a correia.
Na Figura 2.7, verifica-se a ilustração do projeto do posicionamento das furações
realizadas na lateral.
83
Figura 2.7 – Furação Lateral. Fonte – Autor, 2009.
Com as devidas perfurações e a lateral montada, utilizando-se uma fonte de 12V, fez-
se alguns testes de tracionamento e alinhamento da correia, onde verifica-se a necessidade de
ajuste na tensão da correia, assim como um sistema de alinhamento, para que a mesma não
escape da engrenagem. Com isso desenvolve-se uma polia do mesmo material das
engrenagens com o objetivo de guiar o movimento da correia, assim como também regular a
tensão da mesma.
Na Figura 2.8 ilustra-se o projeto da polia.
84
Figura 2.8 – Polia. Fonte – Autor, 2009.
Por ser um material bastante resistente e liso, não há a necessidade de utilizar um
rolamento no eixo na polia, simplesmente a utilização de um eixo liso, que é conectado a
lateral do robô utilizando-se uma porca e contra porca, o mesmo sistema utilizado na fixação
das rodas.
Com as laterais montadas, é necessário uni-las de forma alinhada e com o
espaçamento correto. Para isso utiliza-se de uma barra roscada8 (fuso) com 6mm de diâmetro.
Perfurando a extremidade de cada lateral insere-se a barra roscada utilizando-se de porca e
contra porca para prender cada lateral. Dessa forma é possível ajustar através das porcas a
distância exata entre as laterais do robô para obter-se o tamanho estipulado no regulamento.
8 Barra de 1 metro de comprimento com rosca em toda a sua extensão.
85
2.1.6 Pára-choque e suporte da bateria
No decorrer de uma disputa é necessário que o robô entre em contato com o
adversário e com isso não sofra nenhuma avaria. Dessa forma desenvolve-se um pára-choque
como utilizado nos carros para proteção, assim como também servindo de suporte dos
sensores e da bateria.
Pesquisando no mercado encontra-se um material chamado “plast glass”, semelhante
em sua transparência com um acrílico, porém mais resistente. Assim com uma chapa de 6mm
de espessura, as laterais e o fundo são cortadas e parafusadas conforme é ilustrado na Figura
2.9 desenvolvida no software SolidWorks.
Figura 2.9 – Pára-choque, vista em perspectiva. Fonte – Autor, 2009.
86
Por possuir 6mm de espessura, o “plast glass” se torna muito pesado para o robô o
que pode ultrapassar o peso máximo estipulado no regulamento, então dessa forma a proteção
das rodas são desenvolvidos da altura necessária somente para uma eficácia proteção e
menores acréscimos de peso. Igualmente os suportes de bateria são desenvolvidos para a
utilização de duas baterias chumbo ácidas de 12V e 1,3AH ligadas em paralelo, para se obter
uma maior autonomia, o que acarretou em um peso extra e se torna necessário a utilização de
uma única bateria.
2.2 Sistemas eletrônicos de controle
Os sistemas eletrônicos utilizados no protótipo se baseiam em sensores e atuadores
de forma a automatizar eficientemente o protótipo do robô de sumô nas seguintes áreas.
Sistema de controle a atuação eletrônica nos motores DC através de circuitos chamados de
ponte H, sensores para identificar o adversário a longas distâncias do tipo sonar e sensores
que identifiquem a borda da arena do tipo reflexivo.
Também são desenvolvidos circuitos de controle do robô, como o circuito
responsável pelo início do combate onde se faz necessário identificar o apagamento de um
LED branco de alto brilho na arena, assim como também circuitos que identifiquem e
controlem a carga da bateria, para que a mesma não fique abaixo da tensão de corte,
ocorrendo a sua danificação permanente.
Para que não seja necessário retirar cada bateria do robô para carregar, desenvolve-se
também um circuito carregador de duplo estágio controlado pelo microcontrolador.
87
Para que todos os sensores e dispositivos do robô sejam controlados, utiliza-se 2
microcontroladores dsPIC, sendo um deles com o objetivo de controlar os sensores de borda
da arena e a carga da bateria, transmitindo pela UART para o outro microcontrolador,
responsável pela tática de combate, controle dos sensores sonar, controle do sensor de início
da partida e dos motores para a movimentação do robô na arena.
2.2.1 Desenvolvimento da ponte H
Com a utilização de dois motores DC se faz necessário a utilização de duas pontes H,
uma para cada motor, com a finalidade de polarizá-los para que através do microcontrolador
seja possível controlar o sentido de giro de cada motor, assim como também freia-los.
Para um menor consumô de bateria, utiliza-se Transistor de Efeito de Campo (FET),
para efetuar o chaveamento da ponte H, sendo quatro para cada motor e um quinto FET em
cada motor para efetuar o chaveamento do PWM controlado pelo dsPIC, com o objetivo de
aumentar e diminuir a velocidade de cada motor.
Na Figura 2.10 ilustra-se o circuito utilizado para controlar os dois motores DC.
88
Q4IRF530N
Q5IRF530N
Q2IRF9530
Q3IRF9530
Q1IRF9530
J6
HDR1X8_M
J5
HDR1X8_M
J4
HDR1X8_M
U4A
7406N
2 1
U4B
7406N
4 3
U4C
7406N
6 5
U4D
7406N
8 9
U4E
7406N
10 11
U4F
7406N
12 13
R71.0kOhm_5%
D1
1N4148
R81.0kOhm_5%
D2
1N4148
R91.0kOhm_5%
D3
1N4148
VAGOVAGO
R124.7kOhm_5%
+12V
+5VGND
Bateria1
MKDS15_2RMM_M
+V
-V GND
C4100nF
C3
10uF_tant
DIR-BRK-0-M2
DIR-BRK-0-M1
DIR-BRK-1-M1
PWM-H-M2
PWM-H-M1
DIR-BRK-1-M2
Q9IRF530N Q10
IRF530N
Q7IRF9530
Q8IRF9530
Q6IRF9530
R151.0kOhm_5%
D4
1N4148
R161.0kOhm_5%
D5
1N4148
R171.0kOhm_5%
D6
1N4148
Motor2
+V
-V
Motor1
+V
-V
LD1
LedV_3
R44.7kohm
LD2
LedV_3
+12V
Bateria2
MKDS15_2RMM_M
+V
-V GND
DB1
1N4001GP
DB2
1N4001GPjump1
HDR1X2_M
jump2
HDR1X2_M
Vreg
U2LM7805CT
INOUT
geral
Key = Space
R54.7kohm
R64.7kohm
R144.7kohm
R134.7kohm
Figura 2.10 – Controle Motores DC. Fonte – Adaptação Autor, 2009.
Para que não ocorra uma situação de acionamento em curto circuito da ponte H, são
utilizados FETs complementares, um canal N e outro canal P acionados por um mesmo pino
do microcontrolador. Os FETs complementares utilizados são “IRF530N e IRF9530”, ambos
do mesmo fabricante e com as mesmas características para que o acionamento na ponte H de
89
cada um dos FETs não ocorra em tempos diferentes, desestabilizando a ponte e dessa forma
gerando um maior aquecimento e gasto de bateria.
Como forma de aumentar a tensão de chaveamento dos FETs, pois a ponte H é ligada
em 12V juntamente com o motor e a tensão do microcontrolador que é de 5V, utiliza-se um
circuito integrado 7406, que é um conversor Transistor Transistor Logic (TTL) /
Complementary Metal Oxide Semiconductor (CMOS), com a saída em coletor aberto para até
30V. Assim como também utiliza-se diodos de sinal 1N414 como forma de proteção dos
pinos do microcontrolador.
Os FETs denominados de Q1 e Q6 em cada uma das pontes H são responsáveis pelo
chaveamento da tensão sobre os motores. Esse chaveamento PWM é controlado pelo
microcontrolador, onde é possível aumentar e diminuir a velocidade de cada motor
independentemente, conforme a lógica efetuada na programação.
Os LEDs são utilizados como forma de identificar o acionamento dos motores pelo
PWM.
2.2.2 Sensores de borda
Como sensores para detectar a borda branca da arena para que o robô se mantenha
dentro da mesma, utiliza-se sensores reflexivos calibrados para que ao invés de detectar um
obstáculo diferencie o centro da arena preta com a sua borda branca.
90
Utiliza-se dessa forma quatro sensores reflexivos nos quatro cantos do robô, para que
suas rodas não caiam fora da arena e assim seja derrotado. Como um sensor reflexivo é
composto por um foto-diodo e um foto-transistor, cada diodo é acionado independentemente
por um pino do microcontrolador, onde os 5 V do microcontrolador são limitados por um
resistor de 150Ω resultando uma corrente de aproximadamente 27mA para cada sensor.
Para economizar bateria, os sensores reflexivos são multilexados no tempo, ou seja, a
cada intervalo de tempo apenas 1 sensor fica ativo, consumindo somente os 27mA e não 4
vezes esse valor. Dessa forma também economiza-se pinos de entrada do microcontrolador,
onde todos os foto transistores, recepção dos sensores reflexivos, são ligados em paralelo em
um circuito comparador de tensão e esse comparador ligado na interrupção externa “INT1” do
microcontrolador.
Na Figura 2.11 ilustra-se o circuito do comparador de tensão utilizado nos sensores
de borda.
91
Figura 2.11 – Comparador de tensão dos sensores de borda. Fonte – Autor, 2009.
Ao receber um sinal vindo do foto diodo refletido na parte branca da arena, o foto
transistor entra em estado de condução gerando uma corrente de IC. Essa corrente gera uma
queda de tensão no resistor de “10K” que é comparada com uma tensão de teste regulada pelo
trimpot. Se a tensão sobre o resistor de “10K” é maior que a tensão de teste, a saída do
comparador é acionada, ligando o LED de teste e acionando a interrupção “INT1” do
dsPIC30F3013.
Utiliza-se um resistor de “10K” para que uma pequena corrente gere uma queda de
tensão inversamente proporcional, facilitando o ajuste do comparador de tensão.
Mesmo utilizando-se sensores reflexivos do mesmo fabricante e modelo, eles
possuem algumas características de funcionamento diferentes, com isso cada sensor é
ajustado na altura em relação ao solo independentemente, já o comparador de tensão se faz
92
necessário para que todos os sensores possuam um ponto de acionamento regulado
concomitantemente através do trimpot, devido a diferentes materiais utilizados nas arenas de
cada campeonato.
Mesmo o dsPIC possuindo tecnologia CMOS, trabalhando de 2,5V até 5,5V, ao ser
alimentado com VDD igual a 5V o pino de interrupção externa não identifica uma interrupção
com um sinal muito abaixo da tensão de VDD utilizada. Ao utilizar o amplificador
operacional CA3140 alimentado com VDD igual a 5V, a sua saída referente a comparação é
de no máximo 3,7V, dessa forma utiliza-se o circuito da Figura 2.12 para efetuar o casamento
da sua saída com o padrão TTL.
Figura 2.12 – Conversão da saída do CA3140 para nível TTL. Fonte – INTERSIL, 2005.
Dessa forma de faz necessário alimentar o operacional diretamente da bateria, com
12V em V+ e terra no V-.
2.2.3 Sensor de início da disputa
Para que o início da disputa entre os dois robôs de sumô seja devidamente
coordenada, é estipulada nas regras da competição a forma adequada que todos os
93
competidores devem seguir. Para isso a arena é construída com um LED de 5mm
devidamente acondicionado no piso, na posição em que cada competidor deve iniciar. Para
que a partida comece, o arbitro aciona um botão desligando ambos os LEDs indicando para
cada robô o seu início.
Assim, utiliza-se um Resistor Dependente de Luz (LDR), que é um resistor que varia
seu valor ôhmico conforme a incidência de luz, em uma abertura criada na parte inferior do
robô. Esse sensor é ligado em um circuito comparador inversor de tensão, conforme verifica-
se o circuito ilustrado na Figura 2.13.
Figura 2.13 – Comparador de tensão para inicio da disputa. Fonte – Autor, 2009.
Ao incidir luz sobre o LDR utilizado no circuito, a sua resistência diminui, para
aproximadamente 500 Ω, dependendo da intensidade. Da mesma forma sem nenhuma fonte
de luz, sua resistência varia em torno de 5KOhm. Assim ao incidir a luz da arena no sensor
LDR a sua resistência diminui, diminuindo também a queda de tensão sobre ele, efetuando a
comparação no amplificador operacional com a tensão ajustada no trimpot. Como o
94
operacional está configurado como inversor, quando a tensão do LDR é menor que a tensão
do trimpot a saída é habilitada ligando um LED de indicação. Essa saída por sua vez indica
nível alto de tensão na porta “RE0” do processador dsPIC30F2010.
Com o sinal do sensor ligado corretamente em um pino digital do microcontrolador,
é possível através do software determinar o inicio da partida, efetuando a movimentação do
robô na arena.
2.2.4 Carregador de bateria
Para evitar que a bateria seja retirada de dentro do robô para efetuar a carga,
desenvolve-se um circuito carregador, utilizando a técnica de carga em dois estágios, onde é
possível carregar a bateria de forma mais rápida sem que a mesma seja danificada.
O primeiro estágio consiste em uma carga por corrente limitada em 450mA que é a
corrente máxima de carga para a bateria utilizada conforme manual do fabricante
(UNICOBA, 2003), para que a mesma não seja danificada. Ao atingir a tensão de 14,5V na
bateria, o microcontrolador através do seu conversor AD identifica essa tensão chaveando o
carregador para uma tensão constante de 13,5V, mantendo a carga da bateria em flutuação,
onde evita-se o super aquecimento dos elementos internos da bateria e carregando-a até a
carga máxima.
Ilustrado na Figura 2.14 verifica-se o circuito para o carregamento de 1 bateria
utilizando a técnica de 2 estágios.
95
Figura 2.14 – Carregador de Bateria. Fonte – Autor, 2009.
Utiliza-se uma fonte de alimentação do circuito carregador de 25V para que seja
fornecido 14,5 volts para a bateria e também aproximadamente 4V de queda de tensão em
cada regulador LM317 para seu correto funcionamento.
O primeiro regulador é configurado como limitador de corrente através do resistor
R6, para que a corrente de carga não exceda o máximo de aproximadamente 450mA. O
segundo regulador destina-se a regular a tensão entre 14,5V através dos resistores R1 e R3 e
ao ser acionado com 5V o transistor entra em saturação colocando somente o resistor R1
como polarizador do LM317 obtendo-se na saída uma tensão de 13,5V.
Quando o microcontrolador seta uma tensão de 5V para saturar o transistor, o LED
liga identificando que o carregador está no segundo estágio de carga. Ao atingir esse estágio,
a carga da bateria está em aproximadamente 80%, necessitando mais algumas horas para
atingir a carga total. Em uma situação de campeonato, essa técnica carrega a bateria até 80%
96
de sua carga de forma rápida, sendo possível utilizar o robô caso necessário, assim como
também ao estar em processo de flutuação o carregador pode ficar ligado por um tempo
indeterminado.
2.2.5 Montagens das placas e sistemas eletrônicos
Com os circuitos simulados e testados em protoboard, os mesmos são montados em
uma placa padrão para que seja possível testá-los diretamente na estrutura do protótipo do
robô. Onde esta placa se adquire com furações padrão e trilhas na horizontal, sendo necessário
romper algumas trilhas e efetuar ligações na vertical utilizando fios, conforme o circuito.
A placa protótipo foi desenvolvida como uma tampa, onde é possível facilmente
desconectar, tendo acesso a parte interna do robô, como a bateria e toda a fiação que liga os
motores, sensores e bateria.
Na Figura 2.15 verifica-se uma foto da placa principal do protótipo do robô,
juntamente com as placas dos microcontroladores.
97
Figura 2.15 – Placa Principal. Fonte – Autor, 2009.
No centro a placa principal desenvolvida e nas laterais as duas placas dos
microcontroladores que são encaixadas na placa principal.
No centro da placa principal insere-se um ventilador, para que seja efetuado o
resfriamento dos motores que ficam logo abaixo da placa e também o resfriamento da bateria.
A direita encontra-se o circuito ponte H, responsável pelo acionamento dos motores e na
esquerda, juntamente com as ligações aos pinos do microcontrolador, o circuito comparador
de tensão dos sensores da borda da arena. Logo acima do ventilador, onde encontra-se um
dissipador, é o circuito do carregador de bateria e abaixo do ventilador o circuito comparador
de tensão do sensor de início da partida localizado na parte inferior do robô.
A Figura 2.16 apresenta a placa principal, juntamente com os microcontroladores
conectados, ao lado do protótipo do robô.
98
Figura 2.16 – Conexões placa principal e protótipo. Fonte – Autor, 2009.
Pode-se verificar que na parte frontal do protótipo, onde localizam-se os sensores
sonar, assim como na parte posterior, desenvolve-se dois conectores de fácil conexão para se
ter acesso a parte interna do robô, com objetivo de efetuar a troca da bateria, assim como
poder efetuar facilmente algum reparo necessário.
Uma vista superior do protótipo do robô está apresentada na Figura 2.17.
99
Figura 2.17 – Interior do Protótipo. Fonte – Autor, 2009.
Essa é a visão que se tem ao retirar a placa principal, onde a direita encontra-se a
bateria com conectores de fácil encaixe que são fixados na estrutura do robô, assim como as
disposições dos motores ao centro, e a esquerda um fusível utilizado para proteção da bateria
em um eventual defeito no circuito.
Da mesma forma como a placa principal é ligada por conectores, toda a fiação vinda
da bateria, motores e sensores também são ligados por conectores na parte frontal e posterior
do robô. Isso para que em uma eventual necessidade de desmontar a parte mecânica, seja
possível retirar toda a parte eletrônica embarcada no protótipo de forma simples e rápida.
Ilustra-se na Figura 2.18 uma foto do sensor de início da partida.
100
Figura 2.18 – Sensor de inicio da partida. Fonte – Autor, 2009.
Em uma abertura na parte inferior do robô, é instalado um LDR, soldado em uma
pequena placa padrão pela parte de baixo, onde por cima da placa são ligados fios para que a
alimentação e o sinal de retorno do sensor sejam disponibilizados na placa principal.
Verifica-se também que no espaço entre cada uma das rodas e o pára-choque os
sensores reflexivos são fixados.
Na Figura 2.19, ilustra-se a montagem completa do protótipo.
101
Figura 2.19 – Montagem Completa. Fonte – Autor, 2009.
Com todas as placas e sensores conectados, o protótipo do robô de sumô está pronto
para receber a programação em cada um dos seus microcontroladores e consequentemente ser
testado na arena de combate.
Vale ressaltar também a existência de uma chave liga-desliga na parte traseira
esquerda e o conector do carregador de bateria no pára-choque traseiro.
Na placa principal são inseridos LEDs, para que durante a operação do robô, seja
quando estiver carregando a bateria ou se movimentando na arena, algumas situações de
funcionamento possam ser identificadas.
Na Figura 2.20 ilustra-se a definição da função de cada LED na placa principal.
102
Figura 2.20 – Identificação da função dos LEDs. Fonte – Autor, 2009.
Além de identificar o correto funcionamento de partes do circuito durante o
desenvolvimento dos mesmos e também do software de controle, utilizam-se os LEDs para a
identificação de ajustes dos circuitos comparadores de tensão, que compõem o sensor de
início da partida e de borda da arena, através dos respectivos trimpots.
Posicionados na borda da placa principal, são utilizados para que durante a
movimentação do robô na arena, seja identificada, por exemplo, a carga baixa da bateria
necessitando nesse caso a substituição ou carregamento da mesma.
103
3 DESENVOLVIMENTO DO SOFTWARE
Desenvolve-se toda lógica de controle e automação do robô utilizando-se dois
microcontroladores da família dsPIC. O dsPIC30F2010 é responsável pelo controle do PWM,
direção dos motores, acionamento e recepção dos sinais vindos dos sensores sonar através de
conversores analógico digital, identificação do sensor de início da disputa e recepção pela
comunicação UART de dados proveniente do outro microcontrolador. Com todas essas
informações, efetua-se decisões de movimentação do robô na arena durante a disputa. O
microcontrolador dsPIC30F3013 é responsável pelo monitoramento da bateria, tanto no
carregamento como no nível de carga durante as disputas e os sensores de borda, que são
multiplexados e captados por um pino de interrupção, esses dados são transmitidos para o
microcontrolador principal onde as decisões são tomadas. O dsPIC30F3013 também identifica
se o carregador de bateria está ligado para controlar a carga em dois estágios, sinalizando
através de um LED a carga completa.
Para se utilizar os microcontroladores, é necessário alguns circuitos adicionais
ligados externamente a eles, como por exemplo o clock e a gravação in circuit, onde evita-se a
retirada do Circuito Integrado (CI) da placa para a atualização do software do
microcontrolador. Dessa forma aproveitando-se recursos existentes na universidade,
desenvolvidos por outros colegas, utiliza-se uma placa com todos os pinos de saída ligados
104
em um conector, como também o circuito de clock, a comunicação serial com um
microcomputador e a gravação in circuit que é utilizada e conectada a placa principal do robô.
Na Figura 3.1 apresenta-se a imagem da placa desenvolvida na Feevale e utilizada no
protótipo.
Figura 3.1 – Placa de Suporte dos Microcontroladores. Fonte – Autor, 2009.
Esta placa foi desenvolvida primeiramente para utilização com o dsPIC30F2010, mas
perfeitamente utilizável com o dsPIC30F3013, onde somente o nome de cada pino é alterado,
o que pode ser verificado no datasheet do fabricante (MICROCHIP, 2005).
No Anexo B, verifica-se o circuito da placa de suporte do microcontrolador
identificando cada pino de ligação ao conector de saída.
Dessa forma se torna possível o acesso a todos os pinos do microcontrolador de
forma fácil, e assim utilizando-se duas destas placas, através de seus conectores, elas são
105
encaixadas na placa principal do robô, interligando a alimentação e todos os sinais necessários
para o funcionamento correto.
3.1 Programação dsPIC30F2010
Antes do desenvolvimento da lógica de programação do microcontrolador é
necessário definir a função de cada pino, onde cada um será ligado e com que finalidade.
Dessa forma verifica-se na Tabela 4 a ligação dos pinos com seus respectivos nomes nos ports
e suas funções.
Tabela 4 – Pinagem dsPIC30F2010.
Pino (conector)
Nome (port) Descrição
17 RB0 / AN0 Analógica recebe sonar esquerdo 18 RB1 / AN1 Analógica recebe sonar direito 19 RB2 Direção 0 motor esquerdo 20 RB3 Direção 1 motor direito 21 RB4 22 RB5 Direção 0 motor direito 4 RD1 Direção 1 motor esquerdo 14 RE0 Identifica Início da partida 13 RE1 PWM motor direito 12 RE2 11 RE3 PWM motor esquerdo 10 RE4 9 RE5 8 RF2 / U1RX UART 1 pino RX 7 RF3 / U1TX UART 1 pino TX 6 RE8 Habilita leitura sonar direito 5 RD0 Habilita leitura sonar esquerdo (led status)
Fonte – Autor, 2009.
106
Com a definição da função de cada pino do respectivo microcontrolador é possível
desenvolver o funcionamento de cada módulo, como a comunicação UART, PWM, conversão
AD e sinais auxiliares.
Verifica-se o código fonte completo para aplicação do dsPIC30F2010 no Apêndice
B.
3.1.1 Lógica de Programação do Bloco de Modulação por Largura de Pulso
A lógica de programação e controle do módulo PWM do microcontrolador se torna a
parte essencial para um bom funcionamento do robô em uma disputa, pois todos os sinais
captados pelos sensores e sistemas periféricos são transmitidos para os motores em forma de
velocidade e sentido de giro, de forma que coordenadamente o robô se movimente na arena.
Alterando o duty cycle de uma onda quadrada pode-se aumentar ou diminuir a
velocidade de rotação de um motor DC e para isso o módulo PWM inserido no
dsPIC30F2010 precisa ser inicializado corretamente conforme código transcrito abaixo.
void inicia_PWM() unsigned int config; //define a variável config
config = ( //Define a variável config com os seguin tes //parâmetros
PWM_INT_EN & //Habilita a interrupção de PWM PWM_INT_PR1 & //Define a prioridade da interrupç ão de
//PWM=1 PWM_FLTA_DIS_INT); //Desabilita a interrupção do "FaultA"
ConfigIntMCPWM(config); //Função que configura as i nterrupções do //PWM de acordo com o conteudo da variável //config
dtycregpwm1 = 1; //Ponteiro para o registrador de Duty Cycle dtycyclpwm1 = 0x0000; //Define o valor inicial de Duty Cycle=0 dtycregpwm2 = 2; //Ponteiro para o registrador de Duty Cycle dtycyclpwm2 = 0x0000; //Define o valor inicial de Duty Cycle=0
107
//Para f=10KHz, dutycycle0%=0, updatedisable = 0; //Habilita a atualização dos reg istros de
//período e Duty Cycle SetDCMCPWM(dtycregpwm1,dtycyclpwm1,updatedisable); SetDCMCPWM(dtycregpwm2,dtycyclpwm2,updatedisable); //Função que configura o Duty Cycle
//do PWM de acordo com o conteudo da //variáveis
period = 0x00ff; //define o período como 0x00fa hex , //freq=10KHz //define o período como 0x00ff hex, freq= +-//10KHz
sptime = 0x0; //define o "sptime" como 0 config1 = ( //Define a variável config1 com os s eguintes
//parâmetros PWM_EN & //Habilita o módulo PWM PWM_IDLE_CON & //Continua a operação em modo IDLE PWM_IPCLK_SCALE1 & //Define o prescaler como 16 PWM_OP_SCALE16 & //Define o Postcaler como 16 PWM_MOD_UPDN); //Define o modo "UPDN"
config2 = ( //Define a variável config2 com os segu intes //parâmetros
PWM_MOD1_IND & //Define o modo complementar para o "PDC1" PWM_MOD2_IND & PWM_PEN1H & //Habilita o PWM1H (pino 25) PWM_PEN2H & //Habilita o PWM2H (pino 23) PWM_PDIS1L & //Desabilita o PWM1L (pino 26) PWM_PDIS3H & //Desabilita o PWM3H (pino 21) PWM_PDIS3L & //Desabilita o PWM3L (pino 22) PWM_PDIS2L); //Desabilita o PWM2L (pino 24)
config3 = (PWM_UEN); //Define a variável config3 co m os seguintes //parâmetros
//Habilita a atualização do módulo PWM OpenMCPWM(period, sptime, config1, config2, config 3); //Função que configura o início do
//módulo de PWM de acordo com o conteudo das //variáveis
Ao ser inicializado o PWM, passa a funcionar com os valores inicialmente
configurados como no caso do duty cycle que define a velocidade de giro do motor. Com isso
utilizando-se do “timer 1” do microcontrolador, a cada contagem máxima do “timer 1” uma
função chamada de void PWM_Motor(void) é executada, para que os valores da velocidade
de cada motor sejam atualizados conforme decisões efetuadas pelo microcontrolador, a partir
da análise dos sensores utilizados. Verifica-se a seguir o código transcrito da respectiva
função.
108
void PWM_Motor(void) if (transmissao == 0x02 ) // variavel transmissão r ecebe byte da UART. fuga02(); //indica sensor frontal direito acionad o else if (transmissao == 0x10) fuga01(); //sensor traseiro esquerdo acionado else if (transmissao == 0x03) fuga03(); //sensor traseiro direito acionado else if (transmissao == 0x04) fuga04(); //sensor frontal esquerdo acionado else if (transmissao == 0x13) fuga13(); //Acionamento dos 2 sensores traseiros. else if (transmissao == 0x06) fuga06(); //2 sensores frontais acionados. else procura(); dtycyclpwm2 = Vel_Pwm2; //variável dutycycle recebe o valor da velocidade dtycyclpwm1 = Vel_Pwm1; //atualiza as configuraçõesdo PWM para assumir o novo valor do Duty Cycle
109
SetDCMCPWM(dtycregpwm1,dtycyclpwm1,updatedisable); SetDCMCPWM(dtycregpwm2,dtycyclpwm2,updatedisable);
Como os sensores de borda são gerenciados pelo dsPIC30F3013, ao ocorrer um
acionamento em um dos sensores, um byte é transmitido através de uma porta serial para o
dsPIC30F2010 e esse byte é guardado na variável transmissão. Dessa forma se compara o
valor da variável transmissão com um dado definido para identificar quais dos sensores foram
acionados e dessa forma atualizar o estado do PWM, assim como o sentido de giro de cada
motor, conforme uma função definida para cada operação. Um exemplo é a função “fuga02”
que seta os motores coordenadamente para que o robô execute uma ação de fuga da borda,
conforme verifica-se o código transcrito a seguir.
void fuga02() //Sensor frontal direito setado. Rot ina para fuga //dessa situação.
LATDbits.LATD1 = 0; LATBbits.LATB2 = 1; //Recua direito LATBbits.LATB3 = 0; LATBbits.LATB5 = 1; // Recua esquerdo Vel_Pwm2=200; // Velocidade motor esquerdo Vel_Pwm1=500; // Velocidade motor direito
fuga++; if (fuga > 10) transmissao = 0x00;
Essa rotina de fuga é executada quando o robô estiver saindo de frente da arena e o
sensor frontal direito identifica a borda. Nessa situação os dois motores são setados para girar
no sentido contrário, para trás, e o motor esquerdo é acelerado com uma velocidade menor
que o direito, fazendo com que o robô efetue uma curva para a esquerda com o objetivo de se
posicionar de frente, voltado para o centro da arena.
110
Para que o robô tenha tempo suficiente para executar o movimento, sem entrar no
estado de procura do adversário, utiliza-se uma variável fuga que é incrementada a cada
chamada da respectiva função selecionada pela variável transmissão, que por sua vez ocorre a
cada contagem máxima do “timer 1”. Assim quando a variável fuga for igual a 11 a variável
transmissão é zerada terminando a execução da respectiva ação. Isso faz com que a ação de
fuga seja executada durante o período de 12 ciclos do “timer 1”, que é uma forma de utilizar
tempos diferentes na execução de funções utilizando o mesmo timer, desde que os tempos
sejam múltiplos.
Se nenhum dos sensores for acionado, individualmente ou em conjunto conforme
situações definidas na função de atualização do estado do PWM, a função procura é
executada, consistindo em uma rotina de leitura dos sensores sonar e movimentação do robô
para identificar a presença do adversário.
3.1.2 Lógica de Programação de Leitura dos Sensores Sonar
Os dois sensores sonar utilizados possuem várias formas de operação, assim como
também vários sinais de saída identificando a condição detectada. Com isso utiliza-se a saída
analógica para determinar a distância do adversário, através do nível de tensão, inserido no
conversor AD existente no microcontrolador.
Para a utilização do conversor AD do microcontrolador dsPIC é necessário a
inicialização do módulo através da utilização dos macros de configuração do compilador C30,
setando entre todas as configurações, a taxa de atualização, o buffer de leitura e os pinos
utilizados para a conversor que neste caso são os pinos “AN0” e “AN1”.
111
A cada conversão efetuada pelo modulo AD, uma interrupção é gerada sendo
possível o tratamento da mesma em sua função específica. No tratamento da interrupção do
AD um ponteiro é criado para a leitura do buffer do conversor e esses valores do buffer são
transferidos para um vetor de 16 posições. A posição “0” e a posição “1” do vetor, ao final da
conversão contém o valor do sonar esquerdo e do sonar direito respectivamente.
Conforme os valores lidos e convertidos pelo módulo AD as ações são decididas na
função procura, conforme verifica-se o código transcrito a seguir.
void procura() if (dist_sonar_d > 30 && dist_sonar_e > 30 && andar < 11 ) LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua Direito LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; andar++; if (andar ==10) giro = 0; else if (dist_sonar_d > 30 && dist_sonar_e > 30 && direc ao==5 && giro < 11 ) LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 0; // Recua Direito LATBbits.LATB5 = 1; Vel_Pwm2=500; Vel_Pwm1=500; giro++; if (giro==10) andar = 0; else if (dist_sonar_d < 20 && dist_sonar_e > 30) LATDbits.LATD1 = 1; //Acelera esquerdo
112
LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua Direito LATBbits.LATB5 = 0; Vel_Pwm2=500; //motor esquerdo Vel_Pwm1=200; // motor direito direcao=5; //se for 5 indica que
//adversário saiu pela //direita.
else if (dist_sonar_d < 20 && dist_sonar_e < 20) LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua Direito LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; else if (dist_sonar_d > 30 && dist_sonar_e < 20)
LATDbits.LATD1 = 1; //Recua esquerdo
LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Acelera Direito
LATBbits.LATB5 = 0; Vel_Pwm2=200; // motor esquerdo Vel_Pwm1=500; // motor direito
direcao=0; //indica que adversario saiu pela esquer da. else if (andar < 11) LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; andar++; else if (giro <11 ) LATDbits.LATD1 = 0; //Acelera direito LATBbits.LATB2 = 1; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; giro++; else andar = 0; giro = 0;
113
Utilizando a mesma técnica das funções de fuga, a função de procura utiliza
incremento de variáveis para executar laços de decisão durante múltiplas interrupções do
“timer 1”. Dessa forma, se as conversões AD resultarem em um valor muito elevado
considera-se que nenhum adversário foi detectado executando um movimento para frente
durante 11 ciclos e em seguida um giro no seu próprio eixo procurando um obstáculo em
360°.
Como utilizam-se dois sensores sonar posicionados de forma paralela, quando um
deles detecta um obstáculo, imediatamente os motores são direcionados para frente, sendo que
o motor do mesmo lado do sensor que efetuou a detecção acelera com uma velocidade menor,
fazendo com que o robô faça uma curva na direção do adversário. Essa lógica funciona da
mesma forma para ambos os sensores, onde o robô irá fazer curvas para determinado lado
sempre procurando uma situação em que os dois sensores sonar identifiquem o adversário ao
mesmo tempo. Quando os dois sensores identificam o adversário os dois motores são setados
a velocidade máxima para frente, com o objetivo de empurrá-lo para fora da arena.
Utilizando dois sensores posicionados em paralelo, é possível determinar se o
adversário passou em frente ao robô e principalmente em qual direção ele se deslocou, se foi
para a esquerda ou para a direita. Esse sentido de deslocamento é determinado pela variável
direção, onde mesmo que os dois sonares não detectem mais nada, a função de procura, no
caso o giro de 360°, será efetuado para o lado em que a última detecção foi executada,
otimizando a velocidade de identificação da posição do adversário na arena.
114
3.1.3 Lógica de Programação da UART
Primeiramente inicializa-se o modulo UART através dos respectivos macros de
configuração do compilador C30, onde define-se os pinos padrão como RX e TX, a geração
de uma interrupção de recebimento de dados quando qualquer byte for recebido e a prioridade
da interrupção de recepção que deve ser a máxima, no caso 7, para que o robô não saia fora da
arena devido a atrasos para determinar uma ação.
Quando algum valor é recebido pela UART, ocorre uma interrupção de “RX” onde o
programa é desviado para o tratamento da interrupção na respectiva função, conforme
verifica-se o código transcrito a seguir.
void _ISR _U1RXInterrupt(void) //função da rotina de interrupção de recepção d e dados while(BusyUART1()); //retorna o status da transmi ssão; espera
//enquanto a UART estiver ocupada transmissao=ReadUART1(); transmissao2=ReadUART1(); //transfere os 4 bytes d a uart para transmissao3=ReadUART1(); // variáveis transmissao4=ReadUART1(); while(BusyUART1()); fuga = 0; IFS0bits.U1RXIF=0; //clear no bit de chamada da i nterrupção de
//recepção
Como configura-se a UART para executar a interrupção quando qualquer dado for
recebido, é necessário através do laço while, esperar até que a UART receba todos os quatro
bytes para a seguir efetuar-se a leitura de cada byte, colocando o seu valor em quatro variáveis
diferentes, que são tratadas no decorrer dos processos. Neste mesmo instante a variável fuga é
zerada para que o tempo de contagem da operação de fuga seja inicializado e em seguida a
flag da interrupção é resetada identificando que a mesma foi tratada.
115
3.1.4 Lógica de Programação da Tática de Combate
A tática de combate baseia-se na temporização e interrupção do “timer 1”, onde a
cada contagem máxima do timer executa-se uma ação, como atualização dos motores e leitura
dos sensores, desde que não ocorra uma interrupção específica que execute um comando com
prioridade. Na Figura 3.2 ilustra-se o fluxograma das operação do robô.
Figura 3.2 – Fluxograma das Operações de Controle e Combate. Fonte – Autor, 2009.
116
Ao ligar a chave geral do robô, todas as funções dos microcontroladores são
inicializadas e o motor mantido em velocidade zero. Para que inicie a sua movimentação, é
necessário que o sensor de inicio da partida seja acionado identificando o LED aceso sob a
arena. Em seguida ao identificar que o LED se apagou parte para o processo de
movimentação, que consiste em andar um determinado tempo para frente e após efetuar um
giro no seu eixo central procurando o adversário dentro da arena. Caso o sensor sonar direito
identifique a presença de um obstáculo, o robô avança para frente efetuando uma curva para a
direita, o mesmo acontece para o sensor esquerdo. Quando ambos os sensores identificarem
um obstáculo simultaneamente, conclui-se que o adversário está na frente do robô, então
efetua-se um avanço reto em velocidade máxima para retirá-lo da arena. Caso os sensores não
identifiquem mais obstáculos a direção de giro da movimentação é atualizada para o lado da
última detecção do adversário, efetuando novamente a rotina de movimentação padrão de
procura.
Caso durante o processo de procura do adversário uma interrupção de recepção da
UART ocorrer, o microcontrolador recebe os dados e decodifica para identificar qual
comando deverá executar, conforme o sensor que foi acionado e identificado pelo
microcontrolador de apoio. No mesmo instante que os dados são decodificados, os valores do
PWM são atualizados, para que o robô efetue de forma mais eficiente possível o comando
recebido, no caso, para se afastar da borda da arena.
Todo o processo ocorre durante o tempo de um round do sumô de robô, caso o tempo
termine, os motores são desligados fazendo com que o robô fique parado na arena, conforme
determinam as regras oficiais. Neste caso para que se inicie novamente o processo de disputa,
deve-se resetar o processador principal reinicializando o sistema.
117
3.2 Programação dsPIC30F3013
Da mesma forma como no dsPIC30F2010 é necessário definir a função e ligações de
cada pino para uma correta programação do mesmo. Conforme verifica-se na Tabela 5.
Tabela 5 – Pinagem dsPIC30F3013
Pino (conector) Nome (port) Descrição 17 RB0 / AN0 Recebe tensão bateria 1 18 RB1 / AN1 19 RB2 / AN2 20 RB3 / AN3 21 RB4 LED identificação carregador plugado 22 RB5 LED identificação Bateria 1 4 RD9 Sensor borda frontal esquerdo 14 RB6 13 RB7 Identifica carregador plugado 12 RB8 Sensor borda traseiro esquerdo 11 RB9 Sensor borda frontal direito 10 RF4 / U2RX Uart 2 pino RX 9 RF5 / U2TX Uart 2 pino TX 8 RF2 7 RF3 6 RF6 Sensor borda traseiro direito 5 RD8 Recebe acionamento sensor de borda
INT1
Fonte – Autor, 2009.
Utiliza-se o microcontrolador dsPIC30F3013 como apoio ao microcontrolador
principal, sendo responsável por controlar os sensores de borda da arena, assim como a tensão
da bateria durante o combate. Fora do combate o dsPIC30F3013 também é responsável pela
identificação do carregador ligado e gerenciamento da carga em dois estágios na bateria.
O código fonte completo desenvolvido para o dsPIC30F3013 encontra-se no
Apêndice C.
118
3.2.1 Lógica de Programação dos Sensores de Borda
Utilizam-se quatro sensores reflexivos para identificar a borda branca da arena de
combate de forma multiplexada, onde o microcontrolador aciona um sensor de cada vez.
Dessa forma a corrente fornecida pela bateria é sempre a suficiente para o funcionamento de
um sensor e também o sinal de resposta dos sensores são captados por um único pino ao invés
de quatro.
Liga-se cada sensor em um pino do microcontrolador, onde são acionados em nível
lógico alto e a resposta é detectada através de um pino de interrupção externa “INT1”.
A interrupção externa assim como todos os outros blocos do microcontrolador
precisa ser inicializada e neste caso configura-se para ocorrer na borda de subida e define-se
prioridade 7, que é a máxima possível.
Utilizando como temporizador o “timer 1”, a cada interrupção gerada por ele, um
sensor é acionado em nível lógico um, deixando os outros três desligados, conforme verifica-
se o código transcrito a seguir.
void _ISR _T1Interrupt(void) //função de interrupç ão. switch(a) case 0: // Todos os sensores verifica-se olhando se
//frente para o robo. LATBbits.LATB8 = 0; LATBbits.LATB9 = 0; // Case que habilita sensor f rontal esquerdo LATFbits.LATF6 = 0; LATDbits.LATD9 = 1; break;
119
case 1: LATDbits.LATD9 = 0; LATBbits.LATB8 = 0; //Case que habilita sensor fr ontal direito. LATBbits.LATB9 = 1; LATFbits.LATF6 = 0; break; case 2: LATDbits.LATD9 = 0; LATBbits.LATB8 = 1; //Case que habilita sensor tr aseiro
//esquerdo. LATBbits.LATB9 = 0; LATFbits.LATF6 = 0; break; case 3: LATDbits.LATD9 = 0; LATBbits.LATB8 = 0; LATBbits.LATB9 = 0; //Case que habilita sensor tr aseiro direito. LATFbits.LATF6 = 1; break; a++; if (a>4) a=0; transmissao=sensor1+sensor2+sensor3+sensor4; if (transmissao >0x00) while(BusyUART2()); //retorna o status da transmiss ão; espera enquanto
//a UART estiver ocupada WriteUART2(transmissao); WriteUART2(transmissao2); WriteUART2(transmissao3); WriteUART2(transmissao4); while(BusyUART2()); sensor1=0x00; sensor2=0x00; sensor3=0x00; sensor4=0x00; transmissao=0x00; IFS0bits.T1IF = 0; // clear no bit de interru pção do timer 1
120
A cada contagem máxima do timer 1 a variável a é incrementada Ao atingir o valor
3, quando um ciclo completo de leitura de todos os sensores é efetuado, as variáveis sensor 1,
sensor2, sensor3 e sensor4 são somadas a transmissão. Se a variável transmissão for maior
que um, indicando que um dos sensores detectou a borda, efetua-se a transmissão da
respectiva variável pela UART e em seguida zerando todas as variáveis para um novo ciclo
ser realizado.
As variáveis sensorX, onde X indica o número do sensor, carregam-se com os
valores correspondentes a cada sensor quando ocorre uma interrupção externa, tratada na
respectiva função, conforme verifica-se no código transcrito a seguir.
void __attribute__((__interrupt__)) _INT1Interrupt( void) // ROTINA PARA TRATAR A INTERRUPÇÃO EXTERNA. if (LATBbits.LATB8 == 1) sensor1 = 0x10; //indica sensor traseiro esquerdo setado. else if (LATBbits.LATB9 == 1) sensor2 = 0x02; //indica sensor frontal direito s etado. else if (LATFbits.LATF6 == 1) sensor3 = 0x03; //indica sensor traseiro direito setado. else if (LATDbits.LATD9 == 1) sensor4 = 0x04; //indica sensor frontal esquerdo setado. IFS1bits.INT1IF = 0;
121
A lógica da função ocorre toda vez que uma interrupção externa acontece, indicando
que um dos sensores atuou, neste instante verifica-se qual sensor esta ativo, carregando um
valor na sua respectiva variável. Os valores que são carregados nas variáveis de cada sensor
são determinados para que, ao ocorrer o acionamento de mais de um sensor em um mesmo
ciclo de leitura, a soma destes valores determinem a exata situação do robô, conforme
verifica-se na Tabela 6.
Tabela 6 – Lógica de acionamento dos sensores de borda.
Sensor 1 = 2 Sensor 2 = 3 Sensor 3 = 4 Sensor 4 = 10 Transmissão 0 0 0 0 0 0 0 0 1 10 0 0 1 0 4 0 0 1 1 14 0 1 0 0 3 0 1 0 1 13 0 1 1 0 7 0 1 1 1 17 1 0 0 0 2 1 0 0 1 12 1 0 1 0 6 1 0 1 1 16 1 1 0 0 5 1 1 0 1 15 1 1 1 0 9 1 1 1 1 19
Fonte – Autor, 2009.
Conforme a tabela acima cada sensor recebe um valor decimal. Se somente o sensor
4 for acionado, transmite-se o valor 10, dessa forma ao ocorrer o acionamento do sensor 3
juntamente com o sensor 4, o valor de cada um deles é adicionado, neste caso 14, que é
transmitido pela UART.
122
Dessa forma, para cada situação gerada pelos sensores combinados ou não, um
código único é gerado, que pode ser facilmente decodificado pelo microcontrolador principal
efetuando a correta operação.
3.2.2 Lógica de Programação de Monitoramento da Bateria
Segundo manual do fabricante da bateria utilizada (UNICOBA, 2003), ela possui
uma tensão mínima de operação, chamada de tensão de corte, onde ao ser utilizada até atingir
uma tensão abaixo dessa estipulada pode ocorrer uma danificação permanente dos seus
elementos internos, não aceitando recargas. Para que isso não ocorra monitora-se a tensão da
bateria durante o funcionamento do robô constantemente pelo conversor AD, que identifica
tensões abaixo de 11V ligando um LED.
Como a tensão de referência do conversor AD fixa-se em 0 e 5Vcc, é necessário
efetuar um divisor de tensão para que os 12V da bateria sejam proporcionalmente convertidos
para a referência. Assim ligam-se 3 resistores de 1K em série efetuando uma divisão por 3,
onde proporcionalmente os 12V da bateria equivale sobre um dos resistores a 4V no
conversor AD.
A seguir verifica-se o código transcrito do bloco responsável pelo monitoramento da
tensão da bateria.
void __attribute__((__interrupt__)) _ADCInterrupt(v oid) int i = 0; //define a variável inteira Pos_Atual ptr = &ADCBUF0; //ponteiro ptr recebe o endereço d o buffer0 //de conversão A/D while (i < 16) //executa a leitura da conversão A/ D enquanto i<16
123
ADResult[i++] = *ptr++; //ponteiro ptr é incremen tado até i=15 //ADResul recebe os valores da
//conversão A/D na posição '0' //são feitas 16 leituras para garantir
//que os 16 buffers da //conversão A/D sejam lidos e
//automaticamente limpos, //garantindo que o resultado da
//próxima leitura fique no buffer0 //fim do while Bat_Atual=ADResult[0]; //Posição atual recebe o r esultado da
//conversão A/D if (plugado == 0) //variável que identifica carre gador plugado if (transmissao2 == 0x02) //seta variável de trans missão para que
//microcontrolador principal saiba que o //carregador está plugado
transmissao2 = 0x01; if (Bat_Atual < 3150 ) //rotina para identificar carga baixa da
//bateria. = 3150 LATBbits.LATB5 = 1; else LATBbits.LATB5 = 0; else // se plugado for igual a 1 transmissao2 = 0x02; if (Bat_Atual > 4000 ) //rotina para acender o led do segundo estágio de
//carga LATBbits.LATB5 = 1; else LATBbits.LATB5 = 0; IFS0bits.ADIF = 0; //clear no bit de chamada d a interrupção da
//conversão A/D
Como o conversor AD utilizado é de 12 bits, a tensão máxima de 5V equivale ao
valor decimal 4096, que equivale a 212. Assim efetuando-se uma regra de três chega-se ao
valor aproximado e ajustado de 3150, proporcionalmente a 4Vdc. Se a cada interrupção no
124
conversor AD o valor medido for abaixo de 3150 o LED de status da bateria liga,
identificando que é necessário parar o robô e ligar a fonte do carregador de bateria.
A cada interrupção do “timer 1” o pino “PORTBbits.RB7” é verificado. Se o mesmo
estiver em nível lógico alto a variável “plugado” é carregada com o valor 1, ligando o
respectivo LED de aviso identificando que o carregador de bateria está conectado. Na
interrupção do conversor AD se a variável “plugado” não estiver em nível lógico zero, o valor
lido correspondente à tensão da bateria é comparado com o valor 4000, ligando o respectivo
LED se for maior. Dessa forma identifica-se a carga da bateria completa, setando o carregador
para o estágio de carga por flutuação.
125
4 TESTES E VALIDAÇÃO
Para que o robô de sumô esteja apto a participar de competições oficiais, faz-se
necessário que algumas condições, como peso, tamanho, assim como características de
funcionamento, sejam as mínimas exigidas nas respectivas regras.
4.1 Peso e Dimensões
Iniciando pela análise das dimensões, constrói-se o protótipo com 200 mm de lado,
padrão definido nas regras, não possuindo um aumento das dimensões para 300 mm de lado
ao início da partida, como uma possibilidade permitida.
Durante a construção do protótipo algumas dificuldades são encontradas com relação
à limitação do peso em 3 Kg, pois ao adicionar mais recursos, sensores, baterias e outros
componentes para melhorar o seu desempenho, mais peso extra é acrescentado ao protótipo,
onde ao final tornou-se necessário à utilização de uma única bateria. Na Figura 4.1 verifica-se
uma foto ilustrando a pesagem.
126
Figura 4.1 – Pesagem do protótipo. Fonte – Autor, 2009.
Utilizando uma balança para carga máxima de 3 Kg, e resolução de escala de 1g,
obtém-se o peso de 2,796 Kg. Este peso está de acordo com as regras determinadas para
competições de sumô de robô.
4.2 Funcionamento dos Sensores e Movimentação
Inicialmente os testes de movimentação do protótipo do robô e testes dos sensores
sonar são efetuados sobre um piso plano e uniforme, em uma área ampla para que os sensores
sonar não identifiquem obstáculos como as paredes do ambiente.
Assim pode-se verificar a velocidade máxima de deslocamento e o giro efetuado no
seu próprio eixo, quando um motor traciona para frente e outro para trás.
127
Posicionando uma caixa próxima ao protótipo, com as dimensões semelhantes aos
adversários de um possível combate, verifica-se que os sonares conseguem identificar o
obstáculo a uma distância de aproximadamente 40 cm, tracionando diretamente para a posição
do obstáculo com o objetivo de empurrá-lo. Com a lógica utilizada em dois sensores sonar
posicionados em paralelo, o robô demonstrou sua capacidade de corrigir o posicionamento
durante o ataque ao adversário, para que o mesmo não se desloque para um dos lados saindo
do campo de ação do robô.
Utilizando cartolina preta e fita adesiva para demarcar a borda, uma arena de
combate foi construída para simular uma disputa e efetuar testes com os sensores de borda e a
movimentação dentro da mesma, assim como o funcionamento do sensor de início do
combate. Verifica-se então que em alguns casos o robô sai com toda a roda para fora da arena,
ou seja, demora muito tempo para identificar a borda, transmitir para o microcontrolador
principal e atualizar a situação dos motores. Neste caso na função de interrupção de recepção
da UART, a função de atualização dos motores é chamada, agilizando o processo e
solucionando o problema encontrado, sendo dessa forma possível efetuar a movimentação
com a velocidade máxima do robô sem sair da arena.
Ao colocar-se um obstáculo estático dentro da arena para que o robô identifique e
remova-o para fora da mesma, o sucesso de identificação e remoção foi de quase 100% nos
testes efetuados, onde se executou alguns ajustes na movimentação do robô para melhorar seu
desempenho. Os testes não são efetuados em situações ideais, com uma arena construída
conforme as regras e também com um espaço livre e adequado, para que obstáculos externos
não interfiram nos sensores utilizados.
128
4.3 Carregador de Bateria e Duração da Carga
Para fins de testes, o protótipo do robô é configurado para funcionar durante um
tempo de 30 segundos, desligando-se após, simulando assim um combate. Dessa forma alguns
ciclos são efetuados seguidamente, onde obtém-se a autonomia da bateria com uma média de
15 ciclos, o que resulta em 450 segundos de funcionamento ou sete minutos e meio com a
mesma carga da bateria. O que supre com folga a necessidade de operação durante uma
disputa de quatro minutos e meio, conforme estipulado nas regras. Assim pode-se no intervalo
de cada combate trocar a bateria com os engates rápidos criados ou carregá-las utilizando o
carregador desenvolvido no próprio robô.
Verifica-se a carga baixa da bateria através de um LED indicativo na placa principal,
sendo assim necessário conectar a fonte do carregador para efetuar a carga. Após a indicação
de carga baixa e conectando-se a fonte, a bateria carregou-se em um tempo de
aproximadamente cinco horas, até a indicação de carga completa efetuada por um segundo
LED na placa principal, conforme ilustra-se na Figura 4.2.
129
Figura 4.2 – Carga Completa indicada pelo multímetro. Fonte – Autor, 2009.
Como o robô não possui um sistema que o desliga automaticamente conforme o nível
de carga da bateria, apenas uma indicação luminosa, o tempo de carga se dá conforme a
profundidade da descarga, como especificado no manual do fabricante (UNICOBA, 2003).
Verifica-se que ao indicar a carga completa na bateria o carregador se mantém em
aproximadamente 13,85V, que é o estado de carga em flutuação, onde a carga é mantida em
baixa corrente sem danificar a bateria.
130
CONSIDERAÇÕES FINAIS
O presente trabalho descrito apresenta como objetivo, desenvolver um protótipo de
um robô de combate na modalidade sumô de robô. Sendo para isso necessário atender as
normas de construção e funcionamento estipuladas nas regras de competições oficiais.
Deste modo, pesquisando em vídeos, imagens e projetos de robôs construídos e
utilizados em competições de anos anteriores, algumas idéias são aproveitadas e adaptadas às
necessidades do protótipo a ser construído. Necessidades essas como, materiais e
componentes disponíveis no mercado.
Como a base de todo o robô é mecânica, muitos testes, pesquisas e a utilização de
softwares de CAD foram necessários para o desenvolvimento de um protótipo em forma de
carro e com o tracionamento estilo tanque de guerra. Sempre com a preocupação de não
ultrapassar o peso permitido e as dimensões estipuladas, assim como possuir um melhor
desempenho em relação aos adversários.
O protótipo foi desenvolvido de forma a ser possível a sua reprodução, onde não
foram utilizadas peças sucatas como visto em competições, mas sim componentes facilmente
adquiridos no mercado, como motores, materiais para rodas, engrenagens, rolamentos,
correia, alumínio, parafusos, sensores e componentes eletrônicos para a automação.
131
Para cada característica do protótipo, como uma boa movimentação na arena,
detectar as bordas, sinalização de início da disputa e reconhecer o adversário para empurrá-lo
para fora, existem várias formas de implementação, sendo uma mais simples e outras mais
complexas. Dessa forma utilizando-se de criatividade e pesquisa sobre sensores existentes, foi
possível executar com sucesso as funções de detecção da borda da arena, movimentando o
robô de forma adequada e também a detecção do adversário efetuando o ataque contra ele.
Utilizando-se dois microcontroladores tornou o protótipo mais versátil, sendo um
responsável por gerenciar sensores e bateria, enviando estas informações ao microcontrolador
principal, responsável pela decodificação das informações e determinação da lógica de
movimentação para o combate. Dessa forma gerando recursos adicionais que podem ser
incluídos em uma futura necessidade.
Mesmo após a troca do motor por um de maior torque e menor velocidade, a
agilidade do robô surpreendeu nos testes efetuados em uma arena simulada, efetuando giros
no seu eixo para alterar a posição de deslocamento ou então na procura do adversário de
forma eficiente. Verifica-se também que para um melhor desempenho dos sensores sonar para
a procura do adversário, é necessário que a arena esteja em uma área isolada, longe de
obstáculos e paredes. O eco gerado pelo sonar em uma parede, por exemplo, gera erro de
leitura fazendo com que o mesmo se desloque em direção dela identificando como a presença
do adversário. Isso ocorre devido ao seu tamanho, pois obstáculos maiores são mais
facilmente detectados pelo sonar.
A partir do protótipo desenvolvido, somente com testes em uma arena oficial e
experiências adquiridas ao longo de disputas efetuadas contra adversários de outras
132
instituições de ensino, será possível verificar a real eficiência dos sistemas desenvolvidos e
também com isso realizar o aperfeiçoamento das lógicas de combate empregadas.
133
REFERÊNCIAS BIBLIOGRÁFICAS
DEPARTAMENTO DE ENGENHARIA ELÉTRICA, Universidade Federal do Rio Grande
do Sul. Desafio UFRGS de Robôs. Regras 2009, Porto Alegre, v. 1, n. 2009, p. 1 - 4, mai.-
dez. 2009.
EZ1, MaxBotix. MaxSonar EZ1. In: Manual Técnico. São Paulo: MaxBotix inc, 2007, v. 3.
Disponível em <www.tato.ind.br>. Acesso em 5 ago. 2009.
PONTE H. In: Wikipedia. EUA: Wikimedia Foundation, Inc, 2009. Disponível em:
<http://en.wikipedia.org/wiki/ponte_h>. Acesso em: 15 out. 2009.
SOUZA, Vitor Amadeu. Programação em C para o dsPIC: Fundamentos. 1.ed. São Paulo -
SP: Ensino Profissional, 2008. 215p.
UNICOBA, Importação e Exportação. Unipower, Bateria Chumbo-Ácida Selada Regulada
por Válvula. In: Manual Técnico de Baterias. São Paulo, 2003. Disponível em
<www.unicoba.com.br>.Acesso em 8 ago. 2009
134
VILLA PAES, Laércio. Construção de Robôs Móveis. Sumô de Robôs, Cascavel , 4
ago.2007, Artigos, p. 14 – 29. Disponível em: <www.sumôderobos.org>. Acesso em 6 ago.
2009.
MICROCHIP, Technology Inc. dsPIC30F2011, dsPIC30F2012, dsPIC30F3012,
dsPIC30F3013 Data Sheet High- Performance Digital Signal Controllers. 2005.
OPTEK, Technology Inc. Reflective Object Sensors types OPB703, OPB704OPB705. 2006.
MPLAB C30, Microchip Technology Inc. Compiler User’s Guide. 2007.
ATUAL. Mecatrônica. Controle de um motor DC pelo pwm do PIC. Editora Saber Ltda,
2008. Disponível em: < http://www.mecatronicaatual.com.br/secoes/leitura/125>. Acesso em:
05 out. 2009.
Despertando Para A Importância Das Competições De Robôs In: COBENGE - Congresso
Brasileiro de Ensino de Engenharia, 2006, Passo Fundo, RS. Proceedings. Passo Fundo,
RS: UPF, 2006.
SILVA, Álison Silveira da. Desenvolvimento e implementação de um protótipo receptor
gps com o uso de dispositivo micro receptor e módulo microcontrolador para aplicação
acadêmica. Novo Hamburgo, RS: 2008.
INMEPE MAIA, Mecânica para Eletrônica Ltda. Micro Redutores DC. Disponível em:
<www.maia.ind.br>, Acesso em: 10 out 2009.
135
INTERSIL, Corporation . Data Sheet BIMOS Operational Amplifier With MOSFET. 2005.
136
ANEXO A – PARTES MANUAL DSPIC30F2010
137
138
139
140
141
142
143
ANEXO B – ESQUEMA DA PLACA DO MICROCONTROLADOR
144
APÊNDICE A – ESQUEMA ELÉTRICO COMPLETO
145
146
147
APÊNDICE B – CÓDIGO FONTE DSPIC30F2010.
/* Autor: Lessandro Cabral Teixeira Data: 08/10/2009 Titulo: Controle dspic 2010 - Sumô de robo Rev: 19/11/2009 Assunto: Decodificação UART recebida do outro micro controlador.
Manipulação da movimentação do Robo. Identificação sensor inicio da partida e carregad or plugado. Temporização da disputa. */ //************************************************* ************************* //***** Bibliotecas Utilizadas ******************** ** #include<p30f2010.h> //Biblioteca do dsPIC30F201 0 #include<uart.h> //Biblioteca UART.h #include<pwm.h> //Biblioteca PWM.h #include<reset.h> //Biblioteca reset.h #include<delay.h> //Biblioteca delay.h #include <outcompare.h> #include <timer.h> #include<ports.h> //************************************************* ************************* //***** Fuses *************************** _FOSC(CSW_FSCM_OFF & HS); // Oscilador externo sem tratamento de erro _FWDT(WDT_OFF); // WatchDog disabilitado _FBORPOR(MCLR_EN & PBOR_OFF & PWRT_OFF); // Habilit a MCLR, Desabilita
//PBOR e PWRT _FGS(CODE_PROT_OFF); // Sem protecao de codigo - é possível a
//leitura // posterior a gravação do chip //************************************************* ************************* //**** Define Valores Padrões para o Programa ***** ************* #define Fcy 5000000 //Freqüência do ciclo=freqüênci a do oscilador/4 //dsPIC necessita de 4 ciclos de clock para
//executar um ciclo de instrução #define Freq_AD (Fcy / 10000) //freqüência do Time r 2 para habilitar
//conv.A/D = 85KHz #define Tad (7) //Tempo para conversão A/D a 104 Ksps
//para Fcy=5000000 //************************************************* ************************* //******** Declarando as variáveis **************** ********** int PWM_inic; unsigned int dist_sonar_d; //define a variável inte ira dist_sonar_d unsigned int dist_sonar_e; int Vel_Pwm1=100; //define a variável inteira Vel _Pwm1 int Vel_Pwm2=100; //define a variável inteira Vel _Pwm2
148
//Velocidade atual do motor unsigned int dtycregpwm1; //define a variável dutyc yclereg pwm1 unsigned int dtycyclpwm1; //define a variável dutyc ycle pwm1 unsigned int dtycregpwm2; //define a variável dutyc yclereg pwm2 unsigned int dtycyclpwm2; //define a variável dutyc ycle pwm2 //Dutycycle (largura do pulso) para o PWM unsigned int updatedisable; //define a variável int eira sem sinal
//updatedisable unsigned int period; //define a variável inteira s em sinal period //período do PWM unsigned int sptime; //define a variável inteira s em sinal sptime unsigned int config1; //define a variável inteira sem sinal
//config1 unsigned int config2; //define a variável inteira sem sinal
//config2 unsigned int config3; //define a variável inteira sem sinal
//config3 unsigned int ADResult[16]; //define a matriz de var iáveis inteiras sem
//sinal ADResult //recebe o resultado da conversão A/D volatile unsigned int *ptr; //define a variável pon teiro inteira sem
//sinal ptr //ponteiro para indicar o resultado da
//conversão A/D nos buffers unsigned int a=1; //define a variável a long unsigned int AD_Med; //define a variável intei ra sem sinal de
//32bits AD_Med //variável utilizada para fazer a média das
//4 conversões A/D int sonar_d=0; int sonar_e; int p; int direcao=5; int transmissao=0x00; int transmissao2=0x00; int transmissao3=0x00; int transmissao4=0x00; int andar=0; int giro=0; int fuga=0; int inicio=0; int tempo=0; //************************************************* ************************* //************* Funções Utilizadas***************** ****** void inicia_timer1(void); void inicia_ADC(); void __attribute__((__interrupt__)) _ADCInterrupt(v oid); void inicia_timer2(void); void inicia_PWM(); //declara a função para inici ar PWM void __attribute__((__interrupt__)) _PWMInterrupt(v oid); void PWM_Motor(void); //declara a função para a Rotina de
//ajuste da rotação do motor DC void inicia_UART(); void _ISR _U1RXInterrupt(void); void fuga02(); void fuga01(); void fuga03(); void fuga04(); void fuga13(); void fuga06(); void procura();
149
//************************************************* ************************* /* Definição dos pinos RB5 - Direção 0 motor direita. RB3 - Direção 1 motor direita. RE1 - PWM motor direita. RB2 - Direção 0 motor esquerda. RD1 - Direção 1 motor esquerda. RE3 - PWM motor esquerda. RD0 - Controle para acionamento da leitura do sonar _d esquerdo. (Led de status) RE8 - Controle para acionamento da leitura do sonar _d direito. Pino 2 - AN0 /RB0 - Analógica que recebe sonar_d es querdo. Pino 3 - AN1 /RB1 - Analógica que recebe sonar_d di reito. */ //***** Rotina Principal do Programa ************** ********* int main(void) TRISB = 0xffd3; TRISD = 0xfffc; TRISE = 0xfef7; PWM_inic=10; inicia_timer1(); inicia_PWM(); //Inicializa o PWM inicia_ADC(); inicia_UART(); inicia_timer2(); //inicializa o timer da convers ão A/D void _ISR _T1Interrupt(void); while(1) return 0; //devolve zero (0) void inicia_timer1(void) T1CON = 0; //desabilita a contagem do timer1 TMR1 = 0; //zera a contagem de tempo do time r1 IFS0bits.T1IF = 0; //clear no bit de chamada da
//interrupção do timer1 PR1 = Fcy/(1800); //ajusta o período de tempo do timer1
//para o valor da freqüência //do ciclo de instrução/256=1 segundo //período que pisca o LED de status
//quando não há comunicação T1CONbits.TCKPS = 3; //Ajusta o prescaler par a 1:256 IPC0bits.T1IP = 4; //Define a prioridade da i nterrupção
//do timer1=7 IEC0bits.T1IE = 1; //habilita a interrupção d o timer1 T1CONbits.TON = 1; //habilita a contagem do t imer1 void _ISR _T1Interrupt(void) //função para tratam enro da
//interrupção do timer 1. // Função responsável pela
//temporização de atualização do PWM e
150
//controle de leitura de cada sensor //separadamente
//para que não ocorra interferência //entre eles.
tempo ++; PWM_Motor(); //Atualiza PWM dos Motores if (a==1) //verifica se a variável a=1 LATDbits.LATD0 = 0; //Liga o LED de status e des liga sonar
//esquerdo. LATEbits.LATE8 = 1; //Habilita sonar direito. a=0; //variável a=0 //fim do if else //se a variável a é diferente de 1
//então executa os seguintes comandos LATDbits.LATD0 = 1; //Desliga o LED de status e liga sonar
//esquerdo. LATEbits.LATE8 = 0; //Desabilita sonar direito. a=1; //fim do else IFS0bits.T1IF = 0; // clear no bit de inter rupção do
//timer 1 void inicia_PWM() unsigned int config; //define a variável config config = ( //Define a variável config com os
//seguintes parâmetros PWM_INT_EN & //Habilita a interrupção de PWM PWM_INT_PR1 & //Define a prioridade da interrup ção
//de PWM=1 PWM_FLTA_DIS_INT); //Desabilita a interrupção do "FaultA" ConfigIntMCPWM(config); //Função que configura as interrupções
//do PWM //de acordo com o conteudo da variável
//config dtycregpwm1 = 1; //Ponteiro para o registrador d e Duty
//Cycle dtycyclpwm1 = 0x0000; //Define o valor inicial de Duty
//Cycle=0 dtycregpwm2 = 2; //Ponteiro para o registrador d e Duty
//Cycle dtycyclpwm2 = 0x0000; //Define o valor inicial de Duty
//Cycle=0 //Para f=10KHz, dutycycle0%=0,
//(dutycycle100%=0x01f6 ???) updatedisable = 0; //Habilita a atualização dos registros
//de período e Duty Cycle SetDCMCPWM(dtycregpwm1,dtycyclpwm1,updatedisable); SetDCMCPWM(dtycregpwm2,dtycyclpwm2,updatedisable); //Função que configura o Duty Cycle //do PWM de acordo com o conteudo da
//variáveis period = 0x00ff; //define o período como 0x00fa hex,
//freq=10KHz //define o período como 0x00ff hex,
//freq= +-10KHz sptime = 0x0; //define o "sptime" como 0 config1 = ( //Define a variável config1 com os s eguintes
151
//parâmetros PWM_EN & //Habilita o módulo PWM PWM_IDLE_CON & //Continua a operação em modo IDLE PWM_IPCLK_SCALE1 & //Define o prescaler como 16 PWM_OP_SCALE16 & //Define o Postcaler como 16 PWM_MOD_UPDN); //Define o modo "UPDN" config2 = ( //Define a variável config2 com os s eguintes
//parâmetros PWM_MOD1_IND & //Define o modo complementar para o "PDC1" PWM_MOD2_IND & PWM_PEN1H & //Habilita o PWM1H (pino 25) PWM_PEN2H & //Habilita o PWM2H (pino 23) PWM_PDIS1L & //Desabilita o PWM1L (pino 26) PWM_PDIS3H & //Desabilita o PWM3H (pino 21) PWM_PDIS3L & //Desabilita o PWM3L (pino 22) PWM_PDIS2L); //Desabilita o PWM2L (pino 24) config3 = (PWM_UEN); //Define a variável config3 c om os seguintes
//parâmetros //Habilita a atualização do módulo PWM OpenMCPWM(period, sptime, config1, config2, config 3); //Função que configura o início do //módulo de PWM de acordo com o conteudo da
//variáveis void PWM_Motor(void) if (transmissao2 == 0x02) Vel_Pwm2=0; // motor esquerdo Vel_Pwm1=0; //motor direito else if(inicio < 2) Vel_Pwm2=0; // motor esquerdo Vel_Pwm1=0; if (PORTEbits.RE0 == 1) inicio = 1; if (PORTEbits.RE0 == 0 && inicio ==1) inicio = 2; else if (tempo > 300) //300 equivale a 30 segundos de f uncionamento. Vel_Pwm2=0; // motor esquerdo Vel_Pwm1=0; else if (transmissao == 0x02 )
152
fuga02(); else if (transmissao == 0x10) fuga01(); else if (transmissao == 0x03) fuga03(); else if (transmissao == 0x04) fuga04(); else if (transmissao == 0x13) fuga13(); //Acionamento dos 2 sensores traseiros. else if (transmissao == 0x06) fuga06(); else procura(); dtycyclpwm2 = Vel_Pwm2; //variável dutycycle receb e o valor da
//velocidade dtycyclpwm1 = Vel_Pwm1; //atualiza as configuraçõesdo PWM para assumir o novo valor do Duty Cycle SetDCMCPWM(dtycregpwm1,dtycyclpwm1,updatedisable);
153
SetDCMCPWM(dtycregpwm2,dtycyclpwm2,updatedisable) ; void __attribute__((__interrupt__)) _PWMInterrupt(v oid) IFS2bits.PWMIF = 0; //clear no bit de chamada da interrupção do
//PWM //--------------------------TRATAMENTO DO AD PARA S ENSORES SONAR------------ void inicia_ADC() ADCON1bits.ADON = 0; //desabilita o módulo de conversão A/D ADCON1bits.ADSIDL = 0; //módulo A/D continua c onvertendo
//mesmo com a CPU em modo //idle(inativa)
ADCON1bits.FORM = 0; //formato da saída da co nversão sem //sinal
ADCON1bits.SSRC = 7; //contador interno termi na uma //amostragem e já começa a próxima
ADCON1bits.ASAM = 0; //amostragem individual ADCON2bits.VCFG = 0; //referencia AVDD e AVSS ADCON2bits.CSCNA = 1; //utiliza apenas um cana l para a
//conversão. Habilita Scan alternado //através das entradas selecionadas no //MUX A
ADCON2bits.SMPI = 2; //gera uma interrupção a cada 2 //conversões - buffer(0)
ADCON2bits.BUFM = 0; //buffer de 16 bits ADCON2bits.ALTS = 0; //utiliza sempre o MUX A , não alterna
//entre MUX A e MUX B ADCON3bits.ADCS = Tad; // Tad equals Min am ount of instr
//cycles Fastest possible //seleciona o clock de conversão ADCON3bits.SAMC = 1; //define o tempo da auto -amostragem em
//1 Tad ADCON3bits.ADRC = 0; // derive Tad from sy stem clock // //utiliza o mesmo clock do sistema ADCHS = 0; //configura o conversor AN0 como
//entrada positiva ADCSSL = 0x0003; //seleciona a entrada AN0 e AN1 para a
//conversão ADPCFG = 0xFFFC; //configura apenas o pino AN0 e AN1
//como entrada analógica IFS0bits.ADIF = 0; //clear no bit de chamada da
//interrupção da conversão A/D IPC2bits.ADIP = 6; //Define a prioridade da i nterrupção
//do módulo A/D=6 IEC0bits.ADIE = 1; //habilita a interrupção d o módulo A/D ADCON1bits.ADON = 1; //habilita o módulo de c onversão A/D //************************************************* ************************* //***** Rotina de Tratamento da Interrupção do Conv ersor A/D *********** void __attribute__((__interrupt__)) _ADCInterrupt(v oid) int i = 0; int bat = 0; //define a variável inteira Pos_Atua l ptr = &ADCBUF0; //ponteiro ptr recebe o endereço d o buffer0
154
for (p=0; p<1; p++) //de conversão A/D for (i=0; i<16; i++) //executa a leitura da conversão A/D enquanto i<16 ADResult[i] = *ptr++; //ponteiro ptr é incrementa do até i=15 //ADResul recebe os valores da
//conversão A/D na posição '0' //são feitas 16 leituras para garantir
//que os 16 buffers da //conversão A/D sejam lidos e
//automaticamente limpos, //garantindo que o resultado da
//próxima leitura fique no buffer0 //fim do while sonar_d = ADResult[1]; sonar_e = ADResult[0]; if(sonar_d < 70 || sonar_d > 10) // rotina utilizad a para limpar
//valores lidos pelo sonar if (sonar_d < dist_sonar_d/1,5 || sonar_d > dist_so nar_d*1,5) dist_sonar_d=sonar_d; dist_sonar_e=sonar_e; IFS0bits.ADIF = 0; //clear no bit de chamada da
//interrupção da conversão A/D //************************************************* ************************* void inicia_timer2(void) T2CON = 0; //desabilita a contagem do timer2 TMR2 = 0; //zera a contagem de tempo do time r2 IFS0bits.T2IF = 0; //clear no bit de chamada da
//interrupção do timer2 PR2 = Freq_AD; //ajusta o período de tempo d o timer2
//para o valor da variável //Freq_AD determinando a frequência de
//conversão do A/D T2CONbits.TCKPS = 0; //Ajusta o prescaler par a 1:1 IPC1bits.T2IP = 5; //Define a prioridade da i nterrupção
//do timer2=5 IEC0bits.T2IE = 1; //habilita a interrupção d o timer2 T2CONbits.TON = 1; //habilita a contagem do t imer2 //************************************************* ************************* //******* Rotina de tratamento da interrupção do Ti mer 2 para conversão A/D void _ISR _T2Interrupt(void) IFS0bits.T2IF = 0; // clear no bit de inter rupção do
// timer 2 ADCON1bits.SAMP = 1; // executa a converssão A /D void inicia_UART()
155
unsigned int ubrg; //define a variável ubrg unsigned int config1; //define a variável config1 unsigned int config2; //define a variável config2 CloseUART1(); // desabilita a UART1 ubrg = 32; // ubrg=(fcy/(BaudRate*16))-1 // fcy=FCristal/4 // Neste Caso: Baud Rate=9600 // Freq.Cristal=20MHz // fcy=5MHz, ubrg=31,55 ConfigIntUART1(UART_RX_INT_EN & //Função para conf iguração das
//interrupções da UART //habilita a interrupção de recepção UART_RX_INT_PR7 & //Define a prioridade da int errupção
//de recepção=2 UART_TX_INT_EN & //habilita a interrupção de
//transmissão UART_TX_INT_PR4); //Define a prioridade da int errupção
//de transmissão=4 config1 = UART_EN & //Define a variável config1 com os
//seguintes parâmetros //Habilita o módulo UART UART_IDLE_CON & //UART funcionando no modo IDLE UART_RX_TX & //Configura a comunicação através dos pinos padrões //de TX e RX (U1TX e U1RX) UART_DIS_WAKE & //Desabilita o modo "Wake-up" UART_DIS_LOOPBACK & //desabilita o modo "loop back" UART_DIS_ABAUD & //Desabilita o modo "autobaud" UART_NO_PAR_8BIT & //Define a comunicação com 8 bi ts de dados e //sem bit de paridade UART_1STOPBIT; //Define o Stop Bit=1 config2 = UART_INT_TX_BUF_EMPTY & //Define a vari ável config2 com
//os seguintes parâmetros //Ocorre interrupção de
//transmissão quando buffer de //transmissão for esvaziado UART_TX_PIN_NORMAL & //Define o bit TXBreak como normal UART_TX_ENABLE & //Habilita a transmissão da UAR T UART_INT_RX_BUF_FUL & //Ativa a interrupção de recepção
//quando Buffer estiver cheio (4 //bytes)
UART_ADR_DETECT_DIS & //Desativa o modo de "adress detect" UART_RX_OVERRUN_CLEAR; //Limpa o flag de "overrun" OpenUART1(config1, config2, ubrg); //Habilita a UAR T1 com os parâmetros
//de configuração //definidos pelas variáveis Config1,
//config2 e ubrg //***** Rotina de tratamento da Interrupção da tran smissão de dados void _ISR _U1TXInterrupt(void) //função da rotina de interrupção de
//transmissão de dados IFS0bits.U1TXIF=0; //clear no bit de chamada d a
//interrupção de transmissão //************************************************* ************************* //***** Rotina de tratamento da Interrupção da rece bimento de dados //************************************************* ************************* void _ISR _U1RXInterrupt(void) //função da rotina de interrupção de recepção d e dados
156
while(BusyUART1()); //retorna o status da transmi ssão; espera
//enquanto a UART estiver ocupada transmissao=ReadUART1(); transmissao2=ReadUART1(); transmissao3=ReadUART1(); transmissao4=ReadUART1(); while(BusyUART1()); fuga = 0; PWM_Motor(); IFS0bits.U1RXIF=0; //clear no bit de chamada da i nterrupção de
//recepção void fuga02() //Sensor frontal direito setado. Ro tina para
//fuga dessa situação. if (fuga < 3) LATDbits.LATD1 = 0; //Acelera direito LATBbits.LATB2 = 1; LATBbits.LATB3 = 0; // Recua esquerdo LATBbits.LATB5 = 1; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga >= 3 && fuga <=7) LATDbits.LATD1 = 0; //Acelera direito LATBbits.LATB2 = 1; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; // Gira para esquerda visto d e frente do
//carro. Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga > 7) transmissao = 0x00; void fuga01() //Sensor traseiro esquerdo. Rotina para fuga
//dessa situação. LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=150; // motor direito fuga++; if (fuga > 5)
157
transmissao = 0x00; void fuga03() //Sensor traseiro direito. Rotina p ara fuga
//dessa situação. LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=150; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga > 5) transmissao = 0x00; void fuga04() //Sensor frontal esquerdo. Rotina p ara fuga
//dessa situação. if (fuga <3) LATDbits.LATD1 = 0; //Acelera direito LATBbits.LATB2 = 1; LATBbits.LATB3 = 0; // Recua esquerdo LATBbits.LATB5 = 1; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga >= 3 && fuga <= 7) LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 0; // Recua esquerdo LATBbits.LATB5 = 1; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga > 7) transmissao = 0x00; void fuga13() //Saída com os dois sensores traseir os. LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++;
158
if (fuga > 7) transmissao = 0x00; void fuga06() // Saída com os dois sensores frontais. if (fuga < 3) LATDbits.LATD1 = 0; //Acelera direito LATBbits.LATB2 = 1; LATBbits.LATB3 = 0; // Recua esquerdo LATBbits.LATB5 = 1; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga >= 3 && fuga <=7) LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 0; // Recua esquerdo LATBbits.LATB5 = 1; Vel_Pwm2=500; // motor esquerdo Vel_Pwm1=500; // motor direito fuga++; if (fuga > 7) transmissao = 0x00; void procura() if (dist_sonar_d > 40 && dist_sonar_e > 40 && andar < 6 ) //velocidade maxima 400. E minima utilizavel 200 LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua Direito LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; andar++; if (andar ==5) giro = 0; else if (dist_sonar_d > 40 && dist_sonar_e > 40 && direc ao==5 && giro < 6 ) LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0;
159
LATBbits.LATB3 = 0; // Recua Direito LATBbits.LATB5 = 1; Vel_Pwm2=500; Vel_Pwm1=500; giro++; if (giro==5) andar = 0; else if (dist_sonar_d < 30 && dist_sonar_e > 40) LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua Direito LATBbits.LATB5 = 0; Vel_Pwm2=500; //motor esquerdo Vel_Pwm1=150; // motor direito direcao=5; //se for 5 indica que
//adversário saiu pela //direita.
else if (dist_sonar_d < 30 && dist_sonar_e < 30) LATDbits.LATD1 = 1; //Acelera esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua Direito LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; else if (dist_sonar_d > 40 && dist_sonar_e < 30)
LATDbits.LATD1 = 1; //Recua esquerdo LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Acelera Direito LATBbits.LATB5 = 0; Vel_Pwm2=150; // motor esquerdo Vel_Pwm1=500; // motor direito direcao=0; //indica que adversario saiu pela esqu erda. else
160
if (andar < 5) LATDbits.LATD1 = 1; //Acelera direito LATBbits.LATB2 = 0; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; andar++; else if (giro <5 ) LATDbits.LATD1 = 0; //Acelera direito LATBbits.LATB2 = 1; LATBbits.LATB3 = 1; // Recua esquerdo LATBbits.LATB5 = 0; Vel_Pwm2=500; Vel_Pwm1=500; giro++; else andar = 0; giro = 0; // FIM DO PROGRAMA.*****
161
APÊNDICE C – CÓDIGO FONTE DSPIC30F3013.
/* Autor: Lessandro Cabral Teixeira Data: 07/10/2009 Titulo: Controle do processador de apoio dsPIC30F30 13. Sumô de robo. Rev: 19/11/2009 Assunto: Controle dos sensores de borda, transmissã o dos dados pela UART, controle de carga da bateria em funcionamento e em carregamento */ //************************************************* *********************** //Bibliotecas Utilizadas ************************** *********************** #include<p30f3013.h> //Biblioteca do dsPIC30F20 10 #include<uart.h> //Biblioteca UART.h #include<pwm.h> //Biblioteca PWM.h #include<reset.h> //Biblioteca reset.h #include<delay.h> //Biblioteca delay.h #include <outcompare.h> #include <timer.h> #include<ports.h> //************************************************* *************************//***** Fuses ************************************* ************************* _FOSC(CSW_FSCM_OFF & HS); // Oscilador externo sem tratamento de erro _FWDT(WDT_OFF); // WatchDog disabilitado _FBORPOR(MCLR_EN & PBOR_OFF & PWRT_OFF); // Habilit a MCLR, Desabilita
//PBOR e PWRT _FGS(CODE_PROT_OFF); // Sem protecao de codigo - é possível a
//leitura posterior a gravação do chip //************************************************* ************************* //**** Define Valores Padrões para o Programa #define Fcy 5000000 //Freqüência do ciclo=freqüênc ia do
//oscilador/4 dsPIC necessita de 4 ciclos de //clock para executar um ciclo de instrução
#define Freq_AD (Fcy / 10000) //freqüência do Timer 2 para habilitar //conv.A/D = 85KHz
#define Tad (9) //Tempo para conversão A/D a 104K sps para //Fcy=5000000
//************************************************* ************************* //******** Declarando as variáveis **************** ********** int Bat_Atual; //define a variável inteira Bat_A tual int Vel_Pwm1=150; //define a variável inteira Ve l_Pwm1
162
int Vel_Pwm2=150; //define a variável inteira Ve l_Pwm2 //Velocidade atual do motor unsigned int dtycregpwm1; //define a variável duty cyclereg pwm1 unsigned int dtycyclpwm1; //define a variável duty cycle pwm1 unsigned int dtycregpwm2; //define a variável duty cyclereg pwm2 unsigned int dtycyclpwm2; //define a variável duty cycle pwm2 //Dutycycle (largura do pulso) para o
//PWM unsigned int updatedisable; //define a variável in teira sem sinal updatedisable unsigned int period; //define a variável inteira sem sinal period //período do PWM unsigned int config1; //define a variável inteira sem sinal
//config1 unsigned int config2; //define a variável inteira sem sinal
//config2 unsigned int config3; //define a variável inteira sem sinal
//config3 unsigned int ADResult[16]; //define a matriz de va riáveis
//inteiras sem sinal ADResult //recebe o resultado da conversão A/D volatile unsigned int *ptr; //define a variável po nteiro inteira
//sem sinal ptr //ponteiro para indicar o resultado da
//conversão A/D nos buffers unsigned int a=0; //define a variável a long unsigned int AD_Med; //define a variável inte ira sem sinal
//de 32bits AD_Med //variável utilizada para fazer a
//média das 4 conversões A/D int transmissao = 0x00; int transmissao2 = 0x00 ; int transmissao3 = 0x00 ; int transmissao4 = 0x00 ; int transmite_borda = 0x00; int sensor1; int sensor2; int sensor3; int sensor4; int acelerax = 2000 ; int aceleray ; int inc_acelera; int b=0; int plugado = 0; //************************************************* ************************* //************* Funções Utilizadas***************** ****************** void inicia_timer1(void); void inicia_int1(void); void inicia_UART2(); void inicia_ADC(); void inicia_timer2(void); //************************************************* ************************* /* Definição dos pinos RD8 - Led de status / Recebe Acionamento sensor de Borda - Pino de interrupção externa INT1. RD9 - Sensor borda 1
163
RB8 - Sensor Borda 6 RB9 - Sensor Borda 5 RF6 - Sensor Borda 2 RB5 - Mostra carga da bateria baixa. RB4 - Mostra carregador plugado RB7 - identifica carregador plugado. UART 2 PINO 22RX - 21TX */ //***** Rotina Principal do Programa ************** ******** int main(void) TRISB = 0xfccf; TRISD = 0xfdff; TRISF = 0xffbf; inicia_timer1(); inicia_int1(); inicia_UART2(); inicia_ADC(); inicia_timer2(); void _ISR _T1Interrupt(void); void __attribute__((__interrupt__)) _INT1Interrupt( void); while(1) return 0; //devolve zero (0) //*********************INICIALIZAÇÃO DO TIMER 1 *** ********** void inicia_timer1(void) T1CON = 0; //desabilita a contagem do timer1 TMR1 = 0; //zera a contagem de tempo do timer 1 IFS0bits.T1IF = 0; //clear no bit de chamada d a interrupção do
//timer1 PR1 = Fcy/(15600); //ajusta o período de tempo do timer1 para o
//valor da freqüência //do ciclo de instrução/256=1 segundo //período que pisca o LED de status quando
//não há comunicação T1CONbits.TCKPS = 3; //Ajusta o prescaler para 1:256 IPC0bits.T1IP = 2; //Define a prioridade da in terrupção do
//timer1=7 IEC0bits.T1IE = 1; //habilita a interrupção do timer1 T1CONbits.TON = 1; //habilita a contagem do ti mer1 //*********************** TRATAMENTO DA INTERRUPÇÃO DO TIMER 1 **** void _ISR _T1Interrupt(void) //função de interrupç ão do timer 1. if (PORTBbits.RB7 == 1)
164
plugado = 1; LATBbits.LATB4 = 1; //identifica carregador de bat eria ligado else plugado = 0; LATBbits.LATB4 = 0; switch(a) case 0: // Todos os sensores verifica-se olhando se
//frente para o robo. LATBbits.LATB8 = 0; LATBbits.LATB9 = 0; // Case que habilita sensor f rontal esquerdo LATFbits.LATF6 = 0; LATDbits.LATD9 = 1; break; case 1: LATDbits.LATD9 = 0; LATBbits.LATB8 = 0; //Case que habilita sensor fr ontal direito. LATBbits.LATB9 = 1; LATFbits.LATF6 = 0; break; case 2: LATDbits.LATD9 = 0; LATBbits.LATB8 = 1; //Case que habilita sensor tr aseiro
//esquerdo. LATBbits.LATB9 = 0; LATFbits.LATF6 = 0; break; case 3: //se a variável a é diferente de 1 entã o
//executa os seguintes comandos LATDbits.LATD9 = 0; LATBbits.LATB8 = 0; LATBbits.LATB9 = 0; //Case que habilita sensor tr aseiro direito. LATFbits.LATF6 = 1; break; //variável a=1 a++; if (a>4) a=0; transmissao=sensor1+sensor2+sensor3+sensor4;
165
if (transmissao >0x00 || transmissao2 > 0x00) while(BusyUART2()); //retorna o status da transmis são; espera
//enquanto a UART estiver ocupada WriteUART2(transmissao); WriteUART2(transmissao2); WriteUART2(transmissao3); WriteUART2(transmissao4); while(BusyUART2()); sensor1=0x00; //reset nas variáveis dos sensores e
//trasnmissão sensor2=0x00; sensor3=0x00; sensor4=0x00; transmissao=0x00; transmissao2=0x00; IFS0bits.T1IF = 0; // clear no bit de interr upção do timer 1 //************************************************* ************************* //*************INICIALIZAÇÃO DA INTERRUPÇÃO EXTERNA void inicia_int1(void) // ROTINA PARA INICIALIZAR A INTERRUPÇÃO EXTERNA. CloseINT1(); ConfigINT1(RISING_EDGE_INT & EXT_INT_PRI_7 & EXT_IN T_ENABLE); //Define a prioridade da interrupção do timer1=1 //********************* ROTINA PARA TRATAMENTO DA I NTERRUPÇÃO EXTERNA void __attribute__((__interrupt__)) _INT1Interrupt( void) if (LATBbits.LATB8 == 1) sensor1 = 0x10; //indica sensor traseiro esquerd o
//setado. else if (LATBbits.LATB9 == 1) sensor2 = 0x02; //indica sensor frontal direito
//setado. else if (LATFbits.LATF6 == 1) sensor3 = 0x03; //indica sensor traseiro direito
//setado.
166
else if (LATDbits.LATD9 == 1) sensor4 = 0x04; //indica sensor frontal esquerdo
//setado. IFS1bits.INT1IF = 0; //********************* INICIALIZAÇÃO DA UART 2 *** ****************** void inicia_UART2() //ROTINA PARA INICIALIZAR A UA RT unsigned int ubrg; //define a variável ubrg unsigned int config1; //define a variável config1 unsigned int config2; //define a variável config2 CloseUART2(); // desabilita a UART1 ubrg = 32; // ubrg=(fcy/(BaudRate*16))-1 // fcy=FCristal/4 // Neste Caso: Baud Rate=9600 // Freq.Cristal=20MHz // fcy=5MHz, ubrg=31,55 ConfigIntUART2(UART_RX_INT_EN & //Função para conf iguração das
//interrupções da UART //habilita a interrupção de recepção UART_RX_INT_PR2 & //Define a prioridade da inter rupção
//de recepção=2 UART_TX_INT_EN & //habilita a interrupção de
//transmissão UART_TX_INT_PR4); //Define a prioridade da inte rrupção
//de transmissão=4 config1 = UART_EN & //Define a variável config1 com os
//seguintes parâmetros //Habilita o módulo UART UART_IDLE_CON & //UART funcionando no modo IDLE UART_RX_TX & //Configura a comunicação através d os
//pinos padrões //de TX e RX (U1TX e U1RX) UART_DIS_WAKE & //Desabilita o modo "Wake-up" UART_DIS_LOOPBACK & //desabilita o modo "loop bac k" UART_DIS_ABAUD & //Desabilita o modo "autobaud" UART_NO_PAR_8BIT & //Define a comunicação com 8 bits de
//dados e //sem bit de paridade UART_1STOPBIT; //Define o Stop Bit=1 config2 = UART_INT_TX_BUF_EMPTY &
//Define a variável config2 com os //seguintes parâmetros
//Ocorre interrupção de transmissão //quando buffer de
//transmissão for esvaziado UART_TX_PIN_NORMAL & //Define o bit TXBreak como normal UART_TX_ENABLE & //Habilita a transmissão da UAR T UART_INT_RX_BUF_FUL & //Ativa a interrupção de re cepção
//quando Buffer estiver cheio (4 //bytes)
UART_ADR_DETECT_DIS & //Desativa o modo de "adress detect" UART_RX_OVERRUN_CLEAR; //Limpa o flag de "overrun"
167
OpenUART2(config1, config2, ubrg); //Habilita a UAR T1 com os parâmetros //de configuração
//definidos pelas variáveis Config1, //config2 e ubrg
//************************************************* ************************* //***** Rotina de tratamento da Interrupção da rece bimento de dados //************************************************* ************************* void __attribute__((__interrupt__)) _U2TXInterrupt( void) IFS1bits.U2TXIF = 0; void __attribute__((__interrupt__)) _U2RXInterrupt( void) IFS1bits.U2RXIF = 0; void inicia_ADC() ADCON1bits.ADON = 0; //desabilita o módulo de conversão A/D ADCON1bits.ADSIDL = 0; //módulo A/D continua c onvertendo
//mesmo com a CPU em modo //idle(inativa)
ADCON1bits.FORM = 0; //formato da saída da co nversão sem //sinal
ADCON1bits.SSRC = 7; //contador interno termi na uma //amostragem e já começa a próxima
ADCON1bits.ASAM = 0; //amostragem individual ADCON2bits.VCFG = 0; //referencia AVDD e AVSS ADCON2bits.CSCNA = 1; //utiliza apenas um cana l para a
//conversão ADCON2bits.SMPI = 3; //gera uma interrupção a cada 3
//conversão - buffer(0) ADCON2bits.BUFM = 0; //buffer de 16 bits ADCON2bits.ALTS = 0; //utiliza sempre o MUX A , não alterna
//entre MUX A e MUX B ADCON3bits.ADCS = Tad; // Tad equals Min am ount of instr
// cycles Fastest possible //seleciona o clock de conversão ADCON3bits.SAMC = 1; //define o tempo da auto -amostragem em
//1 Tad ADCON3bits.ADRC = 0; // derive Tad from sy stem clock // //utiliza o mesmo clock do sistema ADCHS = 0; //configura o conversor AN0 como
//entrada positiva ADCSSL = 0x000D; //seleciona a entrada AN0 pa ra a
//conversão ADPCFG = 0xFFF2; //configura apenas o pino AN0 c omo
//entrada analógica IFS0bits.ADIF = 0; //clear no bit de chamada da
//interrupção da conversão A/D IPC2bits.ADIP = 6; //Define a prioridade da i nterrupção
//do módulo A/D=6 IEC0bits.ADIE = 1; //habilita a interrupção d o módulo A/D ADCON1bits.ADON = 1; //habilita o módulo de c onversão A/D //************************************************* ************************* //***** Rotina de Tratamento da Interrupção do Conv ersor A/D ************** void __attribute__((__interrupt__)) _ADCInterrupt(v oid)
168
int i = 0; //define a variável inteira Pos_Atual ptr = &ADCBUF0; //ponteiro ptr recebe o endereço do buffer0 //de conversão A/D while (i < 16) //executa a leitura da conversão A /D
//enquanto i<16 ADResult[i++] = *ptr++; //ponteiro ptr é incremen tado até i=15 //ADResul recebe os valores da
//conversão A/D na posição '0' //são feitas 16 leituras para garantir
//que os 16 buffers da //conversão A/D sejam lidos e
//automaticamente limpos, //garantindo que o resultado da
//próxima leitura fique no buffer0 //fim do while Bat_Atual=ADResult[0]; //Posição atual recebe o r esultado da
//conversão A/D if (plugado == 0) //variável que identifica carr egador
//plugado if (transmissao2 == 0x02) //seta variável de tran smissão para
//que microcontrolador principal saiba //que o carregador está plugado
transmissao2 = 0x01; if (Bat_Atual < 3150 ) //rotina para identificar carga baixa
//da bateria. = 3150 LATBbits.LATB5 = 1; else LATBbits.LATB5 = 0; else // se plugado for igual a 1 transmissao2 = 0x02; if (Bat_Atual > 4000 ) //rotina para acender o l ed do segundo
//estágio de carga LATBbits.LATB5 = 1; else LATBbits.LATB5 = 0; IFS0bits.ADIF = 0; //clear no bit de chamad a da
//interrupção da conversão A/D //************************************************* ************************* //******************** ROTINA PARA INICIALIZAÇÃO DO TIMER 2 ***********
169
void inicia_timer2(void) T2CON = 0; //desabilita a contagem do timer2 TMR2 = 0; //zera a contagem de tempo do time r2 IFS0bits.T2IF = 0; //clear no bit de chamada da
//interrupção do timer2 PR2 = Freq_AD; //ajusta o período de tempo d o timer2
//para o valor da variável //Freq_AD determinando a frequência de
//conversão do A/D T2CONbits.TCKPS = 0; //Ajusta o prescaler par a 1:1 IPC1bits.T2IP = 5; //Define a prioridade da i nterrupção
//do timer2=5 IEC0bits.T2IE = 1; //habilita a interrupção d o timer2 T2CONbits.TON = 1; //habilita a contagem do t imer2 //************************************************* ************************* //******* Rotina de tratamento da interrupção do Ti mer 2 para conversão A/D void _ISR _T2Interrupt(void) IFS0bits.T2IF = 0; // clear no bit de inter rupção do
//timer 2 ADCON1bits.SAMP = 1; // executa a converssão A /D //************************** FINAL DO PROGRAMA