Realizando acionamentos simples com Elipse SCADA e Arduino

Para desenvolvimento de projetos de automação utilizando o Arduino UNO com o Elipse SCADA, confira como realizar acionamentos simples.
Elipse Scada acionamentos simples processo com Elipse SCADA
Este post faz parte da série Arduino e Elipse Scada. Leia também os outros posts da série:

Qual é o objetivo deste artigo?

 

Este artigo corresponde ao segundo conteúdo da série sobre o desenvolvimento de projetos de automação utilizando o Arduino UNO juntamente com o Elipse SCADA. Neste conteúdo serão apresentados os conceitos básicos para a realização de acionamentos simples, com o intuito de que este possa ser um ponto de partida para que o leitor possa então elaborar seus próprios projetos. Ao final deste artigo o leitor conseguirá criar a aplicação exibida na figura 1.

 

Resultado esperado do acionamento simples proposto.
Figura 1 – Resultado esperado.

Primeiro passo: Definição do hardware que será utilizado

O hardware que será utilizado para demonstrar os conceitos propostos no início deste artigo será composto por um Arduino UNO, três potenciômetros de 4.7kΩ, um led RGB e uma chave seletora. De maneira mais específica, o objetivo do projeto desenvolvido neste artigo consiste em realizar uma aplicação onde o usuário consiga determinar as componentes PWM utilizadas no acionamento do led em questão, tanto por meio dos potenciômetros, quanto pelo sistema supervisório (por conveniência chamaremos estes modos de operação de manual e “automático” respectivamente).

Hardware utilizado para acionamento simples.
Figura 2 – Hardware utilizado.

Segundo passo: Elaboração do código que será inserido no Arduino UNO

No decorrer desta seção serão explicados todos os passos utilizados para o desenvolvimento do projeto proposto, isto é, o código será comentado de modo que todo conhecimento aplicado seja facilmente compreendido.

Num primeiro momento deve-se incluir as bibliotecas necessárias para que o código a ser inserido no Arduino UNO funcione adequadamente. Neste artigo utilizaremos somente a biblioteca desejada para estabelecer a comunicação entre o Arduino UNO e o Elipse SCADA através do protocolo Modbus. Esta pode ser encontrada aqui (baixar o arquivo SimpleModbusSlaveV10.zip).

Em seguida realizou-se o uso da diretiva #define para associarmos as palavras que definem os componentes em questão aos seus respectivos pinos do Arduino UNO.

Posteriormente pode-se observar um bloco chamado enum, neste estarão escritos os registradores que conterão as informações utilizadas na leitura de informações e  acionamento de dispositivos. Estes são denominados Registradores Holding e para declará-los basta escrever seus nomes seguidamente no código.

Neste artigo, os registradores podem ser divididos em quatro blocos:

  • O primeiro bloco  contém os registradores utilizados para armazenar os valores provenientes dos potenciômetros, estes são chamados de VALOR_POTR, VALOR_POTG,   VALOR_POTB;
  • O segundo bloco contém os registradores utilizados para armazenar os valores provenientes do Elipse SCADA, estes são chamados de VALOR_ELIPSER, VALOR_ELIPSEG, VALOR_ELIPSEB;
  • O terceiro bloco contém os registradores utilizados para armazenar os valores que serão utilizados nos acionamentos das componentes do led RGB, estes são chamados de VALOR_PWMR, VALOR_PWMG, VALOR_PWMB;
  • O quarto bloco contém o registrador MAN_AUTO, que irá armazenar o estado da chave seletora.

É importante ressaltar que após as declarações dos respectivos Registradores Holding, deve-se escrever HOLDING_REGS_SIZE (informação utilizada pela biblioteca para identificar a quantidade de Registradores Holding que estão sendo utilizados) e em seguida cria-se a variável holdingRegs para a manipulação dos registradores em questão.

Na função setup() utiliza-se primeiramente a função modbus_configure() para determinar os parâmetros necessários para estabelecer a conexão via comunicação serial utilizando o protocolo Modbus. Os parâmetros mais importantes para este artigo são o segundo, o terceiro e o quarto, que dizem respeito à taxa de transmissão de dados, o formato do pacote utilizado no protocolo Modbus e a identificação do escravo, respectivamente. Note que estes três argumentos citados devem estar em conformidade com as configurações do Elipse SCADA

Em seguida temos a função modbus_update_comms() que também é responsável pela comunicação via Modbus.

O conteúdo da função loop() começa com a função modbus_update() utilizada para a atualização dos valores dos registradores citados anteriormente. Em seguida, realiza-se a leitura das informações presentes nas portas de entrada analógica A0, A1 e A2 e posteriormente realiza-se o mesmo procedimento, porém na porta de entrada digital, ou seja, onde está a chave seletora.

Num primeiro momento é necessário verificar em que posição está a chave seletora para que o programa entenda a partir de que ponto o sistema está sendo controlado. Para isso utiliza-se uma estrutura condicional if(), cuja sentença a ser testada inclui o Registrador Holding MAN_AUTO. Caso o valor deste seja igual a zero, entende-se que o sistema está funcionando de forma manual, portanto, os valores a serem utilizados nos PWMs para o acionamento do led RGB são provenientes diretamente dos valores obtidos através dos potenciômetros.

Em contrapartida, caso a chave seletora aponte para o modo de operação automático, os acionamentos serão feitos utilizando diretamente os Registradores Holding cujos valores foram escritos através do Elipse SCADA.

Terceiro passo: Escolha do driver e criação da(s) Tag(s) necessárias

Primeiramente, deve-se selecionar o driver apropriado para a aplicação que está sendo realizada. No caso, o driver em questão é o dado pelo arquivo Modbus.dll (caso o leitor tenha dúvidas sobre como proceder para adicionar este elemento corretamente, basta ver o passo-a-passo apresentado no primeiro artigo da série).

Da mesma forma que o driver foi inserido, recomenda-se novamente a leitura do artigo anterior para conferir o procedimento para criação das tags a serem inseridas. Nesta publicação foram criadas 10 tags do tipo PLC, sendo uma para cada Registrador Holding existente no código.

Quarto passo: Criação dos elementos gráficos

Neste passo serão criados os elementos necessários para que o operador possa interagir com o sistema existente. Na figura abaixo mostra-se o endereçamento das tags utilizadas no desenvolvimento deste projeto.

Endereçamento das Tags.
Figura 3 – Endereçamento das Tags.

Primeiramente deve-se criar os displays para que os valores referentes aos Registradores Holding possam ser mostrados para o usuário. Lembre-se que o procedimento para a elaboração dos mesmos foi realizado no primeiro artigo desta série. Portanto, essas etapas serão omitidas neste momento.

Ao todo, foram criados sete displays que podem ser divididos em três blocos:

  • O primeiro é composto por três displays, responsável por conter os registradores dos potenciômetros, ou seja, os registradores VALOR_POTR/G/B (localizados à esquerda);
  • O segundo bloco é composto pelos três displays que apresentarão os valores correntes do PWM, ou seja, que apresentarão os valores dos registradores PWMR/G/B (localizados no centro);
  • O terceiro bloco, que por sua vez apresenta um único display, o qual apresenta a posição da chave por meio do registrador CHAVE (localizado no canto superior direito).

Em seguida deve-se criar o elemento Text, este permitirá que uma mensagem dinâmica possa ser atribuída a uma determinada tag, exibindo mensagens conforme os valores existentes no registrador que a tag está representando. O procedimento para a criação do mesmo é idêntica ao realizado para o display, bastando clicar no ícone correspondente e arrastar o mouse conforme o tamanho desejado.

 Ícones dos objetos Slider e Text no Scada.
Figura 4 – Ícones dos objetos Slider e Text.

Os parâmetros mais interessantes neste momento estão na aba Zonas, onde serão criadas 2 zonas (botão adicionar) e cada uma apresentará uma mensagem caso estejam ativas. Portanto, para zona 1, a mensagem deve ser Manual e nos campos Máximo Mínimo devem ser preenchidos ambos com zero, enquanto a zona 2 terá como mensagem a palavra Automático e os campos Máximo Mínimo devem ser preenchidos com um (não se esqueça de associar a tag relativa ao Registrador Holding responsável por armazenar o estado da chave).

Esse procedimento fará com que quando a leitura da porta em que está conectada a chave for zero ou umas mensagens exibidas serão respectivamente Manual Automático.

Criação do objeto Text no Scada.
Figura 5 – Criação do objeto Text.

Por último deve-se criar 3 objetos do tipo Slider (estes são barras onde o usuário poderá determinar o valor do PWM utilizado por meio do deslocamento de um cursor) e definir nas configurações dos mesmos os valores Máximo (255), Mínimo (0) e o Passo (1). Além disso, deve-se associar os elementos criados às tags relacionadas aos registradores VALOR_ELIPSER, VALOR_ELIPSEG, VALOR_ELIPSEB.

Criação do objeto Slider no Scada.
Figura 6 – Criação do objeto Slider.

Finalmente, pode-se conferir o resultado do desenvolvimento realizado neste artigo na figura a seguir.

Sistema supervisório desenvolvido com Elipse Scada.
Figura 7 – Sistema supervisório desenvolvido.

Esperamos que você tenha gostado deste conteúdo, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Na próxima parte abordaremos outros conceitos, visando a progressão do aprendizado referente à manipulação desta ferramenta. Deixe seu comentário abaixo.

Outros artigos da série

<< Integração Arduino e Elipse ScadaMonitoramento de variáveis de processo com Elipse SCADA e Arduino >>

Sou engenheiro eletricista graduado com ênfase em Controle e Automação pela Universidade Federal do Espírito Santo - UFES e Técnico em Eletrotécnica pelo Instituto Federal do Espírito Santo - IFES. Me interesso por todas as vertentes existentes dentro da Engenharia Elétrica, no entanto, as áreas relacionadas à automação e instrumentação industrial possuem um significado especial para mim, assim como a Engenharia de Manutenção que na minha opinião é um setor fascinante.

Notificações
Notificar
guest
6 Comentários
recentes
antigos mais votados
Inline Feedbacks
View all comments
valmir queiroz
valmir queiroz
02/03/2019 23:43

da pra fazer isso usando uma ihm industrial?

FERNANDO CORDEIRO DA SILVA
FERNANDO CORDEIRO DA SILVA
26/02/2018 19:16

O que eu faço pois da erro de não declarado!!!
modbus_configure(&Serial, 9600, SERIAL_8N1, 1, 2, HOLDING_REGS_SIZE, holdingRegs);

modbus_update_comms(9600, SERIAL_8N1, 1);

Marcio Watanabe
Marcio Watanabe
16/02/2017 19:53

Olá Daniel,
Primeiro parabéns pelos tutoriais, até agora só vi esse sobre Modbus e parece ser bem simples.
Estava tentando executar esse seu exemplo como um teste, mas deu um erro na hora de verificar. Diz que a variável POT_R/G/B noa foi declarada, na linha 13, 17 e 21 do código aqui no site.
Acredito que essas variáveis sejam na verdade o VALOR_POTR/G/B correto?

Obrigado!
Watanabe

Celso Domingues
Celso Domingues
15/01/2017 13:29

Ah erros no segundo bloco, algumas variaveis sem declaração.

onde:

holdingRegs[VALOR_PWMR] = map(holdingRegs[POT_R],0,1023,0,255);
analogWrite(LED_VM,holdingRegs[VALOR_PWMR]);

holdingRegs[VALOR_PWMG] = map(holdingRegs[POT_G],0,1023,0,255);
analogWrite(LED_VD,holdingRegs[VALOR_PWMG]);

holdingRegs[VALOR_PWMB] = map(holdingRegs[POT_B],0,1023,0,255);
analogWrite(LED_AZ,holdingRegs[VALOR_PWMB]);

seria:

holdingRegs[VALOR_PWMR] = holdingRegs[VALOR_ELIPSER];
analogWrite(LED_VM, holdingRegs[VALOR_PWMR]);

holdingRegs[VALOR_PWMG] = holdingRegs[VALOR_ELIPSEG];
analogWrite(LED_VD, holdingRegs[VALOR_PWMG]);

holdingRegs[VALOR_PWMB] = holdingRegs[VALOR_ELIPSEB];
analogWrite(LED_AZ, holdingRegs[VALOR_PWMB]);

Procede?

WEBINAR

Imagens de Ultrassom: Princípios e Aplicações

DATA: 26/10 ÀS 19:30 H