Chapter 18 Macro Reference - En.pt PDF

Referência macro
Capítulo 18 Referência Macro .............................................. ............................................... 2

18.1 Instruções para o Editor de Macro ............................................ .............................. 2
18,2 Construção Macro ............................................... ............................................ 11
18,3 Sintaxe ................................................ .................................................. ............. 12
18.3.1 constantes e variáveis ............................................ ............................. 12
18.3.1.1Constants .............................................. ........................................ 12
18.3.1.2 Variáveis .............................................. ......................................... 12
18.3.2 Operadores .............................................. .................................................. 14
18.4 Declaração ................................................ .................................................. ....... 17
18.4.1 Declaração de Definição ............................................. .................................. 17
18.4.2 instrução de atribuição ............................................. ............................... 17
18.4.3 declarações lógicas ............................................. .................................... 17
18.4.4 Demonstrações selectivos ............................................. ................................. 19
18.4.5 Demonstrações reiterativa ............................................. .............................. 21

18.4.5.1 para a próxima Demonstrações ........................................... ........................... 21
18.4.5.2 Demonstrações enquanto Wend-........................................... ..................... 22
18.4.5.3 outros comandos de controlo ............................................ ................. 23

18,5 Blocos Funcionais ............................................... ................................................. 24
18.6 Build-In Bloco Funcional ............................................ ......................................... 27
18.6.1 Funções matemáticas ............................................. ............................. 27
18.6.2 Data Transformation ............................................. .................................. 33
18.6.3 Manipulação de Dados ............................................. ...................................... 38
18.6.4 Transformação Bit ............................................. ..................................... 41

18.6.5 Comunicação .............................................. ......................................... 43
18.6.6 Diversos .............................................. ........................................... 59
18.7 Como criar e executar uma macro .......................................... ...................... 62
18.7.1 Como criar uma macro .......................................... ................................. 62
18.7.2 Executar uma macro ............................................ ......................................... 67
18.8 Algumas Notas sobre o uso do Macro ........................................... ...................... 68
18.9 Use o Protocolo gratuito para controlar um dispositivo ......................................... ............... 69
18.10 Mensagem de erro Compiler .............................................. ................................... 75

18.11 Código de macro de exemplo .............................................. ......................................... 81
18.12 Função TRACE Macro .............................................. .................................... 86
1
Referência macro
Capítulo 18 Referência Macro
Macros fornecer a funcionalidade adicional sua aplicação pode precisar. As macros são automatizado sequências de
comandos que são executados em tempo de execução. Macros permitem que você execute tarefas como operações
complexas de escala, manipulação de strings e interações do usuário com seus projetos. Este capítulo descreve a sintaxe,
uso e métodos de programação de comandos de macro.
18.1 iões Instruir à macro tor Edi
1. editor macro fornece as seguintes novas funções:
uma. exibindo número da linha
b. Desfazer refazer
c. Cut / Copy / Paste
d. Selecionar tudo
e. Alternar marcador / Anterior Bookmark / Next Bookmark / Limpar Todos os Favoritos
f. Alternar Todos Outlining
As instruções abaixo mostram como usar essas novas funções.
2. Abra o editor de macro; você vai ver os números de linha exibidos no lado esquerdo da edição
área.
2
Referência macro
área de edição
3. Botão direito do mouse na área de edição para abrir o menu pop-up, como mostrado abaixo:
3
Referência macro
Os itens com deficiência são de cor cinza, que indica que não é possível usar essa função no estado actual do editor. Por
exemplo, você deve marcar uma área selecionada para ativar a função de cópia, caso contrário ele será desativado.
Aceleradores são suportados como descrito no menu.
4. Acima da área de edição localiza a barra de ferramentas. Ele fornece “Desfazer”, “Refazer”, “Cut”, “Copiar”, “Colar”,
“Toggle Bookmark”, “Next Bookmark”, “Favorito Anterior” e “Limpar Todos os Favoritos” botões para uso
imediato.
5. Modificações feitas para o editor irá habilitar a função de desfazer. função Refazer será ativado
após a tomada da ação de desfazer. Para executar a ação de desfazer / refazer, clique direito para selecionar o item ou usar o acelerador
(Undo: Ctrl + Z, Refazer: Ctrl + Y).
Desfazer
Desfazer
4
Referência macro
refazer
refazer
6. Escolha uma palavra no editor para habilitar a função de corte e cópia. Após corte ou cópia é feita,
a função colar está habilitado.
5
Referência macro
7. Use “Selecionar Tudo” para incluir todo o conteúdo na área de edição.
6
Referência macro
8. Se o código de macro vai muito longo, para facilitar a leitura, os favoritos são fornecidos. a ilustração
abaixo mostra como ele funciona.
uma. Mova o cursor para a posição na área de edição onde inserir um marcador. Certo
clique, selecione “Alternar Bookmark”. Haverá um pequeno quadrado azul que representa um marcador no lado
esquerdo da área de edição.
b. Se já existe um marcador onde o cursor é colocado, selecione “Alternar Bookmark” para fechá-la, caso contrário,
para abri-lo.
c. Botão direito do mouse e selecione “Next Bookmark”, o cursor irá se mover para onde o próximo marcador localiza. A
seleção de”Bookmark Anterior” irá mover o cursor para o favorito anterior.
7
Referência macro
próxima Bookmark
próxima Bookmark
próxima Bookmark
d. Selecionando “Limpar Todos os Favoritos” irá fechar todos os marcadores.
9. editor macro fornece código de macro função de delinear, para facilitar a visualização. Esta função é
esconder códigos macro que pertencem ao mesmo bloco, e exibi-los com um ícone. Lá
será um diagrama de árvore no lado esquerdo da área de edição. Os usuários podem clicar para esconder o bloco ou
a abrir, como mostrado abaixo:
8
Referência macro
Pressione para delinear para o próximo
Pressione para delinear se então bloco
10. Botão direito do mouse para selecionar “Alternar Todos Destaques” para abrir todos os blocos de código de macro.
9
Referência macro
11. Às vezes o delineamento pode ser incorrecta, uma vez que as palavras-chave são oprimidos. Para
exemplo:
Para resolver este problema , clique direito para selecionar “Update All Destaques” para recuperar delineamento correto.
12. As instruções entre as palavras-chave são chamados de um “bloco” do código de macro:
uma. O bloco de funes: sub - sub extremidade
b. declarações reiterativa:
Eu. a seguir
ii. enquanto - Wend
c. declarações lógicas:
Eu. se - final, se
d. declarações seletivos: selecione caso - End Select
10
Referência macro
18.2 Construção de iões macro
Um Macro é composta de declarações. As declarações contêm constantes, variáveis e operações. As demonstrações são
colocados em uma ordem específica para criar a saída desejada.
Um Macro é construído da seguinte maneira:
Declaração de variável global ---------------------------------- - Opcional
Declarações de função Bloco sub ----------------------------------- Opcional

Local Variável declarações End
Sub
macro_command principal () ----------------------------------- - Requeridos

Declarações de variáveis locais
[Demonstrações]
macro_command final ----------------------------------- - Requeridos
Macro deve ter uma e apenas uma função principal, que é o ponto de início de execução da macro. O formato é:
macro_command Function_Name ()
fim macro_command
As variáveis locais são usadas dentro do principal função macro ou em um bloco de funções definido. Seu valor permanece válida
apenas dentro do bloco específico.
As variáveis globais são declaradas antes de todos os blocos de função e são válidos para todas as funções na macro. Quando
as variáveis locais e variáveis globais têm a mesma declaração de nome, apenas as variáveis locais são válidos.
O exemplo abaixo é uma macro simples que inclui uma declaração variável e uma função de chamada.
macro_command principal ()
curta pressão = 10 // declaração de variável local
SetData (pressão, "Allen-Bradley DF1", N7, 0, 1) // função de chamada
macro_command final
11
Referência macro
18,3 Sintaxe
18.3.1 constantes e variáveis
18.3.1.1Constants
Constantes são valores fixos e podem ser escritos diretamente em declarações. O formato é como abaixo:
Tipo constante Nota Exemplo

decimal inteiro 345, -234, 0, 23456
hexadecimal Deve começar com 0x 0x3b, 0xffff, 0x237
ASCII Cadeia deve ser colocado entre aspas simples 'A', 'dados', 'nome'
boleano verdadeiro falso
Exemplo de algumas declarações usando constantes:
macro_command principal () curta
A, B // A e B são variáveis
A = B = 1234
0x12 // 1234 e 0x12 são constantes
macro_command final
18.3.1.2 Variáveis
Variáveis são nomes que representam informações. As informações podem ser alteradas conforme a variável é modificada
por declarações.
Regras de Nomenclatura para as variáveis
1. Um nome de variável deve começar com um alfabeto.
2. Os nomes das variáveis mais de 32 caracteres não são permitidos.
3. As palavras reservadas não podem ser usados como nomes de variáveis.
Existem 8 tipos de variáveis diferentes, 5 para tipos de dados assinados e 3 para tipos de dados não assinados:
12
Referência macro
Tipo de variável Descrição Alcance
bool Um pouco (discreta) 0, 1

Caracteres 8 bits (byte) ± 127
baixo 16 bits (palavras) ± 32.767
int 32 bits (palavra dupla) ± 2147418112
flutuador 32 bits (palavra dupla)
caracter não identifcado 8 bits (byte) 0 a 255

unsigned short 16 bits (palavras) 0-65535
int não assinado 32 bits (palavra dupla) 0 a 4294967295
declarando variáveis
Variáveis devem ser declaradas antes de serem utilizados. Para declarar uma variável, especificar o tipo antes do nome da
variável.
Exemplo:
int um
curto b, interruptor
flutuador unsigned
short pressão c
declarando Arrays
Macros apoiar matrizes unidimensionais (índice de base zero). Para declarar uma matriz de variáveis, especificar
o tipo e o nome da variável seguido pelo número de variáveis na matriz entre colchetes “[]”. Arrays são de 1 a
4096 variáveis de comprimento. (Macros só suportam até 4096 variáveis per macro).
Exemplo:
int um [10]
curto b [20], interruptor [30]
flutuador pressão [15]
Mínimo de índice de matriz é 0 e o máximo de índice de matriz é (tamanho da matriz - 1).
Exemplo:
char data 100] // tamanho da matriz é 100
onde: mínimo de índice de matriz é 0 e o máximo de índice de matriz é 99 (100 - 1)
13
Referência macro
Inicialização variável e matriz

Há duas maneiras variáveis podem ser inicializados:
1. Em declaração usando o operador de atribuição (=)
Exemplo:
int um
flutuador b [3]
a = 10 b [0] = 1
2. Durante declaração char a

= '5', b = 9
A declaração de matrizes é um caso especial. toda a matriz pode ser inicializado durante declaração
colocando valores separados por vírgulas dentro de chavetas “{}”.
Exemplo:
flutuar dados [4] = {11, 22, 33, 44} // Agora, os dados [0] é de 11, dados [1] é 22 ....
18.3.2 Operadores
Operações são usados para designar como os dados devem ser manipulados. Em cada declaração, o operador da esquerda
está definida para as condições à direita.
Operador Descrição Exemplo

= operador de atribuição pressão = 10
Arithmetic Operators Descrição Exemplo

+ Adição A=B+C
- Subtração A=B-C
* Multiplicação A=B*C
/ Divisão A=B/C
% divisão Modulo (retorno A = B% 5
restante)
14
Referência macro
Operadores de Descrição Exemplo

comparação
< Menos que Se a <10, em seguida, B = 5
<= Menos que ou igual a se A <= 10, em seguida, B = 5
> Melhor que se A> 10 então B = 5
>= Melhor que ou igual a se A> = 10 = B, em seguida 5
== Igual a se A == 10, em seguida, B = 5
<> Não igual a Se a <> 10, então B = 5
Operadores lógicos Descrição Exemplo

E E lógico Se a <10 e B> 5 então C = 10
Ou lógico OR se A> = 10 ou B> 5 = C, em seguida 10
Xor Lógico OU exclusivo se A XOR 256, em seguida, B = 5
Não NÃO lógico Se não for um B, em seguida 5 =
operadores de deslocamento e bit a bit são usados para manipular bits dentro char, curto, e tipos de variáveis int com ambas
assinadas e sem sinal. A prioridade destes operadores é da esquerda para a direita dentro da instrução.
operadores de deslocamento Descrição Exemplo

<< Desloca os bits em uma bitset para a esquerda de A = B << 8
um determinado número de posições
>> Desloca os bits em um bitset à direita um A = B >> 8

número especificado de posições
Operadores bit a bit Descrição Exemplo

& bit a bit E A = B & 0xf
| OR bit a bit A=B|C

^ bit a bit XOR A=B^C
~ complemento um do A=B~
15
Referência macro
Prioridade de todos os operadores
A prioridade geral de todas as operações do maior para o menor é a seguinte:
Operações entre parênteses são realizadas primeiras

operações aritméticas Shift e Comparação operações bit a bit
Atribuição operações lógicas operações
Palavras-chave reservadas
As palavras-chave são reservados para uso Macro. Eles não podem ser usados para nomes variável, matriz ou
função.
+ , -, *, /,%,> =,>, <=, <, <>, ==, e, OR, XOR, não, <<, >>, =, &, |, ^, ~
saída, macro_command, para, para, para baixo, passo, em seguida, retorno, bool, short, int, char, float, nula, se, então, o resto, pausa,
continue, jogo, sub, final, enquanto, wend, é verdade, falso
SQRT, Cubert, LOG, LOG10, SIN, COS, TAN, COT, SEC, CSC, ASEN, ACOS, ATAN, BIN2BCD, BCD2BIN,
DEC2ASCII, FLOAT2ASCII, HEX2ASCII, ASCII2DEC, ASCII2FLOAT, ASCII2HEX, FILL, RAND, ATRASO,
SWAPB, SWAPW, LOBYTE, HIBYTE, LOWORD, HIWORD, GETBIT, SETBITON, SETBITOFF, INVBIT,
ADDSUM, XORSUM, CRC, INPORT, OUTPORT, POW, getError, GetData, GetDataEx, SetData, SetDataEx,
SetRTS, GetCTS, Beep, SYNC_TRIG_MACRO, ASYNC_TRIG_MACRO, VESTÍGIO
16
Referência macro
18.4 Declaração
Declaração 18.4.1 Definição
Isto cobre a declaração de variáveis e matrizes. A construção formal é a seguinte:

tipo nome onde definir o tipo de nome
Exemplo:
int A // definir uma variável A como um número inteiro
Tipo de nome [constante] em que definem o tipo de nome de matriz
Exemplo:
int B [10] onde definir uma variável B, tal como uma matriz unidimensional de
tamanho 10
Declaração 18.4.2 Atribuição
instruções de atribuição usar o operador de atribuição de mover dados a partir da expressão no lado direito do operador
para a variável no lado esquerdo. Uma expressão é a combinação de variáveis, constantes e os operadores para se
obter um valor.
Variável = Expressão
Exemplo
A=2 onde uma variável A é atribuído a dois
18.4.3 declarações lógicas
declarações lógicas executar ações, dependendo da condição de uma expressão booleana. A sintaxe é como se
segue:
17
Referência macro
Format-Linha
se < condição> então
[Afirmações]
outro
[Afirmações]
fim se
Exemplo:
se um == 2, em seguida
b=1
else
b=2
fim se
bloco Format
Se < condição> então
[Afirmações]
else if < Condição - n> então
[Afirmações]
outro
[Afirmações]
fim se
Exemplo:
se um == 2, em seguida
b = 1 else if
um == 3
b=2
else
b=3
fim se
descrição de sintaxe:
E se Deve ser utilizado para iniciar a declaração
<Condição> Requeridos. Esta é a declaração de controle. É falso quando o

<Condição> avalia a 0 e TRUE quando for avaliado como diferente de zero.
18
Referência macro
então Deve preceder as declarações para executar se a <condição> avaliada como TRUE.
[Afirmações] É opcional em formato de bloco, mas necessária em formato de linha única, sem mais. A
instrução será executada quando o <Condition> é TRUE.
else if Opcional. A instrução else if será executado quando o parente <Estado-n> é

TRUE.
<Estado-n> Opcional. veja <condição>
outro Opcional. A outra declaração será executada quando <condição> e <Estado-n> são
ambas falsas.
fim se Deve ser usado para terminar uma declaração if-then.
18.4.4 Demonstrações selectivos
A construção select-caso pode ser utilizado para executar grupo selectivo de acções dependendo do valor de uma dada
variável. As acções no âmbito do caso combinado são executadas até que um comando pausa é lido. A sintaxe é como
se segue.
caso padrão formato livre
Selecionar caso [ variável]
caso [ valor]
[Afirmações]
quebrar
final Selecione
Exemplo:
Selecione Caso A
Caso 1
b=1
ruptura final
Select
Formato caso padrão
caso [ valor]
[Afirmações]
quebrar Caso
outra pessoa
19
Referência macro
[Afirmações]
pausa
end Select
Exemplo:
Selecione Caso A
Caso 1
b=1
Caso pausa
pessoa
b=0
ruptura final
Select
casos múltiplas no mesmo bloco
caso [ value1]
[Afirmações]
caso [ value2]
[Afirmações]
pausa
end Select
Exemplo:
Selecione Caso A
Caso 1
Caso 2
b=2
Caso 3
b=3
ruptura final
Select
Selecionar caso Deve ser utilizado para iniciar a declaração
[variável] Requeridos. O valor desta variável será comparado com o valor de
20
Referência macro
cada caso.
Case else Opcional. Representa o caso padrão. Se nenhum dos casos acima são correspondidos, pelas
afirmações feitas em caso padrão será executado. Quando um caso padrão está ausente, ele irá saltar
directamente para o fim das declarações select-caso, se não há nenhum caso correspondido.
pausa Opcional. As demonstrações no âmbito do caso combinado será executado até que o comando de interrupção
é atingido. Se um comando de pausa está ausente, ele simplesmente continua a executar próxima declaração
até que o comando final seja alcançado.
end Select Indica o fim das declarações select-caso
18.4.5 Demonstrações reiterativa
declarações reiterativa controlar loops e tarefas repetitivas, dependendo das condições. Existem dois tipos de
declarações reiterativa.
18.4.5.1 para a próxima Demonstrações
O para-próxima construção é por etapas através de um número fixo de iterações. Uma variável é utilizado como um contador para
controlar o progresso e teste para terminando condições. Utilize este para a contagem de execução fixos. A sintaxe é como se segue:
para [ Contador] = <StartValue> para < EndValue> [ passo < StepValue>]
[Afirmações]
Próximo [ Contador]
ou
para [ Contador] = <StartValue> baixo < EndValue> [ passo < StepValue>]
[Afirmações]
Próximo [ Contador]
Exemplo:
para a = 0 a 10 etapa 2
b = a um
lado
21
Referência macro
para Deve ser utilizado para iniciar a declaração
[Contador] Requeridos. Esta é a declaração de controle. O resultado da avaliação da variável é utilizado como
um ensaio de comparação.
<StartValue> Requeridos. O valor inicial de [Contador]

para baixo Requeridos. Isso determina se o <step> aumenta ou diminui o <Contra>.
“Para” incrementos <Contra> por <StepValue>. “Down”

decréscimos <Contra> por <StepValue>.
<EndValue> Requeridos. O ponto de teste. Se o <Contra> for maior que esse valor, o
macro sai do loop.
degrau Opcional. Especifica que uma <StepValue> que não é para ser usado.
[StepValue] Opcional. A etapa de incremento / decréscimo de <contador>. Ele pode ser omitida
quando o valor é 1 Se [passo <StepValue>] são omitidos os padrões valor etapa a 1.
[Afirmações] Opcional. Demonstrações para executar quando a avaliação é TRUE. "a seguir"
laçadas podem ser aninhados.
Próximo Requeridos.
[Contador] Opcional. Isto é usado quando o aninhamento para-próximos laçadas.
18.4.5.2 Demonstrações enquanto Wend-
A construção while-wend é para percorrendo um número desconhecido de iterações. Uma variável é utilizada para testar
para terminando condições. Quando a condição for verdadeira, as instruções são executadas repetidamente até que a
condição se torna falsa. A sintaxe é como se segue.
enquanto < condição>
[Afirmações]
dirigir-se
Exemplo:
enquanto a <10
a = a + 10
wend
22
Referência macro
enquanto Deve ser utilizado para iniciar a declaração
continuar Requeridos. Esta é a declaração de controle. Quando for TRUE, o loop começa a
execução. Quando for FALSE, o loop termina.
valor de retorno] Demonstrações para executar quando a avaliação é TRUE.
dirigir-se Indica o fim das demonstrações while-end
18.4.5.3 comandos de controlo Outros
pausa Usado em para a próxima e while-wend. Ele salta imediatamente para o fim da instrução
reiterativa.
continuar Usado em para a próxima e while-wend. Ele termina a iteração atual de um ciclo e começa a
próxima.
Retorna O comando de retorno dentro do bloco principal pode forçar a macro para parar em qualquer lugar. Ele
salta imediatamente para o fim do bloco principal.
23
Referência macro
18,5 Blocos de iões Funct
Os blocos de função são úteis para reduzir os códigos repetitivas. Ele deve ser definido antes de usar e suporta qualquer
tipo variável e comunicado. Um bloco de função é chamada, colocando seu nome seguido por parâmetros, entre
parênteses, na função Macro principal. Após o bloco de função é executado, ele retorna o valor para a função principal,
onde ele é usado como uma atribuição ou condição. Um tipo de retorno não é necessária definição de função, o que
significa que um bloco de função nem sempre é necessário para retornar um valor. Os parâmetros também podem estar
ausentes em definição de função enquanto a função não tem nenhuma necessidade de tomar quaisquer parâmetros da
função principal. A sintaxe é como se segue:
Definição de função com tipo de retorno:
sub digite <name> [(parâmetros)]

declarações de variáveis locais
[Demonstrações] [ Retorna [ valor]]
fim sub
Exemplo:
sub int Adicionar (int x, int y)
int resultado final sub
resultado = x + y
resultado de retorno
int a = 10, b = 20, soma soma =
Adicionar (a, b) ou macro_command
final:
sub int Adicionar ()
int resultado, x = 10, y = 20
resultado = x + y resultado de retorno
sub extremidade
24
Referência macro
soma soma int = Adicionar ()
macro_command extremidade
Definição de função sem tipo de retorno:
sub < name> [(parâmetros)]

declarações de variáveis locais
[Demonstrações]
fim sub
Exemplo:
sub Adicionar (int x, int y)
int resultado
resultado = x + y sub
extremidade
int a = 10, b = 20
Adicionar (a, b) ou
macro_command final:
sub Adicionar ()
int resultado, x = 10, y = 20
resultado = x + y sub extremidade
25
Referência macro
Adicionar()
macro_command final
sub Deve ser utilizado para iniciar o bloco de função
tipo Opcional. Este é o tipo de dados do valor que a função retorna. Um bloco de função nem
sempre é necessário para retornar um valor.
(parâmetros) Opcional. Os parâmetros têm valores que são passados para a função pelo Macro
principal. Os parâmetros passados devem ter o seu tipo declarado no campo de
parâmetro e atribuído um nome de variável. Por exemplo: int sub MinhaFunção (int x, int
y). x e y seria inteiros passados para a função pelo Macro principal. Esta função é
chamada por uma instrução que é semelhante a este: ret = MyFunction (456, pressão),
onde “pressão” deve ser inteiro de acordo com a definição de função.
Observe que a instrução de chamada pode passar valores ou variáveis codificados para
a função. Após esta função é executada, um valores inteiros é voltar a 'ret'.
declaração de Variáveis que são usadas no bloco de função devem ser declarados em primeiro lugar. Isto é,
variável local além de parâmetros passados. No exemplo acima de x e y são variáveis que a função pode
utilizados. As variáveis globais também estão disponíveis para uso no bloco de função.
[Afirmações] Demonstrações para executar
[valor de retorno]] Opcional. Usado para retornar um valor para a instrução de chamada. O valor que
pode ser uma constante ou uma variável. Retorno também termina a execução do bloco de
função. Um bloco de função nem sempre é necessário para retornar um valor, mas, quando o tipo
de retorno é definido no início da definição da função, é necessário o comando de retorno.
sub end Deve ser utilizado para terminar um bloco de função.
26
Referência macro
18,6 Bui LD- Em Funct Bloco ião
EasyBuilder8000 tem algumas funções de compilação-in para recuperar e transferir dados para o PLC, gerenciamento
de dados e funções matemáticas.
18.6.1 Funções Matemáticas
Nome SQRT
Sintaxe SQRT (fonte, resultado)
Descrição Calcular a raiz quadrada de fonte em resultado.

Fonte pode ser uma constante ou uma variável, mas resultado deve ser uma variável. Fonte deve ser
um valor não negativo.
Exemplo macro_command principal) fonte
flutuador (, resultar
SQRT (15, resultado)
fonte = 9,0
SQRT (fonte, resultado) // resultado é 3,0
macro_command final
Nome Cubert
Sintaxe Cubert (fonte, resultado)
Descrição Calcular a raiz cúbica de fonte em resultado.
Fonte pode ser uma constante ou uma variável, mas resultado deve ser uma variável. Fonte deve ser
um valor não negativo.
Cubert (27, resultado) // resultado é 3,0
fonte = 27,0
Cubert (fonte, resultado) // resultado é 3,0
macro_command final
27
Referência macro
Nome prisioneiro de guerra
Sintaxe POW (source1, source2, resultado)
Descrição Calcule source1 elevado à potência de source2.

Source1 e source2 pode ser uma constante ou uma variável, mas resultado deve ser uma variável.
Source1 e source2 deve ser um valor não negativo.

Exemplo macro_command principal () flutuador
y, y = 0,5 resultar
POW (25, y, resultado) // = resultado final 5
macro_command
Nome PECADO
Sintaxe SIN (fonte, resultado)
Descrição Calcule o seno de fonte em resultado.

Fonte pode ser uma constante ou uma variável, mas resultado deve ser uma variável.
SIN (90, resultado) // é um resultado
fonte 30 = SIN (fonte,

resultado) // resultado é 0,5
macro_command final
Nome COS
Sintaxe COS (fonte, resultado)
Descrição Calcular o co-seno de fonte em resultado.

28
Referência macro
COS (90, resultado) // resultado é 0
fonte 60 =
GetData (fonte, "HMI Local", LW, 0, 1) COS (fonte,
resultado) // resultado é 0,5
macro_command final
Nome BRONZEADO
Sintaxe TAN (fonte, resultado)
Descrição Calcular a tangente de fonte em resultado.

TAN (45, resultado) // é um resultado
fonte 60 =
TAN (fonte, resultado) // resultado é 1.732
macro_command final
Nome BERÇO
Sintaxe COT (fonte, resultado)
Descrição Calcule a co-tangente de fonte em resultado.

COT (45, resultado) // é um resultado
fonte 60 =
COT (fonte, resultado) // resultado é 0,5774
macro_command final
29
Referência macro
Nome SEC
Sintaxe SEC (fonte, resultado)
Descrição Calcule a secante de fonte em resultado.

SEC (45, resultado) // resultado é 1.414
fonte 60 =
SEC (fonte, resultado) // se é de origem 60, o resultado é 2
macro_command final
Nome CSC
Sintaxe CSC (fonte, resultado)
Descrição Calcule a co-secante de fonte em resultado.

CSC (45, resultado) // resultado é 1.414
fonte 30 =
CSC (fonte, resultado) // resultado é 2
macro_command final
Nome COMO EM
Sintaxe ASIN (fonte, resultado)
Descrição Calcule o seno hiperbólico de fonte em resultado.

30
Referência macro
ASIN (0,8660, resultado) // resultado é 60
fonte = 0,5
ASIN (fonte, resultado) // resultado é 30
macro_command final
Nome ACOS
Sintaxe ACOS (fonte, resultado)
Descrição Calcular o cosseno hiperbólico de fonte em resultado.

ACOS (0,8660, resultado) // resultado é 30
fonte = 0,5
ACOS (fonte, resultado) // resultado é 60
macro_command final
Nome UM BRONZEADO
Sintaxe ATAN (fonte, resultado)
Descrição Calcular a tangente hiperbólica de fonte em resultado.

Atan (1, resultado) // resultado é 45
source = 1.732 ATAN (fonte,
resultado) // resultado é 60
macro_command final
31
Referência macro
Nome REGISTRO
Sintaxe LOG (fonte, resultado)
Descrição Calcula o logaritmo natural de um número.

Fonte pode ser uma variável ou uma constante. Resultado deve
ser uma variável.
Exemplo macro_command principal () fonte
flutuador = 100, resultado
LOG (fonte, resultado) // resultado é de aproximadamente 4,6052
macro_command final
Nome LOG10
Sintaxe LOG10 (fonte, resultado)
Descrição Calcula o logaritmo de base 10 de um número.

Fonte pode ser uma variável ou uma constante. Resultado deve
ser uma variável.
Exemplo macro_command principal () fonte
flutuador = 100, resultado
LOG10 (fonte, resultado) // resultado é 2
macro_command final
Nome RAND
Sintaxe RAND (resultado)
Descrição Calcula um número inteiro aleatório salvos em resultado.
Resultado deve ser uma variável.
Exemplo macro_command main () resultado
curta
RAND (resultado) // resultado não é um valor fixo quando executa macro cada
Tempo
macro_command final
32
Referência macro
Transformação 18.6.2 Dados
Nome BIN2BCD
Sintaxe BIN2BCD (fonte, resultado)
Descrição Transforma um valor-tipo binário (fonte) em um valor do tipo BCD (resultado).

Exemplo macro_command principal ()
curta fonte, resultam
BIN2BCD (1234, resultado) // resultado é 0x1234
fonte = 5678
BIN2BCD (fonte, resultado) // resultado é 0x5678
macro_command final
Nome BCD2BIN
Sintaxe BCD2BIN (fonte, resultado)
Descrição Transforma um valor do tipo BCD (fonte) em um valor do tipo binário (resultado).
curta fonte, resultam
BCD2BIN (0x1234, resultado) // resultado é 1234
source = BCD2BIN 0x5678 (fonte,

resultado) // resultado é 5678
macro_command final
Nome DEC2ASCII
Sintaxe DEC2ASCII (fonte, resultar [Iniciar], len)
Descrição Transforma um valor decimal (fonte) em ASCII string salvo para uma matriz
(resultado).
33
Referência macro
len representa o comprimento da corda e a unidade de comprimento depende do tipo de resultado., ou seja, se
o tipo de resultado é “char” (o tamanho é byte), o comprimento da cadeia é (byte * len). Se o tipo de resultado é
“curto” (o tamanho é a palavra), o comprimento da cadeia é (word * len), e assim por diante.
O primeiro carácter é posto em resultado [start], o segundo carácter é posto em resultado [start + 1], e
o último carácter é posto em resultado [start + (len -1)]. Fonte e len pode ser uma constante ou uma
variável, mas resultado deve ser uma variável. Iniciar deve ser uma constante.
Exemplo macro_command principal result1

() curto fonte char [4] curto result2
[4]
fonte = 5678
DEC2ASCII (fonte, result1 [0], 4) //
result1 [0] é '5', result1 [1] é '6', result1 [2] é '7', result1 [3] é '8' //
o comprimento da corda (result1) é de 4 bytes (= 1 * 4)
DEC2ASCII (fonte, result2 [0], 4) //

result2 [0] é '5', result2 [1] é '6', result2 [2] é '7', result2 [3] é '8' //
o comprimento da corda (result2) é de 8 bytes (= 2 * 4)
macro_command final
Nome HEX2ASCII
Sintaxe HEX2ASCII (fonte, resultar [Iniciar], len)
Descrição Transforma um valor hexadecimal (fonte) em ASCII string salvo em um

matriz (resultado).
fonte e len pode ser uma constante ou uma variável, mas resultado deve ser uma variável. início deve
ser uma constante.
Exemplo macro_command principal resultado
() curto fonte char [4]
34
Referência macro
fonte = 0x5678
HEX2ASCII (fonte, resultar [0], 4) //
resultado [0] é '5', resultado [1] é '6', resultado [2] é '7', resultado [3] é '8'
macro_command final
Nome FLOAT2ASCII
Sintaxe FLOAT2ASCII (fonte, resultar [Iniciar], len)
Descrição Transforma um valor flutuante (fonte) em ASCII string salvo para uma matriz
(resultado).
Fonte e len pode ser uma constante ou uma variável, mas resultado deve ser uma variável. Iniciar deve
ser uma constante.
Exemplo macro_command resultado de char
principal () fonte flutuador [4]
fonte = 56,8
FLOAT2ASCII (fonte, resultar [0], 4) //
resultado [0] é '5', resultado [1] é '6', resultar [2] é '', resultar [3] é '8'
macro_command final
Nome ASCII2DEC
Sintaxe ASCII2DEC (fonte [Iniciar], resultado, len)
Descrição Transforma uma string (fonte) em um valor decimal salvos em uma variável
(resultado).
O comprimento da corda é len. O primeiro caractere da cadeia é fonte [Iniciar].
ser uma constante.
Exemplo macro_command fonte de char
principal () [4]
35
Referência macro
resultado curta
fonte [0] = '5' fonte

[1] = fonte '6' [2] =
'7' fonte [3] = '8'
ASCII2DEC (fonte [0], resultado, 4) // resultado é 5678
macro_command final
Nome ASCII2HEX
Sintaxe ASCII2HEX (fonte [Iniciar], resultado, len)
Descrição Transforma uma string (fonte) em um valor hexadecimal salvos em uma variável
(resultado).
ser uma constante.
Exemplo macro_command principal fonte
char () [4] resultado curto

[1] = fonte '6' [2] =
'7' fonte [3] = '8'
ASCII2HEX (fonte [0], resultado, 4) // resultado é 0x5678
macro_command final
Nome ASCII2FLOAT
Sintaxe ASCII2FLOAT (fonte [Iniciar], resultado, len)
Descrição Transforma uma string (fonte) em um valor flutuante salvos em uma variável (resultado).
36
Referência macro
ser uma constante.
Exemplo macro_command principal fonte char ()
[4] resultado flutuador

[1] = fonte '6' [2] = ''
fonte [3] = '8'
ASCII2FLOAT (fonte [0], resultado, 4) // resultado é 56,8
macro_command final
37
Referência macro
Manipulação 18.6.3 Dados
Nome PREENCHER
Sintaxe ENCHER (fonte [Iniciar], preset, contam)
Descrição Define os primeiros elementos de contagem de uma matriz (fonte) de um valor especificado
(Pré-definido).
e fonte inicial deve ser uma variável, e pode ser memorizada uma constante ou variável.
Exemplo macro_command principal () resultado
char [4] predefinido de char
FILL (resultar [0], 0x30, 4) //
resultado [0] é 0x30, resultar [1] é 0x30,, resultar [2] é 0x30,, resultar [3] é 0x30
predefinidas = 0x31
FILL (resultar [0], alvo, 2) // resultado [0] é 0x31, resultar [1] é 0x31
macro_command final
Nome SWAPB
Sintaxe SWAPB (fonte, resultado)
Descrição Trocas os dados de alta e de baixa byte byte de uma fonte de 16 bits em resultado.
Exemplo macro_command principal) short
fonte (, resultam
SWAPB (0x5678, resultado) // resultado é 0x7856
source = 0x123 SWAPB (fonte,

resultado) // resultado é 0x2301
macro_command final
Nome SWAPW
Sintaxe SWAPW (fonte, resultado)
38
Referência macro
Descrição Trocas os dados de palavras de alta e baixa de palavras de uma fonte de 32 bits em resultado.
Exemplo macro_command principal) fonte int
(, resultar
SWAPW (0x12345678, resultado) // resultado é 0x56781234
source = 0x12345 SWAPW (fonte,

macro_command final
Nome LOBYTE
Sintaxe LOBYTE (fonte, resultado)
Descrição Recupera o byte baixo de uma fonte de 16 bits em resultado.
fonte (, resultam
LOBYTE (0x1234, resultado) // resultado é 0x34
fonte = 0x123
LOBYTE (fonte, resultado) // resultado é 0x23
macro_command final
Nome HIBYTE
Sintaxe HIBYTE (fonte, resultado)
Descrição Recupera o byte de uma fonte de 16 bits em resultado.

fonte (, resultam
HIBYTE (0x1234, resultado) // resultado é 0x12
fonte = 0x123
39
Referência macro
HIBYTE (fonte, resultado) // resultado é 0x01
macro_command final
Nome LOWORD
Sintaxe LOWORD (fonte, resultado)
Descrição Recupera a palavra baixa de uma fonte de 32-bit em resultado.
(, resultar
LOWORD (0x12345678, resultado) // resultado é 0x5678
source = 0x12345 LOWORD (fonte,

macro_command final
Nome HIWORD
Sintaxe HIWORD (fonte, resultado)
Descrição Recupera a palavra alta de uma fonte de 32-bit em resultado.
(, resultar
HIWORD (0x12345678, resultado) // resultado é 0x1234
source = 0x12345 HIWORD (fonte,

macro_command final
40
Referência macro
Transformação 18.6.4 Bit
Nome GETBIT
Sintaxe GETBIT (fonte, resultado, bit_pos)
Descrição Obtém o estado de posição de bit designada de um conjunto de dados (de origem) em resultado.
valor do resultado será 0 ou 1.
Fonte e bit_pos pode ser uma constante ou uma variável, mas resultado deve ser uma variável.
Exemplo macro_command principal fonte int
(), resultar bit_pos curtas
GETBIT (9, resultado, 3) // é um resultado
Source = 4 = 2
bit_pos
GETBIT (fonte, resultado, bit_pos) // é um resultado
macro_command final
Nome SETBITON
Sintaxe SETBITON (fonte, resultado, bit_pos)
Descrição Altera o estado de posição de bit designada de um conjunto de dados (fonte) para 1, e
colocar os dados alterados no resultado.
SETBITON (1, resultado, 3) // resultado é nove
Source = 0 = 2
bit_pos
SETBITON (fonte, resultado, bit_pos) // resultado é 4
macro_command final
41
Referência macro
Nome SETBITOFF
Sintaxe SETBITOFF (fonte, resultado, bit_pos)
Descrição Altera o estado de posição de bit designada de um conjunto de dados (fonte) a 0, e
colocar em dados alterados em resultado.
SETBITOFF (9, resultado, 3) // é um resultado
Source = 4 = 2
bit_pos
SETBITOFF (fonte, resultado, bit_pos) // resultado é 0
macro_command final
Nome INVBIT
Sintaxe INVBIT (fonte, resultado, bit_pos)
Descrição Inverte o estado de posição de bit designada de um conjunto de dados (de origem), e colocar
dados transformados em resultado.
INVBIT (4, resultado, 1) // 6 = resultado
Source = 6 = 1
bit_pos
INVBIT (fonte, resultado, bit_pos) // resultado = 4
macro_command final
42
Referência macro
18.6.5 Comunicação
Nome DEMORA
Sintaxe Tempo de atraso)
Descrição Suspende a execução da macro atual para pelo menos o especificado

tempo de intervalo). A unidade de tempo é milissegundo. O tempo pode
ser uma constante ou uma variável.
Exemplo macro_command principal () int
tempo == 500
ATRASO (100) // atraso de 100 ms de atraso
(tempo) // atrasar 500 ms
macro_command final
Nome ADDSUM
Sintaxe ADDSUM (fonte [Iniciar], resultado, data_count)
Descrição Adiciona-se os elementos de uma matriz (de origem) a partir de fonte [início] a
fonte [start + data_count - 1] para gerar uma soma de verificação. Coloca no checksum no resultado.
Resultado deve ser uma variável. Data_count é a quantidade de elementos acumulados e pode ser
uma constante ou uma variável.
Exemplo macro_command principais dados CHAR
() [5] soma de verificação de curto
Dados [0] = dados
0x1 [1] = dados 0x2
[2] = 0x3 dados [3] =
dados 0x4 [4] = 0x5
ADDSUM (dados [0], de soma de verificação, 5) // soma de verificação é 0xf
macro_command final
43
Referência macro
Nome XORSUM
Sintaxe XORSUM (fonte [Iniciar], resultado, data_count)
Descrição Usa um método de exclusão para calcular a soma de verificação da fonte [Iniciar] para
fonte [start + data_count - 1].

Coloca o checksum no resultado. Resultado deve ser uma variável. Data_count é a quantidade dos
elementos calculados da matriz e pode ser uma constante ou uma variável.
char data [5] = {0x1, 0x2, 0x3, 0x4, 0x5} curto soma de
verificação
XORSUM (dados [0], de soma de verificação, 5) // soma de verificação é 0x1
macro_command final
Nome CRC
Sintaxe CRC (fonte [Iniciar], resultado, data_count)
Descrição Calcula 16-bit CRC das variáveis de fonte [Iniciar] à fonte [start +
count - 1].
Coloca na CRC de 16 bits no resultado. Resultado deve ser uma variável. Data_count é a quantidade
dos elementos calculados da matriz e pode ser uma constante ou uma variável.
char data [5] = {0x1, 0x2, 0x3, 0x4, 0x5} curto

16bit_CRC
CRC (dados [0], 16bit_CRC, 5) // 16bit_CRC é 0xbb2a
macro_command final
Nome OUTPORT
Sintaxe OUTPORT (fonte [start], device_name, data_count)
Descrição Envia os dados especificados a partir da fonte [start] à fonte [start + contar -1] a
PLC através de uma porta COM ou a Ethernet.
Device_name é o nome de um dispositivo definido na tabela o dispositivo e o
44
Referência macro
dispositivo deve ser um “Protocolo gratuito” dispositivo do tipo.
Data_count é a quantidade de dados transmitidos e pode ser uma constante ou uma variável.
Exemplo Para usar uma função OUTPORT, um dispositivo de “Protocolo livre” deve ser criado primeiro da seguinte forma:
O dispositivo é chamado de “RTU dispositivo MODBUS”. O atributo de porta depende da configuração do
presente dispositivo. (A definição actual é “19200, E, 8, 1”)
Abaixo está um exemplo de realização de uma acção de escrita única bobina (SET ON) para um dispositivo
MODBUS.
comando char [32] endereço curto,
soma de verificação
FILL (comando [0], 0, 32) // inicialização comando
comando [0] = 0x1 // estação nenhum
comando [1] = 0x5 // código de função: Write Single Coil
45
Referência macro
endereço = 0
HIBYTE (endereço, comando [2]) LOBYTE

(endereço, comando [3])
comando [4] = 0xFF // força mordeu
comando [5] = 0
CRC (comando [0], de soma de verificação, 6)
LOBYTE (soma de verificação, de comando [6]) HIBYTE
(soma de verificação, de comando [7])
// enviar uma “Write Single Coil” OUTPORT de comando (comando

[0] ", MODBUS RTU Device", 8)
macro_command final
Nome INPORT
Sintaxe INPORT (read_data [start], device_name, read_count, return_value)
Descrição Lê dados a partir de uma porta COM ou a Ethernet. Estes dados são armazenados para
read_data [Iniciar] ~ read_data [start + read_count - 1].

device_name é o nome de um dispositivo definido na tabela de dispositivo eo dispositivo deve ser um
“Protocolo gratuito” dispositivo do tipo.
read_count é a quantidade necessária de leitura e pode ser uma constante ou uma variável.
Se a função é utilizada com sucesso para obter dados suficientes, return_value é 1, caso contrário é 0.
Exemplo Abaixo está um exemplo de executar uma ação de segurar leitura registros de um dispositivo
MODBUS.
// Leia registos de retenção macro_command
comando principal () char [32], resposta [32]
endereço curto, soma de verificação
read_no curto, return_value, read_data [2]
46
Referência macro
FILL (comando [0], 0, 32) // inicialização comando de preenchimento
(resposta [0], 0, 32)
comando [0] = 0x1 // estação nenhum
comando [1] = 0x3 // código de função: Leia Holding Registers
endereço = 0

read_no = 2 // Leia 2 palavras (4x_1 e 4x_2)

HIBYTE (read_no, comando [4]) LOBYTE
(read_no, comando [5])
// enviar um 'Read Holding Registers”OUTPORT de comando

(comando [0], "Device MODBUS RTU", 8)
// Leia as respostas para um 'Read Holding Registers”INPORT comando

(resposta [0], "Device MODBUS RTU", 9, return_value)
se return_value> 0, em seguida,
read_data [0] = resposta [4] + (resposta [3] << 8) // dados em 4x_1 read_data [1] =
resposta [6] + (resposta [5] << 8) // dados em 4x_2
SetData (read_data [0], "HMI local", LW, 100, 2) End If
macro_comm final e
Nome Adquirir dados
Sintaxe GetData (read_data [start], device_name, device_type, address_offset, data_count)
47
Referência macro
ou
GetData (read_data, device_name, device_type, address_offset, 1)

Descrição Recebe dados do PLC. Os dados são armazenados em read_data [início] ~
read_data [start + data_count - 1].
Data_count é a quantidade de dados recebidos. Em geral, read_data é uma matriz, mas se data_count é
1, read_data pode ser uma matriz ou uma variável comum. A seguir estão dois métodos para ler um
dados palavra de PLC.
macro_command principais () read_data_1 curtas
[2], read_data_2
GetData (read_data_1 [0], “FATEK série KB”, RT, 5, 1) GetData

(read_data_2, “KB Série FATEK”, RT, 5, 1)
macro_command final
Device_name é o nome PLC fechado em aspas duplas ( “) e este nome foi definido na lista de
dispositivos de parâmetros do sistema da seguinte forma (ver FATEK KB Series):
Device_type é o tipo de aparelho e método de codificação (ou binário BCD) dos dados do PLC. Por
exemplo, se é device_type LW_BIN, isso significa que o registo é LW e o método de codificação é binária.
Se utilizar o método BIN codificação “_bin” pode ser ignorado.
Se device_type é LW_BCD, isso significa que o registo é LW e o método de codificação é BCD.
Address_offset é o endereço de offset no PLC.

Por exemplo, GetData (read_data_1 [0], “FATEK série KB”, RT, 5, 1)
48
Referência macro
representa que o endereço de offset é 5.
Se address_offset usa o formato - “N # AAAAA”, N indica que o número da estação de PLC é N. AAAAA
representa o endereço de offset. Este formato é usado enquanto múltiplos CLPs ou controladores estão
ligados a uma única porta de série. Por exemplo, GetData (read_data_1 [0], “FATEK série KB”, RT, 2 # 5,
1) representa o número da estação do PLC é 2. Se GetData () usa o número da estação padrão definido
na lista de dispositivos como se segue, não é necessário para definir o número da estação em
address_offset.
O número de registros realmente ler a partir depende tanto do tipo da variável read_data eo valor
do número de data_count.
Tipo de data_count número real de leitura registo de 16 bits

read_data
char (8 bits) 1 1
char (8 bits) 2 1
booleano (8 bits) 1 1
curto (de 16 bits) 1 1
int (32 bits) 1 2
int (32 bits) 2 4
flutuador (32 bits) 1 2
49
Referência macro
Quando um GetData () é executado utilizando um tipo de dados de 32 bits (int ou flutuador), a função vai
converter os dados automaticamente. Por exemplo,
macro_command principal () flutuador f
GetData (f, "MODBUS", 6x, 2, 1) // f irá conter um valor de ponto flutuante
macro_command final
Exemplo macro_command principal () boleano
um booleano b [30] curto c curta d
[50] e int int f [10] duplo g [10]
// obtém o estado de LB2 à variável um GetData

(a, “HMI Local”, LB, 2, 1)
// obtém 30 estados do lb0 ~ LB29 às variáveis b [0] ~ b [29] GetData (b [0]

“HMI Local”, LB, 0, 30)
// obter uma palavra de LW2 à variável c GetData (c,

“HMI Local”, LW, 2, 1)
// obtém 50 palavras de LW0 ~ LW49 às variáveis de d [0] ~ d [49] GetData (d [0]
// obtém 2 palavras a partir LW6 ~ LW7 à variável e // note que

o tipo de e é int GetData (e, “HMI Local”, LW, 6, 1)
// obtém 20 palavras (10 valores inteiros) de LW0 ~ LW19 a variáveis de f [0] ~ f [9] // uma vez que
cada valor inteiro ocupa 2 palavras GetData (f [0] “HMI Local”, LW, 0, 10)
// obtém 2 palavras a partir LW2 ~ LW3 à variável f GetData (f,

50
Referência macro
macro_command final
Nome GetDataEx
Sintaxe GetDataEx (read_data [start], device_name, device_type, address_offset, data_count) ou
GetDataEx (read_data, device_name, device_type, address_offset, 1)

Descrição Recebe dados do PLC e continuar a executar próximo comando mesmo se
nenhuma resposta a partir deste dispositivo.
Descrições de read_data, device_name, device_type, address_offset e data_count são os

mesmos que GetData.
Exemplo macro_command principal () boleano
um booleano b [30] curto c curta d
[50] e int int f [10] duplo g [10]
// obtém o estado de LB2 à variável um GetDataEx

(a, “HMI Local”, LB, 2, 1)
// obtém 30 estados do lb0 ~ LB29 às variáveis b [0] ~ b [29] GetDataEx (b

[0] “HMI Local”, LB, 0, 30)
// obter uma palavra de LW2 à variável c GetDataEx (c,

// obtém 50 palavras de LW0 ~ LW49 às variáveis de d [0] ~ d [49] GetDataEx (d

[0] “HMI Local”, LW, 0, 50)
// obtém 2 palavras a partir LW6 ~ LW7 à variável e // note que

ele tipo de e é int GetDataEx (e, “HMI Local”, LW, 6, 1)
51
Referência macro
// obtém 20 palavras (10 valores inteiros) de LW0 ~ LW19 para f [0] ~ f [9] // uma vez que
cada valor inteiro ocupa 2 palavras GetDataEx (f [0] “HMI Local”, LW, 0, 10 )
// obtém 2 palavras a partir LW2 ~ LW3 à variável f GetDataEx

(f, “HMI Local”, LW, 2, 1)
macro_command final
Nome SetData
Sintaxe SetData (send_data [start], device_name, device_type, address_offset, data_count) ou
SetData (send_data, device_name, device_type, address_offset, 1)

Descrição Enviar dados para o PLC. Os dados são definidos em send_data [start] ~ send_data [início
+ data_count - 1].
data_count é a quantidade de dados enviados. Em geral, send_data é uma matriz, mas se data_count é 1,
send_data pode ser uma matriz ou uma variável comum. A seguir estão dois métodos para enviar dados de
uma palavra.
send_data_1 curta [2] = {5, 6}, send_data_2 = 5 SetData (send_data_1

[0], “FATEK série KB”, RT, 5, 1) SetData (send_data_2,
“KB Série FATEK”, RT, 5, 1)
macro_command final
device_name é o nome PLC fechado em aspas duplas ( “) e este nome foi definido na lista de
parâmetros do sistema dispositivo. device_type é o tipo de aparelho e método de codificação (ou
binário BCD) dos dados do PLC. Por exemplo, se é device_type LW_BIN, isso significa que o
registo é LW e o método de codificação é binária. Se utilizar o método BIN codificação “_bin”
pode ser ignorado.
Se device_type é LW_BCD, isso significa que o registo é LW e o método de codificação é BCD.
52
Referência macro
address_offset é o endereço de offset no PLC.

Por exemplo, SetData (read_data_1 [0], “FATEK série KB”, RT, 5, 1) representa que o
endereço de offset é 5.
Se address_offset usa o formato - “N # AAAAA”, N indica que o número da estação de PLC é N.
AAAAA representa o endereço de offset. Este formato é usado enquanto múltiplos CLPs ou
controladores estão ligados a uma única porta de série. Por exemplo, SetData (read_data_1 [0]
“FATEK KB Series”, RT, 2 # 5, 1) representa o número da estação do PLC é 2. Se SetData () usa o
número da estação padrão definido na lista de dispositivos, é não é necessário para definir o número
da estação em address_offset.
O número de registros realmente envia para depende tanto do tipo da variável send_data eo
valor do número de data_count.
Tipo de data_count número real de registo de envio de 16 bits
read_data
char (8 bits) 1 1
char (8 bits) 2 1
int (32 bits) 1 2
int (32 bits) 2 4
Quando um SetData () é executado utilizando um tipo de dados de 32 bits (int ou flutuador), a função irá enviar
automaticamente int-formato ou flutuar no formato de dados para o dispositivo. Por exemplo,
macro_command principal () flutuador f
= 2,6
53
Referência macro
SetData (f, "MODBUS", 6x, 2, 1) // irá enviar um valor de ponto flutuante para o
dispositivo
macro_command final
Exemplo macro_command principal () int i
boleano verdadeiro =
um boleano b [30] curto
c = falso curta d [50] int
e = 5 int f [10]
para i = 0 a 29 b [i] =
verdadeira seguinte i
para i = 0-49 d [i] = i
* 2 seguinte i
para i = 0 a 9 f [i] =
i * 3 seguinte i
// definir o estado de LB2 SetData (a,
“HMI local”, LB, 2, 1)
// definir os estados de lb0 ~ LB29 SetData (b [0]

// definir o valor de LW2 SetData (c, “HMI

local”, LW, 2, 1)
// definir os valores de LW0 ~ LW49 SetData (d

[0], “HMI local”, PV, 0, 50)
// definir os valores das LW6 ~ LW7, note que o tipo de e é int SetData (e, “HMI
Local”, LW, 6, 1)
54
Referência macro
// definir os valores das LW0 ~ LW19
// 10 inteiros iguais a 20 palavras, uma vez que cada valor inteiro ocupa 2 palavras.
SetData (f [0] “HMI Local”, LW, 0, 10)
macro_command final
Nome SetDataEx
Sintaxe SetDataEx (send_data [start], device_name, device_type, address_offset, data_count) ou
SetDataEx (send_data, device_name, device_type, address_offset, 1)

Descrição Enviar dados para o PLC e continuar a executar próximo comando, mesmo se nenhum
resposta a partir deste dispositivo.
Descrições de send_data, device_name, device_type, address_offset e data_count são os

mesmos que SetData.
Exemplo macro_command principal () int i
boleano verdadeiro =
um boleano b [30] curto
c = falso curta d [50] int
e = 5 int f [10]
para i = 0 a 29 b [i] =
verdadeira seguinte i
para i = 0-49 d [i] = i
* 2 seguinte i
para i = 0 a 9 f [i]
=i*3
55
Referência macro
proximo eu
// definir o estado de LB2 SetDataEx (a,

“HMI local”, LB, 2, 1)
// definir os estados de lb0 ~ LB29 SetDataEx (b [0]

// definir o valor de LW2 SetDataEx (c, “HMI

local”, LW, 2, 1)
// definir os valores de LW0 ~ LW49 SetDataEx (d

[0], “HMI local”, PV, 0, 50)
// definir os valores das LW6 ~ LW7, note que o tipo de e é int SetDataEx (e,
// definir os valores das LW0 ~ LW19
// 10 inteiros iguais a 20 palavras, uma vez que cada valor inteiro ocupa 2 palavras.
SetDataEx (f [0] “HMI Local”, LW, 0, 10)
macro_command final
Nome getError
Sintaxe GetError (ERR)
Descrição Obter um código de erro.
Exemplo macro_command principais ()
byData curto err char [10]
GetDataEx (byData [0] “MODBUS RTU”, 4x, 1, 10) // lê 10 bytes
// se err é igual a 0, é bem sucedida para executar GetDataEx () GetErr (err) // salvar um
código de erro para errar
56
Referência macro
macro_command final
Nome PURGA
Sintaxe PURGA (com_port)
Descrição com_port refere-se ao número da porta COM, que varia de 1 a 3. Pode
ser uma variável ou uma constante.
Esta função é usada para limpar os buffers de entrada e de saída associados com a porta COM.
Exemplo macro_command principal () int
com_port = 3 PURGA (com_port)
PURGA (1)
macro_command final
Nome SetRTS
Sintaxe SetRTS (com_port, fonte)
Descrição Definir o estado RTS para RS232.
com_port refere-se ao número da porta COM 1. Ele pode ser qualquer uma variável ou constante.
Fonte também pode ser uma variável ou uma constante. Este comando levantar sinal RTS enquanto
o valor da fonte é maior do que 0 e inferior sinal RTS enquanto o valor da fonte é igual a 0.
Exemplo macro_command principal () caractere
com_port = um valor de char = 1
SetRTS (com_port, valor) // levantar sinal RTS da COM1, enquanto o valor> 0
SetRTS (1, 0) // sinal RTS inferiores de COM1
macro_command final
57
Referência macro
Nome GetCTS
Sintaxe GetCTS (com_port, resultado)
Descrição Obter estado de CTS para RS232.
com_port refere-se ao número da porta COM 1. Ele pode ser qualquer uma variável ou constante. O
resultado é usado para receber o sinal CTS. Deve ser uma variável. Este comando recebe o sinal
CTS e armazena os dados recebidos na variável resultado. Quando o sinal CTS é puxada alta,
escreve 1 a resultar, caso contrário, escreve 0.
com_port = resultado um caractere
GetCTS (com_port, resultado) // obter sinal CTS de COM1
GetCTS (1, resultado) // obter sinal CTS de COM1
macro_command final
Nome Bip
Sintaxe Bip ()
Descrição Reproduz som de bip.
Este comando desempenha um sinal sonoro com frequência de 800 hertz e duração de 30
milissegundos.
Bip()
macro_command final
58
Referência macro
Nome 18.6.6 Diversos

SYNC_TRIG_MACRO
Sintaxe SYNC_TRIG_MACRO (macro_id)
Descrição Desencadear a execução de uma forma síncrona macro (uso macro_id para
designar essa macro) em uma macro em execução.
A macro atual fará uma pausa até o final da execução deste chamado macro.
macro_id pode ser uma constante ou uma variável.
ON = 1, = 0 OFF
SetData (ON, “HMI Local”, LB, 0, 1)
SYNC_TRIG_MACRO (5) // chamar uma macro (o seu ID é 5)
SetData (OFF, “HMI Local”, LB, 0, 1)
macro_command final
Nome ASYNC_TRIG_MACRO
Sintaxe ASYNC_TRIG_MACRO (macro_id)
Descrição Desencadear a execução de uma macro de forma assíncrona (uso macro_id para
designar essa macro) em uma macro em execução.
A macro atual continuará executando as seguintes instruções depois provocando a macro

designado; em outras palavras, as duas macros estará ativo simultaneamente.
macro_id pode ser uma constante ou uma variável.
ON = 1, = 0 OFF
SetData (ON, “HMI Local”, LB, 0, 1)
ASYNC_TRIG_MACRO (5) // chamar uma macro (o seu ID é 5)
SetData (OFF, “HMI Local”, LB, 0, 1)
macro_command final
59
Referência macro
Nome VESTÍGIO
Sintaxe TRACE (formato, argumento)
Descrição Use esta função para enviar cadeia especificada ao EasyDiagnoser. Os usuários podem
imprimir o valor atual de variáveis durante o tempo de execução da macro para depuração.
Quando TRACE encontra a primeira especificação do formato (se houver algum), que converte o valor do
primeiro argumento após o formato e emite-o de acordo.
formato refere-se ao controlo de formato de cadeia de saída. Uma especificação do formato, o qual consiste
em opcional (em []) e os campos requeridos (em negrito), tem a seguinte forma:
% [ bandeiras] [largura] [.precision] tipo
Cada campo de especificação do formato é descrita como a seguir:
bandeiras ( opcional):
-
+
largura ( opcional):
Um número decimal inteiro n negativo de controlar o número mínimo de
caracteres impressos.
precisão ( opcional):
Um número inteiro não negativo decimal que especifica a precisão e o número de
caracteres a serem impressos.
tipo:
C ou c : Especifica um caractere de byte único.
d : Assinado inteiro decimal.
Eu : Assinado inteiro decimal.
o : Sem sinal inteiro octal.

você : Sem sinal inteiro decimal.
X ou X : Sem sinal inteiro hexadecimal.
E ou E : Valor assinado com a forma. [-] d.dddd e [ assinar] ddd Onde d é
um único dígito decimal, dddd é um ou mais dígitos decimais, ddd é
exatamente três dígitos decimais, e placa é + ou -.
f : Valor assinado que tem a forma [-] dddd.dddd,

Onde dddd é um ou mais dígitos decimais.
O comprimento da corda de saída é limitada a 256 caracteres. Os caracteres extras serão
ignorados.
60
Referência macro
o argumento parte é opcional. Uma especificação do formato converte exatamente um argumento.
Exemplo macro_command principal () c1 char
= 'um' s1 flutuador f1 = 32767 curta =
1,234567
TRACE ( “Os resultados são”) // saída: Os resultados são TRACE (

“c1 =% c, S1 =% d, f1 =% f”, c1, S1, f1) // saída: c1 = A, S1 =
32767, f1 = 1,234567
macro_command final
61
Referência macro
18.7 Como criar e executar uma macro
18.7.1 Como criar uma macro

programação macro pode ser dividido em algumas etapas como se segue,
Passo 1:
Clique no ícone “Macro Manager” na barra de ferramentas de EasyBuilder 8000 para abrir a caixa de diálogo Gerenciador de
Macros como segue.
62
Referência macro
Em Macro Manager, todas as macros compilados com sucesso são exibidos em “lista de Macro”, e todas as macros em
desenvolvimento são exibidos em 'Macro em desenvolvimento”. O seguinte é uma descrição dos vários botões.
[Novo]
Abre um editor em branco “WorkSpace” para criar uma nova macro.
[Excluir]
Exclui a macro selecionada.

[Editar]
Abre o editor do “WorkSpace”, e carrega a macro selecionada.

[Cópia de]
Cópias do macro selecionado para a área de transferência.
[Colar]
Cola o macro na área de transferência na lista, e cria um novo nome para a macro.
Passo 2:
Pressione o botão “Novo” para abrir um editor em branco “WorkSpace”. Cada macro tem um número único definido na caixa
de edição “Macro ID”, e nome da macro deve existir, caso contrário, um erro será exibido ao compilar.
63
Referência macro
Etapa 3:
Projete sua macro. Se for necessário o uso de build-in funções (como SetData () ou Getdata ()), pressione 'Get / botão
para abrir diálogo API e selecione a função e definir parâmetros essenciais Set FN ...”.
64
Referência macro
Passo 4:
Após a conclusão de uma nova macro, pressione 'botão “Compilar para compilar o macro.
65
Referência macro
Se não houver nenhum erro, pressione o botão “Sair” e achar que uma nova macro “macro_test” existe na “lista Macro”.
66
Referência macro
18.7.2 Executar uma Macro

Existem várias maneiras para executar uma macro.
uma. Com um objectivo de controlo PLC
1. Abra o objeto de controle PLC e definir o atributo para “Executar programa de macro”.
2. Selecione a macro pelo nome. Escolha um pouco e selecione uma condição de gatilho para disparar a macro. A
macro continuará a ser re-acionado enquanto a condição for atendida. A fim de garantir que a macro será
executada apenas uma vez, considere trancando a pouco gatilho, e, em seguida, reiniciar a condição de disparo
dentro do macro.
3. Use um conjunto de bits ou chave seletora objeto para ativar o bit.
b. Com um conjunto de bits ou chave seletora objeto
1. Na guia Geral da Bit Set ou diálogo Toggle Switch, selecione a opção “Executar Macro”.
2. Selecione a macro para executar. A macro será executada uma vez quando o botão é ativado.
c. Com um objeto Key Function

1. Na guia Geral da Bit Set ou diálogo Toggle Switch, selecione a opção Macro Executar.
2. Selecione a macro para executar. A macro será executada uma vez quando o botão é ativado.
67
Referência macro
18.8 Algumas Notas sobre o uso do Macro
1. O espaço de armazenamento máximo de variáveis locais em uma macro é 4K bytes. Assim, o tamanho máximo da gama
de diferentes tipos de variáveis são como se segue:
char a [4096]
boleano b [4096]
curtos c [2048] int d
[1024] flutuador e
[1024]
2. Um máximo de 256 macros são permitidos em um 8000 projeto EasyBuilder.
3. A macro pode causar a HMI para trancar. As causas possíveis são:

. Uma macro contém um ciclo infinito com nenhuma comunicação PLC.
. O tamanho de uma matriz excede o espaço de armazenamento numa macro.
4. O tempo de comunicação PLC pode causar a macro para executar mais lento do que o esperado. Além disso, muitas
instruções macro podem retardar a comunicação PLC.
68
Referência macro
18.9 Use o Protocolo gratuito para controlar um dispositivo
Quando EasyBuilder 8000 não fornece um driver essencial para a comunicação com um dispositivo, os usuários também
podem fazer uso de OUTPORT e INPORT para controlar o dispositivo. Os dados enviados com OUTPORT e INPORT
deve seguir protocolo de comunicação do dispositivo. O exemplo a seguir explica como usar essas duas funções para
controlar um dispositivo MODBUS RTU.
Primeiro, crie um novo dispositivo na tabela de dispositivo. O tipo do novo dispositivo dispositivo é definido como “Protocolo Livre” e
nomeado com “dispositivo RTU MODBUS” da seguinte forma:
A interface do dispositivo (PLC I / F) usa “RS-232” agora. Se ligar um dispositivo Modbus TCP / IP, a interface
deve selecionar 'Ethernet”. Além disso, é necessário definir IP correcto e o número da porta da seguinte forma:
69
Referência macro
Suponha que HMI irá ler os dados de 4x_1 e 4x_2 no dispositivo. Em primeiro lugar, utilizar OUTPORT para enviar uma
solicitação de leitura para o dispositivo. O protótipo do OUTPORT é:
OUTPORT (comando [Iniciar], device_name, cmd_count)
Desde “dispositivo RTU MODBUS” é um dispositivo MODBUS RTU, a solicitação de leitura deve seguir protocolo
Modbus RTU. O pedido utiliza”(0x03) Reading Holding Registers” comando para ler os dados. A figura a seguir
exibe o conteúdo do comando. (Os itens do número da estação (byte 0) e os dois últimos bytes (CRC) são
ignorados).
Dependendo do protocolo, o conteúdo de um comando de leitura da seguinte maneira (A total é de 8 bytes):
comando [0]: número da estação (Byte 0)

comando [1]: código de função (BYTE 1)
comando [2]: alta byte de endereço de partida (Byte 2)
comando [3]: baixo byte de endereço de partida (Byte 3)
comando [4]: byte alto da quantidade de registos (BYTE 4)
comando [5]: byte baixo da quantidade de registos (Byte 5)
comando [6]: baixo byte de 16 bits CRC (Byte 6)
comando [7]: alta byte de 16 bits CRC (BYTE 7)
Assim, um pedido de leitura é projetado como segue:
comando char [32] endereço curto, soma
de verificação
FILL (comando [0], 0, 32) // comando inicializar [0] ~ comando [31] para 0
70
Referência macro
comando [0] = 0x1 // número da estação de

comando [1] = 0x3 // leia segurando registros (código de função é 0x3)
endereço = 0 // endereço inicial (4x_1) é 0 HIBYTE

(endereço, comando [2]) LOBYTE (endereço, comando
[3])
read_no = 2 // as palavras totais de leitura é 2 palavras

CRC (comando [0], de soma de verificação, 6) // calcula CRC de 16 bits
Por fim, use OUPORT para enviar esta solicitação de leitura para PLC
OUTPORT (comando [0] "MODBUS RTU Device", 8) pedido // envia ler
Depois de enviar a solicitação, use INPORT para obter a resposta do PLC. Dependendo do protocolo, o conteúdo
da resposta é como se segue (o byte total é de 9): comando [0]: número da estação
(Byte 0)
comando [1]: código de função (BYTE 1)
comando [2]: contagem de bytes (Byte 2)
comando [3]: byte alto da 4x_1 (Byte 3)
comando [4]: byte baixo de 4x_1 (BYTE 4)
comando [7]: baixo byte de 16 bits CRC (BYTE 7)
comando [8]: alta byte de 16 bits CRC (Byte 8)
O uso de INPORT é descrito abaixo:
INPORT (resposta [0], "MODBUS RTU Device", 9, return_value) // ler resposta
Quando a contagem lida real é restaurado para o return_value variável (unidade é byte). Se return_value é 0, isso significa
que a leitura falhar na execução INPORT.
71
Referência macro
Dependendo do protocolo, a resposta [1] deve ser igual a 0x3, se a resposta for correcta. Depois de obter a
resposta correta, calcular os dados de 4x_1 e 4x_2 e colocar nos dados em LW100 e LW101 da HMI.
se (return_value> 0 e resposta [1] == 0x3) seguida

read_data [0] = resposta [4] + (resposta [3] << 8) // 4x_1 read_data [1] =
resposta [6] + (resposta [5] << 8) // 4x_2
A macro completa é a seguinte:

// Read Holding Registers
macro_command main ()
comando char [32], resposta [32] endereço curto,
soma de verificação
read_no curto, return_value, read_data [2], i
FILL (resposta [0], 0, 32)
comando [1] = 0x3 // leia segurando registros (código de função é 0x3)
endereço = 0
endereço = 0 // endereço inicial (4x_1) é 0 HIBYTE

(endereço, comando [2]) LOBYTE (endereço, comando
[3])
read_no = 2 / as palavras totais de leitura é 2 palavras

CRC (comando [0], de soma de verificação, 6) // calcula CRC de 16 bits
LOBYTE (soma de verificação, de comando [6])
72
Referência macro
HIBYTE (soma de verificação, de comando [7])
OUTPORT (comando [0], "Device MODBUS RTU", 8) // enviar pedido INPORT (resposta
[0], "Device MODBUS RTU", 9, return_value) // ler resposta
se (return_value> 0 e resposta [1] == 0x3) seguida

read_data [0] = resposta [4] + (resposta [3] << 8) // 4x_1 read_data [1] =
resposta [6] + (resposta [5] << 8) // 4x_2
macro_command final
O exemplo a seguir explica como criar um pedido para definir o status de 0x_1. O pedido utiliza “Write Single Coil
(0x5)” comando.
A macro completa é a seguinte:

// Write Single Coil (ON)
macro_command main ()
comando char [32], resposta [32] endereço curto,
da soma de verificação de curto i, return_value
FILL (resposta [0], 0, 32)
73
Referência macro
comando [1] = 0x5 // código de função: escrever single coil
endereço = 0

comando [4] = 0xFF // força 0x_1 em

comando [5] = 0
OUTPORT (comando [0], "Device MODBUS RTU", 8) // enviar pedido INPORT

(resposta [0], "Device MODBUS RTU", 8, return_value) // ler resposta
macro_command final
74
Referência macro
18.10 Mensagem ler erro Compi
1. Erro Message Format:
erro c #: descrição de erro

(# É o número mensagem de erro)
Exemplo: erro C37: identificador não declarado: i
Quando há erros de compilação, a descrição do erro pode ser referenciado pelo número mensagem de erro do
compilador.
2. Descrição do erro
(C1) erro de sintaxe : 'Identificador'
Há muitas possibilidades para causar erro do compilador.
Por exemplo:
macro_command principal () i
char, 123xyz // este é um nome de variável não suportada
macro_command final
(C2) 'identificador' usado sem ter sido inicializado

Macro deve definir o tamanho de uma matriz durante a declaração.
Por exemplo:
macro_command principal () carbonizar
i int g [i]
// i devem ser um macro_command final
constante numérica
(C3) erro redefinição: 'identificador'

O nome da variável e função dentro do seu âmbito deve ser exclusivo.
Por exemplo:
macro_command principal () int
g [10] , g // macro_command final
de erro
75
Referência macro
(C4) erro de nome de função: 'identificador'
palavras-chave reservadas e constante não pode ser o nome de uma função
Por exemplo :
sub int if () // erro
(C5) parênteses não vêm em pares

Declaração em falta “(” ou “)”
Por exemplo :
macro_command principal) // ausência de "("
(C6) expressão ilegal sem correspondência 'se'
Faltando expressão “if”
(C7) expressão ilegal (não 'depois') sem correspondência 'se'
Missing “e depois” em “if”
(C8) expressão ilegal (não 'end if')

Missing “acabam se”
(C9) ilegal 'end if' sem correspondência 'se'
Inacabada “Se' declaração perante‘End If’
(C10) ilegal 'else'

O formato do “if” é:
if [expressão lógica] e depois [outra coisa [if
[expressão lógica] então]]
fim se
Qualquer formato diferente este formato irá causar um erro de compilação.
(C17) expressão ilegal (não ''), sem correspondência 'próxima '
“Para” erro de declaração: faltando “para” antes “próxima”
(C18) tipo variável ilegal (não inteiro ou carvão animal)
Deve ser um número inteiro ou variável de char
76
Referência macro
(C19) erro de tipo variável

Faltando declaração de atribuição
(C20) deve ser palavra-chave 'para' ou 'down'
Faltando palavra-chave “para” ou “para baixo”
(C21) expressão ilegal (não 'próxima')
O formato da declaração “for” é:

para [variável] = [valor inicial] a [valor final] [passo]
próximo [variável]
(C22) 'serpenteiam pelo' declaração não contém 'enquanto'
“Enquanto” erro de declaração: faltando “enquanto” antes “Wend”
(C23) expressão ilegal sem correspondência 'serpenteiam'
O formato do “Enquanto” declaração é:
enquanto [expressão lógica]
dirigir-se
(C24) erro de sintaxe: 'break'

“Break” declaração só pode ser usado em “para” “enquanto” declaração.
(C25) erro de sintaxe: 'continue'

“Continuar” declaração só pode ser usado na declaração “for”, ou “enquanto” declaração.
(C26) erro de sintaxe
Erro na expressão.
(C27) erro de sintaxe
A incompatibilidade de um objecto em operação expressão pode causar um erro de compilação.
77
Referência macro
Por exemplo :
macro_command principal () int a,
b para a = 0 a 2 b = 4 + // xyz
ilegal: xyz é indefinido

seguinte, um
macro_command final
(C28) deve ser 'macro_command'

Deve haver 'macro_command'
(C29) deve ser palavra-chave 'sub'
O formato da declaração da função é:
sub [Tipo de dados] function_name (...) .. ......... sub
extremidade
Por exemplo :: sub pow

int (int exp) ....... sub end
(C30) Número de parâmetros é incorrecta

Incompatibilidade do número de parâmetros
(C31) tipo de parâmetro é incorrecto
Incompatibilidade de tipo de dados de parâmetro. Quando uma função é chamada, o tipo de dados eo número de parâmetros
deve coincidir com a declaração de função, caso contrário ele irá causar um erro de compilação.
(C32) variável é incorrecta

Os parâmetros de uma função deve ser equivalente aos argumentos de passagem para uma função para evitar erro
de compilação.
78
Referência macro
(C33) nome função: função não declarado
(C34) esperado expressão constante

formato índice de matriz ilegal.
(C35) declaração de matriz inválido
(C36) erro índice de matriz
(C37) identificador não declarado: i 'identificador'
Qualquer variável ou função deve ser declarada antes do uso.
(C38) de endereço de dados suportada PLC-un
O parâmetro de GetData (...), SetData (...) deve ser o endereço PLC legal. Se o endereço é ilegal, será
mostrada esta mensagem de erro.
(C39) 'idenifier' deve ser um número inteiro, char ou constante
O formato de array é:
Declaração: Array_Name [constante] (constante é o tamanho da matriz) Uso:
Array_Name [inteiro, caracteres ou constante]
(C40) sintaxe execução não deve existir antes de declaração de variável ou definição constante
Por exemplo :
macro_command principal ( )
int a, b
para a = 0 a 2 b = 4
+ h um int, k //
ilegais - definições devem ocorrer antes de quaisquer declarações ou expressões //
por exemplo, b = 4 + um lado
um
macro_command final
(C41) variáveis flutuador não pode ser contida no cálculo mudança
function (C42) deve retornar um valor
79
Referência macro
function (C43) não deve retornar um valor
(C44) variáveis flutuador não pode ser contido no cálculo
erro de endereço (C45) PLC
(C46) o tamanho da matriz de descarga (máx. 4k)
(C47) função macro entrada do comando não é apenas um
(C48) função de entrada macro comando deve ser apenas um
A única entrada principal da macro é:
function_name macro_command ()
(C49) o número da estação de um destinatário prolongado deve estar entre 0 e 255
Por exemplo :
SetData (bits [0], “PLC 1”, LB, 300 # 123, 100) //
ilegal: 300 # 123 significa o número da estação é de 300, mas o máximo é de 255
(C50) um nome de PLC inválido
nome de PLC não está definida na lista de parâmetros do sistema dispositivo.
(C51) comando de macro não controlar um dispositivo remoto
A macro só pode controlar uma máquina local.
Por exemplo :
SetData (bits [0], “PLC 1”, LB, 300 # 123, 100)
“PLC 1” está conectado com o HMI remoto, para que ele não pode trabalhar.
80
Referência macro
18.11 Código de macro de exemplo
1. “para” declaração e outras expressões (aritmética, deslocamento bit a bit, lógica e comparação)
macro_command principal () int a
[10], b [10], i
b [0] = (400 + 400 << 2) / 401 b [1] =

22 * 2 - 30% 7 b [2] = 111 >> 2
b [3] = 403> 9 + 3> = 9 + 3 <4 + 3 <= 8 + 8 == 8 b [4] = não 8

+ 1 e 2 + 1 ou 0 + 1 2 b XOR [5] = 405 e 3 e não 0 b [6] = 8 &
4 + 4 & 4 + 8 | 4 + 8 ^ 4 b [7] = 6 - (~ 4) b [8] = 0x11 b [9] =
409
para i = 0 a 4 passo 1
se (a [0] == 400) então
GetData (a [0],”Dispositivo 1” , 4x, 0,9) GetData (b [0],”
Dispositivo 1” , 4x, 11,10) acabam Se seguinte i
macro_command final
2. “while”, “se” e declarações de “quebrar”
macro_command principal () int b
[10], ii = 5
enquanto i == 5-20% 3
GetData (b [1], “Dispositivo 1”, 4x, 11, 1)
se b [1] == 100 então
quebrar
final se
81
Referência macro
dirigir-se
macro_command final
3. As variáveis globais e chamada de função
g de char
sub divertimento int (int j, int k) int y
SetData (j, “HMI local”, LB, 14, 1) GetData (y,

“HMI local”, LB, 15, 1) g = y
regresso y
End Sub
macro_command principal () int a,
b, i
a=b=
23
i = diversão (a, b)
SetData (i, “HMI local”, LB, 16, 1)
4. “if”
macro_command principal () int k
[10], j
para j = 0 a 10
k [j] = j j
próxima
se K [0] == 0 então
SetData (k [1], “Dispositivo 1”, 4x, 0, 1) end if
82
Referência macro
SetData (k [1], “Device 1”, 4x, 0, 1) else
SetData (k [2], “Dispositivo 1”, 4x, 0, 1) end if
SetData (k [1], “Device 1”, 4x, 1, 1) else if k [2]
== 1, então
SetData (k [3], “Dispositivo 1”, 4x, 2, 1) Se terminar
SetData (k [1], “Device 1”, 4x, 3, 1) else if k [2] ==
2, em seguida,
SetData (k [3], “Device 1”, 4x, 4, 1) else
SetData (k [4], “Dispositivo 1”, 4x, 5, 1) Se terminar
macro_command final
5. declarações “enquanto” e Wend”
macro_command principal () caractere i
=0
int a [13], b [14], c = 4,848
b [0] = 13
enquanto b [0]
um [i] = + 20, i * 10
Se a [i] == 120 e depois
c = 200 fim
ruptura se
i=i+1
83
Referência macro
dirigir-se
SetData (c, “Dispositivos 1”, 4x, 2, 1)
6. “quebrar” e “continuar” declarações
macro_command principal () caractere i
=0
int a [13], b [14], c = 4,848
b [0] = 13
enquanto b [0]
um [i] = + 20, i * 10
Se a [i] == 120 = 200 c
então
i = i + 1 End
If continuar
i=i+1
Se C == 200 então
SetData (c, “Dispositivos 1”, 4x, 2, 1) final
ruptura se wend
macro_command final
7. matriz
macro_command principal () int a
[25], b [25], i
b [0] = 13
84
Referência macro
para i = 0 a b [0] passo 1
um [i] = + 20, i * 10
próximo i
SetData (a [0], “Dispositivo 1”, 4x, 0, 13)
85
Referência macro
18,12 macro TRACE ião Funct
1. função de rastreio é adicionado à macro, e pode ser usado com EasyDiagnoser, para a visualização do conteúdo actual da
variável utilizada.
O seguinte ilustra como utilizar a função TRACE em MACRO.
Primeiro de tudo, adicione macro_1 no projeto, e em macro_1 adicionar TRACE ( “LW =% d”, a) . “% D” indica para
mostrar o valor actual de PV em decimal. O conteúdo macro_1 é como o seguinte:
macro_command a Principal()
baixo uma
Adquirir dados (uma, "HMI Local" , LW, 0 , 1 )
a=a+1
SetData (uma, "HMI Local" , LW, 0 , 1 )
VESTÍGIO ( "LW0 =% d" , uma)
fim macro_command
Para o uso detalhada da função TRACE, consulte a ilustração no parágrafo seguinte.
86
Referência macro
Em segundo lugar, adicionar Numeric Display e função objetos Key na janela 10 do projeto. As definições desses objetos
são mostrados abaixo. Função objeto Key é usado para executar macro_1.
87
Referência macro
Por último, compilar o projeto concluído e executar off-line ou on-line simulação.
Ao processar simulação no PC, clique direito e selecione “Run EasyDiagnoser” no menu pop-up.
Depois, EasyDiagnoser será iniciado. [Logger] vitrines se EasyDiagnoser é capaz de se conectar com o
HMI para ser assistido ou não. [Saída] janela exibe a saída da função TRACE. A figura abaixo mostra que
EasyDiagnoser consegue ligar com IHM.
88
Referência macro
Quando EasyDiagnoser não é capaz de se conectar com HMI, [Logger] vitrines de conteúdo como mostrado abaixo:
89
Referência macro
A possível razão de não ser capaz de obter conexão com HMI pode ser falha na execução de simulação no PC. Outra
razão é que o Porto No. usado em projeto de simulação no PC é incorreta (ou ocupado pelo sistema). Por favor, altere
Porto No. como mostrado, compilar projeto, em seguida, fazer a simulação novamente.
Ao abrir EasyDiagnoser, o Po Só desta forma pode

rt No.adeve ser definido como o mesmo que no projecto.
comunicação bem-sucedida.
Os três portas sucessivas da porta projecto não. são preservados para comunicação IHM. Tomar a definição acima, como
exemplo, Nº porta é definido como 8005, portanto, porta 8005, 8006 e
90
Referência macro
8007 será preservada. Neste caso, ao executar a simulação em PC, certifique-se de que estas portas não estão
ocupadas por outros programas.
2. TRACE Lista Sintaxe :
Nome VESTÍGIO
Sintaxe TRACE (formato, argumento)
Descrição Use esta função para enviar cadeia especificada ao EasyDiagnoser. Os usuários podem
imprimir o valor atual de variáveis durante o tempo de execução da macro para depuração.
Quando TRACE encontra a primeira especificação do formato (se houver algum), que converte o valor do
primeiro argumento após o formato e emite-o de acordo.
formato refere-se ao controlo de formato de cadeia de saída. Uma especificação do formato, o qual consiste
em opcional (em []) e os campos requeridos (em negrito), tem a seguinte forma:
% [ bandeiras] [largura] [.precision] tipo
Cada campo de especificação do formato é descrita como a seguir:
bandeiras ( opcional):
-
+
largura ( opcional):
Um número decimal inteiro n negativo de controlar o número mínimo de
caracteres impressos.
precisão ( opcional):
Um número inteiro não negativo decimal que especifica a precisão e o número de
caracteres a serem impressos.
tipo:
C ou c : Especifica um caractere de byte único.
d : Assinado inteiro decimal.
Eu : Assinado inteiro decimal.
o : Sem sinal inteiro octal.

você : Sem sinal inteiro decimal.
X ou X : Sem sinal inteiro hexadecimal.
E ou E : Valor assinado com a forma. [-] d.dddd e [ assinar] ddd Onde d é
um único dígito decimal, dddd é um ou mais dígitos decimais, ddd é
exatamente três dígitos decimais, e placa é + ou -.
91
Referência macro
f : Valor assinado que tem a forma [-] dddd.dddd,

Onde dddd é um ou mais dígitos decimais.
O comprimento da corda de saída é limitada a 256 caracteres. o argumento parte
é opcional.
Exemplo macro_command principal () c1 char
= 'um' s1 flutuador f1 = 32767 curta =
1,234567
TRACE ( “Os resultados são”) // saída: Os resultados são TRACE (

“c1 =% c, S1 =% d, f1 =% f”, c1, S1, f1) // saída: c1 = A, S1 =
32767, f1 = 1,234567
macro_command final
3. LB9059 recentemente adicionados - desabilitar a função TRACE MACRO (quando ON) Quando definir ON, a
mensagem de TRACE saída não será enviado para EasyDiagnoser.
4. Os usuários podem executar diretamente EasyDiagnoser.exe do Gerente de Projeto. Na Project Manager, HMI atual na linha
serão listados; os usuários podem simplesmente selecionar o HMI para ser assistido.
Por favor, note que o Projeto Porto deve ser o mesmo que Porto No. usado em arquivo de projeto.
92
Referência macro
5. projeto Download to HMI para começar a operar. Quando EasyDiagnoser é incapaz de obter conexão com o HMI para
ser assistido, é possível que o poder HMI não é ON, ou Nº porta está incorreta. Isso pode causar EasyDiagnoser para
se conectar em seguida, desligue com HMI continuamente. Por favor, verifique se a porta No. em ambientes
EasyDiagnoser é o mesmo que o do projeto. A maneira de mudar isso é descrita antes.
6. Quando EasyDiagnoser consegue ligar com HMI, simplesmente executar macro_1, janela [saída] irá
então apresentar o resultado da função de Trace.
93
Referência macro
94

Chapter 18 Macro Reference - En.pt PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Chapter 18 Macro Reference - En.pt PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Referência macro

Capítulo 18 Referência Macro .............................................. ............................................... 2

18.4.5 Demonstrações reiterativa ............................................. .............................. 21

18.4.5.2 Demonstrações enquanto Wend-........................................... ..................... 22

18.4.5.3 outros comandos de controlo ............................................ ................. 23

18.6.4 Transformação Bit ............................................. ..................................... 41

18.10 Mensagem de erro Compiler .............................................. ................................... 75

18.12 Função TRACE Macro .............................................. .................................... 86

Capítulo 18 Referência Macro

uso e métodos de programação de comandos de macro.

18.1 iões Instruir à macro tor Edi

1. editor macro fornece as seguintes novas funções:

uma. exibindo número da linha

c. Cut / Copy / Paste

e. Alternar marcador / Anterior Bookmark / Next Bookmark / Limpar Todos os Favoritos

f. Alternar Todos Outlining

As instruções abaixo mostram como usar essas novas funções.

Aceleradores são suportados como descrito no menu.

(Undo: Ctrl + Z, Refazer: Ctrl + Y).

a função colar está habilitado.

7. Use “Selecionar Tudo” para incluir todo o conteúdo na área de edição.

abaixo mostra como ele funciona.

esquerdo da área de edição.

seleção de”Bookmark Anterior” irá mover o cursor para o favorito anterior.

d. Selecionando “Limpar Todos os Favoritos” irá fechar todos os marcadores.

a abrir, como mostrado abaixo:

Pressione para delinear para o próximo

Pressione para delinear se então bloco

12. As instruções entre as palavras-chave são chamados de um “bloco” do código de macro:

uma. O bloco de funes: sub - sub extremidade

ii. enquanto - Wend

Eu. se - final, se

d. declarações seletivos: selecione caso - End Select

18.2 Construção de iões macro

colocados em uma ordem específica para criar a saída desejada.

Um Macro é construído da seguinte maneira:

Declaração de variável global ---------------------------------- - Opcional

Declarações de função Bloco sub ----------------------------------- Opcional

macro_command principal () ----------------------------------- - Requeridos

macro_command final ----------------------------------- - Requeridos

apenas dentro do bloco específico.

curta pressão = 10 // declaração de variável local

SetData (pressão, "Allen-Bradley DF1", N7, 0, 1) // função de chamada

18.3.1 constantes e variáveis

Tipo constante Nota Exemplo

boleano verdadeiro falso

Exemplo de algumas declarações usando constantes:

macro_command principal () curta

Regras de Nomenclatura para as variáveis

1. Um nome de variável deve começar com um alfabeto.

2. Os nomes das variáveis ​mais de 32 caracteres não são permitidos.

3. As palavras reservadas não podem ser usados ​como nomes de variáveis.

Tipo de variável Descrição Alcance

bool Um pouco (discreta) 0, 1

baixo 16 bits (palavras) ± 32.767

int 32 bits (palavra dupla) ± 2147418112

flutuador 32 bits (palavra dupla)

caracter não identifcado 8 bits (byte) 0 a 255

curto b [20], interruptor [30]

flutuador pressão [15]

Mínimo de índice de matriz é 0 e o máximo de índice de matriz é (tamanho da matriz - 1).

onde: mínimo de índice de matriz é 0 e o máximo de índice de matriz é 99 (100 - 1)

Inicialização variável e matriz

2. Os nomes das variáveis mais de 32 caracteres não são permitidos.

3. As palavras reservadas não podem ser usados como nomes de variáveis.

Isto cobre a declaração de variáveis e matrizes. A construção formal é a seguinte: