ESP8266 DHT Messwerte werden nicht aktualisiert

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;
    }
  }
}

keine Ahnung davon einfach nur gegoogelt
schon mal hier reingeschaut?

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.