Realizando acionamentos simples com Elipse SCADA e Arduino

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.

 

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

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).

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).

#include <SimpleModbusSlave.h>

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.

#define  LED_AZ 9 
#define  LED_VD 10
#define  LED_VM 11
#define  CHAVE 12

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.

enum 
{     
  VALOR_POTR,
  VALOR_POTG,
  VALOR_POTB,
  VALOR_ELIPSER,
  VALOR_ELIPSEG,
  VALOR_ELIPSEB,
  VALOR_PWMR,
  VALOR_PWMG,
  VALOR_PWMB,
  MAN_AUTO,
  HOLDING_REGS_SIZE 
};

unsigned int holdingRegs[HOLDING_REGS_SIZE];

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.

void setup()
{
  	
  modbus_configure(&Serial, 9600, SERIAL_8N1, 1, 2, HOLDING_REGS_SIZE, holdingRegs);
  
  modbus_update_comms(9600, SERIAL_8N1, 1);
  
  
}

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.

void loop()
{
  
  modbus_update();
  
  holdingRegs[VALOR_POTR] = analogRead(A0); 
  holdingRegs[VALOR_POTG] = analogRead(A1);
  holdingRegs[VALOR_POTB] = analogRead(A2);
  holdingRegs[MAN_AUTO] = digitalRead(CHAVE);

  if(holdingRegs[MAN_AUTO] == 0){

  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]);

  } 

else{

  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]);

}  

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.

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.

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 e Mínimo devem ser preenchidos ambos com zero, enquanto a zona 2 terá como mensagem a palavra Automático e os campos Máximo e 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 um, as mensagens exibidas serão respectivamente Manual e Automático.

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.

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

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.