Programm in Routinen strukturieren

Hallo,

ich habe ein Program geschrieben, welches kontinuierlich einen DHT 11 ausliest und entsprechend einer If Else Abfrage zwei Relaisausgänge schalten soll.
Jetzt ist es so, das sich ein Relais normal entsprechend der Schwellwerte HIGH/LOW schaltet, das zweite aber z.B. beim Anstieg der Temperatur erst dann schaltet, wenn der Temperaturanstieg vorbei ist - die Temperatur quasi wieder fällt und eben nicht, wenn die Schwelle mit noch steigender Temperatur überschritten wird. Ich habe den Eindruck, als ob das Programm die Ausführung des Schaltbefehls gemäß der Schwelle ignoriert und erst auf einen Art Flankenwechsel wartet?! Wie kann ich diese einzelnen Routinen so strukturieren, das diese autonom in jedem Zyklus sicher bearbeitet werden?

Da Du hier keine Hellseher finden wirst, musst Du uns schon den Code zeigen.
Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
Dann ist er auch auf mobilen Geräten besser lesbar.

Gruß Tommy

Grundsätzlich sollte das funktionieren. Was du meinst sind Funktionen, auch die Übersicht des Sketches verbessern.
Allerdings ist, wie Tommy schon schrieb, ohne deinen Sketch, eine weitere Hilfe schwer.

(deleted)

Dicsoft:
Jetzt ist es so, das sich ein Relais normal entsprechend der Schwellwerte HIGH/LOW schaltet, das zweite aber z.B. beim Anstieg der Temperatur erst dann schaltet, wenn der Temperaturanstieg vorbei ist - die Temperatur quasi wieder fällt und eben

Deine zweite Schaltschwelle ist falsch deklariert oder abhängig von der ersten.

Zeige Deinen Sketch - Du siehst, hier lesen udn kommentieren gaaaanz viele. Das ist nicht immer so.
Wenn der Sketch hier ist, hast Du ruckzuck Deine passende Antwort.

Vielen Dank...werd ich direkt morgen machen, wenn ich wieder Zugriff auf das Programm habe!

Hallo,
anbei der vollständige Code…

// Klappensteuerung über einen DHT 11 (Feuchte und Temperatur Sensor)
// Smoothing des DHT 11 Sensors über x Messwerte
// Relaisausgang über definierbare Feuchte
// Relaisausgang über definierbare Temperatur

// Libraries 
// - DHT Sensor
// - Adafruit Unified Sensor
// - Servo


#include <DHT.h>
#include <Servo.h>

#define DHTPIN 2                   // DHT 11 Sensor Pin D2
#define DHTTYPE DHT11              // Type DHT 11
#define RelayHPin 4                // Relay Pin D4
#define RelayTPin 5                // Relay Pin D5
#define ServoPin 9                 // Servo PWM out D9

const int numReadingsH = 10000;    // no of readings for the smoothing /akt 10000
const int numReadingsT = 100;      // no of readings for the smoothing   /akt 100
const int numReadingsP = 3000;     // no of readings for the smoothing   /akt 3000

int readingsH[numReadingsH];       // the readings from the dig input Huminity
int readingsT[numReadingsT];       // the readings from the dig input Temperature
int readingsP[numReadingsP];       // the readings from the analog input Poti
int readIndexH = 0;                // the index of the current reading
int readIndexT = 0;                // the index of the current reading
int readIndexP = 0;                // the index of the current reading
int totalH = 0;                    // the running total
int totalT = 0;                    // the running total
int totalP = 0;                    // the running total
int averageH = 0;                  // the average
int averageT = 0;                  // the average
int averageP = 0;                  // the average

int relayH = 4;                    // Relay on Pin D4
int relayT = 5;                    // Relay on Pin D5
int analogPin = A0;                // potentiometer wiper (middle terminal) connected to analog pin 0
                                   // outside leads to ground and +5V
int val = 0;                       // variable to store the value read

Servo mainServo;
int position = 0;
int previousPosition;

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  mainServo.attach(ServoPin);
  pinMode(relayH, OUTPUT);         // Pin for relay module set as OUTPUT
  pinMode(relayT, OUTPUT);         // Pin for relay module set as OUTPUT
  
  Serial.begin(9600);
  dht.begin();

  // initialize all the readings to 0 for smoothing:
  for (int thisReadingH = 0; thisReadingH < numReadingsH; thisReadingH++) 
    readingsH[thisReadingH] = 0;
  for (int thisReadingT = 0; thisReadingT < numReadingsT; thisReadingT++) 
    readingsT[thisReadingT] = 0;
  for (int thisReadingP = 0; thisReadingP < numReadingsP; thisReadingP++) 
    readingsP[thisReadingP] = 0;
}

void loop() {

  // ***************** Potentiometer reading *****************
  // val = analogRead(analogPin);  // read the input pin
  int setpoint = map(averageP, 0, 1024, 0, 50); // mapping from 0-1024 to 0-100
  
  // ****************** DHT sensor reading ********************

  // Reading temperature or humidity takes about 250 milliseconds!
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
 

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // **************** DHT sensor value smoothing for Humidity and Temperature + Poti *****************
  // subtract the last reading:
  totalH = totalH - readingsH[readIndexH];
  totalT = totalT - readingsT[readIndexT];
  totalP = totalP - readingsP[readIndexP];
  // read from the sensor:
  readingsH[readIndexH] = dht.readHumidity();
  readingsT[readIndexT] = dht.readTemperature();
  readingsP[readIndexP] = analogRead(analogPin);
  // add the reading to the total:
  totalH = totalH + readingsH[readIndexH];
  totalT = totalT + readingsT[readIndexT];
  totalP = totalP + readingsP[readIndexP];
  // advance to the next position in the array:
  readIndexH = readIndexH + 1;
  readIndexT = readIndexT + 1;
  readIndexP = readIndexP + 1;

  // if we're at the end of the array... Humindity
  if (readIndexH >= numReadingsH) {
    // ...wrap around to the beginning:
    readIndexH = 0;
  }

   // if we're at the end of the array... Temperature
  if (readIndexT >= numReadingsT) {
    // ...wrap around to the beginning:
    readIndexT = 0;
  }

   // if we're at the end of the array... Poti
  if (readIndexP >= numReadingsP) {
    // ...wrap around to the beginning:
    readIndexP = 0;
  }

  // calculate the average:
  averageH = totalH / numReadingsH;
  averageT = totalT / numReadingsT;
  averageP = totalP / numReadingsP;


  // ******************* Humidity and Temp values + Offset ****************
    float hOffset = averageH + 0.0;
    float tOffset = averageT + 0.0;

  // ******************* Humidity value converting per degree *************
  
  // Converting humidity to degree
    float hScale = (hOffset / 100) * 100;   // Servoposition in degrees (org 80)

  // ******************* Humidity scale to servo *************

  // This maps humidity to degrees open for the flap + Operator setpoint
     //int position = (hScale + setpoint);
   int position = map(hScale + setpoint, 30, 100, 0, 180); // mapping from 30-100° to 0-180°
   if(previousPosition != position){
     mainServo.write(position);
  // Relay ON/OFF by Servo position
   if (position < 100){                 // Relay OFF if Servoposition < setpoint
     digitalWrite(relayH, LOW);         // Relay OFF 
   }    
   else if (position > 110){            // Relay ON if Servoposition > setpoint
     digitalWrite(relayH, HIGH);        // Relay ON
   }
   
// Relay ON/OFF by Temperature
   if (tOffset < 28){                   // Relay OFF if Temperature bigger
     digitalWrite(relayT, HIGH);         // Relay OFF 
   }
   else if (tOffset > 27){              // Relay ON if Temperature smaler
     digitalWrite(relayT, LOW);        // Relay ON
   }

}
    previousPosition = position;
  
  Serial.print(F("Sens1Hum: "));
  Serial.print(h);
  Serial.print(F("%  Sens1Temp: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(F("Hum1Off: "));
  Serial.print(hOffset);
  Serial.print(F("%  Temp1Off: "));
  Serial.print(tOffset);
  Serial.print(F("°C "));
  Serial.print(F("PotiSet: "));
  Serial.println(setpoint);
  Serial.print(F("Hum1ScaleSet: "));
  Serial.print(hScale);
  Serial.print(F("°  ServoPosAct: "));
  Serial.print(position);
  Serial.print(F("° "));
  Serial.print(F("Hum1Ave: "));
  Serial.print(averageH);
  Serial.print(F("% "));
  Serial.print(F("Temp1Ave: "));
  Serial.print(averageT);
  Serial.print(F("°C "));
}

(deleted)

Hallo Peter,

hier skaliere ich mein Poti für die Sollwerteinstellung.
Habe den Bereich etwas kleiner eingestellt, aber den Kommentar nicht angepasst!

Das Relais was mir Sorge bereitet folgt einem Temperaturwert, welcher auch über ein Smoothing
geglättet wird, aber mit der Anweisung oben nix zutun hat.

Hi,
heute leider nicht so viel Zeit um komplett den Code zu überblicken, aber

Dicsoft:

#define DHTPIN 2                   // DHT 11 Sensor Pin D2

#define DHTTYPE DHT11              // Type DHT 11
#define RelayHPin 4                // Relay Pin D4
#define RelayTPin 5                // Relay Pin D5
#define ServoPin 9                 // Servo PWM out D9

const int numReadingsH = 10000;    // no of readings for the smoothing /akt 10000
const int numReadingsT = 100;      // no of readings for the smoothing   /akt 100
const int numReadingsP = 3000;     // no of readings for the smoothing   /akt 3000

int readingsH[numReadingsH];       // the readings from the dig input Huminity
int readingsT[numReadingsT];       // the readings from the dig input Temperature
int readingsP[numReadingsP];       // the readings from the analog input Poti
int readIndexH = 0;                // the index of the current reading
int readIndexT = 0;                // the index of the current reading
int readIndexP = 0;                // the index of the current reading

Schreibe nicht hinter was Du da vorne zu stehen hast, sondern zuwas das gut ist.
Im Code später ist da teilweise raten angesagt, was da eigentlich passieren soll.

}
    previousPosition = position;

Tausche die beiden Zeilen mal gegeneinander (also die Zuweisung vor dem Ende der Funktion)

Hallo my_xy_projekt,

tatsächlich habe ich diesen Tausch (also die Zuweisung vor dem Ende der Funktion) bereits vor Deinem Post vollzogen und jetzt funktioniert es genauso wie es soll! :smiley:

Lasst mich doch jetzt noch verstehen, wie genau dieser Effekt zustande gekommen ist bzw. was
im Programmablauf jetzt anders ist.
Mein Verständnis ist, dass das Programm über die

previousPosition = position; in einer Art Schleife gefangen war und erst bei Richtungsänderung der Messwerte diese verlassen hat?!

Bin für jede Erleuchtung dankbar!

Vielen Dank an alle,
Dirk

const int numReadingsH = 10000;    // no of readings for the smoothing 

...
int readingsH[numReadingsH];      // the readings from the dig input Humidity

Das geht nicht auf jedem Arduino. Sollte aber eine Fehlermeldung geben, da readingsH eine Globale Variable ist.