Rap Overview

Sumário/Resumo RAPID

Características Básicas

Movimento e Princípios E/S

Programação Off-line

Dados Predefinidos e Programas

Índice, Glossário

Índice

IntroduçãoC

arac

terí

stic

as g

erai

s R

AP

ID

3HAC 5780-1Para BaseWare OS 3.2

As informações contidas neste documento estão sujeitas a alterações sem aviso prévio e não deverão ser inter-pretadas como um compromisso da ABB Robotics AB. A ABB Robotics AB não assume qualquer responsabil-idade por eventuais erros que possam surgir neste documento.

Em nenum caso deverá a ABB Robotics AB ser responsabilizada por danos casuais ou de consequência que sur-jam a partir da utilização deste documento, ou do software e hardware aqui descritos.

Este documento ou parte dele não poderá ser copiado ou reproduzido sem permissão, por escrito, da ABB Robot-ics AB e não poderá ser cedido a uma terceira parte, nem ser utilizado para qualquer propósito não autorizado. A transgressão será motivo de processo.

Cópias adicionais deste documento poderão ser obtidas a partir da ABB Robotics AB com seu pagamento à vista.

© ABB Robotics AB

Número do artigo: 3HAC 5780-1Emissão: Para BaseWare OS 3.2

ABB Robotics ABS-721 68 Västerås

Suécia

Características gerais RAPID

ÍNDICEPágina

1 Índice ......................................................................................................... 1-1

2 Introdução ................................................................................................. 2-11 Introdução........................................................................................................................2-1

1.1 Outros Manuais................................................................................................... 2-1

1.2 Como ler este Manual ......................................................................................... 2-1

3 Sumário / Resumo..................................................................................... 3-11 A Estrutura da Linguagem ............................................................................................3-1

2 Controle do Fluxo do Programa ....................................................................................3-3

2.1 Princípios de programação.................................................................................. 3-3

2.2 Chamada de outra rotina ..................................................................................... 3-3

2.3 Controle do programa dentro da rotina............................................................... 3-4

2.4 Parada da execução do programa........................................................................ 3-4

3 Várias Instruções.............................................................................................................3-5

3.1 Atribuição de valores aos dados ......................................................................... 3-5

3.2 Espera.................................................................................................................. 3-5

3.3 Comentários ........................................................................................................ 3-5

3.4 Carregando módulos do programa...................................................................... 3-6

3.5 Várias funções..................................................................................................... 3-6

3.6 Dados básicos ..................................................................................................... 3-6

3.7 Funções de conversão ......................................................................................... 3-7

4 Ajuste de movimentos .....................................................................................................3-9


4.2 Definição da velocidade...................................................................................... 3-9

4.3 Definição da aceleração ...................................................................................... 3-10

4.4 Definição do gerenciamento da configuração .................................................... 3-10

4.5 Definição da carga .............................................................................................. 3-10

4.6 Definição do comportamento próximo de pontos singulares ............................. 3-10

4.7 Deslocamento do programa ................................................................................ 3-11

4.8 “Soft servo”......................................................................................................... 3-11

4.9 Ajuste dos valores de sintonia do robô ............................................................... 3-11

4.10 Zonas globais .................................................................................................... 3-12

4.11 Dados para ajuste dos movimentos................................................................... 3-12

5 Movimentação .................................................................................................................3-13


5.2 Instruções de posicionamento............................................................................. 3-14

Características gerais 2-1


Página

5.3 Procura................................................................................................................ 3-14

5.4 Ativação de saídas ou de interrupções em posições específicas ........................ 3-14

5.5 Controle de movimento se um erro/interrupção ocorrer .................................... 3-15

5.6 Controle de eixos externos ................................................................................. 3-15

5.7 Eixos independentes ........................................................................................... 3-16

5.8 Correção de trajetória ......................................................................................... 3-16

5.9 Controle do transportador ................................................................................... 3-17

5.10 Identificação da carga e detecção de colisões................................................... 3-17

5.11 Funções de posicionamento .............................................................................. 3-17

5.12 Dados de movimentação................................................................................... 3-18

5.13 Dados básicos para os movimentos .................................................................. 3-18

6 Sinais de Entrada e Saída............................................................................................... 3-19

6.1 Princípios de programação ................................................................................. 3-19

6.2 Troca do valor de um sinal ................................................................................. 3-19

6.3 Leitura do valor de um sinal de entrada ............................................................. 3-19

6.4 Testando a entrada em sinais de saída ................................................................ 3-20

6.5 Desativar e ativar módulos de E/O ..................................................................... 3-20

6.6 Definir sinais de entrada e de saída .................................................................... 3-20

7 Comunicação ................................................................................................................... 3-21


7.2 Comunicação usando-se a unidade de programação .......................................... 3-22

7.3 Ler ou escrever em um canal serial baseado em caracteres / arquivo ................ 3-22

7.4 Comunicação usando-se canais/arquivos seriais binários .................................. 3-22

7.5 Dados para canais seriais .................................................................................... 3-23

8 Interrupções..................................................................................................................... 3-25


8.2 Conexão das interrupções às rotinas “trap” ........................................................ 3-25

8.3 Ordenar interrupções .......................................................................................... 3-26

8.4 Cancelar interrupções ......................................................................................... 3-26

8.5 Habilitar/Desabilitar interrupções....................................................................... 3-26

8.6 Tipos de dados para interrupções........................................................................ 3-26

9 Recuperação de Erros..................................................................................................... 3-27


9.2 Criação de uma situação de erro a partir de dentro do programa ....................... 3-28

9.3 Reinício/retorno do tratamento de erros ............................................................. 3-28

9.4 Dados para tratamento de erros .......................................................................... 3-28

10 Sistema & Tempo .......................................................................................................... 3-29

1-2 Características gerais


Página

10.1 Princípios de programação................................................................................ 3-29

10.2 Utilização do relógio para temporizar um evento............................................. 3-29

10.3 Leitura da hora e data atuais ............................................................................. 3-29

10.4 Recuperar informação de hora/data a partir do arquivo ................................... 3-30

11 Matemática.....................................................................................................................3-31


11.2 Cálculos simples em dados numéricos ............................................................. 3-31

11.3 Cálculos mais avançados .................................................................................. 3-31

11.4 Funções aritméticas........................................................................................... 3-32

12 Solda a Ponto .................................................................................................................3-33

12.1 Características da solda a ponto........................................................................ 3-33

12.2 Princípios do SpotWare..................................................................................... 3-34


12.4 Instruções de Solda a ponto .............................................................................. 3-35

12.5 Dados de Solda a ponto .................................................................................... 3-36

13 Solda a Arco...................................................................................................................3-37


13.2 Instruções de solda a arco ................................................................................. 3-37

13.3 Instruções adicionais de solda a arco................................................................ 3-38

13.4 Dados de solda a arco ....................................................................................... 3-38

13.5 Dados adicionais de solda a arco ...................................................................... 3-38

14 GlueWare .......................................................................................................................3-39

14.1 Caraterísticas de colagem ................................................................................. 3-39


14.3 Instruções de colagem....................................................................................... 3-40

14.4 Dados de colagem............................................................................................. 3-40

14.5 Dados do DispenseWare ................................................................................... 3-40

15 Comunicação com Computador Externo....................................................................3-41


15.2 Envio de mensagem controlada pelo programa do robô para o computador.... 3-41

16 Instruções de suporte do RAPID ................................................................................. 43

16.1 Obter dados do sistema ..................................................................................... 43

17 Instruções de Serviço ....................................................................................................3-45

17.1 Direcionamento de um valor para o sinal de teste do robô............................... 3-45

18 Funções com “Strings” .................................................................................................3-47

18.1 Operações básicas ............................................................................................. 3-47

18.2 Comparação e Procura ...................................................................................... 3-47



Página

18.3 Conversão ......................................................................................................... 3-48

19 Multitasking................................................................................................................... 3-49

19.1 Básicos.............................................................................................................. 3-49

19.2 Proteção de acesso de Recurso ......................................................................... 3-49

20 Sumário da Sintaxe ....................................................................................................... 3-51

20.1 Instruções.......................................................................................................... 3-51

20.2 Funções ............................................................................................................. 3-57

4 Características Básicas............................................................................. 4-11 Elementos Básicos ........................................................................................................... 4-1

1.1 Identificadores .................................................................................................... 4-1

1.2 Caracteres de espaço e de linha .......................................................................... 4-2

1.3 Valores numéricos............................................................................................... 4-2

1.4 Valores lógicos.................................................................................................... 4-2

1.5 Valores de “string” .............................................................................................. 4-2

1.6 Comentários........................................................................................................ 4-3

1.7 “Placeholders” .................................................................................................... 4-3

1.8 Cabeçalho do arquivo ......................................................................................... 4-4

1.9 Sintaxe ................................................................................................................ 4-4

2 Módulos............................................................................................................................ 4-7

2.1 Módulos de programa ......................................................................................... 4-7

2.2 Módulos de sistema ............................................................................................ 4-8

2.3 Declaração do módulo ........................................................................................ 4-8

2.4 Sintaxe ................................................................................................................ 4-8

3 Rotinas ............................................................................................................................. 4-11

3.1 Escopo da rotina ................................................................................................. 4-11

3.2 Parâmetros .......................................................................................................... 4-12

3.3 Término da rotina ............................................................................................... 4-13

3.4 Declaração da rotina ........................................................................................... 4-13

3.5 Chamada de procedimento ................................................................................. 4-14

3.6 Sintaxe ................................................................................................................ 4-15

4 Tipos de Dados (data types) ........................................................................................... 4-19

4.1 Tipos de dados sem valor (non-value)................................................................ 4-19

4.2 Tipos de dados iguais (alias)............................................................................... 4-19

4.3 Sintaxe ................................................................................................................ 4-20

5 Dados................................................................................................................................ 4-21

5.1 Escopo dos dados................................................................................................ 4-21

5.2 Declaração de variáveis ...................................................................................... 4-22



Página

5.3 Declaração de persistentes .................................................................................. 4-23

5.4 Declaração de constantes .................................................................................... 4-23

5.5 Dados de inicialização ........................................................................................ 4-24

5.6 Classe de armazenamento................................................................................... 4-24

5.7 Sintaxe ................................................................................................................ 4-25

6 Instruções .........................................................................................................................4-27

6.1 Sintaxe ................................................................................................................ 4-27

7 Expressões ........................................................................................................................4-29

7.1 Expressões aritméticas ........................................................................................ 4-29

7.2 Expressões lógicas .............................................................................................. 4-30

7.3 Expressões com “strings” ................................................................................... 4-31

7.4 Utilização de dados em expressões..................................................................... 4-31

7.5 Utilização de agregados em expressões.............................................................. 4-32

7.6 Utilização de chamadas funcionais em expressões............................................. 4-32

7.7 Prioridade entre operadores ................................................................................ 4-33

7.8 Sintaxe ................................................................................................................ 4-34

8 Recuperação de Erros.....................................................................................................4-37

8.1 Tratamento de erros ............................................................................................ 4-37

9 Interrupções.....................................................................................................................4-39

9.1 Manipulação de interrupções .............................................................................. 4-39

9.2 Rotinas “trap” ..................................................................................................... 4-40

10 Execução de trás para frente........................................................................................4-41

10.1 Manipuladores de trás para frente..................................................................... 4-41

10.2 Limitação de instruções de movimento no manipulador de trás para a frente . 4-42

11 Multitarefa .....................................................................................................................4-43

11.1 Sincronização de tarefas ................................................................................... 4-44

11.2 Comunicação intertarefas.................................................................................. 4-45

11.3 Tipo de tarefa .................................................................................................... 4-46

11.4 Prioridades ........................................................................................................ 4-46

11.5 Dimensões das tarefas....................................................................................... 4-47

11.6 Algo para pensar ............................................................................................... 4-48

5 Movimento e Princípios E/S .................................................................... 5-11 Sistemas de Coordenadas ...............................................................................................5-1

1.1 O ponto central da ferramenta do robô (TCP) .................................................... 5-1

1.2 Sistemas de coordenadas usados para determinar a posição do TCP ................. 5-1

1.3 Sistemas de coordenadas usados para determinar a direção da ferramenta........ 5-6

1.4 Informação relacionada....................................................................................... 5-10



Página

2 Posicion. na Execução do Programa ............................................................................. 5-11

2.1 Geral ................................................................................................................... 5-11

2.2 Interpolação da posição e orientação da ferramenta........................................... 5-11

2.3 Interpolação de trajetos circulares ...................................................................... 5-14

2.4 Eixos independentes ........................................................................................... 5-20

2.5 Soft Servo ........................................................................................................... 5-23

2.6 Parada e reinicialização ...................................................................................... 5-24

2.7 Informação relacionada ...................................................................................... 5-24

3 Sincronização com instruções lógicas............................................................................ 5-25

3.1 Execução sequencial do programa em pontos de parada ................................... 5-25

3.2 Execução sequencial do programa em pontos de passagem............................... 5-25

3.3 Execução simultânea do programa ..................................................................... 5-26

3.4 Sincronização do trajeto ..................................................................................... 5-28


4 Configuração do Robô .................................................................................................... 5-31

4.1 Dados de configuração do robô para 6400C ...................................................... 5-35


5 Modelos cinemáticos de robôs........................................................................................ 5-37

5.1 Cinemática do robô............................................................................................. 5-37

5.2 Cinemática geral ................................................................................................. 5-39

5.3 Informações relacionadas ................................................................................... 5-41

6 Supervisão Movimento/Detecção colisão ...................................................................... 5-43

6.1 Introdução........................................................................................................... 5-43

6.2 Ajuste dos níveis de Detecção de Colisão .......................................................... 5-43

6.3 Caixa de diálogo da supervisão de movimento .................................................. 5-43

6.4 Saídas digitais ..................................................................................................... 5-45

6.5 Limitações .......................................................................................................... 5-45


7 Singularidades ................................................................................................................. 5-47

7.1 Execução do programa através de singularidades .............................................. 5-48

7.2 Movimentação através de singularidades ........................................................... 5-48


8 Zonas Globais .................................................................................................................. 5-51

8.1 Uso das Zonas Globais ....................................................................................... 5-51

8.2 Uso das Zonas Globais ....................................................................................... 5-51

8.3 Definição de Zonas Globais no sistema de coordenadas global......................... 5-51

8.4 Supervisão do TCP do Robô .............................................................................. 5-52



Página

8.5 Ações .................................................................................................................. 5-53

8.6 Tamanho mínimo das Zonas Globais.................................................................. 5-54

8.7 Número máximo de Zonas Globais .................................................................... 5-54

8.8 Falha de corrente, reiniciar e run on ................................................................... 5-54


9 Princípios de E/S .............................................................................................................5-57

9.1 Características de sinais ...................................................................................... 5-57

9.2 Sinais conectados à interrupção.......................................................................... 5-58

9.3 Sinais do sistema................................................................................................. 5-59

9.4 Conexões cruzadas.............................................................................................. 5-59

9.5 Limitações........................................................................................................... 5-60

9.6 Informação relacionada....................................................................................... 5-60

6 Programação off-line................................................................................. 6-11 Programação off-line ......................................................................................................6-1

1 Programação off-line ............................................................................................. 6-1

7 Dados Predefinidos e Programas ............................................................ 7-11 Módulo do sistema User..................................................................................................7-1

1.1 Conteúdo............................................................................................................. 7-1

1.2 Criando um novo dado no módulo ..................................................................... 7-1

1.3 Apagando este dado ............................................................................................ 7-2

8 Index, Glossário .......................................................................................... 8-1

Glossário..............................................................................................................................8-5



Página


Introdução

1 Introdução

Este é um manual de referência contendo explicações detalhadas da linguagem de programação bem como todos os tipos de dados (data types), instruções e funções. Se você está programando off-line, este manual será particularmente útil.

Quando você iniciar a programar o robô, normalmente é melhor consultar o Guia do Usuário até que você fique familiarizado com o sistema.

1.1 Outros Manuais

Antes de utilizar o robô pela primeira vez, consulte Operações Básicas. Ele for-necerá informações básicas sobre a operação do robô.

O Guia do Usuário fornece instruções passo a passo de como efetuar várias tarefas, tais como, mover o robô manualmente, programar, ou iniciar um programa com a produção em andamento.

O Manual do Produto descreve como instalar o robô, bem como procedimentos de manutenção e localização de falhas. Este manual também contém a Especificação do Produto contendo as características e performance do robô.

1.2 Como ler este Manual

Para responder as perguntas Qual instrução devo usar ? ou O que esta instrução sig-nifica ?, veja o Capítulo 3 de Caracteristicas Gerais RAPID : Sumário/Resumo RAPID. Este capítulo descreve resumidamente todas as instruções, funções e tipos de dados agrupados de acordo com as listas de escolha de instrução que são usadas na programação. Incluí igualmente um resumo da sintaxe, que é especialmente útil quando se programa desligado do sistema.

No capítulo 4 de Caracteristicas Gerais RAPID: Características Básicas, explica detalhes inerentes da linguagem. Não é necessário ler este capítulo a não ser que seja um programador experiente.

O capítulo 5 de Caracteristicas Gerais RAPID: Movimento e Princìpios E/S, descreve os vários sistemas de coordenadas do robô, sua velocidade e outras cara-cterísticas de movimento durante diferentes tipos de execução.

Os capítulos 1-3 DataTypes do Sistema e Rotinas, descreve todos os tipos de dados, instruções e funções. Estão escritos em ordem afabética para a sua conveniência.

Este manual descreve todos os dados e programas fornecidos com o robô na entrega. Além deles, existem um número de dados e programas pré-definidos fornecidos com o robô, ou em disquete, ou já carregados. O capítulo 7 de Caracteristicas Gerais RAPID: Programas e Dados Pré-definidos descreve o que acontece quando eles são carregados no robô.


Introdução

2

Se programar off-line, encontrará algumas dicas no capítulo 6 de Caracteristicas Gerais RAPID: Programação off-line.

Para facilitar a localização e compreensão,o capítulo 8 de Caracteristicas Gerais RAPID contem um índice, e um glossário. O capítulo 4 de DataTypes do Sistema e Rotinas contém um índice.

1.3 Convenções tipográficas

Os comandos localizados abaixo das 5 chaves de menu no topo da unidade de pro-gramação estão escritos no formato de Menu: Command. Por exemplo, para ativar o comando Print no menu File, você deve selecionar File: Print.

Os nomes das teclas de função e nos campos de entrada de dados são especificados em caracter bold itálico, por exemplo, Modpos.

Palavras pertencentes à atual linguagem de programação, tais como nomes de instruções são escritos em caracter itálico, por exemplo, MoveL.

Exemplos de programas são sempre apresentados da mesma forma para saída em disquete ou impressora. Este difere do que é apresentado na unidade de pro-gramação nos seguintes aspectos:

Certas palavras de controle são mascaradas na apresentação e impressão na unidade de programação, por exemplo: palavras indicando o início e o fim de uma rotina.

Dados e declarações das rotinas declarations são impressos em formato formal, por exemplo: VAR num reg1;.

1.4 Regras de sintaxe

As instruções e funções são descritas usando-se ambas as sintaxes simplificada e formal. Se você usar a unidade de programação, geralmente você precisa saber somente a sintaxe simplificada, já que o robô automaticamente assegura que a sin-taxe correta é usada.

-2 Características gerais

Introdução

Sintaxe simplificada

Exemplo:

- Argumentos opcionais estão entre colchetes [ ]. Estes argumentos podem ser omitidos.

- Argumentos que são mutuamente exclusivos, isto é, não podem existir na instrução ao esmo tempo, são separados por uma barra vertical |.

- Argumentos que podem ser repetidos um número arbitrário de vezes estão entre chaves { }.

1.5 Sintaxe formal

Exemplo: TPWrite[String’:=’] <expressão (IN) de string>[’\’Num’:=’ <expressão (IN) de num> ] |[’\’Bool’:=’ <expressão (IN) de bool> ] |[’\’Pos’:=’ <expressão (IN) de pos> ] |[’\’Orient’:=’ <expressão (IN) de orient> ]’;’

- O texto entre colchetes [ ] pode ser omitido.

- Argumentos que são mutuamente exclusivos, isto é, não podem existir na instrução ao esmo tempo, são separados por uma barra vertical |.

- Argumentos que podem ser repetidos um número arbitrário de vezes estão entre chaves { }.

- Símbolos que são escritos para se obter a sintaxe correta estão entre aspas ’ ’.

- O tipo de dado dos argumentos (itálicos) e outras caracterísitcas estão entre os símbolos < >. Veja a descrição dos parâmteros de uma rotina para maiores informações.

Os elementos básicos de linguagem e certas instruções são escritas usando-se uma sin-taxe especial, EBNF. Ela é baseada nas mesmas regras, porém com algumas adições.

Exemplo: GOTO <identifier>’;’<identifier> ::= <ident>

| <ID><ident> ::= <letter> {<letter> | <digit> | ’_’}

- O símbolo ::= significa é definido como.

- O texto entre < > é definido em uma linha separada.

TPWrite String [\Num] | [\Bool] | [\Pos] | [\Orient]

Instrução Argumentoopcional

Argumentoobrigatório

Argumantos mutuamenteexclusivos


Introdução


Sumário RAPID A Estrutura da Linguagem

1 A Estrutura da Linguagem

O programa é constituído por um número de instruções que descrevem o trabalho do robô. Portanto, existem instruções específicas para os vários comandos, tais como, movimentar o robô, ligar uma saída, etc.

As instruções geralmente possuem um número de argumentos associados que definem o que deve ocorrer em uma instrução específica. Por exemplo, a instrução para desligar uma saída contem um argumento que define qual saída deve ser desligada; por exem-plo Reset do5. Estes argumentos podem ser especificados das seguintes maneiras:

- como um valor numérico, por exemplo 5 ou 4.6

- como uma referência a um dado, por exemplo reg1

- como uma expressão, por exemplo 5+reg1*2

- como uma chamada funcional, por exemplo Abs(reg1)

- como um valor “string”, por exemplo "Produção parte A"

Existem três tipos de rotinas – procedimentos, funções e rotinas “trap”.

- um procedimento é usado como um subprograma.

- uma função retorna um valor de um tipo específico e é usado como um argu-mento de uma instrução.

- as rotinas “trap” são um meio de responder a interrupções. Uma rotina “trap” pode ser associada a uma interrupção específica; p. ex. quando uma entrada for ligada, ela é automaticamente executada se a interrupção em particular ocorrer.

As informações podem também ser armazenada s em dados (data), por exemplo, dados de ferramenta (que contem todas as informações sobre a ferramenta, tais como, seu TCP e peso) e dados numéricos (que podem ser usados, por exemplo, para contar o número de peças a serem processadas). Os dados são agrupados em diferentes tipos de tipos de dados (data types) que descrevem diferentes tipos de informações, tais como ferramen-tas, posições e cargas. Como estes dados podem ser criados e possuirem nomes arbi-trários, não existe limite de seu número (exceto imposto pela memória). Estes dados podem existir tanto globalmente no programa ou localmente dentro da rotina.

Existem três de dados – constantes, variáveis e persistentes.

- uma constante representa um valor estático e seu valor somente pode ser alterado manualmente.

- uma variável pode ter seu valor alterado durante a execução do programa.

- uma persistente pode ser descrita como uma variável “persistente”. Quando um programa é salvo, os valores de inicialização refletem os seu valores atuais.

Outras características da linguagem são:

- Parâmetros da Rotina

- Expressões lógicas e aritméticas

- Tratamento automático de erros

- Programas Modulares

- Multitarefa

Característica gerais 3-1

A Estrutura da Linguagem Sumário RAPID

3-2 Característica gerais

Sumário RAPID Controle do Fluxo do Programa

2 Controle do Fluxo do Programa

Normalmente o programa é executado seqüencialmente, isto é, instrução por instrução. Algumas vezes, instruções que interrompem esta seqüência e chamam outras instuções são necessárias para o tratamento de diferentes situações que podem ocorrer durante a execução.

2.1 Princípios de programação

O fluxo do programa pode ser controlado de acordo com cinco princípios diferentes:

- chamada de outra rotina (procedimento) e, quando a rotina tiver sido executada, a execução continua a partir da instrução que chamou a rotina.

- execução de instruções diferentes dependendo se uma dada condição tiver sido ou não satisfeita.

- repetição de uma seqüência de instruções um certo número de vezes ou até que uma dada condição seja satisfeita.

- ida para uma etiqueta (label) dentro da mesma rotina.

- parada da execução do programa.

2.2 Chamada de outra rotina

Instrução Usada para:

ProcCall Chamar (saltar para) outra rotina

CallByVar Chama procedimentos com nomes específicos

RETURN Retornar para a rotina original


Controle do Fluxo do Programa Sumário RAPID

2.3 Controle do programa dentro da rotina


Compact IF Executa uma instrução somente se uma condição for satisfeita

IF Executa uma seqüência de instruções diferentes dependendo se uma dada condição tiver sido ou não satisfeita

FOR Repete uma seção do programa um número de vezes

WHILE Repete uma seqüência de instruções diferentes enquanto uma dada condição estiver satisfeita

TEST Executa instruções diferentes dependendo do valor de umaexpressão

GOTO Salta para uma etiqueta (label)

label Especifica uma etiqueta (nome da linha)

2.4 Parada da execução do programa


Stop Pára a execução do programa

EXIT Pára a execução do programa quando o seu reinício não é permitido

Break Pára a execução do programa temporariamente com o propósito de correção


Sumário RAPID Várias Instruções

3 Várias Instruções

Várias instruções são usadas para

- atribuir valores aos dados,

- esperar um certo período de tempo até que uma condição ser satisfeita,

- inserir um comentário no programa.

- carregar módulos do programa

3.1 Atribuição de valores aos dados

Os dados podem posuir valores arbitrários. Podem, por exemplo, ser iniciados com um valor constante, por exemplo 5, ou atualizados com uma expressão aritmética, por exemplo reg1+5*reg3.


:= Atribuir valores para os dados

3.2 Espera

O robô pode ser programado para esperar um certo período de tempo, ou para esperar que até que uma condição arbitrária seja satisfeita; por exemplo, para esperar até que uma entrada seja setada.


WaitTime Esperar um certo intervalo de tempo ou para esperar atéque o robô pare de se movimentar

WaitUntil Esperar até que uma condição seja satisfeita

WaitDI Esperar até que uma entrada digital seja setada

WaitDO Espera até uma saída digital ser ajustada

3.3 Comentários

Comentários são inseridos no programa somente para aumentar sua leitura. A execu-ção do programa não é afetada por um comentário.


comment Inserir um comentário no programa


Várias Instruções Sumário RAPID

3.4 Carregando módulos do programa

Os módulos do programa podem ser carregados a partir da memória de massa ou apa-gados da memória do programa. Desta forma podem ser manuseados grandes progra-mas apenas com uma pequena memória.


Load Carregar um módulo do programa na memória do programa

UnLoad Descarregar um módulo do programa da memória do pro-grama

Start Load Carrega um módulo de programa na memória de programadurante a execução

Wait Load Conecta o módulo, caso este esteja carregado com StartLoad,na tarefa do programa

Save Salva um módulo de programa

Tipo de dados Usado para:

loadsession Programar uma sessão de carregamento

3.5 Várias funções

Função Usada para:

OpMode Ler o modo de operação atual do robô

RunMode Ler o modo de execução do programa atual do robô

Dim Obter as dimensões de uma matriz (array)

Present Verificar se um parâmetro opcional estava presente quando uma chamada de uma rotina foi feita

IsPers Verificar se um parâmetro é do tipo persistente

IsVar Verificar se um parâmetro é uma variável

3.6 Dados básicos

Tipo de dado Usado para definir:

bool Dados lógicos (com valores de verdadeiro ou falso)

num Valores numéricos (decimal ou inteiro)

symnum Dados numéricos com valores simbólicos

string Caracteres alfanuméricos (strings)

switch Parâmetros da rotina sem valores


Sumário RAPID Várias Instruções

3.7 Funções de conversão


StrToByte Converter um byte em um dado de string com um formato de dados de byte definido.

ByteToStr Converter um string com um formato de dados de byte defi-nido em um dado de byte.


Várias Instruções Sumário RAPID


Sumário RAPID Ajuste de movimentos

4 Ajuste de movimentos

Algumas das características de movimento do robô são determinadas pela utilização de instruções lógicas que se aplicam a todos os movimentos:

- Velocidade máxima e sobrevelocidade

- Aceleração

- Gerenciamento de diferentes configurações do robô

- Carga (payload)

- Comportamento próximo de pontos singulares

- Deslocamento do programa

- Soft servo

- Valores de sintonia


As características básicas dos movimentos do robô são determinadas por dados espe-cifiados para cada instrução de posicionamento. Alguns dados, entretanto, são especi-ficados em instruções separadas que se aplicam a todos os movimentos até a mudança do referido dado.

Os ajustes gerais de movimento são especificados por certas instruções, mas também podem ser lidos pelas variáveis do sistema C_MOTSET ou C_PROGDISP.

Os valores “default” são automaticamente definidos (pela execução da rotina SYS_RESET no módulo de sistema BASE)

- na partida a quente,

- quando um novo programa é carregado,

- quando o programa é executado do início.

4.2 Definição da velocidade

A velocidade absoluta é programada como um argumento na instrução de posiciona-mento. Além disso, a velocidade máxima e a sobrevelocidade (uma porcentagem da velocidade programada) podem ser definidas.

Instrução Usada para definir:

VelSet A velocidade máxima e a sobrevelocidade


Ajuste de movimentos Sumário RAPID

4.3 Definição da aceleração

Quando partes frágeis, por exemplo, são manuseadas, a aceleração pode ser reduzida para uma parte do programa.


AccSet A aceleração máxima

4.4 Definição do gerenciamento da configuração

A configuração do robô normalmente é verificada durante o movimento. Se o movi-mento eixo a eixo (junta) for usado, a configuração correta será atingida. Se o movi-mento linear ou circular for usado, o robô sempre mover-se-á em direção da configuração mais próxima, mas uma verificação é feita para ver se ela é a mesma já programada. Entretanto, isto é pode ser alterado.


ConfJ Ligar/desligar o controle durante o movimento de junta

ConfL Ligar/desligar a verificação durante o movimento linear

4.5 Definição da carga

Para atingir o melhor rendimento, a carga correta deve ser definida.


GripLoad A carga da ferramenta

4.6 Definição do comportamento próximo de pontos singulares

O robô pode ser programado para evitar pontos singulares pela mudança automática da orientação da ferramenta.


SingArea O método de interpolação através dos pontos singulares


Sumário RAPID Ajuste de movimentos

4.7 Deslocamento do programa

Quando uma parte do programa tiver que ser deslocada, por exemplo, após uma pesquisa, um deslocamento de programa pode ser adicionado.


PDispOn Ativar um deslocamento de programa

PDispSet Ativar um deslocamento de programa com um valor

PDispOff Desativar um deslocamento de programa

EOffsOn Ativar um offset para um eixo externo

EOffsSet Ativar um offset para um eixo externo com um valor

EOffsOff Desativar um offset para um eixo externo


DefDFrame Calcular um deslocamento de programa a partir de 3 posições

DefFrame Calcular um deslocamento de programa a partir de 6 posições

ORobT Remover um deslocamento de programa de uma posição

4.8 “Soft servo”

Um ou mais eixos do robô podem ser “soft”. Quando da utilização desta função, o robô será menos rígido e pode substituir uma ferramenta elástica, por exemplo.


SoftAct Ativar o “soft servo” para um ou mais eixos

SoftDeact Desativar o “soft servo”

4.9 Ajuste dos valores de sintonia do robô

Geralmente o rendimento do robô é auto-ajustável; entretanto, certos casos extremos, oscilação, por exemlo, podem ocorrer. Você pode ajustar os valores de sintonia do robô para obter o rendimento necessário.


TuneServo1 Ajustar os valores de sintonia do robô

TuneReset Voltar a sintonia ao normal

PathResol Ajustar a resolução do trajeto geométrico

Tipo de dado Usado para:

tunetype Representar o tipo de regulação como uma constante simbólica

1. Somente quando o robô estiver equipado com a opção“Advanced Motion” (Movimento Avançado)


Ajuste de movimentos Sumário RAPID

4.10 Zonas globais

Até 10 volumes diferentes podem ser definidos dentro da área de trabalho do robô. Esses volumes podem ser usados para:

- Indicar que o TCP do robô é uma parte definida da áre de trabalho.

- Delimitar a área de trabalho para o robô e evitar uma colisão com a ferramenta.

- Criar uma área de trabalho comum para dois robôs. A área de trabalho fica então disponível somente para um robô a cada vez.


WZBoxDef1 Definir uma zona global com a forma de caixa

WZCylDef 1 Definir uma zona global cilíndrica

WZSphDef Definir uma zona global esférica

WZLimSup1 Ativar supervisão de limites para uma zona global

WZDOSet1 Ativar zona global para ajustar saídas digitais

WZDisable1 Desativar supervisão de uma zona global temporária

WZEnable1 Ativar supervisão de uma zona global temporária

WZFree1 Apagar supervisão de uma zona global temporária


wztemporary Identificar uma zona global temporária

wzstationary Identificar uma zona global estacionária

shapedata Descrever a geometria de uma zona global

4.11 Dados para ajuste dos movimentos


motsetdata Ajustes de movimento com excepção da deslocação do pro-grama

progdisp Deslocamento de programa

1. Somente quando o robô está equipado com a opção “Funções avançadas”


Sumário RAPID Movimentação

5 Movimentação

Os movimentos do robô são programados “passo a passo”, isto é, “mova-se a partir da posição atual para a nova posição”. A trajetória entre estas duas posições é então cal-culada automaticamnte pelo robô.


As características básicas dos movimentos, tais como o tipo da trajetória, são especifi-cadas pela escolha da instrução de posicionamento apropriada.

As características restantes são especificadas pela definição de dados que são argu-mentos da instrução:

- Dados de posicionamento (posição final para eixos externos e do robô)

- Dados de velocidade (velocidade desejada)

- Dados de zona (precisão do posicionamento)

- Dados de ferramenta (por exemplo, a posição do TCP)

- Dados de objeto de trabalho (por exemplo, o sistema de coordenadas atual)

Algumas das características dos movimentos são determinadas por instruções lógicas que se aplicam a todos os movimentos (veja Ajuste de movimentos na página 9):

- Velocidade máxima e sobrevelocidade

- Aceleração

- Gerenciamento de diferentes configurações do robô

- Carga (payload)

- Comportamento próximo a pontos singulares

- Deslocamento do programa

- Soft servo

- Valores de sintonia

Ambos os eixos externos e os do robô são posicionados pelas mesmas instruções. Os eixos externos são movimentados a uma velocidade constante, chegando na posição final ao mesmo tempo que o robô.


Movimentação Sumário RAPID

5.2 Instruções de posicionamento

Instrução Tipo de movimento:

MoveC O TCP move-se através de uma trajetória circular

MoveJ Movimento eixo a eixo (junta)

MoveL O TCP move-se através de uma trajetória linear

MoveAbsJ Movimento eixo a eixo (junta) absoluto

MoveCDO Move o robô circularmente e fixa uma saída digital no canto

MoveJDO Move o robô pelo movimento de junta e fixa uma saída digital no canto

MoveLDO Move o robô linearmente e fixa uma saída digital no canto

MoveCSync Move o robô circularmente e executa um procedimento RAPID

MoveJSync Move o robô pelo movimento de junta e executa um procedimento RAPID

MoveLSync Move o robô linearmente e executa um procedimento RAPID

1.Somente se o robô estiver equipado com a opção “Advanced Functions” (Funções Avançadas)

5.3 Procura

Durante o movimento, o robô pode procurar por uma posição de um objeto de trabalho. A posição procurada (indicada por um sinal de um sensor) é armazenada e pode ser usada posteriormente para posicionar o robô ou para calcular um deslocamento de pro-grama.


SearchC TCP em uma trajetória circular

SearchL TCP em uma trajetória linear

5.4 Ativação de saídas ou de interrupções em posições específicas

Normalmente, as instruções lógicas são executadas na transição de uma instrução de posicionamento para outra. Se, entretanto, instruções de movimentação especiais são usadas, estas podem ser executadas ao invés de quando o robô está em uma posição específica.




TriggIO Definir uma condição de transição para ligar uma saída emuma dada posição

TriggInt Definir uma condição de transição para executar uma rotina “trap” em uma dada posição

TriggEquip Define uma condição trigg para ajustar uma saída numa deter-minada posição, com a possibilidade de incluir compensações de tempo de espera no equipamento externo

TriggC1 Move o robô (TCP) circularmente com uma condição de transição ativada

TriggJ1 Move o robô eixo a eixo com uma condição de transição ativada

TriggL1 Move o robô (TCP) linearmente com uma condição de transição ativada


triggdata1 Condições de transição

1.Somente se o robô estiver equipado com a opção “Advanced functions”.

5.5 Controle de movimento se um erro/interrupção ocorrer

Para que se possa corrigir um erro ou uma interrupção, o movimento pode ser parado temporariamente e então reinicado novamente.


StopMove Parar os movimentos do robô

StartMove Reiniciar os movimentos do robô

StorePath1 Armazenar a última trajetória gerada

RestoPath1 Regenerar uma trajetória armazenada anteriormente

1. Somente se o robô estiver equipado com a opção “Advanced functions”.

5.6 Controle de eixos externos

Os eixos externos e os do robô são normalmente posicionados utilizando-se as mesmas instruções. Entretanto, algumas instruções somente afetam os movimentos dos eixos externos.


DeactUnit Desativar uma unidade mecânica externa

ActUnit Ativar uma unidade mecânica externa

MechUnit Load Define uma carga útil para uma unidade mecânica



5.7 Eixos independentes

O eixo 6 do robô (e 4 no IRB 2400/4400), ou um eixo externo, pode ser movido inde-pendente dos outros movimentos. A área de trabalho de um eixo pode também ser rea-justada, o que reduzirá os tempos de ciclo.


IndAMove2 Mudar um eixo para o modo independente e mover o eixo para uma posição

absoluta

IndCMove2 Mudar um eixo para o modo independente e inicializar o movi-mento

contínuo do eixo

IndDMove2 Mudar um eixo para o modo independente e mover o eixo numa distância

delta

IndRMove2 Mudar um eixo para o modo independente e mover o eixo para uma posição

relativa (dentro da revolução do eixo)

IndReset2 Mudar um eixo para o modo independente ou/e reajustar a área de trabalho

IndInpos2 Verificar se um eixo independente está em posição

IndSpeed2 Verificar se um eixo independente alcançou a velocidade pro-gramada

2. Apenas se o robô estiver equipado com a opção “Advanced Motion”.(A instrução HollowWristReset só pode ser usada nos robôs IRB 5402 e IRB 5403.)

5.8 Correção de trajetória


CorrCon2 Conectar a um gerador de correção

CorrWrite2 Gravar os deslocamentos do sistema de coordenadas datrajetória em um gerador de correção

CorrDiscon2 Desconectar de um gerador de conversão conectadoanteriormente

CorrClear2 Remover todos os geradores de correção conectados


CorrRead2 Ler todas as correções fornecidas por todos os geradores decorreção conectados


Corrdescr2 Adicionar deslocamentos geométricos no sistema decoordenadas da trajetória



2. Somente se o robô estiver equipado com a opção “Advanced Motion”.(A instrução HollowWristReset só pode ser usada nos robôs IRB 5402 e IRB 5403).

5.9 Controle do transportador


WaitWObj3 Aguardar o objeto de trabalho no transportador

DropWObj3 Soltar o objeto de trabalho no transportador

3. Somente se o robô estiver equipado com a opção “Conveyor tracking”.

5.10 Identificação da carga e detecção de colisões


MotionSup Desativa/ativa a supervisão de movimento

ParIdPosValid Validar a posição do robô na identificação de parâmetros

ParIdRobValid Validar o tipo de robô para identificação de parâmetros

LoadId Carregar identificação da ferramenta ou carga útil

5.11 Funções de posicionamento


Offs Adicionar um offset a uma posição do robô, expresso em relação ao objeto de trabalho

RelToll Adicionar um offset expresso no sistema de coordenadas da ferramenta

CalcRobT Calcula robtarget a partir de jointtarget

CPos Ler a posição atual (somente x, y, z do robô)

CRobT Ler a posição atual (o robtarget completo)

CJointT Ler os ângulos atuais das juntas

ReadMotor Ler os ângulos atuais dos motores

CTool Ler os valotes atuais do dado de ferramenta (tooldata)

CWobj Ler os valores atuais dos dados do objeto de trabalho (wobj-data)

ORobT Remover um deslocamento de programa de uma posição

MirPos Espelhar uma posição

CalcJointT Calcula ângulos de junção a partir de robtarget

Distance A distância entre duas posições



5.12 Dados de movimentação

Os dados de movimentação são usados como argumento nas instruções de posiciona-mento.

Tipos de dados Usados para definir:

robtarget A posição final

jointtarget A posição final de uma instrução MoveAbsJ

speeddata A velocidade

zonedata A precisão do posicionamento (ponto final ou ponto de passagem)

tooldata O sistema de coordenadas e a carga da ferramenta

wobjdata O sistema de coordenadas do objeto de trabalho

5.13 Dados básicos para os movimentos

Tipos de dados Usados para definir:

pos Uma posição (x, y, z)

orient Uma orientação

pose Um sistema de coordenadas (posição + orientação)

confdata A configuração dos eixos do robô

extjoint A posição dos eixos externos

robjoint A posição dos eixos do robô

o_robtarget A posição original do robô quando Limit ModPos for usado

o_jointtarget A posição original do robô quando Limit ModPos é usado para MoveAbsJ

loaddata Uma carga

mecunit Uma unidade mecânica externa


Sumário RAPID Sinais de Entrada e Saída

6 Sinais de Entrada e Saída

O robô pode ser equipado com um número de sinais digitais e analógicos do usuário que podem ser lidos e mudados a partir do programa.


Os nomes dos sinais são definidos nos parâmetros do sistema e, usando estes nomes, eles podem ser lidos pelo programa. Os valores simbólicos para sinais digitais também são definidos nos parâmetros do sistema. Valores simbólicos, como ligado/desligado ou aberto/fechado, podem ser usados em vez de 1/0 para tornar o programa mais fácil de ler.

O valor de um sinal analógico ou de um grupo de sinais digitais é especificado por um valor numérico.

6.2 Troca do valor de um sinal


InvertDO Inverter o valor de um sinal de saída digital

PulseDO Gerar um pulso em um sinal de saída digital

Reset Resetar um sinal de saída digital (para 0)

Set Setar um sinal de saída digital (para 1)

SetAO Trocar o valor de um sinal de saída analógico

SetDO Trocar o valor de um sinal de saída digital (valor simbólico;por exemplo, high/low)

SetGO Trocar o valor de um grupo de sinais de saída digital

6.3 Leitura do valor de um sinal de entrada

O valor de um sinal de entrada pode ser lido diretamente no programa, por exemplo:

! Entrada digitalIF di1 = 1 THEN ...

! Entrada de grupo digitalIF gi1 = 5 THEN ...

! Entrada analógicaIF ai1 > 5.2 THEN ...


Sinais de Entrada e Saída Sumário RAPID

6.4 Testando a entrada em sinais de saída


WaitDI Esperar até que uma entrada digital seja ajustado ou reajustado

WaitDO Esperar até que um digital de saída seja ajustado ou reajustado


TestDI Testar se uma entrada digital está ajustada

6.5 Desativar e ativar módulos de E/O

Os módulos E/O são ativados automaticamente na inicialização, mas podem ser desa-tivados durante a execução do programa e reativados mais tarde.


IODisable Desativar um módulo de E/O

IOEnable Ativar um módulo de E/O

6.6 Definir sinais de entrada e de saída

Tipos de dado Usados para definir:

dionum O valor simbólico de um sinal digital

signalai O nome de um sinal de entrada analógico *

signalao O nome de um sinal de saída analógico *

signaldi O nome de um sinal de entrada digital *

signaldo O nome de um sinal de saída digital *

signalgi O nome de um grupo de sinais de entrada digital *

signalgo O nome de um grupo de sinais de saída digital *


AliasIO1 Definir um sinal com um pseudônimo

* Somente defindos pelos parâmetros do sistema.

1. Apenas se o robô estiver equipado com a opção “Developer’s Functions”


Sumário RAPID Comunicação

7 Comunicação

Existem quatro maneiras possíveis de comunicação por meio de canais seriais:

- Mensagens podem ser mostradas através do display da unidade de programação e o usuário pode responder perguntas, tais como o número de peças a serem processadas.

- Informações baseadas em caracteres podem ser esctitas ou lidas a partir de arquivos de texto em um disquete. Deste modo, por exemplo, a estatística de produção pode ser armazenada e processada posteriormente em um PC. A informação também pode ser impressa através de uma impressora conectada ao robô.

- Informações binárias podem ser transferidas entre o robô e um sensor, por exemplo.

- Informações binárias podem ser transferidas entre o robô e um sensor, por exemplo, com um protocolo.


A decisão de escolher entre usar a informação baseada em caracteres ou a informação binária depende de como o equipamento com o qual o robô se comunica trata a infor-mação. Um arquivo, por exemplo, pode possuir dados que são armazenados de forma binária ou baseado em caracteres.

Se a comunicação for necessária em ambas as direções simultaneamente, a transmissão binária será necessária.

Cada canal serial ou arquivo deve primeiramente ser aberto. Fazendo-se isso, o canal/arquivo recebe um nome que é usado como uma referência para leitura/escrita. A unidade de programação pode ser usada todas as vezes e não precisa ser aberta.

Ambos texto e valores de certos tipos de dados podem ser impressos.


Comunicação Sumário RAPID

7.2 Comunicação usando-se a unidade de programação


TPErase Limpar o display da unidade de programação

TPWrite Escrever textos no display da unidade de programação

ErrWrite Escrever textos no display da unidade de programação e simul-taneamente armazenar a mensagem no registro de eventos

TPReadFK “Etiquetar” as teclas de função e ler qual tecla está pressionada

TPReadNum Ler um valor numérico a partir da unidade de programação

TPShow Escolher uma janela na unidade de programação a partir do RAPID

7.3 Ler ou escrever em um canal serial baseado em caracteres / arquivo


Open1 Abrir um canal/arquivo para escrita ou leitura

Write1 Escrever um texto em um canal/arquivo

Close1 Fechar o canal/arquivo


ReadNum1 Ler um valor numérico

ReadStr1 Ler um “string” de texto

7.4 Comunicação usando-se canais/arquivos seriais binários


Open1 Abrir um canal serial/arquivo para transferência binária dedados

WriteBin1 Escrever para um canal/arquivo serial binário

WriteStrBin1 Escrever um string para um canal/arquivo serial binário

Rewind1 Ajustar a posição do arquivo no início do arquivo

Close1 Fechar o canal/arquivo

WriteBin1 Escrever em um canal serial binário


ReadBin1 Ler um canal serial binário

1. Somente se robô for equipado com a opção “Advanced functions”


Sumário RAPID Comunicação

7.5 Dados para canais seriais


iodev Uma referência para um canal serial/arquivo que pode ser usada para leitura e escrita


Comunicação Sumário RAPID


Sumário RAPID Interrupções

8 Interrupções

Interrupções são usadas pelo programa para habilita-lo a tratar diretamente de um evento, independente de qual instrução está sendo executada naquele instante.

O programa é interrompido, por exemplo, quando uma entrada específica vai a um. Quando isto ocorrer, o programa é interrompido e uma rotia “trap” especial é exe-cutada. Quando esta tiver sido totalmente executada, o programa continua de onde ele foi interrompido.


Cada interrupção é associada à uma identidade de interrupção. Ela obtém esta identi-dade pela criação de uma variável (do tipo de dado intnum) e conectando-a à uma rotina “trap”.

A identidade da interrupção (variável) é então usada para ordenar uma interrupção, isto é, para especificar a razão da interrupção. Isto pode ser um seguintes eventos:

- uma entrada ou saída é ajustada a um ou a zero.

- um certo intervalo de tempo decorre após o qual a interrupção é ordenada.

- uma posição específica é alcançada.

Quando uma interrupção é ordenada, ela também é automaticamante habilitada, mas pode ser temporariamente desabilitada. Isto pode orcorrer em duas situações:

- Todas as interrupções podem estar desabilitadas. Quaisquer interrupções que ocorram durante este período são colocadas em uma fila e então são automati-camente geradas quando as interrupções são novamente habilitadas.

- As interrupções individuais podem estar desativadas. Quaisquer interrupções que ocorram durante este período são desconsideradas.

8.2 Conexão das interrupções às rotinas “trap”


CONNECT Conectar uma variável (identidade de interrupção) à umarotina “trap”


Interrupções Sumário RAPID

8.3 Ordenar interrupções

Instrução Usada para ordenar:

ISignalDI Uma interrupção a partir de um sinal de entrada digital

SignalDO Uma interrupção de um sinal de saída digital

ITimer Uma interrupção programada

TriggInt1 Uma interrupção de posição fixa (a partir da lista de escolha de Movimento)

8.4 Cancelar interrupções


IDelete Cancelar (deletar) uma interrupção

8.5 Habilitar/Desabilitar interrupções


ISleep Desativar uma interrupção individual

IWatch Ativar uma interrupção individual

IDisable Desabilitar todas as interrupções

IEnable Habilitar todas as interrupções

8.6 Tipos de dados para interrupções


intnum A identidade de uma interrupção

1. Only if the robot is equipped with the option “Advanced functions”


Sumário RAPID Recuperação de Erros

9 Recuperação de Erros

Muitos dos erros que ocorrem quando um programa está sendo executado podem ser tratados pelo programa, o que significa qua a sua execução não precisa ser interromp-ida. Estes erros são ou do tipo detectados pelo robô, tais como, divisão por zero, ou do tipo detectados pelo programa, tais como os erros que ocorrem quando um valor incor-reto é lido por uma leitora de código de barras.


Quando ocorre um erro, o tratamento de erros da rotina é chamado (se existir um). Também é possível criar um erro a partir de dentro do programa e então saltar para o tratamento de erro.

Se a rotina não possuir um tratamento de erro, uma chamada será feita para o trata-mento na rotina que chamou a rotina em questão. Se lá também não existir um trata-mento de erro, uma chamada será feita para o tratamento da rotina que chamou aquela rotina e assim por diante até que o tratamento de erros interno do robô assuma e dê uma mensagem de erro e pare a execução do programa.

No tratamento de erros, eles podem ser tratados usando-se instruções normais. Os dados do sistema ERRNO podem ser usados para se determinar o tipo de erro que ocor-reu. Um retorno do tratamento de erros pode ser feito de várias maneiras.

Em liberações futuras, se a rotina atual não tiver um tratamento de erro, o tratamento de erro interno do robô assume diretamente o controle. O tratamento de erro interno ativa uma mensagem de erro e pára a execução do programa com o ponteiro do pro-grama na instrução que estiver errada.

Portanto, uma boa regra para esta questão é a seguinte: se você quiser chamar o trata-mento de erro da rotina que chamou a rotina atual (propaga o erro), deve:

- Acrescentar um tratamento de erro na rotina atual

- Acrescentar a instrução RAISE neste tratamento de erro.


Recuperação de Erros Sumário RAPID

9.2 Criação de uma situação de erro a partir de dentro do programa


RAISE “Criar” um erro e chamar o tratamento de erros

9.3 Reinício/retorno do tratamento de erros


EXIT Parar a execução do programa no caso de um erro fatal

RAISE Chamar o tratamento de erro da rotina que chamou a rotina atual

RETRY Executar novamente a instrução que causou o erro

TRYNEXT Executar a instrução seguinte da instrução que causou o erro

RETURN Retornar para a rotina que chamou a rotina atual

9.4 Dados para tratamento de erros


errnum A razão do erro


Sumário RAPID Sistema & Tempo

10 Sistema & Tempo

As instruções do sistema e de tempo possibilitam ao usuário medir, inspecionar e gravar o tempo.


As instruões do relógio (clock) possibilitam ao usuário a utilização do relógio para fun-cionar como um “monitorador” para paradas. Deste modo, o programa do robô pode ser usado para temporizar qualquer evento desejado.

A hora e a data atuais podem ser recuperadas em texto (string). Este pode ser mostrado ao operador na unidade de programação ou ser usado em arquivos de registro.

Também é possível recuperar componentes da hora atual do sistema como um valor numérico. Isto possibilita ao programa do robô a executar uma ação em uma certa hora ou em um certo dia da semana.

10.2 Utilização do relógio para temporizar um evento


ClkReset Resetar um relógio usado para temporização

ClkStart Iniciar um relógio usado para temporização

ClkStop Parar um relógio usado para temporização


ClkRead Ler um relógio usado para temporização

Tipo de dado Usado para:

clock Temporização – armazena uma medição em segundos

10.3 Leitura da hora e data atuais


CDate Ler a data atual como um texto (string)

CTime Ler a hora atual como um texto (string)

GetTime Ler a hora atual como um valor numérico


Sistema & Tempo Sumário RAPID

10.4 Recuperar informação de hora/data a partir do arquivo


FileTime Recuperar a última data de modificação de um arquivo.

ModTime Recuperar a hora de carga de um módulo específico.


Sumário RAPID Matemática

11 Matemática

Instruções matemáticas e funções são usadas para o cálculo e troca dos valores dos dados.


Os cálculos normalmente são efetuados por instruções de associação, por exemploreg1:= reg2 + reg3 / 5. Existem também algumas instruções usadas para cálculos sim-ples, tais como limpar uma variável numérica.

11.2 Cálculos simples em dados numéricos


Clear Limpar o valor

Add Adicionar ou subtrair um valor

Incr Incrementar de 1

Decr Decrementar de 1

11.3 Cálculos mais avançados


:= Efetuar cálculos em quaisquer tipos de dados


Matemática Sumário RAPID

11.4 Funções aritméticas


Abs Calcular o valor absoluto

Round Arredondar um valor numérico

Trunc Truncar um valor numérico

Sqrt Calcular a raiz quadrada

Exp Calcular o valor exponencial na base “e”

Pow Calcular o valor exponencial com uma base arbitrária

ACos Calcular o valor do arco coseno

ASin Calcular o valor do arco seno

ATan Calcular o valor do arco tangente na faixa [-90,90]

ATan2 Calcular o valor do arco tangente na faixa [-180,180]

Cos Calcular o valor do coseno

Sin Calcular o valor do seno

Tan Calcular o valor da tangente

EulerZYX Calcular os ângulos de Euler a partir de uma orientação

OrientZYX Calcular a orientação a partir dos ângulos de Euler

PoseInv Inverter uma posição (pose)

PoseMult Multiplicar uma posição (pose)

PoseVect Multiplicar uma posição (pose) e um vetor

Vectmagn Calcular a magnitude de um vetor pos.

DotProd Calcular o produto decimal (ou escalar) de dois vetores de pos.

NOrient Normaliza a orientação fora de norma (quartérnion)


Sumário RAPID Solda a Ponto

12 Solda a Ponto

O pacote SpotWare suporta as aplicações de solda a ponto que são equipadas com um temporizador de solda e uma pinça tipo on/off.

A aplicação SpotWare possibilita um posicionamento rápido e preciso combinado com a manipulação da pinça, início do processo e supervisão de um temporizador externo.

A comunicação com o equipamento de solda é executada através de entradas e saídas digitais. Algumas interfaces do controlador de solda serial são também suportadas : Bosch PSS5000, NADEX, ABB Timer. Veja a documentação em separado.

Deve se salientar que o SpotWare é um pacote que pode ser extensamente personali-zado. O objetivo é que o usuário adapte alguns dados e rotinas do usuário conforme a situação do ambiente.

12.1 Características da solda a ponto

O pacote SpotWare possui as seguintes características:

- Posicionamento rápido e preciso

- Manuseio de uma pinça on/off com dois cursos

- Pinças duplas/simples

- Pré-fechamento da pinça

- Supervisão definida pelo usuário do equipamento circundante antes do início da solda

- Supervisão definida pelo usuário do equipamento circundante depois da solda

- Abertura/fechamento da pinça e supervisão definida pelo usuário

- Ajustamento da pressão defininida pelo usuário

- Cálculo do tempo de pré-fechamento definido pelo usuário

- Monitoração do temporizador de solda externo

- Recuperação de erro de solda com ressolda automática

- Retorno para a posição de solda a ponto

- Contadores de pontos

- Liberação para movimentação dependente do tempo - ou de sinal - após a solda

- Início rápido (quick start) após a solda

- Rotinas de serviço definidas pelo usuário

- Pré-ajuste e verificação da pressão da pinça

- Soldagem simulada

- Execução reversa com o controle da pinça


Solda a Ponto Sumário RAPID

- Interfaces paralelos e seriais do temporizador de solda

- Suporta o programa e o início de disparo do controlador de solda

- Informações dos dados atuais do SpotL/J

- Informações sobre a identidade do ponto: nome atual do parâmetro dos dados do ponto (formato de string)

- Transferência de identidade do ponto para o temporizador de solda serial BOSCH PSS 5000

- Supervisão autónoma definida pelo usuário, como o sinal de corrente de solda controlado pelo estado e arranque refrigerado com água. Nota: Esta característica necessita da opção Multitarefas

- Solda manual, abertura da pinça e fechamento da pinça inicializados por entrada digital

- Reconhecimento de erros opcional definida pelo usuário

- É possível a inicialização do processo de solda independentemente da estado de posição

12.2 Princípios do SpotWare

O SpotWare se baseia num tratamento separado do movimento, da solda a ponto e, se Multitarefas estiver instalado, numa supervisão contínua. Em direção à posição progra-mada, a tarefa do movimento ativará as ações nas tarefas de solda a ponto.

As transições (triggers) são ativadas por sinais digitais virtuais.

As tarefas trabalham com suas próprias variáveis e persistentes internas encapsuladas que são totalmente transparentes para as outras tarefas.

Para entradas bem definidas, os chamados das rotinas do usuário oferecem adaptações ao ambiente da instalação. Também se encontram disponíveis vários parâmetros pré-definidos para moldar o comportamento da instrução SpotL/J.

Uma parada no programa somente pára a execução da rotina de movimento. O processo e a supervisão continuam com suas tarefas até uma parada de processo bem definida. Por exemplo, isso finaliza a solda e abre a pinça, apesar do programa ter parado.

A abertura e o fechamento da pinça são sempre executados por rotinas RAPID, mesmo se elas forem ativadas manualmente da janela de E/S na unidade de programação. Estas rotinas podem ser alterdas desde uma funcionalidade padrão liga/desliga até algo mais complexo como o controle analógico da pinça e podem conter supervisão de pinça adi-cional.

Já que as tarefas de processo e de supervisão atuam nos gatilhos (triggers) de E/S, elas serão executadas ou pelo gatilho que foi enviado pelo movimento (SpotL/J) ou por ati-vação manual (unidade de programação ou externo). Isto oferece a possibilidade de sol-dagens “stand-alone” em qualquer lugar sem a necessidade de programação de uma nova posição.


Sumário RAPID Solda a Ponto

É igualmente possível definir novas situações de supervisão e conectá-las a sinais digi-tais de disparo. Por default, são implementados um estado dependente de energia de solda e um sinal de controle de água de refrigeração.

Equipamento suportado:

- Um controlador de solda monitorizando as interfaces standard paralelas (algu-mas seriais). O temporizador de solda pode ser do tipo agenda do programa ou sinal de início de disparo.

- Qualquer tipo de pinças de fechamento simples/duplas e uma pinça de controle do intervalo.

- Qualquer tipo de pré-ajuste de pressão.

- Situação controlada por SpotL/J do equipamento de solda a ponto indepen-dente, tal como contatores, etc. (opção Multitarefas necessária).


Ambos o movimento linear do robô e o controle do processo de solda a ponto estão embutidos em uma instrução, SpotL.

Ambos o movimento de junção do robô e o controle do processo de solda a ponto estão embutidos em uma instrução, SpotJ.

O processo de solda é especificado por:

- Spotdata: dados do processo de solda

- Gundata: dados da pinça de solda

- Módulos do sistema SWUSRF e SWUSRC: rotinas RAPID e dados globais com propósitos de customização. Veja Dados Pré-definidos e Programas Pro-cessWare.

- Parâmetros do sistema: a configuração de E/S. Veja o Guia do Usuário - Parâ-metros do sistema.

12.4 Instruções de Solda a ponto


SpotL Controlar o movimento, o fechamento/ abertura da pinça e o processo de soldagemMovimentar o TCP num trajeto linear e executar a solda a ponto na posição final

SpotJ Controlar o movimento, o fechamento/ abertura da pinça e o processo de soldagemMovimentar o TCP num trajeto não linear e executar a solda a ponto na posição final

SpotML Solda a ponto com várias pinças


Solda a Ponto Sumário RAPID

12.5 Dados de Solda a ponto


spotdata O controle do processo de solda a ponto

gundata A pinça de solda a ponto

spotmdata O controle do processo de soldagem a ponto para váriaspinças

gunmdata Dados de pinça de soldagem a ponto para várias pinças


Sumário RAPID Solda a Arco

13 Solda a Arco

O pacote ArcWare suporta a maioria das funções de soldagem. O enchimento de cra-tera e a raspagem (“scraping start”) podem, por exemplo, ser programados. Usando-se o ArcWare, todo o processo de soldagem pode ser controlado e monitorado pelo robô através de um número de diferentes entradas e saídas analógicas e digitais.


As mesmas instruções podem ser usadas para controlar ambos o movimento do robô e o processo de soldagem real. As instruções de solda a arco indicam quais dados de solda (welddata) e de costura (seamdata) são usados na solda em questão.

Os ajustes da solda para a fase de solda real são definidos nos dados de solda (weld-data). As fases de início e fim são definidas nos dados de costura (semadata).

Qualquer ondulação é definida nos dados de ondulação (weavedata), que também é indicado pela instrução de solda a arco.

Certas funções, tais como raspagem (“scraping start”), são definidas nos parâmetros do sistema.

O processo de soldagem é dividido nas seguintes fases:

13.2 Instruções de solda a arco


ArcC TCP em um trajetória circular

ArcL TCP em um trajetória linear

PRÉ-AÇÃO PÓS-AÇÃOENCHIM.TÉRMINOIGNIÇÃO AQUEC.

SOLDAINÍCIO FIM

t


Solda a Arco Sumário RAPID

13.3 Instruções adicionais de solda a arco


ArcRefresh Atualizar dados ArcWeld

ArcKill Eliminar o processo ArcWeld

SpcWrite Grava em um controlador de processos estatísticos

SpcStat Status do controlador de processos estatísticos

SpcRead Lê o status de processo atual

SpcDump Transfere informações de controle de processos estatísticos

SpcDiscon Desconecta de um controlador de processos estatísticos

SpcCon Conecta a um controlador de processos estatísticos

13.4 Dados de solda a arco

Tipo de dados Usado para definir:

welddata A fase da solda

seamdata As fases inicial e final da solda

weavedata As características da ondulação

arcdata Dados do processo de arco

13.5 Dados adicionais de solda a arco


spcdescr Descritor do controle de processos estatísticos

spcdata Dados de controle de processos estatísticos


Sumário RAPID GlueWare

14 GlueWare

O pacote GlueWare oferece suporte para as aplicações de colagem que são equipadas com uma ou mais pinças de cola.

A aplicação GlueWare oferece posicionamento rápido e eficaz combinado com a mani-pulação da pinça, processa começar e parada.

A comunicação com o equipamento de colagem é levada a cabo por meio de saídas digitais e analógicas .

14.1 Caraterísticas de colagem

O pacote GlueWare contém as seguintes caraterísticas:

- Posicionamento rápido e eficaz

- Manuseio de pinças de on/off bem como pinças proporcionais

- Podem ser manuseadas no mesmo programa duas pinças diferentes, cada pinça controlada por um sinal digital (on/off) e dois sinais analógicos (fluxos)

- Pré-abertura e pré-fechamento da pinça, respetivamente

- Colagem simulada


O movimento do robô e o controle do processo de colagem estão ambos unidos numa só instrução, GlueL e GlueC, respetivamente.

O processo de colagem é especificado por:

- Gundata: cola dados de pinça. Veja Data types - ggundata.

- As rotinas do módulo de sistema GLUSER: rotinas RAPID e dados globais para fins de perso-nalização. Veja Dados pré-definidos e Programas - Módulo do Sistema GLU-SER.

- Parâmetros do Sistema: a configuração de E/S. Veja Parâmetros do Sistema- Glueing


GlueWare Sumário RAPID

14.3 Instruções de colagem

Instrução Usado para:

GlueL Mova o TCP ao longo de um trajeto linear e execute a colagem com os dados fornecidos

GlueC Mova o TCP ao longo de um trajeto circular e execute a cola-gem com os dados fornecidos

14.4 Dados de colagem


ggundata A pinça de cola usada

14.5 Dados do DispenseWare


beaddata Dados de distribuição de rebordo

equidata Dados de distribuição de equipamento


Sumário RAPID Comunicação com Computador Externo

15 Comunicação com Computador Externo

O robô pode ser controlado por um computador superior. Neste caso, um protocolo de comunicação especial é usado para transferir a informação.


Como um protocolo de comunicação comum é usado para transferir informações do robô para o computador e vice-e-versa, o robô e o computador podem se entender e nenhuma programação é necessária. O computador pode, por exemplo, alterar valores nos dados do programa sem que nenhuma programação seja feita (exceto para definir estes dados). A programação somente é necessária quando informações controladas pelo programa devem ser enviadas do robô para o computador superior.

15.2 Envio de mensagem controlada pelo programa do robô para o computador


SCWrite1 Enviar uma mensagem para o computador superior

1. Somente se o robô for equipado com a opção “RAP Serial Link”.


Comunicação com Computador Externo Sumário RAPID


Sumário RAPID Instruções de suporte do RAPID

16 Instruções de suporte do RAPID

Várias funções para suporte da linguagem RAPID:

- Obter dados do sistema

16.1 Obter dados do sistema

Instrução para obter o valor e (opcionalmente) o nome do símbolo dos dados atuais de sistema do tipo especificado.

Instrução usada para:

GetSysData Obtém dados e o nome do objeto de trabalho ou ferramenta atualmente ativo(a).


Instruções de suporte do RAPID Sumário RAPID


Sumário RAPID Instruções de Serviço

17 Instruções de Serviço

Um número de instruções estão disponíveis para testar o robô. Veja o Capítulo sobre Detecção de Falhas no Manual do Produto para mais informações.

17.1 Direcionamento de um valor para o sinal de teste do robô

Um sinal de referência, tal como a velocidade de um motor, pode ser direcionado para um sinal de saída analógica localizado na placa traseira do robô.


TestSign Definir a ativar o inal de teste


testsignal O tipo do sinal de teste


Instruções de Serviço Sumário RAPID


Sumário RAPID Funções com “Strings”

18 Funções com “Strings”

Funções com “strings” são usadas para operações com “strings” tais como cópia, con-catenação, comparação, procura, conversão, etc.

18.1 Operações básicas


string String. Constantes pré-definidas STR_DIGIT, STR_UPPER,STR_LOWER e STR_WHITE

Instrução/Operador Usada para:

:= Associar um valor (cópia do “string”)

+ Concatenar um “string”


StrLen Encontar o comprimento do “string”

StrPart Obter parte de um “string”

18.2 Comparação e Procura

Operador Usado para:

= Testar se é igual a

<> Testar se não é igual a


StrMemb Verificar se o caracter pertence a um conjunto

StrFind Procurar por um caracter em um “string”

StrMatch Procurar por um padrão (pattern) em um “string”

StrOrder Verificar se os “strings” estão em ordem


Funções com “Strings” Sumário RAPID

18.3 Conversão


NumToStr Converter um valor numérico em um “string”

ValToStr Converter um valor num “string”

StrToVal Converter um “string” num valor

StrMap Mapear um “string”

StrToByte Converter um byte em dados de “string”

ByteToStr Converter um “string” em um byte


Sumário RAPID Multitasking

19 Multitasking

Multitasking RAPID é um modo de executar programas em (pseudo) paralelo com a execução normal. Um programa paralelo poderá ser colocado em primeiro plano ou em segundo plano em relação a outro programa. Poderá estar também no mesmo nível de outro programa.(Veja Multitarefas/Multitasking, Características Básicas.)

19.1 Básicos

Para usar esta função, o robô deverá estar configurado com uma TASK/TAREFA extra para cada programa em segundo plano.

Até 10 tarefas diferentes poderão ser operadas em pseudo-paralelo. Cada tarefa é com-posta de um conjunto de módulos, de modo igual a um programa normal. Todos os módulos, em cada tarefa, são locais.

Em cada tarefa, as variáveis e as constantes são locais mas não são persistentes. Uma persistente com o mesmo nome e tipo é atingível em todas as tarefas. Se duas persis-tentes tiverem o mesmo nome, mas diferente no tipo ou tamanho (dimensão de matriz), poderá ocorrer um erro de tempo de percurso (runtime).

Uma tarefa tem o seu próprio manuseio trap e as rotinas de de evento são disparadas somente nos estados de sistema de suas próprias tarefas (p. ex. Partida/Parada/Reiní-cio...).

19.2 Proteção de acesso de Recurso


TestAndSet Repôr o direito exclusivo para especificar áreas de código

RAPID ou recursos do sistema.


Multitasking Sumário RAPID


Sumário RAPID Sumário da Sintaxe

20 Sumário da Sintaxe

20.1 Instruções

Data := Value

AccSet Acc Ramp

ActUnit MecUnit

Add Name AddValue

ArcRefresh

ArcKill

Break

CallBy Var Name Number

Clear Name

ClkReset Clock

ClkStart Clock

ClkStop Clock

Close IODevice

! Comment

ConfJ [\On] | [\Off]

ConfL [\On] | [\Off]

CONNECT Interrupt WITH Trap routine

CorrClear

CorrCon Descr

CorrDiscon Descr

CorrWrite

CorrWrite Descr Data


Sumário da Sintaxe Sumário RAPID

CorrClear

DeactUnit MecUnit

Decr Name

DropWObj WObj

EOffsSet EAxOffs

ErrWrite [ \W ] Header Reason [ \RL2] [ \RL3] [ \RL4]

Exit

ExitCycle

FOR Loop counter FROM Start value TO End value [STEP Step value] DO ... ENDFOR

GOTO Label

GripLoad Load

GetSysData DestObject [\ ObjectName ]

IDelete Interrupt

IF Condition ...

IF Condition THEN ... {ELSEIF Condition THEN ...}

[ELSE ...]

ENDIF

Incr Name

IndAMove MecUnit Axis [ \ToAbsPos ] | [ \ToAbsNum ] Speed [ \Ramp ]

IndCMove MecUnit Axis Speed [ \Ramp ]

IndDMove MecUnit Axis Delta Speed [ \Ramp ]

IndReset MecUnit Axis [ \RefPos ] | [ \RefNum ] | [ \Short ] | [ \Fwd ] | [ \Bwd ] | [ \Old ]

IndRMove MecUnit Axis [ \ToRelPos ] | [ \ToRelNum ] | [ \Short ] |[ \Fwd ] | [ \Bwd ] Speed [ \Ramp ]



InvertDO Signal

IODisable UnitName MaxTime

IOEnable UnitName MaxTime

ISignalDI [ \Single ] Signal TriggValue Interrupt

ISignalDO [ \Single ] Signal TriggValue Interrupt

ISleep Interrupt

ITimer [ \Single ] Time Interrupt

IVarValue VarNo Value, Interrupt

IWatch Interrupt ParIdType LoadIdType Tool [\PayLoad] [\WObj][\ConfAngle] [\SlowTest] [\Accuracy]

LoadId ParIdType LoadIdType Tool [\PayLoad] [\WObj][\ConfAngle] [\SlowTest] [\Accuracy]

MechUnitLoad MechUnit AxisNo Load

MoveAbsJ [ \Conc ] ToJointPos Speed [ \V ] | [ \T ] Zone [ \Z] Tool [ \WObj ]

MoveC [ \Conc ] CirPoint ToPoint Speed [ \V ] | [ \T ] Zone [ \Z] Tool [ \WObj ]

MoveCDO CirPoint ToPoint Speed [ \T ] Zone Tool [\WObj ] Signal Value

MoveCSync CirPoint ToPoint Speed [ \T ] Zone Tool [\WObj ] ProcName

MoveJ [ \Conc ] ToPoint Speed [ \V ] | [ \T ] Zone [ \Z ] Tool [ \WObj ]

MoveJDO ToPoint Speed [ \T ] Zone Tool [ \WObj ] Signal Value

MoveJSync ToPoint Speed [ \T ] Zone Tool [ \WObj ] ProcName

MoveL [ \Conc ] ToPoint Speed [ \V ] | [ \T ] Zone [ \Z ] Tool [ \WObj ]



MoveLDO ToPoint Speed [ \T ] Zone Tool [ \WObj ] Signal Value

MoveLSync ToPoint Speed [ \T ] Zone Tool [ \WObj ] ProcName

MotionSup [ \On] | [ \Off] [\TuneValue]

Open Object [\File] IODevice [\Read] | [\Write] | [\Append] | [\Bin]

ParIdPosValid ( ParIdType Pos AxValid [\ConfAngle] )

ParIdRobValid (ParIdType)

PathResol Value

PDispOn [ \Rot ] [ \ExeP ] ProgPoint Tool [ \WObj ]

PDispSet DispFrame

Procedure { Argument }

PulseDO [ \PLength ] Signal

RAISE [ Error no ]

Reset Signal

RETURN [ Return value ]

Rewind IODevice

Save [\Task] ModuleName [\FilePath] [\File]

SearchC [ \Stop ] | [ \PStop ] | [ \Sup ] Signal SearchPoint CirPointToPoint Speed [ \V ] | [ \T ] Tool [ \WObj ]

SearchL [ \Stop ] | [ \PStop ] | [ \Sup ] Signal SearchPoint ToPointSpeed [ \V ] | [ \T ] Tool [ \WObj ]

Set Signal

SetAO Signal Value

SetDO [ \SDelay ] Signal Value

SetGO Signal Value

SingArea [ \Wrist] | [ \Arm] | [ \Off]



SoftAct Axis Softness [\Ramp ]

SpcCon Descr Status [\GrpSize ] [\Teach ] [\Strict ] [\Header ] [\BackupFile ]

SpcDiscon Descr

SpcDump

SpcRead

SpcStat

SpotJ

SpotL ToPoint Speed Spot [\InPos] [\NoConc] [\Retract] Gun Tool [\WObj]

SpotML

Stop [ \NoRegain ]

TEST Test data {CASE Test value {, Test value} : ...} [ DEFAULT: ...] ENDTEST



TPReadFK Answer String FK1 FK2 FK3 FK4 FK5 [\MaxTime][\DIBreak] [\BreakFlag]

TPReadNum Answer String [\MaxTime] [\DIBreak] [\BreakFlag]

TPShow Window

TPWrite String [\Num] | [\Bool] | [\Pos] | [\Orient]

TriggC CirPoint ToPoint Speed [ \T ] Trigg_1 [ \T2 ] [ \T3 ][ \T4] Zone Tool [ \WObj ]

TriggEqip

TriggInt TriggData Distance [ \Start ] | [ \Time ] Interrupt

TriggIO TriggData Distance [ \Start ] | [ \Time ] [ \DOp ] | [ \GOp ] | [\AOp ] SetValue [ \DODelay ] | [ \AORamp ]

TriggJ ToPoint Speed [ \T ] Trigg_1 [ \T2 ] [ \T3 ] [ \T4 ]Zone Tool [ \WObj ]

TriggL ToPoint Speed [ \T ] Trigg_1 [ \T2 ] [ \T3 ] [ \T4 ]Zone Tool [ \WObj ]

TuneServo MecUnit Axis TuneValue

TuneServo MecUnit Axis TuneValue [\Type]

UnLoad FilePath [\File]

VelSet Override Max

WaitDI Signal Value [\MaxTime] [\TimeFlag]

WaitDO Signal Value [\MaxTime] [\TimeFlag]

WaitTime [\InPos] Time

WaitUntil [\InPos] Cond [\MaxTime] [\TimeFlag]

WaitWObj WObj [ \RelDist ]

WHILE Condition DO ... ENDWHILE

Write IODevice String [\Num] | [\Bool] | [\Pos] | [\Orient] [\NoNewLine]

WriteBin IODevice Buffer NChar



WriteStrBin IODevice Str

WZBoxDef [\Inside] | [\Outside] Shape LowPoint HighPoint 1

WZCylDef [\Inside] | [\Outside] Shape CentrePoint Radius Height

WZDisable WorldZone

WZDOSet [\Temp] | [\Stat] WorldZone [\Inside] | [\Before] Shape Signal SetValue

WZEnable WorldZone

WZFree WorldZone

WZLimSup [\Temp] | [\Stat] WorldZone Shape

WZSphDef [\Inside] | [\Outside] Shape CentrePoint Radius

20.2 Funções

Abs (Input)

ACos (Value)

AOutput (Signal)

ArgName (Parameter)

ASin (Value)

ATan (Value)

ATan2 (Y X)

ByteToStr (ByteData [\Hex] | [\Okt] | [\Bin] | [\Char])

ClkRead (Clock)

CorrRead

Cos (Angle)

CPos ([Tool] [\WObj])

CRobT ([Tool] [\WObj])

DefDFrame (OldP1 OldP2 OldP3 NewP1 NewP2 NewP3)



DefFrame (NewP1 NewP2 NewP3 [\Origin])

Dim (ArrPar DimNo)

DOutput (Signal)

DotProd (Vector1 Vector2)

EulerZYX ([\X] | [\Y] | [\Z] Rotation)

Exp (Exponent)

FileTime ( Path [\ModifyTime] | [\AccessTime] | [\StatCTime] )

GOutput (Signal)

GetTime ( [\WDay] | [\Hour] | [\Min] | [\Sec] )

IndInpos MecUnit Axis

IndSpeed MecUnit Axis [\InSpeed] | [\ZeroSpeed]

IsPers (DatObj)

IsVar (DatObj)

MirPos (Point MirPlane [\WObj] [\MirY])

ModTime ( Object )

NOrient (Rotation)

NumToStr (Val Dec [\Exp])

Offs (Point XOffset YOffset ZOffset)

OrientZYX (ZAngle YAngle XAngle)

ORobT (OrgPoint [\InPDisp] | [\InEOffs])

PoseInv (Pose)

PoseMult (Pose1 Pose2)

PoseVect (Pose Pos)

Pow (Base Exponent)

Present (OptPar)



ReadBin (IODevice [\Time])

ReadMotor [\MecUnit ] Axis

ReadNum (IODevice [\Time])

ReadStr (IODevice [\Time])

RelTool (Point Dx Dy Dz [\Rx] [\Ry] [\Rz])

Round ( Val [\Dec])

Sin (Angle)

Sqrt (Value)

StrFind (Str ChPos Set [\NotInSet])

StrLen (Str)

StrMap ( Str FromMap ToMap)

StrMatch (Str ChPos Pattern)

StrMemb (Str ChPos Set)

StrOrder ( Str1 Str2 Order)

StrPart (Str ChPos Len)

StrToByte (ConStr [\Hex] | [\Okt] | [\Bin] | [\Char])

StrToVal ( Str Val )

Tan (Angle)

TestDI (Signal)

TestAndSet Object

Trunc ( Val [\Dec] )

ValToStr ( Val )

VectMagn (Vector)




Características Básicas RAPID Execução de trás para frente

1 Elementos Básicos

1.1 Identificadores

Identificadores são usados para nomear módulos, rotinas, dados e etiquetas (labels);

por exemplo MODULE module_namePROC routine_name()VAR pos data_name;label_name:

O primeiro caracter em um identificador deve ser uma letra. Os outros caracteres podem ser letras, números ou sublinhados “_”.

O máximo comprimento de qualquer identificador é 16 caracteres, cada um deles sendo significante. Os identificadores são considerados os mesmos se forem digitados em letra maiúscula.

Palavras reservadas

As palavras listadas abaixo são reservadas. Elas possuem um significado especial na lin-guagem RAPID e portanto não devem ser usadas como identificadores.

Existem também determinados nomes pré-definidos para tipos de dados, dados de sis-tema, instruções e funções que não devem ser usados como identificadores. Veja os Capí-tulos 7, 8, 9, 10, 13, 14 e 15 neste Manual

ALIAS AND BACKWARD CASECONNECT CONST DEFAULT DIVDO ELSE ELSEIF ENDFORENDFUNC ENDIF ENDMODULE ENDPROCENDRECORD ENDTEST ENDTRAP ENDWHILEERROR EXIT FALSE FORFROM FUNC GOTO IFINOUT LOCAL MOD MODULENOSTEPIN NOT NOVIEW ORPERS PROC RAISE READONLYRECORD RETRY RETURN STEPSYSMODULE TEST THEN TOTRAP TRUE TRYNEXT VARVIEWONLY WHILE WITH XOR


Execução de trás para frente Características Básicas RAPID

1.2 Caracteres de espaço e de linha

A linguagem de programação RAPID possui formato livre, o que significa que os espaços podem ser usados em qualquer lugar exceto em:

- identificadores

- palavras reservadas

- valores numéricos

- “placeholders”

Os caracteres de mudança de linha, tabulação e de mudança de página podem ser usa-dos em qualquer lugar do mesmo modo que um espaço, exceto dentro de comentários.

Identificadores, palavras reservadas e valores numéricos podem ser separados uns dos outros por um espaço, mudança de linha, tabulação ou mudança de página.

Espaços desnecessários e caracteres de mudança de linha serão automaticamente deletados de um programa carregado na memória. Conseqüentemente os programas carregados a partir de um disquete e gravados novamente podem não ser idênticos.

1.3 Valores numéricos

Um valor numérico pode ser expresso como

- um inteiro, por exemplo 3, -100, 3E2

- um número decimal, por exemplo 3.5, -0.345, -245E-2

O valor deve estar na faixa especificada no formato flutuante padrão ANSI IEEE 754-1985 (precisão simples).

1.4 Valores lógicos

Um valor lógico pode ser expresso como TRUE ou FALSE.

1.5 Valores de “string”

Um valor de “string” é uma seqüência de caracteres (ISO 8859-1) e de caracteres de controle (caracteres não-ISO 8859-1 na faixa de código numérico 0-255). Códigos de caracteres podem ser incluídos, sendo possível a inclusão de caracteres não imprimíveis (dados binários) também no “string”. O comprimento máximo do “string” é 80 caracteres.

Exemplo: "This is a string""This string ends with the BEL control character \07"

Se uma barra invertida (que indica um código de caracter) ou aspas forem incluídos, eles devem ser escritos duas vezes.



Exemplo: "This string contains a "" character""This string contains a \\ character"

1.6 Comentários

Os comentários são usados para fazer o programa mais fácil de ser entendido. Eles não afetam o significado do programa de nenhuma forma.

Um comentário começa com um ponto de exclamação “!” e termina com um caracter de mudança de linha. Ele ocupa uma linha interia e não pode ocorrer entre dois módulos;

Exemplo ! comentárioIF reg1 > 5 THEN

! comentárioreg2 := 0;

ENDIF

1.7 “Placeholders”

“Placeholders” podem ser usados temporariamente para representar partes de um pro-grama que “ainda não está definido”. Um programa que contem “placeholders” está sin-taticamente correto e deve ser carregado na memória.



“Placeholder” Representa:

<TDN> definição do tipo de dados

<DDN> declaração de dados

<RDN> declaração de rotina

<PAR> parâmetro alternativo opcinal formal

<ALT> parâmetro formal opcinal

<DIM> dimensão matricial formal (conformidade)

<SMT> instrução

<VAR> referência de objeto (variável, persistente ou parâmetro)

<EIT> condição else if de uma instrução if

<CSE> condição case de uma instrução test

<EXP> expressão

<ARG> argumento de chamada de procedimento

<ID> identificador

1.8 Cabeçalho do arquivo

Um arquivo de programa começa com o seguinte cabeçalho:

%%% VERSION:1 (Versão do programa M94 ou M94A) LANGUAGE:ENGLISH (ou outra língua qualquer:%%% GERMAN or FRENCH)

1.9 Sintaxe

Identificadores (Identifiers)

<identifier> ::=<ident>| <ID>

<ident> ::= <letter> {<letter> | <digit> | ’_’}

Valores numéricos (Numeric values)

<num literal> ::=<integer> [ <exponent> ]| <integer> ’.’ [ <integer> ] [ <exponent> ]| [ <integer> ] ’.’ <integer> [ <exponent> ]

<integer> ::= <digit> {<digit>}<exponent> ::= (’E’ | ’e’) [’+’ | ’-’] <integer>



Valores lógicos (Logical values)

<bool literal> ::= TRUE | FALSE

Valores “string” (String values)

<string literal> ::= ’"’ {<character> | <character code> } ’"’<character code> ::= ’\’ <hex digit> <hex digit><hex digit> ::= <digit> | A | B | C | D | E | F | a | b | c | d | e | f

Comentários (Comments)

<comment> ::=’!’ {<character> | <tab>} <newline>

Caracteres (Characters)

<character> ::= -- ISO 8859-1 --<newline> ::= -- newline control character --<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9<letter> ::=

<upper case letter>| <lower case letter>

<upper case letter> ::=A | B | C | D | E | F | G | H | I | J| K | L | M | N | O | P | Q | R | S | T| U | V | W | X | Y | Z | À | Á | Â | Ã| Ä | Å | Æ | Ç | È | É | Ê | Ë | Ì | Í| Î | Ï | 1) | Ñ | Ò | Ó | Ô | Õ | Ö | Ø| Ù | Ú | Û | Ü | 2) | 3) | ß

<lower case letter> ::=a | b | c | d | e | f | g | h | i | j| k | l | m | n | o | p | q | r | s | t| u | v | w | x | y | z | ß | à | á | â| ã| ä | å | æ | ç | è | é | ê | ë | ì| í | î | ï | 1) | ñ | ò | ó | ô | õ | ö| ø | ù | ú | û | ü | 2) | 3) | ÿ

1) letra nórdica eth.2) Letra Y com acento agudo.3) letra nórdica thorn.





2 Módulos

O programa é dividido em programa e módulos de sistema. O programa também pode ser dividido em módulos (veja a Figura 1).

Figura 1 O programa pode ser dividido em módulos.

2.1 Módulos de programa

Um módulo pode ser constituído de diferentes dados e rotinas. Cada módulo, ou o pro-grama inteiro, pode ser copiado para o disquete, RAM disk, etc., e vice-versa.

Um dos módulos contem o procedimento de entrada global chamado main (principal). A execução do programa significa, na realidade, a execução do procedimento principal. O programa pode incluir vários módulos, mas somente um deles possuirá o procedimento principal.

Um módulo pode, por exemplo, definir a interface com equipamento externo ou conter dados geométricos gerados por sistemas CAD ou criados “on-line” por digitação (unidade de programação).

As instalações pequenas normalmente estão contidads em um módulo enquanto as insta-lações maiores podem possuir um módulo principal que se referencia a rotinas e/ou dados contidos em um ou vários módulos.

Módulo principal

Módulo 2

Módulo 3

Módulo 4

Dados Programa

Rotina principal

Rotina1

Rotina2

Dados Programa

Rotina4

Rotina5

Rotina3

Módulo 1

Módulo sistema1

Módulo sistema2

Dados Programa

Rotina6

Rotina7

Mem. do programaPrograma



2.2 Módulos de sistema

Os módulos de sistema são usados para definir dados específicos de sistema e rotinas comuns, tais como ferramentas. Eles não estão incluídos quando um programa é salvo, o que significa que qualquer atualização feita em um módulo de sistema afetará todos os programas existentes atuais, ou carregados em um estágio posterior na memória.

2.3 Declaração do módulo

Uma declaração de um módulo especifica o nome e os atributos daquele módulo. Estes atributos somente podem ser adicionados “off-line”, sem a utilização da unidade de programação. Seguem abaixo exemplos de atributos de um módulo:

Atributo Se especificado, o módulo:

SYSMODULE é um módulo de sistema; caso contrário, módulo de programa

NOSTEPIN não pode ser introduzido durante a execução passo a passo

VIEWONLY não pode ser modificado

READONLY não pode ser modificado, mas atributos podem ser removidos

NOVIEW não pode ser visualizado mas apenas executado. As rotinasglobais podem ser atingidas a partir de outros módulos e sãorodam sempre como o NOSTEPIN. Os valores atuais paradados globais podem ser atingidos a partir de outros módulosou a partir da janela de dados da unidade de programação. Ummódulo ou um programa contendo um módulo de programaNOVIEW não pode ser guardado. Portanto, o NOVIEWdeverá ser usado em primeiro lugar para os módulos do sis-tema. O NOVIEW só pode ser definido off-line num PC

Exemplo MODULE module_name (SYSMODULE, VIEWONLY)!definição de tipo de dados!declaração de dados

!declarações de rotinasENDMODULE

Um módulo não deve ter o mesmo nome que outro módulo, rotina global ou dado.

2.4 Sintaxe

Declaração do módulo (Module declaration)

<module declaration> ::=MODULE <module name> [ <module attribute list> ]<lista de definição de tipos><lista de declaração de dados><lista de declaração de rotinas>ENDMODULE



<module name> ::= <identifier><lista de atributos de módulos> ::= ‘(‘ <atributo de módulo> { ‘,’ <atributo de módulo>

} ‘)’<atributo de módulo> ::=

SYSMODULE| NOVIEW| NOSTEPIN | VIEWONLY | READONLY

(Nota. Se usar dois ou mais atributos, estes têm que estar na ordem acima, o atributo NOVIEW só pode ser especificado independentemente ou juntamente com o atributo SYSMODULE.)

<lista de definições de tipos> ::= { <definição de tipos> }<lista de declaração de dados> ::= { <declaração de dados> }<lista de declaração de rotinas> ::= { <declaração de rotinas> }





3 Rotinas

Existem três tipos de rotinas (subprogramas): procedimentos, funções e ”traps”.

- Os procedimentos não retornam um valor e são usados para instruções.

- As funções retornam um valor de um tipo específico e são usados para expressões.

- As rotinas “trap” são usadas para interrupções. Uma rotina “trap” pode ser associ-ada com uma interrupção específica e então, se aquela interrupção em particular ocorrer em um estágio posterior, ela será automaticamente executada. Uma rotina “trap” nunca pode ser explicitamente chamada a partir de um programa.

3.1 Escopo da rotina

O escopo de uma rotina denota a área na qual a rotina é visível. A diretiva local opcional da declaração da rotina classifica a mesma como local (dentro de um módulo), caso con-trário ela é global.

Exemplo: LOCAL PROC local_routine (...PROC global_routine (...

As seguintes regras de escopo se aplicam às rotinas (veja o exemplo na Figura 2):

- o escopo de uma rotina global pode incluir qualquer módulo.

- o escopo de uma rotina local compreende o módulo no qual ela está contida.

- dentro de seu escopo, uma rotina local esconde qualquer rotina global ou dados com o mesmo nome.

- dentro de seu escopo, uma rotina esconde instruções, rotinas pré-definidas e dados com o mesmo nome.

Figura 2 Exemplo: as seguintes rotinas podem ser chamadas a partir da Rotina h:Módulo1 - Rotina c, d.Módulo2 - Todas as rotinas.

Uma rotina não deve ter o mesmo nome que outra rotina ou dado no mesmo módulo. Uma rotina global não deve possuir o mesmo nome que um módulo, rotina global ou dado glo-bal em outro módulo.

Módulo1 Módulo2

Rotina local a

Rotina local b

Rotina c

Rotina d

Rotina e

Rotina local a

Rotina local e

Rotina f

Rotina g

Rotina h



3.2 Parâmetros

A lista de parâmetros de uma declaração da rotina especifica os argumentos (parâmteros reais) que devem/podem ser fornecidos quando a rotina é chamada.

Existem quatro tipos de parâmetros diferentes (no modo de acesso):

- Normalmente um parâmetro é usado como uma entrada e é tratado como uma variável da rotina. A troca da variável não mudará o argumento correspondente.

- Um parâmetro INOUT especifica que o argumento correspondente deve ser uma variável (inteira, elemento ou componente) ou uma persistente inteira que pode ser alterada pela rotina.

- Um parâmetro VAR especifica que o argumento correspondente deve ser uma variável (inteira, elemento ou componente) que pode ser alterda pela rotina.

- Um parâmetro PERS especifica que o argumento correspondente deve ser uma persistente inteira que pode ser alterada pelo programa.

Se um parâmetro INOUT, VAR ou PERS for atualizado, isto significa na realidade, que o próprio argumento é atualizado, isto é, é possível usar argumentos para retornar val-ores para a rotina de chamada.

Exemplo: PROC routine1 (num in_par, INOUT num inout_par, VAR num var_par, PERS num pers_par)

Um parâmetro pode ser opcional e ser omitido da lista de argumentos de uma chamada de rotina. Um parâmetro opcional é denotado por um barra invertida “\” antes dele.

Exemplo: PROC routine2 (num required_par \num optional_par)

O valor de um parâmetro opcional que é omitido em uma chamada de rotina não pode ser referenciado. Isto significa que as chamadas de rotina devem ser verificadas para parâmetros opcionais antes de utilizar outro parâmetro opcional.

Dois ou mais parâmetros opcionais podem ser mutuamente exclusivos (isto é, declara-dos para se excluirem), o que significa que somente um deles pode estar presente na chamada da rotina. Isto é indicado por uma barra vertical “|” entre eles.

Exemplo: PROC routine3 (\num exclude1 | num exclude2)

O tipo especial, switch, pode (somente) ser associado à parâmetros opcionais e possi-bilita um meio de usar argumentos tipo switch, isto é, argumentos que somente são especificados por nomes (não valores). Um valor não pode ser transferido para um parâmetro switch . A única maneira de usar um parâmetro switch é verificar sua presença usando-se a função pré-definida, Present.

Exemplo: PROC routine4 (\switch on | switch off)...

IF Present (off ) THEN ...ENDPROC



As matrizes podem se passar por argumentos. O grau de um argumento matricial (array) deve “casar” com o grau do parâmetro formal correspondente. A dimensão de um parâmetro matricial é “conforme” (marcado com “*”). Portanto a dimensão real depende da dimensão do argumento correspondente na chamada da rotina. Uma rotina pode deter-minar a dimensão real de um parâmetro usando-se a função pré-definida, Dim.

Exemplo: PROC routine5 (VAR num pallet{*,*})

3.3 Término da rotina

A execução de um procedimento ou é terminada explicitamente por uma instrução RETURN ou implicitamente, quando o final (ENDPROC, BACKWARD ou ERROR) do procedimento for atingido.

A avaliação de uma função deve ser terminada por uma instrução RETURN.

A execução de uma rotina “trap” é terminada explicitamente usando-se a instrução RETURN ou implicitamente, quando o final (ENDTRAP ou ERROR) da rotina “trap” for atingido. A execução continua a partir do ponto onde a interrupção ocorreu.

3.4 Declaração da rotina

Uma rotina pode conter declarações da rotina (incluindo parâmetros), dados, um corpo, um manipulador de trás para a frente (somente procedimentos) e um tratamento de erros (veja a Figura 3). As declarações da rotina não podem ser agrupadas, isto é, não é possível declarar uma rotina dentro de uma rotina.

Figura 3 Uma rotina pode conter declarações, dados, um corpo, manipulador de trás para frente e um tratamento de erros.

Declaração da rotina

Declaração de dados

Corpo (Instruções)

Manipulador trás p/ frente

Módulo

Declarações de dados

Rotina a

Rotina b

Rotina c

Rotina d

Rotina eTratamento de erros



Declaração de procedimento (Procedure declaration)

Exemplo: Multiplicar todos os elementos de uma matriz por um fator;

PROC arrmul( VAR num array{*}, num factor)FOR index FROM 1 TO dim( array, 1 ) DO

array{index} := array{index} * factor;ENDFOR

ENDPROC

Declaração de função (Function declaration)

Uma função pode retornar qualquer valor de tipo de dado, mas não um valor matricial.

Exemplo: Retornar o comprimento de um vetor;

FUNC num veclen (pos vector) RETURN Sqrt(Pow(vector.x,2)+Pow(vector.y,2)+Pow(vector.z,2));ENDFUNC

Declaração “trap” (Trap declaration)

Exemplo: Responder a um alimentador vazio;

TRAP feeder_empty wait_feeder; RETURN;ENDTRAP

3.5 Chamada de procedimento

Quando um procedimento for chamado, os argumentos que correspondem aos parâmet-ros do procediemnto devem ser usados:

- Parâmetros obrigatórios devem ser especificados. Eles também devem ser espe-cificados na ordem correta.

- Argumentos opcionais podem ser omitidos.

- Argumentos condicionais podem ser usados para transferir parâmetros de uma chamada de rotina para outra.

Veja o Capítulo Utilização de chamadas funcionais em expressões na página 32 para mais detalhes.

O nome do procedimento pode ser estatisticamente especificado usando um identifica-dor (early binding) ou avaliado durante o tempo de execução a partir de uma expressão do tipo de string (late binbing). Apesar da early binding dever ser considerada uma forma de chamada de procedimento “normal”, por vezes o late binbing fornece um código muito eficiente e compacto. O late binding é definido colocando os sinais antes e depois da string que indica o nome do procedimento.



C

Exemplo: ! early bindingTEST products_idCASE 1:

proc1 x, y, z;CASE 2:

proc2 x, y, z;CASE 3:

...

! mesmo exemplo usando ligação tardia% “proc” + NumToStr(product_id, 0) % x, y, z;

...

! mesmo exemplo usando outra variante de ligação tardiaVAR string procname {3} :=[“proc1”, “proc2”, “proc3”];

...% procname{product_id} % x, y, z;

...

Note que a ligação tardia está disponível apenas para chamadas de procedimento e não para chamadas de função.??? Se uma referência é feita a um procedimento desconhecido usando a ligação tardia, a variável do sistema ERRNO é definida para ERR_REFUNKPRC. Se uma referência é feita a um erro de chamada de procedimento (sintaxe, não procedimento) usando a ligação tardia, a variável do sistema ERRNO é definida para ERR_CALLPROC.

3.6 Sintaxe

Declaração da rotina (Routine declaration)

<routine declaration> ::=[LOCAL] ( <procedure declaration> | <function declaration> | <trap declaration> )| <comment>| <RDN>

Parâmetros (Parameters)

<parameter list> ::=<first parameter declaration> { <next parameter declaration> }

<first parameter declaration> ::= <parameter declaration>| <optional parameter declaration>| <PAR>

<next parameter declaration> ::=’,’ <parameter declaration> | <optional parameter declaration> | ’,’<optional parameter declaration> | ’,’ <PAR>

aracterísticas gerais 4-15


<optional parameter declaration> ::=’\’ ( <parameter declaration> | <ALT> )

{ ’|’ ( <parameter declaration> | <ALT> ) }<parameter declaration> ::=

[ VAR | PERS | INOUT] <data type> <identifier> [ ’{’ ( ’*’ { ’,’ ’*’ } ) | <DIM>] ’}’

| ’switch’ <identifier>

Declaração de procedimento (Procedure declaration)

<procedure declaration> ::=PROC <procedure name>’(’ [ <parameter list> ] ’)’<data declaration list><instruction list>[ BACKWARD <instruction list> ][ ERROR <instruction list> ]ENDPROC

<procedure name> ::= <identifier><data declaration list> ::= {<data declaration>}

Declaração de função (Function declaration)

<function declaration> ::=FUNC <value data type><function name>’(’ [ <parameter list> ] ’)’<data declaration list><instruction list>[ ERROR <instruction list> ]ENDFUNC

<function name> ::= <identifier>

Declaração da rotina “trap” (Trap routine declaration)

<trap declaration> ::=TRAP <trap name><data declaration list><instruction list>[ ERROR <instruction list> ]ENDTRAP

<trap name> ::= <identifier>

Chamada de procedimento (Procedure call)

<procedure call> ::= <procedure> [ <procedure argument list> ] ’;’<procedure> ::=

<identifier>| ’%’ <expression> ’%’



<procedure argument list> ::= <first procedure argument> { <procedure argument> }<first procedure argument> ::=

<required procedure argument>| <optional procedure argument>| <conditional procedure argument>| <ARG>

<procedure argument> ::=’,’ <required procedure argument>| <optional procedure argument>| ’,’ <optional procedure argument>| <conditional procedure argument>| ’,’ <conditional procedure argument>| ’,’ <ARG>

<required procedure argument> ::= [ <identifier> ’:=’ ] <expression><optional procedure argument> ::= ’\’ <identifier> [ ’:=’ <expression> ] <conditional procedure argument> ::= ’\’ <identifier> ’?’ ( <parameter> | <VAR> )






4 Tipos de Dados (data types)

Existem dois tipos diferentes de tipos de dados:

- um tipo atomic, no sentido que ele não é definido baseado em nenhum outro tipo e não pode ser dividido em partes ou componentes, por exemplo, num.

- um tipo record, composto por componentes nomeadas e ordenadas, por exem-plo, pos. Uma componente pode ser do tipo atomic ou record.

Um valor “record” pode ser expresso usando-se a representação agregada;

exemplo [ 300, 500, depth ] valor pos record agregado.

Uma componente específica de um dado “record” pode ser acessada usando-se o nome daquela componente;

exemplo pos1.x := 300; atribuição da componente x da pos1.

4.1 Tipos de dados sem valor (non-value)

Cada tipo de dado disponível ou é um tipo com valor (value) ou é sem valor (non-value). Simplesmente um tipo de dado com valor representa alguma forma de “valor”. Dados sem valor não podem ser usados em operações orientadas por valor:

- Inicialização

- Associação (:=)

- Verificações Equal to (=) e not equal to (<>)

- Instruções TEST

- Parâmetros IN (modo de acesso) em chamadas de rotina

- Tipos de dados funcionais (return)

Os dados de entrada (signalai, signaldi, signalgi) são do tipo semi value. Eles podem ser usados em operações orientadas por valor, exceto inicializações e associações.

A descrição de um tipo de dado somente é especificada quando ele for um tipo semi value ou sem valor.

4.2 Tipos de dados iguais (alias)

Um tipo de dado alias é definido como sendo igual a outro tipo. Dados com o mesmo tipo de dado (data type) podem ser substituídos um pelo outro.

Exemplo: VAR dionum high:=1;VAR num level; Está OK já que dionum é um tipo level:= high; de dado alias para num


4.3 Sintaxe

<data type> ::= <identifier>

[LOCAL] ( <record definition>| <alias definition> )

| <comment>| <TDN>

<record definition>::=RECORD <identifier> <record component list> ’;’ENDRECORD

<record component list> ::= <record component definition> |<record component definition> <record component list>

<record component definition> ::=<data type> <record component name>

<alias definition> ::=ALIAS <data type> <identifier> ’;’

<data type> ::= <identifier>


Características Básicas RAPID Dados

5 Dados

Existem três tipos de dados: variáveis, persistentes e constantes.

- uma variável pode ter um novo valor durante a execução do programa.

- uma persistente pode ser descrita como uma variável “persistente”. Isto é obtido deixando-se uma atualização do valor de uma persistente automaticamente causar a atualização do valor de inicialização de sua declaração. (Quando um programa é salvo o valor de inicialização de qualquer declaração da persistente reflete o valor atual da persistente).

- uma constante representa um valor estático e não pode ter um novo valor.

Uma declaração introduz o dado pela associação de um nome (identificador) com um tipo de dado. Com execeção de dados pré-definidos e variáveis de “loops”, todos os dados devem ser declarados.

5.1 Escopo dos dados

O escopo de um dado denota a área na qual ele é visível. A diretiva local opcional da declaração classifica o dado como local (dentro de um módulo), caso contrário ele é glo-bal. Note que a diretiva local pode ser usada somente a nível de módulo, não dentro de uma rotina.

Exemplo: LOCAL VAR num local_variable;VAR num global_variable;

Dados declarados fora da rotina são chamados de dados de programa. As seguintes regras de escopo se aplicam aos dados de programa:

- o escopo de dados pré-definidos ou globais pode incluir qualquer módulo.

- o escopo de dados locais compreende o módulo no qual ele está contido.

- dentro de seu escopo, dados locais escondem quaisquer dados globais ou rotinas com o mesmo nome (incluindo intruções, rotinas pré-definidas e dados).

Dados de programa não devem ter o mesmo nome que os outros dados ou rotina no mesmo módulo. Um dado global não deve possuir o mesmo nome que outro dado global ou rotina em outro módulo. Uma persistente não deve ter o mesmo nome que outra per-sistente no mesmo programa.

Dados declarados dentro da rotina são chamados de dados de rotina. Note que os parâmet-ros de uma rotina também são tratados como dados de rotina. As seguintes regras de escopo se aplicam aos dados de rotina:

- o escopo dos dados compreendem a rotina na qual eles estão contidos.

- dentro de seu escopo, dados de rotina escondem quaisquer outras rotinas ou dados com o mesmo nome.

Veja o exemplo da Figur 4.

Manual de Referência do RAPID 5-21

Dados Características Básicas RAPID

Figur 4 Exemplo: Os seguintes dados podem ser chamados a partir da rotina e:Módulo1: Dados c, d.Módulo2: Dados a, f, g, e1.Os seguintes dados podem ser chamados a partir da rotina h:Módulo1: Dado d.Módulo2: Dados a, f, g, h1, c.

Dados de rotina não devem ter o mesmo nome que outros dados ou etiquetas na mesma rotina.

5.2 Declaração de variáveis

Uma variável é introduzida por uma declaração de variável.

Exemplo: VAR num x;

Variáveis de quaisquer tipo podem ter um formato matricial (de grau 1, 2 ou 3) pela adição de informações dimensionais à declaração. Uma dimensão é um valor inteiro maior que 0.

Exemplo: VAR pos pallet{14, 18};

Variáveis com tipos de valor podem ser inicializadas (ter um valor inicial). A expressão usada para iniciar uma variável deve ser constante. Note que o valor de uma variável não inicializada pode ser usada, mas ela é indefinida, isto é, zero.

Exemplo: VAR string author_name := "John Smith";VAR pos start := [100, 100, 50];VAR num maxno{10} := [1, 2, 3, 9, 8, 7, 6, 5, 4, 3];

Módulo1 Módulo2

Dado local a

Dado local b

Dado c

Dado d

Dado e

Dado local a

Dado local f

Dado g

Rotina local e

Rotina h

Dado e1

Dado h1Dado c

5-22 Manual de Referência do RAPID


O valor de inicialização é setado quando:

- o programa é aberto,

- o programa é executado a partir de seu início.

5.3 Declaração de persistentes

Persistentes somente podem ser declaradas a nível de módulo, não dentro de uma rotina, e deverão ter sempre um valor inicial. O valor de inicialização deve ser um valor sim-ples (sem dados ou operandos), ou um agregado simples com membros, que por sua vez, são valores simples ou agregados simples.

Exemplo: PERS pos refpnt := [100.23, 778.55, 1183.98];

Persistentes de quaisquer tipo podem ter um formato matricial (de grau 1, 2 ou 3) pela adição de informações dimensionais à declaração. Uma dimensão é um valor inteiro maior que 0.

Exemplo: PERS pos pallet{14, 18} := [...];

Note que se o valor de uma persistente for atualizado, isto automaticamente causa a atu-alização do valor de inicialização da declaração da persistente.

Exemplo: PERS num reg1 := 0; ...reg1 := 5;

Após a execução, o programa terá o seguinte aspecto:

PERS num reg1 := 5; ...reg1 := 5;

É possível declarar dois persistentes com nome igual em diferentes módulos, se forem locais dentro do módulo (PERS LOCAL), sem qualquer erro do sistema (escopo de dados diferente). Contudo, observar a limitação de que estes dois persistentes sempre terão o mesmo valor atual (usam a mesma posição na memória).

5.4 Declaração de constantes

Uma constante é introduzida por uma declaração de constante. O valor de uma constante não pode ser modificado.

Exemplo: CONST num pi := 3.141592654;

Uma constante de qualquer tipo pode ter um formato matricial (de grau 1, 2 ou 3) pela adição de informações dimensionais à declaração. Uma dimensão é um valor inteiro maior que 0.

Exemplo: CONST pos seq{3} := [[614, 778, 1020],[914, 998, 1021],[814, 998, 1022]];



5.5 Dados de inicialização

O valor de inicialização para uma constante ou variável pode ser uma expressão con-stante.O valor de inicialização para um dado persistente só pode ser uma expressão lit-eral.

Example: CONST num a := 2;CONST num b := 3;! Correct syntaxCONST num ab := a + b;VAR num a_b := a + b;PERS num a__b := 5;! Faulty syntaxPERS num a__b := a + b;

No quadro abaixo, você pode ver o que acontece nas várias atividades, por exemplo, partida a quente, novo programa, início de programa, etc.

* Gera uma erro quando existe um erro semântico no programa de tarefa real.

5.6 Classe de armazenamento

A classe de armazenamento de um objeto de dados determina quando o sistema aloca e desaloca memória para o objeto de dados. A classe de armazenamento de um objeto de dados é determinada pelo tipo de objeto de dados e o contexto de sua declaração, podendo ser estática ou volátil.

Tabela 1

SituaçãodosistemaAfeta

Ligado (Partida a quente)

Abre, Fecha ou Novoprograma

Inicia programa (Move PP

para principal)


para Rotina)


para cursor)

Inicia programa (chama Rotina)

Inicia programa

(após ciclo)

Inicia programa

(Após parada)

Constante Inalterado Init Init Init Inalterado Inalterado Inalterado Inalterado

Variável Inalterado Init Init Init Inalterado Inalterado Inalterado Inalterado

Persistente Inalterado Init Init Init Inalterado Inalterado Inalterado Inalterado

Interrupções controladas

Re-orde-nado

Desaparece Desaparece Desaparece Inalterado Inalterado Inalterado Inalterado

Rotina de arraanque

SYS_RESET(com ajustes

de movi-mento)

Nãoexecuta

Executa* Executa Nãoexecuta

Nãoexecuta

Nãoexecuta

Nãoexecuta

Nãoexecuta

Arquivos Fecha Fecha Fecha Fecha Inalterado Inalterado Inalterado Inalterado

Trajeto Refeito na ligação

Desaparece Desaparece Desaparece Desaparece Inalterado Inalterado Inalterado



Constantes, dados persistentes e variáveis de módulo são estáticas, ou seja, têm o mesmo armazenamento durante a vida útil de uma tarefa. Isso significa que qualquer valor atribuído a um dado persistente ou a uma variável de módulo sempre permanece inal-terado até a próxima atribuição.

As variáveis de rotina são voláteis. A memória necessária para armazenar o valor de uma variável volátil é alocada primeiro quando da chamada da rotina na qual a declaração da variável está contida. A memória é, posteriormente, desalocada no ponto de retorno da chamada à rotina. Isso significa que o valor de uma variável de rotina é sempre indefinido antes da chamada à rotina e é sempre perdido (torna-se indefinido) no final da execução da rotina.

Em uma cadeia de chamadas recursivas à rotina (uma rotina chamada a si mesma direta ou indiretamente), cada instância da rotina recebe sua própria posição de memória para a “mesma” variável de rotina - são criadas várias instâncias da mesma variável.

5.7 Sintaxe

Declaração de dados (Data declaration)

<data declaration> ::=[LOCAL] ( <variable declaration> | <persistent declaration> | <constant declaration> )

| <comment> | <DDN>

Declaração de variáveis (Variable declaration)

<variable declaration> ::=VAR <data type> <variable definition> ’;’

<variable definition> ::=<identifier> [ ’{’ <dim> { ’,’ <dim> } ’}’ ]

[ ’:=’ <constant expression> ]<dim> ::= <constant expression>

Declaração de persistentes (Persistent declaration)

<persistent declaration> ::=PERS <data type> <persistent definition> ’;’

<persistent definition> ::=<identifier> [ ’{’ <dim> { ’,’ <dim> } ’}’ ]

’:=’ <literal expression>



Declaração de constantes (Constant declaration)

<constant declaration> ::=CONST <data type> <constant definition> ’;’

<constant definition> ::=<identifier> [ ’{’ <dim> { ’,’ <dim> } ’}’ ]

’:=’ <constant expression><dim> ::= <constant expression>



6 Instruções

As instruções são executadas em sucessão a não ser que uma instrução de fluxo de pro-grama, interrupção ou erro faça com que a execução continue em qualquer outro lugar.

A maioria das instruções são terminadas por ponto e vírgula “;”. Uma etiqueta (label) é terminada por dois pontos “:”. Algumas instruções são terminadas por palavras específi-cas:

Instrução Palavra de terminação

IF ENDIF

FOR ENDFOR

WHILE ENDWHILE

TEST ENDTEST

Exemplo: WHILE index < 100 DO.

index := index + 1; ENDWHILE

6.1 Sintaxe

<instruction list> ::= { <instruction> }<instruction> ::=

[<instruções de acordo com capítulo separado deste manual>| <SMT>





7 Expressões

Uma expressão especifica uma operação à um valor. Pode ser usada como:

- uma instrução de associação p.ex. a:=3*b/c;

- uma condição em uma instrução IF p.ex. IF a>=3 THEN ...

- um argumento em uma instrução p.ex. WaitTime time;

- um argumento em uma chamada funcional p.ex. a:=Abs(3*b);

7.1 Expressões aritméticas

Uma expressão aritmética é usada para operar um valor numérico.

Exemplo: 2*pi*radius

A Tabell 2 mostra os diferentes tipos de operações possíveis.

1. O resultado recebe o mesmo tipo que o operando. Se o operando possuir um tipo de dado “alias”, o resultado recebe o tipo alias "base" (num ou pos).

2. Operações com inteiros, p.ex. 14 DIV 4=3, 14 MOD 4=2.(operações com operandos não inteiros são ilegais)

3. Preserva a representação inteira (exata) desde que os operandos e o resultado sejam mantidos dentro do subdomínio do tipo num.

Tabell 2 Operações aritméticas

Operador Operação Tipos de operando Tipo de resultado

+ adição num + num num3)

+ manter sinal +num ou +pos o mesmo1)3)

+ adição de vetores pos + pos pos

- subtração num - num num3)

- trocar sinal -num ou -pos o mesmo1)3)

- subtração de vetores pos - pos pos

* multiplicação num * num num3)

* multiplicação de vetores por escalar num * pos ou pos * num pos

* produto de vetores pos * pos pos

* ligação de rotações orient * orient orient

/ divisão num / num num

DIV 2) divisão de inteiros num DIV num num

MOD 2) módulo inteiro; sobra num MOD num num



7.2 Expressões lógicas

Uma expressão lógica é usada para operar um valor lógico (TRUE/FALSE).

Exemplo: a>5 AND b=3

A Tabell 3 mostra os diferentes tipos de operações possíveis.

1) Somente tipos de dados com valor. Os operandos devem ter tipos iguais.

Observe que a avaliação de expressões envolvendo operadores and e or é otimizada de forma que o operando direito da expressão não seja avaliado se o resultado da operação puder ser determinado após a avaliação do operando esquerdo.

Tabell 3 Operações lógicas


< menor que num < num bool

<= menor ou igual a num <= num bool

= igual a qq 1)= qq 1) bool

>= maior ou igual a num >= num bool

> maior que num > num bool

<> não igual a qq 1) <> qq 1) bool

AND e bool AND bool bool

XOR ou exclusivo bool XOR bool bool

OR ou bool OR bool bool

NOT negação NOT bool bool

a AND b

ab

True False

True

False

True False

FalseFalse

a XOR b

ab

True False

True

False

False True

FalseTrue

a OR b

ab

True False

True

False

True True

FalseTrue

NOT b

b

True

False

False

True



7.3 Expressões com “strings”

Uma expressão com “strings” é usada para efetuar operações em “strings”.

Exemplo: “IN” + “PUT” dá o resultado “INPUT”

A Tabell 4 mostra uma operação possível.

.

7.4 Utilização de dados em expressões

Uma variável, persistente ou constante inteira pode ser uma parte de uma expressão.

Exemplo: 2*pi*radius

Matrizes

Uma variável, persistente ou constante declarada como uma matriz pode ser referenciada a toda a matriz ou a um simples elemento.

Um elemento da matriz é referenciado usando-se o número de índice do elemento. O índice é um valor inteiro maior que 0 não pode violar a dimensão declarada. O valor de índice 1 seleciona o primeiro elemento. O número de elementos na lista de índice deve corresponder ao grau declarado (1, 2 ou 3) da matriz.

Exemplo: VAR num row{3};VAR num column{3};VAR num value;

.value := column{3}; somente um elemento na matrizrow := column; todos os elementos na matriz

Registros

Uma variável, persistente ou constante declarada como um registro pode ser referenciada a todo o registro ou a uma simples componente.

Uma componente do registro é referenciada usando-se o nome da componente.

Exemplo: VAR pos home;VAR pos pos1;VAR num yvalue;..yvalue := home.y; somente a componente Ypos1 := home toda a posição

Tabell 4 Operações com “Strings”


+ concatenação de “strings” string + string string



7.5 Utilização de agregados em expressões

Um agregado é usado para valores de registro ou de matriz.

Exemplo: pos := [x, y, 2*x]; agregado de registro posposarr := [[0, 0, 100], [0,0,z]];agregado de matriz pos

Deve ser possível determinar o tipo de dados de um agregado no contexto. O tipo de dados de cada membro agregado deve ser igual ao tipo de membro correspondente do tipo determinado.

Exemplo VAR pos pl;p1 :=[1, -100, 12]; tipo de agregado post-determinado

por p1

IF [1, -100, 12] = [a,b,b,] THEN ilegal, visto que o tipo de dadosde nenhum dos agregados podeser determinado pelo contexto.

7.6 Utilização de chamadas funcionais em expressões

Uma chamada funcional inicia a operação de uma função específica e recebe o valor de volta da função.

Exemplo: Sin(angle)

Os argumentos de uma chamada funcional são usados para transferir dados para (e pos-sivelmente de) a função chamada. O tipo de dado de um argumento deve ser igual ao tipo do parâmetro correspondente da função. Os argumentos opcionais podem ser omitidos mas a ordem dos argumentos (atuais) deve ser a mesma dos parâmetros for-mais. Além disso, dois ou mais argumentos opcionais podem ser declarados para se excluirem, e no caso, somente um deles pode estar presente na lista de argumentos.

Um argumento necessário (compulsório) é separado a partir de um argumento prece-dente por uma vírgula “,”. O nome do parâmetro formal pode ser incluído ou omitido.

Exemplo: Polar(3.937, 0.785398) dois argumentos necessáriosPolar(Dist:=3.937, Angle:=0.785398)... utilizando nomes

Um argumento opcional deve ser precedido por uma barra invertida “\” e o nome do parâmetro formal. Um argumento tipo “switch” é especial; ele pode não incluir nen-huma expressão de argumento. Ao invés disso, tal argumento somente pode ser “pre-sente” ou “não presente”.

Exemplo: Cosine(45) um argumento necessárioCosine(0.785398\Rad) ... e uma “switch” Dist(p2) um argumento necessárioDist(\distance:=pos1, p2) ... e um opcional




Argumentos condicionais são usados para uma propagação suave dos argumentos opcionais através das cadeias das chamadas da rotina. Um argumento condicional é considerado “presente” se o parâmetro opcional especificado (da função que chama) estiver presente, caso contrário ele é simplesmente considerado omisso. Note que o parâmetro especificado deve ser opcional.

Exemplo: PROC Read_from_file (iodev File \num Maxtime)..character:=ReadBin (File \Time?Maxtime);

! Max. time is only used if specified when calling the routine! Read_from_file

..ENDPROC

A lista de parâmetros de uma função associa um modo de acesso para cada parâmetro. O modo de acesso pode ser in, inout, var ou pers:

- um parâmetro IN (default) permite o argumento ser qualquer expressão. A função chamada vê o parâmetro como uma constante.

- um parâmetro INOUT requer que o argumento correspondente seja uma var-iável (inteira, elemento matricial ou componente de registro) ou uma persistente inteira. A função ganha acesso (leitura/escrita) para o argumento.

- um parâmetro VAR requer que o argumento correspondente seja uma variável (inteira, elemento matricial ou componente de registro). A função ganha acesso (leitura/escrita) para o argumento.

- um parâmetro PERS requer que o argumento correspondente seja uma per-sistente inteira. A função ganha acesso (leitura/escrita) para o argumento.

7.7 Prioridade entre operadores

A prioridade relativa entre os operadores determina a ordem na qual as operações são efetuadas. O parênteses proporciona um meio de sobrepor a prioridade do operador. As regras abaixo implicam nas seguintes prioridades:

* / DIV MOD - mais alta+ -< > <> <= >= =ANDXOR OR NOT - mais baixa

Um operador com alta prioridade é efetuado antes de um operador com baixa priori-dade. Operadores com a mesma prioridade são efetuados da esquerda para direita.

Exemplo

Expressão Ordem de operação Comentário

a + b + c (a + b) + c regra esq. p/ dir.a + b * c a + (b * c) * é maior que +a OR b OR c (a OR b) OR c regra esq. p/ dir.


a AND b OR c AND d (a AND b) OR (c AND d) AND maior queOR

a < b AND c < d (a < b) AND (c < d) < maior que AND

7.8 Sintaxe

Expressões (Expressions)

<expression> ::=<expr>| <EXP>

<expr> ::= [ NOT ] <logical term> { ( OR | XOR ) <logical term> }<logical term> ::= <relation> { AND <relation> }<relation> ::= <simple expr> [ <relop> <simple expr> ]<simple expr> ::= [ <addop> ] <term> { <addop> <term> }<term> ::= <primary> { <mulop> <primary> }<primary> ::=

<literal>| <variable>| <persistent>| <constant>| <parameter>| <function call>| <aggregate>| ’(’ <expr> ’)’

Operadores (Operators)

<relop> ::= ’<’ | ’<=’ | ’=’ | ’>’ | ’>=’ | ’<>’<addop> ::= ’+’ | ’-’<mulop> ::= ’*’ | ’/’ | DIV | MOD

Valores constantes (Constant values)

<literal> ::= <num literal>| <string literal>| <bool literal>

Dados (Data)

<variable> ::=<entire variable>| <variable element>| <variable component>

<entire variable> ::= <ident><variable element> ::= <entire variable> ’{’ <index list> ’}’



<index list> ::= <expr> { ’,’ <expr> }<variable component> ::= <variable> ’.’ <component name><component name> ::= <ident><persistent> ::=

<entire persistent>| <persistent element>| <persistent component>

<constant> ::=<entire constant>| <constant element>| <constant component>

Agregados (Aggregates)

<aggregate> ::= ’[’ <expr> { ’,’ <expr> } ’]’

Chamadas funcionais (Function calls)

<function call> ::= <function> ’(’ [ <function argument list> ] ’)’<function> ::= <ident><function argument list> ::= <first function argument> { <function argument> }<first function argument> ::=

<required function argument>| <optional function argument>| <conditional function argument>

<function argument> ::=’,’ <required function argument>| <optional function argument>| ’,’ <optional function argument>| <conditional function argument>| ’,’ <conditional function argument>

<required function argument> ::= [ <ident> ’:=’ ] <expr><optional function argument> ::= ’\’ <ident> [ ’:=’ <expr> ]<conditional function argument> ::= ’\’ <ident> ’?’ <parameter>

Expressões especiais (Special expressions)

<constant expression> ::= <expression><literal expression> ::= <expression><conditional expression> ::= <expression>

Parâmetros (Parameters)

<parameter> ::=<entire parameter>| <parameter element>| <parameter component>





8 Recuperação de Erros

Um erro é uma situação anormal, relacionado com a execução de uma parte específica de um programa. Um erro faz com que a execução do programa seja impossível (ou no mín-imo perigosa). “Overflow” e “divisão por zero” são exemplos de erros. Os erros são iden-tificados pelo seu único número de erro e são sempre reconhecidos pelo robô. A ocorrência de um erro causa a suspensão da execução normal do programa e o controle é passado para um tratamento de erro. O conceito de tratamento de erro faz com que seja possível responder, e possivelmente, recuperar a execução partir dos erros que aparecem durante o programa. Se a execução posterior não for possível, o tratamento de erro pelo menos assegura que o programa é abortado de um modo suave.

8.1 Tratamento de erros

Qualquer rotina pode incluir um tratamento de erros. Um tratamento de erros é realmente uma parte da rotina, e o escopo de qualquer dado de rotina também compreende o trata-mento de erro da rotina. Se um erro ocorrer durante a execução da rotina, o controle é transferido para o seu tratamento de erro.

Exemplo: FUNC num safediv( num x, num y)RETURN x / y;

ERRORIF ERRNO = ERR_DIVZERO THEN

TPWrite "O numero nao pode ser igual a 0";RETURN x;

ENDIFENDFUNC

A variável do sistema ERRNO contem o número de erro (mais recente) e pode ser usada pelo tratamento de erro para identificar aquele erro. Após as ações necessárias terem sido tomadas, o tratamento de erro pode:

- Recomeçar a execução, iniciando pela instrução na qual o erro ocorreu. Isto é feito usando-se a instrução RETRY. Se esta instrução causar o mesmo erro novamente, até quatro tentativas de recuperação serão feitas; logo após a execução irá parar.

- Resume a execução, inicializando a instrução que segue a instrução na qual o erro ocorreu. Isto é feito usando a instrução TRYNEXT.

- Retorna o controle ao emissor da rotina usando a instrução RETURN. Se a rotina é uma função, a instrução RETURN tem de especificar um valor de retorno apro-priado.

- Propaga o erro ao emissor da rotina usando a instrução RAISE

Se ocorrer um erro numa rotina que não contenha um tratamento de erros ou quando se chegar ao fim do tratamento de erros (ENDFUNC, ENDPROC ou ENDTRAP), é cha-mado o tratamento de erros do sistema. O tratamento de erros do sistema informa a ocor-rência do erro, parando a execução.



Numa cadeia de rotina de chamados, cada rotina pode ter o seu próprio tratamento de erros. Se ocorrer um erro numa rotina com um tratamento de erros e se o erro for explic-itamente propagado usando a instrução RAISE, o mesmo erro ocorre novamente no ponto do chamado da rotina - o erro é propagado. Quando se alcançar o topo da cadeia de chamados (a rotina de entrada da tarefa) sem que se encontre qualquer tratamento de erros ou quando se chegar ao fim de um tratamento de erros na cadeia de chamados, o tratamento de erros do sistema é chamado. O tratamento de erros do sistema informa sobre o erro, parando a execução. Uma vez que uma rotina trap só pode ser chamada pelo sistema (em resposta a uma interrupção), os erros são sempre propagados de uma rotina trap para o tratamento de erros do sistema.

A recuperação de erros não está disponível para instruções no tratamento de trás para frente. Tais erros são sempre propagados para o tratamento de erros do sistema.

Além dos erros detectados e levantados pelo robô, um programa pode explicitamente levantar erros pelo uso da instrução RAISE. Esta facilidade pode ser usada para recu-peração a partir de situações complexas. Ela pode, por exemplo, ser usada para escapar de posições de código agrupadas. Os números de erro de 1- 90 podem ser usados na instrução RAISE. Os erros levantados explicitamente são tratados exatamente como erros levantados pelo sistema.

Note que não é possível recuperar ou responder a erros que ocorrem dentro de uma con-dição de erro. Tais erros são sempre propagados para o tratamento de erros do sistema.



9 Interrupções

Interrupções são eventos definidos pelo programa, identificados por um número de inter-rupção. Uma interrupção ocorre quando uma condição de interrupção for verdadeira. Diferentemente dos erros, a ocorrência de uma interrupção não está diretamente relacion-ada (sincronizada com) a uma posição de código específica. A ocorrência de uma inter-rupção causa a suspensão da execução normal do programa e o controle é passado para uma rotina “trap”.

Apesar do robô reconhecer imediatamente a ocorrência de uma interrupção (somente atrasada pela velocidade do hardware), a sua resposta – chamada da rotina “trap” corre-spondente – somente pode ter lugar em posições específifcas do programa, a saber:

- quando a próxima instrução entrar,

- a qualquer momento durante uma instrução de espera, p. ex. WaitUntil,

- a qualquer momento durante uma instrução de movimento, p. ex. MoveL.

Isto resulta normalmente em um atraso de 5-120 ms entre o reconhecimento da inter-rupção e sua resposta, dependendo do tipo de movimento que está sendo executado no instante da interrupção.

O levantamento das interrupções pode ser desabilitado e habilitado. Se as interrupções forem desabilitadas, qualquer interrupção que ocorrer é colocada em uma fila e não é levantada até que as interrupções sejam habilitadas novamente. Note que a fila da inter-rupção pode conter mais de uma interrupção na condição de espera. As interrupções são levantadas na ordem FIFO. As interrupções são sempre desabilitadas durante a execução de uma rotina “trap”.

Quando executar os passos e quando o programa tiver sido parado, não serão manuseadas nenhumas interrupções. As interrupções que forem geradas sob estas circunstâncias não serão tratadas.

O número máximo de interrupções simultâneas é de 70 por tarefa de programa. A lim-itação total definida pelo CPU de E/S é de 100 interrupções.

9.1 Manipulação de interrupções

A definição de uma interrupção faz com que a mesma seja reconhecida pelo robô. A defin-ição especifica a condição de interrupção e habilita a mesma.

Exemplo: VAR intnum sig1int;.

ISignalDI di1, high, sig1int;

Uma interrupção habilitada pode ser desabilitada (e vice-versa).Durante o período de desabilitação, quaisquer interrupções do tipo especificado geradas serão descartadas sem a execução de qualquer interceptação.



Exemplo: ISleep sig1int; desabilitada .

IWatch sig1int; habilitada

A deleção de uma interrupção remove a sua definição. Não é necessário remover explicitamente uma definição de interrupção, mas uma nova interrupção não pode ser associada a uma variável de interrupção até que a definição anterior tenha sido deletada.

Exemplo: IDelete sig1int;

9.2 Rotinas “trap”

As rotinas “trap” possibilitam um meio de lidar com interrupções. Uma rotina “trap” pode ser conectada a uma interrupção usando-se a instrução CONNECT. Quando uma interrupção ocorre, o controle é transferido imediatamente para a rotina “trap” associ-ada (se existir). Se uma interrupção ocorrer, e ela não tem nenhuma rotina “trap” conectada, isto é tratado como um erro fatal, isto é, causa o término imediato da execução do programa.

Exemplo: VAR intnum rmpty;VAR intnum full;

PROC main()VAR intnum empty;VAR intnum full;.CONNECT empty WITH etrap;conecta rotinas “trap”CONNECT full WITH ftrap;ISignalDI di1, high, empty;interrupções alimentadorISignalDI di3, high, full;.IDelete empty;IDelete full;

ENDPROC

TRAP etrap responde à interrupçãoopen_valve; de “alimentador vazio”RETURN;

ENDTRAP

TRAP ftrap responde à interrupçãoclose_valve; de “alimentador cheio”RETURN;

ENDTRAP

Várias interrupções podem ser conectadas a uma mesma rotina “trap”. A variável do sistema INTNO contem um número de interrupção e pode ser usada por uma rotina “trap” para identificar uma interrupção. Após as ações necessárias terem sido tomadas, a rotina “trap” pode ser terminada uando-se a instrução RETURN ou quando o fim (ENDTRAP ou ERROR) da rotina “trap” for alcançado. A execução continua a partir do lugar de onde a interrupção ocorreu.



10 Execução de trás para frente

Um programa pode ser executado de trás para frente uma instrução por vez. As seguin-tes restrições gerais são válidas para execução de trás para frente:

- as instruções IF, FOR, WHILE e TEST não podem ser executadas de trás para frente.

- Não é possível efetuar o recuo de uma rotina quando se atinge o início da rotina.

10.1 Manipuladores de trás para frente

Os procedimentos podem conter um manipulador de trás para frente que definem a execução de trás para frente de uma chamada de procedimento.

O manipulador de trás para frente é realmente uma parte do procedimento e o escopo de qualquer dado de rotina também compreende o manipulador de trás para frente do procedimento.

Exemplo: PROC MoveTo ()MoveL p1,v500,z10,tool1;MoveL p2,p3,v500,z10,tool1;MoveL p4,v500,z10,tool1;

BACKWARDMoveL p4,v100,z10,tool1;MoveL p2,p3,v100,z10,tool1;MoveL p1,v500,z10,tool1;

ENDPROC

Quando o procedimento é chamado durante a execução para frente, ocorre o seguinte:

PROC MoveTo ().. MoveL p1,v500,z10,tool1;MoveTo; MoveL p2,p3,v500,z10,tool1;.. MoveL p4,v500,z10,tool1;


ENDPROC



Quando o procedimento é chamado durante a execução de trás para frente, o seguinte ocorre:

PROC MoveTo ().. MoveL p1,v500,z10,tool1;MoveTo; MoveL p2,p3,v500,z10,tool1;.. MoveL p4,v500,z10,tool1;


ENDPROC

As instruções do tratamento de erros não podem ser executadas de trás para frente. A execução de trás para frente não pode ser agrupada, isto é, duas instruções em um elo de chamada não podem ser executadas de trás para frente simultaneamente.

Um procedimento sem um manipulador de trás para frente não pode ser executado de trás para frente. Um procedimento com um manipulador de trás para frente vazio é exe-cutado como uma “não operação”.

10.2 Limitação de instruções de movimento no manipulador de trás para a frente

O tipo e a seqüência da instrução de movimento no manipulador de trás para a frente deverá ser um espelho do tipo e da seqüência da instrução de movimento da execução para a frente na mesma rotina:

Note que a ordem de CirPoint p2 e ToPoint p3 em MoveC deverá ser a mesma.

As instruções de movimento se referem a todas as instruções que resultam em algum movimento do robô ou de eixos externos, como MoveL, SearchC, TriggJ, ArcC, PaintL ...

Qualquer afastamento desta limitação de programação no manipulador de trás para a frente poderá resultar em falha do movimento de trás para a frente. O movimento linear poderá resultar em movimento circular e vice versa, em alguma parte do trajeto de trás para a frente.

PROC MoveTo ()MoveL p1,v500,z10,tool1;MoveC p2,p3,v500,z10,tool1;MoveL p4,v500,z10,tool1;

BACKWARDMoveL p4,v500,z10,tool1;MoveC p2,p3,v500,z10,tool1;MoveL p1,v500,z10,tool1;

ENDPROC

Plano do espelho



11 Multitarefa

Os eventos em uma célula robotizada normalmente são em paralelo, então por que os programas não são em paralelo ?

A Multitarefa RAPID é uma maneira de executar programas em (pseudo) paralelo com a execução normal. A execução é iniciada na energização e continua indefinida-mente, a não ser que ocorra um erro no programa. Um programa paralelo pode ser colo-cado em um plano posterior (background) ou em um plano anterior (foreground) de outro programa. Ele também pode estar no mesmo nível que outro programa.

Para o uso desta função o robô deve ser configurado com uma TAREFA (task) extra para cada programa em background.

Até 10 tarefas diferentes podem ser rodadas em pseudo paralelo. Cada tarefa é con-stituída por um conjunto de módulos, do mesmo modo que um programa normal. Todos os módulos são locais em cada tarefa.

As variáveis e constantes são locais em cada tarefa, mas as persistentes não. Uma per-sistente com mesmo nome e tipo pode ser alcançada em todas as tarefas. Se duas per-sistentes tiverem o mesmo nome, mas seu tipo ou tamanho (dimensão da matriz) forem diferentes, um erro de rotina acontecerá.

Uma tarefa tem o seu próprio tratamento trap e as rotinas de eventos apenas são acion-adas nos seus próprios estados de sistemas de tarefas (por exemplo Start/Stop/Restart...).

Existem algumas restrições no uso da Multitarefa RAPID.

- Não misture programas paralelos com um PLC. O tempo de resposta é o mesmo que o tempo de resposta de interrupção para uma tarefa. Isto é verdade, é claro, quando a tarefa não está em background de outro programa ocupado.

- Existe somente uma unidade de programação física, portanto tome cuidado para que um TPWrite não se misture com a Janela do Operador para todas as tarefas.

- Quando rodar uma instrução Wait em modo manual, um diálogo de simulação aparecerá após 3 segundos. Isto ocorrerá na tarefa principal.

- As instruções de movimento só podem ser executadas na tarefa principal (a tarefa conexão do program instance 0, veja o Guia do Usuário - Parâmetros do sistema).

- A execução de uma tarefa será interrompida durante o tempo em que outras tarefas estão acedendo ao sistema de arquivos, isto se o operador escolher guardar ou abrir um programa, ou se o programa numa tarefa usar as instruções carregar/ apagar/ ler/ escrever.

- A unidade de programação não pode acessar outras tarefas além da principal. Portanto, o desenvolvimento de programas RAPID para outras tarefas somente pode ser feito se o código for carregado na tarefa principal, ou off-line.

Para todos os ajustes, veja o Guia do Usuário - Parâmetros do Sistema.



11.1 Sincronização de tarefas

Em muitas aplicações, uma tarefa paralela somente supervisiona uma unidade de uma célula, independente das outras tarefas sendo executadas. Em tais casos, nenhum mecanismo de sincronização é necessário. Mas existem aplicações onde é necessário saber o que a tarefa principal está fazendo, por exemplo.

Sincronização usando-se “polling”

Esta é a maneira mais fácil de fazer, mas o rendimento será o mais vagaroso.

Persistentes são usadas juntamente com as intruções WaitUntil, IF, WHILE ou GOTO.

Se a instrução WaitUntil for usada, ela questionará internamente a cada 100 ms. Não use um “polling” mais freqüente em outras implementações.

Exemplo

TAREFA 0

MODULE module1PERS bool startsync:=FALSE;PROC main()

startsync:= TRUE;.

ENDPROCENDMODULE

TAREFA 1

MODULE module2PERS bool startsync:=FALSE;PROC main()

WaitUntil startsync;.

ENDPROCENDMODULE

Sincronização usando-se uma interrupção

são usadas as instruções SetDO e ISignalDO.

Exemplo

TAREFA 0



MODULE module1PROC main()

SetDO do1,1;.

ENDPROCENDMODULE

TAREFA 1

MODULE module2VAR intnum isiint1;PROC main()

CONNECT isiint1 WITH isi_trap;ISignalDO do1, 1, isiint1;

WHILE TRUE DOWaitTime 200;

ENDWHILE

ENDPROC

TRAP isi_trap

.

ENDTRAPENDMODULE

11.2 Comunicação intertarefas

Todos os tipos de dados podem ser enviados entre duas (ou mais) tarefas persistentes.

Uma variável persistente é global em todas as tarefas. A variável persistente deve ser do mesmo tipo e tamanho (dimensão matricial) em todas as tarefas em que ela for declarada. Caso contrário um erro de operação (runtime) irá ocorrer.

Todas as declarações devem especificar um valor inicial para a variável persistente, mas somente o primeiro módulo carregado com a declaração irá usa-lo.

Exemplo

TAREFA 0

MODULE module1PERS bool startsync:=FALSE;PERS string stringtosend:=””;PROC main()



stringtosend:=”this is a test”;

startsync:= TRUE

ENDPROCENDMODULE

TAREFA 1

MODULE module2PERS bool startsync:=FALSE;PERS stringtosend:=””;PROC main()

WaitUntil startsync;

!read stringIF stringtosend = “this is a test” THEN

ENDPROCENDMODULE

11.3 Tipo de tarefa

Cada tarefa extra (não 0) é iniciada na sequência de início do sistema. Se a tarefa for do tipo STATIC, ela será reiniciada na posição atual (onde o PP estava quando o sis-tema foi desligado), mas se o tipo for setado para SEMISTATIC, ela será reiniciada a a partir do começo toda vez que a energia for ligada.

Também é possível setar a tarefa para o tipo NORMAL, então ela terá o mesmo com-portamento que a tarefa 0 (a tarefa principal que controla os movimentos do robô). A unidade de programação somente pode ser usada para iniciar a tarefa 0, e portanto o único modo de iniciar outras tarefas tipo NORMAL é usar o CommunicationWare.

11.4 Prioridades

O modo padrão de executar as tarefas é roda-las todas ao mesmo nível de um modo circular (um passo básico para cada instância). Mas é possível mudar a prioridade de uma tarefa colocando-a em background de outra. Então a background somente exec-utará quando a foreground estiver esperando por alguns eventos, ou tiver parado a execução (idle). Um programa do robô com instruções de movimentação estará em estado ”idle”, ocioso, a maioria do tempo.

O exemplo abaixo descreve algumas situações onde o sistema possui 10 tarefas (veja a Figura 5)

Elo circular 1: tarefas 0, 1 e 8 estão ocupadas

Elo circular 2: tarefas 0, 3, 4, 5 e 8 estão ocupadastarefas 1 e 2 estão ociosas



Elo circular 3: tarefas 2, 4 e 5 estão ocupadastarefas 0, 1, 8 e 9 estão ociosas.

Elo circular 4: tarefas 6 e 7 estão ocupadastarefas 0, 1, 2, 3 4, 5, 8 e 9 estão ociosas

Figura 5 As tarefas podem ter diferentes prioridades.

11.5 Dimensões das tarefas

O sistema irá fornecer uma área de memória com uma instalação dependendo da dimen-são. Esta área é partilhada por todas as tarefas.

Se a memória para uma tarefa for definida nos parâmetros do sistema, ser-lhe-á atribuída a quantidade de memória especificada.

Todas as tarefas sem especificações de dimensão deverão partilhar a parte livre da área fornecida da seguinte forma. Se a dimensão da tarefa principal não for especificada, ser-lhe-á atribuída a percentagem da área livre que é especificada no parâmetro da MemoryTask0 (veja Parâmetros do Sistema). O restante da área livre será repartida em partes iguais entre as outras tarefas.

tarefa 3

tarefa 7

tarefa 6

tarefa 9

tarefa 5

tarefa 2

tarefa 4

tarefa 8

tarefa 1

tarefa 0

elo 1 elo 2

elo 3

elo 4



O valor de uma variável persistente será armazenado numa parte separada do sistema e não afetará a área de memória acima mencionada. Veja Parâmetros do Sistema - Aver-agePers.

11.6 Algo para pensar

Quando você especificar as prioridades das tarefas, você deve pensar sobre o seguinte:

- Sempre use o mecanismo de interrupção ou “loops” com atrasos nas tarefas de supervisão. Caso contrário, a unidade de programação nunca terá tempo para uma interação com o usuário. Se a tarefa de supervisão for executada em pri-meiro plano, nunca será permitida a execução de outra tarefa em segundo plano.


Movimento e Princípios de E/S Sistemas de Coordenadas

1 Sistemas de Coordenadas

1.1 O ponto central da ferramenta do robô (TCP)

A posição do robô e seus movimentos estão sempre relacionados ao ponto central da ferramenta. Este ponto é normalmente definido em alguma parte da ferramenta, por exemplo, no bico de aplicação da pistola de cola, no centro da garra ou na extremidade de uma ferramenta.

Vários TCP’s (ferramentas) podem ser definidos, mas somente um pode ser ativado por vez. Quando uma posição é registrada, é a posição de um TCP que é gravada. Este também é o ponto que se move no trajeto a uma dada velocidade.

Se o robô está segurando um objeto de trabalho e trabalhando com uma ferramenta estacionária, um TCP estacionário é usado. Se esta ferramenta é ativada, o trajeto programado e a velocidade estão relacionados ao objeto de trabalho. Veja Ferramenta Estacionária na página 10.

1.2 Sistemas de coordenadas usados para determinar a posição do TCP

A posição da ferramenta (TCP’s) pode ser especificada em diferentes sistemas de coordenadas para facilitar a programação e ajustes de programas.

O sistema de coordenadas definido depende do que o robô tem que fazer. Quando nenhum sistema de coordenadas é definido, as posições do robô são definidas no sistema de coordenadas de base.

1.2.1 Sistema de coordenadas de base

Em uma aplicação simples, a programação pode ser feita no sistema de coordenadas de base; aqui o eixo z coincide com o eixo 1 do robô (veja Figura 1).

Figura 1 O sistema de coordenadas de base.

Z

X

Y


Sistemas de Coordenadas Movimento e Princípios de E/S

O sistema de coordenadas de base está localizado na base do robô:

- A origem está situada na intersecção do eixo 1 e a superfície da base montada.

- O plano xy é o mesmo que a superfície da base montada.

- O eixo x aponta para frente.

- O eixo y aponta para a esquerda (da perspectiva do robô).

- O eixo z aponta para cima.

1.2.2 Sistema de coordenadas global

Se o robô está montado no solo, programar no sistema de coordenadas de base é fácil. Se, entretanto, o robô está montado acima do solo (suspenso), programar no sistema de coordenadas de base é mais difícil porque as direções dos eixos não são as mesmas que as direções principais na área de trabalho. Nestes casos, é mais comum definir um sistema de coordenadas global. O sistema de coordenadas global irá coincidir com o sistema de coordenadas de base, se este não for definido especificamente.

Às vezes, vários robôs trabalham na mesma área de trabalho em uma planta. Um sistema de coordenadas global comum é usado neste caso para habilitar o programa do robô se comunicar um com o outro. Também pode ser vantajoso usar este tipo de sistema quando as posições estão relacionadas a um ponto fixo na área de trabalho comum aos dois robôs. Veja o exemplo na Figura 2.

Figura 2 Dois robôs (um dos quais suspenso) com um sistema de coordenadas global comum.

Coordenadas de base do robô 2

x

y

z

Coordenadas global

Coordenadas de base do robô 1

Z

X

YZ

X

Y



1.2.3 Sistema de coordenadas do usuário

Um robô pode trabalhar com diferentes bases ou superfícies de trabalho tendo diferentes posições e orientações. Um sistema de coordenadas do usuário pode ser definido para cada base. Se todas as posições são armazenadas em coordenadas de objeto, você não precisará reprogramar se a base precisar ser movida ou girada. Movendo/girando o sistema de coordenadas do usuário como a base foi movida/girada, todas posições programadas seguirão a base e a reprogramação não será necessária.

O sistema de coordenadas do usuário é definido baseado no sistema de coordenadas global (veja Figura 3).

Figura 3 Dois sistemas de coordenadas do usuário descrevem a posição de duas bases.

1.2.4 Sistema de coordenadas do objeto

O sistema de coordenadas do usuário é usado para conseguir diferentes sistemas de coordenadas para diferentes bases ou superfícies de trabalho. Uma base, entretanto, pode incluir vários objetos de trabalho que são processados ou tratados pelo robô. Logo, isto normalmente ajuda a definir um sistema de coordenadas para cada objeto de trabalho para tornar mais fácil o ajuste do programa se o objeto de trabalho for movido ou se um novo objeto, igual ao anterior, é programado em um local diferente. Um sistema de coordenadas referido a um objeto é chamado sistema de coordenadas do objeto. Este sistema de coordenadas também é usado em programação off-line desde

Sistema de coordenadas de base

x

y

z

Coordenadas global

Coordenadas do usuário 1

Z

X

Y

Y

Z

X

Coordenadas do usuário 2

Y

Z

X



que as posições especificadas sejam tiradas diretamente de um desenho do objeto de trabalho. O sistema de coordenadas do objeto também pode ser usado para movimentar o robô. O sistema de coordenadas do objeto é definido baseado no sistema de coordenadas do usuário (veja Figura 4).

Figura 4 Dois sistemas de coordenadas do objeto descrevem a posição de dois diferentes objetos de trabalho localizados na mesma base.

As posições programadas são sempre definidas em relação a um sistema de coordenadas do objeto. Se uma base é movida/girada, isto pode ser compensado pelo movimento/giro do sistema de coordenadas do usuário. Nem as posições programadas nem os sistemas de coordenadas do objeto definidos precisam ser alterados. Se o objeto de trabalho é movido/girado, este pode ser compensado pelo movimento/giro do sistema de coordenadas do objeto.

Se um sistema de coordenadas do usuário é móvel, isto é, eixos externos coordenados são usados, então o sistema de coordenadas do objeto se move com o sistema de coordenadas do usuário. Isto torna possível mover o robô em relação ao objeto quando a mesa de trabalho for manipulada.

1.2.5 Sistema de coordenadas de deslocamento

Às vezes, o mesmo trajeto deve ser executado em vários lugares no mesmo objeto. Para evitar de reprogramar todas as posições cada vez, um sistema de coordenadas, conhecido como sistema de coordenadas de deslocamento, é definido. Este sistema de coordenadas também pode ser usado em conjunto com procuras, para compensar as diferenças nas posições de partes individuais. O sistema de coordenadas de deslocamento é definido baseado no sistema de coordenadas do objeto (veja Figura 5).

Coordenadas do usuário

x

y

z

Coordenadas global

Coordenadas do objeto 2

yy

z

z

xx

y

z

x

Coordenadas do objeto 1



Figura 5 Se o deslocamento de programa é ativado, todas as posições são deslocadas

1.2.6 Eixos externos coordenados

Coordenação do sistema de coordenadas do usário

Se um objeto de trabalho está localizado em uma unidade mecânica externa, este é movido enquanto o robô está executando um trajeto definido no sistema de coordenadas do objeto, um sistema de coordenadas do usuário móvel pode ser definido. A posição e orientação do sistema de coordenadas do usuário irá, neste caso, ser dependente das rotações dos eixos da unidade externa. O trajeto programado e a velocidade serão então relacionados ao objeto de trabalho (veja Figura 6) e não haverá necessidade de considerar o fato que este objeto é movido pela unidade externa.

Figura 6 Um sistema de coordenadas do usuário, definido seguindo os movimentos do eixo 3 de uma unidade mecânica externa.

Posição original

Posição nova

x

yx

y

Coordenadas do objeto

Coordenadas de deslocamento

eixo 1

eixo 2 eixo 3

x

y

z

Coordenadas global


y

z

x



Coordenação do sistema de coordenadas de base

Um sistema de coordenadas móvel pode também ser definido pela base do robô. Isto é interessante na instalação quando o robô é montado em um trilho, por exemplo. A posição e orientação do sistema de coordenadas de base irá, como pelo sistema de coordenadas do usuário, ser dependente dos movimentos da unidade externa. O trajeto programado e velocidade serão relacionados ao sistema de coordenadas do objeto (Figura 7) e não haverá necessidade de pensar sobre o fato que a base do robô é movida pela unidade externa. Uma coordenada do sistema de coordenadas do usuário e uma coordenada do sistema de coordenadas de base podem ser definidos ao mesmo tempo.

Figura 7 Interpolação coordenada com um trilho movendo o sistema de coordenadas de base do robô.

Para possibilitar calcular os sistemas de coordenadas do usuário e de base quando as unidades envolvidas são movidas, o robô deve conhecer:

- As posições de calibração dos sistemas de coordenadas do usuário e da base

- As relações entre os ângulos dos eixos externos e a translação/rotação dos sis-temas de coordenadas do usuário e da base.

Estas relações são definidas nos parâmetros do sistema.

1.3 Sistemas de coordenadas usados para determinar a direção da ferramenta

A orientação de uma ferramenta em uma posição programada é dada pela orientação do sistema de coordenadas de ferramenta. O sistema de coordenadas de ferramenta é referido ao sistema de coordenadas do punho, definido pelo flange de montagem no punho do robô.

Coordenadas do objeto

Coordenadas de base

Coordenadas glo-bal

Track




1.3.1 Sistema de coordenadas de punho

Em uma aplicação simples, o sistema de coordenadas de punho pode ser usado para definir a orientação da ferramenta; aqui o eixo z coincide com o eixo 6 do robô (veja Figura 8).

Figura 8 O sistema de coordenadas de punho.

O sistema de coordenadas de punho não pode ser alterado e é sempre o mesmo que no flange de montagem do robô respeitando:

- A origem está situada no centro do flange de montagem ( superfície do flange de montagem).

- O eixo x aponta na direção oposta ao furo de controle do flange de montagem.

- O eixo z aponta para fora, em ângulo a direita do flange de montagem.

1.3.2 Sistema de coordenadas da ferramenta

A ferramenta fixada no flange de montagem do robô normalmente precisa ter seu próprio sistema de coordenadas para habilitar a definição de seu TCP, o qual é a origem do sistema de coordenadas da ferramenta. O sistema de coordenadas da ferramenta pode também ser usado para conseguir direções de movimento apropriadas quando movimentar o robô.

Se uma ferramenta é danificada ou trocada, tudo que você precisa fazer é redefinir o sistema de coordenadas de ferramenta. O programa normalmente não tem que ser alterado.

O TCP (origem) é selecionado como o ponto na ferramenta que deve ser posicionado corretamente, por exemplo, o bico de aplicação da pistola de cola. Os eixos coordenados da ferramenta são definidos como os naturais da ferramenta em questão.

xz

y



Figura 9 Sistema de coordenadas de ferramenta, como é normalmente definido para a tocha de solda a arco (esquerda) e a pinça de solda a ponto (direita).

O sistema de coordenada de ferramenta é definido baseado no sistema de coordenada de punho (veja Figura 10).

Figura 10 O sistema de coordenada de ferramenta é definido relativo ao sistema de coordenada de punho, aqui para uma garra.

1.3.3 TCP’s estacionários

Se o robô está segurando o objeto de trabalho e trabalhando em uma ferramenta estacionária, um TCP estacionário é usado. Se esta ferramenta é ativada, o trajeto programado e velocidade estão relacionados ao objeto de trabalho preso ao robô.

Isto signiifca que os sistemas de coordenadas serão mantidos, como na Figura 11.

Pontax

z

x

z

Ponta

z

y

x

Coordenada de ferramenta



Figura 11 Se um TCP estacionário é usado, o sistema de coordenadas de objeto é normalmente baseado no sistema de coordenadas de punho.

No exemplo da Figura 11, nem o sistema de coordenadas do usuário nem o deslocamento de programa é usado. É, entretanto, possível usá-los e, se eles são usados, eles estarão relacionados um ao outro como mostra a Figura 12.

Figura 12 Deslocamento do programa pode também ser usado junto com TCP’s estacionários.

Coordenada de base

x

y

z

Coordenada global

Z

X

Y

Coordenada de ferramenta

Z

X

Y

Z

YX

Coordenada de objeto

x

y

z

Coordenadas de punho

x

y

z

Coordenadas de objeto

x

y

z


x

y

z

Coordenadas de deslocamento



1.4 Informação relacionada

Descrito em:

Definição do sistema de coordenadas global Guia do Usuário - Parâmetros do Sistema

Definição do sistema de coord. do usuário Guia do Usuário - CalibraçãoTipos de dados - wobjdata

Definição do sistema de coord. do objeto Guia do Usuário - CalibraçãoTipos de dados - wobjdata

Definição do sistema de coord.de ferramenta Guia do Usuário - CalibraçãoTipos de dados - tooldata

Definição de um ponto central da ferramenta Guia do Usuário - CalibraçãoTipos de dados - tooldata

Definição da base de deslocamento Guia do Usuário - CalibraçãoSumário RAPID - Ajuste de Movi-mento

Movimento em diferentes sist.de coordenadas Guia do Usuário - Movimentação


Movimento e Princípios de E/S Posicion. na Execução do Programa

2 Posicion. na Execução do Programa

2.1 Geral

Durante execução do programa, as instruções de posicionamento no programa do robô controlam todos os movimentos. A tarefa principal das instruções de posicionamento é fornecer a seguinte informação de como executar movimentos:

- O ponto destino do movimento (definido como a posição do ponto central da ferramenta, a configuração do robô e a posição dos eixos externos).

- O método de interpolação usado para chegar no ponto destino, por exemplo, interpolação de eixo, interpolação retangular ou interpolação circular.

- A velocidade do robô e eixos externos.

- O dado de zona (define como o robô e eixos externos passarão pelo ponto destino).

- Os sistemas de coordenadas (ferramenta, usuário e objeto) usado para o movimento.

Como uma alternativa para definir a velocidade do robô e eixos externos, o tempo do movimento pode ser programado. Isto deve, entretanto, ser evitado se a função de ondulação é usada. Ao invés disto as velocidades de orientação e eixos externos devem ser usados para limitar a velocidade, quando pequenos ou movimentos do TCP são feitos.

No manuseio de material e aplicações de paletas com movimentos intensos e frequentes, a supervisão do sistema de acionamento pode parar o robô para evitar o sobreaquecimento dos drives ou do motor. Se tal acontecer, o tempo de ciclo precisa ser ligeiramente aumentado através da redução da velocidade ou da aceleração programada.

2.2 Interpolação da posição e orientação da ferramenta

2.2.1 Interpolação de eixos

Quando a precisão do trajeto não é muito importante, este tipo de movimento é usado para mover a ferramenta do robô rapidamente de uma posição para outra. A interpolação de eixo também permite um eixo mover-se de qualquer localização para outra na sua área de trabalho, em um movimento singular.

Todos eixos se movem do ponto inicial para o ponto destino com uma velocidade de eixo constante (veja Figura 13).


Posicion. na Execução do Programa Movimento e Princípios de E/S

Figura 13 Interpolação de eixos é a forma mais rápida para mover-se entre dois pontos pois os eixos do robô seguem o trajeto mais próximo entre o ponto inicial e o ponto destino (pela perpectiva dos ângulos dos eixos).

A velocidade do ponto central da ferramenta é expresso em mm/s (no sistema de coordenadas do objeto). Como a interpolação movimenta eixo-a-eixo, a velocidade não será exatamente o valor programado.

Durante a interpolação, a velocidade do eixo de limitação, isto é, o eixo que se move mais rápido em relação a sua velocidade máxima para executar o movimento, é determinada. Então, as velocidades de permanência dos eixos são calculadas para que todos os eixos alcancem o ponto destino ao mesmo tempo.

Os eixos estão coordenados para obter uma trajetória independente da velocidade. A aceleração é automaticamente otimizada para uma performance máxima do robô.

2.2.2 Interpolação retangular

Durante a interpolação retangular, o TCP move-se ao longo de uma linha reta entre os pontos inicial e final (veja Figura 14).

e

Figura 14 Interpolação retangular sem reorientação da ferramenta.

Para obter um trajeto linear no sistema de coordenadas do objeto, os eixos do robô devem seguir um trajeto não linear no espaço do eixo. Quanto mais a configuração do robô é não linear, maior é a aceleração e desaceleração necessária para fazer a ferramenta se mover em linha reta e obter a orientação da ferramenta desejada. Se a configuração é extremamente não linear (na proximidade do punho e singularidades do braço), um ou mais dos eixos precisará de mais torque que o motor pode fornecer. Neste caso, a velocidade de todos os eixos será automaticamente reduzida.

A orientação da ferramenta permanece constante durante o movimento inteiro, a menos que uma reorientação tenha sido programada. Se a ferramenta tiver sido reorientada, é rodada à velocidade constante.

Ponto destinoTrajeto interpoladode eixoPonto início

Ponto inicial Ponto destino



Uma velocidade rotacional máxima (em graus por segundo) pode ser especificada quando rotacionamos a ferramenta. Se esta é setada em um valor baixo, a reorientação será suave, independente da velocidade definida para o ponto central da ferramenta. Se este for um valor alto, a velocidade de reorientação é somente limitada pela velocidade máxima do motor. Contanto que o motor não exceda o limite do torque, a velocidade definida será mantida. Se, por outro lado, um dos motores exceder o limite da corrente, a velocidade de todo o movimento (com relação a posição e orientação) será reduzida.

Todos os eixos são coordenados para obter um trajeto que é independente da velocidade. A aceleração é otimizada automaticamente.

2.2.3 Interpolação circular

Um trajeto circular é definido usando três posições programadas que definem um segmento circular. O primeiro ponto a ser programado é o início do segmento circular. O próximo ponto é um ponto suporte (ponto circular) usado para definir a curvatura do círculo, e o terceiro ponto marca o final do círculo (veja Figura 15).

Os três pontos programados devem ser separados com intervalos regulares ao longo do arco do círculo para torná-lo o mais preciso possível.

A orientação definida pelo ponto suporte é usada para selecionar entre uma curvatura curta e longa da orientação do ponto inicial para o ponto final.

Se a orientação programada é a mesma em relação ao círculo do ponto inicial ao final, e a orientação para o suporte está perto da mesma orientação relacionada ao círculo, a orientação da ferramenta será mantida constante em relação ao trajeto.

Figura 15 Interpolação circular com uma pequena curvatura da parte de um círculo (segmento circular) com um ponto inicial, ponto circular e ponto destino.

Entretanto, se a orientação do ponto suporte é programada próxima a orientação rotacionada em 180°, a curvatura alternativa é selecionada (veja Figura 16).

Ponto inicial

Ponto circular

Ponto destino



Figura 16 Interpolação circular com uma longa curvatura para orientação é obtida definindo a orientação no ponto circular na direção oposta comparado com o ponto inicial.

Contanto que todos os torques do motor não excedam o valor máximo permitido, a ferramenta irá se mover na velocidade programada ao longo do arco do círculo. Se o torque de qualquer um dos motores for insuficiente, a velocidade será automaticamente reduzida para estas partes do trajeto circular onde o rendimento do motor é insuficiente.

Todos eixos são coordenados para obter um trajeto independente da velocidade. A aceleração é otimizada automaticamente.

2.2.4 SingArea\Wrist

Durante a execução na proximidade de um ponto singular, interpolação retangular ou circular podem ser problemáticas. Neste caso, é melhor usar interpolação modificada, o que significa que os eixos do punho são interpolados eixo-a-eixo, com o TCP seguindo um trajeto linear ou circular. A orientação da ferramenta, entretanto, será diferente da orientação programada.

No caso de SingArea\Wrist a orientação no ponto de suporte do círculo será igual ao programado. Entretanto, a ferramenta não terá uma direção constante relacionada ao plano circular como numa interpolação circular normal. Se o trajeto circular passa por uma singularidade, a orientação nas posições programadas deve ser modificada para permitir grandes movimentos do punho. Isto ocorre se uma reconfiguração completa do punho é gerada quando o círculo é executado (eixos 4 e 6 movem 180 graus cada).

2.3 Interpolação de trajetos circulares

O ponto destino é definido como uma ponto de parada para conseguir movimentos ponto a ponto. Isto significa que o robô e qualquer eixo externo irão parar e que não será possível continuar o posicionamento até que a velocidade de todos os eixos seja zero e os eixos estejam perto dos seus destinos.

Pontos de passagem são usados para obter movimentos contínuos após as posições programadas. Assim, as posições podem ser passadas em alta velocidade sem a reduçãi desnecessária da velocidade. Um ponto de passagem gera um trajeto circular (trajeto

Ponto inicial

Ponto circular

Ponto destino



parabólico) passando pelo ponto programado. Isto significa que a posição programada nunca será alcançada. O início e fim deste trajeto circular serão definidos pela zona ao redor da posição programada (veja Figura 17).

Figura 17 O ponto de passagem gera um trajeto circular para passar pela posição programada.

Todos os eixos são coordenados para obter um trajeto que independa da velocidade . A aceleração é automaticamente otimizada.

2.3.1 Interpolação de eixos nos trajetos circulares

O tamanho do trajeto circular (zonas) para movimentos do TCP é expresso em mm (veja Figura 18). Desde que a interpolação é executada eixo a eixo, o tamanho das zonas (em mm) deve ser recalculado em ângulos do eixo (radianos). Este cálculo tem um fator de erro (normalmente máx. 10%), o que significa que a zona verdadeira deve desviar da qual foi programada.

Se programar velocidades diferentes antes ou depois da posição, a transição de uma velocidade para outra acontece suavemente no trajeto circular sem afetar o trajeto.

Figura 18 Na interpolação de eixo, o trajeto circular é gerado para passar por um ponto de passagem.

A zona do trajeto

Trajeto circular

Posição programada

do TCP

Ponto inicial

ZonaPonto de passagemprogramado

Trajeto circular



2.3.2 Interpolação retangular de uma posição em trajetos circulares

O tamanho dos trajetos circulares (zonas) para o movimento do TCP é expresso em mm (veja Figura 19).

Figura 19 Durante interpolação retangular, um trajeto circular é gerado para passar um ponto de passagem.

Se velocidades diferentes foram programadas antes ou depois da posição circular, a transição será suave e acontecerá no trajeto circular sem afetar o trajeto atual

Se a ferramenta executar um processo (como solda a arco, cola ou corte com água) ao longo de um trajeto, o tamanho da zona pode ser ajustado para conseguir o trajeto desejado. Se a superfície da parábola do trajeto circular não for igual ao objeto geometricamente, as posições programadas podem ser marcadas próximas uma das outras, tornando possível a aproximação do trajeto desejado usando dois ou mais pequenos trajetos parabólicos.

2.3.3 Interpolação retangular da orientação de trajetos circulares

Zonas podem ser definidas para a orientação da ferramenta, como zonas podem ser definidas para posições da ferramenta. A zona de orientação é usualmente setada maior que a zona da posição. Neste caso, a reorientação iniciará a interpolação em direção à orientação da próxima posição antes de iniciar o trajeto circular. A reorientação então será mais suave e provavelmente não será necessário reduzir a velocidade para executar a reorientação.

A ferramenta será reorientada para que a reorientação no final da zona seja igual à definida pela programação do ponto de parada (veja a Figura 20a-c).

Figura 20a Três posições com diferentes orientações estão programadas acima.

Ponto destino

Ponto inicial

ZonaPosição circularprogramada

Trajeto circular



Figura 20b Se todas posições forem pontos de paradas, a execução do programa será como esta.

Figura 20c Se a posição do meio for um ponto de passagem, a execução do programa será como esta.

A zona da orientação para o movimento da ferramenta é normalmente expresso em mm. Desta forma, você pode determinar diretamente onde no trajeto a zona da orientação começa e termina. Se a ferramenta não se move, o tamanho da zona é expresso em ângulos da rotação em graus ao invés do TCP em mm.

Se diferentes velocidades de reorientação são programadas antes e depois do ponto de passagem, e se as velocidades de reorientação limitam o movimento, a transição de uma velocidade para outra acontecerá suavemente no trajeto circular.

2.3.4 Interpolação de eixos externos em trajetos circulares

Zonas podem também ser definidas para eixos externos, da mesma forma que para a orientação. Se a zona do eixo externo é setada para ser maior que a zona do TCP, a interpolação dos eixos externos em direção ao destino da próxima posição será iniciado antes de iniciar o trajeto circular do TCP. Isto pode ser usado para suavizar movimentos de eixos externos da mesma forma que a zona da orientação é usada para suavizar movimentos do punho.

2.3.5 Trajetos circulares quando alteramos o método de interpolação

Trajetos circulares também são gerados quando um método de interpolação é mudado para outro. O método de interpolação usado nos trajetos circulares atuais é escolhido como uma forma de fazer a transição de um método para outro o mais suave possível. Se as zonas do trajeto circular da orientação e posição não são as mesmas, mais que um método de interpolação pode ser usado no trajeto circular (veja Figura 21).

Tamanho da zona de operação



Figura 21 Interpolação quando mudamos de um método de interpolação para outro. Interpolação retangular foi programada entre p1 e p2; interpolação de eixo entre p2 e p3; e interpolação Sing Area\Wrist entre p3 e p4.

Se a interpolação é alterada de um movimento de TCP normal para uma reorientação sem um movimento de TCP ou vice-versa, nenhuma zona circular será gerada. O mesmo acontece se a interpolação é alterada para, ou de um movimento de eixos externos sem movimento do TCP.

2.3.6 Interpolação quando alteramos o sistema de coordenadas

Quando existe uma alteração do sistema de coordenadas em um trajeto circular, por exemplo, um novo TCP ou um novo objeto de trabalho, a interpolação de eixo do trajeto circular é usada. Isto também é aplicável quando alteramos de uma operação coordenada para uma operação não coordenada, ou vice-versa.

2.3.7 Programming of more than one point in the same position

A programação de mais de um ponto na mesma posição provocará uma redução desnecessária de velocidade ou atrasos durante a execução do programa, e poderá também, provocar a parada do programa quando da mudança do sistema de coordenadas em um trajeto de canto.

2.3.8 Trajetos circulares com sobreposição de zonas

Se posições programadas são localizadas perto uma das outras, é normal ocorrer zonas programadas sobrepostas. Para conseguir um trajeto bem definido e conseguir otimizar a velocidade todo o tempo, o robô reduz o tamanho da zona para metade da distância de uma posição programada de sobreposição para outra (veja Figura 22). O mesmo raio da zona é sempre usado para entradas e saídas de uma posição do programa, para obter trajetos circulares simétricos.

p1

p2 p3

p4InterpolaçãoSingArea\Wrist

InterpolaçãoSingArea\Wrist

Interpolaçãoretangular

Interpolação de eixo

Zona da posição Zona da orientação



Figura 22 Interpolação com sobreposição de zonas de posição. As zonas ao redor de p2 e p3 são maiores que metade da distância entre p2 e p3. Então, o robô reduz o tamanho das zonas para torná-las iguais a metade da distância entre p2 e p3, gerando trajetos circulares simétricos com as zonas.

As zonas de posição ou orientação de trajetos circulares podem se sobrepor. Assim que uma destas zonas do trajeto circular se sobrepõem, esta zona é reduzida (veja Figura 23).

Figura 23 Interpolação com sobreposição de zonas de orientação. A zona de orientação de p2 é maior que metade da distância entre p2 e p3 e esta é reduzida para metade da distância entre p2 e p3. As zonas de posição não se sobrepõem e consequentemente não são reduzidas; a zona de orientação de p3 também não é reduzida.

p1

p2

p3

p4

Zonas de posição programadas

Zonas circularescalculadas pelo robô

Trajetogerado

p1

p2

p3

p4

Zonas de posição

Trajeto gerado

Zona da orientaçãoprogramada

Zona da orientação gerada

Zona de orientação



2.3.9 Planejando o tempo dos pontos de passagem

Ocasionalmente, se o próximo movimento não é marcado em tempo, pontos de passagens programados podem ser alcançados como um ponto de parada. Isto talvez aconteça quando:

- Um número de instruções lógicas com tempo de execução muito longo são executadas entre dois movimentos curtos.

- Os pontos estão muito próximos com alta velocidade.

Se os pontos de destino são um problema, use o programa de execução concomitante.

2.4 Eixos independentes

Um eixo independente é um eixo que se move independentemente dos outros eixos no sistema do robô. É possível mudar um eixo para o modo independente e mais tarde tornar a mudá-lo para o modo normal.

Um conjunto especial de instruções manuseia os eixos independentes. Quatro instruções de movimento diferentes especificam o movimento do eixo. Por exemplo, a instrução IndCMove inicia o movimento contínuo do eixo. O eixo continua a movimentar-se a uma velocidade constante (independentemente do que o robô está fazendo) até ser executada uma nova instrução independente.

Para mudar novamente uma instrução de reajuste para o modo normal é usado IndReset. A instrução de reajuste pode também ajustar uma referência nova para o sistema de medição - um tipo de nova sincronização do eixo. Uma vez o eixo alterado para o modo normal é possível executá-lo como um eixo normal.

2.4.1 Execução do programa

Um eixo é automaticamente mudado para o modo independente quando uma instrução Ind_Move é executada. Isto ocorre mesmo se o eixo estiver a ser movido nesse momento, tal como quando um ponto precedente tiver sido programado como um ponto de passagem, ou quando a execução simultânea do programa é usada.

Se uma nova instrução Ind_Move for executada antes da instrução anterior terminar, a nova instrução substitui imediatamente a anterior.

Se uma execução de programa for interrompida quando o eixo independente está em movimento, esse eixo parará. Quando o programa é reinicializado o eixo independente arranca automaticamente. Não existe coordenação ativa entre os eixos independentes e os outros eixos quando estes se encontram no modo normal.

Caso ocorra uma falha de voltagem quando um eixo se encontra no modo independente, o programa não pode ser reinicializado. Neste caso, aparece uma mensagem de erro e o programa tem de ser inicializado a partir do início.

Note que uma unidade mecânica pode não ser desativada quando um dos seus eixos se encontra no modo independente.



2.4.2 Execução faseada

Durante a execução por fases um eixo independente é executado apenas quando outra instrução está sendo executada. O movimento do eixo será também faseado em linha com a execução de outros instrumentos, veja a Figura 24.

Figura 24 Execução faseada de eixos independentes.

2.4.3 Movimentando

Um eixo no modo independente não ser movimentado. No caso de ser feita uma tentativa para executar manualmente o eixo, o eixo não se movimenta e aparece uma mensagem de erro. Execute uma instrução IndReset ou mova o ponteiro do programa para main, de forma a abandonar o modo independente.

2.4.4 Gama de trabalho

A gama de trabalho física é o movimento total dos eixos.

A gama de trabalho lógica é a gama usada pelas instruções RAPID e lida na janela de movimentação.

Após a sincronização (contador de voltas atualizado) a gama de trabalho física e lógica coincide. Usando a instrução IndReset a área de trabalho lógica pode ser movimentada, veja a Figura 25.

IndAMove WaitTime 10

10 s

MoveL MoveL

Eixo independente atinge a posição final

Velocidade do eixo independente

Velocidade do eixo normal



Figura 25 A gama de trabalho lógica pode ser movimentada, usando a instrução IndReset.

A resolução de posições é reduzida quando se afasta da posição lógica 0.

Baixa resolução junto com o controlador de regulação firme pode dar origem a um torque inaceitável, ruído e instabilidade do controlador. Verifique o controlador de regulação e a performance do eixo relativamente ao limite da gama de trabalho na instalação. Verifique também se a resolução da posição e a performance do trajeto são aceitáveis.

2.4.5 Velocidade e aceleração

No modo manual com uma velocidade reduzida, a velocidade é reduzida para o mesmo nível como se o eixo estivesse a rodar como não independente. Note que a função IndSpeed\InSpeed não será TRUE se a velocidade do eixo for reduzida.

A instrução VelSet e a velocidade de correção em percentagem via janela de produção estão ativas para o movimento independente. Note que a correção via janela de produção inibe o valor TRUE a função IndSpeed\InSpeed.

No modo independente o valor de aceleração e desaceleração mais baixo, especificado no arquivo de configuração, é usado tanto para aceleração como para desaceleração. Este valor pode ser reduzido pelo valor ramp na instrução (1 - 100%). A instrução AccSet não afeta o eixo no modo independente.

2.4.6 Eixos do robô

Apenas o eixo 6 do robô pode ser usado como um eixo independente. Em geral, apenas a instrução IndReset é usada para este eixo. Contudo, a instrução IndReset também pode ser usada para o eixo 4 nos modelos IRB 2400 e 4400. Se IndReset for usado para o eixo 4 do robô, então o eixo 6 não deverá estar no modo independente.

Gama de trabalho lógica após sincronização

Gama de trabalho lógica após IndReset

Gama de trabalho física

0

0

0

Gama de trabalho lógica no modo independente



Se o eixo 6 for usado como um eixo independente podem surgir problemas de singularidade, pois a função normal de transformação da coordenada do eixo 6 está a ser usada. Se houver algum problema, execute este programa com o eixo 6 no modo normal. Modifique os pontos ou use as instruções a função SingArea\Wrist ou MoveJ.

O eixo 6 fica internamente ativo no cálculo da performance do trajeto. Porém, o movimento interno do eixo 6 pode reduzir a velocidade dos outros eixos no sistema.

A gama de trabalho independente para o eixo 6 é definida com os eixos 4 e 5 na posição home. Se os eixos 4 ou 5 estiverem fora da posição home a gama de trabalho para o eixo 6 movimenta-se através do acoplamento da engrenagem. No entanto, a posição lida a partir da unidade de programação para o eixo 6 é compensada com as posições dos eixos 4 e 5 através do acoplamento da engrenagem.

2.5 Soft Servo

Em algumas aplicações existe a necessidade de um servo, o qual atua como uma mola mecânica. Isto significa que a força do robô no objeto de trabalho crescerá como uma função da distância entre a posição programada (atrás do objeto de trabalho) e a posição de contato (ferramenta do robô - objeto de trabalho).

O relacionamento entre o desvio da posição e a força, é definido por um parâmetro chamado softness. Quanto maior o parâmetro de softness, maior o desvio de posição requerido para obter a mesma força.

O parâmetro softness é setado no programa e é possível alterar o seu valor em qualquer parte do programa. Diferentes valores de softness podem ser setados para diferentes eixos e também é possível misturar eixos de servo normal com eixos de soft servo.

A ativação e desativação do soft servo e como mudar os valores de softness podem ser feitos quando o robô está em movimento. Quando isto ocorre, uma afinação será feita entre modos de servo diferentes e entre valores de softness diferentes para conseguir transições suaves. O tempo de afinação pode ser setado do programa com o parâmetro ramp. Com ramp = 1, a transição será de 0.5 segundos, e no caso geral o tempo de transição será ramp x 0.5 em segundos.

Note que a desativação do soft servo deve ser feita quando existe uma força entre o robô e o objeto de trabalho.

Com valores de softness alto existe um risco que os desvios da posição de servo podem ser tão grandes que os eixos irão se mover fora da área de trabalho do robô.



2.6 Parada e reinicialização

Um movimento pode ser parado de três maneiras diferentes:

1. Por uma parada normal o robô irá parar no trajeto, o qual torna o reinício fácil.

2. Por uma parada stiff o robô irá parar em um tempo menor que o de parada normal, mas o trajeto de desaceleração não seguirá o trajeto programado. Este método de parada é, por exemplo, usado para paradas de busca quando é importante parar o movimento assim que possível.

3. Por uma parada rápida os freios mecânicos são usados para conseguir uma distância de desaceleração, a qual é tão menor quanto especificada por razões de segurança. O desvio de trajeto será usualmente maior para uma parada rápida que para uma parada stiff.

Depois de uma parada (qualquer dos tipos acima) um reinício pode ser executado em um trajeto interrompido. Se o robô parou fora do trajeto programado, o reinício começará com o retorno para a posição no trajeto, onde o robô devia ter parado.

Um reinício seguindo uma falha de energia é equivalente a reinicializar depois de uma parada rápida. Deve ser notado que o robô irá sempre retornar para o trajeto antes da operação do programa interrompido ser reinicializado, em casos quando a falha de energia ocorreu enquanto uma instrução lógica era executada. Quando reinicializamos, todos os tempos são contados do início; por exemplo, posicionando no tempo ou uma interrupção na instrução WaitTime.


Descrito em:

Definição de velocidade Tipos de dados - speeddata

Definição de zonas (trajetos circulares) Tipos de dados - zonedata

Instrução para interpolação de eixos Instruções - MoveJ

Instrução para interpolação retangular Instruções - MoveL

Instrução para interpolação circular Instruções - MoveC

Instrução para interpolação modificada Instruções - SingArea

Singularidade Movimento e Princípios de E/S-Singularidade

Execução do programa concomitante Movimento e princípios de E/S-Sincronização Usando Instruções-Lógicas

Otimização do CPU Guia do Usuário - Parâmetros do-sistema


Movimento e Princípios de E/S Sincronização com instruções lógicas

3 Sincronização com instruções lógicas

Instruções são normalmente executadas sequencialmente no programa. Entretanto, instruções lógicas podem também ser executadas em posições específicas ou durante um movimento.

Uma instrução lógica é qualquer instrução que não gere um movimento do robô ou de eixos externos, por exemplo, uma instrução de E/S.

3.1 Execução sequencial do programa em pontos de parada

Se uma instrução de posicionamento pode ser programada como um ponto de parada, a instrução subseqüente não é executada até que o robô e eixos externos venham a parar, isto é, quando a posição programada for atingida (veja Figura 26).

Figura 26 Uma instrução lógica depois de um ponto de parada não é executada até que o ponto destino tenha sido alcançado.

3.2 Execução sequencial do programa em pontos de passagem

Se uma instrução de posicionamento for programada como um ponto de passagem, as instruções lógicas subsequentes são executadas algum tempo antes de atingir a maior zona (para posição, orientação ou eixos externos). Veja Figura 26. Estas instruções são então executadas em ordem.

Figura 27 Uma instrução lógica seguindo um ponto de passagem é executada antes de atingir a zona.

p1

Execução do SetDOMoveL p1, v1000, fine, tool1;SetDO do1, on;

MoveL p2, v1000, z30, tool1;

Execução do SetDO

DT

Zona de orientação

Zona da posição

p1


SetDO do1, on;



Sincronização com instruções lógicas Movimento e Princípios de E/S

O tempo no qual elas são executadas (DT) compreendem as seguintes componentes de tempo:

- O tempo gasto pelo robô para planejar o próximo movimento: aprox. 0.1 segundos.

- O atraso do robô (servo lag) em segundos: 0 - 0.5 segundos dependendo da velocidade.

3.3 Execução simultânea do programa

Execução simultânea do programa pode ser programada usando o argumento \Conc na instrução de posicionamento. Este argumento é usado para:

- Executar uma ou mais instruções lógicas ao mesmo tempo em que o robô se move para reduzir o tempo de ciclo (por exemplo, usado em canais de comunicação serial).

Quando uma instrução de posicionamento com o argumento \Conc é executada, as seguintes instruções lógicas são executadas (na seqüência):

- Se o robô não está em movimento, ou se a instrução de posicionamento anterior terminou com um ponto de parada, as instruções lógicas são executadas logo que a instrução de posicionamento atual inicie (ao mesmo tempo com o movimento). Veja Figura 26.

- Se a instrução de posicionamento anterior termina em um ponto de passagem, as instruções lógicas são executadas em um tempo dado (DT) antes de atingir a zona maior (para posição, orientação ou eixos externos). Veja Figura 26.

Figura 28 No caso de execução simultânea do programa depois de um ponto de parada, uma instrução de posicionamento e instrução lógica subsequente são iniciadas ao mesmo tempo.

Execução do SetDO

p1

p2

MoveL p1, v1000, fine, tool1;

SetDO do1, on;MoveL p3, v1000, z30, tool1;

MoveL \Conc, p2, v1000, z30, tool1;



Figura 29 No caso de execução de programa simultâneo depois de um ponto de passagem, a instrução lógica inicia a execução antes das instruções de posicionamento com o argumento \Conc serem iniciadas.

As instruções que indiretamente afetam movimentos, como ConfL e SingArea, são executadas da mesma maneira que outras instruções lógicas. Elas, entretanto, não afetam movimentos anteriores às instruções de posicionamento.

Se várias instruções de posicionamento com o argumento \Conc e várias instruções lógicas em uma longa seqüência são misturadas, o seguinte se aplica:

- Instruções de posicionamento são executadas depois da instrução anterior de posicionamento ter sido executada.

- Instruções lógicas são executadas diretamente, da forma que foram programadas. Elas tomam lugar ao mesmo tempo que o movimento (veja Figura 26) significando que instruções lógicas são executadas um estágio anterior no trajeto que elas foram programadas.

- Movimentos não podem ser reinicializados depois de um programa ser interrompido, se duas ou mais instruções na sequência estão aguardando para ser executadas.

DT

Execução do SetDO

Zona maior

p1p2


SetDO do1, on;MoveL p3, v1000, z30, tool1;




Figura 30 Se várias instruções de posicionamento com o argumento \Conc são programadas na sequência, todas as instruções lógicas conectadas são executadas ao mesmo tempo como a primeira instrução executada.

Durante a execução simultânea de programa, as seguintes instruções são programadas para terminar a sequência e subsequentemente resincronizar instruções de posicionamento e instruções lógicas:

- uma instrução de posicionamento sem o argumento \Conc,

- a instrução WaitTime ou WaitUntil com o argumento \Inpos.

3.4 Sincronização do trajeto

Para sincronizar equipamento de processo (aplicações como cola, pintura e solda a arco) com os movimentos do robô, diferentes tipos de sinais de sincronização de trajeto podem ser gerados.

Com um chamado de evento de posições, um sinal de disparo será gerado quando o robô passar por uma posição pré-definida no trajeto. Com um evento de tempo, um sinal será gerado em um tempo pré-definido antes do robô parar na posição de parada. Adicionalmente, o sistema de controle também trata de eventos de ondulação, os quais geram pulsos em ângulos de fase pré-definidos de um movimento de onda.

Todos os sinais de posição sincronizados podem ser atingidos ambos antes (look ahead time) e depois (delay time) do tempo que o robô passa pela posição pré-definida. A posição é dada por uma posição programada e pode ser afinada como uma distância de trajeto antes da posição programada.

DT

Execução de

SetDO e SetAOZona maior

p1p2


SetDO do1, on;MoveL \Conc, p3, v1000, z30, tool1;


SetAO ao2, 5;



A precisão é de ±2 ms. Na parte do trajeto antes da posição final (máx. 12 mm a 500 mm/s), o sinal pode entretanto ser atrasado em 24 ms.

Se uma falha de energia ocorrer quando executando uma instrução de Trigg, a condição de “trigg” é ativada pelo novo ponto de início. Isto significa que o sinal será setado incorretamente se o argumento \Start for usado. Se a condição de “trigg” ocorreu antes da falha de energia, então o evento de “trigg” será ativado novamente.


Descrito em:

Instruções de posicionamento Sumário RAPID - Movimento

Definição do tamanho da zona Tipos de dados - zonedata




Movimento e Princípios de E/S Configuração do Robô

4 Configuração do Robô

Normalmente é possível atingir a mesma posição de ferramenta do robô e orientação de diferentes maneiras, usando diferentes ângulos de eixos. Nós chamamos estas diferenças de configurações do robô. Se, por exemplo, uma posição está localizada aproximadamente no meio da área de trabalho, alguns robôs podem conseguir esta posição por cima ou por baixo (veja Figura 31). Isto também pode ser conseguido pela rotação da parte frontal do braço superior do robô (eixo 4) de cima para baixo enquanto rotacionamos os eixos 5 e 6 para uma posição e orientação desejada (veja Figura 32).

Figura 31 Duas configurações de braço diferentes usadas para atingir a mesma posição e orientação. Em uma das configurações, o braço aponta para cima e para atingir a outra configuração, o eixo 1 deve ser rotacionado 180 graus.


Configuração do Robô Movimento e Princípios de E/S

Figura 32 Duas diferentes configurações de punho usado para atingir a mesma posição e orientação. A configuração na qual a parte da frente do braço superior aponta para cima (mais abaixo), eixo 4 rotacionou 180 graus, eixo 5 girou 180 graus e eixo 6 girou 180 graus para atingir a configuração na qual a parte da frente do braço superior aponte para baixo (mais acima).

Usualmente você quer que o robô alcance a mesma configuração durante a execução do programa como a que você programou. Para fazer isto, você pode fazer o robô verificar a configuração e, se a configuração correta não foi conseguida, a execução do programa irá parar. Se a configuração não for verificada, o robô talvez comece inesperadamente a mover seus braços e seu punho o qual, na volta, talvez cause uma colisão com equipamentos periféricos.

A configuração do robô é especificada definindo apropriadas revoluções do quadrante dos eixos 1, 4 e 6. Se o robô e a posição programada tem a mesma revolução de quadrante para estes eixos, a configuração do robô está correta.

Figura 33 Um quarto de volta para um ângulo de eixo positivo: .

eixo 6

eixo 5

eixo 4

1

2 3

0

int jointangleπ 2⁄

--------------–



Figura 34 Revolução de quadrante de um ângulo de eixo negativo: .

Para um eixo de robô linear, o valor define um intervalo métrico para o eixo do robô, O valor 0 significa uma posição entre 0 e 1 metro, 1 significa uma posição entre 1 e 2 metros. Para valores negativos, -1 significa uma posição entre -1 e 0 metros, etc.

Figura 35 Valores de configuração para um eixo linear

O conjunto de dados de configuração consiste nos quatro componentes cf1, cf4, cf6, cfx. cf1 especifica o valor do eixo 1, cf4 para o eixo 4, cf6 para o eixo 6. cfx é um componente adicional usado para tipos de robô com estruturas que precisam de um componente extra.

A verificação da configuração envolve a comparação da configuração da posição programada com a configuração do robô. A configuração de um eixo específico é aceita quando o valor de eixo obtido está dentro de +/- 45 graus a partir do quadrante especificado para uma junção rotacional ou dentro de +/- 0,5 m a partir do valor em metros epseicicado de um eixo linear.

-3

-2 -1

-4

int jointangleπ 2⁄

--------------– 1–

0 1 2 3-1-2-3

Valor de configuração210-1-2-3

x (m)



Figura 36 Examplo: Valor de eixo aceito de 135graus < junção 4 <-45 graus para eixo rotacional 4 quando cf4 = 0

Figura 37 Examplo: Valor de eixo aceito -1,5 m < junção 1 < 0,5 m para eixo linear 1 quando cf1 = -1

Durante o movimento retangular, o robô sempre se move o mais próximo possível desta configuração. Se, entretanto, a verificação da configuração está ativa, a execução do programa pára assim que:

- A configuração da posição programada não for obtida.

- A reorientação necessária de qualquer dos eixos de punho para chegar à posição programada exceder um limite (140 a 180 graus).

Durante movimento eixo-a-eixo ou retangular modificado usando uma verificação de configuração, o robô sempre se move para a configuração de eixos programada. Se a posição programada e orientação não são alcançadas, a execução do programa pára antes de iniciar o movimento. Se a configuração não é ativada, o robô move-se para a posição especificada e orientação com a configuração mais próxima.

Quando a execução de uma posição programada é interrompida por causa de um erro de configuração, muitas vezes isso pode ser causado por uma ou mais das seguintes razões:

• A posição é programada off-line com uma configuração errada.

• A ferramenta do robô foi alterada causando obrigando o robô a ter uma configuração diferente daquela que foi programada.

• A posição é sujeita a uma operação de estrutura ativa (deslocação, usuário, objeto, base).

cf4 = 0

0 1 2 3-1-2-3

Valor de configuração-1

x (m)



A configuração correta na posição destino pode ser encontrada pelo posicionamento do robô próximo a ela e lendo a configuração na unidade de programação.

Se os parâmetros de configuração mudam por causa da base de operação ativa, a verificação da configuração pode ser desativada.

4.1 Dados de configuração do robô para 6400C

O IRB 6400C é ligeiramente diferente na sua forma inequívoca de indicar uma configuração de robô. A diferença está na interpretação do confdata cf1.

cf1 é usado para selecionar uma das duas configurações principais possíveis de eixos (eixo 1, 2 e 3):

- cf1 = 0 é a configuração para a frente

- cf1 = 1 é a configuração para trás.

A Figura 38 mostra um exemplo de uma configuração para a frente e de uma configuração para trás dando a mesma posição e orientação.

Figura 38 A mesma posição e orientação com as duas configurações principais diferentes de eixos.

A configuração para a frente é a parte frontal do espaço de trabalho do robô com o braço direcionado para a frente. A configuração para trás é a parte de serviço do espaço de trabalho com o braço direcionado para trás.

PARA TRÁS,cf1 = 1.

PARA A FRENTE,cf1 = 0




Descrito em:

Definição de configuração do robô Tipos de dados - confdata

Ativando/desativando a verificação Sumário RAPID - Setando Movimentoda configuração


Movimento e Princípios de E/S Modelos cinemáticos de robôs

5 Modelos cinemáticos de robôs

5.1 Cinemática do robô

A posição e orientação de um robô é determinada a partir de um modelo cinemático de sua estrutura mecânica. Cada instalação exige os seus modelos específicos de unidade mecânica definidos. Para robôs mestres e externos ABB padrão, estes modelos estão predefinidos no controlador.

5.1.1 Robô mestre

O modelo cinemático dos robôs mestre modela a posição e a orientação da ferramenta do robô em relação à sua base como função dos ângulos de junção do robô.

Os parâmetros cinemáticos especificando o comprimento dos braços, desvios e modos dos eixos, estão predefinidos no arquivo de configuração para cada tipo de robô.

Figura 39 Estrutura cinemática de um robô IRB1400

Um procedimento de calibragem suporta a definição da estrutura de base do robô mestre em relação à estrutura global.

eixo 1

eixo 2

eixo 3

eixo 5

altura_do_pé

desvio_do_eixo_2

comprimento_braço_inferior

desvio_do_eixo_3

comprimento_do_braço_superior

eixo 4 eixo 6

X

Z

Z6

X6

comprimento_do_punho


Modelos cinemáticos de robôs Movimento e Princípios de E/S

Figura 40 Estrutura de base do robô mestre

5.1.2 Robô externo

A coordenação para um robô externo exige também um modelo cinemático para este mesmo robô. É suportado um número de classes predefinidas de estruturas mecânicas de 2 a 3 dimensões.

Figura 41 Estrutura cinemática de um robô ORBIT 160B usando modelo predefinido

Os procedimentos de calibragem que definem a estrutura de base em relação à estrutura global são fornecidos para cada classe de estruturas.

Z

X

Y

Estrutura base do robô mestre

Estrutura global

Z6

X6

altura_do_pé

X0

Z0

desvio_do_eixo 1_x

comprimento_do_braço_inferior

desvio_do_braço_superior

mesa_giratória

modo_do_eixo 1

modo_do_eixo

X2

Z2

eixo 1

eixo 2



Figura 42 Estrutura de base para um robô ORBIT_160B

Figura 43 Pontos de referência em uma mesa giratória para calibragem da estrutura de base de um robô ORBIT_160B, na posição recolhido, usando um modelo predefinido

5.2 Cinemática geral

As estruturas mecânicas não suportadas por estruturas predefinidas poderão ser modeladas usando um modelo cinemático geral. Isto será possível para robôs externos.

A modelagem está baseada na convenção Denavit-Hartenberg conforme Introduction to Robotics, Mechanics & Control, John J. Craigh (Addison-Wesley 1986)

Corpo A

Corpo B

X2

Z2

Corpo C

X0

Z0

Estrutura global

Estrutura de base do robô externo

X0

Y0

Y2

x1 x2

y1

X2



Figura 44 Estrutura cinemática de um robô ORBIT 160B usando um modelo cinemátio geral

Um procedimento de calibragem suporta a definição da estrutura de base do robô externo em relação à estrutura global.

Figura 45 Estrutura de base de um robô ORBIT_160B usando um modelo cinemático geral

mesa_giratória

Z2

X0

Z0

d2

alfa2

Y2

d1

a1 = 0a2 = 0alfa1 = 0

Z2

Estrutura global

X0

Z0

Estrutura de base de robô externo

Y2



Figura 46 Pontos de referência na mesa giratória para calibragem da estrutura de base de um robô ORBIT_160B na posição de recolhido (eixos = 0 graus)

5.3 Informações relacionadas

Descrita em:

Definição da cinemática geral Guia do Usuário- Parâmetros dede um robô externo Sistema

X0

Y0

x1

x2 Y2

X2

y1




Movimento e Princípios de E/S Supervisão Movimento/Detecção colisão

6 Supervisão Movimento/Detecção colisão

A supervisão do movimento é o nome de um conjumto de funções de alta sensibili-dade, baseadas no modelo de supervisão dos movimentos do robô. A supervisão do movimento inclui funções para detecção de colisão, obstrução e definição de carga incorreta. Esta função é chamada de Detecção de Colisão.

6.1 Introdução

A detecção de colisão atuará se a carga for definida incorretamente. Se a carga não for conhecida, a função de identificação de carga poderá ser usada para defini-la.

Quando a detecção de colisão for atuada, o torque do motor será invertido e os freios mecânicos aplicados, para parar o robô. O robô então recuará uma pequena distância, dentro do trajeto, para remover qualquer força residual que possa estar presente, caso tenha ocorrido uma colisão ou obstrução. Após isto, o robô pára novamente permane-cendo no estado de motores ligados. Uma colisão típica é mostrada na figura abaixo.

A supervisão de movimento só é ativa quando, no mínimo, um eixo (incl. eixos exter-nos) estiver em movimento. Se todos os eixos estiverem em repouso, a função é desa-tivada. Isto para evitar atuação desnecessária no caso de forças de processo externas.

6.2 Ajuste dos níveis de Detecção de Colisão

A detecção de colisão usa um nível de supervisão variável. Em baixas velocidades é mais sensível do que em altas velocidades. Por esta razão, não deverá ser exigido, pelo usuário, nenhum ajuste durante as condições de operação normais. No entanto, é possível ligar e desligar a função e ajustar os níveis de supervisão. Estão dis-poníveis parâmetros de ajuste em separado para deslocamento lento (jog) e execução do programa. Os diferentes parâmetros de ajuste estão descritos com maiores detal-hes no Guia do Usuário no capítulo Parâmetros do Sistema: Manipulador (Robô).

Existe uma instrução RAPID chamada MotionSup a qual liga e desliga a função, e modifica o nível de supervisão. Isto é usual em aplicações onde forças de processo externas atuam no robô em certas partes do ciclo. A instrução MotionSup está descrita com maiores detalhes no Manual de Referência RAPID.

6.3 Caixa de diálogo da supervisão de movimento

Selecionar a supervisão de movim. no menu especial na janela de deslocamento lento (jog). Esta mostra uma caixa de diálogo a qual permite à supervisão de movimento ser lig. e desl. Isto só afetará o robô quando em jog. Se a supervisão de movimento for desligada na caixa de diálogo, e o programa for executado, a deteção de colisão poderá ainda estar ativa durante o funcionamento do programa. Se o programa for então parado e o robô colocado em jog, a bandeira de estado na caixa de diálogo surge outra vez. É uma medida de segurança para evitar desligamento acidental.


Supervisão Movimento/Detecção colisãoMovimento e Princípios de E/S

colisãodetetada

instante dacolisão

robôparado remoção das

forças residuais

veloc.motor

torque motor

tempo

tempo

torqueinvertido

rotaçãoinvertida

Figura: Colisão típica

Fase 1 - O torque do motor éinvertido para parar o motor.

Fase 2 - A rotação do motor é invertida para remover as forçasresiduais na ferramenta e no robot.


Movimento e Princípios de E/S Supervisão Movimento/Detecção colisão

6.4 Saídas digitais

A saída digital MotSupOn é alta quando a função de detecção de colisão estiver ativa e baixa quando não estiver ativa. Observar que uma mudança no estado da função vigora no início do movimento. Assim, se a detecção estiver ativa e o robô estiver em movimento, a MotSupOn será alta. Se o robô estiver parado e a função desligada, ainda assim a MotSupOn será alta. Quando o robô iniciar o movimento, a MotSupOn comuta para baixa.

A saída digital MotSupTrigg fica alta quando a detecção de colisão dispara. A saída permanecerá alta até o codigo de erro ser validado, ou a partir da unidade de pro-gramação, ou através da entrada digital AckErrDialog.

As saídas digitais estão descritas com maiores detalhes no Guia do Usuário no capí-tulo Parâmetros do Sistema: Sinais E/S.

6.5 Limitações

A supervisão de movimento só está disponível para os eixos do robô. Não está disponível para movimentos por esteira (track motions), estações de órbita, ou quaisquer outros manipuladores externos.

No RobotWare 3.1, a supervisão de movimento, só está disponível para a família de robôs IRB6400.

A detecção de colisão será desativada quando pelo menos um eixo estiver funcionando no modo de junta independente. Este caso é o mesmo de um eixo externo que funciona como no modo de junta independente.

A detecção de colisão poderá disparar quando o robô for usado na modo servo soft. Por esta razão, é recomendável desligar a detecção de colisão, quando o robô estiver a ser usado no modo servo soft.

Se a instrução RAPID MotionSup for usada para desligar a detecção de colisão, isto somente vigorará após o robô iniciar o movmento. Como consequência, a saída digital MotSupOn poderá estar temporariamente alta no arranque do programa antes do início do movimento do robô.

A distância de recuo do robô, após uma colisão, é proporcional à velocidade do movimento antes da colisão. Se colisões a baixa velocidade ocorrerem repetidamente, o robô poderá não retornar o suficiente para aliviar o esforço da colisão. Como consequência, poderá não ser possível operar o robô em jog sem disparar a supervisão. Neste caso usar o menu jog para desligar temporariamente a detecção de colisão e afastar lentamente (jog) o robô do obstáculo.

Na hipótese de uma colisão seca durante a execução do programa, poderá levar alguns segundos até o robô começar a recuar.


Supervisão Movimento/Detecção colisãoMovimento e Princípios de E/S


Descritas em:

Instrução RAPID MotionSup Sumário/Resumo RAPID - Motion

Ajuste para parâmetros do sistema Parâmetros do Sistema - Manipulator

Sinais E/S, Supervisão do movimento Parâmetros do Sistema - IO Signals

Identificação de Carga Desloc./Movimento e Principios E/S


Movimento e Princípios de E/S Singularidades

7 Singularidades

Algumas posições no espaço de trabalho do robô podem ser atingidas usando um número infinito de configurações do robô para posição e orientação da ferramenta. Estas posições, conhecidas como pontos singulares (singularidades), constituem um problema quando calculando ângulos do braço do robô baseado na posição e orientação da ferramenta.

Geralmente falando, um robô tem dois tipos de singularidades: singularidades do braço e singularidades do punho. Singularidades de braço são todas configurações onde o centro do punho (a intersecção dos eixos 4, 5 e 6) terminam diretamente acima do eixo 1 (veja Figura 47). Singularidades de punho são configurações onde eixo 4 e eixo 6 estão na mesma linha, isto é, eixo 5 tem um ângulo igual a 0 (veja Figura 48).

Figura 47 Singularidade do braço ocorre quando o punho central e o eixo 1 se interligam.

Figura 48 Singularidade de punho ocorre quando o eixo 5 está em 0 graus.

Xbase

Rotação central do eixo 1

Singularidade na intersecção do centro do punho e eixo 1

Zbase

Eixo 6 paralelo ao eixo 4

Eixo 5 com um ângulo de 0 graus


Singularidades Movimento e Princípios de E/S

Pontos de singularidade/IRB 6400C

Entre o espaço de trabalho do robô com o braço direcionado para a frente e o braço direcionado para trás, existe um ponto de singularidade acima do robô. Existe também um ponto de singularidade nas partes laterais do robô. Estes pontos contêm uma singularidade e possuem limitações cinéticas. Uma posição nestes pontos não pode ser especificada como para a frente/trás, e apenas pode ser atingida com MoveAbsJ. Quando o robô se encontra num ponto singular :

- Apenas é possível usar MoveAbsJ ou movimentar o robô eixo a eixo.

7.1 Execução do programa através de singularidades

Durante a interpolação de eixos, o robô nunca tem nenhum problema passando por pontos singulares.

Quando executando um trajeto retangular ou circular próximo a uma singularidade, as velocidades em alguns eixos (1 e 6/4 e 6) podem ser muito altas. Para não exceder a velocidade máxima do eixo, a velocidade de um trajeto retangular é reduzida.

As altas velocidades de eixo podem ser reduzidas usando o modo (Sing Area\Wrist) quando os eixos do punho são interpolados em ângulos de eixo enquanto mantemos um trajeto retangular da ferramenta do robô. Um erro de orientação comparado a interpolação linear total é entretanto introduzido.

Note que a configuração do robô muda drasticamente quando o robô passa próximo a singularidade com interpolação retangular ou circular. Para permitir a reconfiguração, a primeira posição do outro lado da singularidade deve ser programada com uma orientação que torne a reconfiguração desnecessária.

Também note que o robô não deve estar na sua singularidade quando somente eixos externos são movidos, como este pode causar aos eixos do robô movimentos desnecessários.

7.2 Movimentação através de singularidades

Durante a interpolação de eixo, o robô nunca tem nenhum problema passando por pontos singulares.

Durante interpolação retangular o robô pode passar por pontos singulares mas com a velocidade reduzida.


Movimento e Princípios de E/S Singularidades


Descrito em:

Controlando como o robô atua na Instruções - SingAreaexecução próximo a pontos singulares


Singularidades Movimento e Princípios de E/S


Movimento e Princípios de E/S Zonas Globais

8 Zonas Globais

8.1 Uso das Zonas Globais

Com esta função, o robô pára ou uma saída é automaticamente ajustada quando o robô se encontra dentro de uma área especial definida pelo usuário. A função pode ser usada em várias ocasiões, por exemplo:

- Quando dois robôs têm uma parte das suas áreas de trabalho em comum. Super-visionando estes sinais, os robôs podem garantir que não colidirão um com o outro.

- Quando um equipamento externo está dentro da área de trabalho do robô. Uma área “proibida” pode ser criada para evitar que o robô colida com este equipa-mento.

- Indicação que o robô está em uma posição onde é admissível iniciar a execução do programa a partir de um PLC.

8.2 Uso das Zonas Globais

Para indicar que o ponto central da ferramenta está em uma parte específica da área de trabalho.Para limitar a área de trabalho do robô a fim de evitar colisão com a ferramenta.Para que uma área de trabalho comum para dois robôs, fique disponível para somente um robô de cada vez.

8.3 Definição de Zonas Globais no sistema de coordenadas global

Todas as Zonas Globais têm de ser definidas no sistema de coordenadas global.Os lados das Caixas são paralelos aos eixos das coordenadas e os eixos do Cilindro são paralelos ao eixo Z do sistema de coordenadas global.


Zonas Globais Movimento e Princípios de E/S

Uma Zona Global pode ser definida para ficar dentro ou fora da forma Caixa, Esfera ou Cilindro.

8.4 Supervisão do TCP do Robô

É o movimento do ponto central da ferramenta que é supervisionado e nenhum outro ponto do robô.

O TCP é sempre supervisionado independente do modo de operação, por exemplo, execução do programa e movimento.

8.4.1 TCP estacionário

Se o robô está segurando um objeto de trabalho e trabalhando em uma ferramenta estacionária, um TCP estacionário é usado. Se essa ferramenta está ativa, a ferramenta não se moverá e se está dentro de uma Zona Global, então está sempre no seu interior.

Sistema de coordenadas de base do robô

x

y

z

Sistema de coordenadas global

Z

X

Y

Altura

Esfera

Raio

Raio

Cilindro

Caixa

TCP

TCP

Não supervisionado



8.5 Ações

8.5.1 Ajustar uma saída digital quando o tcp está dentro de uma Zona Global.

A ação ajusta uma saída digital quando o tcp está dentro de uma Zona Global. É útil indicar que o robô parou em uma área especificada.

8.5.2 Ajustar uma saída digital antes do tcp atingir uma Zona Global.

Esta ação ajusta uma saída digital antes do tcp atingir uma Zona Global. Pode ser usado para parar o robô dentro de uma Zona Global.

8.5.3 Parar o robô antes do tcp atingir uma Zona Global.

Uma Zona Global pode ser definida para ficar fora da área de trabalho. O robô parará então com o Ponto Central da Ferramenta fora da Zona Global quando se dirigir para a Zona.

Se o robô foi movido para uma Zona Global definida como fora da área de trabalho, por exemplo, liberando os freios e empurrando manualmente, então movimentando ou empurrando manualmente com freios liberados são as únicas formas de sair da Zona.

Estado da saída digital

Movimento do TCP

Tempo entre checagemcontra Zonas Globais

Zona Global

Tempo de Parada para o Robô

Estado da saída digital

Zona Global

Movimento do TCP


Tempo de Parada para oRobô

Movimento do TCP



8.6 Tamanho mínimo das Zonas Globais

A supervisão dos pontos centrais da ferramentas é efetuada em pontos discretos com intervalos que dependem da resolução do trajeto.Cabe ao usuário determinar zonas com tamanhos que impeçam o robô de se dirigir diretamente para a zona sem ser checado dentro da Zona.

Se a mesma saída digital é usada para mais de uma Zona Global, a distância entre Zonas tem de exceder o tamanho mínimo, de acordo com a tabela acima, para evitar um estado incorreto para a saída.

Se o tempo dentro da zona é demasiado pequeno, o robô pode passar o canto de uma zona sem o ver. Assim, garanta que a zona é maior do que a área de perigo.

8.7 Número máximo de Zonas Globais

Poderão se definidas, no máximo, dez Zonas Globais ao mesmo tempo.

8.8 Falha de corrente, reiniciar e run on

Zonas Globais Estacionárias serão eliminadas com a falha de corrente e reinseridas com corrente por meio de uma rotina de eventos conectada ao evento POWER ON.

Zonas Globais Temporárias sobreviverão à falha de corrente, mas serão eliminadas quando um novo programa for carregado ou iniciado na unidade principal.

As saídas digitais das Zonas Globais serão atualizadas no modo run on. Assim, se o robô tiver sido movido durante o run off, as saídas serão atualizadas primeiro em run on.

Tamanho mín. da zona

1000 mm/s 2000 mm/s 4000 mm/s

1

2

3

para resolução de tr ajeto e velocidade máx. usadas

25 mm

50 mm

75 mm

50 mm

100 mm

150 mm

100 mm

200 mm

300 mm

resol.

veloc





Manual de Referência RAPID

Movimentação e Princípios de E/S: Sistemas de coordenadas

Tipos de dados: wztemporary

wzstationary

shapedata

Instruções: WZBoxDef

WZSphDef

WZCylDef

WZLimSup

WZDOSet

WZDisable

WZEnable

WZFree

WZTempFree




Movimento e Princípios de E/S Princípios de E/S

9 Princípios de E/S

O robô geralmente tem uma ou mais placas de E/S. Cada uma das placas tem vários canais digitais e/ou analógicos os quais devem ser conectados para sinais lógicos antes deles poderem ser usados. Isto é carregado nos parâmetros do sistema e tem nomes padrões prontos antes do robô ser entregue. Nomes lógicos devem sempre ser usados durante a programação.

Um canal físico pode ser conectado à vários nomes lógicos, mas também pode não ter nenhuma conexão lógica (veja Figura 49).

Figura 49 Para estar apto a usar uma placa de E/S, nomes lógicos devem ser dados a seus canais. No exemplo acima, a saída física 2 está conectada a dois diferentes nomes lógicos. IN16, por outro lado, não tem nenhum nome lógico e então não pode ser usada.

9.1 Características de sinais

As características de um sinal são dependentes do canal físico usado e como o canal está definido nos parâmetros do sistema. O canal físico determina o atraso de tempo e níveis de tensão (veja a Especificação do Produto). As características, tempos de filtro e escalonamento entre valores programados e físicos, são definidos nos parâmetros do sistema.

Quando a fonte de alimentação do robô é ligada, todos os sinais são setados para zero. Eles, entretanto, não afetam paradas de emergência ou eventos similares.

I/O board

IN1IN2

IN16

.

.

.

.

OUT1OUT2

OUT16

.

.

.

.

Canal físico Sinal lógico

do1feeder

gripperdo2

feeder2

do16


Princípios de E/S Movimento e Princípios de E/S

Uma saída pode ser setada para 1 ou 0 pelo programa. Isto também pode ser feito usando um atraso ou na forma de um pulso. Se um pulso ou atraso altera uma saída, a execução do programa continua. A alteração é então carregada sem afetar o resto da execução do programa. Se, por outro lado, uma nova alteração é ordenada para a mesma saída antes do tempo dado ocorrer, a primeira alteração não pode ser carregada (veja Figura 50).

Figura 50 A instrução SetDO não é carregada completamente por causa do novo comando que é dado antes do atraso de tempo ocorrer.

9.2 Sinais conectados à interrupção

As funções de interrupção do RAPID podem ser condicionadas por alterações de sinais digitais. A função pode ser chamada na borda de subida ou de descida do sinal. No entanto, se o sinal digital mudar muito rapidamente, a interrupção poderá ser perdida.

Ex:

Se uma função estiver conectada a um sinal chamado do1 e você criar um progama do tipo:SetDO do1,1;SetDO do1,0;Primeiro, o sinal irá para nível alto e, em seguida, para nível baixo em alguns milissegundos. Nesse caso, você pode perder a interrupção. Para ter certeza de que você receberá a interrupção, certifique-se de que a saída esteja alta antes de redefini-la.

Ex:SetDO do1,1;WaitDO do1 ,1;SetDO do1,0;Dessa forma, você nunca perderá uma interrupção.

SetDO \SDelay:=1, do1;WaitTime 0.5;PulseDO do1;

Valor de sinal

Tempo0 0.5 1

1


Movimento e Princípios de E/S Princípios de E/S

9.3 Sinais do sistema

Sinais lógicos podem ser interconectados pelo significado de funções especiais do sistema. Se, por exemplo, uma entrada é conectada à função do sistema Start, um início de programa é automaticamente gerado logo que esta entrada seja habilitada. Estas funções do sistema são geralmente habilitadas em modo automático. Para maiores informações, veja Capítulo 9, Parâmetros do Sistema, ou o capítulo Instalação e Comissionamento - Comunicação com PLC no Manual do Produto.

9.4 Conexões cruzadas

Os sinais digitais podem ser inter-conectados de forma a serem afetados automaticamente:

- Um sinal de saída pode ser conectado a um ou mais sinais de entrada ou de saída.

- Um sinal de entrada pode ser conectado a um ou mais sinais de entrada ou de saída.

- Se o mesmo sinal for usado em várias conexões cruzadas, o valor desse sinal é o mesmo do valor que foi ativado por último (alterado).

- As conexões cruzadas podem ser inter-ligadas, por outras palavras, uma conexão cruzada pode afetar outra. Não podem, no entanto, estar conectadas de modo a formar um “ciclo viciado”, por exemplo, di1 é uma conexão cruzada a di2, enquanto di2 é uma conexão cruzada a di1.

- Se houver uma conexão cruzada num sinal de entrada, a conexão física correspondente é automaticamente desativada. Quaisquer alterações a este canal físico não será, portanto, detectado.

- Impulsos ou atrasos não são transmitidos a conexões cruzadas.

- Podem ser definidas condições lógicas usando NOT, AND ou OR (Opção: Funções Avançadas)

Exemplos:

- di2=di1

- di3=di2

- do4=di2

Se di1 muda, di2, di3 e do4 serão alterados com o valor correspondente.

- do8=do7

- do8=di5

Se do7 é setado para 1, do8 também será setado para 1. Se di5 é então setado para 0, do8 também será alterado (apesar de do7 continuar em 1).

- do5=di6 and do1

Do5 é ajustado para 1 se di6 e do1 forem ajustados para 1.


Princípios de E/S Movimento e Princípios de E/S

9.5 Limitações

Um máximo de 10 sinais podem ser pulsados ao mesmo tempo e um máximo de 20 sinais podem ser atrasados ao mesmo tempo.


Descrito em:

Definição de placas E/S e sinais Guia do Usuário - Parâmetros

Instruções de tratamento de E/S Sumário RAPID - Sinais de Entrada e Saída

Manuseio do Manual de E/S Guia do Usuário - Entradas e Saídas


Programação off-line


1 Programação off-line

Programas RAPID podem facilmente ser criados, corrigidos e armazenados em um computador comum. Todas as informações podem ser lidas e alteradas diretamente usando um editor de texto comum. Este capítulo explica o procedimento de trabalho de como fazer isso. Além da programação off-line, você também pode usar uma outra ferramenta, o QuickTeach.

1.1 Formatar arquivo

O robô armazena e lê programas RAPID no formato TXT (ASCII) e podem ser tratados tanto por textos formato DOS e UNIX. Se você usar um processador de texto para editar programas, estes devem ser salvos no formato TXT (ASCII) antes de serem usados no robô.

1.2 Editando

Quando um programa é criado ou alterado em um processador de texto, todas as informações serão tratadas na forma de um texto. Isto significa que as informações sobre dados e rotinas serão diferentes do que é apresentado no display da unidade de programação.

Note que o valor de uma posição armazenada é somente mostrado com um * na unidade de programação, onde um arquivo texto irá conter o valor da posição atual (x, y, z, etc.).

Para minimizar o risco de erros na sintaxe (falhas de programa), você deve usar uma máscara. Uma máscara pode ter a forma de um programa que foi criado previamente no robô ou usando o QuickTeach. Estes programas podem ser lidos diretamente com um editor de texto sem precisar ser convertido.

1.3 Verificar a sintaxe

Programas devem estar sintaticamente corretos antes deles serem carregados no robô. Isto significa que os textos devem seguir as regras fundamentais da linguagem RAPID. Um dos seguintes métodos deve ser usado para detectar erros no texto:

• Salve o arquivo no disquete e tente carregar no robô. Se existir qualquer erro de sintaxe, o programa não será aceito e uma mensagem de erro será apresentada. Para obter informações sobre o tipo de erro, o robô armazena uma lista chamada PGMCPL1.LOG no interior da RAM disk. Copie esta lista em um disquete usando o Gerenciador de Arquivos do robô (File Manager). Carregue a lista em um editor de texto e você poderá ler qual linha está incorreta e receber uma descrição do erro.



• Carregue o arquivo no QuickTeach e leia o erro de sintaxe com ajuda do QuickTeach.

• Use a verificação de sintaxe de programa RAPID para PC.

Quando o programa esta sintaticamente correto, ele pode ser verficado e editado no robô. Para ter certeza que todas as referências para rotinas e dados estão corretas, use o comando File: Check Program. Se o programa for alterado no robô, ele pode ser armazenado no disquete novamente e processado e armazenado em um PC.

1.4 Exemplos

A seguir apresentamos exemplos de uma rotina em formato de texto.

%%%VERSION: 1 LANGUAGE: ENGLISH

%%%MODULE mainVAR intnum process_int ;! Demo of RAPID programPROC main()

MoveL p1, v200, fine, gun1; ENDPROC

TRAP InvertDo12! Trap routine for TriggInt

TEST INTNOCASE process_int:InvertDO do12;DEFAULT:TPWrite “Unknown trap , number=”\Num:=INTNO;

ENDTESTENDTRAP

LOCAL FUNC num MaxNum(num t1, num t2)IF t1 > t2 THEN

RETURN t1;ELSE

RETURN t2;ENDIF

ENDFUNCENDMODULE



1.5 Criando suas próprias instruções

Para tornar a programação mais fácil, você pode criar suas próprias instruções. Estas são criadas na forma de uma rotina normal, mas, quando programamos e testamos, elas funcionam como instruções:

- Elas podem ser chamadas pela lista de instruções de escolha (pick list) e programadas como instruções normais.

- A rotina completa será executada durante a execução passo-a-passo.

• Crie um novo módulo de sistema onde você pode colocar suas rotinas que funcionarão como instruções. Como alternativa, você pode colocá-las no módulo de sistema USER.

• Crie uma rotina neste módulo de sistema com o nome que você quer que sua nova instrução seja chamada. Os argumentos das instruções são definidos em forma de parâmetros da rotina. Note que o nome dos parâmetros será apresentado na janela durante a programação e deve portanto ser dado um nome que o usuário entenda.

• Coloque a rotina em uma das listas Most Common.

• Se a instrução deve se comportar de uma certa maneira durante a execução do programa de trás para frente, isto pode ser feito na forma de um tratamento de trás para frente. Se não existir nenhum tratamento, não será possível chamar a instrução durante a execução do programa de trás para frente (veja Capítulo 5 deste manual - Características Básicas). Um tratamento de trás para frente deve ser feito usando o comando Routine: Add Backward Handler na janela Program Routines.

• Teste a rotina completamente para que ela trabalhe com diferentes tipos de dados de entrada (argumentos).

• Altere o módulo atribuido para NOSTEPIN. A rotina completa será então executada durante a execução passo-a-passo. Este atributo, entretanto, deve ser feito off-line.

Exemplo: Para tornar mais fácil o manuseio da garra, duas novas instruções são criadas, GripOpen e GripClose. O nome da saída digital é dado como argumento desta instrução, por exemplo, GripOpen gripper1.

MODULE My_instr (SYSMODULE, NOSTEPIN)PROC GripOpen (VAR signaldo Gripper)

Set Gripper;WaitTime 0.2;

ENDPROCPROC GripClose (VAR signaldo Gripper)

Reset Gripper;WaitTime 0.2;

ENDPROCENDMODULE




Módulo do sistema User

1 Módulo do sistema User

De modo a facilitar a programação, os dados pré-definidos são fornecidos com o robô. Estes dados não precisam de ser criados e, consequentemente, podem ser usados dire-tamente.

Se este dado é usado, a programação inicial é feita facilmente. Entretanto, normal-mente é melhor dar seu próprio nome ao dado que você usar, desde que o programa feito seja de fácil leitura.

1.1 Conteúdo

User compreende cinco dados numéricos (registros), um dado de ferramenta, um dado de carga, um dado de objeto de trabalho, um de relógio (cronômetro) e dois valores simbólicos para sinais digitais.

Nome Tipo de dado Declaração

reg1 num VAR num reg1:=0reg2 . .reg3 . .reg4 . .reg5 num VAR num reg5:=0

wobj1 wobjdata PERS wobjdata wobj1:=wobj0

clock1 clock VAR clock clock1

high dionum CONST dionum high:=1low dionum CONST dionum low:=0edge dionum CONST dionum edge:=2

User é um módulo do sistema, o que significa que está sempre presente na memória do robô apesar do programa estar carregado.

1.2 Criando um novo dado no módulo

Este módulo pode ser usado para criar dados semelhantes e rotinas que devem estar sempre presentes na memória do robô apesar do programa estar carregado, por exem-plo, ferramentas e rotinas de serviço.

• Escolha View: Modules na janela Program.

• Selecione o módulo do sistema User e pressione a tecla Enter .

• Troque ou crie dados e rotinas normalmente (veja Programando e Testando).


Módulo do sistema User

1.3 Apagando este dado

Para apagar todos os dados (por exemplo, o módulo completo)

• Escolha View: Modules na janela Program.

• Selecione o módulo User.

• Pressione a tecla Delete .

Para trocar ou apagar dados individuais

• Escolha View: Data na janela Program.

• Escolha Data: In All Modules.

• Selecione o dado desejado. Se ele não aparecer, pressione a tecla funcional Types para selecionar o tipo de dado correto.

• Troque ou apague normalmente (veja Programando e Testando).


INDEX

A

agregada 4-19ajuste de movimentos 3-9algo para pensar 4-48AND 4-30argumentos

condicionais 4-33argumentos condicionais 4-33atribuição de valores aos dados 3-5

B

Backward Handler 6-3

C

cabeçalho de arquivo 4-4chamada de outra rotina 3-3chamadas funcionais 4-32comentários 3-5, 4-3componente de um record 4-19comunicação 3-41conexões cruzadas 5-59configuração das instruções de verificação

3-10configuração do eixo 5-31configuração do robô 5-31CONST 4-23constante 4-21coordenadas de deslocamento

coordenadas 5-5

D

dados 4-21utilização em expressões 4-31

dados de programa 4-21dados de rotina 4-21declaração

constante 4-23módulo 4-8rotinas 4-13variável 4-22

declarationpersistent 4-23

deslocamento do programa 3-11DIV 4-29

E

eixos externos coordenados 5-5ERRNO 4-37escopo

escopo da rotina 4-11escopo dos dados 4-21

espera 3-5execução concomitante 5-45execução de trás para a frente 4-41execução simultânea 5-26expressões 4-29expressões aritméticas 4-29expressões com "strings" 4-31expressões lógicas 4-30

F

formato matricial 4-22, 4-23funções 4-11

G

globaldados 4-21rotina 4-11

GlueWare 3-39

I

identificador 4-1instruções de arquivo 3-21instruções de comunicação 3-21instruções de deslocamento 3-11instruções de entrada 3-19instruções de movimento 3-14instruções de procura 3-14instruções de saída 3-19instruções do fluxo do programa 3-3instruções matemáticas 3-31, 3-47interpolação 5-11interpolação circular 5-13interpolação retangular 5-12interrupções 3-25, 4-39

L

localdados 4-21


8

rotina 4-11

M

manipulador de trás para a frente 4-13manipuladores de trás para a frente 4-41MOD 4-29módulos 4-7

declaração 4-8módulos de programa 4-7módulos de sistema 4-8movimento singular 5-11multitarefa 4-43Multitasking 3-49

N

NOT 4-30número de erro 4-37

O

operadoresprioridade 4-33

OR 4-30

P

palavras reservadas 4-1parada da execução do programa 3-4parâmetros 4-12parâmetros opcional 4-12PERS 4-23persistente 4-21placeholder 4-3ponto central da ferramenta 5-1, 5-37posição fixa E/S 5-28posicionamento

instrução 3-14princípios E/S 5-57prioridades 4-46procedimentos 4-11programa 4-7programação 6-1programação offline 6-1

R

recuperação de erros 4-37rotina "trap" 4-39rotinas 4-11

declaração 4-13

S

sincronização de tarefas 4-44sincronização do trajeto 5-28sincronização E/S 5-25singAreapunho 5-14singularidades 5-47sistema de coordenadas 5-37sistema de coordenadas da ferramenta 5-7sistema de coordenadas de base 5-1sistema de coordenadas de deslocamento 5-

4, 5-5sistema de coordenadas de punho 5-7sistema de coordenadas do objeto 5-3sistema de coordenadas do usuário 5-3sistema de coordenadas global 5-2sistemas de coordenadas 5-1soft servo 3-11, 5-23solda a ponto 3-33string 4-2switch 4-12syntax rules 2-2

T

TCP 5-1, 5-37estacionários 5-8

TCP’s estacionários 5-8time instructions 3-29tipo record 4-19tipos de dados 4-19tipos de dados iguais 4-19tipos de dados iguais (alias) 4-19tipos de dados sem valor 4-19tipos de dados semi value 4-19trajetos circulares 5-14trap routine 4-11tratamento de erros 4-37typographic conventions 2-2

U

User - módulo do sistema 7-1

V

valores lógicos 4-2valores numéricos 4-2VAR 4-22

-2 Características gerais

variável 4-21

X

XOR 4-30



Glossário

Glossário

Argumento A parte de uma instrução que pode ser mudada, p.ex. tudo exceto o nome da instrução.

Modo Automático O modo aplicado quando o seletor do modo de operação estiver setado para .

Componente Uma parte de um "record".

Configuração A posição dos eixos do robô em uma determinada posição.

Constante Dado que só pode ser mudado manualmente.

Trajetória em curva A trajetória gerada ao passar num ponto de passagem.

Declaração Parte de uma rotina ou dado que define suas propriedades.

Diálogo/Caixa de Diál. Qualquer caixa de diálogo aparecendo no display da uni-dade de programação deve ser sempre concluida (normal-mente pressionando OK ou Cancel) antes de poder sair.

Manipulador de Erros Uma parte separada de uma rotina onde um erro pode ser tratado. A execução normal pode então ser reiniciada auto-maticamente.

Expressão Uma sequência de dados e sinais associados; p. ex. reg1+5 ou reg1>5.

Ponto de passagem Um ponto no qual o robô passa apenas na sua proximidade – sem parar. A distância para este ponto depende do tama-nho da zona programada.

Função Uma rotina que retorna um valor.

Grupo de sinais Um número de sinais digitais que estão agrupados e são manipulados como um único sinal.

Interrupção Um evento que temporariamente interrompe a execução do programa e executa um rotina "trap".

E/S Entradas e Saídas elétricas.

Rotina principal A rotina que normalmente se inicia quando a tecla Start é pressionada.

Modo manual O modo aplicado quando o seletor do modo de operação estiver setado para .

Unidade Mecânica Um grupo de eixos externos.

Módulo Um grupo de rotinas e dados, p. ex. uma parte do programa.

Motors On/Off O estado do robô, p. ex. se a fonte de alimentação dos motores está ligada ou não.

Painel de operação O painel localizado na frente do painel de controle.

Orientação A direção de um atuador final, por exemplo.

Parâmetro O dado de entrada de uma rotina, enviado com a rotina cha-mada. Ele corresponde ao argumento de uma instrução.

Persistente Uma variável, cujo valor é persistente.


Glossário

Procedure Uma rotina que, quando chamada, pode independentemente executar uma instrução.

Programa O conjunto de instruções e dados que definem a tarefa do robô. Programas, porém, não contém módulos de sistema.

Dado de programa Dado que pode ser acessado dentro de um módulo ou pro-grama completo.

Módulo de programa Um módulo incluido no programa do robô e que é trans-ferido ao copiar o programa para o disquete, por exemplo.

Record Um tipo de dado composto.

Rotina Um subprograma.

Dados de rotina Dados local que só podem ser usados numa rotina.

Ponto de partida A instrução que será executada primeiro ao iniciar a execução do programa.

Ponto de parada Um ponto no qual o robô pára antes de seguir para o próximo ponto.

Módulo de sistema Um módulo que está sempre presente na memória do pro-grama. Quando um novo programa é lido, os módulos de sistema continuam na memória de programa.

Parâmetros de sistema Os dados que definem o tipo e as propriedades do robô; em outras palavras dados de configuração.

Tool Centre Point (TCP) O ponto, normalmente na ponta da ferramenta, que se move ao longo da trajetória programada, na velocidade progra-mada.

Rotina "trap" A rotina que define o que deve acontecer quando ocorrer uma interrupção específica.

Variável Dados que podem ser alterados dentro de um programa, mas que perdem seu valor (retorna ao seu valor inicial) quando o programa é executado do início.

Janela O robô é programado e operado por meio de várias janelas, tais como a Janela de Programação e Janela de Serviço. Podemos sempre sair de uma janela escolhendo outra janela.

Zona O espaço esférico que circunda um ponto de passagem. Tão logo o robô entre nesta zona, ele inicia o movimento para a próxima posição.


Rap Overview

Text of Rap Overview

Overview Solutions

Biovale Project Overview

Aop5911 Overview

Overview TI

Overview solucoes

boletim RAP 1 - elosdasaude.files.wordpress.com · O RAP Informa conversou com a coordenadora do UNICEF/RJ Luciana Phebo sobre a Plataforma e a parceria com o RAP. RAP Informa: Qual

Google AppsScript - Overview

Overview SAP FI

EM Overview

UMA overview

Arduino Overview

Overview ODI 2k7

VC - Overview

Rap psicologia

reD | Overview

Puppet overview

SAP Overview

Rap lanches

Highwinds Overview Brazil

Apple Overview

CObIT Module - OverView

SharePoint 2013 Overview

Rap planetas

Overview Azure

Overview Corporativo Polvora!

Beehive - Overview

ITIL Module - OverView

ExecutiveScrum - Overview

Energia Overview

Ltsp Overview

Documents

Rap Overview

Text of Rap Overview