Hysterese mit zwei Temperatursensoren STM32

[Chris (Gast)]

Hallo zusammen,

für meine Lüftersteuerung verwende ich den Temperaturchip EMC1428, 
dieser besitzt zwei Temperaturwerte. Einmal die interne Messung und eine 
externe Messung der Temperatur.

Ich möchte diese zwei Werte nun mit einer Hysterese verknüpfen und in 
Abhängigkeit diese Temperaturwerte meine Lüfter mit unterschiedlichen 
PWM Signalen versorgen.
Da dies mein erstes eigenes STM32 Projekt ist habe ich leider noch nicht 
sehr viel Erfahrung und entschuldige mich für die dummen Fragen.

Weiß von euch jemand wie ich das am besten lösen kann ?


Vielen Dank schon mal für eure Hilfe.


Viele Grüße,

Chris

[Rainer U. (r-u)]

Chris schrieb:
> Weiß von euch jemand wie ich das am besten lösen kann ?

Kleine Brötchen backen. Die Basics lernen. Programmieren lernen durch 
ausprobieren und nachmachen. Dazu die Aufgabe in kleine, beherrschbare 
Teilaufgaben zerlegen (Temeratur messen und ausgeben, einen Lüfter an- 
und ausschalten, einen Lüfter per PWM ansteuern). Dafür gibt es hier 
Beispiele. Wenn Du das drauf hast, fällt Dir das mit der Hysterese 
leicht.

[Thomas E. (picalic)]

Chris schrieb:
> Ich möchte diese zwei Werte nun mit einer Hysterese verknüpfen und in
> Abhängigkeit diese Temperaturwerte meine Lüfter mit unterschiedlichen
> PWM Signalen versorgen.

Hallo Chris,

wenn die Lüfter durch PWM "analog" (also nicht bloss "an" und "aus") 
gesteuert werden, wozu dann eine Hysterese? Evtl. kann ich mir noch 
vorstellen, daß ein Minimalwert definiert wird, damit die Lüfter nicht 
mit so zu kleinen PWM-Werten angesteuert werden, bei denen sie nicht 
mehr zuverlässig laufen.

[Chris (Gast)]

Hallo,

Danke für die schnellen Antworten.

Ich habe bereits die Temperatur erfolgreich ausgelesen(Tempsensor via 
I2C ausgelesen) und steuere meine Lüfter bereits mit einem 2 Punkte 
Regler an dh. ich schalte meine Lüfter zur Zeit bei einer gewissen 
Temperatur ein (mit einem 50% PWM Signal) ein und unter dieser 
Schwelltemperatur wieder aus.

Jetzt möchte ich meine Regelung verbessern indem ich bei verschiedenen 
Temperaturschwellpunkten meine Lüfter mit einem unterschiedlichen PWM 
Signal ansteuere. Und um zu vermeiden dass die Lüfter bei kleinen 
Temperaturschwankungen um die Schwelltemperatur "zittern" wollte ich 
eine Empfindlichkeit der Lüfter von +-5 Grad einbauen.

Und meine Frage wäre jetzt gewesen wie ich das am besten realisieren 
kann ?
Sorry für die schlechte Beschreibung am Anfang :)


Grüße,

Chris

[Hack S. (hackspider)]

Hi Chris,

Dieses Vorhaben ist relativ einfach umzusetzen:

Als erstes malst du dir eine Kurve auf. Auf der X-Achse schreibst du dir 
die Temperaturwerte auf und auf der Y-Achse dann die % die dein Lüfter 
bei dieser Temperatur steuern soll.

Dann wählst du dir soviele Stützstellen aus um diese Kurve mit 
angemessenen Fehler zu repräsentieren. Diese Stützstellen packst du dann 
in ein 2D Arrary:

uint16 TempConfig[COUNT_OF_PARAMETER][COUNT_OF_PARAMETER]; //Temp in 0.1 Grad C; PWM Value 0-255
TempConfig[0][0] = 0;   //Bei 0 Grad -> PWM 100
TempConfig[0][1] = 100;
TempConfig[1][0] = 100; //Bei 10 Grad -> PWM 125
TempConfig[1][1] = 125;
TempConfig[2][0] = 200; //Bei 20 Grad -> PWM 150
TempConfig[2][1] = 150;
TempConfig[3][0] = 300; //Bei 30 Grad -> PWM 175
TempConfig[3][1] = 175;
...

Wenn du jetzt eine neue Messung machst, dann gehst du den ersten Wert 
des Arrays durch und schaust wo die Temperatur dazwischen liegt. Z.B. 
15Grad liegt zwischen dem Stützpunkt 100 und 200 (10 und 20Grad). Jetzt 
musst du nur noch dazwischen linear interpolieren: 15Grad liegt 50% 
zwischen den Stützpunkten 100 und 200 also einfach die werte der beiden 
Stützpunkte addieren und mal 50% rechnen: (125+150) * 0.5 = 137(.5) als 
PWM value an den Lüfter senden.

Ich hoffe, dass hilft dir bei der Implementierung weiter ;)

Viele Grüße

[Haas (Gast)]

Meinst du sowas?

if (temperature > max_temperature)
{
    pwm_on();
} else if (temperature < min_temperature)
{
    pwm_off();
}

[Eric B. (beric)]

Hack S. schrieb:
> uint16 TempConfig[COUNT_OF_PARAMETER][COUNT_OF_PARAMETER]; //Temp in 0.1
> Grad C; PWM Value 0-255
> TempConfig[0][0] = 0;   //Bei 0 Grad -> PWM 100
> TempConfig[0][1] = 100;
> TempConfig[1][0] = 100; //Bei 10 Grad -> PWM 125
> TempConfig[1][1] = 125;
> TempConfig[2][0] = 200; //Bei 20 Grad -> PWM 150
> TempConfig[2][1] = 150;
> TempConfig[3][0] = 300; //Bei 30 Grad -> PWM 175
> TempConfig[3][1] = 175;
> ...

*Pfui!* Für sowas sind doch structs oder classes erfunden worden!
Und wenn der OP das interpolieren weglassen möchte, dafür aber eine 
hysterese haben, dann würde ich das etwa so aufbauen:

typedef struct 
{
  uint8_t temp_lo;  // Lower and upper temperature bound for 
  uint8_t temp_hi;  // this band
  uint8_t pwm;      // pwm duty in %
} TempConfig;

#define NR_OF_CFGS xyz

const TempConfig cfg[NR_OF_CFGS] =
{
  {   0, 15,  0 }, // between 0 and 15 degrees: Off
  {  10, 25, 25 }, // between 10 and 25 degrees: 25% duty
 ...
};

Wenn jetzt die Temperatur von 0 auf 20° hochsteigt, soll erst bei temp > 
15° die 25% PWM eingestaltet werden. Umgekehrt soll, die PWM erst 
ausgeschaltet werden wenn die temp unter 10&° fällt.

static uint8_t current_cfg = 0;

void set_pwm(uint8_t new_temp)
{
  // search up for upper limit
  while((new_temp > cfg[current_cfg].temp_hi)
      && (current_cfg < NR_OF_CFGS))
  {
     current_cfg ++;
  }

  // search down for lower limit
  while((new_temp < cfg[current_cfg].temp_lo)
      && (current_cfg > 0))
  {
     current_cfg --;
  }

  // set pwm for the found temperature band
  set_pwm_output(cfg[current_cfg].pwm);
}

[Thomas E. (picalic)]

Chris schrieb:
> Und um zu vermeiden dass die Lüfter bei kleinen
> Temperaturschwankungen um die Schwelltemperatur "zittern" wollte ich
> eine Empfindlichkeit der Lüfter von +-5 Grad einbauen.

Das kannst Du z.B. realisieren, indem Du einen Wert, der den 5 Grad 
entspricht, auf den Messwert vom Fühler addierst, wenn der Lüfter 
eingeschaltet ist.

[Chris (Gast)]

Haas schrieb:
> Meinst du sowas?
>
> if (temperature > max_temperature)
> {
>     pwm_on();
> } else if (temperature < min_temperature)
> {
>     pwm_off();
> }

So etwas habe ich bereits implementiert leider kann ich hier das PWM 
Signal nicht genau genug in Abhängigkeit der Temperatur einstellen.

Viele Grüße

[Chris (Gast)]

Eric B. schrieb:

> Wenn jetzt die Temperatur von 0 auf 20° hochsteigt, soll erst bei temp >
> 15° die 25% PWM eingestaltet werden. Umgekehrt soll, die PWM erst
> ausgeschaltet werden wenn die temp unter 10&° fällt.static uint8_t
> current_cfg = 0;
>
> void set_pwm(uint8_t new_temp)
> {
>   // search up for upper limit
>   while((new_temp > cfg[current_cfg].temp_hi)
>       && (current_cfg < NR_OF_CFGS))
>   {
>      current_cfg ++;
>   }
>
>   // search down for lower limit
>   while((new_temp < cfg[current_cfg].temp_lo)
>       && (current_cfg > 0))
>   {
>      current_cfg --;
>   }
>
>   // set pwm for the found temperature band
>   set_pwm_output(cfg[current_cfg].pwm);
> }

Vielen Dank für die ausführliche Antwort :)
Ich werde es mal probieren ob ich es so ungefair bei mir implentieren 
kann.

Viele Grüße