bruno albertini ebiner eucyelle k. de souza pinto...
TRANSCRIPT
1
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
DEPARTAMENTO ACADÊMICO DE ELETRÔNICA - DAELN
DEPARTAMENTO ACADÊMICO DE INFORMÁTICA - DAINF
CURSO DE ENGENHARIA DE COMPUTAÇÃO
BRUNO ALBERTINI EBINER
EUCYELLE K. DE SOUZA PINTO
RENAN F. C. DE MORAES
PROJETO GUINCHO
MONOGRAFIA
CURITIBA
2013
2
BRUNO ALBERTINI EBINER
EUCYELLE K. DE SOUZA PINTO
RENAN F. C. DE MORAES
PROJETO GUINCHO
Trabalho apresentado à
disciplina de Oficina de
Integração Dois, do Curso de
Engenharia de Computação da
UTFPR como requisito parcial
para aprovação.
CURITIBA
2013
3
Resumo
Ebiner, Bruno Albertini; Pinto, Eucyelle K. de Souza; Moraes, Renan F. C. de.
Projeto Guincho. Monografia – Curso de Engenharia de Computação,
Universidade Tecnológica Federal do Paraná. Curitiba, 2013.
Esse projeto tem como objetivo a construção de um protótipo de guincho, cuja
altura da cesta é determinada pelo usuário através de um software de
computador. Utilizamos um sensor ótico e um encoder para determinação da
altura, também utilizamos uma ponte H para efetuar a mudança no sentido de
rotação do motor do projeto. Optamos pela escolha desse projeto, por se tratar
de um desafio interessante para nossa equipe, já que nunca havíamos
trabalhado com atuador, sensor, encoder e Arduino tudo em um único projeto.
Conseguimos integrar todos os componentes envolvidos no projeto, porém com
algumas limitações 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.
4
Lista de Figuras
Figura 1: Diagrama de Blocos do Projeto ............................................................................... 6
Figura 2: Arduino. ....................................................................................................................... 8
Figura 3: Estrutura básica de um motor de corrente contínua. ........................................... 9
Figura 4: Motor RF-300EH – 1D390, utilizado no projeto. ................................................... 9
Figura 5: Representação de uma Ponte H simples. ........................................................... 10
Figura 6: Sentido de rotação 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: Conexões 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 usuário. ............................................................................................. 18
5
Sumário 1 – Introdução ............................................................................................................................. 6
1.1 Objetivos ........................................................................................................................... 7
1.1.1 Objetivo Geral ........................................................................................................... 7
1.1.2 Objetivos Específicos ............................................................................................... 7
2 – Conteúdos Envolvidos ........................................................................................................ 7
2.1 Microcontrolador .............................................................................................................. 7
2.2 Motor de Corrente Contínua .......................................................................................... 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 – Conclusão ........................................................................................................................... 21
5 - Referências Bibliográficas ................................................................................................. 22
APÊNDICE A - Orçamento ..................................................................................................... 23
APÊNDICE B – Código do programa do Arduino ............................................................... 24
APÊNDICE C – Código do programa na plataforma Processing ..................................... 25
APÊNDICE D – Reuniões (APS) ........................................................................................... 38
6
1 – Introdução Com este trabalho, visamos a construção de um pequeno protótipo de
Guincho, com posicionamento de sua cesta. A altura de elevação será
fornecida por um usuário através de um software de computador.
Neste relatório iremos apresentar o projeto, começando pelos objetivos
de desenvolvimento do mesmo, e a seguir um detalhamento sobre os
componentes e peças utilizados. Também apresentaremos a metodologia
empregada, o orçamento do projeto, conclusão e suas devidas referências.
O projeto consiste em desenvolver um protótipo de guincho controlado
através da plataforma Arduino, utilizando um motor de corrente contínua com
escovas e tensão de 5,9 volts para subida e descida do cabo, um sensor foto
reflexivo juntamente com um encoder, que é basicamente um disco formado
por marcações brancas e pretas, onde será refletida a luz do sensor, gerando
pulsos elétricos que serão processados no Arduino, fornecendo a posição da
cesta do guincho. Utilizaremos também uma ponte H, dispositivo que permite a
inversão do sentido de rotação do motor. O usuário entrará com valores em
centímetros para a subida e descida da cesta através 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 Própria.
7
1.1 Objetivos
1.1.1 Objetivo Geral Construir um guincho cuja altura da cesta é determinada pelo usuário através do software de computador.
1.1.2 Objetivos Específicos • Estudar e aprender a teoria sobre os componentes utilizados no projeto,
como microcontroladores, motores, sensores, ponte H, e aplicar na
prática.
• Familiarizar-se com a plataforma Arduino e sua linguagem de
programação.
• Controlar o sentido de rotação de um motor CC.
• Utilizar um sensor ótico + encoder para determinação de posição.
2 – Conteúdos Envolvidos Neste tópico, iremos apresentar os conceitos básicos de funcionamento
dos componentes e peças envolvidos no projeto.
2.1 Microcontrolador Escolhemos a plataforma Arduino (ARDUINO, 2013), figura 2, como
microcontrolador. Ele é a parte central do projeto, responsável pela
realimentação entre o motor e sensor. Ele também faz a análise dos pulsos
gerados pelo sensor e encoder, e então envia comandos, passando pela ponte
H, para que o motor efetue o movimento de subida ou descida da cesta do
guincho conforme solicitado pelo usuário.
8
Figura 2: Arduino. Fonte: (FREEDUINO, 2013)
O Arduino é uma plataforma de prototipagem eletrônica livre, baseado
em um microcontrolador com hardware e software fáceis de utilizar além de
apresentar um baixo custo. A linguagem de programação utilizada é própria da
plataforma Arduino, mas se assemelha muito à linguagem C/C++, facilitando
assim a implementação de programas. Seu ambiente de desenvolvimento,
também é próprio, 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
comunicação e alimentação externa caso necessário. Escolhemos este
modelo, pois ele atende às necessidades do projeto e a equipe já possuía o
microcontrolador.
Seus comandos simplificaram parte do projeto, proporcionando à equipe
um tempo maior para desenvolvimento de outras tarefas do mesmo, como: a
implementação do sensor, o funcionamento do motor e a parte da aplicação de
interação com o usuário.
2.2 Motor de Corrente Contínua Um motor de corrente contínua, como o próprio nome já nos indica, deve
ser alimentado com tensão contínua. Essa tensão pode vir de pilhas e baterias
no caso de motores pequenos, ou de uma rede alternada retificada para
motores maiores (FRANCA, 2001).
9
Segundo (FRANCA, 2001) basicamente os principais componentes de
um motor de corrente contínua são:
• Estator : contém um enrolamento (chamado campo), que é
alimentado diretamente por uma fonte de tensão contínua,
podendo ser um simples imã permanente no caso de pequenos
motores;
• Rotor : contém um enrolamento (chamado armadura). Que é
alimentado por uma fonte de tensão contínua através do
comutador e escovas;
• Comutador : dispositivo mecânico no qual estão conectados os
terminais das espiras da armadura, cujo papel é inverter o sentido
da corrente contínua que circula na armadura.
Figura 3: Estrutura básica de um motor de corrente contínua. Fonte: (Franca, 2001).
Para o nosso projeto, iremos utilizar um motor de corrente contínua com
escovas da marca Mabuchi Motors, modelo RF-300EH – 1D390, com tensão
de alimentação nominal de 5,9 volts.
Figura 4: Motor RF-300EH – 1D390, utilizado no proj eto. Fonte: Autoria Própria.
10
2.3 Ponte H Pontes H são circuitos amplamente utilizados em projetos de
automação, segundo (PRADO, 2009) esses circuitos são “utilizados para o
controle de motores CC, onde este pode girar tanto para um sentido quanto o
outro (horário e anti-horário)”. Podem ser construídos por meio de utilização 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: Representação de uma Ponte H simples. Fonte: (Patsko, 2006).
Conforme (BRAGA, 2013), para determinar para qual sentido o motor
terá sua rotação temos que verificar a corrente pelos seus enrolamentos.
Assim, “invertendo a polaridade da alimentação de um motor, invertemos
também o seu sentido de rotação”, conforme sugere a figura 6.
11
Figura 6: Sentido de rotação do motor dado pela cor rente. Fonte: (Braga, 2013).
Para o nosso projeto, escolhemos o Circuito Integrado da marca ST
Microelectronics L293D, o qual possui uma ponte H dupla internamente, porém,
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 lógicas 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 são de saída 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 proj eto.
Fonte: Autoria Própria.
12
Figura 8: Circuito interno do CI ST Microelectronic s L293D. Fonte: (ST Microelectronics, 1996).
Na figura 9, apresentamos as conexões dos pinos do CI L293D, o qual é descrito com mais detalhes no item 3.3 deste relatório.
Figura 9: Conexões dos Pinos do CI ST Microelectron ics 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 três categorias, que são: 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 após a
incidência e o acionamento da saída 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
13
do guincho, através da contagem dos pulsos que serão 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 Po litronic.
Fonte: (Politronic, 1999.)
O sensor possui um led emissor o qual fica constantemente refletindo até que algum objeto obstrua a reflexão entre ele e o receptor. O encoder é quem faz esta obstrução ao se movimentar juntamente com o motor.
Conforme a variação do encoder, que gira passando dentro do sensor, podemos identificar através do sinal que ele gera, se o estado é 0 ou 1 conforme a figura 12, sendo 1 quando o led não é interrompido pelo encoder e 0 quando é interrompido. Através desse pulso gerado, contabilizamos quanto de volta do encoder seria necessário para que a cesta do guincho desça ou suba 1 cm.
14
Figura 12: Exemplo de Sinal.
Fonte: Autoria Própria.
Em conjunto com o sensor, temos o encoder, que desenhamos no software de
edição de imagens Photoshop (Adobe Systems Software, 2013) e pode ser
observado na figura 13.
Figura 13: Exemplo de Encoder. Fonte: Autoria Própria.
15
Figura 14: Conjunto montado entre Sensor, Encoder e Motor.
Fonte: Autoria Própria.
2.5 Interface com o Usuário - Processing
O Processing (PROCESSING, 2013) é uma linguagem aberta, com um
ambiente próprio de desenvolvimento. Sua IDE (Integrated Development
Environment) é muito semelhante a do Arduino. A aplicação possui duas
funções fundamentais: setup () e draw () ambas não possuem retorno. As
linguagens de programação C e Java formam a base para a linguagem do
Processing. Sua programação é amplamente utilizada para a manipulação de
gráficos, animações e sons. Escolhemos esta plataforma para o
desenvolvimento do software do projeto, que será a interação com o usuário,
devido à grande integração 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
própria IDE já existem alguns exemplos para serem usados como base. Dentre
eles há um conjunto de códigos no menu “Examples” e em seguida no sub-
menu “Firmata”, que criam um protocolo de comunicação para que o Arduino
possa se comunicar com o computador local. Então no microcontrolador
gravamos o código denominado “SimpleDigitalFirmata”, na integra no apêndice
B, e esse armazena um protocolo para que o Processing consiga, através de
uma biblioteca pronta, entender os sinais que recebeu do Arduino.
16
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
sustentação evitando tombamentos durante a utilização. O Arduino e a
Protoboard, que comporta o Circuito Integrado L293D (Ponte H dupla) e todas
as ligações do projeto, foram acoplados em seus espaços reservados na
estrutura de madeira, conforme figura 15. Nesse projeto a utilização de uma
Ponte H foi necessária para que a cesta do guincho pudesse subir e descer, já
que ela permite o controle do sentido de rotação do motor CC. Através do
software desenvolvido para o computador, podemos alterar este sentido. O
circuito integrado L293D (Ponte H) necessita de duas fontes de alimentação,
sendo elas: quatro pilhas AA em seu suporte e a segunda através de um pino
específico do Arduino que fornece 5 volts para o CI e demais componentes.
Para saber a posição da cesta, foi utilizado o sensor PHCT202 junto com um
encoder. Os custos de cada item estão especificados no Apêndice A. A
alimentação do Arduino é feita através da entrada USB, que conectada ao
Microcomputador também nos possibilita a comunicação com o usuário através
do software do projeto.
Na parte de superior da estrutura fica o motor CC conectado a uma
engrenagem através 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.
17
Figura 15: Circuito da Ponte H e Arduino fixados na estrutura.
Fonte: Autoria Própria.
Figura 16: Estrutura de palitos de picolé montada c om todos os componentes.
Fonte: Autoria Própria.
18
3.2 – Software
Um dos objetivos do projeto é a interação do usuário com o guincho. Para isso utilizamos duas linguagens de programação: a do Arduino e a do Processing. O Arduino terá a função de controlar o sistema através de comandos passados por uma interface em Processing.
3.2.1 Linguagem Arduino
A linguagem do Arduino é baseada em C/C++ e possui dois métodos principais: setup () e loop (), ambos não possuem retorno. O método setup () é chamado pelo programa uma única vez a cada inicialização do programa, seja por resetar o Arduino ou ligá-lo. É no método setup que ficam as definições de quais serão as entradas utilizadas e inicialização das bibliotecas. Já o método loop permanecerá em laço infinito ou até que algum comando mande parar de executar o programa. Assim ele deve monitorar o que vem das entradas analógicas e digitais do Arduino e também controlar suas saídas.
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 usuário. Assim como o Arduino, o Processing também possui dois métodos principais: o setup () e o draw (). O setup possui as mesmas funções do setup do Arduino, que é de inicializar as variáveis e é executado apenas uma vez também. O método draw tem a função de monitorar e imprimir na tela as decisões conforme as estruturas de controle. Na figura 17 temos a interface que foi desenvolvida para a aplicação. Nela o usuário clica em uma das distâncias em cm que deseja, escolhe o sentido e envia.
Figura 17: Interface do usuário.
Fonte: Autoria Própria.
19
Agora, temos uma descrição do código do software. Esse código está na
integra no Apêndice C.
Primeiramente são importadas as bibliotecas do Arduino e da Serial.
Após isso algumas variáveis são definidas para serem utilizadas ao longo do
código.
No método setup é definido o tamanho da tela, a cor de fundo da
aplicação, a fonte, e a inicialização do Arduino. Também entramos com o pino
de saída do Arduino.
No método draw primeiramente desenhamos todos os componentes da
tela. Colocamos uma estrutura de controle pegando a posição do mouse. Se o
mouse estiver na área do botão, preenchemos o botão com a cor preta para
que o usuário perceba a seleção. Depois desenhamos os caracteres e
definimos suas posições. Após isso criamos uma estrutura de controle para
que quando clicado em uma determinada distância, verifique se já existe outra
selecionada. Assim evitamos duas distâncias selecionadas ao mesmo tempo.
Também temos o botão para Enviar o comando e o Limpar que define os
valores padrões dos botões.
No método enviar(), são feitas algumas validações, como se o usuário
preencheu a distância que gostaria de percorrer e se o guincho deve subir ou
descer. Se todas as validações forem aceitas ele liga o motor e começa a
contagem de pulsos elétricos através de um laço, verificando em cada
passagem por esse laço, se houve alguma alteração de sinal na porta digital
que está ligada ao pino do sensor. A cada segundo ele sai do laço e
incrementa a contagem em uma variável. Assim verifica se já chegou ao valor
estipulado pelo usuário. Caso afirmativo desliga o motor, se não, continua a
percorrer o laço novamente.
20
3.3 – Hardware
A ligação 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 visualização, podemos observar a figura 9.
21
4 – Conclusão
Neste projeto desenvolvemos um Guincho controlado por Arduino e
interface para interação com o usuário. Através do uso da Ponte H
disponibilizamos a operação 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 usuário. O desenvolvimento deste projeto foi baseado na
proposta da matéria, porém, o Arduino possui diversas entradas e saídas de
dados que não foram exploradas no projeto, devido ao curto cronograma,
permitindo expansões com a utilização de sensores ou motores de maior
tensão e velocidade. A implantação de um novo motor para que o Guincho
rotacione em 360º em volta do seu eixo seria uma das expansões possíveis
com alguns ajustes.
Investimos bastante tempo para a aquisição de alguns componentes
específicos, como a Protoboard em tamanho compatível com as dimensões do
Guincho. No entanto no âmbito dos requisitos da disciplina o objetivo foi
alcançado pelo grupo com a utilização de motores e sensores.
22
5 - Referências Bibliográficas
ARDUINO, 2013. Disponível em: <http://www.arduino.cc/> Acesso em 30 ago.
2013.
FREEDUINO, 2013. Disponível em: <http://www.freeduino.org/index.html>
Acesso em 30 ago. 2013.
ANTUNES, F. L. M. Motores elétricos de corrente contínua e universal .
2001. Disponível 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. Disponível em:
<http://www.mecatrons.xpg.com.br/Artigos/ArtigoVII/artigoVII.html>. Acesso
em: 01 set. 2013.
BRAGA, C. N. Conheça as Pontes H . 2013. Disponível 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. Disponível 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. Disponível em:
<http://pdf.datasheetcatalog.com/datasheet/stmicroelectronics/1330.pdf>.
Acesso em 02 set. 2013.
PROCESSING, 2013. Disponível em: <http://processing.org/>. Acesso em: 12
set. 2013.
23
DANTAS, L. Sensores digitais – Óticos e ultra sônicos . 2010. Disponível
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. Disponível em:
<http://www.adobe.com/br/products/photoshop.html>. Acesso em 12 set. 2013.
POLITRONIC, PHCT202 Datasheet . 1999. Disponível em:
<http://politronic.com.br/especs/cha/PHCTX0X.pdf>. Acesso em: 03 out. 2013.
APÊNDICE A - Orçamento 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.
24
APÊNDICE B – Código do programa do Arduino
Abaixo, temos o código Firmata que é gravado no Arduino, permitindo assim a comunicação 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(); } }
25
APÊNDICE C – Código do programa na plataforma Proce ssing 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 rotação definido como de entrada. arduino.pinMode(chaveMudaSentRot,Arduino.INPUT); //Pinos do motor e de ativação do L293D definidos como de saída. arduino.pinMode(motorCCEnt1,Arduino.OUTPUT); arduino.pinMode(motorCCEnt2,Arduino.OUTPUT); arduino.pinMode(controleL293D,Arduino.OUTPUT); arduino.pinMode(ledSensor,Arduino.INPUT); }
26
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); } }
27
//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); }
28
} //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);
29
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);
30
}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){ //Botão 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;
31
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;
32
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; }
33
} //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;
34
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;
35
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);
36
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 distância."); }else{ if(!selectAbaixo && !selectAcima){ JOptionPane.showMessageDialog(null,"Selecione o sentido."); }else{ motorLigado = true; barraProgresso = true; //Controlando o sentido de rotação 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); }
37
//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; }
38
APÊNDICE D – Reuniões (APS)
Segue registro dos encontros do grupo desde inicio das aulas, solicitado
pelos professores como APS, até hoje presente dia da entrega da monografia.
Reunião na UTFPR 12/06/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Estudo para definição do projeto que seria abordado
pela equipe. Foi definido o projeto do Guinho.
Tópico pendente: Início do projeto.
Reunião na UTFPR 13/06/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópicos abordados: Início da programação do Arduino, definição do uso
de uma Ponte H e escolha do motor.
Tópico pendente: Construção da Ponte H.
Reunião na UTFPR 18/06/2013
Integrantes: Bruno e Renan
Tópico Abordado: Construção da Ponte H.
Tópico concluído: Ponte H construída.
Reunião na UTFPR 26/06/2013
Integrantes: Bruno, Eucyelle e Renan.
39
Tópico abordado: Início da construção da estrutura.
Encontro na Rua 24 de Maio 03/07/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópicos abordados: Compra dos materiais e alguns componentes
faltantes.
Reunião pela Internet 07/07/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Discussão de qual seria o professor orientador.
Tópico concluído: Definição do Professor orientador: Valfredo Pilla
Junior.
Reunião na UTFPR 10/07/2013
Integrantes: Bruno, Eucyelle e Renan.·.
Tópico abordado: Conversa com os professores Mário e Hugo sobre
possível sensor a ser utilizado.
Tópico concluído: Definição de um sensor ótico.
Encontro Rua 24 de Maio 11/07/2013
Integrantes: Bruno e Renan.
Tópico abordado: Compra do sensor ótico.
40
Reunião pela Internet 12/07/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Divisão dos custos do projeto.
Reunião na casa do Renan 18/07/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópicos abordados: Termino da comunicação Arduino / Motor e início da
programação do Software.
Reunião casa do Renan 22/07/2013
Integrantes: Eucyelle e Renan.
Tópico abordado: Testes de comunicação Ponte H com o motor.
Tópico concluído: Funcionamento correto da Ponte H com Motor
Reunião na UTFPR 31/07/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Comunicação entre o Arduino e o microcomputador.
Reunião na casa da Eucyelle 02/08/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Trabalho na construção da estrutura.
Reunião pela Internet 04/08/2013
41
Integrantes: Bruno e Renan.
Tópico abordado: Dúvidas na alimentação da Ponte H.
Reunião na UTFPR 07/08/2013
Integrantes: Eucyelle e Renan.
Tópico abordado: Estudo de sensores.
Reunião na UTFPR 14/08/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Início dos testes com sensores.
Reunião na casa do Bruno 22/08/2013
Integrantes: Bruno e Renan
Tópico abordado: Desenvolvimento da estrutura do Guincho.
Reunião na UTFPR 28/08/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópicos abordados: Comunicação do Arduino com o sensor, e
desenvolvimento do Software.
Reunião na casa da Eucyelle 30/08/2013
Integrantes: Bruno e Eucyelle.
42
Tópico abordado: Desenvolvimento do Software.
Reunião na UTFPR 04/09/2013
Integrantes: Bruno e Renan.
Tópico abordado: Montagem do circuito na nova Protoboard.
Reunião na UTFPR 11/09/2013
Integrantes: Bruno e Renan.
Tópico abordado: Estudo de comunicação do sensor com o motor.
Reunião na UTFPR 13/09/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Elaboração da monografia.
Reunião na Internet 17/09/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Monografia.
Reunião na Internet 03/10/2013
Integrantes: Bruno, Eucyelle e Renan.
Tópico abordado: Atualização Monografia.