tcc - esteira para contagem de caixas via bluetooth
TRANSCRIPT
IFMA – INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLÓGIA DO MARANHÃO DESU – DIRETORIA DE ENSINO SUPERIOR
DEE – DEPARTAMENTO DE ELETRO-ELETRÔNICA CURSO DE ENGENHARIA ELÉTRICA INDUSTRIAL
ÁLVARO METON SOUSA PERDIGÃO
ESTEIRA PARA CONTAGEM DE CAIXAS VIA BLUETOOTH
SÃO LUÍS - MA 2012
ÁLVARO METON SOUSA PERDIGÃO
ESTEIRA PARA CONTAGEM DE CAIXAS VIA BLUETOOTH Trabalho de Conclusão de Curso apresentado para obtenção do grau de Engenheiro Eletricista pelo Instituo Federal de Educação, Ciência e Tecnologia do Maranhão.
SÃO LUÍS - MA 2012
ÁLVARO METON SOUSA PERDIGÃO
ESTEIRA PARA CONTAGEM DE CAIXAS VIA BLUETOOTH
Trabalho de Conclusão de Curso submetido ao corpo docente do IFMA –
Instituto Federal de Educação, Ciência e Tecnologia do Maranhão, como parte dos
requisitos necessários à obtenção do grau de Bacharel em Engenharia Elétrica
Industrial.
Data da aprovação: _____ / ______ / ______________
Nota: ___________
Aprovada por:
____________________________________
Prof. Claúdio Leão
____________________________________
Prof. Evandro Gomes
____________________________________
Prof. Eliude Trovão
SÃO LUÍS - MA 2012
Dedico este trabalho de conclusão de
curso a minha avó e mãe, Izabel Santana
Perdigão e a minha segunda avó e
também mãe Benedita Maria Marinho
AGRADECIMENTOS
Agradeço ao meu Tio e Padrinho, Airton Santana Perdigão, que sempre me
deu todo o suporte para a minha educação e foi a minha inspiração.
Agradeço a todos os meus tios, Ana Tereza Santana Perdigão, Maria das
Graças Barros, Alvanir Santana Perdigão e Álvaro Ribeiro Perdigão Neto, que
sempre foram exemplos dos ensinamentos da minha avó de que a educação e o
respeito são as coisas mais importante na vida uma pessoa.
Agradeço aos meus pais, Adilson Santana Perdigão e Inácia Madalena Bógea
Sousa Perdigão, pela força e o apoio na escolha da minha carreira.
Agradeço a minha namorada, Raissy Oliveira e Costa, pela compreensão nas
vésperas das provas, pelo apoio depois das provas e por me levar pra sair nos
momentos que eram preciso.
Agradeço a todos os meus colegas do curso, que desde o começo sempre
todos se ajudaram para se chegar até aqui.
Resumo
Este trabalho tem como objetivo reproduzir em escala reduzida o processo de
automação da contagem de caixas em uma esteira de uma linha produção,
identificando o tamanho das caixas e armazenando em um banco de dados o total
de caixas e a quantidade de cada tipo de caixa, utilizando apenas um WiiRemote,
controle do console Wii da Nintendo, e linguagem orientada a objeto. No decorrer do
trabalho serão mostrados os sensores e atuadores do WiiRemote que foram
utilizados, todo o código escrito em JScript (uma derivação do JavaScript) para fazer
a interpretação das informações enviadas via Bluetooth do controle para o
computador, e o driver desenvolvido para realizar a comunicação do controle com o
motor de tração da esteira. Além dos conceitos de Programação e Eletrônica
envolvidos no controle, será mostrado também o processo de confecção da esteira
transportadora que necessitou de conceitos da Mecânica, o que torna este trabalho
completamente interdisciplinar.
Palavras-Chave: Esteira, Contagem, Orientado a objeto, WiiMote, JScript, Banco de
dados
Abstract
This work aims to reproduce in a reduced scale an automation of the process
of counting boxes on a treadmill of a line production, identifying the size of the boxes
and stored in a database the total of boxes and how much boxes of each size, using
only one WiiRemote, control of Nintendo Wii console, and object-oriented language.
In the course of the work will be shown all the sensors and actuators WiiRemote that
were used and all the code written in JScript (a derivation of JavaScript) to do the
interpretation of the information sent via Bluetooth for control to the computer.
Beyond the concepts of Programming and Eletronics envolved in the control, Will be
show too how the treadmill was made, and the Mechanics concepts envolveds, what
makes this job quite interdisciplinary.
Keywords: Treadmill, Count, Object-oriented, WiiMote, Jscipt, Database
Sumário
1. INTRODUÇÃO .................................................................................................... 12
2. VISÃO GERAL DO PROCESSO ........................................................................ 18
2.1. Comunicação .................................................................................................. 18
2.2. Acionamento ................................................................................................... 18
2.3. Leitura ............................................................................................................. 19
2.4. Classificação ................................................................................................... 20
2.5. Armazenamento .............................................................................................. 20
3. CONFECCÇÃO DA ESTEIRA ............................................................................... 21
4. CONEXÃO DO CONTROLE COM O PC .............................................................. 26
5. SISTEMA DE ACIONAMENTO ............................................................................. 29
6. SISTEMA DE LEITURA ......................................................................................... 33
7. SISTEMA DE CLASSIFICAÇÃO E ARMAZENAMENTO ...................................... 38
8. INTERFACE .......................................................................................................... 49
CONCLUSÃO ............................................................................................................ 53
REFERÊNCIA BIBLIOGRÁFICA ............................................................................... 54
ANEXOS ................................................................................................................... 55
1. Datasheat do tranistor BD135 ............................................................................ 55
2. Datasheet do Opto-acoplador 4N25 ................................................................... 59
3. Script - principal ................................................................................................ 65
4. Script – LigaDesliga ........................................................................................... 70
5. Script - InterfaceEsteira ...................................................................................... 71
6. Fotos da Esteira ................................................................................................. 72
FIGURAS
Figura 1 – Linha de produção nos anos 30 ............................................................... 12
Figura 2 – Linha de produção automatizada ............................................................. 13
Figura 3 - Controle do Atari ....................................................................................... 14
Figura 4 – WiiMote do Nintendo Wii .......................................................................... 15
Figura 5 - PlayStation Move ...................................................................................... 15
Figura 6 - Kinect ........................................................................................................ 16
Figura 7 - Visão Geral ............................................................................................... 18
Figura 8 – Fluxograma do processo .......................................................................... 19
Figura 9 – Diagrama de Blocos das trocas de informação ........................................ 20
Figura 10 – Dimensões da esteira ............................................................................. 22
Figura 11 – Motor CC ................................................................................................ 23
Figura 12 – Redução ................................................................................................. 23
Figura 13 – Carregador de celular ............................................................................. 23
Figura 14 – Sistema de tração direta ........................................................................ 24
Figura 15 – Sistema de correia ................................................................................. 25
Figura 16 - Esteira ..................................................................................................... 25
Figura 17 – Vista Inferior da Placa do WiiMote ......................................................... 26
Figura 18 – Encontrando dispositivos ....................................................................... 27
Figura 19 – Serviço disponível .................................................................................. 27
Figura 20 – Solicitação de serviço ............................................................................. 28
Figura 21 – Conexão estabelecida ............................................................................ 28
Figura 22 – GlovePIE – Código InterfaceEsteira ....................................................... 29
Figura 23 – Circuito 1 de interface WiiRemote – Motor Esteira ................................. 31
Figura 24 – Circuito 2 de interface WiiRemote – Motor Esteira ................................. 32
Figura 25 – Circuito de acionamento ......................................................................... 32
Figura 26 – SensorBar .............................................................................................. 33
Figura 27 – Circuito de alimentação dos led’s ........................................................... 33
Figura 28 – Dimensão das caixas e led’s .................................................................. 34
Figura 29 – Imagem capturada por câmera de celular .............................................. 34
Figura 30 – Leitura de caixa pequena ....................................................................... 35
Figura 31 – Leitura de caixa grande .......................................................................... 36
Figura 32 – Unity 3D.................................................................................................. 38
Figura 33 – Scripts criados ........................................................................................ 39
Figura 34 – Ícone do Relatório gerado ...................................................................... 47
Figura 35 – Visualização em Bloco de Notas ............................................................ 47
Figura 36 – Visualização no Microsoft Excel ............................................................. 48
Figura 37 – Interface ................................................................................................. 49
Figura 38 – Posição Desligado .................................................................................. 50
Figura 39 – Posição Ligado ....................................................................................... 50
Figura 40 – Caixa Pequena classificada ................................................................... 50
Figura 41 – Solicitação de Nova Contagem .............................................................. 51
Figura 42 – Contagem Zerada .................................................................................. 52
Figura 43 – Salvar Contagem .................................................................................... 52
Figura 44 – Aviso de salvamento do arquivo ............................................................. 52
TABELAS
Tabela 1 – Tipos de esteiras ..................................................................................... 21
Tabela 2 – Especificações da carga transportada ..................................................... 22
Tabela 3 – Correntes de acionamento ...................................................................... 31
Tabela 4 – Padrão de leitura das caixas grandes ..................................................... 36
Tabela 5 – Padrão de leitura das caixas pequenas ................................................... 36
12
1. INTRODUÇÃO
A utilização de esteiras em processos produtivos iniciou-se quando as
produções adotaram o método de linha, primeiramente evidenciado no Fordismo
no início da década de 20, quando os carros eram colocados em uma esteira
onde passavam pelos postos de trabalho em que cada trabalhador realizava
apenas uma especifica tarefa repetidamente.
Esse método aumento consideravelmente a quantidade de carros produzidos,
Ford chegou a dizer que metade dos carros do mundo seriam Ford T, o modelo
produzido na fábrica. Porém devido as atividades simples e repetitivas realizadas
pelos empregados eram pagos pequenos salários e subutilizada uma mão-de-
obra com uma enorme capacidade que é a do ser humano, que foi satirizado no
filme de Charlie Chaplin, Tempos Modernos (EUA, 1936).
Figura 1 – Linha de produção nos anos 30
Nos dias de hoje é impossível imaginar um processo que não utilize esteiras e
uma produção em linha se quiser ter alta produtividade, porém essa subutilização
da mão-de-obra humana foi diminuída com o advento da Automação Industrial,
sendo utilizada a mão-de-obra humana apenas em processo muito complexos
que máquinas ainda não são capazes de realizar. Ao contrário do que muitos
13
acham a Automação não veio para tirar empregos e sim melhor aplicar o a
capacidade do ser humano.
Atualmente uma esteira automatizada tem a capacidade de classificar,
etiquetar, envasar, cortar e até apertar os parafusos em uma linha de produção,
através de sensores e atuadores que são capazes de enxergar, empurrar,
detectar metais, pesar e etc.
Figura 2 – Linha de produção automatizada
Junto com a evolução dos processos produtivos outra industria que também
evoluiu muito foi a de Games, principalmente os consoles dos vídeo-games. Os
primeiros jogos interativos datam do final dos anos 1940 e inicio dos anos 1950,
não muito distante da utilização da linha de produção.
Um dos exemplos de jogos dessa época é o Tennis for Two, de 1958,
desenvolvido no Brookhaven National Laboratory, pelo cientista William
Higinbotham onde o console na verdade era um osciloscópio e os comandos
eram dados por potenciômetros, que controlavam barras nas laterais da tela
rebatendo um pontinho verde que se deslocava de um lado para o outro como
uma bola de tênis.
Com o passar do tempo muitas empresas de Games surgiram, como
Nintendo, Sony, Sega e mesmo a Microsoft que é uma empresa de software
também tem participação na indústria dos Games. Atualmente todas disputam
não apenas por jogos com gráficos mais impressionantes ou consoles mais
potentes como também por novos métodos do usuário interagir com o
14
jogopassando do simples apertar de botões para uma interação com os outros
sentidos.
Essa mudança começou a acontecer em dezembro de 2006, quando a Nintendo
revolucionou esse jeito do usuário interagir com console com o lançamento do
vídeo-game Nintendo Wii, que possui um controle chamado WiiMote, o controle
veio equipado com uma câmera infravermelha na parte frontal com uma
resolução de 1024x768 pixels e freqüência de atualização de 100 Hz, capaz de
detectar até quatro pontos infravermelhos e se orientar no espaço por eles.
Figura 3 - Controle do Atari
Outro recurso do controle foram os acelerômetros, sensores capazes de detectar
a intensidade e o sentido de forças aplicadas, com esses sensores o controle se
tornou capaz de detectar movimentos, como pular, dar um soco, ou até mesmo
rebater uma bola de tênis, muito mais interativo do que simplesmente girar um
potenciômetro. E o melhor do controle, que é a ausência de fios, que possibilita
toda essa mobilidade, devido a comunicação do controle se dar via Bluetooth
com o console.
Ainda no controle pode ser encontrado um auto-falante para simular sons
como o de batidas de bolas ou pequenos alarmes e também um sistema de
vibração, chamado RumblePack, desenvolvido pela própria Nintendo ainda no
console anterior o Nintendo 64, só que anteriormente necessitava-se acoplar o
sistema ao controle com uma alimentação independente, muito incomodo para o
usuário.
15
Figura 4 – WiiMote do Nintendo Wii
Após o enorme sucesso do WiiMote as outras empresas da área de games
resolveram investir nessa interatividade, que conseguiu inserir um público que
antes não conseguia vencer a barreira da quantidade de botões em um controle.
Em 2010 Sony lançou o PlayStation Move onde uma câmera infravermelha
posicionada próximo ao console capta a movimentação do controle que emite
uma luz infravermelha, dotado também de acelerômetros é capaz de reconhecer
gestos.
Figura 5 - PlayStation Move
16
Mas no final de 2010 houve a maior revolução dentre todos os controles, foi o
lançamento do Kinect, da Microsoft, um dispositivo que acompanha o vídeo-
game Xbox 360. O Kinect revolucionou por que na verdade eliminou o controle,
posicionado próximo ao console, o dispositivo possui uma câmera infravermelha
que capta a projeção de raios infravermelhos em forma de linhas emitidas pelo
próprio dispositivo, que ao tocarem em qualquer objeto são deformadas, de
acordo com a deformação das linhas o console interpreta as informações e
delimita a silueta do jogador reconhecendo todos os seus movimentos.
Figura 6 - Kinect
É baseada nessas duas evoluções em paralelo, a Automação Industrial e a
evolução dos Consoles de Vídeo-Games que se baseia esse trabalho, com a
necessidade de melhor um processo produtivo e com a disponibilidade de todos
esses recursos tecnológicos nos controles atuais que o desafio foi aceito e ao
decorrer deste trabalho será mostrada uma aplicação de contagem de caixas de
acordo com o seu tamanho em uma reprodução de um processo produtivo.
No Capítulo 2 iremos ter uma visão geral do processo que pode ser dividido
Acionamento, Leitura e Classificação & Armazenamento.
O Capítulo 3 mostrará todos os componentes utilizados na confecção da
esteira, especificando os componentes, materiais e dimensões.
No Capítulo 4 será exposto o processo de estabelecimento da comunicação
entre o WiiMote e computador utilizado passo-a-passo, especificando todos os
softwares necessários.
O Acionamento será abordado no Capítulo 5, mostrando tanto o circuito de
interface do controle com o motor quanto a parte do código que envia o sinal
para do computador para o controle.
17
No Capítulo 6 será explicado como o ocorre o processo de Leitura do
tamanho das caixas, mostrando o padrão das informações obtidas pelo sensor
infravermelho que servirão para o processo de Classificação.
O Capítulo 7 mostrará a parte do código que faz a Contagem de acordo com
as informações vindas da Leitura e Armazena em um arquivo “TXT”, e também a
interface criada para a visualização das informações pelo usuário.
18
2. VISÃO GERAL DO PROCESSO
O processo de contagem de caixas pode ser dividido em cinco etapas:
Comunicação, Acionamento, Leitura, Classificação e Armazenamento.
Figura 7 - Visão Geral
2.1 Comunicação
É a função básica de todo o processo, o acionamento depende da
comunicação para o WiiRemote receber o comando do computador, e a leitura depende da comunicação para o WiiRemote enviar os dados obtidos para o
computador poder realizar a classificação da caixa e conseqüentemente o
armazenamento. Essa comunicação se da através do dispositivo Bluetooth
presente no WiiRemote, no terceiro capítulo será explicado todo o processo para o
estabelecimento dessa comunicação.
2.2 Acionamento
Esta parte do processo consiste em acionar o motor de tração da esteira para
o deslocamento das caixas em direção a coluna de led’s infravermelhos onde será
efetuada a leitura, como dito anteriormente o comando virá do computador através
do WiiRemote, para a realização desse processo foi desenvolvido um circuito para
fazer a interface do controle para o motor, utilizando um opto-acoplador para isolar o
controle e um transistor de potência para suprir a necessidade de corrente do motor.
19
Figura 8 – Fluxograma do processo
2.3. Leitura
Para o processo de leitura será utilizado outro recurso do WiiRemote, que é a
câmera infravermelha localizada na frente do controle, que consegue visualizar até 4
pontos infravermelhos retornando Verdadeiro ou Falso de acordo com a visualização
ou impossibilidade de visualizar cada ponto, enviando essas informações para o
computador.
20
2.4 Classificação
Todos os verdadeiros e falsos enviados pela visualização dos led’s serão
tratados pelo software de comunicação com o controle, após o tratamento o software
irá emular comandos que serão recebidos pelo programa principal onde de acordo
com as entradas será incrementada a contagem de cada tipo de caixas.
2.5 Armazenamento
A qualquer momento o usuário irá poder gerar um relatório com a data, hora,
quantidade de cada tipo de caixa e o total de caixas. Ao solicitar a geração do
relatório será criado um arquivo “TXT”, com uma formatação que possibilitará sua
abertura em planilhas eletrônicas com todos os dados separados em células
podendo ser gerados gráficos mais detalhados da produção.
Figura 9 – Diagrama de Blocos das trocas de informação
21
3. CONFECCÇÃO DA ESTEIRA
O projeto de uma esteira inicia-se com a determinação da carga a ser
transportada, tendo como parâmetros: tamanho (grão ou objeto), peso e seu
material, que irá influenciar na aderência (papelão, plástico ou vidro), o que pode
influenciar inclusive nos sensores a serem utilizados. De acordo com a carga deve
ser escolhido o tipo de esteira mais indicado.
Esteira de Caneca
Destinada a elevação de cargas, com
pás de sustentação para a carga,
Esteira de Roletes
Sem controle de velocidade e distância
entre as cargas, o movimento se da por
acumulo.
Esteira Simples de Carga
A carga se apóia diretamente na correia,
mantendo a distância de acordo com a
freqüência de colocação na esteira.
Tabela 1 – Tipos de esteiras
22
Para o projeto de contagem a carga apresentava as seguintes características:
2 tipos de caixas:
Formato cúbico
L = 5 cm e l = 3 cm
Material: Papelão
Necessitavam manter uma distância
constante uma das outras
Tabela 2 – Especificações da carga transportada
O que levou a escolha de uma esteira do tipo simples, horizontal, baixa
velocidade e sem a necessidade de conexões.
Material Utilizado
Para base da esteira foi confeccionada uma estrutura com perfis de alumínio,
fixadas com arrebites nas extremidades, com um espaço de deslocamento da carga
suficiente para ser instalado o um sistema de tração e mais uma área para a leitura
do sensor.
Figura 10 – Dimensões da esteira
23
Para a tração foi escolhido um Motor Elétrico CC retirado de carro de controle
remoto, juntamente com a redução. O Motor originalmente no carro era alimentado
por uma tensão de 4,5V (3 pilhas AA) tendo em média 800 rpm com carga máxima,
e demandando uma corrente de 200mA.
Figura 11 – Motor CC
Figura 12 – Redução
Como a velocidade necessitava ser constante por um longo período de tempo,
para não haver variações na leitura, seria inviável a utilização de pilhas para a
alimentação do motor, pois iria haver a variação da velocidade de acordo com o
descarregamento natural das pilhas. Então foi definida como nova alimentação um
carregador de celular, que tem saída de 5,7 V, próximo da tensão nominal de
trabalho do motor, e é capaz de fornecer uma corrente de até 800 mA, suprindo
completamente as necessidades do motor.
Figura 13 – Carregador de celular
24
O material da esteira transportadora foi um grande desafio na confecção da
esteira, primeiramente foi testado um elástico de 80mm de largura, porém a relação
Tensão X Aderência não foi satisfatória, para se obter uma aderência suficiente
entre o elástico e o eixo do motor para se conseguir fazer a transmissão da tração,
era necessário uma tensão muito grande no elástico, o que acabava
sobrecarregando o motor DC que não dava nem a partida.
Para a solução do problema foram tomadas duas medidas, primeiro o
aumento do diâmetro do eixo do motor para aumentar a área de contato com a
esteira e conseqüentemente aumentar a tração transmitida, fixando um cano de
PVC de 15mm junto ao eixo e a troca do material da esteira, que foi trocado de
elástico por um material plástico, que precisa de menos tensão para obter o mesmo
nível de aderência.
Figura 14 – Sistema de tração direta
No primeiro teste com o eixo de tração ligado diretamente na redução a
velocidade de deslocamento da caixa não foi satisfatória, pois a velocidade da
esteira estava muito alta, impossibilitando tanto a estabilidade da caixa sobre a
esteira quanto a leitura no instante da passagem da caixa pelo sensor.
Para reduzir ainda mais a velocidade da esteira seria necessário modificar o
tamanho das engrenagens da redução, porém como não dispúnhamos de outras
engrenagens foi decido modificar o sistema de transmissão de tração.
Foi acoplada uma roldana de 5 cm de diâmetro ao eixo de tração e
confeccionada uma correia com fita isolante para transmitir a tração de um eixo
secundário para a roldana instalada que por ter um diâmetro muito maior do que o
25
eixo secundário diminuirá consideravelmente o número de rotações por minuto,
conseqüentemente diminuindo a velocidade da esteira.
Com a alteração feita foi obtida uma velocidade satisfatória, que possibilitou a
estabilidade da caixa sobre a esteira e tempo suficiente de passagem no sensor
para a leitura correta.
Figura 15 – Sistema de correia
Para fixação da esteira e de todos os componentes foi cortada uma folha de
compensado com espessura de 1’’ nas dimensões de 20x30cm. Todos os outros
sistemas (Leitura e Acionamento) terão seus componentes especificados em seus
respectivos capítulos, mas podem serem vistos todos já instalados na esteira na
figura abaixo:
Figura 16 - Esteira
26
4. CONEXÃO DO CONTROLE COM O PC Este pode ser considerado o ponto vital de todo o processo, a conexão do
WiiMote com o computador, pois sem essa comunicação é impossível movimentar
as caixas, ler os dados do sensor e enviar as informações para o computador, para
enfim ser visualizado o tamanho da caixa. A comunicação é feita através de uma conexão Bluetooth Classe 2, que
permite uma comunicação de até 10 metros que consome até 2,5 mW de potência, o
protocolo usado é o Bluetooth HID (Humam Interface Device), que dá suporte a
comunicações de mouse, joystick e teclado, sendo assim, o WiiMote será visto pelo
computados dessa forma, como algum desses periféricos.
Figura 17 – Vista Inferior da Placa do WiiMote
Para esta estabelecer a conexão, além do hardware instalado no computador
é necessário a instalação do software BlueSoleil, neste projeto será utilizada a
versão 8.0.338.0 apenas de demonstração que permite a transferência de até 2 Mb
de dados, mais do que o suficiente para o projeto, pois devido o protocolo utilizado
os pacotes de dados são mínimos.
27
O procedimento de conexão é bastante simples, o primeiro passo é iniciar o
BlueSoleil e solicitar uma busca de dispositivos, clicando duas vezes no círculo
central da interface do programa. Enquanto estiver sendo realizada a busca
mantenha os botões 1 e 2 do WiiMote pressionados por pelo menos 5 segundos, ao
final da busca serão exibidos todos os dispositivos que estiverem com o Bluetooth
ligado ao seu redor, o controle será exibido como um joystick.
Figura 18 – Encontrando dispositivos
Após encontrado, serão dados dois clicks no ícone do joystick para serem
exibidos os serviços disponíveis para aquele dispositivo. O ícone do mouse na parte
superior do programa irá ser realçado, indicando que aquele serviço está disponível,
um dispositivo de interface humana.
Figura 19 – Serviço disponível
28
O próximo passo é solicitar a ligação, com um click com o botão direito em
cima do dispositivo serão mostradas as opções para aquele dispositivo, a opção a
ser escolhida é Ligar Dispositivo de interface humana Bluetooth.
Figura 20 – Solicitação de serviço
Caso o procedimento ocorra corretamente será exibida uma linha tracejada
verde entre o joystick e o círculo central.
Figura 21 – Conexão estabelecida
29
5. SISTEMA DE ACIONAMENTO Após estabelecida a comunicação, o próximo passo é iniciar o deslocamento
das caixas em direção ao sensor, essa tarefa se da com o acionamento do motor da
esteira, que de acordo com o diagrama de blocos do Cap. 2, o seu sinal de comando
vem do WiiRemote, do seu sistema de vibração, o Rumble Pack.
Neste projeto o acionamento é feito remotamente pelo computador de
controle através das setas para cima e para baixo do teclado. Mesmo o controle já
conectado com o computador esses comandos ainda não são enviados para o
controle. Para interpretar esses comandos será utilizado mais um software, que com
uma linguagem própria e não-linear, utiliza a conexão já estabelecida e faz a
interface para enviar as instruções para o controle.
O software utilizado para essa tarefa será o GlovePIE, desenvolvido por Carl
Kenner e distribuído gratuitamente, esse programa é capaz de emular diversos
periféricos como mouse, mouse 3D e teclado através de controles de vídeo-games,
como o WiiMote, Xbox360 Controller, Playstation 3 BDRemote.
Figura 22 – GlovePIE – Código InterfaceEsteira
Todo o código para envio e recebimento de informações do controle está
mostrado na Fig. 15, tanto da parte de acionamento do motor quanto de leitura do
tamanho das caixas, que será comentado no próximo capítulo.
30
// Acioamento if (Keyboard.Up) var.ativado = True if (Keyboard.Down) var.ativado = False WiiMote.Rumble = var.ativado
(1)
O código é bem simples e direto, não é necessário nem a declaração do tipo
da variável, e nem uma atribuição de bibliotecas no início do programa, de acordo
com o acontecimento do evento a variável é criada e atribuído um valor a ela.
Como pode ser visto na parte (1), a seção de acionamento possui duas
condições, quando pressionada a tecla para cima do teclado (Keyboard.Up), é
atribuída uma condição verdadeira a variável ativado, a função WiiMote.Rumble que
recebe como parâmetro a variável ativado, enviará um sinal para o controle para
ativar o seu motor interno, criando um efeito de vibração enquanto a variável for
verdadeira, pressionando a tecla para baixo (Keyboard.Down) do teclado, será
atribuída uma condição falsa a variável ativado, desabilitando o motor interno do
controle.
Foram realizadas medições nos terminais do motor durante o seu
acionamento encontrado um valor de 3.2 V, abaixo da sua tensão de trabalho
nominal no carro de controle remoto, além disso seria inviável a alimentação do
motor de tração da esteira vir do WiiRemote, pois o consumo do motor iria diminuir a
vida útil da das pilhas do controle, e conseqüentemente prejudicar o sistema de
leitura.
Devido a impossibilidade de alimentação direta do WiiRemote para o motor de
tração, foi desenvolvido um driver para fazer a interface do comando entre o controle
e o motor de tração. Como parâmetros para desenvolvimento do driver tínhamos
que: elevar a tensão em cima dos terminais do motor para um valor igual ou maior a
4,5 V e alimentar o motor e com uma fonte independente do controle. Características
que poderiam ser completamente atendidas com apenas um transistor funcionando
como chave, recebendo o comando do controle na base e alimentando o motor pelo
31
carregador de celular. O transistor que mais se adequou as necessidades do projeto
foi o BD135 (datasheet em anexo), foi montado então o seguinte circuito:
Figura 23 – Circuito 1 de interface WiiRemote – Motor Esteira
O circuito cumpriu o desejado, que era realizar o acionamento do motor da
esteira, porém durante os testes, ao acionar o motor, o sistema de leitura, que será
explicado no próximo capítulo, travava a câmera infravermelha, o led’s
infravermelhos deixavam de ser visualizados. Foram então realizadas medições da
corrente demandada para o acionamento, individualmente, apenas com o Rumble
Pack, e depois com o driver acoplado, foram coletados os seguintes dados:
IRB – Corrente do Rumble Pack 8mA
IDR – Corrente do Driver 20mA
Tabela 3 – Correntes de acionamento
Foi constatado que ao acoplar o driver de acionamento a corrente demandada
pelo circuito do Rumble Pack ao controle mais que dobrava, o que causava uma
sobre carga para o sistema do controle travando a câmera infravermelha, sendo
assim tornou-se necessário diminuir a corrente demanda pelo driver.
Como solução foi desenvolvido um segundo driver, onde além de
simplesmente diminuir a corrente demanda pelo driver, foi isolado o controle do
transistor, através de um opto-acoplador, o 4N25 (datasheet em anexo). Ao ser
testado, assim como o primeiro circuito, o acionamento ocorreu perfeitamente,
porém desta vez, sem o travamento da câmera, ao realizar novamente as medições
32
de corrente demanda, foi constato que houve uma queda significativa, a corrente
demandada pelo driver caiu para menos de 6mA, dentro do seu limite de
funcionamento normal apenas com o Rumble Pack.
Figura 24 – Circuito 2 de interface WiiRemote – Motor Esteira
Figura 25 – Circuito de acionamento
33
6. SISTEMA DE LEITURA
O sistema de leitura foi baseado na funcionalidade básica do console Wii, que
é o reconhecimento de pontos infravermelhos pelo controle WiiMote para servir de
referência para o deslocamento do mouse na tela e conseqüentemente a navegação
pelos menus. Esses pontos infravermelhos são Led’s Infravermelhos nas
extremidades de uma barra alimentada pelo console, chamada de SensorBar.
Figura 26 – SensorBar
Os leds que servirão de referência para o controle foram fixados em um palito
de picolé com o espaçamento definido de acordo com o tamanho das caixas a
serem classificadas. Para alimentação dos leds também foi o carregador de celular
com a tensão de 5,7 V, só que para os leds foi utilizado um resistor de 120Ω para
limitar a corrente evitando a queima.
Figura 27 – Circuito de alimentação dos led’s
34
Figura 28 – Dimensão das caixas e led’s
A luz emitida pelos led é infra-vermelha, não visível a olho nú, mas com
qualquer câmera, inclusive de celular, podemos visualizar se realmente o circuito
está funcionando.
Figura 29 – Imagem capturada por câmera de celular
Como citado no capítulo anterior, o responsável por receber essas
informações no computador é o GlovePIE, na segunda parte do código são dados os
comandos de emulação, com uma sintaxe bem simples e direta, quando o segundo
led não estiver visível será pressionada a tecla “B” do teclado e quando o primeiro
35
led não estiver visível será pressionada a tecla “A” do teclado, resultando em uma
lógica inversa. Nesse caso as variáveis foram declaradas apenas para efeito de
visualização na interface do próprio software para confirmação da leitura.
// Leitura
var.A = !WiiMote.dot1vis
var.B = !WiiMote.dot2vis
A = (!WiiMote.dot2vis) && (!WiiMote.dot1vis)
B = (((!WiiMote.dot1vis)&&(WiiMote.dot2vis)) ||
((WiiMote.dot1vis)&&(!WiiMote.dot2vis)))
(2)
O controle não consegue distinguir qual dos dois leds vistos é o primeiro ou o
segundo, por default quando um led deixa de estar visível, automaticamente ele é
considerado como o segundo led, e quando o próximo led deixar de estar visível é
considerado o primeiro.
Figura 30 – Leitura de caixa pequena
36
Figura 31 – Leitura de caixa grande
Então quando for bloqueada a visualização de apenas um dos leds, (caso da
caixa pequena), será pressionada a tecla “B”. Quando os dois leds tiverem a
visualização bloqueada será pressionada a tecla “A”.
Como teste foi utilizado o Microsoft Word 2010 para verificar os padrões
criados pela emulação do teclado, obtendo-se o seguinte resultado:
Passagem de caixas grandes Baa Aba Abbbb Baaaaa Ab Aba Abaa Ab ABB Abbbbbbbbbbbbbbb Baaa Ab Abbb BA Baa Abbb Baa Baa Aba ABB Baa
Tabela 4 – Padrão de leitura das caixas grandes
Passagem de caixas pequenas B B B B B B B B B B B B B B B B B B
Tabela 5 – Padrão de leitura das caixas pequenas
37
Durante a passagem da caixa pelo sensor a emulação do teclado ocorre
várias vezes. Pode ser observado que na passagem da caixa pequena, onde é
bloqueada apenas a visão de um dos leds, o padrão são apenas teclas “B”, já na
passagem da caixa grande, onde os dois leds são bloqueados, apresentam-se dois
tipos de entrada, mas seguindo um padrão de aparecer sempre a tecla “A”, como
explicado anteriormente, a linguagem utilizada pelo GlovePIE é não linear, então o
programa executa as duas ações aleatoriamente, já que as duas estão acontecendo.
Tendo os dois padrões definidos o próximo passo é o tratamento dessas
informações de entrada para a classificação e armazenamento, que serão
detalhados no próximo capítulo.
38
7. SISTEMA DE CLASSIFICAÇÃO E ARMAZENAMENTO
De acordo com os padrões obtidos pela leitura do sensor, o objetivo agora é
tratar e fazer com que esses caracteres se transformem em informações e sejam
armazenados possibilitando a sua consulta futuramente.
Para essa atividade foi escolhido o software Unity 3D na versão 3.4.0f5, uma
Game Engine 3D, com suporte a várias linguagens de programação, como Boo
(variante do Python desenvolvida pelo brasileiro Rodrigo Barreto de Oliveira), JScript
(variante do JavaScript, da Microsoft) e C# (muitíssimo conhecida e também da
Microsoft). O método de trabalho com todas as linguagem é através de scripts que
são atribuídos a objetos em um espaço tridimensional, um jeito muito mais visual de
programar, o que facilita a estruturação da criação do aplicativo.
Outro fator muito importante é o suporte a parte gráfica para criação da
interface, que dispensa a necessidade do conhecimento de bibliotecas especificas, a
interface será apresentada no próximo capítulo. Neste capítulo serão abordados
apenas os códigos criados.
Figura 32 – Unity 3D
39
A linguagem escolhida como padrão para esse projeto foi o JScript, devido a
farta documentação encontrada na internet, por possuir todas as funções
necessárias e ter uma sintaxe de fácil assimilação.
Para esse projeto foi necessária a criação de apenas 3 scripts:
Figura 33 – Scripts criados
Script – LigaDesliga
Define a textura a ser utilizada em um dos principais botões da interface, a
alavanca de acionamento da esteira, dando idéia de animação. No início do script
são declaradas todas as variáveis a serem utilizadas, tanto booleanas quanto
texturas.
static var acionamento = false;
var lig : Texture;
var des : Texture;
(3)
As variáveis “lig” e “des” criam slots no objeto para o recebimento dos
arquivos de imagem que representarão o estado ligado e desligado da alavanca. Os
arquivos primeiramente precisam ser importados para dentro do Unity, simplesmente
sendo transferidos ou salvos dentro da pasta Assets dentro da pasta do projeto.
A variável “acionamento” do tipo booleana, será chamada pelo script leitor e
será a principal condição para liberação do processo de leitura e classificação, que
só poderá ocorrer quando “acionamento” for verdadeiro.
A principal função de todos os scripts é a função Update( ), o Unity trabalha
em um esquema de clico de frames, onde são executados todos os comandos
dentro da função a cada ciclo, a freqüência de ciclos é inversamente proporcional a
40
quantidade de elementos carregados na interface, para essa aplicação a taxa de
atualização está em torno de 107 frames/s.
function Update()
if (Input.GetKeyDown (KeyCode.UpArrow))
IO.acionamento = true;
renderer.material.mainTexture = des;
if (Input.GetKeyDown (KeyCode.DownArrow))
IO.acionamento = false;
renderer.material.mainTexture = lig;
(4)
As condições if(Input.GeyKeyDown(KeyCode.UpArrow)) e
if(Input.GeyKeyDown(KeyCode.UpArrow)) captam as entradas de teclado seta para
cima e seta para baixo, mesmos comandos citados anteriormente para o GlovePie,
que estará sendo executado por trás recebendo os mesmos comandos e atuando no
acionamento do motor.
Com o pressionamento da tecla de seta para cima a variável “acionamento” é
setada como verdadeira, o que habilitará o processo de contagem e classificação no
script leitor e aplica a textura “lig” ao objeto que contém o script IO. O procedimento
inverso acontece quando pressionada a tecla seta para baixo, sendo aplicada a
textura “des”.
Script – Principal
Este é o principal script de todo o aplicativo, responsável pelas tarefas de
receber as informações enviadas pelo GlovePIE, interpretar, definir o tamanho da
caixa e armazenar no banco de dados. O principio de funcionamento é bem simples,
ao iniciar a passagem de uma caixa, que o GlovePIE emular o pressionamento de
41
uma tecla, automaticamente a primeira tecla pressionada será armazenada em um
vetor e será iniciada uma contagem, dentro de um determinado espaço de tempo,
todas as teclas pressionadas também serão armazenas nesse mesmo vetor, ao final
do intervalo de tempo será feito uma varredura no vetor, de acordo com os padrões
obtidos nos testes de leitura, caso apareça algum caractere “A”, essa caixa será
classificada como grande, caso não apareça nenhum, será classificada como
pequena.
Especialmente nesse script será necessário a importação de duas bibliotecas
especificas do pacote Microsoft.Net Framework que não estão no Unity e são
responsáveis pela função da criação do arquivo “TXT”.
import System.IO;
import System;
(5)
Após a importação das bibliotecas teremos a declaração das variáveis:
var HAB = true;
var instante : float;
var lista2 = new Array ();
var ident : int;
static var data : String;
static var caixa_grande : int = 0;
static var caixa_pequena : int = 0;
static var total_de_caixas : int = 0;
(6)
A primeira variável, “HAB” , será uma variável auxiliar irá variar entre
“verdadeiro” e “falso”, habilitando novas entradas após a primeira leitura e
desabilitando no final da janela de leitura.
42
“Instante” receberá um valor em segundos, correspondente ao tempo
decorrido desde o início do programa até o instante do pressionamento da primeira
tecla emulada de cada caixa.
A variável “lista2” é um vetor que receberá em cada elemento as entradas
emuladas pelo GlovePIE (“A” e “B”), de acordo com a visualização dos led’s
infravermelhos.
“Ident” será apenas um identificador da presença de caracteres “A” no vetor,
para cada caractere “A” presente no vetor, a variável é incrementada, “ident” seja
maior do que zero, a caixa será classificada como grande.
“Data” receberá o dia e a hora no instante em que for dado o comando de
gravação no banco de dados, será do tipo string para ser adicionado tanto ao titulo
do arquivo “TXT” gerado quando ao próprio conteúdo do arquivo.
“Caixa_grande”, “caixa_pequena” e “total_de_caixas” serão as variáveis
incrementadas durante o processo de contagem. Como pode ser visto, algumas
variáveis foram declaradas simplesmente como var e outras como static var, isso
acontece por que na estrutura do JScript variáveis que necessitam ter seu valor lido
tanto dentro da função em que estão sendo incrementadas quanto em outras
funções, necessitam ser declaradas como static.
function Update ()
//Display das informações
GameObject.Find("caixa_grande_text").guiText.text=""+caixa_grande;
GameObject.Find("caixa_pequena_text").guiText.text=""+caixa_pequena;
(7)
Logo no início do script, na função Update ( ), que atualiza a cada ciclo, é
chamada a função GameObject.Find que busca o objeto com o nome passado como
parâmetro, atuando no texto que será exibido nesse objeto através da função
guiText.text, textos esses que serão as quantidades de caixas.
Em seguida inicia-se a principal parte do script, que é classificação das
caixas. A primeira condição para o processo iniciar é que a variável “acionamento”,
do script anterior, esteja na condição de verdadeira, ou seja, que a esteira esteja
ligada, caso contrário a leitura não é realizada.
43
//Processo de Classificação
if (LigaDesliga.acionamento == true)
(8)
Caso esta condição esteja satisfeita, será liberado o recebimento para as
entradas emuladas pelo GlovePIE de acordo com os led’s visualizados.
//Primeira leitura
if ( (Input.GetKeyDown ("a") || Input.GetKeyDown ("b")) &&
(HAB == true) )
instante = Time.time;
ident = 0;
if (Input.GetKeyDown ("a"))
lista2.Push ("a");
if (Input.GetKeyDown ("b"))
lista2.Push ("b");
HAB = false;
(9)
O programa ficará aguardando a primeira entrada, independente de ser o
caractere “A” ou “B”, e precisará que a variável “HAB” seja verdadeira. No momento
em que ocorrer a leitura, a variável “instante” receberá automaticamente o valor em
segundos referente ao tempo decorrido desde o início do programa até aquele
momento. A variável “ident” será zerada para a classificação não sofrer
interferências de classificações anteriores e será adicionado ao vetor o caractere
que for emulado pelo GlovePIE através da função Push, ao final da primeira leitura a
variável “HAB” é desabilitada para esse processo inicial não se repetir caso novas
emulações de teclas ocorram, protegendo a variável “instante” que irá definir o
tempo em que a janela de tempo para recebimento das emulações ficará em aberto.
44
//Leituras sequintes
if (HAB == false)
if (Input.GetKeyDown ("a"))
lista2.Push ("a");
if (Input.GetKeyDown ("b"))
lista2.Push ("b");
(10)
Ao ser desabilitada na primeira parte do código, a variável “HAB” estando no
estado falso, habilita o vetor para o recebimento de novos elementos, mas sem
alterar nenhuma outra variável.
//Classificação
if ((HAB == false) && (Time.time > instante + 3))
for (var n=0; n < lista2.length; n++)
if (lista2[n]=="a")
ident++;
if (ident > 0)
caixa_grande++;
if (ident == 0)
caixa_pequena++;
lista2.Clear();
HAB = true;
total_de_caixas = caixa_pequena+ caixa_grande;
(11)
45
No instante em que o tempo decorrido desde o início do programa seja maior
que o valor em segundos do instante da primeira leitura mais 3, ou seja, passados 3
segundos da abertura da janela de tempo para as entradas emuladas pelo
GlovePIE, será dado início ao processo de classificação.
Será iniciada a varredura do vetor “lista2”, independente de quantos
elementos tiverem sido adicionados ao vetor. Para cada caractere “A” encontrado no
vetor será incrementado de um a variável “ident”, ao final da varredura será feita
uma comparação da variável, e de acordo com o padrão de leitura das caixas, caso
tenha aparecido um caractere “A”, a caixa será classificada como grande,
incrementando a variável “caixa_grande”, caso não tenha nenhum caractere “A” no
vetor, a caixa será classificada como pequena, incrementando a variável
“caixa_pequena”. Ao final da classificação o vetor é limpado, com a função Clear( ),
e a janela para recebimento de uma nova leitura inicial é liberada novamente.
Outra atividade que está dentro da função Update ( ) é a de iniciar uma nova
contagem, zerando as variáveis que foram incrementadas “caixa_pequena”,
“caixa_grande” e “total_de_caixas” mediante o pressionamento da tecla “N”.
//Iniciar nova contagem
if (Input.GetKey(KeyCode.N))
leitor.caixa_grande = 0;
leitor.caixa_pequena = 0;
leitor.total_de_caixas = 0;
(12)
Por último temos a atividade de armazenamento dos dados, que será
realizada mediante o pressionamento da tecla “S”.
//Salvar a contagem
if (Input.GetKey(KeyCode.S))
var dia = System.DateTime.Now.Day.ToString();
var mes = System.DateTime.Now.Month.ToString();
var ano = System.DateTime.Now.Year.ToString();
46
var hora = System.DateTime.Now.Hour.ToString();
var min = System.DateTime.Now.Minute.ToString();
var seg = System.DateTime.Now.Second.ToString();
leitor.data = dia+"-"+mes+"-"+ano+" "+hora+"h"+min+"m"+seg+"s";
WriteFile("C:/Relatório "+data+".txt");
(13)
Primeiramente foi utilizada apenas a função System.DateTime.ToString( )
para retornar o dia e a hora no momento em que a tecla era pressionada para a
variável “data”, que seria utilizada para nomear o arquivo TXT gerado, porém o
formato das horas continha o caractere “:”, que não é aceito em nomes de arquivos
do Windows por ser um caractere especial, sendo assim foi necessário extrair cada
elemento individualmente para compor a variável “data” somando a caracteres
aceitos pelo Windows para nomear o TXT.
Após compor a variável “data” é chamada a função WriteFile que está
declarada abaixo com o parâmetro do local a ser salvo o arquivo gerado quando a
tecla “S” for pressionada.
function WriteFile (filepathIncludingFileName : String)
var sw : StreamWriter = new StreamWriter(filepathIncludingFileName);
sw.WriteLine("---------------------------------------------");
sw.WriteLine("Relatório de Caixas Produzidas");
sw.WriteLine(leitor.data);
sw.WriteLine("Quantidade de caixas grande;"+leitor.caixa_grande);
sw.WriteLine("Quantidade de caixas pequenas;"+leitor.caixa_pequena)
sw.WriteLine("QuantidadeTotaldeCaixas;"+leitor.total_de_caixas);
sw.WriteLine("----------------------------------------------");
sw.Flush();
sw.Close();
(14)
47
Indo no local indicado é constatado que o arquivo realmente foi gerado com o
nome Relatório seguido da data e da hora no exato momento em que foi solicitada a
geração do relatório.
Figura 34 – Ícone do Relatório gerado
O TXT gerado pode ser aberto tanto no bloco de notas onde os dados são
visualizados como simples texto quanto em um editor de planilhas, como o Microsoft
Excel, que devido a formatação aplicada todo o conteúdo já é automaticamente
divido em células, podendo ser manipulado facilmente.
Figura 35 – Visualização em Bloco de Notas
48
Figura 36 – Visualização no Microsoft Excel
49
8. INTERFACE
Após a apresentação de todos os sistemas individualmente, vamos ver como
o usuário visualiza todas essas informações e interage com o processo. Por ser um
processo bem simples e industrial, a linguagem tem que ser bem visual e intuitiva,
para isso foram utilizados ícones grandes e bem significativos.
Figura 37 – Interface
Logo bem grande do lado esquerdo podemos ver a alavanca de acionamento,
a parte mais importante da interface, pois caso ela esteja no estado DESLIGADO, a
esteira permanece parada e não é efetuada a contagem como citado no capítulo
anterior. De forma bem intuitiva foram colocados do lado os comandos que acionam
a alavanca [(↑) Seta para Cima] e [(↓) Seta para Baixo].
O programa é iniciado com a alavanca na posição DESLIGADO e a esteira
parada, quando pressionada a tecla [(↑) Seta para Cima], a textura da alavanca é
alterada e é selecionado o estado LIGADO, automaticamente a esteira é ligada e se
houver alguma caixa será iniciado o seu deslocamento.
50
Figura 38 – Posição Desligado
Figura 39 – Posição Ligado
Como citado, se houver alguma caixa ela será deslocada, indo em direção ao
sistema de leitura constituído pela coluna de LED’s, a passagem de uma caixa
pequena irá incrementar a variável “caixa_pequena” que poderá ser visualizada no
painel CAIXAS CLASSIFICADAS do lado direito.
Figura 40 – Caixa Pequena classificada
51
Caso a caixa que passar pelo sistema de leitura for seja uma caixa grande,
será incrementada a variável “caixa_grande” e poderá ser visualizado o incremento
no mesmo painel anterior só que sob a caixa da esquerda, representando a caixa
grande.
Figura 38 – Caixa Grande Classificada
A qualquer momento pode ser solicitada uma nova contagem, independente
de ter sido salva ou não a contagem, como citado no capitulo anterior a solicitação
de uma nova contagem zera as variáveis “caixa_grande” e “caixa_pequena”, na
interface esta bem destacado que para a solicitação de uma nova contagem é
necessário o pressionamento da tecla “N”.
Figura 41 – Solicitação de Nova Contagem
Após a solicitação pode ser visualizado no painel de CLASSIFICAÇÃO DE
CAIXAS que as variáveis realmente foram zeradas.
52
Figura 42 – Contagem Zerada
O outro botão presente na interface é o botão SALVAR CONTAGEM, que pode ser acionado com o pressionamento da tecla “S”.
Figura 43 – Salvar Contagem
Quando solicitado o salvamento da contagem é realizado todo o processo
relatado no final do capitulo anterior, armazenando a quantidade de caixas grandes
e pequenas no arquivo TXT e retornada uma mensagem indicando local e o nome
do arquivo salvo.
Figura 44 – Aviso de salvamento do arquivo
53
CONCLUSÃO
Este trabalho foi um grande desafio, pois necessitou de conceitos de várias
áreas completamente diferentes tendo que funcionarem juntos com o mesmo
objetivo, como relação de polias que dependiam da velocidade de leitura de um
sensor, que influenciaria diretamente no código do programa que iria interpretar as
informações do sensor.
Foi enorme a experiência adquirida, pois mesmo em uma escala muito menor,
vários problemas presentes em um processo industrial puderam ser vividos, desde a
adaptação do sistema aos parâmetros do produto a ser produzido quanto à
necessidade da aplicação de novas tecnologias, como foi a utilização de um controle
de vídeo-game para redução dos custos com sensores no projeto.
Outro desafio foi a quantidade de softwares utilizados, com várias funções
diferentes para se chegar a único objetivo, mas isso é justamente o que acontece na
realidade, em uma linha de produção automatizada pode-se ter vários equipamentos
de fabricantes diferentes, que utilizam PLC’s de marcas diferentes, enfrentando
muitas vezes vários casos de incompatibilidades, sendo necessário adaptações,
assim como no programa de classificação devido ao padrão das entradas do sensor
serem apenas verdadeiro ou falso, precisando serem emuladas para serem
reconhecidas por outro programa.
Concluímos que apesar de desafiador, a reprodução do processo industrial de
automação foi reproduzido, e propiciou a experiência de um projeto, desde o
conceito, passando pela implantação e a entrega do projeto funcionando de acordo
com os parâmetros propostos.
54
REFERÊNCIA BIBLIOGRÁFICA
ALMANADA, Negreiros. Como construir uma esteira transportadora. Disponível
em: <http://www.comofazertudo.com.br/casa-e-jardim/como-construir-uma-esteira-
transportadora>. Acesso em: 28 nov. 2011.
Wikipédia, a enciclopédia livre. Fordismo. Disponível em:
<http://pt.wikipedia.org/wiki/Fordismo> Acesso em 14. fev. 2012
Wikipédia, a enciclopédia livre. Bluetooth. Disponível em:
<http://pt.wikipedia.org/wiki/Bluetooth> Acesso em 27. jan. 2012
CEBILDS. Projeto Esteira Seletora.avi. Dispnível em:
< http://www.youtube.com/watch?v=HDgVJQiJpcc >. Acesso em 23 nov. 2011
KENNER, Carl. Documentation - GlovePIE.doc. Disponível em:
<http://glovepie.org/> Acesso em: 12 nov. 2011
UNITY3D. Unity Script Reference. Acesso em 12. jan. 2012
<http://unity3d.com/support/documentation/ScriptReference/ >
55
ANEXOS 1. Datasheat do tranistor BD135
56
57
58
59
2. Datasheet do Opto-acoplador 4N25
60
61
62
63
64
65
3. Script - principal 1 . import System.IO;
2 . import System;
3 .
4 . var HAB = true;
5 . var instante : float;
6 . var lista2 = new Array ();
7 . var ident : int;
8 .
9 . static var data : String;
10 . static var caixa_grande : int = 0;
11 . static var caixa_pequena : int = 0;
12 . static var total_de_caixas : int = 0;
13 .
14 . function Update()
15 .
16 . //Display das informações
17 . GameObject.Find("caixa_grande_text").guiText.text = "" + caixa_grande;
18 . GameObject.Find("caixa_pequena_text").guiText.text = "" + caixa_pequena;
19 .
20 . if (LigaDesliga.acionamento == true)
21 .
66
22 . //Primeira leitura
23 . if ( (Input.GetKeyDown ("a") || Input.GetKeyDown ("b")) && (HAB == true) )
24 . instante = Time.time;
25 . ident = 0;
26 . if (Input.GetKeyDown ("a"))
27 . lista2.Push ("a");
28 .
29 . if (Input.GetKeyDown ("b"))
30 . lista2.Push ("b");
31 .
32 . HAB = false;
33 .
34 .
35 .
36 . //Leituras sequintes
37 . if (HAB == false)
38 . if (Input.GetKeyDown ("a"))
39 . lista2.Push ("a");
40 .
41 . if (Input.GetKeyDown ("b"))
42 . lista2.Push ("b");
43 .
67
44 .
45 .
46 . //Classificação
47 . if ((HAB == false) && (Time.time > instante + 3))
48 . for (var n=0; n < lista2.length; n++)
49 . if (lista2[n]=="a")
50 . ident++;
51 .
52 .
53 . if (ident > 0)
54 . caixa_grande++;
55 .
56 . if (ident == 0)
57 . caixa_pequena++;
58 .
59 . lista2.Clear();
60 . HAB = true;
61 .
62 .
64 .
65 . //Iniciar nova contagem
66 . if (Input.GetKey(KeyCode.N))
68
67 . principal.caixa_grande = 0;
68 . principal.caixa_pequena = 0;
69 . principal.total_de_caixas = 0;
70 .
71 .
72 .
73 . //Salvar a contagem
74 . if (Input.GetKey(KeyCode.S))
75 . var dia = System.DateTime.Now.Day.ToString();
76 . var mes = System.DateTime.Now.Month.ToString();
77 . var ano = System.DateTime.Now.Year.ToString();
78 . var hora = System.DateTime.Now.Hour.ToString();
79 . var min = System.DateTime.Now.Minute.ToString();
80 . var seg = System.DateTime.Now.Second.ToString();
81 . principal.data = dia+"-"+mes+"-"+ano+" "+hora+"h"+min+"m"+seg+"s";
82 .
83 . WriteFile("C:/Relatório "+principal.data+".txt");
84 .
85 .
86 .
87 . function WriteFile (filepathIncludingFileName : String)
88 .
69
89 . var sw : StreamWriter = new StreamWriter (filepathIncludingFileName);
90 . sw.WriteLine("---------------------------------------------------");
91 . sw.WriteLine("Relatório de Caixas Produzidas");
92 . sw.WriteLine(principal.data);
93 . sw.WriteLine("Quantidade de caixas grande: ;"+principal.caixa_grande);
94 . sw.WriteLine("Quantidade de caixas pequenas: ;"+principal.caixa_pequena);
95 . sw.WriteLine("Quantidade Total de Caixas: ;"+principal.total_de_caixas);
96 . sw.WriteLine("---------------------------------------------------");
97 . sw.Flush();
98 . sw.Close();
99 .
70
4. Script – LigaDesliga
1 . static var acionamento = false;
2 . var lig : Texture;
3 . var des : Texture;
4 .
5 .
6 . function Update()
7 . if (Input.GetKeyDown (KeyCode.UpArrow))
8 . LigaDesliga.acionamento = true;
9 . renderer.material.mainTexture = des;
10 . Debug.Log ("LIGADO");
11 .
12 . if (Input.GetKeyDown (KeyCode.DownArrow))
13 . LigaDesliga.acionamento = false;
14 . renderer.material.mainTexture = lig;
15 . Debug.Log ("DESLIGADO");
16 .
17 .
71
5. Script - InterfaceEsteira
1 . // Leitura
2 .
3 . var.A = WiiMote.dot1vis
4 . var.B = WiiMote.dot2vis
5 .
6 . A = !(WiiMote.dot1vis)
7 . B = !(WiiMote.dot2vis)
8 .
9 . // Acioamento
10 .
11 . if (Keyboard.Up)
12 . var.ativado = True
13 .
14 . if (Keyboard.Down)
15 . var.ativado = False
16 .
17 . WiiMote.Rumble = var.ativado
72
6. Fotos da Esteira
VISÃO GERAL
DETALHE DA ESTEIRA