Interrupt

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Hallo!

      Ich habe folgendes Problem: Ich möchte Takte per Interrupt zählen.Es dürfen keine Takte verloren gehen. Ich kann nun in der ISR eine Flag setzen. Das Problem ist aber, dass der Prozessor in der Hauptroutine immer wieder sehr grosse Mengen an Daten verarbeiten muss und in der Zeit mehrere Takte zu zählen sein könnten. In diesem Fall wäre aber die Flag noch immer gesetzt (weil noch nicht verarbeitet) und es würden Takte verloren gehen.

      Ich kann in der ISR auch eine Variable hochzählen. Das wäre erst mal kein Problem, die Taktfrequenz kann nur bis zu 30 HZ gehen, ist meist aber deutlich niedriger. Wie gehe ich aber dann mit dem Problem um, dass ich womöglich gerade dabei bin, die Zählvariable zu lesen (in der Main) und genau da mittendrin ein IRQ kommt und genau diese Variable verändert wird?

      Wie kann ich an der Stelle Datenchaos verhindern? Gibt es dazu eine gute Lösung oder einen gänzlich anderen Lösungsansatz?

      Viele Grüße und Danke für jede Hilfe!

      Andy
    • Genau, jetzt egal, ob du einen counter verwendest, du lässt die Variable hochzählen, in der main liest du die und ziehst den alten Stand der Variablen von dem jetzt gelesenen Wert ab. Jetzt hast du die Veränderung. Diesen zuletzt gelesenen Wert speichern, für das Ermitteln der nächsten Veränderung.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo Ihr beiden,

      herzlichen Dank für Eure Antworten!

      O.K., wenn ich so was habe (das ist jetzt nur eine Art Pseudocode!):

      Was passiert, wenn ein IRQ ausgelöst wird, so lange Zeile 4 oder 5 bearbeitet wird? Zählvariable ist ein Word, byte ist zu klein.
      Mit Zeile 5 möchte ich verhindern dass es einen Variablenüberlauf gibt.

      Quellcode

      1. 'Main
      2. do
      3. Verarbeitungsvariable = Zählvariable
      4. Zählvariable = Zählvariable - Verarbeitungsvariable
      5. print Verarbeitungsvariable
      6. loop
      7. end
      8. '##########
      9. ISR_Sub
      10. incr Zählvariable
      11. return
      Alles anzeigen

      Das mit dem Timer habe ich auch schon überlegt. Allerdings zähle ich auf mehreren Kanälen gleichzeitig...

      Viele Grüße

      Andy
    • Hallo Michael,

      danke für Deine Antwort!

      Folgende zwei Fragen:

      - Wie verhindere ich dann einen Überlauf der Zählvariable?
      - Was ist wenn die Zählvariabe ein Word oder Dword ist? Dann geht doch das Lesen derselben nicht in einem Takt. Kann dann z.B. nicht das High-Byte im IRQ verändert werden, so lange das Low-Byte gelesen wird (oder umgekehrt)? Oder verstehe ich das falsch?

      Viele Grüße

      Andy
    • Wenn dir 512 Zählungen reichen, kannst du auch mit einem byte arbeiten. Wenn dein byte, mit dem du zählst max 1x überläuft, brauchst du dich um nix kümmern. Den counter oder Zählvariable nicht zurück setzen, nur immer mit dem vorher gelesenem Wert die Differenz bilden.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Mechanic schrieb:

      - Wie verhindere ich dann einen Überlauf der Zählvariable?
      Der Überlauf stört nicht, wenn alle beteiligten Variablen gleichen Typs sind.
      Die Zählweite ist allerdings auch nur so groß wie der jeweilige Datentyp (Byte = 256)

      Mechanic schrieb:

      - Was ist wenn die Zählvariabe ein Word oder Dword ist? Dann geht doch das Lesen derselben nicht in einem Takt. Kann dann z.B. nicht das High-Byte im IRQ verändert werden, so lange das Low-Byte gelesen wird (oder umgekehrt)? Oder verstehe ich das falsch?
      Ich fürchte, di u gehst dein Problem von der falschen Seite an.
      Beschreib doch mal, was das werden soll, ich kann mir kaum vorstellen, dass es beio 30 Hz Probleme geben soll.
    • Mechanic schrieb:

      dass der Prozessor in der Hauptroutine immer wieder sehr grosse Mengen an Daten verarbeiten muss und in der Zeit mehrere Takte zu zählen sein könnten.
      Soweit mir bekannt ist, würde die ISR deine Main unterbrechen, und ihre Befehle abarbeiten.
      Ein Counter, wie vorgeschlagen , erledigt das hardwaremäßig, also so nebenbei. Du musst halt nur
      gucken , ob ,oder wie sich der Zähler verändert hat.
      Interessant wäre vielleicht auch,was das für Takte sind, und wo sie herkommen. 30 Hz sind ja nicht gerade
      der Bourner , um einen Atmega außer Tritt zu bringen.

      Detlef
      Leichtsinn ist kein Mut, Vorsicht keine Feigheit.
    • Hallo Michael, hallo alle Anderen!

      Die Takte kommen von Stromzählern, die Frequenz schwank dementsprechend mit der abgerufenen el. Leistung.
      Auswerten soll das ein ATMEGA 128 der zugleich ein Web-Interface besitzt. Die meiste Zeit ist das kein Problem. Wenn aber gerade eine Datei versendet wird, dann können in der Zeit mehrere Impulse eingehen. Wie gesagt, das ist nicht das Problem. Das Problem (sofern es eines ist und ich nicht Geister sehe), ist nur das Auslesen der Zählvariable.

      Zu dem Problem mit dem Überlauf: Den kann ich auffangen, in dem ich schaue, ob sich die Zählvariable verkleinert hat im Vergleich zum letzen Auslesen. Dann weiss ich, dass es (mindestens) einen Überlauf gegeben hat.

      Deshalb kann ich das Problem jetzt schon auf folgende Frage reduzieren:

      Quellcode

      1. dim Zählvariable as word
      2. Verarbeitungsvariable = Zählvariable
      3. '...
      Kann etwas Unvorhergesehenes passieren, wenn ein IRQ ausgelöst wird, so lange Zeile drei abgearbeitet wird (Achtung: Zählvariable ist ein Word oder sogar Dword) und dort dann die Zählvariable incrementiert wird?

      Viele Grüße und danke für Eure Hilfe!

      Andy

      @Tschoeatsch: "Wenn dir 512 Zählungen reichen, kannst du auch mit einem byte arbeiten." Wie komme ich bei einem Byte auf 512 Zählungen? Habe ich etwas übersehen oder meintest Du 256? Trotzdem Danke für Deine Hilfe!
    • Ja, ich hab' mich da getäuscht. Geht nur bis 255 gezählte Impulse. Es reicht aber immer nur 'neuer Wert'-'alter Wert' zu rechnen, ob die Zählvariable oder counter über läuft ist egal, da braucht man sich nicht drum kümmern.

      Deine Frage würde ich mit ja beantworten. Weil die Zählvariable größer als ein byte ist.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Also wenn Dein Zähler 10.000 Impulse pro kWh abgibt und Du mit 10kWh/h in der Spitze rangehst, dann landest Du richtigerweise bei ca. 30Hz. Dann wäre das Fenster zwischen den Impulsen ca. 33ms lang. Bei 16MHz hättest Du dann 528.000 Takte Zeit um „Dinge“ zu tun. Quasi eine Ewigkeit.

      Zusammen mit den Vorschlägen aus den Beiträgen kommst Du auch mit einem Byte für den Zähler aus.
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • Und wenn du Bedenken hast, deine Zählvariable könnte 'zerschossen' sein, dann lies 2x direkt hintereinander die Zählvariable und mach erst weiter, wenn beide Lesungen dasselbe ergeben haben.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • tschoeatsch schrieb:

      Und wenn du Bedenken hast, deine Zählvariable könnte 'zerschossen' sein, dann lies 2x direkt hintereinander die Zählvariable und mach erst weiter, wenn beide Lesungen dasselbe ergeben haben.
      Hallo Tschoeatsch,

      das hatte ich mir auch schon überlegt. Ich müsste die Zählvariable so oft auslesen, bis die zweimal nacheinander das gleiche Ergebnis überträgt. Sehe ich das richtig?

      Allgemein:

      Quellcode

      1. a = b
      braucht für ein Byte 4 Takte für ein Word 12 und für ein Dword 20 Takte. Da wäre also genug Zeit, dass ein Interrupt dazwischen kommt. Ich weiss nur nicht, was da alles passieren kann. Ab Word kann ich mir halt vorstellen, wenn ich beim Lesen bin und dann per IRQ von 00000000_11111111 auf 00000001_00000000 beim Zählen springe, dass es als gelesenes Ergebnis vielleicht 00000000_00000000 oder 00000001_11111111 geben könnte (wenn der IRQ genau zwischen das Lesen der beiden Bytes kommt).

      Viele Grüße und danke an alle Mithelfer und Mitdenker!

      Andy
    • six1 schrieb:

      Hz = 1/s
      demnach müsstest du über einen Zeitraum messen. Du schreibst aber durch die ganzen Beiträge, dass du die Zählvariable nur inkrementieren möchtest.
      Da fehlt meiner Meinung nach noch etwas in deinen Überlegungen...
      Hallo Michael,

      es geht nicht um die Frequenz (= el. Leistung). Es geht um die Impulsanzahl (= el. Energiemenge). Die maximale Frequenz habe ich nur angegeben, damit man sich ein Bild von den zeitlichen Zusammenhängen machen kann.

      Viele Grüße und danke für Deine Hilfe!

      Andy
    • six1 schrieb:

      ohne einen zeitlichen Zusammenhang hat eine Anzahl Impulse keinen Aussagewert.
      das ist der Zählerstand, oder eine Erhöhung dessen. Mal dem Preis für eine Einheit hast du die Energiekosten.... Die Stadtwerke sind mit dem Stand ja auch zufrieden.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------