Immer wieder Servos...

**oberallgeier** · 26.06.2017, 16:01

.. Die kürzeste Zeit .. bis zum nächsten Interrupt hat, sind 0,6 ms .. gibt es Anhaltswerte wonach ich gehen kann? Dass ich abschätzen kann wie viele Anweisungen in eine Zeit x passen?
Wie macht ihr das? ..

600 µs bei 16 MHz ergibt 9600 Taktzyklen. Das sind ja nu nicht sooo viel. Nen genauen Zeitbedarf bekommst Du aus der fooxxfile.lls heraus. Darin, in der *.lls steht nämlich neben allen möglichen Dingen auch der (dis-)assemblierte Code Deines Programms, siehe dieses Beispiel aus (m)einen Codevorrat :

Code:

arno_01.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         00000366  00800100  000019cc  00001a80  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         000019cc  00000000  00000000  000000b4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          00000165  00800466  00800466  00001de6  2**0
                  ALLOC
  3 .eeprom       00000001  00810000  00810000  00001de6  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  4 .debug_aranges 00000020  00000000  00000000  00001de7  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_pubnames 000006d9  00000000  00000000  00001e07  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_info   000019a4  00000000  00000000  000024e0  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_abbrev 00000311  00000000  00000000  00003e84  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_line   0000141d  00000000  00000000  00004195  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_frame  000002e0  00000000  00000000  000055b4  2**2
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_str    00000649  00000000  00000000  00005894  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_loc    00000619  00000000  00000000  00005edd  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_ranges 000000c0  00000000  00000000  000064f6  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
       0:    0c 94 34 00     jmp    0x68    ; 0x68 <__ctors_end>
       4:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
       8:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
       c:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      10:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      14:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      18:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      1c:    0c 94 6e 02     jmp    0x4dc    ; 0x4dc <__vector_7>
      20:    0c 94 a0 02     jmp    0x540    ; 0x540 <__vector_8>
      24:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      28:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      2c:    0c 94 f4 01     jmp    0x3e8    ; 0x3e8 <__vector_11>
      30:    0c 94 2c 02     jmp    0x458    ; 0x458 <__vector_12>
      34:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      38:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      3c:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      40:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      44:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      48:    0c 94 90 00     jmp    0x120    ; 0x120 <__vector_18>
      4c:    0c 94 bc 00     jmp    0x178    ; 0x178 <__vector_19>
      50:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      54:    0c 94 5b 06     jmp    0xcb6    ; 0xcb6 <__vector_21>
      58:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      5c:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      60:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>
      64:    0c 94 51 00     jmp    0xa2    ; 0xa2 <__bad_interrupt>

..
00000120 <__vector_18>:
// ============================================================================== =


// ============================================================================== =
ISR( USART0_RX_vect )
{
     120:    1f 92           push    r1
     122:    0f 92           push    r0
     124:    0f b6           in    r0, 0x3f    ; 63
     126:    0f 92           push    r0
     128:    11 24           eor    r1, r1
     12a:    8f 93           push    r24
     12c:    9f 93           push    r25
     12e:    ef 93           push    r30
     130:    ff 93           push    r31
  u8 i = rx_in;
     132:    90 91 af 04     lds    r25, 0x04AF

  ROLLOVER( i, RX0_SIZE );
     136:    9f 5f           subi    r25, 0xFF    ; 255
     138:    90 34           cpi    r25, 0x40    ; 64
     13a:    08 f0           brcs    .+2          ; 0x13e <__vector_18+0x1e>
     13c:    90 e0           ldi    r25, 0x00    ; 0
  if( i == rx_out ){            // buffer overflow
     13e:    80 91 b0 04     lds    r24, 0x04B0
     142:    98 17           cp    r25, r24
     144:    31 f4           brne    .+12         ; 0x152 <__vector_18+0x32>
    URX0_IEN = 0;            // disable RX interrupt
     146:    80 91 c1 00     lds    r24, 0x00C1
     14a:    8f 77           andi    r24, 0x7F    ; 127
     14c:    80 93 c1 00     sts    0x00C1, r24
     150:    0a c0           rjmp    .+20         ; 0x166 <__vector_18+0x46>
    return;
  }
  rx_buff[rx_in] = UDR0;
     152:    e0 91 af 04     lds    r30, 0x04AF
     156:    f0 e0           ldi    r31, 0x00    ; 0
     158:    80 91 c6 00     lds    r24, 0x00C6
     15c:    e1 59           subi    r30, 0x91    ; 145
     15e:    fb 4f           sbci    r31, 0xFB    ; 251
     160:    80 83           st    Z, r24
  rx_in = i;
     162:    90 93 af 04     sts    0x04AF, r25
}
     166:    ff 91           pop    r31
     168:    ef 91           pop    r30
     16a:    9f 91           pop    r25
     16c:    8f 91           pop    r24
     16e:    0f 90           pop    r0
     170:    0f be           out    0x3f, r0    ; 63
     172:    0f 90           pop    r0
     174:    1f 90           pop    r1
     176:    18 95           reti

00000178 <__vector_19>:
// ============================================================================= =
..
..
// ============================================================================= =
..
000019c8 <_exit>:
    19c8:    f8 94           cli

000019ca <__stop_program>:
    19ca:    ff cf           rjmp    .-2          ; 0x19ca <__stop_program>

Anfangs allerlei Organisation. Beachte die beispielhafte ISR( USART0_RX_vect ), besonders die pushs am Beginn und die pops am Ende der ISR. Die sind blanker Overhead, weil die ISR erstmal alle von ihr benutzten (manchmal nicht benutzte) Register am Stack sichern - pushen - muss. Weil sie ja zu einem beliebigen Zeitpunkt/Codeabschnitt bedient wird, an dem "niemand" weiß, was gerade in den zentralen Registern der ALU steckt. Am Ende des eigentlich "sinnvollen" Codes der ISR werden die entsprechend der ISR-Startsituation gesicherten Register wieder zurückgeladen - gepopt. Zweimal je sieben pushs bzw. pops sind schon mal achtundzwanzig Maschinenzyklen - die aufgewendet werden müssen, damit alles seine Richtigkeit hat (im beispielhaften Controller pro push oder pull jeweils 2 Zyklen).

Dieser Overhead kostet Zeit wie jeder andere Prozessor-Codeschritt. Und so simpel wie eben von mir vorgerechnet kannst Du nun Routine für Routine durchgehen und die einzelnen Zeiten rauslesen (siehe Datenblatt, Instruction Set Summary, hier aus dem Atmel-42735B-ATmega328/P_Datasheet_Complete-11/2016). Dies gilt aber nur dann, wenn nicht innerhalb Deines betrachteten Codes eine - oder mehrere - ISR ausgelöst werden und abgearbeitet werden müssen . . . es sei denn, es geht um einen Abschnitt der z.B. mit cli (); (=Global Interrupt Disable) anfängt und mit sei (); (= Global Interrupt Enable) endet ODER wenn Interrupts z.B. noch garnicht erlaubt sind.

Klar ?