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

Izabel Santana Perdigão e a minha segunda avó e também mãe Benedita Maria Marinho .Dedico este trabalho de conclusão de curso a minha avó e mãe.

pela força e o apoio na escolha da minha carreira. 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. Alvanir Santana Perdigão e Álvaro Ribeiro Perdigão Neto. 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. que desde o começo sempre todos se ajudaram para se chegar até aqui. Maria das Graças Barros. Agradeço aos meus pais. Airton Santana Perdigão. Adilson Santana Perdigão e Inácia Madalena Bógea Sousa Perdigão. Raissy Oliveira e Costa.AGRADECIMENTOS Agradeço ao meu Tio e Padrinho. pelo apoio depois das provas e por me levar pra sair nos momentos que eram preciso. Agradeço a minha namorada. Ana Tereza Santana Perdigão. pela compreensão nas vésperas das provas. Agradeço a todos os meus colegas do curso.

utilizando apenas um WiiRemote. Contagem. o que torna este trabalho completamente interdisciplinar. Palavras-Chave: Esteira. No decorrer do trabalho serão mostrados os sensores e atuadores do WiiRemote que foram utilizados. e linguagem orientada a objeto. WiiMote. Além dos conceitos de Programação e Eletrônica envolvidos no controle. identificando o tamanho das caixas e armazenando em um banco de dados o total de caixas e a quantidade de cada tipo de caixa. 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. Orientado a objeto. Banco de dados . e o driver desenvolvido para realizar a comunicação do controle com o motor de tração da esteira.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. será mostrado também o processo de confecção da esteira transportadora que necessitou de conceitos da Mecânica. JScript. controle do console Wii da Nintendo.

control of Nintendo Wii console. Object-oriented. identifying the size of the boxes and stored in a database the total of boxes and how much boxes of each size. Will be show too how the treadmill was made. 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. Database . Beyond the concepts of Programming and Eletronics envolved in the control. using only one WiiRemote. Keywords: Treadmill. and the Mechanics concepts envolveds. what makes this job quite interdisciplinary. WiiMote. Jscipt. Count. and object-oriented language.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.

............................................................ 65 4..............................................1.................4..... 20 3......................................................................................principal ............................................... Acionamento ... SISTEMA DE LEITURA ........... 54 ANEXOS ............................................................ 38 8................................... Classificação ................................................ VISÃO GERAL DO PROCESSO ...... Fotos da Esteira ................. SISTEMA DE ACIONAMENTO .........Sumário 1.............................................................................................................. 59 3.......................... 55 2.......3.......................................................... 29 6................................................................................ SISTEMA DE CLASSIFICAÇÃO E ARMAZENAMENTO ..................... 49 CONCLUSÃO ....................................... Script ................... Armazenamento ................. 21 4......5............................................................................................................. CONEXÃO DO CONTROLE COM O PC ............... INTRODUÇÃO ............................ 18 2...... 12 2.............................................................................................. 18 2............................. 71 6............................................................................................ 19 2.................. 18 2......................................................... 26 5............................... 72 ................. Comunicação ....... 53 REFERÊNCIA BIBLIOGRÁFICA ............................................................ Leitura ....................................................2.......................... Script – LigaDesliga ............................................................................. Datasheat do tranistor BD135 .......................InterfaceEsteira....................................................................................... INTERFACE .............. 70 5............................................................................... CONFECCÇÃO DA ESTEIRA ............................................................................................ 20 2.............. 55 1........................................ Datasheet do Opto-acoplador 4N25... 33 7........... Script ..................................................

.................................................................. 36 ................................................................. 15 Figura 6 .................................................................................... 34 Figura 30 – Leitura de caixa pequena .............................................................................................................................................................................................................................................................................................. 24 Figura 15 – Sistema de correia ........................................... 12 Figura 2 – Linha de produção automatizada ...........................................................................................Kinect ....FIGURAS Figura 1 – Linha de produção nos anos 30 ............................................................................................. 14 Figura 4 – WiiMote do Nintendo Wii .................. 35 Figura 31 – Leitura de caixa grande ................................................................................................................................ 28 Figura 21 – Conexão estabelecida .................................................................................. 27 Figura 20 – Solicitação de serviço ...................................................... 32 Figura 25 – Circuito de acionamento . 23 Figura 14 – Sistema de tração direta ........................................................................................................PlayStation Move ...................................................... 31 Figura 24 – Circuito 2 de interface WiiRemote – Motor Esteira ....................................................................................................................... 15 Figura 5 .................. 25 Figura 17 – Vista Inferior da Placa do WiiMote ......... 32 Figura 26 – SensorBar ........ 23 Figura 13 – Carregador de celular ... 20 Figura 10 – Dimensões da esteira ............................................... 13 Figura 3 ..................................................... 19 Figura 9 – Diagrama de Blocos das trocas de informação .................... 29 Figura 23 – Circuito 1 de interface WiiRemote – Motor Esteira ..................................................... 34 Figura 29 – Imagem capturada por câmera de celular ................................ 33 Figura 28 – Dimensão das caixas e led’s ....................................................................................................................... 18 Figura 8 – Fluxograma do processo .......................................................Controle do Atari .................. 25 Figura 16 ..... 26 Figura 18 – Encontrando dispositivos .. 16 Figura 7 .......................................................................................................................................................................................................................................... 27 Figura 19 – Serviço disponível ....... 28 Figura 22 – GlovePIE – Código InterfaceEsteira ..Visão Geral .......................................Esteira ............................................................................... 33 Figura 27 – Circuito de alimentação dos led’s ...... 22 Figura 11 – Motor CC ................................................................................................................................. 23 Figura 12 – Redução ............................

......................................................................... 52 ......................................................................................................................................................................................................................................................... 50 Figura 40 – Caixa Pequena classificada ........................................................................................................................Figura 32 – Unity 3D.......................... 52 Figura 44 – Aviso de salvamento do arquivo.............................................................................................................................. 51 Figura 42 – Contagem Zerada ................................................. 39 Figura 34 – Ícone do Relatório gerado .......................................................... 49 Figura 38 – Posição Desligado......................................................................... 38 Figura 33 – Scripts criados ..................................... 47 Figura 35 – Visualização em Bloco de Notas ................... 52 Figura 43 – Salvar Contagem........................................ 50 Figura 39 – Posição Ligado ......................... 48 Figura 37 – Interface ..................... 47 Figura 36 – Visualização no Microsoft Excel .......................... 50 Figura 41 – Solicitação de Nova Contagem ..........................................................

...... 22 Tabela 3 – Correntes de acionamento ... 36 Tabela 5 – Padrão de leitura das caixas pequenas ............TABELAS Tabela 1 – Tipos de esteiras .......................................................................................................... 31 Tabela 4 – Padrão de leitura das caixas grandes ................ 21 Tabela 2 – Especificações da carga transportada ................................................................................. 36 .........................................................................................

1936). quando os carros eram colocados em uma esteira onde passavam pelos postos de trabalho em que cada trabalhador realizava apenas uma especifica tarefa repetidamente. sendo utilizada a mão-de-obra humana apenas em processo muito complexos que máquinas ainda não são capazes de realizar. o modelo produzido na fábrica. que foi satirizado no filme de Charlie Chaplin. porém essa subutilização da mão-de-obra humana foi diminuída com o advento da Automação Industrial. primeiramente evidenciado no Fordismo no início da década de 20. Esse método aumento consideravelmente a quantidade de carros produzidos. Ford chegou a dizer que metade dos carros do mundo seriam Ford T. INTRODUÇÃO A utilização de esteiras em processos produtivos iniciou-se quando as produções adotaram o método de linha. Ao contrário do que muitos . Porém devido as atividades simples e repetitivas realizadas pelos empregados eram pagos pequenos salários e subutilizada uma mão-deobra com uma enorme capacidade que é a do ser humano.12 1. Tempos Modernos (EUA. 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.

Um dos exemplos de jogos dessa época é o Tennis for Two. 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. como Nintendo. 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 . desenvolvido no Brookhaven National Laboratory. envasar. pelo cientista William Higinbotham onde o console na verdade era um osciloscópio e os comandos eram dados por potenciômetros. através de sensores e atuadores que são capazes de enxergar. Os primeiros jogos interativos datam do final dos anos 1940 e inicio dos anos 1950. Sony. Sega e mesmo a Microsoft que é uma empresa de software também tem participação na indústria dos Games. principalmente os consoles dos vídeo-games. etiquetar. detectar metais. Com o passar do tempo muitas empresas de Games surgiram. não muito distante da utilização da linha de produção. pesar e etc.13 acham a Automação não veio para tirar empregos e sim melhor aplicar o a capacidade do ser humano. de 1958. Atualmente uma esteira automatizada tem a capacidade de classificar. cortar e até apertar os parafusos em uma linha de produção. empurrar. 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.

Controle do Atari Outro recurso do controle foram os acelerômetros. dar um soco. Essa mudança começou a acontecer em dezembro de 2006. muito mais interativo do que simplesmente girar um potenciômetro. 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. E o melhor do controle. desenvolvido pela própria Nintendo ainda no console anterior o Nintendo 64.14 jogopassando do simples apertar de botões para uma interação com os outros sentidos. 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. Figura 3 . só que anteriormente necessitava-se acoplar o sistema ao controle com uma alimentação independente. devido a comunicação do controle se dar via Bluetooth com o console. com esses sensores o controle se tornou capaz de detectar movimentos. como pular. que é a ausência de fios. . quando a Nintendo revolucionou esse jeito do usuário interagir com console com o lançamento do vídeo-game Nintendo Wii. que possibilita toda essa mobilidade. muito incomodo para o usuário. ou até mesmo rebater uma bola de tênis. capaz de detectar até quatro pontos infravermelhos e se orientar no espaço por eles. sensores capazes de detectar a intensidade e o sentido de forças aplicadas. que possui um controle chamado WiiMote. chamado RumblePack.

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. Figura 5 .PlayStation Move . dotado também de acelerômetros é capaz de reconhecer gestos. 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.

Leitura e Classificação & Armazenamento. Figura 6 . No Capítulo 2 iremos ter uma visão geral do processo que pode ser dividido Acionamento. O Acionamento será abordado no Capítulo 5. materiais e dimensões. O Kinect revolucionou por que na verdade eliminou o controle. um dispositivo que acompanha o vídeogame Xbox 360. que ao tocarem em qualquer objeto são deformadas.16 Mas no final de 2010 houve a maior revolução dentre todos os controles. o dispositivo possui uma câmera infravermelha que capta a projeção de raios infravermelhos em forma de linhas emitidas pelo próprio dispositivo. especificando os componentes. especificando todos os softwares necessários. 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. No Capítulo 4 será exposto o processo de estabelecimento da comunicação entre o WiiMote e computador utilizado passo-a-passo. foi o lançamento do Kinect. 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. O Capítulo 3 mostrará todos os componentes utilizados na confecção da esteira. 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. . a Automação Industrial e a evolução dos Consoles de Vídeo-Games que se baseia esse trabalho. da Microsoft. posicionado próximo ao console.Kinect É baseada nessas duas evoluções em paralelo.

e também a interface criada para a visualização das informações pelo usuário. . 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”. mostrando o padrão das informações obtidas pelo sensor infravermelho que servirão para o processo de Classificação.17 No Capítulo 6 será explicado como o ocorre o processo de Leitura do tamanho das caixas.

utilizando um opto-acoplador para isolar o controle e um transistor de potência para suprir a necessidade de corrente do motor. 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. .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. Classificação e Armazenamento. para a realização desse processo foi desenvolvido um circuito para fazer a interface do controle para o motor. Leitura. VISÃO GERAL DO PROCESSO O processo de contagem de caixas pode ser dividido em cinco etapas: Comunicação. Figura 7 .18 2. Acionamento.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. 2. 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.

que consegue visualizar até 4 pontos infravermelhos retornando Verdadeiro ou Falso de acordo com a visualização ou impossibilidade de visualizar cada ponto. Leitura Para o processo de leitura será utilizado outro recurso do WiiRemote.19 Figura 8 – Fluxograma do processo 2.3. enviando essas informações para o computador. que é a câmera infravermelha localizada na frente do controle. .

hora.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. Figura 9 – Diagrama de Blocos das trocas de informação . quantidade de cada tipo de caixa e o total de caixas. Ao solicitar a geração do relatório será criado um arquivo “TXT”.20 2.5 Armazenamento A qualquer momento o usuário irá poder gerar um relatório com a data. 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. 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. 2.

Esteira Simples de Carga A carga se apóia diretamente na correia. plástico ou vidro). o movimento se da por acumulo. o que pode influenciar inclusive nos sensores a serem utilizados. 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). Tabela 1 – Tipos de esteiras . com pás de sustentação para a carga. Esteira de Caneca Destinada a elevação de cargas. que irá influenciar na aderência (papelão.21 3. peso e seu material. De acordo com a carga deve ser escolhido o tipo de esteira mais indicado. mantendo a distância de acordo com a freqüência de colocação na esteira. Esteira de Roletes Sem controle de velocidade e distância entre as cargas.

baixa velocidade e sem a necessidade de conexões. Figura 10 – Dimensões da esteira . horizontal. 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. fixadas com arrebites nas extremidades.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. Material Utilizado Para base da esteira foi confeccionada uma estrutura com perfis de alumínio.

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

0. Figura 17 – Vista Inferior da Placa do WiiMote Para esta estabelecer a conexão. pois devido o protocolo utilizado os pacotes de dados são mínimos. CONEXÃO DO CONTROLE COM O PC Este pode ser considerado o ponto vital de todo o processo. que dá suporte a comunicações de mouse. joystick e teclado. para enfim ser visualizado o tamanho da caixa. além do hardware instalado no computador é necessário a instalação do software BlueSoleil. sendo assim. mais do que o suficiente para o projeto.0 apenas de demonstração que permite a transferência de até 2 Mb de dados. A comunicação é feita através de uma conexão Bluetooth Classe 2. ler os dados do sensor e enviar as informações para o computador. . neste projeto será utilizada a versão 8.26 4.5 mW de potência. como algum desses periféricos. que permite uma comunicação de até 10 metros que consome até 2. pois sem essa comunicação é impossível movimentar as caixas. a conexão do WiiMote com o computador. o protocolo usado é o Bluetooth HID (Humam Interface Device). o WiiMote será visto pelo computados dessa forma.338.

indicando que aquele serviço está disponível. Enquanto estiver sendo realizada a busca mantenha os botões 1 e 2 do WiiMote pressionados por pelo menos 5 segundos. um dispositivo de interface humana. o controle será exibido como um joystick. clicando duas vezes no círculo central da interface do programa. o primeiro passo é iniciar o BlueSoleil e solicitar uma busca de dispositivos. Figura 18 – Encontrando dispositivos Após encontrado. Figura 19 – Serviço disponível . ao final da busca serão exibidos todos os dispositivos que estiverem com o Bluetooth ligado ao seu redor. serão dados dois clicks no ícone do joystick para serem exibidos os serviços disponíveis para aquele dispositivo.27 O procedimento de conexão é bastante simples. O ícone do mouse na parte superior do programa irá ser realçado.

28 O próximo passo é solicitar a ligação. a opção a ser escolhida é Ligar Dispositivo de interface humana Bluetooth. com um click com o botão direito em cima do dispositivo serão mostradas as opções para aquele dispositivo. Figura 21 – Conexão estabelecida . 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.

do seu sistema de vibração.29 5. desenvolvido por Carl Kenner e distribuído gratuitamente. Neste projeto o acionamento é feito remotamente pelo computador de controle através das setas para cima e para baixo do teclado. Playstation 3 BDRemote. como o WiiMote. o seu sinal de comando vem do WiiRemote. que com uma linguagem própria e não-linear. Mesmo o controle já conectado com o computador esses comandos ainda não são enviados para o controle. Xbox360 Controller. Figura 22 – GlovePIE – Código InterfaceEsteira Todo o código para envio e recebimento de informações do controle está mostrado na Fig. SISTEMA DE ACIONAMENTO Após estabelecida a comunicação. o próximo passo é iniciar o deslocamento das caixas em direção ao sensor. O software utilizado para essa tarefa será o GlovePIE. . que de acordo com o diagrama de blocos do Cap. tanto da parte de acionamento do motor quanto de leitura do tamanho das caixas. 15. mouse 3D e teclado através de controles de vídeo-games. 2. Para interpretar esses comandos será utilizado mais um software. o Rumble Pack. utiliza a conexão já estabelecida e faz a interface para enviar as instruções para o controle. essa tarefa se da com o acionamento do motor da esteira. que será comentado no próximo capítulo. esse programa é capaz de emular diversos periféricos como mouse.

abaixo da sua tensão de trabalho nominal no carro de controle remoto. de acordo com o acontecimento do evento a variável é criada e atribuído um valor a ela.Rumble = var.Down) do teclado. além disso seria inviável a alimentação do motor de tração da esteira vir do WiiRemote.5 V e alimentar o motor e com uma fonte independente do controle. desabilitando o motor interno do controle.30 // Acioamento if (Keyboard. será atribuída uma condição falsa a variável ativado. e nem uma atribuição de bibliotecas no início do programa. a função WiiMote. recebendo o comando do controle na base e alimentando o motor pelo .Rumble que recebe como parâmetro a variável ativado. quando pressionada a tecla para cima do teclado (Keyboard. não é necessário nem a declaração do tipo da variável. criando um efeito de vibração enquanto a variável for verdadeira. enviará um sinal para o controle para ativar o seu motor interno. pressionando a tecla para baixo (Keyboard. a seção de acionamento possui duas condições.Down){ var.ativado = False } WiiMote.2 V. Foram realizadas medições nos terminais do motor durante o seu acionamento encontrado um valor de 3.Up). foi desenvolvido um driver para fazer a interface do comando entre o controle e o motor de tração. e conseqüentemente prejudicar o sistema de leitura.ativado = True } if (Keyboard. é atribuída uma condição verdadeira a variável ativado.Up){ var.ativado (1) O código é bem simples e direto. 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. Como pode ser visto na parte (1). pois o consumo do motor iria diminuir a vida útil da das pilhas do controle. Características que poderiam ser completamente atendidas com apenas um transistor funcionando como chave. Devido a impossibilidade de alimentação direta do WiiRemote para o motor de tração.

o sistema de leitura. o 4N25 (datasheet em anexo). e depois com o driver acoplado. apenas com o Rumble Pack. foram coletados os seguintes dados: IRB – Corrente do Rumble Pack IDR – Corrente do Driver 8mA 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. através de um opto-acoplador. o led’s infravermelhos deixavam de ser visualizados. o acionamento ocorreu perfeitamente. o que causava uma sobre carga para o sistema do controle travando a câmera infravermelha. individualmente. Foram então realizadas medições da corrente demandada para o acionamento. que era realizar o acionamento do motor da esteira. sendo assim tornou-se necessário diminuir a corrente demanda pelo driver. sem o travamento da câmera. O transistor que mais se adequou as necessidades do projeto foi o BD135 (datasheet em anexo). porém desta vez. onde além de simplesmente diminuir a corrente demanda pelo driver. que será explicado no próximo capítulo. ao realizar novamente as medições . foi montado então o seguinte circuito: Figura 23 – Circuito 1 de interface WiiRemote – Motor Esteira O circuito cumpriu o desejado.31 carregador de celular. foi isolado o controle do transistor. assim como o primeiro circuito. Como solução foi desenvolvido um segundo driver. porém durante os testes. Ao ser testado. ao acionar o motor. travava a câmera infravermelha.

Figura 24 – Circuito 2 de interface WiiRemote – Motor Esteira Figura 25 – Circuito de acionamento . foi constato que houve uma queda significativa. dentro do seu limite de funcionamento normal apenas com o Rumble Pack. a corrente demandada pelo driver caiu para menos de 6mA.32 de corrente demanda.

Esses pontos infravermelhos são Led’s Infravermelhos nas extremidades de uma barra alimentada pelo console.7 V. 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. 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. SISTEMA DE LEITURA O sistema de leitura foi baseado na funcionalidade básica do console Wii. Para alimentação dos leds também foi o carregador de celular com a tensão de 5.33 6. 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 . chamada de SensorBar.

quando o segundo led não estiver visível será pressionada a tecla “B” do teclado e quando o primeiro . com uma sintaxe bem simples e direta. 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. podemos visualizar se realmente o circuito está funcionando.34 Figura 28 – Dimensão das caixas e led’s A luz emitida pelos led é infra-vermelha. na segunda parte do código são dados os comandos de emulação. inclusive de celular. não visível a olho nú. mas com qualquer câmera.

dot2vis)) || ((WiiMote.dot2vis) && (!WiiMote. por default quando um led deixa de estar visível. Figura 30 – Leitura de caixa pequena .dot1vis)&&(!WiiMote.B = !WiiMote. 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. e quando o próximo led deixar de estar visível é considerado o primeiro. automaticamente ele é considerado como o segundo led.dot2vis A = (!WiiMote.35 led não estiver visível será pressionada a tecla “A” do teclado.dot2vis))) (2) O controle não consegue distinguir qual dos dois leds vistos é o primeiro ou o segundo. // Leitura var.dot1vis var.dot1vis) B = (((!WiiMote.A = !WiiMote.dot1vis)&&(WiiMote.

(caso da caixa pequena).36 Figura 31 – Leitura de caixa grande Então quando for bloqueada a visualização de apenas um dos leds. Quando os dois leds tiverem a visualização bloqueada será pressionada a tecla “A”. 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 Tabela 5 – Padrão de leitura das caixas pequenas B B B B B B . será pressionada a tecla “B”. Como teste foi utilizado o Microsoft Word 2010 para verificar os padrões criados pela emulação do teclado.

. já que as duas estão acontecendo. a linguagem utilizada pelo GlovePIE é não linear. apresentam-se dois tipos de entrada. que serão detalhados no próximo capítulo. mas seguindo um padrão de aparecer sempre a tecla “A”. já na passagem da caixa grande. então o programa executa as duas ações aleatoriamente. o padrão são apenas teclas “B”. onde é bloqueada apenas a visão de um dos leds. onde os dois leds são bloqueados. Pode ser observado que na passagem da caixa pequena. Tendo os dois padrões definidos o próximo passo é o tratamento dessas informações de entrada para a classificação e armazenamento.37 Durante a passagem da caixa pelo sensor a emulação do teclado ocorre várias vezes. como explicado anteriormente.

da Microsoft) e C# (muitíssimo conhecida e também da Microsoft). JScript (variante do JavaScript. SISTEMA DE CLASSIFICAÇÃO E ARMAZENAMENTO De acordo com os padrões obtidos pela leitura do sensor. como Boo (variante do Python desenvolvida pelo brasileiro Rodrigo Barreto de Oliveira). um jeito muito mais visual de programar. a interface será apresentada no próximo capítulo.4. Neste capítulo serão abordados apenas os códigos criados.0f5. uma Game Engine 3D. Para essa atividade foi escolhido o software Unity 3D na versão 3. com suporte a várias linguagens de programação. Figura 32 – Unity 3D . 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.38 7. o objetivo agora é tratar e fazer com que esses caracteres se transformem em informações e sejam armazenados possibilitando a sua consulta futuramente. 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. que dispensa a necessidade do conhecimento de bibliotecas especificas.

(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. que só poderá ocorrer quando “acionamento” for verdadeiro. A principal função de todos os scripts é a função Update( ). onde são executados todos os comandos dentro da função a cada ciclo. a freqüência de ciclos é inversamente proporcional a .39 A linguagem escolhida como padrão para esse projeto foi o JScript. var lig : Texture. static var acionamento = false. por possuir todas as funções necessárias e ter uma sintaxe de fácil assimilação. dando idéia de animação. devido a farta documentação encontrada na internet. será chamada pelo script leitor e será a principal condição para liberação do processo de leitura e classificaçã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 variável “acionamento” do tipo booleana. simplesmente sendo transferidos ou salvos dentro da pasta Assets dentro da pasta do projeto. No início do script são declaradas todas as variáveis a serem utilizadas. var des : Texture. a alavanca de acionamento da esteira. o Unity trabalha em um esquema de clico de frames. tanto booleanas quanto texturas.

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. mesmos comandos citados anteriormente para o GlovePie.UpArrow)) e if(Input.GeyKeyDown(KeyCode.GetKeyDown (KeyCode. } if (Input.mainTexture = des. ao iniciar a passagem de uma caixa. Com o pressionamento da tecla de seta para cima a variável “acionamento” é setada como verdadeira. renderer. O procedimento inverso acontece quando pressionada a tecla seta para baixo. } } (4) As condições if(Input. Script – Principal Este é o principal script de todo o aplicativo.material. que o GlovePIE emular o pressionamento de .GeyKeyDown(KeyCode. function Update(){ if (Input.material. definir o tamanho da caixa e armazenar no banco de dados.40 quantidade de elementos carregados na interface.DownArrow)){ IO. responsável pelas tarefas de receber as informações enviadas pelo GlovePIE. para essa aplicação a taxa de atualização está em torno de 107 frames/s. interpretar.UpArrow)) captam as entradas de teclado seta para cima e seta para baixo.GetKeyDown (KeyCode. sendo aplicada a textura “des”.acionamento = true.UpArrow)){ IO. renderer.acionamento = false. que estará sendo executado por trás recebendo os mesmos comandos e atuando no acionamento do motor. O principio de funcionamento é bem simples.mainTexture = lig.

import System. (5) Após a importação das bibliotecas teremos a declaração das variáveis: var HAB = true. habilitando novas entradas após a primeira leitura e desabilitando no final da janela de leitura. var lista2 = new Array (). (6) A primeira variável. será uma variável auxiliar irá variar entre “verdadeiro” e “falso”. var ident : int. “HAB” . de acordo com os padrões obtidos nos testes de leitura. dentro de um determinado espaço de tempo. static var total_de_caixas : int = 0. static var caixa_pequena : int = 0.Net Framework que não estão no Unity e são responsáveis pela função da criação do arquivo “TXT”. static var data : String. essa caixa será classificada como grande.IO. import System.41 uma tecla. automaticamente a primeira tecla pressionada será armazenada em um vetor e será iniciada uma contagem. static var caixa_grande : int = 0. ao final do intervalo de tempo será feito uma varredura no vetor. todas as teclas pressionadas também serão armazenas nesse mesmo vetor. var instante : float. . caso não apareça nenhum. caso apareça algum caractere “A”. Especialmente nesse script será necessário a importação de duas bibliotecas especificas do pacote Microsoft. será classificada como pequena.

“caixa_pequena” e “total_de_caixas” serão as variáveis incrementadas durante o processo de contagem.guiText.Find("caixa_pequena_text"). que é classificação das caixas. A variável “lista2” é um vetor que receberá em cada elemento as entradas emuladas pelo GlovePIE (“A” e “B”). A primeira condição para o processo iniciar é que a variável “acionamento”.Find("caixa_grande_text"). “ident” seja maior do que zero. algumas variáveis foram declaradas simplesmente como var e outras como static var. caso contrário a leitura não é realizada. correspondente ao tempo decorrido desde o início do programa até o instante do pressionamento da primeira tecla emulada de cada caixa. atuando no texto que será exibido nesse objeto através da função guiText.42 “Instante” receberá um valor em segundos. para cada caractere “A” presente no vetor.text. ou seja. que atualiza a cada ciclo. 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. (7) Logo no início do script. “Ident” será apenas um identificador da presença de caracteres “A” no vetor. a caixa será classificada como grande. GameObject.Find que busca o objeto com o nome passado como parâmetro. do script anterior. necessitam ser declaradas como static. Como pode ser visto. será do tipo string para ser adicionado tanto ao titulo do arquivo “TXT” gerado quando ao próprio conteúdo do arquivo.text=""+caixa_pequena. function Update () { //Display das informações GameObject. “Data” receberá o dia e a hora no instante em que for dado o comando de gravação no banco de dados.guiText. textos esses que serão as quantidades de caixas. “Caixa_grande”. é chamada a função GameObject. de acordo com a visualização dos led’s infravermelhos. a variável é incrementada.text=""+caixa_grande. . Em seguida inicia-se a principal parte do script. esteja na condição de verdadeira. na função Update ( ). que a esteira esteja ligada.

} (9) O programa ficará aguardando a primeira entrada.GetKeyDown ("a")){ lista2. será liberado o recebimento para as entradas emuladas pelo GlovePIE de acordo com os led’s visualizados. 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.Push ("a"). .GetKeyDown ("a") || Input. e precisará que a variável “HAB” seja verdadeira.43 //Processo de Classificação if (LigaDesliga. //Primeira leitura if ( (HAB == true) (Input.acionamento == true){ (8) Caso esta condição esteja satisfeita. if (Input. protegendo a variável “instante” que irá definir o tempo em que a janela de tempo para recebimento das emulações ficará em aberto. a variável “instante” receberá automaticamente o valor em segundos referente ao tempo decorrido desde o início do programa até aquele momento.Push ("b").GetKeyDown ("b")){ lista2.GetKeyDown ("b")) && ){ instante = Time. ident = 0. } HAB = false.time. 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. independente de ser o caractere “A” ou “B”. No momento em que ocorrer a leitura. } if (Input.

HAB = true. a variável “HAB” estando no estado falso. } if (ident == 0){ caixa_pequena++.length.44 //Leituras sequintes if (HAB == false){ if (Input. } } (10) Ao ser desabilitada na primeira parte do código. habilita o vetor para o recebimento de novos elementos. } if (Input.Push ("b").time > instante + 3)){ for (var n=0. } } if (ident > 0){ caixa_grande++.Push ("a").Clear(). mas sem alterar nenhuma outra variável. total_de_caixas = caixa_pequena+ caixa_grande.GetKeyDown ("a")){ lista2. n++){ if (lista2[n]=="a"){ ident++. } lista2.GetKeyDown ("b")){ lista2. //Classificação if ((HAB == false) && (Time. } } (11) . n < lista2.

Outra atividade que está dentro da função Update ( ) é a de iniciar uma nova contagem. a caixa será classificada como grande. será dado início ao processo de classificação. zerando as variáveis que foram incrementadas “caixa_pequena”. leitor.Now. incrementando a variável “caixa_pequena”. leitor.caixa_grande = 0. (12) Por último temos a atividade de armazenamento dos dados. caso não tenha nenhum caractere “A” no vetor. caso tenha aparecido um caractere “A”.S)){ var dia = System.ToString(). e a janela para recebimento de uma nova leitura inicial é liberada novamente.caixa_pequena = 0.GetKey(KeyCode. . //Salvar a contagem if (Input.DateTime.Year.DateTime.Now. var ano = System.Month. Ao final da classificação o vetor é limpado.GetKey(KeyCode. //Iniciar nova contagem if (Input. e de acordo com o padrão de leitura das caixas.Day. var mes = System. passados 3 segundos da abertura da janela de tempo para as entradas emuladas pelo GlovePIE.ToString(). que será realizada mediante o pressionamento da tecla “S”. “caixa_grande” e “total_de_caixas” mediante o pressionamento da tecla “N”.DateTime. independente de quantos elementos tiverem sido adicionados ao vetor.total_de_caixas = 0.Now.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. com a função Clear( ). a caixa será classificada como pequena. Para cada caractere “A” encontrado no vetor será incrementado de um a variável “ident”. Será iniciada a varredura do vetor “lista2”.ToString().N)){ leitor. incrementando a variável “caixa_grande”. ao final da varredura será feita uma comparação da variável.

sw."+leitor. } (14) .caixa_grande). 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. sw.DateTime. que seria utilizada para nomear o arquivo TXT gerado.ToString(). WriteFile("C:/Relatório "+data+".Flush().Now.WriteLine("Quantidade de caixas grande. sw.Second.Minute.WriteLine("---------------------------------------------")."+leitor.WriteLine("QuantidadeTotaldeCaixas. 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. var min = System. sw. function WriteFile (filepathIncludingFileName : String){ var sw : StreamWriter = new StreamWriter(filepathIncludingFileName).WriteLine("Relatório de Caixas Produzidas").WriteLine("Quantidade de caixas pequenas. sw. que não é aceito em nomes de arquivos do Windows por ser um caractere especial.DateTime.ToString().Close(). sw. sw.data = dia+"-"+mes+"-"+ano+" "+hora+"h"+min+"m"+seg+"s".Now."+leitor. leitor.total_de_caixas).WriteLine("----------------------------------------------").WriteLine(leitor.DateTime. sw.ToString().ToString( ) para retornar o dia e a hora no momento em que a tecla era pressionada para a variável “data”.Now. var seg = System.caixa_pequena) sw.DateTime.txt").46 var hora = System. } (13) Primeiramente foi utilizada apenas a função System.Hour.data). porém o formato das horas continha o caractere “:”.

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.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. podendo ser manipulado facilmente. Figura 35 – Visualização em Bloco de Notas .

48 Figura 36 – Visualização no Microsoft Excel .

quando pressionada a tecla [(↑) Seta para Cima]. Figura 37 – Interface Logo bem grande do lado esquerdo podemos ver a alavanca de acionamento. Por ser um processo bem simples e industrial. automaticamente a esteira é ligada e se houver alguma caixa será iniciado o seu deslocamento. 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. para isso foram utilizados ícones grandes e bem significativos.49 8. pois caso ela esteja no estado DESLIGADO. a parte mais importante da interface. a linguagem tem que ser bem visual e intuitiva. . a esteira permanece parada e não é efetuada a contagem como citado no capítulo anterior. vamos ver como o usuário visualiza todas essas informações e interage com o processo. INTERFACE Após a apresentação de todos os sistemas individualmente. a textura da alavanca é alterada e é selecionado o estado LIGADO.

indo em direção ao sistema de leitura constituído pela coluna de LED’s.50 Figura 38 – Posição Desligado Figura 39 – Posição Ligado Como citado. 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 . se houver alguma caixa ela será deslocada.

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. . independente de ter sido salva ou não a contagem.51 Caso a caixa que passar pelo sistema de leitura for seja uma caixa grande. Figura 38 – Caixa Grande Classificada A qualquer momento pode ser solicitada uma nova contagem. como citado no capitulo anterior a solicitação de uma nova contagem zera as variáveis “caixa_grande” e “caixa_pequena”. 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. na interface esta bem destacado que para a solicitação de uma nova contagem é necessário o pressionamento da tecla “N”.

Figura 44 – Aviso de salvamento do arquivo . Figura 43 – Salvar Contagem Quando solicitado o salvamento da contagem é realizado todo o processo relatado no final do capitulo anterior. que pode ser acionado com o pressionamento da tecla “S”. armazenando a quantidade de caixas grandes e pequenas no arquivo TXT e retornada uma mensagem indicando local e o nome do arquivo salvo.52 Figura 42 – Contagem Zerada O outro botão presente na interface é o botão SALVAR CONTAGEM.

e propiciou a experiência de um projeto. a reprodução do processo industrial de automação foi reproduzido. sendo necessário adaptações. desde o conceito. passando pela implantação e a entrega do projeto funcionando de acordo com os parâmetros propostos. Foi enorme a experiência adquirida. que influenciaria diretamente no código do programa que iria interpretar as informações do sensor. mas isso é justamente o que acontece na realidade. . como relação de polias que dependiam da velocidade de leitura de um sensor. precisando serem emuladas para serem reconhecidas por outro programa. Concluímos que apesar de desafiador.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. que utilizam PLC’s de marcas diferentes. Outro desafio foi a quantidade de softwares utilizados. com várias funções diferentes para se chegar a único objetivo. desde a adaptação do sistema aos parâmetros do produto a ser produzido quanto à necessidade da aplicação de novas tecnologias. assim como no programa de classificação devido ao padrão das entradas do sensor serem apenas verdadeiro ou falso. como foi a utilização de um controle de vídeo-game para redução dos custos com sensores no projeto. enfrentando muitas vezes vários casos de incompatibilidades. em uma linha de produção automatizada pode-se ter vários equipamentos de fabricantes diferentes. vários problemas presentes em um processo industrial puderam ser vividos. pois mesmo em uma escala muito menor.

Negreiros. Projeto Esteira Seletora. Como construir uma esteira transportadora. 2011.com/support/documentation/ScriptReference/ > .org/wiki/Fordismo> Acesso em 14.doc.wikipedia. Unity Script Reference. Carl. Disponível em: <http://pt.com/watch?v=HDgVJQiJpcc >.avi.br/casa-e-jardim/como-construir-uma-esteira- transportadora>.wikipedia. a enciclopédia livre. jan. Dispnível em: < http://www. Wikipédia. Disponível em: <http://glovepie. 2012 <http://unity3d. Documentation .org/wiki/Bluetooth> Acesso em 27. Fordismo. a enciclopédia livre.com. Disponível em: <http://pt. 2012 CEBILDS.org/> Acesso em: 12 nov. fev. Acesso em: 28 nov.comofazertudo.54 REFERÊNCIA BIBLIOGRÁFICA ALMANADA.GlovePIE. Disponível em: <http://www. 2011 UNITY3D. jan. 2011 KENNER. Acesso em 23 nov. 2012 Wikipédia.youtube. Bluetooth. Acesso em 12.

Datasheat do tranistor BD135 .55 ANEXOS 1.

56 .

57 .

58 .

Datasheet do Opto-acoplador 4N25 .59 2.

60 .

61 .

62 .

63 .

64 .

. . if (LigaDesliga. . . . . var instante : float.text = "" + caixa_grande. Script .Find("caixa_grande_text"). import System. static var caixa_grande : int = 0. function Update(){ //Display das informações GameObject. . .acionamento == true){ . var lista2 = new Array (). . static var total_de_caixas : int = 0. . . . . var HAB = true. .principal 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 .guiText.Find("caixa_pequena_text").65 3.text = "" + caixa_pequena. . GameObject. static var data : String. .IO. . var ident : int. static var caixa_pequena : int = 0. import System.guiText. . . .

ident = 0. .GetKeyDown ("b")) && (HAB == true) ){ instante = Time.time. . . . . } if (Input. . . . . . . } //Leituras sequintes if (HAB == false){ if (Input.GetKeyDown ("a") || Input.Push ("a").GetKeyDown ("b")){ lista2.Push ("b").Push ("a"). . if (Input. . .GetKeyDown ("a")){ lista2. . . . . } HAB = false.GetKeyDown ("b")){ lista2.GetKeyDown ("a")){ lista2. . } if (Input. .66 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 . //Primeira leitura if ( (Input.Push ("b"). } . .

} if (ident == 0){ caixa_pequena++. .Clear(). . . . . n < lista2. .N)){ . . .length.67 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 64 65 66 . } //Iniciar nova contagem if (Input. . . . . HAB = true. } lista2. . . } } //Classificação if ((HAB == false) && (Time. } } if (ident > 0){ caixa_grande++.time > instante + 3)){ for (var n=0. . . . . . n++){ if (lista2[n]=="a"){ ident++. .GetKey(KeyCode. .

ToString(). principal. . .ToString(). .Hour. var hora = System.DateTime.caixa_pequena = 0. var min = System.txt"). .caixa_grande = 0.DateTime.Year.GetKey(KeyCode.Now.total_de_caixas = 0.data = dia+"-"+mes+"-"+ano+" "+hora+"h"+min+"m"+seg+"s". . WriteFile("C:/Relatório "+principal. .Day.data+". //Salvar a contagem if (Input. .68 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 .DateTime. principal. .DateTime. . . .Now.Month.Now. .Second.ToString(). } function WriteFile (filepathIncludingFileName : String){ .ToString(). . var mes = System. principal.Now. . . . .Now. } } principal. .Minute.DateTime. var ano = System. .DateTime. var seg = System.Now.S)){ var dia = System. .ToString(). .ToString().

Close(). sw. ."+principal. sw. var sw : StreamWriter = new StreamWriter (filepathIncludingFileName)."+principal. .caixa_pequena).WriteLine(principal. .Flush().caixa_grande).data). .WriteLine("Relatório de Caixas Produzidas")."+principal. } . sw.total_de_caixas). sw. . sw. sw.WriteLine("Quantidade de caixas grande: .WriteLine("Quantidade de caixas pequenas: .WriteLine("---------------------------------------------------"). .69 89 90 91 92 93 94 95 96 97 98 99 . sw. . . sw. . sw.WriteLine("---------------------------------------------------").WriteLine("Quantidade Total de Caixas: . .

Script – LigaDesliga 1 2 3 4 5 6 7 8 9 . . renderer.GetKeyDown (KeyCode. . .GetKeyDown (KeyCode.material. } } static var acionamento = false. var des : Texture.mainTexture = des. Debug.Log ("DESLIGADO").acionamento = false. 15 .acionamento = true. function Update(){ if (Input. . 17 . . . var lig : Texture.material. } if (Input.DownArrow)){ LigaDesliga. 16 . .mainTexture = lig. 11 .Log ("LIGADO"). 10 .UpArrow)){ LigaDesliga. 14 . renderer. Debug. .70 4. . 13 . 12 .

. . . .dot2vis) var. .dot1vis var. } WiiMote. Script .Down){ var.Rumble = var.B = WiiMote. .ativado = True // Acioamento A = !(WiiMote. . .ativado = False if (Keyboard. .ativado } if (Keyboard.A = WiiMote. .dot2vis // Leitura . .dot1vis) B = !(WiiMote. . .InterfaceEsteira 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 .Up){ var. . .71 5. .

72 6. Fotos da Esteira VISÃO GERAL DETALHE DA ESTEIRA .

Sign up to vote on this title
UsefulNot useful