Você está na página 1de 274

CNC PROGRAMMING

USING FANUC CUSTOM MACRO B.


S. K. SINHA.
CNC PROGRAMMING
USING FANUC CUSTOM MACRO B.
S. K. SINHA.
Sumário
Tabela Expandida de Conteúdos....................................................................................... 11
 Sobre o autor................................................................................................................. 11
 B. Prefácio ..................................................................................................................... 11
1. Introdução ......................................................................................................................... 11
 Técnicas de programação de peças ......................................................................... 11
 Certos aplicativos de programação macro ............................................................... 11
 Minha máquina tem capacidade de macro? ............................................................ 11
 Objetivo do texto atual ................................................................................................. 11
 Como usar este livro .................................................................................................... 11
2. Variáveis e Expressões................................................................................................... 11
 Variáveis de macro....................................................................................................... 11
 Expressões macro ........................................................................................................ 11
 Atribuindo um valor a uma variável ........................................................................... 11
 Exibição de variáveis ................................................................................................... 11
 Valores reais versus valores inteiros ......................................................................... 11
 Variáveis Indefinidas .................................................................................................... 11
 Um uso simples dos recursos de programação de macros................................... 11
 Retendo programas no modo MDI ............................................................................ 11
3. Tipos de Variáveis ........................................................................................................... 11
 Variáveis locais e globais ............................................................................................ 11
 Efeito da redefinição do sistema nas variáveis de macro ...................................... 11
 Níveis de Variáveis Locais .......................................................................................... 11
 Intervalo de valores armazenados em variáveis ..................................................... 11
 Variáveis do sistema .................................................................................................... 11
4. Funções Macro ................................................................................................................. 12
 Tipos de funções de macro ......................................................................................... 12
 Operações aritméticas ................................................................................................. 12
 Funções trigonométricas ............................................................................................. 12
 Funções de arredondamento...................................................................................... 12
 Funções diversas.......................................................................................................... 12
 Funções lógicas ............................................................................................................ 12
 Funções de Conversão................................................................................................ 12
5. Filiais e Loops ................................................................................................................... 12
 Bran Ramificação Incondicional ................................................................................. 12
 Bran Ramificação condicional .................................................................................... 12
 Execução condicional de uma única declaração macro ........................................ 12
 Execução em um loop ................................................................................................. 12
 Operações aritméticas em números variáveis macro............................................. 12
 Declaração WHILE aninhada ..................................................................................... 12
6. Revisão de Subprogramas ............................................................................................. 12
 Introdução ...................................................................................................................... 12
 Chamada de Subprograma......................................................................................... 12
 Chamada Múltipla de um Subprograma ................................................................... 12
 Nest Aninhamento de subprograma .......................................................................... 12
7. Chamada Macro ............................................................................................................... 12
 Introdução ...................................................................................................................... 12
 Macro versus Subprograma........................................................................................ 12
 Chamada Macro ........................................................................................................... 12
 Chamada de subprograma sem usar o M98 / M198 .............................................. 12
 Especificação de Argumento ...................................................................................... 12
 Processamento de declarações macro ..................................................................... 12
8. Geração Complexa de Movimento ................................................................................ 12
 o Introdução................................................................................................................... 12
 o Arco com Raio de Variação Uniforme.................................................................... 12
 Interpolação Helicoidal com Raio Variável ............................................................... 12
 o giro parabólico ........................................................................................................... 12
 o Transformando uma curva de seno ....................................................................... 12
9. Programação Paramétrica .............................................................................................. 12
 Introdução ...................................................................................................................... 13
 Pin Locator..................................................................................................................... 13
 Parafusos de fixação em uma flange ........................................................................ 13
10. Ciclos Enlatados Personalizados ................................................................................ 13
 Introdução ...................................................................................................................... 13
 P Furação profunda em um torno .............................................................................. 13
 Perfuração com redução de comprimentos de peck em uma fresadora ............. 13
11. sondagem ....................................................................................................................... 13
 Introdução ...................................................................................................................... 13
 Pular a função em uma máquina CNC ..................................................................... 13
 Sondando um bolso ..................................................................................................... 13
 Encontrando Centro de um Buraco ........................................................................... 13
 Encontrando o ângulo de uma borda ........................................................................ 13
 Ajuste do Desgaste do Desgaste ............................................................................... 13
12. Comunicação com Dispositivos Externos .................................................................. 13
 Introdução ...................................................................................................................... 13
 Princípio de Comutação .............................................................................................. 13
 Tipos de entrada e fiação ............................................................................................ 13
 Atribuição de pinos do conector ................................................................................. 13
 Sensores discretos para insumos de Sourcing / Sinking PLC .............................. 13
 Tipos de saída e fiação................................................................................................ 13
13. Entrada de Dados Programável .................................................................................. 13
 Introdução ...................................................................................................................... 13
 Entrada de Dados para Distâncias de WCS Offset ................................................ 13
 Entrada de dados para distâncias adicionais do WCS........................................... 13
 Entrada de dados para valores de compensação em uma fresadora ................. 13
 Entrada de dados para valores de compensação em um torno ........................... 13
 Entrada de dados para valores de parâmetro ......................................................... 13
 Lista de macros complexas ........................................................................................ 13
 B. Lista de Parâmetros ................................................................................................ 13
1.1 Introdução ......................................................................................................................... 14
Técnicas de Programação de Peças ........................................................................................ 15
Programação Convencional de Peças ..................................................................................... 15
Programação de parte conversacional.................................................................................... 16
Programação de peças usando o software CAM .................................................................... 16
Versão de controle. ................................................................................................................. 17
Programação macro ................................................................................................................ 17
Comparação entre os quatro métodos ................................................................................... 17
l.2 Determinadas Aplicações da Programação Macro ............................................................ 17
Movimentos Complexos.......................................................................................................... 18
Famílias de Peças .................................................................................................................... 18
Ciclos fixos personalizados ...................................................................................................... 19
O mesmo exercício teria ......................................................................................................... 20
Programas "inteligentes" ........................................................................................................ 20
Sondagem................................................................................................................................ 21
Informações de status da máquina / manipulação................................................................. 21
l.3 Minha máquina tem capacidade de macro? ...................................................................... 21
1.5 Como usar este livro.......................................................................................................... 23
2.1 Variáveis e Expressões ...................................................................................................... 24
2.2 Expressões Macro ............................................................................................................. 24
Exemplos: ................................................................................................................................ 25
Exemplos: ................................................................................................................................ 25
Exemplos: ................................................................................................................................ 25
2.3 Atribuindo um valor a uma variável ............................................................................. 27
Exemplos: ................................................................................................................................ 29
2.5 Valores reais versus números inteiros .............................................................................. 30
Por exemplo, ........................................................................................................................... 33
2.6 Variáveis Indefinidas ......................................................................................................... 33
2. 7 Um uso simples dos recursos de programação de macros .............................................. 35
2.8 Retendo Programas no Modo MDI ................................................................................... 35
Tipos de Variáveis.................................................................................................................... 36
3.l Variáveis locais e Globais ................................................................................................... 36
Programa principal .................................................................................................................. 36
3.2 Efeito da reinicialização do sistema em variáveis de macro ............................................. 37
3.3 Níveis de Variáveis locais .................................................................................................. 38
Programa principal .................................................................................................................. 39
Aninhamento de macros até um máximo de quatro níveis é permitido. ............................... 40
3.4 Faixa de Valores Armazenados em Variáveis .................................................................... 45
Sinais de Interface ................................................................................................................... 47
Exemplo: .................................................................................................................................. 56
Pausa de Execução .................................................................................................................. 59
Funções Macro ........................................................................................................................ 66
4.1 Tipos de Funções Macro.................................................................................................... 66
Aninhamento de Suportes ...................................................................................................... 68
Operaçoes aritimeticas ........................................................................................................... 68
4.3 Funções trigonométricas ................................................................................................... 69
4.4 Funções de arredondamento ............................................................................................ 72
ROUND, FIX e FUP ................................................................................................................... 73
4.5 Funções Diversas ............................................................................................................... 76
SQRT ........................................................................................................................................ 76
Exemplos: ................................................................................................................................ 76
ABS .......................................................................................................................................... 76
lN ............................................................................................................................................. 77
log x ......................................................................................................................................... 77
EXP........................................................................................................................................... 77
Exemplos: ................................................................................................................................ 78
Expoente Arbitrário de um Número ....................................................................................... 78
4.6 Funções lógicas.................................................................................................................. 78
Funções bit a bit ...................................................................................................................... 78
Funções bit a bit ...................................................................................................................... 78
Funções booleanas .................................................................................................................. 80
4. 7 Funções de Conversão...................................................................................................... 83
Formato: .................................................................................................................................. 84
Exemplos: ................................................................................................................................ 84
Ramos e loops ......................................................................................................................... 86
5.l Ramificações Incondicionais............................................................................................... 86
08000 (SUMMAÇÃO DE NÚMEROS); ...................................................................................... 90
0800l (lIMPEZA DE TODAS AS COMUNIDADES PERMANENTES);............................................ 93
08002 (CÁlCUlO DE DESVIO PADRÃO); ........................................................................ 95
5.4 - Execução em um loop ................................................................................................... 102
08005 (APAGAR VARS COM USAR WHILE); ........................................................................... 107
5.5 Operações Aritméticas em Números Variáveis Macro ................................................... 112
08007 (CÁlCUlO DE MARCAS AGREGADAS); ......................................................................... 114
Métodos de Mudança Zero ................................................................................................... 115
Sistema de Coordenadas da Máquina................................................................................... 116
G54-G59, G54.l Sistemas de coordenadas de peças Pl-P48 .................................................. 117
08008 (CURR WCS DATUM SHIFT no moinho M / C); ........................................................... 121
08009 (CURR WCS Z-DATUM SHIFT NO TORNO); ................................................................. 123
5.6 Instrução WHILE aninhada .............................................................................................. 124
080l2 (MOlA DE FURO USANDO UM CIClO EM CANA); ........................................................ 125
CAPÍTULO 6 Revisão de Subprogramas ................................................................................. 130
Introduções ........................................................................................................................... 130
O que é um subprograma?.................................................................................................... 130
Por que é usado? ................................................................................................................... 130
Subprogramas versus sub-rotinas de uma linguagem convencional de computador. ......... 130
6.2 Chamada do Subprograma .............................................................................................. 131
0000l; (Programa número l) .................................................................................................. 132
00002; (Programa número 2) ................................................................................................ 133
00003; (Programa número 3) ................................................................................................ 134
00004; (Programa número 4) ................................................................................................ 134
00005; (Programa número 5) ................................................................................................ 135
00006; (Programa número 6) ................................................................................................ 135
00007; (Programa número 7) ................................................................................................ 136
00008; (Programa número 8) ................................................................................................ 137
(Programa de chamada) ........................................................................................................ 139
6.4 Assentamento do Subprograma ..................................................................................... 141
00010; (Programa número 10) .............................................................................................. 143
00011; (Programa número 11) .............................................................................................. 143
Chamada Macro .................................................................................................................... 144
7.1 Introdução ....................................................................................................................... 144
7.2 Macro versus Subprograma ............................................................................................ 145
7.3 Chamada Macro .............................................................................................................. 145
00013; (Programa número 13) .............................................................................................. 147
00014; (Programa número 14) .............................................................................................. 148
00015; (Programa número 15) .............................................................................................. 148
00016; (Programa número 16) .............................................................................................. 149
Chamada Modal (G66) .......................................................................................................... 150
Chamada única de uma macro com G66: ............................................................................. 151
Chamada repetida de uma macro com G66: ........................................................................ 151
Chamada macro com vários blocos G66: .............................................................................. 152
Comentários adicionais: ........................................................................................................ 152
Chamada com o código G definido pelo usuário .................................................................. 153
Chamada com o código M definido pelo usuário ................................................................. 155
7.4 Chamada do Subprograma sem usar o M98 / M198 ...................................................... 156
Chamada do Subprograma Usando um Código M ................................................................ 156
09001; (O número do programa correspondente ao parâmetro número 6071, conforme
Tabela 7.3) ............................................................................................................................. 158
Chamada do Subprograma Usando um Código T ................................................................. 158
09000;(O número do programa permitido para chamar um subprograma, usando um
código-T)................................................................................................................................ 159
7.5 Especificação de Argumento ........................................................................................... 160
Especificação de Argumento I ............................................................................................... 160
Especificação de Argumento II .............................................................................................. 161
Especificação de Argumento Misto ....................................................................................... 163
09011 (REDEFINAS G01 NA MÁQUINA DE FRESAMENTO); .................................................. 166
09012 (REDEFINAS G01 EM TORNO);.................................................................................... 169
7.6 Processamento de declarações macro............................................................................ 172
O que é buffer? ..................................................................................................................... 172
Quantos blocos são armazenados? ....................................................................................... 172
Quando os blocos com buffer são processados? .................................................................. 172
Processamento no modo de compensação de raio (caso 1) ................................................ 173
Efeito do buffer de instruções macro na execução do programa......................................... 175
Movimento complexo Geração ............................................................................................. 176
8.1 Introdução ....................................................................................................................... 176
8.2 Arco com Raio de Variação Uniforme ............................................................................. 176
08014 (ARCO COM RAIO VARIÁVEL); .................................................................................... 180
8.3 Interpolação Helicoidal com Raio Variável...................................................................... 185
8.4 Torneamento Parabólico ................................................................................................. 192
8.5 Transformando uma curva de seno ................................................................................ 198
Paramétrica Programação..................................................................................................... 202
9.1 Introduction..................................................................................................................... 202
9.2 Pino do Localizador ......................................................................................................... 203
9.3 Bolt Holes on a Flange ..................................................................................................... 210
Personalizado em lata Ciclos ................................................................................................. 216
10.1 Introdução ..................................................................................................................... 216
10.2 Perfuração Profunda em um Torno Mecha .................................................................. 217
10.3 Perfuração com Comprimentos Reduzidos de Peck em um ......................................... 224
Fresadora............................................................................................................................... 224
Sondagem.............................................................................................................................. 232
11.1 Introdução ..................................................................................................................... 232
11.2 Função de pulo em uma máquina CNC ......................................................................... 233
11.3 Sondando um bolso....................................................................................................... 233
11.4 localizando o centro de um furo ................................................................................... 237
08022 (LOCATING HOLE CENTER ON MILL); ......................................................................... 239
11.5 Encontrando o Ângulo de uma Borda ........................................................................... 240
11.6 Ajustando o Desvio de Desgaste ................................................................................... 242
O algoritmo para a macro 0 8023 é simples: ........................................................................ 243
08023 (WEAR OFFSET CORRECTION ON LATHE); .................................................................. 243
Comunicação com Dispositivos Externos .............................................................................. 246
12.1 Introdução ..................................................................................................................... 246
12.2 Princípio de Comutação ................................................................................................ 246
12.3 Tipos de Entrada e Fiação ............................................................................................. 248
12.4 Atribuição do Pino do Conector .................................................................................... 249
12.5 Sensores discretos para entradas de PLC de Sourcing / Sinking ................................... 254
12.6 Tipos de Saída e Fiação ................................................................................................. 256
Entrada de dados programável ............................................................................................. 260
13.1 Introdução ..................................................................................................................... 260
13.2 Entrada de Dados para Distâncias de WCS Offset ........................................................ 261
13.3 Entrada de Dados para Distâncias Adicionais de WCS Offset ....................................... 262
13.4 Entrada de Dados para Valores de Compensação em uma Fresadora ......................... 263
13.5 Entrada de dados para valores de compensação em um torno ................................... 265
Nota: ...................................................................................................................................... 269
13.6 Entrada de dados para valores de parâmetros ............................................................. 269
Onde ...................................................................................................................................... 271
NOTA: .................................................................................................................................... 271
Exemplo 1 (parâmetro do tipo de palavra): .......................................................................... 271
Exemplo 3 (parâmetro do tipo byte):.................................................................................... 272
Exemplo 5 (Parâmetro Bit-Axis-Type): .................................................................................. 273

Tabela Expandida de Conteúdos

 Sobre o autor
 B. Prefácio

1. Introdução

 Técnicas de programação de peças


 Certos aplicativos de programação macro
 Minha máquina tem capacidade de macro?
 Objetivo do texto atual
 Como usar este livro

2. Variáveis e Expressões

 Variáveis de macro
 Expressões macro
 Atribuindo um valor a uma variável
 Exibição de variáveis
 Valores reais versus valores inteiros
 Variáveis Indefinidas
 Um uso simples dos recursos de programação de macros
 Retendo programas no modo MDI

3. Tipos de Variáveis

 Variáveis locais e globais


 Efeito da redefinição do sistema nas variáveis de macro
 Níveis de Variáveis Locais
 Intervalo de valores armazenados em variáveis
 Variáveis do sistema
4. Funções Macro

 Tipos de funções de macro


 Operações aritméticas
 Funções trigonométricas
 Funções de arredondamento
 Funções diversas
 Funções lógicas
 Funções de Conversão

5. Filiais e Loops

 Bran Ramificação Incondicional


 Bran Ramificação condicional
 Execução condicional de uma única declaração macro
 Execução em um loop
 Operações aritméticas em números variáveis macro
 Declaração WHILE aninhada

6. Revisão de Subprogramas

 Introdução
 Chamada de Subprograma
 Chamada Múltipla de um Subprograma
 Nest Aninhamento de subprograma

7. Chamada Macro

 Introdução
 Macro versus Subprograma
 Chamada Macro
 Chamada de subprograma sem usar o M98 / M198
 Especificação de Argumento
 Processamento de declarações macro

8. Geração Complexa de Movimento

 o Introdução
 o Arco com Raio de Variação Uniforme
 Interpolação Helicoidal com Raio Variável
 o giro parabólico
 o Transformando uma curva de seno

9. Programação Paramétrica
 Introdução
 Pin Locator
 Parafusos de fixação em uma flange

10. Ciclos Enlatados Personalizados

 Introdução
 P Furação profunda em um torno
 Perfuração com redução de comprimentos de peck em uma fresadora

11. sondagem

 Introdução
 Pular a função em uma máquina CNC
 Sondando um bolso
 Encontrando Centro de um Buraco
 Encontrando o ângulo de uma borda
 Ajuste do Desgaste do Desgaste

12. Comunicação com Dispositivos Externos

 Introdução
 Princípio de Comutação
 Tipos de entrada e fiação
 Atribuição de pinos do conector
 Sensores discretos para insumos de Sourcing / Sinking PLC
 Tipos de saída e fiação

13. Entrada de Dados Programável

 Introdução
 Entrada de Dados para Distâncias de WCS Offset
 Entrada de dados para distâncias adicionais do WCS
 Entrada de dados para valores de compensação em uma fresadora
 Entrada de dados para valores de compensação em um torno
 Entrada de dados para valores de parâmetro

 Lista de macros complexas

 B. Lista de Parâmetros
CAPITULO 1
1.1 Introdução

O controle numérico é uma aplicação da tecnologia digital para controlar uma


máquina ferramenta acionando vários motores de acionamento, relés, etc. por
uma série de instruções codificadas, chamadas programas de peça. Estas
máquinas foram inicialmente chamadas de numericamente controladas (NC)
máquinas. A tecnologia NC foi disponibilizada comercialmente em meados
l950s. Mais tarde, conforme a tecnologia avançava, um computador foi feito
parte integrante da máquina, e a maioria das funções da máquina foram
controlados através de software, em vez de hardware dedicado para cada
função. Tais máquinas foram chamadas de controle numérico de computador
Máquinas CNC. Máquinas NC não são mais fabricadas, embora ainda usemos
esse termo para se referir a essa tecnologia.
Devido à excelente precisão, repetibilidade e vários outros inigualáveis e
características exóticas, as máquinas CNC têm agora virtualmente substituiu
completamente as máquinas manuais na fabricação industrial. Até mesmo
pequenas unidades fabris estão usando agora máquinas, porque estas provam
ser mais baratas em longo prazo. De fato, "por que CNC?" Não é de todo um
tópico de discussão nos dias de hoje. No entanto, como acontece com
qualquer outro aplicativo de computador, é imperativo desenvolver programas
bons e eficientes para explorar todo o potencial de Máquinas CNC.
Infelizmente, há falta de treinamento adequado mão de obra nesta área. A
principal razão é que o antigo currículo de faculdades de engenharia /
politécnicos não lida com programação CNC em detalhe. Além disso, se você é
um engenheiro praticante, você pode ter percebido que as poucas pessoas na
indústria que realmente têm bom conhecimento de programação não estão
muito dispostas a compartilhar conhecimento e experiência com os outros, por
razões óbvias! E, aprender sozinho não é tão fácil, especialmente se o assunto
é complexo e as informações estão disponíveis de forma dispersa. Para
atender a esta necessidade, um número de treinamento comercial CNC
escolas surgiram recentemente. No entanto, a maioria deles fornece apenas
treinamento básico em CNC. O treinamento avançado em CNC é fornecido por
poucas escolas de formação em todo o mundo. Mesmo os livros relevantes,
apresentados em um estilo de livro de texto independente, não estão
disponíveis. E, manuais / manuais são principalmente úteis apenas para
referência, quando quer ver uma descrição detalhada de algum recurso
específico. Este dificulta a aprendizagem por auto estudo, especialmente para
um recém-chegado que nem sabe como começar. De fato, se você quiser
dominar um complexo assunto, para o qual você é completamente novo, por
conta própria, a primeira coisa que você precisa saber é como começar a
aprender. E se você falhar escolha o caminho certo, muito em breve o assunto
aparecerá de forma frustrante complexo e chato. Então, uma abordagem
metódica e passo a passo é extremamente importante. Este livro visa atender a
essa necessidade. Se você tem algum básico conhecimento de programação e
operação de máquinas CNC, este livro irá ajuda ló a aprender as
características avançadas do CNC máquinas, recursos que você pode nem ter
ouvido falar. E o mais importante é que, o livro é projetado de tal maneira que
você vai aprender por conta própria! Vamos primeiro discutir as várias técnicas
de programação de peças, e suas áreas de aplicação. Isto será seguido por
uma discussão de uma técnica de programação avançada que adiciona uma
nova dimensão à programação CNC convencional. Os restantes capítulos do
livro são dedicados a uma descrição detalhada desta técnica.

Técnicas de Programação de Peças

Uma máquina CNC é tão boa quanto os programas de peça usados para
usinagem. O papel do operador da máquina é geralmente limitado à fixação e
desencaixe da peça de trabalho, para o qual mesmo um trabalhador seria bom
o suficiente. A qualidade e eficiência de a produção dependem principalmente
da habilidade de programação do programador. O programador não precisa ser
um maquinista especialista, mas ele deve ter um bom conhecimento das
práticas de chão de fábrica. Além do que, além do mais, ele deve conhecer os
recursos de controle disponíveis de sua máquina. Isto é só então, programas
de peças eficientes, produzindo bons resultados, podem ser desenvolvidos.
Uma máquina CNC funciona como um "escravo obediente" fazendo
exatamente o que é instruído a fazer, de uma maneira muito precisa. Assim,
uma máquina CNC valeria o seu nome, somente se as instruções dadas a ele,
através dos programas de peça, oferecer a melhor solução para executar uma
determinada tarefa. De um modo geral, existem quatro maneiras diferentes de
preparar programas, descritos em breve nas seções seguintes.

Programação Convencional de Peças

Programação convencional de peças, que é um simples código G / M


programação, sofre de várias limitações e tem escopo limitado. Se for
necessário usinar somente tipos limitados de peças de trabalho em uma rotina
maneira, sem se preocupar muito com a eficiência da produção atividade, a
programação convencional de peças seria geralmente adequada. A limitação
da programação convencional é que ela não permite o uso de variáveis,
operações matemáticas, funções, instruções lógicas, looping e similares em um
programa. Em outras palavras, ele não tem nem mesmo os recursos básicos
de uma linguagem de computador típica como PASCAL. É apenas um
programa de tipo rígido para um determinado requerimento. Isso obviamente
limita o escopo dos programas a uma grande extensão. Não é possível
escrever um programa de peça "inteligente" com lógica interna para diferentes
requisitos. De fato, como veremos mais adiante, há um número de aplicações
onde a programação de parte convencional não pode ser usada. Só serve ao
propósito limitado pelo qual foi designado.

Programação de parte conversacional

Até mesmo a programação convencional de peças é bastante complexa.


Então, para o objetivo de simplificar a programação para certas aplicações
comuns, programação de conversação ou lead-through (referida como
programação de impressão ou programação de dimensão direta) foi
introduzida, que permite aos usuários até mesmo sem ter programação
adequada experiência, desenvolva facilmente programas de peças adequadas.
O programador não precisa conhecer a linguagem de programação de peças
em detalhes; ele só tem para saber o que deve ser feito em que sequência, e
com que corte parâmetros. O controle pede a ele todas as informações
necessárias, de uma maneira interativa. Este método de programação, no
entanto, sofre com a limitação inerente de ser aplicável apenas a certas
geometrias específicas. Então, mesmo que seja possível rapidamente escrever
programas eficientes para algumas aplicações comuns, este método é inútil
para requisitos especiais. Na realidade, a programação conversacional é
apenas um pequeno subconjunto do que pode ser feito com parte programação
técnica. Na verdade, a programação de conversação é não significou para
engenheiros qualificados.

Programação de peças usando o software CAM

Contanto que apenas dois eixos de uma máquina devam ser simultaneamente
controlados (incluindo a interpolação helicoidal), que geralmente o caso na
maioria das aplicações práticas, é possível escrever programas de peças
adequados manualmente, a menos que a geometria esteja fora do padrão, por
exemplo, envolvendo um segmento parabólico. Para não padrão e / ou
geometrias tridimensionais, como usinagem de matrizes, manual
desenvolvimento de programas de peças pode se tornar muito entediante ou
mesmo impossível em certos casos. Vários softwares CAM foram
desenvolvidos, que geram o percurso necessário para a usinagem desejada, e
preparar automaticamente um programa de peças para atender às
necessidades selecionadas.
Versão de controle.

No entanto, o objetivo básico do software CAM é calcular o que não pode ser
calculado manualmente (por exemplo, o caminho da ferramenta para uma
usinagem do eixo S, onde é desejável manter sempre o eixo da ferramenta
perpendicular à superfície que está usinando). Então, mesmo que pode gerar
um caminho de ferramenta complexo e fornece algumas informações como
tempo de usinagem, verificação de interferências, etc., isso é tudo isso pode
fazer. De um modo geral, não adiciona recursos adicionais para programação
de peças convencionais. A diferença entre convencional programação de
peças e programação de peças assistida por computador é muito parecido com
a diferença entre cálculos aritméticos manuais e cálculos usando uma
calculadora. Assim, o software CAM é útil apenas para a finalidade para a qual
foi projetado. Não oferece fabricação total solução. Existem requisitos, como
veremos mais adiante, para os quais se torna simplesmente inútil.

Programação macro

Nos anos 90, os recursos básicos das linguagens de alto nível eram
incorporados na linguagem de programação de peças convencionais. A nova
linguagem de programação foi chamada de programação macro, os recursos
dos quais se assemelham a linguagem de computador BASIC. Sobre nos anos,
a programação macro tem visto um desenvolvimento constante. Isto é agora
bastante avançado, exceto que caracteres alfanuméricos ainda não serem
usados como nomes de variáveis, entre outras limitações. Macro programação,
como verá mais adiante, mudou completamente a maneira Máquinas CNC são
programadas nos dias de hoje, abrindo possibilidades infinitas, limitado apenas
pela imaginação do programador.

Comparação entre os quatro métodos

Cada uma das quatro maneiras de preparar programas de peça tem sua
própria área de aplicação, atendendo ao seu propósito específico. Qualquer
comparação entre isto é assim sem sentido. A programação macro, no entanto,
oferece várias ferramentas para aumentar a produtividade, o que não é
possível com qualquer dos outros três métodos. A ênfase hoje não é apenas na
automação, para aumentar a produtividade; é também em automação flexível,
de modo a responder rapidamente aos requisitos de mercado que mudam
rapidamente. Macro programação pode tornar os programas de parte tão
flexível com built-in lógica que o mesmo programa pode ser usado para
diferente usinagem requisitos. Além disso, em muitos casos, uma máquina
CNC pode ser programada tomar a sua própria decisão em diferentes
situações, sem qualquer intervenção do operador. Tudo isso resulta em
incomparável aprimoramento de produtividade.

l.2 Determinadas Aplicações da Programação Macro


Muitas unidades fabris têm excelentes aplicações para programação de
macros, mas nem sequer estão conscientes desse fato. E, se alguém não sabe
que há um aplicativo para algo, nunca se considerará aprendê-lo, muito menos
usá-lo! Na verdade, a maioria das máquinas CNC modernas tem essa
capacidade como um recurso embutido (opcional em algumas máquinas), mas
muitos usuários nem sabem disso. No mundo atual da concorrência feroz, não
se pode realmente ignorar totalmente uma característica tão poderosa das
máquinas CNC. Dadas as melhorias que esse tipo de programação traz, é
surpreendente que a maioria dos construtores de máquinas-ferramenta (MTB),
fabricantes de controle e até mesmo escolas de treinamento comercial não
digam muito sobre isso. As principais áreas de aplicação da programação de
macros são discutidas nas seções a seguir.

Movimentos Complexos

A maioria dos controles CNC fornece apenas movimentos lineares e circulares.


Como resultado, não é possível, por exemplo, fazer o giro parabólico em um
torno ou cortar um sulco elíptico em uma fresadora. Para tais aplicações, é
necessário obter ajuda de alguma linguagem de programação externa para
gerar o caminho da ferramenta, como uma cadeia de segmentos de linha reta
muito pequenos, unidos sequencialmente por interpolação linear (G01). A outra
maneira seria usar o software CAM. No entanto, a programação macro, que
possui todas as características relevantes de uma linguagem de programação
de alto nível, nos permite gerar facilmente qualquer tipo de movimento
complexo para o qual estão disponíveis equações matemáticas. Também
elimina o problema de carregar na memória RAM do CNC, o arquivo
extremamente grande gerado pelo programa de computador externo ou o
software CAM, que às vezes faz da programação macro uma opção muito
melhor. Embora a programação macro não possa substituir completamente o
software CAM, certamente pode fazer muitas coisas que podem não ser
possíveis sem o uso do software CAM.

Famílias de Peças

Quase todas as empresas têm alguns aplicativos que se encaixam nessa


categoria. O tempo de programação parcial pode ser reduzido desenvolvendo
programas paramétricos para famílias de peças. Um exemplo é a perfuração
de parafusos em um flange. Embora todos os flanges possam pertencer à
mesma família em virtude da similaridade no design e no método de produção,
eles podem ser realmente diferentes. Por exemplo, o número de furos, a
profundidade dos furos (isto é, a espessura do flange) e o diâmetro do círculo
de passo podem ser diferentes em flanges diferentes. Mesmo os materiais da
peça de trabalho podem ser diferentes, exigindo diferentes taxas de
alimentação e rpm. Essas diferenças também podem exigir o uso de diferentes
ciclos de usinagem (G8l, G82, etc.) em diferentes flanges. Isto significa que,
embora os métodos de usinagem para todos os flanges são essencialmente os
mesmos, todos os programas seriam um pouco diferentes. No entanto, um
único programa, usando os recursos de programação de macro, faria o
trabalho. Nós só temos que identificar as entidades variáveis e escrever um
programa com essas entidades como variáveis definidas no início do programa.
Também é possível definir uma sub-rotina, com as variáveis como seus
argumentos. Para um flange particular, o programa principal (isto é, o programa
no nível mais superior em programas aninhados) pode simplesmente chamar a
sub-rotina, com os valores desejados para seus argumentos. A sub-rotina seria
executada com os valores especificados para as quantidades variáveis. A
metodologia de programação é muito similar àquela em qualquer linguagem de
computador de alto nível. A principal diferença está na maneira como as
variáveis são designadas. Observe que uma sub-rotina chamada sem uma lista
de argumentos é chamada de subprograma, WHILE que, se for chamada com
uma lista de argumentos, é chamada de programa de macro (ou,
simplesmente, um macro). Um macro incorporado, que é disponibilizada na
máquina pelo construtor de máquinas-ferramenta, é chamado de macro de
máquina e uma macro definida pelo usuário é referida como um macro. Os
subprogramas são chamados pelo M98 (o que não permite uma lista de
argumentos), WHILE os macros são chamados pelo G65 ou pelo G66 (que
permitem uma lista de argumentos). Note que G65 / G66 não precisa
necessariamente ter uma lista de argumentos (embora seja uma possibilidade
rara). Um macro é projetado para ser chamada com uma lista de argumentos.
Um subprograma, por outro lado, é projetado para ser chamado sem uma lista
de argumentos. O mesmo programa se comporta como um subprograma se for
chamado pelo M98, enquanto se comporta como um macro se for chamado por
G65 ou G66 (com ou sem uma lista de argumentos). A diferença entre um
subprograma e um macro é explicada em detalhes no Chaps. 6 e 7. O uso de
um macro para uma família de peças é geralmente chamado de programação
paramétrica; os argumentos do macro são os parâmetros que definem a função
específica do macro. Aqui, o termo "parâmetro" é usado no sentido
matemático. Não está nem remotamente relacionado aos parâmetros de
controle, que definem as configurações padrão da máquina. Os parâmetros de
controle também são chamados de parâmetros do sistema, parâmetros CNC /
PMC, parâmetros da máquina ou simplesmente, parâmetros. Também é
possível definir um novo G-eode (digamos, GlOO) ou um novo Mcode
(digamos, MlOO), correspondente a um macro. Então, esse macro também
pode ser chamado pelos códigos G ou M definidos. De fato, os novos códigos
ficam disponíveis para todos os programas daquela máquina em particular, e
todos os programadores podem usá-los. Isso simplifica a programação, pois os
programadores nem precisam saber como chamar uma macro; eles só
precisam saber como usar os novos códigos que se tornam semelhantes aos
códigos G / M comuns. Naturalmente, um programador especialista tem que
desenvolver os novos códigos inicialmente.

Ciclos fixos personalizados

As máquinas CNC são equipadas com um grande número de ciclos fixos para
diferentes requisitos de usinagem, o que simplifica a programação em grande
medida. Por exemplo, se alguém tiver que gerar um caminho de ferramenta G7l
(ciclo de torneamento múltiplo) usando GOO e GOl, seria proibitivamente
complexo e demorado devido ao enorme número de cálculos matemáticos
envolvidos.

O mesmo exercício teria

Introdução a ser repetida para cada trabalho com uma geometria diferente.
Mas o G7l é apenas um código de duas linhas, para todas as geometrias.
No entanto, uma situação pode surgir quando nenhum ciclo fixo predefinido
seria bastante adequado para uma aplicação específica. Por exemplo, se um
furo muito profundo deve ser perfurado, pode ser desejável reduzir
progressivamente o comprimento do beck nas bicadas subsequentes, para
permitir que os cavacos saiam facilmente do buraco, especialmente quando a
ferramenta estiver dentro do buraco. Esse ciclo fixo não está disponível em
nenhuma máquina CNC. Todos os ciclos de perfuração de peck usam um
comprimento de pica uniforme em toda a profundidade do furo (exceto o último
passo, que é ajustado para se adequar à profundidade do furo).
No entanto, usando a técnica de programação de macros, é possível escrever
um programa com tamanho variável (conforme a lógica definida pelo usuário)
e, como mencionado anteriormente, também é possível definir um novo G-eode
para esse programa, que pode, então, ser muito convenientemente usado da
maneira que um ciclo fixo embutido é usado. O desenvolvimento de novos
ciclos fixos personaliza máquinas CNC, conforme as necessidades individuais.

Programas "inteligentes"

A programação de macros permite o uso de instruções condicionais


(IF_THEN,) a serem usadas com operadores condicionais (igual a, diferente de
menor que, menor que ou igual a, maior que, e maior que ou igual a),
operadores lógicos (AND, OR e XOR), ramificação condicional e incondicional
(IF _GOTO e GOTO) e loops (WHIlE_DO_END), além das funções
matemáticas e trigonométricas usuais. Isso permite que o programador escreva
um programa "inteligente" que tomará certas decisões automaticamente com
base em certas condições de entrada. Por exemplo, se a profundidade de corte
especificada for muito grande, a máquina pode ser programada para selecionar
automaticamente uma ferramenta de desbaste. Da mesma forma, o ciclo de
perfuração apropriado pode ser selecionado automaticamente pela máquina,
dependendo dos parâmetros do furo. As possibilidades são ilimitadas.
Praticamente qualquer lógica que você pode pensar pode ser incorporada em
um programa de macro, e então você não precisa se preocupar com uma
situação do tipo "e se". A máquina sabe o que deve fazer situações
específicas. Também é possível inserir traps de erros em um programa.
Sob determinadas condições especificadas, a máquina pausará ou abortará
automaticamente a execução de um programa e exibirá a mensagem de erro
programada. Após a ação corretiva ser executada pelo operador, o programa
pausado pode ser retomado a partir desse ponto pressionando o botão CYClE
START novamente. Tudo isso torna o programa bastante flexível, o que
melhora a qualidade de usinagem e a produtividade, um passo importante para
a automação flexível.
Sondagem

A sondagem em uma máquina CNC tem várias vantagens, porque os


resultados da inspeção estão imediatamente disponíveis, com uma pequena
fração do custo de ter uma instalação CMM separada. Há, no entanto, uma
percepção geral de que, como a máquina é muito precisa, não há necessidade
de medir as dimensões obtidas. Esta é uma visão muito otimista. A ferramenta
pode se desgastar em uma extensão inaceitável, ou pode até quebrar. Se as
dimensões críticas não forem verificadas pelo menos ocasionalmente, um lote
grande de peças defeituosas pode ser produzido antes de perceber o
problema. O escopo da sondagem não se limita a apenas medir certas
dimensões de uma peça ou inspecionar as ferramentas para fins de controle de
qualidade. Também é possível reduzir drasticamente o tempo de configuração
automatizando o procedimento de configuração de correção da ferramenta.
Isso é extremamente útil se a inicial tamanho de diferentes peças de trabalho
não são exatamente iguais, o que requer que o procedimento de ajuste de
offset seja repetido para cada nova peça de trabalho. A sondagem também
elimina a necessidade de equipamentos extremamente precisos, que são
caros. Qualquer imprecisão no aperto da peça de trabalho pode ser medida
pela sonda, e a lógica corretiva pode ser dada no programa. No curso da
usinagem, a máquina pode ser programada para tomar automaticamente
certas decisões com base nos resultados da medição. Tudo isso leva a uma
melhor qualidade e aumenta a produtividade a um custo menor. No entanto, a
análise não seria possível, a menos que a máquina tenha capacidade de
programação de macros.

Informações de status da máquina / manipulação

Muitas vezes é desejável conhecer as condições de controle de uma máquina,


tais como distâncias de deslocamento, a posição atual da ferramenta, a
velocidade atual do fuso / avanço / número da ferramenta, os códigos modais
ativos dos vários grupos de G-eodes (por exemplo, se G90 ou G9l do Grupo 3
está ativo em um lembre-se que em cada grupo de G-eodes, exceto aqueles
pertencentes ao Grupo 0 que são códigos não modais, um código permanece
ativo até ser substituído por outro código do mesmo grupo.) O número de
peças produzidas, a data / hora atual, o tempo incremental de operação da
máquina, etc. Tais dados são disponibilizados através de um número de
variáveis do sistema (descritas em detalhes no Capítulo 3), que podem ser
usadas em um programa, para tomar certas decisões. Também é possível
obter a impressão de tais dados em uma impressora conectada à máquina.
Algumas dessas variáveis, como a variável para armazenar a posição atual da
ferramenta, são tipos somente leitura que não pode ser modificado. Outras
variáveis, como aquelas para distâncias de deslocamento, podem ser
modificadas através do programa, para alterar o comportamento da máquina.
Tal comunicação com a máquina, para conhecer ou alterar seu status de
controle, é possível somente através do recurso de programação de macro.

l.3 Minha máquina tem capacidade de macro?


Esta é a questão mais pertinente neste estágio, porque, a menos que a
máquina na qual se trabalha tenha capacidade de macro, não faz sentido
aprender programação de macros. Embora a programação de macros tenha se
tornado um recurso padrão na maioria dos controles, ela ainda é um recurso
opcional em alguns. Portanto, se uma nova máquina for adquirida, esse
recurso deve ser mencionado nas especificações. Em uma máquina existente,
execute alguma declaração de macro para testar se a máquina tem esta opção
ativada, da seguinte maneira:

• Defina as condições adequadas para usinagem (bomba hidráulica ON,


unidades de alimentação habilitadas, rotação do eixo ativada, cabeçote móvel
estendido, mandril fechado e porta fechada).
• Selecione o modo de entrada manual de dados (MDI), usando a chave
seletora no painel do operador da máquina (MOP).
• Pressione a tecla de função PROG no painel MDI. Se um espaço em branco a
tela do programa não aparecer, pressione PROG novamente. As telas em
branco.

00000
%
• Digite # l = l (ou qualquer outro macro "inofensivo", de modo a não causar
nenhum comportamento inesperado da máquina), seguido por o caractere de
fim de bloco (EOB) (que é um ponto-e-vírgula) e em seguida, pressione a tecla
INSERT, no painel MDI.

• Pressione o botão CYClE START no MOP.


Isso atribuirá um valor de l à variável de macro número l. Se nenhuma
mensagem de erro vier, a máquina possui capacidade de programação de
macro com funcionalidade completa (os fabricantes de controle não ativam
esse recurso com funcionalidade parcial; ele estará disponível ou não
disponível). Para ter certeza, verifique o valor da variável de macro definida na
tela de configuração do deslocamento I:

• Pressione a tecla de função OFSI SET no painel MDI.


• Pressione a tecla de extensão direita (~) abaixo da tela, se a tecla MACRO
não aparece. Agora pressione o MACRO tecla de função.

Isso mostrará, em uma tela de rolagem (isto é, a primeira linha reaparece


depois da última linha, na rolagem para frente), os valores armazenados em
todas as variáveis macro (00l a 033, l00 a l99 e 500 a 999, normalmente), que
podem ser visualizados usando as teclas de seta para cima e para baixo Eu
abro as teclas no painel MDI. O valor armazenado na variável número 00l (que
é o mesmo que a variável número l) seria exibido como 0000l.000 (os valores
são armazenados usando oito dígitos), com campos em branco para as
variáveis restantes (um campo em branco indica uma variável indefinida),
exceto talvez aqueles na faixa de 500 a 999, que retêm os valores
armazenados, mesmo após desligar. Essas variáveis, que são chamadas
variáveis comuns permanentes, podem, no entanto, ser redefinidas. Pressionar
a tecla RESET irá limpar todas as variáveis, exceto as variáveis comuns
permanentes. Uma configuração de parâmetro, no entanto, pode reter os
valores de todas as variáveis, mesmo após a operação RESET. Diferentes
tipos de variáveis são descritos em detalhes no Capítulo. 3. Se a máquina não
tiver o recurso de macro, ela não reconhecerá a instrução de macro e
apresentará uma mensagem de erro. Nesse caso, a empresa cujo controle está
instalado na máquina (como Fanuc, Siemens, Heidenhain, etc.) deve ser
contatada. Eles ativarão essa opção na máquina por uma taxa. É interessante
notar que o hardware eletrônico de uma determinada versão de controle é o
mesmo para todas as máquinas nas quais os recursos padrão sempre
permanecem disponíveis. Mas os fabricantes de controle permitem (através de
codificação de software) apenas os recursos opcionais pelos quais recebem
pagamento adicional. Portanto, não se preocupe se sua máquina não estiver
habilitada para macro, apenas esteja disposta a pagar por ela. No entanto,
controles não padrão normalmente não possuem capacidade de macro.

1.5 Como usar este livro

Este livro é escrito em estilo de livro didático. Ele é projetado para ser lido
sequencialmente, do começo ao fim. Prossiga mais sem pular nenhum capítulo
ou seção (a menos que seja sugerido de outra forma), porque isso pode causar
dificuldades na compreensão de certos conceitos discutidos posteriormente. A
programação de macros é uma linguagem típica de programação de alto nível
que precisa ser aprendida passo a passo e completamente. Quanto mais
lentamente você se mover, mais rápido você chegará ao seu destino, porque
um conhecimento superficial de qualquer linguagem de programação pode
causar problemas a qualquer momento, e você pode nem ser capaz de
descobrir seus erros. Uma leitura simples, no entanto, não será suficiente,
porque não é possível lembrar-se de tudo, a menos que seja praticado com
rigor. Então, na medida do possível, os leitores devem verificar todas as
declarações de programação em suas máquinas. Por exemplo, se for
declarado que # 0,5 é equivalente a # l, pode ser testado executando um
programa de uma linha, # 0.5 = l; que deve atribuir um valor de l à variável # l.
Instruções simples também podem ser verificadas no modo MDI, sem criar um
novo programa. A configuração de parâmetro padrão para o modo MDI, no
entanto, apaga automaticamente o programa digitado depois que sua execução
termina (e não é possível salvar um programa criado no modo MDI). Se alguma
mudança no programa tipado anteriormente for desejada, todo o programa
precisaria ser digitado novamente. Uma mudança na configuração dos
parâmetros resolveria esse problema; isso é explicado no cap. 2. Com as
configurações de parâmetro apropriadas, o programa MDI pode ser excluído ou
modificado apenas intencionalmente, através das teclas de edição no painel
MDI. Por fim, é importante observar que não existe um padrão universalmente
aceito para programação macro. Embora todos os fabricantes de controle de
renome ofereçam recursos semelhantes, há diferenças em sua metodologia de
programação. Isso impede a possibilidade de portabilidade de macro-
programas entre diferentes controles. De fato, mesmo entre as diferentes
versões de controle do mesmo fabricante, l00% de portabilidade geralmente
não seria possível, principalmente devido a diferenças nos parâmetros de
controle e variáveis do sistema em diferentes versões de controle. O importante
é entender os conceitos básicos da técnica de programação de macro. O ajuste
fino necessário para se adequar a uma versão específica de controle sempre
pode ser feito. As técnicas de programação de macros não são muito comuns
entre os usuários de CNC, muitos dos quais nem sabem que sua máquina
possivelmente possui esse recurso de programação. Infelizmente, a
programação de macros é considerada uma maneira extremamente complexa
e sofisticada de programação de peças. Isso causou um obstáculo indevido no
processo de aprendizagem. O fato é que a programação de macros é muito
mais simples que uma linguagem de programação de alto nível como o
PASCAL. Tudo o que é necessário é a vontade de aprender e uma abordagem
metódica. O autor acredita que um conhecimento viável pode ser adquirido em
apenas uma semana. leia e descubra por si mesmo!

CAPITULO 2
2.1 Variáveis e Expressões

Uma variável macro é uma quantidade matemática que pode assumir qualquer
valor dentro do intervalo permitido. Embora a programação macro na Fanuc e
controles similares tem vários recursos de um computador de alto nível
linguagem de programação, é um pouco em uma fase primitiva quando trata do
modo como as variáveis são definidas. Não permite o uso de combinações
arbitrárias de caracteres alfanuméricos para designar um variável, para a qual
existe um único caminho específico. Variáveis são designadas com o símbolo
#, seguido de um número (chamado de variável número), na faixa permissível
(que depende da versão de controle).

Alguns exemplos de variáveis são


#l
# l0
# l00
# l000
# l0000

Esses números representam locais de memória específicos que podem contém


alguns valores aritméticos positivos ou negativos (se definidos, isto é, se algum
valor é atribuído a eles) ou estar vazio (se não definido).

2.2 Expressões Macro

Existem dois tipos de expressões macro: expressões aritméticas e expressões


condicionais. Uma expressão aritmética é uma fórmula matemática que
envolve variáveis e / ou constantes (como 0.12, 1.2, 12, 120, etc.), com ou sem
funções (como SIN, ACOS, SQRT, lN, etc., que são descritas no chap. 4). Uma
expressão aninhada e o argumento de uma função devem ser colocado entre
colchetes. Colchetes pequenos (parênteses) não podem ser usados porque
são usados para inserir comentários em um programa. Uma expressão
aritmética é avaliada como um valor aritmético.
Exemplos:

1+#2
# 3 + # 4 * SIN [30 * [# 5 / 10]]

Uma expressão condicional inclui operadores condicionais (como EQ, NE e lT)


entre duas variáveis / constantes / expressões aritméticas. Deve ser colocado
entre colchetes. Ele avalia tanto TRUE ou FAlSE (estes são chamados de
valores booleanos). Uma condicional expressão também é referida como uma
expressão booleana.

Exemplos:

[# 1 EQ 0]
[[# 2 + 1] lT [SIN [30] * # 3]]

As variáveis de macro disponíveis não podem ser usadas para armazenar o


resultado de uma expressão condicional. Somente valores aritméticos podem
ser armazenados variáveis macro. O booleano TRUE / FALSE não é
equivalente à aritmética 1/0.

Exemplos:

# 110; (Armazena l0.000 na variável # 1)


# 2 = [l lT2]; (ilegal, como TRUE ou FALSE não pode ser armazenado em uma
variável)

O painel de entrada de dados manual (MDI) geralmente tem apenas uma


chave para o suporte esquerdo e outro para o suporte direito. Enquanto digita
se o colchete aparecerá como um colchete ou um parêntese, depende da
configuração do seu parâmetro. Se a máquina tiver Fanuc Oi ou Oi Controle de
posicionamento, defina o primeiro bit (da direita), que é convencional referido
como bit # 0 (os oito bits são designados como # 0 a # 7, começando pela
direita), do parâmetro 3204 a 0 para um quadrado suporte e l parêntese:

A configuração padrão para os bits restantes é 0, que não é mostrada, com o


objetivo de destacar o que precisa ser editado (ou seja, bit # 0). Obviamente,
não seria possível usar colchetes e inserir comentários ao mesmo tempo com
essa configuração de parâmetro. Se alguns comentários forem desejados para
serem inseridos em um programa de macros, primeiro digite / edite o programa
usando colchetes, sempre que necessário. Em seguida, altere a configuração
do parâmetro para obter parênteses, com o objetivo de inserir comentários.
Após a inserção de comentários, se novamente algumas correções no
programa envolvendo colchetes forem necessárias, outra alteração no
parâmetro 3204 seria necessária.

Há, no entanto, uma maneira de usar os dois tipos de colchetes, com a mesma
configuração de parâmetro. Para isso, defina o parâmetro 3204 # 2 para l (3204
# 0 deve permanecer como 0; o status dos outros seis bits não afeta esse
recurso):

Essa configuração de parâmetro exibe um conjunto de caracteres estendido,


como teclas programáveis, no modo EDIT, exibindo "(", ")" e "@". Com essa
configuração, se colchetes forem necessários, use as teclas de colchetes no
painel MDI e, se os parênteses forem necessários, faça o seguinte (no modo
EDIT):

• Pressione PROG no painel MDI (pressione PROG novamente se a corrente


programa não é exibido).
• Pressione a tecla programável OPRT.
• Pressione a tecla de extensão direita (, ..) Duas vezes.
• Pressione a tecla programável C-EXT.

Depois disso, softkeys para parênteses à esquerda, parênteses à direita e @


(que podem ser usados nos comentários inseridos em um programa)
aparecerão, que podem ser usados como e quando necessários para edição
no modo EDITAR. No entanto, uma alteração no ecrã fará com que estas soft
keys desapareçam. Se eles forem necessários novamente, o processo para
exibi-los terá que ser repetido.
Note que o painel MDI e a tela lCD (colorida ou monocromática) vêm como
uma unidade integral, bem como unidades separadas. O painel MDI do tipo
autônomo é maior e possui mais chaves. Portanto, há uma menor necessidade
de usar a tecla SHIFT para digitar caracteres alfanuméricos / operadores
aritméticos, o que torna a digitação mais rápida. O teclado também possui
teclas separadas para os dois tipos de suportes, evitando a necessidade de
exibir teclas programáveis para eles. Voltando à discussão sobre expressões
de macro, uma expressão aritmética avalia um valor aritmético positivo ou
negativo, seguindo a regra de prioridade usual: colchete (primeiro mais interno)
~ avaliação de função ~ divisão e multiplicação, adição e subtração. Aritmética
de modo misto, ou seja, cálculos envolvendo números reais e inteiros, é
permitida, o que resulta em um número real. Na verdade, o controle armazena
até mesmo um número inteiro como um número real, com zeros após o ponto
decimal. Então, por exemplo, l0 é equivalente a l0.0, e estes podem ser usados
alternadamente em todos os cálculos aritméticos. Note que esta declaração é
válida apenas para cálculos aritméticos. Por exemplo, Xl0 pode ser interpretado
como l0 mm ou l0 J.lm (no modo milímetro), dependendo de o parâmetro 340l #
0 ser l ou 0.
O negativo do valor armazenado em uma variável pode ser usado colocando
um sinal de menos antes do endereço da variável, mas dois operadores
aritméticos consecutivos,
(+, -, * e /) não são permitidos. Em tais casos, os colchetes terão que ser
usados:

- # 1 + 10 (Uma expressão válida)


10 + - # 1 (Uma expressão inválida)
10 + (- # 1] (Uma expressão válida)

Uma variável também pode ser designada em termos de outra variável ou uma
expressão aritmética, que deve estar entre colchetes:

# [# l] (# 1 deve conter um número na faixa permitida. Se, por exemplo, # 1


contém 10, então # [# 1] é equivalente a # 10. ## 1 é ilegal)
# [# 1 + 10] (Se # 1 contiver 10, então a variável referida é # 20)

O número de designação de uma variável é uma quantidade inteira. Se um


o valor real é especificado (o que é apenas uma possibilidade teórica, pois
essa situação nunca surgiria em qualquer aplicação prática), é
automaticamente arredondado para o número inteiro mais próximo (consulte a
Seção 2.3 para os métodos de atribuição de um valor a uma variável):

# 1 = 1,4999999; (Armazena 1.4999999 na variável # 1)


# [# 1] 1,5000000; (Armazena 1.5000000 na variável # 1)

# [# 1] = 1; (Armazena 00001.000 na variável # 2. Uma variável armazena e


exibe um valor usando oito dígitos, com três dígitos após o decimal, a menos
que o valor não pode ser expresso neste formato)

# 0.49999991; (Comando ilegal porque tenta atribuir um valor para a variável #


0. A variável nº 0 é uma predefinida variável nula do tipo somente leitura, que
não pode ser redefinido. Propriedades de variáveis nulas são descritos em
detalhes na Sec. 2.5)

# 0,50000001; (Armazena 00001, 000 na variável # 1)

2.3 Atribuindo um valor a uma variável


Um valor pode ser atribuído a uma variável no formato geral #i = <algum valor
ou expressão aritmética>; onde i é o número da variável. No lado esquerdo, no
lugar de i, uma expressão também pode ser usada.

Alguns exemplos são

# 1 = 10; (Armazena 00010.000 na variável # l)


# 1 = # 1 + 1; (Redefine # 1, armazenando 00011.000 nele)
# [# 1 + 10] = [10 + 20] / 30- # 1; (Armazena -00010.000 na variável # 21)
# [# 1] = SQRT [- # 21]; (Armazena 3.1622777, o valor arredondado para cima
para oito dígitos, na variável # 11. Arredondamento é feito automaticamente
pelo controle, em todos os casos de atribuição de um valor a uma variável.
Apenas oito dígitos decimais são armazenados).

# [# 1] = SQRT [- # 21];

G00 W # 11; (Provoca um deslocamento de 3.162 mm, o valor arredondado até


três dígitos após decimal, como o menor incremento de entrada deslocamento
é de 0,00l mm, em milímetro modo. Em uma declaração NC, o arredondamento
valores do eixo, até o menor incremento de entrada da máquina, é feito
automaticamente por o controle, se os valores forem especificados em termos
de variáveis. Consulte a Sec. 4.4 também).

O termo "declaração NC" foi usado sem formalmente defini-lo. É um bloco de


programa envolvendo pelo menos um endereço NC, como G, M, F, S, T, X, Y e
Z, exceto códigos para chamar um programa de macro (como G65, G66, etc.).
Por outro lado, uma instrução macro simplesmente atribui um valor a uma
variável (#i = <algum valor ou uma expressão aritmética>), ou pula para um
número de bloco especificado (GOTO_ e IF GOTO_), ou usa uma instrução
condicional (IF_THEN_, WHIlE_DO_ , e fim_), ou chama um programa de
macro. Para simplificar, um macro instrução não causa diretamente o
movimento físico da máquina, enquanto uma instrução NC controla diretamente
o movimento da máquina. Uma instrução NC pode ou não usar variáveis /
funções macro. Existem duas diferenças principais na maneira como o controle
trata as instruções NC e as instruções macro:

• Se o programa for executado no modo de bloco único (existe um interruptor


para este propósito no MOP), sua execução para em o final de cada
declaração NC, e prossegue para o próximo bloco somente após o botão
CYCLE START ser pressionado novamente. Contudo, a execução não pára no
final de uma declaração macro, prossegue para o próximo bloco. Se é
desejado executar as instruções de macro também no modo de bloco único,
defina o parâmetro 6000 # 5 para l. Em uma situação normal, tal exigência
nunca surgiria, porque uma declaração macro não envolvem o movimento da
máquina. No entanto, em caso de erro no programa, execute as instruções
macro uma de cada vez para verificar os cálculos intermediários.

• Embora a execução do programa seja bloco a bloco, o controle lê o próximo


bloco e o interpreta antecipadamente, para acelerar a execução. No modo de
compensação de raio, dois
blocos são pré-visualizados, porque o controle precisa posicionar a ferramenta
corretamente no final do bloco atual, para se adequar ao próximo segmento de
caminho. No entanto, todos (ou tantos quanto possível) sequenciais instruções
macro são lidas e avaliadas imediatamente. Em Na verdade, o controle não
conta uma instrução macro como um bloco. Uma declaração NC constitui um
bloco.

Voltando à discussão sobre a definição de variáveis, observe que


variável sempre armazena um valor com um mínimo de três casas decimais,
se o número total de dígitos não exceder oito. Se menos de três
casas decimais são usadas, zeros são adicionados.
Exemplos:
# l= l23 4; (lojas 0l234.000)
# l= l23 45; (lojas l2345.000)
# l= l23 45 6; (lojas l23456,00)
# l= l23 45 67; (lojas l234567.0)
# l= l23 45678; (lojas l2345678)

Se mais de oito dígitos forem especificados, os dígitos adicionais podem ser


convertido para 0, após arredondar até oito dígitos (independentemente
posição decimal), o que pode dar resultados inesperados, como explicado no
exemplo a seguir:

# l= l23456. 7 89; (Armazena l23456,790 na variável # l)


# 2= l23456. 7 94; (Armazena l23456,790 na variável # 2)
# 3= # 2 - # l; (Armazena 0,000 na variável # 3)

No entanto, no controle Fanuc Oi, especificando mais de oito dígitos,


para qualquer valor, gera uma mensagem de erro, "MUITOS DÍGITOS" e
termina a execução do programa. Não irá armazenar valores como l23456.789
em uma variável e exibirá a mensagem de erro. Se, no entanto, mais de oito
dígitos resultam de um cálculo aritmético,
arredondamento é feito automaticamente até oito dígitos, e nenhum erro
mensagem) ou aviso (mensagem do operador) aparecem. Uma variável
também pode ser definida de maneira condicional (condicional declarações são
explicadas na Sec. 5,3):

# l0 = 10;
# 25 = 5;
SE [#10 GT #25] ENTÃO # 25
2.4 Exibição de Variáveis
# 2510; (Condição VERDADEIRA, então # 25 torna-se 15.000)

É necessário entender como os valores das variáveis são exibidos na tela da


variável de macro, porque pode causar alguma confusão. O valor calculado de
uma variável deve estar dentro da faixa permitida (l0 a 29 ~ magnitude ~ l047
ou seja 0). No entanto, todos os valores legais não podem ser exibido
corretamente na tela, que usa um simples oito dígitos formato decimal, sem
dígitos exponenciais. Mesmo assim, o valor (desde que seja legal) mantido na
variável é corretamente usado para cálculos. Além disso, os controles da série
Fanuc Oi não permitem oito dígitos (incluindo zeros à esquerda ou à direita)
para especificar valor na atribuição direta. Alguns exemplos são dados abaixo:

# l = 0 0000000l; (Valor ilegal, como contém mais de oito dígitos)

# l. 0000000l; (Atribui o valor correto a # l, mas exibe nove estrelas, *********,


porque o número não pode ser corretamente exibido usando oito dígitos,
porque a tela adiciona automaticamente pelo menos um zero à esquerda do
decimal. Assim, ele deve exibir 0,0000000l, o que não pode porque nove
dígitos são obrigatórios. Observe que o valor é o mesmo que o valor no
exemplo anterior)

# l= # l * l0; (Atribui 0.000000l a # l que também é exibido corretamente)


# l= # l * # l * # l * # l / l0; (Atribui I0-29 para # l, mas exibe nove estrelas)
# l= # l / l0; (O valor calculado é menor que I0-29, que não está em o intervalo
permitido, então a execução termina com um alarme. Note que a mensagem de
alarme seria "CALCULADO SOBRECARGA DE DADOS ", embora é na
verdade uma matemática underflow)

# l= l0000000; (Exibe l0000000)


# l= # l * # l * # l * # l * # l * # l; (Atribui de l042 a # l, mas exibe nove estrelas)
# l= # l * l00000; (Atribui l047 a # l, mas exibe nove estrelas)
# l= # l * l0; (O valor calculado é mais que l047 que não mente na faixa
permitida. Assim,
a execução termina com um alarme, "CALCULAT)

2.5 Valores reais versus números inteiros

Embora talvez inapropriado, o controle do Fanuc é muito liberal no uso de


números reais no lugar de números inteiros, e vice-versa, em instruções macro
(somente). Enquanto números inteiros no lugar de números reais não causam
nenhum problema, números reais (atribuição direta ou o valor de uma
expressão aritmética) usados no lugar de números inteiros são
automaticamente arredondados. Isso já foi explicado com referência aos
números de designação das variáveis. Aqui estão alguns exemplos diferentes
(mais uma vez, esta é apenas uma discussão teórica, com o único propósito de
explicar a lógica que está sendo seguida pelo controle, pois pode ajudar no
diagnóstico de erros):

# 1 = 1000.4999;

M03 S # 1; (Equivalente a M03 Sl000)

# l = l000.5000;
M03 S # l; (Equivalente a M03 Sl00l)
M03 Sl0000,0; (Uma declaração ilegal. O valor 5 deve ser um número inteiro
número)
# l = 3.4 999999;
M # l Sl000; (Equivalente a M03 Sl000)
# l = 3.5000000;
M # l Sl000; (Equivalente a M04 Sl000)
M3.0 Sl000; (Uma declaração ilegal. O valor M deve ser um número inteiro
número)
Embora a última declaração seja ilegal, se 3.0 (ou algum outro número real ou
expressão) é colocado entre colchetes, torna-se um expressão macro e
arredondamento é feito:

M [3,0] Sl00 0; (Equivalente a M03 5l000)


M [3. 499999 9] Sl000; (Equivalente a M03 5l000)
M [3, 5] Sl000; (Equivalente a M04 5l000)

Isto também se aplica a todos os outros endereços (exceto G-eodes) como


fuso
velocidade também:

M03S [l 000,0]; (Equivalente a M03 5l000)


M03 S [l000. 4999]; (Equivalente a M03 5l000)
M03S [l000,5000]; (Equivalente a M03 5l00l)

Todos esses colchetes também podem conter expressões aritméticas.


Note que se o parâmetro 345l # 2 (somente em uma fresadora, este parâmetro
não está disponível em um torno mecânico) está definido para l, a velocidade
do fuso pode ter até uma casa decimal, embora a velocidade interpretada seja
a valor inteiro arredondado:

Sl000.5; (Equivalente a Sl00l, se o parâmetro 345l # 2 = l)


Sl000.50; (Ilegal, por causa de mais de uma casa decimal)

“Demasiada flexibilidade faz uma linguagem de programação em vez


indisciplinada” e torna-se propenso a erros. Um erro inadvertido pelo
programador pode ser interpretado "corretamente" pela máquina, levando a
consequências indesejáveis. E isso é muito possível porque programação
macro pode envolver cálculos complexos e complicados lógica. Na opinião do
autor, um valor real não deve ser aceito onde um valor inteiro é necessário.
Além disso, como foi descrito na seção 2.6, controle Fanuc (na verdade, talvez
todos os controles) trata um nulo variável como uma variável com valor 0 em
cálculos aritméticos. Este é novamente ilógico e pode revelar-se perigoso.
Erros de digitação são sempre é possível. Talvez os fabricantes de controle
devam modificar seus compiladores de macros para torná-lo uma linguagem
disciplinada semelhante ao PASCAl. Atualmente, o programador precisa
entender muito meticulosamente a lógica seguida pelos compiladores de
macros.

O problema é mais grave no uso de G-eodes. O controle não permite qualquer


expressão de macro como o número de um G-eode. Assim, um comando como
G [Ol] não é equivalente a GOl e é ilegal. Mas, é preciso estar ciente de que o
controle não pode dar uma mensagem de erro em todos os casos. Por
exemplo, G [03] causa um movimento inesperado da ferramenta em taxa de
avanço rápido no controle Oi Mate TC, que pode causar um acidente na
máquina. Então, como regra geral, nunca use uma expressão macro como o
número de um G-eode.
Os G-eodes podem, no entanto, usar variáveis macro como seus números.
Essas variáveis também podem ser definidas em termos de uma expressão
aritmética.
Embora nenhuma aplicação prática possa precisar usar expressões
para definir essas variáveis, deve-se ter consciência de até mesmo teórica
possibilidades, o que pode ser útil na interpretação do
resultado de certos erros no programa:

# l = 0; (Armazena 0,000 em # l)
# 2 = l; (Armazena l.000 em # 2)
Eu F [# 2 GT # l] THEN # 3 = 9 9; (Condição VERDADEIRA, então o nº 3 se
torna 99.000)
# 4= [# 2 + # 3] / 2; (Cálculo faz # 4 igual a 50.000)
G # l; (Equivalente a GOO)
G # 2; (Equivalente a GOl)
G # 3; (Equivalente ao G99)
G # 4; (Equivalente a G5O)

Exceto alguns (por exemplo, Gl2.l e Gl3.l), todos os números de G-eode são
inteiros.
Assim, os valores das variáveis (atribuídos diretamente ou atribuídos através
de uma expressão), para serem usados como números de G-eode, devem ser
inteiros. Fanuc controle aceita números reais também, desde que sua forma
arredondada, até o primeiro lugar após o ponto decimal, contém 0 após o ponto
decimal. Em outras palavras, permite um "erro" de ± 0,05. Então, um número
no intervalo de l,95 : o; não; 2.0499999 seria tomado como 2 (como a forma
arredondada, até o primeiro coloque depois do decimal, é 2.0); em 2,95: o; não;
Intervalo de 3,0499999, seria tomado como 3, enquanto 2,05: o; não;
2.9499999 é um intervalo ilegal (como o intervalo é 2,l: o; não; 2.9, na forma
arredondada). Então, l.95, 2.0, 2.0499999, etc. são todos tomado como 2,
WHILE l.9499999,2.05, 2.5, 2.9499999, etc. seriam ilegais:

# l= l,9499999;
# 2= l,95;
# 3= 2,00;
# 4= 2,0499999;
# 5= 2,05;

G # l; (Ilegal)
G # 2; (Equivalente a G02)
G # 3; (Equivalente a G02)
G # 4; (Equivalente a G02)
G # 5; (Ilegal)

O propósito de explicar o efeito de especificar um número real, no lugar de um


inteiro, é descrever completamente a lógica usada pelos controles típicos.
logicamente, uma situação em que o resultado do cálculo (ou atribuição direta)
sai como um número real (com dígitos diferentes de zero após o ponto
decimal), em que um número inteiro é esperado (como os valores associados a
G-, M- e S -códigos), nunca surgiria a menos que haja algum erro no programa.
No entanto, para um diagnóstico rápido, é necessário entender completamente
a lógica construída no compilador de macros.
Mesmo que o programa seja perfeito, erros de digitação sempre lembre-se que
o parâmetro 340l # 0 decide se um valor dimensional (como distância e
avanço) expresso como um número sem um ponto decimal seria interpretado
como um valor milimétrico ou um valor mícron (assumindo o modo G2l). Isso
pode causar um problema sério em alguns controles, além do Fanuc, se um
número inteiro for usado no lugar de um número real, enquanto se define uma
variável.

Por exemplo,

# 1 = 10;
GOO W # 1;

pode causar um deslocamento de 0,0l mm. Portanto, para estar no lado mais
seguro, sempre use pontos decimais para todos os valores dimensionais. Este
problema, no entanto, não existe no controle Fanuc que armazenaria 000l0.000
na variável # l, independentemente da configuração do parâmetro. Variáveis
podem ser usadas como valores após qualquer endereço de carta, exceto 0
(número do programa) e N (número de sequência). / (número de salto de bloco
opcional) também não permite o uso de variáveis:

# 1 = 1;
0 # 1; (Uma declaração ilegal. Use 0l)
N # 1 G01 X100; (Uma declaração ilegal. Use Nl)
/ # 1 G01 X100; (Uma declaração ilegal. Use / l)

2.6 Variáveis Indefinidas

Se um valor não for explicitamente atribuído a uma variável, ele permanecerá


indefinido e não conterá nada. Essa variável é chamada de variável nula ou
variável vazia. # 0 é uma variável nula pré-definida, do tipo somente leitura.
Nenhum dado pode ser armazenado nele. Ele foi fornecido com o único
propósito de comparação lógica de alguma outra variável com ele, para
descobrir se a variável está definida ou não. As instruções de comparação são
usadas em expressões condicionais, que são explicadas com mais detalhes
em Sees. 4.1 e 5.2.

Variáveis nulas em endereços do Word

Quando uma variável nula aparece em um endereço, esse endereço específico


(apenas) é ignorado. Por exemplo, se # 1 for uma variável nula, então GOO X #
1 não causará nenhum movimento, embora GOO se torne o código modal ativo
do Grupo 1. Essa instrução é equivalente a um único comando GOO, sem
nenhuma palavra de eixo. Por outro lado, GOO X #1 Z1OO é equivalente a
GOO Z1OO.

Variáveis nulas em operações aritméticas geralmente, se uma variável nula é


usada em algum lugar, para uma finalidade diferente de uma comparação para
descobrir se é ou não uma variável nula, uma mensagem de erro, UNDEFINED
VARIABlE, teria sido mais apropriada.
Mas, o compilador de macros Fanuc (e possivelmente compiladores de outros
fabricantes também) não foi concebido desta forma. Em operações aritméticas,
como adição e multiplicação, bem como na avaliação de função, uma variável
nula é tratada como uma variável com valor 0. Nos exemplos a seguir, todas as
variáveis são consideradas variáveis nulas, inicialmente:

# 2 = # l; (# 2 permanece uma variável nula porque não há aritmética operação


ou avaliação de função nesta declaração)

# 3 [# l]; (A presença de parênteses faz com que seja uma expressão, mas
ausência de qualquer operação aritmética com # l mantém nulo. Então, o item
3 continua sendo uma variável nula)

# 4 # l + # l; (Equivalente a # 4 = 0 + 0. Então, # 4 é definido e lojas 0)

# 5 # l * 5; (Equivalente a # 5 = 0 * 5. Então, # 5 é definido e lojas 0)

# 6 l / # l; (Equivalente a # 6 = l I 0, que dará "DIVIDED POR ZERO "erro)

# 7 SQRT [# l]; (Equivalente a # 7 = SQRT [O]. Então, # 7 é definido e lojas 0)

# 8 # 4l09; (Variável # 4l09 contém o avanço atualmente ativo na máquina, e se


nenhuma palavra F tiver sido usada em qualquer lugar nos blocos de programa
anteriores, contém 0. Portanto, # 8 armazenaria o avanço atual ou 0. As
variáveis do tipo # 4l09 são descritas no Cap. 3. Estas variáveis nunca são
nulas, mesmo que não sejam explicitamente definidas)

Variáveis nulas em expressões condicionais

Exceto para EQ (igual a) e NE (não igual a), uma variável nula é a mesmo que
0. Nas seguintes afirmações, # 1 é uma variável nula:

[# 1 LT O] (Equivalente a 0 LT 0, portanto, FALSE)


[# 1 LE O] (Equivalente a 0 LE 0, portanto VERDADEIRO)
[# 1 GT O] (Equivalente a 0 GT 0, daí FALSE)
[# 1 GE O] (Equivalente a 0 GE 0, daí VERDADEIRO)
[# 1 LT #O] (Equivalente a 0 LT 0, portanto, FALSE)
[# 1 LE #O] (Equivalente a 0 LE 0, portanto VERDADEIRO)
[# 1 GT #O] (Equivalente a 0 GT 0, portanto FALSE)
[# 1 GE #O] (Equivalente a 0 GE 0, portanto VERDADEIRO)

No entanto, uma variável nula não é igual a 0 nas instruções de comparação


usando EQ e NE:
[# 1 EQ 0] (Com EQ, uma variável nula não é igual a 0, portanto FALSE)
[# 1 NE 0] (Com NE, uma variável nula não é igual a 0, portanto, TRUE)
[# 1 EQ # 0] (Ambas são variáveis nulas, portanto, TRUE)
[# 1 NE # 0] (Ambos são variáveis nulas, portanto, FALSE)

2. 7 Um uso simples dos recursos de programação de macros

Finalmente, o exemplo simples a seguir mostra como o uso de variáveis faz


com que o mesmo programa funcione sob diferentes requisitos:

# 1 = 0;
# 10 = 1;
# 100 = 50;
# l0l = 60;
# l02 = 30;
G # 10 X # 100 Z # 101 R # 1 F # 102;

Estas declarações são equivalentes a GO1 X5O.OOO Z60.000 RO.OOO


F30.000, que pode ser feito para fazer coisas diferentes simplesmente
alterando os valores armazenados nas diferentes variáveis. Pode haver várias
declarações desse tipo no programa. Não há necessidade de modificar
nenhum deles. Basta definir as variáveis no início do programa e alterá-las
conforme a necessidade. Este é o uso mais simples, mas efetivo, da
programação de macros, que não requer um detalhamento conhecimento desta
linguagem de programação. É necessário estar ciente apenas dos tipos de
variáveis macro e seus intervalos permitidos.

2.8 Retendo Programas no Modo MDI

Todas as declarações feitas acima e nos capítulos subsequentes foram


realmente verificadas no Fanuc Oi Mate TC, onde aplicável. Se alguém deseja
verificá-los, ou quer tentar algumas outras combinações, isso pode ser feito
com segurança usando o recurso gráfico dinâmico no modo AUTO (modo de
operação automática, que também é chamado de modo de memória). Se, no
entanto, nenhum movimento da ferramenta estiver envolvido, a verificação
pode ser feita sem o uso de gráficos dinâmicos, no modo de memória. Na
verdade, até mesmo o modo MDI pode ser usado. Mas a configuração padrão
para o modo MDI é tal que o programa é apagado automaticamente após a
conclusão da execução. Isso significa que o programa teria que ser digitado
novamente, para uma execução subsequente. Isso torna a tentativa e o erro
impraticáveis no modo MDI. No entanto, se o parâmetro 3204 # 6 estiver
definido como l, o programa MDI será mantido mesmo após a conclusão da
execução. A tecla RESET irá, variáveis e Expressões 25 claro, apague-o. Se
desejar retê-lo mesmo depois de pressionar a tecla RESET, ajuste o parâmetro
3203 # 7 para 0. Em outras versões do controle Fanuc, esses números de
parâmetro podem ser diferentes. Referência aos respectivos manuais de
parâmetros seria necessária. Um programa MDI, no entanto, não pode ser
salvo permanentemente com um número de programa para uso futuro. Desligar
a máquina apaga-a permanentemente.

CAPITULO 3
Tipos de Variáveis

3.l Variáveis locais e Globais

Em uma linguagem de computador de alto nível, existem conceitos de variáveis


locais e variáveis globais. Variáveis locais são definidas dentro de uma sub-
rotina, e são locais para eles. Eles são usados para cálculos intermediários em
a sub-rotina e não tem significado fora dela ou em outra sub-rotina aninhado a
ele. Então, mesmo que diferentes sub-rotinas usem variáveis locais com os
mesmos nomes, referem-se a diferentes e independentes locais de memória e,
portanto, não afetam um ao outro. E no caso de aninhamento, após o término
da execução da sub-rotina aninhada e a execução volta para a sub-rotina de
chamada, a anterior variáveis locais definidas da sub-rotina de chamada
tornam-se novamente disponíveis para isso, com os mesmos valores
armazenados anteriormente. O programa principal também pode ter seu
próprio conjunto de variáveis locais. Variáveis globais, em Por outro lado, são
globais por natureza em todo o programa. Eles podem ser usados em qualquer
lugar com o mesmo significado, uma vez que estes se referem aos mesmos
locais de memória:

Programa principal

GlOVAR = l
Chamar a sub-rotina l
Imprimir GlOVAR (Imprime 3, porque a variável global, GlOVAR, modificado
por ambas as sub-rotinas)

Fim
Sub-rotina l
Variáveis locais: lOCVAR
lOCVAR = l
GlOVAR = GlOVAR + l
Chame Sub-rotina 2
Imprimir lOCVAR (Imprime l, não l0, porque o local variáveis lOCVAR
dos dois sub- rotinas são armazenados em diferentes memória
independente localizações)

Retorna

Sub-rotina i ne 2
Variáveis locais: lOCVAR
lOCVAR = l0
GlOVAR GlOVAR + l
Retorna
(lOCVAR definido aqui é diferente de lOCVAR definido em Sub-rotina l)

Subprogramas e macros são usados como sub-rotinas em um programa CNC.


A discussão sobre variáveis locais se aplica somente a macros. Um
subprograma não possui seu próprio conjunto de variáveis locais. Ele usa as
variáveis do programa de chamada, com o mesmo significado. E, se um
subprograma definir algumas novas variáveis, elas também estarão disponíveis
para o programa de chamada, quando a execução retornar a ele. Na verdade,
um subprograma só pode ser considerado parte do programa de chamada, que
é definido separadamente para evitar a múltipla digitação de linhas repetitivas.
Na terminologia de programação de macros, as variáveis locais são referidas
apenas como variáveis locais, mas as variáveis globais são referidas como
variáveis comuns. Além disso, variáveis comuns de um tipo especial estão
disponíveis, as quais retêm os valores armazenados nelas mesmo depois que
a máquina é desligada. Os valores armazenados nestas variáveis permanecem
disponíveis em todas as sessões de usinagem futuras e podem ser usados /
modificados por todos os programas. Estes podem ser apagados (feitos nulos)
ou modificados apenas intencionalmente. Tais variáveis são chamadas
variáveis comuns permanentes. Essas variáveis são um dos recursos
exclusivos da programação de macros e não estão disponíveis em linguagens
de programação convencionais, como o PASCAl. Há mais um tipo de variável
usada para ler / gravar uma variedade de dados de controle, indicando o status
da máquina, como a posição atual da ferramenta e os valores de correção da
ferramenta. Estas são chamadas de variáveis do sistema, algumas
dos quais são do tipo somente leitura. Variáveis do sistema são descritas em
detalhes na Sec. 3.5.
Assim, as variáveis macro são dos seguintes tipos:

• Variável nula pré-definida, somente leitura (# 0)


• Variáveis locais (# l a # 33)
• Variáveis comuns (# l00 a # l99)
Variáveis comuns permanentes (# 500 a # 999)
• Variáveis do sistema (# l000 e acima)

As variáveis # 34 a # 99 e # 200 a # 499 não estão disponíveis e não podem


ser usadas.

3.2 Efeito da reinicialização do sistema em variáveis de macro


Sempre que M02 ou M30 são executados, ou o botão RESET no painel MDI é
pressionado, todas as variáveis locais (ou seja, # l a # 33) e variáveis comuns
(ou seja, # l00 a # l99) são limpas para nulo. Isso significa que uma variável
comum,

com o mesmo significado, só pode ser usado em um programa (e nos


subprogramas / macros aninhados a ele). Portanto, se um valor calculado em
um programa for necessário para ser usado por outro (s) programa (s) também,
ele deve ser armazenado em uma variável comum permanente (ou seja, # 500
a # 999). Uma variável comum permanente sempre tem o mesmo significado
para todos os programas, não apenas na sessão de usinagem atual, mas
também em todas as sessões futuras, até que seja modificada para armazenar
um novo valor. E pode ser modificado a qualquer momento por qualquer
programa. Também pode ser modificado no modo MDI. Não é apagado pelo
botão M02 / M30 / RESET. Embora não seja recomendado (no interesse de
uma prática de programação segura, como a maioria das pessoas acredita que
as variáveis locais e as variáveis comuns em um novo programa começam com
valores nulos),
a seguinte configuração de parâmetro manteria os valores armazenados em
variáveis locais e comuns, mesmo após a reinicialização do sistema (embora a
energia desligada ainda os limpe):

Parâmetro 600l # 6 = l (Mantém as variáveis comuns mesmo após a


reinicialização do sistema)
Parâmetro 600l # 7 = l (Mantém as variáveis locais mesmo após a
reinicialização do sistema)

A configuração padrão para esses bits de parâmetro é 0, que limpa os valores


armazenados, se houver, sempre que o sistema é redefinido. No entanto, é
uma boa prática de programação não depender dos padrões e definir todas as
variáveis locais e comuns como null antes de usá-las em um programa. Além
disso, as variáveis comuns permanentes também devem ser usadas com
cuidado, pois podem conter alguns valores armazenados anteriormente.

3.3 Níveis de Variáveis locais

Um macro sempre começa com valores nulos para todas as variáveis locais,
exceto aquelas cujos valores são passados para o macro através dos
argumentos da chamada de macro. O método de passar os valores desejados
para certas variáveis locais é discutido em detalhes no Capítulo. 7. Neste
estágio, é suficiente saber que G65 P2 AS é uma chamada de macro para o
programa número 2, com a variável de macro # l = 5 (inicialmente) e as outras
variáveis locais do macro permanecendo nulas. As variáveis locais, definidas
em um macro, permanecem adequadamente definidas apenas na chamada
atual do macro. Qualquer chamada subsequente do mesmo macro iniciará
novamente com valores nulos para todas as variáveis locais (exceto, é claro,
aquelas definidas pela lista de argumentos):
Programa principal

0000l; (Programa número l)


G65 P2 AS; (A execução do macro começa com # l = 5 e define
# l0 = 5. Então, ele redefine # l e armazena 6 nele.
Outras variáveis locais do macro permanecem nulas.
Quando a execução do macro estiver concluída, o
valores atribuídos a # l e # l0 são perdidos)

G65 P2 A5; (Esta chamada de macro não é afetada pelo anterior ligue de
qualquer maneira.
A execução da macro começa com # l = 5 e valores nulos para o
restante variáveis locais, como na chamada anterior. Então,
a macro define # l0 = 5 e # l = 6, como na chamada anterior)

M30; (Fim do programa principal)

Macro
00002; (Programa número 2)
# l0 = # l0 + # l; (lembre-se que uma variável nula é equivalente a 0, em
operações aritméticas)

# l0 = # l0 + # l; (Redefine # l)

M99; (Retornar ao programa de chamada)

Macro
00002;
# l0 = # l0 + # l;
# l0 = # l0 + # l;
M99;
Aninhamento de macros até um máximo de quatro níveis é permitido.

Isso significa que o programa principal pode chamar macro l, macro l pode
chamar macro 2, macro 2 pode chamar macro 3 e macro 3 pode chamar macro
4. Se uma variável local com a mesma designação estiver sendo usada em
todos os lugares, ela terá cinco significados diferentes, correspondendo ao
programa principal e as quatro macros. Quando um macro chama outro macro,
um novo conjunto de variáveis locais se torna ativo. No entanto, os valores
armazenados nas variáveis locais do macro de chamada não são perdidos.
Depois de M99, quando o controle retorna para o macro de chamada, os
valores armazenados anteriormente ficam disponíveis. Por exemplo, vamos
supor que o programa principal e as quatro macros aninhadas definam uma
variável local nº l0 igual a l, 2, 3, 4 e 5, respectivamente. Então, quando o
controle retorna para, digamos, macro 2 (depois de executar M99 da macro 3),
o valor de # l0 seria restaurado
3. Observe que os valores das variáveis locais de um macro são retidos
somente no caso de aninhamento, não em uma chamada subseqüente da
macro, como já discutido. Os cinco conjuntos diferentes de variáveis locais em
macros aninhadas são referidos como cinco níveis (que são na verdade cinco
locais de memória diferentes) de variáveis locais. O nível do programa principal
é definido como nível 0, e os níveis das macros aninhadas subseqüentes são
incrementados em l:

Programa principal: # l a # 33 do nível 0


Macro l (chamado pelo programa principal): # l a # 33 do nível l
Macro 2 (chamado pela macro l): de l a 33 do nível 2
Macro 3 (chamado pela macro 2): de l a 33 do nível 3
Macro 4 (chamado pela macro 3): de l a 33 do nível 4

Observe que o programa principal pode chamar macros e subprogramas e,


macros e subprogramas também podem chamar uns aos outros. Como os
subprogramas também permitem um aninhamento de até quatro níveis,
podemos ter um aninhamento misto de até oito níveis - quatro para macros e
quatro para subprogramas - em qualquer ordem:
programa principal chamando macro l, macro l chamando macro 2, macro 2
chamando macro 3, macro 3 chamando macro 4, macro 4 chamando
subprograma l,
subprograma l chamando subprograma 2, subprograma 2 chamando
subprograma 3,

e subprograma 3 chamando subprograma 4. Várias outras combinações das


quatro macros e dos quatro subprogramas também são possíveis, como macro
de chamada de programa principal l, subprograma l de chamada de macro l,
macro de chamada de subprograma l 2, subprograma 2 de chamada de macro
2, subprograma 2 chamando macro 3, macros 3 chamando subprograma 3,
subprograma 3 chamando macro 4, e macros 4 chamando subprograma 4. Não
há restrição sobre
o número total de macros ou subprogramas em um programa; somente o nível
máximo de aninhamento deve ser quatro ou menos, separadamente para
macros e subprogramas. Em outras palavras, no caso de um aninhamento
misto, não são permitidas mais de quatro macros ou quatro subprogramas. No
entanto, não há restrição quanto ao número total de chamadas aninhadas em
locais diferentes no mesmo programa, desde que o nível máximo permitido de
aninhamento
não é excedido em cada lugar. Deve-se notar, no entanto, que os
subprogramas não possuem seu próprio conjunto de variáveis locais. Um
subprograma usa as variáveis locais, conforme definido pelo programa de
chamada (que pode ser o programa principal, uma macro ou outro
subprograma), e também pode modificar essas variáveis.
Por exemplo, vamos supor que o programa principal chame uma macro e a
macro chame um subprograma. Se a mesma variável local # l0 (digamos)
estiver sendo usada em todos os lugares, então # l0 do programa principal e #
l0 da macro terão significados diferentes (correspondendo ao nível 0 e nível l,
respectivamente), mas # l0 da macro será o mesmo que o # l0 do
subprograma. Se o subprograma modificar # l0, ele também substituirá o
número l0 da macro, porque ambos se referem à mesma localização de
memória (correspondente ao nível l).

Estes conceitos são ainda explicados através de exemplos das Figs. 3.l e 3.2,
representando o nível máximo possível de aninhamento. Consulte Chaps. 6 e 7
para os métodos de chamar subprogramas e macros.

Para esses exemplos, basta saber o seguinte:

G65 P2 A3; (Chama o programa número 2 como uma macro e define macro, #
l = 3, com as outras variáveis locais restantes null, inicialmente)

M98 P2; (Chama o programa número 2 como um subprograma. programa e


número de programa 2, ambos usam o mesmo conjunto de variáveis locais)

M99; (Retorna a execução para o programa de chamada)

G65 P2 A3;
M98 P2;
M99;

Observe que um subprograma não é diferente de uma macro, estrutura. Ambos


(bem como o programa principal) podem usar todos os tipos de macro variáveis
e funções macro. Se um programa é chamado pelo G65, torna-se uma macro,
e as regras relativas às variáveis locais são seguidas. O mesmo programa, se
chamado pelo M98, torna-se um subprograma. No entanto, geralmente um
programa é projetado para ser usado como uma macro ou como um
subprograma (ou como o programa principal). Se for uma macro, certas
variáveis locais serão atribuídas a alguns valores através do argumento lista na
instrução de chamada de macro; outras variáveis locais permanecerão nulas.
Também é possível não atribuir qualquer valor inicial a qualquer variável local,
enquanto chama uma macro (por exemplo, G65 P2 que simplesmente chama o
programa número 2, como uma macro, com valores nulos para todas as
variáveis locais). Por outro lado, uma chamada de subprograma é como uma
operação de copiar e colar do programa chamado no programa de chamada.
Não altera o nível das variáveis locais do programa de chamada. Assim, ele
pode modificar o valor armazenado em qualquer variável do programa de
chamada e também pode definir novas variáveis, durante o curso de sua
execução. No fim de sua execução, os valores finais armazenados em todas as
variáveis são passados para o programa de chamada. O controle armazena
todos os programas da mesma maneira. É o uso específico de um programa
que o classifica como o programa principal ou um subprograma ou um macro.
A Figura 3.3 dá um exemplo de aninhamento misto de um macro e um
subprograma. Um máximo de mais três macros e mais três subprogramas
podem ser aninhados neste programa. Neste programa, o programa principal e
o subprograma referem-se ao mesmo conjunto de variáveis locais do nível 0,
enquanto as variáveis locais na macro são variáveis de nível l. lembre-se de
que uma variável indefinida (isto é, não atribuída) é uma variável nula, que é
equivalente a 0 em todas as operações aritméticas.
3.4 Faixa de Valores Armazenados em Variáveis

Variáveis locais e comuns podem ter um valor 0 ou um valor nas seguintes


gamas:

-l,0E47 a -l,0*E-29
+ l,0E29 a + l,0E47

Se, como resultado de cálculos, um valor aritmético (final ou intermediário)


ultrapassar esse intervalo, uma condição de erro (que é chamada de alarme) é
gerada e a execução é interrompida. De fato, um valor situado entre -l,0*l0^-29
e +l,0*l0^-29 (mas não igual a 0) também não é permitido. A mensagem de
alarme associada é "SOBRECORRENTE DE DADOS CAlCUlADO" (embora
este seja realmente um caso de underflow matemático).

Um programador pode desejar que o controle ignore esse "erro" e tratar


qualquer valor nesse intervalo como 0. Isso, no entanto, não é possível, pois
não há nenhum parâmetro para controlar esse recurso. Mas esta é apenas
uma possibilidade teórica. É improvável que tal situação surja em cálculos
relacionados ao CNC. Um exemplo da possibilidade teórica é dado abaixo.

# l= 0.0000000l; (Atribui l,0*E-8 à variável # l)


# 2= # l * # l * # l * # l; (O cálculo do valor é de l,0*E-32 o que gera um alarme,
como o valor é menor que l,0*E-29)

# l= 0.0000000l;
# 2= # l * # l * # l * # l;

Se tal situação ocorrer, o programador deve normalizar a variável "suspeita"


para 0, sempre que seu valor absoluto se tornar menor que, por exemplo, l,0*E-
l0 Isso não terá nenhum efeito adverso na precisão de novas causas, pois os
cálculos macro são precisos até apenas oito dígitos decimais. Uma declaração
condicional como a seguinte pode ser usada:

IF [ABS [# l] LT [0. 0000l * 0. 0000l]] THEN # 1 = 0;

Note que todos os valores situados na faixa permitida não podem ser exibidos
na tela, que usa o formato decimal de oito dígitos. Assim, o valor mínimo não-
zero (magnitude) que pode ser exibido é 0,000000l, e o valor máximo é
99999999. O controle exibe nove estrelas (*********) como o valor de uma
variável (no tela de variável de macro) sempre que a sua exibição não for
possível, desde que o valor esteja na faixa permitida (magnitude situada entre
o l.0*E-29 e o l,0E47).

O termo "sistema" refere-se a "controle do CNC". Portanto, as variáveis do


sistema também podem ser chamadas de variáveis de controle. Este é o último
grupo de variáveis relacionadas ao status atual do controle do CNC. Variáveis
do sistema versus parâmetros do sistema Variáveis do sistema não devem ser
confundidas com parâmetros do sistema (que são comumente referidos como
apenas parâmetros). Parâmetros decidem as configurações padrão do
controle. Por exemplo, conforme já discutido, o valor de um determinado
parâmetro decide se a chave de colchetes no painel MDI fornecerá um
parêntese ou um colchete. Um parâmetro não é uma variável. Selecionamos
um valor para o parâmetro para atender às nossas necessidades e não o
alteramos a menos que nossa exigência seja alterada. Em uma nova máquina,
todos os parâmetros são configurados de fábrica, tendo em mente os
aplicativos mais comuns. Normalmente, os usuários não precisam alterar os
parâmetros. De fato, eles não devem, a menos que seja absolutamente
essencial e o usuário compreenda claramente o efeito da mudança, porque um
ajuste incorreto do parâmetro pode causar um comportamento inesperado da
máquina, levando a acidentes. Os usuários devem, de fato, manter o backup
dos parâmetros originais em um local seguro, para que possam ser
reinstalados, se necessário, no futuro. Os controles da série Fanuc Oi vêm com
um cartão de memória flash e um slot PCMCIA para ele, para fins de backup.
As variáveis do sistema, por outro lado, na verdade variam, como se trabalha
na máquina. Como os valores armazenados neles continuam mudando, eles
são chamados de variáveis, mas não podem ser usados da mesma forma que
variáveis locais e comuns são usadas. O único propósito das variáveis do
sistema é trocar informações com o controle em relação ao seu status atual.
Assim, as variáveis do sistema nos permitem comunicar com o controle, o que
é essencial para o desenvolvimento de programas de uso geral e automação.
Tais aplicações, que são o principal objetivo da programação macro, são
discutidas em mais detalhes nos capítulos subsequentes. A única semelhança
entre as variáveis do sistema e os parâmetros do sistema é que ambos são
números de quatro dígitos (alguns deles também são números de cinco
dígitos). Variáveis de sistema nos controles da série Fanuc Oi Existem
centenas de variáveis de sistema e é improvável que um usuário use todas
elas. Ele deve, no entanto, estar bem ciente das informações disponíveis
através dessas variáveis, sem as quais ele não pode utilizar totalmente a
capacidade de sua máquina. Como os parâmetros do sistema, várias das
variáveis do sistema diferem em diferentes versões de controle de
a mesma empresa, mesmo para as mesmas funções. A parte restante deste
capítulo descreve algumas das variáveis de sistema comumente usadas nos
controles da série Fanuc Oi. Em um controle diferente, seria necessário
consultar o manual do operador. As coisas básicas seriam as mesmas, apenas
os números das variáveis podem diferir. Exibindo Variáveis do Sistema Embora
variáveis do sistema possam ser lidas e escritas (embora algumas
tipo somente leitura) em um programa, eles não são exibidos na tela de
variável de macro. Somente os valores armazenados em variáveis locais e
comuns podem ser vistos na tela. Então, se alguém realmente quiser ver o
valor armazenado em uma variável do sistema em particular, uma abordagem
indireta terá que ser usada: copiar a variável do sistema em uma variável local
ou comum, que pode ser vista no offset / setting (OFS / SET). As informações
fornecidas abaixo devem ser usadas apenas como referência. Não há
necessidade de ler tudo aqui, nesta fase. Então, pule para o próximo capítulo,
depois de dar uma olhada superficial nessa informação. As variáveis do
sistema podem ser amplamente categorizadas com base em seu uso para os
seguintes propósitos:
• sinais de interface
• Geometria e valores de deslocamento de desgaste
• Quantidade de deslocamento do sistema de coordenadas da peça de trabalho
• Alarme macro (parada de execução)
• informação de tempo
• controle de operação automática
• Pausa de execução (que pode ser reiniciada com CYClE START)
• Informação de imagem espelhada
• Número de peças usinadas
• Informação Modal
• Posição atual da ferramenta
• Valores de deslocamento de trabalho

Sinais de Interface

Este é talvez o conceito mais difícil na programação de macros, porque


também requer um conhecimento da programação do ClP. É apenas para
usuários avançados. Assim, os leitores podem ignorá-lo até que tenham
aprendido os recursos básicos da programação de macros.
Os sinais de interface são utilizados para comunicar com (isto é, receber
entrada e enviar saída, como sinais binários, de / para) dispositivos externos,
ligados à máquina CNC. Esta questão é discutida em mais detalhes no
Capítulo. l2. Aqui, apenas uma visão ampla é dada, sem entrar nos detalhes
mais sutis, então, certas coisas podem não ficar muito claras até que o leitor se
refira ao capítulo dedicado exclusivamente a este tópico. O principal objetivo
aqui é explicar quais são os sinais de interface,
não como eles são usados, embora alguma ideia disso também seja dada.
Uma discussão sobre sinais de interface e seu uso requer um entendimento da
arquitetura de hardware do controle (consulte também Comunicação com
dispositivos externos na Seção l.2, onde algumas informações são fornecidas).
O CNC (controle) está preocupado principalmente com o controle do caminho
da ferramenta. O controle geral da máquina é através da lógica incorporada em
um ClP. Por exemplo, se a porta estiver aberta, a usinagem não deve começar.
Se, por algum motivo, a usinagem precisar ser feita com
a porta aberta, a lógica do PlC terá que ser alterada, através de uma mudança
no seu diagrama de escada. (ladder diagram ou ladder language é um dos
métodos de programação de um ClP. Supõe-se que o leitor possua seu
conhecimento básico. Caso contrário, pode-se referir a algum livro sobre
programação de ClP, como o de John R. Hackworth, publicado pela Pearson
Education.) Embora um ClP seja parte integrante do hardware de controle
fornecido pelos fabricantes de controle, ele é programado pelos fabricantes de
máquinas-ferramenta para atender a determinadas máquinas-ferramentas. A
Fanuc chama seu controle de máquina programável PlC (PMC).
Essencialmente, o PlC e o PMC referem-se à mesma coisa. Quando uma
máquina CNC está conectada a dispositivos externos,
É necessária uma comunicação entre o CNC, o PMC e os dispositivos
externos. O CNC, no entanto, não se comunica diretamente com os
dispositivos externos. A comunicação entre os dois é através do PMC, como
mostrado na Fig. 3.4
O PMC aceita entradas do CNC, bem como de fontes externas
dispositivos (incluindo a máquina-ferramenta). Essas entradas são chamadas
de sinais F e sinais X, respectivamente. Da mesma forma, envia saídas para o
CNC (sinais G), bem como para os dispositivos externos (sinais Y). Os sinais X
e Y também são chamados de sinais DI (data in) e DO (data out),
respectivamente. Como os sinais F e G são internos ao controle, os endereços
de sinal e os significados correspondentes são decididos pela Fanuc. Por outro
lado, os sinais X e Y são sinais externos, portanto os endereços de sinais e
seus significados são decididos pelo MTB. O MTB não precisa usar todos os
endereços X e Y disponíveis. Os endereços à esquerda podem ser usados pelo
usuário final, como sinais de interface de / para dispositivos externos. Alguns
endereços X (como X4.0 a X4.7 e X8.4), no entanto, são padrão e sempre
usados com o mesmo significado. Todos os sinais são sinais de oito bits, cada
bit levando um significado diferente dos outros sete bits. Por exemplo, o PMC
envia o sinal de "início de ciclo" ao CNC por G7.2 (que significa bit # 2 de G7
ou G007; geralmente, os endereços de sinal F e G são números de três dígitos,
e X- e Os endereços Y são números de dois dígitos, onde os zeros iniciais
podem ser omitidos). Por outro lado, G7.l é o sinal "start lock" (que desabilita o
botão CYClE START no MOP), e o G7.0 não está definido. Similarmente, XO.O
(bit # 0 de XO) e X0.l (bit # l de XO) são dois sinais de entrada independentes.
Às vezes, uma combinação de certos bits é usada para enviar sinais
apropriados. Por exemplo, G43.0, G43.l e G43.2 são para o sinal de seleção de
modo para o CNC. Quando estes são todos 0, o CNC considera uma instrução
para trabalhar no modo MDI. Por outro lado, 00l é para o modo HANDlE, l00 é
para o modo MEMORY ou AUTO e assim por diante. As conexões de hardware
para os sinais F e G são internas. Os significados pré-definidos dos sinais F e
G não podem ser alterados pelo MTB ou pelo usuário final. Os números de
endereço destes sinais e os dados associados significados podem ser
encontrados no Manual de Manutenção da Fanuc. Vários sinais X e Y estão
disponíveis para interação com o mundo lá fora. Normalmente, XO a X3 são
para sinais de finalidade geral, X4 a Xll são conectados às teclas do MOP
fabricado pela Fanuc, Xl2 é conectado ao gerador de pulso manual (MPG), Xl3
e Xl4 são para MPGs adicionais, e Xl5 é para sinais de erro. Muitos MTBs não
use o MOP da Fanuc. Eles projetam seu próprio MOP. Nesses casos, XO a Xll
se tornam sinais de finalidade geral e qualquer sinal pode ser usado para
qualquer finalidade. Os sinais Y disponíveis são de YO a Y7. Um terá que se
referir ao manual fornecido pelo MTB para descobrir quais endereços X e Y
foram usados por eles. Os endereços restantes podem ser usados pelos
usuários para fins de comunicação com dispositivos externos. A conexão física
entre o PMC e os dispositivos externos é feita conectando os fios à barra de
terminais conectada ao módulo I / 0 (entrada / saída) (também chamado de
unidade I / 0) do PMC. Consulte o Manual de conexão (Hardware) do Fanuc
para saber a atribuição de pino (ou seja, qual terminal corresponde a qual
endereço X ou Y) na faixa de terminais. O módulo de E / S é geralmente
colocado no gabinete de fiação projetado pelo MTB. Ele está conectado à barra
de terminais por quatro conectores de 50 pinos (no módulo l/0) a: nd cabos de
fita. Para comunicar um sinal externo ao CNC, o sinal X correspondente
precisará ser gravado no sinal G apropriado (G54.0 a G54.7 e G55.0 a G55.7
são reservados para este propósito). Isso pode ser feito adicionando uma nova
linha à escada do PMC:

Isso define uma variável do sistema (correspondente ao Gaddress


especificado), que pode ser lido em um programa. Por exemplo, quando XO.O
(assumindo que o MTB não usou este endereço) é gravado em G54.0 (que
corresponde à variável # l000), ele define a variável # l000 (que se torna 0 ou l
dependendo se XO.O é baixa ou alta). A variável # l000 pode ser lida em um
programa. Assim, o estado ON / OFF de um sensor externo fica disponível
dentro do programa. Da mesma forma, os sinais F (aqueles que são usados
para fins de comunicação externa, F54.0 a F54.7 e F55.0 a F55.7) gerados
pelo CNC tornam-se disponíveis para o mundo exterior somente quando estes
são transmitidos como os sinais Y, adicionando novos degraus à escada do
PMC (então esses sinais podem ser aproveitados dos pinos especificados na
faixa de terminais e enviados para dispositivos externos por meio de fios):

Por exemplo, se F54.0 (que corresponde à variável # ll00) for escrito em YO.O
(supondo que o MTB não tenha usado YO.O), o valor atribuído (0 ou l) à
variável # ll00, dentro do programa, fica disponível no terminal de saída YO.O,
que pode ser usado para ligar ou desligar um dispositivo externo. Assim, uma
instrução de programa pode dirigir um dispositivo externo. Os sinais binários
(correspondentes às variáveis # l000, etc.) para tal comunicação são chamados
de sinais de interface. Normalmente, l6 sinais de entrada e l6 sinais de saída
estão disponíveis. O status atual desses sinais está disponível dentro de um
programa através de certas variáveis do sistema, como já explicado em alguns
exemplos.
Dois tipos de variáveis do sistema estão disponíveis: para l6 sinais de bit único
e para um sinal de l6 bits (para sinais de entrada e saída). Os exemplos
fornecidos pertencem a variáveis de sistema para sinais de bit único que
podem ser apenas 0 ou l. As variáveis para sinais de l6 bits são usadas para ler
/ gravar todos os l6 sinais simultaneamente por uma única instrução de
programa. Por exemplo, se o primeiro e o segundo sinais (isto é, F54.0 e F54.l)
são l e os restantes são 0 então o sinal de l6 bits correspondente seria
00000000000000ll (a interpretação decimal é 3). Então, # ll00 = l; e # ll0l = l; é
o mesmo que # ll32 = 3; exceto que as duas saídas são disparadas
simultaneamente no segundo caso. É uma questão de escolha individual /
exigência se os sinais são lidos / escritos pelo programa um por um ou
simultaneamente. A lista completa de variáveis é fornecida abaixo. (Sinais de
32 bits também estão disponíveis. Eles não são descritos aqui porque são
raramente usados).

Variáveis de sistema para sinais de interface de entrada


# l000 a # l0l5, # l032: # l000 a # l0l5 são sinais de bit único.
# l032 é um sinal de l6 bits, cujo
bits individuais (a partir da direita)
correspondem a # l000 a # l0l5. Estes
são variáveis somente leitura.

Variáveis de sistema para sinais de interface de saída


# 1100 a # 1115, # 1132: # 1100 a # 1115 são de um único bit
sinais. # 1132 é um sinal de l6 bits
cujos bits individuais (a partir de
à direita) correspondem a # 1100
para # lll5. Estes são de leitura / gravação
variáveis.
Os valores decimais de # l032 e # ll32 (todas as outras variáveis são
0 ou l) seria dado pelas seguintes equações:

l5
# l032 =∑, # [l000 + i] x 2i
i=O

l5
# ll32 = ∑, # [ll00 + i] x 2i
i=O

onde os termos individuais do lado direito seriam 0 ou 2i, dependendo se o


sinal correspondente é 0 ou l. A correspondência entre essas variáveis e os
sinais F e G é dada na Tabela 3.l.

Valores de deslocamento de geometria e desgaste


Os valores especificados de geometria e deslocamento de desgaste são
armazenados em determinadas variáveis do sistema. Estas variáveis são
descritas abaixo para

versões de controles da série Oi que usam o que é chamado Tipo de Memória


C. Para uma versão de controle mais antiga (ou seja, para aqueles que usam
memória Tipo A ou Tipo B), consulte o manual da máquina. Como existe uma
diferença na geometria da ferramenta em tornos e fresadoras, as variáveis do
sistema para as diversas distâncias de deslocamento possuem diferentes
significados nesses dois tipos de máquinas. Normalmente, os números de
deslocamento de 64 (série # 2000) ou 99 (série # l0000) em um torno (série #
l0000 também podem ser usados para 64 números de deslocamento) e
números de deslocamento 200 (série # 2000) ou 400 (série # l0000) em uma
fresadora (a série # l0000 também pode ser usada para 200 números de
correção) estão disponíveis. Isto é, no entanto, é melhor usar a série # l0000,
porque seu alcance é maior e ela também pode ser usada para o intervalo mais
baixo. A série # 2000 foi usada em versões mais antigas de controle. A série #
l0000 foi introduzida com o propósito de aumentar os números de offset, o que
também permite um aumento adicional além de 99 (em tornos) e 400 (em
fresadoras) em futuras versões de controle. Se for feita uma tentativa de ler /
gravar variáveis do sistema indefinidas, uma mensagem de erro, "NÚMERO
VARIÁVEl IlEGAl" é exibida. Por exemplo, um comando como # l = # l0065;
daria um mensagem de erro em um torno com 64 offsets disponíveis. As
tabelas 3.2, 3.3 e 3.4 mostram as variáveis do sistema para vários valores de
offset em máquinas de torno e fresadoras. Quando a configuração de
deslocamento é feita, as variáveis de sistema correspondentes armazenam
automaticamente as respectivas distâncias de deslocamento. Estes são de
leitura / gravação variáveis, por isso também é possível alterar os valores de
deslocamento modificando essas variáveis. Isso pode ser feito executando,
digamos, # l500l = 5; no modo MDI ou memória, que irá definir o valor
especificado (5, neste exemplo) como o valor de deslocamento da geometria
do eixo X correspondente ao número de correção l, em um torno. Para
modificar valores de offset durante a execução do programa, o
Variáveis do sistema apropriadas não precisam ser redefinidas explicitamente.
É possível modificar os valores de correção (e, portanto, as variáveis de
sistema associadas também) através do comando de entrada de dados
programável, Gl0,
que é descrito no cap. l3. GlO também pode ser comandado no modo MDI.
Como um erro na especificação de valores de offset produz partes defeituosas,
e um erro grave pode até causar um acidente na máquina, a modificação de
offset não deve ser feita durante a execução automática de um programa, a
menos que seu efeito seja totalmente verificado testando primeiro o efeito da
modificação no modo MDI. Para isso, execute primeiro o comando de alteração
de deslocamento (designação direta ou através de GlO) e o código T no modo
MDI e, em seguida, verifique a exibição da posição depois de colocar
manualmente a ferramenta em uma posição conhecida. Em uma fresadora, o
código de compensação do comprimento da ferramenta (G43 / G44) também
terá que ser executado para verificar o valor de correção do comprimento da
ferramenta. O raio da ferramenta (raio do nariz e direção da ponta em um
torno) pode ser visto simplesmente nas tabelas de deslocamento para
verificação de seu valor.
Quantidade de turnos do sistema de coordenadas da peça de trabalho
Os sistemas de coordenadas da peça de trabalho, definidos por G54 etc.,
podem ser deslocados pelas quantidades desejadas ao longo dos eixos X e /
ou Z, através da tela de troca da peça de trabalho em um torno. Tal instalação
não está disponível em uma fresadora. Pressione a soft key de extensão direita
duas vezes na tela offset / ajuste, para obter a tela de troca da peça de
trabalho. Tal mudança, que se aplica a todas as operações subseqüentes da
máquina até que o valor do turno seja alterado, é útil para mudar o sistema de
coordenadas da peça definido (pelo valor do deslocamento, na direção oposta)
sem alterar as distâncias do deslocamento. Por exemplo, se a exibição de
posição for l00 e -50 (para os eixos X e Z, respectivamente, em um torno), um
deslocamento de + l nas direções X e Z mudaria o sistema de coordenadas em
l mm na direção negativa X e Z, alterando o
exibição de posição para l0l e -49, respectivamente. O deslocamento
especificado aplica-se uniformemente a todos os sistemas de coordenadas da
peça, definidos por G54, G55, etc. As variáveis do sistema associadas são
fornecidas na Tabela 3.5. Estas são variáveis de leitura / gravação. Por
exemplo, para especificar um deslocamento de + l para o eixo X, defina # 250l
= l. Da mesma forma, para ler a quantidade de deslocamento para o eixo X,
defina # l = # 250l e leia o valor da variável # l em a tela da variável de macro.

Alarmes Macro
Alarme refere-se a uma condição de erro que finaliza a execução da operação
atual. Pressionando a tecla MESSAGE no painel MDI
mostra a mensagem de erro. A condição de alarme pode surgir devido a vários
motivos, incluindo problemas de hardware com a máquina. A continuação da
operação na máquina só é possível após a correção do problema e, em
seguida, pressionar a tecla RESET. Um erro de sintaxe no programa, valores
fora da faixa, entrada ilegal de dados, etc., são condições de erro relacionadas
ao software. O CNC emite automaticamente um alarme nesses casos. Há, no
entanto, situações em que o controle não detectará o erro, mesmo que a
execução do programa deva ser finalizada. Por exemplo, um sistema de
análise instalado na máquina pode detectar a quebra da ferramenta, exigindo a
finalização imediata da execução do programa, embora o controle não
reconheça esse problema. Para lidar com esses casos, também foi previsto
provisionar alarmes gerados pelo usuário, que são chamados de alarmes de
macros. Quando um valor de 0 a 200 é atribuído à variável de sistema # 3000,
a máquina para com a mensagem de alarme "MACRO AlARM". O número de
alarme exibido é 3000 mais o número atribuído a ele. Assim, # 3000 = l;
terminará a operação atual e exibirá "300l AlARME MACRO" quando a tecla
MENSAGEM for pressionada. Também é possível exibir uma mensagem
especificada pelo usuário de até 26 caracteres como mensagem de alarme,
digitando-a entre parênteses, após o valor atribuído à variável # 3000.

Exemplo:

# 3 000 = l (FERRAMENTA QUEBRADA);


que exibiria "300l TOOl BROKEN" na tela de mensagens.

Informação do Tempo

As variáveis do sistema para informações relacionadas ao tempo são


fornecidas na Tabela 3.6.
Variáveis # 300l e # 3002 são variáveis de leitura / gravação, enquanto # 30ll e
# 30l2 são variáveis somente leitura. Portanto, não é possível alterar a data ou
hora atual por meio dessas variáveis.

A data / hora atual só pode ser ajustada / alterada na configuração de hora


tela, que é chamada de temporizador / tela de contagem de peças. (Selecione
o modo MDI --7 Pressione a tecla OFS / SET --7 Pressione a tecla programável
DEFINIR --7 Pressione a tecla da página para baixo duas vezes --7 Usando as
teclas de seta para cima / para baixo / esquerda / direita, coloque o cursor na
hora ou data, digite o novo valor e pressione a tecla INPUT.) Essa tela também
exibe algumas informações relacionadas ao tempo, como tempo de ligação e
tempo de corte, no formato hora-minuto-segundo. Informações sobre contagem
de peças (o número de peças necessárias e o número de peças produzidas)
também são exibidas nesta tela. Isso é discutido na seção "Número de peças
usinadas". Controle Automático de Operação O comutador de bloco único no
MOP pode ser usado para executar um programa bloco a bloco, ou seja, um
bloco por vez. Para executar o próximo bloco, o botão CYClE START deve ser
pressionado novamente.
No entanto, é possível desativar esse comutador através da variável de
sistema # 3003.

Outra característica, que é controlada pela variável # 3003, diz respeito à


conclusão de funções auxiliares (código M, S e T), especificadas em um bloco
que também possui um G-eode. Os G-eodes permitem a especificação de
códigos auxiliares no mesmo bloco. Se a execução do G-eode inicia
imediatamente ou aguarda que a conclusão do comando auxiliar seja decidida
por esta variável. Por exemplo, se GOl XlOO S5OO; é comandada, a
interpolação linear pode iniciar imediatamente, sem esperar que o spindle atinja
500 rpm, ou pode esperar até que a rpm especificada seja atingida. Observe
que o código T possivelmente não pode ser usado para trocar a ferramenta
durante a usinagem, devido a uma possível interferência entre a ferramenta e a
peça de trabalho ou o corpo da máquina. O único uso do código T, em tal caso,
seria para alterar o número de correção da ferramenta (por exemplo, T0l0l,
TOlll, T0ll2, etc., com a ferramenta número l na posição de corte, em um torno
mecânico). Mesmo se os códigos auxiliares forem especificados em um bloco
separado, a execução do próximo bloco pode ou não aguardar a conclusão do
comando auxiliar, dependendo da configuração da variável # 3003.
A Tabela 3.7 mostra o efeito de atribuir os quatro valores permitidos a essa
variável. Quando a máquina é ligada, o valor desta variável é 0,
independentemente do seu valor na sessão de usinagem anterior. Outra
variável do sistema, # 3004, controla os interruptores de avanço de
alimentação e override de alimentação no MOP, bem como a verificação de
parada exata executada internamente pelo controle no final de um movimento
de corte. Pressionar o botão de retenção de avanço interrompe o movimento
da ferramenta sem encerrar a execução do programa. O movimento da
ferramenta recomeça assim que o feed
botão de espera é liberado. A chave de cancelamento de alimentação permite
uma taxa de avanço de 0 a 254% do valor programado (ou menos,
dependendo das máquinas-ferramentas específicas), exceto no encadeamento,
onde é automaticamente desativado pelo controle (isto é, permanece fixo em
l00%). A verificação de parada exata é executada pelo controle para garantir
que a ferramenta atinja o ponto comandado dentro da tolerância especificada.
Isso diminui o desempenho da máquina um pouco. Então, se muita precisão
não for desejada para uma operação de corte em particular (por exemplo,
corte, que deve ser seguido por um corte de acabamento), esta verificação
pode estar temporariamente desativada. A Tabela 3.8 mostra o efeito da
variável # 3004 na retenção de feed, no override de feed e na verificação de
parada exata. Quando a máquina é ligada, o valor desta variável é
automaticamente feito 0 pelo controle, independentemente do seu valor na
sessão de usinagem anterior.
Pausa de Execução

A variável de sistema # 3000 gera uma condição de alarme e termina a


execução do programa, enquanto a variável # 3006 causa uma pausa
temporária de execução, que pode ser reiniciada pressionando o botão CYClE
START novamente. No estado pausado, pressionar a tecla MESSAGE exibe a
mensagem especificada pelo usuário (até 26 caracteres). Atribuir um número à
variável # 3006 interrompe a execução do programa. Não há significado para
este número, porque o número da mensagem não é exibido. Então,
normalmente, l é atribuído.
Exemplo:
# 3006 = 1 (VER O DIÂMETRO);
Isso interromperia temporariamente a execução e exibiria "CHECK THE
DIAMETER" na tela de mensagens. Se nenhuma mensagem for digitada, nada
será exibido. Informação de Imagem Espelhada
Além do comando de imagem de espelho programável, também é possível
obter perfis de imagem de espelho usando comutadores externos no MOP
(existem interruptores separados para eixos diferentes) ou através da tela de
definição de imagem de espelho. (Selecione o modo MDI ~ Pressione a tecla
de função OFS / SET ~ Pressione a tecla programável SETTING ~ Agora,
depois de pressionar a tecla page down, a tela de imagem espelhada
aparecerá, na qual selecione l para ativar o botão
imagem espelhada para um determinado eixo.) O status da imagem espelhada
de cada eixo é armazenado em uma variável do sistema somente de leitura #
3007. Esta é uma variável do tipo bit, mas armazena o valor na forma decimal.
Por exemplo, 000000ll (em que l indica imagem espelhada ativada e 0 indica
imagem espelhada desativada) é armazenado como 3. Portanto, o valor
armazenado nessa variável precisa ser convertido em binário
para interpretá-lo. Por exemplo, um valor de 3 indica que a imagem de espelho
está ativada para os dois primeiros eixos. A Tabela 3.9 mostra as
configurações de bits para essa variável. Em um torno, o primeiro e o segundo
eixo referem-se aos eixos X e Z, respectivamente, e em uma fresadora, os três
primeiros eixos referem-se aos eixos X, Y e Z, respectivamente. Eixos
adicionais podem ou não estar disponíveis em uma determinada máquina.
Apenas os primeiros quatro bits dessa variável
são usados para a série Fanuc Oi. Número de peças usinadas
O número de peças necessárias e o número de peças concluídas na sessão de
usinagem atual podem ser lidos ou gravados em variáveis do sistema

# 3902 e # 390l, respectivamente. Informações sobre contagem de peças


também podem ser vistas / modificadas na tela temporizador / contagem de
peças, ou através dos parâmetros 67l3 e 67ll, que armazenam o número de
peças necessárias a serem produzidas e o número de peças produzidas,
respectivamente. O temporizador / tela de contagem de peças também exibe o
número total de peças produzidas durante todo o tempo de serviço da
máquina, como informações somente leitura. Sempre que uma peça é
completada, tanto o número de peças produzidas quanto o número total de
peças produzidas são incrementados em l. Enquanto o número de peças
requerido e completado pode ser alterado (através das variáveis de sistema
associadas, configurações de parâmetros ou a tela de configuração ), como e
quando desejado, o número total de peças concluídas só pode ser alterado
através do parâmetro 67l2. Essas informações foram disponibilizadas para
manter um registro do número total de peças produzidas durante todo o tempo
de serviço da máquina. A configuração padrão (parâmetro 6700 # 0 = 0) da
máquina incrementa a contagem de peças em l sempre que M02, M30 ou o
número do código M especificado no parâmetro 67l0 (que normalmente contém
apenas 30, significando M30) é executado. Se for desejado incrementar a
contagem de peças somente após o código-M especificado no parâmetro 67l0
ser executado (que pode ser o mesmo ou diferente de 02 ou 30, mas não 0, 98
ou 99), defina
parâmetro 6700 # 0 = l. Por fim, observe que M02 ou M30 devem ser digitados
com o símbolo de fim de bloco (EOB) (ou seja, como M02; ou M30;), caso
contrário, a contagem de peças não será aumentada, embora a peça seria
produzida sem qualquer mensagem de erro (o controle permite o símbolo EOB
ausente no final do programa). Informações Modais Os G-eodes foram
categorizados em diferentes grupos com base na similaridade na
funcionalidade. A qualquer momento, um G-eode de cada grupo (exceto o
Grupo 0) permanece ativo. Aqueles pertencentes ao Grupo 0 são chamados de
códigos não-modais, que permanecem efetivos apenas no bloco onde estão
programados. Outros códigos são códigos modais, que permanecem em vigor
até serem substituídos por algum outro código do mesmo grupo. Por exemplo,
G0l é um código modal, agrupado com GOO, G02, G03, etc.
G0l é usado uma vez no programa, não precisa ser digitado novamente, se os
movimentos subsequentes forem executados com interpolação linear. No
entanto, assim que G02 (ou algum outro código do mesmo grupo) é
comandado, G0l é cancelado e G02 se torna ativo. Durante a programação,
especialmente ao usar macros de uso geral, que devem ser usadas com vários
programas, pode ser necessário conhecer o G-eode ativo de um grupo
específico. Por exemplo, referindo-se a uma fresadora, se o programa principal
chamar uma macro no modo incremental, a macro deve interpretar os valores
na lista de argumentos de chamada da macro como sendo valores
incrementais. A macro deve funcionar corretamente nos casos de ambos os
modos absoluto e incremental do programa de chamada. Isso só seria possível
se essas informações estivessem disponíveis durante a execução da macro. A
variável do sistema # 4003 armazena 90 ou 9l dependendo se o modo absoluto
ou incremental está atualmente ativo. A macro pode ler isto para ter
informações sobre o modo ativo. Por exemplo, vamos supor que a variável
número l da macro represente a posição absoluta do eixo X e obtenha um valor
através da lista de argumentos da chamada de macro. Então, para cuidar do
possível modo incremental do programa principal no momento de chamar a
macro, a seguinte instrução no início da macro precisaria ser inserida (IF
_THEN_ é descrita no Capítulo 5):
SE [# 4003 EQ 9l] ENTÃO # l = # 504l + # l;
A variável de sistema # 504l armazena a posição atual da ferramenta ao longo
do eixo X, conforme descrito na Tabela 3.ll.
As variáveis do sistema para várias informações modais da série Fanuc Oi são
fornecidas na Tabela 3.l0 (a) e (b). As colunas vagas são para

outras versões do Fanuc. Essas variáveis do sistema são, obviamente, apenas


variáveis de leitura. Note que todos os G-eodes de uma determinada versão de
controle podem não estar disponíveis em uma máquina específica. Alguns G-
eodes são recursos opcionais do controle (que precisam ser adquiridos
separadamente) e outros não podem ser usados devido à limitação de
hardware da máquina-ferramenta.
O parâmetro 6006 # l (nos controles da máquina fresadora Fanuc Oi) decide se
a informação modal obtida através das variáveis do sistema (# 400l a # 4022) é
até o bloco imediatamente anterior (que é a configuração padrão) ou até a
execução atual. quadra:

6006 # l = 0 (até o bloco imediatamente anterior)


6006 # l = l (até o momento da execução b trava)

O controle realça automaticamente o bloco atualmente em execução na tela.


Este parâmetro, no entanto, não está disponível no torno onde as informações
do modelo estão disponíveis até o último bloco executado.
Posição atual da ferramenta
As variáveis do sistema, que armazenam informações sobre a posição atual da
ferramenta, são fornecidas na Tabela 3.ll. Estas são todas as variáveis
somente leitura.
Observe o seguinte:
• O primeiro dígito da direita (l, 2, 3 ou 4) representa um eixo
número. Então, em um torno de 2 eixos, l representa o eixo X, 2 representa
o eixo Z e os dois restantes não são usados. este
também se aplica às Tabelas 3.l2 e 3.l3.
• A posição da ferramenta onde o sinal de pulo é ligado em um G3l
O bloco (função skip) é armazenado nas variáveis # 506l a # 5064.
Quando o sinal de pulo não é ligado durante o curso de
movimento da ferramenta sob G3l, o ponto final especificado neste
bloco é armazenado nessas variáveis.
• Determinadas variáveis, como as da posição atual da ferramenta,
não pode ser lido enquanto a ferramenta está em movimento. Os valores
armazenados em
eles só podem ser lidos quando o movimento da ferramenta parar. Então o
"posição atual" não é realmente a posição instantânea.

Valores de compensação de trabalho


Consulte a Sec. 5.5 para uma discussão detalhada sobre como as distâncias
de deslocamento para vários sistemas de coordenadas da peça de trabalho
são definidas. As distâncias de deslocamento do trabalho medido são
armazenadas em determinadas variáveis do sistema. Estas são variáveis de
leitura / gravação. Portanto, também é possível alterar as distâncias de
deslocamento modificando o conteúdo dessas variáveis. A Tabela 3.l2 explica
a função dessas variáveis. A Tabela 3.l3 mostra números variáveis alternativos
que também podem ser usados em fresadoras, para distâncias de
deslocamento de trabalho.
CAPITULO 4
Funções Macro

4.1 Tipos de Funções Macro

A programação macro está equipada com todos os métodos matemáticos


comumente usados. funções que normalmente estão disponíveis em um
computador de alto nível linguagem de programação. As funções de macro
disponíveis podem ser separadas em grupos, para facilitar seu entendimento e
uso aprender. Existem, em geral, cinco grupos, além da aritmética usual
operações:

• Funções trigonométricas
• funções de arredondamento
• funções diversas
• funções lógicas
• funções de conversão

Um valor pode ser atribuído a uma variável (ou uma expressão que avalia para
um número variável legal) usando qualquer combinação (que deveria, claro,
estar logicamente correto) dessas funções. Um não atribuído. A variável
(indefinida) é chamada de variável nula que é equivalente a 0 em cálculos
matemáticos. Então, como regra geral, uma variável não deve ser usada em
qualquer expressão matemática sem primeiro defini-lo.

Prioridade de Operações em Expressões Aritméticas

Em uma expressão complexa, envolvendo várias funções e colchetes, a


seguinte regra de prioridade é seguida:

l. Suportes (apenas colchetes são permitidos)


2. Funções (como SIN, ATAN, SQRT e EXP)
3. Multiplicação (*), divisão (/) e bit a bit E
4. Adição (+), subtração (-), bit a bit OR e bit a bit XOR.

Se mais de uma operação de igual prioridade aparecer em uma linha, o cálculo


é feito da esquerda para a direita.

Exemplos:
2+2I2
[2 + 2] eu 2
2I2I2
(Retorna 3)
(Retorna 2)
(Retorna 0,5)
Prioridade de Operações em Expressões Booleanas
Uma expressão booleana pode ter expressões aritméticas (dentro do quadrado
parênteses) à esquerda e à direita do operador condicional.
As regras de prioridade são seguidas dentro de cada suporte
independentemente:

[[2 + 2 I 2] lT [2 + 2]] (Equivalente a [3 lT 4], que


retorna VERDADEIRO)

A expressão aritmética à direita de um operador condicional


deve ser colocado entre parênteses, mas os parênteses à esquerda são
opcional:

[2 + 2 I 2 lT [2 + 2]] (O mesmo que acima, portanto, retorna TRUE)


[2 + 2 I 2 lT 2 + 2] (Após avaliar a expressão aritmética em
a esquerda, que retorna 3, avaliação adicional é
feito da esquerda para a direita. Então, a afirmação é
equivalente a FAlSE + 2, que é
sem sentido e, portanto, ilegal)

Saltar colchetes em expressões booleanas (mesmo que não forneça um erro,


em alguns casos) é uma fonte de confusão. Portanto, é uma boa prática de
programação usar colchetes em ambos os lados de operadores condicionais,
bem como colchetes externos para toda a expressão.

Efeito da ordem de cálculos


Em alguns casos, a ordem de cálculo não altera o significado matemático de
uma expressão aritmética e, portanto, o mesmo resultado final é esperado. No
entanto, em certos casos de valores extremamente grandes ou extremamente
pequenos, a ordem de cálculo pode se tornar muito importante:

# l = l0000000; (Atribui um valor de l0 ^ 7 a # l)

# l = # l * # l * # l * # l * # l * # l; (Atribui um valor de l0 ^ 42 a # l)
# l = # l * l00000; (Atribui um valor de l0 ^ 47 a # l, que é o
maior valor legal)
# 2 = # l I l0 * l0; (Conjuntos # 2 = l0 ^ 47)
# 3 = # l * l0 I l0; (Embora a expressão no RHS seja
matematicamente o mesmo que o anterior
expressão, o primeiro cálculo do
esquerda dá l048 o que causaria dados
estouro, terminando o programa
execução. Nestes casos, os parênteses
podem ser usado para alterar a ordem de cálculo)

# 4 = # l * [l 0 I l0 l; (Conjuntos # 4 = l0 ^ 47)
Aninhamento de Suportes

A aninhamento dos parênteses é permitida até um máximo de cinco níveis (isto


é, cinco parênteses esquerdos e cinco aninhados direitos podem ser usados),
incluindo os parênteses usados com funções como SIN [<um número variável
ou um valor aritmético ou uma aritmética expressão> l SQRT [<um número
variável ou um valor aritmético ou uma expressão aritmética> l O cálculo
começa dos colchetes mais internos e prossegue para os colchetes mais
externos, um por um. O exemplo dado na Fig. 4.l é trivial, mas mostra o nível
máximo possível de aninhamento e explica a ordem de cálculo. Não há
limitação no número total de colchetes em uma expressão. A mesma
expressão pode ter aninhamento em vários locais, sendo cada aninhamento
restrito a um máximo de cinco níveis.

Operaçoes aritimeticas

Os quatro operadores aritméticos, adição (+), subtração (-), divisão (/) e


multiplicação (*), carregam significados usuais e fornecem resultados de tipo de
cálculo. De fato, estes já foram usados em vários exemplos. A única coisa que
precisa ser repetida aqui é que o controle não diferencia entre números reais e
inteiros. De fato, todos os números são tratados como números reais, em
cálculos. Assim,

# l= l / 2.
# l= l. 0 / 2;
# l= l / 2.0;
# l =l.0 / 2.0;

são todos equivalentes e atribuem um valor de 0,5 a # l.

Outro ponto a mencionar é sobre a precisão dos valores calculados. Como os


cálculos são feitos usando um número limitado de dígitos binários,
normalmente um erro de l0 a l0 é introduzido em cada operação aritmética.
Isso é insignificante porque a precisão da máquina é de apenas 0,00l mm no
modo milímetro. No entanto, em instruções de comparação de igualdade, isso
pode criar problemas, pois os valores podem não ser exatamente iguais, até
todos os dígitos decimais.

Então, ao invés de usar

SE [# l EQ # 2] THEN # 3 = l0;
usar
SE [ABS [# l - # 2] lT 0,00l) THEN # 3 = l0;

assumindo 0.00l é o erro aceitável (ou então, escolha um valor ainda menor).
Declarações condicionais são explicadas em detalhes no Cap. 5

Função de divisão versus bloqueio de bloco


O símbolo de barra (/) é usado tanto para divisão quanto para a função de
bloqueio de bloco. Normalmente, uma barra no início de um bloco é
interpretada como o símbolo block-skip e, no meio de um bloco, é considerada
como o operador de divisão. No entanto, alguns controles (incluindo o Fanuc)
permitem o salto no meio do bloco também. Isso pode dar resultados
inesperados. Então, em tais controles, coloque a operação de divisão entre
parênteses:

# l= l0;
# 2= # l / 2;
# 3= [# l / 2];

(A barra pode ser interpretada como o símbolo block-skip. Portanto, o nº 2 é


ajustado para l0, se o interruptor de salto do bloco no MOP estiver ligado)
(# 3 é sempre definido como 5, mesmo que o salto de meio bloco seja
permitido
e o comutador de salto de bloco está aceso) Alguns modelos de máquinas-
ferramenta não têm interruptores de salto de bloco. Em tais máquinas, a barra
é sempre interpretada como o operador de divisão; como tal, não há
necessidade de usar colchetes para divisão.

4.3 Funções trigonométricas

As funções disponíveis são

Seno
Cos
tang
Asen
Acos
Atang

representando seno, cosseno, tangente, arco seno (sin-l), arco cosseno (cos-l)
e arco-tangente (tan-l), respectivamente, iguais aos encontrados em
calculadoras científicas. Todas as entradas para SIN, COS e TAN estão em
graus, e as saídas das funções inversas ASIN, ACOS e ATAN também estão
em graus. Então, se um ângulo é dado no formato grau / minuto / segundo, ele
precisaria ser convertido em graus usando a fórmula de conversão

nde D, M e S são valores de graus, minutos e segundos do ângulo


especificado, respectivamente, e Dd é o valor convertido em graus.

Exemplo:

l0 ° 30 '36 "= l0 + 0,5 + 0,0l = l0,5l °

Como todas as outras funções, as funções trigonométricas também devem ser


usadas com colchetes. Os colchetes podem conter uma constante, um número
variável ou uma expressão aritmética. Observe que o ATAN usa uma maneira
incomum de representação - os dois lados (perpendicular e base) do triângulo
retângulo precisam ser especificados dentro de colchetes separados,
separados por uma barra:

# l = SIN [30]; (Conjuntos # l = 0,500)


# 2 = ACOS [# l]; (Conjuntos # 2 = 60.000)
# 3 = TAN [# 2 * 3 I 4]; (Conjuntos # 3 = l.000)
# 4 = ATAN [SQRT [3]] / [# l * 2]; (Equivalente a tan-l 3 ^ l/2. Então, define # 4 =
60.000)
# 5 = TAN [90]; (Erro de estouro, desde 90 ° = infinito)

Note que, como outras funções macro, as funções trigonométricas


também são precisos até cerca de oito dígitos decimais. Por exemplo, ACOS
[0.5] na verdade retorna 59.999999 no controle Fanuc Oi. Tais imprecisões
pode ser encontrado em todas as funções trigonométricas, mesmo que não
explicitamente mencionado nos exemplos dados aqui. A representação do
ATAN é uma característica única da programação de macros, que sempre dá o
valor correto do ângulo, mesmo se não é um ângulo agudo (ASIN e ACOS são
principalmente úteis para ângulos):

# 5 = ATAN [l] / [l]; (Conjuntos # 5 = 45.000)


# 6 = ATAN [l] / [-l]; (Conjuntos # 6 = l35.000)
# 7 = ATAN [-l] / [-l]; (Conjuntos # 7 = 225.000)
# 8 = ATAN [-l] / [l]; (Conjuntos # 8 = 3l5.000)
# 9 = ATAN [l]; (Erro de sintaxe)

Quando o parâmetro 6004 # 0 está definido como 0, o intervalo de solução de


ATAN é de 0 ° a 360 °, como nos exemplos anteriores. Quando 6004 # 0 é
definido como l, o o alcance se torna de -l80 ° a l80 ° (note que o ângulo
permanece o mesmo, apenas a sua representação muda):

# l0 ATAN [l] eu [l]; (Conjuntos # l0 = 45.000)


# ll ATAN [l] eu [-l]; (Conjuntos # ll = l35.000)
# l2 ATAN [-l] I [-l]; (Conjuntos # l2 = -l35.000)
# l3 ATAN [-l] eu [l]; (Conjuntos # l0 = -45.000)

Como outras funções, não há necessidade de incluir a função ATAN com


colchetes externos em cálculos aritméticos:

# l4 = ATAN [l] eu [l] eu [l + l]; (Conjuntos nº l4 = 22,500)

O parâmetro 6004 # 0 não afeta ASIN ou ACOS. Independentemente da


configuração 6004 # 0, a faixa de solução de ASIN é de 270 ° a 360 ° e 0 ° a 90
°, enquanto a faixa de ACOS é de 0 ° a l80 °. Assim, ASIN nunca daria uma
resposta no segundo ou terceiro quadrante. Da mesma forma, ACOS não dá
uma resposta no terceiro ou quarto quadrante:

# l5 ASIN [O. 5]; (Conjuntos l5 = 30.000)


# l6 ASIN [-0,5]; (Conjuntos # l6 = 330.000)
# l7 ACOS [0,5]; (Conjuntos # l7 = 60.000)
l8 ACOS [-0,5]; (Conjuntos # l8 = l20.000)

Então, para evitar qualquer confusão, resultando em uma resposta inadequada,


Recomenda-se a utilização de ATAN sempre que o ângulo possa variar em
todo o intervalo de 0 ° a 360 °.
A magnitude do valor (ou seja, o valor absoluto) especificado para ACOS e
ASIN deve ser menor ou igual a l, caso contrário, geraria uma condição de
alarme, encerrando a execução do programa. Os ângulos para SIN, COS e
TAN podem ser positivos ou negativos e podem até ser maiores que 360 °.
Praticamente, não há limite superior para o ângulo. O controle Fanuc Oi
permite um valor máximo de l048575.999 °. O ângulo correspondente na faixa
de 0 ° a 360 ° é calculado subtraindo múltiplos de 360 do ângulo especificado.
Por exemplo, l048575.999 = 29l2 X 360 + 255.999 que é equivalente a 255.999
°.
Como a precisão das funções trigonométricas é tipicamente lQ-8, um cálculo
como o SIN [OJ não retorna 0. Alguns resultados típicos de cálculo são

SIN [O] (Retorna -0,46566l29 x lQ-8)


COS [90] (retorna 0,37252903 x l0-a)
TAN [O] (retorna -0,46566l28 x l0-8)

Devido à limitação da tela, que pode mostrar apenas oito dígitos decimais e
não inclui nenhum dígito exponencial, estes os valores são exibidos como
*********, mas usados "corretamente" em cálculos subsequentes:

l eu SI N [0] (retorna 2l4748370.0)

A inexatidão deste nível não é importante para o propósito de uma máquina


CNC porque a precisão da máquina é tipicamente 0,00l no modo milímetro e
0,000l no modo polegada. Não importa o quão complexo e extensivo seja o
cálculo, o erro resultante provavelmente será muito menor que a precisão da
máquina. No entanto, como já sugerido, o programador deve evitar a
comparação direta de igualdade, digamos, do SIN [O] com zero. Em vez disso,
se necessário, a diferença nos valores deve ser testada em relação a um valor
pequeno escolhido:

[SIN [O] EQ 0] (FAlSE, então não use este formato)

[ABS [SIN [O] - 0] lT 0,000000l] (VERDADEIRO, daí o formato recomendado)

Enquanto o programador entender as implicações de tais imprecisões, nenhum


problema surgirá. No entanto, o parâmetro 6004 # l pode ser usado para
normalizar o resultado para 0 sempre que o valor calculado de SIN, COS e
TAN for menor que l0 s. Quando 6004 # l é definido como l (sua configuração
padrão é 0),

SIN [O] (retorna 0)


COS [90] (retorna 0)
TAN [O] (retorna 0)
l / SIN [O] (a execução termina com uma mensagem de alarme "DIVIDED BY
ZERO").

4.4 Funções de arredondamento

O arredondamento é de dois tipos: arredondamento implícito e arredondamento


explícito. O arredondamento implícito é feito automaticamente pelo controle,
para se adequar ao endereço específico. Vários desses casos já foram
discutidos no cap. 2. Alguns exemplos semelhantes são dados aqui para
atualizar a memória (consulte o Capítulo 2 para obter detalhes):

# l = SQRT [2]; → (SQRT 2 = l,4l42l356237 ... O controle usa apenas oito


dígitos decimais, com número adequado de zeros à esquerda ou à direita, para
salvar um número. Então, o valor salvo é l,4l42l36).

# l.5000000 = l; → (Equivalente a # 2 = l).

M2 5 Sl000,4; → (Declaração ilegal).

M [2. 5] S [l000. 4]; → (Equivalente a M03 Sl000; arredondamento é feito


somente se o número estiver entre colchetes).

G [2. 5]; → (Nunca use um G-eode desta maneira. Ele será um comando ilegal
ou pode causar uma ferramenta inesperada movimento, causando acidentes).

# 3 = 2 .4;
# 4 = 2,04;
M # 3; (Equivalente a M02)
G # 3; (Declaração ilegal)
G # 4; (Equivalente a C02)
# 5 = l 23. 45 678;
GOO X # 5; (Equivalente a GOO Xl23.457 em modo milimétrico)
Como uma boa prática de programação, nunca se deve confiar
arredondamento implícito, pois isso é altamente propenso a erros. Se o
programador não entender claramente a lógica construída no controlador,
poderá ocorrer um comportamento inesperado da máquina. O arredondamento
implícito deve ser feito apenas com a finalidade de usar um número real como
um número inteiro, descartando zeros após o ponto decimal (por exemplo, l.0
sendo convertido em l). Por exemplo, G # l é equivalente a GOl, se o valor
armazenado em # l for l, l., l.0 ou l.0000000. De fato, isso se torna necessário
porque o controle não define uma variável como uma variável inteira; todas as
variáveis armazenam números reais.

ROUND, FIX e FUP

Três funções estão disponíveis para arredondamentos explícitos: ROUND, FIX


e FUP. Eles são usados para arredondar um número real para o inteiro mais
próximo, o inteiro inferior e o inteiro superior, respectivamente. A operação
dessas funções é semelhante à de uma linguagem de programação típica de
alto nível, exceto pelo fato de que o controle do CNC salva a resposta inteira
como um número real com zero após o ponto decimal!

Exemplos:
ROUND [lO.O] (retorna l0,0)
RONDA [l0.2] (retorna l0,0)
RODADA [l0.499999] (retorna l0.0)
RODADA [l0.5] (retorna ll,0)
Rodada [l0.8] (retorna ll.0)
CORRECÇÃO [lO. O] (retorna l0,0)
CORRECÇÃO [l0,2] (retorna l0,0)
CORRECÇÃO [l0. 499999] (retorna l0,0)
CORRECÇÃO [l0. 5] (retorna l0,0)
CORRECÇÃO [l0.8] (retorna l0,0)
FUP [lO.O] (retorna l0,0)
FUP [lO. OOOOOl] (retorna ll,0)
FUP [l0.2] (retorna ll,0)
FUP [l0.499999] (retorna ll.0)
FUP [l0. 5] (retorna ll,0)
FUP [l0. 8] (retorna ll,0)

O resultado de operar essas funções em um número negativo é o mesmo que


no caso de um número positivo, exceto que o sinal negativo é retido:

RODADA [-l0.2] (retorna -l0,0)


ROUND [-l0.8] (retorna -ll,0)
CORRECÇÃO [-l0. 2] (retorna -l0,0)
CORRECÇÃO [-l0.8] (retorna -l0,0)
FUP [-l0.2] (retorna -ll,0)
FUP [-l0,8] (retorna -ll,0)
Funções Macro 65
Essas funções também podem ser aplicadas em variáveis que armazenam
algum valor. Os exemplos a seguir assumem que # l armazena l.3 e # 2
armazena l.7:
Rodada [# l] (retorna l.0)
Rodada [- # 2] (retorna -2,0)
CORRECÇÃO [# l] (retorna l.0)
CORRECÇÃO [- # 2] (retorna -l,0)
FUP [# l] (retorna 2,0)
FUP [- # 2] (retorna -2,0)
Também é possível arredondar um valor para o número desejado de lugares
após o ponto decimal, o que pode ser necessário para alguma aplicação
especial. Por exemplo, se l00.l2345 precisar ser arredondado para quatro
lugares após o ponto decimal, execute o seguinte procedimento:

# l l00.l2345;
# 2 # l * l0000; (Conjuntos # 2 = l00l234.5)
# 3 REDONDO [# 2]; (Conjuntos nº 3 = l00l235.0)
# 4 # 3 I l0000; (Conjuntos # 4 = l00.l2350)
# l # 4; (# l contém valor arredondado até quatro lugares
após o ponto decimal, l00.l235)

Esses comandos são fornecidos separadamente para explicar as etapas


intermediárias do cálculo. Também é possível combiná-los em um único bloco
aninhado, da seguinte maneira:

# l = REDONDO [# l * l0000] I l0000;

Para arredondar para três locais após o ponto decimal, use l000 como
multiplicador; para dois locais após o ponto decimal, use l00 e assim por diante.
Um cuidado especial é necessário ao usar a função FIX devido a uma possível
imprecisão nos cálculos macro. Por exemplo, se a variável # l contiver 0.002 e
a variável # 2 for definida como # l * l000, o valor resultante pode não ser
exatamente 2. Geralmente, ela pode ser l.9999999. Como resultado, o FIX [# 2]
retornaria l.0! Portanto, nesses casos, use a função ROUND ou modifique o
valor calculado adequadamente. Como o menor incremento de entrada da
máquina no modo milimétrico é 0,00l, é seguro adicionar 0,000l ao valor
calculado, com a finalidade de arredondá-lo para baixo. Portanto, em vez de
usar FIX [# 2], use FIX [# 2 + 0,000l], o que resolverá o problema.
Finalmente, é muito importante entender que se ROUND for usado
para alguma distância do eixo em uma instrução NC, o arredondamento é feito
até
o menor incremento de entrada da máquina. O menor incremento de entrada
no modo milimétrico é tipicamente 0,00l mm, como se supõe nos seguintes
exemplo:
# l = l00. l23 4 5;
GOO X [REDONDO [# l]]; (Coloca a ferramenta em X = l00.l23)
Na verdade, a função ROUND é redundante aqui. Como já explicado
no chap. 2, mesmo sem a função ROUND, arredondamento implícito
seria feito até o menor incremento de entrada. Então, a segunda afirmação
é equivalente a
GOO X # l;
Observe também a presença do suporte externo na função ROUND.
Se uma função ou uma expressão está sendo usada como o valor em um NC
palavra, deve ser entre colchetes é:
X ROUND [l. 2];
X [ROUND [l. 2]];
(Um comando ilegal)
(Equivalente a Xl.200)
Não é que a função ROUND seja completamente inútil em um NC
declaração (como pode ser concluído a partir do exemplo dado). Na verdade,
pode ser usado com muita eficácia para eliminar os erros de arredondamento
execução do programa. Considere o seguinte caso, com 0,00l como o
menor incremento de entrada, em uma fresadora (suponha que a corrente
a posição da ferramenta é Xl00, ao longo do eixo X):
# l = l00,23 45;
# 2 = 200,3 45 6;
G9l GOO X # l;
X # 2;
X - [# l + # 2];
(Coloca a ferramenta em X200.235)
(Coloca a ferramenta em X400.58l, porque 200.235 +
200,346 = 400,58l)
(Equivalente a X- [300,580l], que é arredondado para
X -300.580 Então, a ferramenta é colocada em XlOO.OOl, que
não é a posição inicial da ferramenta)
Embora a diferença entre a posição esperada (Xl00) e a
posição real (Xl00.00l) é muito pequena (0.00l), o que pode não ser de
preocupação prática, causará uma falha lógica em um aplicativo envolvendo
comparação de posições de ferramentas. Além disso, como o erro é
cumulativo,
é possível que, após várias operações desse tipo, a ferramenta possa
desviar da posição correta para uma extensão inaceitável. Este problema
pode ser facilmente evitado, substituindo a última declaração por
X [ROUND [# l] + ROUND [# 2]];
que é equivalente a X- [l00.235 + 200.346], isto é, X-300.58l,
que colocaria a ferramenta exatamente na posição esperada.

Observe que o arredondamento das distâncias dos eixos até o menor


incremento de entrada é feito somente se os valores forem especificados em
termos de variáveis, como nos casos discutidos acima. Um valor constante é
truncado até o menor incremento de entrada. Por exemplo, G9l GOO
Xl00.2345 moveria a ferramenta em l00,234 mm.
4.5 Funções Diversas

Funções adicionais para avaliação de raiz quadrada (SQRT), valor absoluto


(ABS), logaritmo natural (lN) e valor exponencial (EXP) estão disponíveis. Os
valores calculados são arredondados automaticamente para oito casas
decimais. SQRT e ABS possuem significados usuais e já foram utilizados em
diferentes contextos.

SQRT

Isso calcula a raiz quadrada de um dado número positivo (um número negativo
daria uma mensagem de alarme "ARGUMENTO IlEGAl"). SQRT é a única
função disponível na sua categoria. Não há função disponível para calcular,
digamos, a raiz cúbica ou o quadrado de um número. No entanto, conforme
explicado posteriormente, uma combinação de funções lN e EXP pode ser
usada para calcular qualquer expoente arbitrário de um determinado número.

Exemplos:

SQRT [-2) (argumento ilegal)


SQRT [O] (retorna 0,000)
SQRT [2] (retorna l,4l42l36)

ABS

Essa função simplesmente altera o sinal de um valor negativo e não afeta um


valor positivo.
Exemplos:
ABS [-2) (retorna 2.000)
ABS [O] (retorna 0,000)
ABS [2] (retorna 2.000)

A função ABS "aparentemente inocente" é muito útil em


vezes; alguns desses exemplos já foram discutidos. Como outro exemplo,
considere uma macro que envolve uma operação de perfuração usando G8l,
em uma fresadora. A escolha habitual para o nível ZO é a superfície superior
da peça de trabalho. Então, a profundidade do furo deve ter um sinal negativo
no bloco G8l. Portanto, quando um programa chama essa macro, um valor
negativo para a profundidade do furo deve ser passado para a macro (o
método de passar os valores desejados para as variáveis locais de uma macro
não foi discutido formalmente até agora. Portanto, sem se preocupar com o
procedimento exato, apenas tente entender o tema da discussão). Se, por
engano ou devido a um mal-entendido, um programador especificar um valor
positivo para a profundidade, o G8l começará a "perfurar" na direção Z positiva,
longe da peça de trabalho! Para se certificar de que ambos os valores positivos
e negativos funcionam igualmente bem, é necessário que o G8l use o negativo
do valor absoluto da profundidade especificada. Isso garantirá que o valor Z
para G8l seja sempre negativo. Por exemplo, se a variável nº 26 for usada para
transmitir o valor da profundidade do furo, a macro deverá usar o G8l da
seguinte maneira:

G81 X_ Y_ Z- [ABS [# 26]] R_ K_F_;

Como uma macro é supostamente um programa de uso geral que é usado


(chamado) por vários programas escritos por diferentes programadores, tais
inconsistências não são muito incomuns. Desenvolver uma macro requer um
conhecimento profundo da programação macro, que é um assunto bastante
vasto e especializado. Assim, a maioria dos programadores tem que usar as
macros desenvolvidas por especialistas, como uma caixa preta. Escrever uma
macro pode ser difícil, mas, como veremos mais adiante, usar uma macro é tão
simples quanto usar um ciclo fixo interno. Basta saber o propósito dos
diferentes endereços de letras da macro. Embora se espere que um
programador macro documente adequadamente a macro desenvolvida por ele,
inserindo comentários adequados na macro e / ou explicando seu uso em
apostilas separadas, deve-se tomar cuidado para erros comuns. Uma
abordagem profissional à programação macro visa antecipar o que pode dar
errado, antes que realmente dê errado!

lN

Esta função calcula o logaritmo natural, isto é, o logaritmo da base e


(2.7l828l8). O logaritmo da base l0 (isto é, a função lOG) não está disponível.
Se necessário, pode ser calculado usando a fórmula

log x = (ln x) / (ln l 0), isto é, lN [x] I lN [lO]

Um valor negativo ou zero para o argumento do lN é inválido, o que


daria uma mensagem de alarme "Calculado DATA OVERFlOW".

Exemplos:
lN [O] (Resultados no erro de estouro)
lN [l] (retorna 0,000)
lN [2] (retorna 0,693l472)

EXP

Esta função calcula o antilog do logaritmo natural (isto é, e). O valor máximo
admissível para o seu argumento é de cerca de ll0,2. Um valor mais alto daria
"ESTOURO DE DADOS CAlCUlADO", pois o valor calculado se aproximaria /
excederia l048 • Antilog para a base l0 (isto é, l0x) não está disponível. Se
necessário, pode ser calculado usando a fórmula.

l0x = e "ln l0, ou seja, EXP [x * lN [lO]]


Exemplos:

EXP [-2] (retorna 0,l353353)


EXP [O] (retorna l.000)
EXP [2] (retorna 7.389056l)
EXP [ll0. 2 5] (erro de estouro)

Expoente Arbitrário de um Número

Nenhuma função padrão está disponível para avaliar uma expressão na forma
xY. Pode, no entanto, ser calculado de forma indireta, usando a fórmula

x Y = eY ln x, t h é, EXP [y * lN [x]]

Exemplos:
EXP [4 * lN [3]] (Equivalente a 34, que retorna 8l.000)
EXP [4 * lN [lO]] (Equivalente a l04, que retorna l0000.000)

4.6 Funções lógicas

As funções lógicas disponíveis são AND, OR e X OR. Estes podem ser usados
de duas maneiras diferentes, como

Funções bit a bit


• funções booleanas

Funções bit a bit

Quando usadas como funções bit a bit, todos os bits correspondentes das
representações binárias dos dois números (nos quais essas funções são
operadas) são comparados individualmente e a resposta resultante no formato
binário é convertida novamente para o formato decimal. A Tabela 4.l é a tabela
de verdade das três funções. Bit l e bit 2 são os bits correspondentes dos dois
números. A Figura 4.2 fornece as representações do diagrama de Venn dessas
funções. Nesta figura, a área circular correspondente a um bit representa um
valor binário de l e a área situada fora do círculo representa o valor binário 0. A
área sombreada representa o resultado (valor binário l) da operação lógica
especificada. Esta figura também indica que todos os
três operações lógicas são associativas. Então, por exemplo, # l e # 2 é
equivalente a # 2 e # l.
Alguns exemplos de operações lógicas bit a bit são fornecidos abaixo:

# l 4 · (Igual ao binário 0l00)


# 2 3; (Igual ao binário 00ll)
# 3 l · (Igual ao binário 000l)
# 4 # l AND # 2; (O resultado na forma binária é 0000. Então, o número 4 é
definido como 0,000)
# 5 # 2 AND # 3; (O resultado na forma binária é 000l. Então, o # 5 está
definido para l.000)
# 6 # l OU # 2; (O resultado na forma binária é 0lll. Portanto, # 6 está definido
como 7.000)
# 7 # 2 OU # 3; (O resultado na forma binária é 00ll. Portanto, o número 7 está
definido como 3.000)
# 8 # l XOR # 2; (O resultado na forma binária é 0lll. Portanto, o número 8 está
definido como 7.000)
# 9 # 2 XOR # 3; (O resultado na forma binária é 00l0. Então, o número 9 está
definido para 2.000)
As funções lógicas são operadas em inteiros. Se um inteiro
valor (ou uma variável contendo um valor inteiro) não é especificado,
arredondamento é feito automaticamente para o inteiro mais próximo:
# l = l 5;
# 2 = l,4999999;
# 3 = # l E # 2; (Equivalente a # 3 = 2 AND l; que é bit a bit
E dos números binários 0l0 e 00l.
resultado é binário 000, que é o mesmo que
decimal 0. Então, 0,000 é armazenado em # 3)

# 4 = 2,5 XOR 2,4999999; (Equivalente a # 4 = 3 XOR 2; que é


XOR bit a bit dos números binários 0ll
e 0l0. O resultado é binário 00l, que
é o mesmo que decimal l. Então, l.000 é
armazenado em # 4)

Embora as operações bit a bit sejam realmente operações lógicas,


eles se parecem com as operações aritméticas. De fato, o resultado de
operações bit a bit pode ser usado em cálculos aritméticos também, embora
sua finalidade seja inteiramente diferente. Então, uma declaração como

# l = # 2 * # 3 AND # 4;

pode ser sem sentido, mas não ilegal. Observe que, como a multiplicação e
AND têm prioridade igual, a expressão seria avaliada da esquerda para a
direita como # l = [# 2 * # 3] AND # 4; Por outro lado, a multiplicação tem maior
prioridade que o OR. Portanto, ambas as declarações a seguir são
equivalentes:

# l # 2 OU # 3 * # 4;
# l # 2 OU [# 3 * # 4];

Se a avaliação de OR for desejada primeiro, os colchetes terão que ser


usados:

# l = [# 2 OU # 3] * # 4;

Talvez nem sempre se lembre de todas as regras de prioridade, portanto, é


uma boa prática usar colchetes para evitar confusão. Suportes extras não
causam danos, exceto que o nível máximo permitido de aninhamento é cinco.
Se essa limitação criar um problema ou se o aninhamento múltiplo tornar a
expressão muito complexa, divida a expressão em partes menores, distribuídas
em várias linhas.

Funções booleanas

Os lógicos AND, OR e XOR também podem ser usados como funções


booleanas, operadas em duas expressões booleanas, e o resultado da
operação é um valor booleano - TRUE ou FAlSE (lembrar que a operação bit a
bit é feita em dois valores aritméticos ou expressões aritméticas, e o resultado
da operação é um valor aritmético). Estes são frequentemente usados em
declarações condicionais IF e WHIlE (declarações condicionais são descritas
em detalhes no próximo capítulo), de uma maneira tal como

I F [<expressão condicional -l> E <expresso condicional on-2>] THEN # l = l;


que define # l = l, se ambas as condições forem verdadeiras. Esse uso de
AND, OR e XOR é semelhante às funções AND, OR e XOR de qualquer
linguagem de programação de computador de alto nível, e o significado é o
mesmo do inglês simples. A tabela de verdade (dada na Tabela 4.2) é
semelhante àquela das funções bit a bit.

*
Um exemplo de aplicação de operação bit a bit
O booleano AND, OR e XOR são usados com mais frequência do que o bit a
bit AND, OR e XOR em aplicativos comuns. Funções bit a bit são normalmente
usadas em conjunto com variáveis do sistema para sinais de interface para
interação com dispositivos externos conectados ao CNC. Como exemplo,
considere o caso em que vários paletes estão disponíveis para segurar as
peças de uma fresadora, e o programa precisa saber se o palete correto está
carregado. Cada palete tem um número de designação exclusivo (por exemplo,
27) e um sistema de codificação binária para indicar esse número. Ele também
tem um número de chaves de limite independentes N / 0 (normalmente
abertas) (uma chave para cada sinal binário) para indicar se está carregado ou
vazio. Embora o método descrito abaixo seja simples, não é o melhor método,
dadas as considerações práticas. É dado aqui porque, a menos que se perceba
a limitação de uma determinada solução, não se poderá apreciar a melhor
solução. Um método melhor é
descrito no final. Em um arranjo de codificação simples, pode haver um switch
de encapsulamento duplo em linha de oito polos (DIP) ligado a cada palete
(supondo que o maior número de palete seja de 255 ou menos) e a
configuração do interruptor indicaria o número do palete (em binário, ou seja, 0
para OFF e l para ON), o que seria OOOllOll correspondente a 27. Um
interruptor DIP é um conjunto de interruptores elétricos manuais que estão
dispostos em um grupo em um pacote padrão. Toda a unidade do pacote é
referida como um interruptor DIP no
singular. O DIP às vezes também é chamado de OIl (dual in-line). Esse tipo de
switch é projetado para ser usado em uma placa de circuito impresso (PCB)
junto com outros componentes eletrônicos e é comumente usado para
personalizar o comportamento de um dispositivo eletrônico para situações
específicas. Vários tipos de chaves DIP estão disponíveis. Os switches DIP do
tipo slide e do tipo rocker são muito usados para codificação binária. Estas são
matrizes de contatos SPST (single-pole, single-throw) simples,
que pode ser ON ou OFF. Isso permite que cada comutador selecione um valor
binário onebit. Os valores de todos os comutadores no pacote podem ser
interpretados como um número decimal. Oito switches oferecem 256
combinações para 255, correspondendo a 00000000 e llllllll, respectivamente.
Um comum multipin IC é outro exemplo de um pacote duplo em linha. Cada
pólo da chave DIP é conectado em série com um comutador de limite N / 0
independente, para que os sinais binários sejam enviados somente se o
interruptor de limite for pressionado. Uma conexão física, através de um cabo
de fita (com oito fios de sinal e um fio comum) entre a faixa de terminais do
módulo de entrada / saída (l/0) do PMC e os interruptores de limite de cada
palete, seria necessária para enviar o sinais para o PMC. A adição de oito
degraus na escada do PMC, um para cada sinal de entrada, para gravar esses
sinais (de maneira seqüencial) nos sinais G apropriados (G54.0 a G54.7),
definiria as variáveis de sistema correspondentes (# l000 para # l007 e # l032).
Enquanto # l000 a # l007 conteria 0 ou l, correspondendo ao estado OFF / ON
da chave correspondente, # l032 conteria a informação completa em seus l6
bits (na verdade, a interpretação decimal da representação binária, 27 neste
caso, ficaria armazenado em # l032). Então, analisando o conteúdo do # l032
bitwise AND / OR / XOR são necessários para este propósito.
Por exemplo, # l032 XOR 27 retornaria 0 para # l032 = 27 e
um número diferente de zero. Então, um valor 0 confirmaria que o palete o
número 27 é carregado), informações sobre o palete carregado ficam
disponíveis dentro do programa que pode tomar decisões de usinagem
apropriadas, adequadas para a peça de trabalho naquele palete específico. O
método explicado acima é teoricamente correto, mas não prático, devido a uma
possível interferência causada pelos cabos (que vão de cada palete até a tira
de terminais) em um sistema em movimento. Um método prático é descrito
abaixo. Primeiro, determine o número máximo de paletes diferentes que
existirão. Dois paletes podem ser codificados com apenas um interruptor (ON
ou OFF). Quatro paletes com dois interruptores (OFF / OFF, ON / OFF, OFF /
ON e ON / ON), oito paletes com três interruptores, dezasseis paletes com
quatro interruptores e assim por diante. Não há necessidade de usar oito
switches, a menos que haja 256 paletes. Além do conjunto de chaves "número
binário", um interruptor adicional seria necessário para confirmar se o palete
está carregado e bloqueado. Agora, o que resta é como ativar esses switches.
Todos os interruptores (do tipo push-to-ON) são montados na parte
estacionária da máquina, embaixo de onde os paletes são fixados. Os paletes
simplesmente têm botões pequenos (significando l) ou recuados (significando
0) (o número de botões é igual ao número de interruptores) na parte inferior,
que se alinham com os interruptores montados na máquina. Quando um palete
é bloqueado, uma certa combinação de comutadores é acionada pelos botões
no palete, indicando o seu número. O comutador adicional, para detectar se um
palete está ou não carregado, é acionado por todos os paletes da mesma
maneira. E não há necessidade de ter uma conexão em série física entre este
comutador e os comutadores usados para fins de codificação de paletes (na
verdade, para tal conexão, seriam necessários vários comutadores
independentes - um para cada comutador de codificação). Em vez disso, pode
aparecer como um relé N / 0, em série, em todos os degraus da escada
correspondentes a outros
comuta. A matriz de comutadores e o comutador adicional são conectados
permanentemente ao módulo l/0 com um cabo. Portanto, basta um único cabo,
que permanece sempre fixo, fixo nas partes estacionárias da máquina. Um
sistema de paletes mais sofisticado pode usar código de barras ou uma
etiqueta de radiofreqüência (RF) para passar mais informações para a máquina
do que apenas um número de palete. O conhecimento da linguagem ladder é
um pré-requisito para tais aplicações. Embora a linguagem ladder não seja
abordada neste texto, uma breve descrição dos métodos de fiação é dada no
Capítulo. l2
4. 7 Funções de Conversão

As funções disponíveis são BIN e BCD, que são usadas para converter um
número do formato decimal codificado em binário para o formato binário e vice-
versa. Essas funções são usadas para troca de sinal bidirecional entre o PMC
(que usa sinais em formato binário) e o

dispositivos externos (que podem estar usando sinais no formato decimal com
código binário, por exemplo, para exibição de sete segmentos de cada dígito
de um número, separadamente), conectados ao CNC Recall que, na
representação decimal codificada com binário (BCD) de um número decimal,
cada dígito do número é representado independentemente por quatro dígitos
binários. Consulte a Tabela 4.3 para alguns exemplos de
Representações BCD de números decimais de até quatro dígitos. Observe que
quatro dígitos binários podem ter um valor decimal mais alto de l5, mas como o
dígito decimal mais alto é apenas 9, l0l0 e acima (ou seja, até llll) não
aparecem na representação BCD.
Formato:

#i BCD [<interpretação binária de um número binário>];


#i BIN [<interpretação binária de um número BCD>];

Os argumentos do BCD e do BIN são interpretações binárias e os resultados


da conversão são novamente interpretados em binário. Note que a
interpretação binária de um número binário é o número real, mas tal
interpretação de um número BCD não é o número que o BCD representa. A
conversão de formato é feita em relação ao número decimal real que está
sendo representado nos dois formatos.

Exemplos:

# l = BCD [lO]; (Converte l0l0 a 000l 0000, correspondente a


número decimal equivalente l0. Explicação:
Existe um número binário (l0l0) que, quando
interpretado em binário, é l0. Então, l0 é o
argumento da função BCD. este
número, quando convertido para o formato BCD,
torna-se 000l 0000. O decimal
interpretação do BCD convertido
a representação é l6. Então, # l armazena l6}

# 2 BIN [l 6]; (Converte 000l 0000 a l0l0, correspondente a


número decimal equivalente l0. Explicação:
Existe um número BCD (000l 0000), que,
quando interpretado em binário, é l6. Então, l6 é o
argumento da função BIN. Este número,
que é na verdade decimal l0, torna-se l0l0
quando convertido em formato binário. O decimal
interpretação do binário convertido
a representação é l0. Então, o número 2 armazena l0)

Observe que, nos dois exemplos, o mesmo número decimal l0 está envolvido
na conversão. O conceito seria mais fácil de entender se for percebido que a
representação de um determinado número decimal em um formato é convertida
para a representação do mesmo número decimal no outro formato.

Seguindo lógica semelhante, verifique, como exercício, que o BCD [64] retorna
l00 e BIN [l00] retorna 64:
0ll0 0l 00 ~ l000000 (ambos representam o número decimal 64
em BCD e formatos binários, respectivamente)

Valores negativos para os argumentos de BCD e BIN não são permitidos (uma
mensagem de alarme "ARGUMENTO IlEGAl" será exibida). Os argumentos
devem ser inteiros. Se um valor real for especificado, arredondar para o inteiro
mais próximo é feito automaticamente. Essas funções são usadas em conjunto
com variáveis do sistema para sinais de interface (explicados no Capítulo 3),
que são usados para receber / enviar sinais de l6 bits / 32 bits para / do MP C.
Por exemplo, se a variável # l032 corresponder para introduzir o status
00000000000l00ll, ele armazenará um valor decimal de l9.000:

# l = # l032; (# l está definido para l9.000)

Se o mesmo sinal for enviado para um dispositivo externo, no formato BCD,


através da variável # ll32, a função BCD será necessária:

# 2 = BCD [# l];
# ll32 = # 2;

(A representação do BCD de l9 é 0000 0000 000ll00l.


Sua interpretação binária é 25. Então, # 2 está definido como 25)
(# ll32 envia o sinal BCD necessário,
00000000000ll00l} De fato, não há necessidade de envolver variáveis
intermediárias. A seguinte declaração faria o mesmo:

# ll32 = BCD [# l032];

As funções BIN e BCD também podem ser usadas para a variável # ll33 que
envia um sinal de 32 bits. Como a representação de um sinal de bit único, nos
formatos binário e BCD, é a mesma, essas funções não são necessárias para
as variáveis # l000 a # l0l5 e # ll00 a # lll5.
CAPITULO 5
Ramos e loops

Em um programa, a sequência de execução pode ser alterada usando as


instruções GOTO e IF _GOTO_, que é chamado de ramificação. Essas
instruções também podem ser usadas para criar um loop e executá-lo
repetidamente até que uma determinada condição seja satisfeita. Isso, no
entanto, não é considerado um bom método para criar loops. É uma prática
padrão evitar o uso de GOTO em qualquer linguagem de programação
estruturada (como Pascal), pois isso torna o programa menos legível. Além
disso, também introduz um elemento de risco, pois uma alteração subsequente
nos números de sequência pode tornar o programa inutilizável. Melhores
métodos estão disponíveis.
O macro personalizado B fornece a instrução WHIlE para essa finalidade.

5.l Ramificações Incondicionais

O formato é

GOTO n;
onde n é o número de sequência desejado (l a 99999).
Isso causa um salto incondicional para a sequência especificada número
(lembre-se que o número de sequência também é referido como número de
bloco ou número de linha ou número N).
O número de sequência no GOTO A instrução também pode ser especificado
usando uma variável ou uma expressão. Se o número de sequência
especificado não estiver no intervalo de l a 99999, ou se o programa não
contiver o número de sequência especificado, a execução adicional do
programa termina com um alarme. Não é necessário ter números de sequência
para todos os blocos de o programa; somente os blocos de destino devem ter
números de sequência. A duplicação de números de sequência é permitida em
um programa de peça, embora não seja recomendado, pois pode causar erros
inadvertidos. Com declaração GOTO, isso resultaria em uma ramificação
ambígua instrução, gerando uma condição de erro. Então, por uma questão de
boa prática de programação, o mesmo número de sequência não deve
aparecer mais de uma vez em um programa de peça, especialmente quando o
programa usa recursos de programação de macro.

Alguns exemplos de salto incondicional são dados abaixo:


GOTO l00;
# l = l000;
GOTO # l;
GOT0 (# l + l00);
GOTO 0;
GOTO l00000;
(O fluxo da execução do programa pula para o bloco Nl00. esse número de
sequência não existe no programa, execução posterior seria encerrada, e uma
mensagem de alarme seria exibida na tela)
(Salta para o bloco Nl000)
(Pula para o bloco NllOO)
(Comando ilegal)
(Comando ilegal)
O argumento de GOTO é esperado para ser um inteiro. No entanto, se um
número real é especificado, ou se a variável ou a expressão, usada como o
argumento, avalia para um número real, o arredondamento é automaticamente
feito para o inteiro mais próximo:
GOTO l00,0;
GOTO l00.49999;
GOTO l00,5;
# l = l00.49999;
GOTO # l;
GOT0 (# l + .0000l];
(Equivalente a GOTO l00)
(Equivalente a GOTO l00. Mais de oito dígitos,
como l00.499990, não é permitido)
(Equivalente ao GOTO l0l)
(Pula para o bloco Nl00)
(Pula para o bloco Nl0l)
Embora tal uso de GOTO seja apenas uma possibilidade teórica, e nunca é
provável que ocorra em uma situação prática, um entendimento completo A
lógica que está sendo seguida pelo controle ajuda no diagnóstico de erros.
Pelo menos, erros de digitação são sempre possíveis, o que pode dar
resultados, sem gerar nenhuma mensagem de erro!
5.2 Ramificação Condicional
Na ramificação condicional, o GOTO é usado em conjunto com uma expressão.
O formato é
IF (<expressão condicional>] GOTO n;
Se a condição especificada for satisfeita (ou seja, avaliada como TRUE), o
programa a execução salta para o número de sequência n. Se a condição
especificada não está satisfeito (isto é, avalia a FAlSE), a execução prossegue
para o próximo bloco. A expressão condicional deve ser incluída dentro
colchetes.
Os seis operadores condicionais disponíveis, que podem ser usados em
expressão condicional, carregam os significados dados na Tabela 5.l
operadores já foram utilizados em vários contextos; aqui estão eles descrito
formalmente). Note que os símbolos matemáticos equivalentes, mostrado nesta
tabela, são dadas apenas para referência. Estes não podem ser usados como
operadores condicionais.
Os operadores condicionais são usados para comparação entre dois
constantes / variáveis / expressões aritméticas, em qualquer combinação (por
exemplo, comparação entre uma constante e uma variável, ou entre uma
variável e uma expressão aritmética, etc). A expressão aritmética (s), se
houver, deve ser colocado entre colchetes separados.
Exemplos:
[2 lT 3]
[2 lT # l]
[# l lT # 2]
[2 lT [# 2 + # 3]]
[# l lT [# 2 * 5]]
[[# l * # 2) lT [l3 + l0]]
As expressões aritméticas também podem usar qualquer uma das expressões
matemáticas disponíveis.
funções e / ou funções lógicas bit a bit:
[l lT TAN [Il]]
[ll lT [l2 E # 3)]
Uma expressão aritmética pode ter vários níveis de aninhamento. Mas no
geral, pode haver até cinco no máximo e cinco no lado direito colchetes. Em
uma expressão complexa, conte sempre o número de colchetes para se
certificar de que os parênteses esquerdo e direito são iguais em número, caso
contrário, a expressão se tornaria sem sentido, gerando uma condição de
alarme:
[# l lT [REDE [SQRT [# 2 * [l3 + # 4))]]]

Esta expressão tem cinco colchetes esquerdos e cinco direitos. Note que os
dois funções consecutivas (ROUND e SQRT, neste exemplo) devem ser
separados por colchetes. Demasiado complexa, uma expressão deve
preferencialmente ser quebrada partes menores, espalhadas por várias linhas,
para facilitar a interpretação.
Por exemplo, a expressão dada acima pode ser substituída pela seguinte
blocos:

# l00 # 2 * [# 3 + # 4];
# l00 SQRT [# l00];
# l00 RODADA [# l00];

Posteriormente, uma expressão simples [# l lT # l00] pode ser usada no lugar


de
a expressão original.
Também é permitido usar uma combinação de múltiplas condições,
juntamente com Booleanos AND, OR e XOR, desde que o parâmetro
6006 # 0 é definido como l. Por exemplo, pode ser desejado executar uma
ação se
duas condições são TRUE ao mesmo tempo. Tal exemplo é
já dado no final do Sec. 4.6. De fato, qualquer combinação de
as três funções booleanas podem ser usadas para simular uma condição
complexa.
Note que, em uma expressão complexa, é melhor usar
colchetes para indicar a hierarquia de avaliação, mesmo que estes
na verdade, ser redundante devido a regras de prioridade. Isso faz com que a
expressão
mais legível e reduz a possibilidade de erros lógicos:
SE [[[# l lT # 2] E [# 3 lT # 4]] OU [[# 5 lT # 6] XOR [# 7]
lT # 8]]] GOTO l00;
O número total de colchetes esquerdo e direito aninhados é de três cada neste
comando. Sem aninhamento, qualquer número de colchetes pode ser usado.
Sete à esquerda e sete colchetes direitos foram usados neste exemplo.
Finalmente, como um exemplo prático de ramificação condicional, considere
o problema de calcular a soma de todos os números de l a l0 (ou seja,
l + 2 + 3 + ... + 9 + l0). O fluxograma para um algoritmo de soma,
junto com seu traço de execução, é mostrado na Fig. 5.l. É uma boa
programação
Prática para primeiro preparar um fluxograma para o algoritmo escolhido,
e traçar a execução, na medida do possível. A codificação do programa deve
ser
iniciado apenas após a verificação completa do algoritmo. Isso reduz a
possibilidade
de erros lógicos em grande medida.
Há mais uma vantagem de trabalhar com um fluxograma. o
variáveis macro não refletem o significado físico de uma variável
(o que é realmente uma séria limitação da programação macro). Para
exemplo, se a variável nº l00 for definida para conter o valor de uma certa
variável, um sempre teria que lembrar o significado de # l00.
Isso se torna difícil quando se trabalha com um grande número de variáveis.
Como resultado, desenvolver um programa torna-se um pouco difícil porque
não se tem uma sensação intuitiva de qual variável está sendo usada
para qual finalidade. O cérebro humano não funciona como um computador.
Na verdade, esta é uma das razões pelas quais alguns programadores
encontram macro
programação muito complexa. Um fluxograma resolve esse problema. Uma vez
que é
preparado, basta simplesmente copiá-lo em termos de variáveis macro e o
programa está pronto! Então, desenhar um fluxograma não deve ser
considerado um exercício adicional e desnecessário. leva algum tempo
inicialmente, mas, em última análise, um programa complexo pode estar pronto
em muito menos Tempo. Além disso, em um programa complexo, o diagnóstico
de erros extremamente difícil se não houver fluxograma. Na programação
macro área, muitas vezes, a mais lenta se move, o mais rápido atinge o
destino. Então, como regra geral, nunca se deve iniciar o programa codificação
sem primeiro preparar um fluxograma, especialmente se alguém é novo
programação macro. Caso contrário, a natureza abstrata de um programa
macro, o que faz com que pareça muito complexo, pode desencorajar um novo
aluno para estudá-lo ainda mais, e a batalha se perderia antes de combatê-lo!
O próximo passo após a verificação do algoritmo é atribuir a variável números
para todas as variáveis que aparecem no fluxograma. Para o bem
documentação adequada, as variáveis escolhidas devem ser descritas em o
início do programa, dentro de comentários, em benefício de outros usuários
que desejam analisar o programa. Agora, escrevendo o programa é
simplesmente uma questão de converter o fluxograma em uma linguagem
codificada. O número de programa 8000 é baseado no fluxograma apresentado
na Fig. 5.l.

08000 (SUMMAÇÃO DE NÚMEROS);

(O número do programa para uma macro é


geralmente escolhido de 8000 ou 9000 séries,
como é possível editar-proteger estes
programas, para evitar a sua acidental
edição / exclusão. Configurações de parâmetros
3202 # 0 = l e 3202 # 4 = l editar proteger
números de programa 8000 a 8999 e

9000 to 9999, respectively. In fact, the


protected programs are not even displayed
. Only the program numbers
of such programs can be displayed in
directory search, provided parameter
3202#6 is set to l)
(Note that the MDI panel has keys only
for the upper-case alphabets, and no key
for the @ character. @ can be typed using
a soft key. Refer to Sec. 2.2 for details)
(Up to which summation is desired)
(This is a blank NC statement, which
does not do anything. It has been
inserted here for better readability of
the program)
(Initial value of NUMBER)
(Initial value of SUM)
(Summation from l to l0 is desired)
(NUMBER incremented by l)
(SUM calculated)
(Branching to Nl0 if the current value of
the NUMBER is less than l0)
(The final value of the SUM stored in
the permanent common variable #500)
(Replace M30 by M99 if this program is
to be called by other programs)
Observe que M02 e M30 incluem a ação RESET. Então, tudo isso claro
variáveis locais (ou seja, # l a # 33), bem como variáveis comuns (# l00 a
# l99) para null. Portanto, se um valor é necessário para estar disponível
mesmo após
o fim de um programa (por exemplo, para examinar seu valor ou para usá-lo
através de diferentes programas), tem que ser armazenado de forma
permanente
variável. Então, quando a execução do programa dado terminar, # l,
# 2 e # 3 são limpos para nulo e o valor final da soma (que é
55, neste exemplo) permanece armazenado em # 500, que pode ser exibido
na tela de variável de macro (consulte a Seção l.3 para o método de exibição
variáveis macro).
Embora recursos de programação macro possam ser usados em qualquer
programa
(o programa dado acima é um exemplo, que pode ser executado como o
programa principal), um programa macro ou um subprograma é
invariavelmente
ser chamado por outros programas (programas principais, subprogramas ou
macro
programas). Como mencionado na Sec. 3.3, e discutido em detalhes em
Chaps. 6
e 7, um subprograma é chamado pelo M98, e um programa de macro (que é
simplesmente chamado de macro) é chamado por G65 ou G66. E, se um
programa
é projetado para ser chamado por outros programas, deve terminar com M99,
em vez
do que M30. Então, se algum dos programas apresentados neste capítulo for
chamado por outros programas, substitua M30 por M99 no final. M30 tem
deliberadamente usado para que esses programas pudessem ser executados
como programas principais.
M99 no final de um programa principal executa o programa repetidamente,
em um loop infinito, até que a tecla RESET seja pressionada.
lembre-se também que se um comentário for inserido imediatamente após a
0 palavras, como foi feito neste programa, a exibição do diretório (por
exibição do diretório, pressione a tecla de função PROG, seguida pelo DIR
tecla de função ou pressione a tecla PROG duas vezes, no modo EDIT) no MDI
tela mostra o comentário inserido (até 3l caracteres em 7,2 polegadas
Tela lCD) junto com o número do programa. Este é um recomendado
prática, como se obtém a informação sobre o tipo de um programa sem
abri-lo (ou seja, 0 SRHing).
O programa dado é bastante geral por natureza. Por exemplo, se
soma de l a l00 é desejada, simplesmente mude o valor # 3 para l00
no início do programa e o valor somatório obtido
5050. Um bom programa macro deve prever essa flexibilidade
no início do programa, para que outros usuários
(uma macro é invariavelmente projetada para ser usada por vários usuários),
podem não ser programadores especialistas, não precisam analisar o
programa para descobrir onde ele precisa ser editado.
Como exercício, o leitor pode tentar escrever um programa para calcular
a soma dos quadrados dos primeiros l0 números (isto é, l2 + 22 + · · · + l0Z). o
programa seria quase o mesmo que o dado acima para calcular
a soma dos primeiros l0 números. Somente a declaração # 2 = # 2 + # l seria
precisa ser substituído por # 2 = # 2 + # l * # l. A resposta seria 385.
Embora variáveis comuns permanentes sejam muito úteis para aplicações
como o que acabamos de discutir, valores pré-inseridos podem não
sempre desejável, pois isso pode resultar na inicialização incorreta
variáveis em alguns casos (por exemplo, # 500 = # 500 + # l, em que o valor
inicial
de # 500 é desejado para ser 0). Além disso, nunca pode ser dito com certeza
se os valores exibidos forem realmente calculados pelo programa
ou são apenas os valores antigos. Então, por uma questão de prática de
programação segura,
todas as variáveis comuns permanentes, que devem ser usadas em um
programa, são definidos como nulo no início do programa, a menos que
seus valores antigos são realmente necessários.
Em alguns casos, pode até ser desejável limpar todas as
variáveis comuns. O número do programa 800l faz o mesmo, configurando
todas as variáveis
no intervalo de # 500 a # 999 a nulo. A execução é concluída em cerca de
l0 segundos no Oi Mate TC (os cálculos macro não são muito rápidos). o
O fluxograma de um algoritmo e seu traço de execução são mostrados na Fig.
5.2.

0800l (lIMPEZA DE TODAS AS COMUNIDADES PERMANENTES);


(# l @ COUNTER);
;
# l = 500; (Valor inicial de COUNTER)
Nl0 # [# l] # 0; (O número da variável, referenciado por COUNTER, definido
como null)

# l = # l + l; (COUNTER incrementado em l, para selecionar a próxima variável)

SE [# l lE 999] GOTO l0; (Ramifica para Nl0 se # l for menor que ou


igual a 999, ou seja, se todas as variáveis até # 999 não forem limpas)

M30;

Um exemplo mais complexo é calcular o desvio padrão da amostra (crn_l) de,


digamos, l0 números que são armazenados em # l a # l0. A fórmula
matemática é

onde x. = dados individuais I


n = o número total de dados
lor médio dos dados fornecidos

O fluxograma de um algoritmo para calcular crn_l é dado em


Fig. 5.3. O número do programa 8002 é baseado neste algoritmo. Embora
quaisquer valores possam ser armazenados nas variáveis # l a # l0, os valores
escolhidos neste exemplo são l, 2, 3,. . . l0, respectivamente. A resposta obtida
seria 3.0276503. Este programa pode ser usado para calcular crn_l para até 33
números, armazenados em # l a # 33.
08002 (CÁlCUlO DE DESVIO PADRÃO);

(# l ATRAVÉS # l0 @ DATA);
(Armazene os valores desejados em # l ... # l0);
(# l00 @ NÚMERO DE DADOS);
(SET # l00 para o número de dados);
(# l0l @ COUNTER);
(# l02 @ SUM OF GIVEN DATA);
(# l03 @ MÉDIA DOS DADOS);
(# l04 @ SOMA DE DESVIO QUADRADO);
(# l05 @ DESVIO QUADRADO MÉDIO);
(# 50l @ DESVIO PADRÃO);
;
# l = l (primeiros dados)
# 2 = 2 (segundos dados)
# 3 = 3 (terceiro dados)
# 4 = 4 (quarto dados)
# 5 = 5 (quinto dados)
# 6 = 6 (sexto dados)
# 7 = 7 (sétimo dado)
# 8 = 8 (oitavo dados)
# 9 = 9 (nono dados)
# l0 = l0 (Décimos dados. Note que o passo de entrada de dados não é
mostrado no fluxograma)
# l00 = l0 (NUMBER de dados)
# l0l = l (valor inicial de COUNTER)
# l02 = l (soma inicial configurada para os primeiros dados)

# l = 0;
Nl0 # l0l = # l0l + l; (COUNTER incrementado em l)
# l02 = # l02 + # [# l0l]; (Próximos dados adicionados à soma)
SE [# l0l lT # l00] GOTO l0; (A ramificação para os dados de queda do Nl0i não
# l03 # l02 / # l00; (MÉDIA calculada)
# l0l l; (COUNTER inicializado para l)
adicionado a SUM)

# l04 [# l03 - # l] * [# l03 - # l]; (Soma inicial do quadrado


DESVIO definido para o quadrado
desvio para os primeiros dados)

N20 # l0l = # l0l + l; (COUNTER incrementado em l)

# l04 = # l04 + [# l03- # [# l0l]] * [# l03- # [# l0l]];


(Desvio quadrado para os próximos dados adicionados a SUM OF SQUARE
DEVIATION)

SE [# l0l lT # l00] GOTO 20; (Ramificando para N20 se quadrado


desvios para todos os dados não são
adicionado ao SUM OF SQUARE
DESVIO)

# l05 # l04 / [# l00 - l]; (DESVIO SQUARE QUADRADO


calculado)

# 50l SQRT [# l05]; (DESVIO PADRÃO calculado


e armazenado na permanente
variável corrunon # 50l)
M30;

Note que, em uma tela lCD de 7,2 polegadas, não é possível digitar
continuamente mais de 34 caracteres em um bloco, usando as teclas MDI. Em
um cálculo matemático complexo, aparecem mais de 34 caracteres em um
bloco. Por exemplo, no programa de desvio padrão, há um bloco (o próximo ao
bloco N20) com 40 caracteres. A única maneira de ter esses blocos em um
programa é primeiro digitar o programa em um PC e depois baixá-lo para o
CNC através da porta RS-232C. Desta forma, um bloco com praticamente
qualquer número de caracteres pode ser usado em um programa. Se, no
entanto, o programa tiver que ser digitado apenas com chaves MDI, um bloco
longo (com mais de 34 caracteres) precisaria ser dividido em blocos menores.
Por exemplo,

# l04 = # l04 + [# l03 - # [# l0l)]) * [# l03 - # [# l0l)];

pode ser dividido em blocos menores da seguinte maneira, o que terá o mesmo
efeito:

# lll # l03 # [# l0l]; (Uma nova variável # lll introduzida para


cálculos intermediários)
# lll # lll * # lll;
# l04 # l04 + # lll;

O próximo exemplo encontra as raízes de uma equação quadrática no


Formato

ax2 + bx + c = 0

A fórmula para as duas raízes é

O fluxograma de um algoritmo para encontrar as duas raízes é mostrado na


Fig. 5.4. No programa número 8003, que é baseado neste algoritmo, quaisquer
valores podem ser atribuídos às variáveis correspondentes a, b e c. Aqui, l, l e -
2 foram dados, o que dá l e -2 como a solução para as duas raízes.

08003 (SOlUÇÃO QUADRATIC EQUATION);


(FORM @ A * X * X + B * X + C = 0);
(# l @ A);
(# 2 @ B);
(# 3 @ C);
(Atribuir os valores desejados a A, B, C);
(# l00 @ DISCRIMINANTE);
(# 502 @ ROOTl);
(# 503 @ ROOT2);

# l = l; (a, ou seja, coeficiente de x2)

# 2 = l; (b, ou seja, coeficiente de x)


# 3 = -2; (c, isto é, termo constante)
# l00 = # 2 * # 2 - 4 * # l * # 3; (Determinante calculado)

SE [ABS [# l00] lT 0,00000l] GOTO l0; (Ramificação para NlO se o


determinante for 0)

SE [# l00 lT 0] ENTÃO # 3000 = l (IMAG ROOTS);

("300l IMAG ROOTS" exibido e execução terminada, para um determinante


negativo. IF_THEN_statement é descrito em detalhes na Sec. 5.3)

# 502 = [- # 2 + SQRT [# l00]] / [2 * # l];


(Primeira raiz calculada e armazenada na variável comum permanente # 502)

# 503 [- # 2 - SQRT [# l00]] Eu [2 * # l]; (Segunda raiz calculada e armazenada


em outra variável comum permanente # 503)

GOTO 20; (Ramificando para N20)

Nl0 # 502 = - # 2 I [2 * # l]; (Primeira raiz calculada, quando o determinante é 0)


# 503 = # 502; (As duas raízes são iguais)
N20 M30;

lembre-se de que todo cálculo de macro geralmente envolve um erro de l0 s.


Assim, mesmo que o determinante seja realmente 0, ele pode não ser
exatamente 0. É por essa razão que o valor absoluto do determinante está
sendo comparado com um valor pequeno, neste programa. Observe que,
mesmo se o determinante for negativo, gerando um alarme, as variáveis
comuns permanentes # 502 e # 503 ainda terão valores antigos (se houver)
armazenados neles. Se isso provavelmente causar confusão, defina # 502 e #
503 como nulo (# 0), se o determinante for negativo. De fato, como já foi dito,
uma boa prática de programação seria definir incondicionalmente essas
variáveis como null no início do programa. Isso se aplica a todos os programas
que usam variáveis comuns permanentes, sem precisar de seus valores
antigos. Para uma prática adicional, o leitor pode tentar desenvolver programas
para encontrar

• O maior e o menor número em um dado conjunto de dados


• A soma de uma série finita do tipo I, ~ (uma expressão em termos do índice i)
• A soma de uma série infinita, mas convergente (o cálculo precisaria ser
encerrado quando um termo de série for encontrado ser muito pequeno,
digamos, menos de 0,00000l)
• O cálculo de fatorial de um determinado número, etc.
Sempre que possível, a relação de recorrência deve ser usada para eficiência
computacional. Por exemplo, o fatorial de um determinado número pode ser
definido em termos do fatorial de seu número anterior: i! = (i -l)! XI. Tal técnica é
especialmente vantajosa na soma das séries. Um exemplo é dado abaixo:

Assim, o termo (i + l) pode ser expresso em termos de iésimo termo da


seguinte maneira:
O fluxograma baseado nesta relação de recorrência é dado na Fig. 5.5. Os
dados de entrada recebem valores para X e o número de termos (n) na série. O
fluxograma é válido para n ~ 2. Ele é deixado como um exercício para o leitor
escrever um programa para encontrar a soma desta série. Vários dos
programas indicados e sugeridos são para o único propósito de explicar o uso
de declarações condicionais em uma macro, além de descrever a metodologia
apropriada para desenvolver um programa macro (na prática, nenhuma
máquina CNC pode exigir o uso de alguns esses programas). Esses programas
foram selecionados principalmente porque todos os graduados em engenharia
escrevem esses programas em algum curso de programação. E, quando os
programas são familiares, basta ver como eles podem ser convertidos na
linguagem macro. Isso facilita o aprendizado de um novo idioma. Esses
programas também indicam que a linguagem de programação macro pode ser
usada para fazer cálculos complexos. Na verdade, a discussão a seguir
mostrará que um programa de macros pode fazer muito mais do que o descrito
aqui. Até agora, tivemos apenas uma introdução a essa linguagem.

5.3 Execução condicional de uma única declaração de macro Tal declaração


(IF _THEN_) já foi usada no programa número 8003 (é deixado como um
exercício para o leitor pensar como o programa pode ser desenvolvido sem
usar esta declaração). Aqui, é formalmente descrito, em detalhes.

Uma instrução de macro especificada pode ou não ser executada dependendo


se uma condição especificada é satisfeita ou não. O formato é.
IF [<expressão condicional>] ENTÃO <a macroexposição>;

A expressão condicional pode até ser uma combinação complexa de várias


condições independentes.
O formato IF _THEN_ possui as seguintes limitações:
• Apenas um único macro declarado pode ser especificado.
• Uma declaração NC não é permitida.

Exemplos:

SE [# l lT # 2] ENTÃO # 3 = 3;
(Se a condição for TRUE, um valor de 3 é atribuído à variável nº 3. Uma
condição FAlSE deixa o valor anterior armazenado em # 3 inalterado)

SE [# l lT # 2] # 3 = 3;
(Comando ilegal. THEN deve estar lá)

SE [# l lT # 2] THEN M30;
(Comando ilegal porque uma instrução NC foi especificada)

SE [# l lT # 2] THEN [# 3 = 3; # 4 = 4];
(Comando ilegal porque mais de uma declaração de macro foi especificada. De
fato, não é possível ter este comando exibido da maneira mostrada. O primeiro
ponto-e-vírgula muda a linha que divide a declaração em dois blocos
separados, tornando-a completamente sem sentido)

Se mais de uma macroexposição e / ou declarações NC forem desejadas para


serem executadas se uma condição especificada for VERDADEIRA (por
exemplo, se [# l lT # 2] for VERDADEIRO), isso poderá ser feito da seguinte
maneira (onde as declarações entre os blocos IF GOTO_ e Nl00 são
executados somente se # l for menor que # 2):

SE [# l GE # 2] GOTO l00;

<macro statement -l> “(statement = declarado)”


<macro statement -2>
<macro statement -n>
<NC statement -l>
<Declaração NC - 2>

<NC statemen t n>


NlOO;
<parte restante do plano de fundo>

lembre-se de que um símbolo EOB isolado (;) em um bloco, com ou sem um


número sequencial (como NlOO; ou simplesmente;), é tratado como uma
instrução NC em branco que não faz nada, mas possui todas as propriedades
de um NC declaração. Por exemplo, no modo de bloco único, a execução deve
parar aqui e esperar que o botão CYClE START seja pressionado novamente
para retomar a execução. Isso também pode ser usado para impedir a pré-
leitura de instruções de macro, o que pode não ser desejável em certos casos.
Esse problema é discutido com mais detalhes na Sec. 7.6 Como o GOTO n é
uma instrução macro, também é permitido comandar.

I F [<a condicional expr ess i on>] ENTÃO GOTO n;

que é equivalente a

I F [<expressão de condição]> GOTO n;

5.4 - Execução em um loop

É possível executar certas linhas de um programa repetidamente (ou seja, em


um loop), desde que uma condição especificada permaneça satisfeita. Isso, na
verdade, já foi feito em vários dos programas discutidos até agora. A
ramificação condicional, IF GOTO_, foi usada para essa finalidade. No entanto,
o uso de GOTO (especialmente GOTO incondicional) geralmente não é
recomendado, pois torna o programa menos legível, dificultando sua
interpretação. Uma maneira melhor de construir um loop é usar a instrução
WHIlE. E esta é a única maneira alternativa disponível na macro personalizada
B, para executar em um loop. Outra vantagem de criar um loop usando a
instrução WHIlE é que seu processamento leva menos tempo em comparação
com o processamento da instrução GOTO. Isso pode afetar a velocidade de
execução do programa se o número de vezes que o loop for necessário para
ser executado for muito grande.

A sintaxe da instrução WHIlE é WHIlE [<uma expressão condicional>] DO n;

<blocos de programa dentro do loop>


...
...
...
END n;
...
...
...
onde n pode ser l, 2 ou 3.

Se a condição especificada for satisfeita (ou seja, se a expressão condicional


for avaliada como TRUE), os blocos de programa entre DO e END serão
executados. Posteriormente, a condição é verificada novamente e, se a
condição ainda estiver satisfeita, o loop é reexecutado. Contanto que a
condição permaneça satisfeita (o que é testado no início de cada loop), o loop
é repetidamente executado.
Os blocos de programa dentro do loop são projetados de tal forma que seu
processamento afeta a condição especificada, de modo que, após algumas
execuções do loop, a condição se torne FAlSE. Posteriormente, a execução do
programa prossegue para o bloco próximo a END, após concluir totalmente a
execução do loop que alterou a condição de TRUE para FAlSE. Observe que a
condição é verificada antes de executar um novo loop;
não é verificado durante a execução de um loop. O fluxograma para o
WHIlE declaração é dada na Fig. 5.6.
Embora somente l, 2 e 3 possam ser usados como números de identificação
(n), eles podem ser usados qualquer número de vezes em um programa:

WHIlE [<expressão condicional em l>) DO l; (O número de identificação é l)


...
...
...
<blocos de programa dentro do primeiro loop>
...
...
...
END l;

WHILE [<expressão concomitante 2>> DO l; (O mesmo número de


identificação permitido)
...
...
...
<blocos de programa dentro do segundo loop>
...
...
...

END l;

Na verdade, o mesmo número de identificação (digamos, l) pode ser usado em


qualquer lugar do programa (como no exemplo anterior), exceto no
aninhamento onde l, 2 e 3 correspondem aos três níveis de instruções WHIlE
aninhadas (até um máximo de três níveis de aninhamento é permitido):

Os intervalos DO_END_ não podem se sobrepor no aninhamento, pois tornam


a declaração ilógica e sem sentido:
It is permitted to use any macro or NC statement, including IF_ THEN_, IF
_GOTO_ and GOTO_, inside a loop (i.e., inside the DO_ END_ range):

WHIlE [<condition l>] DO l;


...
...
...

IF (<condição 2>] GOTO l0; (permitido usar GOTO dentro de um loop)


...
...
...
Nl0
...
...
...
END l;

Também é permitido pular fora do loop usando um GOTO


declaração:
WHIlE (<condição l>] DO l; (permitido saltar fora do loop)
...
...
...
IF (<condição 2>] GOTO l0;
...
...
...
END l;
...
...
...
Nl0 ...;
...
...
...
No entanto, saltar dentro de um loop (de fora) não é permitido:
IF (<condição l>] GOTO l0; (salto ilegal dentro de um loop)
...
...
...
WHIlE (<condição 2>] DO l;
...
...
...
Nl0
...
...
...
END l;

Para ilustrar o uso da instrução WHIlE, os mesmos problemas seriam


considerados para trazer a diferença dos loops criados usando a instrução
GOTO condicional.
Como já foi dito, a codificação do programa deve ser feita somente após a
preparação de um fluxograma. O fluxograma para a instrução WHIlE seria um
pouco diferente porque a condição especificada é verificada no início do loop.
O fluxograma para o problema da soma (l + 2 + 3 + ... ... + l0) é dado na Fig.
5.7. O número do programa 8004 é baseado neste fluxograma.

08004 (SUMMAÇÃO DOS NÚMEROS USANDO WHILE);


(# l @ NUMBER);
(# 2 @ SUM);
(# 3 @ MAX NUMBER); (Até qual somatório é desejado)
(# 504 @ SUMAl FINAl);
# l = l; (Valor inicial de NUMBER)
# 2 = # l; (valor inicial de SUM)
# 3 = l0; (Soma de l a l0 é desejado)
WHILE [# l lT # 3] DO l; (O loop começa aqui. Ele é executado se # l for menor
que # 3. Se não, o loop termina e a execução pula para o bloco após END l)

# l = # l + l; (NUMBER incrementado em l)

# 2 = # 2 + # l; (SUM calculado)

END l; (O final do loop. A execução salta para o início do loop para verificar se
o número l ainda é menor que 3)

# 504 # 2; (O valor final da soma armazenada na variável comum permanente


# 504)
M30;

O fluxograma para limpar todas as variáveis comuns permanentes usando uma


instrução WHIlE é dado na Figura 5.8. O número do programa 8005 é baseado
neste fluxograma. A execução deste programa leva cerca de 5 segundos, o
que é quase a metade do tempo gasto pelo número de programa 800l, que
usou uma instrução GOTO para construir o loop.

08005 (APAGAR VARS COM USAR WHILE);


(# l @ COUNTER);
# l = 50 0; (Valor inicial de COUNTER)
WHILE [# l lE 9 9 9] DO # l;
(O loop começa aqui. Ele é executado se # l for menor ou igual a 999. Se não,
o loop é finalizado e a execução pula para o bloco após END l)
# [# l] = # 0; (O número da variável, referenciado por COUNTER, desmarcado
para null)

# l = # l + l; (COUNTER incrementado em l, para selecionar


a próxima variável)

END # l;
(O final do loop. A execução salta para o início do loop para verificar se # l
ainda é menor ou igual a 999)

M30;

O fluxograma para cálculo do desvio padrão usando o


A instrução WHIlE é dada na Figura 5.9 (a etapa de entrada de dados, no início
do algoritmo, não foi mostrada no fluxograma). O número do programa 8006 é
o programa correspondente. Note que este algoritmo usa dois loops.

08005
# l = 50 0;
WHILE [# l LE 9 9 9] DO # l;
# [# l] = # 0;
# [# l] = # 0;
# l = # l + l;
END # l;
M30;
08006 (CÁlCUlO DE DESENVOlVIMENTO DST USANDO WHILE);
(# l ATRAVÉS # l0 @ DATA);
(Armazene os valores desejados em # l... # l0);
(# l00 @ NÚMERO DE DADOS);
(SET # l00 para o número de dados);
(# l0l @ COUNTER);
(# l02 @ SUM OF GIVEN DATA);
(# l03 @ MÉDIA DOS DADOS);
(# l04 @ SOMA DE DESVIO QUADRADO);
(# l05 @ DESVIO QUADRADO MÉDIO);
(# 505 @ DESVIO PADRÃO);
# l = l; (Primeiros dados)
# 2 = 2; (Segundos dados)
# 3 = 3; (Terceiro dados)
# 4 = 4; (Quarto dados)
# 5 = 5; (Quinto dados)
# 6 = 6; (Sexto dados)
# 7 = 7; (Sétimo dado)
# 8 = 8; (Oitavo dados)
# 9 = 9; (Nono dados)
# l0 = l0; (Décimo dados)
# l00 = l0; (NUMBER de dados)
# l0l = l; (Valor inicial de COUNTER)
# l02 = # l; (SUM inicial definido para os primeiros dados)

WHILE [# l0l lT # l00] DO l;


(O primeiro loop começa aqui. Ele termina no bloco END l. Observe que END l
aparece duas vezes neste programa porque o mesmo número de identificação,
l, foi usado para ambos os loops. O loop atual é executado se # l0l for menor
que # l00. Se não, o loop termina, e a execução salta após o bloco END l deste
loop)

# l0l = # l0l + l; (COUNTER incrementado em l)


# l02 = # l02 + # [# l0l]; (Valor inicial de COUNTER)
END l;
(O final do primeiro loop. A execução salta para o início do loop para verificar
se # l 0l ainda é menor que # l00)

# l03 = # l02 / # l00; (MÉDIA calculada)


# l0l l; (COUNTER inicializado para l)
# l04 [# l03 - # l] * [# l03 - # l];
(Soma inicial da opção SQUARE DEVIATION para o desvio quadrado para os
primeiros dados)

WHILE [# l0l lT # l00] DO l;


(O segundo loop começa aqui. Ele é executado se # l0l for menor que # l00. Se
não, o loop termina, e a execução pula para o bloco após o bloco END l desse
loop, ou seja, pula após o segundo END l deste programa)

# l0l # l0l + l; (COUNTER incrementado em l)

# l04 # l04 + [# l03 - # [# l0l]] * [# l03 - # [# l0l]];


(Desvio quadrado para os próximos dados adicionados a SUM OF SQUARE
DEVIATION)

END l;
(O final do segundo loop. A execução salta para o início do loop para verificar
se # l0l ainda é menor que # l00)

# l05 # l04 Eu [# l00 - l]; (DESVIO SQUARE SQUARE calculado)

# 505 SQRT [# l05];


(DESVIO PADRÃO calculado e armazenado na variável comum permanente #
505)

M30;
O fluxograma de soma das séries mostrado na Fig. 5.5 foi projetado para ser
usado com a instrução GOTO condicional. O mesmo algoritmo, se desejado
para ser implementado com a instrução WHIlE, teria um fluxograma como
mostrado na Fig. 5.l0. O leitor deve tentar escrever um programa, baseado
neste fluxograma, que está sendo deixado como exercício. Apenas defina
variáveis para entradas x e n, assim como para contador i, termo e soma.
Posteriormente, a escrita do programa é simplesmente uma questão de copiar
o fluxograma em termos das variáveis definidas.
Embora a instrução WHIlE tenha o propósito de executar em um loop, ela
também pode ser usada para executar determinados blocos uma vez, se uma
condição especificada for verdadeira:

WHIlE [<conditional express on on]] DO 1;


...
...
...
GOTO 10;
END 1 ·
Nl0 ...;

lembre-se de que o formato IF_ THEN_ pode executar apenas uma instrução
macro se uma condição especificada for satisfeita. Um método indireto foi
sugerido para executar mais de uma instrução.
5.5 Operações Aritméticas em Números Variáveis Macro

Como já discutido, as variáveis macro não podem ser definidas usando


combinações arbitrárias de caracteres alfanuméricos. Estes só podem ser
definidos em termos de determinados números de variáveis. Isso é um pouco
inconveniente porque o programador não percebe intuitivamente os
significados atribuídos às diferentes variáveis que estão sendo usadas em um
programa. No entanto, uma característica única das variáveis de macro é que
as operações aritméticas são permitidas nos números das variáveis. Isso pode
ser usado vantajosamente em certos casos. Por exemplo, em PASCAl, pode-
se armazenar as notas em cinco disciplinas obtidas por um aluno em cinco
variáveis,
diga, MARKSl, MARKS2, MARKS3, MARKS4 e MARKS5.
Por outro lado, em um programa de macro, as marcas podem ser armazenadas
em, digamos, # l0l, # l02, # l03, # l04 e # l05. WHILE MARKSl, MARKS2,
MARKS3, MARKS4 e MARKS5 são independentes um do outro, # l0l, # l02, #
l03, # l04 e # l05 seguem um padrão. O número variável de um sujeito pode ser
obtido adicionando l ao número da variável para o assunto anterior. Esse fato
pode ser usado ao escrever um programa para, digamos, calcular as marcas
agregadas. O fluxograma de tal algoritmo é dado na Fig. 5.ll, e o número do
programa correspondente é 8007. A instrução WHIlE foi usada para criar o loop
neste programa, como é preferível sobre a instrução GOTO condicional. Os
leitores devem, no entanto, tentar construir o loop
usando a instrução IF _GOTO_, como um exercício.
08007 (CÁlCUlO DE MARCAS AGREGADAS);
(# l @ COUNTER);
(# 2 @ SUM);
(# 3 @ TOTAl DE SUJEITOS);
(# 506 @ SUMAl FINAl);
# l0l = 50;
# l02 = 60;
# l03 = 70;
# l04 = 80;
# l05 = 90;
# l = 0;
# 2 = 0;
# 3 = 5;
(Se o número total de assuntos for diferente de 5, defina # 3 de acordo)

WHILE [# l LT # 3] DO l; (Início do loop)

# l # l + l; (COUNTER incrementado em l)

# 2 = # 2 + # [l00 + # l]; (Marcas obtidas no próximo assunto adicionado a


SUM)

END l; (Fim do loop)

# 506 # 2;
(SUM FINAL armazenado na variável comum permanente # 506)

M30;

Isso, claro, é um exemplo trivial; as marcas nos cinco temas podem ser
adicionadas imediatamente! No entanto, se o número de dados for muito
grande (digamos, l00), tal programa seria útil. Além disso, o objetivo aqui é
explicar como operações aritméticas são feitas em números de variáveis, e
como o fluxograma, envolvendo um loop, nesse caso é desenhado. Tal
característica de variáveis de macro também pode ser usada para manipular
certas variáveis do sistema que seguem um padrão definido. Para
Por exemplo, há um salto de 20 nos números das variáveis para vários valores
de deslocamento de trabalho para um determinado eixo (veja cada linha da
Tabela 5.2 (a), que é uma parte da Tabela 3.l2). Da mesma forma,
correspondente a um sistema específico de coordenadas da peça, o número da
variável aumenta em incrementos de l para o próximo eixo (ver cada coluna da
Tabela 5.2 (a). O padrão identificado pode ser descrito matematicamente, em
termos do número 520l, como mostrado na Tabela 5.2). (b), que é uma parte
da Tabela 5.2 (a) Assim, se o eixo e o sistema de coordenadas da peça forem
especificados, o número da variável do sistema correspondente pode ser
calculado Os fatores de multiplicação (de 20) para G54, G55, Os sistemas de
coordenadas da peça G56, G57, G58 e G59 são 0, l, 2, 3, 4, 5 e 6,
respectivamente, e os adendos são 0, l e 2 para os eixos X, Y e Z ,
respectivamente (3, 4, 5, etc. para os eixos restantes, se disponíveis) Assim,
por exemplo, o valor de deslocamento do eixo Y para o sistema de
coordenadas G56 é armazenado na variável número 520l + 20 x 3 + l, ou seja,
em # 5262.

Métodos de Mudança Zero

Vamos agora considerar um exemplo simples para ver como tais variáveis de
sistema podem ser identificadas e manipuladas para um efeito desejado
através de um programa. Digamos, o requisito é colocar a origem do sistema
de coordenadas da peça atualmente ativo (ou algum outro) (entre G54-G59 e,
opcionalmente, 48 sistemas de coordenadas adicionais G54.l Pl-P48) na
posição XY atual da ferramenta, em uma máquina de trituração. Isso é
conhecido como deslocamento zero ou deslocamento de dados. lembre-se que
a origem do sistema de coordenadas da peça (G54, GSS, etc.) também é
como o ponto zero da peça ou o ponto zero do programa ou o ponto zero do
componente, e a qualquer momento, qualquer um dos seis sistemas padrão e
48 coordenadas adicionais da peça pode ser selecionado para ser o sistema de
coordenadas ativo. Um programa é executado no sistema de coordenadas
atualmente ativo (o CNC interpreta os valores de coordenadas usados em um
programa no sistema de coordenadas atualmente ativo). O deslocamento zero
pode ser feito de forma muito simples apenas com o comando G90 G92 XO
YO, que é obviamente o método mais simples. O comando correspondente em
um torno é GSO XO ZO. Deslocamento zero para eixo único também é
possível. Por exemplo, G90 G92 ZO (GSO ZO em um torno) desloca zero
apenas para o eixo Z. No entanto, uma limitação do uso de G92 ou GSO é que
a mudança permanece válida somente para a sessão de usinagem atual.
Quando a máquina é desligada e novamente ligada, as informações fornecidas
a ela através do G92 ou GSO na sessão anterior são perdidas, e a máquina
começa a usar a configuração original de zero. Além disso, o deslocamento
zero, usando este método, só pode ser feito para o sistema de coordenadas
atualmente ativo. Por outro lado, se o deslocamento zero for feito manipulando
os valores armazenados nas variáveis do sistema para as distâncias de desvio
de trabalho relevantes, a origem deslocada permanecerá fixa na nova posição
permanentemente, até que os valores de deslocamento sejam alterados
novamente (usando qualquer método). Além disso, esse método funciona para
todos os sistemas de coordenadas, mesmo que eles não estejam atualmente
ativos. É claro que, se as variáveis do sistema, correspondentes às distâncias
de deslocamento de um sistema de coordenadas que não está ativo no
momento, forem manipuladas, seu efeito será visto somente depois disso.
sistema de coordenadas se torna ativo. As variáveis do sistema para vários
valores de deslocamento são do tipo leitura / gravação. Então, se os valores
armazenados neles forem alterados, o deslocamento correspondente
distâncias mudam automaticamente. Por outro lado, se as distâncias de
deslocamento forem alteradas, as variáveis de sistema correspondentes serão
redefinidas automaticamente (isto é, armazenando novos valores). Observe
que os termos "distância de deslocamento", "valor de deslocamento" e até
"deslocamento" são geralmente usados como sinônimos. Portanto, o valor de
Xoffset, a distância de deslocamento X e o deslocamento X significam a
mesma coisa. Uma discussão mais aprofundada sobre esse tópico exige um
entendimento claro da maneira como o controle define e usa os vários sistemas
de coordenadas. Consulte a Fig. 5.l2 para a discussão que se segue. As
distâncias de deslocamento X e Y são o componente X e Y (com sinal) do vetor
de correção correspondente mostrado nesta figura. Para um torno, substitua X
por Z e Y por X.

Sistema de Coordenadas da Máquina

Em qualquer máquina, a origem do sistema de coordenadas da máquina


(MCS), que também é chamado de ponto zero da máquina, é colocada em um
local desejado por uma configuração de parâmetro. Isso é feito pelo MTB e não
há necessidade de o usuário final alterá-lo. Na verdade, não deve ser alterado
porque várias configurações da máquina são feitas no MCS. Por exemplo, os
parâmetros da série l300 (consulte o Manual de Parâmetros para detalhes) são
usados para definir os limites de excesso de software para o movimento da
ferramenta. Se, devido a um erro de programação ou outro, a ferramenta for
necessária para entrar na zona proibida, ela será automaticamente
interrompida no limite, com um alarme. Tal limite de software é desejável
devido a considerações de segurança. Por exemplo, a ferramenta nunca deve
bater o mandril ou o cabeçote móvel em um torno. Os limites de software não
permitem que a ferramenta entre em uma zona perigosa definida. Esses limites
são especificados em determinados parâmetros, como valores de coordenadas
no MCS. Isso significa que qualquer mudança na posição do MCS redefiniria
automaticamente a zona proibida, o que obviamente não é desejável. Então,
pode-se dizer que o MCS é fixo para uma dada máquina. O MCS, no entanto,
não é conveniente para executar programas de peça; Na verdade, o controle
não permite a execução do programa no MCS. Existem outros sistemas de
coordenadas para este propósito. Sistema Externo de Coordenadas da Peça
O sistema externo de coordenadas da peça, que geralmente é referido
simplesmente como o sistema de coordenadas externo, é definido em relação
a l07 MCS, como mostra a Fig. 5.l2. As coordenadas X e Y (em MCS) da
origem desse sistema de coordenadas são chamadas de deslocamentos
externos X e Y. Esses valores são armazenados nas variáveis do sistema #
520l e # 5202, respectivamente, em uma fresadora. Todos os outros sistemas
de coordenadas da peça de trabalho (G54, G55, etc.) são definidos em relação
a este sistema de coordenadas, que é sua única finalidade. Não pode ser
usado para execução de programas. Um programa é sempre executado no
sistema de coordenadas da peça escolhido (WCS). Se nenhuma escolha for
feita, o G54 é usado, que é o WCS padrão. O sistema externo de coordenadas
da peça de trabalho é usado para mudar uniformemente as origens de todos os
outros sistemas de coordenadas da peça de trabalho. Tal situação surge
quando o mesmo acessório, que contém um número de peças de trabalho,
todas requerendo serem usinadas em diferentes sistemas de coordenadas
(G54, G55, etc.), é colocado em um local diferente na mesa da máquina. Em
tais casos, em vez de redefinir G54, G55, etc. independentemente, somente o
sistema de coordenadas externo é redefinido para ter o mesmo efeito. Tal
situação em um torno surge quando o mandril original, que foi usado para
ajuste de deslocamento, é substituído por outro mandril com uma posição de
retenção diferente ao longo do eixo Z. Se tal requisito não estiver presente, não
há necessidade de usar este sistema de coordenadas. Nesses casos, todos os
valores de offset externos são mantidos como zero o que significa que este
sistema de coordenadas coincide com o MCS, e G54, G55, etc. são
efetivamente definidos diretamente em relação ao MCS.

G54-G59, G54.l Sistemas de coordenadas de peças Pl-P48

Seis padrões e 48 opcionais (que são ativados somente em fresadoras,


mediante pagamento extra), os sistemas de coordenadas da peça estão
disponíveis. Todos eles são definidos em relação ao sistema externo de
coordenadas da peça, como mostra a Fig. 5.l2. As várias distâncias de
deslocamento são armazenadas em diferentes variáveis do sistema, conforme
mostrado nas Tabelas 3.l2 e 5.2 (que é um subconjunto da Tabela 3.l2). Estes
sistemas de coordenadas são utilizados para fins de usinagem (apenas) e
colocados em locais desejados (isto é, no dado desejado da peça de trabalho),
especificando as várias distâncias de deslocamento. O procedimento de ajuste
de correção da ferramenta mede essas distâncias de deslocamento apenas.
Apenas um desses sistemas de coordenadas permanece ativo por vez. As
coordenadas usadas no programa são interpretadas pelo controle, no sistema
de coordenadas ativas (digamos, no sistema de coordenadas G54, embora o
controle converta internamente todas as coordenadas na máquina
sistema de coordenadas). Se houver apenas uma única peça a ser usinada o
tempo todo, não há necessidade de ter tantos sistemas de coordenadas da
peça. No entanto, em uma situação prática, várias peças de trabalho precisam
ser usinadas, todas com dados em diferentes locais. Em tais casos, sistemas
de coordenadas independentes, correspondentes a cada dado, são definidos, e
o sistema de coordenadas apropriado é ativado sempre que necessário. Como
o G54 é o sistema de coordenadas padrão, sempre que a máquina é ligada ou
o controle é o reset (pressionando a tecla RESET ou executando M02 ou M30),
o G54 se torna ativo. Deslocamento Zero Manipulando Distâncias de
Deslocamento Até agora, deve ficar claro que o controle coloca as origens de
diferentes WCSs nas distâncias especificadas pelo usuário a partir da origem
do MCS. Essa distância é a soma vetorial do vetor de deslocamento externo e
o vetor de deslocamento de trabalho correspondente. Assim, por exemplo, se o
deslocamento X-externo for l0, e o deslocamento X para G54 for 200, então o
controle colocará a origem do sistema de coordenadas G54 a uma distância de
2l0, na direção X positiva, de a origem do MCS. Por outro lado,
se a distância desejada de G54 do MCS for, digamos, 250, e o offset externo
não for alterado, então o deslocamento X de G54 terá que ser alterado para
240. Portanto, como um exemplo de deslocamento zero, se a atual posição X
da ferramenta deve ser feita para a origem do G54 (que pode ou não ser o
sistema de coordenadas atualmente ativo), a soma do deslocamento X-externo
e o deslocamento X de G54 terão que ser feitos igual à distância X da posição
atual da ferramenta do MCS (que será igual à coordenada X da posição atual
da ferramenta em
MCS). Matematicamente,

Deslocamento X-externo + deslocamento X de G54 = coordenada X da posição


atual da ferramenta, em MCS

Portanto, se o valor do deslocamento externo não for alterado, o deslocamento


X de G54 terá que ser igual à coordenada X no MCS menos o deslocamento
externo X, ou seja,

Deslocamento X de G54 = coordenada X da posição atual da ferramenta, no


deslocamento MCS-X-externo

Da mesma forma, para deslocamento zero para a posição Y atual da


ferramenta,

Deslocamento em Y de G54 = coordenada Y da posição atual da ferramenta,


em offset MCS-Y-extemal Este é o princípio que usaremos para deslocamento
zero, isto é, para mudar a origem do desejado (ativo ou caso contrário) WCS
para a posição atual da ferramenta.

Deslocamento Zero através das Variáveis do Sistema Para posicionar a origem


do WCS atual (embora o método seja válido também para um sistema de
coordenadas que não está ativo atualmente) na posição atual da ferramenta,
vamos supor, para fins de ilustração, que o ativo atual O sistema de
coordenadas é G56, e a atual posição XY da ferramenta deve ser feita com o
novo datum em uma fresadora. Isso pode ser feito redefinindo os valores de
deslocamento X e Y de G56, usando as seguintes fórmulas:

Deslocamento X de G56 = coordenada X da posição atual da ferramenta,


em offset externo MCS-X

Deslocamento Y de G56 = coordenada Y da posição atual da ferramenta, no


deslocamento externo MCS-Y

Em termos de variáveis do sistema, elas são convertidas para (consulte a


Tabela 3.ll e a Tabela 3.l2 / Tabela 5.2)

# 5 2 6l
# 5262
# 502l
# 5022
# 520l;
# 5202;

Observe que o RHS das fórmulas dadas acima seria o


mesmo para todos os WCSs. Por exemplo, essas fórmulas terão o seguinte
formato para deslocamento de dados XY para o G59:

# 532l = # 502l - # 520l;


# 5322 = # 5022 - # 5202;

Exibição de deslocamento de trabalho em uma fresadora

Uma tela típica de deslocamento de trabalho em uma fresadora, quando o


sistema de coordenadas ativo é G56, é mostrada na Tabela 5.3. Os
componentes do vetor de correção externa e os vários vetores de correção de
trabalho, ao longo de diferentes eixos, são os valores de correção
correspondentes, que são exibidos nessa tela. Os valores de deslocamento X,
Y e Z correspondentes
para G54, G55 e G56 foram deixados em branco nesta tabela. Estes irão
realmente exibir alguns valores. Os valores de deslocamento externos serão
todos zeros, conforme exibido, se o sistema de coordenadas externo não
estiver sendo usado, o que geralmente é o caso. Como já foi explicado, o
propósito de usar o sistema de coordenadas externo é deslocar o dado de
todos os outros sistemas de coordenadas da peça, G54 para G59, assim como
G54.l Pl-P48, pela mesma quantidade especificada. A tela de correção de
trabalho pode ser exibida pressionando a tecla OFS / SET, seguida pela tecla
de função WORK. Observe a exibição do G56 no canto superior esquerdo
dessa tela, que indica que o G56 está ativo no momento. Variáveis de sistema
para vários valores de offset de trabalho. Os números de variáveis de sistema,
correspondentes a vários valores de offset, são mostrados na Tabela 5.4, que é
uma repetição deliberada da Tabela 5.2 (a), em uma forma diferente, para
melhor clareza, pode correlacionar diretamente as variáveis do sistema com o
que se vê na tela. Os números variáveis correspondentes a G57, G58 e G59,
em uma fresadora, são mostrados na Tabela 5.5. Observe que os números de
variáveis correspondentes a vários valores de deslocamento não são alterados
quando o sistema de coordenadas atual é alterado. Portanto, por exemplo, #
526l sempre contém o valor de deslocamento do eixo X para G56,
independentemente de qual sistema de coordenadas está atualmente ativo. Do
Naturalmente, a máquina usa o valor armazenado em # 526l somente quando
G56 se torna o sistema de coordenadas atual. Deslocamento Zero através de
um Programa Para deslocamento zero, os valores de correção
correspondentes ao sistema de coordenadas da peça ativa atualmente
precisarão ser editados (a edição é possível para qualquer WCS, mas estamos
considerando o WCS atual em nosso
Exemplo). Isso pode ser feito manualmente também, após destacá-lo pelas
teclas de seta, digitando o novo valor e pressionando a tecla de função INPUT
ou a tecla INPUT no painel MDI. Quando isto é desejado para ser feito através
de um programa, é necessário ter as seguintes informações, dentro do
programa:

• O sistema de coordenadas da peça ativa atualmente


• Os números das variáveis do sistema, correspondentes ao deslocamento do
trabalho
valores deste sistema de coordenadas
• As coordenadas da posição atual da ferramenta no MCS

Referindo-se à Tabela 3.l0 (b), a variável de sistema # 40l4 armazena o


número do atual sistema de coordenadas da peça (que seria 56 em nosso
exemplo, já que G56 é assumido como o sistema de coordenadas atual). Por
outro lado, as variáveis de sistema # 502l e # 5022 armazenam as
coordenadas X e Y atuais (em uma fresadora), respectivamente,
no MCS (consulte a Tabela 3.ll). O número do programa 8008, que é baseado
nessas informações, desloca a origem do sistema de coordenadas atualmente
ativo para a posição atual da ferramenta em uma fresadora.

08008 (CURR WCS DATUM SHIFT no moinho M / C);

# l = # 40l4;
(O sistema de coordenadas atual, em nosso exemplo, é G56. Então, 56 seria
armazenado em # l)

# l # l - 53;
(Isso armazenaria l em # l, se o sistema de coordenadas atual for G54. Da
mesma forma, correspondendo a GSS, G56, G57, G58 e G59, os valores
armazenados seriam 2, 3, 4, 5 e 6, respectivamente. Em nosso exemplo, # l
armazenaria 3)
# l = # l * 20;
(Isso calcula o fator de multiplicação, conforme definido na Tabela 5.2 (b), para
o sistema de coordenadas atual. Em nosso exemplo, # l armazenaria 60)

# l = # l + 520l;
(# l armazenaria 522l, 524l, 526l, 528l, 530l e 532l, correspondendo a G54,
G55, G56, G57, G58 e G59, respectivamente, dependendo de qual deles é o
sistema de coordenadas atual. O valor armazenado seria o número da variável
correspondente ao valor do deslocamento de trabalho do eixo X para o sistema
de coordenadas atual, conforme mostrado na Tabela 3.l2 / Tabela 5.2 (a). Em
nosso exemplo, # l armazenaria 526l)

# [# l] = # 502l - # 5 20l;
(# 502l contém o Xcoordinate atual da ferramenta no MCS, e # 520l contém o
deslocamento X externo. Como já explicado, quando a diferença em seus
valores é armazenada na variável do sistema correspondente ao deslocamento
X de um WCS, a posição atual da ferramenta torna-se o novo X-datum daquele
WCS, ou seja, a posição atual da ferramenta é redefinida como XO nesse
WCS.No nosso exemplo, # 526l seria apropriadamente modificado, o que
mudaria o datum X de G56 para o posição X atual da ferramenta)

# [# l + l] = # 5 0 2 2 - # 5 2 0 2; (Desloca o ponto de referência do eixo Y para a


posição Y atual da ferramenta. Em nosso exemplo, # 5262 seria
apropriadamente modificado, o que mudaria o dado Y de G56)

M30;

Note que este programa foi escrito sem fazer um fluxograma. Um fluxograma
não é necessário para casos simples como este. O algoritmo neste programa é
muito simples: l. Identifique o atual sistema de coordenadas da peça de
trabalho. 2. Identifique as variáveis do sistema para os valores de
deslocamento de trabalho X e Y correspondentes a esse sistema de
coordenadas. 3. Redefina as variáveis do sistema identificado, usando as
fórmulas dadas. Entretanto, mesmo que se decida escrever um programa sem
fazer um fluxograma, pelo menos o algoritmo deve ser anotado em preto e
branco antes de tentar escrever o programa. Isso seria útil para referência
futura também, pois uma interpretação rápida e intuitiva de um programa de
macro geralmente não é possível devido à sua aparência abstrata.

Embora o programa dado acima deva ser usado em uma fresadora, ele
funcionaria em um torno praticamente da mesma maneira. A única diferença é
que o segundo eixo em um torno é o eixo Z. Então, o programa seria
exatamente o mesmo. Apenas substitua Y por Z na descrição deste programa.
No entanto, em uma aplicação prática em um torno, normalmente
somente deslocamento de dados Z pode ser necessário. Nesse caso, exclua o
bloco # [# l] = # 502l - # 520l do programa. O número do programa 8009 é o
programa modificado.

08009 (CURR WCS Z-DATUM SHIFT NO TORNO);

# l = # 40l4;
# l = # l - 53;
# l = # l * 20;
# l = # l + 520l;
# [# l + l] = # 5022- # 5202;
M30;

Ambos os programas são projetados para identificar e deslocar o datum do


atual WCS. Se o requisito é mudar o datum de, digamos, sistema de
coordenadas G56, independentemente de qual WCS é atual, esta é uma tarefa
mais simples, que pode ser feita pelos números de programa 80l0 e 80ll. É
claro que o efeito de deslocamento de dados será visível somente após o G56
se tornar o WCS atual.

080l0 (G56 DATUM SHIFT no moinho M / C);


# 526l = # 502l - # 520l;
# 5262 = # 5022 - # 5202;
M30;

080ll (G56 Z-DATUM SHIFT NO TORNO);


# 5262 = # 5022 - # 5202;
M30;

O programa dado pode parecer trivial (como se pode deslocar o dado


manualmente, usando o procedimento usual de configuração de
deslocamento), mas pode ser usado com muita eficiência. Por exemplo, se a
peça de trabalho em um torno é alterada para outra, com dimensões diferentes,
a configuração de referência para Z precisaria ser repetida (o dado X
permaneceria o mesmo, porque a posição XO não depende do diâmetro da
peça). a peça de trabalho). Se o operador da máquina não estiver totalmente
ciente da configuração de compensação
Neste procedimento, ele pode simplesmente ser solicitado a primeiro trazer a
ferramenta manualmente (no modo JOG ou HANDlE) para a posição ZO
desejada, e então executar o programa número 8009, sem perturbar a posição
da ferramenta. Isso colocaria o datum Z do WCS atual no local escolhido.
Naturalmente, isso deve ser feito no mesmo sistema de coordenadas da peça
que o programa de usinagem usa. Se for, digamos, G56, será preciso primeiro
executar G56 no modo MDI, antes de executar o número de programa 8009 no
modo AUTO. E a tecla RESET não deve ser pressionada
no meio, caso contrário, o sistema de coordenadas padrão da peça, G54,
voltará a ser o sistema de coordenadas ativo!

Nesta fase, é adequado salientar uma grande diferença no


a maneira como um programa é executado nos modos MDI e AUTO. Enquanto
esses dois modos são para propósitos diferentes: o modo MDI para 2-3
programas de linha que não precisam ser salvos, e o modo AUTO para
executar programas longos armazenados na memória do CNC, esta não é a
única diferença. Quando um programa é executado no modo MDI, o sistema
não é redefinido automaticamente quando a execução termina. Se o reset for
desejado, M02 ou M30 terão que ser programados explicitamente. Por outro
lado, mesmo que M02 ou M30 estejam faltando no final do programa sendo
executado no modo AUTO, o sistema será resetado automaticamente quando
a execução terminar (se o parâmetro 3404 # 6 estiver configurado para 0, o
sistema entrará no estado de alarme se M30 ou M02 estiver ausente no final do
programa.A configuração padrão deste parâmetro é l,
redefine o sistema sem qualquer alarme, mesmo se M30 ou M02 estiverem
faltando). Isso significa que, se um programa de linha única G56 for executado
no modo MDI, o G56 se tornará o WCS ativo. Por outro lado, se o mesmo
programa for executado no modo AUTOMÁTICO, o WCS ativo retornará ao
G54 no final da execução! Outra diferença, que não é relevante para nossa
discussão, é que a exibição gráfica dinâmica não está disponível no modo MDI.
O programa dado para deslocamento de referência, após algumas alterações,
também pode ser usado para configuração automática de correção de
ferramenta, usando sondas de toque, o que reduzirá drasticamente o tempo de
configuração. Esse aspecto é discutido em detalhes no cap. ll

5.6 Instrução WHILE aninhada

A discussão neste capítulo está completa, exceto que nenhum exemplo para
uma instrução WHIlE aninhada foi fornecido, até agora. Uma instrução WHIlE
simples é usada quando é necessário executar várias operações semelhantes,
desde que uma condição especificada permaneça satisfeita. Por outro lado, se
cada operação envolver outro conjunto de operações semelhantes, em um
loop condicional, em seguida, uma instrução WHIlE aninhada é usada. Embora
o controle permita mais um nível de aninhamento, praticamente nunca é
necessário. O conjunto retangular regular de furos em uma placa, mostrado na
Fig. 5.l3, pode ser feito de forma muito conveniente usando um ciclo fixo para
furação (digamos, G8l), já que todos os ciclos fixos podem ser repetidos em um
determinado número de vezes. O número do programa 80l2 é um desses
programas para este trabalho. Assume-se que a profundidade necessária dos
furos é de 5 mm e a superfície superior da placa é o ponto de referência para o
eixo Z. O dado XY é colocado no centro do furo l, como mostrado na figura. O
número do programa 80l3 usa uma instrução WHIlE aninhada de dois níveis,
com base no fluxograma mostrado na Figura 5.l4. Na instrução WHIlE
aninhada,
o laço externo foi usado para perfurar o número necessário de
orifícios ao longo do eixo X (isto é, na linha Y = 0), e o laço interno foi utilizado
para criar uma coluna de orifícios em cada orifício feito pelo laço externo.
080l2 (MOlA DE FURO USANDO UM CIClO EM CANA);

G2l G94 G90 G54; (Configurações iniciais)


M06 Tl; (Número de ferramenta l colocado no fuso)
M03 Sl 000; (Rpm no sentido horário l000)
G43 H0l; (Compensação do comprimento da ferramenta invocada)
GOO XO YO Zl00; (Ferramenta colocada l00 mm acima do furo l)
G8l G99 Z-5 R2 F30; (Furo l perfurado. Retração para Z = 2 mm)
G9l Y25 K2; (Buraco 2 e 3 perfurados)
X20 Y-50; (Buraco 4 perfurado)
Y25 K2; (Buraco 5 e 6 perfurados)
X20 Y-50; (Buraco 7 perfurado)
Y25 K2; (Buraco 8 e 9 perfurados)
X20 Y-50; (Buraco l0 perfurado)
Y25 K2; (Furos ll e l2 perfurados)
G80; (Ciclo fixo cancelado)
M05; (O fuso pára)
G90 GOO Zl00; (Ferramenta recolhida para Z = l00 mm)
M30; (Fim do programa e reinicialização do controle)

080l3 (MOlA DE FURO USANDO UM ENTRADO);


(# l @ COUNTERl, CONTADOR DE FURO AO longo DO X);
(# 2 @ COUNTER2, CONTADOR DE FURO AO longo DE Y);
(# 3 @ TOTAl DE NÚMEROS DE FUROS AO longo DE X);
(# 4 @ TOTAl DE NÚMEROS DE FUROS AO longo DE Y);
(# 5 @ PROFUNDIDADE DO BURACO);
(# 6 @ PITCH X);
(# 7 @ PITCH AO longo Y);

# 3 = 4; (Quatro furos ao longo do eixo X a serem feitos)


# 4 = 3; (Três buracos ao longo do eixo Y a ser feito)
# 5 = 5; (A profundidade do buraco é 5 mrn)
# 6 = 20; (Pitch ao longo de uma linha é de 20 mm)
# 7 = 25; (Pitch ao longo de uma coluna é de 25 mrn)

G2l G94G90G54; (Configurações iniciais)


M06 T1; (Número de ferramenta 1 colocado no fuso)
M03 S1000; (RPM no sentido horário 1000)
G43 H01; (Compensação do comprimento da ferramenta invocada)

G00 X0 Y0 Z100; (Ferramenta colocada 100 mm acima do furo 1)


# 1 = 1; (COUNTER 1 inicializado)

WHILE [# 1 LE # 3] D01;
(O loop externo é iniciado. Ele é executado uma vez para cada coluna de furos)

G90 G8l G99 Z- [ABS [# 5]] R2 F30; (O uso da função ABS faz o programa
funcionar mesmo que um valor negativo seja especificado para a profundidade
do furo)
# l = # l + l; (COUNTERl incrementado para furos na próxima coluna de furos)

# 2 = l; (COUNTER2 inicializado)

WHILE [# 2 lE [# 4- l]] DO 2;
(O loop interno é iniciado. Ele faz o número necessário de furos em cada
coluna de furos)

G9l GOO Y # 7;
(A ferramenta deslocada ao longo do eixo Y para o centro do próximo furo na
coluna atual de furos)

G90 G8l G99 Z- [ABS [# 5]] R2 F30;


(Furado)

# 2 = # 2 + l;
(COUNTER2 incrementado para contar e perfurar o número necessário de
furos na coluna atual de furos)

END 2; (O loop interno termina)

SE [# l GT # 3] GOTO l0;
(Deslocar para a base da próxima coluna de furos não é necessário após a
última coluna)

G9l GOO X # 6 Y - [# 7 * [# 4 - l]];


(Ferramenta deslocada para a base da próxima coluna de furos)

Nl0; (Uma declaração NC em branco)


END l; (O loop externo termina)
G8O; (Ciclo fixo cancelado)
M05; (O fuso pára)
G90 GOO Zl00; (Ferramenta recolhida para Z = l00 mm)
M30; (Fim do programa e reinicialização do controle)

Embora possa parecer que o uso da instrução WHIlE neste


Caso é um método muito complexo para um problema muito simples, este
método seria definitivamente preferível para um grande número de buracos. De
fato, mesmo que o número de buracos aumente, o programa permanece
essencialmente o mesmo; somente as duas variáveis (# 3 e # 4) para o número
de furos ao longo das direções X e Y precisariam ser redefinidas, conforme a
necessidade. Embora o uso de um loop, especialmente um loop aninhado,
torne um programa simples complexo, ele torna um problema complexo
bastante simples! De qualquer forma, o objetivo básico aqui era explicar o uso
da instrução WHIlE aninhada. Além disso, este é o nosso primeiro programa
que envolve usinagem, e que também é uma aplicação prática comum.
A utilidade de um fluxograma é mais do que aparente neste exemplo. Mesmo
que o fluxograma pareça simples e sua lógica possa ser facilmente verificada,
isso não acontece com o programa. Um programa que usa recursos de macro
sempre parece muito mais complexo do que realmente é. Assim, sem um
fluxograma, não só é difícil interpretar o programa, mas também é provável que
os erros lógicos se insinuem durante o desenvolvimento de tal programa. Por
outro lado, se o fluxograma estiver pronto e verificado, a codificação do
programa é apenas um trabalho mecânico. Note que o programa dado é mais
geral que o fluxograma. Este é outro truque para simplificar a nossa vida.
Primeiro, faça um fluxograma simples para um caso especial e escreva o
programa. Quando o programa estiver pronto, é fácil modificá-lo para um caso
geral. O programa dado aceitaria quaisquer valores para o número de linhas e
colunas de furos, profundidade de furos, pitch ao longo de linhas e pitch ao
longo de colunas. De fato, é possível introduzir mais complexidade no
programa. Por exemplo, dependendo da profundidade especificada dos furos, o
programa pode ser feito para selecionar automaticamente um ciclo de furação
apropriado, por exemplo, G8l para furos rasos, G73 para furos profundos e G83
para furos muito profundos. Para isso, basta substituir G8l por G # 8 e definir #
8 (que pode ser 8l, 73 ou 83) com base no # 5 (profundidade do furo), usando
instruções condicionais da seguinte maneira:

IF [# 5 LE 5] ENTÃO # 8 = 81; (Poços rasos, profundidade <= 5 mm)

IF [[# 5 GT 5] E [# 5 LE 50]] ENTÃO # 8 = 73;

(Furos profundos, 5 mm <profundidade: <= 5 mm)

SE [# 5 GT 50] ENTÃO # 8 = 83;


(Furos muito profundos, profundidade> 50 mm)

G90 G # 8 G99 Z- [ABS [# 5]] R2 F30;

Também é possível inserir traps de erro no programa, para abortar ou


interromper temporariamente a execução em caso de dados / valores de
entrada fora do intervalo ou ilegais:

IF [# 5 GT 100] ENTÃO # 3000 = 1 (FURO MUITO PROFUNDO);


IF [[# 6 LE 5] OU [# 7 LE 5]] ENTÃO # 3006 = 1 (PITCH TOO SMAll);

Observe que a primeira instrução geraria uma condição de alarme, que


encerraria a execução adicional do programa. A segunda instrução irá apenas
pausar a execução, que pode ser reiniciada pressionando CYCLE START
novamente, se o operador achar que a inclinação especificada está correta. Em
ambos os casos, as mensagens nos colchetes serão exibidas na tela de alarme
/ tela de mensagens. Em geral, modificar um programa é muito mais simples do
que preparar o programa básico. Portanto, não importa o quão complexo seja
um requisito, comece sempre com um caso simplificado. Nunca se preocupe
com os aspectos ornamentais de um programa no começo. De fato, uma vez
que o programa básico está pronto e funciona bem, o próprio programador é
incentivado a torná-lo melhor!

Então, como regra geral, comece sempre com um alvo pequeno e facilmente
alcançável. Voltando à questão do aninhamento, o leitor deve ter percebido que
se houvesse um padrão de furos em vez de um único buraco em cada local, o
terceiro nível de aninhamento teria sido necessário para fazer o padrão de
furos em cada local. Esse exemplo é mostrado na Fig. 5.l5. No entanto, três
níveis de aninhamento tornam a lógica complexa demais para ser facilmente
entendida. Portanto, não devem ser usados mais do que dois níveis, a menos
que seja absolutamente necessário. Isso seria praticamente possível, embora o
programa não fosse tão compacto e geral quanto os três níveis de
aninhamento. Por exemplo, é possível usar apenas um nível de aninhamento
(na verdade, um nível de aninhamento implica que não há nenhum
aninhamento) para o trabalho da Fig. 5.l5. Basta escrever uma macro para o
padrão polar (que exigirá um único nível da instrução WHIlE, sem qualquer
aninhamento) e chamá-la l2 vezes depois de colocar a ferramenta nos centros
de todos os padrões polares, um por um. Tal programa, evidentemente, não
será um programa de propósito geral.

CAPÍTULO 6 Revisão de Subprogramas

Introduções

É necessário entender por que e como os subprogramas são usados antes de


tentar aprender como escrever macros. Embora se espere que os leitores
estejam bem cientes dos subprogramas, este capítulo apresenta uma breve
revisão para atualizar a memória. Mesmo se alguém já usou subprogramas
antes, é altamente recomendado que este capítulo seja lido com atenção, para
eliminar a possibilidade de qualquer elo perdido.

O que é um subprograma?

Como o nome sugere, um subprograma é uma parte de um programa que é


armazenado na memória do CNC como qualquer outro programa com um
número de programa especificado. Não é um programa completo e foi
projetado para ser chamado por outro programa, que pode ser um programa
principal, outro subprograma ou uma macro. Um subprograma por si só seria
geralmente sem sentido, a menos que fosse usado dentro de algum outro
programa.

Por que é usado?

Às vezes, um programa contém blocos de programas repetitivos que aparecem


em vários lugares sem qualquer alteração. Por exemplo, suponha que uma
ranhura de certa geometria e l0 mm de profundidade seja cortada em uma
placa plana em uma fresadora. Se a profundidade máxima permitida de corte
for de 2 mm, a ranhura teria que ser fresada em cinco passos, depois de
colocar a ferramenta em sucessivamente.

Subprogramas versus sub-rotinas de uma linguagem convencional de


computador.

A única semelhança entre os dois é que ambos são chamados por outros
programas. Os subprogramas não são tão flexíveis e versáteis como as sub-
rotinas. As sub-rotinas de uma linguagem de computador convencional, como
FORTRAN, são mais parecidas com as macros descritas no Cap. 7. Uma
chamada de subprograma é simplesmente uma operação de copiar e colar do
programa chamado no programa de chamada. Apesar de seu escopo limitado,
o uso de subprogramas simplifica a programação e torna o programa
organizado.

6.2 Chamada do Subprograma

A sintaxe de uma chamada de subprograma é M98 – Pl234;

Que chama o programa 0l234 uma vez, como um subprograma. O número do


programa de um subprograma pode ser qualquer número de programa válido,
ou seja, qualquer programa no intervalo 0000l (que é o mesmo que 0l, 00l, ou

000l, isto é, o número de programa l) a 09999:


M98 PODOl; (Chama o programa 0000l uma vez)
M98 POOl; (O mesmo que acima)
M98 POl; (O mesmo que acima)
M98 Pl; (O mesmo que acima)
M98 P9999; (Chama o programa 09999 uma vez)

O fim da execução do subprograma é indicado por M99 que retorna a


execução para o bloco seguindo o bloco de chamada do programa que chamou
o subprograma (ou seja, para o bloco próximo a M98 Pl234, no primeiro
exemplo). M99 é semelhante à instrução RETURN do FORTRAN. Como
exemplo de uso de subprogramas, considere o sulco triangular da Fig. 6.l. O
programa 0000l usinaria essa ranhura movendo uma fenda de 6 mm de
diâmetro ao longo da linha central da ranhura. Os blocos repetitivos, que
definem a geometria da ranhura, aparecem em cinco locais neste programa.
Esses blocos foram destacados para fácil identificação. O ponto zero da peça
de trabalho foi escolhido para ficar no canto inferior esquerdo do triângulo,
como mostrado na figura. O dado Z, para este programa, assim como para
todos os programas que aparecem neste livro, é colocado na superfície
superior da peça de trabalho.

0000l; (Programa número l)


G2l G94; (Modo milimetrado e velocidade de avanço em milímetro por minuto)
G54; (Sistema de coordenadas da peça de trabalho)
G9l G28 XO YO ZO; (Retorno do ponto de referência)

O fim da execução do subprograma é indicado por M99 que retorna a


execução para o bloco seguindo o bloco de chamada do programa que chamou
o subprograma (ou seja, para o bloco próximo a M98 Pl234, no primeiro
exemplo). M99 é semelhante à instrução RETURN do FORTRAN. Como
exemplo de uso de subprogramas, considere o sulco triangular da Fig. 6.l. O
programa 0000l usinaria essa ranhura movendo uma fenda de 6 mm de
diâmetro ao longo da linha central da ranhura. Os blocos repetitivos, que
definem a geometria da ranhura, aparecem em cinco locais neste programa.
Esses blocos foram destacados para fácil identificação. O ponto zero da peça
de trabalho foi escolhido para ficar no canto inferior esquerdo do triângulo,
como mostrado na figura. O dado Z, para este programa, assim como para
todos os programas que aparecem neste livro, é colocado na superfície
superior da peça de trabalho.

0000l; (Programa número l)

G2l G94; (Modo milimetrado e velocidade de avanço em milímetro por minuto)


G54; (Sistema de coordenadas da peça de trabalho)
G9l G28 XO YO ZO; (Retorno do ponto de referência)

M06 Tl; (Ferramenta número l)


M03 SlOOO; (CW rpm l000)
G90 G43 HOl; (Compensação do comprimento da ferramenta)
GOO XO Y60 ZlOO; (Posicionamento rápido até l00 mm acima do canto
superior da ranhura)
Zl; (Posicionamento rápido a l mm acima da peça de trabalho)
GOl Z-2 FlO; (Buraco de 2 mm de profundidade)
YO F60; (Sulco de 2 mm de profundidade ao longo do eixo Y)
X60; (Sulco de 2 mm de profundidade ao longo do eixo X)
XO Y60; (Ranhura de 2 mm a 45 °)
Z-4 FlO; (Buraco de 4 mm de profundidade)
YO F60; (Sulco de 4 mm de profundidade ao longo do eixo Y)
X60; (Sulco de 4 mm de profundidade ao longo do eixo X)
XO Y60; (Ranhura de 4 mm a 45 °)
Z-6 FlO; (Buraco de 6 mm de profundidade)
YO F60; (Sulco de 6 mm de profundidade ao longo do eixo Y)
X60; (Sulco de 6 mm de profundidade ao longo do eixo X)
XO Y60; (Ranhura de 6 mm a 45 °)
Z-8 FlO; (Buraco de 8 mm de profundidade)
YO F60; (Sulco de 8 mm de profundidade ao longo do eixo Y)
X60; (Sulco de 8 mm de profundidade ao longo do eixo X)
XO Y60; (Ranhura de 8 mm a 45 °)
Z-l0 FlO; (Buraco de l0 mm de profundidade)
YO F60; (Sulco de l0 mm de profundidade ao longo do eixo Y)
X60; (Sulco de l0 mm de profundidade ao longo do eixo X)
XO Y60; (Ranhura de l0 mm a 45 °)
GOO ZlOO; (Retração rápida até l00 mm acima do
peça de trabalho)
M05; (Parada do fuso)
M30; (Final de execução e reset de controle)

O programa acima pode ser reduzido usando um subprograma para armazenar


os blocos repetitivos. O programa 00002 é um programa que chama o
programa 00003 como um subprograma, cinco vezes.

00002; (Programa número 2)

G2l G94; (Modo milimetrado e velocidade de avanço em milímetro


por minuto)
G54; (Sistema de coordenadas da peça de trabalho)
G9l G28 XO YO ZO; (Retorno do ponto de referência)
M06 Tl; (Ferramenta número l)
M03 SlOOO; (CW rpm l000)
G90 G43 HOl; (Compensação do comprimento da ferramenta)
GOO XO Y60 ZlOO; (Posicionamento rápido até l00 mm acima
o canto superior da ranhura)
Zl; (Posicionamento rápido a l mm acima do
peça de trabalho)
GOl Z-2 FlO; (Buraco de 2 mm de profundidade)
M98 P0003; (Chamada de subprograma de 00003)
GOl Z-4 FlO; (Buraco de 4 mm de profundidade)
M98 P0003; (Chamada de subprograma de 00003)
GOl Z-6 FlO; (Buraco de 6 mm de profundidade)
M98 P0003; (Chamada de subprograma de 00003)
GOl Z-8 FlO; (Buraco de 8 mm de profundidade)
M98 P0003; (Chamada de subprograma de 00003)
GOl Z-l0 FlO; (Buraco de l0 mm de profundidade)
M98 P0003; (Chamada de subprograma de 00003)
GOO ZlOO; (Retração rápida até l00 mm acima do peça de trabalho)
M05; (Parada do fuso)
M30; (Final de execução e reset de controle)
00003; (Programa número 3)

YO F60; (Sulco ao longo do eixo Y, na profundidade atual)


X60; (Ranhura ao longo do eixo X, na profundidade atual)
XO Y60; (Ranhura a 45 °, na profundidade atual)
M99; (Retornar ao programa de chamada)

É possível chamar o subprograma um número desejado de vezes


repetidamente, isto é, um após o outro. Até 999 repetições são permitidas. O
argumento do bloco Pin M98 deve conter sete dígitos (ou um mínimo de cinco
dígitos) para isso. Quatro dígitos da direita são considerados o número do (sub)
programa e os dígitos restantes (no máximo três) à esquerda indicam o número
de repetições. E se oito dígitos forem especificados na palavra P, o oitavo
dígito da direita será ignorado:

M98 P5000l; (Chama o número do programa l, cinco vezes, o que equivale a


cinco blocos consecutivos de M98 PODOl ou M98 Pl)

M98 P05000l; (O mesmo que acima)


M98 P005000l; (O mesmo que acima)
M98 P 999000l; (O número do programa l é chamado 999 vezes)
M98 Pl23 4000l; (O número do programa l é chamado 234 vezes. O oitavo
dígito da direita é ignorado)

Uma sub-rotina também pode ser chamada repetidamente inserindo uma


palavra L no bloco M98. O argumento da palavra L é o número de repetições. A
vantagem de usar esse método é que até 9999 repetições seriam possíveis,
em comparação com apenas 999 com o método anterior:

M98 POOOl L9999; (O número de programa l é chamado 9999 vezes)


M98 Pl L9999; (O mesmo que acima)
M98 Pl Ll OOOO; (Palavra L ilegal)

Se a chamada repetida de um subprograma simplesmente refizer o percurso, a


repetição seria desnecessária e sem sentido. Repetição seria útil apenas no
modo incremental, onde é possível ter caminhos de ferramenta diferentes nas
execuções subsequentes do mesmo subprograma. Por exemplo, o programa
00004 chama repetidamente o programa 00005 cinco vezes no modo
incremental, para fazer a ranhura da Fig. 6.l.

00004; (Programa número 4)

G2l G94; (Modo milimetrado e velocidade de avanço em milímetro por minuto)


G54; (Sistema de coordenadas da peça de trabalho)
G9l G28 XO YO ZO; (Retorno do ponto de referência)
M06 Tl; (Ferramenta número l)
M03 SlOOO; (CW rpm l000)
G90 G43 HOl; (Compensação do comprimento da ferramenta)
GOO XO Y60 ZlOO; (Posicionamento rápido até l00 mm acima do canto
superior da ranhura)
Zl; (Posicionamento rápido a l mm acima da peça de trabalho)
GOl ZO FlO; (A ferramenta toca a peça de trabalho)
G9l; (Modo de coordenadas incrementais)
M98 P50005; (Chamada de subprograma de 00005, cinco vezes)
G90 GOO ZlOO; (Retração rápida até l00 mm acima da peça de trabalho)
M05; (Parada do fuso)
M30; (Final de execução e reset de controle)

00005; (Programa número 5)

Z-2 FlO; (Profundidade do furo aumentada em 2 mm)


Y-60 F60; (Sulco ao longo do eixo Y, na profundidade atual)
X60; (Ranhura ao longo do eixo X, na profundidade atual)
X-60 Y60; (Ranhura a 45 °, na profundidade atual)
M99; (Retornar ao bloco G90 GOO Zl00 do chamado
programa, após cinco execuções sucessivas do
subprograma)

Embora o subprograma dado acima funcione bem, ele pode ser um pouco mais
geral invocando o modo incremental dentro dele. Então, mesmo que seja
chamado no modo absoluto, o groove seria feito corretamente. Isso reduz a
possibilidade de seu uso incorreto. Os programas 00006 e 00007 usam essa
ideia.

00006; (Programa número 6)

G2l G94; (Modo milimetrado e velocidade de avanço em milímetro por minuto)


G54; (Sistema de coordenadas da peça de trabalho)
G9l G28 (retorno do ponto de referência)
M06 Tl; (Ferramenta número l)
M03 SlOOO; (CW rpm l000)
G90 G43 HOl; (Compensação do comprimento da ferramenta)
ZO; (Posicionamento rápido até l00 mm acima do canto superior da ranhura)
GOO XO Y60 ZlOO; (Posicionamento rápido a l mm acima do
Zl; peça de trabalho)
GOl ZO FlO; (A ferramenta toca a peça de trabalho)
M98 P50007; (Chamada de subprograma de 00007, cinco vezes)
G90 GOO ZlOO; (Retração rápida até l00 mm acima da peça de trabalho)
M05; (Parada do fuso)
M30; (Final de execução e reset de controle)
00007; (Programa número 7)

G9l Z-2 FlO; (Profundidade do furo aumentada em 2 mm)


Y-60 F60; (Sulco ao longo do eixo Y, na profundidade atual)
X60; (Sulco ao longo do eixo X, na profundidade atual)
X-60 Y60; (Sulco a 45 °, na profundidade atual)
M99; (Retornar para o bloco G90 GOO ZlOO da chamada
programa, após cinco execuções sucessivas do
subprograma)

O subprograma dado acima é definitivamente melhor, já que pode ser chamado


nos modos absoluto e incremental. No entanto, ele tem uma falha: força o
modo incremental quando a execução retorna ao programa de chamada. Além
disso, assume que o COl está ativo no momento de chamá-lo. Esta é outra
fonte de erros de programação. Subprogramas e macros devem ser feitos o
mais geral possível / prático, porque geralmente eles são desenvolvidos por
programadores especialistas para uso em vários programas preparados por
outros programadores. Se um novo programador chamar um subprograma
desenvolvido por algum outro programador, ele definitivamente não espera que
o subprograma altere o modo de coordenadas ou qualquer outra configuração
do programa de chamada! Felizmente, usando recursos de programação
macro, é possível identificar o modo de coordenadas atual, entre várias outras
coisas. Assim, um subprograma pode ser projetado de tal maneira que não
altere o status atual do controle. Isso pode ser feito identificando o status do
controle no início do subprograma e restaurando-o no final, ou seja, antes de
sair do programa de chamada por M99.
Observe que o subprograma 00007 precisa usar três coisas: COl, G9l e F-
code. O COl pertence ao Grupo G-éode 0l, e o G9l pertence ao Grupo 03. Os
outros G-eodes do Grupo 0l são GOO, C02, G03 e G33 em uma fresadora. Por
outro lado, G90 é o único outro G-eode no Grupo 3. Referindo-se à Tabela 3.l0
(b), a variável de sistema # 400l armazena 0, l, 2, 3 ou 33 dependendo do G-
éode atualmente ativo de Grupo 0l (GOO, COl, C02, G03 e G33,
respectivamente). Por exemplo, se o COl estiver ativo no momento, o # 400l
armazenará l (lembre-se de que, a qualquer momento, um G-eode de cada
grupo permanece ativo). Da mesma forma, a variável do sistema # 4003
armazena 90 ou 9l dependendo de qual dos G90 e G9l está atualmente ativo.
O avanço atual é armazenado na variável de sistema # 4l09.

O subprograma 00008 usa essas variáveis do sistema para verificar o status


atual do controle no início do programa e restaura-lo no final (lembre-se que
uma instrução como COl, sem palavras de eixo, simplesmente altera o G-eode
atualmente ativo do Grupo l para COl, sem causar nenhum movimento da
ferramenta): Observe que a lógica funciona mesmo no caso de várias
chamadas do subprograma.

Além disso, com a finalidade de tornar o subprograma 00008 ainda mais geral,
a velocidade do fuso também pode ser especificada dentro dele, de modo que
uma rpm possivelmente incorreta especificada no programa de chamada não
seja usada. Como o subprograma supõe uma rpm constante, o G97 precisaria
ser especificado. Referindo-se à Tabela 3.l0 (b), a variável do sistema # 40l3
armazena 96 ou 97 dependendo do que é G96 (velocidade de superfície
constante) e G97 (constante rpm) está atualmente ativo, e a velocidade atual
do fuso / velocidade de superfície constante é armazenada na variável de
sistema # 4ll9.

Além disso, o avanço no subprograma é desejado em milímetro por minuto.


Então, G94 também é necessário. Referindo-se novamente à Tabela 3.l0 (b), a
variável de sistema # 4005 armazena 94 ou 95, correspondendo a G94 e G95.
Finalmente, o subprograma foi escrito em modo milimétrico. Portanto, se for
chamado no modo polegadas, a execução deve ser finalizada com uma
mensagem de alarme (lembre-se de que o modo de coordenadas não pode ser
alternado no meio de um programa). A variável de sistema # 4006 armazena
20 ou 2l, correspondendo a G20 e G2l [consulte a Tabela 3.l0 (b).]

00008; (Programa número 8)

# l = # 400l; (# l armazena 0, l, 2, 3 ou 33)


# 2 = # 4003; (# 2 armazena 90 ou 9l)
# 3 = # 4l09; (# 3 armazena o valor atual especificado na Fword, ou seja, o
atual avanço)
# 4 = # 40l3 (# 4 armazena 96 ou 97)
# 5 # 4ll9; (# 5 armazena o valor atual especificado na Espada, ou seja, a rpm
atual ou a velocidade de superfície constante, dependendo de qual dos G97 e
G96 está atualmente ativo)
# 6 = # 4005; (Nº 6 armazena 94 ou 95)
# 7 = # 4006; (# 7 armazena 20 ou 2l)
SE [# 7 EQ 20] ENTÃO # 3000 = l (MODO DE ENTRADA NÃO PERMITIDO);
(Se G20 for usado no programa de chamada, a execução terminará
imediatamente com a mensagem de alarme "MODO DE POUPANÇA 300l NÃO
PERMITIDO." Consulte Alarmes de Macro no Capítulo 3.5).
G94 G97 G9l; (Seleciona a velocidade de avanço em milímetro por minuto, rpm
constante e modo incremental)
GOl Z-2 FlO SlOOO; (Profundidade do furo aumentada em 2 mm a l000 rpm e
avanço de l0 mm / min)
Y-60 F60; (Sulco ao longo do eixo Y, na profundidade atual)
X60; (Ranhura ao longo do eixo X, na profundidade atual)
X-60 Y60; (Ranhura a 45 °, na profundidade atual)
G # l G # 2 F # 3 G # 4 S # 5 (Restaura o status do controle original)
M99; (Retornar ao programa de chamada)

O subprograma 00008 é bastante geral. Assume-se apenas que a ferramenta


(um slot de 6 mm de diâmetro) toca a peça de trabalho no canto superior da
ranhura triangular, no momento em que a chama. O único lirnitation é que só
pode fazer sulcos de profundidades no múltiplo de 2 mm. Por exemplo, o M98
P40008 faria um sulco de 8 mm de profundidade. Mas não é possível ter uma
profundidade de, digamos, 5 mm, pois não é um múltiplo de 2 mm. Além disso,
a ferramenta permanece na parte inferior do canto superior da ranhura quando
a execução retorna ao programa de chamada. Embora a posição XY seja a
mesma que no começo, a posição Z também deve ser restaurada. Idealmente,
um subprograma ou uma macro deve fazer o que for necessário, sem perturbar
qualquer configuração de controle. Embora as macros possam fazer
praticamente qualquer coisa, os subprogramas têm suas próprias limitações,
porque não é possível transmitir quaisquer valores para suas variáveis ao
chamá-las. Além disso, um subprograma não possui seu próprio conjunto de
variáveis locais. Apenas age como uma extensão do programa de chamada.
Uma macro para uma profundidade arbitrária do sulco é dada no Capítulo. 8.
Se a mesma coisa deve ser feita através de um subprograma, uma variável,
digamos, # l00 precisará ser definida, armazenando a profundidade desejada
da ranhura, antes de chamar o subprograma, para que o subprograma possa
usá-lo. Como tal subprograma usa uma lógica envolvendo a execução em um
loop, um fluxograma do algoritmo escolhido deve ser preparado antes de
gravar o programa. A Figura 6.2 mostra esse fluxograma. Subprograma 00009,
que é baseado neste fluxograma, é fornecido juntamente com a parte relevante
do programa de chamada. Note que 00009 precisa ser chamado apenas uma
vez, para qualquer profundidade de groove. O uso de loops elimina a
necessidade de várias chamadas de subprogramas.
(Programa de chamada)

# l00 = 5; (Especifique a profundidade desejada da ranhura)


M98 P0009; (Chamada de subprograma de 00009)
M30; (Final de execução e reset de controle)
00009; (Programa número 9)
# l # 400l; (# l armazena 0, l, 2, 3 ou 33)
# 2 # 4003; (# 2 armazena 90 ou 9l)
# 3 # 4l09; (# 3 armazena o valor atual especificado na palavra F, ou seja, o
avanço atual)
# 4 # 40l3; (# 4 armazena 96 ou 97)
# 5 # 4ll9; (# 5 armazena o valor atual especificado na palavra S, ou seja, a rpm
atual ou a velocidade da superfície constante, dependendo de qual dos G97 e
G96 está atualmente ativo)
# 6 # 4005; (Nº 6 armazena 94 ou 95)
# 7 # 4006; (# 7 armazena 20 ou 2l)
# 8 ABS [#lOO]; (# 8 armazena a profundidade desejada da ranhura. A função
ABS garante que, mesmo que a profundidade seja especificada com um sinal
de menos, o programa funcionaria corretamente)
# 9 = # 8; (# 9 armazena a profundidade restante da ranhura, que será
usinada)
SE [# 7 EQ 20] ENTÃO # 3000 = l (MODO DE ENTRADA NÃO PERMITIDO);
(Se G20 for usado no programa de chamada, a execução terminará
imediatamente com a mensagem de alarme "MODO DE POUPANÇA 300l NÃO
PERMITIDO". Consulte Alarmes de Macro na seção 3.5)
G94 G97 G9l; (Seleciona a velocidade de avanço em milímetro por minuto, rpm
constante e modo incremental)
WHILE [# 9 GT 2] DO l; (Início do loop WHILE. O loop é executado se a
profundidade restante da ranhura for maior que 2 mm. Caso contrário, o loop é
ignorado e a execução salta para o bloco após ENDl)
GOl Z-2 FlO SlOOO; (Profundidade do furo aumentada em 2 mm a l000 rpm e
avanço de l0 mm / min)
Y-60 F60; (Sulco ao longo do eixo Y, na profundidade atual)
X60; (Ranhura ao longo do eixo X, na profundidade atual)
X-60 Y60; (Ranhura a 45 °, na profundidade atual)
# 9 = # 9 - 2; (Profundidade remanescente recalculada)
END l; (Fim do loop WHILE. A execução salta para o início do loop para
verificar se a profundidade restante da ranhura ainda é maior que 2 mm)
GOl Z- # 9 FlO; (Profundidade do furo aumentada pela quantidade necessária,
que é agora menor ou igual a 2 mm, para alcançar a profundidade final da
ranhura, a l000 rpm e l0 mm / min de avanço)
Y-60 F60; (Sulco ao longo do eixo Y, na profundidade final)
X60; (Sulco ao longo do eixo X, na profundidade final)
X-60 Y60; (Sulco a 45 °, na profundidade final)
GOO Z # S; (Restaura a posição Z inicial da ferramenta)
G # l G # 2 F # 3 G # 4 (Restaura o status do controle original)
M99; (Retornar ao programa de chamada)
No programa 00009, assume-se que a profundidade máxima permitida de corte
é de 2 mm. Como exercício, tente modificar o programa quando a profundidade
de corte máxima permitida for de l mm. Além disso, tente construir o loop
usando a instrução IF _GOTO_. O fluxograma para esse caso é dado na Fig.
6.3. Observe, no entanto, que a instrução WHILE é preferida à instrução IF
GOTO_ para construir loops, conforme discutido no Cap. 5. O fluxograma
apresentado na Fig. 6.3 precisaria usar a instrução IF_ GOTO duas vezes. Isso
ocorre porque a profundidade desejada da ranhura pode ser menor que l mm.
No loop criado pela instrução IF _GOTO_, a condição de finalização do loop é
verificada no final. Portanto, também é necessário verificar a profundidade
desejada antes de entrar no loop, para decidir se o loop deve ser executado.
Esse problema não estava lá com o loop WHILE porque a condição de
finalização do loop está marcada no início do loop. Esta é mais uma razão pela
qual o loop WHILE é preferido sobre o IF _GOTO_loop. Os programas 00008 e
00009 usaram vários recursos de macroprogramação. O uso de recursos de
macroprogramação não se restringe apenas ao desenvolvimento de macros,
embora esse seja seu objetivo principal. Os principais programas também
podem usar esses recursos. Na verdade, é assim que se deve começar a
aprender programação macro. Escrever macros para diferentes aplicativos
deve ser iniciado somente depois de dominar os recursos básicos da
linguagem, usando-os nos principais programas e subprogramas, tanto quanto
possível.
6.4 Assentamento do Subprograma

Um subprograma pode chamar outro subprograma, que é chamado de


aninhamento. Um máximo de quatro níveis de aninhamento, envolvendo o
programa principal e quatro subprogramas diferentes, é permitido, isto é, o
programa principal pode chamar o subprograma l, o subprograma l pode
chamar o subprograma 2, o subprograma 2 pode chamar o subprograma 3 e o
subprograma 3 pode chamar subprograma 4 (o subprograma 4 não pode
chamar nenhum outro subprograma). Isto é representado pictoricamente na
Fig. 6.4, onde o fluxo de execução é mostrado por setas. Observe que não há
restrições sobre o número total de subprogramas ou o número de
subprogramas aninhados em um programa principal, apenas que o nível de
aninhamento em um determinado local deve ser de quatro ou menos. Consulte
também a Fig. 3.2, que explica que as variáveis do programa principal e todos
os subprogramas aninhados pertencem ao mesmo conjunto de variáveis. Por
exemplo, se uma variável, digamos # l, está sendo usada pelo programa
principal, bem como todos os subprogramas aninhados, todas as cinco
ocorrências de # l referem-se ao mesmo local de memória.
Como um exemplo de aninhamento de subprogramas, considere o trabalho
mostrado na Fig. 6.5, onde cinco ranhuras triangulares de 10 mm de
profundidade devem ser usinadas em uma placa de tamanho de 600 mm x 300
mm. O recurso de aninhamento de subprogramas pode ser usado para tornar o
programa para um padrão tão regular e repetitivo muito curto. Mais uma vez, a
profundidade máxima de corte permitida é de 2 mm. Portanto, como a
profundidade dos sulcos é de 10 mm, seriam necessários cinco passes para
cada triângulo. Todo o exercício precisaria ser repetido cinco vezes, para fazer
cinco sulcos triangulares. Isso pode ser feito por aninhamento de dois níveis. A
chamada do subprograma 00011 faz as ranhuras triangulares em cinco locais,
e a chamada aninhada do subprograma 00012 faz cada ranhura em cinco
passa. O ponto zero da peça de trabalho é escolhido para ficar no canto inferior
esquerdo da placa, com dados Z em sua superfície superior. Note que, em tais
aplicações, os subprogramas precisam ser escritos no modo incremental.
Nenhuma tentativa foi feita nesses programas para torná-los adequados para
um caso geral, usando recursos de programação macro, já que o único objetivo
aqui é ilustrar o aninhamento de subprogramas.

00010; (Programa número 10)

G21 G94; (Modo milimetrado e velocidade de avanço em milímetro por minuto)


G54; (Sistema de coordenadas da peça de trabalho)
G91 G28 X0YO (retorno do ponto de referência)
M06 T1; (Ferramenta número 1)
M03 SlOOO; (CW rpm 1000)
G90 G43 HOl; (Compensação do comprimento da ferramenta)
GOO X-25 Y-25 Z100 (posicionamento rápido até 100 mm acima do ponto
inicial, conforme indicado na Fig. 6.5)
Zl; (Rápida a 1 mm acima da peça de trabalho)
M98 P50011; (Chamada de subprograma de 00011, cinco vezes, para os cinco
triângulos)
GOO Z100 (Retração rápida até 100 mm acima da peça de trabalho)
MO5; (Parada do fuso)
M30; (Final de execução e reset de controle)

00011; (Programa número 11)

G91 GOO XlOO Y25; (Posicionamento rápido no canto inferior esquerdo da


ranhura triangular que será usinada em seguida)
GOl Z-1 FlO; (A ferramenta toca a peça de trabalho)
M98 P50012; (Chamada de subprograma de 00012, cinco vezes, para os cinco
passos)
G90 G00 Z1; (Retração rápida até 1 mm acima da peça de trabalho)
M99; (Retorne ao bloco GOO Z100 de 00010, após cinco execuções
sucessivas deste subprograma)

00012; (Programa número 12)


G91 G01 Z-2 F10; (Profundidade do furo aumentada em 2 mm)
X50 Y100 F60; (Corte de ranhura ao longo do lado inclinado do triângulo, na
profundidade atual)
Y-100; (Corte de ranhura ao longo do lado do eixo Y do triângulo, na
profundidade atual)
X-50; (Corte de ranhura ao longo do lado do eixo X do triângulo, na
profundidade atual)
M99; (Retorno ao bloco G90 Z00 de 00011, após cinco execuções sucessivas
deste subprograma)
O exemplo dado acima usa o aninhamento de dois níveis. Embora o controle
permita o aninhamento de até quatro níveis, o aninhamento além de dois níveis
é raramente usado, já que esses programas tendem a se tornar complexos
demais para serem entendidos. O objetivo do aninhamento é simplificar a
programação, não complicá-la! Embora o aninhamento e o uso de recursos de
programação macro em subprogramas tornem um programa bastante geral e
compacto, a energia real é fornecida por meio de macros que possuem escopo
virtualmente ilimitado. É claro que uma compreensão completa dos
subprogramas é absolutamente necessária para o desenvolvimento de macros
com qualidade profissional. Portanto, os leitores devem ler e reler cada linha
deste capítulo, até que os conceitos sejam claros.

CAPITULO 7
Chamada Macro

7.1 Introdução

Vários dos recursos de programação macro já foram discutidos. O uso desses


recursos não está restrito apenas a macros. Eles podem ser usados em
qualquer lugar - no programa principal, subprogramas e macros. Um programa
de macro, no entanto, é uma característica única da programação de macros,
que adiciona uma dimensão totalmente nova ao que pode ser feito através da
programação. Desenvolver uma macro requer boas habilidades de
programação, possuídas por poucos indivíduos, mas usar uma macro é bem
simples - é como comandar um ciclo fixo. Este capítulo explica como definir e
usar macros.
7.2 Macro versus Subprograma

Uma macro pode ser amplamente descrita como uma versão sofisticada de
subprogramas (esta é a razão pela qual este capítulo é precedido pelo capítulo
Revisão de Subprogramas). A estrutura geral do programa é a mesma para
ambos. Um subprograma pode ser chamado pelo programa principal, outros
subprogramas ou macros, e também pode chamar qualquer tipo de programa.
Da mesma forma, uma macro pode ser chamada por qualquer programa e
pode chamar qualquer programa. Ambos permitem aninhar até um máximo de
quatro níveis. No caso de um aninhamento misto, um máximo de quatro
subprogramas e quatro macros podem aparecer, em qualquer ordem, além do
programa principal. A principal diferença entre um subprograma e uma macro
reside na flexibilidade dos dados de entrada. Um subprograma não usa
variáveis, ou usa sempre dados iniciais fixos para as variáveis usadas dentro
dele, com valores definidos no programa de chamada no momento de chamar
o subprograma. Uma macro, por outro lado, usa os valores especificados na
instrução de macro-chamada, para suas variáveis locais. (Se a macro chamada
não definir uma variável local, ela permanecerá nula, inicialmente). De fato,
como discutido no Cap. 3, um subprograma não possui seu próprio conjunto de
variáveis locais. Ele usa as variáveis do programa de chamada. Variáveis
comuns, variáveis comuns permanentes e variáveis do sistema, obviamente, se
comportam da mesma maneira em ambos os subprogramas e macros.

7.3 Chamada Macro

Por agora, deve ficar claro que a principal diferença entre uma chamada de
macro e uma chamada de subprograma é que o nível de variáveis locais muda
com uma chamada de macro, mas ela não muda com uma chamada de
subprograma. Além disso, uma chamada de macro pode passar dados para o
programa chamado, enquanto uma chamada de subprograma não tem esse
recurso. Um subprograma é chamado por M98 e M198. Uma macro pode ser
chamada usando qualquer um dos seguintes métodos:

• Chamada simples (G65)


• Chamada modal (G66)
• Chamada com G-eode definido pelo usuário
• Chamada com o código M definido pelo usuário

Aqueles que são novos em programação de macro podem pular os dois últimos
métodos de chamar uma macro, neste estágio. Mesmo a chamada modal
(G66) não é usada com muita frequência. G65 pode ser usado para chamar
qualquer macro, sem qualquer limitação. Outros métodos fornecem alguma
conveniência, mas também é possível gerenciar com o G65. No entanto, é
preciso conhecer todos os métodos por causa das vantagens específicas que
eles oferecem. Além disso, qualquer método pode ter sido usado nos
programas desenvolvidos por outros programadores, que só se pode entender
se se conhece o método utilizado. No entanto, no interesse de uma curva de
aprendizado mais íngreme, pode-se escolher ler apenas sobre o G65. Os
demais métodos podem ser aprendidos em um estágio posterior. Um pode
pular Sec. 7.4 também.

Chamada Modal (G65)

A sintaxe da chamada de macro com G65 é

G65 P <número do programa> L <número de repetições> <argumento 1> ... ...


<argumento n>;

O número do programa é o número de um programa existente que deve ser


chamado. Normalmente, números de série 8000 ou 9000 são usados como
números de macroprograma, uma vez que estes podem ser protegidos contra
edição / exclusão acidental, através dos parâmetros 3202 # 0 e 3202 # 4,
respectivamente. No entanto, qualquer número de programa legal (1 a 9999)
pode ser usado. A contagem de repetições, cujo padrão é um (isto é, L1 pode
ser omitido), é o número de execuções sucessivas da macro chamada. Essa é
a única maneira pela qual uma macro pode ser executada repetidamente. A
contagem de repetição de uma macro não pode ser incluída na palavra P,
diferentemente do que pode ser feito para repetir uma chamada de
subprograma. Conforme explicado no cap. 6, a contagem de repetições de um
subprograma também pode ser incluída na palavra P (à parte do método da
palavra-L). Aqui, a palavra P é usada apenas para especificar o número do
programa. Até 9999 repetições macro são possíveis.

A especificação do argumento é para passar os valores iniciais desejados para


as variáveis locais da macro. Todas as variáveis locais, de 1 a 33, podem ser
inicializadas. As variáveis locais não inicializadas permanecem nulas no início
da execução da macro. O método exato de especificação de argumentos é
discutido na Sec. 7,5.

Como exemplo, G65 P8000 L2 A/O B20 chama o número de programa 8000
duas vezes, em sucessão, com # 1 (por causa do endereço A) e # 2 (por causa
do endereço B) definido como 10 e 20, respectivamente, enquanto as outras
variáveis locais ( # 3 a # 33) permanecem nulos, inicialmente. Observe que, se
a macro chamada modificar as variáveis # 1 e / ou # 2, sua segunda chamada
será iniciada com os novos valores armazenados em # 1 e # 2. Da mesma
forma, se a primeira chamada definir uma nova variável local, por exemplo, # 3,
a segunda chamada será iniciada com o valor armazenado em # 3. (A primeira
chamada começou com um valor nulo para # 3). Nas chamadas repetidas de
uma macro, os valores especificados na lista de argumentos são passados
para as variáveis locais somente na primeira execução da macro. Qualquer
execução subseqüente usa os valores obtidos na execução anterior. Assim,
G65 P8000 L2 AlO B20 não é equivalente a G65 P8000 A10 B20 comandado
duas vezes em dois blocos sucessivos. Se uma macro é chamada em dois (ou
mais) blocos sucessivos, todas as execuções tornam-se independentes das
execuções anteriores, com cada execução usando os valores especificados em
seu bloco de macro-chamada, como os valores iniciais para suas variáveis
locais.
Para uma melhor clareza, considere o programa 00013 que chama
repetidamente o subprograma 00014 e o macro 00015, três vezes cada,
seguidos por três chamadas macro separadas de 00016 em três blocos
sucessivos. Os números de programa 14, 15 e 16 são essencialmente os
mesmos, mas se comportam de maneira diferente dependendo de como são
chamados, o que explica os princípios subjacentes. Lembre-se de que o
mesmo programa se torna um subprograma quando chamado pelo M98 e uma
macro quando chamado pelo G65 ou pelo G66. Alguns desses conceitos já
foram discutidos no cap. 3. (Consulte as figuras 3.1, 3.2 e 3.3).

00013; (Programa número 13)

# 1 = 1;
(O valor atribuído aqui é usado apenas por este programa e pelo subprograma
aninhado
00014, mas não pelas macros aninhadas, porque um subprograma usa as
variáveis locais do programa de chamada, enquanto as macros usam um
conjunto ou nível diferente de variáveis locais)

M98 P30014;
(O mesmo que M98 P0014 L3, para executar 00014 três vezes em sucessão,
como um subprograma)

G65 POO15 L3 Al;


(Chama 00015 como uma macro, três vezes consecutivas. A primeira
execução usa # 1 = 1, inicialmente, mas a segunda e a terceira execuções
começam com os valores atualizados de # 1, obtidos no final das primeira e
segunda execuções, respectivamente)

G65 P0016 A1;


(Chama 00016 como uma macro uma vez, com # 1 definido como 1,
inicialmente)

G65 P0016 A1;


(Essa chamada de macro é independente da chamada no bloco anterior.
Portanto, 00016 é executado uma vez, com # 1 novamente definido
inicialmente como 1, mesmo que # 1 da execução anterior contivesse um valor
diferente. execução anterior não tem significado agora)

G65 P0016 A1;


(O mesmo que acima)

# 503 = # 1;
(Como a chamada de subprograma modificou o valor armazenado em # 1 a 7,
# 503 armazenaria 7. Uma chamada de macro não tem efeito sobre as
variáveis locais do programa de chamada)

M30;
(Final de execução e reset de controle)

00014; (Programa número 14)

# 1 = # 1 + 2;
(Desde que este programa foi chamado como um subprograma, # 1 usados
aqui é o mesmo que # 1 do programa de chamada 00013. Uma vez que cada
execução deste programa adiciona 2 ao valor armazenado em # 1, o valor final
se torna 7, após três execuções)

# 500 = # 1;
(# 500 armazena 3 após a primeira execução, 5 após o segundo e 7 após a
terceira e última execução)

M99;
(Retorne ao programa de chamada, depois que todo o número especificado de
repetições terminar. Após o retorno, o número 1 do programa de chamada
conteria 7, já que é o mesmo que # 1 deste subprograma)

00015; (Programa número 15)

#1=#1+2
(Como este programa foi chamado como uma macro, # 1 usado aqui é
diferente de # 1 do programa de chamada 00013. A chamada de macro atribui
um valor de 1 à variável de macro # 1, em o início da primeira chamada deste
programa. As chamadas repetidas usam os valores atualizados de nº 1. Uma
vez que toda execução deste programa adiciona 2 ao valor armazenado em #
1, o valor final se torna 7, após três execuções)

# 501 # 1;
(# 501 armazena 3 após a primeira execução, 5 após o segundo e 7 após a
terceira e última execução)

M99;
(Retorne ao programa de chamada, depois que todo o número especificado de
repetições tiver terminado. Como o número 1 deste programa e o número 1 do
programa chamador são variáveis diferentes, o número 1 do programa
chamador ainda conteria 7. É apenas uma questão de chance que # 1 deste
programa também contém 7 após três execuções. Na verdade, quando a
execução retorna para o programa de chamada, depois de executar uma
macro, todas as variáveis locais da macro tornam-se inexistentes, portanto,
sem sentido)

00016; (Programa número 16)

# 1 = # 1 + 2;
(Como este programa foi chamado como uma macro, sem repetição, sua
execução sempre começa com # 1 = 1, independentemente do número de
execuções deste programa)

# 502 = # 1;
(# 502 armazena 3, independentemente de quantas vezes essa macro é
chamada)

M99;
(Retornar ao programa de chamada)

Para resumir, a primeira execução do subprograma começa com # 1 = 1 e


define # 1 = 3 e # 500 = 3 quando a execução termina. Cada execução
subsequente do subprograma adiciona 2 a esses valores. Portanto, no final de
três execuções do subprograma, # 1 e # 500 armazenamento 7. Em seguida,
vem a chamada de macro de 00015, com a variável de macro nº 1 inicialmente
definida como 1 (por causa da palavra A1 na chamada de macro). No final da
execução da macro, as lojas nº 1 e nº 501 3. Agora, a macro deve ser
executada mais duas vezes. Como as execuções subsequentes começam com
o valor atualizado armazenado em # 1, # 501 armazena 7 no final de três
chamadas da macro. Finalmente, as três chamadas do macro 00016 são
independentes umas das outras. Portanto, # 1 e, portanto, # 502 também,
armazene 3 no final de cada execução. No final, # 503 armazena o valor
armazenado em # 1 do programa principal. Assim, o resultado (valores
armazenados nas variáveis comuns permanentes) após a execução completa
de 00013 é

# 500 lojas 7.
# 501 lojas 7.
# 502 lojas 3.
# 503 lojas 7.

Este exemplo explica claramente que as variáveis locais do programa principal


e do subprograma são as mesmas (pertencentes ao nível 0), mas a macro usa
um conjunto diferente de variáveis locais (pertencentes ao nível 1). As variáveis
comuns permanentes (# 500 e # 501) foram usadas aqui, para que os valores
armazenados nelas possam ser inspecionados no final da execução do
programa. Lembre-se de que o conteúdo de uma variável comum permanente
não é eliminado pela reinicialização do sistema ou pela desativação. No
entanto, isso também significa que, se um programa não modificar o conteúdo
de uma variável comum permanente, a variável exibirá o valor antigo
armazenado nela! Portanto, execute o programa número 8001 ou 8005, dado
no Cap. 5, para limpar todas as variáveis comuns permanentes, se os seus
valores antigos forem susceptíveis de causar confusão.

Chamada Modal (G66)

Às vezes, uma macro deve ser chamada várias vezes, mas não na mesma
posição da ferramenta. Por exemplo, suponha que uma macro tenha sido
escrita para fazer um furo de alguma maneira especial (por exemplo, com a
redução progressiva do comprimento do pica-pau). Agora, se vários furos
devem ser perfurados, a macro precisaria ser chamada, usando G65, várias
vezes, depois de trazer a ferramenta para os locais desejados:

...
...
<Move the tool to locat ion 1>
G65 P L_ <argument specification>;
<Move the tool to location 2>
G65 P_ L_ <argumen t speci f ication>;
<Move t h e tool to location 3>
G65 P_ L <ar gument specification>;
...
...
<Move the tool to l ocation n>
G65 P L_ <argument specification>;
...
...

Embora não haja nada de errado com este método, o bloco G65 precisa ser
inserido repetidamente. No caso de qualquer mudança no bloco G65 ser
desejada, a mudança teria que ser incorporada em todos os blocos G65. Isso
não envolve apenas esforço extra de digitação, o tamanho do programa
também aumenta. A chamada modal, G66, remove essa dificuldade. Uma
chamada de macro G66 permanece em vigor até ser cancelada por G67. Após
um bloco G66, sempre que a ferramenta é movida em um bloco subsequente,
a macro é automaticamente chamada, depois de completar o movimento, até
que G67 seja programado, o que cancela o modo G66. A estrutura do
programa com o G66 tomaria a seguinte forma (isto é similar, mas não
exatamente equivalente ao formulário G65 dado acima, devido a razões
explicadas abaixo)

...
...
G66 P_ L_ <argument specification>;
<Move the tool to locat i on 1>
<Move the tool to location 2>
<Move the tool to location 3>
...
...
<Move the tool to location n>
G67;
...
...

A sintaxe do G66 é exatamente igual à do G65. Todas as regras aplicáveis ao


G65 também se aplicam ao G66. A principal diferença é que o G66 armazena
apenas as informações fornecidas em seu bloco como dados modais (ou seja,
dados para uso futuro, até serem alterados), sem chamar a macro. A macro é
chamada somente quando a ferramenta é movida em um bloco subsequente,
após a conclusão do movimento especificado. Além disso, os valores
especificados no bloco G66 são passados para a macro somente em sua
primeira chamada. Todas as outras chamadas, até que G67 seja encontrado
ou outro G66 seja comandado, use os valores atualizados para as variáveis
locais, obtidos da execução anterior. Os números de programa 17, 18 e 19
ilustram essas regras.

Chamada única de uma macro com G66:

00017; (Programa número 17)


G66 POO15 A1; (Armazena informações modais, sem chamar a macro.
Embora o programa número 15 seja o mesmo programa fornecido
anteriormente, as explicações dadas no lado direito não se aplicam aqui)
G91 GOO X100; (A ferramenta se move 100 mm ao longo do eixo X.
Posteriormente, 00015 é chamada como uma macro, com # 1 inicialmente
definido como 1. A execução da macro atribui um valor de 3 a ambos # 1 e #
501)
X100; (A ferramenta ainda se move 100 mm ao longo do eixo X.
Posteriormente, 00015 é novamente chamado como uma macro, com # 1
inicialmente definido como 3, seu valor atualizado na execução anterior.
Portanto, a execução atual da macro atribui um valor de 5 para ambos # 1 e #
501)
G67; (Modo G66 cancelado)
X1OO; (Como o G66 não está mais ativo, somente a ferramenta
mover por 100 mm, sem chamar qualquer macro)
M30; (Final de execução e reset de controle)

Chamada repetida de uma macro com G66:

00018; (Programa número 18)


G66 POO15 L3 A1; (Armazena informações modais, sem chamar a macro)
G91 GO 0 X100; (A ferramenta se move 100 mm ao longo do eixo X.
Posteriormente, 00015 é chamado como uma macro três vezes, com # 1
inicialmente definido como 1. As três execuções da macro atribuem um valor
de 7 a # 1 e # 501)
X1OO; (A ferramenta ainda se move 100 mm ao longo do eixo X.
Posteriormente, 00015 é novamente chamado três vezes como uma macro,
com # 1 inicialmente definido como 7, seu valor atualizado na execução
anterior. Portanto, as três execuções atuais da macro atribuem um valor de 3
para ambos # 1 e # 501)
G67; (Modo G66 cancelado. G67 pode ser omitido aqui porque o próximo
comando é M30, causando reset de controle, que muda automaticamente o
status de controle para G67)
M30; (Final de execução e reset de controle)

Chamada macro com vários blocos G66:

00019; (Programa número 19)


G66 POO15 A1; (Armazena informações modais, sem chamar a macro)
G91 GOO X100; (A ferramenta se move 100 mm ao longo do eixo X.
Posteriormente, 00015 é chamada como uma macro, com # 1 inicialmente
definido como 1. A execução da macro atribui um valor de 3 a ambos # 1 e #
501)
G66 POO15 A1; (Armazena informações modais, sem chamar a macro. Um
segundo ou qualquer bloco G66 subsequente permanece independente de
blocos G66 anteriores. Na verdade, o G66 anterior é automaticamente
cancelado e o novo G66 entra em vigor. Assim, os valores atualizados para as
variáveis locais da execução anterior não são usados. A próxima execução de
00015 começaria novamente com os dados especificados no bloco G66 atual)
X1OO; (A ferramenta ainda se move 100 mm ao longo do eixo X.
Posteriormente, 00015 é novamente chamado como uma macro, com # 1
inicialmente definido como 1, seu valor especificado no bloco G66 ativo no
momento. Portanto, a execução atual da macro atribui um valor de 3 para
ambos # 1 e # 501, que é o mesmo que o obtido na execução anterior da
macro, porque todos os parâmetros modais são os mesmos em ambos os
blocos G66)
G67; (O modo G66 atual foi cancelado. O modo G66 anterior foi cancelado
automaticamente quando um novo G66 foi comandado)
M30; (Final de execução e reset de controle)

Comentários adicionais:

• Aninhamento com G66 é permitido. Uma profundidade máxima de


aninhamento de quatro níveis é permitida, incluindo G65 e G66. Subprogramas
também podem ser aninhados em G66. Acima de tudo, um máximo de quatro
macros (chamadas por G65 e / ou G66) e quatro subprogramas podem ser
aninhados.
• O bloco G66 armazena apenas dados modais. Não chama uma macro.
Portanto, nenhum comando de movimento deve ser incluído no bloco G66. Se
o comando de movimento (como XlOO) aparecer antes da palavra G66, a
ferramenta se move sem chamar a macro (embora os dados modais sejam
armazenados para uso futuro). Se aparecer depois da palavra G66, ela será
usada como dados para uma variável local (XlOO atribuirá um valor de 100 à
variável # 24)! Além disso, um endereço como o GOl à direita do G66 é ilegal,
uma vez que as letras L, 0, N, G e Pare não podem ser usadas para
especificação de argumentos.
• Enquanto o G66 está ativo, os códigos M ou qualquer outro código que não
cause movimento da ferramenta são executados sem chamar a macro.
• Assim como no G65, são permitidas até 9999 repetições (especificadas com o
endereço L) em uma macro chamada G66.
• Os dados modais são definidos apenas no bloco G66. Por exemplo, em um
bloco subseqüente em que o G66 está ativo, o XlOO l3 não alteraria a
contagem de repetições para 3.
• Se uma chamada de macro for necessária sem o movimento da ferramenta,
especifique a distância zero para alguns eixos no modo incremental. Por
exemplo, G91 GOO XO (GOO UO em um torno mecânico) chamaria a macro
sem nenhum movimento da ferramenta. Na verdade, um bloco de movimento
de eixo é necessário; o deslocamento especificado pode ser zero também!
• No formato de endereço de palavras, que as máquinas CNC atuais usam, a
ordem das diferentes palavras associadas a um comando não é importante.
Por exemplo, G66 Pl5 Al e G66 Al Pl5 são ambos equivalentes (embora Pl5
G66 Al seja ilegal, já que todos os argumentos de um G-eode devem vir depois
do código). No entanto, apenas a ordem recomendada deve ser usada, de
modo a eliminar qualquer possibilidade de confusão para outros usuários.

Chamada com o código G definido pelo usuário

É possível definir até 10 novos G-eodes que podem ser usados para chamar
uma macro na forma como G65 a chama, com a diferença de que o número do
programa não precisa ser mencionado com o G-eode definido. Esses G-eodes
se tornam similares aos Geodes padrão internos, especialmente como os
códigos para ciclos fixos (aqueles ciclos fixos que são definidos em um bloco).
Para usar esses códigos, basta saber os significados dos endereços de letras
usados. Por exemplo, o G100 D80 QS R90 F10 S1000 pode ser projetado para
chamar uma macro para perfurar um furo com redução progressiva do
comprimento do beck, com os seguintes significados para seus endereços de
letras. (Ainda não discutimos a correspondência entre vários endereços de
letras e as variáveis locais da macro chamada. A única coisa que usamos até
agora é a letra A define a variável # 1 e a letra B define a variável # 2. Portanto,
não se preocupe como a macro chamada neste exemplo usa os dados
fornecidos. Ela é discutida mais adiante.)

G100 : New G-eode


D80: Depth of hole (80 mm)
Q5 : First peck length (5 mm)
R90: Reduction percentage for the next peck length (90%)
F10 : Feedrate (10 mm/ min)
S1000: Spindle speed (1000 rpm)

Se o G100 for projetado para chamar a macro 09010, o comando especificado


será equivalente a G65 P9010 D80 Q5 R90 F10 S1000. A vantagem de chamar
uma macro dessa maneira é que mesmo um programador com menos
habilidades de programação pode fazer uso de algumas (não todas) macros
predefinidas, sem precisar saber nada sobre programação de macro! Um novo
G-eode pode ser usado como um G-eode padrão. Não é preciso nem saber o
número do programa macro que ele chama. Em outras palavras, alguns G-
eodes extras ficam disponíveis na máquina. Naturalmente, apenas um
programador experiente pode definir esses códigos. O procedimento exato é
descrito abaixo.

Somente as macros que carregam os números de programa 9010 a 9019


podem ser chamadas por esse método. Os G-eodes para chamar essas
macros podem ter qualquer número entre 1 e 9999. No entanto, somente os G-
eodes não utilizados devem ser selecionados, caso contrário, o G-eode
existente seria redefinido!
Os números do G-eode, que são selecionados para chamar macros (no
intervalo 9010 a 9019), são especificados em determinados parâmetros (6050
a 6059). A correspondência entre os dois é dada na Tabela 7.1. Por exemplo,
se 100 for armazenado no parâmetro 6050, o G100 chamaria a macro 09010.
Da mesma forma, se 1000 for armazenado no parâmetro 6059, o G1000
chamaria a macro 09019. E, se o número do programa correspondente a um
G-eode definido não existir, o controle entraria no estado de alarme, exibindo a
mensagem de alarme "NUMBER NOT FOUND". Por exemplo, armazenar 100
no parâmetro 6050, sem definir o programa 09010, causaria um estado de
alarme se G100 for comandado. Todas as regras e restrições que se aplicam
ao G65 também se aplicam à chamada de macro com G-eodes. Por exemplo,
1 a 9999 repetições podem ser especificadas com o endereço L. Os
argumentos também são especificados da mesma maneira.
Para fins de ilustração, considere um exemplo muito simples de definir um
código G500 (sem argumentos) para causar incondicionalmente uma pausa de
10 segundos. Para isso, armazene 500 no parâmetro 6050 (supondo que o
parâmetro 6050 não tenha sido usado para definir algum outro G-eode). Em
seguida, o G500 chamaria a macro 09010 que deveria ser definida da seguinte
maneira: 09010; (O número do programa correspondente ao parâmetro número
6050, conforme Tabela 7.1) G04 X10; (Causa uma permanência de 10
segundos) M99; (Retorne ao programa de chamada).
Agora, em qualquer programa, onde quer que o G100 seja comandado, isso
resultaria em uma pausa de 10 segundos. E, para uma duração de, digamos,
50 segundos, o G500 L5 precisaria ser programado. G65 P9010 e G65 P9010
L5 também fariam o mesmo, causando atrasos de 10 e 50 segundos,
respectivamente. Basicamente, G65 P está sendo substituído por um G-eode,
por conveniência. Macros extremamente complexas também podem ser
usadas para definir novos G-eodes. Tal exemplo não é dado aqui, pois a ideia
era explicar apenas a metodologia.
Além desse método de chamar um programa, um programa também pode ser
chamado com códigos M e códigos T, como discutido na próxima seção. Em
um programa, que é chamado por qualquer um desses métodos, todos os G-
eodes são tratados como G-eodes comuns, com seus significados originais.
Em outras palavras, um G-eode em tais programas não chamaria um
programa, mesmo que ele seja projetado para chamar um programa. Seria
executado da maneira usual. Esse problema é discutido em mais detalhes
posteriormente.
Chame com o código M definido pelo usuário.
A maneira como uma macro pode ser chamada por um G-eode, também pode
ser chamada por um código M, exatamente da mesma maneira. Esse método
de chamada de macro define um novo código M ou redefine um código M
existente, se o número de um código M predefinido for escolhido. Portanto,
apenas um número não utilizado deve ser selecionado.

Chamada com o código M definido pelo usuário


7.4 Chamada do Subprograma sem usar o M98 / M198

M98 é o método usual de chamar um subprograma. (M198 chama um


subprograma armazenado em um dispositivo externo de entrada / saída, como
arquivo prático da Fanuc, conectado via porta RS-232C da máquina. Defina o
parâmetro 0020 como 0, e 0102 como 3, para habilitar tal chamada de
subprograma. Se o parâmetro 0020 estiver definido como 4, M198 chama um
subprograma armazenado na placa de memória flash PCMCIA, que é o método
mais simples nas versões de controle mais recentes, já que um slot PCMCIA
agora se tornou um recurso padrão do controle. além de M198, também pode
ser usado para chamada de subprograma, armazenando o número desejado,
escolhido entre 1 e 255, no parâmetro 6030. Se o valor armazenado for 0,
M198 será usado.) No entanto, se o recurso de programação de macro estiver
ativado Na máquina, é possível chamar até nove subprogramas usando
determinados códigos M definidos pelo usuário. Também é possível chamar
um subprograma usando um código-T. Observe que, como os subprogramas
estão sendo chamados, nenhum argumento pode ser especificado para passar
os dados iniciais para as variáveis locais do programa chamado, como no caso
da chamada M98. Todas as regras, que se aplicam à chamada M98, também
se aplicam a esses métodos de chamada.

Chamada do Subprograma Usando um Código M


Qualquer número entre 1 e 99.999.999 pode ser selecionado como um número
de código M para chamar um subprograma. Os nove números máximos
permitidos são armazenados nos parâmetros 6071 a 6079. Os códigos M
definidos por esses parâmetros chamam os subprogramas de 09001 a 09009.
A correspondência entre os números do programa e os números dos
parâmetros

é dado na Tabela 7.3. Por exemplo, se o subprograma 09001 tiver que ser
chamado por M100, o parâmetro 6071 precisaria armazenar 100. Em seguida,
MlOO se tornaria equivalente a M98 P9001. Embora nenhum argumento seja
permitido, o subprograma chamado pode ser executado repetidamente até
9999 vezes, usando uma palavra L. Por exemplo, M100 L5, que é equivalente
a M98 P9001 L5, chama o subprograma 09001 cinco vezes seguidas. Existe
uma restrição que este método de chamada de subprograma não pode ser
usado em programas chamados por G-eodes (exceto G65 I G66), códigos M

(diferente de M98 / M198) ou códigos-T. De fato, em geral, os métodos de


chamar uma macro / subprograma, usando código G / código M / código T, não
podem ser usados em programas chamados por qualquer um desses métodos.
O código G-eode / M-code / T usado nesses programas são tratados como
códigos comuns com a função original. Por exemplo, se o parâmetro 6071
contiver 3, M03 chamará o subprograma 09001. Mas, se M03 for novamente
usado em 09001, ele será tratado como comando de partida do fuso. Essa
"restrição" pode ser usada com muita vantagem, conforme explicado no
exemplo a seguir. Se o fuso estiver girando, o comando para alterar a direção
de rotação abruptamente (sentido anti-horário para sentido horário ou vice-
versa) pode causar carga excessiva no motor do fuso, devido à inércia.
Portanto, pode ser desejável inserir M05, com uma espera de 5 segundos,
enquanto alterna entre M03 / M04. Armazenando 3 no parâmetro 6071 e
definindo 09001 da maneira indicada, M03 usado em qualquer programa (o
programa principal, um subprograma chamado por M98 / M198, ou uma macro
chamada por G65 / G66, ou seja, um programa não chamado por Código G /
código M / código T) primeiro parará o fuso e permanecerá por 5 segundos
antes de iniciar a rotação no sentido horário. Assim, o M03 é modificado para
ter uma função semelhante, porém estendida.

09001; (O número do programa correspondente ao parâmetro número


6071, conforme Tabela 7.3)

M05; (Parada do fuso)


G04 X5; (Permaneça por 5 segundos, para permitir que o fuso pare
completamente)
M03; (Este código M é um código M comum, com seu significado predefinido.
Assim, a rotação no sentido horário seria iniciada)
M99; (Retornar ao programa de chamada)

O M04 também pode ser modificado de maneira semelhante, armazenando 4


no parâmetro 6072 e definindo 09002 da maneira indicada.

09002; (O número do programa correspondente ao parâmetro número 6072,


conforme Tabela 7.3)
M05; (Parada do fuso)
G04 X5; (Permaneça por 5 segundos, para permitir que o fuso pare
completamente)
M04; (Este código M é um código M comum, com seu significado predefinido.
Assim, a rotação no sentido anti-horário seria iniciada)
M99; (Retornar ao programa de chamada)

A única desvantagem do código M03 / M04 modificado é que, mesmo quando o


fuso está parado, isso causa um tempo de espera de 5 segundos. No entanto,
em comparação com o tempo total de usinagem de um trabalho, esse atraso
pode ser ignorado.

Chamada do Subprograma Usando um Código T

Este método não é permitido, a menos que o parâmetro 6001 # 5 esteja


definido como 1. Usando este método, somente um subprograma 09000 pode
ser chamado. Qualquer número entre 1 e 99.999.999 pode ser selecionado
para o código T (isto é, T1 a T99999999 são permitidos). Após a execução do
Tcode, o número do código T especificado é automaticamente armazenado na
variável comum # 149 (que pode ou não ser usada). Por exemplo, se T20 é
usado para chamar o subprograma, # 149 armazenaria 20. Há várias limitações
desse método. Primeiro, apenas um subprograma (09000) pode ser chamado.
Em segundo lugar, nenhum parâmetro pode ser especificado no bloco de
código T (já que é uma chamada de subprograma). No entanto, até 9999
repetições são possíveis através de uma palavra L. Note que este método
desabilita a função de troca de ferramenta do código T no programa principal,
em um subprograma chamado por M98 / M198, e em uma macro chamada por
G65 / G66. Por exemplo, T0101 (que é o mesmo que T101) não mudará a
ferramenta (com ou sem M06); ele simplesmente chamará 09000, como um
subprograma. (Independentemente do número usado no código T, apenas
09000 é chamado. Se 09000 não for definido, o alarme "NUMBER NOT
FOUND" ("NÚMERO NÃO ENCONTRADO") ocorrerá.) No entanto, como já foi
dito, em um programa chamado G-eode (outro que G65 / G66), código M
(diferente de M98 / M198), ou código T, o código T é tratado como um código
comum com a função usual de troca de ferramenta. Esse recurso pode ser
usado para modificar a função de troca de ferramenta de um código T,
conforme explicado no texto a seguir.

É perigoso trocar a ferramenta a menos que a torre esteja na posição inicial,


devido a uma possível interferência entre as ferramentas rotativas e o
contraponto da bucha / peça de trabalho. Portanto, o comando G28 UO WO
deve ser dado antes de emitir um comando de troca de ferramenta. Se um
programador esquece de fazer isso, isso pode causar um acidente na máquina.
No entanto, é possível redefinir o comando de troca de ferramenta, para enviar
a torre para a posição inicial automaticamente, antes de alterar a ferramenta.
Primeiro, defina o parâmetro 6001 # 5 para 1 e, em seguida, defina 09000 da
maneira especificada. Então, T0707 (digamos) no programa chamador trará a
ferramenta número 7 para a posição de corte, escolhendo o número de
correção 7, depois de enviar a torre para a posição inicial.

09000;(O número do programa permitido para chamar um subprograma,


usando um código-T)

G28 UO WO; (Retorno da posição inicial)

T # l49; (Este é o comando usual de troca de ferramenta, com o número de


correção. O número 149 armazena o número usado com o código T no
programa de chamada. Assim, o código T especificado é executado aqui com a
função usual de troca de ferramenta).

M99; (Retornar ao programa de chamada)

Agora, deve estar claro que o propósito de redefinir os G-eodes, M-códigos e


T-códigos existentes é incorporar funções estendidas neles. Esse recurso
nunca deve ser usado para alterar o significado básico de qualquer código.
Sempre use um número não utilizado para definir códigos com novas funções.
Como outro exemplo, pode-se tentar redefinir G01, tal que se a velocidade de
avanço especificada for maior que 100 mm / min para a ferramenta número 7, a
velocidade de avanço usada na interpolação linear seria de apenas 100 mm /
min. (Esse é um requisito arbitrário, apenas para fins de ilustração.) Essa
macro, no entanto, não pode ser escrita a menos que se conheça inteiramente
os métodos de especificação de argumentos. Portanto, este exemplo será
retomado na próxima seção, com o propósito adicional de explicar o uso da
especificação de argumentos.

7.5 Especificação de Argumento

Em uma chamada de macro, determinados endereços de letras podem ser


usados para passar os valores iniciais desejados para as variáveis locais da
macro chamada. Isso é chamado de especificação de argumento. Dois
métodos de especificação de argumento estão disponíveis:
• Especificação do argumento I, que usa todas as letras do alfabeto, exceto L,
0, N, G e P, uma vez em cada.
• Especificação de argumento II, que usa A, B e C uma vez cada, e também
usa I, J e K até 10 vezes cada. O tipo de especificação do argumento é
determinado automaticamente de acordo com as letras usadas.

Especificação de Argumento I

Este tipo de especificação de argumento pode definir as variáveis de # 1 a #


26, exceto # 10, # 12, # 14, # 15 e # 16. As variáveis de 27 a 33 não podem ser
definidas. A correspondência entre os endereços das letras e os números das
variáveis é dada na Tabela 7.4. Os endereços de carta proibidos podem ser
facilmente lembrados pela frase "LONG Program". Como exemplo de
especificação de argumento I, G65 P8000 L2 A/O D20 H30 140 MSO Q60 Z70
chamaria o número de programa 08000, como uma macro, com suas variáveis
locais inicialmente definidas como # 1 = 10, # 7 = 20, # 11 = 30, # 4 = 40, # 13
= 50, # 17 = 60, # 26 = 70 e as demais variáveis locais definidas como nulas. A
palavra L2 causaria duas execuções sucessivas da macro, antes de retornar ao
programa de chamada. No entanto, como já discutido na Sec. 7.3, na segunda
execução (bem como em todas as execuções subsequentes, se a palavra L
tiver um valor maior que 2), as variáveis locais não usam os valores
especificados no bloco G65 como seus valores iniciais. Em vez disso, os
valores atualizados na primeira execução (anterior) são usados como valores
iniciais na segunda execução (subsequente). Como o CNC usa o formato de
endereço da palavra, os argumentos do G65 / G66, incluindo a palavra P e a
palavra L, podem ser especificados em qualquer ordem (mas nenhum
argumento deve aparecer à esquerda de G65 / G66). No entanto, I, J e K, se
usados, devem ser especificados alfabeticamente. Assim, por exemplo, ... K_
I_ ... deve ser substituído por ... I_ K_ ..., caso contrário,

seria interpretado na especificação de argumento II, alterando a


significando completamente.

Especificação de Argumento II

A especificação do argumento II usa A, B e C uma vez em cada. Além dessas


três letras, ele usa, J e K até 10 vezes cada (isto é, 10 conjuntos
independentes de I, J e K são usados). Assim, pode passar valores iniciais
para todas as 33 variáveis locais. A correspondência entre os endereços das
letras e as variáveis locais é dada na Tabela 7.5. Note que I1 a I10, J1 a Iw e K1
a K10 são escritos, respectivamente, como I, J e K apenas no bloco de macro-
chamada. Usamos os subscritos (que indicam o número de set: set 1 a set 10)
apenas para nossa referência. O controle identifica o subscrito (número do
conjunto) de acordo com a sequência em que os endereços das letras
aparecem. Por exemplo, se eu aparecer 4 vezes na lista de argumentos, a
primeira ocorrência significa I1, a segunda ocorrência significa I2, a terceira
ocorrência significa I3 'e a ocorrência de
quarta significa I4, referindo-se às variáveis # 4, # 7, # 10 e # 13,
respectivamente. I, J e K, correspondendo a um subscrito particular, aparecem
sempre na mesma sequência. Em outras palavras, esses três sempre
aparecem como um conjunto ordenado. Todas as três entradas de um conjunto
não precisam ser definidas. Por exemplo, I_J_I_K_K_L significa I 1 _J1 _ I2 _K2
_K3 _J4 _ onde K1, J2, I3, J3, I4 e K4 não estão definidos. Se usarmos colchetes
para separar os conjuntos, ele apareceria como (I_L) (I_K_) (K_) G_), onde os
colchetes indicam conjuntos diferentes, o número definido aumenta da
esquerda para a direita, começando em 1. Observe que o conjunto J ao lado de
K3 tem que ser J4 porque K3 marca o fim do terceiro set, após o qual o quarto
set começa.
A vantagem da especificação do argumento II é que todas as 33 variáveis
locais podem receber valores iniciais. Além disso, como I, J e K aparecem em
um grupo, esse método de especificação de argumentos é muito conveniente
para passar dados como coordenadas tridimensionais. No entanto, a
especificação de argumentos I é mais comumente usada por causa de sua
simplicidade e fácil interpretação de endereços de letras. Por exemplo, se os
dados para profundidade de um furo, velocidade do fuso e velocidade de
avanço tiverem que ser passados, as letras D, S e F podem ser usadas na
especificação do argumento I, ao passo que quaisquer três entre A, B, C, I, J e
K teria que ser usados na especificação de argumento II. Obviamente, o
primeiro tipo é preferível porque é fácil lembrar qual endereço de carta se
refere a quê.

Especificação de Argumento Misto

A mistura de especificação de argumentos I e especificação de argumentos II é


permitida, embora não seja aconselhável, pois pode causar confusão. Observe
que, se apenas A, B, C, I, J e K forem usados, eles se referem às variáveis de
# 1 a # 6 em ambos os métodos de especificação de argumento. Quando uma
letra diferente dessas seis aparece, ela é interpretada na especificação do
argumento I. Por outro lado, se qualquer letra entre I, J e K for repetida (ou uma
ordem diferente for usada, como I, K e J ), é interpretado na especificação do
argumento II. Se, por acaso, a mesma variável é referida por duas letras
(usando os dois métodos), a especificada posteriormente na lista de
argumentos é usada para passar o valor. Como exemplo, G65 P8000 L2 E10
J20 J30] 40 HSO K60 K70 F80, que chama o programa número 08000 duas
vezes, usa especificação de argumento misto. Portanto, os argumentos são
interpretados da esquerda para a direita, conforme indicado na Tabela 7.6.
Como resultado, as variáveis 8, 5, 11, 12, 15 e 9 recebem 30, 20, 50, 60, 70 e
80, respectivamente. Deve-se sempre ter em mente que eu, J e K aparecem
como um conjunto, na mesma sequência. Se algum desses itens for repetido
ou aparecer em uma sequência diferente, ele pertence a um conjunto diferente.
Portanto, no exemplo dado, os três Js referem-se a J1, J2 e J3,
respectivamente (da esquerda para a direita), e o K após J3 seria ~ 'porque
apenas K3, I4 eJ4 podem aparecer ao lado de J3 (na especificação de
argumento II). Seguindo lógica semelhante, verifique o seguinte:
1. Especificação do argumento: Elo K60 J20 J30 J40 H50 K60 K70 F80
Atribuição variável: # 6 = 60, # 8 = 20, # 9 = 80, # 11 = 50, # 14 = 40, # 15 = 60,
# 18 = 70

2. Especificação do argumento: B20 A10 D40 J50 K60


Atribuição variável: # 1 = 10, # 2 = 20, # 5 = 50, # 6 = 60, # 7 = 40

3. Especificação do argumento: B20 A10 D40 K60] 50


Atribuição variável: # 1 = 10, # 2 = 20, # 6 = 60, # 7 = 40, # 8 = 50

4. Especificação do argumento: 110 110 110 110 D40 K60] 50


Atribuição variável: # 4 = 10, # 7 = 40, # 10 = 10, # 13 = 10, # 15 = 60, # 17 =50
Um exemplo de uma chamada de macro G-Code com argumentos.
Tendo discutido os métodos de especificação de argumentos, estamos agora
em posição de escrever uma macro para redefinir o G01, um problema que foi
introduzido no final da Sec. 7.4. Para redefinir o G01, seria necessário

armazenar 1 no número do parâmetro 6051 (ou em algum outro parâmetro no


intervalo de 6050 a 6059). A macro correspondente ao parâmetro 6051 é
09011 (consulte a Tabela 7.1). Portanto, sempre que G01 (ou G1) é
comandado em um programa (programa principal, uma macro chamada por
G65 / G66, ou um subprograma chamado por M98 / M198), 09011 seria
chamado como uma macro. Agora, a próxima tarefa é escrever a macro 09011.
Um formato geral para G01, para chamar a macro, seria usado: G01 X_ Y _ Z_
F _ S_, onde os endereços das letras teriam seus significados usuais. Como a
especificação de argumento I foi usada, a chamada de macro inicializaria as
variáveis locais # 24, # 25, # 26, # 9 e # 19, correspondentes aos endereços de
letras usados (X, Y, Z, F e S, respectivamente ). Consulte a Tabela 3.10 (b)
para os significados das variáveis do sistema usadas no programa 09011. Para
manter as coisas simples, seria assumido que a macro está sendo chamada no
modo de rpm constante (G97). O modo de velocidade constante da superfície
(G96) é raramente usados em uma fresadora, embora seja muito útil e
frequentemente usado em um torno mecânico. Embora qualquer variável local
e / ou comum possa ser usada para armazenar os resultados de cálculos
intermediários, é melhor usar somente variáveis comuns, porque variáveis
locais são usadas para passar dados para a macro. Isso reduzirá a
possibilidade de erros de programação. Além disso, uma modificação
subsequente na macro, para incluir dados adicionais a serem passados para a
macro, seria fácil, já que qualquer variável local (que não tenha sido usada
anteriormente para passar dados) pode ser usada para armazenar os dados
adicionais. Caso contrário, o número total de variáveis comuns disponíveis
também é muito maior que o número de variáveis locais. Finalmente, se o
resultado de um cálculo precisar ser armazenado permanentemente (ou seja,
para ser retido mesmo após a reinicialização do sistema ou um ciclo de
energia), ele precisaria ser armazenado em uma variável comum permanente.
Esta metodologia será usada em todos os programas que se seguem a partir
de agora. Antes de tentar escrever a macro, recomenda-se primeiro anotar o
procedimento passo-a-passo em inglês simples. Isso simplificaria a codificação
do programa em grande medida. Ignorar essa etapa é como escrever
equações de equilíbrio sem criar diagramas de corpo livre em um problema de
mecânica de engenharia! De fato, se a macro envolve uma lógica complexa,
um fluxograma apropriado do algoritmo deve ser feito, e seu traço de execução
deve ser analisado. A menos que se separe a lógica da linguagem, a
programação macro parecerá muito difícil, o que não é. Essa abordagem foi
recomendada no cap. 5 também. Está sendo reavaliado aqui porque é muito
importante. O algoritmo, que foi usado na macro 09011, é dado abaixo:

1. Descubra se o G94 ou o G95 está ativo no momento de chamar a macro.


2. Descubra se o G20 ou G21 está ativo no momento de chamar a macro.
3. Descubra a taxa de avanço ativa no bloco, imediatamente antes do bloco de
chamada de macro.
4. Se o bloco G01 não contiver uma palavra F, use o avanço obtido na etapa
anterior. 5. Descobrir o rpm no momento de chamar a macro (ou seja, no bloco
imediatamente anterior). 6. Se o bloco G01 não contiver uma palavra S, use a
rpm obtida na etapa anterior.
7. Descubra o número da ferramenta.
8. Se o número da ferramenta não for 7, vá para a etapa 13.
9. Especifique o avanço máximo admissível (F maJ em milímetros por minuto.
10. Converta F max em milimetros por revolução, se G95 estiver ativo, usando
a fórmula de avanço por minuto = avanço por rotação x rpm
11. Converta F max em polegadas por minuto ou polegadas por revolução, se
G20 estiver ativo, dividindo-o por 25,4.
12. Se o avanço especificado / anterior for maior que F max, use F max como o
avanço.
13. Execute a interpolação linear com valores especificados / anteriores de X,
Y, Z e S e o valor apropriado de F.
14. Retorne ao programa de chamada.

Observe a macro 09011 somente depois de entender claramente a lógica


usada no algoritmo fornecido. Depois disso, é apenas uma questão de
converter o algoritmo em códigos. Lembre-se de que um G-eode dentro de
uma macro, que é chamado por um G-eode (seja igual ou diferente), é tratado
como um G-eode padrão, com seu significado predefinido. Portanto, na etapa
13 da macro chamada por G01, o GOl é interpretado como interpolação linear.
Além disso, se um endereço de letra específico tiver um valor nulo, essa
palavra será ignorada na execução. Por exemplo, GOO X10 Y # 1 é
equivalente a GOO X10, se # 1 é nulo. Portanto, na etapa 13, o uso de G01
com endereços X, Y e Z não causará nenhum problema, mesmo se um valor
não for atribuído a algum eixo. O formato geral para chamar essa macro é G01
X_ Y _ Z_ F S 'onde nem todos os endereços de letras precisam ser usados.

09011 (REDEFINAS G01 NA MÁQUINA DE FRESAMENTO);

# 100 = # 4005;
(Armazena 94 ou 95, correspondendo a G94 e G95, respectivamente, o que
estava ativo no momento de chamar a macro. Essa informação é necessária
porque é necessário saber se o avanço especificado no bloco de
macroconferência está em feed por minuto ou feed por revolução. Etapa 1
completa)

# 101 = # 4006;
(Armazena 20 ou 21, correspondendo a C20 e C21, respectivamente, o que
estava ativo no momento de chamar a macro. Essa informação é necessária
porque é necessário saber se as distâncias especificadas estão em polegadas
ou milímetros. Etapa 2 completa)

# 102 = # 4109;
(Armazena o avanço ativo até o bloco anterior. Esta informação seria
necessária se o COl fosse comandado sem uma palavra F. Nesse caso, o
último avanço especificado seria usado. Etapa 3 completa)
SE [# 9 EQ # 0] ENTÃO # 9 = # 102;
(O último avanço especificado sendo usado, na ausência de uma palavra F no
bloco COl. Etapa 4 completa)

# 103 # 4119;
(Armazena o fuso rpm no momento de chamar a macro. Esta informação seria
necessária se o COl fosse comandado sem uma palavra S. Nesse caso, o rpm
atual seria usado. Observe que essa macro foi projetada para ser chamada no
modo de rpm constante, ou seja, quando o C97 está ativo. No modo C96,
algumas mudanças precisariam ser feitas. Entretanto, o C96 raramente é
usado em fresadoras.

SE [# 19 EQ # 0] ENTÃO # 19 = # 103;
(A rotação atual do fuso sendo usada, na ausência de uma palavra S no bloco
COl. Etapa 6 completa)

# 104 = # 4120;
(Armazena o número da ferramenta atual, para verificar se é o número da
ferramenta 7. Etapa 7 completa)

SE [# 104 NE 7] GOTO 10; (Se a ferramenta atual for diferente da ferramenta


número 7, pule para o número de sequência NlO, para
executar COl sem alterar o avanço. Passo 8 completo)

# 105 = 100;
(Especifique o avanço máximo admissível, em milímetros por minuto, para o
número de ferramenta 7. Etapa 9 completa)

SE [# 100 EQ 95] ENTÃO # 105 = # 105 I # 19;


(Velocidade máxima permitida convertida para ser alimentada por rotação, para
uso no modo C95. Etapa 10 completa)

SE [# 101 EQ 20] ENTÃO # 105 = # 105 I 25,4;


(Converte o avanço máximo permissível em polegadas por minuto ou
polegadas por rotação, se o programa estiver no modo C20. Etapa 11
completa)

SE [# 9 GT # 105] ENTÃO # 9 = # 105;


(Avanço especificado / anterior fixado ao valor máximo admissível. Etapa 12
completa)

N10 G01 X # 24 Y # 25 Z # 26 F # 9 S # 19;


(Interpolação linear com valores especificados / anteriores de X, Y, Z e S e
valor apropriado de F. Etapa 13 completa)

M99;
(Retorne ao programa de chamada. Etapa 14 completa)
O programa 09011 dado aqui é para fresadoras. Para um torno, precisaria ser
modificado para excluir a palavra Y. Além disso, além de X e Z, U e W também
são usados em um torno. Portanto, o programa para um torno precisaria ser
chamado por G01 X_ Z_ U_ W_F_ S_. Pode-se armazenar 1 no parâmetro
6052 (digamos) e definir o programa correspondente 09012, para redefinição
de G01. Consulte a Tabela 3.10 (a) e a Tabela 3.11 para obter informações
sobre as variáveis do sistema usadas neste programa. O algoritmo é
semelhante ao usado no programa 09011, exceto que o 09012 também cuida
do modo de velocidade de superfície constante (C96), para calcular a rpm
necessária na fórmula que relaciona a alimentação por minuto ao avanço por
rotação, para uso no modo C99. Observe, no entanto, que o avanço seria
fixado (se necessário) apenas no início do movimento de interpolação linear.
Se o modo de avanço por rotação (C99) também estiver ativo no modo C96, a
velocidade de avanço (avanço por minuto) aumentará se o diâmetro de corte
diminuir durante a execução de interpolação linear (por exemplo, em face ou
inclinação). A macro fornecida não tem controle sobre esse tipo de avanço. Só
irá verificar a velocidade de avanço no início do movimento. A rpm (N) está
relacionada com a velocidade de superfície constante (CSS) e com o diâmetro
de corte (0), que é igual à atual posição X da ferramenta, pela seguinte fórmula:

onde CSS está em metros por minuto e 0 está em milímetros e

onde CSS está em pés por minuto e 0 está em polegadas.

O algoritmo usado na macro 09012 é dado abaixo, seguido por


o programa:
1. Descubra se o C98 ou C99 está ativo no momento da chamada
a macro.
2. Descubra se o C20 ou C21 está ativo no momento da chamada
a macro.
3. Descobrir a taxa de avanço ativa no bloco, imediatamente anterior
o bloco de chamada de macro.
4. Se o bloco GO1 não contiver uma palavra F, use a velocidade de
obtido no passo anterior.
5. Descubra o valor da palavra S ativo no imediatamente anterior
quadra.
6. Se o bloco G01 não contiver uma palavra S, use o valor
obtido no passo anterior.
7. Descubra o número da ferramenta, usando FIX [T-code value / 100], que
extrai os dois dígitos mais à esquerda dos quatro dígitos (pode ser um
número de três dígitos também) valor do código-T. Por exemplo, 0102
(correspondente a T0102) daria 01, como a ferramenta atual
número.
8. Se o número da ferramenta não for 7, vá para a etapa 15.
9. Descubra se G96 ou G97 está ativo no momento da chamada
a macro.
10. Descobrir o rpm no momento de chamar a macro (ou seja, no
imediatamente precedente). No modo G97, seria
igual ao valor da palavra S. No modo G96, o cálculo usando o
dada fórmula seria necessária.
11. Especifique o avanço máximo admissível (F maJ em milímetros
por minuto.
12. Converta F max em milímetros por revolução se G99 for
ativo, usando a fórmula
feed por minuto = avanço por revolução x rpm
13. Converta F max em polegadas por minuto ou polegadas por revolução,
se o G20 estiver ativo, dividindo-o por 25,4.
14. Se o avanço especificado / anterior for maior que F max, use F max
como taxa de avanço.
15. Executar interpolação linear com valores especificados / anteriores
de X, Z, U, W e S e valor apropriado de F.
16. Volte para o programa de chamada.

09012 (REDEFINAS G01 EM TORNO);

# 100 = # 4005; (Armazena 98 ou 99, correspondentes a G98 e G99,


respectivamente, o que estava ativo no momento de chamar a macro. Essa
informação é necessária porque é necessário saber se o avanço especificado
no bloco de macro chamada está em feed por minuto ou feed por revolução
(passo 1 completo)
# 101 = # 4006;
(Armazena 20 ou 21, correspondendo a G20 e G21, respectivamente, o que
estava ativo no momento de chamar a macro. Essa informação é necessária
porque é necessário saber se as distâncias especificadas estão em polegadas
ou milímetros. Etapa 2 completa)

# 102 = # 4109; (Armazena o avanço ativo até o bloco anterior. Esta


informação seria necessária se o GOl for comandado sem uma palavra F.
Nesse caso, a última taxa de avanço especificada seria usada. Etapa 3
completa)

SE [# 9 EQ # 0] ENTÃO # 9 = # 102;
(O último avanço especificado sendo usado, na ausência de uma palavra F no
bloco GOL. Etapa 4 completa)

# 103 = # 4119;
(Armazena o spindle rpm / CSS na hora de chamar a macro. Esta informação
seria necessária se o GOl fosse comandado sem uma Sword. Nesse caso, o
rpm / CSS atual seria usado. Note que quando o G97 está ativo, o A palavra S
indica rpm No modo G96, representa o CSS.
SE [# 19 EQ # 0] ENTÃO # 19 = # 103;
(O atual fuso rpm / CSS sendo usado, na ausência de uma palavra S no bloco
GOl. Etapa 6 completa)

# 104 = # 4120;
(Armazena o código de ferramenta atual de quatro dígitos, para verificar se é o
número de ferramenta 7)

# 104 FIX [# 104 I 100];


(Extrai o número da ferramenta do código de ferramenta de quatro dígitos.
Etapa 7 completa)

SE [# 104 NE 7] GOTO 10;


(Se a ferramenta atual for diferente da ferramenta número 7, pule para o
número de sequência NlO para executar G01 sem alterar a velocidade de
avanço.

# 106 = # 4002;
(Armazena 96 ou 97 dependendo de qual dos G96 e G97 está atualmente
ativo. Etapa 9 completa)

SE [# 106 EQ 97] ENTÃO # 107 = # 19;


(No modo G97, a palavra S contém rpm que é armazenada no # 107)

# 108 = # 5041;
(Ajusta a posição atual da ferramenta ao longo do Xaxis. Isso é igual ao
diâmetro que está sendo girado atualmente, ou seja, no momento de chamar
GOl. Observe que o diâmetro de giro muda continuamente no viramento ou no
revestimento cônico.
na fórmula para calcular a rpm, no modo G96, é usado o diâmetro inicial,
conforme obtido aqui. Como resultado, mesmo que o rpm mude continuamente
no modo G96 enquanto executa G0l, apenas a rpm inicial é calculada)

# 109 [[1000 * # 19] eu [3 .14 159 * # 108]];


(Cálculo intermediário. O uso de colchetes externos garante que a barra seja
sempre interpretada como o operador de divisão, nunca como o símbolo de
salto intermediário)

SE [[# 106 EQ 96] E [# 101 EQ 21]] ENTÃO # 107 = # 109;


(# 107 armazena o rpm calculado nos modos CSS e milímetro)

# 110 [[12 * # 19] eu [3 .14159 * # 108]];


(Cálculo intermediário. O uso de colchetes externos garante que a barra seja
sempre interpretada como o operador de divisão, nunca como o símbolo de
salto intermediário)

SE [[# 106 EQ 96] E [# 101 EQ 20]] ENTÃO # 107 = # 110;


(# 107 armazena o rpm calculado nos modos CSS e polegada. Etapa 10
completa)
# 105 = 100;
(Especifique o avanço máximo admissível, em milímetros por minuto, para o
número de ferramenta 7. Etapa 11 completa)

SE [# 100 EQ 99] ENTÃO # 105 = # 105 I # 107;


(Velocidade máxima permitida convertida para ser alimentada por rotação, para
uso no modo G99. Etapa 12 completa)

SE [# 101 EQ 20] ENTÃO # 105 = # 105 I 25,4;


(Converte o avanço máximo permitido em polegadas por minuto ou polegadas
por rotação, se o programa estiver no modo G20. Passo 13 completo)

SE [# 9 GT # 105] ENTÃO # 9 = # 105;


(Avanço especificado / anterior fixado ao valor máximo admissível. Etapa 14
completa)

N10 G01 X # 24 Z # 26 U # 21 W # 23 F # 9 S # 19;


(Interpolação linear com valores especificados / anteriores de X / U, Z / W e S e
valor apropriado de F. Etapa 15 completa)

M99;
(Retorne ao programa de chamada. Etapa 16 completa)

O objetivo de selecionar este exemplo não foi apenas gravar uma macro para
um aplicativo específico. (Na verdade, nunca é necessário redefinir o G01 em
uma máquina.) Esse exemplo deixa bastante claro que uma macro complexa
como essa, talvez, não pode ser gravada corretamente sem primeiro escrever
o algoritmo. No entanto, quando o algoritmo está pronto, o que resta é o
trabalho mecânico de convertê-lo em códigos. Sem adotar essa abordagem,
um novo aprendiz talvez jamais seria capaz de dominar a programação de
macros; até mesmo um programador experiente pode cometer erros. Mais
algumas coisas ainda precisam ser discutidas, embora não estejam
diretamente relacionadas ao tópico deste capítulo. Eles são, no entanto,
discutidos aqui porque eles não merecem um capítulo separado, e este é o
último capítulo que trata dos fundamentos da macro programação.
7.6 Processamento de declarações macro

Primeiro é necessário entender o conceito de buffer durante a execução do


programa, antes de discutir como as instruções de macro são processadas
pelo controle.

O que é buffer?

Embora a execução de um programa seja bloco a bloco, o controle lê a


declaração NC a ser executada a seguir, para uma usinagem mais suave. A
próxima instrução NC é lida e interpretada com antecedência, mas executada
somente após a execução da instrução anterior estar completa. Se ambos
forem comandos de movimento, a execução do segundo comando começa um
pouco antes do ponto final do primeiro comando ser alcançado, o que resulta
em cantos ligeiramente arredondados. Essa pequena distância é chamada
largura na posição, especificada no parâmetro 1827. Para obter cantos agudos,
especifique um valor pequeno nesse parâmetro. Alternativamente, em uma
fresadora, execute o programa no modo de parada exata, G6l. No entanto,
arredondar os cantos acelera a execução, devido ao menor efeito de
desaceleração / aceleração e, na maioria dos casos, cantos muito agudos não
são necessários. No modo de compensação de raio, duas instruções NC são
lidas antecipadamente e, se uma delas não for um comando de movimento no
plano de compensação, mais uma instrução NC será pré-determinada. Essa
operação de pré-leitura é chamada de buffering.

Quantos blocos são armazenados?

Até três instruções NC são armazenadas em buffer, dependendo de situações


específicas, embora os blocos próximos aos códigos G31, MOO, MOl, M02,
M30 e M especificados nos parâmetros 3411 a 3420 não sejam armazenados
em buffer. No entanto, o controle tenta armazenar tantas instruções de macro
quanto possível, durante a execução da instrução NC atual.

Quando os blocos com buffer são processados?

Como já mencionado, uma instrução NC em buffer é processada (executada)


depois que a execução da instrução NC atual termina (ou "quase" termina). No
entanto, uma instrução de macro é processada imediatamente, assim que é
armazenada em buffer.

O processamento de instruções de macro depende de como o buffer é feito


pelo controle. Existem quatro situações possíveis, em que o buffer é feito de
forma diferente. O processamento de instruções de macro nesses casos é
descrito a seguir, com a ajuda de exemplos.
Processando quando o próximo bloco não está armazenado em buffer

Ao executar certos códigos M e G31, o controle não armazena o próximo bloco.


Portanto, se o próximo bloco contiver uma instrução de macro, ela será
armazenada em buffer e processada somente após a conclusão do
processamento do bloco atual:

...
N100 G31 X100; (O próximo bloco não está em buffer por causa do G31)
N101 # 100 = 1; (# 100 é definido como 1, após a execução do G31 ser
concluída)
...

Processamento no modo de cancelamento de compensação de raio (G40)

Todas as instruções de macro subseqüentes, até a próxima instrução NC, são


lidas e processadas imediatamente:

N100 G01 X100 F100; (Durante a execução deste bloco, o buffer é feito até
N104)

N101 # 100 = 1; (# 100 está definido como 1 enquanto o N100 está sendo
executado)
N102 # 101 = 2; (# 101 está definido para 2 enquanto o N100 está sendo
executado)
N103 # 102 = 3; (# 102 está definido para 3 enquanto o N100 está sendo
executado)
N104 Z100; (A próxima declaração NC, após o bloco N100)
N105 # 103 = 4; (Esta instrução de macro não é armazenada em buffer
N100 está sendo executado)
...

Processamento no modo de compensação de raio (caso 1)

Para processamento no modo de compensação de raio (G41 / G42), quando as


próximas duas instruções NC são comandos de movimento, no plano de
compensação, todas as declarações macro, até a segunda instrução NC após
a instrução NC atualmente em execução, são lidas e imediatamente
processado. (Este exemplo refere-se a uma fresadora, assumindo que o plano
de compensação é G17, ou seja, o plano XY.)

NlOO G01 X100 F100; (Durante a execução deste bloco, o buffer é feito até
N106)
N101 # 100 = 1; (# 100 está definido como 1 enquanto o N100 está sendo
executado)
N102 # 101 = 2; (# 101 está definido para 2 enquanto o N100 está sendo
executado)
N103 Y100; (A primeira declaração NC, após o bloco N100)
N104 # 102 = 3; (# 102 está definido para 3 enquanto o N100 está sendo
executado)
N105 # 103 = 4; (# 103 está definido como 4 enquanto o N100 está sendo
executado)
N106 X200; (A segunda declaração NC, após o bloco N100)
N107 # 104 = 5; (Esta instrução de macro não é armazenada em buffer
N100 está sendo executado)

Processamento no modo de compensação de raio (caso 2)

Para processamento no modo de compensação de raio (G41 / G42), quando


um (qualquer um) das próximas duas instruções NC não é um comando de
movimento, no plano de compensação, todas as declarações macro, até a
terceira instrução NC após a atual executando a instrução NC, são lidos e
processados imediatamente. (Este exemplo refere-se a uma fresadora,
assumindo que o plano de compensação é G17, ou seja, o plano XY.)

...
N100 G01 X100 F100; (Ao executar este bloco, o buffer é feito até o N109)
N101 # 100 = 1; (# 100 está definido como 1 enquanto o N100 está sendo
executado)
N102 # 101 = 2. (# 101 está definido como 2 enquanto N100 está sendo
executado)
N103 Y100; (A primeira declaração NC, após o bloco N100)
N104 # 102 = 3; (# 102 está definido para 3 enquanto o N100 está sendo
executado)
N105 # 103 = 4; (# 103 está definido como 4 enquanto o N100 está sendo
executado)
N106 Z10; (A segunda declaração NC, após o bloco N100. Esta declaração
não causa movimento no plano de compensação)
N107 # 104 = 5; (# 104 está definido para 5 enquanto o NlOO está sendo
executado)
N108 # 105 = 6; (# 105 está ajustado para 6 enquanto o NlOO está sendo
executado)
N109 X100; (A terceira declaração NC, após o bloco N100)
NllO # 106 = 7 · (Esta declaração de macro não está em buffer enquanto o
N100 está sendo executado)
...

Finalmente, no modo de compensação de raio, se ambas as instruções NC


subsequentes, após a instrução NC atualmente em execução, não envolver
movimento no plano de compensação, isso resultaria em compensação
incorreta. O programa deve ser modificado para evitar essa situação. No
entanto, para fins de discussão, esse caso é equivalente ao caso anterior, com
relação ao armazenamento em buffer de instruções macro (por exemplo, se
N103 Y100 for substituído por, digamos, N103 M08, o armazenamento em
buffer ainda seria feito somente até N109).

Efeito do buffer de instruções macro na execução do programa

O objetivo do buffer é acelerar a execução do programa executando os


cálculos antecipadamente. Normalmente, isso apenas melhora o desempenho
da máquina, mas há situações em que o buffer não é desejável e deve ser de
alguma forma suprimida. Por exemplo, suponha que a variável de sistema #
1100 (que corresponde ao sinal F54.0 no diagrama ladder PMC) tenha sido
usada para operar um dispositivo externo, conectado ao terminal de saída
YS.O (que pode ser localizado na faixa de terminais de o módulo de entrada /
saída do PMC), adicionando a seguinte linha ao diagrama ladder existente:

Essa linha deve ligar ou desligar o dispositivo de saída, dependendo do status


atual (1 ou 0) da variável # 1100. Agora, se o requisito é ligar o dispositivo em
algum lugar no meio da execução do programa, esperar por 5 segundos e
depois desligá-lo e reiniciar a execução, pode-se inserir os seguintes blocos no
programa, no local desejado:

# 1100 = 1;
G04 X5;
# 110 0 = 0;

Infelizmente, isso não funcionaria. A saída seria, de fato, ativada, mas, durante
a permanência por 5 segundos, a próxima instrução de macro (# 1100 = 0)
seria armazenada em buffer e executada imediatamente, desligando a saída
instantaneamente. Assim, mesmo que a execução permanecesse por 5
segundos, a saída ligaria apenas momentaneamente. Portanto, para ter o
efeito desejado, é necessário suprimir o buffer nesse caso. Isso pode ser feito
simplesmente inserindo uma instrução NC em branco (um ponto-e-vírgula, o
símbolo EOB, é tratado como uma instrução NC em branco) após o bloco G04:

# 1100 = 1;
G04 X5;
;
# 1100 = 0;

O controle Fanuc não define um G-eode para limitar o buffer ao número


desejado de blocos, ao contrário do controle Haas que possui G103 para este
propósito. No entanto, como mencionado anteriormente, é possível definir
certos códigos M (no intervalo de 0 a 255), com o único propósito de impedir o
armazenamento em buffer do bloco seguinte. Por exemplo, se 100 for
armazenado em qualquer parâmetro no intervalo 3411 a 3420, o M100
impediria o armazenamento em buffer de o bloco a seguir. Então, em vez de
inserir uma instrução NC em branco, no exemplo anterior, o M100 pode ser
comandado. Esse método é melhor porque um programador diferente pode
considerar o ponto-e-vírgula extra desnecessário e pode até optar por excluí-lo!
Observe, no entanto, que o buffer não deve ser suprimido no modo de
compensação de raio, porque, caso contrário, a compensação não seria
implementada adequadamente pelo controle, resultando em uma usinagem
incorreta.

CAPITULO 8
Movimento complexo Geração

8.1 Introdução

Até agora, apenas as ferramentas básicas da programação de macros foram


discutidas. Com a ajuda destes, é possível gerar percursos complexos, além de
várias outras aplicações que são discutidas nos capítulos seguintes. Alguns
exemplos de geração de movimento complexo são apresentados neste
capítulo. De um modo geral, é mais fácil fazê-lo em uma fresadora (em
usinagem 2D) do que em um torno, porque o caminho da ferramenta gerado
teria que ser usado em conjunto com um ciclo fixo adequado (G71 / G72 / G73)
em um torno , para evitar grande profundidade de corte. Portanto, os exemplos
de fresamento são discutidos primeiro.

8.2 Arco com Raio de Variação Uniforme

Considere a fenda mostrada na Fig. 8.1, que está na forma de um arco (AB),
com raio uniformemente crescente. Os raios de início e fim são 35 mm (CA) e
40 rnrn (CB), respectivamente. O ângulo do arco é de 60 °, o ângulo inicial é de
15 °. O ponto zero da peça (origem ou dado da WCS escolhida, entre G54,
G55, ..., G59) está em 0. O centro do arco (C) está localizado nas coordenadas
(30, 20). A profundidade do slot é assumido como sendo 3 rnrn.
Como o raio do arco varia continuamente, a interpolação circular não pode ser
usada neste caso. A única maneira é localizar pontos espaçados no arco AB e
uni-los por interpolação linear. O espaçamento entre esses pontos deve ser
cuidadosamente selecionado. Um pequeno valor melhoraria a suavidade do
arco. No entanto, um valor muito pequeno aumentaria os cálculos, o que pode
resultar em movimentos lentos da ferramenta. (Outra e a principal causa do
movimento lento é que a aceleração / desaceleração está envolvida em cada
segmento do caminho da ferramenta. Portanto, a velocidade de avanço efetiva
pode ser muito menor que a velocidade de avanço especificada).
As coordenadas de algum ponto P no arco (Xp, Yp), como uma função do
ângulo 9, podem ser encontradas usando as seguintes equações, assumindo
que o raio r muda com uma maneira uniforme (linear):

No ponto inicial do arco (A), o valor de e é zero. Depois disso, aumenta


gradualmente para atingir o ponto final (B). Isso forma a base de um algoritmo
para esse problema. O primeiro passo no desenvolvimento de um algoritmo
para a macro é decidir como usar a macro. Aqui, assume-se que a ferramenta
está 2 mm acima do ponto inicial do arco (A) no momento de chamar a macro,
e volta para o mesmo nível Z no ponto final do arco (B) quando execução das
extremidades da macro. Também é assumido que o programa de chamada usa
milímetros, (G21), o plano XY (G17), avanço em milímetros por minuto (G94),
coordenadas absolutas (G90), sem compensação de raio --- (G40) e nenhum
ciclo fixo ativo (G80). Supõe-se ainda que a ferramenta correta (slotdrill de 6
mm de diâmetro) é mantida pelo fuso, e está girando com a rotação correta.
Finalmente, a escolha da WCS (digamos, G54) e a compensação do
comprimento da ferramenta (G43 H_) são consideradas corretas. Com essas
suposições, não se pode dizer que a macro seja bastante geral, mas o objetivo
aqui é descrever a técnica de gerar um arco com raio variável. O arco, é claro,
seria definido em termos de vários parâmetros variáveis, o que o tornaria
bastante geral. Uma vez que o programa básico está pronto, torna-se fácil
torná-lo mais geral, conforme a necessidade. Na verdade, não é recomendável
considerar todas as possibilidades no início, pois essa abordagem dificulta a
programação, deixando margem suficiente para erros lógicos. Os parâmetros
do slot, os endereços de letra selecionados para estes e as variáveis locais
associadas, conforme a especificação do argumento I (consulte a Tabela 7.4),
são fornecidos na Tabela 8.1. Como esses endereços de letras seriam usados
para passar dados na chamada de macro G65 / G66, a escolha deles deve
refletir o significado físico real, tanto quanto possível. Isso ajudaria a lembrar
qual endereço de carta se refere a qual parâmetro. No presente caso, as
primeiras letras dos parâmetros foram escolhidas como endereços de letras,
exceto A e F, onde não seria possível. Agora, o algoritmo para este problema,
adequado para loop WHILE_DO_ END, pode ser escrito (note que a condição
especificada é verificada no início do loop, em uma instrução WHILE): 1. Faça
uma entrada de mergulho até a profundidade especificada, com o avanço de
mergulho especificado. 2. Escolha o incremento em ângulo, ~ 8 e atribua 8 = ~
8. 3. Se 8 for maior que o ângulo do arco incluído, vá para a etapa 8. (G40) e
nenhum ciclo fixo ativo (G80). Supõe-se ainda que a ferramenta correta
(slotdrill de 6 mm de diâmetro) é mantida pelo fuso, e está girando com a
rotação correta. Finalmente, a escolha da WCS (digamos, G54) e a
compensação do comprimento da ferramenta (G43 H_) são consideradas
corretas. Com essas suposições, não se pode dizer que a macro seja bastante
geral, mas o objetivo aqui é descrever a técnica de gerar um arco com raio
variável. O arco, é claro, seria definido em termos de vários parâmetros
variáveis, o que o tornaria bastante geral. Uma vez que o programa básico está
pronto, torna-se fácil torná-lo mais geral, conforme a necessidade. Na verdade,
não é recomendável considerar todas as possibilidades no início, pois essa
abordagem dificulta a programação, deixando margem suficiente para erros
lógicos. Os parâmetros do slot, os endereços de letra selecionados para estes
e as variáveis locais associadas, conforme a especificação do argumento I
(consulte a Tabela 7.4), são fornecidos na Tabela 8.1. Como esses endereços
de letras seriam usados para passar dados na chamada de macro G65 / G66, a
escolha deles deve refletir o significado físico real, tanto quanto possível. Isso
ajudaria a lembrar qual endereço de carta se refere a qual parâmetro. No
presente caso, as primeiras letras dos parâmetros foram escolhidas como
endereços de letras, exceto A e F, onde não seria possível. Agora, o algoritmo
para esse problema, adequado para loop WHILE_DO_ END, pode ser gravado
(observe que a condição especificada é verificada no início do loop, em uma
instrução WHILE):
1. Faça uma entrada de mergulho até a profundidade especificada, com a
velocidade de avanço.
2. Escolha o incremento em ângulo, e atribua

3. Se 8 for maior que o ângulo do arco incluído, vá para a etapa 8.


4. Calcule r, xp e yp, usando a fórmula dada.
5. Mova para as coordenadas calculadas (Xp, Yp) por G01, com o
Avanço de fresagem especificado.
6. Ângulo de incremento ( = + ).
7. Vá para o passo 3.
8. Recolha a ferramenta a 2 mm acima da peça de trabalho.
9. Retorne ao programa de chamada.

O número do programa 8014 é baseado neste algoritmo. Para fazer o slot da


Fig. 8.1, essa macro precisaria ser chamada por
G65 P8014 A15 I60 S35 E40 D3 X30 Y20 F20 M60;
onde o avanço de mergulho e o avanço de fresagem são considerados como
20 e 60 mm / min, respectivamente.
08014 (ARCO COM RAIO VARIÁVEL);

G01 Z- [ABS [# 7)] F # 9; (Entrada de mergulho com o mergulho especificado


avanço no ponto inicial A. O uso da função ABS aceita valores positivos e
negativos para a profundidade do slot. Etapa 1 concluída)

# 100 = 0,1;
( selecionado, em graus). ( Delta Teta).
# 101 = # 100;
( set igual a L-8. Etapa 2 completa) ( Teta)
WHILE [# 101 LE # 4) FAÇA 1;
(Saia do loop se 8 for maior que o ângulo do arco incluído. Etapa 3 completa)
# 102 # 19 + [[# 8 # 19) * # 101 I # 4);
(calculado)
# 103 # 24 + # 102 * COS [# 101 + # 1);
(Xp calculado)
# 104 # 25 + # 102 * SIN [# 101 + # 1];
(Fim do loop WHILE. Etapa 7 completa)
X # 103 Y # 104 F # 13;
(Mova para (Xp, Yp) com o avanço de fresagem especificado. Etapa 5
completa)
# 101 = # 101 + # 100;
(Ângulo 8 incrementado pelo passo escolhido. Passo 6 completo)
END 1;
(Fim do loop WHILE. Etapa 7 completa)
GOO Z2;
(A ferramenta está agora no ponto final B do arco. Aqui, ela é retraída até 2 mm
acima da peça de trabalho. Etapa 8 completa)
M99;
(Retorne ao programa de chamada. Etapa 9 completa)

Este macro funcionaria tanto para aumentar quanto para diminuir os raios (ou
seja, também quando r A> r8). No entanto, para um arco no sentido horário
(isto é, quando as posições de A e B são trocadas, e a usinagem ainda é
desejada de A para B, na Fig. 8.1), as seguintes mudanças seriam
necessárias:

• Especifique um valor negativo para (por exemplo, # 100 = -0.1).


• Na fórmula para r, o valor absoluto de e (que se torna
negativo quando ~ e é atribuído um valor negativo) deve ser usado.
Então, substitua o número 101 por ABS [# 101] no bloco que calcula r.
Não haveria alteração nos blocos que calculam Xp e
Yp. A outra maneira seria especificar um valor negativo, no
bloco de macro-chamada, para o ângulo incluído se mede no
sentido horário, ao passar de OA para OB. Isso seria
Evite a necessidade de qualquer mudança no programa.
• O bloco WHILE deve comparar os valores absolutos.

Modificar a macro para requisitos ligeiramente diferentes não é


Boa prática, porque um programador menos experiente pode estragar
inadvertidamente a macro desenvolvida meticulosamente por algum
programador especialista. Além disso, outros usuários da máquina podem não
estar cientes das alterações feitas no macro. Na verdade, é por essa razão que
os macros geralmente são protegidos por edição.
Em vista da discussão anterior, seria melhor definir mais uma variável local (por
exemplo, # 17 que se refere ao endereço de letra Q) para passar o valor do
incremento no ângulo para o macro, de forma que um incremento positivo
valor faria um arco no sentido anti-horário e um valor negativo faria um arco no
sentido horário. Além disso, como pode haver uma confusão em relação ao
sinal do ângulo incluído, a macro deve aceitar ambos os sinais. Uma vantagem
de passar o valor de é que o usuário do macro também pode controlar a
suavidade do arco. O número do programa 8015 é um macro que pode ser
chamada por

G65 P8015 A15 I60 535 E40 D3 X30 Y20 F20 M60 Q -0,1;
ou
G65 P8015 A15 I-60 535 E40 D3 X30 Y20 F20 M60 Q -0,1;

para um arco no sentido horário. Os leitores podem tentar tornar a macro mais
geral para atender a aplicativos específicos. Uma vez que o núcleo do
programa esteja pronto, modificá-lo não é um grande problema, como pode ser
visto no presente caso, onde 08014 foi modificado para 08015.

08015 (ARCO COM VARIÇÃO DO RAD - MODIFICADO);

G01 Z- [AB5 [# 7]] F # 9; (Entrada de mergulho com a velocidade de avanço de


mergulho especificada no ponto inicial A. O uso da função ABS aceita valores
positivos e negativos para a profundidade do slot. Etapa 1 completa)

# 100 = # 17; ((~ 8) definido para o valor especificado na palavra Q, que pode
ser positivo e negativo, para arcos CCW e CW, respectivamente)

# 101 = # 100;
((8) conjunto igual a (~ 8). Etapa 2 completa)

WHILE [ABS [# 101] LE ABS [# 4]] DO 1;


(Saia do loop se a magnitude de e for maior que a magnitude do ângulo do
arco incluído. O ABS [# 4] aceitaria valores positivos e negativos para o ângulo
incluído. Etapa 3 completa)

# 102 # 19 + [[# 8 - # 19] * ABS [# 101] Eu ABS [# 4]];


(r calculado. ABS [# 4] aceitaria valores positivos e negativos para o ângulo
incluído)

# 103 # 24 + # 102 * COS [# 101 + # 1];


(Xp calculado)
# 104 # 25 + # 102 * SIN [# 101 + # 1];
(Yp calculado. Passo 4 completo)

X # 103 Y # 104 F # 13;


(Mova para (Xp, Yp) com o avanço de fresagem especificado. Etapa 5
completa)

# 101 = # 101 + # 100; (Ângulo teta e incrementado pelo valor do passo


especificado. O ângulo, na verdade, é diminuído se o valor do passo for
negativo, para um arco no sentido horário. Etapa 6 completa)
END 1;

(Fim do loop WHILE. Etapa 7 completa)

GOO Z2;
(A ferramenta está agora no ponto final B do arco. Aqui, ela é retraída até 2 mm
acima da peça de trabalho. Etapa 8 completa)

M99;
(Retorne ao programa de chamada. Etapa 9 completa)

Essa macro faria o slot em uma passagem. Se a profundidade do slot for


grande, digamos, 10 mm, pode não ser prático fresá-lo em uma passagem. Se
a profundidade máxima permitida de corte for de, digamos, 3 mm, quatro
passagens seriam necessárias (a, digamos, profundidades de 3, 6, 9 e 10 mm,
respectivamente). Portanto, a próxima tarefa é cuidar desse requisito. Pode-se
fazer uso da lógica usada no fluxograma apresentado na Fig. 6.2. Os seguintes
passos precisariam ser incorporados no algoritmo dado anteriormente:

1. Mova a ferramenta para a posição ZO.


2. Se a profundidade especificada / calculada for maior do que 3 mm, então

• Faça um arco de 3 mm de profundidade (distância incremental em relação ao


nível Z anterior), usando o algoritmo do programa anterior (este passo
apareceria como um aninhado). WHILE loop neste programa).
• Depois de atingir o ponto final do arco, retraia a ferramenta acima da peça de
trabalho e traga-a de volta ao ponto inicial do arco, no mesmo nível Z, com taxa
rápida (GOO).
• Agora traga a ferramenta para o nível Z anterior (com taxa rápida até 1 mm
acima do nível Z anterior, seguido por avanço na última viagem de 1 mm).
• O fresamento de ranhura no passe anterior reduz a necessidade
profundidade de 3 mm, então, definir profundidade = profundidade de 3.
• Volte ao passo 2.

3. Faça o arco na profundidade especificada / calculada (incremental


distância do nível Z anterior). Outro loop WHILE
será necessário para esta etapa.
4. Recolha a ferramenta a 2 mm acima da peça de trabalho.
5. Retorne ao programa de chamada.

O número do programa 8016 é baseado nesse algoritmo, que usa uma


instrução WHILE aninhada de dois níveis. Pode ser chamado por

G65 P8016 A15 I60 S35 E40 D10 X30 A20 F20 M60 Q -0 .1;
ou
G65 P8016 A15 I-60 S35 E40 D10 X30 Y20 F20 M60 Q -0,1;

para um arco no sentido horário de 10 mm de profundidade. A usinagem seria


feita em quatro passagens (uma vez em Z = -3, -6, -9 e -10 mm)

08016 (VAR RAD ARC WITH ARBIT DEPTH);

G01 ZO F # 9; (Ferramenta feita para tocar a peça na


ponto inicial do arco. Etapa 1 concluída)

# 10 7 = ABS [# 7); (O valor positivo da profundidade do slot especificado no


bloco de chamada de macro seria usado posteriormente, o que permite valores
positivos e negativos no bloco de chamada de macro)

WHILE [# 107 GT 3] DO 1; (Step2 começa aqui)

G91 G01 Z-3 F # 9;


(Mergulhe 3 mm abaixo do nível Z atual, no ponto inicial A, com o avanço de
mergulho especificado)

# 100 # 17;
( ajustado para o valor especificado na palavra Q, que pode ser positivo e
negativo, para arcos CCW e CW, respectivamente.
block pode ser colocado fora do loop também, isto é, antes do bloco
WHILE_OO_, porque # 100 não é redefinido pelo loop)

# 101 = # 100;
( set igual a )

WHILE [ABS [# 101] LE ABS [# 4)) DO 2;


(Saia do loop se a magnitude de 9 for maior que a magnitude do ângulo do
arco incluído. O ABS [# 4] aceitaria valores positivos e negativos para o ângulo
incluído)

# 102 # 19 + [[# 8 - # 19) * ABS [# 101] Eu ABS [# 4));


(r calculado. ABS [# 4] aceitaria valores positivos e negativos para o ângulo
incluído)

# 103 # 24 + # 102 * COS [# 101 + # 1);


(Xp calculado)

# 104 # 25 + # 10 2 * SIN [# 101 + # 1];


(Yp calculado)

G90 X # 103 Y # 104 F # 13;


(Mova para (XP, Yp) com o avanço de fresagem especificado)

# 101 = # 101 + # 100;


(Ângulo e incrementado / decrementado pelo passo escolhido)

END 2;
(Fim do loop WHILE. Arco feito)

# 105 = # 5043
(A coordenada Z absoluta atual da ferramenta armazenada no # 105)
;
GOO Z2;
(A ferramenta está agora no ponto final B do arco. Aqui, é retraída até 2 mm
acima da peça de trabalho)

X (# 24 + # 19 * COS [# 1)) Y [# 25 + # 19 * SIN [# 1]);


(Ferramenta trazida de volta ao ponto inicial A)

Z [# 10 5 + 1);
(Rápido a 1 mm acima do nível Z anterior)

G01 Z # 105 F # 9; (Movimento de alimentação na última viagem de 1 mm)

# 107 = # 107 - 3; (Calcula a profundidade restante da ranhura, a ser


maquinada)

END 1; (Volte para o início da etapa 2. Etapa 2 conclua)

G91 G01 Z- # 107 F # 9; (Mergulhe na profundidade final, no ponto inicial A,


com o avanço de mergulho especificado)

# 100 = # 17;
( definido para o valor especificado. Esta declaração é redundante, porque #
100 já está definido)

# 101 = # 100; ( definido como )

WHILE [ABS [# 101] LE ABS (# 4)) DO 3;


(Saia do loop se a magnitude de e for maior que a magnitude do ângulo
incluído do arco. Como não é um loop WHILE aninhado, pode-se optar por usar
até 1 ou 2, no lugar de 3, como identificação de loop número)

# 102 # 19 + ((# 8 # 19) * ABS [# 101] / ABS (# 4));


(calculado)

# 103 # 24 + # 102 * COS (# 101 + # 1);


(Xp calculado)

# 104 # 25 + # 102 * SIN [# 101 + # 1];


(Yp calculado)

G90 X # 103 Y # 104 F # 13;


(Mova para (Xp, Yp) com o avanço de fresagem especificado)

# 101 = # 101 + # 100;


(Ângulo e incrementado / decrementado pelo passo escolhido)
END 3; (Fim do loop WHILE. Arc made. Passo 3 completo)
GOO Z2; (A ferramenta está agora no ponto final B do arco. Aqui, ela é retraída
até 2 mm acima da peça de trabalho. Etapa 4 completa)

M99;
(Retorne ao programa de chamada. Etapa 5 completa)

Este programa é bastante geral agora, exceto que ele assume certas
condições de controle. É deixado como um exercício para os usuários para
tornar a macro adequada para quaisquer condições de controle. A abordagem
seria semelhante à usada nas macros do Chap. 7 (09011 e 09012). Além disso,
a macro pressupõe que a profundidade máxima permitida de corte em um
passe é de 3 mm. Uma variável local pode ser usada para fornecer esse valor
para a macro. Isto é desejável porque diferentes condições de corte requerem
diferentes parâmetros de corte. Os leitores devem tentar fazer isso também, o
que é bastante simples (apenas substitua 3 pela variável local escolhida nos
locais requeridos). Um ponto importante em relação ao estilo deste programa
deve ser observado: as variáveis locais, que foram usadas para atribuição de
valor através da declaração G65 / G66, não foram redefinidas dentro da macro.
Os resultados temporários do cálculo foram armazenados em variáveis
comuns. Essa prática reduz a possibilidade de erros na macro que podem
exigir o uso dos valores especificados originais em vários locais. Portanto, se o
valor especificado de alguma variável local for alterado, conforme a lógica da
macro, armazene-a em alguma variável comum e use-a em vez da variável
local. O comando # 107 = ABS [# 7] faz exatamente a mesma coisa, para
reduzir a profundidade do slot, após cada passe. # 7 não foi redefinido.

8.3 Interpolação Helicoidal com Raio Variável

A interpolação helicoidal está disponível em fresadoras de três eixos, como


uma opção. Basicamente, é apenas uma interpolação circular, sobreposta com
movimento linear sincronizado ao longo do terceiro eixo, de modo que os
motores de acionamento de todos os três eixos atinjam o ponto final
especificado ao mesmo tempo, movendo-se a uma taxa uniforme ser diferente
um do outro). O avanço especificado é mantido ao longo do percurso calculado
no plano de interpolação circular. Portanto, a velocidade de avanço ao longo do
eixo linear seria (que é calculada automaticamente pelo controle)
Obviamente, o avanço real da ferramenta, isto é, a velocidade de avanço ao
longo do percurso da ferramenta, seria maior que o avanço especificado. Seria,
de fato,

Em uma fresadora de três eixos, a interpolação helicoidal é possível ao longo


dos eixos X, Y e Z, correspondendo a G19 (plano YZ), G18 (plano XZ) e G17
(plano XY), respectivamente. . A interpolação helicoidal ao longo do eixo Z é
mostrada na Fig. 8.2, que pode ser comandada como

<Coloque a ferramenta no ponto inicial S>


Gl7 G03 X_ Y_ Z_ R_ F_; ou G17 G03 X_ Y_ Z_ I J_ F_;

onde X_, Y_, Z_ = coordenadas do ponto final P


R = raio da hélice / interpolação circular
I_, J_ = X-, Y-coordenadas do eixo da hélice com
em relação ao ponto de partida S
F = avanço ao longo do percurso calculado no
Avião XY

G03 gera uma hélice no sentido anti-horário, como na Fig. 8.2. Substitua por
G02 por uma hélice no sentido horário. A direção da hélice (CW / CCW) é
determinada pela regra da mão direita, onde o polegar aponta na direção
positiva do eixo linear. Assim, se o caminho da ferramenta segue a direção dos
dedos enrolados, é chamado de hélice no sentido anti-horário. Interpolações
helicoidais ao longo dos eixos X e Y são feitas de maneira similar. (Note que as
ordens escolhidas de X_, Y _ e Z_ são apenas para nossa conveniência na
identificação do plano de interpolação circular associada. O plano de
interpolação circular é decidido por G17 / Gl8 / Gl9. Na palavra formato de
endereço, que o O uso de máquinas CNC, a ordem dos argumentos de um G-
eode não é importante, salvo algumas exceções, como a ordem das palavras
1-, J- e K na lista de argumentos G65 / G66):

Gl8 G02 / G03 X_ Z_ Y_ R_ F_; ou G18 G02 / G03 X_ Z_ Y_ I_ K_F_;

Gl9 G02 / G03 Y_ Z_ X_R_F_; ou Gl9 G02 / G03 Y_ Z_ X_ J_ K_F_;

Existem duas limitações da interpolação helicoidal interna, descrita acima:

• O raio / inclinação da hélice não pode ser variado.


• A velocidade de avanço ao longo do percurso atual é maior que a velocidade
de avanço especificada.
Vamos agora desenvolver uma macro para eliminar essas limitações. No
entanto, por uma questão de simplicidade, a viagem ao longo do eixo linear
seria assumida como ocorrendo em uma taxa uniforme, sincronizada com o
deslocamento angular. Em outras palavras, o pitch seria considerado
constante, como no caso da interpolação helicoidal embutida. O raio variaria, é
claro, mas a mudança de raio seria assumida em uma taxa uniforme, com
relação ao deslocamento angular. Assim, a hélice seria formada na superfície
lateral de um cone de ângulo reto.

Um macro com esse recurso pode ser usada para fresamento de rosca de
roscas de tubo cônico, com uma modificação para introduzir passo em vez de
número de loops. Isso é deixado como um exercício para os leitores. No
entanto, é possível usar a macro dado, mesmo sem qualquer modificação, só
tem que calcular e, em seguida, especificar o número de voltas (que podem
estar em fração também), dividindo a profundidade total (Z-viagem) por altura.
Considere uma hélice com um passo constante e um raio uniformemente
variável, com as seguintes características:

A vista superior de tal percurso helicoidal é mostrada na Fig. 8.3, onde quatro
curvas completas são mostradas, e o raio final é menor que o raio inicial
(embora isso não afete a equação matemática da hélice). Para ter
conformidade com a forma como a interpolação helicoidal interna é usada, a
macro seria projetada de tal maneira que o ponto inicial da hélice estaria na
posição atual da ferramenta, e a ferramenta permanecerá no ponto final da
hélice. hélice no final. Em outras palavras, a posição da ferramenta no
momento de chamar a macro se tornaria automaticamente o ponto inicial da
hélice. Isso significa que a linha central (eixo) do
A hélice fica localizada automaticamente se o raio inicial e o ângulo inicial
forem especificados. Portanto, suas coordenadas (X0, Y0) podem ser
calculadas. A primeira tarefa é gerar matematicamente a equação da hélice.
Para isso, a equação paramétrica de um ponto arbitrário na hélice precisaria
ser escrita, com o ângulo como parâmetro:
Agora, o algoritmo para esse problema, adequado para o loop
WHILE_DO_END, pode ser escrito:
1. Determine a posição atual da ferramenta (X1, Y1, Z1), através da variável de
sistema apropriada. 2. Descubra as coordenadas XY (X0, Y0) do eixo da
hélice, usando as fórmulas fornecidas. 3. Use o incremento especificado em
ângulo, ~ 8 e atribua 8 = ~ 8. 4. Se 8 for maior que 360T, vá para a etapa 9. 5.
Calcule R (8), X (8), Y (8) e Z (8), usando as fórmulas fornecidas. 6. Mova para
as coordenadas calculadas por COl, com o avanço especificado. 7. Ângulo de
incremento (8 = 8 + ~ 8). 8. Avance para o passo 4. 9. Volte ao programa de
chamada. O número do programa 8017 é baseado nesse algoritmo, que usa as
variáveis locais fornecidas na Tabela 8.2. Para interpolação helicoidal com raio
de variação uniforme, essa macro precisaria ser chamada de uma maneira
como G65 P8017 T10 S50 E4 0 D30 A45 Q1 F60; no modo absoluto, após
colocar a ferramenta no ponto inicial desejado da hélice. Note que não é
necessário estar necessariamente no modo G17, pois o COl não é afetado pelo
G17 / G18 / Gl9.
08017 (INTERPOLAÇÃO HELICOAL VAR RAD);

IF [# 19 LT O] ENTÃO # 3000 = 1 (NEGATIVE START RADIUS);


IF [# 8 LT O] ENTÃO # 3000 2 (RAIO DA EXTREMIDADE NEGATIVA);
IF [# 20 LT O] ENTÃO # 3000 = 3 (NÚMERO NEGATIVO DE VOLTAS);
(Valores negativos para raio inicial, raio final e número de voltas não são
permitidos; estes gerariam os respectivos alarmes com as mensagens
especificadas. O número de voltas também pode ter um valor fracionário. Por
exemplo, T = 1,1 refere-se a 396 °)

# 100 = # 5041; (Posição X atual determinada)


# 101 = # 5042; (Posição Y atual determinada)
# 102 = # 504 3; (Posição Z atual determinada. Etapa 1 concluída)
# 103 = # 100 - # 19 * COS [# 1];

(Coordenada X do eixo da hélice calculada. O ângulo de partida também pode


ser negativo. Deve ser especificado em graus. É permitido o intervalo de 360 °
inteiro)

# 104 # 101- # 19 * SIN [# 1];


(Coordenada Y do eixo da hélice calculada. Etapa 2 completa)

# 105 # 17;
((~ e) definido para o valor especificado, em grau, na palavra Q, que pode ser
positivo e negativo, para hélices CCW e CW, respectivamente)

# 106 = # 105;
((9) conjunto igual a (~ e). Etapa 3 completa)

WHILE [ABS [# 106] LE [360 * # 20]] DO 1;


(Saia do loop se a magnitude de e for maior que o ângulo total percorrido.
Etapa 4 completa)

# 107 # 19 - [[# 19 # 8] * ABS [# 106] eu [360 * # 20]];


(R (9) calculado)

# 108 # 103 + # 107 * COS [# 1 + # 106];


(X (9) calculado)

# 109 # 104 + # 107 * SIN [# 1 + # 106];


(Y (9) calculado)

# 110 # 102 + [# 7 * ABS [# 106] Eu [360 * # 20]];


(Z (9) calculado. Ambos os valores positivos e negativos podem ser
especificados para a profundidade. Um valor positivo move a ferramenta na
direção Z positiva, indo do ponto inicial até o ponto final, enquanto um valor
negativo faz com que ela se mova. no negativo
Direção Z Passo 5 completo)

G01 X # 108 Y # 109 Z # 110 F # 9;


(Mova para a coordenada de cálculo com o avanço especificado. Etapa 6
completa)

# 106 # 106 + # 105;


(Ângulo (9) e incrementado pelo valor do passo especificado. O ângulo é
diminuído se o valor do passo for negativo, o que gera uma hélice no sentido
horário.

END 1;
(Fim do loop WHILE. A ferramenta fica no ponto final da hélice. Etapa 8
completa)

É deixado como um exercício para os leitores modificarem essa macro para


torná-la adequada para os modos absoluto e incremental. Na verdade, é bem
simples:

• No início da macro, leia a variável de sistema # 4003 para descobrir o modo


(armazena 90 no modo absoluto e 91 no modo incremental).
• Substitua COl por C90 COl na macro, para forçar o modo absoluto. •
Comando C91 no final da macro, se o primeiro passo revelou o modo
incremental.

Os exemplos fornecidos acima explicam como um caminho de ferramenta


complexo pode ser gerado, se for definido matematicamente. Não há
necessidade de usar um software CAM para tal requisito. Além disso, um
software CAM pode não fornecer a maior flexibilidade possível com uma
macro. Alguns exemplos para um torno são discutidos a seguir.

Uma complicação em aplicações de torneamento é que a profundidade de


corte deve ser limitada ao seu valor máximo admissível, para uma dada
condição de corte. Portanto, não é possível obter uma forma complexa
transformada apenas movendo a ferramenta ao longo do limite gerado. Deve-
se fazer uso de C71 / C72 / C73, onde o limite da peça é definido entre os
números de blocos P e Q. Se C71 / C72 tipo II ciclos não estão disponíveis em
uma máquina particular, C73 teria que ser usado sempre que a mudança no
diâmetro da peça, ao longo do eixo da peça, não é monótona. C71 / C72 ciclos
tipo I exigem que haja aumento ou diminuição monotônica no diâmetro da
peça, ao longo de seu eixo.

Dois casos são discutidos abaixo: um com aumento monotônico e outro com
aumento não monotônico. O caso monotônico pode ser considerado adequado
para C71, enquanto o caso não monotônico usa C73. No entanto, conforme
explicado na próxima seção, o C71 I C72 não pode ser usado para tais
aplicativos.
8.4 Torneamento Parabólico

Os refletores recebem formas parabólicas porque um sinal ou luz emitida em


seu foco se torna paralela ao seu eixo após a reflexão, o que torna a
transmissão possível a longa distância. Da mesma forma, se for usado para
receber sinais de longa distância (que são quase raios paralelos), um receptor
de sinal colocado em seu foco recebe fortes sinais convergentes. O giro
parabólico, no entanto, não é uma característica padrão de um torno, embora
possa ser feito com facilidade usando um macro. Considere que a geometria
mostrada na Fig. 8.4.1t é presumida que a peça de trabalho tem um diâmetro
inicial, e a circunferência da ferramenta de torneamento interno é pequena o
suficiente para entrar no furo, sem qualquer interferência. Se não, um orifício
central de diâmetro apropriado seria necessário para ser perfurado primeiro,
antes de prosseguir com o torneamento parabólico. O método dado aqui, no
entanto, não pode ser usado diretamente se o projeto não permitir a existência
de um furo central. Nesse caso, a usinagem teria que ser feita usando o ciclo
de repetição de padrão (G73) na operação de revestimento (ou seja, com alívio
radial = 0 e alívio axial = conforme necessário), com uma ferramenta de face
neutra. No entanto, como uma primeira aproximação, um furo central ainda
pode ser feito, com uma fenda, para ter uma superfície plana na parte inferior
do furo. O erro introduzido (a distância entre o vértice da parábola e o fundo
plano) pode ser insignificante. Por exemplo, é 0.3175 mm para as dimensões
dadas na Fig. 8.4. A primeira tarefa é derivar uma equação matemática para a
parábola. Pode-se mostrar que a equação geral em termos do diâmetro
máximo (M), diâmetro do furo (B) e profundidade (D) é
que se pode verificar que Z = 0 dá X = M, e Z = - D dá X = B. Note que esta
equação foi escrita em um formulário para se adequar à programação do
diâmetro em um torno. Para as dimensões apresentadas na Fig. 8.4, esta
equação reduz para

X2 = 315 (Z + 20,3175).

No entanto, em vez de usar essa equação, o formato geral seria usado no


macro.
A usinagem deste tipo, interna e externa, que envolve a remoção de material a
granel, é geralmente feita pelo G71, o ciclo de torneamento múltiplo (também
chamado de ciclo de retirada de material, ou simplesmente ciclo de desbaste)
ou G72, o ciclo de múltiplas faces. são os ciclos mais eficientes. Então, pode-
se pensar em usar, digamos, G71, para usinagem, onde as equações dadas
seriam usadas para definir a curva parabólica entre os números de blocos Q da
Pand. (Note, no entanto, que quando a dimensão radial do material a ser
removido é maior do que sua dimensão axial, como no presente caso, onde
esses valores são 35 e 20 mm, respectivamente, G72 seria mais eficiente que
G71.) envolvendo G71 pode ser escrito da seguinte maneira: 1. Coloque a
ferramenta no ponto inicial de G71. 2. Comando G71 e coloque a ferramenta
no ponto inicial da parábola, isto é, em X = M e Z = 0. 3. Use a distância do
passo axial especificada t1Z e atribua Z = -t1Z. 4. Se eu z é maior que D, que é
zmax eu vou para o passo 9. 5. Calcule X, usando a fórmula dada. 6. Mova
para as coordenadas calculadas por G01. 7. Altere a coordenada Z (Z = Z-t1Z).
8. Vá para o passo 4. 9. Fim do G71. 10. Termine por G70 com metade do
avanço especificado e duas vezes a rotação atual, para um melhor
acabamento. 11. Retorne ao programa de chamada. Infelizmente, a técnica
descrita acima não funciona. Isso ocorre porque, embora G71 e G72 permitam
loops entre os blocos Q da Pand, a presença de um comando de movimento
em um loop não é permitida. Portanto, não é possível definir a geometria da
peça através de um loop, para G71 / G72. Além disso, mesmo os
subprogramas / macros não podem ser chamados de dentro dos ciclos G71 /
G72 (o M98 é ignorado e o alarme do G65 / G66 é desativado). O G73, o ciclo
de repetição de padrões, não possui essas limitações, mas seria um ciclo
altamente ineficiente para tais aplicações, já que estaria cortando o ar a maior
parte do tempo. Portanto, a única maneira, nesse caso, é simular a operação
de desbaste de G71 e G72 chamando G90 e G94, respectivamente, em um
loop. A operação de remoção de degraus do G71 / G72 pode ser simulada
movendo a ferramenta ao longo do perfil desejado, definido como pequenos
segmentos de linha reta. Um algoritmo para simular o G72 (que é mais
eficiente comparado ao G71, para as dimensões dadas) é dado abaixo:

Operação de desbaste

1. Coloque a ferramenta em Z = 0, com uma folga de 1 mm do orifício, ou seja,


em X = B-2.
2. Atribua Z = - <profundidade de corte de desbaste especificada>.
3. Se I Z I for maior que D, vá para o passo 9.
4. Calcule X, usando a fórmula dada.
5. Comando G94, com as coordenadas calculadas e o avanço especificado
como seus argumentos. 6. Desloque a ferramenta axialmente para o nível Z da
superfície usinada, que seria o ponto inicial do próximo ciclo G94. 7. Altere a
coordenada Z (Z = Z - <profundidade de corte de desbaste especificada>). 8.
Vá para o passo 3.

Operação de remoção de etapas

1. Coloque a ferramenta na borda interna da parábola, isto é, em (B, -D).


2. Atribua Z = -D.
3. Se Z for maior que 0, vá para a etapa 16.
4. Calcule X, usando a fórmula dada.
5. Mova para as coordenadas calculadas por G01.
6. Altere a coordenada Z (Z = Z + <distância do passo especificado em Z>).
7. Vá para o passo 11.
8. Volte para o programa de chamada.

Observe que, se a profundidade da parábola não for um múltiplo exato da


distância especificada em Z, a ferramenta não atingirá exatamente a borda
externa da parábola. Isso deixaria uma pequena torção na borda. Isso pode ser
removido movendo a ferramenta por alguma distância ao longo da direção
tangencial em Z = 0. Pode ser mostrado que os incrementos em X e Z, em Z =
0, estão relacionados pela seguinte fórmula:

Assim, um movimento tangencial adicional, usando a fórmula dada, é desejável


antes de retornar ao programa de chamada. O número do programa 8018 é
baseado nesse algoritmo, usando as variáveis locais fornecidas na Tabela 8.3.
O percurso para este programa é mostrado na Fig. 8.5. Para a geometria dada
na Fig. 8.4, este programa precisaria ser chamado de uma maneira como GOO
XO Z2; G65 P8018 M80 B10 020 Q0.1 R0,5 F60; O posicionamento inicial da
ferramenta em (XO, Z2) evita uma possível interferência entre a ferramenta e a
peça de trabalho ou o corpo da máquina, quando a ferramenta faz o primeiro
movimento dentro da macro. O desbaste é feito na rotação atual e no avanço
especificado, enquanto o acabamento é feito com o dobro da rotação atual e
metade do avanço especificado. Isto dá um melhor acabamento superficial.

08018 (PARABOLIC TURNING COM G9 4);

# 105 = # 5041;
(Armazena a posição X inicial da ferramenta)

# 106 = # 5042;
(Armazena a posição Z inicial da ferramenta)

GOO X [# 2 - 2] ZO;
(Ferramenta colocada no ponto inicial do primeiro ciclo G94, deixando uma
folga de 1 mm na direção radial. Etapa 1 completa)

# 100 ABS [# 17];


(A função ABS aceitaria valores positivos e negativos para a distância do passo
em Z)

# 101 = - # 18;
(A primeira mudança de etapa em Z. Etapa 2 completa)
WHILE [ABS [# 101] LE ABS [# 7]] DO 1;
(Saia do loop se toda a profundidade for desbastada. Etapa 3 completa)

# 102 [[# 13 * # 13 * ABS [# 7]] / [# 13 * # 13 - # 2 * # 2]];


(Cálculo intermediário)

# 102 = # 101 + # 102;


(Cálculo intermediário)

# 102 = [[# 13 * # 13 - # 2 * # 2] Eu ABS [# 7]] * # 102;


(Cálculo intermediário)

# 102 SQRT [# 102];


(X calculado. Passo 4 completo)

G94 X # 102 Z # 101 F # 9;


(Desbaste com G94. Passo 5 completo)
GOO Z # 101;
(Posicionamento da ferramenta para o próximo ciclo G94. Etapa 6 completa)

# 101 = # 101 - # 18;


(Z decrementado pela profundidade de desbaste especificada. Passo 7
completo)

END 1;
(Fim do loop. Etapa 8 completa)

G01 X # 2 Z [- ABS [# 7]] F [# 9/2] S [# 103 * 2];


(Ferramenta colocada na borda interna da parábola. Etapa 9 completa)

# 101 = - ABS [# 7];


(Coordenada Z da borda interna da parábola armazenada. Etapa 10 completa)

WHILE [# 101 LE 0] DO 1;
(Saia do loop se a borda externa da parábola for atingida. Etapa 11 completa)

# 102 [[# 13 * # 13 * ABS [# 7]] Eu [# 13 * # 13 - # 2 * # 2]];


(Cálculo intermediário)

# 102 = # 101 + # 102;


(Cálculo intermediário)

# 102 [[# 13 * # 13 - # 2 * # 2] Eu ABS [# 7]] * # 102;


(Cálculo intermediário)

# 102 = SQRT [# 102];


(X calculado. Etapa 12 completa)

X # 102 Z # 101;
(Interpolação linear para as coordenadas calculadas. Etapa 13 completa)

# 101 = # 101 + # 100;


(Z incrementado pela distância do passo especificado. Etapa 14 completa)

END 1;
(Fim do loop. Etapa 15 completa)

# 104 = [[# 13 * # 13 - # 2 * # 2] / [2 * # 13 * ABS [# 7]] * 2];


(Cálculo ΔX, correspondente a ΔZ = 2 mm, em Z = 0)

U # 104 W2;
(Movimento tangencial adicional na borda externa da parábola para remover
qualquer possível torção)
G00 X # 105 Z # 106;
(Mover rapidamente para a posição original da ferramenta)

S # 103 F # 9;
(Original rpm e taxa de avanço restaurada)

M99;
(Retorne ao programa de chamada. Etapa 16 completa)

Embora a macro 08018 não tenha a característica de tolerância de acabamento


do G72, ela pode ser facilmente incorporada a ela. Basta subtrair a margem de
acabamento X desejada dos valores X calculados e adicionar a permissão de
acabamento Z aos valores Z calculados, tanto no desbaste como nas
operações de remoção de etapas. Finalmente, a operação de remoção de
etapas seria repetida sem adição / subtração de permissões de acabamento,
com a mesma ferramenta ou ferramenta diferente, se desejado. Também é
possível introduzir mais duas variáveis locais para passar os valores das
tolerâncias de acabamento X e Z para a macro, através do bloco macrocalling.
É deixado como um exercício para os leitores desenvolverem essa macro.

8.5 Transformando uma curva de seno

Considere a peça mostrada na Fig. 8.6, que deve ser usinada a partir de uma
peça de trabalho cilíndrica. A superfície lateral desta parte é definida por uma
curva senoidal. Uma complexidade adicional neste caso é que o diâmetro da
peça não tem aumento ou diminuição monotônica ao longo do comprimento. O
diâmetro aumenta primeiro, depois diminui e aumenta novamente, na direção Z
negativa. Isso dificulta a operação de desbaste do G90 / G94, o que foi feito
com facilidade no exemplo anterior de torneamento parabólico. Assim, a única
maneira é fazer uso do ciclo G73. Na verdade, basta definir a geometria do
perfil entre os números de bloco P e Q de G73. Como discutido anteriormente,
esta técnica não pode ser usada com G71 e G72, porque um loop não pode ter
G-eodes de movimento para definir o perfil para G71 / G72. G73, no entanto,
não tem essa limitação. O único problema, na verdade sério, com o G73 é que
ele é muito ineficiente para esse tipo de trabalho, onde a maior parte do
movimento de alimentação seria no ar, desperdiçando muito tempo. No
entanto, na ausência de um método adequado, deve-se usar o G73 que
produzirá pelo menos a parte correta. Idealmente, o G73 deve ser usado onde
a peça de trabalho já tenha uma forma pré-formada, exigindo uma quantidade
quase igual de remoção de material em todo o seu comprimento, para obter a
forma exata. Em outras palavras, é principalmente adequado para usinagem de
peças fundidas ou forjadas, para as quais nenhum outro ciclo de usinagem
seria tão eficiente. Todo ciclo fixo foi projetado com algum propósito específico.
Estamos usando o ciclo de termos e ciclo fixo de forma intercambiável. De um
modo geral, se um G-eode traz de volta a ferramenta para sua posição inicial
após a usinagem, ela é chamada de ciclo. Se um ciclo também envolve alguns
cálculos, é geralmente referido como um ciclo fixo. Assim, o G90 é um ciclo,
enquanto o G71 é um ciclo fixo. Os manuais do Fanuc, no entanto, referem-se
para todos os ciclos como ciclos fixos. Por essa razão, não estamos
diferenciando os dois termos deste texto. Voltando ao problema original, um
algoritmo para transformar uma curva senoidal é dado abaixo:
1. Coloque a ferramenta no ponto inicial de G73.
2. Comande G73 e coloque a ferramenta no ponto inicial da curva senoidal, isto
é, em X = D e Z = 0.
3. Use a distância de passo axial especificada. E atribua Z = - ΔZ.
4. Se I z I for maior que W, que é I Zmax I, vá para a etapa 9. 5. Calcule X,
usando a equação da curva senoidal:

6. Mova para as coordenadas calculadas por G01.


7. Altere a coordenada Z (Z = Z - ΔZ).
8. Vá para o passo 4.
9. Fim da definição do perfil de G73.
10. Termine em G70 com metade do avanço especificado e duas vezes o
rpm atual, para um melhor acabamento.
11. Retorne ao programa de chamada.

Número do programa 8019, que usa as variáveis locais dadas na Tabela 8.4,
é baseado neste algoritmo.
O alívio axial deve ser mantido como zero no caso considerado, já que o
A geometria da peça requer que não haja deslocamento axial no
passagens de corte de G73 (porque o deslocamento axial resultaria em
interferência entre o percurso e a geometria da peça. De fato, para o
mesma razão, até mesmo a permissão de acabamento Z para o ciclo G73 tem
que

ser mantido zero neste caso). Neste exemplo, os passes de corte são
necessários para mudar apenas na direção radial, para se aproximarem
gradualmente do perfil definido. O relevo radial no presente caso pode ser
escolhido para ser igual à profundidade máxima do "vale" (isto é, igual a 2A).
No entanto, com este alívio radial, a primeira passagem do G73 tocaria apenas
a peça de trabalho em um local onde a peça tenha diâmetro mínimo, sem
remover nenhum material. Como é desejável que o material seja removido
mesmo na primeira passada de corte, o relevo radial deve ser considerado
igual a (2A <profundidade de corte desejada>). Embora a macro 08019 permita
a especificação da profundidade de desbaste, o G73 não usa essa informação
diretamente. Em vez disso, deve-se especificar o número de passes de corte
(palavra-R no primeiro bloco de G73), para o relevo radial / axial escolhido
(palavra-U / palavra-W no primeiro bloco de G73), de forma que a resultante
profundidade de corte é a desejada. Lembre-se de que o G73 compensa o
primeiro passe de corte, em relação ao perfil definido (deslocado pelas
tolerâncias de acabamento, se especificado, ao longo das direções
correspondentes), pelas quantidades de alívio radial e axial especificadas, nas
direções radial e axial, respectivamente. O último passo de corte segue
exatamente o perfil definido (mais tolerâncias de acabamento). Como o número
total de passes é o valor especificado na palavra-R, haveria (<valor-R> -2)
passagens intermediárias. Todos os passes são automaticamente
uniformemente espaçados e aproximam-se do último passe (isto é, o perfil
definido mais os limites de acabamento) gradualmente. Portanto, o
espaçamento entre duas passagens consecutivas determina a profundidade de
corte em um passe. O número necessário de passes (valor R), para garantir
que a profundidade máxima de corte em cada passagem seja igual ou menor
que a profundidade de corte especificada, seria igual a

Como, em geral, essa expressão avaliaria um número real, o próximo número


inteiro (maior) deveria ser especificado como o valor-R. Observe que a
profundidade real de corte no exemplo que está sendo considerado não
permanecerá constante. Variaria entre zero (onde não há corte) e a
profundidade de corte especificada (onde a peça tem diâmetro mínimo).

08019 (girando uma curva sinusal);

# 105 = # 5041;
(Armazena a posição X inicial da ferramenta)

# 106 = # 5042;
(Armazena a posição Z inicial da ferramenta)

GOO X [# 7 + 2 * # 1 + 4] Z2;
(Ferramenta colocada no ponto inicial do ciclo G73, deixando uma distância de
2 mm na direção radial e axial, em relação à peça de trabalho. Etapa 1
completa)

# 100 AB8 [# 17];


(A função ABS aceitaria valores positivos e negativos para a distância do passo
em Z)
G73 U [2 * # 1 - # 18] WO
R [FUP [[[2 * # 1 - # 18] I # 18] + 1]];
G73P1Q2U0.1 WOF # 9; (Subsídio de acabamento X escolhido para ser
0,1 mm)
N1 GOO X [# 7 + 4] ZO;

G01 X # 7 Z0;
(Ferramenta colocada no ponto inicial da curva senoidal. Este movimento foi
dividido em dois movimentos porque a ferramenta aproxima-se da peça de
trabalho ao avanço, e um único movimento de alimentação perderia muito
tempo. Modifique o comando anterior se a profundidade de corte é mais do que
2 mm. Etapa 2 completa)

# 101 = - # 100;
(A primeira mudança de etapa em Z. Etapa 3 completa)

WHILE [AB8 [# 101] LE AB8 [# 23]] DO 1;


(Saia do loop se a curva do seno for definida completamente, ou seja, até Z = -
W. Etapa 4 completa)

# 102 = [# 7 + # 1 * 8IN [360 * AB8 [# 101] Eu AB8 [# 2 3]]];


(X calculado. Passo 5 completo)

X # 102 Z # 101;
(Interpolação linear para as coordenadas calculadas. Etapa 6 completa)

# 101 = # 101 - # 100;


(Z decrementado pela distância do passo especificado. Etapa 7 completa)

END 1;
(Fim do loop. Etapa 8 completa)

N2 X [# 7 + 2 * # 1];
(Fim da definição do perfil. O último segmento, um movimento radial até o
diâmetro inicial da peça, é geralmente dado para garantir uma melhor
superfície usinada no final. No entanto, no presente caso, onde possivelmente
uma ferramenta neutra seria usada, passo pode ser considerado
desnecessário, e pode-se simplesmente escrever N2 END 1. Passo 9
completo)

# 103 = # 4119; (RPM atual armazenado)

G70 P1 Q2 F [# 9 I 2] 8 [# 103 * 2];


(Acabamento por G70. Faça a alteração necessária aqui, caso seja desejada
uma ferramenta diferente para o acabamento. Etapa 10 completa)

GOO X # 105 2 # 106;


(Ferramenta enviada de volta à sua posição original)
F # 9 S # 103;
(O avanço original e a rpm restaurados)

M99;
(Retorne ao programa de chamada. Etapa 11 completa)

Esse macro, para obter a forma da Fig. 8.6, pode ser chamada de uma maneira
tal como

...
G98 G00 X100 Z0;
G65 P8019 D30 W65 A3 Q0. l R0.5 F60;
...

A haste de uma ferramenta de giro à direita provavelmente interferirá na


geometria dessa peça, a menos que o ângulo da ponta seja muito pequeno
(digamos, 35 °), e a amplitude da relação de comprimento da curva senoidal
também seja pequena. Isso requer o uso de uma ferramenta neutra. Se uma
inserção em forma de diamante for usada em uma haste neutra, a borda
quadrada na extremidade esquerda da curva senoidal não pode ser obtida por
este método. (Não haveria corte excessivo na metade do ângulo da ponta no
lado esquerdo.) Não é possível usar uma pastilha redonda, porque ela deve ser
usada com compensação de raio (pois o ponto na ferramenta que corta o
material muda continuamente sua posição) e a compensação de raio não pode
ser usada dentro dos ciclos G71-G73 (o que é uma limitação desses ciclos).

CAPITULO 9
Paramétrica Programação
9.1 Introduction

O termo "programação paramétrica" não está muito claramente definido.


Pessoas diferentes usam isso para significar coisas diferentes. Por exemplo,
algumas pessoas usam isso no sentido em que estamos usando o termo
"programação macro". Eles diriam que Macro Macro Personalizada Fanuc,
Macro Fadal, Tarefa do Usuário Okuma, etc., são as linguagens de
programação disponíveis para programação paramétrica. Por outro lado,
algumas pessoas usam este termo em seu sentido matemático, isto é, para um
programa escrito em termos de parâmetros, que pode ser feito para fazer
coisas diferentes apenas alterando os valores dos parâmetros do programa.
Em outras palavras, a técnica de escrever um único programa para uma família
de peças é chamada de programação paramétrica. Esta definição tem uma
aceitação mais ampla e, portanto, adotada neste texto. A perfuração de
orifícios de parafusos em flanges, com diferentes números de furos, diferentes
profundidades e orientação angular de furos, diferentes diâmetros de afinação,
etc. é um bom exemplo de uma aplicação da técnica de programação
paramétrica. Todos os flanges podem ter dimensões diferentes, mas
características semelhantes. Assim, estes pertencem à mesma família de
partes. Nesses casos, em vez de escrever programas diferentes para flanges
diferentes, é muito melhor escrever um único programa em termos de
parâmetros (variáveis) e chamá-los com os valores desejados para os
parâmetros. Tal programa seria necessariamente uma macro, embora nem
todas as macros possam ser chamadas de programas paramétricos. Por
exemplo, uma macro para um ciclo de perfuração de bicadas projetado pelo
usuário para furos muito profundos, que gradualmente reduz os comprimentos
de sondagem nos bicos subsequentes, não se qualifica para ser chamada de
parâmetros de controle, ou simplesmente parâmetros) que decidem as
configurações padrão de uma máquina. (Se uma alteração em alguma
configuração padrão for necessária, os parâmetros de máquina
correspondentes precisariam ser alterados. Isso geralmente é feito
manualmente, no modo MDI. No entanto, também é possível alterá-los
automaticamente, através de qualquer programa, incluindo um programa
paramétrico. Esta questão é discutida no Capítulo 13.) A parte restante deste
capítulo é dedicada a exemplos de programas paramétricos para máquinas de
torno e fresadoras.

9.2 Pino do Localizador

Considere o pino localizador mostrado na Fig. 9.1. Das sete dimensões que
definem a geometria do pino, apenas duas dimensões são fixas. As cinco
dimensões restantes são dadas em termos de variáveis A, B, C, D e R. Os
valores dessas variáveis são dados na Tabela 9.1, para cinco pinos de
diferentes dimensões. Não há necessidade de escrever cinco
programas diferentes para os cinco pinos. Um único programa paramétrico
08020 produziria todos os cinco tipos de pinos (bem como pinos com quaisquer
outras dimensões, desde que a geometria geral seja a mesma), quando
chamados com os valores desejados para os parâmetros A, B, C, D e R que
correspondem às variáveis locais # 1, # 2, # 3, # 7 e # 18, respectivamente, no
programa 08020. Assim, G65 P8020 AlO B10 C15 D25 R2 produziria o pino
número 1, G65 P8020 A15 B10 C15 D30 R2 produzir o número de pino 2 e
assim por diante.
As seguintes suposições foram feitas durante a gravação da macro:

1. O programa de chamada está no modo milímetro (G21).


2. O diâmetro inicial da peça de trabalho é de 50 mm, para todos os pinos.
3. O ponto zero da peça está no centro da face direita da peça de trabalho. (Na
verdade, todos os programas de torno neste texto assumem o mesmo local
para o ponto zero da peça.)
4. A peça requer uma face de 0,5 mm, em uma passagem. (Um contraponto
não está sendo usado para sustentar a peça de trabalho.) Observe que isso
resultaria na face direita da peça em Z = -0,5 mm, uma vez que Z = 0 é
considerado na face direita da peça de trabalho.
5. O avanço e a velocidade do fuso (ou CSS, a velocidade constante da
superfície no modo G96) no programa de chamada estão corretos e seriam
usados para desbaste. Para o acabamento, o avanço seria reduzido pela
metade e a velocidade do fuso / CSS seria dobrada.
6. O número de ferramenta 1 com o número de correção 1 seria usado para o
desbaste e a ferramenta número 3 com o número de correção 3 seria usada
para acabamento.
7. G71 (Tipo 1) e G70 seriam usados para desbaste e acabamento,
respectivamente.
8. A operação de peça parcial não é necessária (seria feita separadamente,
usando, digamos, G75), para o qual deve ser fornecido comprimento extra de 3
mm no diâmetro maior.

Essas suposições não são realmente uma limitação da macro dada. Sempre é
preciso primeiro decidir o que a macro deve fazer, que é o que foi feito aqui. Se
algumas dessas suposições não forem adequadas em um determinado caso, a
macro precisará ser modificada de acordo. Em geral, modificar em uma macro
é muito mais simples do que gravar uma nova macro. Na verdade, deve-se
sempre começar com um objetivo simples e facilmente alcançável. As
complexidades devem ser incorporadas uma a uma, somente depois que a
macro básica estiver pronta e testada. Tentar desenvolver uma macro
complexa na primeira tentativa é uma fonte de confusão, levando a erros de
programação. Tal programação estilo foi recomendado anteriormente neste
texto. Está sendo reiterado aqui porque é tão importante.
Este não é um exemplo de macro envolvendo uma lógica complexa. Portanto,
um fluxograma ou um algoritmo não é realmente necessário. É recomendado,
no entanto, pelo menos escrever como o caminho da ferramenta deve ser
gerado, o que simplificaria o processo de pensamento:

1. Envie a torre para sua posição inicial e selecione o número de ferramenta 1


com o número de correção 1.
2. Coloque a ferramenta em (X54 Z2) e a face para Z-0.5 usando G94, em uma
única passagem.
3. Coloque a ferramenta em (X50 Z2) e desbaste usando G71, deixando as
necessidades de acabamento adequadas.
4. Envie a torre para sua posição inicial e selecione o número de ferramenta 3
com o número de correção 3.
5. Coloque a ferramenta em (X50 Z2) e termine em G70, com avanço reduzido
e aumento de rpm / CSS, com compensação de raio. (Como é uma ferramenta
de torneamento do lado direito, o número da ponta da ferramenta em um torno
do tipo traseiro seria 3, que deve ser inserido na terceira linha da geometria ou
na tabela de deslocamento do desgaste. O raio da ponta da ferramenta é
inserido na tabela de deslocamento de geometria.)

O perfil definido, que é o mesmo para ambos G71 e G70, é mostrado na Fig.
9.2.
08020 (PIN LOCATOR);

G28 UO;
(X-home)

G28 WO;
(Z-home. O posicionamento separado de X e Z elimina a possibilidade de
qualquer interferência entre a torre em movimento e o corpo da máquina, como
o cabeçote móvel)

T0101;
(Número da ferramenta 1, com o número de correção 1, colocado na posição
de corte. Etapa 1 completa)

GOO Z2;
(Movimento de posicionamento)

X54;
(Ferramenta colocada no ponto inicial de G94. Aqui também, dois movimentos
separados são dados para eliminar a possibilidade de interferência)
(Rotação no sentido horário do fuso começa, na rpm atualmente ativa)

M03;
(Rotação no sentido horário do fuso começa, na rpm atualmente ativa)

M08;
(Refrigerante começa. Normalmente, apenas um código M em uma linha é
permitido)

G94 X-4 Z-0,5;


(O faceamento até abaixo do eixo da peça de trabalho remove qualquer dobra
no centro. Na ausência de uma palavra F, o avanço ativo, no momento de
chamar a macro, seria usado para o revestimento. Etapa 2 completa)

GOO X50 Z2;


(Ferramenta colocada no ponto inicial do ciclo G71. Z2 é redundante neste
comando)

G71 U2 RO. 5;
(Profundidade de corte de 2 mm e retração radial de 0,5 mm escolhida.
Modifique esses valores, se não forem considerados adequados)

G71 P10 Q20 U0.2 W0.1;


(A definição do perfil começa no bloco N10 e termina no bloco N20. As
tolerâncias de acabamento X e Z são de 0,2 e 0,1 mm, respectivamente.
Modifique esses valores, se não forem considerados adequados. Na ausência
de uma palavra F, o avanço anterior seria ser usado para desbaste)

N10 G00 X [# 1 - 9];


(A definição do perfil começa aqui. G71 (Tipo 1) não permite uma palavra Z
neste bloco. Ele usa automaticamente a posição Z atual, para localizar o
primeiro ponto no perfil, ponto Pino Fig. 9.2)

G01 X # 1 Z-2,5;
(Fazendo chanfro)

Z - [# 2 + 0,5- # 18];
(Virando em linha reta no diâmetro menor)

G02 X [# 1 + 2 * # 18] Z - [# 2+ 0,5] R # 18;


(Fazendo filete côncavo)

G01 X [# 7 - 4];
(Voltado para o diâmetro maior)

G03 X # 7 z- [# 2 + 2. 5] R2;
(Fazendo filete convexo)

GO1 Z- [# 3 + 3. 5); (Virar em linha reta no diâmetro maior, proporcionando 3


mm de comprimento extra para a operação de partida)

N20 X54;
(Em linha reta para limpar a peça de trabalho. A definição de perfil termina
aqui, com folga radial de 2 mm da peça de trabalho, que é o ponto Q na Fig. 9
.2. Etapa 3 completa)

G28 UO;
X-home)

G2 8 WO;
(Z-home)

T0303;
(Número de ferramenta 3 com o número de correção 3 selecionado para
acabamento. Etapa 4 completa)

G42 GOO Z2;


(Compensação de raio invocada. Não foi usada antes porque a compensação
de raio é ignorada pelos ciclos fixos, G71-G76)

X50; (Alguns controles exigem que os dois primeiros movimentos, após invocar
a compensação de raio, sejam ao longo dos dois eixos, separadamente, antes
de atingir o ponto inicial do perfil; caso contrário, pode haver algum erro no
posicionamento da ferramenta no ponto inicial. no entanto, um único
movimento de inicialização, como G42 GOO XSO Z2, é suficiente. Aqui, o
principal motivo para dividi-lo em dois movimentos é a prevenção de
interferência)

G70 P10Q20F [# 4109/2] S [# 4119 * 2);


(Acabamento pela metade do avanço atual e duas vezes o rpm / CSS atual.
Modifique se desejado. Etapa 5 completa)

G40 U4 W2;
(Compensação de raio cancelada. Como regra geral, o cancelamento deve ser
acompanhado de movimento de saída adequado, caso contrário a ferramenta
pode se mover na direção da peça durante o cancelamento. Mesmo se a
compensação não for explicitamente cancelada pelo G40, ela será cancelada
automaticamente pelo M30. redefine o controle)

M05;
(O fuso pára)

M09;
(Líquido refrigerante pára)

G28 UO;
(X-home)

G28 WO;
(Z-home)

F [# 4109 * 2] S [# 4119/2];
(O avanço original e o rpm / CSS restaurados)

M99;
(Retornar ao programa de chamada)

Para fazer o pino número 1, essa macro pode ser chamada por um programa
como o abaixo:

G21 G97 G98;


(Mude para G96 para CSS e G99 para avanço em milímetros por revolução)

F60 S1000;
(Especifique o avanço de desbaste e a velocidade do fuso)

G65 P8020 A1 0 B10 C15 D25 R2;

M30;

A macro fornecida pode criar pinos com qualquer dimensão, definida em


termos dos parâmetros A, B, C, D e R. No entanto, se o requisito for criar pinos
apenas dos cinco tipos especificados, e não se espera que o operador se
lembre os significados dos endereços de letra associados e / ou as dimensões
exatas dos pinos, pode-se escrever um programa principal modificado que
produziria o tipo desejado de pino apenas inserindo o número de pino
apropriado no começo do programa. Tal programa pode ser chamado de
programa para uma família de partes, no verdadeiro sentido:

# 100 = 1; (Especifique o número do pino aqui. Também é possível usar uma


variável local como # 1 aqui. Isso seria diferente da variável # 1 usada dentro
da macro, já que as variáveis locais do programa principal e aquelas da macro
chamada por ele pertencem a nível 0 e nível 1, respectivamente)

Eu F [[# 100 LT 1] OU [# 100 GT 5]] ENTÃO # 3000 = 1 (ILEGAL


NÚMERO DO PIN) ;

(Qualquer valor diferente de 1, 2, 3, 4 e 5 seria alarmante, terminando a


execução do programa)

G21 G97 G98;


F60 81000;
SE [# 100 EQ1] GOTO 1 · - (Ramifica em N1 para produzir o pino 1)
SE [# 100 EQ2] GOTO 2 · - (Ramifica em N2 para produzir o pino 2)
SE [# 100 EQ3] GOTO 3; - (Ramifica para N3 para produzir o pino 3)
SE [# 100 EQ4] GOTO 4; - (Ramifica para N4 para produzir o pino 4)
SE [# 100 EQ5] GOTO 5; - (Ramifica para o N5 para produzir o pino 5)

N1 G65 P8020 A10 B10 C5 D25 R2;


(Chamada macro com parâmetros de pin-1)

GOTO 6;

N2 G65 P8020 A15 B10 C15 D30 R2;


(Chamada macro com parâmetros pin-2)

GOTO 6;

N3 G65 P8020 A20 B15 C25 D35 R3;


(Chamada de macro com parâmetros de pin-3)

GOTO 6;

N4 G65 P8020 A25 B15 C25 D40 R3;


(Chamada macro com parâmetros de pin-4)

GOTO 6;

N5 G65 P8020 A30 B20 C35 D45 R4;


(Chamada macro com parâmetros do pin-5)

N6 M30;
9.3 Bolt Holes on a Flange

Consider the flange shown in Fig. 9.3. It can be described in terms of the
following parameters. (The corresponding local variables, as per argument
specification 1, are indicated in brackets.)

X (#24) = X-coordinate of the center of the pitch circle


Y (#25) = Y-coordinate of the center of the pitch circle
Z (#26) =depth of holes
D (#7) =pitch circle diameter
H (#11) =number of holes
S (#19) =start angle (angle of the first hole, with the X-axis)
R (#18) = R-point level for the drilling cycle F (#9) = federate

Para manter as coisas simples, o G81 seria usado para fazer furos, na
velocidade atual do fuso. Os leitores são, no entanto, encorajados a introduzir
variáveis locais adicionais para estes, que está sendo deixado como um
exercício. Para um ciclo de perfuração diferente do G81, informações sobre o
valor de permanência (para G82) ou distância bicuda (para G73 / G83) também
seriam necessárias, necessitando do uso de mais duas variáveis locais para
atribuir valores para estas. Observe que não há nenhum dano em especificar
um valor de pausa ou uma distância de peck para um ciclo fixo que não usa
esses recursos. Ele simplesmente ignoraria esses argumentos. Portanto, o
bloco de blocos canônicos pode ter a mesma lista de argumentos,
independentemente de se referir a G81, G82, G73 ou G83. Embora uma macro
possa ser escrita para usinar um flange com quaisquer valores para os
parâmetros escolhidos, uma família de flanges, como descrito na Tabela 9.2,
seria considerada aqui. Note que X e Y não são realmente os parâmetros de
um flange. Seus valores dependem de como o flange foi fixado na mesa da
máquina, em relação ao sistema de coordenadas de trabalho ativo (G54, GSS,
etc.). Assim, os mesmos valores para estes foram tomados para todos os
flanges, pois estes valores não têm significância em relação ao tipo de flange.
Era necessário incluir essas variáveis em nome da generalidade. Da mesma
forma, o ângulo inicial pode não ter qualquer relevância. Por isso, 0 ° foi
tomado em todos os casos. Foi introduzido para atender a alguns requisitos
especiais. Nós assumiríamos o seguinte (embora não seja difícil relaxar essas
suposições, ele foi deixado como um exercício para os leitores): 1. O programa
de chamada usa coordenadas absolutas (G90). 2. A ferramenta apropriada é
mantida pelo fuso que gira com a rotação correta antes de chamar a macro. 3.
A compensação do comprimento da ferramenta foi incorporada no programa de
chamada.

O algoritmo a seguir pode ser usado para desenvolver uma macro (08021) para
este problema:

1. Defina os argumentos para G81, com KO (com KO, as informações são


armazenadas sem fazer um furo).
2. Calcule o ângulo entre os furos consecutivos, dividindo 360 pelo número de
furos.
3. Defina <contador de furos> = 1.
4. Se o contador de furos for maior que o número de furos, vá para o passo 8.
5. Especifique as coordenadas XY do primeiro furo / próximo. (Isso faria com
que a ferramenta se movesse para as coordenadas especificadas, onde um
furo seria perfurado por G81.)
6. Incrementar o contador de furos em 1.
7. Vá para a etapa 4.
8. Cancele o ciclo fixo.
9. Retorne ao programa de chamada.

08021 (PARAFUSOS EM UMA FLANGE);

G81 Z [ABS [# 26]] R # 18 F # 9 KO;


(Argumentos de G81 especificados. Etapa 1 completa)
# 100 = [360 / # 11];
(Ângulo entre os furos subseqüentes calculados. Um valor negativo para o
número de furos, H, também é permitido para perfurar os furos no sentido
horário. Etapa 2 completa)

# 101 = 1;
(O contador de furos foi inicializado. Seu valor indica o número do furo que será
perfurado em seguida. 1 e # 11 correspondem ao primeiro e último furos,
respectivamente. Etapa 3 completa)

WHILE [# 101 LE ABS [# 11]] DO 1;


(Pule para fora do loop se o contador de furos exceder o número especificado
de furos, ou seja, quando todos os furos tiverem sido perfurados. Etapa 4
completa)

# 102 # 19 + # 100 * [# 101 - 1];


(Calcula a posição angular do primeiro / próximo furo em relação ao eixo X, isto
é, o ângulo de sentido horário subtendido no centro do círculo de inclinação
pela posição onde a próxima perfuração deve ser feita. Um valor negativo para
o início ângulo, # 19, também é permitido)

# 103 # 24 + [# 7 I 2] COS [# 102];


(Coordenada X do primeiro / próximo furo calculado)

# 104 # 25 + [# 7/2] SIN [# 102];


(Coordenada Y do primeiro / próximo furo calculado)

X # 103 Y # 104;
(Primeiro / próximo buraco perfurado por G81 que está atualmente ativo.
Enquanto não for cancelado por, digamos, G80, todo deslocamento de eixo
faria com que um buraco fosse perfurado na nova posição, usando G81. Passo
5 completo)

# 101 = # 101 + 1;
(Contador de furos incrementado em 1, para perfurar o próximo furo. Etapa 6
completa)

END 1;
(Fim do loop atual. Salta para o bloco WHILE, para verificar a condição de
execução do próximo loop. Etapa 7 completa)

G80;
(G81 cancelado. Um ciclo fixo é cancelado também pelo grupo 1 G-eodes,
como GOO e G01. Etapa 8 completa)

M99;
(Retorne ao programa de chamada. Etapa 9 completa)
Se alguns traps de erro forem desejados para serem adicionados à macro,
insira os seguintes blocos no início do programa:

SE [# 24 EQ # 0] ENTÃO # 3000 = 1 (PCD CENTER X NÃO ESPECIFICADO);


SE [# 25 EQ # 0] ENTÃO # 3000 = 2 (PCD CENTER Y NÃO ESPECIFICADO);
SE [# 26 EQ # 0] ENTÃO # 3000 = 3 (PROFUNDIDADE DO FURO NÃO
ESPECIFICADA);
SE [# 7 EQ # 0] ENTÃO # 3000 = 4 (PCD NÃO ESPECIFICADO);
SE [# 11 EQ # 0] ENTÃO # 3000 = 5 (NO. DE FUROS NÃO
ESPECIFICADOS);
SE [# 19 EQ # 0] ENTÃO # 3000 = 6 (INICIAR O ÂNGULO NÃO
ESPECIFICADO);
SE [# 18 EQ # 0] ENTÃO # 3000 = 7 (PONTO R NÃO ESPECIFICADO);
SE [# 9 EQ # 0] ENTÃO # 3000 = 8 (FEEDRATO NÃO ESPECIFICADO);

Para fazer o flange número 1, essa macro pode ser chamada por um programa
como o abaixo:

G21 G94;
(Mude para G20 para modo de polegada e G95 para avanço de avanço por
revolução)

G91 G28 ZO;


(Revista de ferramentas enviada para a posição inicial, para troca de
ferramenta)

G28 XO YO;

M06 T01;
(Ferramenta desejada colocada no fuso)

G90;
(Modo de coordenada absoluta selecionado)

GOO XO YO;
(Posicionamento XY. Especifique diferentes valores de coordenadas, se
necessário, por exemplo, quando o centro do círculo de afinação está muito
longe do datum XY)

G43 H01 Z50;


(Compensação do comprimento da ferramenta invocada. Ferramenta colocada
em Z = 50 mm. Define o nível Z inicial para G81)

M03 S1000;
(Especifique a velocidade apropriada do fuso CW)
M08;
(Refrigerante começa)

G65 P8021 X150 Y100 Z5 D50 H4 SO R1 F60;

M09;
(Líquido refrigerante pára)

M30;

A próxima tarefa é modificar o programa de chamada para que o tipo desejado


de flange seja produzido apenas especificando seu número no início do
programa. Isso evitaria a necessidade de se referir à tabela de desenho / dados
para obter as dimensões de diferentes flanges. Além disso, não haveria
necessidade de entender o significado de cada endereço de letra no bloco
G65. Tal programa, com uma provisão adicional para especificar valores para
as coordenadas do centro do círculo de arremesso e o ângulo de início (desde
que os valores dados na Tabela 9.2 podem não se aplicar em todos os casos),
é dado abaixo:

# 100 = 1;
(Especifique o número do flange)

# 101 = 150; (Especifique a coordenada X do centro do círculo de afinação.


Uma maneira de determinar o valor é mover manualmente o fuso até o centro
desejado do círculo de afinação e depois ler o display de coordenadas)

# 102 = 100;
(Especifique a coordenada Y do centro do círculo de piche)

# 103 = 0;
(Especifique o ângulo inicial)

SE [[# 100 LT 1] OU [# 100 GT 5]] ENTÃO # 3000 = 1


(NÚMERO DE FLANGE ILEGAL);

(Qualquer valor diferente de 1, 2, 3, 4 e 5 seria alarmante, terminando a


execução do programa)

G21 G94;

G91 G28 ZO;

G28 XO YO;

M06 T01;
(Modifique T01 se um número de ferramenta diferente de 1 for usado)
G90;

GOO X # 101 Y # 102;


(Posicionamento XY no centro do círculo de piche)

G43 H01 Z50;


M03 51000;
M08;

SE [# 100 EQ 1] GOTO 1; (Ramifica para N1 para produzir flange 1)


SE [# 100 EQ 2] GOTO 2; (Ramifica para N2 para produzir flange 2)
SE [# 100 EQ 3] GOTO 3; (Ramifica para N3 para produzir flange 3)
SE [# 100 EQ 4] GOTO 4; (Ramifica para N4 para produzir flange 4)
SE [# 100 EQ 5] GOTO 5; (Ramifica para N5 para produzir flange 5)

N1 G65 P8021 X # 101Y # 102 Z5 D50 H4 5 # 103 R1 F60;


(Chamada macro com parâmetros de flange-1)

GOTO 6;

N2 G65 P8021 X # 101 Y # 102 Z10 0100 H6S # 103 R1 F50;


(Chamada macro com parâmetros de flange-2)

GOTO 6;

N3 G65 P8021 X # 101 Y # 102 Z15 0150 H8S # 103 R1,5 F40;
(Chamada macro com parâmetros de flange-3)

GOTO 6;

N4 G65 P8021 X # 101 Y # 102 Z20 0200 H10S # 103 R2 F30;


(Chamada macro com parâmetros de flange-4)

GOTO 6;

N5 G65 P8021 X # 101 Y # 102 Z20 0300 H12S # 103 R2 F30;


(Chamada macro com parâmetros de flange-5)

N6 M09;

M30;

Os leitores devem observar os estilos de programação adotados em 08020 e


08021. 08020 inclui a maioria dos comandos relacionados à configuração
(como troca de ferramentas), exigindo muito poucos deles no programa de
chamada. Por outro lado, o 08021 não possui nenhum desses comandos, o
que requer que eles sejam inseridos no programa de chamada. O primeiro
estilo é considerado melhor, desde que a macro seja flexível o suficiente
usando variáveis locais para controlar sua ação. Por exemplo, uma limitação de
08020 é que ele sempre usará T0101 para desbaste e T0303 para
acabamento. Se alguma outra ferramenta / número de deslocamento for
desejada, a macro precisará ser modificada, o que não é considerado uma boa
prática. Geralmente, os macros são escritos por programadores especialistas e
são protegidas por edição por meio de parâmetros. Portanto, variáveis locais
para números de ferramentas de desbaste e acabamento deveriam ter sido
adicionadas na lista de argumentos. Por outro lado, embora vários comandos
de configuração sejam necessários para chamar 08021, essa macro pode ser
usado em diferentes condições de corte, sem qualquer modificação nela. Toda
abordagem tem suas próprias vantagens e limitações. É basicamente uma
questão de escolha individual e requisitos específicos.

CAPITULO 10
Personalizado em lata Ciclos

10.1 Introdução

Já foi discutido na Sec. 7.3 (subseção Chamar com o Código G UserDefined)


como um novo G-eode pode ser definido ou um existente pode ser redefinido.
O objetivo básico de definir um novo G-eode, em vez de usar uma chamada de
macro G65 / G66, é que não é necessário saber nada sobre programação
macro para poder chamar uma macro. O Geode definido chamaria uma macro
sem usar o G65 / G66. Ele pode ser usado da mesma forma que um ciclo fixo
predefinido, como G71 em um torno, é usado, com a diferença de que o G-
eode definido como definido sempre seria um código de bloco único. Na
verdade, todos os ciclos fixos internos chamam internamente apenas algumas
macros predefinidas, sem que percebamos isso. Só é necessário saber o
significado de diferentes endereços de letras nesses códigos. O novo G-eode
também pode ser usado da mesma maneira. Assim, de certa forma, aprimora
os recursos de controle padrão, disponibilizando alguns G-eodes extras para
algumas aplicações complexas de usinagem. Até 10 novos G-eodes podem ser
definidos (incluindo G-eodes redefinidos). Pode haver situações em que
nenhum padrão G-eode seria bastante adequado. Uma furação profunda,
exigindo perfuração profunda com comprimentos progressivamente reduzidos,
é um desses exemplos em uma fresadora. Da mesma forma, em um torno,
G74 está disponível para perfuração profunda, mas a ferramenta não se retrai
para fora do furo, após um passo. Isso pode dificultar a perfuração de furos
profundos. Além disso, alguns dos G-eodes, como a interpolação helicoidal,
estão disponíveis como opções, que precisam ser adquiridas adicionalmente.
Em todos esses casos, pode ser possível definir / redefinir o G-eode para se
adequar à aplicação particular. Dois exemplos, um para um torno e um para
uma fresadora, são discutidos a seguir.
10.2 Perfuração Profunda em um Torno Mecha

A pecking ação do ciclo G74 padrão em um torno é mostrada na Fig. 10.1. O


G74 é projetado para perfurar orifícios profundos, mas não funciona
satisfatoriamente quando o buraco é muito profundo, porque apesar de quebrar
as aparas, ele não as limpa. Embora isso não cause qualquer problema com
uma broca de refrigeração, é provável que resulte na redução da vida útil da
ferramenta devido ao entupimento e à privação de refrigerante, se forem
usadas brocas sólidas. O G74 é, de fato, o equivalente do G73 em uma
fresadora, com limitações semelhantes. Enquanto o G83 está disponível em
uma fresadora, que limpa os cavacos retraindo-se para fora do furo (até o
ponto-R) após cada passo, normalmente ele está disponível em um torno
somente se ele tiver ferramentas ao vivo. Portanto, é desejável ter um G-eode
definido pelo usuário em um torno, que retrai a ferramenta para fora do furo
após cada passo. O caminho da ferramenta desejado é mostrado na Fig. 10.2,
onde o número do código G174 foi escolhido especialmente para indicar que é
uma versão modificada do G74. De fato, é por essa razão que o comprimento
do peck em G174 foi mantido em mícrons, não em milímetros. Isso garante que
as palavras Z, Q e F de ambos os ciclos tenham os mesmos significados.
Assim, ambos G74 e G174 podem ser usados da mesma maneira, exceto que
G174 teria um primeiro bloco "ausente". Qualquer programador seria capaz de
usar o G174, como se fosse um ciclo fixo embutido do controle, sem se
preocupar com a forma como foi disponibilizado na máquina. E então, se o
programador nunca tivesse ouvido falar sobre programação de macro! Nossa
próxima tarefa é definir um tal G-eode. Referindo-se à Tabela 7.1, 174
precisaria ser armazenado no parâmetro número 6051 (digamos), enquanto a
macro correspondente 09011 deveria gerar o caminho da ferramenta desejado,
como mostrado na Figura 10.2, para o qual o seguinte algoritmo pode ser
usado:

1. Armazene a posição Z inicial.


2. Calcule <profundidade necessária>. (Perfuração para ser iniciado a partir da
posição Z inicial.)

3. Se <profundidade exigida> for menor ou igual a Q, vá para a etapa 15.


4. Perfure na velocidade de avanço especificada até a profundidade Q a partir
da posição inicial.
5. Guarde a posição Z atual.
6. Defina <profundidade exigida> = <profundidade exigida> - Q
7. Retraia rapidamente para a posição inicial.
8. Se <profundidade exigida> for menor ou igual a Q, vá para o passo 17.
9. Movimento rápido até 1 mm antes da posição Z no final do passo anterior.
10. Alimente o movimento para aumentar a profundidade existente do furo em
Q.
11: Armazene a posição Z atual.
12. Recue rapidamente para a posição inicial.
13. Defina <profundidade exigida> = <profundidade exigida> - Q
14. Vá para o passo 8.
15. Movimento de avanço único e contínuo até a profundidade final.
16. Vá para o passo 18.
17. Perfure a profundidade necessária, com movimento rápido de até 1 mm
antes da profundidade perfurada anterior, seguida pelo movimento de avanço
para chegar ao fundo do furo.
18. Recue rapidamente para a posição inicial.
19. Retorne ao programa de chamada.

A Macro 09011, que é baseada no algoritmo fornecido, também inclui algumas


armadilhas de erro no início do programa, para detectar certas formas
incorretas de chamá-lo. Esta macro perfura o furo usando a velocidade do fuso
usada no programa de chamada, pela ferramenta existente no fuso, como é
feito pelo G74. A macro é, no entanto, projetada para ser chamada com um
avanço desejado. Se um avanço não for comandado durante a chamada da
macro, a velocidade de avanço ativa no programa de chamada, no momento
de chamar a macro, seria usada para perfuração. A profundidade do furo pode
ser comandada tanto na forma absoluta (palavra Z) quanto na forma
incremental (palavra W), embora a especificação simultânea dos dois não seja
permitida (o que seria alarmante). Finalmente, a macro não exige que o dado Z
esteja necessariamente na face direita da peça de trabalho. A posição axial do
furo desejado não é de todo restringida pelo dado Z. O buraco inteiro pode
estar à direita ou à esquerda do dado Z, ou pode até ter um dado Z em algum
lugar dentro dele. A letra endereça no bloco de macro-chamada (as variáveis
locais correspondentes, conforme especificação de argumento 1, são dadas
entre parênteses), e as variáveis comuns usadas nesta macro são

Z (# 26) = coordenada Z absoluta da parte inferior da o buraco


W (# 23) = coordenada Z incremental do fundo do buraco (medido a partir da
posição inicial da ferramenta)
Q (# 17) = comprimento do pique (em microns, no modo milímetro)
F (# 9) = velocidade de avanço

# 100 = armazena a coordenada Z da posição inicial da ferramenta


# 101 = armazena <a profundidade requerida> (a profundidade restante a ser
perfurada), que é atualizada depois de cada passo
# 102 = armazena a coordenada Z ao final de um passo, daí também é
atualizado após cada peck

09011 (PERFURAÇÃO DE FURO PROFUNDO NO TORNO);

IF [# 17 EQ # 0] ENTÃO # 3000 1
(PECK LENGTH NOT ESPECIFICADAS);

IF [[# 23 EQ # 0] E [# 26 EQ # 0]] ENTÃO # 3000 = 2


(PROFUNDIDADE NÃO ESPECIFICADAS);

IF [[# 23 NE # 0] E [# 26 NE # 0]] ENTÃO # 3000 = 3


(AMBOS AND W ESPECIFICADO);

IF [[# 26 NE # 0] E [# 5042 LE # 26]] ENTÃO # 3000 4


(POSIÇÃO INICIAL INCORRETA);

IF [# 23 GT 0] ENTÃO # 3000 = 5
(W DEVE SER NEGATIVO);

IF [[# 26 EQ # 0] E [# 23 EQ 0]] ENTÃO # 3000 = 6


(ZERO DEPTH ESPECIFICADAS);

IF [# 9 EQ # 0] ENTÃO # 9 = # 4109;
IF [# 9 EQ 0] ENTÃO # 3000 = 7
(FEEDRATE NÃO ESPECIFICADO);
(Alarmes se entradas incorretas forem especificadas)

# 100 = # 5042;
(Posição Z inicial armazenada. Etapa 1 completa)

# 101 = # 5042 - # 26;


(Calcula a profundidade necessária quando Z é especificado)

SE [# 23 NE # 0] ENTÃO # 101 = ABS [# 23];


(Calcula a profundidade necessária quando W é especificado. Etapa 2
completa)

# 17 ABS [# 17] / 1000;


(Comprimento do Peck em mícrons convertido para milímetros. Ambos os
valores positivos e negativos para o comprimento do peck permitido. O bicar
sempre seria feito na direção Z negativa)

SE [# 101 LE # 17] GOTO 10;


(Se a profundidade exigida for Jess igual ou igual ao comprimento do salto
especificado, pule para o bloco N10 para perfurar o buraco sem bicar. Etapa 3
completa)

G01 W- # 17 F # 9;
(Perfuração realizada até o comprimento do peck especificado, medido a partir
da posição Z inicial. Etapa 4 completa)

# 102 = # 5042;
(Posição Z atual armazenada. Etapa 5 completa)

# 101 = # 101 - # 17;


(Profundidade necessária atualizada. Etapa 6 completa)

GOO Z # 100;
(Retração rápida para a Zposition inicial. Etapa 7 completa)

WHILE [# 101 GT # 17] DO 1;


(Perfuração em um loop. Se a profundidade necessária ficar menor ou igual ao
comprimento do peck especificado, saia do loop. Etapa 8 completa)

GOO Z [# 102 + 1];


(Movimento rápido até 1 mm à direita da posição Z no final do passo anterior.
Passo 9 completo)

G01 Z [# 102 - # 17];


(Movimento de avanço para aumentar a profundidade pelo comprimento do
passo especificado. Etapa 10 completa)
# 102 = # 5042;
(Posição Z atual armazenada. Etapa 11 completa)

G00 Z # 100;
(Retração rápida para a Zposition inicial. Etapa 12 completa)

# 101 = # 101 - # 17;


(Profundidade necessária atualizada. Etapa 13 completa)

END 1;
(Salte para o bloco WHILE para verificar novamente a condição do loop. Etapa
14 completa)

GOTO 20;
(Ir para N20 para perfurar a profundidade restante)

N10 G01 W- # 101 F # 9;


(Movimento de avanço único para atingir a profundidade final. Etapa 15
completa)

GOTO 30;
(Ir para N30 para retrocesso rápido e retornar ao programa de chamada. Etapa
16 completa)

N20 GOO Z [# 102 + 1];


(Movimento rápido até 1 mm antes da profundidade perfurada anterior)

G01 Z [# 102 - # 101];


(Profundidade restante perfurada. Etapa 17 completa)

N30 GOO Z # 100;


(Retração rápida para a Zposition inicial. Etapa 18 completa)

M99;
(Retorne ao programa de chamada. Etapa 19 completa)

Esta macro foi projetada para ser usada no modo milimetrado. No entanto, é
muito fácil modificá-lo para torná-lo adequado para o modo milímetro (G21) e o
modo polegada (G20). No modo de polegada, a quantidade de folga de 1 mm
(consulte a Fig. 10.2) precisaria ser substituída por 0,04 pol. Para isso,
substitua o valor de folga (1) por uma nova variável, digamos, # 103, em toda a
macro ( há duas ocorrências desse tipo). Leia a variável do sistema # 4006
para descobrir se o G20 ou G21 está ativo. Se # 4006 contiver 20, defina # 103
como 0,04 e, se # 4006 contiver 21, defina # 103 como 1, no início da macro.
No modo inch, o divisor 1000 também precisaria ser substituído por 10.000, no
bloco que redefine # 1 7. A modificação necessária no programa foi deixada
como um exercício para os leitores.
Em termos de estrutura, a macro 09011 não é diferente de outras macros.
Pode ser chamado, da maneira usual de chamar uma macro, por

G65 P9011 Z I W_ Q_ F_; or


G65 P9011 Z I W_ Q_ ;

No entanto, também define G174 se 174 é armazenado no parâmetro 6051,


conforme já mencionado. Nesse caso, G174 ... seria equivalente a G65 P9011
... Para ilustrar o uso do novo G-eode (G174), considere a parte mostrada na
Fig. 10.3. Para usiná-lo com G174, basta preparar um programa para G74 e
substituir G74 por G174 (como é simples!). O bloco correspondente é mostrado
em negrito, para fácil identificação:

G21 G97 G98;


G28 UO;
G28 WO;
T0101;

G00 Z12;
X0;
M03 S1OOO;
M08;
G174 Z-20 Q5000 F20;
(ou, G17 4 W-32 Q5000 F20);
M09;
M05;
G28 U0;
G28 W0;
M30;

Observe que a forma cônica na parte inferior do furo é causada pelo ângulo da
ponta da broca. Usando relações trigonométricas, pode-se mostrar que, para
um dado diâmetro de ferramenta D e ângulo de ponta 8, a altura h do cone é
dada por
Para o ângulo de ponta usual de 119 °, esta equação é simplificada para

h = 0,3D

Assim, para obter um furo cilíndrico de um certo comprimento, com uma broca
de 10 mm de diâmetro, deve-se acrescentar 3 mm ao comprimento cilíndrico
desejado. Assim, na Fig. 10.3, o comprimento da porção cilíndrica seria de
cerca de 27 mm, se o diâmetro da ferramenta for de 10 mm.

Isso completa a discussão sobre como definir um novo G-eode em um torno.


Também é possível redefinir um G-eode existente para adicionar certos
recursos desejáveis a ele. Por exemplo, comandar G01 com velocidade de fuso
muito baixa provavelmente será um erro de programação. (Como você pode
maquinar a menos que o fuso esteja girando em uma velocidade razoável?)
Portanto, pode ser desejável que comandar G01 com uma velocidade de fuso
muito baixa interrompa a execução do programa, e espere por uma
confirmação do operador (pressionando CYCLE START novamente ), para
continuar a execução. Da mesma forma, comandar X e U (ou Z e W) no
mesmo bloco não tem sentido e deve ser alarmado. A modificação necessária
no G01 pode ser feita da seguinte maneira:

SE [[# 24 NE # 0) E [# 21 NE # 0]) ENTÃO 3000 = 1 (AMBOS X


E U ESPECIFICADO);

SE [[# 26 NE # 0) E [# 23 NE # 0]) ENTÃO 3000 = 2 (AMBOS


AND W ESPECIFICADO);

SE [# 9 EQ # 0] ENTÃO # 9 = # 4109;

SE [# 1 9 EQ # 0] ENTÃO # 19 = # 4119;

F [[# 19 LT 100) E [# 4002 EQ 97)) ENTÃO # 3006 = 1 (ESTÃO BAIXAS RPM


OK);

SE [[# 19 LT 10] E [# 4002 EQ 96)) ENTÃO # 3006 = 1 (IS LOW CSS OK);

G01 X # 24 U # 21 Z # 26 W # 23 F # 9 S # 19;

É deixado como um exercício para os leitores interpretarem os blocos de


programa dados e completarem este exercício editando um parâmetro entre
6050-6059 (armazenando 1 nele) e definindo o número do programa
correspondente entre 09010-09019. Lembre-se que um G-eode, dentro de uma
macro chamada pelo mesmo ou por um G-eode diferente (diferente de G65 /
G66), é tratado como o padrão G-eode predefinido, com a função usual. Assim,
o GO1 dentro da macro chamada por G01 seria considerado apenas
interpolação linear; não chamaria a mesma macro novamente, formando um
loop infinito. Note que os valores mínimos escolhidos para rpm e CSS (100 e
10m / min, respectivamente) são arbitrários. Especifique valores adequados
para aplicativos específicos. Além disso, apenas verificar o valor S não
confirma que M03 ou M04 foi comandado para iniciar o fuso! De fato, não há
como determinar se o fuso está girando ou não através de um programa. A
variável de sistema para o código M (# 4113) armazena o último número de
código M comandado. Por exemplo, se M08 for comandado após M03, # 4113
conteria 8. Portanto, para estar no lado mais seguro, pode-se tender a
comandar M03 ou M04 na macro, mas isso também não é infalível, porque
apenas um dos dois seria ser adequado em uma configuração de máquina
específica (seja torno frontal ou traseiro e fixação de ferramenta normal ou
invertida), que o programador de macros só pode adivinhar. Assim, a discussão
sobre a verificação da velocidade do fuso na macro, praticamente permanece
apenas teórica, embora seja um bom exercício de programação. Deve-se
conhecer as capacidades, bem como as limitações da programação de macros.
Além disso, tente tornar a macro adequada para o modo polegada também.

10.3 Perfuração com Comprimentos Reduzidos de Peck em um


Fresadora

G73 e G83 são os dois ciclos de sondagem disponíveis nas fresadoras. G73 é
um ciclo de perfuração rápido de alta velocidade, usando uma retração muito
pequena após cada passo. É usado quando o buraco não é muito profundo.
G83 retrai a ferramenta para o ponto R depois de cada passo. Isso limpa
completamente os cavacos, tornando o ciclo adequado para furos profundos.
Se, no entanto, o buraco for muito profundo, a falta de refrigerante se torna um
problema depois de alguns beijos. A única solução é usar picos de
comprimentos gradualmente reduzidos, por um fator desejado. Tal ciclo de
perfuração é também referido como um ciclo regressivo de perfuração
profunda. Infelizmente, o controle Fanuc não fornece um ciclo regressivo de
peck-drilling integrado. Portanto, caso seja realmente necessário, seria
necessário escrever uma macro para isso. Melhor ainda, um novo G-eode
(digamos, G183 que indica um G83 modificado) pode ser definido para ele.
Para isso, 183 precisaria ser armazenado, digamos, no parâmetro 6052,
enquanto o programa correspondente 09012 deveria gerar o caminho da
ferramenta desejado, como mostrado na Fig. 10.4. O algoritmo para a macro
09012 geralmente seria similar ao usado para a macro 09011, com a principal
diferença de que o comprimento do peck precisaria ser calculado antes de
cada peck:

1. Armazene a posição Z inicial.


2. Movimento rápido para a posição XY (o centro do buraco).
3. Movimento rápido para o ponto R.
4. Calcule <profundidade necessária> (perfuração a ser iniciada a partir do
ponto-R).
5. Se <profundidade exigida> for menor ou igual a Q, vá para a etapa 20. 6.
Perfure na velocidade de avanço especificada até a profundidade Q a partir do
ponto R. 7. Guarde a posição Z atual.
8. Defina <profundidade exigida> = <profundidade exigida> - Q.
9. Retraia a uma taxa rápida para o ponto R.
10. Se <profundidade exigida> for menor ou igual a M ou o novo comprimento
de passo (que é igual ao comprimento da ponta anterior multiplicado pelo fator
de regressão I), vá para a etapa 18.
11. Calcule o novo comprimento do peck. Se ele for menor que M, configure-o
igual a M.

FIGURA 10.4 Ciclo Regressivo de Peck-Drilling em uma Fresadora.

Nota:

1. A sintaxe do G 183, um ciclo regressivo de peck-drilling em uma fresadora,


pode ser
G 183 X_ S Z_ R_ Q_ I_ M_ F;
Onde:
X, Y é a localização do buraco,
Z é a profundidade do buraco
R é o nível do ponto A,
Q é o primeiro comprimento do beijo
1. é o fator de regressão,
M é o comprimento mínimo e
F é a taxa de alimentação.
2. A ferramenta primeira se move para o ponto XY (eixo do furo) e, em seguida,
para o ponto A, no atravessar rápido, após o qual a furação é iniciada. O
caminho da ferramenta projetado é o mesmo do ciclo G83 padrão, exceto que
os comprimentos de pica-pau subsequentes são reduzidos pelo fator de
regressão (Q → Q x I, Q → I x I e assim por diante).
3. Todas as bicadas e retrações estão ao longo do eixo do furo. Na figura,
estas são mostradas separadamente para maior clareza.
4. Se um comprimento calculado do peck for menor do que o comprimento
mínimo do peck especificado, este, bem como todos os comprimentos de peck
subsequentes, são fixados ao valor mínimo especificado.
5. Todos os movimentos para fora (retrações) são movimentos rápidos.
6. Cada movimento de perfuração é rápido até 1 mm antes da profundidade
previamente reduzida, após o que o movimento de avanço é iniciado, para
aumentar a profundidade pelo comprimento de passo calculado.
7. O passo continua até que o fundo do buraco seja alcançado. Posteriormente,
a ferramenta se retrai para o ponto A ou o nível Z inicial. O último passo teria
um movimento ajustado, para se adequar à profundidade especificada.

Corresponde a FIG 10.4 Ciclo Regressivo de Peck-Drilling em uma Fresadora.

12. Movimento rápido até 1 mm acima da posição Z no final do passo anterior.


13. Alimente o movimento para aumentar a profundidade de furo existente pelo
novo comprimento do passo.
14. Guarde a posição Z atual.
15. Recue rapidamente a um ponto R.
16. Defina <profundidade exigida> = <profundidade exigida> - <comprimento
de pico atual>.
17. Vá para o passo 10.
18. Perfure a profundidade necessária, com movimento rápido até 1 mm acima
da profundidade perfurada anterior, seguido pelo movimento de avanço para
alcançar o fundo do furo.
19. Vá para o passo 21.
20. Movimento de alimentação única e contínua até a profundidade final.
21. Retraia rapidamente para o ponto R se G99 estiver ativo, ou a posição Z
inicial se G98 estiver ativo.
22. Retorne ao programa de chamada.

As variáveis locais e comuns usadas nesta macro são dadas abaixo (todas as
coordenadas estão no modo de coordenadas absolutas, G90):

X (# 24) = coordenada X do centro do furo


Y (# 25) = coordenada Y do centro do buraco
Z (# 26) = coordenada Z do fundo do buraco
R (# 18) = coordenada Z do ponto R
Q (# 17) = comprimento do primeiro peck
I (# 4) = fator de regressão (tal que qualquer comprimento de peck
subsequente é igual ao comprimento de peck anterior multiplicado pelo fator de
regressão. Assim, I = 1 corresponde a comprimentos de peck constantes)
M (# 13) = comprimento mínimo de peck
F (# 9) = velocidade de avanço # 100 = armazena a coordenada Z da posição
inicial da ferramenta # 101 = armazena <profundidade exigida> (a profundidade
restante a ser perfurada), que é atualizada após cada passo # 102 = armazena
a coordenada Z em o final de um peck, portanto, isso também é atualizado
após cada peck # 103 = comprimento atual do peck (calculado como seu valor
anterior multiplicado por # 4)

09012 (PESCOÇO REGRESSIVO NO MOINHO M / C);

SE [# 24 EQ # 0] ENTÃO # 3000 1 (ESPECIFIQUE FURO X-COORDENADO);


SE [# 25 EQ # 0] ENTÃO # 3000 2 (ESPECIFIQUE A COORDENADA Y DO
FURO); SE [# 26 EQ # 0] ENTÃO # 3000 = 3 (ESPECIFIQUE A
PROFUNDIDADE DO FURO);
SE [# 18 EQ # 0] ENTÃO # 3000 = 4 (ESPECIFIQUE O PONTO-R);
SE [# 17 EQ # 0] ENTÃO # 3000 5 (ESPECIFIQUE PRIMEIRO
COMPRIMENTO PECK); SE [# 13 EQ # 0] ENTÃO # 3000 6 (ESPECIFIQUE
COMPRIMENTO MÍNIMO DE PECK);
SE [# 4 EQ # 0] ENTÃO # 3000 7 (ESPECIFIQUE O FATOR DE
REGRESSÃO); SE [# 9 EQ # 0] ENTÃO # 9 # 4109;
SE [# 9 EQ 0] ENTÃO # 3000 = 8 (ESPECIFIQUE FEEDRATE);
(Alarma se entradas estão faltando)

# 100 = # 5043;
(Posição Z inicial armazenada. Etapa 1 completa)

GOO X # 24 Y # 25;
(Travessia rápida até o centro do furo. Etapa 2 completa)

Z # 18;
(Travessia rápida até o ponto R.. Etapa 3 completa)

# 101 = # 18 - # 26;
(Calcula a profundidade necessária. Etapa 4 completa)

SE [# 101 LE 0] ENTÃO # 3000 = 9 (R IMPROPEDIDO OU Z


ESPECIFICADO);

# 17 = ABS [# 17];
(Ambos os valores positivos e negativos para o primeiro comprimento do bico
permitido. O registro sempre seria feito na direção Z negativa)

# 13 ABS [# 13];
(Valores positivos e negativos para o comprimento mínimo permitido)

SE [# 101 LE # 17] GOTO 10;


(Se a profundidade requerida for menor ou igual ao primeiro comprimento do
pique, pule para o bloco NlO para perfurar o buraco sem bicar. Etapa 5
completa)

G01 Z [# 18- # 17] F # 9;


(Perfuração realizada até o primeiro comprimento do peck, medido a partir do
ponto R. Etapa 6 completa)

# 102 = # 5043;
(Posição Z atual armazenada. Etapa 7 completa)

# 101 = # 101 - # 17;


(Profundidade necessária atualizada. Etapa 8 completa)

GOO Z # 18;
(Retração rápida para o ponto-R. Passo 9 completo)

# 103 = # 17;
(Comprimento atual do bico inicializado)

WHILE [[# 101 GT # 13] E [# 101 GT [# 103 * # 4]]] DO 1; (Perfuração em um


loop. Se a profundidade necessária ficar menor ou igual ao comprimento
mínimo do peck ou o novo comprimento do peck, saia do loop. Etapa 10
completa)

# 103 = # 103 * # 4;

SE [# 103 LT # 13] ENTÃO # 103 # 13;


(Novo comprimento de peck calculado. Passo 11 completo)

G00 Z [# 102 + 1];


(Movimento rápido até 1 mm acima da posição Z no final do passo anterior.
Etapa 12 completa)

G01 Z [# 102 - # 103];


(Movimento de avanço para aumentar a profundidade pelo comprimento
calculado do passo. Etapa 13 completa)

# 102 = # 5043;
(Posição Z atual armazenada. Etapa 14 completa)

G00 Z # 18;
(Retração rápida para o ponto R.. Etapa 15 completa)

# 101 = # 101 - # 103;


(Profundidade necessária atualizada. Etapa 16 completa)
END 1;
(Salte para o bloco WHILE para verificar novamente a condição do loop. Etapa
17 completa)

GOO Z [# 102 + 1];


G01 Z # 26;
(Profundidade restante perfurada. Etapa 18 completa)

GOTO 20;
(Pule para N20 para a retração final. Etapa 19 completa)

N10 G01 Z # 26 F # 9;
(Movimento de avanço único para atingir a profundidade final. Etapa 20
completa)

N20 GOO Z # 18;


(Recua para o ponto-R)

SE [# 4010 EQ 99] GOTO 30;


(Pula para o final do programa se o G99 estiver ativo)

GOO Z # 100;
(Recua para o nível Z inicial, se o G98 estiver ativo. Etapa 21 completa)

N30 M99;
(Retorne ao programa de chamada. Etapa 22 completa)

A macro fornecida usa o modo milímetro e pode ser chamada apenas no modo
de coordenada absoluta. Embora seja fácil torná-lo adequado para o modo
polegadas também, seria necessário um pouco mais de esforço para usá-lo no
modo de coordenadas incrementais (G91). Isso está sendo deixado como um
exercício para os leitores. Para ilustrar o uso desta macro, considere a parte
mostrada na Fig. 10.5, onde é assumido que os furos são tão profundos (isto é,
com uma grande relação comprimento-diâmetro) que estes requerem o uso de
ciclo de perfuração de retorno (G183). ). Os blocos G183 são mostrados
destacados para fácil identificação:

G21 G94 G54;


G91 G28 ZO;
G28 XO YO;
M06 T01;
G90 GOO XO YO;
G43 HOl ZlOO;
M03 51000; MO8;
G99;
G183 X1O Y1O Z-53 R2 Q10 I0,9 M5 F20;
G183 X20 Y1O Z-53R2 Q10 I0,9 M5 F20;
G183 X30 Y10 Z- 53 R2 Q10 I0,9 M5 F20;
G98;
G183 X40 Y1O Z-53R2 Q10 I0,9 M5 F20;
M09;
M05;
G91 G28 ZO;
M30;

Note que os primeiros três furos foram feitos no modo G99, e o último no modo
G98. Assim, a ferramenta ficaria no ponto R (2 mm acima da superfície
superior do bloco) depois de fazer cada um dos três primeiros furos, ao passo
que recuaria para o nível Z inicial (100 mm acima do bloco) depois de
completar o último buraco. Além disso, as últimas três chamadas podem não
ter palavras F, uma vez que a macro foi projetada para usar automaticamente o
avanço anterior, se a velocidade de avanço não for especificada durante a
chamada da macro.
A chamada de macro (com G65 ou por outros métodos) deve aparecer em um
bloco separado, como no exemplo dado, onde G98 e G99 não estão lotados
com G183. Se um G-eode for comandado à esquerda da chamada de macro,
no mesmo bloco, ele será ignorado pelo controle. Por outro lado, um G-eode à
direita da macro chama alarma, porque é considerado um argumento da
macro, enquanto que uma palavra G não é permitida como argumento. M98
tem um comportamento diferente nesta situação. Ele não ignora o G-eode ou
alarma, mas não espera pela conclusão da execução do G-eode. Portanto, se
for um código de movimento (como COl), a execução do subprograma será
iniciada enquanto a ferramenta ainda estiver em movimento. Portanto, para
evitar qualquer confusão, subprogramas e macros devem sempre ser
chamados em blocos separados.

Alguns dos ciclos fixos, bem como códigos para funções especiais, como a
interpolação helicoidal, estão disponíveis como opções, para as quais é
necessário efetuar um pagamento adicional ao fabricante do controle. Também
é possível ativar qualquer opção em uma data posterior, desde que o hardware
da máquina operatriz esteja equipado para lidar com ela (em caso de dúvida,
consulte o MTB). No entanto, como os exemplos apresentados demonstram, é
possível que os próprios usuários definam os G-eodes necessários, com os
recursos desejados. E estes podem ser ainda melhores que os códigos padrão,
em certos casos! Se você conhece bem a programação de macros e está
pronto para flexionar seu cérebro, você pode fazer praticamente qualquer
coisa.
CAPITULO 11
Sondagem

11.1 Introdução

A produtividade de uma máquina CNC pode ser aumentada se o tempo de


preparação e o tempo de inspeção forem reduzidos, automatizando esses
processos de consumo de tempo. A técnica envolve amplamente a medição
automática de certas dimensões e a tomada de decisões relacionadas à
usinagem, com base no resultado da medição. Este processo é referido como
sondagem.

Os dispositivos comumente usados para sondagem é um apalpador que


permanece eletronicamente conectado (através de um cabo ou sinal de
infravermelho / rádio) ao controle. Um sensor de toque detecta um
deslocamento muito pequeno e envia um sinal elétrico (chamado de sinal de
salto) quando "tocado". O controle armazena imediatamente a posição da
sonda / ferramenta no momento em que recebe o sinal, nas variáveis do
sistema, # 5061- # 5064 (consulte a Tabela 3.11) e interrompe o movimento
adicional da ferramenta. As posições armazenadas em locais planejados são
usadas para calcular as dimensões desejadas.

Existem dois tipos básicos de sondas de toque: apalpador de ferramenta e


sonda de trabalho. Uma sonda de ferramenta é usada para automatizar o
procedimento de configuração de deslocamento da ferramenta, que é um
processo manual que envolve julgamento humano propenso a erros. É uma
sonda de tipo fixo e permanece ligada a uma parte estacionária no corpo da
máquina. A ferramenta, que deve ser sondada, é feita para tocá-la (sonda).
Como a posição da sonda é conhecida, informações sobre a geometria da
ferramenta podem ser extraídas. Além disso, uma repetição periódica desse
processo fornece informações sobre a extensão do desgaste da ferramenta, de
modo que o deslocamento do desgaste possa ser adequadamente editado
para anular o erro introduzido devido ao desgaste da ferramenta. Uma
mudança súbita e grande nas dimensões da ferramenta indica quebra da
ferramenta.

A sonda de trabalho, por outro lado, é uma sonda do tipo móvel. É mantido
pela máquina como uma ferramenta é mantida. Ele é movido como uma
ferramenta para tocar a peça / peça acabada nos locais desejados. As
posições armazenadas nos sinais de salto são usadas para calcular as
dimensões desejadas da peça / peça acabada. Os exemplos neste capítulo
referem-se apenas a esse tipo de sonda. Tal sonda tem um longo estilete, com
uma pequena bola de rubi no final (o rubi é usado, pois é duro e, portanto,
impede qualquer alteração na dimensão da bola devido ao desgaste). Quando
o
a bola pressiona contra uma superfície fixa, a caneta desvia um pouco e
perturba um arranjo de focalização ótica dentro da sonda. Uma fotocélula
diferencial detecta a mudança na posição do ponto de imagem e dispara um
sinal. O diâmetro da bola deve ser levado em conta nos cálculos, se
necessário. (Em alguns casos, ele não entra em cena, por exemplo, pode ser
cancelado enquanto ocorre uma diferença em duas posições.)

O estilete da sonda é suportado por um sistema de molas, de modo que não


quebra quando desviado repentinamente por uma superfície dura.
Normalmente, uma deflexão de até 5 mm na ponta da sonda (bola) é permitida.
Observe que as posições armazenadas provavelmente não serão muito
precisas devido ao excesso de ponta. Uma maneira de lidar com o overshoot é
usar uma velocidade fixa e controlada (taxa de avanço) e usar um gráfico de
calibração para estimar o overshoot. Outra maneira envolve sondar a uma
velocidade muito lenta. Como levaria muito tempo, a superfície é sondada duas
vezes. Primeiro ele é tocado com alta velocidade, então, quando o sinal de pulo
é acionado, ele é recuado por uma pequena quantidade (digamos, 2 a 3 mm), e
movido novamente em direção à superfície com uma velocidade muito baixa.
Esta técnica dá bons resultados em um tempo muito curto e, portanto, é
preferida na maioria das vezes. Os exemplos neste capítulo usam o mesmo
método.

11.2 Função de pulo em uma máquina CNC

Além do hardware necessário (uma ponta de prova de toque e uma conexão


física para receber o sinal de pulo pelo controle), o controle também deve ser
equipado com o recurso de função pular, no nível do software. O G-eode
associado é G31. Portanto, a menos que o G31 (ou um código similar em
outros controles que não o Fanuc) esteja disponível, o teste não seria possível.
O G31 pode ser um recurso opcional em algumas versões de controle.
G31 é muito semelhante ao G01, exceto que quando o controle recebe um
sinal de salto, a execução do G31 termina imediatamente, a posição da
ferramenta / sonda nesse instante é automaticamente armazenada em certas
variáveis do sistema e a execução do próximo bloco é iniciada. Quando
falamos em mover a ferramenta / sonda em direção à superfície a ser sondada,
ela realmente se refere ao movimento com o comando G31. A Figura 11.1
explica a função do G31, com e sem sinal de salto, em uma fresadora. Sem um
sinal de salto, o movimento ocorre até o ponto final programado, enquanto o
movimento é finalizado e a execução do próximo bloco é iniciada, o controle de
momento recebe um sinal de salto.

11.3 Sondando um bolso

Medir as dimensões de um bolso é um exemplo muito simples de sondagem,


mas explica muito claramente os princípios subjacentes. A sonda simplesmente
tem que tocar a superfície superior da peça e a parte inferior da bolsa, uma por
uma, para medir a profundidade. A diferença
F IGURA 11.1 Movimento associado à função de salto (G31).

Nota:

O G31 é projetado para trabalhar com um obstáculo no caminho da ferramenta,


de modo a gerar um sinal de salto para o propósito de medição. Não tem outro
uso. Portanto, uma ausência de sinal de salto antes de atingir o ponto final
especificado em G31 possivelmente indica uma condição de erro, seja na
programação ou devido a um desvio inesperado nas dimensões da peça.
Portanto, alguns controles emitem um alarme e encerram a execução adicional
do programa, nesses casos.
comprimento / largura da peça) pode ser medida. O comprimento do bolsão
pode ser medido tocando o bolso em, digamos, as posições C e E, e então
tomando a diferença nas posições X armazenadas. Como fica claro na
geometria, o diâmetro da bola precisaria ser adicionado ao comprimento obtido.
Por outro lado, quando o comprimento da peça é medido ao tocá-la nas
posições A e F, o diâmetro da bola precisaria ser subtraído do valor obtido.

As dimensões da bolsa não são importantes para explicar o princípio de


sondagem. No entanto, para o propósito de escrever um programa, assume-se
que o tamanho "esperado" do bloco e da bolsa são 90 mm x 36 mm x 20 mm e
50 mm x 16 mm x 10 mm, respectivamente, com seus centros em (45, 18).
Assume-se também que a sonda ocupa a posição do número de ferramenta 1,
com 01 número de correção para compensação de comprimento. O diâmetro
da bola é assumido como 5 mm. O programa para este problema não é
intencionalmente feito para um caso geral, uma vez que seu único objetivo é
explicar o princípio da sondagem, sem envolver complicações adicionais:

00020;
G21 G94;
G91 G28 ZO;
G28 XO YO;
M06 TOl;
G90 GOO XlO Yl8;
G43 HOl Z50;
G91 G31 Z- 100 F200;
Z2;
G31 Z-5 FlO;
#100 = #5063;
Z5;
X35;
G31 Z-100 F200;
Z2;
G31 Z-5 FlO;
#101 #5063;
#500 #100 - #101 ;
Z3;
G31 X-100 F200;
X2;
G31 X-5 FlO;
#102 = #5061;
G31 XlOO F200;
X-2;
G31 X5 FlO;
#103 #5061;
#501 = #103 - #102 + 5;
X-5;
ZlO;
X50;
Z- 10;
G31 X-100 F200 ;
X2 ;
G31 X-5 FlO;
#104 = #5061;
X5;
ZlO ;
X-120 ;
Z-10 ;
G31 XlOO F200;
X- 2;
G31 X5 FlO ;
#105 #5061 ;
#5 02 = #10 4 - #105 - 5;
X-5;
G28 ZO ;
G28 XO YO ;
M30 ;

(A sonda se aproxima da posição B. É esperava que a sonda iria


definitivamente tocar a superfície dentro do distância especificada. A distância
100 não tem significado especial, exceto que deve ser maior que o intervalo
entre a sonda e a superfície a ser sondada. Note-se que este, assim como
todos os subsequentes os movimentos estão no modo incremental)

(Recua em 2 mm. GOO está implícito. assume-se que o overshoot é menos


than2 mm)

(Velocidade de aproximação muito baixa, para garantir precisão)

(Coordenada Z no sinal de salto armazenado, que corresponde à posição B)

(Sonda posicionada no centro do bolso)

(A sonda se aproxima da parte inferior do bolso)

(Coordenada Z correspondente à posição D armazenado)

(Profundidade do bolso calculado. Diâmetro da sonda não entra na foto)

(Se aproxima do lado esquerdo do bolso)

(Coordenada X na posição C armazenada)

(Se aproxima do lado direito do bolso)

(Coordenada X na posição E armazenada)

(Comprimento do bolsão calculado, em qual diâmetro da bola foi tomado em


consideração)

(Aproxima-se o lado direito do quadra)

(Coordenada X na posição F armazenada)

(Aproxima-se o lado esquerdo do bloco)

(Coordenada X da posição A armazenada)

(Comprimento do bloco calculado, em qual diâmetro da bola foi tomado em


consideração)

As dimensões Y da bolsa e do bloco podem ser determinadas de maneira


semelhante. Isso foi deixado como um exercício para os leitores. A sondagem
em um torno é feita de maneira semelhante, onde a sonda é geralmente
mantida como uma ferramenta interna.

11.4 localizando o centro de um furo

Às vezes, a peça de trabalho é uma peça fundida com um furo pré-existente e


o programa de peça é gravado com o ponto zero da peça no centro do furo.
Isso requer que o fuso seja alinhado exatamente com o eixo do furo, para
determinar deslocamentos de trabalho ao longo dos eixos X e Y. Isso
geralmente é feito com a ajuda de um indicador de tipo de fuso. O final da
alavanca é feito para tocar o buraco em algum momento, e o fuso recebe uma
rpm muito baixa. As posições X e / ou Y são ajustadas para obter a mesma
leitura de discagem em todas as posições angulares, que localizam o centro do
furo. Embora esse método seja teoricamente correto e seja usado com
bastante frequência, envolve tentativa e erro. Como resultado, o tempo gasto
na configuração dos dados depende em grande parte da habilidade do
operador. Vamos agora ver como isso pode ser feito automaticamente, usando
uma sonda de toque. Considere o buraco mostrado na Fig.1.1.3. O princípio
envolvido na localização do centro é muito simples. O centro ficaria no ponto de
intersecção das bissectrizes perpendiculares em quaisquer dois acordes. Como
um

FIGURA 11.3 Localizando o centro de um buraco.

caso especial, se os dois acordes são escolhidos para serem paralelos aos
eixos X e Y, respectivamente, então a coordenada X do centro seria a mesma
que a do ponto médio do acorde que é paralelo ao X -eixo. Da mesma forma, a
coordenada Y do centro seria a mesma do ponto médio do acorde que é
paralelo ao eixo Y. Quando os pontos finais dos acordes são encontrados
usando uma sonda de toque, seu diâmetro entra na imagem, porque o círculo
não é tocado pelo mesmo ponto na bola. (Os pontos da bola, que tocam o
círculo, são mostrados por pontos na Fig. 11.3.) Isso, no entanto, não afeta
nossos cálculos por causa da simetria, como pode ser observado na figura.
Uma macro, baseada neste princípio, será desenvolvida agora. Para localizar o
centro de um buraco, basta colocar a bola da sonda em algum lugar dentro do
buraco (digamos, a posição A) e, em seguida, chamar a macro. Depois de
localizar o centro, a macro colocaria o ponto zero da peça nesse ponto,
editando as variáveis do sistema associadas.

08022 (LOCATING HOLE CENTER ON MILL);


G21 G94;
#100 = #5041; (Coordenada X na posição inicial um armazenado. Consulte a
Tabela 3.11)

G91 G31 X-200 F200; (Aborda a posição B)


GOO X2;
G31 X-5 FlO;
#101 = #5061; (Coordenada X do centro da bola armazenada, na posição B)

G31 X200 F200; (Aborda a posição C)


X-2 ;
G31 X5 FlO;
#102 #5061; (Coordenada X do centro da bola armazenada, na posição C)
#500 [ [#101 + #102] I 2]; (X-coordinate of the center calculated)

G90 X#lOO; (A sonda se move para a posição A)


G91 G31 Y- 200 F200;
GOO Y2;
G31 Y-5 FlO;
#103 = #5062 ; (Coordenada Y do centro do bola guardada, na posição D)

G31 Y200 F200; (Aborda a posição E)


Y-2;
G31 Y5 FlO; (Aborda a posição D)
#104 #5062; (Coordenada Y do centro do bola guardada, na
posição E)

#501 [ [#103 + #104] I 2]; (Coordenada Y do centro calculado)


G90 X#500 Y#501; (A sonda se move para o centro da buraco)

G65 P8008; (Programa 08008, que é dado em Rachar. 5, desloca a peça de


trabalho atual ponto zero para a ferramenta atual posição, em uma fresadora.
Somente substituir M30 por M99 no último bloco de 08008, para usá-lo como
uma macro / subprograma)

M30;

Esta macro, no entanto, não funcionaria se o WCS adicional, como o G54.1 Pl,
estiver atualmente ativo, ou quando o diâmetro do furo for maior que 200 mm.
É deixado como um exercício para os leitores para tornar essa macro
adequada para esses casos. Além disso, eles também podem tentar calcular o
raio do buraco. Para isso, calcule a distância entre o centro do furo e qualquer
uma das posições B, C, D ou E, usando a fórmula da geometria das
coordenadas, e acrescente a ela o raio da bola. Isso exigiria a coordenada Y da
posição inicial da ferramenta (em A), se as posições B ou C forem
selecionadas para cálculos. Para evitar isso, use as posições D ou E. O centro
de um bolsão retangular pode ser determinado de maneira similar.

11.5 Encontrando o Ângulo de uma Borda

Às vezes, o programa de usinagem para um bloco retangular é escrito com o


ponto zero do programa, digamos, no canto inferior esquerdo do bloco, com os
eixos coordenados paralelos às suas bordas. Nesse caso, é necessário um
acessório muito preciso (e portanto caro) para segurar a peça corretamente.
Um acessório incorreto o manteria incorretamente, como mostra a Fig. 11.4,
onde o sistema de coordenadas usado para programação (XY) não coincide
com o sistema de coordenadas da peça (Xw-YJ. Uma solução para esse
problema seria deslocar o ponto zero da peça ponto a ponto 0 e, em seguida,
executar o programa de usinagem usando o recurso de rotação do sistema de
coordenadas (G68) .Chamando a macro 08008, depois de colocar a ferramenta
no ponto 0, mudaria o sistema de coordenadas, como foi feito no exemplo
anterior. o ângulo e (em graus) deve ser conhecido

O algoritmo seria

1. Encontre o ângulo θ
2. Encontre as coordenadas X e Y do ponto 0.
3. Coloque a ferramenta no ponto 0 (a uma altura segura da peça de trabalho)
4. Ligue para 08008.

FIGURA 11.4 Encontrando o ângulo de uma aresta.


5. Comando G17 G68 XO YO R <O> (XO YO, que é o centro de rotação, pode
ser omitido porque a posição atual da ferramenta automaticamente se torna o
centro de rotação, se não for especificado).
6. Execute o programa de usinagem.
7. Comando G69 (cancelar rotação de coordenadas).
8. Fim do programa.

As coordenadas X e Y do ponto 0, e o ângulo e, podem ser determinadas


usando sondas de toque. Para isso, a sonda precisaria tocar as bordas
ortogonais da peça em três pontos, como mostra a Fig. 11.4. Deixe as
coordenadas do centro da sonda serem (xA 'yA), (xC' Yc) e (x 0, y0),
respectivamente, correspondentes aos pontos A, C e D. As equações
fornecidas abaixo podem ser usadas para os cálculos necessários. (Tente
derivar isso usando geometria de coordenadas.)
As equações das linhas CD e AB (que é ortogonal ao CD) seriam

As coordenadas (x6, y6) do ponto de intersecção dessas linhas (ponto B)


podem ser encontradas resolvendo-se estas equações simultaneamente, o que

O algoritmo fornecido, juntamente com essas equações, pode ser usado para
desenvolver uma macro para esse problema. Defina o parâmetro 6004 # 0 para
1, por ter a faixa de solução de tan-1 (função ATAN) entre -180 ° e 180 °,
embora mesmo que a faixa seja de 0 ° a 360 ° (com 6004 # 0 definido como 0),
é matematicamente equivalente. Portanto, não se preocupe com este
parâmetro, se, digamos, 355 ° no lugar do "esperado" -5 ° não parecer
estranho para você. É deixado como um exercício para os leitores para
completar este problema.

11.6 Ajustando o Desvio de Desgaste

Como um exemplo final, considere o caso de obter peças grandes em um


torno, devido ao desgaste da ferramenta. Embora esse problema também
possa ser resolvido ajustando o deslocamento da geometria, esse não é um
método recomendado. A razão é que, quando a pastilha desgastada é
substituída por uma nova pastilha, o deslocamento da geometria original
precisaria ser usado novamente. Se os valores originais forem perdidos, o
procedimento de registro de tempo da configuração do deslocamento da
geometria teria que ser repetido. Portanto, a prática recomendada é começar
com zero deslocamento de desgaste para uma nova pastilha e ajustá-la para
cuidar do desgaste da ferramenta. Quando a pastilha é finalmente substituída
por uma nova pastilha, os valores de correção do desgaste são ajustados
novamente em zero. O deslocamento de geometria nunca é manipulado. Isso
elimina a necessidade de repetir o procedimento de configuração de
deslocamento.

Quando uma ferramenta externa se desgasta, os diâmetros externos da peça


tornam-se maiores que os valores programados. Por outro lado, se uma
ferramenta interna se desgasta, os diâmetros internos tornam-se menores. Isto
requer que, para um dado diâmetro programado, uma ferramenta externa seja
aproximada do eixo do fuso, e uma ferramenta interna seja movida para longe
dele, por uma quantidade igual ao erro observado, para compensar o desgaste.
Isso pode ser feito manipulando as distâncias de deslocamento, que definem a
posição do sistema de coordenadas em relação ao sistema de coordenadas
fixo da máquina. Como o controle usa a soma algébrica de geometria e
desfasamentos de desgaste (assim como todos os outros deslocamentos), a
alteração no deslocamento de desgaste para uma ferramenta externa seria
negativa, enquanto seria positiva para uma ferramenta interna. Observe que
todos os valores de deslocamento são "valores de diâmetro", se a
programação de diâmetro estiver sendo usada.

O método de correção de offset é o mesmo para ferramentas internas e


externas (exceto para os sinais opostos para a alteração necessária nos
valores de compensação de desgaste e adição / subtração do diâmetro da
esfera de / para o diâmetro observado durante a medição do diâmetro da
peça). Correção de deslocamento para uma ferramenta externa é considerada
aqui, como um exemplo. Como a quantidade de erro permanece igual em todos
os diâmetros, qualquer diâmetro conveniente pode ser escolhido para
determinar o erro. No exemplo dado na Fig. II, <20> o diâmetro foi escolhido
arbitrariamente para a medição, na posição axial Z-25.
F IGURA 11.5 Medição de diâmetro em um torno.

O algoritmo para a macro 0 8023 é simples:

1. Determine o número de correção da ferramenta atual (que foi usada para


usinar a peça de trabalho), usando <número da ferramenta atual> = FIX [#
4120/100] <número de correção da ferramenta atual> = # 4120 - <número da
ferramenta atual > x 100
2. Meça o diâmetro especificado, no local especificado (X20 Z-25, neste
exemplo).
3. Subtraia o diâmetro especificado (20, neste caso) do diâmetro obtido, para
determinar o erro devido ao desgaste da ferramenta.
4. Determine a variável do sistema para o desvio de desgaste correspondente
ao número de correção que está sendo usado (consulte as Tabelas 3.2 e 3.3).
5. Subtraia o erro dessa variável de sistema que contém o valor atual do
deslocamento de desgaste correspondente ao número de correção que está
sendo usado.
6. Retorne ao programa de chamada.

08023 (WEAR OFFSET CORRECTION ON LATHE);


MO5;
# 100 = # 4120; (Espera-se que essa macro seja chamada com o fuso não
girando. No entanto, como medida de segurança, M05 é explicitamente
comandado aqui)
# 101 = CORRIGIR [# 4120/100]; (Código de ferramenta atual armazenado)
# 102 = # 4120 - # 101 * 100; (Número atual da ferramenta determinado)
(Número de compensação da atual para a conclusão determinada. Etapa 1
completa)
G28 UO; (X-home)
G28 WO; (Z-home)
T # 20; (A sonda se torna a "ferramenta" atual)
GOO Z [# 26- # 7 I 2]; (Centro da sonda no Zcoordinate especificado, onde a
medição deve ser feita. O raio da sonda foi subtraído do valor especificado,
assumindo que a ponta da sonda é o seu ponto de referência)
X [# 24 + # 7 + 4]; (Sonda a uma folga de 2 mm do diâmetro a ser medido.
Faça as mudanças necessárias no percurso, se um diâmetro interno usinado
por uma ferramenta interna estiver sendo sondado. Além disso, ambos os
sinais positivos mudam para sinais negativos, para um interno medição)
# 103 # 4005; (Armazena 98 ou 99, dependendo de qual dos G98 e G99 está
atualmente ativo)
G98; (Como o fuso é estacionário, essa macro não funcionaria no G99, o modo
de avanço por rotação, porque a velocidade de avanço se tornaria zero com
zero rpm)
G31 U-10 FlO; (Pára na superfície, onde o diâmetro deve ser medido)
# 104 # 5061; (Coordenada X do centro da esfera da sonda armazenada
quando toca a parte)
# 105 # 104 - # 7; (Diâmetro da peça calculada. No caso de um diâmetro
interno, o diâmetro da bola teria que ser adicionado aqui. Etapa 2 completa)
# 106 # 105 - # 24; (Erro devido ao desgaste calculado. Essa quantidade seria
negativa se a medição estivesse sendo feita para uma ferramenta interna.
Etapa 3 completa)
# 107 10000 + # 102; (A variável de sistema para correção de desgaste,
correspondente ao número de correção usado, é determinada. Substitua
10.000 por 2.000, se apenas 64 números de correção estiverem disponíveis.
10.000 séries é para 99 números de correção. Etapa 4 completa)
# [# 107] # [# 107] - # 106; (Erro subtraído do valor atual de compensação de
desgaste. Esta expressão também é correta também para medição interna,
uma vez que o sinal de # 106 se tornará automaticamente negativo. Etapa 5
completa)
G28 UO; (X-home)
G28 WO; (Z-home)
T # 1OO; (Ferramenta original chamada, com o valor de compensação de
desgaste atualizado)
G # 103; (Modal G-eode restaurado)
M99; (Retorne ao programa de chamada. Etapa 6 completa)

A correção do deslocamento de desgaste para o eixo Z pode ser feita de


maneira semelhante, que é deixada como um exercício (geralmente, o
desgaste radial é mais grave do que o desgaste axial). Seria necessário tocar
em uma superfície Z conhecida (que foi enfrentada pela ferramenta a ser
investigada) e determinar o erro. O programa para ferramentas internas e
externas seria o mesmo neste caso. As variáveis do sistema de desvio do
desgaste do eixo Z pertencem à série # 2100 para 64 deslocamentos e à série
# 11000 para 99 compensações (consulte as tabelas 3.2 e 3.3).

Para usar o macro 08023, ele precisaria ser chamado imediatamente após a
usinagem pela ferramenta, para o qual o ajuste de desgaste deve ser feito. É
possível continuar a usinagem com os novos valores de correção de desgaste.
De fato, no caso de suspeita de imprecisão, um único comando de giro direto,
com uma pequena profundidade de corte, pode ser dado primeiro. Os
principais códigos de usinagem podem ser dados após a chamada desta
macro. Isso automatizaria o processo de inspeção e correção. Pode-se usar
essa técnica depois, digamos, a cada 10 partes, o que garantiria praticamente
zero rejeição. O número de peças usinadas, na sessão de usinagem atual, fica
armazenado na variável de sistema # 3901 (consulte a Seção 3.5, subseção
Número de peças usinadas). O programa principal pode chamar / pular a
macro de sondagem

<comandos de configuração>
<viragem direta>

SE (# 3901 LE 10) GOTO 100;


G65 P8023 T_ X_ Z_ D_;
# 3901 = 0;
N100;
<programa de usinagem>
M30;

onde a contagem de peças é redefinida para zero sempre que a macro é


chamada. É deixado como um exercício para os leitores pensarem como
implementar a mesma lógica se a variável de contagem de peças # 3901 não
for resetada (pois pode ser desejado manter o controle do número total de
peças usinadas na usinagem atual sessão).

Os argumentos da macro chamam para 08023 passam dados para o seguinte:

T (# 20) = código de ferramenta de quatro dígitos para a sonda


X (# 24) = diâmetro a ser sondado
Z (# 26) = posição do eixo onde a sondagem deve ser feita
D (# 7) = diâmetro da esfera da sonda

Embora seja possível desenvolver macros para requisitos de sondagem


específicos, os fabricantes de sondas geralmente fornecem sondas com
software para aplicativos comuns de sondagem.
CAPITULO 12
Comunicação com Dispositivos Externos

12.1 Introdução

Uma descrição adequada de como controlar um dispositivo externo através do


PMC já foi dada na Sec. 3.5 (Sinais de interface de subsecção). O
conhecimento da linguagem Ladder, no entanto, é um pré-requisito para
programar o PMC. Além disso, também é necessário conhecer os tipos de
entrada (tipo de fonte / coletor), tipos de saída (fonte / coletor / tipo de relé) e
técnicas de fiação para um CLP. Além disso, se se desejar utilizar sensores de
proximidade do tipo sem contato para detectar a presença de um objeto, é
necessário conhecer as características de tais sensores (fonte / tipo pia). A
coisa toda é bastante vasta e pode ser descrita em detalhes apenas em um
texto criado especialmente para esse fim. No entanto, para a conveniência dos
leitores, uma breve descrição é dada neste capítulo, a mínima deve saber. O
principal objetivo aqui é atualizar a memória, em vez de explicar os conceitos
fundamentais meticulosamente. Portanto, um leitor que é completamente novo
em aplicações de CLP precisaria se referir a algum texto básico sobre CLP.

12.2 Princípio de Comutação

Os sinais digitais de entrada / saída de um CLP baseiam-se no princípio da


operação em modo de saturação de um transistor, quando ele começa a
funcionar como um interruptor eletrônico ON / OFF. (Antes da saturação, ela
serve ao propósito de amplificação de sinal.) A representação de um transistor
NPN é mostrada na Fig. 12.1, juntamente com seu modelo funcional. I6, IC 'e
IE são corrente de base, corrente de coletor e corrente de emissor,
respectivamente (IE = I6 + Ic). A resistência variável entre o coletor e o emissor
(RcE), à qual a fonte de energia (+ Vcc) e a carga estão conectadas, pode ser
considerada como sendo controlada pela corrente de base; quando a corrente
de base é zero, a resistência é infinita, o que diminui com um aumento na
corrente de base. Como resultado, quando a corrente base aumenta, a
corrente do coletor também aumenta.
FIGURA 12.1 Um transistor NPN.

A razão entre Ic e I8 é chamada de ganho de corrente do transistor, sendo um


valor típico de 100. (Como o ganho de corrente é tipicamente muito alto, Ic e IE
seriam quase iguais.) Isso descreve o uso de um transistor como corrente.
amplificador. No entanto, além de um certo valor de corrente de base, RcE se
torna quase zero. Como resultado, o Ic não aumenta mais e o transistor é dito
saturado. No modo de saturação, depende da resistência externa (carga) e da
fonte de alimentação, com o transistor oferecendo quase zero de resistência ao
fluxo de corrente. Essa característica ideal do transistor é mostrada na Fig.
12.2.

Assim, um transistor pode ser usado como um comutador eletrônico, no modo


de saturação. Para tal uso de um transistor, o circuito (regulando a corrente
base) é projetado de tal maneira que o transistor permaneça DESLIGADO (I8 =
0, resultando em Ic = 0) ou fique saturado.

As entradas / saídas digitais de um PLC usam comutação eletrônica similar. No


entanto, para proteger os circuitos internos de correntes externas, geralmente
algum tipo de optoisolador é usado. Um optoisolator é um dispositivo que
consiste em um elemento produtor de luz, como um LED, e um elemento de
iluminação, como um fototransistor. Quando uma voltagem é aplicada
FIGURA 12.2 Uma característica ideal do transistor.

FIGURE 12.3 Typical PLC input circuits.

para o LED, é produzida luz que é detectada pelo fotodetector. Luz suficiente
faz com que o fototransistor sature e comece a conduzir. Esse arranjo isola
completamente o CLP da corrente / tensão externa, já que a conexão entre os
dois é feita apenas através de um feixe de luz. Para entradas CA, dois LEDs
opostos são usados. A Figura 12.3 mostra esse arranjo para os sinais de
entrada CC e CA. Os sinais CC também podem ser dados às entradas AC,
sem se preocupar com a polaridade. Portanto, a entrada do tipo CA é, na
verdade, entrada do tipo CA / CC. Um resistor limitador de corrente é
necessário para limitar a corrente através do LED. Os terminais de saída de
estado sólido também geralmente usam uma técnica de isolamento similar.

12.3 Tipos de Entrada e Fiação

Um CLP comercial fornece vários tipos de entradas, como entradas "normais"


CC, AC e analógicas, além de entradas para funções especiais, como entrada
de alta velocidade e entrada imediata. O PMC, no entanto, geralmente aceita
apenas entradas normais de 24 V CC. Uma restrição é que uma fonte de
energia externa não deve ser usada para fornecer sinais de entrada; 24 VCC
de dentro do PMC permanece disponível para este propósito, em um pino de
cada conector de 50 pinos na unidade de entrada / saída (no número de pino
BOl do CB104 / 105/106/107 no controle Oi: 0 Vis disponível no número de
pinos AOl). Isso ocorre porque o PMC geralmente não possui optoisoladores
do tipo PLC dentro dele. Note, no entanto, que vários tipos de entradas /
saídas, com ou sem isolamento, podem ser disponibilizados como opções,
inserindo certos cartões de entrada / saída na unidade de entrada / saída do
PMC. A configuração padrão geralmente aceita somente entradas de fonte /
coletor de 24 VCC e fornece saídas de tipo de fonte de alimentação (projetadas
para alimentar dispositivos externos, como um relé, trabalhando em uma fonte
de alimentação externa de 24 V CC). Nossa discussão neste capítulo
permaneceria limitada apenas a esses tipos de entrada / saída.

Os sinais de entrada (referidos como sinais DI) para o PMC, através dos
conectores CB104 / 105/106/107, são geralmente do tipo sink (um tipo que
drena energia). Portanto, +24 V, como sinais de entrada ON, devem ser
fornecidos nos respectivos terminais. Alguns sinais Dl, no entanto, podem ser
definidos como tipo de coletor ou tipo de fonte, embora um sinal Dl do tipo fonte
seja indesejável do ponto de vista da segurança. Isso ocorre porque uma
entrada do tipo fonte requer que 0 V, como sinal de entrada ON, seja fornecido
ao terminal de entrada. Isso é perigoso, porque uma linha de entrada aterrada
(devido a uma falha) seria interpretada como sinal de entrada ON. Portanto,
recomenda-se que todos os sinais DI sejam usados como sinais do tipo coletor.

A Figura 12.4 explica o método de fornecer sinal DI tipo sink (digital, é claro) ao
PMC. A fiação para o sinal DI do tipo fonte seria similar, com a diferença de
que, em vez de +24 V, 0 V disponível no pino número A01 é usado como sinal
de entrada ON. Os sinais DI X0004.0 a X0004.7 (que são fornecidos através do
conector CB106) podem ser usados como sinais do tipo fonte e coletor. O
terminal COM4 (número de terminal A14) do CB106 é conectado a 0 V (número
de terminal A01) quando esses sinais são usados como sinais do tipo coletor.
Para aplicações do tipo fonte, COM4 é conectado a +24 V (número de terminal
B01). COM4 nunca deve ser deixado aberto, caso contrário, X0004.0 a
X0004.7 permaneceriam sempre desligados, independentemente da condição
do sinal de entrada. O interruptor externo representa a ação de comutação
discreta (ON / OFF) por um interruptor / sensor externo.

12.4 Atribuição do Pino do Conector

O diagrama de blocos do arranjo geral (no controle Oi) para conexões de


entrada / saída é mostrado na Fig. 12.5. O PMC reside na unidade de controle
CNC. Ele está conectado à unidade 1/0 através de um link 1/0 (que é um cabo
Fanuc padrão). A unidade 1/0, a barra de terminais e a PCB do relé podem ser
vistas no gabinete elétrico projetado pela MTB da máquina. Na unidade 1/0,
quatro conectores de 50 pinos (CB104, CB105, CB106 e CB107) estão
presentes para receber / enviar sinais de entrada / saída. Estes são conectados
à faixa de terminais através de quatro cabos de fita (planos). Cada pino desses
conectores é usado para algum sinal de entrada / saída específico, conforme
indicado nas Tabelas 12.1 e 12.2. Os fios de entrada dos interruptores /
sensores estão diretamente conectados à barra de terminais, mas os
dispositivos de saída são acionados através de relés, pois podem exigir alta
corrente e / ou suprimento de CA.

FIGURA 12.4 Fiação de entrada para sinais Dl do tipo coletor.

Normalmente, 96 entradas (mais 24 entradas para geradores manuais de


pulsos e oito para detecção de alarmes por DO) e 64 saídas estão disponíveis.
No controle Oi, XO a X11 (cada um consistindo de oito bits, por exemplo,
XOOOO.O a X0000.7) são usados para 96 sinais DI, X12 é usado para MPG,
X13 e X14 (oito sinais cada) para MPGs adicionais (se any) e X15 (oito sinais)
para detecção de alarme de OD (por exemplo, sobrecorrente ou temperatura
anormal dentro do driver DO, causada por sobrecarga devido a razões como
aterramento acidental do cabo de alimentação). YO a Y7 (cada um consistindo
em oito sinais, por exemplo, YOOOO.O até Y0000.7) são usados para sinais
de OD. As 96 entradas e todas as 64 saídas podem ser usadas para qualquer
finalidade. No entanto, se a máquina tiver Fanuc MOP, X4 a X11 estão
conectados a várias teclas do MOP. Assim, apenas XO a X3 (32 sinais) são
sinais DI de finalidade geral, alguns dos quais podem ser usados pelo MTB, e

FIGURA 12.5 Diagrama de blocos de conexões de entrada / saída com PMC.


TABELA 12.1 Designação de pinos para conectores CB104 e CB105

TABELA 12.1 (Continuação)


TABELA 12.2 Designação de pinos para conectores CB106 e CB107

TABELA 12.2 Designação de pinos para conectores CB106 e CB107


(continuação)

o resto permanece livre. Da mesma forma, vários dos sinais de saída são
conectados aos LEDs do Fanuc MOP. No entanto, em muitos casos, o MTB
projeta seu próprio MOP e seleciona qual sinal usar para esse propósito. Os
sinais não utilizados podem ser usados para comunicação com dispositivos
externos. Seria necessário examinar o manual da interface elétrica fornecido
pelo MTB para descobrir quais sinais foram usados por eles. Os sinais
restantes são gratuitos e podem ser usados pelos usuários. Se o número de
pontos de DI / DO não for suficiente, unidades de E / S adicionais precisarão
ser adicionadas. Por outro lado, se mesmo os pontos mínimos disponíveis
excederem o requisito, o MTB pode não fornecer conexão para todos os quatro
conectores. Nesses casos, a faixa de terminais normalmente não possui
conexão física para o CB107.

12.5 Sensores discretos para entradas de PLC de Sourcing / Sinking

Na configuração padrão do PMC, somente sinais discretos de entrada / saída


são permitidos. Os sinais de entrada podem ser fornecidos por chaves
mecânicas (chave liga / desliga do tipo momentânea ou mantida, ou chave
limitadora) ou sensores de proximidade. Os sensores de proximidade têm um
sistema de comutação eletrônica dentro deles. Normalmente, eles são
normalmente abertos (N / 0) e, quando um objeto entra em seu intervalo
projetado, o contato é fechado, simulando uma ação de comutação.

FIGURA 12.6 Sensores de proximidade discretos.

Uma vez que um transistor interno é tipicamente usado para comutação, tais
sensores podem ser ambos os tipos PNP e NPN. O sensor do tipo PNP
fornece + V cc em seu terminal de saída, enquanto um sensor do tipo NPN o
conecta ao terra (0 V), quando ligado. No estado OFF, o terminal de saída
permanece eletricamente aberto. Assim, um sensor PNP fornece uma saída de
fonte (+ Vee) e, portanto, é chamado de sensor de tipo de fonte. Da mesma
forma, um sensor NPN é chamado de sensor do tipo coletor (já que atrai
corrente através de seu terminal de saída). A Figura 12.6 mostra os dois tipos
de sensores.

O circuito elétrico só pode ser concluído se a corrente fornecida por uma fonte
for drenada para uma pia. Portanto, um sensor de abastecimento só pode ser
conectado a uma entrada de afundamento do PLC. Da mesma forma, um
sensor de afundamento é conectado a uma entrada de abastecimento. Embora
ambas as possibilidades existam, geralmente todas as entradas do PMC são
configuradas como entradas do tipo sink, portanto, apenas sensores de tipo de
fonte de alimentação são conectados a elas. A Figura 12.7 mostra como um
sensor de tipo de fonte de alimentação é conectado a uma entrada de CLP do
tipo coletor. A conexão com o PMC é feita de maneira semelhante. (A entrada
do PMC pode não ter optoisolação.)

Uma limitação das entradas PLC do tipo sink é que tanto o sensor quanto o
PLC devem usar a mesma entrada PLC de fonte Vcc A, por outro lado, permite
que o sensor trabalhe em um Vcc diferente; apenas o solo deve ser comum.
Isso é útil quando os requisitos de tensão de operação do sensor e do PLC são
diferentes. Tal arranjo é mostrado na Fig. 12.8, onde um sensor do tipo coletor
é conectado a uma entrada PLC do tipo fonte. Observe que as entradas do
PLC mostradas nesta figura são, na verdade, fonte / tipo sink (tipo CA) que
podem ser conectadas como fonte e tipo sink. Aqui, a fiação do tipo fonte é
mostrada, o que é necessário para um sensor do tipo coletor. As tensões
operacionais do PLC e do sensor, V ccJ e V cc2, respectivamente, podem ser
iguais ou diferentes. No entanto, conforme discutido anteriormente, esse tipo
de fiação não é recomendado para considerações de segurança.
FIGURA 12.7 Sensor de fonte conectado a uma entrada do PLC que está
afundando.

12.6 Tipos de Saída e Fiação

Nos CLPs comerciais, vários tipos de saídas estão disponíveis, empregando


diferentes tecnologias. O PMC usado no controle Oi, no entanto, usa a técnica
de chaveamento MOSFET do tipo N-channel. A ação de chaveamento é
semelhante à de um transistor NPN, onde a fonte, a porta e o dreno do
MOSFET correspondem, respectivamente, ao emissor, à base e ao coletor do
transistor NPN. A principal diferença entre um MOSFET e um transistor é que o
MOSFET é controlado por tensão, enquanto o transistor é controlado por
corrente (para polarização necessária). Quando uma tensão é aplicada no
portão, um campo eletrostático é gerado, o que cria um canal condutor (tipo P
ou tipo N) entre o dreno e a fonte. Nenhuma corrente flui através do

FIGURA 12.8 Sensor de afundamento conectado a uma entrada de PLC de


fornecimento.
FIGURA 12.9 Um MOSFET tipo realce de canal N como um comutador. 5V

consome energia insignificante. Consulte um texto básico sobre dispositivos de


estado sólido para obter mais informações sobre MOSFETs. Os sinais de saída
do PMC são projetados para serem usados como saídas de fornecimento, com
MOSFETs usados como dispositivos de comutação. Uma fiação de saída típica
para CB104 (fiação para CB105, CB106 e CB107 são similares; consulte as
Tabelas 12.1 e 12.2 para conexões de pino) é mostrada na Fig. 12.10, onde
relés externos, alimentados por fonte de alimentação externa de 24 V CC, são
sendo controlado por sinais DO. Os relés são usados porque um MOSFET não
pode levar corrente muito pesada. Além disso, não pode ser usado para
dispositivos AC. Um relé evita tais problemas. Todos os terminais de saída
devem ser conectados independentemente, conforme mostrado na figura.
Nunca curto dois (ou mais) terminais de saída para acionar um único
dispositivo. Observe também a presença de diodos com polarização inversa,
conectados em paralelo a cada bobina do relé. Esse diodo evita o acúmulo
excessivo de tensão na bobina do relé, quando o sinal MOSFET é desligado.
Se desmarcada, a tensão desenvolvida pode subir até várias centenas de volts,
o que pode danificar o MOSFET. O diodo desvia a corrente induzida,
impedindo o aumento de tensão. De fato, alguns relés são fabricados com este
diodo pré-instalado. Uma limitação das saídas do tipo fonte é que todos os
dispositivos de saída teriam que trabalhar no mesmo Vee (embora isso não
importe, porque usamos somente relés como dispositivos de saída, e sempre
podemos decidir usar o mesmo tipo de relés), desde Vee. está conectado ao
terminal de saída comum (DOCOM). Em uma saída do tipo sink (que não está
disponível com PM C), 0 Vis conectado ao terminal de saída comum e Vee vai
diretamente para os dispositivos de saída. Por isso, é possível usar
FIGURA 12.10 Fiação de saída para sinais DO do tipo fonte.

diferentes V cc com diferentes dispositivos. Este arranjo, no entanto, tem uma


séria desvantagem. Se, devido a alguma falha, o fio (no lado do PLC) de um
dispositivo de saída ficar aterrado, o dispositivo será ligado sem qualquer sinal
de saída. Portanto, a partir de considerações de segurança, as saídas do tipo
de fonte são preferenciais em relação às saídas do tipo coletor. Obviamente,
com o PMC, não há outra opção além das saídas do tipo fonte.
CAPITULO 13
Entrada de dados programável

13.1 Introdução

Esse recurso de uma máquina CNC não está realmente relacionado à


programação macro. Ele foi incluído neste texto porque é um recurso de
programação avançada do qual muitos programadores não estão cientes,
embora seja muito útil e seu uso seja bem direto. Como o nome sugere, a
entrada de dados programável, que é comandada pelo GIO, é usada para
gravar determinados dados no controle, como valores e parâmetros de
deslocamento. O GIO é um recurso opcional em algumas versões de controle,
que precisaria ser ativado se seu uso fosse desejado.

Este recurso não permite a leitura dos valores atuais de tais dados; só se pode
sobrescrever estes. As principais aplicações do G1O são dados de entrada
para:
• Distâncias de deslocamento para sistemas de coordenadas da peça
• Distâncias de deslocamento para sistemas adicionais de coordenadas da
peça em uma fresadora
• Valores de compensação em uma fresadora (comprimento e diâmetro)
• Valores de compensação em um torno valores radiais / axiais, raio da ponta e
número da ponta)
• Valores de parâmetros

G1O também pode ser usado para alimentar dados de gerenciamento de


ferramentas, como a vida útil da ferramenta e o número de correção. Isto, no
entanto, não é discutido neste capítulo, já que não é uma aplicação muito
comum.

Se o recurso de programação macro estiver disponível na máquina, o G1O não


será necessário na maioria dos casos. Isso ocorre porque as variáveis do
sistema para todas as distâncias do deslocamento e valores de compensação
estão disponíveis como variáveis de leitura / gravação (consulte a Seção 3.5).
De fato, as variáveis do sistema oferecem mais flexibilidade, uma vez que os
valores atuais armazenados neles também podem ser lidos, o que não é
possível com o G10. As variáveis do sistema estão disponíveis mesmo para
alguns dos parâmetros (embora muito poucos deles sejam cobertos). No
entanto, para os demais parâmetros e dados de vida da ferramenta, G1O tem
que ser usado, se seus valores forem alterados através de um programa.

O G10 pode ser usado nos modos absoluto e incremental, para especificar
distâncias de deslocamento e valores de compensação. No modo absoluto, os
valores especificados simplesmente sobrescrevem os valores existentes; no
modo incremental, os valores especificados são adicionados (com sinal) aos
valores existentes.
O efeito de G10 é permanente, isto é, permanece válido para todas as sessões
de usinagem subsequentes, até que os valores sejam alterados novamente
pelo G1O ou contrário.

13.2 Entrada de Dados para Distâncias de WCS Offset

Distâncias de deslocamento para sistemas de coordenadas de peça de


trabalho externos e G54 a G59 podem ser especificadas para cada eixo, em
modo absoluto ou incremental. A sintaxe é a mesma para ambos os torno e
fresadoras:

G10 L2 P_ X_ Y_ Z_;

Onde

L2 seleciona essa categoria de entrada de dados,


PO refere-se ao WCS externo,
P1 refere-se ao G54 WCS,
P2 refere-se ao GSS WCS,
P3 refere-se a G56 WCS,
P4 refere-se ao G57 WCS,
PS refere-se ao G58 WCS,
P6 refere-se ao G59 WCS,

X, Y e Z contêm os valores desejados para os respectivos eixos. Em uma


fresadora, o G90 / G91 precisaria ser comandado antes do G10, para
selecionar os modos absoluto / incremental. Em um torno, com o sistema G-
code A, X / Z são usados para valores absolutos e U / W para valores
incrementais (o eixo Y geralmente não está disponível em um torno mecânico).

O modo incremental é muito útil para corrigir as distâncias do deslocamento


pelo erro observado. Por exemplo, em uma fresadora, se desejar deslocar o
G54 WCS em 0,1 mm na direção Z negativa (de forma que a mesma
ferramenta agora usina em um nível de 0,1 mm nível anterior, sem modificar o
programa), pode-se comandar (no modo MDI, se o ajuste for feito apenas uma
vez)

G91 G10 L2P1 Z-0,1;

Claro, isso também pode ser feito através da variável de sistema associada
(consulte a Tabela 3.12):

# 5223 = # 5223 - 0,1;


Ambos os métodos têm o mesmo efeito. A seleção entre os dois é uma
questão de escolha individual. No entanto, se a opção de macro não estiver
ativada na máquina, o G10 deverá ser usado. Na verdade, o G10 também é um
recurso opcional, mas agora está normalmente disponível com o pacote de
controle padrão.

13.3 Entrada de Dados para Distâncias Adicionais de WCS Offset

Além dos seis padrões WCS, selecionáveis com G54 a G59, 48


WCS adicionais estão disponíveis opcionalmente em fresadoras (na verdade,
esta opção está disponível para até 300 WCS adicionais também). Esses são
invocado em um programa por

G54 1 P <n>;

ou simplesmente por

G54 P <n>;

onde n = 1 a 48.

Estes são referidos como primeiro WCS adicional, segundo adicional


WCS, e assim por diante, ton correspondente = 1, 2, .... Uma palavra P deve
ser
especificado com G54.1 / G54. Se não for especificado, P1 (implicando
primeiro
WCS adicional) é automaticamente assumido pelo controle.

As distâncias de deslocamento para estas podem ser especificadas de maneira


similar a
que usado no segundo. 13,2:
G10 L20 P_ X_ Y_ Z_;

Onde

L20 seleciona essa categoria de entrada de dados,


P1 refere-se ao primeiro WCS adicional,
P2 refere-se ao segundo WCS adicional,
...
...
P48 refere-se ao 48º WCS adicional,
X, Y e Z contêm os valores desejados para os respectivos eixos.
Ambos os modos absoluto e incremental podem ser usados. Como um
exemplo,
o seguinte comando mudaria o primeiro WCS adicional em 0,1 mm na direção
Z positiva:

G91 G10 L20 P1 Z0,1;

Isso, é claro, também pode ser feito através de variáveis do sistema (consulte
Tabela 3.12):

# 7003 = # 7003 + 0,1;

13.4 Entrada de Dados para Valores de Compensação em uma Fresadora

A descrição aqui fornecida refere-se à memória de compensação do tipo C


(também conhecida como memória de deslocamento do tipo C), usada nos
controles da série Oi. Os valores de compensação para comprimento (código-
H) e raio (código-D) de uma fresa podem ser especificados como descrito na
Tabela 13.1, onde a palavra-P define o número de correção (tipicamente, 1 a
400) e a palavra-R contém o valor de compensação correspondente. Para
fornecer compatibilidade com programas escritos para modelos de controle
mais antigos, o sistema permite que L1 seja especificado em vez de L11. O
intervalo de entrada permitido para valores de compensação, em IS-B
(Incremento do Sistema B), é dado na Tabela 13.2. O intervalo válido é muito
maior do que o que pode ser realmente necessário. Alguns exemplos são
dados abaixo. Note que as descrições dadas são válidas apenas quando estes
comandos são executados sequencialmente:

G90 G10 L1 2 P10 R5;


(Enters 5 mm into offset number 10, as the
geometry compensation value for
D-code, making the tool radius equal to 5 mm,
assuming that the wear value for the radius is
zero. Note that the D-code refers to the radius,
not to the diameter)

G91 G10 L12 P10 R5;


(Enters 5 mm incrementally into offset number
10, as the geometry compensation value for
the D-code, making the tool radius equal to 10
mm, which was 5 mm earlier)
G90 G10 L13 P10 R-0.5;
(Enters -0.5 mm into offset number 10, as the
wear compensation value for the D-code,
making the tool radius equal to 9.5 mm)

TABELA 13.2 O intervalo de entrada válido para valores de compensação em


IS-B

G91 G10 L13 P10 R-0. 05;


(Introduz -0,05 mm incrementalmente no
número de correção 10, como o valor de
compensação de desgaste para o código D,
alterando seu valor para -0,55, o que torna o
raio da ferramenta igual a 9,45 mm)
G90 G10 L10 P10 R-500;
(Insere -500 mm no offset número 10, como
valor de compensação da geometria para o
código H)
G91 G10 L10P10R5;
(Entra 5 mm incrementalmente no offset
número 10, como o valor de compensação da
geometria para o código H, tornando-o menor
em 5 mm, para se tornar -495 mm. Assim, a
mesma ferramenta cavaria 5 mm a menos na
peça de trabalho, pelo mesmo programa, se
G43 estiver sendo usado para compensação
de comprimento)
G91 G10 L11 P10 RO. 5;
(Introduz 0,5 mm incrementalmente no offset
número 10, como o valor de compensação de
desgaste para o código H. Assim, o valor de
desgaste aumentaria em 0,5 mm e, portanto,
a mesma ferramenta cavaria 0,5 mm a menos
na peça de trabalho, para o mesmo programa,
se G43 estiver sendo usado)
Obviamente, as variáveis do sistema também podem ser usadas para a mesma
funcionalidade.
Por exemplo, o primeiro e o último exemplos são, respectivamente, equivalente
a (consulte a Tabela 3.4)

# 13010 = 5;
# 10010 = # 10010 + 0,5;

13.5 Entrada de dados para valores de compensação em um torno

Geometria, bem como valores de desgaste para distâncias radiais / axiais,


nariz
radius, e o número da ponta pode ser especificado. Uma diferença dos
formatos descritos anteriormente é que nenhuma palavra L é usada para inserir
valores de compensação em um torno.

O formato é

G10 P_ X_ Y_ Z_ R_ Q_; (Modo absoluto)


G10 P_ u_ v_ w_ c_ Q_; (Modo incremental)

Onde:

PO refere-se a valores de turnos de trabalho, P1 a P64 referem-se a valores de


compensação de desgaste correspondentes aos números de correção 1 a 64
(supondo disponibilidade de 64 números de correção),
P10001 a P10064 referem-se a valores de compensação de geometria
correspondendo aos números de correção 1 a 64, X / U, Y / V (se o eixo Y
estiver disponível) e Z / W contêm os valores desejados para os respectivos
eixos no modo absoluto / incremental, o RIC contém raio de ponta em absoluto
/ incremental modo e Q contém o número da ponta (em ambos os modos). O
número da ponta ou o número da ponta foi arbitrariamente definido pela Fanuc
para diferentes orientações da ferramenta. A Figura 13.1 mostra os números de
ponta definidos pelo Fanuc em um torno tipo traseiro. Observe que o valor de
Q, especificado para um número de correção de geometria, atribui
automaticamente o mesmo valor ao número de correção de desgaste
correspondente e vice-versa. Em outras palavras, os valores de geometria e
compensação de desgaste para Q são sempre iguais. Este é um recurso de
segurança interno do controle que elimina a possibilidade de erro inadvertido
ao especificar o número da dica.

Nem todos os valores de compensação no bloco G10 precisam ser


especificados. Os valores não especificados permanecem inalterados. Alguns
exemplos são dados abaixo:

G10 P10010 X-100 WS; (Correspondente ao número de correção de geometria


10, isto é, na linha G10 na tela de correção de geometria, o valor de
compensação radial é definido em -100 mm e o valor de compensação axial é
aumentado em 5 mm. )
G10 P10 xo zo; (Correspondente ao número de correção de desgaste 10, os
valores de compensação radial e axial são definidos como zero. Em outras
palavras, os desvios de desgaste radial e axial são zerados, para a linha W10
na tela de deslocamento de desgaste)

G10 P10010 RO. 8 Q3; (Correspondente ao número de correção de geometria


10, ou seja, na linha G10 na tela de correção de geometria, o raio da ponta é
definido em 0,8 mm. O número da ponta é definido como 3 nas telas de
geometria e de correção de desgaste, correspondentes ao número de correção
10)

Neste caso também, é possível usar variáveis do sistema para ter o


mesmo resultado. Os três blocos GlO indicados acima podem ser substituídos
pelo
seguintes blocos (consulte a Tabela 3.2):

Para G10 P10010 X-100 W5; usar


# 2710 = -100;
# 2810 = # 2810 + 5;

Para G10 P10 XO ZO; usar


# 2010 = 0;
# 2110 = 0;

Para G10 P10010 R0.8 Q3; usar


# 2910 0,8;
# 2310 = 3;

Como outro exemplo, se for desejado limpar todos os 64 deslocamentos, o G10


pode ser executado em um loop. Se 99 compensações estiverem disponíveis,
basta substituir 64 por 99 no programa fornecido:

Nota:

1. O método usual de configuração de deslocamento estabelece o ponto


imaginário R como o ponto de referência da ferramenta. Existem oito
orientações possíveis deste ponto em relação ao centro da ponta C,
dependendo do tipo de ferramenta (esquerda, direita ou neutra) e sua
orientação em relação à peça de trabalho. Cada orientação recebeu um
número único de ponta da ferramenta, de 1 a 8.

2. Também é possível fazer o centro do nariz C o ponto de referência da


ferramenta. Isso é feito adicionando o raio da ponta ao valor Z e duas vezes o
raio da ponta ao valor X, enquanto mede as distâncias do deslocamento.
Nesse caso, o número de ponta de ferramenta atribuído é 0. Uma
desvantagem séria desse método é que esse tipo de configuração de
deslocamento não pode ser usado para usinagem sem compensação de raio
devido a erro excessivo, mesmo em torneamento direto e reto. O método usual
de ajuste de deslocamento garante que, pelo menos em curvas retas e retas,
não haverá erro devido ao raio da ponta, mesmo se a compensação de raio
não for usada.

FIGURA 13 .1 Números de ponta definidos por Fanuc para diferentes


orientações de ferramenta em um torno tipo traseiro.

08024 (LIMPAR COMPARTIMENTOS COM G10);

# 100 = 1; (Contador inicializado)


WHILE [# 100 LE 64] DO 1; (Início do loop)
G10 P # 100 X0 Z0 R0 Q0; (Limpa o deslocamento do desgaste)
G10 P [10000 + # 100] X0 Z0 RO QO; (Apaga a compensação de geometria)
# 100 = # 10 0 + 1; (Contador incrementado)
END 1; (Fim do loop)
M99; (Retorna ao programa de chamada)

A mesma coisa pode ser feita usando variáveis do sistema também, embora o
método G10 é mais simples neste caso:

08025 (APAGAR COMPENSAÇÕES COM SYSVAR);


# 100 = 1; (Contador inicializado)
WHILE [# 100 LE 64] DO 1; (Start of loop)
[# 2000 + # 100] = 0; (Clears X-axis wear offset)
[# 2100 + # 100] = 0; (Apaga o deslocamento do
desgaste do eixo Z)
[# 2200 + # 100] = 0; (Limpa o desgaste do raio do
nariz)
[# 2300 + # 100] = 0; (Apaga o número da dica)
[# 2700 + # 100] = 0; (Apaga o deslocamento da
geometria do eixo X)
[# 2800 + # 100] = 0; (Apaga a compensação da
geometria do eixo Z)
[# 2900 + # 100] = 0; (Apaga o desvio da geometria
do raio do nariz)
# 100 = # 100 + 1; (Contador incrementado)
END 1; (Fim do loop)
M99; (Retorna ao programa de
chamada)
FIGURE 13 .1 Números de ponta definidos por Fanuc para diferentes
orientações de ferramenta em um torno tipo traseiro.
Nota:

1. O método usual de configuração de deslocamento estabelece o ponto


imaginário R como o ponto de referência da ferramenta. Existem oito
orientações possíveis deste ponto em relação ao centro da ponta C,
dependendo do tipo de ferramenta (esquerda, direita ou neutra) e sua
orientação em relação à peça de trabalho. Cada orientação recebeu um
número único de ponta da ferramenta, de 1 a 8.

2. Também é possível fazer o centro do nariz C o ponto de referência da


ferramenta. Isso é feito adicionando o raio da ponta ao valor Z e duas vezes o
raio da ponta ao valor X, enquanto mede as distâncias do deslocamento.
Nesse caso, o número de ponta de ferramenta atribuído é 0. Uma
desvantagem séria desse método é que esse tipo de configuração de
deslocamento não pode ser usado para usinagem sem compensação de raio
devido a erro excessivo, mesmo em torneamento direto e reto. O método usual
de ajuste de deslocamento garante que, pelo menos em curvas retas e retas,
não haverá erro devido ao raio da ponta, mesmo se a compensação de raio
não for usada.

13.6 Entrada de dados para valores de parâmetros

Até agora, os leitores podem ter ficado com a impressão de que não há
necessidade de usar o G10 se a opção de programação macro estiver
disponível na máquina. O método de variável de sistema, no entanto, é limitado
apenas ao que já foi discutido até agora. A maioria dos parâmetros não possui
variáveis de sistema associadas. Portanto, G10 é o único método para alterar
parâmetros através de um programa. Tal uso de G10 é frequentemente referido
como entrada de parâmetro programável. Uma diferença das aplicações
anteriores do G10 é que ele se comporta como um código modal, quando
usado para entrada de parâmetros. Uma vez que ele entra no modo de entrada
de parâmetros, tantos parâmetros quantos desejados podem ser inseridos em
blocos subsequentes, até que este modo seja cancelado por G11. Outra
diferença é que nenhum valor decimal é permitido. Portanto, se o parâmetro se
relacionar com alguma distância do eixo, o valor deve ser especificado no
menor incremento de entrada (ou seja, em microns no modo milimetrado e em
etapas de 0,0001 polegadas no modo polegadas). Observe que, se o mesmo
parâmetro também tiver uma variável do sistema definida para ele, o valor
milímetro ou polegada (conforme apropriado) será usado nessa variável.

Observe que os valores de parâmetros mais adequados para a maioria dos


casos já estão definidos pelo MTB. Qualquer alteração nesses valores não é
recomendada, pois uma configuração incorreta pode resultar em um
comportamento imprevisível, possivelmente perigoso, da máquina, causando
ferimentos ao operador ou danos à máquina ou a ambos. No entanto, certos
parâmetros, como os limites de ultrapassagem de software, seleção do sistema
G-code (A, B ou C) em um torno, posicionamento em linha reta com G00,
entrada de dados do tipo calculadora (de modo que X10, por exemplo, é
interpretado como 10 mm, não como 10 μm), etc. pode precisar ser alterado
para se adequar a uma aplicação específica. No entanto, em tais casos,
primeiro anote as configurações originais antes de fazer qualquer alteração,
para que possa reverter para os valores originais, no caso de qualquer
configuração incorreta. Qualquer alteração deve ser feita por uma pessoa
experiente, depois de estudar cuidadosamente o parâmetro que se pretende
alterar. A descrição completa de todos os parâmetros pode ser encontrada no
Manual de Parâmetros fornecido com a máquina. Discussões adicionais
exigem uma compreensão clara dos tipos de parâmetros. Existem, em termos
gerais, quatro tipos de parâmetros: tipo de bit (dados permitidos 0 ou 1), tipo de
byte (faixa de dados admissível -128 a 127 ou 0 a 255), tipo de palavra
(intervalo de dados admissíveis -32.768 a 32.767 ou 0 a 65.535) e tipo de duas
palavras (faixa de dados permitida -99.999.999 a 99.999.999). Os parâmetros
do tipo de bit possuem linhas de oito bits (bit # 0 na extrema direita e bit # 7 na
extrema esquerda). Alguns parâmetros do tipo bit possuem várias linhas de oito
bits em cada linha, correspondendo a cada eixo da máquina. Vários outros
tipos de parâmetros também possuem várias linhas para diferentes eixos. Em
um torno de dois eixos, a primeira linha corresponde ao eixo X e a segunda
linha ao eixo Z. Em uma fresadora de três eixos, as três linhas correspondem
aos eixos X, Y e Z, respectivamente. Tais parâmetros são chamados de
parâmetros do tipo eixo. Para fins de utilização efetiva da memória, diferentes
tipos de parâmetros são usados para diferentes aplicativos. Por exemplo, I / 0
CHANNEL é um parâmetro do tipo byte, enquanto os parâmetros para
configuração de software overtravellirnits (distâncias em mícrons, no sistema
de coordenadas da máquina) são parâmetros de duas palavras. O formato da
entrada de parâmetro programável é o seguinte:

G10 L50; (O modo de entrada de parâmetro é iniciado)

N_R_; (Para parâmetros diferentes do tipo de eixo)

NPR_; (Para parâmetros do tipo eixo)

...

... (Entrada de múltiplos parâmetros é permitida)

...

G11; (Modo de entrada de parâmetro termina)


Onde

L50 seleciona o modo de entrada de parâmetros,

N contém o número do parâmetro,

P contém o número do eixo (usado apenas para parâmetros do tipo eixo),

R contém o valor especificado do parâmetro.

NOTA:

1. Em um parâmetro do tipo bit, não é possível alterar um único bit


independentemente. Todos os oito bits devem ser especificados.

2. Um decimal não pode ser usado no valor especificado na palavra - R.

3. Outras declarações NC não podem ser especificadas entre G10 LSO e G11.

4. Se um ciclo fixo estiver sendo usado, ele deve ser cancelado antes
comandando o G10 LSO.

5. Para os parâmetros do tipo eixo, Pl refere-se à primeira linha, P2 à segunda


linha e assim por diante.

6. Inserir números de sequência no formato dado é permitido.

Se duas palavras N aparecerem em um bloco, o da esquerda é considerado o


número de sequência e o outro número de parâmetro.

Exemplo 1 (parâmetro do tipo de palavra):

O G-eode que chama o número de programa de macro personalizado 09010 é


armazenado no parâmetro 6050, tanto no torno como na máquina de fresagem.
Portanto, se for desejado chamar 09010 por, digamos, G100 (qualquer valor de
1 a 9999 pode ser selecionado; observe que o intervalo aceitável de um
parâmetro de tipo de palavra é maior que o intervalo definido para o parâmetro
6050), 100 precisaria para ser armazenado no parâmetro 6050. Isso pode ser
feito
G10 L50;

N6050 R100;

G11;

Exemplo 3 (parâmetro do tipo byte):

Se uma placa PCMCIA compacta é desejada para ser usada como um


dispositivo de memória externo, o parâmetro 0020 precisaria armazenar 4, em
ambos os torno e fresadoras. O intervalo permitido deste parâmetro é de 0 a 35
(que é menor que o intervalo definido para um parâmetro do tipo byte). A
mudança desejada pode ser feita

G10 L50;
N20 R4;
G11;

Ao especificar o número do parâmetro, zeros à esquerda podem ser omitidos.


Portanto, N20 e N0020 são equivalentes neste exemplo.

Exemplo 4 (parâmetro do tipo de bit):

É desejável usar uma entrada decimal do tipo calculadora para distâncias (de
modo que, por exemplo, X10 é interpretado como 10 mm, não como 10 μm).
Parâmetro 3401 # 0 (que significa bit # 0, o da extrema direita, do parâmetro
3401) é necessário para ser definido como 1. Para isso, o método G10 L50
requer que todos os oito bits sejam especificados, mesmo se a mudança em
apenas um bit for necessário vamos assumir que a configuração atual do
parâmetro 3401 em um torno é 00000010 (é preciso descobri-lo; não há saída).

Isso precisaria ser alterado para 00000011, o que pode ser feito

G10 L50;
N3401 ROOOOOO11;
G11;

Note que zeros à esquerda na palavra R não podem ser omitidos.


Exemplo 5 (Parâmetro Bit-Axis-Type):

O G51 / G51.1 está disponível em uma fresadora para espelhamento de um


caminho de ferramenta selecionado. Se, no entanto, desejar sempre ter
espelhamento para, digamos, o eixo X, isso pode ser feito mais
convenientemente definindo o parâmetro 0012 # 0 para 1 para o eixo X, o que
evitaria a necessidade de usar G51 / G51 .1 para espelhamento. Vamos supor
que a configuração atual do parâmetro 0012 seja 00000000, na primeira linha
(ou seja, para o eixo X). Isso precisaria ser alterado para 00000001, para o
espelhamento do eixo X. A mudança pode ser feita por

G10 L50;
N12 P1 ROOOOOOO1;
G11;

Outra maneira mais simples de fazer isso é usar a variável de sistema para
espelhamento,

# 3007 (ver Tabela 3.9):


# 3007 = 1;

Uma alteração no parâmetro 0012 # 0 altera automaticamente a variável #


3007 e vice-versa. Em geral, se uma variável de sistema correspondente a um
parâmetro estiver disponível, não há necessidade de usar G10, já que o
método de variável de sistema seria mais simples. Além disso, lendo as
variáveis do sistema, também é possível conhecer as configurações atuais
(para qual pode reverter, se assim o desejar), o que não é possível com
parâmetros que só podem ser sobrescritos com novos valores (se a mudança
através de um programa for desejada).

Na verdade, o G10 é um recurso antigo que veio antes da introdução da


programação de macro. Agora, perdeu sua relevância em muitos casos.

Uma Limitação do Método L50 G10 Uma vez que um parâmetro é alterado, não
há como ele ser revertido ao seu valor original, a menos que saibamos seu
valor de troca. (Então podemos usar G10 L50 novamente com os valores
originais.) G10 L50 somente sobrescreve um parâmetro com um novo valor
(es). De fato, isso é verdade para todas as aplicações do G10. Não é possível
"desfazer" um G10. Embora alterações incorretas em outros aplicativos
possam não ter sérias implicações, a configuração incorreta dos parâmetros
pode ser extremamente perigosa. Portanto, extremo cuidado deve ser exercido
durante o uso de G10 L50. De fato, como regra geral, não se deve brincar com
os parâmetros, a menos que seja absolutamente necessário, e compreende-se
completamente a função do parâmetro que será mudado. Para estar no lado
mais seguro, deve-se sempre manter um backup das configurações originais
de todos os parâmetros. Se você não tiver um dispositivo de memória externa
(como um cartão flash compacto) ou conexão RS-232 em sua máquina, ou
simplesmente não souber como fazer o backup, anote todos os valores de
parâmetro em um pedaço de papel. E mantê-lo em um lugar seguro. Uma ou
duas horas gastas hoje podem um dia economizar semanas de inatividade na
máquina!