Einblick: 2020-04-25

Interrupt Latenz in Embedded Systemen (interrupt latency)

Am Beispiel eines Atmel AtTiny85 8-bit Mikroprozessors und der Microchip Atmel Studio 7 avr8-gnu-toolchain

Interrupt Latenz (interrupt latency) - Am Beispiel eines Atmel AtTiny85 8-bit MikroprozessorsBei der Entwicklung von Embedded HW/SW Systemen müssen unter Umständen "harte" Echtzeitanforderungen (Real-time conditions) eingehalten werden. Echtzeit bedeutet hier, dass das System vorgegebene Reaktions-, Bearbeitungs- oder Antwortzeiten einhält. Das kann z.B. bei der Bearbeitung von Sensorsignalen, das Ansprechen von Aktoren oder das Handling von User Interfaces (Eingabe/Ausgabe) der Fall sein. Um solche Echtzeitanforderungen einzuhalten, können Interrupts und sogenannte Interrupt Service Routinen (ISR) verwendet werden. Wie lange dauert im einfachsten Fall solch ein Interrupt Sprung? Wir haben am Beispiel eines Atmel AtTiny85 8-bit Mikroprozessors und der Microchip Atmel Studio 7 avr8-gnu-toolchain die Laufzeit des generierten Interrupt Codes berechnet und die Ausführung am Oszilloskop nachgemessen. Der vom Compiler generierte Assembler Code basiert auf einem einfachen C-Programm.

Zuerst einige Details zum Interrupt und der ISR. Einfach gesagt, ermöglicht ein Interrupt die Unterbrechung des gerade laufenden Programms und den anschließenden Sprung zu einer ISR. Eine ISR kann z.B. eine "globale" Variable mit einem bestimmten Wert setzen, die dann im Programm verwendet wird, oder ein Unterprogramm ausführen. Am Ende der ISR veranlasst die ISR einen Rücksprung zum unterbrochenen Programm. Dabei muss beachtet werden, dass beim Verlassen des Programms diejenigen Prozessor-/Programmzustände gesichert werden, die für eine reibungslose Fortführung des Programms nach der Abarbeitung der ISR notwendig sind. Der Program Counter (PC) ist solch ein Zustandswert, da er dem Prozessor sagt an welcher Stelle er im Programm nach der ISR fortfahren soll. Dazu werden direkt nach dem Sprung zur ISR diese Prozessor-/Programmzustände auf dem Stack zwischengespeichert, um diese am Ende der ISR wieder rückzusichern. Hinweis, der Stack ist der "höchste" Speicherbereich im RAM, der für Programmvariablen etc. dynamisch, d.h. je nach Bedarf, während der Programmausführung verwendet wird.

Wir haben folgenden C-Code verwendet, um einen sogenannten INT0 Interrupt festzulegen. Damit erzeugt der Atmel AtTiny85 Mikroprozessor einen Interrupt sobald ein Signalwechsel am Pin PB2 eintritt. Über das Setzen von bestimmten Bits im MCUCR register legen wir fest, bei welchem Signalwechsel ein Interrupt INT0 erzeugt wird.

C-Code

#define F_CPU 8000000 // Internal RC-Oscillator is clocked at 8Mhz

#include <avr/io.h>
#include <avr/interrupt.h>

ISR(INT0_vect)
{
  // ... ISR Code could go here ...
}

int main(void)
{
  GIMSK |= (1<<INT0);  // General Interrupt Mask Register - Enable External Interrupt Request INT0
                       // Memo: AtTiny85 INT0 is hardwired to Pin PB2
  MCUCR |= (1<<ISC01); // MCU Control Register - INT0 Sense Control i.e., define which change in logic level/edge will trigger INT0 interrupt
                       // We set it such, that the falling edge of INT0 generates an interrupt request.

  sei();               // Enable global interrupts

  while (1)
  {
    // ... Main Program Loop ...
  }
}

Generierter Assembler-Code

Die avr8-gnu-toolchain erzeugt aus dem oben aufgeführten C-Code folgenden Assembler Code. Es wird ein Code-Ausschnitt aus der Interrupt Vektor Tabelle und der INT0 Routine gezeigt. Die INT0 Routine beinhaltet den Sprung zur eigentlichen ISR, hier bewußt ohne Code Beispiel gezeigt.

// Interrupt Vektor Tabelle (IVT) - CC denotes clock cycles (execution time)
00000000  RJMP PC+0x000F
00000001  RJMP PC+0x0017  Relative jump, INT0 Interrupt Vektor => jump to Program Counter 00000018
                          2 CC, but hardware triggered jump into IVT
                          requires 1 extra CC, thus in total 3 CC
00000002  RJMP PC+0x0015 
...
// INT0 Interrupt Routine - Save Processor State
00000018  PUSH R1     Push register R1 on stack (save R1) - 2 CC
00000019  PUSH R0     Push register R0 on stack (save R0) - 2 CC
0000001A  IN R0,0x3F  In from I/O location 0x3F (get value from Status Register) - 1 CC
0000001B  PUSH R0     Push register on stack (save value on Stack) - 2 CC
0000001C  CLR R1      Clear Register (set R1 to 0 value) - 1 CC
 ... ISR goes here ... if done, write back Processor State ... 
0000001D  POP R0      Pop register from stack (get saved Status Register value from Stack) - 2 CC
0000001E  OUT 0x3F,R0 Out to I/O location 0x3F (restore Status Register) - 1 CC
0000001F  POP R0      Pop register from stack (restore R0) - 2 CC
00000020  POP R1      Pop register from stack (restore R1) - 2 CC
00000021  RETI        Interrupt return, jump back to main program location using Program Counter saved on Stack - 4 CC
                      Memo: RETI also enables the Global Interrupt Flag ("I" Bit set to 1)
...

Aus dem generierten Assembler Code ergeben sich insgesamt 3 + 19 = 21 CC (Clock Zyklen).

Gemäß dem Atmel AtTiny85 Datasheet wird vor dem Sprung in die Interrupt Tabelle, also bevor der o.a. Code ausgeführt wird, das Global Interrupt Flag (GIE) deaktiviert (auf Null gesetzt) und der aktuelle Program Counter auf dem Stack gesichert. Dieser Vorgang geschieht direkt über die Hardware der CPU, d.h. ohne entsprechenden Assembler Code, und taucht daher im obigen Assembler Code nicht auf. Für diesen Vorgang werden laut Atmel Datasheet mind. 4 Prozessor Takte benötigt. Danach triggert die Hardware den Sprung in die Interrupt Tabelle.

Im AtTiny85 Datasheet steht dazu (Seite 12 und 13):

"... When an interrupt occurs, the Global Interrupt Enable I-bit is cleared and all interrupts are disabled ... The I-bit is automatically set when a Return from Interrupt instruction – RETI – is executed ...
The interrupt execution response for all the enabled AVR interrupts is four clock cycles minimum. After four clock cycles the Program Vector address for the actual interrupt handling routine is executed. During this four clock cycle period, the Program Counter is pushed onto the Stack. The vector is normally a jump to the interrupt routine, and this jump takes three clock cycles."

Das Global Interrupt Enable Flag wird tatsächlich vor dem Sprung in die Interrupt Tabelle auf 0 gesetzt. Wir haben das über Statustests nachvollziehen können. Damit wird vermieden, dass die Ausführung der ISR nicht durch weitere Interrupts unterbrochen wird. Falls während der ISR Ausführung dennoch Interrupts, sogenannte verschachtelte Interrupts gewünscht sind, kann dies mit dem erweiterten Interrupt Aufruf ISR(INT0_vect, ISR_NOBLOCK) definiert werden. Dann fügt der Compiler am Anfang der ISR Routine den SEI Befehl ein, welcher das Global Interrupt Enable I-bit wieder auf 1 setzt.

Das Atmel Datasheet gibt für Sprung über den Interrupt Vector zur ISR mit 3 CC an. Laut unserer Oszilloskop Messung beinhaltet das den RJMP Sprung (2 CC) aus der Interrupt Vektor Tabelle zur eigentlichen ISR. Daraus schließen wir, dass der hardwareseitige Sprung in die Interrupt Vektor Tabelle 1 CC benötigt.

Ergebnis - Ermittlung der Interrupt Latenz:
Es werden insgesamt mind. 4 CC (PC auf Stack sichern) + 3 CC (Jump über die Interrupt Tabelle zur ISR) + 19 CC (generierter Assembler Code, siehe Code Fragment oben) = 26 Clock Zyklen für die Abarbeitung eines INT0 Interrupts benötigt. Dazu käme der Zeitbedarf einer gesonderten ISR Routine, die ja variabel gestaltet werden kann. Bei einer CPU Taktfrequenz von 8 Mhz dauert ein Clock Zyklus rechnerisch 0.125 µs.

Der INT0 Interrupt benötigt in unserem Code-Beispiel mindestens 26 Clock Zyklen, was bei 8 Mhz einer Dauer von 26x0.125 = 3.25 µs entspricht. Diesen Wert konnten wir mit einer durchgeführten Oszilloskop Messung bestätigen. Diese 3.25 µs müssen zur einer ISR Routine, wie z.B. eine globale Variable setzen oder ein Sprung in ein Unterprogramm, dazugerechnet werden.

Einblicke

Zurück zur Gesamtliste aller "Einblicke":

Kontakt

Bei Bedarf können Sie uns gern Ihr Feedback mitteilen oder Anfragen stellen. Hier geht es zum Kontakt Formular: