Belajar

AVR assembly di browser, di Arduino Uno simulasi

Pemula

Atau lihat semua pelajaran.

  • 526komponen di meja kerja
  • 46board sedang berjalan
  • 1.00xwaktu nyata, di semua board
Arduino Uno: LED di pin 13, berkediplive0.000 s 0.00x
Klik untuk membukanya di editor
Blink bawaan, dalam bahasa C, dengan LED dan resistor 220 ohm di pin 13. Buka di editor dan pilih Blink dalam assembly untuk menjalankan LED yang sama dari main.S.

Arduino Uno adalah ATmega328P, dan di balik setiap sketch ia menjalankan kode mesin AVR: 32 register, satu byte flag, dan instruksi yang masing-masing membutuhkan jumlah siklus clock yang sudah diketahui. Mokxi memungkinkan kamu menulis layer itu langsung. Tambahkan tab .S di samping sketch-mu, atau jadikan seluruh board proyek assembly tanpa Arduino core sama sekali, lalu tekan Jalankan.

Halaman ini membahas blink yang diberikan editor kepadamu: apa yang dilakukan tiap instruksi, mengapa PORTB menjadi dua angka berbeda, dan bagaimana loop berhitung menjadi tepat 250 milidetik. Lalu interrupt timer, dan debugger yang membacanya kembali satu instruksi demi satu instruksi.

Rangkaian di atas adalah blink bawaan biasa, ditulis dalam bahasa C. Untuk menjalankan versi assembly, buka di editor, pilih Uno, lalu pilih **Blink dalam assembly** di bawah **Assembly (tanpa Arduino)** pada panel Firmware. File di board menjadi satu main.S saja.

Blink dalam assembly, baris demi baris

Tidak ada yang disembunyikan di bawah program ini: tidak ada setup(), tidak ada loop(), tidak ada interrupt millis() di latar belakang. Kode startup mengosongkan r1, meletakkan stack di puncak RAM dan memanggil main. Setelah itu, setiap siklus yang dihabiskan chip adalah yang kamu tulis sendiri. #include <avr/io.h> bisa dipakai karena file .S melewati preprocessor C lebih dulu, dan file itu memberimu nama register dan bit.

sbi mengatur satu bit dari satu register I/O. Yang pertama menjadikan PB5, pin yang bertanda 13, sebagai output. Yang kedua adalah trik yang patut kamu tahu: menulis 1 ke satu bit PINB akan mengubah (toggle) bit yang sama di PORTB, dalam satu instruksi dua siklus tanpa pembacaan dan tanpa mask. Lalu rcall memanggil delay, ret kembali, dan rjmp loop mengulang lagi.

main.S: starter Blink, seperti yang diberikan panel Firmware kepadamu
; 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

Register-register, dan mana yang boleh kamu pakai

Chip memiliki 32 register umum, r0 sampai r31, masing-masing satu byte, diakses dalam satu siklus. Setengah atasnya istimewa: ldi, yang memuat sebuah konstanta, hanya bekerja pada r16 sampai r31, itulah sebabnya blink menyimpan counter-nya di r18, r24 dan r25. Tulis ldi r3, 5 dan build berhenti dengan pesan ldi hanya bekerja pada r16 sampai r31, dan r3 bukan salah satunya.

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.

Register AVR yang ditemui program assembly pertama
RegisterApa iniYang perlu diwaspadai
r0Byte serbaguna, `__tmp_reg__`. `lpm` menulis ke sini secara default.Compiler memakainya, jadi tidak ada nilai yang bertahan melewati sebuah call.
r1Always zero, `__zero_reg__`.`mul` menulis ke r1:r0, jadi lakukan `clr r1` setelahnya.
r2 sampai r17Umum, tapi milik pemanggil.Push dan pop jika fungsimu memakainya.
r16 sampai r31Setengah atas.`ldi`, `cpi`, `subi`, `andi` dan `ori` hanya bekerja di sini.
r18 sampai r27, r30, r31Bebas dipakai di dalam fungsimu.Fungsi C yang kamu panggil bisa menimpanya.
r24, r26, r28, r30Pasangan yang dikerjakan `adiw` dan `sbiw`.r24:r25 juga membawa argumen dan hasil 16-bit.
X, Y, Zr26:r27, r28:r29, r30:r31: pointer-pointer itu.Hanya Z yang membaca flash, dengan `lpm`. Y adalah frame pointer milik C.
SREGFlag-flagnya: I T H S V N Z C.Diatur oleh aritmetika dan compare, bukan oleh `sbi`, `ldi` atau `mov`.

Alamat I/O dan alamat data: mengapa PORTB adalah 0x25 dan 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().

Kalau salah, Mokxi menghentikan build sebelum alat apa pun berjalan, karena kesalahan itu akan dirakit menjadi program yang menulis register yang keliru. sbi PORTB, 5 memberi pesan PORTB di sini adalah alamat data 0x25, dan sbi mengambil alamat I/O-nya: tulis _SFR_IO_ADDR(PORTB), yaitu 0x05. Register di atas alamat I/O 63, seperti TCCR1B, tidak punya bentuk pendek sama sekali: pakai lds dan sts.

Bit yang sama, tiga cara
; 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

Menghitung siklus: 4.000.000 siklus untuk 250 ms

Tidak ada delay() di sini, jadi delay-nya adalah loop yang kamu hitung sendiri. Uno berjalan pada 16 MHz, jadi satu siklus adalah 62,5 nanodetik dan 250 milidetik adalah 4.000.000 siklus. Inner loop blink terdiri dari dua instruksi: sbiw r24, 1 memakan dua siklus, dan brne inner memakan dua saat melompat. Satu putaran empat siklus, 25.000 putaran berarti 100.000 siklus, dan 40 kali perulangan menghasilkan 4.000.000 itu. Outer loop menambah sekitar 120 siklus seluruhnya, yaitu tiga dari seratus ribu.

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.

Versi panjangnya juga setuju: 160 kali perulangan loop 25.000 putaran adalah 16.000.000 siklus, dan micros() menaruhnya antara 1.000.000 dan 1.015.000 mikrodetik. Setengah persen tambahan itu adalah interrupt Timer 0 sendiri, yang menjaga millis() tetap berjalan, dan Uno sungguhan juga kehilangan waktu untuk itu.

Biaya instruksi-instruksi blink pada ATmega328P, dalam siklus clock
InstruksiSiklusDalam blink
`ldi`1Memuat dua loop counter.
`sbi`, `cbi`2Menjadikan PB5 output, lalu mengubahnya (toggle).
`sbiw`2Mengurangi 1 dari counter 16-bit di r24:r25.
`dec`1Mengurangi 1 dari counter luar di r18.
`brne`2 jika lompat, 1 jika tidakMenutup kedua loop: dua ditambah dua menjadi empat siklus perputaran.
`rjmp`2Kembali ke awal loop utama.
`rcall`3Memanggil delay.
`ret`4Kembali dari pemanggilan.
sketch.ino: mengukur waktu sebuah loop dengan Timer 1, yang mencetak 202
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() {}

Buka sketch ini di editorKodenya saja: editor menempatkan board dan komponen yang bisa dibacanya dari sketch.

Interrupt timer sebagai pengganti loop delay

Loop berhitung itu cara yang bagus untuk belajar siklus, tapi cara yang buruk untuk mengukur waktu, karena prosesor tidak bisa melakukan hal lain saat menghitung. Di bawah ini, Timer 1 berjalan dalam mode CTC pada clock dibagi 256, menghitung 62.500 kali per detik, jadi nilai compare 31.249 tiba setiap setengah detik. OCIE1A di TIMSK1 meminta interrupt dan sei mengizinkan interrupt terjadi.

TIMER1_COMPA_vect adalah nama dari avr/io.h, dan sebenarnya dia adalah __vector_11, entri kesebelas dari tabel vektor. Deklarasikan dengan .global, definisikan labelnya, dan tabel dari kode startup akan melompat ke sana. Setiap vektor tanpa handler dari kamu akan mendapat reti weak, jadi interrupt liar akan kembali dengan diam-diam. Akhiri dengan reti, bukan ret. Handler ini muat dalam tiga baris hanya karena sbi tidak mengubah flag.

main.S: starter interrupt Timer
; 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

Memanggil assembly dari sebuah sketch

Kamu tidak harus meninggalkan Arduino core. Pertahankan sketch.ino, tambahkan tab bernama blink.S, dan keduanya akan dikompilasi dan di-link bersama, seperti Arduino IDE mem-build .S di samping sebuah sketch. Serial, millis() dan pinMode() tetap berfungsi.

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: tab yang dipanggil sketch, yang memanggil kembali sketch
#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

Sketch di sampingnya

Jalankan dengan sebuah LED dan resistor 220 ohm di pin 13: Serial Monitor mencetak 1, 2, 3, 4, 5 sementara LED berganti setiap 250 milidetik. Ini Arduino core dengan satu fungsi yang ditulis dalam assembly. Untuk beberapa instruksi saja, asm volatile inline dengan constraints lebih ringkas, seperti pada sketch penghitung siklus di atas.

sketch.ino: separuh lainnya
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);
}

Buka sketch ini di editorKodenya saja: editor menempatkan board dan komponen yang bisa dibacanya dari sketch.

Melihatnya di debugger

Di sinilah assembly di simulator mengungguli assembly di meja kerja. Klik gutter di samping sebuah baris pada tab .S milikmu dan breakpoint akan dipasang di sana, sama seperti pada baris C, karena nomor baris yang dicatat build adalah nomor baris tab itu sendiri. Tekan Jalankan dan board akan berhenti di sana, lengkap dengan rangkaiannya.

Tab Debug menunjukkan tempat ia berhenti, register milik core dengan sreg dijabarkan sebagai flag-flagnya, daftar watch untuk variabel global, dan Disassembly: instruksi-instruksi di sekitar program counter, setiap baris berisi alamat, byte-nya, instruksinya, dan baris sumber asalnya. Berhenti di baris sbi pada tab di atas dan barisnya terbaca sbi 0x3, 0x5, itulah makna sebenarnya dari _SFR_IO_ADDR(PINB), PINB5. Step instruction menjalankan tepat satu instruksi dan menggambar ulang daftarnya.

Saat gagal dikompilasi, dan apa lagi yang bisa berjalan

Error muncul di tab dan baris yang tepat dengan satu kalimat di bawahnya. Instruksi yang salah tulis akan menampilkan "lid" is not an AVR instruction dan mengingatkanmu bahwa sebuah label diakhiri titik dua. add r16, 5 adalah yang diam-diam: assembler LLVM membacanya sebagai add r16, r5, jadi Mokxi malah berhenti dengan add takes two registers, and 5 is a constant dan menunjuk ke subi r16, -5, karena AVR tidak punya ADDI.

Assembly di sini bukan hanya urusan AVR. Tab .S atau .s berfungsi di setiap board yang bisa dikompilasi, dan Pico serta STM32F411 Black Pill punya empat starter yang sama dalam ARM Thumb, di mana file-mu adalah seluruh programnya, lengkap dengan tabel vektor. Nano dan Pro Mini 16 MHz memakai chip yang sama dengan Uno. Artikel Writing assembly di pusat bantuan, link-nya di bawah, adalah referensi untuk sisanya.

Buka rangkaian ini di editor. Arduino Uno: sebuah LED di pin 13, berkedip, dirangkai seperti yang berjalan di bagian atas halaman ini. Ubah sebuah komponen atau nilainya dan jalankan lagi.

Buka rangkaian ini

Pertanyaan

Bisakah aku benar-benar menulis assembly untuk Arduino di browser?

Bisa. Tambahkan tab berakhiran .S atau .s dan ia akan dirakit serta di-link dengan sketch-mu, seperti cara Arduino IDE mem-build-nya. Atau pilih starter di bawah "Assembly (no Arduino)" di panel Firmware board dan seluruh board menjadi satu main.S tanpa Arduino core di bawahnya.

Apa bedanya file .S dan file .s?

.S huruf besar melewati C preprocessor dulu, jadi #include <avr/io.h> dan #define berfungsi di dalamnya. .s huruf kecil langsung diberikan ke assembler apa adanya.

Mengapa sbi PORTB, 5 gagal padahal PORTB register yang benar?

Di file .S nama PORTB adalah alamat datanya, 0x25, seperti di avr-libc, dan sbi butuh alamat I/O, 0x05. Tulis _SFR_IO_ADDR(PORTB), atau letakkan #define __SFR_OFFSET 0 di atas include.

Apakah jumlah siklusnya sama dengan chip sungguhan?

Sama, untuk instruksinya. ATmega328P yang disimulasikan menghabiskan siklus sesuai data sheet untuk setiap instruksi, jadi 50 putaran nop, dec dan brne menghitung 202 pada Timer 1 dengan clock penuh.

Bisakah aku menjalankan assembly satu instruksi per satu langkah?

Bisa. Breakpoint berfungsi di baris-baris tab .S, dan tab Debug menunjukkan instruksi di sekitar titik henti beserta baris sumber asal masing-masing. Step instruction menjalankan tepat satu di antaranya.

Rakit versi nyatanya

Buka editor, ubah sebuah nilai, dan lihat angkanya ikut berubah. Tidak ada yang perlu dipasang, dan tidak perlu akun.