Apostila de CODESYS v3

V1.0

Internal
 2

Internal
Objetivo da apostila
Esta apostila fornece aos usuários informações sobre o produto para a criação de
projetos usando o software de programação CODESYS v3 com o controlador WAGO
751-9301 da linha CC100 e também a linha 750-XXX. Cada seção desta apostila
fornece instruções simples e sugestões úteis que você poderá aplicar ao seu projeto.
Abaixo um breve esboço do conteúdo do documento:

Configurações. Inicias
Dentro do escopo das configurações inicias, iremos explorar as principais
configurações e funcionalidade dos controladores para iniciar a configuração no
CODESYS.

- Entendendo e explorando os Hardware 750/751 WAGO;

- Configurando o endereço IP;
- Primeiro acesso ao Web Based Management (WBM);
- Ativando / Desativando os protocolos nativos dos controladores;
- Ativando / Desativando a autenticação do e!runtime e servidor Web.
- Definindo o software de programação;

Explorando o software CODESYS v3

Dentro desse escopo iremos conhecer mais sobre o ambiente de programação e
entender as principais funcionalidades dessa ferramenta, como:

- Explicando o ambiente inicial;

- Definindo a linguagem de programação default
- Criando um novo projeto
- Configurando e parametrizando Controladores e I/O’s
• Offline;
• Online.
- Criando uma nova rotina;
- Adicionado tarefas dentro do controlador WAGO;
- Conhecendo as principais instruções das linguagens de programação LD e ST;
- Criando um Bloco de função (Function block – FB)
- Criando uma função;
- Criando uma estrutura – Struct
- Tipos de variáveis no Programa;
- Adicionando uma nova biblioteca em seu programa;
- Realizando o download no controladores;
• Explorando os tipos de download;
• Simular CODESYS
- Como realizar o upload do software;

Exercícios de programação
Nessa apostilha serão apresentados exercícios para que você possa desenvolver um
software dentro da ferramenta de programação do CODESYS v3. Alguns exercícios
estarão disponibilizados na linguagem de programação LD e ST para que você possa
explorar as vantagens e característica de cada linguagem de programação. A seguir
iremos explorar tópicos que os exercícios irão explorar:

- Exercício introdutório;
- Criando seu bloco de função do início;
- Criando suas visualizações – Recurso (WEBVISU);
3
Internal
- Comunicação através do protocolo Modbus TCP;
• PFC sendo mestre da rede
• PFC sendo escravo da rede
- Comunicação através do protocolo MQTT (Envio de dados);
- Escrevendo em um banco de dados MySQL
- Utilizando o Dashboard Grafana

4
Internal
Sumário
Objetivo da apostila --------------------------------------------------------------------------------------------------------------- 3
Configurações. Inicias --------------------------------------------------------------------------------------------------------------------------------------- 3
Explorando o software CODESYS v3--------------------------------------------------------------------------------------------------------------------- 3
Exercícios de programação -------------------------------------------------------------------------------------------------------------------------------- 3

Configurações Inicias -------------------------------------------------------------------------------------------------------------- 6

Entendo e explorando o hardware 750- WAGO ------------------------------------------------------------------------------ 6
Entendendo e explorando o hardware 751- WAGO ------------------------------------------------------------------------ 7
Configurando o endereço IP ---------------------------------------------------------------------------------------------------------- 8
Primeiro acesso ao Web Based Management (WBM) ------------------------------------------------------------------- 10
Ativar / Desativar os protocolos nativos dos controladores PFC ------------------------------------------------- 11
Ativar / Desativar autenticação para e! RUNTIME e servidor web------------------------------------------------- 12
Definindo o software de programação ----------------------------------------------------------------------------------------- 12
Explorando o software Codesys 3.5 ----------------------------------------------------------------------------------------- 14
Explicando o ambiente inicial do software ---------------------------------------------------------------------------------- 15
Criando um novo Projeto ------------------------------------------------------------------------------------------------------------ 17
Configuração e parametrização controladores PFC e I/O’s ---------------------------------------------------------- 18
Modo Online – Função Scan ---------------------------------------------------------------------------------------------------------------------------- 18
Modo Offline ------------------------------------------------------------------------------------------------------------------------------------------------ 22
Endereçamento de Entradas/Saídas ------------------------------------------------------------------------------------------------------------------ 25
Conhecendo as principais funções da linguagem LD (Ladder) e ST (Texto estruturado) ------------- 25
Criando um nova Rotina -------------------------------------------------------------------------------------------------------------- 35
Criando uma função (FUN) ---------------------------------------------------------------------------------------------------------- 36
Criando uma estrutura – Função Struct --------------------------------------------------------------------------------------- 38
Tipos de variáveis no Programa -------------------------------------------------------------------------------------------------- 40
Adicionando uma nova biblioteca em seu programa ------------------------------------------------------------------- 46
Realizando o download nos controladores ---------------------------------------------------------------------------------- 47
Simulador Codesys --------------------------------------------------------------------------------------------------------------------- 49
Exercícios de programação ---------------------------------------------------------------------------------------------------- 50
Exercício 1 - Introdutório ------------------------------------------------------------------------------------------------------------- 50
Exercício 2 – Criando seu bloco de função (FB) do inicio ------------------------------------------------------------ 60
Exercício 3 – Controlador Wago sendo mestre na rede Modbus TCP ------------------------------------------ 83
Exercício 4 – Controlador Wago sendo escravo da rede Modbus TCP ----------------------------------------- 91

5
Internal
Configurações Inicias
A seguir iremos demonstrar os principais elementos para entendimento do sistema de
automação da WAGO baseado nos controladores PFC da WAGO.

Entendo e explorando o hardware 750- WAGO

A seguir iremos demonstrar os principais elementos para entendimento do sistema de
automação da WAGO baseado nos controladores PFC da WAGO.

A composição do Hardware de automação da WAGO é definida pela seguinte estrutura:

ATENÇÃO
Se faz necessário sempre incluir um módulo final (750-600) ao final de sua configuração
de Hardware.
O controlador PFC WAGO permite ser configurados sem os módulos I/O’s, tendo somente
a composição formada por Controlador + Módulo Final

Se faz necessário sempre incluir um módulo final (750-600) ao final de sua configuração
de Hardware.
O controlador PFC WAGO permite ser configurados sem os módulos I/O’s, tendo somente
a composição formada por Controlador + Módulo Final
Para os módulos de I/Os é possível identificá-los através das seguintes cores:

6
Internal
Entendendo e explorando o hardware 751- WAGO

A seguir iremos demonstrar os principais elementos para entendimento do sistema de

automação da WAGO baseado nos controladores CC100 da WAGO.

A composição dos sinais de comunicação de automação é definida pela seguinte estrutura:

7
Internal
Configurando o endereço IP
Existem várias opções para configurar o endereço IP do seu controlador, iremos descrever
algumas delas abaixo:

ATENÇÃO
Para que os passos a seguir funcionem se faz necessário configurar a faixa da porta de
rede de seu computador/Laptop no mesmo range: 192.168.1.X, sendo a letra X um número
diferente indicado ao controlador.

Obtendo um endereço IP via DHCP`

Nas configurações de fábrica do controlador, a interface ETHERNET (porta X1 e porta X2)
estão definidas com endereço IP usando o protocolo DHCP (Dynamic Host Configuration
Protocol).

Definir um endereço IP provisório no PFC ou CC100

Se você não estiver executando nenhum servidor DHCP em sua rede, defina o endereço IP
manualmente para acessar o controlador via ETHERNET. A porta ETHERNET X1 do
controlador pode ser definida com o endereço provisório "192.168.1.17".
Coloque a chave de modo de funcionamento na posição STOP (posição intermédia).

Definir a chave de modo de funcionamento para a posição STOP

Pressione o botão Reset (RST) com uma ferramenta adequada durante pelo menos 8
segundos.

Pressione o botão Reset

A gravação do novo endereço IP provisório é indicada pelo LED "SYS" piscando em laranja.
O controlador pode agora ser acessado através do endereço IP fixo "192.168.1.17." Este
endereço IP é válido até a próxima reinicialização. Você pode acessar o Gerenciamento do
controlador via Web através do endereço provisório e fazer as configurações. A configuração
IP anterior é restaurada após um reinício.

Testando o link ETHERNET

Para testar o link ETHERNET, abra o Comando Prompt digitando "cmd" em Iniciar> Executar
... em Windows.

8
Internal
Janela de diálogo "Executar ............................ "
Digite o comando "ping 192.168.1.17".

Comando ping

Quando o link ETHERNET estiver livre de erros, você receberá as seguintes estatísticas de
ping: "Pacotes: Enviados = 4, Recebidos = 4, Perdidos = 0 (perda de 0%)".

Comando ping com estatísticas

9
Internal
Primeiro acesso ao Web Based Management (WBM)

Configurações adicionais podem ser inseridas no controlador através das páginas HTML
dentro do controlador, o Gerenciamento via Web (WBM). O endereço IP provisório
"192.168.1.17" é usado para o exemplo (ver seção anterior).
Abra um navegador e digite "http://192.168.1.17/wbm" na linha de endereço. Isso abrirá o
gerenciamento via Web. O login deve ser feito para inserir as configurações. Sem um login,
os itens do menu estarão desabilitados.

Gerenciamento via Web

Clique no botão [Login] no canto superior. Insira “Username” e “Password.”

Padrão:
Username admin
Password wago

Alterando o endereço IP de provisório para fixo via WBM

As configurações para a interface ETHERNET podem ser salvas permanentemente na

página WBM em
"Configuration" > "Networking" > "TCP / IP Configuration".

Salvando configurações ETHERNET permanentemente

10
Internal
Ativar / Desativar os protocolos nativos dos controladores PFC

Ativar / desativar protocolos não criptografados como HTTP, FTP ou Telnet na página WBM
Para isso abra novamente a página Web do controlador e acesse a seguinte aba:
"Configuration” > "Ports and Services” > “Network Services ".

Ativando/desativando protocolos

Para realizar todos os exercícios dessa apostila recomendamos ativação das seguintes
portas:
• FTP, HTTP, HTTPS e I/O Check

Ativando/desativando protocolos

11
Internal
Ativar / Desativar autenticação para e! RUNTIME e servidor web
Você pode alterar os dados de acesso e a senha para e!RUNTIME em "Configuration">
"Ports and Services"> "PLC Runtime Services" ou ativá-los / desativá-los ("Port
Authentication enabled"). Estes dados de acesso são necessários quando você efetua
login no dispositivo ao programar em Codesys. Se você deseja usar a visualização web, você
também pode ativar o servidor web e!RUNTIME nesta página ("Webserver enabled"). O
servidor da Web é desativado por padrão de fábrica.

Ativando / Desativando Autenticação para e! RUNTIME e Web Server

Definindo o software de programação

A seguir iremos apresentar como definir o software de programação para os controladores
PFC 200 WAGO, tendo as opções:

CODESYS 2;
e!RUNTIME;

ATENÇÃO
Caso você esteja utilizando os controlador da linha PFC 100 essa função não estará
disponível pois os controlador PFC 100 só podem utilizar a ferramenta de programação
e!COCKPIT.

12
Internal
Você pode alterar a ferramenta de programação dos controladores PFC200 através da
janela de navegação “Configuration”>"PLC Runtime” em seguida definida qual dos
ambientes você irá utilizar para programar seu controlador: CODESYS 2 ou e!RUNTIME(No
caso do CC100 é somente e!RUNTIME), em seguida clique em submit para validar a
configuração

13
Internal
Explorando o software Codesys 3.5
Codesys é um ambiente de desenvolvimento integrado com retenção de dados perfeita
para todas as tarefas de automação:

Configuração e parametrização de hardware

A configuração do hardware é um elemento essencial dos aplicativos de automação.
Todos os dispositivos são configurados para que o software do controlador produza os
melhores resultados durante o tempo de execução. Podem ser configurados controladores,
acopladores / controladores fieldbus, módulos, dispositivos de entrada e saída, bem como
suas relações de comunicação. Os configuradores integrados auxiliam na configuração do
dispositivo e da rede usando procedimentos operacionais padrão: por exemplo, é possível
organizar os dispositivos, usar copiar e colar para multiplicar rapidamente dispositivos
individuais ou ramos inteiros da rede ou definir valores de parâmetro para vários
dispositivos simultaneamente. Além da organização dos dispositivos em uma estrutura de
árvore, o Codesys também permite a exibição do status da topologia de uma forma de
exibição. Isso torna possível monitorar relacionamentos complexos entre os dispositivos e
seus status atuais. A topologia de rede também é usada para configurar diferentes
protocolos de comunicação. O Codesys simplifica a conexão de controladores a
barramentos de campo. Arquivos de descrição de dispositivos específicos de fieldbus (por
exemplo, EDS), drivers de dispositivos e bibliotecas permitem que sistemas de outros
fornecedores sejam integrados na topologia junto com dispositivos WAGO. Como tal, o
software tem informações sobre as especificações do dispositivo, ou seja, dados do
dispositivo ou funções suportadas.

Programação com Codesys

O Codesys permite o desenvolvimento de software nas linguagens de programação padrão
IEC 61131-3: texto estruturado (ST), diagrama de escada (LD), diagrama de bloco de
função (FBD), gráfico de função sequencial (SFC) e “Gráfico de função contínua” (CFC).
Para flexibilidade, todas as linguagens de programação podem ser combinadas umas com
as outras. Os programas criados podem ser verificados facilmente por meio de simulações
no PC de desenvolvimento. Os programas existentes podem ser reutilizados e
desenvolvidos.

Visualização (operação e monitoramento)

O editor de visualização integrado do CODESYS oferece acesso direto às variáveis do
programa para simular a interface homem-máquina (IHM) e o programa PLC. O uso de
Unicode e dos padrões mais recentes, como HTML 5 ou CSS, também evita a
dependência de determinados idiomas e sistemas de destino.

Diagnóstico para desenvolvimento e comissionamento orientado para o

objetivo
Seja no escritório para desenvolvimento ou na máquina para comissionamento: Conhecer
o status atual e detalhado da rede de automação é vital para obter, auditar e permitir uma
rápida localização e depuração de falhas. O Codesys oferece opções de diagnóstico
poderosas para esse propósito: As mensagens de erro são exibidas imediatamente. Por
meio da função de teste de fiação estruturada, a fiação incorreta pode ser identificada
sistematicamente.

14
Internal
Outras funções úteis
O Codesys vem com uma ampla variedade de bibliotecas IEC. O software também oferece
várias funções convenientes, como atualizações automáticas, menus contextuais ou áreas
de trabalho definidas pelo usuário.

Explicando o ambiente inicial do software

A visualização inicial permite criar novos projetos ou usar modelos existentes. Se os
projetos foram criados anteriormente, os projetos usados mais recentemente podem ser
acessados rapidamente nesta página.

No. Descrição
1 Basic operations
Exibe modelos que podem ser usados para novos projetos
2 Recent projects
Opções de começar um projeto ou abrir um já existente.

15
Internal
Ao selecionar New Project... a seguinte opções irão aparecer:

Empty project

Um projeto vazio será criado. Depois de adicionar

um dispositivo, você precisa adicionar PLC_PRG,
Task Configuration e standard.lib manualmente
ao dispositivo.

HMI project

Cria projetos para o dispositivo CODESYS HMI

(não adequado para componentes WAGO)

Standart project

Criando o projeto, você deve selecionar um

dispositivo. O primeiro dispositivo é criado com
PLC_PRG, é o metodo mais recomendado

Standart project with Application Composer

Cria projeto com a ferramenta extra Application

Composer (disponivel na loja CODESYS)

16
Internal
Criando um novo Projeto
1. Abra o Codesys.
2. Selecione New Project... -> Standard Project
3. Insira o nome do projeto e click em OK

Selecione um dispositivo e a linguagem de programação.

Visão Geral (Não precisa fazer os passos)

Os seguintes ambientes de trabalho são usados em geral:

• Network/Devices
• Programming

Após a criação do projeto, o Codesys é aberto pela primeira vez com o ambiente de
trabalho.

17
Internal
Configuração e parametrização controladores PFC e I/O’s
Para iniciar a configuração e parametrização do seu hardware é possível de duas
maneiras:
• Online
• Offline

A seguir iremos explorar os dois métodos para consulta.

IMPORTANTE

Caso você possua o controlador PFC e todo o hardware 750, recomendamos utilizar a
configuração Online

Modo Online – Função Scan

Ao iniciar um novo projeto através da função "Standart project" você irá selecionar o
hardware e apos isso realizar o SCAN dos seus módulos no barramento, recomendamos
realizar os seguintes passos:
Acesse primeiramente a aba "Communication Settings" em seguida digite o endereço IP
do controlador e pressione a tecla Enter

18
Internal
Selecione o Gateway e clique em Scan Network, apos isso, basta selecionar o dispositivo
detectado e clicar em OK.

19
Internal
Feito isso, ele ira solicitar a senha do Controlador, o usuário que vem padrão de fábrica é
admin e a senha wago.

Agora é necessário fazer um login no controlador, para depois podermos fazer o Scan do
barramento.

20
Internal
Para fazer o scan dos módulos de I/O que temos no barramento, devemos clicar com o botão
direito do mouse no modulo Kbus (kbus) e selecionar “Scan for Devices...”

Feito o scan, basta clicar em Copy All Devices to Project

21
Internal
 Pronto, agora eles estão na arvore do projeto.

Modo Offline
No modo de configuração off-line, você configura os dispositivos, sem se conectar aos
dispositivos reais. A configuração é salva e transferida posteriormente.

22
Internal
Adicionando dispositivos ao Projeto
Ao criar um Standart Project você já seleciona o dispositivo(Controlador) que precisa para
começar o projeto, depois disso, basta você inserir o barramento do controlador. Caso o
projeto mude e seja necessário alterar o controlador, basta clicar com o botão direito do
mouse no Device e selecionar Update Device... e selecionar o novo controlador.

Para inserir os módulos no barramento basta dar um clique com o botão direito do mouse
no Kbus e selecionar Add Device...

23
Internal
Basta dar um duplo clique no modulo desejado que ele vai adicionando ao barramento
automaticamente.

Adicione os seguintes módulos ao nó:

Posição 1: 2 DI 24 VDC, 0750-1405

Posição 2: 2DO 24 VDC, 0750-1504

24
Internal
Endereçamento de Entradas/Saídas
No Codesys 3 podemos dar nomes as variáveis que devem ser atribuídas às entradas e
saídas.

▪ No dispositivo, selecione o módulo ao qual fica os módulos de IOs, no caso do CC100 pé

Compact_Controller_100_Onboard_IO e no PFC 200 o K-Bus. Despois crie e vincule
variáveis nos endereços das entradas e saídas.
Módulo e os nomes das variáveis:

xEntrada_1 – para a primeira entrada (%IX1.0)

xEntrada_2 – para a segunda entrada (%IX1.1)
xSaida_1 – para a primeira saída (%QX0.0)
xSaida_2 – para a segunda saída (%QX0.1)

Conhecendo as principais funções da linguagem LD (Ladder) e ST

(Texto estruturado)

Sabemos que conhecer os principais elementos e instruções de programação facilitam no

desenvolvimento de suas lógicas e a seguir iremos apresentar as principais funções para
as linguagens de programação como o “Ladder (LD)” e “Structered Text (ST)”.

Ladder Logic Diagram (LD)

O diagrama ladder (LD) é uma linguagem de programação orientada graficamente que se
aproxima de um diagrama de circuito elétrico. Por um lado, o diagrama ladder é adequado
para projetar unidades de comutação lógicas, mas, por outro lado, você também pode criar
redes como no FBD. Portanto, você pode usar LD muito bem para controlar chamadas de
outros blocos de programa.

Dentro do CODESYS é possível já localizar as principais instruções para linguagem de

programação Ladder e a seguir iremos explicar as principais funções.

25
Internal
 Ao adicionar sua Rotina Ladder automaticamente a caixa de ferramenta (ToolBox) se
encontra disponível com as seguintes instruções:

General
Nesse campo você encontra as opções gerais para programação (adicionar linha do
programa (Network), caixa vazia (Box), Jump e etc);

Boolean Operators
Nesse campo é possível encontrar algumas portas lógicas (AND, OR, XOR e etc);

26
Internal
Math Operators
Nesse campo você encontra algumas expressões matemáticas (somar (ADD), multiplicar
(MUL), comparar valor igual (EQ) e etc);

27
Internal
Other Operators
Nesse campo você encontra instruções como (mover valor de uma variável para outra
(MOVE), limite (LIMITE) e etc);

Function Blocks

Nesse campo você encontra alguns blocos de funções da biblioteca Standar.lib (Detecta
uma borda subida de um sinal booleano (R_TRIG), Detecta uma borda descida de um sinal
booleano (F_TRIG), temporizador ON (TON), temporizador OFF (TOF), contadores UP
(CTU) e etc)

28
Internal
Ladder Elements
Nesse campo você encontra as instruções básicas, mais fundamentais para programação
em ladder como (Contatos (Contact), Contatos em paralelo (Parallel contact), bobinas
(Coil), bobinas para setar booleana (Set coil), bobinas para resetar booleana (Reset coil)
e alguns outros elementos já mencionados em outros campos)

POUs
Nesse campo você encontra todas as rotinas e bloco de funções (FB) já criados em seu
software

29
Internal
Structured Text (ST)
O editor ST é utilizado para a programação de POUs na linguagem de programação IEC-
61131-3 Texto Estruturado (ST) e Texto Estruturado Estendido. O Texto Estruturado
Estendido oferece algumas funções adicionais em relação ao padrão IEC 61131-3

Texto Estruturado é uma linguagem de programação, comparável a outras linguagens de

alto nível, como C ou PASCAL, que permite o desenvolvimento de algoritmos complexos.
O código do programa consiste em uma combinação de expressões e instruções, que
também podem ser executadas condicionalmente (IF ... THEN ... ELSE) ou CASE.
.
Abaixo, segue como utilizar as principais funções:

Acionando uma variável booleana

Usando o set uma variável booleana

Utilizando a função IF
A instrução IF é usada para verificar uma condição e, dependendo dessa condição, para
executar as instruções subsequentes.
Uma condição é codificada como uma expressão que retorna um valor booleano. Se a
expressão retornar TRUE, a condição será satisfeita e as instruções correspondentes após
THEN serão executadas. Se a expressão retornar FALSE, as seguintes condições, que
são identificadas com ELSIF, são avaliadas. Se uma condição ELSIF retornar TRUE, as
instruções serão executadas após o THEN correspondente. Se todas as condições
retornarem FALSE, as instruções após ELSE serão executadas.
Portanto, no máximo uma ramificação da instrução IF é executada. As ramificações ELSIF
e a ramificação ELSE são opcionais.

30
Internal
 31
Internal
Utilizando a função CASE
Use a instrução CASE para agrupar várias instruções condicionais contendo a mesma
variável de condição em uma construção. Abaixo na sintaxe é possível verificar que
variável Var1 se trata da variável que iremos analisar e caso seu resultado um valor
específico (value1, value2 ... e etc)será executado um comando

Para cria seu próprio function block dentro do CODESYS basta clicar com o botão direito
em cima do Application (PFC200_CS_2ETH_RS) e adicionar uma POU.

Em sequência janela assistente irá se abrir e você deve configurar os seguintes campos:

32
Internal
 Name – Defina o nome para seu bloco de função
Ex: FB_SOMA

Type – Defina o tipo da POU

Ex: Function Block (Bloco de função)

Language – Defina qual a linguagem de programação para a criação

do seu bloco de função
Ex: Ladder Logic Diagram (LD)

Após adicionado você configurar os seguintes campos:

Defina as variaveis e o tipos das variaveis dentro do seu

ambiente de declaração.

Lembrando que as variaveis do seu FB podem ser dos tipos:

Var_Input – Variaveis na entrada do bloco que receberão
valores externos

Var_Output – Variaveis na saída do bloco que

disponibilizaram valores externos

Var – Variaveis internas do bloco que ajudam na lógica do

bloco, porém não receberá valores e nem disponibilizará
valores externos.

No ambiente de programação você ira definir sua lógica para seu bloco de função (FB)

33
Internal
 IMPORTANTE

O bloco de função (FB) é uma importante ferramenta de programação que permite utilziar
algoritmos ou conjunto de ações aplicados aos dados de entrada para ter uma ou mais
resultados de saída.

Depois de criado basta chamá-lo dentro de suas rotinas de programação, conforme

exemplo abaixo:

34
Internal
Criando um nova Rotina
Adicione uma POU clicando com o botão direito em cima do Application -> Add Object ->
POU

Uma janela aparecerá com o nome POU.

Preencha as informações da POU da seguinte forma: Name: Exercicio_01_Ladder

Type: Program
Implementation Language : Ladder Logic Diagram (LD)

35
Internal
Criando uma função (FUN)

Para cria seu próprio function block dentro do Codesys basta clicar com o botão direito em
cima do Application e adicionar uma POU.

Em sequência janela assistente irá se abrir e você deve configurar os seguintes campos:

Name – Defina o nome para sua função

Ex: FUN_FAH_CEL

Type – Defina o tipo da POU

Ex: Function (Função), veja que por ser um função já se faz
necessário informar qual o tipo da variável será seu resultado
REAL

Language – Defina qual a linguagem de programação para a

criação de sua função
Ex: Sctrucured Text (ST)

Após adicionado você configurar os seguintes campos:

Defina as variaveis e o tipos das variaveis dentro do seu

ambiente de declaração.

Lembrando que as variaveis do seu FUN podem ser dos

tipos:
Var_Input – Variaveis na entrada da sua função que
receberão valores externos

Var – Variaveis internas do bloco que ajudam na lógica do

bloco, porém não receberá valores e nem disponibilizará
valores externos. 36
Internal
 No ambiente de programação você ira definir sua lógica para seu bloco de função (FB)

IMPORTANTE

A função (FUN) é uma importante ferramenta de programação que permite utilziar

algoritmos ou conjunto de ações aplicados aos dados de entrada para ter uma única
saída

Depois de criado basta chamá-lo dentro de suas rotinas de programação.

37
Internal
Criando uma estrutura – Função Struct
A função do tipo “Struct” é uma estrutura de registos muito usual nos desenvolvimentos
de software, pois é através dela é possível agrupar variáveis sob um mesmo tipo de dado.
ideia de usar uma struct é permitir que, ao armazenar os dados de uma mesma entidade,
isto possa ser feito declarar sob uma única estrutura de variáveis.

Para cria seu próprio “Struct” dentro do Codesys basta clicar com o botão direito em cima
do “Application ” e adicionar uma DUT.

Em sequência janela assistente irá se abrir e você deve configurar os seguintes campos:

Name – Defina o nome para sua Struct

Ex: Estru_Tanque

Type – Defina o tipo como Structure

IMPORTANTE

Veja que além da Struture é possível criar na opção DUT os tipos Union, Alias e
Enumeration.

Após adicionado você configurar adicionar as variáveis a sua estrutura, veja abaixo o

38
Internal
exemplo
:

Depois de criada as variáveis basta chamá-lo dentro de suas rotinas de programação.

39
Internal
Tipos de variáveis no Programa

As variáveis representam posições da memória (do controlador), gerenciadas pelo sistema.

Elas podem ser escritos e lidas. Não há necessidade do uso de mapeamento de
endereços físicos (fixos) da memória

É muito importante saber os tipos de variáveis que o Codesys possui e a seguinte iremos
apresentar as principais opções:

▪ “VAR”: Variavel local da sua rotina, ;

▪ “VAR Input”: Variavel de entrada, normalmente utilizada na criação de bloco de função
(FB) ou função (FUN);
▪ “VAR Output”: Variavel de saída, normalmente utilizada na criação de bloco de função
(FB) ou função (FUN);;
▪ “VAR Global”: Variavel global, pode ser encontrada em todas as rotinas do seu programa,
Recomendasse utilziar essa varriavel em situações que necessita utilziar a variavel em
varias rotinas.;

IMPORTANTE

As variáveis declaradas nos módulos de I/Os dos cartões são consideradas variáveis
Globais do sistems..

40
Internal
Para adicionar variáveis globais é necessário criar a instruções antes através dos
seguintes passos. Basta clicar com o botão direito em cima do “Application
(PFC200_CS_2ETH_RS)” e adicionar uma “Global Variable List”.

Em sequência janela assistente irá se abrir e você deve configurar os seguintes campos:

Name – Defina um nome para sua lista de variáveis Globais

Ex: GVL

Agora basta utilizar o assistente durante a declaração de suas variáveis e definir suas
variáveis como global, veja abaixo um exemplo:

41
Internal
 Os tipos de variáveis disponíveis no Codesys respeita a IEC 61131-3, disponibilizando os
seguintes tipos:

Existem algumas variáveis que necessitam de algumas particularidades, como reter o valor
mesmo em algumas situações que ocorram com os controladores.

Alguns desses tipos são: Constantes, retentivas e persistentes

▪ “Constant”: O valor da variável não muda durante a execução do programa (ready only);
▪ “Retaint”: O valor da variável permanece, mesmo após o controlador sair do modo run, ou
mesmo após um reset;
▪ “Persistent”: O valor da variável permanece mesmo após um download. O conteúdo da
variável só é zerado quando se faz um reset original.

Veja na tabela abaixo algumas situações no qual você irá manter ou reiniciar os valores

42
Internal
Para adicionar variáveis desses tipos dentro Codesys basta clicar com o botão direito em
cima do “Application” e adicionar uma “Persistent variável”.

Em sequência janela assistente irá se abrir e você deve configurar os seguintes campos:

Name – Defina o nome para sua area de variaveis

persistentes
Ex: PersistentVrs

Após criado essa área o campo ficará da seguinte maneira:

Agora retorne a seu programa e crie uma variável do tipo “Persisten” e também “Retain”

43
Internal
utilizando o assistente:

Veja que dentro da sua rotina de programa a variável de tipo foi criada:

ATENÇÃO

Mesmo realizando os passos acima você ainda não enviou as variáveis para a área de
variáveis persistentes e retentivas para realizar esses passos sigam os passam a seguir.

44
Internal
Após declarado a variável clique no painel principal na função “Program”>”Build” para
compilar as variáveis

Para transferir as variáveis locais / globais criadas para a área de variáveis “Persistent” é
necessário entrar na função a pouco criada “Persistent variables” > “Declarations”>”
Execute”>”Add all Instance Paths” e automaticamente as variáveis desse tipo criadas
em seu sistema serão copiadas para essa área automaticamente, veja abaixo

45
Internal
Adicionando uma nova biblioteca em seu programa

Ao instalar o software Codesys 3 todas s biblioteca de desenvolvimento da WAGO já vem

instaladas, porém para usa-las em seu desenvolvimento de software é necessário chama-
las em seu software.

Para chamar as bibliotecas é necessário dar um duplo clique com o botão direito no
gerenciador de bibliotecas (Library Manager) . Após isso clique em “Add Library”

Em sequencia janela assitente irá se abrir e você deve procurar sua biblioteca. Para essa
ação existem duas maneiras:

1. Caso já conheça o nome da biblioteca basta digitar no campo pesquisa seu nome;

2. Caso não conhecça, basta procuarr no campo Library sua biblioteca

3. Por fim clique em OK para adicionar a biblioteca em seu programa.

46
Internal
Realizando o download nos controladores
Após finalizado seu software ou para testar sua lógica na prática se faz necessário realizar
o download em seu controlador. A seguir serão apresentados os tipos de download em seu
controlador:

Dowload rápido na memoria volátil (Memoria RAM);

Caso deseje realizar um donwload rápido em seu controlador apenas para verificar o
funcionamento de sua lógica e realizar alguns testes recomendamos seguir os seguintes
passos;

1. Primeiramente verifique se seu software possui algum erro em sua programação, para
isso clique no painel principal na função “Build”>”Rebuild”>”Messages”

2. Após validar que não possui erro no software clique na função “Online -> Login” e

em seguida em “Debug -> Start” para descarregar o software na memoria RAM do

PFC
A seguinte janela de login irá aparecer, inserá os seguintes dados nos campos:

User name: admin

Password: wago

47
Internal
 48
Internal
 3. Você consegue validar que o software está com o software através da seguinte
informação:

Download definitivo (Memoria Flash);

Caso deseje realizar um donwload definitivo em seu controlador basta seguir o passo
anterior de donwload na memoria RAM e clicar em sequência na função “Create Boot
Application”

Simulador Codesys
Dentro do software Codesys 3 é possível realizar a simulação de suas lógicas para isso
basta seguir os passos abaixo;

ATENÇÃO

Lembrando que ao tuilizar o módulo simulação, alguns funções podem não funcionar para

49
Internal
 validar suas lógicas, como: Variaveis de rede; Datalloger entre outras funcionalidades que
dependam do hardware.

1. Primeiramente verifique se seu software possui algum erro em sua programação, para isso
clique no painel principal na função “Program”>”Rebuild”>”Messages”

2. Após validar que não possui erro no software clique na função “Build” e em seguida em
“Login” para descarregar o software no modulo simulação

Exercícios de programação
Exercício 1 - Introdutório

Nesse exercício iremos fazer um simples programa utilizando um contador e comparador

para resetar a contagem. Comece um novo projeto selecionando a opção “Standart
Project” e dê o nome do projeto de Exercicio_1. Em seguida, selecione o controlador
0751-9301 e a linguagem de programação “Ladder”.

50
Internal
Adicione uma nova POU no programa

Agora iremos chamar essa POU no nossa TASK

51
Internal
Agora vamos criar nomes (apelidos) para as entradas e saídas do nosso controlador.
Lembrando que, neste exemplo, estamos utilizando:

Dê um duplo clique na aba ‘Compact_Controller_100_Onboard_IO’ e selecione a aba

‘Onboard-IO I/O Mapping’

Ao clicar nas entradas digitais, logo abaixo aparecerá os campos para inserir os nomes
(apelidos) para cada entrada digital. Esse nome será vinculado com o endereçamento
físico e se tornará uma variável global de sistema, sendo possível a utilização dessa
variável em todos os programas criados. Escreva o nome xEntrada_1 e xEntrada_2.

52
Internal
Selecione as saídas digitais e crie dois nomes nas duas primeiras saídas digitais. Digite
xSaida_1 e xSaida_2

Agora vá ao programa criado e adicione uma nova POU ‘Exercicio_1’ e adicione 3

elementos Ladder, sendo um contato aberto, um contato fechado e uma bobina de saída.
Para o contato aberto utilize a xEntrada_1. Para o contato fechado utilize a variável
xEntrada_2 e para a bobina utilize a xSaida_1. Para adicionar essas variáveis criadas nos
endereçamentos físicos, temos duas opções. Clique nos três pontos de interrogação e

53
Internal
procure a variável desejada, ou utilize a tecla “F2” para acessar o assistente de entrada

O seu programa deverá ficar desse jeito:

Agora, utilize um temporizador do tipo TON. Para isso, adicione uma nova linha e puxe
para o seu programa um Box with EN/ENO.

54
Internal
Selecione os pontos de interrogação que estão dentro do bloco, clique no botão com os
três pontos e utilize o assistente de entrada para encontrar o temporizador, ou você poderá
usar um método mais simples. Nesse caso, basta colocar o nome do bloco de função que
deseja utilizar. No caso insira TON.

Por fim, é preciso declarar esse bloco então utilize o nome Temporizador e declare esse
bloco do tipo TON. Ele ficará desse jeito:

55
Internal
Repita o mesmo processo feito para inserir mais 3 linhas. Na linha 3 insira um Box with
EN/ENO e utilize um contador CTU. Declare esse como Contador do tipo CTU.

Na linha 4 utilize 2 contatos abertos, 1 contato fechado e uma bobina de saída.

Na linha 5 utilize um Box with EN/ENO e use uma função de comparação com o nome GT.

Esse comparador irá comparar as duas entradas. Quando a primeira entrada for maior que
a segunda a saída vai para ON. Sua tela terá de ficar assim:

Apague todos os contatos de entrada das linhas que possuem bloco de função.

56
Internal
No bloco temporizador, na entrada IN utilize a variável xEntrada_1. Na entrada PT utilize
T#5S (5 segundos). Na saída Q, crie uma variável T1_Done do tipo BOOL. Na saída ET
crie uma variável com nome Temp do tipo TIME. A segunda linha ficará desse jeito

Na linha 3, na entrada IN utilize a mesma saída do temporizador T1_Done. No Reset, crie

uma variável chamada Reset do tipo BOOL. No campo PV coloque o número 3. Na saída
Q do contador, crie uma variável chamada C1_Done do tipo BOOL. E no campo CV, crie
uma variável com nome C1_Valor do tipo WORD. O bloco ficará assim:

Na linha 4, insira na entrada a variável já criada xEntrada_1 e no contato fechado

xEntrada_2. No contato aberto de entrada paralelo, utilize a variável C1_Done. E Na

57
Internal
bobina utilize a variável de saída já criada xSaida_2. Essa linha ficará assim:

E para a linha 5, na primeira entrada use a variável C1_Valor. Na segunda entrada do

bloco utilize o número 3. E na saída use a variável Reset também já criada. A linha ficará
assim:

Por fim o seu programa deverá ficar assim:

Agora basta testar seu projeto. Lembrando que, se você possuir o hardware, basta testá-lo
com a aplicação. Caso não tenha o hardware, utilize o modo simulação do Codesys 3.5

58
Internal
para fazer o teste. Para forçar variáveis normais utilize a tecla “Ctrl+F7”. Para forçar
variáveis que estão ligadas a endereçamento físico (são as variáveis xEntrada_1,
xEntrada_2, xSaida_1 e xSaida_2) utilize apenas a tecla “F7”.

Para utilizar o método de simulação, basta habilitar a seguinte função:

59
Internal
Exercício 2 – Criando seu bloco de função (FB) do inicio
Nesse exercício iremos criar um bloco de função do zero. Esse bloco de função fará com
que uma lâmpada tenha 3 status sendo:

0 -> Desligado
1 -> Ligado
2 -> Piscante

Para começar, utilize a mesma aplicação do exercício 1. Porém iremos criar uma nova
POU que se chamará Exercicio_2. Para isso clique com o botão direito em Application e
adicione a POU.

Em seguida clique duas vezes em “PLC_Task” e insira o Exrercicio_2 na chamada

dessa tarefa.

60
Internal
Agora, mais uma vez clique com o botão direito do mouse em Application e crie uma nova
POU. Nela, coloque o nome de Lamp_FB, selecione o tipo “Function block” e a
linguagem de programação Texto Estruturado.

No bloco de função, na janela de declaração de variáveis, crie as variáveis de acordo com

a imagem abaixo. Se atente em colocar a variável de “VAR_INPUT”, “VAR_OUTPUT” e
“VAR”:

61
Internal
Agora, na janela de lógica do nosso bloco de função digite as informações de acordo com
a imagem abaixo:

Agora na janela de programação da POU Exercicio_2, utilize um Box with EN/ENO para
puxar nosso bloco de função criado.

Comece apagando o contato de entrada desse bloco, em seguida digite nos 3 pontos de
interrogação interno o nome do nosso bloco de função Lamp_FB. Perceba que o bloco
será alterado mostrando as variáveis de entrada e saída que criamos. Em seguida, declare
ess bloco com o nome Lampada:

62
Internal
Agora crie duas variáveis para acessar a entrada e saída de nosso bloco. A variável para a
entrada se chamará Status e será do tipo INT. A saída se chamará My_Lamp e será do
tipo BOOL.

O programa ficará assim:

Agora precisaremos criar nossa lâmpada para a visualização. Clique com o botão direto
em Application e selecione a opção “Visualization Manager”.

63
Internal
 64
Internal
Depois de se criar o gerenciador, faça o mesmo processo e adicione um “Visualization”
que terá o nome Lampada_Visu.

Na opção “Basic”, selecione o retângulo e insira na sua tela de visualização

Em propiedades (“properties”), altere a cor desse objeto. Este passo fica a seu critério,
pode utilizar a cor que quiser:

65
Internal
Insira um retângulo por cima do primeiro. Em “properties”, selecione a opção “Text
Variable” e procure a variável “Status”.

66
Internal
Selecione a aba “Visualization Toolbox” e selecione a lâmpada para ser inserida no seu
projeto. Fique a vontade caso queira alterar a cor da sua lâmpada.

67
Internal
Nas propriedades da lâmpada, selecione a variável MyLamp que se encontra no programa
Exercicio_2.

Selecione o retângulo branco e digite o texto Status: %s na propriedade Text.

68
Internal
Para encerrar as configurações da visualização, ainda no retângulo branco, é preciso
informar a esse objeto que ele irá escrever a informação em uma variável. Para isso
acesse o “Input configuration” -> OnMouseClick. Abrirá uma janela, selecione a opção
“Write variable” e siga conforme imagem abaixo.

Depois de criar sua visualização, é necessário configurá-la para o navegador/IHM. Acesse

a propriedade “WebVisu”. Em seguida, mude 3 parâmetros. O primeiro é necessário
inserir a tela que se iniciará ao acessar o webvisu do controlador. O segundo é com
relação a escala da sua visusalização -> como boa prática é aconselhável usar
“Isotropic”. O terceiro é caso tenha um teclado, poderá utilizá-lo.

69
Internal
 ATENÇÃO

Caso não tenha o hardware, não será possível ver a visualização de sua aplicação no
navegador. Nesse caso, será necessário usar o modo simulação do Codesys

Caso você tenha hardware, será necessário habilitá-la na página web do controlador. Para
isso, acesse a página web via endereço IP do CLP. Em seguida selecione a aba
“Configuration”-> “Ports and Service”-> “PLC Runtime Services” e habilite a opção
“Webserver”. Toda vez que acessar o webvisu aparecerá uma janela para login e senha.
Para desabilitá-la, é só desabilitar a opção “Port Authentication enabled”, conforme
imagem abaixo

70
Internal
Caso dê tudo certo com seu projeto e seu download, e claro, depois de seguir os passos
citados o seu projeto será visualizado no navegador. Ainda na página Web do controlador,
basta acessar a aba “Information” ->” PLC Runtime” -> “Open WebVisu”.

Funções Avançadas de Visualização

Agora, iremos adicionar um FRAME para a visualização já criada. Para isso, crie
mais uma visualização e daremos o nome de “Visualization_Frame”.

71
Internal
Vá na aba “ToolBox”, clique em “Basic” e selecione o retângulo

Selecione “Properties” e, caso queira alterar as propriedades das cores, selecione as

opções abaixo:

Crie mais um retângulo e o coloque por cima do primeiro

Vá em “Image Pool” e adicione o caminho da imagem que irá utilizar

72
Internal
Depois de escolher a imagem, selecione “Embed into Project “para não depender de
caminhos do computador.

73
Internal
Selecione a opção “ImagePool” e clique no logotipo para adicionar em sua visualização.

74
Internal
Pronto acabamos de criar nosso Frame. Agora chame o frame na visualização que
criamos

75
Internal
Sua visualização ficará assim:

Agora, crie uma nova visualização (Monitoracao) e insira o Frame criado. Nesse Frame
adicione um medidor e faça um link com a variável da saída do contador (C1_Valor).

Na primeira visualização (Lampada_Visu), crie um botão para conseguir ir para a segunda

visualização (Monitoracao).

76
Internal
Selecione o botão e, em propriedades, selecione “InputConfiguration” e clique na opção
“OnMouseClick”.

Selecione “Change shown Visualization” e, em seguida, selecione a tela que irá chamar
quando o botão for clicado. Escolha a tela e clique em OK.

77
Internal
Repita o processo para a tela Monitoracao -> Lampada_Visu.

Agora, iremos fazer uma tela de LOGIN e LOGOUT para acessar essas visualizações.
Para isso crie mais uma visualização. Torne a visualização de Login como sendo a tela
principal (já vimos esse passo na nossa apostila Página XX). Insira novamente o Frame
criado. Crie 3 botões, conforme imagem abaixo:

78
Internal
Vá em “VisualizationManager” e selecione “User Management”. Crie um grupo de
usuários. Logo após esse passo, defina se terá” Logout” automático

Crie os usuários desse grupo, coloque a senha e faça um link entre esses usuários criados
com o grupo que criamos (WAGO).

79
Internal
Volte na tela de início (Login) e selecione o botão Login. Nas Propriedades do botão, vá
em “Input Configuration” e clique em “OnMouseClick”. Abrirá uma janela, nela
selecione “User Management” e uma ação para Login.

80
Internal
Na opção “Access Rights” defina o nível de acesso para os usuários do grupo criado.

Na tela de Login, selecione o botão lâmpada_Visu e vá na opção “Access Rights” e

defina que ele estará visível porém não operável quando não Logado. Faça o mesmo
procedimento com o outro botão (Monitoração).

81
Internal
Pronto, seu programa já está com todas as funções mencionadas. Basta testá-las fazendo
o download para seu hardware e visualizando-as no navegador.

82
Internal
 Comunicação através do protocolo Modbus TCP

Nos exercícios 3 e 4 utilizaremos o protocolo Modbus TCP para fazer uma comunicação
Mestre e Escravo. No exercício 3 o controlador será Mestre. Já no exercício 4 o
controlador será Escravo.

Exercício 3 – Controlador Wago sendo mestre na rede Modbus

TCP

Agora iremos colocar nosso controlador para trocar dados via Modbus TCP, ele sendo
mestre da rede, para isso vamos seguir os passos a seguitr:

Para essa configuração iremos utilizar a ferramenta dentro do Codesys 3.5 MODBUS
(TCP) Fieldbus Configurator.

Inicialmente precisamos adicionar em nosso programa um dispositivo de comunicação

Ethernet:

83
Internal
Agora click no dispositivo de rede que adicionamos ao nosso projeto e selecione Modbus -
> Modbus TCP Master, esse dispositivo funciona como Mestre na rede Modbus:

84
Internal
Agora click no dispositivo de rede Modbus Mestre que adicionamos ao nosso projeto e
selecione Modbus -> Modbus TCP Master - Modbus TCP Slave, esse dispositivo funciona
como um dispositivo Modbus genérico que é configurado como Slave para um Modbus
TCP Master:

Devera ficar assim na arvore do projeto:

85
Internal
Agora será necessário configurar o endereço IP do dispositivo Modbus Mestre, para isso
clique duplamente no ícone do dispositivo e configure os parâmetros do controlador:

86
Internal
Em seguida a janela de configuração do dispositivo Slave. Configure o endereço IP no
campo “IP address” e também certifique se a porta é a 502 no campo “Port”.

Agora vamos configurar uma variavel modbus dentro do configurador, para isto clique no
dispositivo Slave e acesse a função “Modbus Slave Channel” e click em “Add
Channel..”.

87
Internal
Em nosso exemplo iremos disponibilizar quatro variáveis que serão lidas do dispositivo
slave modbus TCP que serão do tipo:

Variável 1:
Código de função: 15
Offset (Endereço): 512
Tamanho: 4;

Apos adicionar o Canal ele ira criar a aba “Modbus TCP/Slave I/O Mapping”. Agora
defina o nome das variáveis para podermos utilizá-las no nosso programa.

88
Internal
Agora crie uma POU com o nome Exercicio_03 e insira duas linhas. Igual a imagem a
seguir:

Agora vincule as bobinas com as variáveis que vinculamos as saídas do módulo Modbus
Escravo e selecione uma variável para comutar as saídas,
Obs: Não esqueça de adicionar a chamada dele em Plc_Task.

89
Internal
Faça o download para o hardware e coloque em RUN.

90
Internal
Exercício 4 – Controlador Wago sendo escravo da rede Modbus
TCP
Agora vamos colocar nosso controlador para trocar dados via Modbus TCP, ele sendo
slave da rede, para isso vamos seguir os passos a seguir:

Para essa configuração iremos uma biblioteca da Wago chamada “WagoAppPlcModbus”.

Inicialmente vamos adicionar essa biblioteca em nossa Library Manager, para isso
devemos dar um duplo clique em Library Manager, clicar “add” e procurar pelo biblioteca:

Agora crie uma POU com o nome Exercicio_04 e selecione a linguagem Structured Text
(ST). Igual a imagem a seguir:

91
Internal
Agora, abra novamente o “Library Manager”, selecione a biblioteca que inserimos, na aba
inferior selecione 20 Program Organization Units -> 30 Simple Modbus Slave ->
FbMbSimpleServerTcp e na aba lateral clique em Documentation, conforme figura
abaixo:

Ainda na aba Documentation teremos um programa de referência para utilização desse

FB, nos iremos copiar esse programa e colar na nossa POU Exercicio_04, lembrando que
temos que copiar a declaração das variáveis e depois o programa:

92
Internal
A área de declaração de variáveis da nossa POU devera ficar da seguinte forma:

93
Internal
A área de programação da nossa POU devera ficar da seguinte forma:

Obs: Não esqueça de adicionar a chamada dele em Plc_Task.

Nesta configuração padrão da biblioteca os endereços das variáveis são as seguintes :

Modbus bit address 0 .. 20

Modbus bit address 0 .. 20
Modbus word address 100 .. 200
Modbus word address 0 .. 20

Para alterar o endereço modbus basta mudar o range da Array das variáveis, como por
exemplo myCoils : ARRAY[20..40] OF BOOL.

IMPORTANTE

Todo dispositivo Modbus slave deve disponibilizar os códigos de funções e registros

modbus para realizar a comunicação, abaixo, segue mapa disponibilizado no manual do
PFC.

Para acessar as variáveis que iremos disponibilizar para o mestre podemos utilizar os
seguintes Function Codes FCs:

94
Internal
 Agora iremos inserir um somador e mover alguns valores nas variáveis para podermos
visualizar a comunicação:

ATENÇÃO

Caso não tenha o hardware, não será possível realizar os testes, pois para uma
comunicação com protocolos d rede se faze necessário possuir um hardware.

Agora para simular o mestre Mosdbus vamos utiliziar o software ModScan32. Após
executado, basta abri-lo e iniciar as configurações

Primeiramente clique em “Connection” e em seguida vamos preencher os seguintes parâmetros:

Connect Using: Remote TCP/IP Server

IP Address: 192.168.2.30 (Informar o IP do controlador)
Service Port: 2000

95
Internal
Agora basta inserir os endereços no campo “Adress” do software “ModScan2”
juntamente com a função configurada e verificar os valores.

ATENÇÃO

Veja na imagem abaixo que o “ModScan32” dá um shift de 1 endereço Modbus

configurado no Controlador Wago, por isso estamos lendo o valor “0” no endereço” 0001”

96
Internal