Bagian 1 Perakitan ARM TI RSLK Robotika Pembelajaran Kurikulum Lab 7 STM32 Inti: 16 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:55

Fokus dari Instructable ini adalah mikrokontroler STM32 Nucleo. Motivasi selama ini untuk bisa membuat proyek perakitan dari tulang belulang. Ini akan membantu kita menggali lebih dalam dan memahami proyek Launchpad MSP432 (TI-RSLK) yang telah menjadi topik beberapa Instructables.

Tidak banyak bantuan online untuk membuat proyek khusus perakitan untuk MSP432, menggunakan Code Composer Studio. Sampai sekarang kami hanya menyalin/menempel dari proyek perakitan yang sudah ada sebelumnya. Pendekatan ini telah membantu kami dengan baik.

Namun, sekarang, untuk Lab 7, kami mengalami sedikit masalah. Atau setidaknya cegukan sementara. Lab 7 memperkenalkan finite-state-machine, dan hal pertama yang kami temui adalah kebutuhan untuk membuat dan menggunakan array nilai. Karena kursus TI terutama menggunakan pemrograman C - ini bukan masalah. Tetapi Instructable ini berfokus pada perakitan, bukan C.

Lebih lanjut, karena array adalah nilai read-only, akan lebih baik untuk memasukkannya ke dalam memori flash, bukan RAM.

Tampaknya ada lebih banyak bantuan online untuk proyek perakitan menggunakan STM32 MCU, jadi, kita mulai dengan Instruksi ini, dengan tujuan menggunakan apa yang dipelajari, untuk kemudian diterapkan ke MSP432 dan Code Composer Studio.

Dalam perjalanan menuju tujuan itu, kita juga akan mendapatkan pengalaman dengan mikrokontroler populer lainnya.

Langkah 1: Tes Awal Perangkat

Sekali lagi, mengapa memilih Nucleo STM32 secara khusus?

Sejujurnya? Karena saya sedang mencari artikel bagus tentang proyek perakitan bare-metal untuk pengontrol ARM, dan saya menemukan seri ini. Dan juga karena STM32 tampaknya menjadi MCU yang populer.

Saya memang melakukan riset (ada banyak versi untuk dipilih - lihat gambar di atas), tetapi pada akhirnya itu menjadi apa yang sebenarnya bisa saya dapatkan, karena saya akan menggunakan Amazon (di AS).

Itu datang dalam paket sederhana namun profesional, dengan beberapa instruksi start-up. Agak lucu melihat demo yang dibakar ke pengontrol hampir persis seperti yang kami lakukan di Instructables sebelumnya - LED berkedip dan mengubah kecepatan sesuai dengan menekan tombol.

Tampaknya papan pengembangan ini sangat mirip dengan MSP432 karena ada 2 LED, dan satu tombol tekan pengguna. MSP432 memiliki 2 tombol pengguna.

Seperti yang Anda lihat di foto, saya sedikit terkejut bahwa papan ini memiliki mini dan bukan micro USB. Harus kehabisan untuk membeli kabel.

Tes bagus lainnya adalah ketika Anda menghubungkannya ke komputer Anda (saya menggunakan kotak Linux), itu muncul di manajer file saya, sebagai sistem file, yang disebut "NODE_F303RE". Pembukaan yang mengungkapkan dua file, satu HTML dan satu teks.

Itu saja, tetapi setidaknya dikatakan konektivitas tampaknya cukup mudah.

Sekarang kita siap untuk memulai.

Saya akan mencoba untuk tidak mengulangi informasi bagus apa pun dari seri artikel IVONOMICON Bare Metal, melainkan menambahnya.

Langkah 2: Yang Penting

Hal pertama yang kita butuhkan adalah compiler.

Dan kemudian, kita membutuhkan debugger:

devchu@chubox:~$ sudo apt-get install gdb-arm-none-eabiMembaca daftar paket… Selesai Membangun pohon ketergantungan Membaca informasi status… Selesai Paket BARU berikut akan diinstal: gdb-arm-none-eabi 0 ditingkatkan, 1 baru diinstal, 0 untuk dihapus dan 8 tidak ditingkatkan. Perlu mendapatkan arsip 2.722 kB. Setelah operasi ini, 7, 738 kB ruang disk tambahan akan digunakan. Dapatkan:1 https://us.archive.ubuntu.com/ubuntu xenial/universe amd64 gdb-arm-none-eabi amd64 7.10-1ubuntu3+9 [2, 722 kB] Diambil 2, 722 kB dalam 1 detik (1, 988 kB/s) Memilih paket yang sebelumnya tidak dipilih gdb-arm-none-eabi. (Membaca database … 262428 file dan direktori yang saat ini diinstal.) Bersiap untuk membongkar …/gdb-arm-none-eabi_7.10-1ubuntu3+9_amd64.deb … Membongkar gdb-arm-none-eabi (7.10-1ubuntu3+9) … Memproses pemicu untuk man-db (2.7.5-1) … Menyiapkan gdb-arm-none-eabi (7.10-1ubuntu3+9) …

Langkah 3: Hal-Hal Penting - Windows

Langkah di atas diasumsikan kita menggunakan Linux. Bagaimana jika kita menggunakan Windows?

Anda dapat pergi ke situs Pengembang lengan, dan ada beberapa opsi unduhan yang tersedia. Saya menggunakan mesin Windows 8.

Selama instalasi, saya memilih untuk menginstalnya ke drive "C:\" root daripada Program Files hanya karena saya juga menggunakan cygwin, dan lebih mudah untuk membuat tautan dari bin lokal saya ke folder root C: daripada semua berantakan di jalur ke Program Files (dengan spasi, dll).

Jadi, lingkungan dan jalur cygwin saya, dll, terlihat seperti ini:

C:\cygwin64\home\bin\arm-none-eabi-gcc, di mana arm-none-eabi-gcc adalah tautan ke C:\GNUToolsArmEmbedded\7.2018.q2.update\bin\arm-none-eabi- gcc.

Saya kemudian membuat folder "dev" di bawah cygwin home, dan di sanalah saya meletakkan file core. S dan menjalankan perintah kompiler. (lihat lebih lanjut di bawah untuk hal-hal kompiler).

Saya melakukan hal yang sama persis untuk gdb (arm-none-eabi-gdb).

Langkah 4: Apa yang Penting?

Jadi apa itu "gcc-arm-none-eabi"?

Kompilator gnu (GCC) akan mengkompilasi bahasa pemrograman (seperti C) ke dalam kode asli untuk mesin yang dijalankannya. Misalnya, jika Anda mengkompilasi beberapa kode C menggunakan GCC di mesin Windows Anda, kode itu akan dibuat untuk dijalankan di mesin Windows. Eksekusi yang dihasilkan tidak akan (biasanya) berjalan pada mikrokontroler ARM.

Jadi, untuk membangun program yang akan diunduh dan dibakar ke dalam mikrokontroler ARM (dalam kasus kami saat ini yang akan menjadi STM32 Nucelo), kami perlu memberikan sesuatu yang lain kepada GCC: kemampuan untuk "mengkompilasi silang". Artinya, kemampuan untuk menghasilkan executable, bukan untuk sistem aslinya (dan prosesor), tetapi untuk sistem target (kontroler mikro ARM). Di situlah "gcc-arm-none-eabi" berperan.

Jadi apa itu "gdb-arm-none-eabi"?

Setelah kami mengunduh dan membakar (mem-flash) executable yang baru dibuat ke dalam mikrokontroler, kami mungkin ingin men-debug-nya - langkah demi baris kode. GDB adalah debugger gnu, dan juga membutuhkan cara untuk melakukan tugasnya, tetapi menargetkan sistem yang berbeda.

Jadi, gdb-arm-none-eabi adalah untuk GDB, apa gcc-arm-none-eabi adalah untuk GCC.

Instalasi paket lain yang disarankan adalah "libnewlib-arm-none-eabi". Apa itu?

Newlib adalah perpustakaan C dan perpustakaan matematika yang dimaksudkan untuk digunakan pada sistem tertanam. Ini adalah konglomerasi dari beberapa bagian perpustakaan, semuanya di bawah lisensi perangkat lunak bebas yang membuatnya mudah digunakan pada produk yang disematkan.

Dan akhirnya, paket "libstdc++-arm-none-eabi". Yang itu cukup jelas; itu adalah pustaka C++ untuk kompiler silang; untuk mikrokontroler ARM tertanam.

Langkah 5: File Linker

Mari kita buat skrip tautan.

Satu bagian atau blok kunci dalam file ini adalah perintah MEMORY.

--- dari sourceware.org:

Konfigurasi default linker mengizinkan alokasi semua memori yang tersedia. Anda dapat menimpa ini dengan menggunakan perintah MEMORY. Perintah MEMORY menjelaskan lokasi dan ukuran blok memori di target. Anda dapat menggunakannya untuk menjelaskan wilayah memori mana yang dapat digunakan oleh penaut, dan wilayah memori mana yang harus dihindari. Anda kemudian dapat menetapkan bagian ke wilayah memori tertentu. Penaut akan menetapkan alamat bagian berdasarkan wilayah memori, dan akan memperingatkan tentang wilayah yang menjadi terlalu penuh. Penaut tidak akan mengacak bagian agar sesuai dengan wilayah yang tersedia. Skrip tautan mungkin berisi banyak kegunaan dari perintah MEMORY, namun, semua blok memori yang ditentukan diperlakukan seolah-olah mereka ditentukan di dalam satu perintah MEMORY. Sintaks untuk MEMORY adalah:

PENYIMPANAN

{ nama [(attr)]: ASAL = asal, PANJANG = len … }

Contoh dalam artikel:

/* Menentukan akhir RAM dan batas memori tumpukan *//* (4KB SRAM pada baris STM32F031x6, 4096 = 0x1000) */ /* (RAM dimulai pada alamat 0x20000000) _estack = 0x20001000;

PENYIMPANAN

{ FLASH (rx): ASAL = 0x08000000, PANJANG = 32K RAM (rxw): ASAL = 0x20000000, PANJANG = 4K }

Jadi kita perlu mencari tahu berapa banyak FLASH (untuk program dan konstanta kita, dll) dan berapa banyak RAM (untuk digunakan oleh program; heap dan stack, dll) untuk papan khusus kita. Ini menjadi sedikit menarik.

Kartu kecil yang bagus yang datang dengan Nucleo mengatakan bahwa ia memiliki memori flash 512 Kbytes, dan SRAM adalah 80 Kbytes. Namun, menghubungkannya ke USB, itu akan dipasang sebagai sistem file dengan dua file, dan pengelola file dan GParted menunjukkan itu memiliki lebih dari 540+ Kbytes ruang. (RAM?).

TETAPI, mencoba menghapus dua file menggunakan pengelola file, memutuskan sambungan lalu menyambungkan kembali perangkat, masih menampilkan dua file. (dan pengelola file memang mengenali sesuatu karena ada ikon "kunci" kecil di setiap file.

Jadi mari kita pergi dengan angka-angka di kartu. Jadi sekarang kami mengambil contoh di atas dan mengubahnya menjadi papan khusus kami.

Anda mungkin ingin menggunakan sesuatu seperti konverter memori online ini, untuk beralih dari KB umum ke jumlah byte tertentu.

Maka Anda mungkin ingin menggunakan pengonversi desimal ke heksadesimal online.

/* Tentukan akhir RAM dan batas memori tumpukan */

/* (4KB SRAM pada baris STM32F031x6, 4096 = 0x1000) *//* contoh*/

/* langkah 1: (80KB SRAM pada STM32F303RE, 81920 = 0x14000) *//* board kami */

/* langkah 2, tambahkan ukuran hex ke alamat awal hex (di bawah). */

/* (RAM dimulai dari alamat 0x20000000) */

_tumpukan = 0x20001000; /* Contoh */

_estack = 0x20014000; /* papan kita */

PENYIMPANAN {

FLASH (rx): ASAL = 0x08000000, PANJANG = 512K

RAM (rxw): ASAL = 0x20000000, PANJANG = 80K

}

Sebut saja file di atas "linker.script.ld".

Langkah 6: Tabel Vektor

Sekarang kita akan membuat file assembly kecil (dengan arahan) untuk melakukan penanganan interupsi yang sangat mendasar. Kami akan mengikuti contoh artikel dan membuat file bernama "core. S".

Sekali lagi, ini adalah contoh isi file, tetapi saya membuat perubahan untuk papan khusus kami:

// Instruksi ini mendefinisikan atribut chip kami dan

// bahasa assembly yang akan kita gunakan:.syntax unified /* Lihat di bawah setelah area kode ini */ /*.cpu cortex-m0 */ /*komentari baris contoh ini */.cpu cortex-m4 /* tambahkan sebagai gantinya korteks papan kami. lihat gambar di atas pada langkah ini */ /*.fpu softvfp */ /* beri komentar pada baris contoh ini */.fpu vfpv4 /* tambahkan papan kami; itu memang memiliki FPU */.thumb // Lokasi memori global..global vtable.global reset_handler /* * Tabel vektor sebenarnya. * Hanya ukuran RAM dan pengendali 'reset' yang * disertakan, untuk kesederhanaan. */.type vtable, %object vtable:.word _estack.word reset_handler.size vtable,.-vtable

Hmm.. Tidak ada '.align' Directive

Namun, itu tidak kritis. Lebih lanjut tentang itu (mungkin) nanti.

.sintaks terpadu

.sintaks [bersatu | terbagi]

Arahan ini mengatur Sintaks Set Instruksi seperti yang dijelaskan di bagian ARM-Instruction-Set

9.4.2.1 Sintaks Set Instruksi Dua sintaks yang sedikit berbeda adalah dukungan untuk instruksi ARM dan THUMB. Default, dibagi, menggunakan gaya lama di mana instruksi ARM dan THUMB memiliki sintaks terpisah sendiri. Sintaks terpadu yang baru, yang dapat dipilih melalui direktif.syntax.

.fpu vfpv4

Kompiler GCC dapat menghasilkan binari dengan beberapa opsi mengenai floating point: lunak - cocok untuk berjalan pada CPU tanpa FPU - perhitungan dilakukan dalam perangkat lunak oleh kompiler yang dihasilkan softfp - cocok untuk berjalan pada CPU dengan atau tanpa FPU - akan menggunakan FPU jika ada. Untuk kasus khusus kami (Anda harus melakukan riset sendiri), FPU papan khusus ini sesuai dengan vfpv4. Anda mungkin harus bermain dengan ini. Atau bahkan biarkan di softfp.

.jempol (vs.lengan)

Mikrokontroler ARM ini sebenarnya memiliki campuran set instruksi. Salah satunya adalah ARM, yang lain adalah THUMB. Satu perbedaan adalah instruksi 16-bit vs instruksi 32-bit. Dengan demikian, direktif ini memberi tahu kompiler untuk memperlakukan instruksi selanjutnya sebagai THUMB atau ARM.

Kami hanya akan mengambil sisa file apa adanya karena Instructables ini belum mempelajari pemrograman perakitan yang digerakkan oleh interupsi.

Langkah 7: Versi Perakitan dari Program 'Hello World'

Berikut ini juga dapat masuk ke file "core. S" yang dibuat sebelumnya. Ini, sekali lagi, dari contoh di artikel.

/* * Pengendali Reset. Dipanggil saat reset. */.type reset_handler, %function reset_handler: // Atur penunjuk tumpukan ke akhir tumpukan. // Nilai '_estack' didefinisikan dalam skrip linker kami. LDR r0, =_tumpukan MOV sp, r0

// Tetapkan beberapa nilai dummy. Ketika kita melihat nilai-nilai ini

// di debugger kami, kami akan tahu bahwa program kami // dimuat pada chip dan berfungsi. LDR r7, =0xDEADBEEF MOVS r0, #0 main_loop: // Tambahkan 1 untuk mendaftarkan 'r0'. TAMBAHKAN r0, r0, #1 // Ulangi kembali. B main_loop.size reset_handler,.-reset_handler

Jadi, tujuan dari program di atas adalah memuat pola yang dapat dikenali ke dalam satu register MCU inti (dalam hal ini R7), dan nilai peningkatan mulai dari nol ke dalam register MCU inti lainnya (dalam hal ini R0). Jika kita melangkah melalui kode yang dieksekusi, kita akan melihat peningkatan data R0.

Jika Anda telah mengikuti Instruksi tentang MSP432 dan kursus/lab TI-RSLK, maka hampir semua program di atas pasti sudah tidak asing lagi bagi Anda.

Satu hal baru yang saya lihat adalah penggunaan "=" saat memuat "DEADBEEF" untuk mendaftar R7. Kami tidak menggunakan itu.

File "core. S" yang dilampirkan di sini sekarang berisi sumber lengkap.

Langkah 8: Menyusun Kode

Saatnya melakukan beberapa hal baris perintah. Sesuatu yang nyata, akhirnya.

Namun, kami tidak cukup sampai di sana. Kami sekali lagi harus mengubah perintah yang diberikan dalam artikel, dan memodifikasinya ke situasi kami sendiri.

Berikut contoh kodenya:

arm-none-eabi-gcc -x assembler-with-cpp -c -O0 -mcpu=cortex-m0 -mthumb -Wall core. S -o core.o

Jika kita pergi ke situs gnu.org untuk GCC, (dalam hal ini versi 7.3),

x

-x adalah untuk menentukan bahasa. Sebaliknya jika tidak ada -x, maka compiler akan mencoba menebak dengan menggunakan ekstensi file. (dalam kasus kami, *. S).

Contoh di atas dari artikel menentukan assembler-with-cpp, tapi kita bisa melakukan assembler.

C

-c mengatakan kompilasi tetapi jangan tautkan.

O0

The -O adalah untuk mengatur tingkat optimasi. Menggunakan -O0 (oh-nol) mengatakan "kurangi waktu kompilasi dan buat debugging menghasilkan hasil yang diharapkan. Ini adalah default".

mcpu=korteks-m0

-mcpu menentukan nama prosesor target. Dalam kasus kami, itu akan menjadi korteks-m4.

jempol

-mthumb menentukan pemilihan antara menghasilkan kode yang mengeksekusi status ARM dan THUMB.

Dinding

The -Wall tentu saja sangat umum dan terkenal. Itu menyalakan semua bendera peringatan.

Akhirnya, di akhir perintah kita memiliki file input core. S dan file output core.o.

Berikut adalah baris perintah baru yang dihasilkan agar sesuai dengan kasus khusus kami.

arm-none-eabi-gcc -x assembler -c -O0 -mcpu=cortex-m4 -mthumb -Wall core. S -o core.o

Dan itu dikompilasi.

Langkah 9: Menautkan Program

Langsung dari contoh di artikel, kami memiliki ini:

arm-none-eabi-gcc core.o -mcpu=cortex-m0 -mthumb -Wall --specs=nosys.specs -nostdlib -lgcc -T./STM32F031K6T6.ld -o main.elf

Sebagian besar hal di atas pernah Anda lihat. Di bawah ini adalah apa yang baru.

specs=nosys.specs

Yang satu ini agak sulit untuk dijelaskan.

Ini ada hubungannya dengan "semihosting" dan "penargetan ulang", dan itu ada hubungannya dengan input/output. Ini juga ada hubungannya dengan panggilan sistem dan perpustakaan.

Biasanya, sistem tertanam tidak menyediakan perangkat input/output standar. Ini akan memengaruhi panggilan sistem atau pustaka (contoh: printf()).

Semihosting berarti debugger (lihat gambar Langkah 11 dengan bagian debugger dilingkari merah) memiliki saluran khusus dan menggunakan protokol semihosting, dan Anda dapat melihat output printf() pada mesin host (melalui debugger).

Penargetan ulang, di sisi lain, berarti bahwa sistem atau panggilan perpustakaan yang sama itu berarti sesuatu yang lain. Mereka melakukan sesuatu yang lain, yang masuk akal untuk sistem tertanam. Dalam arti tertentu, katakanlah untuk printf(), ada implementasi baru, implementasi yang ditargetkan ulang dari fungsi itu.

Setelah mengatakan semua itu, --specs=nosys.specs berarti kita tidak akan menjadi semihosting. Itu biasanya berarti kita melakukan penargetan ulang. Itu membawa kita ke bendera berikutnya.

nostdlib

Opsi tautan -nostdlib digunakan untuk menautkan program yang dimaksudkan untuk dijalankan secara mandiri. -nostdlib menyiratkan opsi individual -nodefaultlibs dan -nostartfiles. Di bawah ini kita membahas dua opsi secara terpisah, tetapi penggunaan yang paling umum hanyalah nostdlib untuk one-stop shopping. Saat menautkan program yang dihosting, pustaka sistem standar seperti libc ditautkan secara default, memberikan akses program ke semua fungsi standar (printf, strlen dan teman). Opsi penaut -nodefaultlibs menonaktifkan penautan dengan pustaka default tersebut; satu-satunya pustaka yang ditautkan adalah pustaka yang Anda beri nama secara eksplisit ke tautan menggunakan tanda -l.

lgcc

libgcc.a adalah pustaka standar yang menyediakan subrutin internal untuk mengatasi kekurangan mesin tertentu. Misalnya, prosesor ARM tidak menyertakan instruksi pembagian. Versi ARM dari libgcc.a menyertakan fungsi pembagian dan kompiler mengeluarkan panggilan ke fungsi tersebut jika diperlukan.

T

Ini hanyalah cara untuk memberi tahu tautan agar menggunakan file ini sebagai skrip tautan. Dalam kasus kami, nama filenya adalah linker.script.ld.

o main.elf

Akhirnya, kami memberi tahu tautan apa yang akan menjadi nama file gambar keluaran akhir yang akan dibakar/di-flash ke perangkat kami.

Berikut adalah versi baris perintah lengkap kami, dimodifikasi untuk situasi khusus kami:

arm-none-eabi-gcc core.o -mcpu=cortex-m4 -mthumb -Wall --specs=nosys.specs -nostdlib -lgcc -T./linker.script.ld -o main.elf

Kami memastikan bahwa file skrip, dan file core.o, keduanya berada di direktori yang sama, tempat kami akan menjalankan baris perintah di atas.

Dan itu terhubung tanpa masalah.

Cek

Kami kemudian menjalankan:

arm-none-eabi-nm main.elf

dan kita mendapatkan:

devchu@chubox:~/Development/Atollic/TrueSTUDIO/STM32_workspace_9.1$ arm-none-eabi-nm main.elf 20014000 A _estack 08000010 t main_loop 08000008 T reset_handler 08000000 T vtable

Kelihatan bagus. Perintah arm-none-eabi-nm adalah cara untuk membuat daftar simbol di dalam file objek.

Langkah 10: Menguji Koneksi ke STM32 Nucleo-64

Misi pertama Anda, jika Anda memilih untuk menerimanya, adalah membuat sistem Anda melihat papan pengembangan Anda.

Menggunakan Windows

Untuk Windows, saya memutuskan untuk menginstal TrueSTUDIO dari Atollic (versi gratis). Itu adalah instalasi yang tidak menyakitkan dan secara otomatis menginstal driver sehingga saya dapat menggunakan st-link untuk menguji koneksi. Setelah saya menginstal TrueSTUDIO dan manajer perangkat melihat perangkat, saya mengunduh alat texan/stlink yang disarankan oleh artikel Bare Metal yang telah kami ikuti. Saya kembali menempatkan folder langsung di bawah "C:\", dan sekali lagi membuat beberapa tautan dari bin rumah cygwin lokal saya ke perintah.

ln -s /c/STM32. MCU/stlink-1.3.0-win64/bin/st-info.exe ~/bin/st-info

Sebagai tes awal untuk melihat apakah kami benar-benar dapat berkomunikasi dengan perangkat, saya menjalankan:

st-info --probe

Dan kembali:

Ditemukan 1 pemrogram stlink

Jadi sekarang kami tahu bahwa kami dapat berbicara/meminta papan pengembangan kami.

Menggunakan Linux

Untuk linux, Anda tidak benar-benar membutuhkan driver. Tetapi untuk Debian, Anda harus membuat alat st dari sumber.

git clone

Pastikan Anda telah menginstal libusb-1.0-0-dev.

daftar yang tepat | grep -E "*libusb.*dev*"

Anda harus melihat:

libusb-1.0-0-dev/xenial, sekarang 2:1.0.20-1 amd64 [dipasang]

atau semacam itu.

Untuk menginstalnya:

sudo apt-get install libusb-1.0-0-dev

Perhatikan bahwa di atas tidak sama dengan:

sudo apt-get install libusb-dev

libusb dev yang hilang dengan benar dapat menyebabkan cmake mengalami masalah.

Kesalahan CMake: Variabel berikut digunakan dalam proyek ini, tetapi disetel ke NOTFOUND. Harap atur atau pastikan variabel tersebut disetel dan diuji dengan benar dalam file CMake: LIBUSB_INCLUDE_DIR (ADVANCED)

Ubah ke direktori root proyek (…blah/blah /stlink). Lakukan "rilis".

Setelah itu membangun, alat harus berada di bawah ".. /build/Release".

Anda kemudian dapat menjalankan "st-info --probe". Inilah output dengan Nucleo terhubung, lalu tidak.

devchu@chubox:~/Development/stlink$./build/Release/st-info --probeFound 1 stlink programmer serial: 303636414646353034393535363537 openocd: "\x30\x36\x36\x41\x46\x46\x35\x30\x34\ x39\x35\x35\x36\x35\x37" flash: 524288 (ukuran halaman: 2048) sram: 65536 chipid: 0x0446 descr: F303 perangkat kepadatan tinggi devchu@chubox:~/Development/stlink$./build/Release/st- info --probe Ditemukan 0 pemrogram stlink devchu@chubox:~/Development/stlink$

Langkah 11: Mari Gunakan GDB Dengan Linux

Jika Anda telah mencoba semua ini, dan Anda sudah sejauh ini - bagus! Bagus sekali. Mari kita bersenang-senang sedikit sekarang.

Ketika Anda membeli papan pengembangan ARM ini, apakah itu Launchpad MSP432 dari Texas Instruments, atau yang sedang kita diskusikan sekarang, Nucleo-F303 (STM32 Nucleo-64), mereka biasanya tiba sudah di-flash dengan program yang sedang berjalan, biasanya beberapa program berkedip yang juga termasuk menekan tombol untuk mengubah kecepatan LED berkedip.

Sebelum kita terlalu cepat menulisnya, mari kita lihat apa yang bisa dilihat dan dilakukan.

Dengan Linux, buka terminal, ubah direktori proyek git stlink yang baru saja kita buat, dan temukan alat st-util.

devchu@chubox:~/Pengembangan/stlink$ temukan. -nama st-util

./build/Release/src/gdbserver/st-util

Jalankan alat itu. Karena sebelumnya kita telah menguji koneksi kita dengan st-info --probe, kita akan mendapatkan beberapa output seperti ini:

st-util 1.4.0-50-g7fafee2 2018-10-20T18:33:23 INFO common.c: Memuat parameter perangkat…. 2018-10-20T18:33:23 INFO common.c: Perangkat yang terhubung adalah: F303 perangkat kepadatan tinggi, id 0x10036446 2018-10-20T18:33:23 INFO common.c: Ukuran SRAM: 0x10000 byte (64 KiB), Flash: 0x80000 byte (512 KiB) di halaman 2048 byte 2018-10-20T18:33:23 INFO gdb-server.c: Chip ID adalah 00000446, Core ID adalah 2ba01477. 2018-10-20T18:33:23 INFO gdb-server.c: Mendengarkan di *:4242…

Itulah server GDB yang berjalan sekarang, dan ia melihat papan pengembangan kami, dan yang lebih penting, ia mendengarkan pada port 4242 (port default).

Sekarang kita siap untuk menjalankan klien GDB.

Di Linux, buka terminal lain, masukkan ini:

arm-none-eabi-gdb -tui

Itu sama saja dengan menjalankan gdb secara ketat baris perintah, namun malah menghasilkan terminal berbasis teks (tebakan saya adalah ia menggunakan kutukan).

Kami menjalankan klien GDB dan server GDB. Namun, klien tidak terhubung ke server. Saat ini ia tidak tahu apa-apa tentang Nucleo kami (atau papan pilihan Anda). Kita harus menceritakannya. Di terminal, Prompt Anda sekarang harus menjadi "(gdb)". Memasuki:

bantu target

Ini akan memberi Anda daftar. Perhatikan bahwa yang kita inginkan adalah target extended-remote - Gunakan komputer jarak jauh melalui jalur serial.

Tapi kita juga harus memberikan lokasinya. Jadi, pada prompt (gdb), masukkan:

(gdb) menargetkan localhost jarak jauh yang diperluas: 4242

Anda harus mendapatkan kembali respons seperti ini:

(gdb) menargetkan localhost jarak jauh yang diperluas: 4242

Debugging jarak jauh menggunakan localhost:4242 0x080028e4 di ?? ()

Sementara itu, di terminal yang menjalankan st-util gdbserver, kami mendapatkan ini:

2018-10-20T18:42:30 INFO gdb-server.c: Ditemukan 6 register breakpoint hw

2018-10-20T18:42:30 INFO gdb-server.c: GDB tersambung.

Langkah 12: Mari Ulangi, Dengan Windows dan Flash Program Kami

Langkah-langkah untuk menjalankan st-util gdbserver, dan klien arm-none-eabi-gdb pada dasarnya sama seperti yang kita lakukan pada Langkah sebelumnya. Anda membuka dua terminal (cygwin, DOS cmd, atau Windows Powershell), cari lokasi st-util, jalankan. Di terminal lain, jalankan klien arm-none-eabi-gdb. Satu-satunya perbedaan adalah bahwa mode -tui (tampilan teks berbasis terminal) kemungkinan besar tidak didukung.

Jika hal di atas berfungsi di Windows, maka Anda mungkin harus berhenti (hanya klien). Pada titik ini, entah bagaimana Anda harus menjalankan klien GDB tempat file build Anda ("core.out"), atau menambahkan seluruh jalur ke file itu sebagai argumen ke klien GDB.

Saya menyederhanakan hidup saya dengan menggunakan cygwin dan membuat tautan dari direktori $HOME//bin lokal saya ke tempat kedua alat itu berada.

Ok, kita sudah mengkompilasi dan menautkan seperti sebelumnya, dan kita memiliki file main.elf yang siap untuk di-flash.

Kami memiliki st-util yang berjalan di satu jendela. Kami memulai kembali klien GDB, kali ini kami melakukan:

arm-none-eabi-gdb main.elf

Kami membiarkannya memulai, menunggu prompt (gdb), lakukan perintah koneksi yang sama ke server GDB (st-util), dan kami siap untuk mem-flash file yang dapat dieksekusi. Ini sangat anti-iklim:

(gdb) memuat

Berjalan dengan terminal cygwin, ada masalah yang diketahui dengan terkadang perintah konsol tidak keluar. Jadi dalam kasus kami, jendela yang menjalankan server benar-benar diam. Yang menjalankan klien, tempat kami menjalankan beban, menampilkan ini:

Memuat bagian.teks, ukuran 0x1c lma 0x8000000Alamat awal 0x8000000, memuat ukuran 28 Kecepatan transfer: 1 KB/detik, 28 byte/tulis.

Langkah 13: Flashing Dengan Linux - Lebih Berharga:D

Langkah 14: Mari Menyelam Sedikit Lebih Dalam

Jika Anda sampai di sini, luar biasa. Mari kita lanjutkan.

Mengapa tidak melihat ke dalam file main.elf, yang dapat dieksekusi? Jalankan yang berikut ini:

arm-none-eabi-objdump -d main.elf

Anda akan melihat output seperti ini:

main.elf: format file elf32-littlearm

Pembongkaran bagian.text:

08000000:

8000000: 00 40 01 20 09 00 00 08.@. ….

08000008:

8000008: 4802 ldr r0, [pc, #8]; (8000014) 800000a: 4685 mov sp, r0 800000c: 4f02 ldr r7, [pc, #8]; (8000018) 800000e: 2000 gerakan r0, #0

08000010:

8000010: 3001 menambahkan r0, #1 8000012: e7fd b.n 8000010 8000014: 20014000.word 0x20014000 8000018: deadbeef.word 0xdeadbeef

Nugget kecil apa yang bisa kita dapatkan dari output di atas?

Jika Anda ingat kembali ketika kami membahas dan membuat file linker.script.ld, kami menyatakan bahwa perangkat ARM ini memiliki RAM mulai dari 0x20000000, dan memori FLASH dimulai pada 0x08000000.

Dengan demikian, kita dapat melihat bahwa memang programnya sedemikian rupa sehingga semuanya berada di memori FLASH.

Kemudian, di atas, tetapi Langkah selanjutnya, ketika kami sedang membahas bagian "Hello World", ada pernyataan di mana kami memuat nilai literal langsung, konstan, ("0xDEADBEEF") ke dalam register inti MCU ("R7").

Pernyataan itu adalah:

LDR R7, =0xDEADBEEF

Dalam kode kami, itu adalah satu-satunya tempat di mana kami bahkan menyebutkan DEADBEEF. Tidak ada tempat lain. Namun, jika Anda melihat instruksi yang dibongkar/direkonstruksi di atas, dll, ada lebih banyak hal yang terkait dengan DEADBEEF daripada yang kami duga.

Jadi, compiler/linker entah bagaimana memutuskan untuk mem-flash nilai DEADBEEF secara permanen ke alamat FLASH, di lokasi 0x8000018. Dan kemudian, kompiler mengubah instruksi LDR kami di atas menjadi:

LDR R7, [PC, #8]

Itu bahkan menghasilkan komentar untuk kami. Bagusnya. Dan itu memberitahu kita untuk mengambil nilai penghitung program saat ini (register PC), tambahkan 0x8 ke nilai itu, dan di sanalah DEADBEEF telah dibakar, dan dapatkan nilai itu dan masukkan ke dalam R7.

Jadi itu juga berarti bahwa penghitung program (PC) menunjuk ke alamat 0x8000010, yang merupakan awal dari main_loop, dan bahwa nilai DEADBEEF berada di dua alamat setelah akhir dari main_loop.

Langkah 15: Akhirnya, Sekilas tentang Program yang Berjalan

Bahkan jika Anda keluar dari GDB, cukup masukkan kembali perintahnya. Anda bahkan tidak perlu memberikan file apa pun; kami tidak berkedip lagi, hanya menjalankannya.

Setelah Anda menghubungkan kembali klien GDB ke server GDB, pada prompt perintah (gdb):

(gdb) info register

Anda akan melihat sesuatu seperti ini:

r0 0x0 0

r1 0x0 0 r2 0x0 0 r3 0x0 0 r4 0x0 0 r5 0x0 0 r6 0x0 0 r7 0x0 0 r8 0x0 0 r9 0x0 0 r10 0x0 0 r11 0x0 0 r12 0x0 0 sp 0x20014000 0x20014000 fflx 0x20014000

Tapi kemudian, pada prompt (gdb), masukkan:

(gdb) lanjutkan

Dan dengan sangat cepat tekan CTRL-C. Itu harus menghentikan program. Masukkan perintah "info registers" lagi.

Kali ini terlihat berbeda:

(gdb) info register

r0 0x350ffa 3477498 r1 0x0 0 r2 0x0 0 r3 0x0 0 r4 0x0 0 r5 0x0 0 r6 0x0 0 r7 0xdeadbeef 3735928559 r8 0x0 0 r9 0x0 0 r10 0x0 0 r10 0x0 0 r12 0x0 0ff r11 0x0 0ff 16777216

Apa yang terjadi? Persis apa yang kami inginkan. DEADBEEF dimuat ke R7, dan R0 telah meningkat (sangat cepat). Jika Anda ulangi, Anda akan melihat R0 lagi dengan nilai lain.

Langkah 16: Kami Ingin Membuat Array Read-Only di Flash

Salah satu cara untuk membuat ekuivalen dari array menggunakan assembly dan directives, adalah sebagai berikut:

.type myarray, %object // nama atau label 'myarray' didefinisikan sebagai tipe objek.

myarray: // ini adalah awal dari deklarasi 'myarray' // (terdiri dari apa)..word 0x11111111 //anggota atau nilai pertama yang terdapat dalam 'myarray'..word 0x22222222 //nilai kedua (alamat bersebelahan)..word 0x33333333 //dan seterusnya..size myarray,.-myarray // compiler/assembler sekarang tahu di mana akhir atau // batas 'myarray'.

Sekarang kita telah mengaturnya di memori FLASH, kita dapat menggunakannya dalam program. Di bawah ini adalah sebagian:

LDR R1, myarray // ini memuat data yang ada di lokasi pertama 'myarray'.' // ini bukan yang kita inginkan.

LDR R1, =myarray // ini memuat nilai lokasi itu sendiri (alamat pertama), // bukan datanya.. // ini yang kita inginkan.

MOV R2, #0 // R2 akan menghitung untuk memastikan kita tidak pergi

// akhir larik. LDR R3, =myarrsize // R3 akan sama dengan 'myarrsize'.

// R0 akan menyimpan data kita

main_loop:

LDR R0, [R1] // Muat data yang ditunjuk oleh R1 ('myarray') ke R0. CMP R2, R3 // Apakah kita berada di batas array? BEQ main_loop // Jika ya, kita sudah selesai, jadi kita akan mengulang selamanya.

ADD R2, #1 // Jika tidak, kita dapat terus melakukan iterasi melalui array.

ADD R1, #4 // Tambahkan 4 ke register R1, jadi menunjuk dengan benar ke next

// alamat..

B main_loop // Ulangi kembali.

Video melewati semua ini, dan ada bug di dalamnya. Ini baik; itu menunjukkan bahwa itu penting menjalankan dan men-debug kode. Ini menunjukkan kasus klasik berjalan dari ujung array.