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: Criao de Interface para Parametrizao de Sistema de Controle
Autnomo Microcontrolado de Motores de Corrente Contnua
Vigncia da Bolsa: 01/09/2012 31/07/2013
INTRODUO

A utilizao de microcontroladores no controle de processos

frequente, devido preciso, baixa necessidade de manuteno,
durabilidade, tamanho reduzido e confiabilidade.
Porm, isto requer a atuao de um especialista em
programao. Ele dever receber uma descrio do problema e
dever escrever um programa a ser executado pelo microcontrolador.
Isto requer, tambm, um tempo considervel.
Prope-se aqui a criao de uma interface que permitir a
gerao automtica daqueles programas de forma amigvel e rpida,
a partir da definio de valores para um conjunto de parmetros, feita
por no especialistas. Esta interface possuir um display e um
teclado, para a apresentao de perguntas cujas respostas,
fornecidas pelo usurio, definiro os valores daqueles parmetros.
Terminada a parametrizao, o sistema gerar automaticamente um
programa apropriado.
Uma soluo geral para este problema seria de obteno difcil.
Por isto, este sistema ser capaz de realizar esta tarefa apenas para
um conjunto restrito de condies. Uma delas o uso de um nico
modelo de microcontrolador MSP430. Outra a de que os dispositivos
controlados s sero motores de corrente contnua. Este controle ser
feito a partir de valores lidos de um conjunto de sensores. Na
parametrizao, o usurio definir, de forma simples, como cada
motor dever reagir em funo das leituras dos sensores. Por
exemplo, um usurio poder determinar que sempre que um sensor
de proximidade fornecer um valor acima de certo limiar, um motor
dever girar num certo sentido.

PROPOSIO

Criar uma interface que permita que usurios no especialistas

na programao de microcontroladores possam, fcil e rapidamente,
especificar programas para aqueles dispositivos apenas pela
definio de um conjunto de parmetros, de forma amigvel.
Para que se atinja o objetivo central, os objetivos intermedirios
sero:
1. Escolha de um modelo de microcontrolador, estudo de sua
arquitetura e de sua programao;
2. Delimitao do conjunto de problemas que o sistema ser
capaz de resolver;
3. Especificao do conjunto de parmetros a serem definidos e
das perguntas correspondentes na fase de parametrizao;
4. Implementao do programa parametrizvel;
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 robs mveis tracionados por rodas, que a partir de
sensores, fosse capaz controlar o movimento do mesmo de maneira
autnoma.
Esse controle ser feito por meio de configuraes que sero
determinadas pelo usurio antes de colocar o sistema para funcionar.
Atravs de um display de LCD sero dadas opes 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
contedo bibliogrfico para embasar a pesquisa, no site do
fabricante, em fruns, 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
aplicaes embarcados, possvel fazer clculos com 16 bits, clock
interno de 16MHz, 10 pinos de I/O, 2 KB de memria 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 proteo 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 conduo mais rpida,
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 automtico.
A parte mecnica constituda por dois motores de corrente
contnua fixados em um chassi de polmero.
Aps 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 limitao de linhas de
cdigo na verso gratuita, a facilidade de programao e a
disponibilidade de bibliotecas e menus de ajuda. Os compiladores
CCS e IAR deixaram a desejar no aspecto de facilidade de
programao e ambos possuem limitaes para programao em C.
Aps os testes verificou-se que o Energia possua uma interface
mais amigvel e compatibilidade com alguns programas do Arduno,
alm de no existir limite de cdigo para a linguagem de
programao C.

Durante os testes foram analisados os programas que sero utilizados

no programa final como conversores AD, entradas e sadas digitais,
temporizadores, contadores, PWM e Display de LCD.

A imagem abaixo representa a relao da LaunchPad com a IDE

Energia, mostrando a nomenclatura de programao e os pinos
correspondentes

Ms 4: Delimitao do conjunto de problemas que o sistema ser

capaz de resolver;
Estamos desenvolvendo um estudo preliminar para determinar
quais os tipos de sensores sero lidos pelo dispositivo. Esto em
anlise sensores capacitivos, acelermetros, giroscpios, chaves fim
de curso entre outros que permitam a leitura pelo microcontrolador
para tomada de decises.
No display aparecero opes dos tipos de sensores a serem
analisados durante o funcionamento, que sero selecionados pelo
usurio e fornecidos parmetros que podem ser ajustados (resposta
do sistema para cada tipo de sensor).
Ms 5: Mudana do bolsista de pesquisa e rearranjo do projeto
para adequao 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 razo do tempo para atingi-los e da capacidade
limitada que o MSP430 possuiu em relao quantidade de entrada e
sada de seus terminais. Sendo assim, para a obteno apenas do
objetivo principal do projeto, que uma interface amigvel para
controle de motores DC, a ideia inicial de se construir um rob mvel
programvel por sensores foi substituda por um controle simples de
apenas um Motor DC que possui um sensor de velocidade acoplado,
um sensor de distncia (ultrassnico) ao seu lado e pode ser
parametrizado atravs de uma matriz de teclas com a interface de
um display de LCD 16x2.
O sensor ultrassnico que do modelo HC-SR04 e o display de
LCD que do modelo HD44780 foram importados para economizar
custos, j que os mesmo no Brasil so bem mais caros. A importao
foi realizada no incio do ms e est a caminho do Brasil com previso
de chegada no ms que vem. Enquanto isso, o estudo da
programao para escrita atravs do microcontrolador em um Display
LCD emprestado mostra que palavras simples com at 16 caracteres
funcionam perfeitamente. A prxima etapa encontrar programas
que faam escritas de frases com mais caracteres e que fiquem em
rotao no Display para sua visualizao, caso nenhum programa seja
encontrado ser desenvolvido um programa prprio que faa a
rotao das frases atravs de Strings em linguagem C.
O programa para leitura do Teclado (uma matriz de tecladas) j
foi desenvolvido, como mostrado no anexo A, e falta apenas
adequao para o programa principal que ser criado.
Tambm comeou-se uma pesquisa sobre o sensor de
velocidade para aquisio de um modelo adequado ao projeto ou

dependendo do caso, construo de um a partir de componentes

pticos.
Ms 6: H uma biblioteca para o compilador Energia que permite
escrever no Display LCD frases com mais de 16 caracteres, atravs da
funo scroll dessa biblioteca possvel escrever frases que
rotacionam para direita ou para esquerda a fim de aparecerem por
completo. Porm a biblioteca tem uma limitao de 40 caracteres por
linha para rotao, 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 parametrizao no
podem ultrapassar os 40 caracteres limites que devem ser o
suficiente para cada pergunta. Outras limitaes o fato da funo
scroll no agir independente entre as duas linhas, ou seja, ao
ativarmos essa funo, a escrita nas duas linhas do display so
rotacionadas e, tambm, o fato das letras com caracteres especiais
no aparecerem corretamente, assim no possvel usar o ou o
na escrita do display por exemplo.
Estudando mais a programao da biblioteca scroll do
compilador e fazendo algumas alteraes necessrias conseguiu-se
contornar duas das limitaes da biblioteca. Sendo que agora
possvel o scroll independente entre as linhas, onde uma linha pode
se manter parada enquanto apenas a outra se rotaciona, e tambm
possvel a escrita de frases com mais de 40 caracteres, como
mostrado no programa do anexo B. Ainda no foi possvel resolver a
limitao dos caracteres especiais.
Pesquisando pelo sensor de velocidade que ser utilizado, optou-se
por escolher um encoder ptico por seu baixssimo custo em
comparao com outros sensores. Porm esse tipo de sensor trs
uma dificuldade no tratamento do sinal, diferente de outros sensores
de velocidade que foram vistos, como o tacmetro. O encoder ptico
no gera um sinal de sada analgico correspondente velocidade do
motor e sim um pulso digital de sada que varia a frequncia
conforme a velocidade do motor. Nesse caso a leitura da velocidade
pelo microcontrolador ser atravs 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 Aplicaes, rica.
Esse tipo de sensor em comparao com os outros, por ser um
sensor ptico, no apresenta a limitao fsica de desgaste para
mxima rotao do motor controlado por no estarem acoplados um
no outro diretamente, mas apresenta uma limitao eletrnica que
depender da capacidade de chaveamento do receptor ptico no
sensor e da frequncia de funcionamento do microcontrolador. Tanto
o sensor quanto o microcontrolador no so capazes de fazer a leitura
de velocidade do motor se este apresentar rotao muito elevada.
Assim, respeitando-se as limitaes de ambos componentes
eletrnicos, que embora existam dificilmente sero atingidas pelo
motor controlado, pois trabalham com uma altssima taxa de
frequncia para aquisio e manipulao de dados, ser possvel a
medio da velocidade.
A importao do sensor mencionado foi realizada e assim como o
sensor ultrassnico e o display de LCD, o prazo para entrega de
aproximadamente 30 dias. Enquanto isso comeou-se uma pesquisa
para o desenvolvimento da programao que ser capaz de fazer a
leitura dos pulsos e converte-los em RPM para leitura do usurio. O
disco para gerao dos pulsos pelo sensor ptico e que ficar
acoplado ao motor ser feito artesanalmente utilizando uma placa de
PVC, j que o mesmo disco no acompanha o sensor adquirido pela
internet.
Analisando alguns exemplos de programaes que fazem a leitura
do sensor de velocidade adquirido, uma programao prpria
comeou a ser desenvolvida por entender-se que possvel
simplificar as programaes j existentes. Assim, considerando que o
disco que gerar os pulsos contenha apenas UM orifcio em uma de
suas extremidades, o programa descrito faz a leitura da velocidade
atravs da diferena de tempo que o disco leva para gerar DOIS
pulsos, ou seja, UMA volta completa, esse tempo convertido em

RPM e mostrado na tela (anexo C). Essa programao ainda no

capaz de analisar o sentido de rotao do motor controlado, mas
acrescentando mais um orifcio no disco (que no seja do lado oposto
ao primeiro) e fazendo algumas alteraes no algoritmo espera-se ser
capaz de medir a velocidade e o sentido de rotao do motor.
Pesquisando acerca dos encoders pticos para medio de
velocidade, descobriu-se que maioria no so capazes de medir o
sentido de rotao junto com a velocidade, o que o caso do sensor
ptico adquirido, para que o mesmo possa medir o sentido de rotao
do motor seria necessrio implementar outro sensor ptico igual ao
adquirido, mas que ficasse disposto em defasagem ao primeiro nas
aberturas do disco acoplado ao motor. Dada essa dificuldade, a
determinao do sentido de rotao do motor no ser automtica, e
sim fornecida ao microcontrolador pelo usurio, no momento da
parametrizao inicial do motor.
Ms 7: Iniciou-se a montagem de um modelo prottipo para testes
e
integrao
entre
microcontrolador,
display,
teclado
e
parametrizaes do motor. E ao se iniciar a conexo dos perifricos
percebeu-se um problema quanto a colocao de todos os perifricos
necessrios para montagem da interface. Como j foi dito durante o
desenvolvimento desse projeto, uma das maiores deficincias do
microcontrolador utilizado, MSP430, seu nmero limitado de portas
de I/O, assim no seria possvel a disposio de todos perifricos
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 trs botes push Button, de
contatos normalmente abertos (NA), que utilizam apenas 3 pinos do
MSP430.

Assim, para a escolha numrica de valores durante a fase de

configurao dos parmetros do motor o usurio utilizar um boto
de incremento (partindo do zero) e um boto de decremento
(partindo do numero atual at o zero) para escolher a velocidade ou
distncia desejada. O terceiro boto ser o boto de confirma.
Outros ajustes sero feito na programao e nas frases de
parametrizao para adequar a mudana de perifrico feita. Com o
problema da falta de portas no microcontrolador resolvida pela
substituio do teclado, a utilizao da quantidade de perifricos

propostos correspondentes a quantidade de portas disponveis para

MSP430, ficou:
o 6 portas para o Display de LCD;
o 3 portas para os botes 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 distncia (ultrassnico).
Totalizando assim 14 portas de I/O, que o nmero mximo que
um MSP430 dispe.
Conectando os perifricos:
Como ligao adotada entre os perifricos e o microcontrolador
MSP430, o display LCD foi conectado da seguinte forma:
Display de LCD
Pino

Descri
o

Conexo
(MSP430)

01

GND

GND

02

VCC

+3,3v

03

Contrast

04

Rs

05

R/W

GND

06

EM

Pino
(P1.1)

07

DB0

GND

08

DB1

GND

09

DB2

GND

10

DB3

GND

11

DB4

Pino
(P1.2)

04

12

DB5

Pino
(P2.3)

11

GND
Pino
(P2.0)

08

03

13

DB6

Pin12 (P2.4)

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

Conexo

Pino

Descri
o

01

Up

Pino
(P1.6)

14

02

Down

Pino
(P1.7)

15

03

Enter

Pino
(P1.5)

07

(MSP430)

O sensor ultrassnico que possui trs terminais tambm foi

conectado conforme a tabela:
Sensor
Ultrassnico

Conexo
(MSP430)

Pino

Descri
o

01

Vcc

+3,3v

02

Trig

Pino 6 (P1.4)

03

Echo

Pino 5 (P1.3)

04

GND

GND

Por ltimo foi conectado o sensor de velocidade do motor:

Encoder

Conexo

Pino

Descri
o

01

GND

GND

02

Out

Pino 2 (P1.0)

03

Vcc

+3,3v

(MSP430)

A ponte H, que servir de driver para o motor (em pesquisa)

ser conectada
aos pinos 9 e 10 (P2.1 e P2.2) do MSP430, pois so
pinos que o microcontrolador possui com sada PWM.
Com o conhecimento da disposio de todos os perifricos
ligados ao microcontrolador, comeou-se o desenvolvimento do
programa que fornecer as perguntas para parametrizao e
configurao do motor e sensores.
Iniciou-se, tambm, um estudo prvio da ponte H que ser
utilizada como driver de potencia para o motor, foi levado em conta a
sugesto do antigo bolsista de utilizar o circuito integrado L289, mas
pelas mudanas no projeto e utilizao 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 s conter um motor, o CI para esse fim mais fcil e barato
de se encontrar no mercado e suas especificaes atendem muito
bem aos propsitos de controle.

A ponte H funciona ligando o motor ao microcontrolador atravs

de quatro transistores, dois transistores das diagonais so ativados
por vez para dar ao motor um sentido de rotao e poder de inverso
dessa rotao, pela inverso nessas duplas de transistores. Cada
dupla de transistores ativa o motor numa polaridade inversa da outra.
Esses transistores so utilizados como chaves no circuito e podem ser
acionados com uma tenso muito menor que a tenso 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 conexes do CI.

Com a ponte-H em mos, esta foi soldada sobre uma placa de

fenolite e interligada soquetes para fazer sua conexo com as
fontes de alimentao, microcontrolador e motor.

E fez-se a montagem de como ficaria disposto o display, botes,

sensor ultrassnico, enconder, motor e driver fisicamente, ligando-os
em seus respectivos pinos no microcontrolador.

Para facilitar a programao e diminuir o uso da memria do

microcontrolador com as mensagens no display, a funo scroll foi
abandonada e cada frase aparecer por etapas no display, divididas a
cada 3 segundos para visualizao do usurio. Caso a frase no caiba
no display, ela dividida em partes que caibam e cada parte aparece
por 3 segundo no display para que o usurio possa ler cada parte e
montar a frase em sua cabea. Assim, o algoritmo de parametrizao
e configurao comeou a ser desenvolvido seguindo esse novo
modelo de frases.
Ms 9: Para configurao e parametrizao do programa base e
do motor, o usurio dever responder a uma srie de perguntas
atravs do teclado, que aparecero na tela do display LCD. As
perguntas devero ser respondidas numa sequncia que informa ao
programa principal quais sensores esto alocados ao motor e como o
motor deve reagir para esses sensores, essas informaes sero
processadas pelo microcontrolador que atuar no motor. O usurio
ser instrudo no prprio display como dever proceder em cada
etapa de perguntas. Se a mensagem de instruo no necessitar de
uma resposta do usurio, ela ficar visvel por um tempo e ser
mudada para a prxima mensagem.
A primeira mensagem que aparecer, ser uma mensagem de
boas vindas e em seguida comearo as mensagens com instrues e
perguntas.
1. Mensagem de boas vindas que ficar visvel por alguns
segundos no momento que o controlador ligado.
Ol, bem vindo ao IPSCA. (Interface para Parametrizao
de Sistema de Controle Autnomo).
2. A prxima mensagem ser com instrues para utilizao
dos botes nas respostas das perguntas.

 Utilize os botes up e down para navegar entre as opes

e enter para confirmar.
3. Aqui comeam as perguntas para parametrizao. Como
sero utilizados apenas dois sensores para a demonstrao
do projeto, as opes de parametrizao foram limitadas,
mas poderiam abranger quantos sensores fossem
necessrios.
4. Sensor de velocidade (1):
Parametrizao da velocidade:
Auto detectar veloc. maxima?
Sim ou No (alternados pelos botes up e down e
selecionados pelo boto enter)
Se Sim, ser feita a deteco da velocidade mxima e
mostrada na tela. O valor mximo da velocidade ser guardado
numa varivel do programa e utilizado pra futuras
configuraes.
Se No, o usurio dever entrar com a velocidade mxima
nominal do motor.
Entre com a velocidade mxima do motor (em rpm)
Velocidade (Max)
__ (O cursor aguardar at que o usurio escolha o valor e
pressione enter)

5. Sensor de Sentido de rotao (2):

Parametrizao do Sentido
Auto detectar?
Sim ou No
Se Sim, seria feita a deteco do sentido e memorizado
em uma varivel. Como o projeto no possu um sensor para
deteco de sentido o programa acusa a menssagem:
Sensor no encontrado E muda para a deteco manual.
Se No, o motor entrar em baixa rotao para que o
prprio usurio informe manualmente ao programa qual seu
sentido de rotao.
Qual o sentido de rotao atual do motor?
Horrio ou Anti-horario (a resposta guardada em uma
varivel).
6. Sensor de Distncia (3): (ultrassnico)

Como
cada
sensor
ultrassnico
pode
apresentar
caractersticas diferentes para leitura mxima e mnima da
distncia, o usurio dever selecionar qual modelo est
utilizando para que o programa busque nas suas bibliotecas as
configuraes correspondentes ao sensor.
Parametrizao da distncia:
Qual sensor ultrassnico est utilizando?
Modelo do sensor
HC-SR04 ou Nenhum
Pelo fato do projeto apresentar um estudo simplificado
aparecer a opo para o modelo de sensor que utilizado ou
para no utilizar tal sensor.
Caso o usurio escolha o modelo utilizado, uma mensagem
informar no display as caractersticas especficas do sensor.
Sensor HC-SR04 Ultrassnico funciona com alcance mximo
de 200 cm e alcance mnimo de 3 cm.
Aps a mensagem aparecer por completo, o programa
passar para a prxima etapa de parametrizao.
Escolha o modo de configurao: 1- Velocidades e rotao
especficas
para
distancias
fixas.
2Velocidades
proporcionais para uma faixa de distancias
Modo?
1- Fixas ou 2- Proporcionais
Se o usurio optar pela primeira opo, o programa
perguntar quantas velocidades diferentes deseja configurar e
esperar que o usurio insira os valores desejados.
Quantas velocidades deseja configurar?
N de velocidades
__ (O cursor aguardar at que o usurio escolha o valor e
pressione enter)
Velocidade 1
__
Distancia 1
__
Rotao?
1- Horriaou 2- Anti-Horria
Essas mensagens podero ser repetidas conforme o nmero
de velocidades diferentes escolhidas, respeitando um limite
mximo dentro da programao.

Se a configurao escolhida pelo usurio for para

velocidades proporcionais, este ento definir uma distancia
mxima e mnima e uma velocidade mxima e mnima para que
o programa calcule uma srie de velocidades correspondentes
ao intervalo de distncias.
Dist. Inicial
__
Veloc. Inicial
__
Dist. Final
__
Veloc. Final
__
Rotao?
1- Horria ou 2- Anti-Horria
Caso o usurio opte por no selecionar um sensor
ultrassnico para parametrizao, o programa ir oferecer
uma velocidade nica de trabalho.
Escolha uma velocidade nica de trabalho.
Velocidade (rpm)
__
Rotao?
1- Horriaou 2- Anti-Horria
7. Aps a concluso das parametrizaes o motor atuar
conforme as configuraes e o display informar para o
usurio a Velocidade de rotao, o Sentido ou a Distncia
acusada pelo sensor ultrassnico, conforme ele for
alternando atravs dos botes up e down.
8. Para o usurio reconfigurar o motor com novos parmetros,
basta alternar para a opo de Reconfigurar e confirmar.
Ms 10: No desenvolvimento do programa base para leitura da
distncia, atravs do sensor ultrassnico, fez-se primeiro uma
pesquisa para o entendimento do funcionamento do sensor. O sensor
ultrassnico HC-SR04 funciona medindo a distncia de um objeto
atravs do tempo que leva pra o eco de uma onda ultrassnica,
emitida por ele, chegar ao seu receptor. Como ele utiliza do eco para
fazer a medio de distancia preciso que o som seja ultrassnico
para que o receptor do sensor no sofra influncias dos sons externos
que variam entre 20Hz e 20kHz para o ouvido humano, assim apenas

sons na faixa de frequncia de 40kHz so detectados e emitidos pelo

sensor. Para o clculo que o sensor realiza na determinao da
distncia 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 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 medio seria
170m/s ou 17cm/ms, o que d uma resposta de 58us para um objeto
a 1cm de distancia. Fazendo uma regra de 3 simples, chega-se
equao onde:
Distncia do objeto (em cm) = Tempo de resposta do som (em
us) / 58
Entendendo os clculos que o sensor precisa realizar pode-se
entender com mais detalhes seu funcionamento interno. O sensor
possui 4 Pinos para conexo sendo um pino de Alimentao (+5Vcc),
um pino de Terra (GND), um pino Trigger (sinal de sada) e um pino
Echo (sinal de entrada).

Como caractersticas nominais sua medio mxima de 4,3m,

sua medio mnima de 2,5cm e sua resoluo de 3mm utilizando um
sinal de disparo de 10us. Mas para uma melhor preciso na leitura da
distancia nesse projeto utilizou-se uma margem maior de erro, onde a
distancia mxima de 2m, a distancia mnima de 3cm e a resoluo
de 1cm. Para a medio, colocamos no pino do Trigger um pulso de
5v (sinal TTL) por 10us, assim que o pulso cessa o sensor vai ento
liberar 8 pulsos de 40khz em seu emissor ultrassnico e fazer a
leitura do eco desses pulsos em sue receptor, atravs da mdia 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

distncia do objeto e esse tempo que o microcontrolador usa para
definir a distncia do objeto, conforme pode ser visto no programa
anexo D.
Ms 11: Desenvolvimento da programao de controle do
motor atravs do sensor ptico. Utilizando a velocidade obtida pelo
microcontrolador atravs do encoder, o programa faz uma rpida
comparao entre a velocidade medida e a velocidade de setpoint
selecionada pelo usurio na fase de parametrizao, o programa
tambm pode utilizar a velocidade de setpoint gerada pelo sensor
ultrassnico dependendo da configurao que o usurio 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 at encontrar a velocidade requerida. E o contrario ocorre
do mesmo jeito, quando a velocidade medida est 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 clculo
de comparao no gere um sinal que ultrapasse os nveis mximos e
mnimos do PWM, foi colocado um algoritmo de saturao, mantendo
os nveis de PWM no mximo ou no mnimo quando estes so
alcanados, at que a velocidade seja estabilizada. Como possvel
ver no programa do anexo E.
Com todos os programas individuais necessrios desenvolvidos
(Configurao do usurio, leitura de velocidade, leitura do sensor
ultrassnico e controle da velocidade) pde-se fazer uma
programao final integrando todo o sistema. O programa de
parametrizao e configurao foi otimizado utilizando funes void
de programao em C, para melhor aproveitamento da memria
interna do microcontrolador e possvel desenvolvimento da
integrao entre os programas. Assim, a programao final
desenvolvida de Interface para Parametrizao de Sistema de
Controle Autnomo Microcontrolado de Motores de Corrente Contnua,
foi implementada no microcontrolador MSP430 e testada com todos
os perifricos conectados. A programao final pode ser vista no
anexo F.
Ms 12: Desenvolvimento do relatrio final descrevendo o
passo-a-passo da elaborao do projeto, mostrando as dificuldades,
acertos e aprendizagem adquirida durante sua execuo.

Anexo A - Programa para leitura do Teclado (matriz de teclas).

/*Varredura para matriz de teclas*/
// Constantes:
const int Marrom = 2;
// 2 a 4 Botes
referentes
as colunas do teclado
const int Amarelo = 3;
const int Azul
= 4;
const int Vermelho = 5;
// 5 a 8 Botoes
referentes
as linhas do teclado
const int Laranja = 6;
const int Verde = 7;
const int Roxo
= 8;
void setup() {
// Define configurao dos pinos
pinMode(Marrom, INPUT_PULLUP);
pinMode(Amarelo, INPUT_PULLUP);
pinMode(Azul, INPUT_PULLUP);
pinMode(Vermelho, OUTPUT);
pinMode(Laranja, OUTPUT);
pinMode(Verde, OUTPUT);
pinMode(Roxo,
OUTPUT);
}
void loop(){
//Verifica teclado
digitalWrite(Vermelho, LOW);
digitalWrite(Laranja, LOW);
digitalWrite(Verde, LOW);
digitalWrite(Roxo,
LOW);
if (digitalRead(Azul) == LOW ||
digitalRead(Marrom) == LOW ||
digitalRead(Amarelo) == LOW){
teclado();
}
}
void teclado(){
//Leitura da linha vermelha
digitalWrite(Vermelho, LOW );
digitalWrite(Laranja, HIGH);
digitalWrite(Verde, HIGH);
digitalWrite(Roxo,
HIGH);
while (digitalRead(Marrom) == LOW)
{dig[i] = 1;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Amarelo) == LOW)
{dig[i] = 2;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Azul) == LOW)
{dig[i] = 3;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}

//Leitura da linha Laranja

digitalWrite(Vermelho, HIGH);
digitalWrite(Laranja, LOW );
digitalWrite(Verde, HIGH);
digitalWrite(Roxo,
HIGH);
while (digitalRead(Marrom) == LOW)
{dig[i] = 4;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Amarelo) == LOW)
{dig[i] = 5;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Azul) == LOW)
{dig[i] = 6;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
//Leitura da linha Verde
digitalWrite(Vermelho, HIGH);
digitalWrite(Laranja, HIGH);
digitalWrite(Verde, LOW );
digitalWrite(Roxo,
HIGH);
while (digitalRead(Marrom) == LOW)
{dig[i] = 7;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Amarelo) == LOW)
{dig[i] = 8;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Azul) == LOW)
{dig[i] = 9;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
//Leitura da linha Roxa
digitalWrite(Vermelho, HIGH);
digitalWrite(Laranja, HIGH);
digitalWrite(Verde, HIGH);
digitalWrite(Roxo,
LOW );
while (digitalRead(Marrom) == LOW)
{dig[i] = '*';
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Amarelo) == LOW)
{dig[i] = 0;
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
while (digitalRead(Azul) == LOW)
{dig[i] = '#';
digitalWrite(Beep, HIGH);
digitalWrite(Open, LOW );}
//Correo dos Leds incadores
digitalWrite(Beep, LOW );
digitalWrite(Open, HIGH);
//Calculo da posio do digito

i++;

Anexo B - Programa scroll independente e com mais de 40

caracteres.

/* Ligao 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 - BLGND
================================= */
#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-Posio;");
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>
volatile unsigned long tempo1, tempo2,
tempo3, tempo4;
volatile int x = 0;
LiquidCrystal lcd(P2_0, P1_1, P1_2, P2_3,
P2_4, P2_5);
int
int
int
int

Speed = 800;
controle = 0;
mostra;
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, controle);
while (digitalRead(P1_5) == LOW){
Speed -= 100;
delay(500);
}
if (Speed < 0){
Speed = 800;
}
if (Speed > mostra){
controle--;
delay (controle + 100);
if (controle < 0){

controle = 0;
}
}
if (Speed < mostra){
controle++;
delay (controle + 100);
if (controle > 255){
controle = 255;
}
}
if(x >= 2){
velocidade = 60000 / (tempo2 tempo1);
x = 0;
if (velocidade < 1000){
mostra = velocidade;
tempo3 = millis();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Velocidade");
lcd.setCursor(11,0);
lcd.print(Speed, DEC);
lcd.setCursor(0,1);
lcd.print(mostra);
}
}
}
void time()
{
if (x == 0){
tempo1 = millis();
}
if (x ==1){
tempo2 = millis();
}
x++;
}

Anexo F - Programa final.

/*
The Display circuit:
=============================
====
LCD pin
Connect to
--------------------------------01 - GND
GND
02 - VCC
+3.3v
03 - Contrast
GND
04 - RS
Pin8 (P2.0)
05 - R/W
GND
06 - EN
Pin3 (P1.1)
07 - DB0
GND
08 - DB1
GND
09 - DB2
GND
10 - DB3
GND
11 - DB4
Pin04 (P1.2)
12 - DB5
Pin11 (P2.3)
13 - DB6
Pin12 (P2.4)
14 - DB7
Pin13 (P2.5)
15 - BL+
+5V
16 - BLGND
=============================
====
The Push Buttons circuit:
=============================
====
Push Button
Connect to
--------------------------------01 - Up
Pin14 (P1.6)
02 - Down
Pin15 (P1.7)
03 - Enter
Pin7 (P1.5)
=============================
====
The Ultrasonic circuit:
=============================
====
Ultrasonic
Connect to
--------------------------------01 - Vcc
+3.3V
02 - Trig
Pin6 (P1.4)
03 - Echo
Pin5 (P1.3)
04 - GND
GND
=============================
====
The Sensor Speed circuit:
=============================
====
01 - GND
GND
02 - Out
Pin2 (P1.0)
03 - Vcc
+3.3V
=============================
====
*/
// Inclui a biblioteca do Display
#include <LiquidCrystal.h>
//Define pinos do sensor ultrassonico
#define echoPin 5 //P1.3 - Echo (input).
#define trigPin 6 //P1.4 - Trig (output).
//|Inicializa a biblioteca do display com os
numeros dos //|depinos da inteface.
LiquidCrystal lcd(P2_0, P1_1, P1_2, P2_3, P2_4,
P2_5);

//|Define os pinos dos bottons e as variaveis

do //|programa.
const int stop = P1_0; //interrupo.
const int enter = P1_5;
const int up = P1_6;
const int down = P1_7;
int duration, distance; //|variaveis para medio
da
//|distancia.
int right = P2_1;
//sentido horario.
int left = P2_2;
//sentido anti-horario.
int sent;
//Sentido de setpoint.
String nome1;
String nome2;
unsigned long time;
unsigned long tempo1;
unsigned long tempo2;
long int intmax = 1000000;
int vfalse = 0;
//Velocidade falsa descartada.
int intmin = 0;
int nv = 0;
//|Numero de velocidades
desejadas no
//|modo fixo.
int num = 0;
//|Numero da velocidade
desejada no
//|modo fixo.
int vel[10];
//|Array para armazenar valores de
// |velocidade no modo fixo.
int dis[10];
//|Array para armazenar valores de
//|distancia no modo fixo.
int bv = 0;
//Velocidade anterior para o modo
fixo
int bd = 3;
//Distancia anterior para o modo
fixo.
int dmaxp = 0;

//|Distancia maxima no modo

//|proporcional.
int dminp = 0;
//|Distancia minima no modo
//|proporcional.
int vmaxp = 0;
//|Velocidade maxima no
modo
//|proporcional.
int vminp = 0;
//|Velocidade minima no modo
//|proporcional.
int di, df;
//|Distancias inicial e final pra o
modo
//|proporcional.
int vi, vf;
//|Velocidades inicial e final pra o
modo
//|proporcional.
int
int
int
int

vmax = 0;
ctrl = 0;
vsp = 0;
dsp = 0;

int op = 0;
Distancia,
int
int
int
int

v = 0;
x = 0;
y = 0;
z = 0;

//PWM de Controle da velocidade.

//Velocidade de setpoint.
//Distancia de setpoint.
//|Operao - Velocidade,
//|Rotao, Configurao.
//Variavel de Velocidade.

//Variaveis do Menu Central.

int Visor = 0;
int Modo [3] = {1, 0, 0};
/*
modo[0] = 1 -> Config
modo[0] = 2 -> ReConfig??

if (digitalRead(enter) == LOW){
config();
x = 1;
}
}

modo[1] = 1 -> Velocidade (fixas)

modo[1] = 2 -> Velocidade (proporcionais)
modo[1] = 3 -> Velocidade unica (sem HC-SR04)
modo[2] = 1 -> Distancias (fixas)
modo[2] = 2 -> Distancias (proporcionais)
modo[3] = 1 -> Rotao Horaria
modo[3] = 2 -> Rotao Anti-horaria
*/
void setup() {
// Define o numero de colunas e linhas do LCD.
lcd.begin(16, 2);
//Define os pinos dos botes com entrada.
pinMode(up, INPUT_PULLUP);
pinMode(down, INPUT_PULLUP);
pinMode(enter, INPUT_PULLUP);
pinMode(right, OUTPUT);
pinMode(left, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(stop, INPUT);
//Define o pino de interrupo.
attachInterrupt(stop, tempo, RISING);
// Mensagem de boas vindas.
lcd.print(" Ola, bem-vindo ");
lcd.setCursor(4,1);
lcd.print("ao IPSCA ");
delay(3000);
// Mensagem de instrues.
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Utilize os");
lcd.setCursor(0,1);
lcd.print("botoes up e down");
delay(3000);
lcd.clear();
lcd.setCursor(2,0);
lcd.print("para navegar");
lcd.setCursor(0,1);
lcd.print("entre as opcoes");
delay(3000);
lcd.clear();
lcd.setCursor(2,0);
lcd.print("e enter para");
lcd.setCursor(3,1);
lcd.print("confirmar.");
delay(3000);
//Primeira configurao.
config();

void loop() {
//Visor em Config.
if (Visor == 0){
x = 0;
noInterrupts();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Pressione enter");
lcd.setCursor(0,1);
lcd.print("p/ reconfigurar.");
while(x == 0){
if (digitalRead(up) == LOW ||
digitalRead(down) == LOW){
x = 1;
mudavisor();
}

}
//Visor em Velocidade.
if (Visor == 1){
x = 0;
interrupts();
if (Modo[1] == 1){ velfixas(); }
if (Modo[1] == 2){ velprop(); }
nome1 = "Velocidade (";
nome2 = String(vsp);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(nome1);
lcd.print(nome2);
lcd.print(")");
lcd.setCursor(0,1);
lcd.print("Carregando...");
while (x == 0){
controle();
if (digitalRead(up) ==
digitalRead(down) == LOW){
x = 1;
mudavisor();
}
}
}
//Visor em Distancia.
if (Visor == 2){
noInterrupts();
while(digitalRead(up) ==
digitalRead(down) == HIGH){
if (Modo[2] == 1){ disfixas(); }
if (Modo[2] == 2){ disprop(); }
}
mudavisor();
}
//Visor em Sentido.
if (Visor == 3){
noInterrupts();
while(digitalRead(up)
digitalRead(down) == HIGH){
lcd.clear();
lcd.setCursor(4,0);
lcd.print("Sentido");
if (sent == right){
lcd.setCursor(4,1);
lcd.print("Horario");
}
if (sent == left){
lcd.setCursor(2,1);
lcd.print("Anti-horario");
}
delay(500);
}
mudavisor();
}
}//Fecha void loop.

==

void mudavisor() {
if (digitalRead(up) == LOW){
Visor--;
if (Visor < 0){
Visor = 3;
}
if (Visor == 2 && Modo [2] == 0){
Visor = 1;
}

LOW

||

HIGH

&&

HIGH

&&

delay(500);
}
if (digitalRead(down) == LOW){
Visor++;
if (Visor > 3){
Visor = 0;
}
if (Visor == 2 && Modo [2] == 0){
Visor = 3;
}
delay(500);
}
}//Fecha void mudavisor.
void config() {
noInterrupts();
analogWrite(P2_1, 255);
analogWrite(P2_2, 255);
//Parametrizao da velocidade.
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Parametrizacao");
lcd.setCursor(1,1);
lcd.print("da velocidade:");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Auto detectar");
lcd.setCursor(1,1);
lcd.print("veloc. maxima?");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Auto detectar?");
lcd.setCursor(5,1);
lcd.print("1- Sim");
nome1 = "
1- Sim
";
nome2 = "
2- Nao
";
x = 0;
var_binario();
if (x == 0){ //Deteco automatica de Vmax.
ctrl = 255;
x = 0;
v = 0;
nome1 = "Velocidade (";
nome2 = "Max";
interrupts();
vmaxima();
noInterrupts();
vmax = v;
x = 0;
} //Fecha Deteco automatica de Vmax.
if (x == 1){ //Deteco manual de Vmax.
lcd.clear();
lcd.setCursor(2,0);
lcd.print("Entre com a");
lcd.setCursor(3,1);
lcd.print("velocidade");
delay(3000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("maxima do motor");
lcd.setCursor(4,1);
lcd.print("(em rpm)");
delay(3000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Velocidade (Max)");
lcd.setCursor(0,1);
lcd.cursor();

nome1 = "Velocidade (Max)";

x = 16;
v = vmax;
intmax = 1000000;
intmin = 0;
var_inteiro();
vmax = v;
v = 0;
} //Fecha Deteco manual de Vmax.
//Parametrizao do sentido.
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Parametrizacao");
lcd.setCursor(2,1);
lcd.print("do sentido:");
delay(3000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Auto detectar?");
lcd.setCursor(5,1);
lcd.print("1- Sim");
x=0;
nome1 = "
1- Sim
";
nome2 = "
2- Nao
";
var_binario();
if (x == 0){
//Deteco sem o sensor.
lcd.clear();
lcd.setCursor(3,0);
lcd.print("Sensor nao");
lcd.setCursor(3,1);
lcd.print("encontrado");
delay(3000);
x = 1;
}
if (x == 1){
analogWrite(right, 200); //|aciona rotao em
baixa
//| velocidade.
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Qual o sentido");
lcd.setCursor(3,1);
lcd.print("de rotacao");
delay(3000);
analogWrite(right, 215);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("atual do motor?");
delay(3000);
analogWrite(right, 230);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Rotacao atual:");
lcd.setCursor(3,1);
lcd.print("1- Horaria");
x=0;
nome1 = " 1- Horaria ";
nome2 = "2- Anti-horaria ";
var_binario();
analogWrite(right, 255);
if (x == 1){
right = P2_2;
left = P2_1;
}
}
//Parametrizao da distancia.
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Parametrizacao");

lcd.setCursor(2,1);
lcd.print("da distancia:");
delay(3000);
lcd.clear();
lcd.setCursor(2,0);
lcd.print("Qual sensor");
lcd.setCursor(2,1);
lcd.print("Ultrassonico");
delay(3000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("esta utilizando?");
delay(3000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Modelo do sensor");
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.
if (x == 1){ // Modo Proporcional.
Modo[1] = 2;
Modo[2] = 2;
x = 16;
v = 0;
lcd.clear();
//fixando a distancia
inicial.
lcd.setCursor(0,0);
lcd.print("Dist. Inicial");
lcd.setCursor(0,1);
lcd.cursor();
nome1 = "Dist. Inicial";
intmax = 200;
intmin = 3;
v = 3;
var_inteiro();
di = v;
lcd.clear();
//fixando a velocidade
inicial.
lcd.setCursor(0,0);
lcd.print("Veloc. Inicial");
lcd.setCursor(0,1);
lcd.cursor();
nome1 = "Veloc. Inicial";
intmax = vmax;
intmin = 0;
v = 0;
var_inteiro();
vi = v;
lcd.clear();
//fixando a distancia final.
lcd.setCursor(0,0);
lcd.print("Dist. Final");
lcd.setCursor(0,1);
lcd.cursor();
nome1 = "Dist. Final";
intmax = 200;
intmin = 3;
v = di;
var_inteiro();
df = v;
lcd.clear();
//fixando a velocidade
final.
lcd.setCursor(0,0);
lcd.print("Veloc. Final");
lcd.setCursor(0,1);
lcd.cursor();
nome1 = "Veloc. Final";
intmax = vmax;
intmin = 0;
v = vi;

var_inteiro();
vf = v;
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 Proporcional.
Visor = 2;
v = 0;
}// fecha Sensor HC-SR04 (x == 0)
if (x == 1){ //Sem Sensor de distancia.
Modo[1] = 0;
Modo[2] = 0;
lcd.clear();
lcd.setCursor(2,0);
lcd.print("Escolha uma");
lcd.setCursor(0,1);
lcd.print("velocidade unica");
delay(3000);
lcd.clear();
lcd.setCursor(2,0);
lcd.print("de trabalho.");
delay(3000);
lcd.clear();
//fixando velociade nica.
lcd.setCursor(0,0);
lcd.print("Velocidade (rpm)");
lcd.setCursor(0,1);
lcd.cursor();
nome1 = "Velocidade (rpm)";
intmax = vmax;
intmin = 0;
x = 16;
v = 0;
var_inteiro();
vsp = v;
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 = 1;
Visor = 1;
v = 0;
} // Fecha Sem Sensor de distancia (x == 1)
v = 0;
} //Fecha void config.
//Seleo
e
--------------------------------------------void var_inteiro() {
while (digitalRead(enter) != LOW){
time = millis();

Botes

while (digitalRead(up) == LOW && v <

intmax){
lcd.noCursor();
v++;
lcd.setCursor(0,1);
lcd.print(v, DEC);
if (millis() - time < 2000){delay(500);}
//Corre devagar.
if (millis() - time > 2000){delay(30);} //Corre
rapido.
}
while (digitalRead(down) == LOW && v >
intmin){
lcd.noCursor();
v--;
lcd.clear();
lcd.setCursor(0,0);
lcd.print(nome1);
lcd.setCursor(x,0);
lcd.print(num, DEC);
lcd.setCursor(0,1);
lcd.print(v, DEC);
if (millis() - time < 2000){delay(500);}
//Corre devagar.
if (millis() - time > 2000){delay(30);} //Corre
rapido.
}
}
delay (500);
} //fecha void var_inteiro.

analogWrite(right, ctrl);
ctrl += 5;
delay(100);
}
ctrl = 255;
}//Fecha vmaxima.
//============================
=============//

void var_binario() {
while(digitalRead(enter) == HIGH){
if
(digitalRead(up)
==
LOW
||
digitalRead(down) == LOW){
x = !x;
if (x == 0){
lcd.setCursor(0,1);
lcd.print(nome1);
delay(500);
}
if (x == 1){
lcd.setCursor(0,1);
lcd.println(nome2);
delay(500);
}
}
}// fecha botao enter
delay(500);
}//fecha var_binario.
//============================
============//

//Mostra
velocidade
do
motor----------------------------------void displaiv()
{
if(z >= 2){
vfalse = 60000 / (tempo2 - tempo1);
z = 0;
if (vfalse < 1000 && vfalse >= 0){
v = vfalse;
lcd.clear();
lcd.setCursor(0,0);
lcd.print(nome1);
lcd.print(nome2);
lcd.print(")");
lcd.setCursor(0,1);
lcd.print(v);
lcd.print(" rpm");
}
}
} //Fecha displaiv.
//============================
=============//

//Deteco
Vmax---------------------------------------------void vmaxima() {
while (ctrl >= 0){
displaiv();
analogWrite(right, ctrl);
ctrl -= 5;
delay(100);
}
ctrl = 0;
analogWrite(right, 0);
delay (3000);
displaiv;
lcd.clear();
delay(500);
lcd.setCursor(0,0);
lcd.print("Velocidade (Max)");
lcd.setCursor(0,1);
lcd.print(v);
lcd.print(" rpm");
while (ctrl <= 255){

de

//Controle
da
velocidade--------------------------------------//
void controle(){
analogWrite(sent, ctrl);
delay (ctrl + 100);
if (vsp > v){
ctrl--;
if (ctrl < 0){
ctrl = 0;
}
}
if (vsp < v){
ctrl++;
if (ctrl > 255){
ctrl = 255;
}
}
displaiv();
} //Fecha controle.
//============================
=============//

//Interrupo-------------------------------------------------void tempo()
{
if (z == 0){
tempo1 = millis();
}
if (z == 1){
tempo2 = millis();
}
z++;
} //ficha tempo.
//============================
=============//
//Velocidade
proporcional-----------------------------------void velprop(){
if (di < df && vi < vf){
dmaxp = df;

dminp = di;
vmaxp = vf;
vminp = vi;
vsp = vminp + (((vmaxp - vminp)*(dsp dminp))/(dmaxp - dminp));
}
if (di > df && vi > vf){
dmaxp = di;
dminp = df;
vmaxp = vi;
vminp = vf;
vsp = vminp + (((vmaxp - vminp)*(dsp dminp))/(dmaxp - dminp));
}
if (di < df && vi > vf){
dmaxp = df;
dminp = di;
vmaxp = vi;
vminp = vf;
vsp = vmaxp - (((vmaxp - vminp)*(dsp dminp))/(dmaxp - dminp));
}
if (di > df && vi < vf){
dmaxp = di;
dminp = df;
vmaxp = vf;
vminp = vi;
vsp = vmaxp - (((vmaxp - vminp)*(dsp dminp))/(dmaxp - dminp));
}
//y = (vsp*255)/vmax;
//ctrl = y^255;
z = 0;
} //Fecha void veloprop .
//============================
=============//
//Distancias
proporcionais------------------------------------void disprop(){
if (di > df){
dmaxp = di;
dminp = df;
}
if (di < df){
dmaxp = df;
dminp = di;
}
distmedida();
if (distance <= 200 || distance >= 0){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Distancia");
if (dmaxp >= distance && distance >=
dminp){
dsp = distance;
lcd.setCursor(0,1);
lcd.print(dsp);
lcd.print(" cm (!)");
}
if (dmaxp < distance || distance < dminp){
lcd.setCursor(0,1);
lcd.print(distance);
lcd.print(" cm ");
}
}
if (distance > 200 || distance <= 0){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Distancia");
lcd.setCursor(0,1);

lcd.print("Setada = ");
lcd.print(dsp);
lcd.print(" cm");
}
delay(500);
} //Fecha dis prop.
//============================
============//
//Velocidades
fixas-------------------------------------------void velfixas(){
for (int i = 0; i < nv; i++){
if (dsp == dis[i]){
vsp = vel[i];
}
}
z = 0;
}
//============================
=============//
//Distancias
fixas
--------------------------------------------void disfixas(){
x = 0;
distmedida();
if (distance <= 200 || distance >= 0){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Distancia");
for (int i = 0; i < nv; i++){
if (distance == dis[i]){
dsp = distance;
lcd.setCursor(0,1);
lcd.print(dsp);
lcd.print(" cm (!)");
x = 1;
}
if (x == 0) {
lcd.setCursor(0,1);
lcd.print(distance);
lcd.print(" cm ");
}
}
}
if (distance > 200 || distance <= 0){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Distancia");
lcd.setCursor(0,1);
lcd.print("Setada = ");
lcd.print(dsp);
lcd.print(" cm");
}
delay(500);
} //Fecha dis fixas.
//============================
=============//
//Medio
da
distancia-----------------------------------------void distmedida(){
digitalWrite(trigPin, HIGH);
delayMicroseconds(1000);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;
}
//============================
=============//

CRONOGRAMA FINAL

Ms 4 e ms 5: Especificao do conjunto de parmetros a

serem definidos e das perguntas correspondentes na fase de
parametrizao;
Ms 5 ao ms 7: Implementao do programa parametrizvel;
Ms 7 ao ms 9: Montagem da interface;
Ms 9 e ms 10: Testes;
Ms 10 e ms 12: Redao de artigos e de relatrios.

REFERNCIAS

[1]
OGATA,K.; Engenharia de Controle Moderno, Prentice-Hall
Brasil, So 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 Bsica, Prentice-Hall Brasil, So
Paulo, 2005
[5]
Texas
Instruments,
MSP430f149.PDF,
MSP430x13x,
MSP430x14x Mixed Signal Microcontroller, datasheet, 2003.
[6] PEREIRA,F., Microcontroladores MSP430 - Teoria e Prtica, rica,
So Paulo, 2010.
[7] McRoberts, M.; Arduino bsico. So Paulo: Novatec, , 2011.
[8] Thomazini, D. e Albuquerque, P. U. B., Sensores Industriais:
Fundamentos e Aplicaes, rica.

DATA 30/12/2013
ASSINATURA DO ORIENTADOR ______________________________
ASSINATURA DO BOLSISTA

______________________________

Coordenao da Iniciao Cientfica - IFSP

http://www2.ifsp.edu.br/edu/iniciacaocientifica/
OBS: Este relatrio dever 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
Pr-reitoria de Pesquisa e Inovao - PRP