Sistema supervisório com SCADABR - Embarcados
Este artigo corresponde ao segundo material voltado para utilização do ScadaBR em projetos de automação. Nesta publicação serão abordados alguns aspectos relativos ao acionamento de alguns componentes além de propor a elaboração de um supervisório para que o usuário possa efetuar todo o controle e monitoramento do sistema em questão, porém este sistema de supervisão não possuirá gráficos dinâmicos, isto é atualizados constantemente ao longo do tempo.
Gostaríamos de ressaltar para o leitor, como de praxe, que a estrutura utilizada para interagir com o ScadaBR será um Arduino UNO via protocolo Modbus. Obviamente, por se tratar de uma questão de praticidade e também por fugir do escopo proposto, não será mostrado neste artigo os procedimentos necessários (na íntegra) para efetivar a comunicação destes dois elementos, até porque o artigo anterior cobre este passo-a-passo.
O hardware que será utilizado para dar continuidade aos conceitos já demonstrados no artigo anterior será composto por um Arduino UNO, um led RGB(e os respectivos resistores para o acionamento dos mesmos, com valores de resistência de 280Ω), três potenciômetros de 4.7kΩ (responsáveis pelo acionamento do led RGB), um botão para o acionamento on/off de um outro led, além de uma chave seletora para definir os modos de operação automático e manual do sistema.
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 SCADABR através do protocolo MODBUS. Esta pode ser encontrada aqui (baixar o arquivo SimpleModbusSlaveV10.zip).
#define LED_VM 11 #define LED_VD 10 #define LED_AZ 9 #define LED 8 #define BOTAO 12 #define CHAVE 13
#define BOTAO 12
#define CHAVE 13
Antes de prosseguirmos com o código, foi necessário criar algumas variáveis para uso posterior no acionamento dos componentes.
int PWM_R; int PWM_G; int PWM_B;
int PWM_R;
int PWM_G;
int PWM_B;
Neste momento serão definidos os registradores holding utilizados no SCADABR. Caso o leitor tenha alguma dúvida neste ponto, insistimos em pedir para o leitor consultar o link disponibilizado no início deste artigo, nele estão contidas todas as informações para que o leitor compreenda cada um dos pontos deste desenvolvimento de código.
Os registradores holding POT_R/POT_G/POT_B são responsáveis por conter os valores referentes às leituras realizadas através dos potenciômetros enquanto os registradores LED_R/LED_G/LED_B estão diretamente ligados ao acionamento do led RGB . Os registradores BOT e LED_ON_OFF definem o comportamento do led on/off, enquanto o registrador MAN_AUTO está relacionado com a chave que determina o modo de operação (manual ou automático).
enum { POT_R, POT_G, POT_B, BOT, LED_R, LED_G, LED_B, LED_ON_OFF, MAN_AUTO, HOLDING_REGS_SIZE }; unsigned int holdingRegs[HOLDING_REGS_SIZE];
POT_R,
POT_G,
POT_B,
LED_R,
LED_G,
LED_ON_OFF,
Na função setup() utiliza-se 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" são o segundo, o terceiro e o quarto, que dizem respeito à taxa de transmissão de dados e o formato do pacote utilizado no protocolo MODBUS. Note que estes três argumentos citados devem estar em conformidade com as configurações do SCADABR.
Em seguida temos a função modbus_update_comms(), que também é responsável pela comunicação via MODBUS, enquanto a função pinMode() determina os modos de operação (como saída) dos pinos onde estão conectados os diversos elementos presentes no sistema em questão.
void setup() { modbus_configure(&Serial, 9600, SERIAL_8N1, 1, 2, HOLDING_REGS_SIZE, holdingRegs); modbus_update_comms(9600, SERIAL_8N1, 1); pinMode(LED_VM, OUTPUT); pinMode(LED_VD, OUTPUT); pinMode(LED_AZ, OUTPUT); pinMode(LED, OUTPUT); pinMode(BOTAO, INPUT); pinMode(CHAVE, INPUT); }
pinMode(LED_VM, OUTPUT);
pinMode(LED_VD, OUTPUT);
pinMode(LED_AZ, OUTPUT);
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 nas portas de entrada digital, ou seja, onde está a chave seletora e o botão.
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 dos leds são provenientes diretamente dos valores obtidos através dos potenciômetros. E o led com comportamento on/off responde diretamente de acordo com o botão enquanto solto ou pressionado. Observe que apesar de não utilizarmos os registradores holding nos acionamentos (no caso do led RGB), estes ainda assim são atualizados para que seus valores sejam devidamente apresentados no SCADABR.
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, pois assim é possível realizar estes por meio da alteração de valores no supervisório que será apresentado a seguir.
void loop() { modbus_update(); holdingRegs[POT_R] = analogRead(A0); holdingRegs[POT_G] = analogRead(A1); holdingRegs[POT_B] = analogRead(A2); holdingRegs[BOT] = digitalRead(BOTAO); holdingRegs[MAN_AUTO] = digitalRead(CHAVE); if(holdingRegs[MAN_AUTO] == 0){ PWM_R = map(holdingRegs[POT_R],0,1023,0,255); analogWrite(LED_VM,PWM_R); holdingRegs[LED_R] = PWM_R; PWM_G = map(holdingRegs[POT_G],0,1023,0,255); analogWrite(LED_VD,PWM_G); holdingRegs[LED_G] = PWM_G; PWM_B = map(holdingRegs[POT_B],0,1023,0,255); analogWrite(LED_AZ,PWM_B); holdingRegs[LED_B] = PWM_B; digitalWrite(LED,holdingRegs[BOT]); holdingRegs[LED_ON_OFF] = holdingRegs[BOT]; } else{ analogWrite(LED_VM, holdingRegs[LED_R]); analogWrite(LED_VD, holdingRegs[LED_G]); analogWrite(LED_AZ, holdingRegs[LED_B]); digitalWrite(LED,holdingRegs[LED_ON_OFF]); }
holdingRegs[POT_R] = analogRead(A0);
holdingRegs[POT_G] = analogRead(A1);
holdingRegs[POT_B] = analogRead(A2);
holdingRegs[BOT] = digitalRead(BOTAO);
PWM_R = map(holdingRegs[POT_R],0,1023,0,255);
analogWrite(LED_VM,PWM_R);
holdingRegs[LED_R] = PWM_R;
PWM_G = map(holdingRegs[POT_G],0,1023,0,255);
analogWrite(LED_VD,PWM_G);
holdingRegs[LED_G] = PWM_G;
PWM_B = map(holdingRegs[POT_B],0,1023,0,255);
analogWrite(LED_AZ,PWM_B);
holdingRegs[LED_B] = PWM_B;
digitalWrite(LED,holdingRegs[BOT]);
holdingRegs[LED_ON_OFF] = holdingRegs[BOT];
analogWrite(LED_VM, holdingRegs[LED_R]);
analogWrite(LED_VD, holdingRegs[LED_G]);
analogWrite(LED_AZ, holdingRegs[LED_B]);
digitalWrite(LED,holdingRegs[LED_ON_OFF]);
Terceiro passo: Criação do Data Source e seu(s) respectivo(s) Data Point(s) para manipulação dos dados
Neste momento iremos abordar os passos necessários para realizar interação do Arduino UNO com o SCADABR. Vale ressaltar que neste artigo partiremos de uma parte mais avançada, no entanto, é conveniente que caso o leitor não esteja familiarizado com o conteúdo mostrado a seguir, veja como são feitos os procedimentos iniciais para tal objetivo em nosso artigo anterior cujo link encontra-se disponibilizado no início deste artigo.
Primeiramente é necessário produzir o Data source referente ao Arduino UNO utilizando a opção modbus serial como modo de conexão e em seguida criar os Data points que serão utilizados no programa. Por uma questão de didática e também para facilitar a programação e o entendimento do leitor, os nomes dos Data points são iguais aos dos registradores holding declarados no código (exceto os que possuem "/" no nome, pois este caractere não foi aceito no código, dessa maneira este foi substituído por "_"). Observe que neste artigo alguns Data points foram declarados como inteiros de 2 bytes sem sinal ao passo que outros foram tidos como binários.
Figura 2 – Data points criados
Quarto passo: Desenvolvimento do sistema supervisório
Para desenvolver um sistema supervisório, o usuário deve inicialmente clicar no ícone referente ao modo que por sua vez proporciona o ambiente necessário para a produção de tal sistema. Este ícone possui o nome de representação gráfica.
Em seguida, o leitor deve escolher um nome para este sistema supervisório assim como uma imagem de fundo caso seja desejo do desenvolvedor (neste caso, após selecionar a imagem desejada, basta clicar no botão responsável por fazer o upload da imagem).
Figura 4 – Propriedades na criação do supervisório
Neste momento nosso supervisório recém criado se encontra desta maneira:
Figura 5 – Imagem de fundo do supervisório
Primeiramente serão criados os leds de sinalização do modo de operação, isto é, um mecanismo para que o usuário saiba se o sistema esta em modo manual ou automático. Como dito anteriormente, no modo manual, as alterações só podem ser realizadas através dos potenciômetros e pelo botão, ao passo que no modo automático, as mudanças só podem ser realizadas pelo supervisório. Observe que a única coisa que define o modo de operação é a chave seletora diretamente contida no hardware.
Figura 6 – Modo automático/manual
Para adicionar os componentes escritos, deve-se selecionar na lista de componentes a opção HTML e clicar no ícone ao lado da mesma lista. Posteriormente o desenvolvedor deve escrever as frases desejadas. Neste caso, o procedimento em questão foi repetido 3 vezes com as seguintes frases: "Modo de operação", "Automático" e "Manual".
Figura 7 – Adicionando itens no supervisório
Já para inserir os elementos gráficos deve-se selecionar na lista de componentes a opção GIF Binário e clicar no ícone ao lado para adicioná-lo ao supervisório. Em seguida aparecerá um ícone igual ao mostrado na figura abaixo (extremidade esquerda), de modo que o leitor deve definir alguns parâmetros para que o item gráfico funcione de maneira efetiva. Num primeiro momento deve-se posicionar o mouse sobre ícone citado e aparecerão algumas opções, o leitor deve primeiramente clicar na opção marcada de vermelho e definir qual Data point estará "ligado" ao elemento gráfico em questão (no nosso caso, o Data point escolhido está relacionado ao registrador holding responsável por conter o valor relativo à leitura da chave seletora que define o modo de operação).
Figura 8 – Atribuição do Data point ao elemento criado
Depois de realizar o procedimento anterior, o leitor deve clicar no ícone abaixo do selecionado anteriormente, e então escolher qual tipo de elemento gráfico deseja utilizar. Neste caso foi selecionado o conjunto "leds24", composto por uma série de imagens onde o usuário deve determinar uma para o caso do Data point em questão atribuir o valor 0 (led apagado) ao registrador holding correpondente e outra para o caso deste possuir o valor 1 (led aceso). Observe que a intenção neste momento é fazer com que o led acenda caso o modo vigente seja automático, ou seja, quando a chave seletora apresentar nível alto na entrada correspondente do Arduino.
Figura 9 – Atribuição de imagens ao elemento criado
Conforme citado, o elemento que foi adicionado anteriormente está ligado à sinalização do modo automático. Para inserir outro relacionado ao modo manual deve-se proceder da mesma forma, no entanto é necessário inverter as imagens pois, quando a chave seletora proporcionar nível baixo na entrada digital do Arduino, este deve entender que o sistema está em modo manual, acendendo portanto o led referente a este modo de operação. Lembre-se sempre de salvar as alterações clicando no ícone do disquete no canto superior direito.
O próximo passo no desenvolvimento do supervisório consiste em construirmos estruturas para sinalizar as componentes do led RGB.
Figura 10 – Led RGB
Basicamente, o procedimento para incluir os elementos gráficos, a ser realizado neste ponto, é idêntico ao anterior. No entanto, para esta aplicação nós não dispomos de Data points que representam registradores holding binários (como por exemplo MAN_AUTO) para controlar os 2 estados definidos pelas imagens dos leds acesos e apagados. Portanto deve-se criar alguns Data points virtuais (neste momento utilizaremos o led que controla a componente vermelha do RGB como exemplo, porém os passos a serem seguidos são os mesmos para as outras componentes), para isso deve-se criar no mesmo lugar onde foi criado o Data source responsável pela interação do Arduino UNO com o SCADABR via MODBUS e escolher a opção Data Source Meta.
Figura 11 – Criação de um Data Source Meta
O Data Source Meta criado neste artigo possui o nome "Auxiliares" e no momento em que este é criado, abre-se uma tela de configurações deste Data source onde o desenvolvedor deve procurar a área relativa à criação de Data points para adiciona-los. Após criar o Data point deve-se nomeá-lo, definir o tipo de dado como binário e selecionar outro Data point (já existente) no campo Contexto do Script para criar uma estrutura que irá definir quando este recém criado assumirá os valores 0 e 1, neste caso escolhemos o Data point LED_R (responsável por conter o valor utilizado no PWM para o acionamento do led). Observe que existe uma coluna na tabela onde foi adicionado este Data point já existente chamada Var, onde pode-se dar um nome para uma variável que irá conter o valor presente no registrador holding representado pelo Data point LED_R, cujo nome é pwm_vm.
No script apresentado conforme a figura a seguir, utiliza-se uma estrutura condicional if() para que este Data point criado retorne 1 (returne true) caso a variável pwm_vm possua um valor maior do que 0 (if (pwm_vm.value > 0)) ou retorne 0 (returne false) caso o valor da mesma variável seja igual a zero (else return false).
Figura 12 – Criação de um Data point virtual utilizando script
Voltando ao ambiente de desenvolvimento do sistema supervisório deve-se associar o Data point virtual criado ao elemento gráfico em questão da mesma maneira realizada anteriormente além de definir as duas imagens, uma para quando este for 0 e outra para quando este for 1.
Repare que até o presente momento foram adicionados apenas elementos gráficos, no entanto agora será inserido na representação gráfica um dispositivo que mostre os valores que serão utilizados nos PWMs dos acionamentos dos leds. Para isso deve-se selecionar a opção Data point simples na lista de seleção de componentes e definir suas configurações. Primeiramente, deve-se atribuir o Data point desejado ao item (no caso o que está representando o registrador holding que contém o valor do PWM a ser utilizado no acionamento do led vermelho), em seguida o usuário pode ou não definir um texto para aparecer juntamente com o valor e por fim deve-se marcar as duas caixas de seleção. O próximo passo consiste em simplesmente escolher as duas imagens para representar os estados distintos de funcionamento.
Figura 13 – Atribuição do Data point ao elemento criado
Após estes procedimentos torna-se possível alterar os valores dos PWMs simplesmente posicionando o valor mostrado e clicando no ícone conforme mostrado na figura abaixo. Caso estes valores sejam alterados enquanto o sistema estiver no modo manual, ocorrerá somente a mudança no supervisório até a próxima atualização do sistema (que retornará o valor que estava antes), no entanto, não haverá alteração no acionamento pelo fato de o código ser protegido contra tal ação enquanto o sistema estiver operando de forma manual.
Figura 14 – Alterando valor por meio do supervisório
Por último será desenvolvido o mecanismo utilizado para o controle do led on/off. Este pode ter sinalização criada exatamente da mesma maneira que foi feita no início deste item com os leds indicando os modos de operação, no entanto, o Data point escolhido para as imagens que representarão o led aceso e apagado deve ser o LED_ON_OFF.
Figura 15 – Led on/off
Para inserir o botão mostrado na figura anterior basta ir na lista de componentes do ambiente de representação gráfica e selecionar a opção botão (escrita) e adiciona-lo. Num primeiro momento deve-se incluir o Data point correspondente (LED_ON_OFF) da mesma forma feita para os outros elementos além de marcar as caixas de seleção existentes. Posteriormente é necessário determinar os textos que aparecerão quando o Data point escolhido anteriormente assumir os possíveis valores além da altura e comprimento do botão.
Figura 16 – Definindo as propriedades do botão
A figura a seguir exibe o resultado do projeto desenvolvido neste artigo, onde é possível ver o sistema supervisório em questão possibilitando a análise dos valores além da sua manipulação.
Figura 17 – Resultado final do supervisório
Nós do EMBARCADOS esperamos que você tenha gostado deste conteúdo, sinta-se à vontade para sugestões, críticas ou elogios. Deixe seu comentário abaixo.
<< Estabelecendo comunicação via protocolo Modbus com ScadaBRCriação de sistemas supervisórios dinâmicos com ScadaBR >>
AnteriorAnteriorArduino Uno Wifi
PróximoSpartixed – Uma placa para você aprender a codificar em VHDL e VerilogPróximo
Arilson Ferreira da
Só a dor de cabeça na hora da instalação, já se torna pra mim inviavel, uma vez que o processo come muito tempo pra se conseguir instalar na primeira tentativa. É muito árduo, e muitas vezes, vc mesmo seguindo varios tutoriais disponibilizados nos foruns, é certo passar muita raiva na hora de iniciar a plataforma. Instalei e depois de muitas e várias tentativas deu certo, pois bastou eu formatar o pc pra não conseguir mais ter êxito, não sei se foi as atualizações, não sei o que foi, mas o fato é, não tem como eu confiar e indicar um… Leia mais »
Reply to Arilson Ferreira da
bom dia, eu rodo tranquilo aqui, se quiser ajuda, e so falar comigo.
Opa, acho que vc poderia me ajudar. Já tentou instalar no Raspberry PI? O tomcat está ok, mas o ScadaBR, tá dificil rodar…
No Windows eu concordo, eu apanhei um pouco, mas agora está rodando. O problema maior que eu vejo é a compatibilidade entre as versões do java e do ScadaBR, não sei se eles já acertaram isto?
sai fora do tomcat ele é muito chato de configurar, usa o jetty é muito mais fácil. Tem um tutorial do lab de garagem ensinando como faz. Uma dica que eu dou é criar um serviço pra rodar o aplicativo .jar na inicialização, e depois que ligar o desktop espera uns 30 segundos antes de abrir a pagina do scadabr
Fiquei com dúvida quanto a comunicação física entre o ScadaBr e o arduino, se precisa de algum conversor usb e serial rs 232 ou coisa parecida. Só o USB já comunica?
Desde já agradeço pelo artigo!!!
Sim, pela porta usb do arduino. a biblioteca modbus se encarrega disso. la no scada, tem que se usar a opcao Modbus serial.
No Windows eu concordo, eu apanhei um pouco, mas agora está rodando. O problema maior que eu vejo é a compatibilidade entre as versões do java e do ScadaBR, não sei se eles já acertaram isto.
Last edited 1 ano atrás by Carlos
Daniel, Parabéns! Muito bom usar o ScadaBR, em uma parte porque ele é free em outra porque é um projeto nacional! Há tempos que estou apenas planejando instalar um supervisório lá em casa para facilitar um pouco as coisas e gerenciar outras! Mas sempre falta tempo (claro). Mas me diz uma coisa, qual IDE do Arduino você está utilizando para compilar esse código? Baixei a biblioteca utilizada aqui (tanto nesse quanto no Artigo anterior, que por sinal é a mesma claro) e sempre da erro na compilação! Já baixei outras bibliotecas Modbus Slave para o Arduino, mas não são nada… Leia mais »
Bom dia Rafael, tudo bem? Primeiramente, muito obrigado por ter dado essa chance ao material que fizemos. Acredito que a IDE não seja o problema, eu utilizei a 1.6.5, na verdade, vou trocar o link que disponibilizei para baixar a biblioteca por que aparentemente cometi uma falha e coloquei uma versão da mesma que não é a que eu tenho utilizado, peço desculpas. Antes de alterar no texto vou colocar aqui o link para que você possa testar e me dar algum retorno, se possível. A biblioteca pode ser encontrada neste link: https://drive.google.com/folderview?id=0B0B286tJkafVYnBhNGo4N3poQ2c&usp=drive_web&tid=0B0B286tJkafVSENVcU1RQVBfSzg Existem alguns arquivos nesta pasta, você deve… Leia mais »
Eu que agradeço pelo material de ótima qualidade aqui postado! Sucesso!
Utilizei essa nova biblioteca disponibilizada e compilou perfeitamente! Tanto o exemplo da própria lib, quanto o código postado neste artigo! Muito obrigado por compartilhar o arquivo!
Vou seguir todo o artigo agora, pois o artigo trata muitos pontos que eu tinha dúvida no próprio ScadaBR.
Muito obrigado por compartilhar este conhecimento Daniel!
Que bom!! Obrigado por ter testado, já atualizei os artigos com a nova informação para que este tipo de problema não ocorra novamente, foi muito importante você ter trazido este impasse à tona!
Qualquer dúvida, pode postar aqui que vamos sempre tentar ajudar da melhor forma!
Depois que você conseguir fazer o supervisório para atender os seus objetivos, mostre para nós resultado, ficaremos felizes em ver nossa contribuição gerando resultados!
Fiquei com duvida sobre qual a lógica para ajuste do Offset ao adicionar um Data Point?
Reply to Ramon Basilio
O offset serve para você escolher o registrador utilizado! Confira nossos outros artigos que você poderá aprender melhor!
SHOW DE BOLA PARABENS DANIEL, POR COMPARTILHAR CONHECIMENTO!
FORTE ABRAÇO ME AJUDOU MUITO TEUS TUTORIAIS
Fábio Prudente Durão
Aee Embarcados e Amantes da Automação, Ótimo tutorial!!! Boas novas, o ScadaBR está voltando com tudo!!! Adeus JRE6, estamos para lançar a versão 1.1 com melhorias de estabilidades e novas funções super bacanas, não precisar mais de um gateway para integrar um modem gprs ao ScadaBR está entre elas. Além disso estamos oferecendo cursos para a comunidade, aos interessados, abaixo o link, a ideia é aumentar a comunidade e reativá-la, além do aluno sair do curso sabendo criar uma aplicação completa e gerenciar o sistema, vendo até tópicos avançados de scripts, datasource SQL, e operação distribuída com concentrador. Quem se… Leia mais »