Hallo,
Ich hab einen ESP8266 der einen DHT11 auswertet und per Modbus TCP an ein Register weiter schreibt. Die Daten werden dann im Codesys weiter verarbeitet.
War gar nicht so einfach einen Code zu finden der keine Probleme beim Kommunizieren macht.
Nun aber das Eigentliche Problem:
die Werte werden nur bei einem Reset oder Neustart obwohl der Delay eingegebn wird aber auch berechnet wird. Siehe Code im Anhang.
Kann mir jemand sagen wo der Fehler liegt?
Ich hätte dasselbe auch schon auf dem ESP32 probiert klappt aber auch nicht..7
Vielen Dank vorab!
#include <ESP8266WiFi.h>
#include "DHT.h"
const char* ssid = "----";
const char* password = "----";
int ModbusTCP_port = 502;
///////////////////////DEF Output
const int DOutput1 = 5;//d5 pin board
const int DOutput2 = 4;//d6 pin board
const int DOutput3 = 14;//d7 pin board
#define DHTPIN 5 // Digital PIN D1 !!!!!!!
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);
unsigned long previousMillis = 500; // will store last time DHT was updated
const long interval = 1000; // Updates DHT readings every 10 seconds
float t = 0.0;
float h = 0.0;
float T_max = 0.0;
float T_min = 0.0;
int T_Reg = 0;
int F_Reg = 0;
//////// 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(DOutput1,OUTPUT);
pinMode(DOutput2,OUTPUT);
pinMode(DOutput3,OUTPUT);
Serial.begin(115200); ///9600
dht.begin();
WiFi.begin(ssid, password);
delay(1000);
Serial.println(".");
dht.begin();
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");
}
void loop() {
delay(1000);
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you updated the DHT values
previousMillis = currentMillis;
float newT = dht.readTemperature();
if (isnan(newT)) {
Serial.println("Failed to read from DHT sensor!");
}
else {
if (T_max < newT ) {
T_max = t;
}
if (newT < T_min ) {
T_min = newT;
}
if (T_min = 0.0) {
T_min = newT;
}
t = newT;
T_Reg = newT * 10;
//MBHoldingRegister[1] = (new_T*10);
//Serial.print("akt.Temp ");
// Serial.println(t);
// Serial.print("max Temp ");
// Serial.println(T_max);
// Serial.print("min Temp ");
//Serial.println(T_min);
//Serial.println("REGISTERWERT");
//Serial.println(T_Reg);
//Serial.println();
}
// Read Humidity
float newH = dht.readHumidity();
// if humidity read failed, don't change h value
if (isnan(newH)) {
Serial.println("Failed to read from DHT sensor!");
}
else {
h = newH;
F_Reg = newH * 10;
//Serial.print("akt.Humidity ");
//Serial.println(h);
//Serial.println();
}
}
// 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();
///// code here --- codigo aqui
///////// Holding Register [0] A [9] = 10 Holding Registers Escritura
///////// Holding Register [0] A [9] = 10 Holding Registers Writing
MBHoldingRegister[0] = currentMillis;
MBHoldingRegister[1] = T_Reg;
MBHoldingRegister[2] = F_Reg;
MBHoldingRegister[3] = random(0,12);
MBHoldingRegister[4] = random(0,12);
MBHoldingRegister[5] = random(0,12);
MBHoldingRegister[6] = random(0,12);
MBHoldingRegister[7] = random(0,12);
MBHoldingRegister[8] = random(0,12);
MBHoldingRegister[9] = random(0,12);
///////// Holding Register [10] A [19] = 10 Holding Registers Lectura
///// Holding Register [10] A [19] = 10 Holding Registers Reading
int Temporal[10];
Temporal[0] = MBHoldingRegister[0];
Temporal[1] = MBHoldingRegister[1];
Temporal[2] = MBHoldingRegister[2];
Temporal[3] = MBHoldingRegister[3];
Temporal[4] = MBHoldingRegister[4];
Temporal[5] = MBHoldingRegister[5];
Temporal[6] = MBHoldingRegister[6];
Temporal[7] = MBHoldingRegister[7];
Temporal[8] = MBHoldingRegister[8];
Temporal[9] = MBHoldingRegister[9];
/// Enable Output 14
digitalWrite (DOutput1,MBHoldingRegister[3]);
digitalWrite (DOutput2,MBHoldingRegister[4]);
digitalWrite (DOutput3,MBHoldingRegister[5]);
//// debug
for (int i = 0; i < 10; i++) {
Serial.print("[");
Serial.print(i);
Serial.print("] ");
Serial.print(Temporal[i]);
}
Serial.println("");
Serial.print("akt.Temp ");
Serial.println(t);
Serial.print("akt.Humidity ");
Serial.println(h);
Serial.println("");
//// end code - fin
//// routine 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;
}
}
}