-         
Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 16 von 16

Thema: Verschiedene Taktraten im Atmega?

  1. #11
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.753
    Anzeige

    Zitat Zitat von Don Simon Beitrag anzeigen
    .. 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.
    Geändert von oberallgeier (07.09.2018 um 16:08 Uhr) Grund: Kurz erläutert: Zeitbedarf von Routinen
    Ciao sagt der JoeamBerg

  2. #12
    Neuer Benutzer Öfters hier
    Registriert seit
    24.06.2018
    Ort
    Bayern
    Beiträge
    8
    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.

  3. #13
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.753
    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:



    .. 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):



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

    Ist das so nachvollziehbar?
    Geändert von oberallgeier (10.10.2018 um 23:20 Uhr) Grund: Nachtrag opcode
    Ciao sagt der JoeamBerg

  4. #14
    Neuer Benutzer Öfters hier
    Registriert seit
    24.06.2018
    Ort
    Bayern
    Beiträge
    8
    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.

  5. #15
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.753
    .. 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.
    Ciao sagt der JoeamBerg

  6. #16
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.753
    .. 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 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.
    Ciao sagt der JoeamBerg

Seite 2 von 2 ErsteErste 12

Ähnliche Themen

  1. Verschiedene FET's ?
    Von maxman1506 im Forum Elektronik
    Antworten: 12
    Letzter Beitrag: 11.03.2012, 17:42
  2. Schrittmotorenansteuerung: Welche Taktraten??
    Von bernhard1366 im Forum Motoren
    Antworten: 1
    Letzter Beitrag: 07.03.2008, 10:26
  3. Verschiedene Kleinmotoren
    Von $robocop$ im Forum Motoren
    Antworten: 5
    Letzter Beitrag: 08.05.2007, 19:22
  4. Verschiedene Frequenzen
    Von T.r.Agent D im Forum AVR Hardwarethemen
    Antworten: 5
    Letzter Beitrag: 28.05.2006, 16:23
  5. 2 Verschiedene Zeitabläufe ?
    Von BlaueLed im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 3
    Letzter Beitrag: 28.09.2005, 11:30

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •