Recomendamos a leitura prévia dos Tutoriais: Drivers de CLP’s e endereçamento dos Tag’s nas IHMs
e Macros nas IHM’s WEINTEK.
Mostraremos como utilizar uma IHM Weintek como CLP utilizando os módulos de entradas e saídas TECNOLOG AM8DI e AM8RO.
1. Construção do cabo de comunicação da IHM com os módulos AM8x
2. Ligação e configuração dos módulos de entradas e saídas digitais AM8x
3. Parametrização da porta COM1 no software EasyBuilder8000
Abra o software e uma janela de nome “EasyBuilder8000” irá aparecer, escolha “NEW” e em seguida clique “OK”. Escolha o modelo da IHM e clique “OK” novamente. Na janela “System Parameter Settings” escolha “NEW” e configure os seguintes parâmetros: Escolha “PLC type” = MODBUS RTU, “PLC I/F” = RS-485 2W, e em “Settings…” configure como abaixo:
Clique “OK” e “OK” novamente para completar a configuração do protocolo.
4. Construção do CLP na IHM através de macros
5. Criação dos Macros 0 e 1
Clique em “Tools” > “Macro…” > “NEW” > “Compile” > “Exit” para criar o Macro_0, para criar o Macro_1 clique novamente em “NEW” > “Compile” > “Exit”.
6. Construção do Macro_0
6.1 Leitura das Entradas digitais e espelhamento na memória imagem da IHM
Na “Macro list” escolha Macro_0 e clique ”Edit”, onde, após “Macro_command main()”, criaremos nosso algoritmo.
Construção do algoritmo de leitura do módulo de entradas digitais AM8DI com endereço “1” na rede:
Declare a variável “bool entrada1[9]” e clique no botão [GET/SET FN…] para abrir a janela API. Na função GetData configure: “Variable” = bool entrada1[9], “Array index” = 1, “PLC name” = “MODBUS RTU”, “Device type” = 3x , “address” = Station number”#”Posição na memória”, então address = 1#00001.
Este GetData lê as 8 entradas no endereço 0 do modulo AM8DI e armazena o estado lógico de cada entrada nas variáveis “bool entrada1[ ]” do Macro 0.
Para espelhar a imagem das entradas na memória da IHM precisamos copiar o conteúdo das variáveis entrada1[ ] através da função SetData: “Variable” = entrada1, “PLC name” = Local HMI, “Device type” = LW, “Address” = 10, “Data count” = 1.
Agora o seu código deve estar igual a figura abaixo:
6.2 Leitura das Saídas digitais e espelhamento na memória imagem da IHM
Construção do algoritmo de escrita no módulo de saídas à relé AM8RO que possui o endereço “5” na rede:No
mesmo Macro, abaixo de “bool entrada1[9]” declare a variável “bool saida1[9]” e clique no botão [GET/SET FN…] para abrir a janela API e programar GetData e SetData como fizemos com as entradas, mas agora, para transferir as saídas:GetData
: “Variable” = saida1, “Array index” = 1, “PLC name” = “Local HMI”, “Device type” = LW, “Address” = 50, “Data count” = 1.
SetData: “Variable” = saida1, “Array index” = 1, “PLC name” = MODBUS RTU, “Device type” = 6x (escrita) “Address” = 5#00001, “Data count” = 1.
O código deve estar como segue:
A imagem das saídas “LW50” é copiada para dentro do Macro 1 nas variáveis saida1[1 até 9] pelo GetData e depois é transferida pelo SetData para o endereço 0 do módulo AM8RO.
Precisamos acrescentar a função “SYNC_TRIG_MACRO(Macro ID)” que vai chamar o Macro 2 logo após as entradas terem sido lidas no modulo AM8DI e terem sido copiadas na memória da IHM. Assim asseguramos que as entradas estão atualizadas antes de iniciarmos a execução do programa.
Agora temos o Macro 1 terminado e já podemos compila-lo.
Cique em “Compile” e a informação “0 error(s)” deverá aparecer na janela acima do botão “Compile”, caso contrário corrija o código e compile novamente. Ao final do processo clique “Exit”.
7. Exemplo de construção do Macro 2 “Programa do CLP”
Neste exemplo vamos controlar a partida de 2 motores ligados nas saídas 3 e 5 do AM8RO, as chaves que ligam os 2 motores são as entradas 1 e 3 do módulo AM8DI e as que desligam são as entradas 6 e 8, o motor número 2 liga somente quando o motor 1 estiver ligado.
Circuito em Ladder com 2 linhas lógicas:
O anexo ” Conversão de esquemas elétricos Ladder em equações lógicas” explica como fazer a conversão das linhas Ladder em equações lógicas no Macro.
entrada1[ ]: entradas P0001=1, P0003=3, P0006=6 e P0008=8
saída1[ ]: saidas K0003=3 e K0005=5
A 1º linha K0003 = (P0001 or K0003) and (not P0006) fica como
Saida1[3] = (entrada[1] or saida1[3]) and (not entrada1[6])
A 2º linha K0005 = (P0003 or K0005) and (K0003 and not P0008) fica como:saida1
[5] = (entrada1[3] or saida1[5]) and (saida1[3] and not entrada1[8])
Construindo o Macro_1 “Macro de processos”:
Na “Macro list” escolha o Macro_2 e clique ”Edit”, onde, após “Macro_command main()”, criaremos nosso algoritmo.
1º – Declare as variáveis tipo array “bool entrada[9]” e “bool saida[9]”, onde copiaremos a memória imagem da IHM.
2º – Leia a imagem das entradas em entrada[1~8]: GetData(entrada[1], “Local HMI“, LW_Bit, 0001000 , 8)
3º – Leia a imagem das saidas em saida[1~8]: GetData(saida[1], “Local HMI“, LW_Bit, 0005000 , 1).
4º – Agora escrevemos as equações lógicas do nosso programa. Lógica do exemplo proposto:
saida[3] = (entrada[1] or saida[3]) and (not entrada[6])
saida[5] = (entrada[3] or saida[5]) and (saida[3] and not entrada[8])
5º – Agora precisamos atualizar as saídas (resultado da lógica) na memória imagem das saídas da IHM que será a palavra LW50, faremos isso usando a função SetData como segue:
“SetData(saida[1], “Local HMI”, LW_Bit, 0005000,1)”.
Código resultante para o Macro_1:
Agora o nosso Macro_1 está pronto, confira o código e se ele estiver idêntico clique em “Compile” e a informação “0 error(s)” deverá aparecer na janela acima do botão “Compile”.
Caso contrário, corrija os erros e “Compile” novamente até eliminar todos os erros, depois clique em “Exit”.
8. Ativando o Macro_0 ciclicamente para fazer a varredura do CLP
Macros somente são executados quando são “chamados”, para ativar os macros do clp ciclicamente vamos utilizar a função “PLC Control”. Clique em “Objects” > “PLC Control”, clique em “New” e configure como abaixo:
Em “Attribute”: “Type of control” = “Execute a macro program” e “Macro name” = macro de entradas e saídas, no nosso caso o macro [ID:001].
Em “Trigger address”: “Address” = LW_Bit e “0903000” (Oscilador de 100ms do RTC da IHM)
Na Opção “Trigger mode” escolhemos OFF<->ON e o macro será acionado a cada transição de estado do LW_Bit 0903000, ou seja cada 100ms.
O Macro_1 (macro de processos do clp) não precisa ser ativado pois a função SYNC_TRIG_MACRO(2) dentro do Macro 1 vai fazer esta operação.
Clique em “OK” e em seguida ”Exit”. Agora a IHM estará funcionando como um CLP.
9. Limites atuais do sistema
Podemos adicionar até 15 módulos de 8 E/S da série AM8x, possibilitando ao usuário ter até 120 E/S, não importando se são digitais ou analógicos e nem a proporção de entradas ou saídas.
O menor clock disponível para atualização das entradas e saídas é o bit de 100ms do RTC da IHM.
O limite de variáveis por macro é fixado em 4096, se declararmos um array a[4096] todas as posições estarão ocupadas.
Você pode criar vários macros de processo para executar lógicas no CLP, basta adicionar no Macro_0 mais uma função SYNC_TRIG_MACRO( ) com o ID do novo macro, lembrando que esta função só irá iniciar o processamento do novo macro quando o anterior tiver concluído a sua execução.
O tamanho do macro, assim como a ocorrência de falhas de comunicação com módulos da rede Modbus, pode aumentar o tempo de varredura do programa, pois a função GetData só irá passar para o próximo comando após o “Time out” da comunicação.
10. Anexo: Conversão de esquemas elétricos Ladder em equações lógicas
Este é o circuito básico para ligação de motores. Dividiremos o circuito em partes, a divisão é feita a cada ramo com contatos em paralelo, o ultimo campo será o resultado, no caso, a ligação do motor “K0007”.
Parte 1: K0000 “ou” K0007 : (K0000 or K0007) Qualquer um dos contatos torna o ramo paralelo verdadeiro.
Parte 2: “Não” K0001 (normalmente fechado): (not K0001) Equivale ao contato NF, nega o valor da variável.
Parte 3: K0007 Resultado da equação lógica: verdadeiro/falso ou ligado/desligado.
A equação começa pelo resultado seguido por ”=” e depois pelas partes interligadas pelo operador “and” :
K0007 = (PARTE 1) e (PARTE 2): O resultado da parte 1 é operado(and) com o resultado da parte 2:
A equação final fica : K0007 = (K0000 or K0007) and (not K0001)
O processador vai executar primeiro as equações que estão dentro de parênteses, após todas as operações que se encontram dentro dos parênteses serem executadas, as operações fora deles serão executadas em série, da esquerda para a direita, ou seja:
Convertendo equações mais complexas
O circuito abaixo mostra um circuito mais complexo onde utilizaremos a mesma lógica do exemplo 1:
Parte 1: (K0000 “e” “não” K0001), “ou” K0007: ((K0000 and not K0001) or K0007)
Parte 2: “Não” K0002 “e” K0003: (not K0002 and K0003)
Parte 3: “Não” K0004 “ou” K0005 “ou” K0006: (not K0004 or K0005 or K0006)
Parte 4: K0007, bobina de saída (resultado): K0007 =
Para montar a equação vamos interconectar as “Partes” através do operador “e”, pois todas as partes precisam estar verdadeiras simultaneamente para acionar a nossa bobina de saída.
A equação vai ficar assim: K0007 = (PARTE 1) e (PARTE 2) e (PARTE 2)
Ou seja:A
equação lógica será resolvida da esquerda para a direita, uma parte de cada vez, começando pelos parênteses.
O resultado da 1º Parte será operado com o resultado da 2º Parte e assim por diante.
Se a 1º Parte e a 2º e a 3º forem verdadeiras, o resultado final será também verdadeiro.
Então, para que a saída K0007 ligue, todas as partes do circuito deverão ter resultado verdadeiro.
