Wie am besten pulsierende Eingänge abfragen/auswerten?

[Pascal H. (0skill)]

Hallo,

Hab in der Schule gerade ein kleines Projekt bekommen.
Nun habe ich folgendes Problem
Ich hab bei mehreren Eingängen am µC Verschiedene Zustände die 
ausgewertet werden müssten.
Folgende Zustände sind möglich:
Low, High, Blinken (ca. 1Hz), Blitzen (ca. 2Hz)

Eine Delay Funktion geht schon mal gar nicht da sie zu viel Zeit und 
Ressourcen verbraten würde

Eine andere Möglichkeit die mir gekommen wäre ist das ganze via 
Interrupt zu realisieren
Hätte ich mir ungefähr so vorgestellt:
Pseudo Code:

void ISR_Input1(int i, count_Timer)
{

count_Timer = timer2
i++

if(i==10)
{
global_Var_Auswertung1= count_Timer/10
i= 0
}
}

Da die Zustände an den Eingängen verschiedene Tests darstellen welche 
bis zu 1,5h dauern können und parallel laufen (können) ist mir nicht 
wirklich klar wie man das am besten lösen könnte
da ich sonst ja 10 Interrupts brauchen würde und sich diese dann 
gegenseitig stören würden bzw. Frage ich mich wie würde das dann mit dem 
restlichen Code aussehen
Ob dafür noch genügend Ressourcen übrig bleiben?

Wie kann man das elegant lösen?
Bin für jede Hilfe dankbar

[Erich (Gast)]

Du brauchst EINEN zyklischen Timer-Interrupt, z.B. alle 10ms.
In der zugehörigen INT-Routine fragst du alle deine Eingänge ab und 
bildest für jeden Eingang eine Zustandsvariable.
Zuerst musst du aber auf kariertem Papier aufzeichnen, wieviele 
Möglichkeiten und Zustandübergänge es geben kann, anhand deiner 4 (?) 
unterschiedlichen Eingangstypen.
Und du musst festlegen nach welcher jeweiligen Zeit der "andere" Zustand 
erkannt werden soll bzw. kann.
Gruss

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Pascal H. schrieb:
> wie man das am besten lösen könnte da ich sonst ja 10 Interrupts
> brauchen würde
Das Ganze ist so schnarchlangsam, dass du nur 1 Interrupt und 10 Zähler 
brauchst. Der Interrupt wird jede Millisekunde aufgerufen und setzt ein 
msFlag. Dieses msFlag wird in der Hauptschleife abgefragt, und die 
Zähler hochgezählt. Dann wird ebenfalls jede ms eine Flankenerkennung 
auf die Eingänge gemacht und bei Bedarf die Zähler abgespeichert. 
Fertig. Fast.

Denn jetzt müssen nur noch die gespeicherten Zählerstände ausgewertet 
werden...

volatile char msFlag;

ISR_Input1() // jede Millisekunde
{
  msFlag++;
}

main() {

  while(1) {

     ...

     if (msFlag) {
       msFlag--;

       Cnt1++;
       if (In1 != In1Alt) {
          if (In1) { // steigende Flanke
             Puls1 = Cnt1;
             Cnt1 = 0;
          }
          In1Alt= In1;
       }

       Cnt2++;
       if (In2 != In2Alt) {
          if (In2) { // steigende Flanke
             Puls2 = Cnt2;
             Cnt2 = 0;
          }
          In2Alt = In2;
       }

       .....

       Cnt10++;
       if (In10 != In10Alt) {
          if (In10) { // steigende Flanke
             Puls10 = Cnt10;
             Cnt10 = 0;
          }
          In10Alt = In10;
       }

     } // msFLag
  } // while(1)
}

Eines ist klar: auf jeden Fall wirst du (ohne tiefgehende Erfahrung!!) 
niemals 10 Interrupts sicher und stabil zum Laufen bringen.

Erich schrieb:
> In der zugehörigen INT-Routine fragst du alle deine Eingänge ab und
> bildest für jeden Eingang eine Zustandsvariable.
Ich halte es so:
1. Ein Interrupt ist immer möglichst kurz.
2. Die Hauptschleife ist immer möglichst schnell.
3. Jede Abweichung davon muss begründet werden.

[Ralf G. (ralg)]

Sieh' dir mal den Pin-Change-Interrupt an.
-> Pegel merken, Zeitstempel dazu -> Zuordnung der Zustände

[Pascal H. (0skill)]

jetzt ist mir das ganze klar

Danke

[Udo S. (urschmitt)]

Pascal H. schrieb:
> Ich hab bei mehreren Eingängen am µC Verschiedene Zustände die
> ausgewertet werden müssten.

Was noch niemand angesprochen hat: Woher kommen die Zustände? Sind das 
mechanische Schaltkontakte, dann können die prellen.
In diesem Fall bedeutet das du musst sie entprellen, sonst kann es sein, 
daß du statt einer tatsächlichen Zustandsänderung das Prellen als 
mehrere kurz hintereinander erfasst.

[Frank E. (Firma: Q3) (qualidat)]

Ich will's auch mal mit einem anders bzw. abstrakter formulierten Ansatz 
versuchen. Du benötigst quasi zwei Auswertungsebenen.

Ebene 1: Eine z.B. per Interrupt zyklisch laufende Routine, die pro 
Eingang feststelt:

a) wie oft hat sich das Signal seit dem letzten Zyklus geändert
b) welches ist der aktuelle Zustand (0 oder 1)


Ebene 2: Du triffst anhand der Informationen aus Ebene 1 (Anzahl der 
Änderungen, aktuelle Wert) die passende Entscheidung

Muss man nur noch programmieren ...

[Conny G. (conny_g)]

Das mit einem Timer und dem Starten/stoppen von Countern pro Eingang 
würde ja schon erwähnt.
Jetzt kannst jeden Eingang als State Machine betrachten:
- anfangs ist der Eingang Low, Timer für de Eingang wird gestartet, 
Ststus=Low
- wenn er nach 1000 ms-Ticks (evtl mit Toleranz) auf High geht, könntest 
Du den ersten Teil eines Blinkens haben, Status=BlinkHigh
- wenn er nach weiteren 1000 Ticks nach Low geht hast Du ein Blinken 
erkannt: dem EventBuffer ein "Blinksignal auf Eingang X hinzufügen ", 
Status=Low
- wenn nach 1000+x Ticks kein Low kam, dann Status=High
Und so weiter.

Musst also vorher einen Timing/Entscheidungsbaum aufzeichnen und die 
States und Fehlerkonditionen entsprechend implementieren.

[Frank E. (Firma: Q3) (qualidat)]

Hmmm ... nun gibt es ja verschiedene Möglichkeiten, Algorithmen zu 
gestalten, die am Ende auch funktionieren - gar keine Frage.

Ich würde es aber anders machen: M.E. ist es gleichgültig, welchen 
Zustand der Eingang mal hatte, mir genügen die Aussagen darüber, wie oft 
sich der Pegel im letzten Überwachungszyklus geändert hat und wie er 
jetzt ist.

Zähler null oder wenig = pseudo-statischer Eingang, aktueller Wert nun 
bekannt

Zähler mittel: Blitzer, Status uninteressant

Zähler hoch: Blinker, Status uninteressant

[Pascal H. (0skill)]

Udo Schmitt schrieb:
> Was noch niemand angesprochen hat: Woher kommen die Zustände?

Die Zustände kommen von einem µC der zur Zeit einfach die Zustände der 
Anlage über LEDs signalisiert
Ziel der Aufgabe ist es die Zustände ab zu greifen und diese Daten dann 
via Webserver dar zu stellen. Des weiteren sollten diese Daten dann auch 
gleich noch einer Software welche auf einem PC läuft gesendet werden(zur 
Aufzeichnung und Protokollierung)

[Udo S. (urschmitt)]

Pascal H. schrieb:
> Die Zustände kommen von einem µC der zur Zeit einfach die Zustände der
> Anlage über LEDs signalisiert

Gut, dann musst du dich auch nicht um Prellen kümmern.