Frequenzkontrolle

Nur so als Idee

Es läuft doch darauf hinaus, lauter parallel laufende Frequenzzähler
zu machen. Bei 10 kHz würde ich das mit einer feststehenden Torzeit
mittels Timer machen. Sagen wir mal: alle 0.1 Sekunden kommt
ein Timerinterrupt.
In der Hauptschleife überwacht der µC 18 Pins, ob er dort einen
Flankenwechsel von 0 auf 1 vorfindet. Wenn ja wird ein, dem
Pin zugehöriger, Zähler erhöht.
Wenn jetzt der Timerinterrupt auftritt, werden die Zähler
ausgewertet. Die muessten bei 0.1 Torzeit alle im Bereich
999 bis 1001 sein. Bereich deshalb, weil die Torzeit ja nicht
exakt mit einem Flankenwechsel am zu überwachenden Pin beginnt.
Wenn ein Zähler jetzt nicht den vorgeschriebenen Wert hat
tritt der Alarmierungsfall ein und die entsprechende Massnahme
wird eingeleitet. Die Zähler alle wieder auf 0 stellen und
der nächste Messzyklus kann beginnen.
Wenn du Pin Change Interrupts zur Verfügung hast, vereinfacht
sich natürlich das Auffinden der Flanken.

So ungefähr, nur so als Idee. Ich hab jetzt nicht geprüft, ob
man da mit dem Timing hinkommt oder nicht. Aus dem Bauch
raus, würde ich aber sagen: könnte klappen.

Stefan wrote:
> Hallo Karl Heinz
>
> mit Torzeit ist einfach eine bestimmte Periodendauer gemeint oder?
>

Ja.

> Und die Überwachung der 18Pins in der Hauptschleife, wenn man das über
> zyklisches Polling macht, dann kann es aber leicht passieren dass so ein
> kurzers Flankenwechsel einfach untergeht, nicht?

Gneau das hab ich gemeint, mit 'ich hab das Timing nicht gecheckt.
Bei 10 kHz hast du von einer Flanke zur nächsten eine Zeitdauer
von 0.05ms zur Verfügung. Sollte eigentlich reichen um reihum
18 Pins abzufragen und zu entscheiden ob sich der Zustand geändert
hat.

Die Hauptschleife sieht in etwa so aus (Ich nehm jetzt
mal irgendwelche Ports an)

1

unsigned char Zustand[18];

2

unsigned int Counter[18];

3

4

....

5

6

int main()

7

{

8

  unsigned char* Vorher;

9

  unsigned int* PinCounter;

10

  unsigned char Pin;

11

  unsigned char Jetzt;

12

  unsigend char i;

13

14

  ...

15

  bla, bla, setup, init, etc ...

16

17

  while( 1 ) {

18

    Vorher = &Zustand[0];

19

    PinCounter = &Counter[0];

20

21

    // die ersten 8 Pins

22

    Pin = 1;

23

    for( i = 0; i < 8; ++i ) {

24

      Jetzt = PINA & Pin;

25

      if( Jetzt != *Vorher && Jetzt != 0 ) {

26

        (*PinCounter)++;

27

        *Vorher = Jetzt;

28

      }

29

      Vorher++;

30

      PinCounter++;

31

      Pin = Pin << 1;

32

    }

33

34

    // Pins 8 bis 15

35

    Pin = 1;

36

    for( i = 0; i < 8; ++i ) {

37

      Jetzt = PINB & Pin;

38

      if( Jetzt != *Vorher && Jetzt != 0 ) {

39

        (*PinCounter)++;

40

        *Vorher = Jetzt;

41

      }

42

      Vorher++;

43

      PinCounter++;

44

      Pin = Pin << 1;

45

    }

46

47

    // und die letzten beiden

48

    Pin = 1;

49

    for( i = 0; i < 2; ++i ) {

50

      Jetzt = PINC & Pin;

51

      if( Jetzt != *Vorher && Jetzt != 0 ) {

52

        (*PinCounter)++;

53

        *Vorher = Jetzt;

54

      }

55

      Vorher++;

56

      PinCounter++;

57

      Pin = Pin << 1;

58

    }

59

  }

60

}

Betrachte das jetzt nicht als der Weisheit letzter Schluss,
sondern als 'erste Skizze'. Die Grosse Frage ist: wie lange
dauert ein Durchlauf durch die while Schleife im schlimmsten
Fall.

Bei einer µC Auswertung ist das Hauptproblem meistens
(so auch hier): je kürzer, desto schwieriger.
Du wirst doch in etwa eine Abschätzung haben, wie lange
die Frequenzaussetzer dauern. Reden wir da von Nanosekunden,
Millisekunden, Stunden, Tage. Irgendeine Untergrenze, die
du detektieren musst wirst du ja haben.
Das andere: Ab welcher Abweichung gilt denn die Frequenz
daneben? Sind 9.999 kHz noch akzeptabel oder ist in diesem
Fall die Frequenz schon daneben.

Wenn du ein Messgerät designen willst, musst du dir erst
mal Gedanken um die Messbereiche und Genauigkeitsanforderungen
machen.