controle remoto de um braço robótico por navegador web

48
INSTITUTO DE ENSINO SUPERIOR PLANALTO DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO CONTROLE REMOTO DE UM BRAÇO ROBÓTICO ATRAVÉS DE UM NAVEGADOR WEB JORGE SEIXAS MAIA THIAGO ALMEIDA SIQUEIRA ORIENTADOR: MARCEL AUGUSTUS PROJETO FINAL DE GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO PUBLICAÇÃO: NÚMERO DO PROJETO FINAL BRASILIA / DF: DEZEMBRO / 2006

Upload: jessica-ramos

Post on 26-Jul-2015

385 views

Category:

Documents


42 download

TRANSCRIPT

Page 1: Controle Remoto de um Braço Robótico  por Navegador Web

INSTITUTO DE ENSINO SUPERIOR PLANALTO

DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO

CONTROLE REMOTO DE UM BRAÇO ROBÓTICO ATRAVÉS DE UM

NAVEGADOR WEB

JORGE SEIXAS MAIA

THIAGO ALMEIDA SIQUEIRA

ORIENTADOR: MARCEL AUGUSTUS

PROJETO FINAL DE GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO

PUBLICAÇÃO: NÚMERO DO PROJETO FINAL

BRASILIA / DF: DEZEMBRO / 2006

Page 2: Controle Remoto de um Braço Robótico  por Navegador Web

ii

INSTITUTO DE ENSINO SUPERIOR PLANALTO

DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO

CONTROLE REMOTO DE UM BRAÇO ROBÓTICO ATRAVÉS DE UM

NAVEGADOR WEB

JORGE SEIXAS MAIA

THIAGO ALMEIDA SIQUEIRA

PROJETO FINAL SUBMETIDO AO DEPARTAMENTO DE CIÊNCIA DA

COMPUTAÇÃO DO INSTITUTO DE ENSINO SUPERIOR PLANALTO COMO

PARTE DOS REQUISITOS NECESSÁRIOS PARA A OBTENÇÃO DO GRAU DE

BACHAREL EM CIÊNCIA DA COMPUTAÇÃO.

APROVADA POR:

MARCEL AUGUSTUS BARBOSA CARVALHO, Mestre, IME (ORIENTADOR)

SÉRGIO ROBERTO GONSALVES TOURINO, Mestre, UnB (EXAMINADOR

INTERNO)

MILTON LUIZ SIQUEIRA, Doutor, UnB (EXAMINADOR EXTERNO)

Page 3: Controle Remoto de um Braço Robótico  por Navegador Web

iii

RESUMO

Devido aos avanços tecnológicos, o preço dos robôs vem reduzindo

consideravelmente. Em detrimento deste fato os robôs estão cada vez mais

presentes na indústria e no comércio. Atualmente as instituições que passam a

utilizar robôs precisam gastar grandes quantias em treinamento dos funcionários.

Isso ocorre na grande maioria das vezes porque o software de controle dos robôs é

complexo e possui uma interface visual pouco amigável. O presente projeto visa

criar um software que utilize navegadores WEB convencionais para controlar o braço

robótico. Desta forma o usuário 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.

Page 4: Controle Remoto de um Braço Robótico  por Navegador Web

iv

SUMÁRIO

LISTA DE FIGURAS .......................................................................................................................................... V

LISTA DE TABELAS.........................................................................................................................................VI

1. INTRODUÇÃO............................................................................................................................................ 1 1.1. OBJETIVOS ............................................................................................................................................ 2

1.1.1 Geral................................................................................................................................................ 2 1.1.2 Específicos....................................................................................................................................... 2

1.2. METODOLOGIA...................................................................................................................................... 2 1.3. JUSTIFICATIVA ...................................................................................................................................... 2

2. ROBÓTICA INDUSTRIAL........................................................................................................................ 3 2.1. O HARDWARE MECÂNICO..................................................................................................................... 3 2.2. O HARDWARE ELETRÔNICO E O SOFTWARE.......................................................................................... 5 2.3. PROGRAMAÇÃO DE ROBÔS.................................................................................................................... 6

2.3.1 Programação por Aprendizagem ou Manual.................................................................................. 6 2.3.2 Programação por Ensino de Pontos ............................................................................................... 7 2.3.3 Programação Off-Line .................................................................................................................... 7 2.3.4 Programação por Tarefas ............................................................................................................... 7 2.3.5 Linguagens de Programação de Robôs........................................................................................... 7

2.4. PORTA SERIAL....................................................................................................................................... 8 3. MATERIAIS E MÉTODOS ..................................................................................................................... 10

3.1. CARACTERÍSTICAS DO ROBÔ ED-7220C ............................................................................................. 10 3.1.1 Estrutura........................................................................................................................................ 11 3.1.2 Volume de trabalho ....................................................................................................................... 12 3.1.3 Motores.......................................................................................................................................... 12 3.1.4 Sensores de ângulo (Encoders) ..................................................................................................... 13 3.1.5 Microinterruptores (Microswitchs) ............................................................................................... 14 3.1.6 Transmissões ................................................................................................................................. 14 3.1.7 Garra ............................................................................................................................................. 15

3.2. CARACTERÍSTICAS DA MK4................................................................................................................ 15 3.3. ENGENHARIA REVERSA NA COMUNICAÇÃO SERIAL ............................................................................. 16 3.4. IMPLEMENTAÇÃO DO CONTROLE COM DOTNET.................................................................................. 18

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

5. RESULTADOS .......................................................................................................................................... 24

6. CONCLUSÃO............................................................................................................................................ 25 6.1. SUGESTÃO DE TRABALHOS FUTUROS................................................................................................... 25

7. REFERÊNCIAS BIBLIOGRÁFICAS..................................................................................................... 26

8. APÊNDICE ................................................................................................................................................ 27 8.1. CÓDIGO DO PROJETO DE CLASSE MANIPULADORROBOTICO ............................................................... 27 8.2. CÓDIGO DO WEBSERVICE ................................................................................................................... 39

8.2.1 Código do Web.Config .................................................................................................................. 41

Page 5: Controle Remoto de um Braço Robótico  por Navegador Web

v

LISTA DE FIGURAS Figura 2.1. Cinco configurações básicas de braços robóticos ....................................................4 Figura 2.2. Diagrama de blocos de uma controladora de robôs .................................................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 contínua ..........................................................................13 Figura 3.7. Encoder óptico .......................................................................................................13 Figura 3.8. Microswitches das juntas do robô..........................................................................14 Figura 3.9. Tipos de transmissão existentes no braço robótico................................................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 versão 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 protótipo desenvolvido em C#.net 2.0 ......................................................24

Page 6: Controle Remoto de um Braço Robótico  por Navegador Web

vi

LISTA DE TABELAS Tabela 2.1. Parâmetros da comunicação serial...........................................................................9 Tabela 3.1. Caracteristicas do robô ED-7220C........................................................................10 Tabela 3.2. Movimento da juntas .............................................................................................11 Tabela 3.3. Características da controladora MK4 ....................................................................16 Tabela 3.4. Parâmetros da comunicação da controladora MK4...............................................17

Page 7: Controle Remoto de um Braço Robótico  por Navegador Web

1

1. INTRODUÇÃO

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 automação flexível e

reprogramável [1] das linhas de fabricação, torna-se desta forma, o principal meio

para se atingir tais metas. A utilização cada vez mais freqüente de robôs em linhas

de produção (o que é lugar comum no primeiro mundo e aos poucos vem sendo uma

realidade no Brasil) só endossa a posição da robótica como estado da arte em

termos de automação reprogramável. Contudo, não lidam aqui com tecnologia

absolutamente dominada.

Apesar dos sistemas robóticos de hoje possuírem precisão, robustez e

confiabilidade mecânica há muito que se aprender sobre o controle numérico e

operação destas máquinas. Temas como controle adaptativo, simulação

computacional, calibração e autocalibração, ou inteligência artificial, a pouco

deixaram de ser estudos acadêmicos para tornarem-se tecnologias utilizáveis por

alguns poucos (e poderosos devido ao alto custo) usuários de robótica industrial. A

própria metodologia de programação da grande maioria dos robôs hoje em operação

deixa muito a desejar em termos de operacionalidade e eficiência na programação

destes sistemas.

Teleoperação significa literalmente “operação a distância” [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. Graças a isso os

teleoperadores são usados em ambientes hostis e inacessíveis. Por exemplo,

sistemas de teleoperação são amplamente utilizados em laboratórios químicos,

usinas nucleares e exploração do fundo do mar [2],[3].

Um dos problemas mais difíceis na construção de um dispositivo apropriado

para ser manipulado por um operador humano está no lado mestre. No geral,

dispositivos mestres para operações remotas são muito complexos, caros e difíceis

de operar. Freqüentemente estes dispositivos exigem treinamentos específicos. Há

Page 8: Controle Remoto de um Braço Robótico  por Navegador Web

2

na literatura trabalhos de pesquisa dedicados a criar uma maneira mais fácil e

intuitiva de operar a parte mestre [3].

Recentemente, com o avanço das redes de comunicações e tecnologias

como Microsoft .NET surgem novas possibilidades para a construção de dispositivos

para interface humana de baixo custo e baixo tempo de aprendizado do sistema,

visto que a interface dos navegadores WEB são padronizadas e amplamente

difundidas.

1.1. Objetivos

1.1.1 Geral

Neste trabalho pretende-se implementar um serviço capaz de controlar o robô

ED-7220C através de um navegador WEB.

1.1.2 Específicos

• Mapear o protocolo de comunicação da controladora do robô

• Implementar o protocolo mapeado utilizando a ferramenta Microsoft dotNET

2.0

• Implementar um serviço WEB que utilize o protocolo implementado

1.2. Metodologia

A primeira etapa foi realizada espionando a comunicação serial da

controladora MK4 com o software proprietário da mesma. Na segunda etapa foi

utilizado o compilador Visual Studio 2005 da Microsoft para implementar o protocolo

de comunicação da controladora. O último subprojeto caracterizou-se pela

construção de um serviço WEB utilizando ASP.net 2.0.

1.3. Justificativa

A escolha deste tema foi motivada pelo interesse em sistemas de

teleoperação e telemetria.

Trata-se de um assunto de grande relevância para o meio acadêmico e para a

indústria de produção, visto que o trabalho propõe a solução de alguns problemas

como: segurança, flexibilidade, desempenho.

Page 9: Controle Remoto de um Braço Robótico  por Navegador Web

3

2. ROBÓTICA INDUSTRIAL

Um robô pode ser definido como um sistema tecnológico, capaz de substituir

ou assistir o homem na execução de uma variedade de tarefas físicas [6]. Um robô

industrial é uma máquina programável para finalidades gerais. Um robô pode ser

ensinado para se mover em uma seqüência de pontos no espaço a fim de realizar

uma tarefa predefinida, que será repetida até que se ensine nova tarefa. Este

ensinamento é chamado de programação, e é esta característica que permite aos

robôs serem usados em uma grande variedade de diferentes operações industriais,

muitas das quais em conjunto e sincronia com outros equipamentos automatizados.

Dentre estas operações podemos citar a manipulação de peças (carregamento e

descarregamento de máquinas, por exemplo), a soldagem a arco voltaico e por

pontos, a pintura à pistola e a aplicação de cola. [1]

A definição oficial de robô industrial é dada pela Associação das Indústrias de

Robótica (RIA): [1]

"Um robô industrial é um manipulador reprogramável, multifuncional, projetado

para mover materiais, peças, ferramentas ou dispositivos especiais em movimentos

variáveis programados para a realização de uma variedade de tarefas.”

Os robôs são normalmente compostos de duas partes físicas: hardware

mecânico, e hardware eletrônico e software.

2.1. O Hardware Mecânico

Aqui encontramos o mecanismo do robô, ou seja, os elos e as juntas cuja

disposição determina a configuração física do robô, os atuadores do sistema de

acionamento, os sensores de posição de junta (caso existam) e o órgão terminal

(end efector) onde se aloja a ferramenta de trabalho. Os movimentos relativos entre

os diversos componentes do mecanismo são proporcionados por uma série de

juntas. Os elementos rígidos que conectam as diversas juntas de um robô são

chamados de elos ou links. Os movimentos individuais de cada junta são

denominados pelo termo "graus de liberdade" (GL's). Ao analisar a configuração

física dos robôs, percebemos a existência de dois conjuntos de mecanismos bem

distintos quanto a sua função,

• Mecanismo posicionador ou braço do robô;

• Mecanismo de orientação ou punho do robô.

Page 10: Controle Remoto de um Braço Robótico  por Navegador Web

4

Os próprios nomes já definem as funções dos dois conjuntos. O braço

normalmente consiste de um mecanismo espacial de três graus de liberdade que

tem a função de posicionar o punho no espaço cartesiano. O punho, por sua vez,

consiste em um mecanismo com dois ou mais GL's, com a função de dar ao órgão

terminal a requerida orientação [4]. A maioria dos robôs comercialmente disponíveis

na atualidade possui uma das cinco configurações físicas básicas de braços abaixo

citadas (Figura 2.1) [1]:

• Cartesiana ou "tipo pórtico"

• Cilíndrica

• Bi-cilíndrica ou modelo "SCARA"

• Esférica

• Articulada ou de revolução

Figura 2.1. Cinco configurações básicas de braços robóticos

Destas tipologias, a mais comum e a mais difundida em toda a indústria, é a

configuração articulada ou de revolução.

Page 11: Controle Remoto de um Braço Robótico  por Navegador Web

5

Na extremidade do braço, ou no punho, o robô leva acoplado a ele o órgão

terminal, que pode ser de dois tipos: As garras que são utilizadas para captar um

objeto, e que podem possuir métodos de captura diversos dos óbvios meios

mecânicos, como por exemplo, ventosas de sucção ou imãs; e as ferramentas que

são necessárias quando o robô deve fazer algum tipo de operação na peça de

trabalho, que incluem a soldagem a ponto, a soldagem a arco voltaico, pintura,

perfuração e outros.

A precisão de um robô refere-se à capacidade de posicionar a extremidade de

seu órgão terminal em um ponto meta determinado, dentro do espaço de trabalho.

Essa especificação descreve o quão perto do ponto determinado o robô é capaz de

posicionar-se. Entende-se por repetibilidade a capacidade do robô de retornar ao

ponto no espaço previamente indicado. Quase sempre estas duas propriedades são

funções da precisão mecânica do robô.

2.2. O Hardware Eletrônico e o Software

No hardware eletrônico está a controladora do robô que é na verdade o

computador que gerência o software de controle do robô. Ele aloja também os

drivers dos motores, os processadores para os sistemas de segurança e para a

entrada e saída de dados digitais e/ou analógicos, os dispositivos para

armazenagem de programas, para fornecimento de potência elétrica, e a interface

de programação com o usuário. Todo este hardware eletrônico é acondicionado em

uma espécie de gabinete de controle do robô que centraliza a emissão e recepção

de informações seja com o robô, seja com outros dispositivos automáticos presentes

na célula de trabalho. É também neste gabinete que se encontra, ligado através de

um cabo de dados, a unidade de programação ou teach-in box que é um painel de

controle móvel utilizado para mover e programar o robô. Um breve esquema do

funcionamento da controladora do robô pode ser visto na Figura 2.2.

Page 12: Controle Remoto de um Braço Robótico  por Navegador Web

6

Figura 2.2. Diagrama de blocos de uma controladora de robôs

2.3. Programação de Robôs

Os robôs atuais são capazes de fazer muito mais do que, simplesmente,

mover-se por uma seqüência de pontos no espaço. Graças a sua capacidade de

comunicação e troca de dados, eles podem enviar sinais para equipamentos que

operam com eles dentro da célula de trabalho (grupo de máquinas, ferramentas e

empregados que produzem uma família de produtos), ou aceitar informações de

sensores e de outros dispositivos. Podem tomar decisões, pode comunicar-se com

computadores para receber instruções e reportarem dados e problemas de

produção. Todas estas capacidades exigem programação.

A programação de robôs pode ser realizada de várias formas:

2.3.1 Programação por Aprendizagem ou Manual

Na programação por aprendizagem exige-se que o programador desloque o

robô fisicamente através da trajetória desejada, a qual fica gravada na memória pela

controladora do robô. Às vezes chamado de método de "ensino por demonstração",

foi a primeira metodologia de programação, mas ainda hoje é utilizada em tarefas de

pintura à pistola.

Page 13: Controle Remoto de um Braço Robótico  por Navegador Web

7

2.3.2 Programação por Ensino de Pontos

Aqui encontramos a metodologia mais difundida atualmente. Com o uso da

unidade de programação, movimenta-se o robô até o ponto de interesse, que é

então armazenado como uma linha de programa. A trajetória do robô, limita-se

então, ao movimento ponto a ponto e não a movimentos contínuos. Para completar,

comandos específicos podem ser adicionados possibilitando a abertura e

fechamento da garra, a tomada de decisões e a entrada e saída de dados. A este

conjunto de instruções damos o nome de linguagens de programação robóticas.

2.3.3 Programação Off-Line

A programação off-line utiliza-se de simulação gráfica computacional para

produzir a trajetória desejada pelo operador. Todo o processo de determinação de

trajetórias, de um ou mais robôs dentro da célula de trabalho, é realizado sem o

acesso físico ao manipulador e seu ambiente. O resultado da programação é

mostrado ao operador por meio de animações, através do uso de computação

gráfica, e, se aprovada, é enviada ao robô na forma digital (disquetes ou

comunicação serial).

2.3.4 Programação por Tarefas

A programação por tarefas é o modo mais avançado de programação robótica

de nossos dias. Uma boa analogia de métodos se faz na programação orientada à

objetos, das linguagens de programação normais de microcomputadores. Na

programação por tarefas, tem-se à disposição várias tarefas predefinidas que podem

ser enviadas ao robô. O robô por sua vez, se vale de técnicas de inteligência 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 Programação de Robôs

Por ser uma tecnologia relativamente recente, a indústria ainda não definiu

padrões na robótica. Ao produzir um robô, o fabricante impõe suas próprias

Page 14: Controle Remoto de um Braço Robótico  por Navegador Web

8

preferências gerando para o mercado uma grande torre de babel em termos de

protocolos de comunicação e linguagens de programação. Existem hoje dezenas de

linguagens para robôs com diferentes níveis de capacidade. Algumas, como VAL II,

desenvolvida pela Unimate, e AML, desenvolvida pela IBM, possuem funções

matemáticas e booleanas, e permitem a estruturação do programa, com subrotinas e

loopings condicionais, assemelhando-se às linguagens de uso geral como PASCAL

e BASIC (são as linguagens de alto nível), enquanto outras apenas determinam as

posições das juntas de seu manipulador (linguagens de baixo nível).

2.4. Porta Serial

Em uma porta de comunicação serial, os dados recebidos na forma de 8 ou

mais bits paralelos, são transformados em uma cadeia de pulsos em "fila indiana".

Cada cadeia de pulsos é chamada de palavra. Como os bits de informação são

transmitidos como uma longa série de pulsos, esta forma de transmissão de dados é

chamada de serial.

O tipo de comunicação serial mais usado em todo o mundo é o definido pela

norma RS-232C da EIA (Eletronics Industry Association), daí o nome RS-232. Nas

comunicações seriais, deve-se garantir que a estação receptora esteja pronta e

aguardando no momento da transmissão. As comunicações seriais síncronas se

valem de um sinal auxiliar para assegurar a sincronia da transmissão. As

comunicações seriais assíncronas acrescentam um bit longo no início e fim de cada

bloco de dados, evitando assim erros de interpretação de dados. Ao fim das palavras

de dados são enviados os stop bits, e entre a palavra e o stop bit, há geralmente o

bit de paridade para verificação da integridade dos dados.

Por fim, as comunicações seriais podem ocorrer de duas formas: na half-

duplex apenas uma estação fala por vez, enquanto que na full-duplex pode ocorrer

envio de sinais simultaneamente pelas duas estações [5].

Para que a comunicação serial seja compreendida pelos dispositivos é

necessário que os bits sejam enviados dentro de uma estrutura predefinida, que

compreende as seguintes características: 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).

Page 15: Controle Remoto de um Braço Robótico  por Navegador Web

9

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 número ímpar de bits em 1.

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

Tabela 2.1. Parâmetros da comunicação serial

Taxa de transmissão

(Baud-rate):

É a velocidade de transmissão dos dados. Neste caso,

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.

Número de Bits do

dados:

É o número de bits que têm num dado em questão. Este

valor pode ser de 5, 6, 7 ou 8 bits.

Paridade:

O bit de paridade é usado como um simples esquema de

detecção de erro. Pode ser ímpar, par ou nenhuma, neste

caso não é 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.

Page 16: Controle Remoto de um Braço Robótico  por Navegador Web

10

3. MATERIAIS E MÉTODOS

3.1. Características do robô ED-7220C

Neste projeto foi utilizado o braço robótico 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 características elétricas e mecânicas do robô podem ser vistas na Tabela 3.1.

Tabela 3.1. Caracteristicas do robô ED-7220C

Estrutura mecânica Vertical Articulada Número de Eixos 5 mais garra

±150º - Base +130 º /-35 º - Ombro ±130 º - Braço ±130 º - Flexão Punho

Limite dos Eixos

∞ º - Rotação do Punho Raio máximo de operação 610mm (24.4") Ferramenta Garra com servo motor CC, encoder óptico, dedos paralelos.

Sensor de deslocamento e força Abertura máxima da Garra 75 mm (3") sem borrachas

65 mm (2.6") com borrachas Hardhome Posição fixa de cada eixo encontrada pelos switchs de

calibração Retroalimentação Encoder óptico de cada motor Atuadores Motores CC de 12V e 24V Transmissão Engrenagens, Correia dentada e Sem-fim Peso 25 Kg Velocidade máxima 100 mm/s Temperatura de operação 0ºC a 40ºC

Page 17: Controle Remoto de um Braço Robótico  por Navegador Web

11

3.1.1 Estrutura

O ED-7220C é um robô articulado vertical, com cinco juntas de revolução.

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 braço pode

alcançar).

As figuras Figura 3.2 e Figura 3.3 identificam as juntas e elos do braço

mecânico.

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 Nome da Junta Movimento Nº do Motor 1 Base Rotaciona o corpo 1 2 Ombro (Shoulder) Movimente braço e antebraço 2 3 Cotovelo (Elbow) Movimente antebraço 3 4 Punho (Wrist Pitch) Flexão do punho 4+5 5 Punho (Wrist Roll) Torsão do punho 4+5

Page 18: Controle Remoto de um Braço Robótico  por Navegador Web

12

3.1.2 Volume de trabalho

O comprimento dos elos e o grau de rotação das juntas determinam o volume

de trabalho do robô. Figura 3.4 e Figura 3.5 mostram as dimensões e o alcance do

ED-7220C.

A base do robô é normalmente fixada a uma superfície estacionária. Ele pode,

entretanto estar fixado a um trilho, resultando em um alcance estendido.

Figura 3.4. Volume de trabalho topo

Figura 3.5. Volume de trabalho lateral

3.1.3 Motores

Os cinco eixos do motor e a garra são operados por servo motores de

corrente contínua (Figura 3.6). A direção da revolução é determinada pela polaridade

da voltagem de operação.

Cada motor é equipado com um encoder para controle da malha fechada. Ou

seja, a posição do motor controlada pela posição de encoder. O sistema servo motor

se encarrega da tensão aplicada no motor para que a posição do encoder desejado

seja alcançada.

Page 19: Controle Remoto de um Braço Robótico  por Navegador Web

13

Figura 3.6. Servo motor de corrente contínua

3.1.4 Sensores de ângulo (Encoders)

A localização e a movimentação de cada eixo são 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 rotação

sofrida por este motor. A seqüência dos sinais indica a direção do movimento.

A controladora lê estes sinais e determina a extensão e a direção da

movimentação do eixo.

Figura 3.7. Encoder óptico

Page 20: Controle Remoto de um Braço Robótico  por Navegador Web

14

3.1.5 Microinterruptores (Microswitchs)

Cinco microswitches estão fixados na estrutura do braço robótico. Quando o

robô assume a posição na qual os switches de todas as juntas então pressionados,

esta posição é denominada como home (casa). Este é o ponto de referência do

robô. Sempre que a controladora for ligada, o robô deverá ser mandado para esta

posição, através da rotina softhome.

Figura 3.8. Microswitches das juntas do robô

3.1.6 Transmissões Vários tipos de transmissão são usados para mover os elos do braço robótico.

• 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 transmissão existentes no braço robótico

Page 21: Controle Remoto de um Braço Robótico  por Navegador Web

15

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 são contrários, a garra faz um movimento de

torção. Quando o movimento dos motores é coincidente a garra apresenta um

movimento de flexão. Uma transmissão Sem-fim ligado ao motor 6 controla o

fechamento da garra.

Figura 3.10. Garra do robô

3.2. Características da MK4

Figura 3.11. Foto ilustrativa da MK4

Page 22: Controle Remoto de um Braço Robótico  por Navegador Web

16

Algumas das características da controladora se encontram Tabela 3.3. Tabela 3.3. Características da controladora MK4

Terminais de entrada 8 portas e LED Switchs de entrada 8 switchs Terminais de Saída 8 portas e LED

Processador Processador de 16bit controlador do motor 8bit Teach pendat 8bit.

Softwares ED-72C RoboTalk ED-7220C Arm Robot Trainer

3.3. Engenharia reversa na comunicação serial

Neste projeto foi feito a engenharia reversa do protocolo de comunicação, que

efetua a comunicação 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 propósito e duas portas

seriais adicionais para que os bytes enviados (Figura 3.13), pelos dois dispositivos,

possam ser lidos. Os bytes são visualizados no computador espião com o Software

Docklight (Figura 3.14).

Figura 3.12. Diagrama do cabo utilizado na engenharia reversa

Page 23: Controle Remoto de um Braço Robótico  por Navegador Web

17

Figura 3.13. Esquema do monitoramento da porta serial

A partir deste ponto foram analisados os dados recebidos nas duas portas

tornando possível o mapeamento das funções e parâmetros da comunicação.

O mapeamento das funções utilizadas, ou seja, o protocolo da controladora

do robô pode ser visto na Tabela 3.4.

Tabela 3.4. Parâmetros da comunicação da controladora MK4

Comando Parâmetro Função Exemplo th Nenhum HandShake tr\r sc Nenhum HandShake sc\r cr,0 Nenhum HandShake cr,0\r pd Motor, Encoder Alterar Encoder Motor pd,E,200\r ms Motor Mover Motor ms,F\r mc Nenhum Mover Todos os Motores mc\r tx Nenhum Finalizar Comunicação tx\r ss Nenhum Verificar a Disponibilidade ss\r

Page 24: Controle Remoto de um Braço Robótico  por Navegador Web

18

Figura 3.14. Tela do software Docklight versão 1.3.33

3.4. Implementação do controle com dotNET

A programação 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.

Page 25: Controle Remoto de um Braço Robótico  por Navegador Web

19

Figura 3.15. Tela do Visual Studio 2005

Na Figura 3.15 pode ser visto a ferramenta Visual Studio e a aplicação deste

projeto.

Page 26: Controle Remoto de um Braço Robótico  por Navegador Web

20

4. CONTROLE USANDO DOT NET

Fora desenvolvido um projeto intitulado “ManipuladorRobotico”, com todas as

classes e métodos necessários 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 união de duas instâncias da classe

motor com métodos semelhantes, visando o controle da Garra que se dá através de

dois motores.

Para o Acesso via comunicação serial, foi feita uma implementação de uma

classe intitulada “PortaSerial” que herda a classe System.IO.Ports.SerialPort da

Framework 2.0. Tal herança se deve por haver a necessidade de parâmetros

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 fábrica de portas, que sempre retornará a porta em questão

aberta e pronta para o uso, na instância dos objetos, garantindo assim que não

existirá a tentativa de abertura de duas portas alocadas no mesmo endereço I/O.

O objetivo é de controlar o braço robótico através 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 serviço tem como meta

atender a diferentes requisições de ambientes distintos e garantir a portabilidade do

“serviço” a qualquer dispositivo que possa acessar e consumir tais métodos.

4.1. Interface WEB

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

melhor experiência pelo usuário. Tendo em vista que a controladora somente aceita

Encoders para a movimentação dos atuadores, fora desenvolvido um componente

em Macromedia FLASH 8, que atuará como controlador e decodificador dos

Encoders. Tal componente efetua os cálculos da cinemática inversa, ou seja, o

usuário terá somente que definir a onde o robô ficará com a garra após o

movimento, através de uma clique e arrastar do mouse.

Além da função de movimento do robô, o usuário terá também controle sobre

a abertura e fechamento da garra, e conseguirá trazer o braço robótico para a

posição inicial a um clique de mouse.

Page 27: Controle Remoto de um Braço Robótico  por Navegador Web

21

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 movimentação dos mesmos através de movimentos coesos e

seqüenciais.

Nela é iniciada a comunicação com o robô e também finalizada.

Page 28: Controle Remoto de um Braço Robótico  por Navegador Web

22

A classe ”Motor”, é utilizada pelas instâncias na classe de ”Robo”, e também

na ”JuntaGarra”. Tem como objetivo disponibilizar total função do motor. A classe

também faz as conversões de valores dos ”Encoders” para ”Angulos”, e através de

um evento pode repercutir o movimento dos motores nos motores seqüenciais 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 função é a movimentação da ”Garra”, sendo possível ”Rotacionar” e

”Flexionar”, nestes movimentos é feita a combinação dos ângulos dos motores B e C

do Robô, e calculado o angulo exato de cada um para que o movimento seja

síncrono e termine no ângulo desejado de rotação ou de flexão.

Page 29: Controle Remoto de um Braço Robótico  por Navegador Web

23

Classe Selada, estática, provendo inicialmente somente a função de espera, a

qual segura a Thread da aplicação por 300 milisegundos.

Utilizadas em vários locais, temos as listas de Motores e de Situação da

Garra.

A classe de porta serial tem como objetivo ser instanciada a fim de que sejam

enviados e recebidos comandos através da Serial, com os parâmetros da

controladora, e com os formatos desejados, sem que se tenha que alterar cada

parâmetro a cada nova instância. Ela Herda da classe System.IO.Ports.PortaSerial.

Todos os códigos fontes das aplicações podem ser encontrados no Anexo 1.

Page 30: Controle Remoto de um Braço Robótico  por Navegador Web

24

5. RESULTADOS

Durante os testes realizados foram observados alguns problemas de

operação do software. A maioria deles ocorreu devido ao baixo poder de

processamento e memória da controladora. Para que a controladora pudesse

responder aos comandos foi necessário reduzir a freqüência com que as

informações eram enviadas para a controladora.

Com estas modificações a controladora passou a responder a maioria das

vezes. Mas foi observado que a controladora não respondia a dois comandos

subseqüentes sem que houvesse um tempo de pausa após a própria controladora

avisar que estava esperando o comando.

Com o protótipo sendo monitorado pelo Docklight foi possível observar que os

dados enviados e recebidos mostrados nas caixas de texto do protótipo (Figura 5.1)

correspondiam à realidade da comunicação. Então 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 protótipo desenvolvido em C#.net 2.0

Após a implementação do serviço web foram realizados alguns teste para

obter o tempo de respota deste sistema de controle. O tempo entre o envio do

comando pelo serviço web e a movimentação do robô foi em média 12 segundos,

sendo que 5 segundos era o tempo de resposta da própria controladora do robô.

Page 31: Controle Remoto de um Braço Robótico  por Navegador Web

25

6. CONCLUSÃO

Com a conclusão deste projeto, os três subprojetos citados na introdução

foram realizados com sucesso. A primeira etapa que corresponde ao mapeamento

do protocolo gerou informações importantes como funções de conectar,

desconectar, mover motor, posição do motor, pegar Status do robô, etc.

O segundo subprojeto foi implementado utilizando C# com programação

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 serviço WEB e o ASP.net para o

fornecedor do serviço. Com estas ferramentas foi possível criar uma interface

simples e amigável para o usuário.

Este projeto mostrou que é viável desenvolver o controle de uma controladora

antiga utilizando tecnologias recentes. Desta forma este robô pode ser utilizado para

aplicações remotas e até mesmo em dispositivos móveis.

Este trabalho foi bem sucedido, pois conseguiu atingir os objetivos específicos

e o geral.

6.1. Sugestão de trabalhos futuros

Uma possível continuação desse projeto seria a implementação de gráficos

3D para visualização do robô dentro do navegador, juntamente com funcionalidades

como simulação. De forma que as movimentações sejam testadas antes de serem

enviadas para o robô real. E seguidamente implementar uma forma de visualizar o

robô no local de trabalho através de câmeras digitais (CCDs, Webcams, etc...).

Page 32: Controle Remoto de um Braço Robótico  por Navegador Web

26

7. REFERÊNCIAS BIBLIOGRÁFICAS

[1] GROOVER, M.P., Robótica: tecnologia e programação e programação, McGraw-Hill, São 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. 5-17, 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 robótico axial, Brasília, UnB, 1993.

[5] ROSCH, W.L., Desvendando o Hardware do PC, Editora Campus, Rio de Janeiro.

[6] L’HOTE, F.,Rototic components and systems, Prentice-Hall, New Jersey, 1984.

Page 33: Controle Remoto de um Braço Robótico  por Navegador Web

27

8. Apêndice

8.1. Código 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 { SituacaoNãoDefinida, Aberta, Fechada }

}

using System; using System.Collections.Generic; using System.Text; using System.Threading; namespace ManipuladorRobotico { public sealed class Geral { public static void Esperar() { Thread.Sleep(300); } } } using System; using System.Collections.Generic; using System.Text; using 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;

Page 34: Controle Remoto de um Braço Robótico  por Navegador Web

28

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; }

Page 35: Controle Remoto de um Braço Robótico  por Navegador Web

29

} 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)

Page 36: Controle Remoto de um Braço Robótico  por Navegador Web

30

{ throw; } } private void VerificaDisponibilidadeRobo() { do { SerialRobo.EnviarDados("ss\r"); Geral.Esperar(); } while (SerialRobo.RecebeValorLinha().Equals(192)); } } }

using System; using System.Collections.Generic; using System.Text; using 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; } }

Page 37: Controle Remoto de um Braço Robótico  por Navegador Web

31

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);

Page 38: Controle Remoto de um Braço Robótico  por Navegador Web

32

} 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;

Page 39: Controle Remoto de um Braço Robótico  por Navegador Web

33

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();

Page 40: Controle Remoto de um Braço Robótico  por Navegador Web

34

_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 System; using System.Collections.Generic; using System.Text; using 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("Conexão Fechada!!"); } char[] tmp = Dados.ToCharArray();

Page 41: Controle Remoto de um Braço Robótico  por Navegador Web

35

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 System; using System.Collections.Generic; using System.Text; using System.IO.Ports; using System.Threading; namespace ManipuladorRobotico {

Page 42: Controle Remoto de um Braço Robótico  por Navegador Web

36

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(); }

Page 43: Controle Remoto de um Braço Robótico  por Navegador Web

37

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) {

Page 44: Controle Remoto de um Braço Robótico  por Navegador Web

38

throw new Exception("Robô não pode ser encontrado, ou não 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 } }

Page 45: Controle Remoto de um Braço Robótico  por Navegador Web

39

8.2. Código do WebService

using System; using System.Web; using System.Collections; using System.Web.Services; using System.Web.Services.Protocols; using 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

Page 46: Controle Remoto de um Braço Robótico  por Navegador Web

40

{ 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; } }

Page 47: Controle Remoto de um Braço Robótico  por Navegador Web

41

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

}

8.2.1 Código 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> -->

Page 48: Controle Remoto de um Braço Robótico  por Navegador Web

42

</system.web> </configuration>