Ketika mencari bootloader untuk mikrokontroler STM8S103F3, ditemukan bahwa bootloader yang tersedia terutama ditulis dalam "C", "mencuri" sejumlah besar memori FLASH, dan mentransfer tabel vektor interupsi.
Bootloader diperlukan untuk beberapa perangkat yang tidak mungkin menghubungkan programmer.
Diputuskan untuk mencoba menulis sendiri bootloader dengan persyaratan berikut:
- loader harus disebut STM8uLoader;
- Kode harus ditulis dalam assembler (manfaat assembler belum dilarang secara hukum);
- bootloader harus menempati jumlah terkecil yang mungkin dalam memori FLASH, jumlah yang ditempati di komputer akan dianggap tidak terbatas;
- loader tidak boleh memindahkan tabel vektor interupsi;
- bootloader harus memiliki fungsionalitas minimal, semua fungsi utama harus diambil alih oleh komputer;
- bootloader harus mentransfer kontrol ke program aplikasi dalam waktu yang wajar setelah reset / power-on jika tidak ada koneksi ke komputer.
Kondisi pertama
dipenuhi secara instan, tetapi persyaratan berikutnya harus dikerjakan.
Tahap pertama. Kode 65 byte dalam memori FLASH
Untuk menyimpan tabel vektor di tempatnya, diputuskan untuk menempatkan kode di akhir memori FLASH dan segera beralih ke sana dari vektor dump $ 8000.
Saat boot, kontrol ditransfer ke kode bootloader dengan harga $ 9FC2. Bootloader mengkonfigurasi UART 9600 8N1, menunggu dua byte pada UART, dan tanpa menunggu, mentransfer kontrol ke program aplikasi di alamat yang disimpan dalam pasangan yang $ 9FFE: $ 9FFF.
Jika loader menerima byte tinggi dan rendah dari ukuran dump yang diharapkan dari program host, ia mengambil dump itu sendiri, menempatkan dump dalam memori RAM dan mentransfer kontrol ke sana.
Selanjutnya, semua perawatan terletak pada program di komputer dan dump yang dikirimkannya. Seharusnya mengirimkan persis dump yang diperlukan untuk menyelesaikan tugas saat ini (baca / hapus / tulis / salin sel memori STM8). Dumps harus dapat saling menggantikan dalam memori RAM dan mentransfer kontrol ke program aplikasi.
Alamat transisi ke aplikasi adalah $ 9FFE: $ 9FFF.
File boot_FLASH.asm:stm8/ TITLE "boot_FLASH.asm" .NOLIST #include "STM8S103F3P.inc" .LIST MOTOROLA WORDS segment byte at 8000 'boot_start' boot_start: jp boot_FLASH_start dc.b $00 ; boot_FLASH ; ******************************************************** ; 0x8004...0x9FC1 WORDS ; segment byte at 8004 'main_FLASH' main_FLASH_start: ldw X, #$03FF ldw SP, X mov UART1_BRR1, #13 mov UART1_CR2, #%00001100 main_FLASH_cycle: callr main_delay ; bset PB_DDR,#5 bset PB_CR1,#5 ; byte1_tx: mov UART1_DR, #$80 byte1_wait_tx btjf UART1_SR, #7, byte1_wait_tx callr main_delay boot_RAM_exit1: ; bres PB_DDR,#5 ; bres PB_CR1,#5 ; ; byte2_tx: mov UART1_DR, #$08 byte2_wait_tx btjf UART1_SR, #7, byte2_wait_tx jra main_FLASH_cycle main_delay: decw X jrne main_delay ret segment byte at 9FC2 'boot_FLASH' boot_FLASH_start: mov UART1_BRR1, #13; Fmaster=16/8=2/9600/16 mov UART1_CR2, #%00001100; / ; UART1 RST_SR boot_FLASH_RST_SR_tx: mov UART1_DR, RST_SR ; , ; ; X ( 200 ) ldw X,#0 boot_FLASH_wait_byte1: decw X jreq boot_FLASH_exit; btjf UART1_SR, #5, boot_FLASH_wait_byte1 ; , , ; X ld A, UART1_DR ld XH, A ; boot_FLASH_wait_byte2: btjf UART1_SR, #5, boot_FLASH_wait_byte2 ; ld A, UART1_DR ld XL, A ; X - ; X ldw Y, #$0400 ; Y 0x0400 (RAM_END + 1) ; boot_FLASH_rx_block_wait: btjf UART1_SR, #5, boot_FLASH_rx_block_wait boot_EEPROM_rx_block_entry: decw Y ; Y ld A, UART1_DR ld (Y), A decw X ; X jrne boot_FLASH_rx_block_wait ; jp (Y) ; () boot_FLASH_exit: dc.b $CC boot_FLASH_exit_addr: dc.w main_FLASH_start end ;
Tahap kedua. Ukuran kode 21 byte dalam FLASH dan 52 byte dalam memori EEPROM
Memilih 65 byte dari memori FLASH (dalam STM8S103F3 hanya 8192 byte) tidak manusiawi. Lagi pula, memori EEPROM yang tidak perlu dengan 640 byte-nya terletak di dekatnya. Mari kita membagi kode bootloader menjadi dua bagian boot_FLASH dan boot_EEPROM.
Saat memuat, kontrol ditransfer ke kode boot_FLASH seharga $ 9FEF. boot_FLASH menyalin gambar kode boot_EEPROM dari EEPROM ke dalam memori RAM dan mentransfer kontrol ke sana.
Sekarang boot_EEPROM mengkonfigurasi UART 9600 8N1, menunggu byte UART, dan tanpa menunggu, mentransfer kontrol ke program aplikasi (kami akan meninggalkan alamat di tempat yang sama $ 9FFE: $ 9FFF).
Jika boot_EEPROM menerima byte dengan ukuran dump yang diharapkan untuk memori RAM, dibutuhkan dump berikutnya, menempatkan dump di area memori RAM lain dan mentransfer kontrol ke sana.
Selanjutnya, semuanya seperti pada tahap pertama.
File boot_FLASH_EEPROM.asm: stm8/ TITLE "boot_FLASH_EEPROM.asm" .NOLIST #include "STM8S103F3P.inc" .LIST MOTOROLA WORDS segment byte at 4000 'eeprom' ; boot_EEPROM dc.b $35, $0D, $52, $32, $35, $0C, $52, $35 dc.b $35, $01, $52, $31, $5A, $27, $16, $72 dc.b $0B, $52, $30, $F8, $C6, $52, $31, $72 dc.b $0B, $52, $30, $FB, $3B, $52, $31, $4A dc.b $26, $F5, $96, $5C, $FC, $CE, $9F, $FE dc.b $2B, $FA, $90, $AE, $42, $7F, $AE, $02 dc.b $7F, $CC, $9F, $F4 segment byte at 8000 'boot_start' boot_start: jp boot_FLASH_start dc.b $01 ; boot_FLASH_EEPROM ; ******************************************************** ; 0x8004...0x9FEE segment byte at 8004 'main_FLASH' ; main_FLASH_start: ldw X, #$03FF ldw SP, X mov UART1_BRR1, #13 mov UART1_CR2, #%00001100 main_FLASH_cycle: callr main_delay ; bset PB_DDR,#5 bset PB_CR1,#5 ; byte1_tx: mov UART1_DR, #$80 byte1_wait_tx btjf UART1_SR, #7, byte1_wait_tx callr main_delay boot_RAM_exit1: ; bres PB_DDR,#5 ; bres PB_CR1,#5 ; ; byte2_tx: mov UART1_DR, #$08 byte2_wait_tx btjf UART1_SR, #7, byte2_wait_tx jra main_FLASH_cycle main_delay: decw X jrne main_delay ret ; EEPROM -> RAM segment byte at 9FEF 'boot_FLASH' boot_FLASH_start: ldw X, SP ; Y <- { EEPROM_START + RAM_END} ; Y <- { $4000 + $03FF = $43FF } ldw Y, #$43FF boot_FLASH_copy: ld A, (Y) ld (X), A decw Y decw X jrpl boot_FLASH_copy incw X jp (X) boot_FLASH_exit_address: dc.w main_FLASH_start end ;
Jalankan file
runSTM8uLoader.bat , tekan tombol reset di papan tulis, bootloader mengirimkan byte 0x01. Sebuah dump dengan kode dari file main_RAM.hex dikirim ke RAM STM8 melalui UART. Papan mulai berkedip LED dan mengirimkan byte 0x20 dan 0x02. Tekan tombol reset lagi. Program aplikasi dari memori FLASH diluncurkan, LED mulai berkedip lebih cepat dan mengirimkan byte 0x80 dan 0x08.
Tahap ketiga. Ukuran kode 18 byte dalam memori FLASH dan 52 byte dalam OPTION Bytes
Tentu saja, kami bergegas dengan memori EEPROM. Di mana menyimpan sinus dan meja lainnya sekarang? Dan dengan memori FLASH, tidak semuanya jelas. Siapa yang memutuskan untuk menyimpan alamat kontrol transfer program aplikasi dalam memori FLASH? Dan byte yang sama dari versi bootloader umumnya disimpan di dua tempat sekaligus. Di mana memeras 52 byte yang ditujukan untuk EEPROM?
Di sini, litografi membantu kita. Memori EEPROM terdiri dari 10 blok masing-masing 64 byte. Menambahkan blok lain ke blok ini, tetapi dengan ukuran yang berbeda, tidak layak secara ekonomi. STMicroelectronics melakukan hal itu, menambahkan blok 64-byte lainnya, menamakan area ini OPTION Bytes dan menyimpan pengaturan mikrokontroler non-volatil yang penting di sana (untuk STM8S103F3 jumlahnya mencapai 11 byte) Dan tentu saja, STM lupa menyebutkan bahwa masih ada 53 sel fungsional yang tersisa di area ini. Rupanya ada banyak model STM8, Anda harus meninggalkan ruang untuk pengaturan penting di masa depan.
Bootloader kami hanya mengklaim pada model STM8 tanpa bootloader bawaan. Oleh karena itu, kami mengambil sel cadangan blok Byte OPSI sejauh ini tidak ada yang melihat. Benar, ada satu ketidaknyamanan kecil,
tetapi diselesaikan ,. Seorang programmer konvensional tidak akan memungkinkan Anda untuk menulis informasi ke sel-sel ini.
Saat memuat, kontrol ditransfer ke kode copy_boot_FLASH awal pada $ 9FF2. boot_FLASH mentransfer gambar bootloader boot_OPTION dari area OPTION Bytes ke RAM.
boot_OPTION mengkonfigurasi UART 9600 8N1, mengirimkan byte UART dengan versinya, menunggu byte UART dari program host, dan tanpa menunggu 0,2 detik transfer kontrol ke program aplikasi pada alamat yang terletak di pasangan $ 4831: $ 4832.
Jika boot_OPTION, setelah mengirim byte dengan versinya, mengambil satu byte dari ukuran dump yang diharapkan, maka itu mengambil dump itu sendiri, menempatkan dump ke dalam memori RAM dan mentransfer kontrol ke sana.
Selanjutnya, semua perawatan terletak pada program di komputer dan dump yang dikirimkannya. Seharusnya mengirimkan persis dump yang diperlukan untuk menyelesaikan tugas saat ini (baca / hapus / tulis / salin sel memori STM8). Dumps harus dapat saling menggantikan dalam memori RAM dan mentransfer kontrol ke program aplikasi.
Alamat transisi ke aplikasi adalah $ 4831: $ 4832.
Loader dan kode aplikasi untuk dijalankan dalam memori FLASH: stm8/ TITLE "boot_FLASH_OPTION.asm" .NOLIST #include "STM8S103F3P.inc" .LIST MOTOROLA WORDS segment byte at 4800 'boot_OPTION' ; boot_OPTION dc.b $00, $00, $FF, $00, $FF, $00, $FF, $00 dc.b $FF, $00, $FF, $35, $0D, $52, $32, $35 dc.b $0C, $52, $35, $35, $25, $52, $31, $5A dc.b $27, $16, $72, $0B, $52, $30, $F8, $C6 dc.b $52, $31, $72, $0B, $52, $30, $FB, $3B dc.b $52, $31, $4A, $26, $F5, $96, $5C, $FC dc.b $AE, $80, $04, $2B, $FA, $90, $AE, $42 dc.b $7F, $AE, $02, $7F, $CC, $9F, $F6, $00 segment byte at 8000 'boot_start' boot_start: ldw X, SP jp boot_FLASH_start ; ******************************************************** ; 0x8004...0x9FF1 segment byte at 8004 'main_FLASH' ; main_FLASH_start: ldw X, #$03FF ldw SP, X mov UART1_BRR1, #13 mov UART1_CR2, #%00001100 main_FLASH_cycle: callr main_delay ; bset PB_DDR,#5 bset PB_CR1,#5 ; byte1_tx: mov UART1_DR, #$80 byte1_wait_tx btjf UART1_SR, #7, byte1_wait_tx callr main_delay boot_RAM_exit1: ; bres PB_DDR,#5 ; bres PB_CR1,#5 ; ; byte2_tx: mov UART1_DR, #$08 byte2_wait_tx btjf UART1_SR, #7, byte2_wait_tx jra main_FLASH_cycle main_delay: decw X jrne main_delay ret ; OPTION -> RAM segment byte at 9FF2 'boot_FLASH' boot_FLASH_start: ; Y <- { OPTION_START + RAM_END} ; Y <- { $4800 + $03FF = $43FF } ldw Y, #$43FF boot_FLASH_copy: ld A, (Y) ld (X), A decw Y decw X jrpl boot_FLASH_copy incw X jp (X) boot_FLASH_exit_address: dc.w main_FLASH_start end ;
Kode aplikasi untuk dieksekusi dalam memori RAM: stm8/ TITLE “boot_RAM.asm” MOTOROLA #include "STM8S103F3P.inc" BYTES segment byte at 0000 'boot_RAM_data' boot_RAM_start: ; pull-up ( ) , , 14 ; ld A, #%01001100 ; [A6 4C] ; cpl A ; [43] ; ld PA_CR1, A ; [C7 50 03] ; ld PB_CR1, A ; [C7 50 08] ; ld PC_CR1, A ; [C7 50 0D] ; ld PD_CR1, A ; [C7 50 12] PD6(UART1_RX), PD2, PD1 ; UART1 / 9600, (8 , , 1 ) ; mov UART1_BRR2, #0 ; [35 00 52 33] Fmaster=16/8=2 9600 mov UART1_BRR1, #13 ; [35 0D 52 32] Fmaster=16/8=2 9600 mov UART1_CR2, #%00001100 ; [35 0C 52 35] UART1_CR2.TEN <- 1 UART1_CR2.REN <- 1 / ; UART1 boot_RAM_byte1_tx: mov UART1_DR, #$02 boot_RAM_byte1_wait_tx btjf UART1_SR, #7, boot_RAM_byte1_wait_tx ldw X,#0 ; [AE 00 00] boot_FLASH X boot_RAM_wait1: decw X ; [5A] jreq boot_RAM_exit1 ; jra boot_RAM_wait1 boot_RAM_exit1: ; bres PB_DDR,#5 ; bres PB_CR1,#5 ; ; UART1 boot_RAM_byte2_tx: mov UART1_DR, #$20 ; [35 11 52 31] boot_RAM_byte2_wait_tx btjf UART1_SR, #7, boot_RAM_byte2_wait_tx ldw X,#0 ; [AE 00 00] boot_FLASH X boot_RAM_wait2: decw X ; [5A] jreq boot_RAM_exit2 ; jra boot_RAM_wait2 boot_RAM_exit2: ; bset PB_DDR,#5 ; bset PB_CR1,#5 ; jra boot_RAM_byte1_tx end
Jalankan file
runSTM8uLoader.bat , tekan tombol reset di papan tulis, bootloader mengirimkan byte 0x25. Sebuah dump dengan kode dari file main_RAM.hex dikirim ke RAM STM8 melalui UART. Papan mulai berkedip LED dan mengirimkan byte 0x20 dan 0x02. Tekan tombol reset lagi. Program aplikasi dari memori FLASH diluncurkan, LED mulai berkedip lebih cepat dan mengirimkan byte 0x80 dan 0x08.
Pada tahap terakhir, untuk menulis image bootloader ke area OPTION Bytes, Anda harus menggunakan
metode ini . Inti dari metode ini adalah bahwa pertama-tama Anda memerlukan programmer untuk menulis file firmware boot_OPTION_rev25.hex ke memori STM8 FLAH, restart mikrokontroler, area Byte OPSI akan diisi dengan informasi yang diperlukan dan LED akan menyala. Kemudian lagi, programmer menulis ke file firmware FLASH dari artikel ini
boot_FLASH_OPTION.hex .
Menambahkan "clean" kode bootloader versi 0x14 tanpa kode aplikasi. Menyebarkan gambar boot_OPTION ke kode sumber. Komentar yang diperbaiki. Berbeda dengan versi $ 25, alamat transfer kontrol aplikasi dalam sel FLASH $ 9FFE: $ 9FFFF. Ukuran dalam FLASH adalah masing-masing 20 byte.
boot_uC_rev14.asm: stm8/ TITLE "boot_uC_rev14.asm" ; boot_uC = boot_OPTION + boot_FLASH MOTOROLA .NOLIST #include "STM8S103F3P.inc" .LIST WORDS ; ******************************************************** segment byte at 4800 'boot_O_IMG' ;0000FF00FF00FF00FF00FF350D523235 ;0C5235351452315A2716720B5230F8C6 ;5231720B5230FB3B52314A26F5965CFC ;CE9FFE2BFA90AE427FAE027FCC9FF400 ; ; $4800 RAM dc.b $00, $00, $FF, $00, $FF, $00, $FF, $00, $FF, $00, $FF ; OPTION (RAM) ; $480B ($0000) boot_O boot_O_start: ; UART 96008N1 Fmaster=16/8=2/9600/16 ; mov UART1_BRR2, #0 ; [35 00 52 33] mov UART1_BRR1, #13 ; [35 0D 52 32] ; UART1_CR2.TEN <- 1 UART1_CR2.REN <- 1 / mov UART1_CR2, #%00001100 ; [35 0C 52 35] ; $4813 ($0008) boot_E_byte1_tx: ; $14 mov UART1_DR, #$14 ; [35 14 52 31] ; , ; ; X ( 200 ) ; clrw X ; [5F] X boot_F ; $4817 ($000C) boot_O_rx_wait_byte: decw X ; [5A] jreq boot_O_exit ; [27 16] btjf UART1_SR, #5, boot_O_rx_wait_byte ; [72 OB 52 30 F8] ; , , A ; $481F ($0014) ld A, UART1_DR ; [C6 52 31] ; $4822 ($0017) boot_O_rx_wait_block: btjf UART1_SR, #5, boot_O_rx_wait_block ; [72 OB 52 30 FB] push UART1_DR ; [3B 52 31] dec A ; [4A] ; A jrne boot_O_rx_wait_block ; [26 F5] ; $482D ($0022) ldw X, SP ; [96] incw X ; [5C] boot_O_exit_to_FLASH: jp (X) ; [FC] ; $4830 ($0025) boot_O_exit: ldw X, boot_F_exit_address ; [CE 9F FE] jrmi boot_O_exit_to_FLASH ; [2B FA] ; if X < $8000 $0000 ; EEPROM boot_O_exit_to_EEPROM: ; Y <- { EEPROM_END} ldw Y, #$427F ; [90 AE 42 7F] ; X <- { EEPROM_END - EEPROM_START } ; EEPROM RAM ldw X, #$027F ; [AE 02 7F] jp boot_F_copy ; [CC 9F F4] ; $483F ($0034) dc.b $00 ; boot_O_end: ; ******************************************************** segment byte at 8000 'RESET_vector' ;96CC9FF0 ldw X, SP ; [96] X <- RAM_END jp boot_F_start ; [CC 9F F0] ; ******************************************************** ; 0x8004...0x9FEF segment byte at 8004 'main_FLASH' ;20FE jra * ; [20 FE] ; ******************************************************** ; boot_FLASH segment byte at 9FF0 'boot_F' ;90AE4C0A90F6F7905A5A2AF85CFC8004 boot_F_start: ; Y <- { boot_O_START + RAM_END} { $480B + $03FF = $4C0A } ldw Y, #$4C0A ; [90 AE 4C 0A] ; ; boot_FLASH, boot_OPTION boot_F_copy: ld A, (Y) ; [90 F6] ld (X), A ; [F7] decw Y ; [90 5A] decw X ; [5A] jrpl boot_F_copy ; [2A F8] X(Y) >= RAM_START(boot_O_START) incw X ; [5C] jp (X) ; [FC] boot_F_exit_address: dc.w $8004 ; [80 04] ; dc.w $0000 ; [00 00] end ;
Menambahkan kode bootloader "bersih" versi 0x25 tanpa kode aplikasi. Menyebarkan gambar boot_OPTION ke kode sumber. Komentar yang diperbaiki. Berbeda dengan versi $ 14, alamat transfer kontrol aplikasi dalam sel $ 4831: $ 4832 dari area Byte OPSI. Ukuran yang ditempati dalam memori FLASH, masing-masing, menurun menjadi 18 byte. Ukuran yang ditempati di area OPTION Bytes tidak berubah (cadangan 52 byte + 1).
boot_uC_rev14.asm: stm8/ TITLE "boot_uC_rev25.asm" ; boot_uC = boot_OPTION + boot_FLASH MOTOROLA .NOLIST #include "STM8S103F3P.inc" .LIST BYTES ; ******************************************************** ; EEPROM ; boot_O_exit_address $0000 ( <$8000) ; ; segment byte at 0000 'boot_O_IMG' main_ram: ;20FE jra * ; [20 FE] WORDS ; ******************************************************** segment byte at 4800 'boot_O_IMG' ;0000FF00FF00FF00FF00FF350D523235 ;0C5235351452315A2716720B5230F8C6 ;5231720B5230FB3B52314A26F5965CFC ;AE80042BFA90AE427FAE027FCC9FF600 ; ; $4800 RAM dc.b $00, $00, $FF, $00, $FF, $00, $FF, $00, $FF, $00, $FF ; OPTION (RAM) ; $480B ($0000) boot_OPTION boot_O_start: ; UART 96008N1 Fmaster=16/8=2/9600/16 ; mov UART1_BRR2, #0 ; [35 00 52 33] mov UART1_BRR1, #13 ; [35 0D 52 32] ; UART1_CR2.TEN <- 1 UART1_CR2.REN <- 1 / mov UART1_CR2, #%00001100 ; [35 0C 52 35] ; $4813 ($0008) boot_E_byte1_tx: ; $14 mov UART1_DR, #$14 ; [35 14 52 31] ; , ; ; X ( 200 ) ; clrw X ; [5F] X boot_F ; $4817 ($000C) boot_O_rx_wait_byte: decw X ; [5A] jreq boot_O_exit ; [27 16] btjf UART1_SR, #5, boot_O_rx_wait_byte ; [72 OB 52 30 F8] ; , , A ; $481F ($0014) ld A, UART1_DR ; [C6 52 31] ; $4822 ($0017) boot_O_rx_wait_block: btjf UART1_SR, #5, boot_O_rx_wait_block ; [72 OB 52 30 FB] push UART1_DR ; [3B 52 31] dec A ; [4A] ; A jrne boot_O_rx_wait_block ; [26 F5] ; $482D ($0022) ldw X, SP ; [96] incw X ; [5C] boot_O_exit_to_FLASH: jp (X) ; [FC] ; $4830 ($0025) boot_O_exit: dc.b $AE ; ldw X, #boot_O_exit_address ; [AE 80 04] ; $4831 ($0026) ; boot_O_exit_address: dc.w main_flash ; [80 04] ; dc.w main_ram ; [00 00] jrmi boot_O_exit_to_FLASH ; [2B FA] ; if X < $8000 $0000 ; EEPROM boot_O_exit_to_EEPROM: ; Y <- { EEPROM_END} ldw Y, #$427F ; [90 AE 42 7F] ; X <- { EEPROM_END - EEPROM_START } ; EEPROM RAM ldw X, #$027F ; [AE 02 7F] jp boot_F_copy ; [CC 9F F4] ; $483F ($0034) dc.b $00 ; boot_O_end: ; ******************************************************** segment byte at 8000-8003 'RESET_vector' ;96CC9FF2 ldw X, SP ; [96] X <- RAM_END jp boot_F_start ; [CC 9F F2] ; ******************************************************** ; 0x8004...0x9FF1 segment byte at 8004 'main_FLASH' main_flash: ;20FE jra * ; [20 FE] ; ******************************************************** ; boot_FLASH segment byte at 9FF2-9FFF 'boot_F' ;90AE4C0A90F6F7905A5A2AF85CFC boot_F_start: ; Y <- { boot_O_START + RAM_END} { $480B + $03FF = $4C0A } ldw Y, #$4C0A ; [90 AE 4C 0A] ; ; boot_FLASH, boot_OPTION boot_F_copy: ld A, (Y) ; [90 F6] ld (X), A ; [F7] decw Y ; [90 5A] decw X ; [5A] jrpl boot_F_copy ; [2A F8] X(Y) >= RAM_START(boot_O_START) incw X ; [5C] jp (X) ; [FC] end ;
Alamat transfer kontrol aplikasi dalam memori FLASH dapat dipilih dari kisaran $ 8004 ... $ 9FF1. Untuk gambar kode aplikasi dari memori EEPROM, transfer kontrol hanya dimungkinkan pada alamat $ 0000 dalam memori RAM.
Program host dapat meneruskan semua alamat transfer kontrol sebagai argumen baris perintah kedua.
Kode sumber program host dapat ditemukan di
sini . Ada juga kontak untuk komunikasi yang lebih rinci.
Saya meminta pembaca untuk kritik dan saran yang ditargetkan untuk pengurangan kode lebih lanjut.
Saya juga mengusulkan untuk membaca artikel
"Cara mengompres bootloader untuk STM8 ke ukuran 8 byte di memori FLASH" .