stm32 kubus cmake vscode

Kode sumber lainnya

Unduh

Lingkungan pengembangan STM32 dengan Visual Studio Code dan CMake

Tutorial ini menjelaskan langkah-langkah untuk mengembangkan dan men-debug aplikasi STM32 secara efektif dalam Visual Studio Code menggunakan generator build CMake , alat build Ninja , dan kompiler GCC .

Hal-hal yang akan Anda pelajari

Cara menginstal dan mengatur semua alat
Cara membuat proyek STM32 baru dengan alat STM32CubeMX atau STM32CubeIDE
Cara memasang dan menyiapkan ekstensi yang direkomendasikan untuk Visual Studio Code untuk pengembangan yang lebih mudah
Cara mengatur daftar CMake dan preset CMake
Cara menghasilkan sistem build untuk kompiler
Cara mengkompilasi proyek dengan GCC
Cara mem-flash dan men-debug aplikasi ke target STM32

Tutorial ini menggunakan sistem operasi Windows . Prosedur serupa akan berlaku untuk sistem operasi Linux dan MAC.

Pemasangan alat

Pembaruan Agustus 2024

Tutorial instalasi alat akan membantu Anda memahami alat yang diperlukan untuk bekerja dengan STM32 dan umumnya baik bagi pemula untuk memahami dengan benar dan memahami persyaratan yang diperlukan.

Sejak beberapa waktu, ST memiliki alat perangkat lunak STM32CubeCLT baru, yang mencakup alat pembangunan yang diperlukan untuk vscode, termasuk sistem pembangunan Ninja dan generator pembangunan CMake . STM32CubeCLT (Command Line Tools) adalah cara sederhana dan mudah untuk mempercepat pengembangan vscode dengan cepat. Ini juga akan mengatur variabel lingkungan build Anda ( Path untuk Windows) secara otomatis, memungkinkan Anda untuk menjalankan ninja , cmake atau perintah lain langsung dari alat baris perintah.

Dengan menginstal STM32CubeCLT , Anda tidak akan mendapatkan alat grafis STM32CubeIDE , Anda juga tidak akan mendapatkan kemampuan alat konfigurasi MCU, melainkan hanya alat baris perintah untuk menjalankan build dan debug, biasanya dari dalam vscode . Anda masih perlu menginstal vscode dan ekstensi yang diperlukan secara terpisah.

STM32CubeIDE

Langkah pertama adalah menginstal STM32CubeIDE, yang akan digunakan untuk memulai proyek STM32 baru dengan mudah dan dilengkapi dengan alat STM32CubeMX terintegrasi - memungkinkan kita melakukan konfigurasi grafis.

STM32CubeIDE juga menyediakan alat yang diperlukan nantinya untuk pengembangan VSCode

Kompiler ARM tidak ada eabi GCC
ST-LINK GDBServer untuk debugging
Alat STM32CubeProgrammer untuk mengunduh kode dan masing-masing driver ST-Link
Folder dengan file STM32 SVD
Driver untuk ST-Link

Pengaturan jalur lingkungan

3 jalur harus ditambahkan ke pengaturan lingkungan dari instalasi STM32CubeIDE, satu jalur untuk masing-masing alat yang disebutkan di atas. Dalam kasus komputer saya, menggunakan STM32CubeIDE 1.8 (diperbarui melalui gerhana, maka jalur instalasi saya yang sebenarnya masih menampilkan versi 1.0.2 ) jalur didefinisikan sebagai:

Kompiler GCC: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346toolsbin
Server ST-Link GDB: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221toolsbin
CLI Pemrogram STM32Cube: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.cubeprogrammer.win32_2.0.100.202110141430toolsbin

Jalur Anda mungkin berbeda pada nomor versi

Verifikasi pengaturan jalur yang benar, jalankan:

arm-none-eabi-gcc --version
STM32_Programmer_CLI --version
ST-LINK_gdbserver --version

Itu akan menghasilkan keluaran yang mirip dengan gambar di bawah

CMembuat

Langkah ini tidak diperlukan jika Anda telah menginstal alat build dengan STM32CubeCLT

Unduh dan instal CMake.

Wizard instalasi akan meminta Anda untuk menambahkan CMake ke jalur lingkungan. Pilih opsi atau tambahkan folder bin dari folder instalasi CMake ke jalur lingkungan.

Ninja

Langkah ini tidak diperlukan jika Anda telah menginstal alat build dengan STM32CubeCLT

Unduh sistem build Ninja dari halaman rilis Github. Itu datang sebagai executable portabel, tanpa perlu menginstal apa pun. Namun hal ini harus terlihat pada tingkat lingkungan, seperti semua alat sebelumnya.

Verifikasi instalasi CMake dan Ninja , jalankan:

cmake --version
ninja --version

Outputnya akan serupa dengan

Kode Visual Studio

Unduh dan instal VSCode. Setelah diinstal dan dibuka, jendela akan terlihat seperti di bawah ini.

Ekstensi Kode Visual Studio

Visual Studio Code adalah editor teks ringan dengan kemampuan untuk memperbesarnya menggunakan ekstensi.

Daftar ekstensi yang berguna untuk pengembangan STM32 menggunakan CMake:

ms-vscode.cpptools : Penyorotan sintaksis dan fitur inti lainnya untuk pengembangan C/C++
ms-vscode.cmake-tools : Alat inti CMake, alat pembuat sistem pembuatan
twxs.cmake : CMembuat penyorotan warna
marus25.cortex-debug : Ekstensi debugging Cortex-M, wajib untuk debug STM32 dari VSCode
dan-c-underwood.arm : Penyorot sintaksis Majelis ARM
zixuanwang.linkerscript : Penyorot sintaksis skrip GCC Linker

Anda dapat menginstalnya dengan menyalin perintah di bawah ini ke jendela terminal internal VSCode.

code --install-extension ms-vscode.cpptools
code --install-extension ms-vscode.cmake-tools
code --install-extension twxs.cmake
code --install-extension marus25.cortex-debug
code --install-extension dan-c-underwood.arm
code --install-extension zixuanwang.linkerscript

Buka Terminal -> Terminal Baru untuk membuka jendela terminal baru

Cara alternatif adalah dengan menggunakan GUI pencarian ekstensi dan menginstal secara manual dari sana.

Alat terpasang - pos pemeriksaan

Pada titik ini, semua alat telah terpasang dengan benar - Anda berada di jalur yang benar menuju kesuksesan.

Pembuatan proyek baru

Persyaratan mendasar untuk maju adalah memiliki proyek kerja yang akan dikonversi ke CMake dan dikembangkan di VSCode . Untuk tujuan ini, saya akan memandu Anda melalui pembuatan proyek baru yang sederhana menggunakan perangkat lunak STM32CubeMX atau STM32CubeIDE .

Anda dapat melewati bagian ini, jika Anda sudah memiliki proyek untuk dikerjakan.

Saya menggunakan alat STM32CubeIDE dan papan STM32H735G-DK untuk demo ini.

Buka STM32CubeIDE dan mulai proyek baru

Pilih STM32 MCU - Saya memilih STM32H735IG yang digunakan pada papan STM32H735G-DK

Pilih nama dan jalur proyek, lalu buat proyek dan tunggu hingga tampilan Pinout terbuka

Tugas kita adalah memiliki proyek sederhana yang akan mengaktifkan LED. LED terhubung ke PC2 dan PC3 masing-masing, aktif RENDAH. Pin dapat dikonfigurasi dalam mode push-pull output atau open-drain

Tetapkan pin sebagai output dengan label opsional masing-masing sebagai LED1 dan LED2

Jika Anda menggunakan STM32CubeMX , buka Manajer proyek , tetapkan nama proyek dan pastikan STM32CubeIDE dipilih sebagai Toolchain .

Buka pengaturan lanjutan dan pilih LL sebagai driver untuk kode yang dihasilkan

Kami menggunakan driver LL demi kesederhanaan dalam tutorial ini

Buat ulang proyek dengan menekan tombol merah atau dengan menyimpan proyek dengan pintasan CTRL + S

Proyek sekarang (kembali) dibuat. File yang disorot kuning adalah sumber untuk dibuat. Biru adalah skrip linker.

Itu saja untuk proses pertama, kami siap untuk mengkompilasinya. Tekan CTRL + B atau klik ikon palu untuk memulai. STM32CubeIDE akan mengkompilasi proyek, Anda akan melihat tampilan seperti pada gambar di bawah. Sekarang siap untuk mem-flash flash MCU dan mulai melakukan debug.

Ini adalah akhir dari bagian pertama, dimana kita berhasil membuat proyek kita. Pada titik ini kami mempertimbangkan proyek siap untuk ditransfer ke sistem pembangunan berbasis CMake.

Anda dapat melanjutkan pengembangan Anda dengan STM32CubeIDE di masa mendatang, menambahkan sumber baru, memodifikasi kode, mengkompilasi, mem-flash biner, dan men-debug mikrokontroler secara langsung. Ini adalah studio pengembangan STM32 pilihan, dikembangkan dan dikelola oleh STMicroelectronics.

Konfigurasi CMake

Diharapkan proyek yang akan dikembangkan di VSCode telah dibuat. Kami akan melanjutkan untuk kompiler GCC, tetapi yang lain juga dapat digunakan.

Dengan dirilisnya Visual Studio Code, banyak pengembang menggunakan alat ini untuk banyak bahasa pemrograman dan untungnya juga dapat mengembangkan aplikasi STM32 dengan satu alat. Jika Anda salah satu pengembang yang menyukai VSCode, cara paling elegan untuk maju adalah dengan mentransfer proyek berbasis STM32CubeIDE ke CMake , mengembangkan kode dalam VSCode dan mengkompilasi dengan sistem build Ninja menggunakan kompiler GCC. Ini cepat dan ringan.

Pengembangan di VSCode ditujukan untuk pengguna tingkat menengah atau berpengalaman. Saya menyarankan kepada semua pemula STM32 untuk tetap menggunakan rantai alat pengembangan STM32CubeIDE . Akan sangat mudah untuk melanjutkan dan membahas topik VSCode nanti.

Siapkan file CMakeLists.txt

Setiap aplikasi berbasis CMake memerlukan file CMakeLists.txt di direktori root , yang menjelaskan proyek dan memberikan informasi masukan untuk pembuatan sistem pembangunan.

File root CMakeLists.txt terkadang disebut file CMake tingkat atas

Hal-hal penting yang dijelaskan dalam file CMakeLists.txt :

Informasi rantai alat, seperti konfigurasi GCC dengan flag build
Nama proyek
File sumber untuk dibuat dengan file kompiler, C, C++, atau Majelis
Daftar jalur penyertaan bagi kompiler untuk menemukan fungsi, definisi, ... ( -I )
Jalur skrip tautan
Definisi kompilasi, atau terkadang disebut definisi praprosesor ( -D )
Pengaturan Cortex-Mxx dan floating point untuk pembuatan set instruksi

Buka VSCode di folder root proyek

Visual Studio Code telah diinstal dan akan digunakan sebagai editor file selanjutnya.

Temukan jalur proyek yang Anda buat dan buka folder dengan VSCode:

Opsi 1: Masuk ke folder dengan explorer, lalu klik kanan dan pilih Open in Code .
Opsi 2: Alternatifnya, buka VScode sebagai solusi kosong baru dan tambahkan folder ke dalamnya secara manual. Gunakan File -> Open Folder... untuk membuka folder
Opsi 3: Buka folder dengan cmd atau alat PowerShell dan jalankan code .

Hasil akhirnya akan terlihat seperti di bawah ini

Informasi rantai alat

CMake perlu mengetahui tentang Toolchain yang ingin kami gunakan untuk mengkompilasi proyek. Karena rantai alat yang sama biasanya digunakan kembali di antara proyek yang berbeda, disarankan untuk membuat bagian ini dalam file terpisah agar lebih mudah digunakan kembali. Ini adalah pengaturan kompiler umum dan tidak terkait langsung dengan proyek itu sendiri.

File .cmake sederhana dapat digunakan dan kemudian digunakan kembali di antara berbagai proyek Anda. Saya menggunakan nama cmake/gcc-arm-none-eabi.cmake untuk tutorial ini dan di bawah ini adalah contohnya:

 set(CMAKE_SYSTEM_NAME Generik)set(CMAKE_SYSTEM_PROCESSOR arm)# Beberapa pengaturan GCC default# arm-none-eabi- harus menjadi bagian dari path environmentset(TOOLCHAIN_PREFIX arm-none-eabi-)set(FLAGS "-fdata-sections -ffunction-sections - -specs=nano.specs -Wl,--gc-sections")set(CPP_FLAGS "-fno-rtti -fno-Exceptions -fno-threadsafe-statics")# Tentukan set pengaturan compiler(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc ${FLAGS })set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}g++ ${FLAGS} ${CPP_FLAGS})set(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)set(CMAKE_SIZE ${TOOLCHAIN_PREFIX}ukuran)set(CMAKE_EXECUTABLE_SU FFIX_ASM". elf")set(CMAKE_EXECUTABLE_SUFFIX_C ".elf")set(CMAKE_EXECUTABLE_SUFFIX_CXX ".elf")set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

Buat file di folder cmake/ direktori proyek root.

Jika plugin penyorot CMake diinstal, VSCode akan menyorot perintah CMake dengan baik untuk Anda

Penyiapan rantai alat selesai. Anda dapat dengan bebas menutup file dan melanjutkan ke langkah berikutnya.

Buat file CMakeLists.txt utama

Kita perlu membuat CMakeLists.txt utama, juga disebut file root CMake.

Pastikan Anda benar-benar menamainya CMakeLists.txt dengan karakter huruf besar dan kecil yang benar.

Saya menyiapkan file template sederhana untuk Anda, yang dapat digunakan kembali untuk semua proyek Anda di masa depan. Anda hanya perlu mengubah hal-hal seperti nama proyek, file sumber, jalur penyertaan, dll.

 cmake_minimum_required(VERSI 3.22)# Atur pengaturan kompilerset(CMAKE_C_STANDARD 11)set(CMAKE_C_STANDARD_REQUIRED ON)set(CMAKE_C_EXTENSIONS ON)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)set(CMAKE_CXX_EXTENSIONS ON)set( PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("Bangun ketik: " ${CMAKE_BUILD_TYPE})## Pengaturan proyek inti#proyek(nama-proyek Anda)enable_bahasa(C CXX ASM)## Bendera inti MCU, CPU, set instruksi, dan pengaturan FPU# Perlu diatur dengan benar untuk MCU Anda #set(CPU_PARAMETERS
    -mthumb# Ini perlu diperhatikan agar disetel dengan benar untuk MCU-mcpu=cortex-m7 yang digunakan
    -mfpu=fpv5-d16
    -mfloat-abi=keras
)# Setel skrip linker(linker_script_SRC ${PROJ_PATH}/path-to-linker-script.ld)set(EXECUTABLE ${CMAKE_PROJECT_NAME})## Daftar file sumber yang akan dikompilasi#set(sources_SRCS# Letakkan di sini file sumber Anda, satu di setiap baris, relatif terhadap lokasi file CMakeLists.txt)## Sertakan direktori#set(include_path_DIRS# Letakkan di sini direktori penyertaan Anda, satu di setiap baris, relatif terhadap lokasi file CMakeLists.txt)## Definisi simbol#set(simbol_SYMB# Masukkan di sini simbol Anda (didefinisikan praprosesor), satu di setiap baris# Enkapsulasi dengan tanda kutip ganda untuk tujuan keamanan)# File yang dapat dieksekusiadd_executable(${EXECUTABLE} ${sources_SRCS})# Sertakan pathtarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Simbol proyektarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Opsi kompilertarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Dinding
    -Wextra
    -Wpedantik
    -Tidak ada-parameter yang tidak digunakan# Konfigurasi debug penuh-Og -g3 -ggdb
)# Opsi tautantarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # Dukungan pemformatan mengambang STDIO-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--grup akhir
    -Wl,--cetak-penggunaan memori
)# Jalankan post-build untuk mencetak sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $
)# Ubah keluaran menjadi hex dan bineradd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $ ${EXECUTABLE}.hex
)# Konversi ke file bin -> tambahkan centang bersyarat?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O biner $ ${EXECUTABLE}.bin
)

File sumber sama dengan proyek STM32CubeIDE . Anda dapat memeriksa gambar sebelumnya dengan sumber yang disorot dalam warna kuning.

Simbol dan jalur penyertaan dapat ditemukan di STM32CubeIDE di bawah pengaturan proyek. 2 gambar di bawah ini menunjukkan bagaimana kasus proyek demo.

Setup Cortex-Mxx perlu perhatian khusus, terutama dengan setup floating point. Untuk STM32H735xx , pengaturannya harus diatur seperti di bawah ini.

 set(CPU_PARAMETERS
    -ibu jari
    -mcpu=cortex-m7 # Setel Cortex-M CPU-mfpu=fpv5-d16 # Setel Tipe titik mengambang-mfloat-abi=hard # Mode ABI perangkat keras)

Aturan umum untuk pengaturan adalah seperti tabel di bawah

Keluarga STM32	-mcpu	-mfpu	-mfloat-abi
STM32F0	`cortex-m0`	`Not used`	`soft`
STM32F1	`cortex-m3`	`Not used`	`soft`
STM32F2	`cortex-m3`	`Not used`	`soft`
STM32F3	`cortex-m4`	`fpv4-sp-d16`	`hard`
STM32F4	`cortex-m4`	`fpv4-sp-d16`	`hard`
STM32F7SP	`cortex-m7`	`fpv5-sp-d16`	`hard`
STM32F7 DP	`cortex-m7`	`fpv5-d16`	`hard`
STM32G0	`cortex-m0plus`	`Not used`	`soft`
STM32C0	`cortex-m0plus`	`Not used`	`soft`
STM32G4	`cortex-m4`	`fpv4-sp-d16`	`hard`
STM32H5	`cortex-m33`	`fpv5-sp-d16`	`hard`
STM32H7	`cortex-m7`	`fpv5-d16`	`hard`
STM32L0	`cortex-m0plus`	`Not used`	`soft`
STM32L1	`cortex-m3`	`Not used`	`soft`
STM32L4	`cortex-m4`	`fpv4-sp-d16`	`hard`
STM32L5	`cortex-m33`	`fpv5-sp-d16`	`hard`
STM32U0	`cortex-m0plus`	`Not used`	`soft`
STM32U5	`cortex-m33`	`fpv5-sp-d16`	`hard`
STM32WB	`cortex-m4`	`fpv4-sp-d16`	`hard`
STM32WBA	`cortex-m33`	`fpv5-sp-d16`	`hard`
STM32WL CM4	`cortex-m4`	`Not used`	`soft`
STM32WL CM0	`cortex-m0plus`	`Not used`	`soft`

Tabel ini memiliki potensi kesalahan, tidak diuji dengan kompiler GCC untuk semua baris. Untuk STM32F7 , buka situs resmi STM32F7xx dan periksa apakah perangkat Anda memiliki FPU presisi tunggal atau ganda, lalu terapkan pengaturan yang sesuai. Daftar produk tidak lengkap.

File CMakeLists.txt akhir setelah file sumber, termasuk jalur, pengaturan inti MCU, dan definisi ditetapkan:

 cmake_minimum_required(VERSI 3.22)# Atur pengaturan kompilerset(CMAKE_C_STANDARD 11)set(CMAKE_C_STANDARD_REQUIRED ON)set(CMAKE_C_EXTENSIONS ON)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)set(CMAKE_CXX_EXTENSIONS ON)set( PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("Bangun ketik: " ${CMAKE_BUILD_TYPE})## Pengaturan proyek inti#proyek(STM32H735G-DK-LED) # Modifiedenable_lingual(C CXX ASM)## Bendera inti MCU, CPU, set instruksi, dan pengaturan FPU# Perlu diatur dengan benar untuk Anda MCU#set(CPU_PARAMETERS
    -mthumb# Ini perlu diperhatikan untuk disetel dengan benar untuk MCU-mcpu=cortex-m7 yang digunakan # Modified-mfpu=fpv5-d16 # Modified-mfloat-abi=hard # Modified)# Setel skrip linker(linker_script_SRC ${PROJ_PATH}/STM32H735IGKX_FLASH. ld) # Modifiedset(EXECUTABLE ${CMAKE_PROJECT_NAME})## Daftar file sumber yang akan dikompilasi#set(sources_SRCS # Modified${PROJ_PATH}/Core/Src/main.c${PROJ_PATH}/Core/Src/stm32h7xx_it.c$ {PROJ_PATH}/Core/Src/syscalls.c${PROJ_PATH}/Core/Src/sysmem.c${PROJ_PATH}/Core/Src/system_stm32h7xx.c${PROJ_PATH}/Core/Startup/startup_stm32h735igkx.s${PROJ_PATH }/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_exti.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_gpio.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_pwr .c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/ stm32h7xx_ll_rcc.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_utils.c
)## Sertakan direktori#set(include_path_DIRS # Dimodifikasi${PROJ_PATH}/Core/Inc${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Inc${PROJ_PATH}/Drivers/CMSIS/Device/ST/STM32H7xx/Include${PROJ_PATH}/ Driver/CMSIS/Sertakan
)## Definisi simbol#set(symbols_SYMB # Dimodifikasi"DEBUG""STM32H735xx""USE_FULL_LL_DRIVER""HSE_VALUE=25000000")# File yang dapat dieksekusiadd_executable(${EXECUTABLE} ${sources_SRCS})# Sertakan pathtarget_include_directories(${EXECUTABLE} PRIVATE ${ include_path_DIRS})# Simbol proyektarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Opsi kompilertarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpedantik
    -Tidak ada-parameter yang tidak digunakan# Konfigurasi debug penuh-Og -g3 -ggdb
)# Opsi tautantarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # Dukungan pemformatan mengambang STDIO-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--grup akhir
    -Wl,--cetak-penggunaan memori
)# Jalankan post-build untuk mencetak sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $
)# Ubah keluaran menjadi hex dan bineradd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $ ${EXECUTABLE}.hex
)# Konversi ke file bin -> tambahkan centang bersyarat?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O biner $ ${EXECUTABLE}.bin
)

Di VSCode, disorot dengan baik, tampilannya seperti ini

Buat file CMakePresets.json yang telah ditetapkan sebelumnya

CMakePresets.json adalah file khusus, tersedia sejak CMake 3.18 dan memberikan definisi untuk konfigurasi pengguna, mirip dengan konfigurasi debug dan rilis yang dikenal di gerhana. Memiliki file ini memungkinkan pengembang dengan cepat mengubah antara mode debug dan rilis , atau bahkan antara bootloader dan aplikasi utama , yang merupakan kasus penggunaan umum dalam aplikasi tertanam.

Tutorial ini tidak akan fokus pada detail tentang file tersebut, melainkan berikut adalah file template yang disediakan

File menjelaskan:

Jalur ke direktori build untuk setiap konfigurasi build
Tipe build default untuk setiap konfigurasi ( Debug , Release , ...)
Jalur ke deskriptor rantai alat .cmake

4 preset dikonfigurasi dalam templat untuk setiap konfigurasi CMake default

 {"versi": 3,"configurePresets": [
        {"name": "default","hidden": true,"generator": "Ninja","binaryDir": "${sourceDir}/build/${presetName}","toolchainFile": "${sourceDir} /cmake/gcc-arm-none-eabi.cmake","cacheVariables": {"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"}
        },
        {"name": "Debug","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "Debug"}
        },
        {"name": "RelWithDebInfo","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "RelWithDebInfo"}
        },
        {"name": "Rilis","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "Rilis"}
        },
        {"name": "MinSizeRel","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "MinSizeRel"}
        }
    ]
}

File yang selalu diperbarui tersedia di templates/CMakePresets.json

Jalankan perintah CMake

Kami telah mengonfigurasi CMake dengan informasi proyek dan sekarang siap menjalankan perintah CMake.

VSCode dilengkapi dengan plugin CMake Tools - penolong hebat untuk perintah CMake. Saat diinstal, tersedia beberapa opsi di bagian bawah jendela aktif VSCode

Seperti yang Anda lihat, tidak ada Preset Konfigurasi yang dipilih.

Jika Anda tidak melihat informasi tersebut, tekan CTRl + ALT + P dan jalankan perintah CMake: Quick Start .

Langkah selanjutnya adalah memilih preset saat ini. Klik pada No Configure Preset Selected untuk membuka jendela di sisi atas dan pilih preset Anda. Saya memilih debug demi tutorial ini.

Saat dipilih, teks akan berubah menjadi label preset yang dipilih.

Sekarang preset sudah aktif, setiap kali pengguna memodifikasi file CMakeLists.txt , berkat ekstensi CMake-Tools , VSCode akan secara otomatis menjalankan perintah pembuatan build untuk menerapkan perubahan baru.

Membangun proyek

Proyek kami siap untuk dibangun dan dihubungkan. Kecuali jika langkah pembuatan build CMake gagal, kita seharusnya sudah menyiapkan direktori build untuk memanggil sistem build ninja .

Langkah selanjutnya adalah menekan tombol Build - seperti yang ditunjukkan dengan persegi panjang hijau. CMake akan menjalankan perintah:

Jalankan generator build untuk preset yang dipilih
Sebenarnya membuat kode dengan Ninja

Jika dibangun dengan baik, langkah terakhir pada output adalah mencetak penggunaan memori dengan bagian yang berbeda.

Hasilnya, kami mendapatkan beberapa output di direktori build// :

file project-name.elf dengan informasi lengkap yang dapat dieksekusi
project-name.hex file HEX
file BIN project-name.bin
file peta project-name.map

Dalam konfigurasi default, file .hex dan .bin tidak dibuat dan penggunaan memori tidak ditampilkan. File CMakeLists.txt yang kami siapkan mencakup opsi POST_BUILD , untuk menjalankan perintah tambahan setelah build berhasil. Kode sudah ada di file CMakeLists.txt Anda, jadi tidak perlu melakukan apa pun, cukup amati.

Ini menjalankan perintah untuk:

Cetak ukuran yang digunakan setiap wilayah + konsumsi memori akhir yang dapat dieksekusi
Hasilkan file .hex dari yang dapat dieksekusi
Hasilkan file .bin dari yang dapat dieksekusi

 # Jalankan post-build untuk mencetak sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $
)# Ubah keluaran menjadi hex dan bineradd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $ ${EXECUTABLE}.hex
)# Konversi ke file bin -> tambahkan centang bersyarat?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O biner $ ${EXECUTABLE}.bin
)

Untuk menonaktifkan pembuatan file .bin , cukup hapus baris POST_BUILD untuk .bin dan buat ulang perintah sistem build CMake. Menghasilkan file .bin mungkin memiliki efek negatif ketika memori dibagi antara memori flash internal dan eksternal. Ini mungkin menghasilkan file yang sangat besar ( >= 2GB ) dengan banyak angka nol yang tidak digunakan.

Ada daftar perintah berguna yang perlu diingat selama pengembangan proyek:

Membangun perubahan
Proyek bersih
Membangun kembali proyek, dengan membersihkan terlebih dahulu
Proyek kilat

Sangat mudah untuk melupakan sintaksis lengkap, mari kita buat file .vscode/tasks.json dengan daftar perintah, untuk dijalankan dengan cepat:

 { "versi": "2.0.0", "tugas": [
        {"type": "cppbuild","label": "Bangun proyek","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "- j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"],"group": {"kind": "build"," isDefault": benar}
        },
        {"type": "shell","label": "Bangun kembali proyek","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "--bersihkan dulu", "-v", "-j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"] ,
        },
        {"type": "shell","label": "Bersihkan proyek","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "- -target", "bersih"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg: Proyek Flash (SWD)","command": "STM32_Programmer_CLI","args": ["--connect","port=swd","- -download", "${command:cmake.launchTargetPath}","-hardRst"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg: Proyek Flash dengan nomor seri yang ditentukan (SWD) - Anda harus menyetel nomor seri terlebih dahulu",

Memperluas

Informasi Tambahan