arduino, eletrônica, robotica...
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
Respostas a este tópico
-
Permalink Responder até adriano de alcantara em
-
aqui informações sobre configuração de email:
http://labdegaragem.com/forum/topics/problema-com-envio-de-email-no...
-
Permalink Responder até wilton feitosa em
-
Adriano bom dia, ate esta parte beleza já esta ok agora preciso quando o valor do data point chegar a zero enviar o e-mail, por exemplo na minha casa sempre fica com 5 A quando ficar 0 A informar por email que faltou energia.
-
-
-
-
aqui um video de como definir os vaalores limites para envio de email:
https://www.youtube.com/watch?v=ZKkoDxhqZ70&feature=youtu.be
link de apoio e referencia para esta resposta:
http://labdegaragem.com/forum/topics/problema-na-configura-o-do-ema...
material referentes a respostas de Wichert e Sdney.
-
Permalink Responder até Sidney Alves Bastos em
-
Esse valor já está em amperes?
-
Permalink Responder até Rafa Br em
-
Pessoal, estou com um problema que tá difícil de resolver.
Estou tentando criar um projeto com um Arduino MEGA para comunicar-se com ScadaBr e a princípio a comunicação esta sendo realizada, porém só consigo visualizar os valores dos Holdind register na tela de configuração do Data Source na aba de leitura de dados Modbus, o ScadaBr tambem esta detectando o nó escravo, mas na tela principal do Wacth List eu não consigo visualizar nada dos valores das variáveis do data point, esta indicando apenas que o valor do ponto pode não ser confiável e n/a, alguem sabe alguma coisa que eu possa esta fazendo de errado?
Abraços!!!
-
-
Rafa,
o seu datapoint pode estar desligado. Volte na tela do datasource, e veja se ele está verdinho. Dai você desce em cada ponto e veja se esta verdinho.
O proximo passo é verificar a comunicação. No meu sistema quando isso acontece é um problema de comunicação do slave com o mestre.
-
-
Sim Sidney esta tudo verde.Pode estar ocorrendo um problema de comunicação mesmo lendo os valores dos registradores? eu também consigo simular as alterações nos valores dos registradores normalmente.O arduino também consegue identificar o nó normalmente.
-
-
Rafa,
pode sim. Quando você pede a leitura de um ponto manualmente pode funcionar e quando o sistema começa a gerar os pedidos a cada minuto pode falhar.
Já aconteceu comigo. Você tem que revisar os dados no datapoint. Veja, vc pode colocar na leitura manual um dado, como ler o slave 1, datapoint 1 que fica no endereço tal.
Mas quando ele vai fazer automaticamente ele usa as informações que já estão salvas, Dai vc colocou por exemplo datasource 1, datapoint 2, que ainda não existe, dai vai dar erro.
entendeu?
-
-
Rafa, faça um print do datasource, do data point e se possivel a parte inicial do codigo que vc está usando.
-
-
Essa é a parte inicial do código até o ínicio das funções escravo.
/*
* configure_mb_slave(baud, parity, tx_en_pin)
*
* configuração dos parametros da porta serial.
*
* baud: taxa de transmissão em bps (valores típicos entre 9600, 19200... 115200)
* parity: seta o modo de paridade:
* 'n' sem paridade (8N1); 'e' paridede impar (8E1), 'o' paridade par (8O1).
* tx_en_pin: pino do arduino que controla a transmissão/recepção em uma linha RS485.
* 0 or 1 desliga esta função (para rede RS232)
* >2 para uma rede multiponto.
*/
void configure_mb_slave(long baud, char parity, char txenpin);
/*
* update_mb_slave(slave_id, holding_regs_array, number_of_regs)
*
* verifica se há qualquer pedido válido do mestre modbus. Se houver,
* executa a ação solicitada
*
* slave: endereço do escravo (arduino) (1 to 127)
* regs: uma matriz com os holding registers. Eles começam no endereço 1 (mestre ponto de vista)
* Regs_size: número total de holding registers.
* Retorna: 0 se não houver pedido do mestre,
* NO_REPLY (-1) se nenhuma resposta é enviada para o mestre
* Caso um código de exceção (1 a 4) em algumas exceções de modbus
* O número de bytes enviados como resposta (> 4) se OK.
*/
int update_mb_slave(unsigned char slave, int *regs,
unsigned int regs_size);
/* Aqui começa o código do exemplo */
/* Parâmetros Modbus RTU de comunicação, o Mestre e os escravos devem usar os mesmos parâmetros */
enum {
COMM_BPS = 9600, /* baud rate */
MB_SLAVE = 1, /* endereço do escravo modbus */
PARITY = 'n' /* paridade */
};
/* registros do escravo (holding registers)
*
* Aqui ficam ordenados todos os registros de leitura e escrita
* da comunicação entre o mestre e o escravo (SCADA e arduino)
*
*/
enum {
MB_PINO_3, /* Controle do Led no pino 3 (desliga=0 liga=1) */
MB_PINO_4, /* Controle do Led no pino 4 (desliga=0 liga=1) */
MB_PINO_5, /* Controle do Led no pino 5 (desliga=0 liga=1) */
MB_PINO_6, /* Controle do Led no pino 6 (desliga=0 liga=1) */
MB_PINO_7, /* Controle do Led no pino 7 (desliga=0 liga=1) */
MB_PINO_8, /* Controle do Led no pino 8 (desliga=0 liga=1) */
MB_PINO_9, /* Controle do Led no pino 9 (desliga=0 liga=1) */
MB_PINO_10, /* Controle do Led no pino 10 (desliga=0 liga=1) */
MB_PINO_11, /* Controle do Led no pino 11 (desliga=0 liga=1) */
MB_PINO_12, /* Controle do Led no pino 12 (desliga=0 liga=1) */
MB_PINO_13, /* Controle do Led no pino 13 (desliga=0 liga=1) */
MB_A0, /* Leitura da entrada analógica 0 (0 a 1023) */
MB_A1, /* Leitura da entrada analógica 1 (0 a 1023) */
MB_A2, /* Leitura da entrada analógica 2 (0 a 1023) */
MB_A3, /* Leitura da entrada analógica 3 (0 a 1023) */
MB_A4, /* Leitura da entrada analógica 4 (0 a 1023) */
MB_A5, /* Leitura da entrada analógica 5 (0 a 1023) */
MB_REGS /* número total de registros do escravo */
};
int regs[MB_REGS];
int ledPin3 = 3;
int ledPin4 = 4;
int ledPin5 = 5;
int ledPin6 = 6;
int ledPin7 = 7;
int ledPin8 = 8;
int ledPin9 = 9;
int ledPin10 = 10;
int ledPin11 = 11;
int ledPin12 = 12;
int ledPin13 = 13;
unsigned long wdog = 0; /* watchdog */
unsigned long tprev = 0; /* tempo anterior do último comando*/
unsigned long tanalogprev = 0; /* tempo anterior da leitura dos pinos analogicos*/
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, OUTPUT);
pinMode(ledPin9, OUTPUT);
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) > 10000) { /* 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) > 500) { /* 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 */
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);
}
}
/**************************************************************************
* INICIO DAS FUNÇÕES ESCRAVO Modbus RTU
**************************************************************************/
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues.
Ativado por
