หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

สภาพแวดล้อมการพัฒนา STM32 พร้อม Visual Studio Code และ CMake

บทช่วยสอนนี้จะอธิบายขั้นตอนในการพัฒนาและแก้ไขข้อบกพร่องแอปพลิเคชัน STM32 ใน Visual Studio Code อย่างมีประสิทธิภาพโดยใช้ CMake build Generator, Ninja build tool และคอมไพเลอร์ GCC

สิ่งที่คุณจะได้เรียนรู้

  • วิธีการติดตั้งและตั้งค่าเครื่องมือทั้งหมด

  • วิธีสร้างโปรเจ็กต์ STM32 ใหม่ด้วยเครื่องมือ STM32CubeMX หรือ STM32CubeIDE

  • วิธีติดตั้งและตั้งค่าส่วนขยายที่แนะนำสำหรับ Visual Studio Code เพื่อการพัฒนาที่ง่ายขึ้น

  • วิธีการตั้งค่ารายการ CMake และการตั้งค่าล่วงหน้าของ CMake

  • วิธีสร้างระบบ build สำหรับคอมไพเลอร์

  • วิธีรวบรวมโครงการด้วย GCC

  • วิธีแฟลชและดีบักแอปพลิเคชันไปยังเป้าหมาย STM32

บทช่วยสอนนี้ใช้ระบบปฏิบัติการ Windows ขั้นตอนที่คล้ายกันจะนำไปใช้กับระบบปฏิบัติการ Linux และ MAC

การติดตั้งเครื่องมือ

อัปเดตเดือนสิงหาคม 2024

บทช่วยสอนการติดตั้งเครื่องมือจะช่วยให้คุณเข้าใจเครื่องมือที่จำเป็นซึ่งจำเป็นในการทำงานกับ STM32 และโดยทั่วไปแล้วเหมาะสำหรับผู้เริ่มต้นที่จะเร่งความเร็วและเข้าใจข้อกำหนดที่จำเป็นอย่างถูกต้อง

ในบางครั้ง ST ก็มีเครื่องมือซอฟต์แวร์ STM32CubeCLT ใหม่ ซึ่งรวมถึงเครื่องมือสร้างที่จำเป็นสำหรับ vscode รวมถึงระบบ Ninja build และ CMake build Generator STM32CubeCLT (เครื่องมือบรรทัดคำสั่ง) เป็นวิธีที่ง่ายและสะดวกในการเพิ่มความเร็วสำหรับการพัฒนา vscode อย่างรวดเร็ว นอกจากนี้ยังจะตั้งค่าตัวแปรสภาพแวดล้อมบิลด์ของคุณ ( Path ในกรณีของ Windows) โดยอัตโนมัติ ทำให้คุณสามารถเรียกใช้ ninja , cmake หรือคำสั่งอื่น ๆ ได้โดยตรงจากเครื่องมือบรรทัดคำสั่ง

เมื่อติดตั้ง STM32CubeCLT คุณจะไม่ได้รับเครื่องมือกราฟิก STM32CubeIDE และคุณจะไม่ได้รับความสามารถของเครื่องมือกำหนดค่า MCU ใดๆ แต่จะเป็นเพียงเครื่องมือบรรทัดคำสั่งเพื่อเรียกใช้ build และ debug ซึ่งโดยปกติจะมาจากภายใน vscode คุณจะต้องติดตั้ง vscode และส่วนขยายที่จำเป็นแยกต่างหาก

STM32CubeIDE

ขั้นตอนแรกคือการติดตั้ง STM32CubeIDE ซึ่งจะใช้ในการเริ่มต้นโปรเจ็กต์ STM32 ใหม่ได้อย่างง่ายดาย และมาพร้อมกับเครื่องมือ STM32CubeMX ในตัว ซึ่งช่วยให้เราสามารถกำหนดค่าแบบกราฟิกได้

STM32CubeIDE ยังมีเครื่องมือที่จำเป็นสำหรับการพัฒนา VSCode ในภายหลังอีกด้วย

  • ARM ไม่มีคอมไพเลอร์ eabi GCC

  • ST-LINK GDBServer สำหรับการดีบัก

  • เครื่องมือ STM32CubeProgrammer สำหรับการดาวน์โหลดโค้ดและไดรเวอร์ ST-Link ที่เกี่ยวข้อง

  • โฟลเดอร์ที่มีไฟล์ STM32 SVD

  • ไดร์เวอร์สำหรับ ST-Link

การตั้งค่าเส้นทางสิ่งแวดล้อม

ควรเพิ่ม 3 เส้นทางในการตั้งค่าสภาพแวดล้อมจากการติดตั้ง STM32CubeIDE หนึ่งเส้นทางสำหรับแต่ละเครื่องมือที่กล่าวถึงข้างต้น ในกรณีของคอมพิวเตอร์ของฉัน การใช้ STM32CubeIDE 1.8 (อัปเดตผ่าน eclipse ดังนั้นพาธการติดตั้งจริงของฉันยังคงแสดงเวอร์ชัน 1.0.2 ) พาธถูกกำหนดเป็น:

  • คอมไพเลอร์ GCC: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346toolsbin

  • เซิร์ฟเวอร์ ST-Link GDB: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221toolsbin

  • STM32Cube โปรแกรมเมอร์ CLI: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.cubeprogrammer.win32_2.0.100.202110141430toolsbin

เส้นทางของคุณอาจแตกต่างกันไปตามหมายเลขเวอร์ชัน

ตรวจสอบการตั้งค่าพาธที่ถูกต้อง รัน: 

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

นั่นควรให้ผลลัพธ์คล้ายกับภาพด้านล่าง

ซีเมค

ขั้นตอนนี้ไม่จำเป็นหากคุณติดตั้งเครื่องมือ build ด้วย STM32CubeCLT

ดาวน์โหลดและติดตั้ง CMake

วิซาร์ดการติดตั้งจะขอให้คุณเพิ่ม CMake ให้กับเส้นทางสิ่งแวดล้อม เลือกตัวเลือกหรือเพิ่มโฟลเดอร์ bin ของโฟลเดอร์การติดตั้ง CMake ไปยังเส้นทางสิ่งแวดล้อม

นินจา

ขั้นตอนนี้ไม่จำเป็นหากคุณติดตั้งเครื่องมือ build ด้วย STM32CubeCLT

ดาวน์โหลดระบบ Ninja build จากหน้าเผยแพร่ Github มันมาพร้อมกับไฟล์ปฏิบัติการแบบพกพาโดยไม่จำเป็นต้องติดตั้งอะไรเลย อย่างไรก็ตาม จะต้องมองเห็นได้ในระดับสภาพแวดล้อม เช่นเดียวกับเครื่องมือก่อนหน้านี้ทั้งหมด

ตรวจสอบการติดตั้ง CMake และ Ninja รัน: 

cmake --version
ninja --version

ผลลัพธ์จะต้องเป็นสิ่งที่คล้ายกับ

รหัสวิชวลสตูดิโอ

ดาวน์โหลดและติดตั้ง VSCode. เมื่อติดตั้งและเปิดแล้ว หน้าต่างจะมีลักษณะคล้ายกับหน้าต่างด้านล่าง

ส่วนขยายรหัส Visual Studio

Visual Studio Code เป็นโปรแกรมแก้ไขข้อความน้ำหนักเบาที่มีความสามารถในการขยายขนาดโดยใช้ส่วนขยาย

รายการส่วนขยายที่เป็นประโยชน์สำหรับการพัฒนา STM32 โดยใช้ CMake:

  • ms-vscode.cpptools : การเน้นไวยากรณ์และคุณสมบัติหลักอื่นๆ สำหรับการพัฒนา C/C++

  • ms-vscode.cmake-tools : เครื่องมือหลักของ CMake, สร้างเครื่องมือสร้างระบบ

  • twxs.cmake : การเน้นสี CMake

  • marus25.cortex-debug : ส่วนขยายการดีบัก Cortex-M จำเป็นสำหรับการดีบัก STM32 จาก VSCode

  • dan-c-underwood.arm : เครื่องมือเน้นไวยากรณ์ของ ARM Assembly

  • zixuanwang.linkerscript : เครื่องมือเน้นไวยากรณ์สคริปต์ GCC Linker

คุณสามารถติดตั้งได้โดยการคัดลอกคำสั่งด้านล่างในหน้าต่างเทอร์มินัลภายในของ 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

ไปที่ Terminal -> New Terminal เพื่อเปิดหน้าต่าง Terminal ใหม่

อีกวิธีหนึ่งคือใช้ GUI การค้นหาส่วนขยาย และติดตั้งด้วยตนเองจากที่นั่น

ติดตั้งเครื่องมือ-จุดตรวจ

ณ จุดนี้ เครื่องมือทั้งหมดได้รับการติดตั้งอย่างเหมาะสม - คุณมาถูกทางสู่ความสำเร็จ

การสร้างโครงการใหม่

ข้อกำหนดพื้นฐานในการก้าวไปข้างหน้าคือการมีโครงการทำงานที่จะถูกแปลงเป็น CMake และพัฒนาใน VSCode เพื่อจุดประสงค์นี้ ฉันจะแนะนำคุณเกี่ยวกับการสร้างโปรเจ็กต์ใหม่ง่ายๆ โดยใช้เครื่องมือซอฟต์แวร์ STM32CubeMX หรือ STM32CubeIDE

คุณสามารถข้ามส่วนนี้ได้ หากคุณมีโครงการที่จะดำเนินการอยู่แล้ว

ฉันใช้เครื่องมือ STM32CubeIDE และบอร์ด STM32H735G-DK สำหรับการสาธิตนี้

เปิด STM32CubeIDE และเริ่มโปรเจ็กต์ใหม่

เลือก STM32 MCU - ผมเลือก STM32H735IG ซึ่งใช้กับบอร์ด STM32H735G-DK

เลือกชื่อโปรเจ็กต์และเส้นทาง จากนั้นสร้างโปรเจ็กต์และรอให้ มุมมอง Pinout เปิดขึ้นมา

งานของเราคือการมีโปรเจ็กต์ง่ายๆ ที่จะสลับไฟ LED LED เชื่อมต่อกับ PC2 และ PC3 ตามลำดับ ซึ่งทำงานเป็น LOW สามารถกำหนดค่าพินได้ในโหมดพุชดึงหรือโหมดเปิดเดรนเอาต์พุต

ตั้งค่าพินเป็นเอาต์พุตโดยมีป้ายกำกับเสริมเป็น LED1 และ LED2 ตามลำดับ

หากคุณใช้ STM32CubeMX ให้ไปที่ Project manager ตั้งชื่อโปรเจ็กต์ และตรวจสอบให้แน่ใจว่าได้เลือก STM32CubeIDE เป็น Toolchain

ไปที่การตั้งค่าขั้นสูงและเลือก LL เป็นไดรเวอร์สำหรับโค้ดที่สร้างขึ้น

เราใช้ไดรเวอร์ LL เพื่อความเรียบง่ายในบทช่วยสอนนี้

สร้างโปรเจ็กต์ใหม่โดยกดปุ่มสีแดงหรือบันทึกโปรเจ็กต์ด้วยทางลัด CTRL + S

โครงการนี้ถูกสร้างขึ้นใหม่แล้ว ไฟล์ที่เน้น สีเหลือง คือแหล่งที่มาของการสร้าง สีน้ำเงิน คือสคริปต์ลิงก์เกอร์

เพียงเท่านี้สำหรับรันแรกเราก็พร้อมที่จะคอมไพล์แล้ว กด CTRL + B หรือคลิกที่ไอคอน รูปค้อน เพื่อเริ่มต้น STM32CubeIDE จะทำการคอมไพล์โปรเจ็กต์ คุณจะเห็นความคล้ายคลึงดังภาพด้านล่าง ตอนนี้พร้อมสำหรับการแฟลชแฟลชของ MCU และเริ่มแก้ไขข้อบกพร่องแล้ว

นี่คือจุดสิ้นสุดของส่วนแรกซึ่งเราสร้างโปรเจ็กต์ของเราสำเร็จแล้ว ณ จุดนี้ เราพิจารณาว่าโปรเจ็กต์พร้อมที่จะถ่ายโอนไปยังระบบบิลด์ที่ใช้ CMake

คุณสามารถพัฒนาต่อด้วย STM32CubeIDE ได้ในอนาคต เพิ่มแหล่งที่มาใหม่ แก้ไขโค้ด คอมไพล์ แฟลชไบนารี และดีบักไมโครคอนโทรลเลอร์โดยตรง นี่คือสตูดิโอพัฒนา STM32 ที่ต้องการ ซึ่งพัฒนาและดูแลโดย STMicroelectronics

การกำหนดค่า CMake

คาดว่าจะมีการสร้างโครงการที่จะพัฒนาใน VSCode เราจะก้าวไปข้างหน้าสำหรับคอมไพเลอร์ GCC แต่คนอื่นๆ ก็สามารถนำมาใช้ได้เช่นกัน

ด้วยการเปิดตัว Visual Studio Code นักพัฒนาจำนวนมากใช้เครื่องมือนี้สำหรับภาษาการเขียนโปรแกรมหลายภาษา และโชคดีที่ยังสามารถพัฒนาแอปพลิเคชัน STM32 ด้วยเครื่องมือเดียวได้ หากคุณเป็นหนึ่งในนักพัฒนาที่ชื่นชอบ VSCode วิธีที่หรูหราที่สุดในการก้าวไปข้างหน้าคือการถ่ายโอนโปรเจ็กต์ที่ใช้ STM32CubeIDE ไปยัง CMake พัฒนาโค้ดใน VSCode และคอมไพล์ด้วยระบบ Ninja build โดยใช้คอมไพเลอร์ GCC มันรวดเร็วและมีน้ำหนักเบา

การพัฒนาใน VSCode มีไว้สำหรับผู้ใช้ระดับกลางหรือผู้ใช้ที่มีประสบการณ์ ฉันขอแนะนำให้ผู้เริ่มต้น STM32 ทุกคนใช้ Toolchain การพัฒนา STM32CubeIDE ต่อไป มันจะง่ายมากที่จะก้าวไปข้างหน้าและมาที่หัวข้อ VSCode ในภายหลัง

เตรียมไฟล์ CMakeLists.txt

แอปพลิเคชันที่ใช้ CMake ทุกรายการต้องมีไฟล์ CMakeLists.txt ในไดเรกทอรีราก ซึ่งอธิบายโปรเจ็กต์และให้ข้อมูลอินพุตสำหรับการสร้างระบบบิลด์

ไฟล์ Root CMakeLists.txt บางครั้งเรียกว่าไฟล์ CMake ระดับบนสุด

สิ่งสำคัญที่อธิบายไว้ในไฟล์ CMakeLists.txt :

  • ข้อมูล Toolchain เช่น การกำหนดค่า GCC พร้อมแฟล็กบิลด์

  • ชื่อโครงการ

  • ไฟล์ต้นฉบับที่จะสร้างด้วยคอมไพเลอร์, C, C++ หรือไฟล์ Assembly

  • รายการเส้นทางรวมสำหรับคอมไพเลอร์เพื่อค้นหาฟังก์ชัน กำหนด ... ( -I )

  • เส้นทางสคริปต์ลิงก์เกอร์

  • การคอมไพล์กำหนดหรือบางครั้งเรียกว่า ตัวประมวลผลล่วงหน้ากำหนด ( -D )

  • การตั้งค่า Cortex-Mxx และจุดลอยตัวสำหรับการสร้างชุดคำสั่ง

เปิด VSCode ในโฟลเดอร์รูทของโปรเจ็กต์

ติดตั้ง Visual Studio Code แล้ว และจะใช้เป็นตัวแก้ไขไฟล์เพิ่มเติม

ค้นหาเส้นทางโปรเจ็กต์ที่คุณสร้างขึ้นและเปิดโฟลเดอร์ด้วย VSCode:

  • ตัวเลือกที่ 1: ไปที่โฟลเดอร์ที่มี explorer จากนั้นคลิกขวาแล้วเลือก Open in Code

  • ตัวเลือกที่ 2: หรืออีกทางหนึ่ง เปิด VScode เป็นโซลูชันเปล่าใหม่ และเพิ่มโฟลเดอร์ด้วยตนเอง ใช้ File -> Open Folder... เพื่อเปิดโฟลเดอร์

  • ตัวเลือกที่ 3: ไปที่โฟลเดอร์ด้วยเครื่องมือ cmd หรือ powershell แล้วเรียกใช้ code .

ผลลัพธ์สุดท้ายควรมีลักษณะคล้ายกับผลลัพธ์ด้านล่าง

ข้อมูลห่วงโซ่เครื่องมือ

CMake จำเป็นต้องทราบเกี่ยวกับ Toolchain ที่เราต้องการใช้เพื่อรวบรวมโปรเจ็กต์ด้วย เนื่องจากโดยปกติแล้ว Toolchain เดียวกันจะถูกนำมาใช้ซ้ำในโปรเจ็กต์ต่างๆ จึงแนะนำให้สร้างส่วนนี้ในไฟล์แยกต่างหากเพื่อให้นำกลับมาใช้ใหม่ได้ง่ายขึ้น การตั้งค่าเหล่านี้เป็นการตั้งค่าคอมไพเลอร์ทั่วไปและไม่ได้เชื่อมโยงโดยตรงกับโปรเจ็กต์

ไฟล์ .cmake แบบธรรมดาสามารถนำมาใช้และนำกลับมาใช้ใหม่ในภายหลังในโปรเจ็กต์ต่างๆ ของคุณได้ ฉันใช้ชื่อ cmake/gcc-arm-none-eabi.cmake สำหรับบทช่วยสอนนี้ และด้านล่างนี้คือตัวอย่าง:

 set(CMAKE_SYSTEM_NAME Generic)set(CMAKE_SYSTEM_PROCESSOR arm)# การตั้งค่า GCC เริ่มต้นบางอย่าง# arm-none-eabi- ต้องเป็นส่วนหนึ่งของสภาพแวดล้อมเส้นทาง set(TOOLCHAIN_PREFIX arm-none-eabi-)set(FLAGS "-fdata-sections -ffunction-sections - -specs=nano.specs -Wl,--gc-sections")set(CPP_FLAGS "-fno-rtti -fno-ข้อยกเว้น -fno-threadsafe-statics")# กำหนดการตั้งค่าคอมไพเลอร์ set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc ${FLAGS})set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}g++ $ {ธง} ${CPP_FLAGS})ชุด(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)ชุด(CMAKE_SIZE ${TOOLCHAIN_PREFIX}ขนาด)ชุด(CMAKE_EXECUTABLE_SUFFIX_ASM ".elf")ชุด(CMAKE_EXECUTABLE_SUFFIX_C ".elf")ชุด(CMAKE_EXECUTABLE_SUFFIX_CXX ".elf") ตั้งค่า (CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

สร้างไฟล์ในโฟลเดอร์ cmake/ ของไดเร็กทอรีโปรเจ็กต์รูท

หากติดตั้งปลั๊กอินเน้นข้อความ CMake แล้ว VSCode จะเน้นคำสั่ง CMake ให้คุณเป็นอย่างดี

การตั้งค่า Toolchain เสร็จสมบูรณ์ คุณสามารถปิดไฟล์ได้อย่างอิสระและย้ายไปยังขั้นตอนถัดไป

สร้างไฟล์ CMakeLists.txt หลัก

เราจำเป็นต้องสร้าง main CMakeLists.txt หรือที่เรียกว่าไฟล์ root CMake

ตรวจสอบให้แน่ใจว่าคุณตั้งชื่อเป็น CMakeLists.txt ด้วยอักขระตัวพิมพ์ใหญ่และตัวพิมพ์เล็กที่ถูกต้อง

ฉันเตรียมไฟล์เทมเพลตง่ายๆ ไว้ให้คุณ ซึ่งสามารถนำมาใช้ซ้ำกับโครงการทั้งหมดของคุณได้ในอนาคต คุณเพียงแค่ต้องเปลี่ยนสิ่งต่าง ๆ เช่น ชื่อโปรเจ็กต์ ไฟล์ต้นฉบับ รวมเส้นทาง ฯลฯ

 cmake_minimum_required(VERSION 3.22)# ตั้งค่าการตั้งค่าคอมไพเลอร์ชุด (CMAKE_C_STANDARD 11)ชุด(CMAKE_C_STANDARD_REQUIRED ON)ชุด(CMAKE_C_EXTENSIONS ON)ชุด(CMAKE_CXX_STANDARD 20)ชุด(CMAKE_CXX_STANDARD_REQUIRED ON)ชุด(CMAKE_CXX_EXTENSIONS ON)set(PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("ประเภทบิลด์: " ${CMAKE_BUILD_TYPE})## การตั้งค่าโปรเจ็กต์หลัก#project(your-project-name)enable_ language(C CXX ASM)## แฟล็ก Core MCU, CPU, ชุดคำสั่งและการตั้งค่า FPU# จำเป็นต้องตั้งค่าอย่างถูกต้องสำหรับ MCU ของคุณ#set(CPU_PARAMETERS
    -mthumb# สิ่งนี้ต้องการความสนใจเพื่อตั้งค่าอย่างถูกต้องสำหรับ MCU-mcpu=cortex-m7 ที่ใช้แล้ว
    -mfpu=fpv5-d16
    -mfloat-abi=ฮาร์ด
)# Set linker scriptset(linker_script_SRC ${PROJ_PATH}/path-to-linker-script.ld)set(EXECUTABLE ${CMAKE_PROJECT_NAME})## รายการไฟล์ต้นฉบับที่จะคอมไพล์#set(sources_SRCS# ใส่ไฟล์ต้นฉบับของคุณที่นี่ หนึ่งไฟล์ ในแต่ละบรรทัด สัมพันธ์กับตำแหน่งไฟล์ CMakeLists.txt)## รวมไดเร็กทอรี#set(include_path_DIRS# ใส่การรวมของคุณที่นี่ dirs หนึ่งตัวในแต่ละบรรทัด สัมพันธ์กับตำแหน่งไฟล์ CMakeLists.txt)## คำจำกัดความของสัญลักษณ์#set(สัญลักษณ์_SYMB# ใส่สัญลักษณ์ของคุณที่นี่ (ตัวประมวลผลล่วงหน้ากำหนด) หนึ่งตัวในแต่ละบรรทัด# ห่อหุ้มด้วยเครื่องหมายคำพูดคู่เพื่อความปลอดภัย)# ไฟล์ปฏิบัติการadd_executable (${EXECUTABLE} ${sources_SRCS})# รวม pathstarget_include_directories(${EXECUTABLE} ส่วนตัว ${include_path_DIRS})# โครงการ symbolstarget_compile_definitions(${EXECUTABLE} PRIVATE ${สัญลักษณ์_SYMB})# คอมไพเลอร์ optionstarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -เว็กซ์ตรา
    -Wpedantic
    -Wno-unused-parameter# การกำหนดค่าการดีบักแบบเต็ม-Og -g3 -ggdb
)# ตัวเชื่อมโยง optionstarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # สนับสนุนการจัดรูปแบบลอย STDIO-Wl,--start-group
    -แอลซี
    -ล
    -lstdc++
    -lsupc++
    -Wl,--จบกลุ่ม
    -Wl,--การใช้งานหน่วยความจำการพิมพ์
)# ดำเนินการหลังการสร้างเพื่อพิมพ์ sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# แปลงเอาต์พุตเป็น hex และ binaryadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# แปลงเป็นไฟล์ bin -> เพิ่มการตรวจสอบแบบมีเงื่อนไข?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
-

ไฟล์ต้นฉบับเหมือนกับในโปรเจ็กต์ STM32CubeIDE คุณสามารถตรวจสอบภาพก่อนหน้าโดยใช้แหล่งที่ไฮไลท์เป็นสีเหลือง

สัญลักษณ์และเส้นทางรวมสามารถพบได้ใน STM32CubeIDE ภายใต้การตั้งค่าโปรเจ็กต์ 2 รูปภาพด้านล่างแสดงให้เห็นว่าในกรณีของโครงการสาธิต


การตั้งค่า Cortex-Mxx ต้องการการดูแลเป็นพิเศษ โดยเฉพาะอย่างยิ่งกับการตั้งค่าจุดลอยตัว สำหรับ STM32H735xx ควรตั้งค่าตามด้านล่างนี้

 ชุด (CPU_PARAMETERS
    -นิ้วหัวแม่มือ
    -mcpu=cortex-m7 # ตั้งค่า Cortex-M CPU-mfpu=fpv5-d16 # ตั้งค่าจุดลอยตัวประเภท -mfloat-abi=hard # โหมดฮาร์ดแวร์ ABI)

กฎทั่วไปสำหรับการตั้งค่าจะเป็นไปตามตารางด้านล่างนี้

ครอบครัว 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
STM32F7 เอสพี cortex-m7 fpv5-sp-d16 hard
STM32F7 ดีพี 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

ตารางนี้เป็นหัวข้อของข้อผิดพลาดที่อาจเกิดขึ้น ไม่ได้ทดสอบกับ คอมไพเลอร์ GCC สำหรับทุกบรรทัด สำหรับ STM32F7 ให้ไปที่เว็บไซต์อย่างเป็นทางการของ STM32F7xx และตรวจสอบว่าอุปกรณ์ของคุณมี FPU ความแม่นยำเดี่ยวหรือสองเท่า จากนั้นใช้การตั้งค่าตามนั้น รายการผลิตภัณฑ์ไม่ครบถ้วนสมบูรณ์

ไฟล์ CMakeLists.txt สุดท้ายหลังจากไฟล์ต้นฉบับ รวมพาธ การตั้งค่าหลัก MCU และการกำหนดได้รับการตั้งค่า:

 cmake_minimum_required(VERSION 3.22)# ตั้งค่าการตั้งค่าคอมไพเลอร์ชุด (CMAKE_C_STANDARD 11)ชุด(CMAKE_C_STANDARD_REQUIRED ON)ชุด(CMAKE_C_EXTENSIONS ON)ชุด(CMAKE_CXX_STANDARD 20)ชุด(CMAKE_CXX_STANDARD_REQUIRED ON)ชุด(CMAKE_CXX_EXTENSIONS ON)set(PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("ประเภทบิวด์: " ${CMAKE_BUILD_TYPE})## การตั้งค่าโปรเจ็กต์หลัก#project(STM32H735G-DK-LED) # Modifiedenable_ language (C CXX ASM)## แฟล็ก Core MCU, CPU , ชุดคำสั่ง และการตั้งค่า FPU# จำเป็นต้องตั้งค่าอย่างเหมาะสมสำหรับคุณ MCU#set(CPU_PARAMETERS
    -mthumb# สิ่งนี้ต้องการความสนใจในการตั้งค่าอย่างถูกต้องสำหรับ MCU-mcpu=cortex-m7 ที่ใช้แล้ว # Modified-mfpu=fpv5-d16 # Modified-mfloat-abi=hard # Modified)# ตั้งค่าชุดสคริปต์ตัวเชื่อมโยง (linker_script_SRC ${PROJ_PATH}/STM32H735IGKX_FLASH ld) # Modifiedset (ปฏิบัติการ $ {CMAKE_PROJECT_NAME}) ## รายการของ ไฟล์ต้นฉบับที่จะคอมไพล์#set(sources_SRCS # แก้ไข ${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}/ไดรเวอร์/STM32H7xx_HAL_Driver/Src/stm3 2h7xx_ll_exti.c${PROJ_PATH}/ไดรเวอร์/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_gpio.c${PROJ_PATH}/ไดรเวอร์/STM32H7xx_HAL_Driver/Src/stm32h7xx_l l_pwr.c${PROJ_PATH}/ไดรเวอร์/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_rcc.c${PROJ_PATH}/ไดรเวอร์/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_utils.c
)## รวมไดเร็กทอรี#set(include_path_DIRS # Modified${PROJ_PATH}/Core/Inc${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Inc${PROJ_PATH}/Drivers/CMSIS/Device/ST/STM32H7xx/Include${PROJ_PATH}/ ไดรเวอร์/CMSIS/รวม
)## คำจำกัดความของสัญลักษณ์#set (สัญลักษณ์_SYMB # ดัดแปลง "DEBUG" "STM32H735xx" "USE_FULL_LL_DRIVER" "HSE_VALUE=25000000")# ไฟล์ปฏิบัติการadd_executable(${EXECUTABLE} ${sources_SRCS})# รวม pathstarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# โครงการ symbolstarget_compile_definitions(${EXECUTABLE} PRIVATE ${สัญลักษณ์_SYMB})# คอมไพเลอร์ optionstarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -เว็กซ์ตรา
    -Wpedantic
    -Wno-unused-parameter# การกำหนดค่าการดีบักแบบเต็ม-Og -g3 -ggdb
)# ตัวเชื่อมโยง optionstarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # สนับสนุนการจัดรูปแบบลอย STDIO-Wl,--start-group
    -แอลซี
    -ล
    -lstdc++
    -lsupc++
    -Wl,--จบกลุ่ม
    -Wl,--การใช้งานหน่วยความจำการพิมพ์
)# ดำเนินการหลังการสร้างเพื่อพิมพ์ sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# แปลงเอาต์พุตเป็น hex และ binaryadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# แปลงเป็นไฟล์ bin -> เพิ่มการตรวจสอบแบบมีเงื่อนไข?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
-

ใน VSCode เน้นไว้อย่างดี หน้าตาจะเป็นแบบนี้

สร้างไฟล์ CMakePresets.json ที่กำหนดไว้ล่วงหน้า

CMakePresets.json เป็นไฟล์พิเศษที่พร้อมใช้งานตั้งแต่ CMake 3.18 และจัดเตรียมคำจำกัดความสำหรับการกำหนดค่าผู้ใช้ คล้ายกับการกำหนดค่า การดีบัก และ รีลีส ที่รู้จักใน eclipse การมีไฟล์นี้ช่วยให้นักพัฒนาสามารถเปลี่ยนระหว่าง โหมดดีบั๊ก และโหมด รีลีส ได้อย่างรวดเร็ว หรือแม้แต่ระหว่างโปรแกรม โหลดบูต และแอปพลิเค ชันหลัก ซึ่งเป็นกรณีการใช้งานทั่วไปในแอปพลิเคชันแบบฝัง

บทช่วยสอนนี้จะไม่เน้นที่รายละเอียดเกี่ยวกับไฟล์ แต่นี่คือไฟล์เทมเพลตที่ให้มา

ไฟล์อธิบาย:

  • เส้นทางสู่ไดเร็กทอรีบิวด์สำหรับการกำหนดค่าบิลด์แต่ละรายการ

  • ประเภทบิลด์เริ่มต้นสำหรับการกำหนดค่าแต่ละรายการ ( Debug , Release , ... )

  • เส้นทางไปยังตัวอธิบาย toolchain .cmake

มีการกำหนดค่าล่วงหน้า 4 รายการในเทมเพลตสำหรับการกำหนดค่า CMake เริ่มต้นแต่ละรายการ

 {"เวอร์ชัน": 3,"กำหนดค่าล่วงหน้า": [
        {"ชื่อ": "default", "ซ่อน": true, "เครื่องกำเนิดไฟฟ้า": "Ninja", "binaryDir": "${sourceDir}/build/${presetName}", "toolchainFile": "${sourceDir} /cmake/gcc-arm-none-eabi.cmake","cacheVariables": {"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"}
        -
        {"ชื่อ": "ดีบัก", "สืบทอด": "ค่าเริ่มต้น", "ตัวแปรแคช": {"CMAKE_BUILD_TYPE": "ดีบัก"}
        -
        {"ชื่อ": "RelWithDebInfo", "สืบทอด": "default", "cacheVariables": {"CMAKE_BUILD_TYPE": "RelWithDebInfo"}
        -
        {"name": "Release", "สืบทอด": "default", "cacheVariables": {"CMAKE_BUILD_TYPE": "Release"}
        -
        {"ชื่อ": "MinSizeRel", "สืบทอด": "default", "cacheVariables": {"CMAKE_BUILD_TYPE": "MinSizeRel"}
        -
    -
-

ไฟล์ที่อัปเดตอยู่เสมอมีอยู่ใน templates/CMakePresets.json

เรียกใช้คำสั่ง CMake

เราได้กำหนดค่า CMake ด้วยข้อมูลโครงการ และตอนนี้พร้อมที่จะรันคำสั่ง CMake แล้ว

VSCode มาพร้อมกับปลั๊กอิน CMake Tools ซึ่งเป็นตัวช่วยที่ยอดเยี่ยมสำหรับคำสั่ง CMake เมื่อติดตั้งแล้ว จะมีตัวเลือกต่างๆ ให้เลือกที่ด้านล่างของหน้าต่าง VSCode ที่ใช้งานอยู่

อย่างที่คุณเห็น ไม่มีการกำหนดค่าล่วงหน้าที่เลือกไว้

หากคุณไม่เห็นข้อมูลดังกล่าว ให้กด CTRl + ALT + P แล้วเรียกใช้ CMake: Quick Start

ขั้นตอนต่อไปคือการเลือก ค่าที่ตั้งล่วงหน้า ปัจจุบัน คลิกที่ No Configure Preset Selected เพื่อเปิดหน้าต่างด้านบนและเลือกค่า ที่ตั้งล่วงหน้า ของคุณ ฉันเลือก การแก้ไขจุดบกพร่อง เพื่อประโยชน์ของบทช่วยสอนนี้

เมื่อเลือกแล้ว ข้อความจะเปลี่ยนเป็น ป้ายกำกับที่กำหนดไว้ล่วงหน้า ที่เลือก

ขณะนี้ค่าที่ตั้งล่วงหน้าใช้งานได้ ทุกครั้งที่ผู้ใช้แก้ไขไฟล์ CMakeLists.txt ต้องขอบคุณส่วนขยาย CMake-Tools ทำให้ VSCode จะเรียกใช้คำสั่งการสร้าง build โดยอัตโนมัติเพื่อใช้การเปลี่ยนแปลงใหม่

สร้างโครงการ

โครงการของเราพร้อมสำหรับการสร้างและเชื่อมโยง ยกเว้นว่าขั้นตอนการสร้าง CMake ล้มเหลว เราควรจะมีไดเร็กทอรี build ที่พร้อมที่จะเรียกใช้ ninja build system

ขั้นตอนต่อไปคือการกดปุ่ม Build - ตามที่ระบุด้วยสี่เหลี่ยมสีเขียว CMake จะรันคำสั่ง:

  • เรียกใช้ตัวสร้างบิลด์สำหรับพรีเซ็ตที่เลือก

  • สร้างโค้ดด้วย Ninja จริงๆ

หากสร้างได้ดี ขั้นตอนสุดท้ายในเอาท์พุตคือการพิมพ์หน่วยความจำที่ใช้กับส่วนต่างๆ

เป็นผลให้เราได้รับผลลัพธ์บางส่วนในไดเร็กทอรี build/<presetname>/ :

  • ไฟล์ project-name.elf พร้อมข้อมูลปฏิบัติการที่สมบูรณ์

  • ไฟล์ project-name.hex HEX

  • ไฟล์ project-name.bin BIN

  • ไฟล์แผนที่ project-name.map

ในการกำหนดค่าเริ่มต้น ไฟล์ .hex และ .bin จะไม่ถูกสร้างขึ้น และไม่มีการแสดง การใช้หน่วยความจำ ไฟล์ CMakeLists.txt ที่เตรียมไว้ของเรามีตัวเลือก POST_BUILD เพื่อดำเนินการคำสั่งเพิ่มเติมหลังจากสร้างสำเร็จ โค้ดอยู่ในไฟล์ CMakeLists.txt ของคุณแล้ว ดังนั้นคุณไม่จำเป็นต้องดำเนินการใดๆ เพียงแค่สังเกตดู

มันดำเนินการคำสั่งเพื่อ:

  • พิมพ์ขนาดที่ใช้ของแต่ละภูมิภาค + การใช้หน่วยความจำที่ปฏิบัติการได้ขั้นสุดท้าย

  • สร้างไฟล์ .hex จากปฏิบัติการ

  • สร้างไฟล์ .bin จากปฏิบัติการ

 # ดำเนินการหลังสร้างเพื่อพิมพ์ sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# แปลงเอาต์พุตเป็น hex และ binaryadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# แปลงเป็นไฟล์ bin -> เพิ่มการตรวจสอบแบบมีเงื่อนไข?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
-

หากต้องการปิดใช้งานการสร้างไฟล์ .bin เพียงลบบรรทัด POST_BUILD สำหรับ .bin และสร้างคำสั่งระบบ CMake build ใหม่ การสร้างไฟล์ .bin อาจส่งผลเสียเมื่อหน่วยความจำถูกแบ่งระหว่างหน่วยความจำแฟลชภายในและภายนอก อาจสร้างไฟล์ขนาดใหญ่มาก ( >= 2GB ) โดยมีศูนย์ที่ไม่ได้ใช้จำนวนมาก

มีรายการคำสั่งที่เป็นประโยชน์ที่ควรคำนึงถึงในระหว่างการพัฒนาโครงการ:

  • สร้างการเปลี่ยนแปลง

  • โครงการสะอาด

  • สร้างโครงการใหม่โดยทำความสะอาดก่อน

  • โครงการแฟลช

มันง่ายที่จะลืมไวยากรณ์แบบเต็ม แต่มาสร้างไฟล์ .vscode/tasks.json พร้อมรายการคำสั่งกันดีกว่า เพื่อการรันที่รวดเร็ว:

 { "เวอร์ชัน": "2.0.0", "งาน": [
        {"type": "cppbuild", "label": "Build project", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", "- j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"],"group": {"kind": "สร้าง", "เป็นค่าเริ่มต้น": จริง}
        -
        {"type": "shell", "label": "สร้างโครงการใหม่", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", "--clean-first", "-v", "-j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"] ,
        -
        {"type": "shell", "label": "Clean project", "command": "cmake", "args": ["--build", "${command:cmake.buildDirectory}", "- -target", "clean"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        -
        {"type": "shell", "label": "CubeProg: Flash project (SWD)", "command": "STM32_Programmer_CLI", "args": ["--เชื่อมต่อ", "พอร์ต=swd", "- -ดาวน์โหลด", "${command:cmake.launchTargetPath}", "-hardRst"],"ตัวเลือก": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        -
        {"type": "shell", "label": "CubeProg: โปรเจ็กต์ Flash พร้อมหมายเลขซีเรียลที่กำหนด (SWD) - คุณต้องตั้งค่าหมายเลขซีเรียลก่อน",
ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด