Zeitverzögerung will nicht

[C-Anfänger (Gast)]

Hallo,

ich probiere gerade ein Relais das ich in bestimmten Fällen anziehen 
lasse, verzögert wieder abfallen zu lassen. Doch irgendwie möchte das 
nicht ganz so wie ich das möchte. Vielleicht findet jemand meinen 
Fehler. Auszug aus dem Code:

set_bit(RELAIS_port,RELAIS_pin);
          unsigned char end = 0;
          unsigned int ns_on = 0;
          unsigned int ms_on = 0;
          unsigned char s_on = 0;
          unsigned char m_on = 0;
          while (end == 0) {
            if (ns_on < 1000) {
              ns_on++;
              _delay_us(1);
              if (bit_is_set(START_MODE_port,START_MODE_pin)) {end = 1;};
            } else {
              ns_on = 0;
              if (ms_on > mseconds_on*10) {
                ms_on--;
              } else {
                ms_on = 999;
                if (s_on > seconds_on) {
                  s_on--;
                } else {
                  s_on = 59;
                  if (m_on > minutes_on) {
                    m_on--;
                  } else {
                    end = 1;
                  }
                }
              }
            }
          }
          clear_bit(RELAIS_port,RELAIS_pin);

mseconds_on, seconds_on, minutes_on ist die Zeit die er warten soll, bis 
das Relais wieder abfallen soll. Dabei wird die so angezeigt: 0;0;0 Die 
Millisekunden sind hierbei nur ein Zehntel. Wenn in der Variable 1 ist, 
dann sind dies 10ms.

Doch irgendwie möchte das nicht wie ich will. Ich habe 0;2;0 
eingestellt, also 2 Sekunden doch das Relais ist weniger als eine 
Sekunde angezogen.

Vielleicht findet jemand den Fehler. Danke schonmal.

[Sascha W. (sascha-w)]

dein ganzer Ansatz passt so nicht!
1. deine Zählvariablen "xx_on" müssen beim Rückwärtszählen mit dem 
Maximalwert initialisiert werden
2. wenn du z.B. 5min 30sec übergibst, dann zähen deine Sekunden immer 
nur von 59 bis 31, und dann ist schon eine Minute um

benutz einfach nur eine Variable die die Zeit *10ms angibt, und die 
zählst du alle 10ms runter bis null und gut

Sascha

[C-Anfänger (Gast)]

Sascha Weber schrieb:
> benutz einfach nur eine Variable die die Zeit *10ms angibt, und die
> zählst du alle 10ms runter bis null und gut

dann muss ich davor doch alles in ms umrechnen oder?
weil ich lese meine mseconds_on, seconds_on, minutes_on aus dem EEPROM 
und deswegen hab ich 3 Variablen

[Sascha W. (sascha-w)]

das ist doch so aufwendig nun auch wieder nicht! Oder ?

sonst muss die die Schleifen in etwas so aufbauen ...

;init
unsigned int ms_on = 0;
unsigned char s_on = 0;
unsigned char m_on = 0;

;..- jede ms
ms_on++;
if (ms_on>999) {
  ms_on=0;
  s_on++;
  if (s_on>59) {
    s_on=0;
    m_on++;
  }
}
if (ms_on==mseconds_on && s_on==seconds_on && m_on==minutes_on) {
  end=1;
}

Sascha

[C-Anfänger (Gast)]

Also ich hab es nun so:

          unsigned char end = 0;
          unsigned int ns_on = 0;
          unsigned int ms_on = 0;
          unsigned char s_on = 0;
          unsigned char m_on = 0;
          while (end == 0) {
            if (ns_on < 1000) {
              ns_on++;
              _delay_us(1);
              if (bit_is_set(START_MODE_port,START_MODE_pin)) {end = 1;};
            } else {
              if (ms_on < 1000) {
                ms_on++;
              } else {
                ms_on = 0;
                if (s_on < 60) {
                  s_on++;
                } else {
                  s_on = 0;
                  if (m_on < 60) {
                    m_on++;
                  }
                }
              }
            }
            if (ms_on == (mseconds_on*10) && s_on == seconds_on && m_on == minutes_on) {
              end = 1;
            }
          }

Aber es ist keine Änderung in Sicht d.h. es ist sind nicht die Sekunden, 
die ich eingestellt habe.

[Sascha W. (sascha-w)]

ns_on sollte beim erreichen von 1000 auch wieder auf 0 gestellt werden!
Sonst dauern die ms anschließend nur noch µs.

Sascha

[Peter D. (peda)]

Für eine Zeitverzögerung kann ich Dir das hier empfehlen:

Beitrag "Wartezeiten effektiv (Scheduler)"

Dann kannst Du das auch für mehrere Relais machen.


Peter

[C-Anfänger (Gast)]

Also ich habs nun rausbekommen. Ich hab dabei nur was komisches 
festgestellt. Ich habe ms_on nur bis 500 zählen lassen? komisch.... Hier 
nur der funktionierende:

          unsigned char end = 0;
          unsigned int ns_on = 0;
          unsigned int ms_on = 0;
          unsigned char s_on = 0;
          unsigned char m_on = 0;
          while (end == 0) {
            if (ns_on < 1000) {
              ns_on++;
              _delay_us(1);
              if (bit_is_set(START_MODE_port,START_MODE_pin)) {end = 1;};
            } else {
              ns_on = 0;
              if (ms_on < 500) {
                ms_on++;
              } else {
                ms_on = 0;
                if (s_on < 60) {
                  s_on++;
                } else {
                  s_on = 0;
                  if (m_on < 60) {
                    m_on++;
                  }
                }
              }
            }
            if (ms_on == (mseconds_on) && s_on == seconds_on && m_on == minutes_on) {
              end = 1;
            }
          }

[Sascha W. (sascha-w)]

Wie schnell ist dein AVR getaktet? Evl. verursacht der Overhead um 
delay_us(1) schon so viel Zeit das sich die Ausführungsdauer dort 
verdoppelt.

Wenn du die Zeiten im ms-Bereich einstellen willst, wird die einzig 
brauchbare Lösung die Verwendung eines Timers werden. Damit bekommst du 
eine saubere Zeitbasis von 1ms, und dein AVR kann nebenbei auch noch was 
anderes machen.

Sascha

[C-Anfänger (Gast)]

Mein AVR ist bei 16 Mhz getaktet und ich nutze schon ein Timer im 
CTC-Mode um das andere Intervall zu takten. Aber bis jetzt funktioniert 
alles und dann ist gut. Fehlen nur noch 2 Buchsen und mein Gerät ist 
fertig. ;)

[Sascha W. (sascha-w)]

nun ja bei 16MHz vertut die delay_us(1) genau 16 Takte, dann haben wir 
die Loop mit 8-Bit-Vergleich, den ns_on 16-Bit-Vergleich, eine 
16-Bit-Addition, den Bit-Test und ein paar Jump's. Kein Wunder das da 
noch mal die selbe Anzahl an Takten zustandekommt. Und dann immer mal 
noch ein Interrupt?!

Vielleicht kannst du den Takt ja von deinem vorhandenen Timer ableiten?
Wenn du das nicht willst, dann lasse die ns_on-Schleife nur bis 500 
laufen, sonst kannst du ja auch nur die ms-Verzögerungszeiten im Bereich 
von 0..500 einstellen.

Sascha