ANEXO 7

RELATRIO FINAL
PIBIC/PIBITI/CNPq/IFSP

Nome do Bolsista inicial: Hugo Bernardino da Silva

Nome do Bolsista Substituto: Caio Nunes Bustamante Reis

Nome do Orientador: Ricardo Pires

Ttulo do Projeto: Criaa o de Interface para Parametrizaa o de Sistema de Controle Auto nomo
Microcontrolado de Motores de Corrente Contnua

Vige ncia da Bolsa: 01/09/2012 a 31/07/2013

INTRODUO

A utilizaa o de microcontroladores no controle de processos e frequente,

devido a precisa o, baixa necessidade de manutena o, durabilidade, tamanho
reduzido e confiabilidade.
Pore m, isto requer a atuaa o de um especialista em programaa o. Ele
devera receber uma descria o do problema e devera escrever um programa a ser
executado pelo microcontrolador. Isto requer, tambe m, um tempo considera vel.
Propo e-se aqui a criaa o de uma interface que permitira a geraa o
automa tica daqueles programas de forma amiga vel e ra pida, a partir da definia o
de valores para um conjunto de para metros, feita por na o especialistas. Esta
interface possuira um display e um teclado, para a apresentaa o de perguntas cujas
respostas, fornecidas pelo usua rio, definira o os valores daqueles para metros.
Terminada a parametrizaa o, o sistema gerara automaticamente um programa
apropriado.
Uma solua o geral para este problema seria de obtena o difcil. Por isto, este
sistema sera capaz de realizar esta tarefa apenas para um conjunto restrito de
condio es. Uma delas e o uso de um u nico modelo de microcontrolador MSP430.
Outra e a de que os dispositivos controlados so sera o motores de corrente
contnua. Este controle sera feito a partir de valores lidos de um conjunto de
sensores. Na parametrizaa o, o usua rio definira , de forma simples, como cada
motor devera reagir em funa o das leituras dos sensores. Por exemplo, um usua rio
podera determinar que sempre que um sensor de proximidade fornecer um valor
acima de certo limiar, um motor devera girar num certo sentido.
PROPOSIO

Criar uma interface que permita que usua rios na o especialistas na

programaa o de microcontroladores possam, fa cil e rapidamente, especificar
programas para aqueles dispositivos apenas pela definia o de um conjunto de
para metros, de forma amiga vel.
Para que se atinja o objetivo central, os objetivos intermedia rios sera o:
1. Escolha de um modelo de microcontrolador, estudo de sua arquitetura e de
sua programaa o;
2. Delimitaa o do conjunto de problemas que o sistema sera capaz de
resolver;
3. Especificaa o do conjunto de para metros a serem definidos e das perguntas
correspondentes na fase de parametrizaa o;
4. Implementaa o do programa parametriza vel;
5. Montagem da interface;
6. Testes.

O objetivo de criar um sistema embarcado, que pudesse realizar o controle de

motores de corrente contnua, surgiu com a necessidade de controlar robo s mo veis
tracionados por rodas, que a partir de sensores, fosse capaz controlar o movimento
do mesmo de maneira auto noma.
Esse controle sera feito por meio de configurao es que sera o determinadas pelo
usua rio antes de colocar o sistema para funcionar. Atrave s de um display de LCD
sera o dadas opo es de possveis respostas para cada entrada nos sensores.
RESULTADOS OBTIDOS

Ms 1 ao ms 4: Escolha de um modelo de microcontrolador, estudo de sua

arquitetura e de sua programao;
Primeiramente foi realizado um estudo e levantamento de conteu do
bibliogra fico para embasar a pesquisa, no site do fabricante, em fo runs, livros e
apostilas, e pode-se claramente perceber que o MSP430 possui algumas
caractersticas que o diferencia dos demais microcontroladores do mercado, por
exemplo, possui um modo de economia de energia muito interessante para
aplicao es embarcados, e possvel fazer ca lculos com 16 bits, clock interno de
16MHz, 10 pinos de I/O, 2 KB de memo ria flash...

Foi construda uma plataforma de testes, pesquisado diversos modelos de

controladores e decidido utilizar o LN298 que controla dois motores e suporta
PWM.
Optou-se por fazer um circuito, onde as sadas dos motores ficassem na mesma
placa. E existe uma protea o feita com dois diodos Schottky ligados a cada sada do
circuito, que tem o objetivo atenuar o rudo gerado pelo motor quando alimentado
em PWM. E os diodos do tipo Schottky por terem condua o mais ra pida,
exterminando o rudo ainda em seu incio.

O desenho do Layout foi feito no software ARES, utilizando os comandos

especficos desse software e conclui-se que seria melhor fazer uma PCI de duas
faces, pois economizaria muito espao. Com um lado das faces em aterramento
automa tico.

A parte meca nica e constituda por dois motores de corrente contnua

fixados em um chassi de polmero.
Apo s montada a plataforma de testes foram testados diversos tipos de
compiladores (IDEs), entre eles CCS, IAR e Energia, para decidir qual seria o
utilizado no desenvolvimento do projeto.
Dentre os aspectos testados estavam a limitaa o de linhas de co digo na versa o
gratuita, a facilidade de programaa o e a disponibilidade de bibliotecas e menus de
ajuda. Os compiladores CCS e IAR deixaram a desejar no aspecto de facilidade de
programaa o e ambos possuem limitao es para programaa o em C.
Apo s os testes verificou-se que o Energia possua uma interface mais amiga vel
e compatibilidade com alguns programas do Arduno, ale m de na o existir limite de
co digo para a linguagem de programaa o C.
Durante os testes foram analisados os programas que sera o utilizados no programa
final como conversores AD, entradas e sadas digitais, temporizadores, contadores,
PWM e Display de LCD.

A imagem abaixo representa a relaa o da LaunchPad com a IDE Energia,

mostrando a nomenclatura de programaa o e os pinos correspondentes
 Ms 4: Delimitaa o do conjunto de problemas que o sistema sera capaz de
resolver;
Estamos desenvolvendo um estudo preliminar para determinar quais os tipos
de sensores sera o lidos pelo dispositivo. Esta o em ana lise sensores capacitivos,
acelero metros, girosco pios, chaves fim de curso entre outros que permitam a
leitura pelo microcontrolador para tomada de deciso es.
No display aparecera o opo es dos tipos de sensores a serem analisados durante
o funcionamento, que sera o selecionados pelo usua rio e fornecidos para metros que
podem ser ajustados (resposta do sistema para cada tipo de sensor).

Ms 5: Mudana do bolsista de pesquisa e rearranjo do projeto para adequaa o

ao cronograma de metas a serem atingidas dentro do objetivo central.
Analisando a pesquisa realizada pelo bolsista anterior e o cronograma vigente,
para essa nova fase do projeto, concluiu-se que os resultados finais que o bolsista
anterior esperava devem ser simplificados em raza o do tempo para atingi-los e da
capacidade limitada que o MSP430 possuiu em relaa o a quantidade de entrada e
sada de seus terminais. Sendo assim, para a obtena o apenas do objetivo principal
do projeto, que e uma interface amiga vel para controle de motores DC, a ideia
inicial de se construir um robo mo vel programa vel por sensores foi substituda por
um controle simples de apenas um Motor DC que possui um sensor de velocidade
acoplado, um sensor de dista ncia (ultrasso nico) ao seu lado e pode ser
parametrizado atrave s de uma matriz de teclas com a interface de um display de
LCD 16x2.
O sensor ultrasso nico que e do modelo HC-SR04 e o display de LCD que e do
modelo HD44780 foram importados para economizar custos, ja que os mesmo no
Brasil sa o bem mais caros. A importaa o foi realizada no incio do me s e esta a
caminho do Brasil com previsa o de chegada no me s que vem. Enquanto isso, o
estudo da programaa o para escrita atrave s do microcontrolador em um Display
LCD emprestado mostra que palavras simples com ate 16 caracteres funcionam
perfeitamente. A pro xima etapa e encontrar programas que faam escritas de
frases com mais caracteres e que fiquem em rotaa o no Display para sua
visualizaa o, caso nenhum programa seja encontrado sera desenvolvido um
programa pro prio que faa a rotaa o das frases atrave s de Strings em linguagem C.
O programa para leitura do Teclado (uma matriz de tecladas) ja foi
desenvolvido, como mostrado no anexo A, e falta apenas adequaa o para o
programa principal que sera criado.
Tambe m comeou-se uma pesquisa sobre o sensor de velocidade para
aquisia o de um modelo adequado ao projeto ou dependendo do caso, construa o
de um a partir de componentes o pticos.

Ms 6: Ha uma biblioteca para o compilador Energia que permite escrever no

Display LCD frases com mais de 16 caracteres, atrave s da funa o scroll dessa
biblioteca e possvel escrever frases que rotacionam para direita ou para esquerda
a fim de aparecerem por completo. Pore m a biblioteca tem uma limitaa o de 40
caracteres por linha para rotaa o, mais caracteres que isso o programa pula os
caracteres excedentes para a outra linha do display, bagunando a escrita da frase.
Dado isso, as perguntas para parametrizaa o na o podem ultrapassar os 40
caracteres limites que devem ser o suficiente para cada pergunta. Outras limitao es
e o fato da funa o scroll na o agir independente entre as duas linhas, ou seja, ao
ativarmos essa funa o, a escrita nas duas linhas do display sa o rotacionadas e,
tambe m, o fato das letras com caracteres especiais na o aparecerem corretamente,
assim na o e possvel usar o ou o a na escrita do display por exemplo.
Estudando mais a programaa o da biblioteca scroll do compilador e fazendo
algumas alterao es necessa rias conseguiu-se contornar duas das limitao es da
biblioteca. Sendo que agora e possvel o scroll independente entre as linhas, onde
uma linha pode se manter parada enquanto apenas a outra se rotaciona, e tambe m
e possvel a escrita de frases com mais de 40 caracteres, como mostrado no
programa do anexo B. Ainda na o foi possvel resolver a limitaa o dos caracteres
especiais.
Pesquisando pelo sensor de velocidade que sera utilizado, optou-se por
escolher um encoder o ptico por seu baixssimo custo em comparaa o com outros
sensores. Pore m esse tipo de sensor tra s uma dificuldade no tratamento do sinal,
diferente de outros sensores de velocidade que foram vistos, como o taco metro. O
encoder o ptico na o gera um sinal de sada analo gico correspondente a velocidade
do motor e sim um pulso digital de sada que varia a freque ncia conforme a
velocidade do motor. Nesse caso a leitura da velocidade pelo microcontrolador sera
atrave s de um programa interno que cronometre o tempo que cada pulso leva para
dar e assim calcular a velocidade em RPM.

Fonte: Thomazini, D. e Albuquerque, P. U. B., Sensores Industriais: Fundamentos

e Aplicao es, E rica.

Esse tipo de sensor em comparaa o com os outros, por ser um sensor

o ptico, na o apresenta a limitaa o fsica de desgaste para ma xima rotaa o do motor
controlado por na o estarem acoplados um no outro diretamente, mas apresenta
uma limitaa o eletro nica que dependera da capacidade de chaveamento do
receptor o ptico no sensor e da freque ncia de funcionamento do microcontrolador.
Tanto o sensor quanto o microcontrolador na o sa o capazes de fazer a leitura de
velocidade do motor se este apresentar rotaa o muito elevada. Assim, respeitando-
se as limitao es de ambos componentes eletro nicos, que embora existam
dificilmente sera o atingidas pelo motor controlado, pois trabalham com uma
altssima taxa de freque ncia para aquisia o e manipulaa o de dados, sera possvel a
media o da velocidade.
A importaa o do sensor mencionado foi realizada e assim como o sensor
ultrasso nico e o display de LCD, o prazo para entrega e de aproximadamente 30
dias. Enquanto isso comeou-se uma pesquisa para o desenvolvimento da
programaa o que sera capaz de fazer a leitura dos pulsos e converte-los em RPM
para leitura do usua rio. O disco para geraa o dos pulsos pelo sensor o ptico e que
ficara acoplado ao motor sera feito artesanalmente utilizando uma placa de PVC, ja
que o mesmo disco na o acompanha o sensor adquirido pela internet.
Analisando alguns exemplos de programao es que fazem a leitura do sensor de
velocidade adquirido, uma programaa o pro pria comeou a ser desenvolvida por
entender-se que e possvel simplificar as programao es ja existentes. Assim,
considerando que o disco que gerara os pulsos contenha apenas UM orifcio em
uma de suas extremidades, o programa descrito faz a leitura da velocidade atrave s
da diferena de tempo que o disco leva para gerar DOIS pulsos, ou seja, UMA volta
completa, esse tempo e convertido em RPM e mostrado na tela (anexo C). Essa
programaa o ainda na o e capaz de analisar o sentido de rotaa o do motor
controlado, mas acrescentando mais um orifcio no disco (que na o seja do lado
oposto ao primeiro) e fazendo algumas alterao es no algoritmo espera-se ser capaz
de medir a velocidade e o sentido de rotaa o do motor.
Pesquisando acerca dos encoders o pticos para media o de velocidade,
descobriu-se que a maioria na o sa o capazes de medir o sentido de rotaa o junto
com a velocidade, o que e o caso do sensor o ptico adquirido, para que o mesmo
possa medir o sentido de rotaa o do motor seria necessa rio implementar outro
sensor o ptico igual ao adquirido, mas que ficasse disposto em defasagem ao
primeiro nas aberturas do disco acoplado ao motor. Dada essa dificuldade, a
determinaa o do sentido de rotaa o do motor na o sera automa tica, e sim fornecida
ao microcontrolador pelo usua rio, no momento da parametrizaa o inicial do motor.

Ms 7: Iniciou-se a montagem de um modelo proto tipo para testes e integraa o

entre microcontrolador, display, teclado e parametrizao es do motor. E ao se iniciar
a conexa o dos perife ricos percebeu-se um problema quanto a colocaa o de todos
os perife ricos necessa rios para montagem da interface. Como ja foi dito durante o
desenvolvimento desse projeto, uma das maiores deficie ncias do microcontrolador
utilizado, MSP430, e seu nu mero limitado de portas de I/O, assim na o seria
possvel a disposia o de todos perife ricos propostos. Para solucionar o problema, o
teclado que inicialmente era uma matriz de teclas de 3x4 que utilizava 7 pinos do
MSP430 para seu funcionamento, foi substitudo por tre s boto es push Button, de
contatos normalmente abertos (NA), que utilizam apenas 3 pinos do MSP430.
 Assim, para a escolha nume rica de valores durante a fase de configuraa o
dos para metros do motor o usua rio utilizara um bota o de incremento (partindo do
zero) e um bota o de decremento (partindo do numero atual ate o zero) para
escolher a velocidade ou dista ncia desejada. O terceiro bota o sera o bota o de
confirma. Outros ajustes sera o feito na programaa o e nas frases de
parametrizaa o para adequar a mudana de perife rico feita. Com o problema da
falta de portas no microcontrolador resolvida pela substituia o do teclado, a
utilizaa o da quantidade de perife ricos propostos correspondentes a quantidade
de portas disponveis para MSP430, ficou:
o 6 portas para o Display de LCD;
o 3 portas para os boto es Push Button;
o 2 portas para a Ponte H;
o 1 porta para o sensor de velocidade (encoder);
o 2 portas para o sensor de dista ncia (ultrasso nico).
Totalizando assim 14 portas de I/O, que e o nu mero ma ximo que um
MSP430 dispo e.

Conectando os perifricos:
Como ligaa o adotada entre os perife ricos e o microcontrolador MSP430, o
display LCD foi conectado da seguinte forma:

Display de LCD Conexa o 07 DB0 GND

Pino Descria o (MSP430) 08 DB1 GND

01 GND GND 09 DB2 GND

02 VCC +3,3v 10 DB3 GND

03 Contrast GND 11 DB4 Pino 04 (P1.2)

04 Rs Pino 08 (P2.0) 12 DB5 Pino 11 (P2.3)

05 R/W GND 13 DB6 Pin12 (P2.4)

06 EM Pino 03 (P1.1) 14 DB7 Pin13 (P2.5)

15 BL+ +5V
 16 BL- GND

Para os push buttons um terminal de cada foi ligado ao GND enquanto os

outros terminais foram ligados ao microcontrolador, conforme a tabela:

Push Buttons Conexa o

Pino Descria o (MSP430)

01 Up Pino 14 (P1.6)

02 Down Pino 15 (P1.7)

03 Enter Pino 07 (P1.5)

O sensor ultrasso nico que possui tre s terminais tambe m foi conectado
conforme a tabela:

Sensor
Ultrasso nico Conexa o
(MSP430)
Pino Descria o

01 Vcc +3,3v

02 Trig Pino 6 (P1.4)

03 Echo Pino 5 (P1.3)

04 GND GND

Por u ltimo foi conectado o sensor de velocidade do motor:

Encoder Conexa o

Pino Descria o (MSP430)

01 GND GND

02 Out Pino 2 (P1.0)

03 Vcc +3,3v

A ponte H, que servira de driver para o motor (em pesquisa) sera conectada
aos pinos 9 e 10 (P2.1 e P2.2) do MSP430, pois sa o pinos que o microcontrolador
possui com sada PWM.
 Com o conhecimento da disposia o de todos os perife ricos ligados ao
microcontrolador, comeou-se o desenvolvimento do programa que fornecera as
perguntas para parametrizaa o e configuraa o do motor e sensores.
Iniciou-se, tambe m, um estudo pre vio da ponte H que sera utilizada como
driver de potencia para o motor, foi levado em conta a sugesta o do antigo bolsista
de utilizar o circuito integrado L289, mas pelas mudanas no projeto e utilizaa o
de apenas um motor, outros modelos de drivers foram pesquisado.

Ms 8: Pelos estudos realizados sobre a ponte H optou-se por usar o

circuito integrado L289N conforme sugerido pelo bolsista anterior. Apesar de ser
um CI para o controle de dois motores e o projeto so conter um motor, e o CI para
esse fim mais fa cil e barato de se encontrar no mercado e suas especificao es
atendem muito bem aos propo sitos de controle.

A ponte H funciona ligando o motor ao microcontrolador atrave s de quatro

transistores, dois transistores das diagonais sa o ativados por vez para dar ao motor
um sentido de rotaa o e poder de inversa o dessa rotaa o, pela inversa o nessas
duplas de transistores. Cada dupla de transistores ativa o motor numa polaridade
inversa da outra. Esses transistores sa o utilizados como chaves no circuito e podem
ser acionados com uma tensa o muito menor que a tensa o nominal utilizada no
motor, assim, o microcontrolador ativa os transistores com os 3,3v e os transistores
controlam o motor com os 12v nominais. Abaixo segue o diagrama de blocos
representando internamente as conexo es do CI.
 Com a ponte-H em ma os, esta foi soldada sobre uma placa de fenolite e
interligada a soquetes para fazer sua conexa o com as fontes de alimentaa o,
microcontrolador e motor.

E fez-se a montagem de como ficaria disposto o display, boto es, sensor

ultrasso nico, enconder, motor e driver fisicamente, ligando-os em seus respectivos
pinos no microcontrolador.
 Para facilitar a programaa o e diminuir o uso da memo ria do
microcontrolador com as mensagens no display, a funa o scroll foi abandonada e
cada frase aparecera por etapas no display, divididas a cada 3 segundos para
visualizaa o do usua rio. Caso a frase na o caiba no display, ela e dividida em partes
que caibam e cada parte aparece por 3 segundo no display para que o usua rio
possa ler cada parte e montar a frase em sua cabea. Assim, o algoritmo de
parametrizaa o e configuraa o comeou a ser desenvolvido seguindo esse novo
modelo de frases.

Ms 9: Para configuraa o e parametrizaa o do programa base e do motor, o

usua rio devera responder a uma se rie de perguntas atrave s do teclado, que
aparecera o na tela do display LCD. As perguntas devera o ser respondidas numa
seque ncia que informa ao programa principal quais sensores esta o alocados ao
motor e como o motor deve reagir para esses sensores, essas informao es sera o
processadas pelo microcontrolador que atuara no motor. O usua rio sera instrudo
no pro prio display como devera proceder em cada etapa de perguntas. Se a
mensagem de instrua o na o necessitar de uma resposta do usua rio, ela ficara
visvel por um tempo e sera mudada para a pro xima mensagem.
A primeira mensagem que aparecera , sera uma mensagem de boas vindas e em
seguida comeara o as mensagens com instruo es e perguntas.
1. Mensagem de boas vindas que ficara visvel por alguns segundos no
momento que o controlador e ligado.
Ola , bem vindo ao IPSCA. (Interface para Parametrizaa o de Sistema
de Controle Auto nomo).
2. A pro xima mensagem sera com instruo es para utilizaa o dos boto es
nas respostas das perguntas.
Utilize os boto es up e down para navegar entre as opo es e enter
para confirmar.
3. Aqui comeam as perguntas para parametrizaa o. Como sera o utilizados
apenas dois sensores para a demonstraa o do projeto, as opo es de
 parametrizaa o foram limitadas, mas poderiam abranger quantos
sensores fossem necessa rios.

4. Sensor de velocidade (1):

Parametrizaa o da velocidade:
Auto detectar veloc. maxima?
Sim ou Na o (alternados pelos boto es up e down e selecionados pelo
bota o enter)
Se Sim, sera feita a deteca o da velocidade ma xima e mostrada na tela.
O valor ma ximo da velocidade sera guardado numa varia vel do programa e
utilizado pra futuras configurao es.
Se Na o, o usua rio devera entrar com a velocidade ma xima nominal do
motor.
Entre com a velocidade ma xima do motor (em rpm)
Velocidade (Max)
__ (O cursor aguardara ate que o usua rio escolha o valor e pressione
enter)

5. Sensor de Sentido de rotao (2):

Parametrizaa o do Sentido
Auto detectar?
Sim ou Na o
Se Sim, seria feita a deteca o do sentido e memorizado em uma
varia vel. Como o projeto na o possu um sensor para deteca o de sentido o
programa acusa a menssagem:
Sensor na o encontrado E muda para a deteca o manual.
Se Na o, o motor entrara em baixa rotaa o para que o pro prio usua rio
informe manualmente ao programa qual e seu sentido de rotaa o.
Qual o sentido de rotaa o atual do motor?
Hora rio ou Anti-horario (a resposta e guardada em uma varia vel).
6. Sensor de Distncia (3): (ultrasso nico)
Como cada sensor ultrasso nico pode apresentar caractersticas
diferentes para leitura ma xima e mnima da dista ncia, o usua rio devera
selecionar qual modelo esta utilizando para que o programa busque nas
suas bibliotecas as configurao es correspondentes ao sensor.
Parametrizaa o da dista ncia:
Qual sensor ultrasso nico esta utilizando?
Modelo do sensor
 HC-SR04 ou Nenhum
Pelo fato do projeto apresentar um estudo simplificado aparecera a
opa o para o modelo de sensor que e utilizado ou para na o utilizar tal
sensor.
Caso o usua rio escolha o modelo utilizado, uma mensagem informara no
display as caractersticas especficas do sensor.
Sensor HC-SR04 Ultrasso nico funciona com alcance ma ximo de 200 cm
e alcance mnimo de 3 cm.
Apo s a mensagem aparecer por completo, o programa passara para a
pro xima etapa de parametrizaa o.
Escolha o modo de configuraa o: 1- Velocidades e rotaa o especficas
para distancias fixas. 2- Velocidades proporcionais para uma faixa de
distancias
Modo?
1- Fixas ou 2- Proporcionais
Se o usua rio optar pela primeira opa o, o programa perguntara quantas
velocidades diferentes deseja configurar e esperara que o usua rio insira os
valores desejados.
Quantas velocidades deseja configurar?
N de velocidades
__ (O cursor aguardara ate que o usua rio escolha o valor e pressione
enter)
Velocidade 1
__
Distancia 1
__
Rotaa o?
1- Hora riaou 2- Anti-Hora ria
Essas mensagens podera o ser repetidas conforme o nu mero de
velocidades diferentes escolhidas, respeitando um limite ma ximo dentro da
programaa o.
Se a configuraa o escolhida pelo usua rio for para velocidades
proporcionais, este enta o definira uma distancia ma xima e mnima e uma
velocidade ma xima e mnima para que o programa calcule uma se rie de
velocidades correspondentes ao intervalo de dista ncias.
Dist. Inicial
__
Veloc. Inicial
__
Dist. Final
 __
Veloc. Final
__
Rotaa o?
1- Hora ria ou 2- Anti-Hora ria
Caso o usua rio opte por na o selecionar um sensor ultrasso nico para
parametrizaa o, o programa ira oferecer uma velocidade u nica de
trabalho.
Escolha uma velocidade u nica de trabalho.
Velocidade (rpm)
__
Rotaa o?
1- Hora riaou 2- Anti-Hora ria
7. Apo s a conclusa o das parametrizao es o motor atuara conforme as
configurao es e o display informara para o usua rio a Velocidade de
rotaa o, o Sentido ou a Dista ncia acusada pelo sensor ultrasso nico,
conforme ele for alternando atrave s dos boto es up e down.

8. Para o usua rio reconfigurar o motor com novos para metros, basta
alternar para a opa o de Reconfigurar e confirmar.

Ms 10: No desenvolvimento do programa base para leitura da dista ncia,

atrave s do sensor ultrasso nico, fez-se primeiro uma pesquisa para o entendimento
do funcionamento do sensor. O sensor ultrasso nico HC-SR04 funciona medindo a
dista ncia de um objeto atrave s do tempo que leva pra o eco de uma onda
ultrasso nica, emitida por ele, chegar ao seu receptor. Como ele utiliza do eco para
fazer a media o de distancia e preciso que o som seja ultrasso nico para que o
receptor do sensor na o sofra influe ncias dos sons externos que variam entre 20Hz
e 20kHz para o ouvido humano, assim apenas sons na faixa de freque ncia de 40kHz
sa o detectados e emitidos pelo sensor. Para o ca lculo que o sensor realiza na
determinaa o da dista ncia utiliza-se a velocidade do som no meio ar, sabendo que
o som se propaga a uma velocidade constante de 340m/s nesse meio, para um
objeto a 170m, por exemplo, ele gastaria exatos 1s, pois utilizaria 170m para ir e
170m para voltar completando os 340m. Assim contando ida e voltada do som a
velocidade de media o seria 170m/s ou 17cm/ms, o que da uma resposta de 58us
para um objeto a 1cm de distancia. Fazendo uma regra de 3 simples, chega-se a
equaa o onde:
Dista ncia do objeto (em cm) = Tempo de resposta do som (em us) / 58
Entendendo os ca lculos que o sensor precisa realizar pode-se entender com mais
detalhes seu funcionamento interno. O sensor possui 4 Pinos para conexa o sendo
um pino de Alimentaa o (+5Vcc), um pino de Terra (GND), um pino Trigger (sinal
de sada) e um pino Echo (sinal de entrada).
 Como caractersticas nominais sua media o ma xima e de 4,3m, sua media o
mnima de 2,5cm e sua resolua o de 3mm utilizando um sinal de disparo de 10us.
Mas para uma melhor precisa o na leitura da distancia nesse projeto utilizou-se
uma margem maior de erro, onde a distancia ma xima e de 2m, a distancia mnima
de 3cm e a resolua o de 1cm. Para a media o, colocamos no pino do Trigger um
pulso de 5v (sinal TTL) por 10us, assim que o pulso cessa o sensor vai enta o liberar
8 pulsos de 40khz em seu emissor ultrasso nico e fazer a leitura do eco desses
pulsos em sue receptor, atrave s da me dia de tempo que o som demora para ir e
voltar o sensor emite um pulso alto no pino do Echo por um tempo correspondente
ao tempo que demora para o eco voltar. Como mostra a imagem.

O tempo que o sinal do eco fica em alta varia conforme a dista ncia do objeto
e e esse tempo que o microcontrolador usa para definir a dista ncia do objeto,
conforme pode ser visto no programa anexo D.

Ms 11: Desenvolvimento da programaa o de controle do motor atrave s do

sensor o ptico. Utilizando a velocidade obtida pelo microcontrolador atrave s do
encoder, o programa faz uma ra pida comparaa o entre a velocidade medida e a
velocidade de setpoint selecionada pelo usua rio na fase de parametrizaa o, o
programa tambe m pode utilizar a velocidade de setpoint gerada pelo sensor
ultrasso nico dependendo da configuraa o que o usua rio fez. Assim, caso a
velocidade medida esteja abaixo da velocidade de setpoint, o programa gera um
sinal PWM de sada para o motor aumentar essa velocidade ate encontrar a
velocidade requerida. E o contrario ocorre do mesmo jeito, quando a velocidade
medida esta a cima da velocidade de setpoint, o programa gera um sinal para o
motor diminuir sua velocidade. Isso ocorre constantemente estabilizando a
velocidade do motor naquela velocidade desejada. Para que o ca lculo de
comparaa o na o gere um sinal que ultrapasse os nveis ma ximos e mnimos do
PWM, foi colocado um algoritmo de saturaa o, mantendo os nveis de PWM no
ma ximo ou no mnimo quando estes sa o alcanados, ate que a velocidade seja
estabilizada. Como e possvel ver no programa do anexo E.
Com todos os programas individuais necessa rios desenvolvidos
(Configuraa o do usua rio, leitura de velocidade, leitura do sensor ultrasso nico e
controle da velocidade) po de-se fazer uma programaa o final integrando todo o
sistema. O programa de parametrizaa o e configuraa o foi otimizado utilizando
funo es void de programaa o em C, para melhor aproveitamento da memo ria
interna do microcontrolador e possvel desenvolvimento da integraa o entre os
programas. Assim, a programaa o final desenvolvida de Interface para
Parametrizaa o de Sistema de Controle Auto nomo Microcontrolado de Motores de
Corrente Contnua, foi implementada no microcontrolador MSP430 e testada com
todos os perife ricos conectados. A programaa o final pode ser vista no anexo F.

Ms 12: Desenvolvimento do relato rio final descrevendo o passo-a-passo da

elaboraa o do projeto, mostrando as dificuldades, acertos e aprendizagem
adquirida durante sua execua o.
Anexo A - Programa para leitura do Teclado (matriz de teclas).
/*Varredura para matriz de teclas*/ digitalWrite(Vermelho, HIGH);
digitalWrite(Laranja, LOW );
// Constantes: digitalWrite(Verde, HIGH);
const int Marrom = 2; // 2 a 4 Boto es referentes digitalWrite(Roxo, HIGH);
as colunas do teclado
const int Amarelo = 3; while (digitalRead(Marrom) == LOW)
const int Azul = 4; {dig[i] = 4;
digitalWrite(Beep, HIGH);
const int Vermelho = 5; // 5 a 8 Botoes referentes digitalWrite(Open, LOW );}
as linhas do teclado while (digitalRead(Amarelo) == LOW)
const int Laranja = 6; {dig[i] = 5;
const int Verde = 7; digitalWrite(Beep, HIGH);
const int Roxo = 8; digitalWrite(Open, LOW );}
while (digitalRead(Azul) == LOW)
void setup() { {dig[i] = 6;
digitalWrite(Beep, HIGH);
// Define configuraa o dos pinos digitalWrite(Open, LOW );}
pinMode(Marrom, INPUT_PULLUP);
pinMode(Amarelo, INPUT_PULLUP); //Leitura da linha Verde
pinMode(Azul, INPUT_PULLUP); digitalWrite(Vermelho, HIGH);
digitalWrite(Laranja, HIGH);
pinMode(Vermelho, OUTPUT); digitalWrite(Verde, LOW );
pinMode(Laranja, OUTPUT); digitalWrite(Roxo, HIGH);
pinMode(Verde, OUTPUT);
pinMode(Roxo, OUTPUT); while (digitalRead(Marrom) == LOW)
} {dig[i] = 7;
digitalWrite(Beep, HIGH);
void loop(){ digitalWrite(Open, LOW );}
while (digitalRead(Amarelo) == LOW)
//Verifica teclado {dig[i] = 8;
digitalWrite(Vermelho, LOW); digitalWrite(Beep, HIGH);
digitalWrite(Laranja, LOW); digitalWrite(Open, LOW );}
digitalWrite(Verde, LOW); while (digitalRead(Azul) == LOW)
digitalWrite(Roxo, LOW); {dig[i] = 9;
digitalWrite(Beep, HIGH);
if (digitalRead(Azul) == LOW || digitalWrite(Open, LOW );}
digitalRead(Marrom) == LOW ||
digitalRead(Amarelo) == LOW){ //Leitura da linha Roxa
teclado(); digitalWrite(Vermelho, HIGH);
} digitalWrite(Laranja, HIGH);
} digitalWrite(Verde, HIGH);
digitalWrite(Roxo, LOW );
void teclado(){
//Leitura da linha vermelha while (digitalRead(Marrom) == LOW)
digitalWrite(Vermelho, LOW ); {dig[i] = '*';
digitalWrite(Laranja, HIGH); digitalWrite(Beep, HIGH);
digitalWrite(Verde, HIGH); digitalWrite(Open, LOW );}
digitalWrite(Roxo, HIGH); while (digitalRead(Amarelo) == LOW)
{dig[i] = 0;
while (digitalRead(Marrom) == LOW) digitalWrite(Beep, HIGH);
{dig[i] = 1; digitalWrite(Open, LOW );}
digitalWrite(Beep, HIGH); while (digitalRead(Azul) == LOW)
digitalWrite(Open, LOW );} {dig[i] = '#';
while (digitalRead(Amarelo) == LOW) digitalWrite(Beep, HIGH);
{dig[i] = 2; digitalWrite(Open, LOW );}
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );} //Correa o dos Leds incadores
while (digitalRead(Azul) == LOW) digitalWrite(Beep, LOW );
{dig[i] = 3; digitalWrite(Open, HIGH);
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );} //Calculo da posia o do digito
i++;
//Leitura da linha Laranja }
Anexo B - Programa scroll independente e com mais de 40 caracteres.
/* Ligaa o do Display LCD ao MSP430:
=================================
LCD pin Connect to
---------------------------------
01 - GND GND, pot
02 - VCC +5V, pot
03 - Contrast Pot wiper
04 - RS Pin8 (P2.0)
05 - R/W GND
06 - EN Pin9 (P2.1)
07 - DB0 GND
08 - DB1 GND
09 - DB2 GND
10 - DB3 GND
11 - DB4 Pin10 (P2.2)
12 - DB5 Pin11 (P2.3)
13 - DB6 Pin12 (P2.4)
14 - DB7 Pin13 (P2.5)
15 - BL+ +5V
16 - BL- GND
================================= */

#include <LiquidCrystal.h>

LiquidCrystal lcd(P2_0, P2_1, P2_2, P2_3, P2_4, P2_5);

void setup() {
lcd.begin(16, 2);
}

void loop() {
lcd.print("Escolha Sensores");
delay(1000);

lcd.setCursor(0,1);
lcd.print("1-Fim de curso; 2-Velocidade; 3-Distanci");
delay(500);
int x = 1;
while(x < 25){
lcd.setCursor(x,0); // Mantem a linha 1 parada
lcd.print("Escolha Sensores");
lcd.scrollDisplayLeft();
delay(350);
x++;}

lcd.clear();
lcd.print("Escolha Sensores");
lcd.setCursor(0,1);
lcd.print("dade; 3-Distancia; 4-Posia o;");
x=1;
while(x < 25){
lcd.setCursor(x,0); // Mantem a linha 1 parada
lcd.print("Escolha Sensores");
lcd.scrollDisplayLeft();
// wait a bit:
delay(350);
x++;}

// delay at the end of the full loop:

delay(1000);
lcd.clear();
}
Anexo C - Programa para leitura de velocidade.
#include <LiquidCrystal.h>

volatile unsigned long tempo1, tempo2;

volatile int x = 0;

LiquidCrystal lcd(P2_0, P1_1, P1_2, P2_3, P2_4, P2_5);

int troca = 0;
int velocidade;

void setup()
{
lcd.begin(16, 2);
pinMode(P2_1, OUTPUT);
pinMode(P2_2, OUTPUT);
pinMode(P1_5, INPUT_PULLUP);
pinMode(P1_0, INPUT);
attachInterrupt(P1_0, time, RISING);
}

void loop()
{
analogWrite(P2_1, troca);
while (digitalRead(P1_5) == LOW){
troca += 10;
delay(500);
}
if(troca > 255){
troca = 0;
}
if(x >= 2){
velocidade = 60000 / (tempo2 - tempo1);
x = 0;
if (velocidade < 1000){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Velocidade");
lcd.setCursor(11,0);
lcd.print(troca^255, DEC);
lcd.setCursor(0,1);
lcd.print(velocidade);
}
}
}

void time()
{
if (x == 0){
tempo1 = millis();
}
if (x ==1){
tempo2 = millis();
}
x++;
}
Anexo D - Programa para leitura de distancia.
#include <LiquidCrystal.h>

#define trigPin 6
#define echoPin 5

LiquidCrystal lcd(P2_0, P1_1, P1_2, P2_3, P2_4, P2_5);

void setup() {
lcd.begin(16, 2);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}

void loop() {
int duration, distance;
digitalWrite(trigPin, HIGH);
delayMicroseconds(1000);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;
if (distance >= 200 || distance <= 0){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Distancia");
lcd.setCursor(0,1);
lcd.print("Out of range");
}
else {
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Distancia");
lcd.setCursor(0,1);
lcd.print(distance);
lcd.print(" cm");
}
delay(500);
}
Anexo E - Programa de controle.
#include <LiquidCrystal.h> if (controle < 0){
controle = 0;
volatile unsigned long tempo1, tempo2, tempo3, }
tempo4; }
volatile int x = 0; if (Speed < mostra){
controle++;
LiquidCrystal lcd(P2_0, P1_1, P1_2, P2_3, P2_4, delay (controle + 100);
P2_5); if (controle > 255){
controle = 255;
int Speed = 800; }
int controle = 0; }
int mostra; if(x >= 2){
int velocidade; velocidade = 60000 / (tempo2 - tempo1);
x = 0;
void setup() if (velocidade < 1000){
mostra = velocidade;
{ tempo3 = millis();
lcd.begin(16, 2); lcd.clear();
pinMode(P2_1, OUTPUT); lcd.setCursor(0,0);
pinMode(P2_2, OUTPUT); lcd.print("Velocidade");
pinMode(P1_5, INPUT_PULLUP); lcd.setCursor(11,0);
pinMode(P1_0, INPUT); lcd.print(Speed, DEC);
attachInterrupt(P1_0, time, RISING); lcd.setCursor(0,1);
} lcd.print(mostra);
}
void loop() }
{ }
analogWrite(P2_1, controle);
while (digitalRead(P1_5) == LOW){ void time()
Speed -= 100; {
delay(500); if (x == 0){
} tempo1 = millis();
if (Speed < 0){ }
Speed = 800; if (x ==1){
} tempo2 = millis();
if (Speed > mostra){ }
controle--; x++;
delay (controle + 100); }
Anexo F - Programa final.
/* int left = P2_2; //sentido anti-horario.
The Display circuit: int sent; //Sentido de setpoint.
================================= String nome1;
LCD pin Connect to String nome2;
--------------------------------- unsigned long time;
01 - GND GND unsigned long tempo1;
02 - VCC +3.3v unsigned long tempo2;
03 - Contrast GND long int intmax = 1000000;
04 - RS Pin8 (P2.0) int vfalse = 0; //Velocidade falsa descartada.
05 - R/W GND int intmin = 0;
06 - EN Pin3 (P1.1)
07 - DB0 GND int nv = 0; //|Numero de velocidades desejadas no
08 - DB1 GND //|modo fixo.
09 - DB2 GND int num = 0; //|Numero da velocidade desejada no
10 - DB3 GND //|modo fixo.
11 - DB4 Pin04 (P1.2) int vel[10]; //|Array para armazenar valores de
12 - DB5 Pin11 (P2.3) // |velocidade no modo fixo.
13 - DB6 Pin12 (P2.4) int dis[10]; //|Array para armazenar valores de
14 - DB7 Pin13 (P2.5) //|distancia no modo fixo.
15 - BL+ +5V int bv = 0; //Velocidade anterior para o modo fixo
16 - BL- GND int bd = 3; //Distancia anterior para o modo fixo.
=================================
int dmaxp = 0; //|Distancia maxima no modo
The Push Buttons circuit: //|proporcional.
================================= int dminp = 0; //|Distancia minima no modo
Push Button Connect to //|proporcional.
--------------------------------- int vmaxp = 0; //|Velocidade maxima no modo
01 - Up Pin14 (P1.6) //|proporcional.
02 - Down Pin15 (P1.7) int vminp = 0; //|Velocidade minima no modo
03 - Enter Pin7 (P1.5) //|proporcional.
================================= int di, df; //|Distancias inicial e final pra o modo
//|proporcional.
The Ultrasonic circuit: int vi, vf; //|Velocidades inicial e final pra o modo
================================= //|proporcional.
Ultrasonic Connect to
--------------------------------- int vmax = 0;
01 - Vcc +3.3V int ctrl = 0; //PWM de Controle da velocidade.
02 - Trig Pin6 (P1.4) int vsp = 0; //Velocidade de setpoint.
03 - Echo Pin5 (P1.3) int dsp = 0; //Distancia de setpoint.
04 - GND GND
================================= int op = 0; //|Operaa o - Velocidade, Distancia,
//|Rotaa o, Configuraa o.
The Sensor Speed circuit: int v = 0; //Variavel de Velocidade.
================================= int x = 0;
01 - GND GND int y = 0;
02 - Out Pin2 (P1.0) int z = 0;
03 - Vcc +3.3V
================================= //Variaveis do Menu Central.
*/ int Visor = 0;
int Modo [3] = {1, 0, 0};
// Inclui a biblioteca do Display /*
#include <LiquidCrystal.h> modo[0] = 1 -> Config
modo[0] = 2 -> ReConfig??
//Define pinos do sensor ultrassonico
#define echoPin 5 //P1.3 - Echo (input). modo[1] = 1 -> Velocidade (fixas)
#define trigPin 6 //P1.4 - Trig (output). modo[1] = 2 -> Velocidade (proporcionais)
modo[1] = 3 -> Velocidade unica (sem HC-SR04)
//|Inicializa a biblioteca do display com os numeros
dos //|depinos da inteface. modo[2] = 1 -> Distancias (fixas)
modo[2] = 2 -> Distancias (proporcionais)
LiquidCrystal lcd(P2_0, P1_1, P1_2, P2_3, P2_4, P2_5);
modo[3] = 1 -> Rotaa o Horaria
//|Define os pinos dos bottons e as variaveis do //| modo[3] = 2 -> Rotaa o Anti-horaria
programa. */
const int stop = P1_0; //interrupa o.
const int enter = P1_5; void setup() {
const int up = P1_6; // Define o numero de colunas e linhas do LCD.
const int down = P1_7; lcd.begin(16, 2);
int duration, distance; //|variaveis para media o da
//|distancia. //Define os pinos dos boto es com entrada.
int right = P2_1; //sentido horario. pinMode(up, INPUT_PULLUP);
 pinMode(down, INPUT_PULLUP); lcd.print(nome2);
pinMode(enter, INPUT_PULLUP); lcd.print(")");
pinMode(right, OUTPUT); lcd.setCursor(0,1);
pinMode(left, OUTPUT); lcd.print("Carregando...");
pinMode(trigPin, OUTPUT); while (x == 0){
pinMode(echoPin, INPUT); controle();
pinMode(stop, INPUT); if (digitalRead(up) == LOW || digitalRead(down) ==
//Define o pino de interrupa o. LOW){
attachInterrupt(stop, tempo, RISING); x = 1;
mudavisor();
// Mensagem de boas vindas. }
lcd.print(" Ola, bem-vindo "); }
lcd.setCursor(4,1); }
lcd.print("ao IPSCA ");
delay(3000); //Visor em Distancia.
if (Visor == 2){
// Mensagem de instruo es. noInterrupts();
lcd.clear(); while(digitalRead(up) == HIGH && digitalRead(down)
lcd.setCursor(3,0); == HIGH){
lcd.print("Utilize os"); if (Modo[2] == 1){ disfixas(); }
lcd.setCursor(0,1); if (Modo[2] == 2){ disprop(); }
lcd.print("botoes up e down"); }
delay(3000); mudavisor();
lcd.clear(); }
lcd.setCursor(2,0);
lcd.print("para navegar"); //Visor em Sentido.
lcd.setCursor(0,1); if (Visor == 3){
lcd.print("entre as opcoes"); noInterrupts();
delay(3000); while(digitalRead(up) == HIGH && digitalRead(down)
lcd.clear(); == HIGH){
lcd.setCursor(2,0); lcd.clear();
lcd.print("e enter para"); lcd.setCursor(4,0);
lcd.setCursor(3,1); lcd.print("Sentido");
lcd.print("confirmar."); if (sent == right){
delay(3000); lcd.setCursor(4,1);
lcd.print("Horario");
//Primeira configuraa o. }
config(); if (sent == left){
} lcd.setCursor(2,1);
lcd.print("Anti-horario");
void loop() { }
//Visor em Config. delay(500);
if (Visor == 0){ }
x = 0; mudavisor();
noInterrupts(); }
lcd.clear(); }//Fecha void loop.
lcd.setCursor(0,0);
lcd.print("Pressione enter"); void mudavisor() {
lcd.setCursor(0,1); if (digitalRead(up) == LOW){
lcd.print("p/ reconfigurar."); Visor--;
while(x == 0){ if (Visor < 0){
if (digitalRead(up) == LOW || digitalRead(down) == Visor = 3;
LOW){ }
x = 1; if (Visor == 2 && Modo [2] == 0){
mudavisor(); Visor = 1;
} }
if (digitalRead(enter) == LOW){ delay(500);
config(); }
x = 1; if (digitalRead(down) == LOW){
} Visor++;
} if (Visor > 3){
} Visor = 0;
}
//Visor em Velocidade. if (Visor == 2 && Modo [2] == 0){
if (Visor == 1){ Visor = 3;
x = 0; }
interrupts(); delay(500);
if (Modo[1] == 1){ velfixas(); } }
if (Modo[1] == 2){ velprop(); } }//Fecha void mudavisor.
nome1 = "Velocidade (";
nome2 = String(vsp); void config() {
lcd.clear(); noInterrupts();
lcd.setCursor(0,0); analogWrite(P2_1, 255);
lcd.print(nome1); analogWrite(P2_2, 255);
 lcd.clear();
//Parametrizaa o da velocidade. lcd.setCursor(1,0);
lcd.clear(); lcd.print("Auto detectar?");
lcd.setCursor(1,0); lcd.setCursor(5,1);
lcd.print("Parametrizacao"); lcd.print("1- Sim");
lcd.setCursor(1,1); x=0;
lcd.print("da velocidade:"); nome1 = " 1- Sim ";
delay(3000); nome2 = " 2- Nao ";
lcd.clear(); var_binario();
lcd.setCursor(1,0);
lcd.print("Auto detectar"); if (x == 0){ //Deteca o sem o sensor.
lcd.setCursor(1,1); lcd.clear();
lcd.print("veloc. maxima?"); lcd.setCursor(3,0);
delay(3000); lcd.print("Sensor nao");
lcd.setCursor(3,1);
lcd.clear(); lcd.print("encontrado");
lcd.setCursor(1,0); delay(3000);
lcd.print("Auto detectar?"); x = 1;
lcd.setCursor(5,1); }
lcd.print("1- Sim"); if (x == 1){
nome1 = " 1- Sim "; analogWrite(right, 200); //|aciona rotaa o em baixa
nome2 = " 2- Nao "; //| velocidade.
x = 0; lcd.clear();
var_binario(); lcd.setCursor(1,0);
lcd.print("Qual o sentido");
if (x == 0){ //Deteca o automatica de Vmax. lcd.setCursor(3,1);
ctrl = 255; lcd.print("de rotacao");
x = 0; delay(3000);
v = 0; analogWrite(right, 215);
nome1 = "Velocidade ("; lcd.clear();
nome2 = "Max"; lcd.setCursor(0,0);
interrupts(); lcd.print("atual do motor?");
vmaxima(); delay(3000);
noInterrupts(); analogWrite(right, 230);
vmax = v;
x = 0; lcd.clear();
} //Fecha Deteca o automatica de Vmax. lcd.setCursor(1,0);
if (x == 1){ //Deteca o manual de Vmax. lcd.print("Rotacao atual:");
lcd.clear(); lcd.setCursor(3,1);
lcd.setCursor(2,0); lcd.print("1- Horaria");
lcd.print("Entre com a"); x=0;
lcd.setCursor(3,1); nome1 = " 1- Horaria ";
lcd.print("velocidade"); nome2 = "2- Anti-horaria ";
delay(3000); var_binario();
lcd.clear(); analogWrite(right, 255);
lcd.setCursor(0,0); if (x == 1){
lcd.print("maxima do motor"); right = P2_2;
lcd.setCursor(4,1); left = P2_1;
lcd.print("(em rpm)"); }
delay(3000); }

lcd.clear(); //Parametrizaa o da distancia.

lcd.setCursor(0,0); lcd.clear();
lcd.print("Velocidade (Max)"); lcd.setCursor(1,0);
lcd.setCursor(0,1); lcd.print("Parametrizacao");
lcd.cursor(); lcd.setCursor(2,1);
nome1 = "Velocidade (Max)"; lcd.print("da distancia:");
x = 16; delay(3000);
v = vmax; lcd.clear();
intmax = 1000000; lcd.setCursor(2,0);
intmin = 0; lcd.print("Qual sensor");
var_inteiro(); lcd.setCursor(2,1);
vmax = v; lcd.print("Ultrassonico");
v = 0; delay(3000);
} //Fecha Deteca o manual de Vmax. lcd.clear();
lcd.setCursor(0,0);
//Parametrizaa o do sentido. lcd.print("esta utilizando?");
lcd.clear(); delay(3000);
lcd.setCursor(1,0);
lcd.print("Parametrizacao"); lcd.clear();
lcd.setCursor(2,1); lcd.setCursor(0,0);
lcd.print("do sentido:"); lcd.print("Modelo do sensor");
delay(3000); lcd.setCursor(3,1);
lcd.print("1- HC-SR04");
x=0;
nome1 = " 1- HC-SR04 ";
nome2 = " 2- Nenhum ";
var_binario();
if (x == 0){ //Sensor HC-SR04.
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Sensor HC-SR04");
lcd.setCursor(2,1);
lcd.print("Ultrassonico");
delay(3000);
lcd.clear();
lcd.setCursor(2,0);
lcd.print("funciona com");
lcd.setCursor(1,1);
lcd.print("alcance maximo");
delay(3000);
lcd.clear();
lcd.setCursor(2,0);
lcd.print("de 200 cm e");
lcd.setCursor(1,1);
lcd.print("alcance minimo");
delay(3000);
lcd.clear();
lcd.setCursor(3,0);
lcd.print("de 3 cm.");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Escolha o modo");
lcd.setCursor(1,1);
lcd.print("de configuracao:");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("1. Velocidades");
lcd.setCursor(2,1);
lcd.print("e rotacao");
delay(3000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("especificas para");
lcd.setCursor(0,1);
lcd.print("distancias fixas");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("2. Velocidades");
lcd.setCursor(1,1);
lcd.print("proporcionais");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("para uma faixa");
lcd.setCursor(1,1);
lcd.print("de distancias");
delay(3000);
lcd.clear();
lcd.setCursor(6,0);
lcd.print("Modo?");
lcd.setCursor(4,1);
lcd.print("1- Fixas");
x=0;
nome1 = " 1- Fixas ";
nome2 = "2- Proporcionais";
var_binario();
if (x == 0){ // Modo Fixos.
Modo[1] = 1;
Modo[2] = 1;
lcd.clear();
lcd.setCursor(4,0);
lcd.print("Quantas");
lcd.setCursor(2,1);
lcd.print("velocidades");
delay(3000);
lcd.clear();
lcd.setCursor(5,0);
lcd.print("deseja");
lcd.setCursor(2,1);
lcd.print("configurar?");
delay(3000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("N de velocidades");
lcd.setCursor(0,1);
lcd.cursor();
v = 0;
x = 16;
intmax = 10;
intmin = 0;
nome1 = "N de velocidades";
var_inteiro();
nv = v;
for (int i = 0; i < nv; i++){
num = i + 1;
lcd.clear(); //fixando as velociades.
lcd.setCursor(0,0);
lcd.print("Velocidade");
lcd.setCursor(11,0);
lcd.print(num, DEC);
lcd.setCursor(0,1);
lcd.cursor();
x = 11;
v = bv;
intmax = vmax;
intmin = 0;
nome1 = "Velocidade";
var_inteiro();
vel[i] = v;
bv = v;
lcd.clear(); //fixando as distancias.
lcd.setCursor(0,0);
lcd.print("Distancia ");
lcd.setCursor(10,0);
lcd.print(num, DEC);
lcd.setCursor(0,1);
lcd.cursor();
x = 10;
v = bd;
intmax = 200;
intmin = 3;
nome1 = "Distancia ";
var_inteiro();
dis[i] = v;
bd = v;
}// fecha o for
lcd.clear(); //fixando o sentido.
lcd.setCursor(4,0);
lcd.print("Rotacao? ");
lcd.setCursor(9,0);
lcd.setCursor(3,1);
lcd.print("1- Horaria");
x=0;
nome1 = " 1- Horaria ";
nome2 = "2- Anti-horaria ";
var_binario();
if (x == 0){ sent = right; }
if (x == 1){ sent = left; }
x = 0;
}// fecha o Modo Fixos.
 Modo[1] = 0;
if (x == 1){ // Modo Proporcional. Modo[2] = 0;
Modo[1] = 2; lcd.clear();
Modo[2] = 2; lcd.setCursor(2,0);
x = 16; lcd.print("Escolha uma");
v = 0; lcd.setCursor(0,1);
lcd.print("velocidade unica");
lcd.clear(); //fixando a distancia inicial. delay(3000);
lcd.setCursor(0,0); lcd.clear();
lcd.print("Dist. Inicial"); lcd.setCursor(2,0);
lcd.setCursor(0,1); lcd.print("de trabalho.");
lcd.cursor(); delay(3000);
nome1 = "Dist. Inicial";
intmax = 200; lcd.clear(); //fixando velociade u nica.
intmin = 3; lcd.setCursor(0,0);
v = 3; lcd.print("Velocidade (rpm)");
var_inteiro(); lcd.setCursor(0,1);
di = v; lcd.cursor();
nome1 = "Velocidade (rpm)";
lcd.clear(); //fixando a velocidade inicial. intmax = vmax;
lcd.setCursor(0,0); intmin = 0;
lcd.print("Veloc. Inicial"); x = 16;
lcd.setCursor(0,1); v = 0;
lcd.cursor(); var_inteiro();
nome1 = "Veloc. Inicial"; vsp = v;
intmax = vmax;
intmin = 0; lcd.clear(); //fixando o sentido.
v = 0; lcd.setCursor(4,0);
var_inteiro(); lcd.print("Rotacao? ");
vi = v; lcd.setCursor(9,0);
lcd.setCursor(3,1);
lcd.clear(); //fixando a distancia final. lcd.print("1- Horaria");
lcd.setCursor(0,0); x=0;
lcd.print("Dist. Final"); nome1 = " 1- Horaria ";
lcd.setCursor(0,1); nome2 = "2- Anti-horaria ";
lcd.cursor(); var_binario();
nome1 = "Dist. Final"; if (x == 0){ sent = right; }
intmax = 200; if (x == 1){ sent = left; }
intmin = 3; x = 1;
v = di; Visor = 1;
var_inteiro(); v = 0;
df = v; } // Fecha Sem Sensor de distancia (x == 1)
v = 0;
lcd.clear(); //fixando a velocidade final. } //Fecha void config.
lcd.setCursor(0,0);
lcd.print("Veloc. Final"); //Selea o e Boto es ---------------------------------------------
lcd.setCursor(0,1);
lcd.cursor(); void var_inteiro() {
nome1 = "Veloc. Final"; while (digitalRead(enter) != LOW){
intmax = vmax; time = millis();
intmin = 0; while (digitalRead(up) == LOW && v < intmax){
v = vi; lcd.noCursor();
var_inteiro(); v++;
vf = v; lcd.setCursor(0,1);
lcd.print(v, DEC);
lcd.clear(); //fixando o sentido. if (millis() - time < 2000){delay(500);}
lcd.setCursor(4,0); //Corre devagar.
lcd.print("Rotacao? "); if (millis() - time > 2000){delay(30);} //Corre rapido.
lcd.setCursor(9,0); }
lcd.setCursor(3,1); while (digitalRead(down) == LOW && v > intmin){
lcd.print("1- Horaria"); lcd.noCursor();
x=0; v--;
nome1 = " 1- Horaria "; lcd.clear();
nome2 = "2- Anti-horaria "; lcd.setCursor(0,0);
var_binario(); lcd.print(nome1);
if (x == 0){ sent = right; } lcd.setCursor(x,0);
if (x == 1){ sent = left; } lcd.print(num, DEC);
x = 0; lcd.setCursor(0,1);
}// fecha o Modo Proporcional. lcd.print(v, DEC);
Visor = 2; if (millis() - time < 2000){delay(500);}
v = 0; //Corre devagar.
}// fecha Sensor HC-SR04 (x == 0) if (millis() - time > 2000){delay(30);} //Corre rapido.
}
if (x == 1){ //Sem Sensor de distancia. }
 delay (500); {
} //fecha void var_inteiro. if(z >= 2){
vfalse = 60000 / (tempo2 - tempo1);
void var_binario() { z = 0;
while(digitalRead(enter) == HIGH){ if (vfalse < 1000 && vfalse >= 0){
if (digitalRead(up) == LOW || digitalRead(down) == v = vfalse;
LOW){ lcd.clear();
x = !x; lcd.setCursor(0,0);
if (x == 0){ lcd.print(nome1);
lcd.setCursor(0,1); lcd.print(nome2);
lcd.print(nome1); lcd.print(")");
delay(500); lcd.setCursor(0,1);
} lcd.print(v);
if (x == 1){ lcd.print(" rpm");
lcd.setCursor(0,1); }
lcd.println(nome2); }
delay(500); } //Fecha displaiv.
} //=========================================//
}
}// fecha botao enter //Interrupa o---------------------------------------------------
delay(500); void tempo()
}//fecha var_binario. {
//========================================// if (z == 0){
tempo1 = millis();
//Deteca o de Vmax---------------------------------------------- }
void vmaxima() { if (z == 1){
while (ctrl >= 0){ tempo2 = millis();
displaiv(); }
analogWrite(right, ctrl); z++;
ctrl -= 5; } //ficha tempo.
delay(100); //=========================================//
}
ctrl = 0; //Velocidade proporcional------------------------------------
analogWrite(right, 0); void velprop(){
delay (3000); if (di < df && vi < vf){
displaiv; dmaxp = df;
lcd.clear(); dminp = di;
delay(500); vmaxp = vf;
lcd.setCursor(0,0); vminp = vi;
lcd.print("Velocidade (Max)"); vsp = vminp + (((vmaxp - vminp)*(dsp - dminp))/
lcd.setCursor(0,1); (dmaxp - dminp));
lcd.print(v); }
lcd.print(" rpm"); if (di > df && vi > vf){
while (ctrl <= 255){ dmaxp = di;
analogWrite(right, ctrl); dminp = df;
ctrl += 5; vmaxp = vi;
delay(100); vminp = vf;
} vsp = vminp + (((vmaxp - vminp)*(dsp - dminp))/
ctrl = 255; (dmaxp - dminp));
}//Fecha vmaxima. }
//=========================================// if (di < df && vi > vf){
dmaxp = df;
//Controle da velocidade--------------------------------------// dminp = di;
void controle(){ vmaxp = vi;
analogWrite(sent, ctrl); vminp = vf;
delay (ctrl + 100); vsp = vmaxp - (((vmaxp - vminp)*(dsp - dminp))/
if (vsp > v){ (dmaxp - dminp));
ctrl--; }
if (ctrl < 0){ if (di > df && vi < vf){
ctrl = 0; dmaxp = di;
} dminp = df;
} vmaxp = vf;
if (vsp < v){ vminp = vi;
ctrl++; vsp = vmaxp - (((vmaxp - vminp)*(dsp - dminp))/
if (ctrl > 255){ (dmaxp - dminp));
ctrl = 255; }
} //y = (vsp*255)/vmax;
} //ctrl = y^255;
displaiv(); z = 0;
} //Fecha controle. } //Fecha void veloprop .
//=========================================// //=========================================//

//Mostra velocidade do motor----------------------------------- //Distancias proporcionais-------------------------------------

void displaiv() void disprop(){
 if (di > df){ //=========================================//
dmaxp = di;
dminp = df; //Distancias fixas ---------------------------------------------
} void disfixas(){
if (di < df){ x = 0;
dmaxp = df; distmedida();
dminp = di; if (distance <= 200 || distance >= 0){
} lcd.clear();
distmedida(); lcd.setCursor(0,0);
if (distance <= 200 || distance >= 0){ lcd.print("Distancia");
lcd.clear(); for (int i = 0; i < nv; i++){
lcd.setCursor(0,0); if (distance == dis[i]){
lcd.print("Distancia"); dsp = distance;
if (dmaxp >= distance && distance >= dminp){ lcd.setCursor(0,1);
dsp = distance; lcd.print(dsp);
lcd.setCursor(0,1); lcd.print(" cm (!)");
lcd.print(dsp); x = 1;
lcd.print(" cm (!)"); }
} if (x == 0) {
if (dmaxp < distance || distance < dminp){ lcd.setCursor(0,1);
lcd.setCursor(0,1); lcd.print(distance);
lcd.print(distance); lcd.print(" cm ");
lcd.print(" cm "); }
} }
} }
if (distance > 200 || distance <= 0){ if (distance > 200 || distance <= 0){
lcd.clear(); lcd.clear();
lcd.setCursor(0,0); lcd.setCursor(0,0);
lcd.print("Distancia"); lcd.print("Distancia");
lcd.setCursor(0,1); lcd.setCursor(0,1);
lcd.print("Setada = "); lcd.print("Setada = ");
lcd.print(dsp); lcd.print(dsp);
lcd.print(" cm"); lcd.print(" cm");
} }
delay(500); delay(500);
} //Fecha dis prop. } //Fecha dis fixas.
//========================================// //=========================================//

//Velocidades fixas-------------------------------------------- //Media o da distancia------------------------------------------

void velfixas(){ void distmedida(){
for (int i = 0; i < nv; i++){ digitalWrite(trigPin, HIGH);
if (dsp == dis[i]){ delayMicroseconds(1000);
vsp = vel[i]; digitalWrite(trigPin, LOW);
} duration = pulseIn(echoPin, HIGH);
} distance = (duration/2) / 29.1;
z = 0; }
} //=========================================//
CRONOGRAMA FINAL

Ms 4 e ms 5: Especificaa o do conjunto de para metros a serem definidos

e das perguntas correspondentes na fase de parametrizaa o;
Ms 5 ao ms 7: Implementaa o do programa parametriza vel;
Ms 7 ao ms 9: Montagem da interface;
Ms 9 e ms 10: Testes;
Ms 10 e ms 12: Redaa o de artigos e de relato rios.
REFERNCIAS

[1] OGATA,K.; Engenharia de Controle Moderno, Prentice-Hall Brasil, Sa o Paulo,

2011
[2] Texas Instruments, A430.PDF, MSP430 Assembler, Linker, and Librarian
Programming Guide, 2003
[3] Texas Instruments, SLAU049C.PDF, MSP430x1xx Family Users Guide, 2003.
[4] GUSSOW,M.; Eletricidade Ba sica, Prentice-Hall Brasil, Sa o Paulo, 2005
[5] Texas Instruments, MSP430f149.PDF, MSP430x13x, MSP430x14x Mixed
Signal Microcontroller, datasheet, 2003.
[6] PEREIRA,F., Microcontroladores MSP430 - Teoria e Pra tica, E rica, Sa o Paulo,
2010.
[7] McRoberts, M.; Arduino ba sico. Sa o Paulo: Novatec, , 2011.
[8] Thomazini, D. e Albuquerque, P. U. B., Sensores Industriais: Fundamentos e
Aplicao es, E rica.

DATA 30/12/2013

ASSINATURA DO ORIENTADOR ______________________________

ASSINATURA DO BOLSISTA ______________________________

Coordenaa o da Iniciaa o Cientfica - IFSP

http://www2.ifsp.edu.br/edu/iniciacaocientifica/
OBS: Este relato rio devera ser entregue em CD-ROM devidamente identificado ao Coordenador de Pesquisa EM SEU
CAMPUS e enviado para o e-mail pibicepibiti2012@gmail.com para conhecimento da Pro -reitoria de Pesquisa e Inovaa o -
PRP