Você está na página 1de 42

UNIVERSIDADE TECNOLGICA FEDERAL DO PARAN

DEPARTAMENTO ACADMICO DE ELETRNICA - DAELN

DEPARTAMENTO ACADMICO DE INFORMTICA - DAINF

CURSO DE ENGENHARIA DE COMPUTAO

BRUNO ALBERTINI EBINER

EUCYELLE K. DE SOUZA PINTO

RENAN F. C. DE MORAES

PROJETO GUINCHO

MONOGRAFIA

CURITIBA

2013

1
BRUNO ALBERTINI EBINER

EUCYELLE K. DE SOUZA PINTO

RENAN F. C. DE MORAES

PROJETO GUINCHO

Trabalho apresentado
disciplina de Oficina de
Integrao Dois, do Curso de
Engenharia de Computao da
UTFPR como requisito parcial
para aprovao.

CURITIBA

2013

2
Resumo

Ebiner, Bruno Albertini; Pinto, Eucyelle K. de Souza; Moraes, Renan F. C. de.


Projeto Guincho. Monografia Curso de Engenharia de Computao,
Universidade Tecnolgica Federal do Paran. Curitiba, 2013.

Esse projeto tem como objetivo a construo de um prottipo de guincho, cuja


altura da cesta determinada pelo usurio atravs de um software de
computador. Utilizamos um sensor tico e um encoder para determinao da
altura, tambm utilizamos uma ponte H para efetuar a mudana no sentido de
rotao do motor do projeto. Optamos pela escolha desse projeto, por se tratar
de um desafio interessante para nossa equipe, j que nunca havamos
trabalhado com atuador, sensor, encoder e Arduino tudo em um nico projeto.
Conseguimos integrar todos os componentes envolvidos no projeto, porm com
algumas limitaes de software e velocidade de processamento, tendo assim,
certa taxa de erro nas medidas de altura da cesta.

Palavras-chave: Guincho, Arduino, Ponte H, Sensor Foto-Reflexivo, Motor CC.

3
Lista de Figuras

Figura 1: Diagrama de Blocos do Projeto ............................................................................... 6

Figura 2: Arduino. ....................................................................................................................... 8

Figura 3: Estrutura bsica de um motor de corrente contnua. ........................................... 9

Figura 4: Motor RF-300EH 1D390, utilizado no projeto. ................................................... 9

Figura 5: Representao de uma Ponte H simples. ........................................................... 10

Figura 6: Sentido de rotao do motor dado pela corrente. .............................................. 11

Figura 7: Circuito integrado ST Microelectronics L293D.................................................... 11

Figura 8: Circuito interno do CI ST Microelectronics L293D. ............................................ 12

Figura 9: Conexes dos Pinos do CI ST Microelectronics L293D.................................... 12

Figura 10: Sensor modelo PHCT202 da Politronic. ............................................................ 13

Figura 11: Diagrama interno do sensor PHCT202 da Politronic. ...................................... 13

Figura 12: Exemplo de Sinal................................................................................................... 14

Figura 13: Exemplo de Encoder............................................................................................. 14

Figura 14: Conjunto montado entre Sensor, Encoder e Motor. ........................................ 15

Figura 15: Circuito da Ponte H e Arduino fixados na estrutura. ........................................ 17

Figura 16: Estrutura de palitos de picol montada com todos os componentes............ 17

Figura 17: Interface do usurio. ............................................................................................. 18

4
Sumrio
1 Introduo ............................................................................................................................. 6

1.1 Objetivos ........................................................................................................................... 7

1.1.1 Objetivo Geral ........................................................................................................... 7

1.1.2 Objetivos Especficos ............................................................................................... 7

2 Contedos Envolvidos ........................................................................................................ 7

2.1 Microcontrolador .............................................................................................................. 7

2.2 Motor de Corrente Contnua .......................................................................................... 8

2.3 Ponte H............................................................................................................................ 10

2.4 Sensor Foto-reflexivo .................................................................................................... 12

3 Metodologia ........................................................................................................................ 16

3.2 Software ........................................................................................................................... 18

3.2.1 Linguagem Arduino .................................................................................................... 18

3.2.2 Linguagem Processing .............................................................................................. 18

3.3 Hardware ......................................................................................................................... 20

4 Concluso ........................................................................................................................... 21

5 - Referncias Bibliogrficas ................................................................................................. 22

APNDICE A - Oramento ..................................................................................................... 23

APNDICE B Cdigo do programa do Arduino ............................................................... 24

APNDICE C Cdigo do programa na plataforma Processing ..................................... 25

APNDICE D Reunies (APS) ........................................................................................... 38

5
1 Introduo
Com este trabalho, visamos a construo de um pequeno prottipo de
Guincho, com posicionamento de sua cesta. A altura de elevao ser
fornecida por um usurio atravs de um software de computador.

Neste relatrio iremos apresentar o projeto, comeando pelos objetivos


de desenvolvimento do mesmo, e a seguir um detalhamento sobre os
componentes e peas utilizados. Tambm apresentaremos a metodologia
empregada, o oramento do projeto, concluso e suas devidas referncias.

O projeto consiste em desenvolver um prottipo de guincho controlado


atravs da plataforma Arduino, utilizando um motor de corrente contnua com
escovas e tenso de 5,9 volts para subida e descida do cabo, um sensor foto
reflexivo juntamente com um encoder, que basicamente um disco formado
por marcaes brancas e pretas, onde ser refletida a luz do sensor, gerando
pulsos eltricos que sero processados no Arduino, fornecendo a posio da
cesta do guincho. Utilizaremos tambm uma ponte H, dispositivo que permite a
inverso do sentido de rotao do motor. O usurio entrar com valores em
centmetros para a subida e descida da cesta atravs de uma interface
desenvolvida para o computador. O Diagrama de blocos pode ser visto na
figura 1.

Figura 1: Diagrama de Blocos do Projeto


Fonte: Autoria Prpria.
6
1.1 Objetivos

1.1.1 Objetivo Geral


Construir um guincho cuja altura da cesta determinada pelo usurio
atravs do software de computador.

1.1.2 Objetivos Especficos


Estudar e aprender a teoria sobre os componentes utilizados no projeto,
como microcontroladores, motores, sensores, ponte H, e aplicar na
prtica.
Familiarizar-se com a plataforma Arduino e sua linguagem de
programao.
Controlar o sentido de rotao de um motor CC.
Utilizar um sensor tico + encoder para determinao de posio.

2 Contedos Envolvidos
Neste tpico, iremos apresentar os conceitos bsicos de funcionamento
dos componentes e peas envolvidos no projeto.

2.1 Microcontrolador
Escolhemos a plataforma Arduino (ARDUINO, 2013), figura 2, como
microcontrolador. Ele a parte central do projeto, responsvel pela
realimentao entre o motor e sensor. Ele tambm faz a anlise dos pulsos
gerados pelo sensor e encoder, e ento envia comandos, passando pela ponte
H, para que o motor efetue o movimento de subida ou descida da cesta do
guincho conforme solicitado pelo usurio.

7
Figura 2: Arduino.
Fonte: (FREEDUINO, 2013)

O Arduino uma plataforma de prototipagem eletrnica livre, baseado


em um microcontrolador com hardware e software fceis de utilizar alm de
apresentar um baixo custo. A linguagem de programao utilizada prpria da
plataforma Arduino, mas se assemelha muito linguagem C/C++, facilitando
assim a implementao de programas. Seu ambiente de desenvolvimento,
tambm prprio, e pode ser facilmente encontrado, por ser de software livre
(ARDUINO, 2013).

Para o projeto, escolhemos o Arduino modelo Freeduino BR v1. 0 que


utiliza um microcontrolador AtMega 168 20PU e apresenta interface USB para
comunicao e alimentao externa caso necessrio. Escolhemos este
modelo, pois ele atende s necessidades do projeto e a equipe j possua o
microcontrolador.

Seus comandos simplificaram parte do projeto, proporcionando equipe


um tempo maior para desenvolvimento de outras tarefas do mesmo, como: a
implementao do sensor, o funcionamento do motor e a parte da aplicao de
interao com o usurio.

2.2 Motor de Corrente Contnua


Um motor de corrente contnua, como o prprio nome j nos indica, deve
ser alimentado com tenso contnua. Essa tenso pode vir de pilhas e baterias
no caso de motores pequenos, ou de uma rede alternada retificada para
motores maiores (FRANCA, 2001).
8
Segundo (FRANCA, 2001) basicamente os principais componentes de
um motor de corrente contnua so:

Estator: contm um enrolamento (chamado campo), que


alimentado diretamente por uma fonte de tenso contnua,
podendo ser um simples im permanente no caso de pequenos
motores;
Rotor: contm um enrolamento (chamado armadura). Que
alimentado por uma fonte de tenso contnua atravs do
comutador e escovas;
Comutador: dispositivo mecnico no qual esto conectados os
terminais das espiras da armadura, cujo papel inverter o sentido
da corrente contnua que circula na armadura.

Figura 3: Estrutura bsica de um motor de corrente contnua.


Fonte: (Franca, 2001).

Para o nosso projeto, iremos utilizar um motor de corrente contnua com


escovas da marca Mabuchi Motors, modelo RF-300EH 1D390, com tenso
de alimentao nominal de 5,9 volts.

Figura 4: Motor RF-300EH 1D390, utilizado no projeto.


Fonte: Autoria Prpria.
9
2.3 Ponte H
Pontes H so circuitos amplamente utilizados em projetos de
automao, segundo (PRADO, 2009) esses circuitos so utilizados para o
controle de motores CC, onde este pode girar tanto para um sentido quanto o
outro (horrio e anti-horrio). Podem ser construdos por meio de utilizao de
componentes ou adquiridos em circuitos prontos.

O nome Ponte H se d devido forma do diagrama do circuito, o qual


lembra a letra H e pode ser visto na figura 5.

Figura 5: Representao de uma Ponte H simples.


Fonte: (Patsko, 2006).

Conforme (BRAGA, 2013), para determinar para qual sentido o motor


ter sua rotao temos que verificar a corrente pelos seus enrolamentos.
Assim, invertendo a polaridade da alimentao de um motor, invertemos
tambm o seu sentido de rotao, conforme sugere a figura 6.

10
Figura 6: Sentido de rotao do motor dado pela corrente.
Fonte: (Braga, 2013).

Para o nosso projeto, escolhemos o Circuito Integrado da marca ST


Microelectronics L293D, o qual possui uma ponte H dupla internamente, porm,
utilizamos somente um lado dela, pois temos apenas 1 motor para controle.
Conectamos o pino 9 digital PWM do Arduino no pino 1 do circuito integrado
que o Enable das portas lgicas 1 e 2. Nos pinos 2 e 7, Input do circuito
integrado, ligamos ao pino digital 3 e 4 do Arduino respectivamente. Os pinos
output 3 e 6 que so de sada do L293D ligamos ao motor. O circuito interno da
ponte H L293D pode ser observado na figura 8.

Figura 7: Circuito integrado ST Microelectronics


L293D com ponte H dupla interna, utilizado no projeto.
Fonte: Autoria Prpria.

11
Figura 8: Circuito interno do CI ST Microelectronics L293D.
Fonte: (ST Microelectronics, 1996).

Na figura 9, apresentamos as conexes dos pinos do CI L293D, o qual


descrito com mais detalhes no item 3.3 deste relatrio.

Figura 9: Conexes dos Pinos do CI ST Microelectronics L293D.


Fonte: (ST Microelectronics, 1996).

2.4 Sensor Foto-reflexivo


O sensor foto-reflexivo um sensor tico. Segundo (DANTAS, 2010) os
sensores ticos se dividem em trs categorias, que so: Difusos, Foto-reflexivo,
Emissor-receptor. O sensor tico reflexivo tem o transmissor e o receptor
montados em uma nica unidade. O feixe de luz chega ao receptor aps a
incidncia e o acionamento da sada ocorre quando um objeto interrompe o
feixe. Neste trabalho ser utilizado o Foto-reflexivo que funcionar em conjunto
com um Encoder, para que possamos identificar corretamente a altura da cesta
12
do guincho, atravs da contagem dos pulsos que sero gerados cada vez que
o sensor detectar movimento do encoder, o qual vai girar juntamente com o
motor. O modelo que escolhemos foi o PHCT202 da marca Politronic, que pode
ser visto na figura 10.

Figura 10: Sensor modelo PHCT202 da Politronic.


Fonte: (Politronic, 1999.)

Figura 11: Diagrama interno do sensor PHCT202 da Politronic.

Fonte: (Politronic, 1999.)

O sensor possui um led emissor o qual fica constantemente refletindo


at que algum objeto obstrua a reflexo entre ele e o receptor. O encoder
quem faz esta obstruo ao se movimentar juntamente com o motor.

Conforme a variao do encoder, que gira passando dentro do sensor,


podemos identificar atravs do sinal que ele gera, se o estado 0 ou 1
conforme a figura 12, sendo 1 quando o led no interrompido pelo encoder e
0 quando interrompido. Atravs desse pulso gerado, contabilizamos quanto
de volta do encoder seria necessrio para que a cesta do guincho desa ou
suba 1 cm.

13
Figura 12: Exemplo de Sinal.

Fonte: Autoria Prpria.

Em conjunto com o sensor, temos o encoder, que desenhamos no software de


edio de imagens Photoshop (Adobe Systems Software, 2013) e pode ser
observado na figura 13.

Figura 13: Exemplo de Encoder.


Fonte: Autoria Prpria.

14
Figura 14: Conjunto montado entre Sensor, Encoder e Motor.

Fonte: Autoria Prpria.

2.5 Interface com o Usurio - Processing

O Processing (PROCESSING, 2013) uma linguagem aberta, com um


ambiente prprio de desenvolvimento. Sua IDE (Integrated Development
Environment) muito semelhante a do Arduino. A aplicao possui duas
funes fundamentais: setup () e draw () ambas no possuem retorno. As
linguagens de programao C e Java formam a base para a linguagem do
Processing. Sua programao amplamente utilizada para a manipulao de
grficos, animaes e sons. Escolhemos esta plataforma para o
desenvolvimento do software do projeto, que ser a interao com o usurio,
devido grande integrao com a plataforma Arduino.

Utilizamos a IDE do Arduino para gravar um firmware no


microcontrolador, para que ele pudesse se comunicar com o Processing. Na
prpria IDE j existem alguns exemplos para serem usados como base. Dentre
eles h um conjunto de cdigos no menu Examples e em seguida no sub-
menu Firmata, que criam um protocolo de comunicao para que o Arduino
possa se comunicar com o computador local. Ento no microcontrolador
gravamos o cdigo denominado SimpleDigitalFirmata, na integra no apndice
B, e esse armazena um protocolo para que o Processing consiga, atravs de
uma biblioteca pronta, entender os sinais que recebeu do Arduino.

15
3 Metodologia

3.1 Estrutura

A estrutura do guincho foi toda feita com palitos de picol (madeira),


iniciamos com a base, na forma quadrada, para garantir uma maior
sustentao evitando tombamentos durante a utilizao. O Arduino e a
Protoboard, que comporta o Circuito Integrado L293D (Ponte H dupla) e todas
as ligaes do projeto, foram acoplados em seus espaos reservados na
estrutura de madeira, conforme figura 15. Nesse projeto a utilizao de uma
Ponte H foi necessria para que a cesta do guincho pudesse subir e descer, j
que ela permite o controle do sentido de rotao do motor CC. Atravs do
software desenvolvido para o computador, podemos alterar este sentido. O
circuito integrado L293D (Ponte H) necessita de duas fontes de alimentao,
sendo elas: quatro pilhas AA em seu suporte e a segunda atravs de um pino
especfico do Arduino que fornece 5 volts para o CI e demais componentes.
Para saber a posio da cesta, foi utilizado o sensor PHCT202 junto com um
encoder. Os custos de cada item esto especificados no Apndice A. A
alimentao do Arduino feita atravs da entrada USB, que conectada ao
Microcomputador tambm nos possibilita a comunicao com o usurio atravs
do software do projeto.

Na parte de superior da estrutura fica o motor CC conectado a uma


engrenagem atravs de uma pequena correia de borracha e pode ser visto na
figura 14. No meio da engrenagem temos um palito de espeto feito em madeira
de onde sai o fio em que a cesta est pendurada.

16
Figura 15: Circuito da Ponte H e Arduino fixados na estrutura.

Fonte: Autoria Prpria.

Figura 16: Estrutura de palitos de picol montada com todos os componentes.

Fonte: Autoria Prpria.

17
3.2 Software
Um dos objetivos do projeto a interao do usurio com o guincho.
Para isso utilizamos duas linguagens de programao: a do Arduino e a do
Processing. O Arduino ter a funo de controlar o sistema atravs de
comandos passados por uma interface em Processing.

3.2.1 Linguagem Arduino


A linguagem do Arduino baseada em C/C++ e possui dois mtodos
principais: setup () e loop (), ambos no possuem retorno. O mtodo setup ()
chamado pelo programa uma nica vez a cada inicializao do programa, seja
por resetar o Arduino ou lig-lo. no mtodo setup que ficam as definies de
quais sero as entradas utilizadas e inicializao das bibliotecas. J o mtodo
loop permanecer em lao infinito ou at que algum comando mande parar de
executar o programa. Assim ele deve monitorar o que vem das entradas
analgicas e digitais do Arduino e tambm controlar suas sadas.

3.2.2 Linguagem Processing


A linguagem utilizada pelo processing baseada em C e Java. No
projeto optamos por utilizar a linguagem Java no desenvolvimento da interface
do usurio. Assim como o Arduino, o Processing tambm possui dois mtodos
principais: o setup () e o draw (). O setup possui as mesmas funes do setup
do Arduino, que de inicializar as variveis e executado apenas uma vez
tambm. O mtodo draw tem a funo de monitorar e imprimir na tela as
decises conforme as estruturas de controle. Na figura 17 temos a interface
que foi desenvolvida para a aplicao. Nela o usurio clica em uma das
distncias em cm que deseja, escolhe o sentido e envia.

Figura 17: Interface do usurio.

Fonte: Autoria Prpria.

18
Agora, temos uma descrio do cdigo do software. Esse cdigo est na
integra no Apndice C.

Primeiramente so importadas as bibliotecas do Arduino e da Serial.


Aps isso algumas variveis so definidas para serem utilizadas ao longo do
cdigo.

No mtodo setup definido o tamanho da tela, a cor de fundo da


aplicao, a fonte, e a inicializao do Arduino. Tambm entramos com o pino
de sada do Arduino.

No mtodo draw primeiramente desenhamos todos os componentes da


tela. Colocamos uma estrutura de controle pegando a posio do mouse. Se o
mouse estiver na rea do boto, preenchemos o boto com a cor preta para
que o usurio perceba a seleo. Depois desenhamos os caracteres e
definimos suas posies. Aps isso criamos uma estrutura de controle para
que quando clicado em uma determinada distncia, verifique se j existe outra
selecionada. Assim evitamos duas distncias selecionadas ao mesmo tempo.
Tambm temos o boto para Enviar o comando e o Limpar que define os
valores padres dos botes.

No mtodo enviar(), so feitas algumas validaes, como se o usurio


preencheu a distncia que gostaria de percorrer e se o guincho deve subir ou
descer. Se todas as validaes forem aceitas ele liga o motor e comea a
contagem de pulsos eltricos atravs de um lao, verificando em cada
passagem por esse lao, se houve alguma alterao de sinal na porta digital
que est ligada ao pino do sensor. A cada segundo ele sai do lao e
incrementa a contagem em uma varivel. Assim verifica se j chegou ao valor
estipulado pelo usurio. Caso afirmativo desliga o motor, se no, continua a
percorrer o lao novamente.

19
3.3 Hardware

A ligao do CI L293D com o Arduino e o Motor foi feita da seguinte


maneira:

Pino 1 - enable 1, 2 - ligado ao pino digital 9 (PWM) do arduino

Pino 2 - input 1 - ligado ao pino digital 3 do arduino

Pino 3 - output 1 - ligado ao motor cc/dc

Pino 4 - GND - ligado ao terra (ground) do arduino

Pino 5 - GND - ligado ao terra (ground) do arduino

Pino 6 - output 2 - ligado ao motor cc/dc

Pino 7 - input 2 - ligado ao pino digital 4 do arduino

Pino 8 - Vcc 2 - ligado ao positivo vindo das pilhas

Pino 12 - GND - ligado ao terra (ground) do arduino

Pino 13 - GND - ligado ao terra (ground) do arduino

Pino 16 - Vcc 1 - ligado ao pino 5V (volts) do arduino

Para facilitar a visualizao, podemos observar a figura 9.

20
4 Concluso

Neste projeto desenvolvemos um Guincho controlado por Arduino e


interface para interao com o usurio. Atravs do uso da Ponte H
disponibilizamos a operao de subida e descida do guincho, juntamente com
um sensor tico e encoder para o controle de altura da cesta do guincho que
determinado pelo usurio. O desenvolvimento deste projeto foi baseado na
proposta da matria, porm, o Arduino possui diversas entradas e sadas de
dados que no foram exploradas no projeto, devido ao curto cronograma,
permitindo expanses com a utilizao de sensores ou motores de maior
tenso e velocidade. A implantao de um novo motor para que o Guincho
rotacione em 360 em volta do seu eixo seria uma das expanses possveis
com alguns ajustes.

Investimos bastante tempo para a aquisio de alguns componentes


especficos, como a Protoboard em tamanho compatvel com as dimenses do
Guincho. No entanto no mbito dos requisitos da disciplina o objetivo foi
alcanado pelo grupo com a utilizao de motores e sensores.

21
5 - Referncias Bibliogrficas

ARDUINO, 2013. Disponvel em: <http://www.arduino.cc/> Acesso em 30 ago.


2013.

FREEDUINO, 2013. Disponvel em: <http://www.freeduino.org/index.html>


Acesso em 30 ago. 2013.

ANTUNES, F. L. M. Motores eltricos de corrente contnua e universal.


2001. Disponvel em:
<http://www.cpdee.ufmg.br/~gbarbosa/Disciplina%20de%20M%E1quinas%20El
%E9tricas/Disciplina%20de%20M%C3%A1quinas%20El%C3%A9tricas/motor_
cc.pdf>. Acesso em: 30 ago. 2013.

PRADO, T. B. C. Circuito Ponte H. 2009. Disponvel em:


<http://www.mecatrons.xpg.com.br/Artigos/ArtigoVII/artigoVII.html>. Acesso
em: 01 set. 2013.

BRAGA, C. N. Conhea as Pontes H. 2013. Disponvel em:


<http://www.newtoncbraga.com.br/index.php/robotica/5166-mec068a>. Acesso
em: 02 set. 2013.

PATSKO, L. F. Tutorial Montagem da Ponte H. 2006. Disponvel em:


<http://www.maxwellbohr.com.br/downloads/robotica/mec1000_kdr5000/tutorial
_eletronica_-_montagem_de_uma_ponte_h.pdf>. Acesso em: 03 out. 2013.

ST MICROELECTRONICS, L293D Datasheet. 1996. Disponvel em:


<http://pdf.datasheetcatalog.com/datasheet/stmicroelectronics/1330.pdf>.
Acesso em 02 set. 2013.

PROCESSING, 2013. Disponvel em: <http://processing.org/>. Acesso em: 12


set. 2013.

22
DANTAS, L. Sensores digitais ticos e ultra snicos. 2010. Disponvel
em: <http://automacao2010.blogspot.com.br/2010/03/sensores-digitais-oticos-
e-ultra.html>. Acesso em 12 set. 2013.

ADOBE S. S. Adobe Photoshop. 2013. Disponvel em:


<http://www.adobe.com/br/products/photoshop.html>. Acesso em 12 set. 2013.

POLITRONIC, PHCT202 Datasheet. 1999. Disponvel em:


<http://politronic.com.br/especs/cha/PHCTX0X.pdf>. Acesso em: 03 out. 2013.

APNDICE A - Oramento
Abaixo temos os componentes utilizados no projeto com seus respectivos
valores.

Arduino Freeduino BR V1. 0 R$59,90


Protoboard Pequena R$20,00
Motor CC 5,9 volts R$8,00
Conjunto de Jumpers (Fios) R$15,00
Circuito integrado L293D Ponte H R$9,00
Sensor foto reflexivo PHCT202 R$7,00
Porta Pilhas R$5,00
Pilhas AA R$10,00
Pacote de Palitos de Picol R$15,00
Cola de Madeira R$6,00
Total: R$154,90

Tabela 1: Itens Utilizados no projeto.

23
APNDICE B Cdigo do programa do Arduino

Abaixo, temos o cdigo Firmata que gravado no Arduino, permitindo assim a


comunicao com a linguagem Processing.
#include <Firmata.h>

byte previousPIN[TOTAL_PORTS]; // PIN means PORT for input


byte previousPORT[TOTAL_PORTS];

void outputPort(byte portNumber, byte portValue)


{
// only send the data when it changes, otherwise you get too many messages!
if (previousPIN[portNumber] != portValue) {
Firmata.sendDigitalPort(portNumber, portValue);
previousPIN[portNumber] = portValue;
}
}

void setPinModeCallback(byte pin, int mode) {


if (IS_PIN_DIGITAL(pin)) {
pinMode(PIN_TO_DIGITAL(pin), mode);
}
}

void digitalWriteCallback(byte port, int value)


{
byte i;
byte currentPinValue, previousPinValue;

if (port < TOTAL_PORTS && value != previousPORT[port]) {


for(i=0; i<8; i++) {
currentPinValue = (byte) value & (1 << i);
previousPinValue = previousPORT[port] & (1 << i);
if(currentPinValue != previousPinValue) {
digitalWrite(i + (port*8), currentPinValue);
}
}
previousPORT[port] = value;
}
}

void setup()
{
Firmata.setFirmwareVersion(0, 1);
Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
Firmata.attach(SET_PIN_MODE, setPinModeCallback);
Firmata.begin(57600);
}

void loop()
{
byte i;

for (i=0; i<TOTAL_PORTS; i++) {


outputPort(i, readPort(i, 0xff));
}

while(Firmata.available()) {
Firmata.processInput();
}
}

24
APNDICE C Cdigo do programa na plataforma Processing
import processing.serial.*;
import cc.arduino.*;
import javax.swing.JOptionPane;

Arduino arduino;

int chaveMudaSentRot = 2;
int motorCCEnt1 = 3;
int motorCCEnt2 = 4 ;
int controleL293D = 9;
int controleVelocPot = 0;
int potVelPotencia = 0;
float valorUsuario = 0;
int ledSensor = 2;
float contagem = 0;
int tempoMotor = 0;

color selecionado = color(0);


color botaoColor = color(25,188,42);
color text = color(255);

boolean select5 = false;


boolean select10 = false;
boolean select15 = false;
boolean select20 = false;
boolean select25 = false;
boolean select30 = false;
boolean select35 = false;
boolean select40 = false;
boolean select45 = false;
boolean select50 = false;
boolean select55 = false;
boolean select60 = false;
boolean iniciarTela = false;

boolean selectAbaixo = false;


boolean selectAcima = false;
boolean selectEnviar = false;
boolean selectLimpar = false;

boolean motorLigado = false;


boolean barraProgresso = false;
PImage iniciar, creditos, sair, ajuda;
PGraphics pg;

void setup(){

size(640, 400);
textSize(20);
background(102,102,102);

String portArduino = Arduino.list()[0];

arduino = new Arduino(this, portArduino, 57600);

//O pino da chave seletora de rotao definido como de entrada.


arduino.pinMode(chaveMudaSentRot,Arduino.INPUT);

//Pinos do motor e de ativao do L293D definidos como de sada.


arduino.pinMode(motorCCEnt1,Arduino.OUTPUT);
arduino.pinMode(motorCCEnt2,Arduino.OUTPUT);
arduino.pinMode(controleL293D,Arduino.OUTPUT);
arduino.pinMode(ledSensor,Arduino.INPUT);
}

25
void draw(){
// Inicia o motor desligado
arduino.digitalWrite(controleL293D, Arduino.LOW);

if(iniciarTela){
strokeWeight(1.0);
strokeCap(SQUARE);
fill(25,188,42,51);
ellipse(101, 145, 90, 90);
ellipse(247, 145,90,90);
ellipse(395, 145,90,90);
ellipse(541, 145,90,90);

fill(255,255,255);
text("Iniciar", 75,147);
text("Creditos",210,147);
text("Sobre",365,147);
text("Fechar", 513,147);
}

if(!iniciarTela){
fill(text);
text("Click na distancia que deseja percorrer: ", 20, 40);
text("Escolha o sentido: ", 20, 221);
//Botao 5
if(mouseX >= 40 && mouseX <=90 && mouseY >= 75 && mouseY <= 105){
fill(selecionado);
rect(40, 75, 50, 30);
}else{
if(select5){
fill(selecionado);
rect(40, 75, 50, 30);
}else{
fill(botaoColor);
rect(40, 75, 50, 30);
}
}
//Botao 10
if(mouseX >= 140 && mouseX <=190 && mouseY >= 75 && mouseY <= 105){
fill(selecionado);
rect(140, 75, 50, 30);
}else{
if(select10){
fill(selecionado);
rect(140, 75, 50, 30);
}else{
fill(botaoColor);
rect(140, 75, 50, 30);
}
}

//Botao 15
if(mouseX >= 240 && mouseX <=290 && mouseY >= 75 && mouseY <= 105){
fill(selecionado);
rect(240, 75, 50, 30);
}else{
if(select15){
fill(selecionado);
rect(240, 75, 50, 30);
}else{
fill(botaoColor);
rect(240, 75, 50, 30);
}
}
26
//Botao 20
if(mouseX >= 340 && mouseX <=390 && mouseY >= 75 && mouseY <= 105){
fill(selecionado);
rect(340, 75, 50, 30);
}else{
if(select20){
fill(selecionado);
rect(340, 75, 50, 30);
}else{
fill(botaoColor);
rect(340, 75, 50, 30);
}
}
//Botao 25
if(mouseX >= 440 && mouseX <=490 && mouseY >= 75 && mouseY <= 105){
fill(selecionado);
rect(440, 75, 50, 30);
}else{
if(select25){
fill(selecionado);
rect(440, 75, 50, 30);
}else{
fill(botaoColor);
rect(440, 75, 50, 30);
}
}
//Botao 30
if(mouseX >= 540 && mouseX <=590 && mouseY >= 75 && mouseY <= 105){
fill(selecionado);
rect(540, 75, 50, 30);
}else{
if(select30){
fill(selecionado);
rect(540, 75, 50, 30);
}else{
fill(botaoColor);
rect(540, 75, 50, 30);
}
}

//Botao 35
if(mouseX >= 40 && mouseX <=90 && mouseY >= 140 && mouseY <= 170){
fill(selecionado);
rect(40, 140, 50, 30);
}else{
if(select35){
fill(selecionado);
rect(40, 140, 50, 30);
}else{
fill(botaoColor);
rect(40, 140, 50, 30);
}
}

//Botao 40
if(mouseX >= 140 && mouseX <=190 && mouseY >= 140 && mouseY <= 170){
fill(selecionado);
rect(140, 140, 50, 30);
}else{
if(select40){
fill(selecionado);
rect(140, 140, 50, 30);
}else{
fill(botaoColor);
rect(140, 140, 50, 30);
}
27
}
//Botao 45
if(mouseX >= 240 && mouseX <=290 && mouseY >= 140 && mouseY <= 170){
fill(selecionado);
rect(240, 140, 50, 30);
}else{
if(select45){
fill(selecionado);
rect(240, 140, 50, 30);
}else{
fill(botaoColor);
rect(240, 140, 50, 30);
}
}
//Botao 50
if(mouseX >= 340 && mouseX <=390 && mouseY >= 140 && mouseY <= 170){
fill(selecionado);
rect(340, 140, 50, 30);
}else{
if(select50){
fill(selecionado);
rect(340, 140, 50, 30);
}else{
fill(botaoColor);
rect(340, 140, 50, 30);
}
}

//Botao 55
if(mouseX >= 440 && mouseX <=490 && mouseY >= 140 && mouseY <= 170){
fill(selecionado);
rect(440, 140, 50, 30);
}else{
if(select55){
fill(selecionado);
rect(440, 140, 50, 30);
}else{
fill(botaoColor);
rect(440, 140, 50, 30);
}
}

//Botao 60
if(mouseX >= 540 && mouseX <=590 && mouseY >= 140 && mouseY <= 170){
fill(selecionado);
rect(540, 140, 50, 30);
}else{
if(select60){
fill(selecionado);
rect(540, 140, 50, 30);
}else{
fill(botaoColor);
rect(540, 140, 50, 30);
}
}

//Botao para cima


if(mouseX >= 40 && mouseX <=120 && mouseY >= 250 && mouseY <= 280){
fill(selecionado);
rect(40, 250, 80, 30);
}else{
if(selectAcima){
fill(selecionado);
rect(40, 250, 80, 30);
}else{
fill(botaoColor);
28
rect(40, 250, 80, 30);
}
}
//Botao para cima
if(mouseX >= 150 && mouseX <=230 && mouseY >= 250 && mouseY <= 280){
fill(selecionado);
rect(150, 250, 80, 30);
}else{
if(selectAbaixo){
fill(selecionado);
rect(150, 250, 80, 30);
}else{
fill(botaoColor);
rect(150, 250, 80, 30);
}
}

//Botao para cima


if(mouseX >= 40 && mouseX <=120 && mouseY >= 250 && mouseY <= 280){
fill(selecionado);
rect(40, 250, 80, 30);
}else{
if(selectAcima){
fill(selecionado);
rect(40, 250, 80, 30);
}else{
fill(botaoColor);
rect(40, 250, 80, 30);
}
}
//Botao para baixo
if(mouseX >= 150 && mouseX <=230 && mouseY >= 250 && mouseY <= 280){
fill(selecionado);
rect(150, 250, 80, 30);
}else{
if(selectAbaixo){
fill(selecionado);
rect(150, 250, 80, 30);
}else{
fill(botaoColor);
rect(150, 250, 80, 30);
}
}

//Botao para Enviar


if(mouseX >= 210 && mouseX <=290 && mouseY >= 340 && mouseY <= 370){
fill(selecionado);
rect(210, 340, 80, 30);
}else{
fill(botaoColor);
rect(210, 340, 80, 30);
}

//Botao para Limpar


if(mouseX >= 350 && mouseX <=430 && mouseY >= 340 && mouseY <= 370){
fill(selecionado);
rect(350, 340, 80, 30);
}else{
fill(botaoColor);
rect(350, 340, 80, 30);
}

if(mouseX >= 490 && mouseX <= 570 && mouseY >= 340 && mouseY <= 370){
fill(selecionado);
rect(490, 570,80,30);
29
}else{
fill(selecionado);
rect(490, 570, 80,30);
}

fill(text);
text("5", 52, 98);
text("10", 152, 98);
text("15", 252, 98);
text("20", 352, 98);
text("25", 452, 98);
text("30", 552, 98);
text("35", 52, 163);
text("40", 152, 163);
text("45", 252, 163);
text("50", 352, 163);
text("55", 452, 163);
text("60", 552, 163);

text("Descer", 55, 273);


text("Subir", 157, 273);

text("Enviar", 220, 362);


text("Limpar", 358, 362);
}
}

void mousePressed() {

if(iniciarTela){
if(mouseX >= 56 && mouseX <=146 && mouseY >= 100 && mouseY <= 190){
iniciarTela = false;
//pg.beginDraw();
background(102,102,102);
}
if(mouseX >= 202 && mouseX <=292 && mouseY >= 100 && mouseY <= 190){
iniciarTela = false;
background(102,102,102);
}
if(mouseX >= 348 && mouseX <=538 && mouseY >= 100 && mouseY <= 190){
iniciarTela = false;
background(102,102,102);
}
if(mouseX >= 494 && mouseX <=584 && mouseY >= 100 && mouseY <= 190){
exit();
}
}

if(!iniciarTela){
//Boto 5
if(mouseX >= 40 && mouseX <=90 && mouseY >= 75 && mouseY <= 105 && !iniciarTela){
if(!select5){
fill(selecionado);
rect(40, 75, 50, 30);
select5 = true;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
30
select60 = false;
valorUsuario = 1;
}else{
fill(botaoColor);
rect(40, 75, 50, 30);
select5 = false;
}
}

//Botao 10
if(mouseX >= 140 && mouseX <=190 && mouseY >= 75 && mouseY <= 105 && !iniciarTela){
if(!select10){
fill(selecionado);
rect(140, 75, 50, 30);
select5 = false;
select10 = true;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 2;
}else{
fill(botaoColor);
rect(140, 75, 50, 30);
select10 = false;
}
}

//Botao 15
if(mouseX >= 240 && mouseX <=290 && mouseY >= 75 && mouseY <= 105 && !iniciarTela){
if(!select15){
fill(selecionado);
rect(240, 75, 50, 30);
select5 = false;
select10 = false;
select15 = true;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 2.5;
}else{
fill(botaoColor);
rect(240, 75, 50, 30);
select15 = false;
}
}

//Botao 20
if(mouseX >= 340 && mouseX <=390 && mouseY >= 75 && mouseY <= 105 && !iniciarTela){
if(!select20){
fill(selecionado);
rect(340, 75, 50, 30);
select5 = false;
select10 = false;
31
select15 = false;
select20 = true;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 3.5;
}else{
fill(botaoColor);
rect(340, 75, 50, 30);
select20 = false;
}
}

//Botao 25
if(mouseX >= 440 && mouseX <=490 && mouseY >= 75 && mouseY <= 105 && !iniciarTela){
if(!select25){
fill(selecionado);
rect(440, 75, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = true;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 4.0;
}else{
fill(botaoColor);
rect(440, 75, 50, 30);
select25 = false;
}
}

//Botao 30
if(mouseX >= 540 && mouseX <=590 && mouseY >= 75 && mouseY <= 105 && !iniciarTela){
if(!select30){
fill(selecionado);
rect(540, 75, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = true;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 5;
}else{
fill(botaoColor);
rect(540, 75, 50, 30);
select30 = false;
}
32
}

//Botao 35
if(mouseX >= 40 && mouseX <=90 && mouseY >= 140 && mouseY <= 170 && !iniciarTela){
if(!select35){
fill(selecionado);
rect(40, 140, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = true;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 7;
}else{
fill(botaoColor);
rect(40, 140, 50, 30);
select35 = false;
}
}

//Botao 40
if(mouseX >= 140 && mouseX <=190 && mouseY >= 140 && mouseY <= 170){
if(!select40){
fill(selecionado);
rect(140, 140, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = true;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 8;
}else{
fill(botaoColor);
rect(140, 140, 50, 30);
select40 = false;
}
}

//Botao 45
if(mouseX >= 240 && mouseX <=290 && mouseY >= 140 && mouseY <= 170 && !iniciarTela){
if(!select45){
fill(selecionado);
rect(240, 140, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = true;
33
select50 = false;
select55 = false;
select60 = false;
valorUsuario = 9;
}else{
fill(botaoColor);
rect(240, 140, 50, 30);
select45 = false;
}
}

//Botao 50
if(mouseX >= 340 && mouseX <=390 && mouseY >= 140 && mouseY <= 170 && !iniciarTela){
if(!select50){
fill(selecionado);
rect(340, 140, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = true;
select55 = false;
select60 = false;
valorUsuario = 10;
}else{
fill(botaoColor);
rect(340, 140, 50, 30);
select50 = false;
}
}

//Botao 55
if(mouseX >= 440 && mouseX <=490 && mouseY >= 140 && mouseY <= 170 && !iniciarTela){
if(!select55){
fill(selecionado);
rect(440, 140, 50, 30);
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = true;
select60 = false;
valorUsuario = 11;
}else{
fill(botaoColor);
rect(440, 140, 50, 30);
select55 = false;
}
}

//Botao 60
if(mouseX >= 540 && mouseX <=590 && mouseY >= 140 && mouseY <= 170 && !iniciarTela){
if(!select60){
fill(selecionado);
select5 = false;
34
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = true;
valorUsuario = 12;
}else{
fill(botaoColor);
rect(540, 140, 50, 30);
select60 = false;
}
}
//Botao para cima
if(mouseX >= 40 && mouseX <=120 && mouseY >= 250 && mouseY <= 280 && !iniciarTela){
if(!selectAcima){
fill(selecionado);
rect(40, 250, 80, 30);
selectAcima = true;
selectAbaixo = false;
println("true");
}else{
fill(botaoColor);
rect(40, 250, 80, 30);
selectAcima = false;
}
}

//Botao para cima


if(mouseX >= 150 && mouseX <=230 && mouseY >= 250 && mouseY <= 280){
if(!selectAbaixo){
fill(selecionado);
rect(150, 250, 80, 30);
selectAcima = false;
selectAbaixo = true;
println(selectAbaixo);
}else{
fill(botaoColor);
rect(150, 250, 80, 30);
selectAbaixo = false;
}
}
}

if(!iniciarTela){
//Botao para Enviar
if(mouseX >= 210 && mouseX <=290 && mouseY >= 340 && mouseY <= 370 && !iniciarTela){
fill(selecionado);
rect(210, 340, 80, 30);
println("Enviado...");
enviar();
}else{
fill(botaoColor);
rect(210, 340, 80, 30);
}
}
//Botao para Limpar
if(!iniciarTela){
if(mouseX >= 350 && mouseX <=430 && mouseY >= 340 && mouseY <= 370 && !iniciarTela){
fill(selecionado);
rect(350, 340, 80, 30);
35
limpar();
}else{
fill(botaoColor);
rect(350, 340, 80, 30);
}
}
}
void enviar(){
float tempo = valorUsuario*1000;
if(!select5 && !select10 && !select15 && !select20 &&
!select25 && !select30 && !select35 && !select40 &&
!select45 && !select50 && !select55 && !select60){
JOptionPane.showMessageDialog(null,"Selecione uma distncia.");

}else{
if(!selectAbaixo && !selectAcima){
JOptionPane.showMessageDialog(null,"Selecione o sentido.");
}else{
motorLigado = true;
barraProgresso = true;
//Controlando o sentido de rotao do motor pela chave liga/desliga e pelos
//INPUTs do L293d.
if (selectAcima) {
arduino.digitalWrite(motorCCEnt1,Arduino.LOW);
arduino.digitalWrite(motorCCEnt2,Arduino.HIGH);
print("s");
} else{
print("s" + selectAbaixo);
if(selectAbaixo){
arduino.digitalWrite(motorCCEnt1,Arduino.HIGH);
arduino.digitalWrite(motorCCEnt2,Arduino.LOW);
print("d");
}
}

// Inicia o motor
arduino.digitalWrite(controleL293D, Arduino.HIGH);

print("Liga o Motor");
tempoMotor = millis();

println("Tempo do Motor" + tempoMotor);


while(motorLigado){
int tempo_final = millis() + 100;
int estado_anterior = arduino.digitalRead(ledSensor);
float contador = 0;
while(tempo_final > millis()){
int estado_atual = arduino.digitalRead(ledSensor);
delay(1);
if(estado_atual != estado_anterior)
{
estado_atual = estado_anterior;
contador ++;
}
}
contagem += (contador / (tempo_final - tempoMotor) );

if((contagem <= ((valorUsuario) + 0.3)) && (contagem >= ((valorUsuario) - 0.3))){


motorLigado = false;
}
tempoMotor = tempo_final;
println("Usuario " + valorUsuario);
println("Contagem " + contagem);
println(tempo_final);
println("Cont " + contador);
}
36
//Desliga o motor
arduino.digitalWrite(controleL293D, Arduino.LOW);
print("Desliga o Motor");
valorUsuario = 0;
barraProgresso = false;
contagem = 0;
}
}
}

void limpar(){
select5 = false;
select10 = false;
select15 = false;
select20 = false;
select25 = false;
select30 = false;
select35 = false;
select40 = false;
select45 = false;
select50 = false;
select55 = false;
select60 = false;
selectAbaixo = false;
selectAcima = false;
}

37
APNDICE D Reunies (APS)

Segue registro dos encontros do grupo desde inicio das aulas, solicitado
pelos professores como APS, at hoje presente dia da entrega da monografia.

Reunio na UTFPR 12/06/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Estudo para definio do projeto que seria abordado


pela equipe. Foi definido o projeto do Guinho.

Tpico pendente: Incio do projeto.

Reunio na UTFPR 13/06/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpicos abordados: Incio da programao do Arduino, definio do uso


de uma Ponte H e escolha do motor.

Tpico pendente: Construo da Ponte H.

Reunio na UTFPR 18/06/2013

Integrantes: Bruno e Renan

Tpico Abordado: Construo da Ponte H.

Tpico concludo: Ponte H construda.

Reunio na UTFPR 26/06/2013

Integrantes: Bruno, Eucyelle e Renan.


38
Tpico abordado: Incio da construo da estrutura.

Encontro na Rua 24 de Maio 03/07/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpicos abordados: Compra dos materiais e alguns componentes


faltantes.

Reunio pela Internet 07/07/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Discusso de qual seria o professor orientador.

Tpico concludo: Definio do Professor orientador: Valfredo Pilla


Junior.

Reunio na UTFPR 10/07/2013

Integrantes: Bruno, Eucyelle e Renan..

Tpico abordado: Conversa com os professores Mrio e Hugo sobre


possvel sensor a ser utilizado.

Tpico concludo: Definio de um sensor tico.

Encontro Rua 24 de Maio 11/07/2013

Integrantes: Bruno e Renan.

Tpico abordado: Compra do sensor tico.

39
Reunio pela Internet 12/07/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Diviso dos custos do projeto.

Reunio na casa do Renan 18/07/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpicos abordados: Termino da comunicao Arduino / Motor e incio da


programao do Software.

Reunio casa do Renan 22/07/2013

Integrantes: Eucyelle e Renan.

Tpico abordado: Testes de comunicao Ponte H com o motor.

Tpico concludo: Funcionamento correto da Ponte H com Motor

Reunio na UTFPR 31/07/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Comunicao entre o Arduino e o microcomputador.

Reunio na casa da Eucyelle 02/08/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Trabalho na construo da estrutura.

Reunio pela Internet 04/08/2013


40
Integrantes: Bruno e Renan.

Tpico abordado: Dvidas na alimentao da Ponte H.

Reunio na UTFPR 07/08/2013

Integrantes: Eucyelle e Renan.

Tpico abordado: Estudo de sensores.

Reunio na UTFPR 14/08/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Incio dos testes com sensores.

Reunio na casa do Bruno 22/08/2013

Integrantes: Bruno e Renan

Tpico abordado: Desenvolvimento da estrutura do Guincho.

Reunio na UTFPR 28/08/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpicos abordados: Comunicao do Arduino com o sensor, e


desenvolvimento do Software.

Reunio na casa da Eucyelle 30/08/2013

Integrantes: Bruno e Eucyelle.


41
Tpico abordado: Desenvolvimento do Software.

Reunio na UTFPR 04/09/2013

Integrantes: Bruno e Renan.

Tpico abordado: Montagem do circuito na nova Protoboard.

Reunio na UTFPR 11/09/2013

Integrantes: Bruno e Renan.

Tpico abordado: Estudo de comunicao do sensor com o motor.

Reunio na UTFPR 13/09/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Elaborao da monografia.

Reunio na Internet 17/09/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Monografia.

Reunio na Internet 03/10/2013

Integrantes: Bruno, Eucyelle e Renan.

Tpico abordado: Atualizao Monografia.

42