Öğren

Tarayıcıda AVR assembly, simüle edilmiş bir Arduino Uno üzerinde

Başlangıç

Ya da tüm dersleri gör.

  • 526parça tezgahta
  • 46kart şu an çalışıyor
  • 1.00xgerçek zamanlı, her kartta
Arduino Uno: pin 13'te yanıp sönen bir LEDcanlı0.000 s 0.00x
Düzenleyicide açmak için tıkla
Hazır blink, C ile, pin 13'teki bir LED ve 220 ohmluk bir direnç üzerinde. Düzenleyicide aç ve aynı LED'i main.S üzerinden çalıştırmak için Blink in assembly seçeneğini seç.

Bir Arduino Uno bir ATmega328P'dir ve her kodun altında AVR makine kodu çalıştırır: 32 yazmaç, bir bayrak baytı ve her biri bilinen sayıda saat döngüsü süren komutlar. Mokxi bu katmanı doğrudan yazmanı sağlar. Kodunun yanına bir .S sekmesi ekle, ya da kartın tamamını Arduino çekirdeği olmayan bir assembly projesine dönüştür ve Çalıştır'a bas.

Bu sayfa, düzenleyicinin eline verdiği blink'i adım adım anlatıyor: her komutun ne yaptığı, PORTB'nin neden iki farklı sayı olduğu ve sayılan bir döngünün nasıl tam 250 milisaniyeye dönüştüğü. Sonra bir zamanlayıcı kesmesi ve bunu tek tek komutlarla geri okuyan hata ayıklayıcı.

Yukarıdaki devre, C ile yazılmış sıradan hazır blink. Assembly sürümünü çalıştırmak için onu düzenleyicide aç, Uno'yu seç ve Firmware panelinde **Assembly (no Arduino)** altındaki **Blink in assembly** seçeneğini seç. Kartın dosyaları tek bir main.S olur.

Blink'i assembly ile satır satır

Bu programın altında hiçbir şey gizli değil: setup() yok, loop() yok, arka planda millis() kesmesi yok. Başlangıç kodu r1'i sıfırlar, yığını RAM'in tepesine koyar ve main'i çağırır. Ondan sonra çipin harcadığı her döngü senin yazdığın bir döngü. #include <avr/io.h> çalışır çünkü bir .S dosyası önce C ön işlemcisinden geçer ve sana yazmaç ve bit adlarını verir.

sbi tek bir G/Ç yazmacının tek bir bitini ayarlar. İlki, 13 olarak işaretlenmiş pin olan PB5'i çıkış yapar. İkincisi bilinmeye değer numara: PINB'nin bir bitine 1 yazmak, PORTB'nin eşleşen bitini tersine çevirir; tek komut, iki döngü, okuma yok, maske yok. Sonra rcall gecikmeyi çağırır, ret geri döner ve rjmp loop başa sarar.

main.S: Firmware panelinin sana verdiği Blink başlangıç dosyası
; Blink the LED on pin 13 (PB5) every 250 ms, in AVR assembly.
; No Arduino core: the startup code clears r1, puts the stack at RAMEND
; and calls main, as avr-gcc's does.

#include <avr/io.h>

    .section .text
    .global main
main:
    sbi  _SFR_IO_ADDR(DDRB), DDB5     ; PB5 is an output
loop:
    sbi  _SFR_IO_ADDR(PINB), PINB5    ; writing 1 to PINB5 toggles PB5
    rcall delay_250ms
    rjmp loop

; 250 ms at 16 MHz is 4,000,000 cycles: 40 times 100,000.
; The inner loop is 4 cycles a turn (SBIW 2, BRNE 2), 25,000 turns.
delay_250ms:
    ldi  r18, 40
outer:
    ldi  r24, lo8(25000)
    ldi  r25, hi8(25000)
inner:
    sbiw r24, 1
    brne inner
    dec  r18
    brne outer
    ret

Yazmaçlar ve hangilerini kullanabilirsin

Çipte 32 genel yazmaç var, r0'dan r31'e, her biri bir bayt ve tek döngüde erişilir. Üst yarı özeldir: sabit yükleyen ldi yalnızca r16'dan r31'e çalışır, blink'in sayaçlarını r18, r24 ve r25'te tutmasının nedeni de budur. ldi r3, 5 yazarsan derleme şu mesajla durur: ldi works only on r16 to r31, and r3 is not one of them.

Two registers are spoken for: r1 must hold zero, because the C compiler assumes it everywhere, and r0 is the scratch byte. Then there is SREG, eight flags set by the last instruction that did arithmetic. sbiw sets Z when its result reaches zero, and brne is simply "branch if Z is clear". sbi and cbi change no flags at all. The debugger spells sreg out as ITHSVNZC, with a dot for each flag that is clear.

İlk assembly programının karşılaştığı AVR yazmaçları
YazmaçNedirDikkat et
r0Karalama baytı, `__tmp_reg__`. `lpm` varsayılan olarak buraya yazar.Derleyici onu kullanır, bu yüzden bir çağrıdan sonra hiçbir değer hayatta kalmaz.
r1Always zero, `__zero_reg__`.`mul` r1:r0'a yazar, o yüzden sonrasında `clr r1` yap.
r2'den r17'yeGenel ama çağıranın.Fonksiyonun bunları kullanıyorsa push ve pop yap.
r16'dan r31'eÜst yarı.`ldi`, `cpi`, `subi`, `andi` ve `ori` yalnızca burada çalışır.
r18'den r27'ye, r30, r31Fonksiyonunun içinde serbest.Çağırdığın bir C fonksiyonu bunları bozabilir.
r24, r26, r28, r30`adiw` ve `sbiw` çiftleri bunlarla çalışır.r24:r25 ayrıca 16 bitlik argümanı ve sonucu taşır.
X, Y, Zr26:r27, r28:r29, r30:r31: işaretçiler.Yalnızca Z, `lpm` ile flash'ı okur. Y, C'nin çerçeve işaretçisidir.
SREGBayraklar: I T H S V N Z C.Aritmetik ve karşılaştırmalarla ayarlanır, `sbi`, `ldi` veya `mov` ile ayarlanmaz.

G/Ç adresleri ve veri adresleri: PORTB neden 0x25 ve 0x05

This is the one that costs people an evening. In a .S file, #include <avr/io.h> defines PORTB as its data address, 0x25, which is what lds and sts want. The short instructions, in, out, sbi, cbi, sbic and sbis, want the I/O address instead, which is 32 lower: 0x05. So you wrap the name in _SFR_IO_ADDR().

Yanlış yaparsan Mokxi derlemeyi hiçbir araç çalışmadan önce durdurur, çünkü aksi halde hata yanlış yazmaca yazan bir programa dönüşürdü. sbi PORTB, 5 şunu verir: PORTB is the data address 0x25 here, and sbi takes its I/O address: write _SFR_IO_ADDR(PORTB), which is 0x05. G/Ç adresi 63'ün üzerindeki yazmaçların, örneğin TCCR1B'nin hiç kısa biçimi yoktur: lds ve sts kullan.

Aynı bit, üç yol
; As avr-libc defines them: a name is a data address.
    sbi  _SFR_IO_ADDR(DDRB), DDB5   ; I/O 0x05, bit 5
    lds  r16, PORTB                 ; data 0x25
    sts  PORTB, r16

; Or move every name down to its I/O address, once:
#define __SFR_OFFSET 0
#include <avr/io.h>
    sbi  DDRB, DDB5                 ; now this is right

Döngü saymak: 250 ms için 4.000.000 döngü

Burada delay() yok, o yüzden gecikme elle saydığın bir döngü. Uno 16 MHz'de çalışır, yani bir çevrim 62,5 nanosaniyedir ve 250 milisaniye 4.000.000 çevrimdir. Blink'in iç döngüsü iki komuttur: sbiw r24, 1 iki çevrim sürer ve brne inner dallandığında iki çevrim sürer. Bir tur dört çevrim, 25.000 tur 100.000 çevrim ve bunun 40 geçişi de 4.000.000 yapar. Dış döngü toplamda yaklaşık 120 çevrim ekler; bu da yüz binde üçtür.

The simulator spends the cycles the data sheet gives each instruction, so you can prove this from a sketch. Set Timer 1 to the full clock, so it counts once per CPU cycle, read it, run a known loop, read it again. Fifty turns of nop, dec and brne is 50 times 4 less the one the last brne saves by falling through, which is 199, plus 2 for the lds and 1 for the ldi. It prints 202, every time.

Uzun versiyon da aynı şeyi söyler: 25.000 turluk bir döngünün 160 geçişi 16.000.000 döngüdür ve micros() bunu 1.000.000 ile 1.015.000 mikrosaniye arasında gösterir. Fazladan yarım yüzde, millis()'i ayakta tutan Timer 0'ın kendi kesmesidir; gerçek bir Uno da bunu kaybeder.

Blink'in komutları bir ATmega328P'de kaç saat döngüsüne mal oluyor
KomutDöngüBlink içinde
`ldi`1İki döngü sayacını yükler.
`sbi`, `cbi`2PB5'i çıkış yapar, sonra tersine çevirir.
`sbiw`2r24:r25 içindeki 16 bitlik sayacı 1 azaltır.
`dec`1r18 içindeki dış sayacı 1 azaltır.
`brne`2 dalış, 1 dalmamaHer iki döngüyü de kapatır: iki artı iki, dört çevrimlik turdur.
`rjmp`2Ana döngünün başına geri döner.
`rcall`3Gecikmeyi çağırır.
`ret`4Ondan geri döner.
sketch.ino: bir döngüyü Timer 1'e karşı zamanlamak, 202 yazdırır
void setup() {
  Serial.begin(9600);
  TCCR1A = 0;
  TCCR1B = _BV(CS10);  // clk/1: one count per CPU cycle
  uint8_t start, stop, n;
  noInterrupts();
  asm volatile(
    "lds %[start], %[tcnt]\n\t"
    "ldi %[n], 50\n"
    "1:\n\t"
    "nop\n\t"
    "dec %[n]\n\t"
    "brne 1b\n\t"
    "lds %[stop], %[tcnt]\n\t"
    : [start] "=&r"(start), [stop] "=&r"(stop), [n] "=&d"(n)
    : [tcnt] "i"(&TCNT1L));
  interrupts();
  Serial.println((uint8_t)(stop - start));  // 202
}

void loop() {}

Bu kodu düzenleyicide açSadece kod: düzenleyici, kartı ve koddan okuyabildiği parçaları yerleştirir.

Gecikme döngüsü yerine bir zamanlayıcı kesmesi

Sayılan bir döngü çevrimleri öğrenmek için iyi bir yoldur ama zaman tutmak için kötü bir yoldur, çünkü işlemci sayarken başka hiçbir şey yapamaz. Aşağıda Timer 1, saat 256'ya bölünmüş halde CTC modunda çalışır ve saniyede 62.500 kez sayar, böylece 31.249'luk bir karşılaştırma değeri her yarım saniyede bir gerçekleşir. OCIE1A, TIMSK1 içinde kesmeyi ister ve sei kesmelerin hiç değilse olmasına izin verir.

TIMER1_COMPA_vect, avr/io.h'den gelen bir addır ve aslında vektör tablosunun on birinci girdisi olan __vector_11'dir. Onu .global olarak bildir, etiketi tanımla, başlangıç kodunun tablosu ona atlar. Senin bir işleyicin olmayan her vektör zayıf bir reti alır, böylece başıboş bir kesme sessizce geri döner. reti ile bitir, ret ile değil. Bu işleyici yalnızca üç satıra sığar, çünkü sbi hiçbir bayrak değiştirmez.

main.S: Timer kesmesi başlangıç dosyası
; Timer 1 interrupts twice a second and the handler toggles pin 13 (PB5).
; main only sets the timer up; the LED is all the interrupt's work.

#include <avr/io.h>

    .section .text
    .global main
main:
    sbi  _SFR_IO_ADDR(DDRB), DDB5
    ; CTC mode, clock / 256: 16 MHz / 256 = 62,500 counts a second,
    ; so a compare at 31,249 is every 0.5 s.
    ldi  r16, hi8(31249)
    sts  OCR1AH, r16                  ; high byte first
    ldi  r16, lo8(31249)
    sts  OCR1AL, r16
    clr  r16
    sts  TCCR1A, r16
    ldi  r16, (1 << WGM12) | (1 << CS12)
    sts  TCCR1B, r16
    ldi  r16, (1 << OCIE1A)           ; interrupt on compare match A
    sts  TIMSK1, r16
    sei
idle:
    rjmp idle

; TIMER1_COMPA_vect is __vector_11; the vector table jumps here.
    .global TIMER1_COMPA_vect
TIMER1_COMPA_vect:
    sbi  _SFR_IO_ADDR(PINB), PINB5    ; toggle the LED (SBI changes no flags)
    reti

Bir koddan assembly çağırmak

Arduino çekirdeğinden vazgeçmek zorunda değilsin. sketch.ino'yu tut, blink.S adında bir sekme ekle, ikisi birlikte derlenir ve bağlanır, tıpkı Arduino IDE'nin bir kodun yanında bir .S dosyası derlemesi gibi. Serial, millis() ve pinMode() çalışmaya devam eder.

The join is extern "C", which stops C++ from mangling the name, and the AVR calling convention, which decides where the values are. Arguments arrive in r24, then r22, then r20; a result goes back in r24, or r25:r24 when it is two bytes. r1 must be zero again on return, and r2 to r17, r28 and r29 belong to the caller. It works in both directions: here the sketch calls led_toggle, and led_toggle calls bump, an ordinary C function back in the sketch.

blink.S: kodun çağırdığı, kodu geri çağıran bir sekme
#include <avr/io.h>

; void led_toggle(void): toggle pin 13, then count it in C.
    .global led_toggle
led_toggle:
    sbi  _SFR_IO_ADDR(PINB), PINB5
    call bump                 ; a C function of the sketch
    ret

Yanındaki kod

Pin 13'te bir LED ve 220 ohmluk bir dirençle çalıştır: seri monitör 1, 2, 3, 4, 5 yazarken LED her 250 milisaniyede bir geçiş yapar. Bu, tek bir işlevi assembly ile yazılmış Arduino çekirdeğidir. Birkaç komut için, yukarıdaki çevrim sayan koddaki gibi, kısıtlamalarla satır içi asm volatile daha az seremoni gerektirir.

sketch.ino: diğer yarısı
extern "C" void led_toggle(void);
extern "C" volatile int bumps;
volatile int bumps = 0;
extern "C" void bump(void) { bumps++; }

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  led_toggle();
  Serial.println(bumps);
  delay(250);
}

Bu kodu düzenleyicide açSadece kod: düzenleyici, kartı ve koddan okuyabildiği parçaları yerleştirir.

Hata ayıklayıcıda izlemek

Assembly'nin bir simülatörde bir tezgahtakinden üstün olduğu yer burasıdır. .S sekmenin bir satırının yanındaki cilt payına tıkla ve oraya bir kesme noktası gider, tıpkı bir C satırında olduğu gibi, çünkü derlemenin kaydettiği satır numaraları sekmenin kendisine aittir. Çalıştır'a bas ve kart, devresiyle birlikte orada durur.

Hata Ayıklama sekmesi nerede durduğunu gösterir, sreg'i bayraklarıyla açıkça yazdığı çekirdeğin kendi kayıtlarını, globals için bir izleme listesi sunar ve Ters Derleme'yi: program sayacının çevresindeki komutları, her satır bir adres, baytlar, komut ve geldiği kaynak satırı olacak şekilde gösterir. Yukarıdaki sekmenin sbi satırında dur ve satır sbi 0x3, 0x5 olarak okunur, ki _SFR_IO_ADDR(PINB), PINB5'in gerçek anlamı budur. Komutu adımla tam bir komut çalıştırır ve listeyi yeniden çizer.

Derlenmediğinde ve başka neler çalıştığında

Hatalar doğru sekme ve satıra düşer, altlarında bir cümle olur. Yanlış yazılmış bir komut "lid" bir AVR komutu değildir der ve bir etiketin iki nokta ile bittiğini hatırlatır. add r16, 5 sessiz olanıdır: LLVM'nin çeviricisi onu add r16, r5 olarak okur, bu yüzden Mokxi bunun yerine add iki yazmaç alır, 5 ise bir sabittir diyerek durur ve subi r16, -5'i gösterir, çünkü AVR'de ADDI yoktur.

Assembly burada yalnızca AVR'a özgü bir şey değil. Bir .S veya .s sekmesi, derlemesi yapılan her kartta çalışır ve Pico ile STM32F411 Black Pill'de, dosyanızın vektör tablosu dahil tüm program olduğu ARM Thumb'da aynı dört başlangıç dosyası bulunur. Nano ve 16 MHz Pro Mini, Uno ile aynı çiptir. Aşağıda bağlantısı verilen yardım merkezindeki Assembly yazma makalesi, geri kalanı için başvuru kaynağıdır.

Bu devreyi düzenleyicide aç. Arduino Uno: pin 13'te bir LED, yanıp sönen, bu sayfanın üstünde çalıştığı haliyle kablolanmış. Bir parçayı ya da değeri değiştir ve yeniden çalıştır.

Devreyi aç

Sorular

Tarayıcıda bir Arduino için gerçekten assembly yazabilir miyim?

Evet. .S ya da .s ile biten bir sekme ekle ve kodunla birlikte derlenir ve bağlanır, tıpkı Arduino IDE'nin derlediği gibi. Ya da kartın Firmware panelinde "Assembly (Arduino yok)" altından bir başlangıç projesi seç ve kartın tamamı altında Arduino çekirdeği olmayan tek bir main.S olur.

Bir .S dosyası ile bir .s dosyası arasındaki fark nedir?

Büyük .S önce C ön işlemcisinden geçer, yani #include <avr/io.h> ve #define içinde çalışır. Küçük .s ise yazıldığı haliyle doğrudan derleyiciye verilir.

PORTB doğru yazmaçken neden sbi PORTB, 5 başarısız olur?

Bir .S dosyasında PORTB adı, avr-libc'deki gibi veri adresi olan 0x25'tir ve sbi I/O adresi olan 0x05 ister. _SFR_IO_ADDR(PORTB) yaz ya da include'un üstüne #define __SFR_OFFSET 0 koy.

Çevrim sayıları gerçek bir çiptekiyle aynı mı?

Evet, komutlar için aynıdır. Simüle edilen ATmega328P, veri sayfasının her komuta verdiği çevrimleri harcar, böylece nop, dec ve brne'den 50 tur, tam saatte Timer 1'de 202 sayar.

Assembly kodunu bir kerede bir komut adımlayabilir miyim?

Evet. Kesme noktaları bir .S sekmesinin satırlarında çalışır ve Hata Ayıklama sekmesi, durma noktasının çevresindeki komutları her birinin kaynak satırıyla gösterir. Komutu adımla tam bir tanesini çalıştırır.

Bunu gerçekten kur

Düzenleyiciyi aç, bir değeri değiştir ve sayının onunla birlikte değiştiğini izle. Kurulacak bir şey yok, hesaba da gerek yok.