Problemas de conexão com ESP 32 LoRa


#1

Estou realizando um projeto onde tenho que acionar uma carga utilizando Esp 32 LoRa e pretendo fazer o monitoramento com o ScadaBr, porem estou com problemas na hora da comunicação.

Eu pretendo no inicio apenas controlar um rele com o ScadaBR, segue minha programação e minhas configurações, desde ja agradeço a ajuda e a atenção.

#include <Modbus.h>
#include <ModbusIP_ESP32.h>

const int REL_COIL = 0;

int rel1 = 22;

ModbusIP mb;

void setup() {
Serial.begin(115200);

mb.config(“login”, “senha”);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}

Serial.println("");
Serial.println(“WiFi connected”);
Serial.println("IP address: ");
Serial.println(WiFi.localIP());

pinMode(rel1, OUTPUT);
mb.addCoil(REL_COIL);
}

void loop(){

mb.task();
digitalWrite(rel1, mb.Coil(REL_COIL));
}


#2

Faz um programa primeiro pra tentar ler um valor do ESP, eu tive esse mesmo problema com compatibilidade de variáveis.

Estava tentando escrever um byte onde era um status coil ou coisa do tipo.


#3

Guilherme, se você especificar o erro fica mais fácil pra gente ajudar. Alguns problemas que vejo no seu código são:

  1. Falta do mb.addHreg e mb.Hreg, para adicionar e setar a variável no mapa Modbus. Eu tô supondo que vc vai usar registrador tipo holding.
  2. O tipo de configuração TCP com manter vivo vai ficar dando erro de comunicação a cada leitura. Use somente TCP

Espero ter ajudado. Abraço


#4

Obrigado pela atenção

O erro é que não consigo ler o estado do rele, como mostrado na imagem aparece “Valor do ponto pode não ser confiavel”, como estou a pouco tempo estudando o ScadaBR talvez tenha feito algum passo errado, mas estou a alguns dias com este problema e não consigo resolve-lo


#5

Obrigado pela atenção, você teria algum norte para me dar para tentar resolver meu problema ?


#6

Tenta esse programa, modifica de acordo com as suas necessidades:

#include <ESP8266WiFi.h>
#include “DHT.h”

int sensorValue = 0; // value read from the pot
const int analogInPin = A0;

const char* ssid = “TP-LINK_B95E”;
const char* password = “peitodemacaco”;
int ModbusTCP_port = 502;

#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

//////// Required for Modbus TCP / IP /// Requerido para Modbus TCP/IP /////////
#define maxInputRegister 20
#define maxHoldingRegister 20

#define MB_FC_NONE 0
#define MB_FC_READ_REGISTERS 3 //implemented
#define MB_FC_WRITE_REGISTER 6 //implemented
#define MB_FC_WRITE_MULTIPLE_REGISTERS 16 //implemented
//
// MODBUS Error Codes
//
#define MB_EC_NONE 0
#define MB_EC_ILLEGAL_FUNCTION 1
#define MB_EC_ILLEGAL_DATA_ADDRESS 2
#define MB_EC_ILLEGAL_DATA_VALUE 3
#define MB_EC_SLAVE_DEVICE_FAILURE 4
//
// MODBUS MBAP offsets
//
#define MB_TCP_TID 0
#define MB_TCP_PID 2
#define MB_TCP_LEN 4
#define MB_TCP_UID 6
#define MB_TCP_FUNC 7
#define MB_TCP_REGISTER_START 8
#define MB_TCP_REGISTER_NUMBER 10

byte ByteArray[260];
unsigned int MBHoldingRegister[maxHoldingRegister];

//////////////////////////////////////////////////////////////////////////

WiFiServer MBServer(ModbusTCP_port);

void setup() {

//pinMode(14, OUTPUT);

Serial.begin(9600);
delay(100) ;
WiFi.begin(ssid, password);
delay(100) ;
Serial.println(".");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
MBServer.begin();
Serial.println("Connected ");
Serial.print(“ESP8266 Slave Modbus TCP/IP “);
Serial.print(WiFi.localIP());
Serial.print(”:”);
Serial.println(String(ModbusTCP_port));
Serial.println(“Modbus TCP/IP Online”);

dht.begin();

}

void loop() {

// Check if a client has connected // Modbus TCP/IP
WiFiClient client = MBServer.available();
if (!client) {
return;
}

boolean flagClientConnected = 0;
byte byteFN = MB_FC_NONE;
int Start;
int WordDataLength;
int ByteDataLength;
int MessageLength;

// Modbus TCP/IP
while (client.connected()) {

if(client.available())
{
flagClientConnected = 1;
int i = 0;
while(client.available())
{
ByteArray[i] = client.read();
i++;
}

client.flush();

///////// Holding Register [0] A [9] = 10 Holding Registers Escritura
///////// Holding Register [0] A [9] = 10 Holding Registers Writing

sensorValue = analogRead(analogInPin);

float h = dht.readHumidity();
float t = dht.readTemperature();

MBHoldingRegister[0] = h10;
MBHoldingRegister[1] = t
10;
MBHoldingRegister[2] = sensorValue;
MBHoldingRegister[3] = 4;
MBHoldingRegister[4] = 5;
MBHoldingRegister[5] = 6;
MBHoldingRegister[6] = 7;
MBHoldingRegister[7] = 8;
MBHoldingRegister[8] = 9;
MBHoldingRegister[9] = 10;

///////// Holding Register [10] A [19] = 10 Holding Registers Lectura
///// Holding Register [10] A [19] = 10 Holding Registers Reading

int Temporal[10];

Temporal[0] = MBHoldingRegister[10];
Temporal[1] = MBHoldingRegister[11];
Temporal[2] = MBHoldingRegister[12];
Temporal[3] = MBHoldingRegister[13];
Temporal[4] = MBHoldingRegister[14];
Temporal[5] = MBHoldingRegister[15];
Temporal[6] = MBHoldingRegister[16];
Temporal[7] = MBHoldingRegister[17];
Temporal[8] = MBHoldingRegister[18];
Temporal[9] = MBHoldingRegister[19];

/// Enable Output 14
// digitalWrite(14, MBHoldingRegister[14] );

//// debug

for (int i = 0; i < 10; i++) {

Serial.print("[");
Serial.print(i);
Serial.print("] ");
Serial.print(Temporal[i]);

}
Serial.println("");

//// rutine Modbus TCP
byteFN = ByteArray[MB_TCP_FUNC];
Start = word(ByteArray[MB_TCP_REGISTER_START],ByteArray[MB_TCP_REGISTER_START+1]);
WordDataLength = word(ByteArray[MB_TCP_REGISTER_NUMBER],ByteArray[MB_TCP_REGISTER_NUMBER+1]);
}

// Handle request

switch(byteFN) {
case MB_FC_NONE:
break;

case MB_FC_READ_REGISTERS: // 03 Read Holding Registers
ByteDataLength = WordDataLength * 2;
ByteArray[5] = ByteDataLength + 3; //Number of bytes after this one.
ByteArray[8] = ByteDataLength; //Number of bytes after this one (or number of bytes of data).
for(int i = 0; i < WordDataLength; i++)
{
ByteArray[ 9 + i * 2] = highByte(MBHoldingRegister[Start + i]);
ByteArray[10 + i * 2] = lowByte(MBHoldingRegister[Start + i]);
}
MessageLength = ByteDataLength + 9;
client.write((const uint8_t *)ByteArray,MessageLength);

byteFN = MB_FC_NONE;

break;

case MB_FC_WRITE_REGISTER: // 06 Write Holding Register
MBHoldingRegister[Start] = word(ByteArray[MB_TCP_REGISTER_NUMBER],ByteArray[MB_TCP_REGISTER_NUMBER+1]);
ByteArray[5] = 6; //Number of bytes after this one.
MessageLength = 12;
client.write((const uint8_t *)ByteArray,MessageLength);
byteFN = MB_FC_NONE;
break;

case MB_FC_WRITE_MULTIPLE_REGISTERS: //16 Write Holding Registers
ByteDataLength = WordDataLength * 2;
ByteArray[5] = ByteDataLength + 3; //Number of bytes after this one.
for(int i = 0; i < WordDataLength; i++)
{
MBHoldingRegister[Start + i] = word(ByteArray[ 13 + i * 2],ByteArray[14 + i * 2]);
}
MessageLength = 12;
client.write((const uint8_t *)ByteArray,MessageLength);
byteFN = MB_FC_NONE;

break;
}
}

}

Já inclui o feedback pelo serial


#7

Excelente ideia, estou tentando o mesmo, com os módulos Esp32 Lora da Heltec. Onde posso encontrar a biblioteca ModbusIP_ESP32.h