scadabr

Alguém conhece o scadabr e sabe como usa-lo, caso conheça por favor entre em contato pois preciso de algumas informações.

Uma delas é o protocolo modbus pois queria saber como comunicar um sensor,atuador,etc como o supervisor por meio de um microcontrolador ou coisa paracida, me parece que para poder acionar ou receber informações o supervisorio precisa de um clp (que é caro) ou por um microcontrolador?

se alguém tiver informações sobre como usar e implementar ou pelo menos mostrar o caminho das pedras já agradeço.

adriano

Exibições: 97570

▶ Responder esta

Respostas a este tópico

Permalink Responder até Jonas Morais em 6 outubro 2015 at 18:43

Prezado André, parabens pelo trabalho!. Dias atrás eu encontrei essa lib até então eu não conhecia. Fazendo testes rodou legal a lib serial(rtu). Não testei com o modulo w5100 mas tenho certeza que tá OK. 

Já os exemplos para o enc28j60 não consegui rodar nenhum todos deram erro. Testei com o MODBUS POOL e com o CAS MODBUS SCANNER. Neste ultimo percebi que o arduino só respondia ao primeiro REQUEST (solicitação do mestre). já estava quase desistindo da lib, foi quando alterei o CORE da ETHERCARD.

no método que envia a resposta HTTP_SERVER_REPLY,  deletei uma flag. Após isso passou a funcionar perfeitamente.

Nos seus testes não aconteceu nada disso?

Permalink Responder até André Sarmento Barbosa em 7 outubro 2015 at 11:13

Olá Jonas, obrigado! Não tive problemas com a ModbusIP para o ENC28J60. Você teve que mexer não na modbus-arduino lib mas na Ethercard, certo? Vou ver se consigo um tempo para testar isso, mas precisaria de mais info (como o código rodando no arduino) do seu setup com o ENC28J60 pra reproduzir o problema 

Permalink Responder até Jonas Morais em 7 outubro 2015 at 11:24

ok! irei providenciar as informações q vc pediu.

E sim tive que mexer na ethercard.

A sua lib está OK.

Agradecemos pelo seu empenho em ajudar a comunidade.

Permalink Responder até Daltro Ribeiro Coutinho Junior em 22 janeiro 2016 at 16:14

Prezado André,

Ontem baixei sua lib para Arduino.

Estou tentando fazer uma aplicação com o ScadaBR e Arduino Mega2560+W5100 uitlizando o protocolo modbus TCP/IP.

Gostaria de saber se tens um tutorial sobre tal implementação no Arduino e, caso tenhas, se poderia disponibiliza-lo.

SDS

Daltro

Permalink Responder até Sidney Alves Bastos em 7 outubro 2015 at 9:16

Mas que beleza. Vou atualizar todos os slaves.

Onde poderei olhar detalhes dos bugs para ver se é necessário atualizar todos?

Permalink Responder até André Sarmento Barbosa em 7 outubro 2015 at 11:08

Oi Sidney, você pode dar uma olhada dos commits do de ontem 06/10:

https://github.com/andresarmento/modbus-arduino/commits/master

Além do suporte ao Leonardo, as correções foram na ModbusIP e nas funções modbus writeMultipleRegisters and writeMultipleCoils (que são puco utilizadas).

Permalink Responder até André Sarmento Barbosa em 11 outubro 2015 at 20:24

Mais uma atualização da biblioteca Modbus Arduino, agora com suporte ao ESP8266!

https://github.com/andresarmento/modbus-arduino

Permalink Responder até hilton lessa em 24 novembro 2015 at 13:53

Andre, parabéns pelo seu trabalho.

Estou tendo problemas pra rodar o lamp do ESP8266

O ESP8266 recebe a request do ScadaBR mas nao responde... tem alguma teoria do que pode ser?

estou usando o firmware ATv0.20 SDK 0.9.2 (notei que o que voce utilizou foi o 0.9.3)

obrigado.

Permalink Responder até André Sarmento Barbosa em 27 outubro 2015 at 15:39

Mais uma atualização da biblioteca Modbus Arduino, agora com suporte a Software Serial

https://github.com/andresarmento/modbus-arduino

Permalink Responder até alan lima da silva em 28 outubro 2015 at 7:41

Bom dia pessoal, estou desenvolvendo um trabalho com o scada e o arduino postei originalmente aqui http://labdegaragem.com/forum/topics/arduino-e-scadabr?xg_source=ac..., estou usando 2 sensores nas portas digitais 8 e 9 e um analógico na porta A0 que acionam um motor para esquerda ou direita. Estava tudo funcionando bem mas agora a porta 8 está me dando dor de cabeça quando coloco ela pra nível 0 dá erro.

Enquanto a entrada digital 8 permanece alta não dá problema:

Estou colocando em anexo as imagens, vejam que os data points das duas entradas digitais estão iguais, mas o problema só ocorre na 8

Já experimentei excluir o data point e fazer de novo, já mudei de pino a entrada estava no pino 11 mas dava o mesmo erro, já experimentei outro arduino e o erro continua.

Se alguém souber o que está causando isso agradeceria muito a ajuda.

Anexos
Permalink Responder até Sidney Alves Bastos em 28 outubro 2015 at 7:45

Alan,

algumas imagens ficaram muito pequenas. Não tem como aumentar? Detalhe, qual o firmware está usando nos arduinos?

Permalink Responder até alan lima da silva em 28 outubro 2015 at 9:09

Sidney, obrigado, não tinha reparado que estava ilegível.

Quanto ao firmware que vc perguntou se refere ao sketch do arduino? Se for por enquanto eu estou usando aquela biblioteca do JPMozeta, ainda não consegui usar a do André Sarmento, ele deve ensinar isso na aula hoje. Vou colocar a parte do código que eu modifiquei, eu usei um exemplo que um dos membros postou neste tópico e fui modificando de acordo com minha necessidade.

int chuva=0;
int estendida=0;


void setup()
{
        /* configura cominicação modbus
         * 9600 bps, 8N1, RS485 network */
        configure_mb_slave(COMM_BPS, PARITY, 2);

        pinMode(ledPin3,  OUTPUT);
        pinMode(ledPin4,  OUTPUT);
        pinMode(ledPin5,  OUTPUT);
        pinMode(ledPin6,  OUTPUT);
        pinMode(ledPin7,  OUTPUT);
        pinMode(ledPin8,  INPUT); //sensor de chuva
        pinMode(ledPin9,  INPUT); //sensor de vento
        pinMode(ledPin10, OUTPUT);
        pinMode(ledPin11, OUTPUT);
        pinMode(ledPin12, OUTPUT);
        pinMode(ledPin13, OUTPUT);

}


void loop()
{
        /* verifica se há solicitações do mestre */
        if(update_mb_slave(MB_SLAVE, regs, MB_REGS))
                wdog = millis();

        if ((millis() - wdog) > 1000000)  {      /* desliga as saidas se não recebe comando a mais de 10 segundos */
                regs[MB_PINO_3]  = 0; /* desliga led  3 */
                regs[MB_PINO_4]  = 0; /* desliga led  4 */
                regs[MB_PINO_5]  = 0; /* desliga led  5 */
                regs[MB_PINO_6]  = 0; /* desliga led  6 */
                regs[MB_PINO_7]  = 0; /* desliga led  7 */
                regs[MB_PINO_8]  = 0; /* desliga led  8 */
                regs[MB_PINO_9]  = 0; /* desliga led  9 */
                regs[MB_PINO_10] = 0; /* desliga led 10 */
                regs[MB_PINO_11] = 0; /* desliga led 11 */
                regs[MB_PINO_12] = 0; /* desliga led 12 */
                regs[MB_PINO_13] = 0; /* desliga led 13 */
        }

        if ((millis() - tanalogprev) > 1000)  {      /* atualiza as entradas analogica a cada 1 segundo */
                regs[MB_A0] = analogRead(0);  /* ler entrada analógica 0 */            
                regs[MB_A1] = analogRead(1);  /* ler entrada analógica 1 */
                regs[MB_A2] = analogRead(2);  /* ler entrada analógica 2 */
                regs[MB_A3] = analogRead(3);  /* ler entrada analógica 3 */
                regs[MB_A4] = analogRead(4);  /* ler entrada analógica 4 */
                regs[MB_A5] = analogRead(5);  /* ler entrada analógica 5 */
                regs[MB_PINO_8] = digitalRead (8); //LER ENTRADA DIGITAL 11 SENSOR DE CHUVA
                regs[MB_PINO_9] = digitalRead (9); //LER ENTRADA DIGITAL 9 SENSOR DE VENTO
                tanalogprev = millis();
        }       

        /* os valores dos registros são definidos pelo mestre modbus (SCADA) */

                switch(regs[MB_PINO_3]) {
        case 1:
                digitalWrite(ledPin3, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin3, LOW);
        }

                 switch(regs[MB_PINO_4]) {
        case 1:
                digitalWrite(ledPin4, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin4, LOW);
        }

                switch(regs[MB_PINO_5]) {
        case 1:
                digitalWrite(ledPin5, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin5, LOW);
        }

                switch(regs[MB_PINO_6]) {
        case 1:
                digitalWrite(ledPin6, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin6, LOW);
        }

                switch(regs[MB_PINO_7]) {
        case 1:
                digitalWrite(ledPin7, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin7, LOW);
        }

                switch(regs[MB_PINO_8]) {
        case 1:
                digitalWrite(ledPin8, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin8, LOW);
        }

                switch(regs[MB_PINO_9]) {
        case 1:
                digitalWrite(ledPin9, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin9, LOW);
        }

                switch(regs[MB_PINO_10]) {
        case 1:
                digitalWrite(ledPin10, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin10, LOW);
        }

                switch(regs[MB_PINO_11]) {
        case 1:
                digitalWrite(ledPin11, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin11, LOW);
        }

                switch(regs[MB_PINO_12]) {
        case 1:
                digitalWrite(ledPin12, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin12, LOW);
        }

                switch(regs[MB_PINO_13]) {
        case 1:
                digitalWrite(ledPin13, HIGH);
                break;       
        default: /* apagado */
                digitalWrite(ledPin13, LOW);
        }

if(regs[MB_PINO_8]==HIGH&&chuva==0){  // lê sensor de chuva (pino11), se alto recolhe roupa e sinaliza na variável chuva que está chovendo
  digitalWrite(ledPin10, HIGH);
  delay (2000);
  digitalWrite(ledPin10, LOW);
  chuva=1;
  estendida=0;}

if(regs[MB_PINO_8]==LOW){ // lê sensor de chuva (pino11), se baixo apenas sinaliza que não há chuva
  chuva=0;}

if(regs[MB_A0]>1000&&chuva==0&&estendida==0){ //lê sensor de luminosidade (pino A0), se >1000 e sem chuva, estende roupa.
  digitalWrite(ledPin12, HIGH);
  delay(2000);
  digitalWrite(ledPin12, LOW);
  chuva=0;
  estendida=1;}

if(estendida==0&&chuva==0&&500<regs[MB_A0]<1000&&regs[MB_PINO_9]==HIGH){ //Se estendido 0; chuva 0; dia e com vento - estende.
  digitalWrite(ledPin12, HIGH);
  delay(2000);
  digitalWrite(ledPin12, LOW);
  chuva=0;
  estendida=1;}

  if(estendida==1&&regs[MB_A0]<500){ //Se estendido e noite - recolhe.
  digitalWrite(ledPin10, HIGH);
  delay(2000);
  digitalWrite(ledPin10, LOW);
  estendida=0;}
 
 
}

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço