INSTITUTO DE ENSINO SUPERIOR PLANALTO

DEPARTAMENTO DE CINCIA DA COMPUTAO

CONTROLE REMOTO DE UM BRAO ROBTICO ATRAVS DE UM NAVEGADOR WEB

JORGE SEIXAS MAIA

THIAGO ALMEIDA SIQUEIRA

ORIENTADOR: MARCEL AUGUSTUS

PROJETO FINAL DE GRADUAO EM CINCIA DA COMPUTAO

PUBLICAO: NMERO DO PROJETO FINAL BRASILIA / DF: DEZEMBRO / 2006

INSTITUTO DE ENSINO SUPERIOR PLANALTO

DEPARTAMENTO DE CINCIA DA COMPUTAO

CONTROLE REMOTO DE UM BRAO ROBTICO ATRAVS DE UM NAVEGADOR WEB

JORGE SEIXAS MAIA

THIAGO ALMEIDA SIQUEIRA

PROJETO

FINAL

SUBMETIDO

AO

DEPARTAMENTO

DE

CINCIA

DA

COMPUTAO DO INSTITUTO DE ENSINO SUPERIOR PLANALTO COMO PARTE DOS REQUISITOS NECESSRIOS PARA A OBTENO DO GRAU DE BACHAREL EM CINCIA DA COMPUTAO.

APROVADA POR:

MARCEL AUGUSTUS BARBOSA CARVALHO, Mestre, IME (ORIENTADOR)

SRGIO ROBERTO GONSALVES TOURINO, Mestre, UnB

INTERNO)

(EXAMINADOR

MILTON LUIZ SIQUEIRA, Doutor, UnB (EXAMINADOR EXTERNO)

ii

RESUMO

Devido aos avanos tecnolgicos, o preo dos robs vem reduzindo consideravelmente. Em detrimento deste fato os robs esto cada vez mais presentes na indstria e no comrcio. Atualmente as instituies que passam a utilizar robs precisam gastar grandes quantias em treinamento dos funcionrios. Isso ocorre na grande maioria das vezes porque o software de controle dos robs complexo e possui uma interface visual pouco amigvel. O presente projeto visa criar um software que utilize navegadores WEB convencionais para controlar o brao robtico. Desta forma o usurio j familiarizado com este tipo de interface pode rapidamente aprender a control-lo sem a necessidade de um treinamento.

Abstract

Due to technological advancements, the robot prices are becoming considerably cheaper. Because of that robots are being even more used on industry and commerce. Currently institutions that use robots have to spend a great deal of money on training the employees. Mainly that occurs because the robot controlling software is usually complex and has a non user friendly interface. The current project aims at the implementation of a WEB Interface (that consumes a WEB Service) capable to control an arm robot. The user that is made familiar to the WEB browser can control the arm robot rapidly without any training.

iii

SUMRIO
LISTA DE FIGURAS .......................................................................................................................................... V LISTA DE TABELAS.........................................................................................................................................VI 1. INTRODUO............................................................................................................................................ 1 1.1. OBJETIVOS ............................................................................................................................................ 2 1.1.1 Geral................................................................................................................................................ 2 1.1.2 Especficos....................................................................................................................................... 2 1.2. METODOLOGIA ...................................................................................................................................... 2 1.3. JUSTIFICATIVA ...................................................................................................................................... 2 2. ROBTICA INDUSTRIAL........................................................................................................................ 3 2.1. 2.2. 2.3. 2.3.1 2.3.2 2.3.3 2.3.4 2.3.5 2.4. 3. O HARDWARE MECNICO ..................................................................................................................... 3 O HARDWARE ELETRNICO E O SOFTWARE .......................................................................................... 5 PROGRAMAO DE ROBS .................................................................................................................... 6 Programao por Aprendizagem ou Manual.................................................................................. 6 Programao por Ensino de Pontos ............................................................................................... 7 Programao Off-Line .................................................................................................................... 7 Programao por Tarefas ............................................................................................................... 7 Linguagens de Programao de Robs........................................................................................... 7 PORTA SERIAL....................................................................................................................................... 8

MATERIAIS E MTODOS ..................................................................................................................... 10 3.1. 3.1.1 3.1.2 3.1.3 3.1.4 3.1.5 3.1.6 3.1.7 3.2. 3.3. 3.4. CARACTERSTICAS DO ROB ED-7220C ............................................................................................. 10 Estrutura........................................................................................................................................ 11 Volume de trabalho ....................................................................................................................... 12 Motores.......................................................................................................................................... 12 Sensores de ngulo (Encoders) ..................................................................................................... 13 Microinterruptores (Microswitchs) ............................................................................................... 14 Transmisses ................................................................................................................................. 14 Garra ............................................................................................................................................. 15 CARACTERSTICAS DA MK4................................................................................................................ 15 ENGENHARIA REVERSA NA COMUNICAO SERIAL ............................................................................. 16 IMPLEMENTAO DO CONTROLE COM DOTNET .................................................................................. 18

4.

CONTROLE USANDO DOT NET.......................................................................................................... 20 4.1. 4.2. INTERFACE WEB ................................................................................................................................ 20 DIAGRAMA DAS CLASSES .................................................................................................................... 21

5. 6.

RESULTADOS .......................................................................................................................................... 24 CONCLUSO............................................................................................................................................ 25 6.1. SUGESTO DE TRABALHOS FUTUROS ................................................................................................... 25

7. 8.

REFERNCIAS BIBLIOGRFICAS..................................................................................................... 26 APNDICE ................................................................................................................................................ 27 8.1. CDIGO DO PROJETO DE CLASSE MANIPULADORROBOTICO ............................................................... 27 8.2. CDIGO DO WEBSERVICE ................................................................................................................... 39 8.2.1 Cdigo do Web.Config .................................................................................................................. 41

iv

LISTA DE FIGURAS
Figura 2.1. Cinco configuraes bsicas de braos robticos .................................................... 4 Figura 2.2. Diagrama de blocos de uma controladora de robs ................................................. 6 Figura 2.3. Diagrama de envio do caractere A da tabela ASCII ................................................9 Figura 3.1. Foto ilustrativa do ED-7220C ................................................................................10 Figura 3.2. Elos do rob ........................................................................................................... 11 Figura 3.3. Juntas do rob ........................................................................................................ 11 Figura 3.4. Volume de trabalho topo........................................................................................ 12 Figura 3.5. Volume de trabalho lateral.....................................................................................12 Figura 3.6. Servo motor de corrente contnua ..........................................................................13 Figura 3.7. Encoder ptico ....................................................................................................... 13 Figura 3.8. Microswitches das juntas do rob..........................................................................14 Figura 3.9. Tipos de transmisso existentes no brao robtico................................................ 14 Figura 3.10. Garra do rob ....................................................................................................... 15 Figura 3.11. Foto ilustrativa da MK4 .......................................................................................15 Figura 3.12. Diagrama do cabo utilizado na engenharia reversa ............................................. 16 Figura 3.13. Esquema do monitoramento da porta serial ......................................................... 17 Figura 3.14. Tela do software Docklight verso 1.3.33 ...........................................................18 Figura 3.15. Tela do Visual Studio 2005.................................................................................. 19 Figura 4.1. Interface utilizando Macromedia Flash 8............................................................... 21 Figura 5.1. Tela do prottipo desenvolvido em C#.net 2.0 ...................................................... 24

LISTA DE TABELAS
Tabela 2.1. Parmetros da comunicao serial...........................................................................9 Tabela 3.1. Caracteristicas do rob ED-7220C ........................................................................10 Tabela 3.2. Movimento da juntas ............................................................................................. 11 Tabela 3.3. Caractersticas da controladora MK4 .................................................................... 16 Tabela 3.4. Parmetros da comunicao da controladora MK4............................................... 17

vi

1. INTRODUO

Verifica-se hoje, em todo o meio industrial, uma grande corrida em busca de produtividade, sempre objetivando produtos mais baratos e com melhor qualidade, o que significa, portanto, produtos mais competitivos. A automao flexvel e reprogramvel [1] das linhas de fabricao, torna-se desta forma, o principal meio para se atingir tais metas. A utilizao cada vez mais freqente de robs em linhas de produo (o que lugar comum no primeiro mundo e aos poucos vem sendo uma realidade no Brasil) s endossa a posio da robtica como estado da arte em termos de automao reprogramvel. Contudo, no lidam aqui com tecnologia absolutamente dominada. Apesar dos sistemas robticos de hoje possurem preciso, robustez e confiabilidade mecnica h muito que se aprender sobre o controle numrico e operao destas mquinas. Temas como controle adaptativo, simulao computacional, calibrao e autocalibrao, ou inteligncia artificial, a pouco deixaram de ser estudos acadmicos para tornarem-se tecnologias utilizveis por alguns poucos (e poderosos devido ao alto custo) usurios de robtica industrial. A prpria metodologia de programao da grande maioria dos robs hoje em operao deixa muito a desejar em termos de operacionalidade e eficincia na programao destes sistemas. Teleoperao significa literalmente operao a distncia [2]. Os sistemas teleoperadores em geral consistem em duas partes fisicamente separadas chamadas de mestre e escravo. Um operador humano controla o dispositivo mestre e o escravo age de acordo com os comandos do operador. O operador fisicamente separado do local onde o trabalho deve ser realizado. Graas a isso os teleoperadores so usados em ambientes hostis e inacessveis. Por exemplo, sistemas de teleoperao so amplamente utilizados em laboratrios qumicos, usinas nucleares e explorao do fundo do mar [2],[3]. Um dos problemas mais difceis na construo de um dispositivo apropriado para ser manipulado por um operador humano est no lado mestre. No geral, dispositivos mestres para operaes remotas so muito complexos, caros e difceis de operar. Freqentemente estes dispositivos exigem treinamentos especficos. H

na literatura trabalhos de pesquisa dedicados a criar uma maneira mais fcil e intuitiva de operar a parte mestre [3]. Recentemente, com o avano das redes de comunicaes e tecnologias como Microsoft .NET surgem novas possibilidades para a construo de dispositivos para interface humana de baixo custo e baixo tempo de aprendizado do sistema, visto que a interface dos navegadores WEB so padronizadas e amplamente difundidas. 1.1. Objetivos

1.1.1 Geral Neste trabalho pretende-se implementar um servio capaz de controlar o rob ED-7220C atravs de um navegador WEB. 1.1.2 Especficos 1.2. Mapear o protocolo de comunicao da controladora do rob Implementar o protocolo mapeado utilizando a ferramenta Microsoft dotNET 2.0 Implementar um servio WEB que utilize o protocolo implementado Metodologia A primeira etapa foi realizada espionando a comunicao serial da controladora MK4 com o software proprietrio da mesma. Na segunda etapa foi utilizado o compilador Visual Studio 2005 da Microsoft para implementar o protocolo de comunicao da controladora. O ltimo subprojeto caracterizou-se pela construo de um servio WEB utilizando ASP.net 2.0. 1.3. Justificativa A escolha deste tema foi motivada pelo interesse em sistemas de teleoperao e telemetria. Trata-se de um assunto de grande relevncia para o meio acadmico e para a indstria de produo, visto que o trabalho prope a soluo de alguns problemas como: segurana, flexibilidade, desempenho.

2. ROBTICA INDUSTRIAL

Um rob pode ser definido como um sistema tecnolgico, capaz de substituir ou assistir o homem na execuo de uma variedade de tarefas fsicas [6]. Um rob industrial uma mquina programvel para finalidades gerais. Um rob pode ser ensinado para se mover em uma seqncia de pontos no espao a fim de realizar uma tarefa predefinida, que ser repetida at que se ensine nova tarefa. Este ensinamento chamado de programao, e esta caracterstica que permite aos robs serem usados em uma grande variedade de diferentes operaes industriais, muitas das quais em conjunto e sincronia com outros equipamentos automatizados. Dentre estas operaes podemos citar a manipulao de peas (carregamento e descarregamento de mquinas, por exemplo), a soldagem a arco voltaico e por pontos, a pintura pistola e a aplicao de cola. [1] A definio oficial de rob industrial dada pela Associao das Indstrias de Robtica (RIA): [1] "Um rob industrial um manipulador reprogramvel, multifuncional, projetado para mover materiais, peas, ferramentas ou dispositivos especiais em movimentos variveis programados para a realizao de uma variedade de tarefas. Os robs so normalmente compostos de duas partes fsicas: hardware mecnico, e hardware eletrnico e software. 2.1. O Hardware Mecnico Aqui encontramos o mecanismo do rob, ou seja, os elos e as juntas cuja disposio determina a configurao fsica do rob, os atuadores do sistema de acionamento, os sensores de posio de junta (caso existam) e o rgo terminal (end efector) onde se aloja a ferramenta de trabalho. Os movimentos relativos entre os diversos componentes do mecanismo so proporcionados por uma srie de juntas. Os elementos rgidos que conectam as diversas juntas de um rob so chamados de elos ou links. Os movimentos individuais de cada junta so denominados pelo termo "graus de liberdade" (GL's). Ao analisar a configurao fsica dos robs, percebemos a existncia de dois conjuntos de mecanismos bem distintos quanto a sua funo, Mecanismo posicionador ou brao do rob; Mecanismo de orientao ou punho do rob. 3

Os prprios nomes j definem as funes dos dois conjuntos. O brao normalmente consiste de um mecanismo espacial de trs graus de liberdade que tem a funo de posicionar o punho no espao cartesiano. O punho, por sua vez, consiste em um mecanismo com dois ou mais GL's, com a funo de dar ao rgo terminal a requerida orientao [4]. A maioria dos robs comercialmente disponveis na atualidade possui uma das cinco configuraes fsicas bsicas de braos abaixo citadas (Figura 2.1) [1]: Cartesiana ou "tipo prtico" Cilndrica Bi-cilndrica ou modelo "SCARA" Esfrica Articulada ou de revoluo

Figura 2.1. Cinco configuraes bsicas de braos robticos Destas tipologias, a mais comum e a mais difundida em toda a indstria, a configurao articulada ou de revoluo.

Na extremidade do brao, ou no punho, o rob leva acoplado a ele o rgo terminal, que pode ser de dois tipos: As garras que so utilizadas para captar um objeto, e que podem possuir mtodos de captura diversos dos bvios meios mecnicos, como por exemplo, ventosas de suco ou ims; e as ferramentas que so necessrias quando o rob deve fazer algum tipo de operao na pea de trabalho, que incluem a soldagem a ponto, a soldagem a arco voltaico, pintura, perfurao e outros. A preciso de um rob refere-se capacidade de posicionar a extremidade de seu rgo terminal em um ponto meta determinado, dentro do espao de trabalho. Essa especificao descreve o quo perto do ponto determinado o rob capaz de posicionar-se. Entende-se por repetibilidade a capacidade do rob de retornar ao ponto no espao previamente indicado. Quase sempre estas duas propriedades so funes da preciso mecnica do rob. 2.2. O Hardware Eletrnico e o Software No hardware eletrnico est a controladora do rob que na verdade o computador que gerncia o software de controle do rob. Ele aloja tambm os drivers dos motores, os processadores para os sistemas de segurana e para a entrada e sada de dados digitais e/ou analgicos, os dispositivos para armazenagem de programas, para fornecimento de potncia eltrica, e a interface de programao com o usurio. Todo este hardware eletrnico acondicionado em uma espcie de gabinete de controle do rob que centraliza a emisso e recepo de informaes seja com o rob, seja com outros dispositivos automticos presentes na clula de trabalho. tambm neste gabinete que se encontra, ligado atravs de um cabo de dados, a unidade de programao ou teach-in box que um painel de controle mvel utilizado para mover e programar o rob. Um breve esquema do funcionamento da controladora do rob pode ser visto na Figura 2.2.

Figura 2.2. Diagrama de blocos de uma controladora de robs

2.3.

Programao de Robs Os robs atuais so capazes de fazer muito mais do que, simplesmente,

mover-se por uma seqncia de pontos no espao. Graas a sua capacidade de comunicao e troca de dados, eles podem enviar sinais para equipamentos que operam com eles dentro da clula de trabalho (grupo de mquinas, ferramentas e empregados que produzem uma famlia de produtos), ou aceitar informaes de sensores e de outros dispositivos. Podem tomar decises, pode comunicar-se com computadores para receber instrues e reportarem dados e problemas de produo. Todas estas capacidades exigem programao. A programao de robs pode ser realizada de vrias formas: 2.3.1 Programao por Aprendizagem ou Manual

Na programao por aprendizagem exige-se que o programador desloque o rob fisicamente atravs da trajetria desejada, a qual fica gravada na memria pela controladora do rob. s vezes chamado de mtodo de "ensino por demonstrao", foi a primeira metodologia de programao, mas ainda hoje utilizada em tarefas de pintura pistola.

2.3.2 Programao por Ensino de Pontos

Aqui encontramos a metodologia mais difundida atualmente. Com o uso da unidade de programao, movimenta-se o rob at o ponto de interesse, que ento armazenado como uma linha de programa. A trajetria do rob, limita-se ento, ao movimento ponto a ponto e no a movimentos contnuos. Para completar, comandos especficos podem ser adicionados possibilitando a abertura e fechamento da garra, a tomada de decises e a entrada e sada de dados. A este conjunto de instrues damos o nome de linguagens de programao robticas. 2.3.3 Programao Off-Line

A programao off-line utiliza-se de simulao grfica computacional para produzir a trajetria desejada pelo operador. Todo o processo de determinao de trajetrias, de um ou mais robs dentro da clula de trabalho, realizado sem o acesso fsico ao manipulador e seu ambiente. O resultado da programao mostrado ao operador por meio de animaes, atravs do uso de computao grfica, e, se aprovada, enviada ao rob na forma digital (disquetes ou comunicao serial). 2.3.4 Programao por Tarefas

A programao por tarefas o modo mais avanado de programao robtica de nossos dias. Uma boa analogia de mtodos se faz na programao orientada objetos, das linguagens de programao normais de microcomputadores. Na programao por tarefas, tem-se disposio vrias tarefas predefinidas que podem ser enviadas ao rob. O rob por sua vez, se vale de tcnicas de inteligncia artificial para concatenar e completar as tarefas, sem que para isto o operador tenha que imaginar cada movimento do manipulador. 2.3.5 Linguagens de Programao de Robs

Por ser uma tecnologia relativamente recente, a indstria ainda no definiu padres na robtica. Ao produzir um rob, o fabricante impe suas prprias

preferncias gerando para o mercado uma grande torre de babel em termos de protocolos de comunicao e linguagens de programao. Existem hoje dezenas de linguagens para robs com diferentes nveis de capacidade. Algumas, como VAL II, desenvolvida pela Unimate, e AML, desenvolvida pela IBM, possuem funes matemticas e booleanas, e permitem a estruturao do programa, com subrotinas e loopings condicionais, assemelhando-se s linguagens de uso geral como PASCAL e BASIC (so as linguagens de alto nvel), enquanto outras apenas determinam as posies das juntas de seu manipulador (linguagens de baixo nvel). 2.4. Porta Serial Em uma porta de comunicao serial, os dados recebidos na forma de 8 ou mais bits paralelos, so transformados em uma cadeia de pulsos em "fila indiana". Cada cadeia de pulsos chamada de palavra. Como os bits de informao so transmitidos como uma longa srie de pulsos, esta forma de transmisso de dados chamada de serial. O tipo de comunicao serial mais usado em todo o mundo o definido pela norma RS-232C da EIA (Eletronics Industry Association), da o nome RS-232. Nas comunicaes seriais, deve-se garantir que a estao receptora esteja pronta e aguardando no momento da transmisso. As comunicaes seriais sncronas se valem de um sinal auxiliar para assegurar a sincronia da transmisso. As comunicaes seriais assncronas acrescentam um bit longo no incio e fim de cada bloco de dados, evitando assim erros de interpretao de dados. Ao fim das palavras de dados so enviados os stop bits, e entre a palavra e o stop bit, h geralmente o bit de paridade para verificao da integridade dos dados. Por fim, as comunicaes seriais podem ocorrer de duas formas: na halfduplex apenas uma estao fala por vez, enquanto que na full-duplex pode ocorrer envio de sinais simultaneamente pelas duas estaes [5]. Para que a comunicao serial seja compreendida pelos dispositivos necessrio que os bits sejam enviados dentro de uma estrutura predefinida, que compreende as seguintes caractersticas: baud-rate, tamanho do dado (6, 7 ou 8 bits), paridade, bit de parada e em alguns casos controle de fluxo (Tabela 2.1). A Figura 2.3 mostra o envio da letra A sendo o tamanho da palavra de 8 bits, com 1 stop bit, paridade mpar e com uma velocidade de 300 bps (bits por segundo).

Como a letra A na tabela ASCII possui 2 bits em 1 e os demais em 0, o bit de paridade est em 1 de forma a gerar um nmero mpar de bits em 1.

Figura 2.3. Diagrama de envio do caractere A da tabela ASCII

a velocidade de transmisso dos dados. Neste caso, Taxa de transmisso (Baud-rate): deve-se observar que os dois equipamentos devem estar com a mesma velocidade. Esta velocidade poder ser de: 110, 150, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 ou 115200. Nmero de Bits do dados: o nmero de bits que tm num dado em questo. Este valor pode ser de 5, 6, 7 ou 8 bits. O bit de paridade usado como um simples esquema de Paridade: deteco de erro. Pode ser mpar, par ou nenhuma, neste caso no gerado o bit de paridade. Stop Bit: O stop bit poder ser configurado como 1, 1.5 ou 2 bits, sendo que na maioria das vezes usa-se o 1 ou 2.

Tabela 2.1. Parmetros da comunicao serial

3. MATERIAIS E MTODOS 3.1. Caractersticas do rob ED-7220C

Neste projeto foi utilizado o brao robtico 7220C (Figura 3.1) da empresa coreana ED juntamente com a sua controladora MK4 (Figura 3.11).

Figura 3.1. Foto ilustrativa do ED-7220C Algumas das caractersticas eltricas e mecnicas do rob podem ser vistas na Tabela 3.1. Tabela 3.1. Caracteristicas do rob ED-7220C
Estrutura mecnica Nmero de Eixos Vertical Articulada 5 mais garra 150 - Base +130 /-35 - Ombro 130 - Brao 130 - Flexo Punho - Rotao do Punho 610mm (24.4") Garra com servo motor CC, encoder ptico, dedos paralelos. Sensor de deslocamento e fora 75 mm (3") sem borrachas 65 mm (2.6") com borrachas Posio fixa de cada eixo encontrada pelos switchs de calibrao Encoder ptico de cada motor Motores CC de 12V e 24V Engrenagens, Correia dentada e Sem-fim 25 Kg 100 mm/s 0C a 40C

Limite dos Eixos

Raio mximo de operao Ferramenta Abertura mxima da Garra Hardhome Retroalimentao Atuadores Transmisso Peso Velocidade mxima Temperatura de operao

10

3.1.1 Estrutura O ED-7220C um rob articulado vertical, com cinco juntas de revoluo. Com a garra, o rob apresenta seis graus de mobilidade. Essa forma permite que a ponta terminal possa ser posicionada e orientada arbitrariamente dentro de um grande volume de trabalho (Volume formado por todos os pontos onde o brao pode alcanar). As figuras Figura 3.2 e Figura 3.3 identificam as juntas e elos do brao mecnico.

Figura 3.2. Elos do rob

Figura 3.3. Juntas do rob

O movimento das juntas est descrito na tabela Tabela 3.2.

Tabela 3.2. Movimento da juntas

N do Eixo 1 2 3 4 5 Nome da Junta Base Ombro (Shoulder) Cotovelo (Elbow) Punho (Wrist Pitch) Punho (Wrist Roll) Movimento Rotaciona o corpo Movimente brao e antebrao Movimente antebrao Flexo do punho Torso do punho N do Motor 1 2 3 4+5 4+5

11

3.1.2 Volume de trabalho O comprimento dos elos e o grau de rotao das juntas determinam o volume de trabalho do rob. Figura 3.4 e Figura 3.5 mostram as dimenses e o alcance do ED-7220C. A base do rob normalmente fixada a uma superfcie estacionria. Ele pode, entretanto estar fixado a um trilho, resultando em um alcance estendido.

Figura 3.4. Volume de trabalho topo 3.1.3 Motores

Figura 3.5. Volume de trabalho lateral

Os cinco eixos do motor e a garra so operados por servo motores de corrente contnua (Figura 3.6). A direo da revoluo determinada pela polaridade da voltagem de operao. Cada motor equipado com um encoder para controle da malha fechada. Ou seja, a posio do motor controlada pela posio de encoder. O sistema servo motor se encarrega da tenso aplicada no motor para que a posio do encoder desejado seja alcanada.

12

Figura 3.6. Servo motor de corrente contnua 3.1.4 Sensores de ngulo (Encoders) A localizao e a movimentao de cada eixo so medidas por encoders eletro-ptico fixados nos eixos dos motores das juntas. Quando um eixo de um motor move, o encoder gera uma serie de sinais digitais alternados. A quantidade de sinais proporcional a quantidade da rotao sofrida por este motor. A seqncia dos sinais indica a direo do movimento. A controladora l estes sinais e determina a extenso e a direo da movimentao do eixo.

Figura 3.7. Encoder ptico

13

3.1.5 Microinterruptores (Microswitchs) Cinco microswitches esto fixados na estrutura do brao robtico. Quando o rob assume a posio na qual os switches de todas as juntas ento pressionados, esta posio denominada como home (casa). Este o ponto de referncia do rob. Sempre que a controladora for ligada, o rob dever ser mandado para esta posio, atravs da rotina softhome.

Figura 3.8. Microswitches das juntas do rob 3.1.6 Transmisses Vrios tipos de transmisso so usados para mover os elos do brao robtico. Engrenagens para mover a base e o ombro. Polias dentadas para mover o cotovelo. Polias dentadas e um diferencial para movimentar o pulso Sem-fim para movimentar a abertura da garra.

Figura 3.9. Tipos de transmisso existentes no brao robtico

14

3.1.7 Garra O ED-7220C possui uma garra com borrachas. Essas borrachas podem ser removidas para que outros dispositivos possam ser fixados, como ventosas. O sistema de polias e diferencial movimenta o punho do rob. Quando o movimento entre os motores 4 e 5 so contrrios, a garra faz um movimento de toro. Quando o movimento dos motores coincidente a garra apresenta um movimento de flexo. Uma transmisso Sem-fim ligado ao motor 6 controla o fechamento da garra.

Figura 3.10. Garra do rob 3.2. Caractersticas da MK4

Figura 3.11. Foto ilustrativa da MK4

15

Algumas das caractersticas da controladora se encontram Tabela 3.3. Tabela 3.3. Caractersticas da controladora MK4 Terminais de entrada Switchs de entrada Terminais de Sada Processador Softwares 3.3. 8 portas e LED 8 switchs 8 portas e LED Processador de 16bit controlador do motor 8bit Teach pendat 8bit. ED-72C RoboTalk ED-7220C Arm Robot Trainer

Engenharia reversa na comunicao serial Neste projeto foi feito a engenharia reversa do protocolo de comunicao, que

efetua a comunicao do software ED-7220C Arm Robot Trainer com a controladora do rob MK4. Essa engenharia reversa baseia-se no monitoramento dos bytes enviados pelas duas partes (Controladora/PC). Este monitoramento feito utilizando-se um cabo serial especialmente (Figura 3.12) montado para esse propsito e duas portas seriais adicionais para que os bytes enviados (Figura 3.13), pelos dois dispositivos, possam ser lidos. Os bytes so visualizados no computador espio com o Software Docklight (Figura 3.14).

Figura 3.12. Diagrama do cabo utilizado na engenharia reversa

16

Figura 3.13. Esquema do monitoramento da porta serial

A partir deste ponto foram analisados os dados recebidos nas duas portas tornando possvel o mapeamento das funes e parmetros da comunicao. O mapeamento das funes utilizadas, ou seja, o protocolo da controladora do rob pode ser visto na Tabela 3.4.

Tabela 3.4. Parmetros da comunicao da controladora MK4 Comando th sc cr,0 pd ms mc tx ss Parmetro Nenhum Nenhum Nenhum Motor, Encoder Motor Nenhum Nenhum Nenhum Funo HandShake HandShake HandShake Alterar Encoder Motor Mover Motor Mover Todos os Motores Finalizar Comunicao Verificar a Disponibilidade Exemplo tr\r sc\r cr,0\r pd,E,200\r ms,F\r mc\r tx\r ss\r

17

Figura 3.14. Tela do software Docklight verso 1.3.33

3.4.

Implementao do controle com dotNET A programao do aplicativo foi feita inteiramente com a ferramenta Visual

Studio 2005, utilizando a linguagem C#.net para framework 2.0 visto que esta apresenta suporte nativo para porta serial.

18

Figura 3.15. Tela do Visual Studio 2005 Na Figura 3.15 pode ser visto a ferramenta Visual Studio e a aplicao deste projeto.

19

4. CONTROLE USANDO DOT NET

Fora desenvolvido um projeto intitulado ManipuladorRobotico, com todas as classes e mtodos necessrios para acesso e controle do Rob, tal projeto possui basicamente duas classes principais, sendo uma delas a classe Motor e a outra a classe JuntaGarra, sendo esta ltima uma unio de duas instncias da classe motor com mtodos semelhantes, visando o controle da Garra que se d atravs de dois motores. Para o Acesso via comunicao serial, foi feita uma implementao de uma classe intitulada PortaSerial que herda a classe System.IO.Ports.SerialPort da Framework 2.0. Tal herana se deve por haver a necessidade de parmetros diferenciados e do tratamento no envio e recebimento dos dados. Todos os Objetos instanciados fazem uso de uma mesma porta serial, ou seja utilizamos uma pequena fbrica de portas, que sempre retornar a porta em questo aberta e pronta para o uso, na instncia dos objetos, garantindo assim que no existir a tentativa de abertura de duas portas alocadas no mesmo endereo I/O. O objetivo de controlar o brao robtico atravs de um navegador WEB, para tal fez-se uso da tecnologia de WebServices, e fora criado um WebService baseado em ASP.NET 2.0, intitulado WSControleRobo, tal servio tem como meta atender a diferentes requisies de ambientes distintos e garantir a portabilidade do servio a qualquer dispositivo que possa acessar e consumir tais mtodos.

4.1.

Interface WEB A interface do projeto tende a facilitar o uso do manipulador, visando uma

melhor experincia pelo usurio. Tendo em vista que a controladora somente aceita Encoders para a movimentao dos atuadores, fora desenvolvido um componente em Macromedia FLASH 8, que atuar como controlador e decodificador dos Encoders. Tal componente efetua os clculos da cinemtica inversa, ou seja, o usurio ter somente que definir a onde o rob ficar com a garra aps o movimento, atravs de uma clique e arrastar do mouse. Alm da funo de movimento do rob, o usurio ter tambm controle sobre a abertura e fechamento da garra, e conseguir trazer o brao robtico para a posio inicial a um clique de mouse. 20

Figura 4.1. Interface utilizando Macromedia Flash 8 4.2. Diagrama das Classes

A classe Rob, tem como objetivo unir os atuadores (jbase, jbraco, jombro, jgarra), e efetuar a movimentao dos mesmos atravs de movimentos coesos e seqenciais. Nela iniciada a comunicao com o rob e tambm finalizada.

21

A classe Motor, utilizada pelas instncias na classe de Robo, e tambm na JuntaGarra. Tem como objetivo disponibilizar total funo do motor. A classe tambm faz as converses de valores dos Encoders para Angulos, e atravs de um evento pode repercutir o movimento dos motores nos motores seqenciais se for utilizado o movimento direto de um nico motor no objeto que instancia a classe Robo.

A classe JuntaGarra, basicamente formada por dois objetos de Motor. A principal funo a movimentao da Garra, sendo possvel Rotacionar e Flexionar, nestes movimentos feita a combinao dos ngulos dos motores B e C do Rob, e calculado o angulo exato de cada um para que o movimento seja sncrono e termine no ngulo desejado de rotao ou de flexo.

22

Classe Selada, esttica, provendo inicialmente somente a funo de espera, a qual segura a Thread da aplicao por 300 milisegundos.

Utilizadas em vrios locais, temos as listas de Motores e de Situao da Garra.

A classe de porta serial tem como objetivo ser instanciada a fim de que sejam enviados e recebidos comandos atravs da Serial, com os parmetros da controladora, e com os formatos desejados, sem que se tenha que alterar cada parmetro a cada nova instncia. Ela Herda da classe System.IO.Ports.PortaSerial. Todos os cdigos fontes das aplicaes podem ser encontrados no Anexo 1.

23

5. RESULTADOS Durante os testes realizados foram observados alguns problemas de operao do software. A maioria deles ocorreu devido ao baixo poder de processamento e memria da controladora. Para que a controladora pudesse responder aos comandos foi necessrio reduzir a freqncia com que as informaes eram enviadas para a controladora. Com estas modificaes a controladora passou a responder a maioria das vezes. Mas foi observado que a controladora no respondia a dois comandos subseqentes sem que houvesse um tempo de pausa aps a prpria controladora avisar que estava esperando o comando. Com o prottipo sendo monitorado pelo Docklight foi possvel observar que os dados enviados e recebidos mostrados nas caixas de texto do prottipo (Figura 5.1) correspondiam realidade da comunicao. Ento eliminado a possibilidade de ser um problema dos dados enviados, passou-se a procurar o problema de tempo de envio.

Figura 5.1. Tela do prottipo desenvolvido em C#.net 2.0 Aps a implementao do servio web foram realizados alguns teste para obter o tempo de respota deste sistema de controle. O tempo entre o envio do comando pelo servio web e a movimentao do rob foi em mdia 12 segundos, sendo que 5 segundos era o tempo de resposta da prpria controladora do rob.

24

6. CONCLUSO Com a concluso deste projeto, os trs subprojetos citados na introduo foram realizados com sucesso. A primeira etapa que corresponde ao mapeamento do protocolo gerou informaes importantes como funes de conectar, desconectar, mover motor, posio do motor, pegar Status do rob, etc. O segundo subprojeto foi implementado utilizando C# com programao orientada a objeto. Desta forma foi feito uma analogia do objeto rob real com o objeto implementado, onde estavam presentes: motores, juntas, porta serial, etc. O terceiro e ltimo subprojeto, a interface WEB, foi implementada utilizando o software Flash 8 da Macromedia para o cliente do servio WEB e o ASP.net para o fornecedor do servio. Com estas ferramentas foi possvel criar uma interface simples e amigvel para o usurio. Este projeto mostrou que vivel desenvolver o controle de uma controladora antiga utilizando tecnologias recentes. Desta forma este rob pode ser utilizado para aplicaes remotas e at mesmo em dispositivos mveis. Este trabalho foi bem sucedido, pois conseguiu atingir os objetivos especficos e o geral. 6.1. Sugesto de trabalhos futuros Uma possvel continuao desse projeto seria a implementao de grficos 3D para visualizao do rob dentro do navegador, juntamente com funcionalidades como simulao. De forma que as movimentaes sejam testadas antes de serem enviadas para o rob real. E seguidamente implementar uma forma de visualizar o rob no local de trabalho atravs de cmeras digitais (CCDs, Webcams, etc...).

25

7. REFERNCIAS BIBLIOGRFICAS

[1] GROOVER, M.P., Robtica: tecnologia e programao e programao, McGraw-Hill, So Paulo, 1988. [2] GEETER, J. de; DECRETON, M.; COLON, E. The challenges of telerobotics in a nuclear environment. Robotics and Autonomous Systems, v. 28, p. 517, 1999. [3] KOIVO, A. J. Fundamentals for control of robotics manipulators. John Wiley & Sons, New York, 1989. [4] CARVALHO, G.C., Desenvolvimento dos 3 primeiros graus de liberdade de um manipulador robtico axial, Braslia, UnB, 1993. [5] ROSCH, W.L., Desvendando o Hardware do PC, Editora Campus, Rio de Janeiro. [6] LHOTE, F.,Rototic components and systems, Prentice-Hall, New Jersey, 1984.

26

8. Apndice 8.1. Cdigo do Projeto de Classe ManipuladorRobotico

using System; using System.Collections.Generic; using System.Text; namespace ManipuladorRobotico { public enum Motores { B, C, D, E, F } public enum SituacaoGarra { SituacaoNoDefinida, Aberta, Fechada } } using using using using System; System.Collections.Generic; System.Text; System.Threading;

namespace ManipuladorRobotico { public sealed class Geral { public static void Esperar() { Thread.Sleep(300); } } } using using using using System; System.Collections.Generic; System.Text; System.Threading;

namespace ManipuladorRobotico { public class JuntaGarra { PortaSerial SerialRobo; private Motor B, C; public JuntaGarra(PortaSerial SerialRobo, bool ExecutarZerarGarra, bool EmpilharZeramento) { this.SerialRob = SerialRobo; B = new Motor(Motores.B,this.SerialRobo,false,false); C = new Motor(Motores.C,this.SerialRobo,false,false); B.DesligarRepercussaoMovimento = true;

27

C.DesligarRepercussaoMovimento = true; B.AtualizarMotor(); C.AtualizarMotor(); if (ExecutarZerarGarra) { if (EmpilharZeramento) { this.EmpilharFlexaoGarra(0); this.EmpilharRotacaoGarra(0); } else { this.FlexionarGarra(0); this.RotacionarGarra(0); } } } public void FlexionarGarra(int Angulo) { try { EmpilharFlexaoGarra(Angulo); MoverMotores(); } catch (Exception) { throw; } } public void EmpilharFlexaoGarra(int Angulo) { try { int tmpb = B.Angulo; B.Angulo = (int)((Angulo - B.Angulo + C.Angulo) / 2); C.Angulo = (int)((Angulo + tmpb - C.Angulo) / 2); B.EmpilharMovimento(); C.EmpilharMovimento(); } catch (Exception) { throw; } } public void RotacionarGarra(int Angulo) { try { EmpilharRotacaoGarra(Angulo); MoverMotores(); } catch (Exception) { throw; }

28

} public void EmpilharRotacaoGarra(int Angulo) { try { int tmpb = B.Angulo; B.Angulo = (int)((Angulo + B.Angulo + C.Angulo) / 2); C.Angulo = (int)((Angulo - tmpb - C.Angulo) / -2); B.EmpilharMovimento(); C.EmpilharMovimento(); } catch (Exception) { throw; } } public void AbrirGarra() { AlterarSituacaoGarra(true); } public void FecharGarra() { AlterarSituacaoGarra(false); } private void AlterarSituacaoGarra(bool AbrirGarra) { try { string comando = ""; if (AbrirGarra) { comando = "go\r"; } else { comando = "gc\r"; } SerialRobo.EnviarDados(comando); Geral.Esperar(); VerificaDisponibilidadeRobo(); } catch (Exception) { throw; } }

private void MoverMotores() { try { SerialRobo.EnviarDados("mc\r"); Geral.Esperar(); VerificaDisponibilidadeRobo(); } catch (Exception)

29

{ throw; } } private void VerificaDisponibilidadeRobo() { do { SerialRobo.EnviarDados("ss\r"); Geral.Esperar(); } while (SerialRobo.RecebeValorLinha().Equals(192)); } } } using using using using System; System.Collections.Generic; System.Text; System.Threading;

namespace ManipuladorRobotico { public class Motor { public delegate void MovimentoHandler(int Angulo, Motores MotorOrigem); public event MovimentoHandler RepercutirMovimentoMotor; private bool _DesligarRepercussaoMovimento; public bool DesligarRepercussaoMovimento { get { return _DesligarRepercussaoMovimento; } set { _DesligarRepercussaoMovimento = value; } } PortaSerial SerialRobo; private int _ValorAngulo; private int _ValorEncoder; private int _ValorEncoderAnguloZero; private Motores _NomeMotor; public int Angulo { get { return _ValorAngulo; } set { _ValorAngulo = value; _ValorEncoder = AnguloEncoder(value); } } public int Encoder { get { return _ValorEncoder; } }

30

public int EncoderAnguloZero { get { return _ValorEncoderAnguloZero; } set { _ValorEncoderAnguloZero = value; } } public Motores NomeMotor { get { return _NomeMotor; } set { _NomeMotor = value; } } private int EncoderAngulo(int ValorEncoder) { int Encoder = (ValorEncoder - _ValorEncoderAnguloZero); int tmp = 0; switch (_NomeMotor) { case Motores.B: tmp = (int)(Encoder / 8.838); break; case Motores.C: tmp = (int)(Encoder / 17.383); break; case Motores.D: if (Encoder < 0) { tmp = (int)(Encoder / 35); } else { tmp = (int)(Encoder / 40.555); } break; case Motores.E: tmp = (int)(Encoder / 37.222); break; case Motores.F: tmp = (int)(Encoder / 47.222); break; } return tmp; } private int AnguloEncoder(int ValorAngulo) { int tmp = 0; switch (_NomeMotor) { case Motores.B: tmp = (int)(ValorAngulo * 8.838); break; case Motores.C: tmp = (int)(ValorAngulo * 17.383); break; case Motores.D: if (ValorAngulo < 0) { tmp = (int)(ValorAngulo * 35); } else { tmp = (int)(ValorAngulo * 40.555);

31

} break; case Motores.E: tmp = (int)(ValorAngulo * 37.222); break; case Motores.F: tmp = (int)(ValorAngulo * 47.222); break; } return (tmp + _ValorEncoderAnguloZero) } public Motor(Motores Motor, PortaSerial PortaSerialRobo, bool ExecutarZerarMotor, bool EmpilharZeramento) { _NomeMotor = Motor; SetarAnguloZero(); this.SerialRob = PortaSerialRobo; if (ExecutarZerarMotor) { ZerarMotor(EmpilharZeramento); } } public void ZerarMotor(bool Empilhar) { Angulo = EncoderAngulo(_ValorEncoderAnguloZero); if (!Empilhar) { _DesligarRepercussaoMovimento = true; MoverMotor(); _DesligarRepercussaoMovimento = false; } else { EmpilharMovimento(); } } ;

public Motor(Motores Motor, int Angulo, PortaSerial PortaSerialRobo) { _NomeMotor = Motor; this.Angulo = Angulo; SetarAnguloZero(); this.SerialRob = PortaSerialRobo; _DesligarRepercussaoMovimento = true; MoverMotor(); _DesligarRepercussaoMovimento = false; } private void SetarAnguloZero() { switch (_NomeMotor) { case Motores.B: _ValorEncoderAnguloZero = 59; break; case Motores.C: _ValorEncoderAnguloZero = -141; break;

32

case Motores.D: _ValorEncoderAnguloZero = 230; break; case Motores.E: _ValorEncoderAnguloZero = 0; break; case Motores.F: _ValorEncoderAnguloZero = 0; break; } } public void MoverMotor() { try { SerialRobo.EnviarDados("pd," + _NomeMotor.ToString() + "," _ValorEncoder.ToString() + "\r"); Geral.Esperar(); Geral.Esperar(); //VerificaDisponibilidadeRobo(); SerialRobo.EnviarDados("ms," + _NomeMotor.ToString() + "\r"); Geral.Esperar(); VerificaDisponibilidadeRobo(); if (!DesligarRepercussaoMovimento) { RepercutirMovimentoMotor(_ValorAngulo, _NomeMotor); } } catch (Exception) { + throw; } } public void EmpilharMovimento() { try { SerialRobo.EnviarDados("pd," + _NomeMotor.ToString() + "," + _ValorEncoder.ToString() + "\r"); Geral.Esperar(); Geral.Esperar(); //VerificaDisponibilidadeRobo(); } catch (Exception) { throw; } }

public void AtualizarMotor() { try { SerialRobo.EnviarDados("pa," + _NomeMotor.ToString() + "\r"); Geral.Esperar();

33

_ValorEncoder = SerialRobo.RecebeValorLinha(); _ValorAngulo = EncoderAngulo(_ValorEncoder); Geral.Esperar(); VerificaDisponibilidadeRobo(); } catch (Exception) { throw; } } private void VerificaDisponibilidadeRobo() { do { SerialRobo.EnviarDados("ss\r"); Geral.Esperar(); } while (SerialRobo.RecebeValorLinha().Equals(192)); } } } using using using using

System; System.Collections.Generic; System.Text; System.IO.Ports;

namespace ManipuladorRobotico { public class PortaSerial: SerialPort { public PortaSerial(string CommPort) { this.BaudRate = 9600; this.StopBits = System.IO.Ports.StopBits.Two; this.DataBits = 7; this.Parity = Parity.Odd; this.PortName = CommPort; this.ReadTimeout = 1000; this.WriteTimeout = 1000; this.Encoding = Encoding.ASCII; this.RtsEnable = true; } public void EnviarDados(string Dados) { try { this.RtsEnable = true; if (!this.IsOpen) { throw new Exception("Conexo Fechada!!"); } char[] tmp = Dados.ToCharArray();

34

for (int i = 0; i < tmp.Length; i++) { this.Write(tmp, i, 1); } } catch (System.Exception ex) { throw ex; } } public string ReceberLinha() { string saida = ""; try { while (this.BytesToRead > 0) { int aux = this.ReadByte(); if (aux != 13) { saida += (char)(aux); } } return saida; } catch (System.Exception ex) { throw ex; } } public int RecebeValorLinha() { try { int x = int.Parse(ReceberLinha()); return x; } catch (Exception) { return 32000; //throw ex; } } } } using using using using using System; System.Collections.Generic; System.Text; System.IO.Ports; System.Threading;

namespace ManipuladorRobotico {

35

public class Robo { PortaSerial SerialRobo; public Motor jBase, jBraco, jOmbro; public JuntaGarra jGarra; //Construtor public Robo(string NomePortaSerial) { try { SerialRob = new PortaSerial(NomePortaSerial); } catch (Exception ex) { throw ex; } } public Robo(PortaSerial Serial, bool ZerarMotores, bool EmpilharZeramento) { try { SerialRob = Serial; InicializaJuntas(ZerarMotores,EmpilharZeramento); } catch (Exception ex) { throw ex; } } public bool InicializaJuntas(bool ZerarMotores, bool EmpilharZeramento) { try { InicializarRobo(); jBase = new Motor(Motores.F, SerialRobo,ZerarMotores,EmpilharZeramento); jBase.DesligarRepercussaoMovimento = true; jBraco = new Motor(Motores.D, SerialRobo, ZerarMotores, EmpilharZeramento); jBraco.RepercutirMovimentoMotor += new Motor.MovimentoHandler(RepercutirMovimentosMotores); jOmbro = new Motor(Motores.E, SerialRobo, ZerarMotores, EmpilharZeramento); jOmbro.RepercutirMovimentoMotor+=new Motor.MovimentoHandler(RepercutirMovimentosMotores); jGarra = new JuntaGarra(SerialRobo,ZerarMotores,EmpilharZeramento); if (ZerarMotores && EmpilharZeramento) { this.MoverMotores(); }

36

return true; } catch (Exception) { return false; } } void RepercutirMovimentosMotores(int Angulo, Motores MotorOrigem) { switch (MotorOrigem) { case Motores.D: // jGarra. //mover B,C break; case Motores.E: jBraco.Angulo = jBraco.Angulo - Angulo; jBraco.MoverMotor(); break; } } //Propriedades #region metodos publicos public bool InicializarRobo() { try { bool tmp = false; for (byte tentativas = 0; tentativas <= 7; tentativas++) { if (SerialRobo.IsOpen) { FinalizarComunicacaoRobo(); SerialRobo.Open(); } else { SerialRobo.Open(); } //Char[13]; SerialRobo.EnviarDados("th\r" ); Geral.Esperar(); SerialRobo.EnviarDados("sc\r\r"); Geral.Esperar(); if (SerialRobo.RecebeValorLinha().Equals(128)) { tmp = true; //SerialRobo.EnviarDados("cr,0\r"); Geral.Esperar(); break; } } return tmp; } catch (Exception) {

37

throw new Exception("Rob no pode ser encontrado, ou no responde!"); } } public void FinalizarComunicacaoRobo() { this.SerialRobo.EnviarDados("tx\r"); SerialRobo.Close(); } public void MoverMotores() { try { SerialRobo.EnviarDados("mc\r"); Geral.Esperar(); VerificaDisponibilidadeRobo(); } catch (Exception) { throw; } } #endregion #region metodos privados private void VerificaDisponibilidadeRobo() { do { SerialRobo.EnviarDados("ss\r"); Geral.Esperar(); } while (SerialRobo.RecebeValorLinha().Equals(128)); } #endregion } }

38

8.2.

Cdigo do WebService

using using using using using using

System; System.Web; System.Collections; System.Web.Services; System.Web.Services.Protocols; ManipuladorRobotico;

[WebService(Namespace = "http://tempuri.org/")] [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)] public class Controle : System.Web.Services.WebService { static PortaSerial Porta; public Controle() { } [WebMethod] public string MoverMotores(int Base, int Ombro, int Braco, int RotacaoPunho, int FlexaoPunho, bool AbrirGarra) { try { FabricaPortaSerial(); ManipuladorRobotico.Rob meuRob = new Robo(Porta,false,false); meuRobo.jBase.Angulo = Base; meuRobo.jBase.EmpilharMovimento(); meuRobo.jOmbro.Angulo = Ombro; meuRobo.jOmbro.EmpilharMovimento(); meuRobo.jBraco.Angulo = -Braco - Ombro; meuRobo.jBraco.EmpilharMovimento(); meuRobo.jGarra.EmpilharFlexaoGarra(-FlexaoPunho - Braco Ombro); meuRobo.jGarra.EmpilharRotacaoGarra(RotacaoPunho); meuRobo.MoverMotores(); if (AbrirGarra) { meuRobo.jGarra.AbrirGarra(); } else { meuRobo.jGarra.FecharGarra(); } meuRobo.FinalizarComunicacaoRobo(); return "ok"; } catch (Exception ex) { return ex.Message; } } private static void FabricaPortaSerial() { try

39

{ if (Porta == null) { Porta = new PortaSerial(System.Configuration.ConfigurationManager.AppSettings["Porta"]. ToString()); } else { if (!Porta.IsOpen) { Porta.Open(); } } } catch (Exception) { throw; } } [WebMethod] public void ZerarRobo() { try { FabricaPortaSerial(); ManipuladorRobotico.Rob meuRob = new Robo(Porta, true, true); meuRobo.FinalizarComunicacaoRobo(); } catch (Exception) { throw; } } [WebMethod] public void AbrirGarra(bool Abrir) { try { FabricaPortaSerial(); ManipuladorRobotico.Rob meuRob = new Robo(Porta, false, false); if (Abrir) { meuRobo.jGarra.AbrirGarra(); } else { meuRobo.jGarra.FecharGarra(); } meuRobo.FinalizarComunicacaoRobo(); } catch (Exception) { throw; } }

40

[WebMethod] public void FinalizarConexaoRobo() { try { FabricaPortaSerial(); ManipuladorRobotico.Rob meuRob = new Robo(Porta, true, true); meuRobo.FinalizarComunicacaoRobo(); } catch (Exception) { throw; } } }

8.2.1 Cdigo do Web.Config

<?xml version="1.0"?> <!-Note: As an alternative to hand editing this file you can use the WEB admin tool to configure settings for your application. Use the Website->Asp.Net Configuration option in Visual Studio. A full list of settings and comments can be found in machine.config.comments usually located in \Windows\Microsoft.Net\Framework\v2.x\Config --> <configuration> <appSettings> <add key="Porta" value ="COM2"/> </appSettings> <connectionStrings/> <system.web> <!-Set compilation debug="true" to insert debugging symbols into the compiled page. Because this affects performance, set this value to true only during development. --> <compilation debug="true"/> <!-The <authentication> section enables configuration of the security authentication mode used by ASP.NET to identify an incoming user. --> <authentication mode="Windows"/> <!-The <customErrors> section enables configuration of what to do if/when an unhandled error occurs during the execution of a request. Specifically, it enables developers to configure html error pages to be displayed in place of a error stack trace. <customErrors mode="RemoteOnly" defaultRedirect="GenericErrorPage.htm"> <error statusCode="403" redirect="NoAccess.htm" /> <error statusCode="404" redirect="FileNotFound.htm" /> </customErrors> -->

41

</system.web> </configuration>

42