Analogwert speichern und später wieder verwenden?

International Deutsch
1

Hi Leute!

Ich hab da mal ne Frage....und alles Suchen scheint nicht zu helfen...Problem ist folgendes:
Ich möchte einen Analogwert speichern und später wieder abrufen, bzw verwenden.
in etwa so:
Am Arduino hängt ein Lüfter und ein Heizelement, beide über ein Relais gesteuert.
Ich habe nun z.B. eine Temperatur von 43,8°C erreicht, was mir das ebenfalls angeschlossene Display
auch anzeigt.
Soweit alles dut, und funktionsfähig....
Jetzt möchte ich diese Temperatur per 5 sekündigem Knopfdruck speichern (SD, oder EEPROM), und zusätzlich eine weitere Temperatur auf einem zweiten knopf in gleicher Weise z.b. 31,4°C
Und nun per kurzem Druck auf den jeweiligen Knopf den Arduino dazu bringen den entprechenden gespeicherten Wert per Lüfter oder Heizelement herzustellen und zu halten.

...ich hoffe man versteht es, und mir kann jemand helfen... :slight_smile:

Dankscheee!

2

müssen die Werte auch bei Stromausfall erhalten bleiben?

3

Ja. deshalb die Idee das auf ner SD zu speichern.

4

Ich verstehe das (glaube ich)...
Aber wie soll man dir helfen?
Was ist dein Problem?

5

Ich kriegs nich hin! :smiley:
wie kann ich dem Ding sagen, dass er den Wert spaichert wenn jemand 5sec den Knopf drückt, und den Wert wieder abruft wenn der Knopf nur kurz gedrückt wird?

6

Eine typische Aufgabe für einen einfachen endlichen Automaten.
Das Thema hatten wir hier schon (sehr) häufig......

"Tasten entprellen" ist auch ein wichtiges Stichwort für dich.

7

Über diesen Thread bin ich auch schon gestolpert, beantwortet mir aber nicht die Frage wie ich mit nur einem
Taster einen Wert speichern, und zu beliebigem Zeitpunkt wieder abrufen kann.

8

Zustand1: Warten.
Zustand2: Entprellen.
Zustand3: Temperatur aktivieren oder speichern.

Nur so als Anregung.

const byte taster = 12;
unsigned long aktMillis;
unsigned long prevMillis;
unsigned int intervall;
bool taster_status;
bool prevtaster;
enum Zustaende {WARTEN, ENTPRELLEN, TEMPERATUR};
byte zustand = WARTEN;

void setup() {
  Serial.begin(9600);
  pinMode (taster, INPUT_PULLUP);    // Signal eingang
  prevtaster = digitalRead(taster);
  Serial.println("Programmanfang");
}

void loop() {
  taster_status = digitalRead(taster) && !prevtaster;  // positive Flanke
  prevtaster = digitalRead(taster);
  switch (zustand) {
    case WARTEN:
      if (taster_status) {
        prevMillis = millis();
        intervall = 50;
        Serial.println("Entprellen starten");
        zustand = ENTPRELLEN;
      }
      break;
    case ENTPRELLEN:
      if (millis() - prevMillis >= intervall) {
        prevMillis = millis();
        intervall = 5000;
        Serial.println("Entprellen beendet");
        zustand = TEMPERATUR;
      }
      break;
    case TEMPERATUR:
      if (digitalRead(taster) == LOW) {
        intervall = 0;
        Serial.println("Temperatur aktivieren");
        zustand = WARTEN;
      } else if (millis() - prevMillis >= intervall) {
        Serial.println("Temperatur speichern");
        zustand = WARTEN;
      }
      break;
  }
}
9

Zum speichern kannst du das EEPROM nehmen. Das kann pro Slot Werte zwischen 0 und 255 aufnehmen.
Wenn dir die Kommastelle wichtig ist, dann nimmst du einfach 2 Slots und speicherst in dem einen den Dezimalwert und im andern dann den Kommawert.

Prinzipiell würde ich mit den Temperaturen sowieso normalisiert rechnen, also die Kommastelle einfach rausmultiplizieren. Die angesprochenen 43,8° wären dann einfach der Wert 438. Damit lässt sich deutlich einfacher hantieren.

Den Taster realisierst du, indem du den Zustandswechsel erfasst (achtung Pseudocode)

boolean bekannterZustand;
unsigned long letzterZustandsWechselMillis;

void loop() {
  boolean aktuellerZustand = digitalRead(...);

  if (aktuellerZustand != bekannterZustand) {
    //Zustandswechsel ist jetzt erfolgt aber wir müssen noch entprellen
    unsigned long aktuelleMillis = millis();
    int zeitIntervall = aktuelleMillis - letzterZustandsWechselMillis;
    if (zeitIntervall < 50) {
      return; //das ist die Entprellung. Erst wenn der geänderte Zustand nach 50ms immer noch erkannt wird, gilt er auch (den Wert kann man wenn man sicher gehen will noch etwas erhöhen)
    }

    letzterZustandsWechselMillis = aktuelleMillis;
    bekannterZustand = aktuellerZustand;

    if(!aktuellerZustand) {
      //Taste wurde losgelassen, jetzt kommts drauf an wie lange gedrückt wurde
      if(zeitIntervall > 5000) {
        //länger als 5sec, also Speichern
        speichereTemperatur();
      } else {
        aktiviereGepseicherteTemperatur();
      }
    }
  }
}

Das ist es schonmal vom Prinzip und sollte dazu führen, dass ein Betätigen des Tasters bei über 5sec speichereTemperatur() aufruft und bei kürzerem drücken aktiviereGespeicherteTemperatur()

Du musst natürlich den Zustand im Setup noch initialisieren und den code so sauber machen, dass er auch kompiliert (das ist jetzt ja nur mal so hingetippert und könnte noch Fehler enthalten, ich kanns ja nicht ausprobieren)

10

Das Entprellen des Schalters ist auch Hardwaremässig möglich.
Einfach einen 10kohm Pullup Widerstand und paralell dazu einen 100nf.

Funktioniert bei mir optimal so.
Wenn die Anzahl der Schalter größer wird, ist die Softwarelösung optimaler.
Weniger Hardwareaufwand.

11