Escolar Documentos
Profissional Documentos
Cultura Documentos
Robótica
Robótica
Automação e Robótica I
Técnicas e Linguagens de
Programação de Robôs
- Viseu, 2001 -
- 2000/2001 - Ricardo Silva, Rui Cabral, Henrique Carvalho 1
Automação e Robótica I – Técnicas e Linguagens de Programação de Robôs
1 - Introdução
Neste trabalho vamos apresentar uma visão geral dos diferentes tipos e métodos de
programação de robôs, o processo de desenvolvimento de um programa para um robô e ainda uma
abordagem às linguagens de programação mais usadas.
• Os graus de liberdade de um robô serão numerados da seguinte forma: θ1, θ2, θ3, etc.
Usualmente os robôs industriais têm entre 4 e 6 graus de liberdade, um em cada junta.
Figura 1
• No final do braço do robô, está situado um órgão terminal. Nas figuras abaixo podemos ver
alguns dos mais utilizados.
Se, por exemplo, o robô tem um gripper de dois dedos, para poder levantar objectos,
definimos geralmente Pe como um ponto entre os dois dedos, de modo que quando um objecto
está neste ponto, tudo o que o robô tem a fazer para o levantar é fechar o gripper para agarrar
o objecto. Pode então executar um movimento com o objecto entre os dedos.
Para este programa ser um programa completo que possa ser compilado e
interpretado em comandos actuais de robô, teremos que acrescentar algumas
definições dos dois objectos envolvidos, e definições da Posição2 e das outras
posições utilizadas.
A programação a nível das juntas e a nível do robô continua a ser o tipo de programação de
robôs mais utilizada. A programação a nível de objectos não tem tido muito êxito, e por isso continua a
ser assunto de investigação. A nível industrial, não há linguagens de programação a nível de tarefas
que possam ser aplicadas, e por isso são também assunto de estudo e investigação.
Estes problemas advém do facto de tanto a programação a nível de objectos como de tarefas
carecer que o robô tenha algum tipo de controlo inteligente.
A diferença entre estes dois tipos de programação reside no facto de na programação on-line
ser necessário utilizar o robô a ser programado para gerar o programa, enquanto que na programação
off-line não é preciso ter o robô senão na fase final de teste e implementação.
Este tipo de programação consiste na movimentação física do braço do robô através dos
movimentos e acções que terá que efectuar num determinado processo. Ao mesmo tempo que esta
movimentação física é efectuada, o robô regista as posições (e trajectórias se necessário) para onde,
ou através das quais, o robô terá de se deslocar.
• Se o controlador pode registar as trajectórias pelas quais o órgão terminal do robô deve
passar, isso é a chamada programação por trajectória. Este conceito é bastante
semelhante à programação ponto-a-ponto excepto no facto de serem gravados muitos
mais “pontos” (configurações do robô). O número necessário e a distância entre eles, são
automaticamente determinados pelo sistema de controlo do robô. O controlador
simplesmente simplifica o movimento do braço do robô enquanto o programador o move na
direcção desejada.
Outros tipos de acções não são geralmente possíveis de programar com este método de
programação, contudo existe usualmente uma maneira de programar a abertura/fecho do gripper, ligar
ou desligar um ponta de solda, etc.
Durante este tipo de programação, os motores do robô são desligados. Por este facto, este tipo
de programação é muitas vezes conhecido como programação on-line passiva.
A maior vantagem deste tipo de programação é que é bastante fácil de fazer, e não requer
nenhum conhecimento especial de programação ou treino.
Para robôs de pequenas dimensões e que só são usados para tarefas relativamente simples
que não envolvam outras máquinas ou robôs, este método de programação é ainda o mais eficaz e o
menos dispendioso.
Algumas das dificuldades podem ser ultrapassadas usando o método de programação pela
consola (teach-box). Este método usa uma consola e uma programação on-line activa.
Embora ambos os métodos serem os mais usados, têm duas importantes desvantagens:
Os métodos de programação on-line só podem ser usados para programação a nível das
juntas ou a nível do robô. Não podem ser usados para programação de alto nível.
programa, são tipicamente como que “primitivos” em comparação com os ambientes actuais de
programação de computadores.
Tal como num programa de computador, o ficheiro de texto especifica a sequência das acções
básicas que deverão ser executadas, juntamente com outra informação necessária para controlar a
velocidade máxima do movimento do órgão terminal (Pe), ou tipos de trajectórias que devem ser
seguidas entre dois pontos , por exemplo.
Ø Dados em CAD podem ser utilizados, por exemplo as dimensões das partes e as
relações geométricas entre elas;
A programação off-line pode ser usada para desenvolver programas a nível do robô e
programas de alto nível. É possível utilizar os métodos off-line para programação a nível das juntas
mas muito raramente são utilizados.
A relação entre a programação on-line e off-line e entre controlo de cinemática e básico num
robô industrial é o representado na figura seguinte:
Figura 6
o V+ - Adept (1989);
Tarefa: Mover o Bloco A e o Bloco B de modo a formar uma torre no topo do Bloco C, na seguinte
ordem C, A, B, desde o fundo. Todos os blocos devem estar bem alinhados na torre final.
B
B A
A D C D C
Figura 7 Figura 8
Para executar a tarefa acima proposta, temos alguns passos que devemos dar. Os seis passos
básicos no processo de programação do robô são:
Passo 1: Analisar e decompor a tarefa numa série de operações dos objectos envolvidos, e especificar
a sua ordem.
Por exemplo, para executar a tarefa definida acima teremos de decompô-la na seguinte
sequência de operações dos três Blocos:
Sabendo que estas duas operações de alinhamento serão necessárias é apenas um caso de
experiência, e isto ilustra o facto de que cada passo do processo de programação necessita de
bastante experiência do modo de funcionamento de todo o processo antes de a podermos
implementar.
Esta solução apresentada com as cinco operações definidas anteriormente não é a única
possível e também não é a melhor.
Por exemplo, é provavelmente melhor alinhar logo o Bloco A com o Bloco C imediatamente
depois deste ter sido colocado em cima do Bloco C, uma vez que o robô já está nessa posição. Esta
operação depende, é claro, de não haver deslocação dos blocos A e C aquando da colocação do Bloco
B por cima do Bloco A. Se a operação for feita suavemente isto provavelmente é verdade.
Se mover os Blocos A e B juntos não é seguro, ou se não for possível devido à largura do
gripper, ou se o robô não tem suficientes graus de liberdade, outra possibilidade é mover o Bloco C.
Nada nos diz na tarefa que esta opção não é possível.
Mover o Bloco C para o mais próximo possível do Bloco A significa que as operações a
realizar com os Blocos A e B implicam trajectórias menores, logo serão mais rápidas. Não terão
necessidade de passar por cima do Bloco D, o que significa um menor risco de colidir com ele ou com
outros obstáculos no caminho.
Todas estas possibilidades mostram-nos que as tarefas do robô não estão usualmente
especificadas. Fica ao critério do programador estudar todas as possibilidades e implementar aquela
que considere mais fiável, rápida e com menos possibilidade de fracasso. É, por isso, importante que
todos os aspectos relativos à tarefa a executar sejam considerados neste estado da programação.
Mudar, mais tarde, o modo como a tarefa é executada pode trazer elevadas despesas e ser mais
propenso a erros.
Assim, para a nossa tarefa de exemplo, nós poderemos especificar as seguintes situações:
2. A situação em que Pe está verticalmente acima do centro do topo do Bloco B (na sua
localização inicial) – donde o robô pode executar a tarefa de pegar no bloco sem
problemas;
3. A situação em que Pe está coincidente com o centro do Bloco B – utilizada para definir
a localização de aperto do Bloco B;
4. A situação em que Pe está ao lado do Bloco A, a uma altura igual a metade da altura
do Bloco A, e a uma distância suficiente deste para que o robô tenha espaço para
colocar o Bloco B – utilizado para definir a tarefa de poisar o Bloco B depois de ter sido
retirado de cima do Bloco A.
É uma boa ideia tentar identificar e especificar as situações que podem ser usadas para
programar diferentes acções do robô. A tarefa 1, indicada acima, é um exemplo disto: é usada para
definir a trajectória de todos os movimentos que terão de passar por cima do bloco D.
Um cuidado especial é também preciso na definição da situação 4, usada para definir o poisar
do Bloco B. É melhor acrescentar um pouco mais de altura à localização de Pe definida por esta
situação de forma que o robô largue o Bloco B quando este está a pouca distância da mesa. Quando o
robô abrir o gripper o Bloco B irá cair assim, a uma distância muito próxima da mesa.
Este procedimento é feito porque existe sempre um pequeno erro na posição e orientação real
de Pe, e se definirmos a tarefa 4 para colocar o Pe exactamente metade da altura do Bloco B sobre a
mesa, existe o risco que quando o robô executa esta tarefa, ele vai tentar mover o Bloco B mais
abaixo do que a mesa. O robô ao colidir com a mesa, e como esta tem mais força que o braço do robô
vai fazer com que o sistema de controlo pare o robô.
Existem dois tipos de erros: erros absolutos e erros de repetição. Erros absolutos acontecem
quando o robô não coloca o órgão terminal (Pe) na configuração para a qual foi programado. Este erro
não é frequente no espaço de trabalho, depende da geometria do braço do robô e de outros aspectos
do seu controlo. Usualmente os erros absolutos serão mínimos se o Pe se encontrar próximo do corpo
do robô (base), do que se Pe se encontrar numa das extremidades do espaço de trabalho. Definir
movimentos próximos da base do robô podem minimizar o aparecimento de erros absolutos, mas
podem ser mais restritos dependendo da geometria do braço do robô. Arranjando maneira de os
movimentos se fazerem o mais próximo possível da base do robô irá, por isso, minimizar o
aparecimento de erros absolutos.
Os erros de repetição ocorrem quando o robô está programado para fazer sempre o mesmo
movimento repetidamente, movendo Pe para a mesma posição e orientação. Usualmente, o robô não
vai deslocar o Pe exactamente para o mesmo sítio do Pe definido (erro absoluto) nem irá exactamente
para o mesmo sítio de cada vez. Existirá sempre um pequeno volume de espaço à volta de Pe para o
qual o robô irá mover o Pe, de cada vez que for instruído para o fazer.
Tanto os erros absolutos como os erros de repetição podem ser minimizados recorrendo a
movimentos lentos do robô. Algumas vezes é também possível especificar o nível de precisão
requerido para cada movimento. Uma precisão mais alta significa que os movimentos serão feitos com
pequenas acelerações, e por consequência, o robô irá demorar mais tempo a realizar os movimentos.
Um ponto intermédio entre a precisão e o tempo de execução requeridos precisa de ser estabelecido
para cada movimento em cada programa.
Na tarefa que considerámos como exemplo, podemos identificar partes de aquisição e partes
de colocação que requerem similares sequências de movimentos e acções que serão precisas diversas
vezes. Por exemplo, poderemos definir uma subrotina, chamada Pegar-Poisar que servirá para pegar
no Bloco e também poisar o Bloco.
Caso contrário FALHA com a mensagem (‘A acção especificada não existe’);
FimDoProcedimento;
Como podemos ver no código acima para esta subrotina, muitas das suas linhas de código são
de validação dos valores dos parâmetros, de modo a verificar se determinada acção pode ser
executada.
O comando Mover para é também definido para ser um movimento lento e com grande
precisão. Por outro lado, mover o Pe para o Inicio pode ser feito mais rapidamente e com menos
precisão.
Passo 5: Testar e depurar o programa utilizando um simulador do robô e do seu espaço de trabalho.
Este passo, como é obvio apenas se aplica aos métodos de programação off-line.
Se o programa a implementar é para ser executado em mais que um robô, por exemplo numa
linha de produção com 10 robôs que vão todos executar as mesmas tarefas, temos de decidir em
quantos deles vamos testar o programa.
Testar o programa num só robô pode não ser a melhor solução. Testar o programa em todos
os 10 robôs da linha de produção se calhar é demasiado. De modo a podermos decidir em quantos
robôs vamos testar o programa é necessário saber algumas características dos robôs onde o programa
vai ser executado, tais como a sua história e desempenho. Quanto menos se souber destes dois
aspectos em mais robôs teremos de testar o programa.
Não tendo em conta todos estes aspectos, poderá dar origem a acidentes, custos
desnecessários de produção e falhas muito dispendiosas.
b. Sensores de um eixo
c. Interruptores
Os sensores simples podem ser ligados directamente ao sistema de controlo do robô que
normalmente têm entradas analógicas e digitais. Estes sensores são baratos.
Existem três aspectos importantes relativamente aos sensores que devem ser considerados
quando se decide usá-los nas aplicações industriais.
Calibração – a calibração dos sensores não deve demorar muito tempo a fazer, nem deve
precisar de especialização ou material especial para a fazer, não deve precisar de ser feita
muito frequentemente.
Precisão – a precisão dos sensores utilizados deve ser constante com o tempo e utilização,
mas não deve ser maior do que o necessário para uma aplicação particular.
Os sensores complexos são muitas vezes usados para fornecer dados sobre os objectos
envolvidos numa tarefa ou sobre o órgão terminal do robô, a posição global e a orientação, por
exemplo.
Para concluir, quanto mais sensores forem usados, mais complicado ficará o programa e por
consequência mais difícil de testar e depurar, e a previsão do tempo de execução mais difícil de fazer.
Todas estas consequências de usar até sensores binários, pode ser razão suficiente para não usar
sensores ou o mínimo possível, e em vez disso, utilizar movimentos e acções do robô mais robustas,
mesmo que o programa fique mais extenso e com um tempo de execução superior.
Algumas das outras linguagens textuais para robôs que deveriam ser mencionadas incluem
RAIL, introduzida em 1981 pela Automatix, para montagem com robôs e solda eléctrica assim como
visão de máquina, MCL (Manufacturing Controle Language), desenvolvida sob o patrocínio da Força
Aérea Norte-Americana pela McDonnell-Douglas como melhoramento da linguagem APT
(Automatically, Programmed Tooling), o HELP, uma linguagem desenvolvida pela General Electric
Company sob licença da firma italiana DEA.
comunicação com outros computadores. Essas linguagens não podem facilmente ser ampliadas para
futuros melhoramentos.
De acordo com esta definição, existem dois aspectos básicos de uma linguagem de
programação baseada num sistema com modelo tridimensional. O primeiro é que o sistema de robô
possui na sua memória de controle um modelo tridimensional do seu espaço de trabalho.
Anexo 1
LINGUAGEM VAL II
Esta linguagem foi desenvolvida pela Unimation Inc. e é usada para os seus robôs industriais.
VAL II é uma versão mais aperfeiçoada da linguagem de programação VAL, lançada pela Unimation
em 1979 para os seus robôs industriais da série PUMA.
§ DESCRIÇÃO GERAL
§ COMANDOS MONITOR
O modo monitor do sistema VAL II é usado para funções como definições de posições de
pontos no volume de trabalho, edição e execução de programas, calibração do braço do robô e
operações semelhantes.
Definindo posições
Comando Descrição
HERE P1 Define a variável P1 como sendo a posição actual do braço do robô.
WHERE Solicita que o sistema exiba a posição actual do robô em coordenadas espaciais cartesianas
e variáveis da articulação do punho. Ele exibe também a abertura actual do gripper se o robô
for equipado com uma mão posicionada por servocomando.
TEACH É usado para registar uma séria de valores de posição sob o comando da tecla de registo na
consola.
TEACH P1 Com a execução deste comando, a primeira variável de posição registada será P1, a próxima
será P2, a terceira será P3 e assim por diante. É possível ensinar uma trajectória completa
posicionando sucessivamente o robô, usando a consola e pressionando a tecla de registo.
POINT PA = P1 Estabelece o valor de PA (uma variável de posição) igual ao valor de P1.
EDIT ASSEMBLY1 Comandos para entrada e saída no modo edição do programa. O comando EDIT abre o
M programa que deve ser chamado ASSEMBLY1. O Comando E (E de EXIT) provoca a saída e
volta para o modo monitor.
E
SPEED Especificação da velocidade. Este comando no modo monitor do sistema VALL II, é fornecido
antes da execução do programa da seguinte maneira: SPEED 50
EXECUTE ASSEMBLY1 Faz o sistema executar o programa chamado ASSEMBLY1
§ COMANDOS DE MOVIMENTO
MOVE P1 Usado para definir a trajectória do movimento, faz com que o braço do robô se mova num
movimento de interpolação de junta até ao ponto P1.
MOVES P1 Faz o movimento ocorrer ao longo de uma trajectória retilínea da posição actual até ao ponto
P1.
APPRO e DEPART Comandos de aproximação e afastamento.
APPRO P1, 50 O primeiro comando movimenta a ferramenta para a posição e a orientação especificadas por
MOVE P1 P1 com um deslocamento ao longo do eixo z da ferramenta de uma distância de 50 mm. O
comando MOVE movimenta a ferramenta até ao ponto P1. A instrução DEPART movimenta a
DEPART 50 ferramenta afastando-se de P1 a uma distância de 50 mm ao longo do eixo z da ferramenta.
SPEED Comando para ajustar a velocidade.
DRIVE 4, -62,5, 75 Uma articulação individual pode ser deslocada de uma certa distância usando este comando,
que muda o ângulo da articulação 4, movimentando-a de 62,5° no sentido negativo a uma
velocidade de 75% da velocidade de modo monitor.
§ CONTROLE DO GRIPPER
OPEN Abrir o gripper. Este comando é executado durante o movimento seguinte do robô.
CLOSE Fechar o gripper. Este comando é executado durante o movimento seguinte do robô.
OPENI Abrir o gripper. Este comando é executado imediatamente, em vez de ser executado durante
o movimento seguinte.
CLOSEI Fechar o gripper. Este comando é executado imediatamente, em vez de ser executado
durante o movimento seguinte.
OPEN 75 M O primeiro comando faz abrir o gripper até 75 mm durante o movimento seguinte do robô. O
segundo comando faz fechar o gripper imediatamente para 50 mm.
CLOSEI 50
GRASP Permite verificar se o gripper fechou conforme esperado. Este comando fornece um método
conveniente de pegar um objecto e testar para assegurar se o contacto foi feito.
- 2000/2001 - Ricardo Silva, Rui Cabral, Henrique Carvalho 28
Automação e Robótica I – Técnicas e Linguagens de Programação de Robôs
§ CONTROLE DE CONFIGURAÇÃO
RIGHTY ou LEFTY Proporcionam uma mudança na configuração do robô de braço articulado, de modo que as
primeiras três juntas (rotação da base, do ombro e do cotovelo) se assemelhem com o braço
humano direito e esquerdo, respectivamente.
ABOVE ou BELOW Solicitam uma mudança na configuração do robô, de modo que o cotovelo do robô seja
apontado para cima ou para baixo, respectivamente.
FLIP ou N0FLIP Proporcionam uma mudança no campo de operação de junta 5 (num robô de 6 juntas) par
ângulos positivos ou negativos, respectivamente.
§ CONTROLE DE INTERTRAVAMENTO
§ CONTROLE DO PROGRAMA
Anexo 2
LINGUAGEM RAIL
A linguagem RAIL é uma linguagem de programação desenvolvida pela Automatix para o seu
sistema de CAM (Computer Aided Manufacturing).
§ DESCRIÇÃO GERAL
Pode ser utilizada para controlar sistemas de fabrico tendo comandos específicos para
controlar um equipamento de solda, além disso possui comandos para controlar o robô numa linha de
montagem e permitir a sua ligação a periféricos, tais como alimentadores de peças, sensores,
conveyors e equipamentos de manuseamento de materiais.
Além disso, integra ainda comandos para interface com um sistema de visão que se destina a
verificar a qualidade ou identificar determinado componente da linha de fabrico.
§ CARACTERÍSTICAS
- comandos de solda do robô e meios para ajustar os parâmetros de solda, como a voltagem e
a taxa de avanço do arame de solda;
- um método simples de acesso aos input e output que estejam ligados a equipamentos;
§ POSIÇÕES
Esta linguagem possui três tipos de dados para posições do robô: pontos, trajectória e sistema
de coordenadas de referencia.
Pontos
Trajectórias
A trajectória é uma série de pontos ligados entre si. Quando o robô é comandado para se
movimentar ao longo de uma trajectória, ele movimenta-se suavemente através de cada ponto na
trajectória, sem parar ou diminuir a marcha em qualquer dos pontos intermédios. Uma trajectória é
especificada indicando os pontos que a definem, como no seguinte comando PATH:
Movimento Linear
Movimento Assíncrono
MOVE SLEW P1 Comando para um movimento assíncrono definido usando o comando SLEW.
Movimento Circular
Esta especificação de movimento faz com que o braço do robô se movimente de tal forma que
a ponta da ferramenta se desloque ao longo de um arco circular formado pelos pontos indicados no
caminho.
CIRCLE Comando que é usado para especificar uma interpolação circular num comando de
movimento. Por exemplo: MOVE CIRCLE PATH (P1, P2, P3, P4).
Aproximação e Afastamento
APPROACH 50 FROM P1 O primeiro comando faz com que a ferramenta se movimente até uma posição 50 mm a
partir do ponto P1 ao longo do eixo z da ferramenta. O segundo comando faz com que a
M
ferramenta se afaste 50 mm do ponto.
DEPART 50
Rotação da ferramenta
ROTATE HAND 180 Comando para girar o actuador de 180° no sentido horário, em volta do eixo de rotação.
Solda
WELD Comando que permite a realização de uma operação de solda num ponto ao longo de um
caminho.
§ COMANDOS LEARN
O conjunto LEARN é utilizado para definir dados de posições com a consola de programação.
O comando pode ser utilizado para programar pontos no espaço ou relativamente a outras posições
predefinidas. Pode também ser usado para ensinar trajectórias e sistemas de coordenadas.
LEARN P1, P2, P3, P4 Neste comando, os quatro pontos são ensinados movimentando o braço para as posições
designadas, usando as teclas de movimento da consola de programação e pressionando a
tecla de registo para armazenar cada posição de ponto na sequência adequada.
LEARN FRAME Este comando facilita ao utilizador o ensino de 3 posições. Estas posições correspondem à
origem do sistema de coordenadas, um ponto ao longo do eixo x e um ponto no plano xy do
sistema de coordenadas.
§ SOLDA
A linguagem RAIL proporciona uma variedade de opções para controlar um robô para
operações de solda. Como já foi referido anteriormente o comando básico de solda da linguagem RAIL
é o WELD, para mais facilmente se entender como funciona este comando, apresentamos de seguida
um exemplo:
WELD SEAM1 WITH WELDSCHED[3] Neste comando a trajectória de solda é chamada de SEAM1. A clausula WITH
WELDSCHED[3] identifica que os parâmetros de solda a serem usados
durante essa trajectória são definidos no programa de solda 3.
§ ENTRADA/SAÍDA
INPUT PORT SWITCH1 7 Este comando define uma variável chamada SWITCH1 para ser uma informação de
entrada para a unidade controladora através da porta de entrada número 7.
OUTPUT PORT MOTOR3 15 Define a variável MOTOR3 como uma saída da unidade controladora através da porta
15. Durante o programa, essa saída pode ser ligada ou desligada por meio dos
comandos MOTOR3 = ON e MOTOR3 = OFF.
WAIT UNTIL Este comando é usado para sincronizar a execução de um programa em linguagem RAIL
com alguma condição. Quando este comendo é encontrado, a execução do programa é
interrompida até que a condição de teste esteja satisfeita.
WAIT 2 SEC Este comando é utilizado para retardar a execução do programa para um intervalo
WAIT 2 especificado de tempo. Este intervalo de tempo é especificado em segundos (SEC) ou
em milisegundos (MSEC). Se este intervalo não for especificado as unidades de tempo
- 2000/2001 - Ricardo Silva, Rui Cabral, Henrique Carvalho 34
Automação e Robótica I – Técnicas e Linguagens de Programação de Robôs
WAIT 2000 MSEC serão consideradas como sendo segundos. Logo, cada um dos comandos aqui
considerados teriam um retardo de tempo idêntico.
READ Lê os dados numéricos introduzidos pelo operador. Os números devem ser inteiros ou reais.
READS É usado para ler dados introduzidos em forma de cadeia de caracteres (Ex: texto contendo
quaisquer caracteres ASCII, caracteres alfabéticos, números, pontuação, etc) pelo operador.
WRITE Este comando é usado para escrever mensagens para o operador no monitor de vídeo
SAVE É usado para guardar o valor corrente das variáveis de RAIL, e/ou as definições escritas pelo
utilizador, num arquivo ou numa fita.
SAVE ‘PARTFILE’ PARTCOUNT, GOODPARTS, BADPARTS Este comando proporciona um meio de guardar os
valores correntes das variáveis (PARTCOUNT,
GOODPARTS, BADPARTS) na lista de variáveis
existentes na fita. O nome do arquivo é PARTFILE.
LOAD ‘PARTFILE’ Carrega o arquivo da fita cassete para a memória do computador.
FILER É usado para operações tais como a listagem do conteúdo de uma fita para copiar ou apagar
arquivos, e assim por diante.
§ CONTROLE DO PROGRAMA
A linguagem RAIL contém um conjunto de comandos típicos para controle do programa, como
IF... THEN, IF... THEN... ELSE e outros. O comando WHILE... DO permite ao programador continuar a
execução de um determinado comando durante o tempo que uma condição especificada de teste
permanecer verdadeira.
ANEXO 3
LINGUAGEM AML
A linguagem AML é uma linguagem de programação interactiva de alto nível desenvolvida pela
IBM Corporation para ser utilizada no seu robô IBM 7565.
§ DESCRIÇÃO GERAL
Como o nome indica é uma linguagem de manufactura que possui diversos tipos e operadores
de dados, sub-rotinas de sistema, estruturas de controlo da linguagem, estação de exibição de dados e
controlos de input/output de arquivos, edição interactiva e facilidade de eliminação de erros, assim
como identificadores do sistema para ajudar a melhorar a leitura do programa.
É uma linguagem orientada para sub-rotinas, ou seja, os programas são escritos estruturando
a aplicação como um conjunto de chamadas para as sub-rotinas escritas pelo utilizador e também
daquelas que integram o sistema. A utilização destas sub-rotinas, quer sejam implementadas pelo
utilizador quer aquelas que integram o sistema, são feitas da mesma maneira.
§ COMANDOS AML
- comando executável;
Comandos Executáveis
rótulo: expressão;
Exemplo:
CALC: 5-1/2*10
ou
Exemplos:
Neste comando é declarado a variável X2 através de uma expressão que a avalia em relação
ao produto de 2,5 vezes o valor corrente de X1.
As variáveis NEW são interpretadas sempre que a sub-rotina dentro da qual residem é
chamada. O interpretador analisa a expressão do lado direito da vírgula de cada vez que uma sub-
rotina é chamada, e é reservado espaço para armazenamento da nova variável. Quando a execução
acaba e o controlo é devolvido ao programa principal, o espaço alocado para a variável nova é
libertado.
Ao contrário das variáveis NEW, as variáveis STATIC não são libertadas do armazenamento
quanto termina a execução da sub-rotina; elas permanecem armazenadas, assim como os valores
correspondentes, mesmo quando o programa não está a ser executado. Assim, o último valor
conservado para qualquer variável STATIC está disponível para uso futuro no programa principal.
Os comandos NEW e STATIC são usados pelo interpretador para determinar como tratar uma
variável declarada. Para variáveis que ficam de fora da sub-rotina não existe diferença na maneira
como o comando é interpretado. A diferença aplica-se apenas para a utilização numa sub-rotina.
subrstatement1;
subrstatement2;
...
subrstatementn;
END;
- parâmetros (p1, p2, p3...pn), que são transferidos do programa principal para
use na chamada da sub-rotina. Quando especificados estes devem ser
colocados entre parênteses;
subrstatement1 ;
subrstatement2;
...
subrstatementn;
Esses comandos têm o mesmo formato a seguem as mesmas regras que outros comandos
AML. O ponto-e-vírgula (;) depois do último comando (subrstatementn) a antes do comando
END é opcional, e o comando END, indica o fim da sub-rotina.
Um ponto-e-vírgula (;) segue o comando END. Regras especiais acerca do sinal (;) aplicam-se
ao comando END para sub-rotinas armazenadas dentro de outras.
§ CONSTANTES E VARIÁVEIS
A linguagem AML usa vários tipos de constantes a de variáveis, que podem ser números
inteiros reais ou cadeias. Constantes e variáveis conjuntas são também possíveis no sistema AML,
incluindo conjuntos que contêm uma combinação de números inteiros, números reais e elementos em
cadeia. Os conjuntos são incluídos entre parênteses angulares < >, e os elementos são separados por
vírgulas.
Pode-se ter acesso aos elementos individuais desse conjunto na linguagem AML por meio dos
símbolos R(1), R(2) etc. Por outras palavras, R(4) representa (5,2, 25,1, 3,0). Isto poderia ser útil para
identificar um ponto no espaço para o qual o robô seria dirigido.
A linguagem AML tem alguns comandos de controlo do programa para a execução condicional
do programa. Essas expressões condicionais incluem os comandos IF...TI-IEN, IF...THEN...ELSE,
WHILE...DO a REPEAT...UNTIL.
§ COMANDOS DO MOVIMENTO
A linguagem AML foi projectada para o robô IBM 7565, que tem coordenadas com uma
configuração máxima de seis juntas mais a garra. As juntas 1, 2 e 3 são lineares, enquanto as 4, 5 e 6
são rotacionais. A garra é também considerada linear em termos de abertura entre seus dedos.
indica que as duas juntas JX a JY deveriam ser movimentadas para seus valores correspondentes de
coordenadas de 8,5 a 1,5 in (inches), respectivamente.
O comando DMOVE é usado para realizar um movimento relativo à posição corrente. Por
exemplo, o comando
DMOVE(JZ, 3,0);
GUIDE (<JX,JY,JZ>);
Essa informação poderia então ser usada para definir um comando MOVE, se desejado.
SPEED (0,5)
ajusta a velocidade para quaisquer movimentos subsequentes (até que a velocidade seja alterada)
para 0,5 vezes a velocidade plena. Velocidades válidas variam de 0,0 até 1,0 vezes a velocidade
máxima do robô.
O robô IBM 7565 proporciona um interface de entrada/saída para sensores para ser ligado com
vários equipamentos dentro da célula de trabalho, tais como sensores, dispositivos, ferramentas,
alimentadores e outros. O sistema tem uma entrada ou saída digital de 1 bit, assim como uma
entrada/saída digital de vários bits (até 16 bits). O sistema IBM 7565 suporta até 64 definições de
entrada/saída lógica. Se o robô for equipado com uma garra com sensores, comandos adicionais são
possíveis para interligação com seus sensores.
Três dos comandos mais importantes para entrada/saída de sensores na linguagem AML são:
DEFIO, SENSIO a MONITOR.
O comando DEFIO é usado para definir um dispositivo lógico de entrada/saída para sensores,
ao qual pode-se ter acesso através dos comandos SENSIO ou MONITOR. A forma do comando DEFIO
é
DEFIO (group,type,format,sbit,length,scale,offset)
Os cinco primeiros parâmetros entre parênteses são obrigatórios, e os dois últimos são
opcionais.
- Scale é um número real ou conjunto opcional que especifica o factor da escala que
deve ser usado para dimensionar a entrada/saída de modo a tornar seu tamanho
compatível com o sistema. O valor default é 1.
O comando DEFIO retorna a definição de um bit ou um conjunto vizinho de bits aos quais se
pode ter acesso pelo comando SENSIO. O retorno é chamado de ionum.
O ionum é um número inteiro ou um conjunto que especifica o identificador numérico para cada
entrada/saída definida. O valor deve ser usado em todas as referências para essa entrada/saída lógica
em particular.
SENSIO(ionum,padrão)
- ionum é o valor (ou valores) que determina(m) a entrada ou saída que deve ser
realizada. Até dez ionums podem ser especificados num único comando SENSIO,
permitindo a execução de 10 entradas/saídas a partir do mesmo comando;
DEFIO (21,0,1,0,1);
1016
SENSIO (1016,INT)
O 21 no comando DEFIO refere-se ao canal 21; o primeiro 0 indica que o tipo é entrada; o
primeiro 1 indica o formato; o segundo 0 indica o primeiro bit do campo, e o segundo 1 indica que o
campo tem um comprimento de 1 bit. O comando DEFIO retorna o ionum a ser fornecido pelo comando
SENSIO (1016). O INT é usado para referenciar os valores sob o controle do programa AML..
O comando MONITOR permite o uso de um ou mais dos canais de entrada/saída para a leitura
dos sensores a intervalos regulares de tempo. Isto pode ser usado para projectar um sistema de
interrupção para monitorização de segurança, por exemplo.
O comando MONITOR difere do comando SENSIO, já que permite uma monitorização quase
que contínua de sinais emitidos por sensores em vez de pontos específicos no programa AML.
Existe uma garra com capacidades sensoras para o robô IBM 7565. Essas capacidades
incluem avaliação da força com medidores de deformação (strain gauges) e avaliação óptica com um
díodo emissor de luz.
- Sensores de ponta: Esses sensores indicam se existe uma força que pressiona de
baixo para cima na garra. Isto poderia ocorrer, por exemplo, se a garra fosse
pressionada contra a mesa de trabalho. Teria também um valor se um objecto
estivesse agarrado pela garra com esta orientação vertical, o peso do objecto iria fazer
com que a força fosse registada nestes sensores. Os comandos SET a SRT em
linguagem AML são usados como identificadores lógicos de entrada/saída para os
sensores da direita nos comandos SENSIO a MONITOR.
serão indicados valores negativo. Os comandos SLP a SRP, em linguagem AML, são
usados como identificadores de entrada/saída lógica para os comandos SENSOR e
MONITOR.
O comando LED, em linguagem AML, pode ser usado com os comandos SENSIO a MONITOR
para determinar se um objecto está bloqueando o díodo emissor de luz. Por exemplo, o comando
SENSOR(LED,INT)
-1
retorna zero para indicar que nenhum objecto está a bloquear o LED, enquanto um valor de -1
indica que nenhum objecto está a bloquear o caminho da luz. O comando LED identifica o número de
entrada/saída lógica do circuito detector de luz da garra.
§ PROCESSAMENTO DE DADOS
Vários comandos podem ser usados pelo programador para definir a comunicação do sistema
para os periféricos. Estes incluem os comandos WRITE, PRINT e DISPLAY.
O comando WRITE é usado para escrever um registo lógico dentro do arquivo através de um
canal definido.
O comando PRINT escreve os valores de uma lista de expressões num canal de dados
correntemente aberto. PRINT é diferente de WRITE porque os dados na expressão são convertidos em
formato de caracteres antes de ser exibidos e porque mais de um registo pode ser transmitido para o
dispositivo. Com o comando WRITE, apenas um registo está escrito para o dispositivo.
Uma outra diferença entre PRINT a WRITE é que os dados de saída são guardados até um
caractere EOL ou EOP (fim de linha ou de impressão) ser detectado ou a capacidade do buffer ser
excedida. Mais uma vez o número do canal deve ser fornecido como um dos argumentos no comando.
O comando DISPLAY é o mesmo que o comando PRINT dirigido para o canal 0. Não requer
nenhuma identificação do canal. O comando seguinte serve como ilustração:
O comando READ é usado para receber dados de um dispositivo periférico. Ele lê um registo
lógico do canal especificado. O comando seguinte ilustra o formato do comando READ:
READ(0, DATA1);
Outros comandos do sistema incluem ERASE (para apagar um arquivo de um disco a libertar o
espaço ocupado por ele, COPYFILE (para copiar um arquivo de um disco para o outro ou para o
mesmo disco.
Índice
1 - Introdução ................................................................................................................................ 1
Anexos
§ COMANDOS DE MOVIMENTO.............................................................................................. 28
§ CONTROLE DO GRIPPER.................................................................................................. 28
§ CONTROLE DE INTERTRAVAMENTO..................................................................................... 29
Linguagem RAIL...................................................................................................................... 31
§ CARACTERÍSTICAS ......................................................................................................... 31
§ POSIÇÕES .................................................................................................................... 32
§ SOLDA ......................................................................................................................... 34
§ COMANDOS AML........................................................................................................... 37
§ CONSTANTES E VARIÁVEIS............................................................................................... 40
§ COMANDOS DO MOVIMENTO............................................................................................. 42
§ PROCESSAMENTO DE DADOS............................................................................................ 47