Verschiedene Taktraten im Atmega?

**oberallgeier** · 07.09.2018, 17:02

Zitat von Don Simon

.. ich werke .. mit eingebautem Atmega64 und externem 16 MHz Quarz, programmiere mit Bascom/Ponyprog/ISP ..

.. Das wusste ich nicht. Wo finde ich die Datei? ..

Oh weh, böses Eigentor - ich hatte nicht daran gedacht, dass Du mit Bascom arbeitest. Ich programmiere meine Atmels mit C (kaum C++) und AVRStudio4 oder Studio7. Da finde ich diese Datei im Projektordner, Subdirectory "default". Sieht etwa wie folgt aus; im Beispiel heißt die Datei ARCo.lss, hier nur Anfang, danach stark gekürzt :

Code:

ARCo.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         00000d9e  00800100  00005922  000059d6  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         00005922  00000000  00000000  000000b4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          000003b7  00800e9e  00800e9e  00006774  2**0
                  ALLOC
  3 .eeprom       000001ea  00810000  00810000  00006774  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  4 .debug_aranges 00000020  00000000  00000000  0000695e  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_pubnames 000008ef  00000000  00000000  0000697e  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_info   00003355  00000000  00000000  0000726d  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_abbrev 000003eb  00000000  00000000  0000a5c2  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_line   000045d7  00000000  00000000  0000a9ad  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_frame  00000600  00000000  00000000  0000ef84  2**2
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_str    00000897  00000000  00000000  0000f584  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_loc    00001f04  00000000  00000000  0000fe1b  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_ranges 00000270  00000000  00000000  00011d1f  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
       0:    0c 94 46 00     jmp    0x8c    ; 0x8c <__ctors_end>
       4:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
       8:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
       c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      10:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      14:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      18:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      1c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      20:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      24:    0c 94 32 0b     jmp    0x1664    ; 0x1664 <__vector_9>
      28:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      2c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      30:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      34:    0c 94 ce 07     jmp    0xf9c    ; 0xf9c <__vector_13>
      38:    0c 94 b3 0a     jmp    0x1566    ; 0x1566 <__vector_14>
      3c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      40:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      44:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      48:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      4c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      50:    0c 94 a4 00     jmp    0x148    ; 0x148 <__vector_20>
      54:    0c 94 d3 00     jmp    0x1a6    ; 0x1a6 <__vector_21>
      58:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      5c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      60:    0c 94 14 0c     jmp    0x1828    ; 0x1828 <__vector_24>
      64:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      68:    0c 94 1d 02     jmp    0x43a    ; 0x43a <__vector_26>
      6c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      70:    0c 94 76 01     jmp    0x2ec    ; 0x2ec <__vector_28>
      74:    0c 94 a6 01     jmp    0x34c    ; 0x34c <__vector_29>
      78:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      7c:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      80:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      84:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>
      88:    0c 94 65 00     jmp    0xca    ; 0xca <__bad_interrupt>

0000008c <__ctors_end>:
      8c:    11 24           eor    r1, r1
      8e:    1f be           out    0x3f, r1    ; 63
      90:    cf ef           ldi    r28, 0xFF    ; 255
      92:    d0 e4           ldi    r29, 0x40    ; 64
      94:    de bf           out    0x3e, r29    ; 62
      96:    cd bf           out    0x3d, r28    ; 61

00000098 <__do_copy_data>:
      98:    1e e0           ldi    r17, 0x0E    ; 14
      9a:    a0 e0           ldi    r26, 0x00    ; 0
      9c:    b1 e0           ldi    r27, 0x01    ; 1
      9e:    e2 e2           ldi    r30, 0x22    ; 34
      a0:    f9 e5           ldi    r31, 0x59    ; 89
      a2:    00 e0           ldi    r16, 0x00    ; 0
      a4:    0b bf           out    0x3b, r16    ; 59
      a6:    02 c0           rjmp    .+4          ; 0xac <__do_copy_data+0x14>
      a8:    07 90           elpm    r0, Z+
      aa:    0d 92           st    X+, r0
      ac:    ae 39           cpi    r26, 0x9E    ; 158
      ae:    b1 07           cpc    r27, r17
      b0:    d9 f7           brne    .-10         ; 0xa8 <__do_copy_data+0x10>

000000b2 <__do_clear_bss>:
      b2:    12 e1           ldi    r17, 0x12    ; 18
      b4:    ae e9           ldi    r26, 0x9E    ; 158
      b6:    be e0           ldi    r27, 0x0E    ; 14
      b8:    01 c0           rjmp    .+2          ; 0xbc <.do_clear_bss_start>

000000ba <.do_clear_bss_loop>:
      ba:    1d 92           st    X+, r1

000000bc <.do_clear_bss_start>:
      bc:    a5 35           cpi    r26, 0x55    ; 85
      be:    b1 07           cpc    r27, r17
      c0:    e1 f7           brne    .-8          ; 0xba <.do_clear_bss_loop>
      c2:    0e 94 06 2a     call    0x540c    ; 0x540c <main>
      c6:    0c 94 8f 2c     jmp    0x591e    ; 0x591e <_exit>

000000ca <__bad_interrupt>:
      ca:    0c 94 00 00     jmp    0    ; 0x0 <__vectors>

000000ce <init_uart0>:
                    // count up and wrap around

// ============================================================================== =
void init_uart0( u16 bauddivider )
{
  UBRR0H = bauddivider >> 8;
      ce:    90 93 c5 00     sts    0x00C5, r25
  UBRR0L = bauddivider;            // set baud rate
      d2:    80 93 c4 00     sts    0x00C4, r24
  UCSR0A = 0;                // no U2X, MPCM
      d6:    10 92 c0 00     sts    0x00C0, r1
  UCSR0C = 1<<UCSZ01^1<<UCSZ00        // 8 Bit
      da:    86 e0           ldi    r24, 0x06    ; 6
      dc:    80 93 c2 00     sts    0x00C2, r24
#ifdef URSEL0
       ^1<<URSEL0            // if UCSR0C shared with UBRR0H
#endif
       ;
  UCSR0B = 1<<RXEN0^1<<TXEN0^        // enable RX, TX
      e0:    88 e9           ldi    r24, 0x98    ; 152
      e2:    80 93 c1 00     sts    0x00C1, r24
       1<<RXCIE0;            // enable RX interrupt
  rx_in = rx_out;            // set buffer empty
      e6:    80 91 21 0f     lds    r24, 0x0F21
      ea:    80 93 20 0f     sts    0x0F20, r24
  tx_in = tx_out;
      ee:    80 91 a3 0f     lds    r24, 0x0FA3
      f2:    80 93 a2 0f     sts    0x0FA2, r24
}
      f6:    08 95           ret

000000f8 <ukbhit0>:


// ============================================================================== =
u8 ukbhit0( void )
{
  return rx_out ^ vu8(rx_in);        // rx_in modified by interrupt !
      f8:    90 91 21 0f     lds    r25, 0x0F21
      fc:    80 91 20 0f     lds    r24, 0x0F20
}
     100:    89 27           eor    r24, r25
     102:    08 95           ret

00000104 <ugetchar0>:


// ============================================================================== =
u8 ukbhit0( void )
{
  return rx_out ^ vu8(rx_in);        // rx_in modified by interrupt !
     104:    90 91 21 0f     lds    r25, 0x0F21
     108:    80 91 20 0f     lds    r24, 0x0F20
// ============================================================================== =
u8 ugetchar0( void )
{
  u8 data;

  while( !ukbhit0() );            // until at least one byte in
     10c:    98 17           cp    r25, r24
     10e:    d1 f3           breq    .-12         ; 0x104 <ugetchar0>
  data = rx_buff[rx_out];        // get byte
     110:    e0 91 21 0f     lds    r30, 0x0F21
     114:    f0 e0           ldi    r31, 0x00    ; 0
     116:    e0 56           subi    r30, 0x60    ; 96
     118:    f1 4f           sbci    r31, 0xF1    ; 241
     11a:    e0 81           ld    r30, Z
  ROLLOVER( rx_out, RX0_SIZE );
     11c:    80 91 21 0f     lds    r24, 0x0F21
     120:    8f 5f           subi    r24, 0xFF    ; 255
     122:    80 93 21 0f     sts    0x0F21, r24
     126:    80 91 21 0f     lds    r24, 0x0F21
     12a:    87 ff           sbrs    r24, 7
     12c:    02 c0           rjmp    .+4          ; 0x132 <ugetchar0+0x2e>
     12e:    80 e0           ldi    r24, 0x00    ; 0
     130:    02 c0           rjmp    .+4          ; 0x136 <ugetchar0+0x32>
     132:    80 91 21 0f     lds    r24, 0x0F21
     136:    80 93 21 0f     sts    0x0F21, r24
  URX0_IEN = 1;                // enable RX interrupt
     13a:    80 91 c1 00     lds    r24, 0x00C1
     13e:    80 68           ori    r24, 0x80    ; 128
     140:    80 93 c1 00     sts    0x00C1, r24
  return data;
}
     144:    8e 2f           mov    r24, r30
     146:    08 95           ret

00000148 <__vector_20>:
...
...
und so weiter
// ============================================================================== =

Hier könnte man (wenn man viel Zeit hat - und Lust, oder wenn man es nötig findet) die Befehle jmp, ldi, out oder alle andern MAschinenbefehle im Datenblatt suchen und deren Anzahl von CPU-Takten notieren. Diese Taktanzahl für die jeweils interessierenden Abschnitte (Subroutinen, ISR etc) zusammenzählen und mit der Taktdauer multiplizieren . . .

.. Nebenbei, Archie sieht nach einem sehr interessanten Projekt aus!

Danke. Ja, schon etwas zeitintensiv, ich lass mir halt Zeit.

**Don Simon** · 10.10.2018, 22:46

Hatte leider in den letzten Wochen keine Zeit.
Aber danke für die Ausführung! Den Teil kannte ich noch garnicht. Das ist natürlich praktisch, wenn man so die einzelnen Zeiten von Routinen bekommen kann.

Steht jeweils die letzte Zahl für die Anzahl der Takte?
Also zB. fast ganz unten:
"13e: 80 68 ori r24, 0x80 ; 128"
Ist hier für ori mit r24 die "128" die Taktanzahl? Hierfür würde ich mit meinen 16 MHz rechnerisch auf 8 µs kommen.

**oberallgeier** · 11.10.2018, 00:10

Hi Simon,
das mit der Zeit für die einzelnen Schritte ist etwas aufwendiger, die müsste man sich für jeden OpCode separat raussuchen. Die Anzahl der Maschinenzyklen steht als #Clocks in der Dokumentation/Datenblatt des Controllers, üblicherweise unter Instruction Set Summary irgendwo ziemlich weit hinten.

.. Steht jeweils die letzte Zahl für die Anzahl der Takte? .. Also zB. fast ganz unten:
"13e: 80 68 ori r24, 0x80 ; 128"
Ist hier für ori mit r24 die "128" die Taktanzahl? Hierfür würde ich mit meinen 16 MHz rechnerisch auf 8 µs kommen.

Nein, 128 ist der Wert 0x80 (hex 80, also dezimal 128 .) mit dem ein logisches OR des Inhaltes vom Register r24 durchgeführt wird. Ausführlich ist das z.B. im Studio4 in der Assemblerhilfe ( siehe [Help][Assembler Help] ) zu finden. Da kommt - wenn man zu ORI runterscrollt die entsprechende Beschreibung, siehe hier:

Bild hier

.. und >>hier - Bild oben<< steht dann unten Cycles: 1. Und das ist die Aussage, dass genau diese einzelne Operation in einem Prozessortakt durchgeführt wird.

Die Befehlszeile ORI steht in der Dokumentation für den mega64 so (die Zeile unter der blau markierten):

Bild hier

Übrigens steht da dann nicht "Cycles" sonder "#Clocks". Is aber dasselbe *gg*.

Ist das so nachvollziehbar?

**Don Simon** · 11.10.2018, 20:16

Sehr gut nachvollziehbar, danke! Die einzelnen Befehle brauchen erstaunlich wenig Zeit. Hier hatte ich mit mehreren Takten gerechnet.
Vielleicht lerne ich doch noch irgendwann Assembler. Hatte vor ein paar Jahren mal ein bisschen damit angefangen mich einzuarbeiten, es dann aber nach 150 Seiten Theorie vorerst wieder aufgegeben.

**oberallgeier** · 12.10.2018, 09:42

.. Assembler. Hatte vor ein paar Jahren mal ein bisschen damit angefangen .. nach 150 Seiten Theorie vorerst wieder aufgegeben.

Das sind sicher hundert Seiten mehr als meine Geduld (und Auffassungsgabe) gereicht hätte.

Ich hatte jahrzehntealten Intel-8080-Assembler (also vorzugsweise alles vergessen) aufgefrischt mit dem Experimentierkasten von B.Kainka. Dort ist der Controller ein ATtiny13 - SEHR übersichtlicher kleiner Controller. Kainka hat dazu noch hier ne Beschreibung. Es sind ne ganze Reihe kleiner Experimente, fast durchwegs in Assembler beschrieben. Das ganze Buch hat weniger als 150 Seiten *gg* - und danach war ich ein ganzes Stück "in" den Atmels drinnen.

**oberallgeier** · 12.10.2018, 23:44

.. Die einzelnen Befehle brauchen erstaunlich wenig Zeit. Hier hatte ich mit mehreren Takten gerechnet ..

Ach jeee. Schon wieder jemand der das Datenblatt schlecht/wenig/kaum/nicht liest.

Zitat von 2490P–AVR–07,09, Seite 1=Deckblatt, vierte Zeile

..
130 Powerful Instructions – Most Single Clock Cycle Execution ..

Erste Seite, vierte Zeile ! Weiter oben gehts ja kaum. => Ohne das zugehörige Datenblatt zu lesen ist der Umgang mit Mikrocontrollern eins der letzten großen Abenteuer unserer Tage.