Started total reworking for supporting modern cmake features (notably - imported targets).

First steps: CMSIS headers and startup sources, linker script generation, some test.

cmake/stm32/cmsis.cmake

@@ -0,0 +1,52 @@
+include(FindPackageHandleStandardArgs)
+
+function(stm32_add_cmsis TARGET)
+    stm32_get_chip(${TARGET} FAMILY DEVICE) 
+    stm32_get_type(${FAMILY} ${DEVICE} TYPE)
+    string(TOLOWER ${FAMILY} FAMILY_L)
+    string(TOLOWER ${DEVICE} DEVICE_L)
+    string(TOLOWER ${TYPE} TYPE_L)
+    
+    if(NOT STM32_CUBE_${FAMILY}_PATH)
+        set(STM32_CUBE_${FAMILY}_PATH /opt/STM32Cube_FW_${FAMILY} CACHE PATH "Path to STM32Cube_FW_${FAMILY}")
+        message(STATUS "No STM32_CUBE_${FAMILY}_PATH specified using default: ${STM32_CUBE_${FAMILY}_PATH}")
+    endif()
+    
+    set(CMSIS_PATH "${STM32_CUBE_${FAMILY}_PATH}/Drivers/CMSIS")
+    
+    find_path(STM32_CMSIS_${FAMILY}_COMMON_INCLUDE
+        NAMES cmsis_version.h
+        PATHS "${CMSIS_PATH}/Include"
+        NO_DEFAULT_PATH
+    )
+    find_path(STM32_CMSIS_${FAMILY}_INCLUDE
+        NAMES stm32${FAMILY_L}xx.h
+        PATHS "${CMSIS_PATH}/Device/ST/STM32${FAMILY}xx/Include"
+        NO_DEFAULT_PATH
+    )
+    find_file(STM32_CMSIS_${FAMILY}_SOURCE
+        NAMES system_stm32${FAMILY_L}xx.c
+        PATHS "${CMSIS_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates"
+        NO_DEFAULT_PATH
+    )
+    find_file(STM32_CMSIS_${FAMILY}_${TYPE}_STARTUP
+        NAMES startup_stm32f${TYPE_L}.s
+        PATHS "${CMSIS_PATH}/Device/ST/STM32${FAMILY}xx/Source/Templates/gcc"
+        NO_DEFAULT_PATH
+    )
+    if((NOT STM32_CMSIS_${FAMILY}_COMMON_INCLUDE) OR
+       (NOT STM32_CMSIS_${FAMILY}_INCLUDE) OR
+       (NOT STM32_CMSIS_${FAMILY}_SOURCE) OR
+       (NOT STM32_CMSIS_${FAMILY}_${TYPE}_STARTUP))
+        message(FATAL_ERROR "Cannot find CMSIS. Make sure STM32_CUBE_${FAMILY}_PATH contains path to STM32Cube_FW_${FAMILY}.")
+    endif()
+            
+    target_include_directories(${TARGET} PRIVATE 
+        ${STM32_CMSIS_${FAMILY}_COMMON_INCLUDE} 
+        ${STM32_CMSIS_${FAMILY}_INCLUDE}
+    )
+    target_sources(${TARGET} PRIVATE 
+        ${STM32_CMSIS_${FAMILY}_${TYPE}_STARTUP}
+        ${STM32_CMSIS_${FAMILY}_SOURCE}
+    )    
+endfunction()

cmake/stm32/common.cmake

@@ -0,0 +1,189 @@
+set(STM32_SUPPORTED_FAMILIES L0 L1 L4 F0 F1 F2 F3 F4 F7 H7)
+
+if(NOT STM32_TOOLCHAIN_PATH)
+     set(STM32_TOOLCHAIN_PATH "/usr")
+     message(STATUS "No STM32_TOOLCHAIN_PATH specified, using default: " ${STM32_TOOLCHAIN_PATH})
+else()
+     file(TO_CMAKE_PATH "${STM32_TOOLCHAIN_PATH}" STM32_TOOLCHAIN_PATH)
+endif()
+
+if(NOT STM32_TARGET_TRIPLET)
+    set(STM32_TARGET_TRIPLET "arm-none-eabi")
+    message(STATUS "No STM32_TARGET_TRIPLET specified, using default: " ${STM32_TARGET_TRIPLET})
+endif()
+
+set(CMAKE_SYSTEM_NAME Generic)
+set(CMAKE_SYSTEM_PROCESSOR arm)
+
+set(TOOLCHAIN_SYSROOT  "${STM32_TOOLCHAIN_PATH}/${STM32_TARGET_TRIPLET}")
+set(TOOLCHAIN_BIN_PATH "${STM32_TOOLCHAIN_PATH}/bin")
+set(TOOLCHAIN_INC_PATH "${STM32_TOOLCHAIN_PATH}/${STM32_TARGET_TRIPLET}/include")
+set(TOOLCHAIN_LIB_PATH "${STM32_TOOLCHAIN_PATH}/${STM32_TARGET_TRIPLET}/lib")
+
+SET(CMAKE_OBJCOPY "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-objcopy" CACHE INTERNAL "objcopy tool")
+SET(CMAKE_OBJDUMP "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-objdump" CACHE INTERNAL "objdump tool")
+SET(CMAKE_SIZE "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-size" CACHE INTERNAL "size tool tool")
+SET(CMAKE_DEBUGGER "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-gdb" CACHE INTERNAL "debugger tool")
+SET(CMAKE_CPPFILT "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-c++filt" CACHE INTERNAL "C++filt tool")
+
+include(stm32/f4)
+include(stm32/linker)
+include(stm32/cmsis)
+
+function(stm32_get_chip TARGET FAMILY DEVICE)
+    get_target_property(CHIP ${TARGET} STM32_CHIP)
+    string(TOUPPER ${CHIP} CHIP)
+    
+    if(NOT CHIP)
+        message(FATAL_ERROR "Please specify STM32 chip for target ${TARGET} using STM32_CHIP property")
+    endif()
+    
+    string(REGEX MATCH "^STM32([A-Z][0-9])([0-9][0-9][A-Z][0-9A-Z]).*$" CHIP ${CHIP})
+    
+    if((NOT CMAKE_MATCH_1) OR (NOT CMAKE_MATCH_2))
+        message(FATAL_ERROR "Unknown chip ${CHIP}")
+    endif()
+    
+    set(STM32_FAMILY ${CMAKE_MATCH_1})
+    set(STM32_DEVICE "${CMAKE_MATCH_1}${CMAKE_MATCH_2}")
+    
+    list(FIND STM32_SUPPORTED_FAMILIES ${STM32_FAMILY} STM32_FAMILY_INDEX)
+    if (STM32_FAMILY_INDEX EQUAL -1)
+        message(FATAL_ERROR "Unsupported family ${STM32_FAMILY} for device ${CHIP}")
+    endif()
+
+    set(${FAMILY} ${STM32_FAMILY} PARENT_SCOPE)
+    set(${DEVICE} ${STM32_DEVICE} PARENT_SCOPE)
+endfunction()
+
+function(stm32_get_type FAMILY DEVICE TYPE)
+    if(${FAMILY} STREQUAL "F4")
+        stm32f4_get_type(${DEVICE} T)
+    endif()
+    set(${TYPE} ${T} PARENT_SCOPE)
+endfunction()
+
+function(stm32_configure_compiler TARGET)
+    stm32_get_chip(${TARGET} STM32_FAMILY STM32_DEVICE) 
+    
+    target_compile_options(${TARGET} PRIVATE 
+        --sysroot="${TOOLCHAIN_SYSROOT}"
+        -mthumb -mabi=aapcs -Wall -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin -ffast-math
+        $<$<CONFIG:Debug>:-Og>
+        $<$<CONFIG:Release>:-Os>
+    )
+    target_link_options(${TARGET} PRIVATE 
+        --sysroot="${TOOLCHAIN_SYSROOT}"
+        -mthumb -mabi=aapcs -Wl,--gc-sections
+        $<$<CONFIG:Debug>:-Og>
+        $<$<CONFIG:Release>:-Os -s>
+    )
+
+    get_target_property(SPECS ${TARGET} STM32_GCC_SPECS)
+    if(SPECS)
+        target_compile_options(${TARGET} PRIVATE $<$<C_COMPILER_ID:GNU>:--specs=${SPECS}.specs>)
+        target_link_options(${TARGET} PRIVATE $<$<C_COMPILER_ID:GNU>:--specs=${SPECS}.specs>)
+    endif()
+    
+    if(${STM32_FAMILY} STREQUAL "F4")
+        stm32f4_configure_compiler(${TARGET})
+    endif()
+endfunction()
+
+function(stm32_target TARGET)
+    get_target_property(TARGET_TYPE ${TARGET} TYPE)
+    stm32_configure_compiler(${TARGET})
+    if(TARGET_TYPE STREQUAL EXECUTABLE)
+        get_target_property(NO_LINKER_SCRIPT ${TARGET} STM32_NO_LINKER_SCRIPT)
+        if(NOT NO_LINKER_SCRIPT)
+            stm32_generate_linker_script(${TARGET})
+        endif()
+        get_target_property(NO_CMSIS ${TARGET} STM32_NO_CMSIS)
+        if(NOT NO_CMSIS)
+            stm32_add_cmsis(${TARGET})
+        endif()
+    endif()
+endfunction()
+
+# function(nrf52_add_sdk_startup TARGET)
+#     get_target_property(TARGET_NO_SDK ${TARGET} STM32_NO_SDK)
+#     if(TARGET_NO_SDK)
+#         return()
+#     endif()
+# 
+#     target_include_directories(${TARGET} PRIVATE "${NRF5_SDK_PATH}/components/toolchain/cmsis/include")
+#     target_include_directories(${TARGET} PRIVATE "${NRF5_SDK_PATH}/modules/nrfx/mdk")
+#     
+#     nrf52_get_chip(${TARGET} STM32_CHIP STM32_CHIP_VARIANT)
+#     
+#     unset(STM32_STARTUP_FILE CACHE)
+#     find_file(STM32_STARTUP_FILE
+#         NAMES gcc_startup_nrf52${STM32_CHIP}.S gcc_startup_nrf52.S
+#         PATHS "${NRF5_SDK_PATH}/modules/nrfx/mdk"
+#         NO_DEFAULT_PATH
+#     )
+#     
+#     unset(STM32_SYSTEM_FILE CACHE)
+#     find_file(STM32_SYSTEM_FILE
+#         NAMES system_nrf52${STM32_CHIP}.c system_nrf52.c
+#         PATHS "${NRF5_SDK_PATH}/modules/nrfx/mdk"
+#         NO_DEFAULT_PATH
+#     )
+#     
+#     if((NOT STM32_STARTUP_FILE) OR (NOT STM32_SYSTEM_FILE))
+#         message(WARNING "Cannot find startup sources for target ${TARGET}, check NRF5_SDK_PATH variable")
+#     else()
+#         target_sources(${TARGET} PRIVATE "${STM32_STARTUP_FILE}" "${STM32_SYSTEM_FILE}")
+#     endif()
+# endfunction()
+# 
+# function(nrf52_add_linker_script TARGET SCRIPT)
+#     target_link_options(${TARGET} PRIVATE -T "${SCRIPT}")
+#     target_link_options(${TARGET} PRIVATE -L "${NRF5_SDK_PATH}/modules/nrfx/mdk")
+# endfunction()
+# 
+# function(nrf52_generate_linker_script TARGET)
+#     get_target_property(TARGET_NO_LINKER_SCRIPT ${TARGET} STM32_NO_LINKER_SCRIPT)
+#     if(TARGET_NO_LINKER_SCRIPT)
+#         return()
+#     endif()
+#     set(STM32_LINKER_FILE ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.ld)
+#     nrf52_linker_generate_script(${TARGET} "${STM32_LINKER_FILE}")
+#     nrf52_add_linker_script(${TARGET} "${STM32_LINKER_FILE}")
+# endfunction()
+# 
+# function(nrf52_configure_compiler TARGET)
+#     nrf52_get_chip(${TARGET} STM32_CHIP STM32_CHIP_VARIANT)
+#     
+#     if(STM32_CHIP EQUAL 840)
+#         target_compile_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16)
+#         target_compile_definitions(${TARGET} PRIVATE -DFLOAT_ABI_HARD)
+#         target_link_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16)
+#     elseif(STM32_CHIP EQUAL 832)
+#         target_compile_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16)
+#         target_link_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16)
+#         target_compile_definitions(${TARGET} PRIVATE -DFLOAT_ABI_HARD)
+#     elseif(STM32_CHIP EQUAL 811)
+#         target_compile_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=soft)
+#         target_compile_definitions(${TARGET} PRIVATE -DFLOAT_ABI_SOFT)
+#         target_link_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=soft)
+#     elseif(STM32_CHIP EQUAL 810)
+#         target_compile_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=soft)
+#         target_compile_definitions(${TARGET} PRIVATE -DFLOAT_ABI_SOFT)
+#         target_link_options(${TARGET} PRIVATE -mcpu=cortex-m4 -mfloat-abi=soft)
+#     endif()
+#     
+#     target_compile_options(${TARGET} PRIVATE -mthumb -mabi=aapcs -Wall -ffunction-sections -fdata-sections -fno-strict-aliasing -fno-builtin -fshort-enums $<$<CONFIG:Release>:-Os>)
+#     target_compile_definitions(${TARGET} PRIVATE -DSTM32${STM32_CHIP}_XX${STM32_CHIP_VARIANT})
+#     target_link_options(${TARGET} PRIVATE -mthumb -mabi=aapcs -Wl,--gc-sections --specs=nano.specs $<$<CONFIG:Release>:-Os>)
+# endfunction()
+# 
+# function(nrf52_target TARGET)
+#     get_target_property(TARGET_TYPE ${TARGET} TYPE)    
+#     nrf52_configure_compiler(${TARGET})
+#     if(TARGET_TYPE STREQUAL EXECUTABLE)
+#         nrf52_add_sdk_startup(${TARGET})
+#         nrf52_generate_linker_script(${TARGET})
+#         target_link_libraries(${TARGET} PRIVATE -lc -lnosys -lm)
+#     endif()
+# endfunction()

cmake/stm32/f4.cmake

@@ -0,0 +1,86 @@
+set(STM32F4_TYPES 
+    401xC 401xE 405xx 407xx 410Cx 410Rx 410Tx 411xE 
+    412Cx 412Rx 412Vx 412Zx 413xx 415xx 417xx 423xx
+    427xx 429xx 437xx 439xx 446xx 469xx 479xx
+)
+set(STM32F4_TYPE_MATCH 
+    "F401.[CB]" "F401.[ED]" "F405.." "F407.." "F410C." "F410R." "F410T." "F411.[CE]"
+    "F412C." "F412R." "F412V." "F412Z." "F413.." "F415.." "F417.." "F423.."
+    "F427.." "F429.." "F437.." "F439.." "F446.." "F469.." "F479.."
+)
+set(STM32F4_RAM_SIZES 
+     64K  96K 128K 128K  32K  32K  32K 128K
+    256K 256K 256K 256K 256K 128K 128K 320K
+    192K 192K 192K 192K 128K 320K 320K
+)
+
+set(STM32F4_CCRAM_SIZES 
+     0K  0K 64K 64K  0K  0K  0K  0K
+     0K  0K  0K  0K 64K 64K 64K  0K
+    64K 64K 64K 64K  0K 64K 64K
+)
+
+function(stm32f4_get_type DEVICE TYPE)
+    set(INDEX 0)
+    foreach(C_TYPE ${STM32F4_TYPES})
+        list(GET STM32F4_TYPE_MATCH ${INDEX} REGEXP)
+        if(DEVICE MATCHES ${REGEXP})
+            set(RESULT_TYPE ${C_TYPE})
+        endif()
+        math(EXPR INDEX "${INDEX}+1")
+    endforeach()
+    if(NOT RESULT_TYPE)
+        message(FATAL_ERROR "Invalid/unsupported STM32F4 device: ${DEVICE}")
+    endif()
+    set(${TYPE} ${RESULT_TYPE} PARENT_SCOPE)
+endfunction()
+
+function(stm32f4_memory_size DEVICE FLASH_SIZE RAM_SIZE CCRAM_SIZE)
+    string(REGEX REPLACE "^F4[0-9][0-9].([8BCDEGHI])$" "\\1" SIZE_CODE ${DEVICE})
+    
+    if(SIZE_CODE STREQUAL "8")
+        set(FLASH "64K")
+    elseif(SIZE_CODE STREQUAL "B")
+        set(FLASH "128K")
+    elseif(SIZE_CODE STREQUAL "C")
+        set(FLASH "256K")
+    elseif(SIZE_CODE STREQUAL "D")
+        set(FLASH "384K")
+    elseif(SIZE_CODE STREQUAL "E")
+        set(FLASH "512K")
+    elseif(SIZE_CODE STREQUAL "G")
+        set(FLASH "1024K")
+    elseif(SIZE_CODE STREQUAL "H")
+        set(FLASH "1536K")
+    elseif(SIZE_CODE STREQUAL "I")
+        set(FLASH "2048K")
+    else()
+        set(FLASH "64K")
+        message(WARNING "Unknow flash size for device ${DEVICE}")
+    endif()
+        
+    stm32f4_get_type(${DEVICE} TYPE)
+    list(FIND STM32F4_TYPES ${TYPE} TYPE_INDEX)
+    list(GET STM32F4_RAM_SIZES ${TYPE_INDEX} RAM)
+    list(GET STM32F4_CCRAM_SIZES ${TYPE_INDEX} CCRAM)
+    
+    set(${FLASH_SIZE} ${FLASH} PARENT_SCOPE)
+    set(${RAM_SIZE} ${RAM} PARENT_SCOPE)
+    set(${CCRAM_SIZE} ${CCRAM} PARENT_SCOPE)
+endfunction()
+
+function(stm32f4_configure_compiler TARGET)
+    stm32_get_chip(${TARGET} FAMILY DEVICE)
+    stm32f4_get_type(${DEVICE} TYPE)
+    
+    target_compile_options(${TARGET} PRIVATE 
+        -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+    )
+    target_link_options(${TARGET} PRIVATE 
+        -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+    )
+    target_compile_definitions(${TARGET} PRIVATE 
+        STM32F4 
+        STM32F${TYPE}
+    )
+endfunction()

cmake/stm32/linker.cmake

@@ -0,0 +1,190 @@
+function(stm32_set_linker_script TARGET SCRIPT)
+    target_link_options(${TARGET} PRIVATE -T "${SCRIPT}")
+endfunction()
+
+function(stm32_generate_linker_script TARGET)
+    stm32_get_chip(${TARGET} FAMILY DEVICE)
+    
+    get_target_property(FLASH_ORIGIN ${TARGET} STM32_FLASH_ORIGIN)
+    get_target_property(RAM_ORIGIN ${TARGET} STM32_RAM_ORIGIN)
+    get_target_property(CCRAM_ORIGIN ${TARGET} STM32_CCRAM_ORIGIN)
+    get_target_property(FLASH_SIZE ${TARGET} STM32_FLASH_SIZE)
+    get_target_property(RAM_SIZE ${TARGET} STM32_RAM_SIZE)
+    get_target_property(CCRAM_SIZE ${TARGET} STM32_CCRAM_SIZE)
+    get_target_property(STACK_SIZE ${TARGET} STM32_STACK_SIZE)
+    get_target_property(HEAP_SIZE ${TARGET} STM32_HEAP_SIZE)
+    
+    if(NOT FLASH_ORIGIN)
+        set(FLASH_ORIGIN 0x8000000)
+    endif()
+    if(NOT RAM_ORIGIN)
+        set(RAM_ORIGIN 0x20000000)
+    endif()
+    if(NOT CCRAM_ORIGIN)
+        set(CCRAM_ORIGIN 0x10000000)
+    endif()
+    
+    if(${FAMILY} STREQUAL "F4")
+        stm32f4_memory_size(${DEVICE} DEF_FLASH DEF_RAM DEF_CCRAM)
+    endif()
+    
+    if(NOT FLASH_SIZE)
+        set(FLASH_SIZE ${DEF_FLASH})
+    endif()
+    if(NOT RAM_SIZE)
+        set(RAM_SIZE ${DEF_RAM})
+    endif()
+    if(NOT CCRAM_SIZE)
+        set(CCRAM_SIZE ${DEF_CCRAM})
+    endif()
+    if(NOT STACK_SIZE)
+        set(STACK_SIZE 0x400)
+    endif()
+    if(NOT HEAP_SIZE)
+        set(HEAP_SIZE 0x200)
+    endif()
+    
+    if((NOT CCRAM_SIZE) OR (CCRAM_SIZE STREQUAL "0K"))
+        set(CCRAM_DEFINITION "")
+        set(CCRAM_SECTION "")
+    else()
+        set(CCRAM_DEFINITION "    CCMRAM (rw) : ORIGIN = ${CCRAM_ORIGIN}, LENGTH = ${CCRAM_SIZE}\n")
+        set(CCRAM_SECTION "
+_siccmram = LOADADDR(.ccmram);\n\
+.ccmram :\n\
+{\n\
+. = ALIGN(4);\n\
+_sccmram = .;\n\
+*(.ccmram)\n\
+*(.ccmram*)\n\
+. = ALIGN(4);\n\
+_eccmram = .;\n\
+} >CCMRAM AT> FLASH\n\
+        ")
+    endif()
+    
+    set(SCRIPT_TEXT 
+"ENTRY(Reset_Handler)\n\
+\n\
+_estack = ${RAM_ORIGIN} + ${RAM_SIZE};\n\
+_Min_Heap_Size = ${HEAP_SIZE};\n\
+_Min_Stack_Size = ${STACK_SIZE};\n\
+\n\
+MEMORY\n\
+{\n\
+    FLASH (rx)      : ORIGIN = ${FLASH_ORIGIN}, LENGTH = ${FLASH_SIZE}\n\
+    RAM (xrw)      : ORIGIN = ${RAM_ORIGIN}, LENGTH = ${RAM_SIZE}\n\
+${CCRAM_DEFINITION}\n\
+}\n\
+\n\
+SECTIONS\n\
+{\n\
+  .isr_vector :\n\
+  {\n\
+    . = ALIGN(4);\n\
+    KEEP(*(.isr_vector))\n\
+    . = ALIGN(4);\n\
+  } >FLASH\n\
+\n\
+  .text :\n\
+  {\n\
+    . = ALIGN(4);\n\
+    *(.text)\n\
+    *(.text*)\n\
+    *(.glue_7)\n\
+    *(.glue_7t)\n\
+    *(.eh_frame)\n\
+\n\
+    KEEP (*(.init))\n\
+    KEEP (*(.fini))\n\
+\n\
+    . = ALIGN(4);\n\
+    _etext = .;\n\
+  } >FLASH\n\
+\n\
+  .rodata :\n\
+  {\n\
+    . = ALIGN(4);\n\
+    *(.rodata)\n\
+    *(.rodata*)\n\
+    . = ALIGN(4);\n\
+  } >FLASH\n\
+\n\
+  .ARM.extab   : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH\n\
+  .ARM : {\n\
+    __exidx_start = .;\n\
+    *(.ARM.exidx*)\n\
+    __exidx_end = .;\n\
+  } >FLASH\n\
+\n\
+  .preinit_array     :\n\
+  {\n\
+    PROVIDE_HIDDEN (__preinit_array_start = .);\n\
+    KEEP (*(.preinit_array*))\n\
+    PROVIDE_HIDDEN (__preinit_array_end = .);\n\
+  } >FLASH\n\
+  .init_array :\n\
+  {\n\
+    PROVIDE_HIDDEN (__init_array_start = .);\n\
+    KEEP (*(SORT(.init_array.*)))\n\
+    KEEP (*(.init_array*))\n\
+    PROVIDE_HIDDEN (__init_array_end = .);\n\
+  } >FLASH\n\
+  .fini_array :\n\
+  {\n\
+    PROVIDE_HIDDEN (__fini_array_start = .);\n\
+    KEEP (*(SORT(.fini_array.*)))\n\
+    KEEP (*(.fini_array*))\n\
+    PROVIDE_HIDDEN (__fini_array_end = .);\n\
+  } >FLASH\n\
+\n\
+  _sidata = LOADADDR(.data);\n\
+\n\
+  .data : \n\
+  {\n\
+    . = ALIGN(4);\n\
+    _sdata = .; \n\
+    *(.data)\n\
+    *(.data*)\n\
+\n\
+    . = ALIGN(4);\n\
+    _edata = .;\n\
+  } >RAM AT> FLASH\n\
+${CCRAM_SECTION}\n\
+  . = ALIGN(4);\n\
+  .bss :\n\
+  {\n\
+    _sbss = .;\n\
+    __bss_start__ = _sbss;\n\
+    *(.bss)\n\
+    *(.bss*)\n\
+    *(COMMON)\n\
+\n\
+    . = ALIGN(4);\n\
+    _ebss = .;\n\
+    __bss_end__ = _ebss;\n\
+  } >RAM\n\
+\n\
+  ._user_heap_stack :\n\
+  {\n\
+    . = ALIGN(8);\n\
+    PROVIDE ( end = . );\n\
+    PROVIDE ( _end = . );\n\
+    . = . + _Min_Heap_Size;\n\
+    . = . + _Min_Stack_Size;\n\
+    . = ALIGN(8);\n\
+  } >RAM\n\
+\n\
+  /DISCARD/ :\n\
+  {\n\
+    libc.a ( * )\n\
+    libm.a ( * )\n\
+    libgcc.a ( * )\n\
+  }\n\
+\n\
+  .ARM.attributes 0 : { *(.ARM.attributes) }\n\
+}"
+    )
+    file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_flash.ld CONTENT "${SCRIPT_TEXT}")
+    stm32_set_linker_script(${TARGET} ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_flash.ld)
+endfunction() 

cmake/stm32_gcc.cmake

@@ -0,0 +1,9 @@
+get_filename_component(STM32_CMAKE_DIR ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
+list(APPEND CMAKE_MODULE_PATH ${STM32_CMAKE_DIR})
+
+include(stm32/common)
+
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+set(CMAKE_C_COMPILER "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-gcc")
+set(CMAKE_CXX_COMPILER "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-g++")
+set(CMAKE_ASM_COMPILER "${TOOLCHAIN_BIN_PATH}/${STM32_TARGET_TRIPLET}-gcc")

packages/CMakeLists.txt

@@ -1,92 +0,0 @@
-cmake_minimum_required(VERSION 2.8.3)
-set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/../gcc_stm32.cmake")
-project(stm32_packages)
-
-if (NOT DEFINED TARGET_TRIPLET)
-  set(TARGET_TRIPLET "arm-none-eabi")
-endif()
-set(CMAKE_BUILD_TYPE "Release")
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules")
-
-set(STM_ARCHIVE_BASEURL "http://www.st.com/st-web-ui/static/active/en/st_prod_software_internet/resource/technical/software/firmware")
-set(STM_ARCHIVE_F1 "stsw-stm32054.zip")
-set(STM_ARCHIVE_F4 "stm32f4_dsp_stdperiph_lib.zip")
-set(STM_ARCHIVE_VERSION_F1 "3.5.0")
-set(STM_ARCHIVE_VERSION_F4 "1.3.0")
-set(STM_ARCHIVE_DIR_F1 "STM32F10x_StdPeriph_Lib_V${STM_ARCHIVE_VERSION_F1}")
-set(STM_ARCHIVE_DIR_F4 "STM32F4xx_DSP_StdPeriph_Lib_V${STM_ARCHIVE_VERSION_F4}")
-
-set(PACKAGE_TYPE "deb")
-
-if(NOT DEFINED STM32_FAMILY)
-  message(FATAL_ERROR "Please specify STM32_FAMILY, eg cmake -DSTM32_FAMILY=F4")
-endif()
-
-set(STM_ARCHIVE "${STM_ARCHIVE_${STM32_FAMILY}}")
-if(EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${STM_ARCHIVE}") 
-  message(STATUS "Using already-downloaded archive: ${STM_ARCHIVE}")
-else()
-  message(STATUS "From st.com, downloading ${STM_ARCHIVE}")
-  file(DOWNLOAD "${STM_ARCHIVE_BASEURL}/${STM_ARCHIVE}"
-                "${CMAKE_CURRENT_BINARY_DIR}/${STM_ARCHIVE}" SHOW_PROGRESS)
-endif()
-
-set(STM_ARCHIVE_DIR "${STM_ARCHIVE_DIR_${STM32_FAMILY}}")
-set(STM_ARCHIVE_FULLDIR "${CMAKE_CURRENT_BINARY_DIR}/${STM_ARCHIVE_DIR}")
-if(EXISTS "${STM_ARCHIVE_FULLDIR}")
-  message(STATUS "Using already-extracted path: ${STM_ARCHIVE_DIR}")
-else()
-  execute_process(COMMAND unzip -o ${STM_ARCHIVE})
-endif()
-
-add_custom_target(debs ALL)
-
-# Install everything into a subdirectory so that we can package it from there.
-set(STM32F1_CHIP_TYPES HD HD_VL MD MD_VL LD LD_VL XL)
-set(STM32F4_CHIP_TYPES 401xx 40_41xxx 427_437xx 429_439xx)
-set(STM32_CHIP_TYPES "${STM32${STM32_FAMILY}_CHIP_TYPES}")
-set(STM32${STM32_FAMILY}_StdPeriphLib_DIR "${STM_ARCHIVE_FULLDIR}")
-
-# Add targets for building cmsis libraries
-set(CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/install/usr/${TARGET_TRIPLET}/")
-add_subdirectory(../cmsis ${CMAKE_CURRENT_BINARY_DIR}/cmsis)
-
-# Add targets for building stdperiph libraries, which need the cmsis headers
-get_property(CMSIS_INCLUDE_DIR DIRECTORY ../cmsis PROPERTY INCLUDE_DIRECTORIES)
-add_subdirectory(../stdperiph ${CMAKE_CURRENT_BINARY_DIR}/stdperiph)
-
-# Ensure all those get built.
-add_custom_target(install_stm32${STM32_FAMILY_LOWER})
-add_dependencies(install_stm32${STM32_FAMILY_LOWER}
-                 cmsis_${STM32_FAMILY_LOWER}
-                 stdperiph_${STM32_FAMILY_LOWER})
-
-set(MODULES_DIR ${CMAKE_CURRENT_BINARY_DIR}/install/usr/share/cmake-2.8/Modules)
-add_custom_command(TARGET install_stm32${STM32_FAMILY_LOWER} POST_BUILD
-  COMMAND ${CMAKE_COMMAND} -P cmake_install.cmake
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules/FindCMSIS.cmake
-          ${MODULES_DIR}/FindCMSIS.cmake
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules/FindStdPeriphLib.cmake
-          ${MODULES_DIR}/FindStdPeriphLib.cmake
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/../gcc_stm32.cmake
-          ${MODULES_DIR}/gcc_stm32.cmake
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/../gcc_stm32${STM32_FAMILY_LOWER}.cmake
-          ${MODULES_DIR}/gcc_stm32${STM32_FAMILY_LOWER}.cmake
-)
-
-# Create package.
-set(PACKAGE_NAME "stm32${STM32_FAMILY_LOWER}-stdperiph")
-set(PACKAGE_VERSION "${STM_ARCHIVE_VERSION_${STM32_FAMILY}}")
-set(PACKAGE_FILENAME "${PACKAGE_NAME}_${PACKAGE_VERSION}_all.${PACKAGE_TYPE}")
-
-add_custom_command(
-  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_FILENAME}
-  COMMAND fpm -a all -s dir -t ${PACKAGE_TYPE} -n ${PACKAGE_NAME}
-              -d gcc-arm-none-eabi
-              -v ${PACKAGE_VERSION} -C install usr
-)
-add_custom_target(${PACKAGE_FILENAME}_
-  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_FILENAME}
-)
-add_dependencies(${PACKAGE_FILENAME}_ install_stm32${STM32_FAMILY_LOWER})
-add_dependencies(debs ${PACKAGE_FILENAME}_)

packages/README.md

@@ -1,46 +0,0 @@
-Package Generation
-==================
-
-This directory creates a debian package of the stm32f1 or f4 CMSIS and StdPeriph libraries
-and headers. This is useful for a few reasons:
-
- - You can use `sudo dpkg -i` to install a deb and avoid manually compiling
-   and installing the library.
- - You can place the deb on an apt repository, and make it trivially easy to
-   set up a development environment on any Ubuntu or Debian machine---this is
-   great for getting a whole team up and running quickly, or for throwaway
-   environments such as CI builders and virtual machines.
-
-Toolchain
----------
-
-You need the right GCC compiler, which is `gcc-arm-none-eabi`. Fortunately, if you're on
-Ubuntu, this is really easy to get from Launchpad, thanks to Terry Guo's PPA:
-
-~~~
-sudo add-apt-repository ppa:team-gcc-arm-embedded/ppa
-sudo apt-get update
-sudo apt-get install gcc-arm-embedded
-~~~
-
-Building the deb
-----------------
-
-You'll need a [fpm](https://github.com/jordansissel/fpm), which is what actually produces
-the deb package from a folder of files. This comes from rubygems:
-
-~~~
-sudo apt-get install rubygems
-gem install fpm
-~~~
-
-Apart from that, it's a regular build:
-
-~~~
-mkdir packages/build
-cd packages/build
-cmake .. -DSTM32_FAMILY=F4
-make
-~~~
-
-Enjoy your deb!

stm32-template/CMakeLists.txt

@@ -1,25 +1,15 @@
-PROJECT(stm32-template)
+set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/stm32_gcc.cmake)
+cmake_minimum_required(VERSION 3.8)
 
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-ENABLE_LANGUAGE(ASM)
+project(stm32-template C ASM)
 
-FIND_PACKAGE(CMSIS REQUIRED)
-FIND_PACKAGE(STM32HAL REQUIRED)
-
-INCLUDE_DIRECTORIES(
-    ${CMAKE_CURRENT_SOURCE_DIR}
-    ${CMSIS_INCLUDE_DIRS}
-    ${STM32HAL_INCLUDE_DIR}
-)
-
-SET(PROJECT_SOURCES
+set(PROJECT_SOURCES
     main.c
 )
 
-SET(STM32_LINKER_SCRIPT ${CMSIS_LINKER_SCRIPT})
-
-ADD_EXECUTABLE(${CMAKE_PROJECT_NAME} ${PROJECT_SOURCES} ${CMSIS_SOURCES} ${STM32HAL_SOURCES})
-
-STM32_SET_TARGET_PROPERTIES(${CMAKE_PROJECT_NAME})
-STM32_ADD_HEX_BIN_TARGETS(${CMAKE_PROJECT_NAME})
-STM32_PRINT_SIZE_OF_TARGETS(${CMAKE_PROJECT_NAME})
+add_executable(stm32-template.elf ${PROJECT_SOURCES})
+set_target_properties(stm32-template.elf PROPERTIES 
+    STM32_CHIP STM32F407IG
+    STM32_GCC_SPECS nosys
+)
+stm32_target(stm32-template.elf)

stm32-template/main.c

@@ -1,11 +1,3 @@
-#if defined STM32F1
-# include <stm32f1xx.h>
-#elif defined STM32F2
-# include <stm32f2xx.h>
-#elif defined STM32F4
-# include <stm32f4xx.h>
-#endif
-
 int main(void)
 {
     for (;;);

tests/cmsis/CMakeLists.txt

@@ -0,0 +1,22 @@
+set(CMAKE_TOOLCHAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/stm32_gcc.cmake)
+cmake_minimum_required(VERSION 3.8)
+
+project(cmsis-test C ASM)
+
+set(SOURCES main.c)
+
+include(${CMAKE_SOURCE_DIR}/../stm32_devices.cmake)
+stm32_get_devices_by_family(F4 DEVICES)
+
+foreach(DEVICE ${DEVICES})
+    string(TOLOWER ${DEVICE} DEVICE_L)
+    set(TARGET cmsis-test-${DEVICE_L})
+    
+    message(STATUS "Testing ${DEVICE}...")
+    add_executable(${TARGET} ${SOURCES})
+    set_target_properties(${TARGET} PROPERTIES 
+        STM32_CHIP ${DEVICE}
+        STM32_GCC_SPECS nosys
+    )
+    stm32_target(${TARGET})
+endforeach()

tests/cmsis/main.c

@@ -0,0 +1,5 @@
+int main(void)
+{
+    for (;;);
+    return 0;
+}

tests/stm32_devices.cmake

@@ -0,0 +1,1060 @@
+set(STM32_ALL_DEVICES
+    STM32F030C6
+    STM32F030C8
+    STM32F030CC
+    STM32F030F4
+    STM32F030K6
+    STM32F030R8
+    STM32F030RC
+    STM32F031C4
+    STM32F031C6
+    STM32F031E6
+    STM32F031F4
+    STM32F031F6
+    STM32F031G4
+    STM32F031G6
+    STM32F031K4
+    STM32F031K6
+    STM32F038C6
+    STM32F038E6
+    STM32F038F6
+    STM32F038G6
+    STM32F038K6
+    STM32F042C4
+    STM32F042C6
+    STM32F042F4
+    STM32F042F6
+    STM32F042G4
+    STM32F042G6
+    STM32F042K4
+    STM32F042K6
+    STM32F042T6
+    STM32F048C6
+    STM32F048G6
+    STM32F048T6
+    STM32F051C4
+    STM32F051C6
+    STM32F051C8
+    STM32F051K4
+    STM32F051K6
+    STM32F051K8
+    STM32F051R4
+    STM32F051R6
+    STM32F051R8
+    STM32F051T8
+    STM32F058C8
+    STM32F058R8
+    STM32F058T8
+    STM32F070C6
+    STM32F070CB
+    STM32F070F6
+    STM32F070RB
+    STM32F071C8
+    STM32F071CB
+    STM32F071RB
+    STM32F071V8
+    STM32F071VB
+    STM32F072C8
+    STM32F072CB
+    STM32F072R8
+    STM32F072RB
+    STM32F072V8
+    STM32F072VB
+    STM32F078CB
+    STM32F078RB
+    STM32F078VB
+    STM32F091CB
+    STM32F091CC
+    STM32F091RB
+    STM32F091RC
+    STM32F091VB
+    STM32F091VC
+    STM32F098CC
+    STM32F098RC
+    STM32F098VC
+    STM32F100C4
+    STM32F100C6
+    STM32F100C8
+    STM32F100CB
+    STM32F100R4
+    STM32F100R6
+    STM32F100R8
+    STM32F100RB
+    STM32F100RC
+    STM32F100RD
+    STM32F100RE
+    STM32F100V8
+    STM32F100VB
+    STM32F100VC
+    STM32F100VD
+    STM32F100VE
+    STM32F100ZC
+    STM32F100ZD
+    STM32F100ZE
+    STM32F101C4
+    STM32F101C6
+    STM32F101C8
+    STM32F101CB
+    STM32F101R4
+    STM32F101R6
+    STM32F101R8
+    STM32F101RB
+    STM32F101RC
+    STM32F101RD
+    STM32F101RE
+    STM32F101RF
+    STM32F101RG
+    STM32F101T4
+    STM32F101T6
+    STM32F101T8
+    STM32F101TB
+    STM32F101V8
+    STM32F101VB
+    STM32F101VC
+    STM32F101VD
+    STM32F101VE
+    STM32F101VF
+    STM32F101VG
+    STM32F101ZC
+    STM32F101ZD
+    STM32F101ZE
+    STM32F101ZF
+    STM32F101ZG
+    STM32F102C4
+    STM32F102C6
+    STM32F102C8
+    STM32F102CB
+    STM32F102R4
+    STM32F102R6
+    STM32F102R8
+    STM32F102RB
+    STM32F103C4
+    STM32F103C6
+    STM32F103C8
+    STM32F103CB
+    STM32F103R4
+    STM32F103R6
+    STM32F103R8
+    STM32F103RB
+    STM32F103RC
+    STM32F103RD
+    STM32F103RE
+    STM32F103RF
+    STM32F103RG
+    STM32F103T4
+    STM32F103T6
+    STM32F103T8
+    STM32F103TB
+    STM32F103V8
+    STM32F103VB
+    STM32F103VC
+    STM32F103VD
+    STM32F103VE
+    STM32F103VF
+    STM32F103VG
+    STM32F103ZC
+    STM32F103ZD
+    STM32F103ZE
+    STM32F103ZF
+    STM32F103ZG
+    STM32F105R8
+    STM32F105RB
+    STM32F105RC
+    STM32F105V8
+    STM32F105VB
+    STM32F105VC
+    STM32F107RB
+    STM32F107RC
+    STM32F107VB
+    STM32F107VC
+    STM32F205RB
+    STM32F205RC
+    STM32F205RE
+    STM32F205RF
+    STM32F205RG
+    STM32F205VB
+    STM32F205VC
+    STM32F205VE
+    STM32F205VF
+    STM32F205VG
+    STM32F205ZC
+    STM32F205ZE
+    STM32F205ZF
+    STM32F205ZG
+    STM32F207IC
+    STM32F207IE
+    STM32F207IF
+    STM32F207IG
+    STM32F207VC
+    STM32F207VE
+    STM32F207VF
+    STM32F207VG
+    STM32F207ZC
+    STM32F207ZE
+    STM32F207ZF
+    STM32F207ZG
+    STM32F215RE
+    STM32F215RG
+    STM32F215VE
+    STM32F215VG
+    STM32F215ZE
+    STM32F215ZG
+    STM32F217IE
+    STM32F217IG
+    STM32F217VE
+    STM32F217VG
+    STM32F217ZE
+    STM32F217ZG
+    STM32F301C6
+    STM32F301C8
+    STM32F301K6
+    STM32F301K8
+    STM32F301R6
+    STM32F301R8
+    STM32F302C6
+    STM32F302C8
+    STM32F302CB
+    STM32F302CC
+    STM32F302K6
+    STM32F302K8
+    STM32F302R6
+    STM32F302R8
+    STM32F302RB
+    STM32F302RC
+    STM32F302RD
+    STM32F302RE
+    STM32F302VB
+    STM32F302VC
+    STM32F302VD
+    STM32F302VE
+    STM32F302ZD
+    STM32F302ZE
+    STM32F303C6
+    STM32F303C8
+    STM32F303CB
+    STM32F303CC
+    STM32F303K6
+    STM32F303K8
+    STM32F303R6
+    STM32F303R8
+    STM32F303RB
+    STM32F303RC
+    STM32F303RD
+    STM32F303RE
+    STM32F303VB
+    STM32F303VC
+    STM32F303VD
+    STM32F303VE
+    STM32F303ZD
+    STM32F303ZE
+    STM32F318C8
+    STM32F318K8
+    STM32F328C8
+    STM32F334C4
+    STM32F334C6
+    STM32F334C8
+    STM32F334K4
+    STM32F334K6
+    STM32F334K8
+    STM32F334R6
+    STM32F334R8
+    STM32F358CC
+    STM32F358RC
+    STM32F358VC
+    STM32F373C8
+    STM32F373CB
+    STM32F373CC
+    STM32F373R8
+    STM32F373RB
+    STM32F373RC
+    STM32F373V8
+    STM32F373VB
+    STM32F373VC
+    STM32F378CC
+    STM32F378RC
+    STM32F378VC
+    STM32F398VE
+    STM32F401CB
+    STM32F401CC
+    STM32F401CD
+    STM32F401CE
+    STM32F401RB
+    STM32F401RC
+    STM32F401RD
+    STM32F401RE
+    STM32F401VB
+    STM32F401VC
+    STM32F401VD
+    STM32F401VE
+    STM32F405OE
+    STM32F405OG
+    STM32F405RG
+    STM32F405VG
+    STM32F405ZG
+    STM32F407IE
+    STM32F407IG
+    STM32F407VE
+    STM32F407VG
+    STM32F407ZE
+    STM32F407ZG
+    STM32F410C8
+    STM32F410CB
+    STM32F410R8
+    STM32F410RB
+    STM32F410T8
+    STM32F410TB
+    STM32F411CC
+    STM32F411CE
+    STM32F411RC
+    STM32F411RE
+    STM32F411VC
+    STM32F411VE
+    STM32F412CE
+    STM32F412CG
+    STM32F412RE
+    STM32F412RG
+    STM32F412VE
+    STM32F412VG
+    STM32F412ZE
+    STM32F412ZG
+    STM32F413CG
+    STM32F413CH
+    STM32F413MG
+    STM32F413MH
+    STM32F413RG
+    STM32F413RH
+    STM32F413VG
+    STM32F413VH
+    STM32F413ZG
+    STM32F413ZH
+    STM32F415OG
+    STM32F415RG
+    STM32F415VG
+    STM32F415ZG
+    STM32F417IE
+    STM32F417IG
+    STM32F417VE
+    STM32F417VG
+    STM32F417ZE
+    STM32F417ZG
+    STM32F423CH
+    STM32F423MH
+    STM32F423RH
+    STM32F423VH
+    STM32F423ZH
+    STM32F427AG
+    STM32F427AI
+    STM32F427IG
+    STM32F427II
+    STM32F427VG
+    STM32F427VI
+    STM32F427ZG
+    STM32F427ZI
+    STM32F429AG
+    STM32F429AI
+    STM32F429BE
+    STM32F429BG
+    STM32F429BI
+    STM32F429IE
+    STM32F429IG
+    STM32F429II
+    STM32F429NE
+    STM32F429NG
+    STM32F429NI
+    STM32F429VE
+    STM32F429VG
+    STM32F429VI
+    STM32F429ZE
+    STM32F429ZG
+    STM32F429ZI
+    STM32F437AI
+    STM32F437IG
+    STM32F437II
+    STM32F437VG
+    STM32F437VI
+    STM32F437ZG
+    STM32F437ZI
+    STM32F439AI
+    STM32F439BG
+    STM32F439BI
+    STM32F439IG
+    STM32F439II
+    STM32F439NG
+    STM32F439NI
+    STM32F439VG
+    STM32F439VI
+    STM32F439ZG
+    STM32F439ZI
+    STM32F446MC
+    STM32F446ME
+    STM32F446RC
+    STM32F446RE
+    STM32F446VC
+    STM32F446VE
+    STM32F446ZC
+    STM32F446ZE
+    STM32F469AE
+    STM32F469AG
+    STM32F469AI
+    STM32F469BE
+    STM32F469BG
+    STM32F469BI
+    STM32F469IE
+    STM32F469IG
+    STM32F469II
+    STM32F469NE
+    STM32F469NG
+    STM32F469NI
+    STM32F469VE
+    STM32F469VG
+    STM32F469VI
+    STM32F469ZE
+    STM32F469ZG
+    STM32F469ZI
+    STM32F479AG
+    STM32F479AI
+    STM32F479BG
+    STM32F479BI
+    STM32F479IG
+    STM32F479II
+    STM32F479NG
+    STM32F479NI
+    STM32F479VG
+    STM32F479VI
+    STM32F479ZG
+    STM32F479ZI
+    STM32F722IC
+    STM32F722IE
+    STM32F722RC
+    STM32F722RE
+    STM32F722VC
+    STM32F722VE
+    STM32F722ZC
+    STM32F722ZE
+    STM32F723IC
+    STM32F723IE
+    STM32F723VE
+    STM32F723ZC
+    STM32F723ZE
+    STM32F730I8
+    STM32F730R8
+    STM32F730V8
+    STM32F730Z8
+    STM32F732IE
+    STM32F732RE
+    STM32F732VE
+    STM32F732ZE
+    STM32F733IE
+    STM32F733VE
+    STM32F733ZE
+    STM32F745IE
+    STM32F745IG
+    STM32F745VE
+    STM32F745VG
+    STM32F745ZE
+    STM32F745ZG
+    STM32F746BE
+    STM32F746BG
+    STM32F746IE
+    STM32F746IG
+    STM32F746NE
+    STM32F746NG
+    STM32F746VE
+    STM32F746VG
+    STM32F746ZE
+    STM32F746ZG
+    STM32F750N8
+    STM32F750V8
+    STM32F750Z8
+    STM32F756BG
+    STM32F756IG
+    STM32F756NG
+    STM32F756VG
+    STM32F756ZG
+    STM32F765BG
+    STM32F765BI
+    STM32F765IG
+    STM32F765II
+    STM32F765NG
+    STM32F765NI
+    STM32F765VG
+    STM32F765VI
+    STM32F765ZG
+    STM32F765ZI
+    STM32F767BG
+    STM32F767BI
+    STM32F767IG
+    STM32F767II
+    STM32F767NG
+    STM32F767NI
+    STM32F767VG
+    STM32F767VI
+    STM32F767ZG
+    STM32F767ZI
+    STM32F769AI
+    STM32F769BG
+    STM32F769BI
+    STM32F769IG
+    STM32F769II
+    STM32F769NG
+    STM32F769NI
+    STM32F777BI
+    STM32F777II
+    STM32F777NI
+    STM32F777VI
+    STM32F777ZI
+    STM32F778AI
+    STM32F779AI
+    STM32F779BI
+    STM32F779II
+    STM32F779NI
+    STM32G030C6
+    STM32G030C8
+    STM32G030F6
+    STM32G030J6
+    STM32G030K6
+    STM32G030K8
+    STM32G031C4
+    STM32G031C6
+    STM32G031C8
+    STM32G031F4
+    STM32G031F6
+    STM32G031F8
+    STM32G031G4
+    STM32G031G6
+    STM32G031G8
+    STM32G031J4
+    STM32G031J6
+    STM32G031K4
+    STM32G031K6
+    STM32G031K8
+    STM32G031Y8
+    STM32G041C6
+    STM32G041C8
+    STM32G041F6
+    STM32G041F8
+    STM32G041G6
+    STM32G041G8
+    STM32G041J6
+    STM32G041K6
+    STM32G041K8
+    STM32G041Y8
+    STM32G070CB
+    STM32G070KB
+    STM32G070RB
+    STM32G071C6
+    STM32G071C8
+    STM32G071CB
+    STM32G071EB
+    STM32G071G6
+    STM32G071G8
+    STM32G071GB
+    STM32G071K6
+    STM32G071K8
+    STM32G071KB
+    STM32G071R6
+    STM32G071R8
+    STM32G071RB
+    STM32G081CB
+    STM32G081EB
+    STM32G081GB
+    STM32G081KB
+    STM32G081RB
+    STM32G431C6
+    STM32G431C8
+    STM32G431CB
+    STM32G431K6
+    STM32G431K8
+    STM32G431KB
+    STM32G431M6
+    STM32G431M8
+    STM32G431MB
+    STM32G431R6
+    STM32G431R8
+    STM32G431RB
+    STM32G431V6
+    STM32G431V8
+    STM32G431VB
+    STM32G441CB
+    STM32G441KB
+    STM32G441MB
+    STM32G441RB
+    STM32G441VB
+    STM32G471CC
+    STM32G471CE
+    STM32G471MC
+    STM32G471ME
+    STM32G471QC
+    STM32G471QE
+    STM32G471RC
+    STM32G471RE
+    STM32G471VC
+    STM32G471VE
+    STM32G473CB
+    STM32G473CC
+    STM32G473CE
+    STM32G473MB
+    STM32G473MC
+    STM32G473ME
+    STM32G473QB
+    STM32G473QC
+    STM32G473QE
+    STM32G473RB
+    STM32G473RC
+    STM32G473RE
+    STM32G473VB
+    STM32G473VC
+    STM32G473VE
+    STM32G474CB
+    STM32G474CC
+    STM32G474CE
+    STM32G474MB
+    STM32G474MC
+    STM32G474ME
+    STM32G474QB
+    STM32G474QC
+    STM32G474QE
+    STM32G474RB
+    STM32G474RC
+    STM32G474RE
+    STM32G474VB
+    STM32G474VC
+    STM32G474VE
+    STM32G483CE
+    STM32G483ME
+    STM32G483QE
+    STM32G483RE
+    STM32G483VE
+    STM32G484CE
+    STM32G484ME
+    STM32G484QE
+    STM32G484RE
+    STM32G484VE
+    STM32GBK1CB
+    STM32H742AG
+    STM32H742AI
+    STM32H742BG
+    STM32H742BI
+    STM32H742IG
+    STM32H742II
+    STM32H742VG
+    STM32H742VI
+    STM32H742XG
+    STM32H742XI
+    STM32H742ZG
+    STM32H742ZI
+    STM32H743AG
+    STM32H743AI
+    STM32H743BG
+    STM32H743BI
+    STM32H743IG
+    STM32H743II
+    STM32H743VG
+    STM32H743VI
+    STM32H743XG
+    STM32H743XI
+    STM32H743ZG
+    STM32H743ZI
+    STM32H745BG
+    STM32H745BI
+    STM32H745IG
+    STM32H745II
+    STM32H745XG
+    STM32H745XI
+    STM32H745ZG
+    STM32H745ZI
+    STM32H747AG
+    STM32H747AI
+    STM32H747BG
+    STM32H747BI
+    STM32H747IG
+    STM32H747II
+    STM32H747XG
+    STM32H747XI
+    STM32H747ZI
+    STM32H750IB
+    STM32H750VB
+    STM32H750XB
+    STM32H750ZB
+    STM32H753AI
+    STM32H753BI
+    STM32H753II
+    STM32H753VI
+    STM32H753XI
+    STM32H753ZI
+    STM32H755BI
+    STM32H755II
+    STM32H755XI
+    STM32H755ZI
+    STM32H757AI
+    STM32H757BI
+    STM32H757II
+    STM32H757XI
+    STM32H757ZI
+    STM32H7A3AG
+    STM32H7A3AI
+    STM32H7A3IG
+    STM32H7A3II
+    STM32H7A3LG
+    STM32H7A3LI
+    STM32H7A3NG
+    STM32H7A3NI
+    STM32H7A3QI
+    STM32H7A3RG
+    STM32H7A3RI
+    STM32H7A3VG
+    STM32H7A3VI
+    STM32H7A3ZG
+    STM32H7A3ZI
+    STM32H7B0AB
+    STM32H7B0IB
+    STM32H7B0RB
+    STM32H7B0VB
+    STM32H7B0ZB
+    STM32H7B3AI
+    STM32H7B3II
+    STM32H7B3LI
+    STM32H7B3NI
+    STM32H7B3QI
+    STM32H7B3RI
+    STM32H7B3VI
+    STM32H7B3ZI
+    STM32L010C6
+    STM32L010F4
+    STM32L010K4
+    STM32L010K8
+    STM32L010R8
+    STM32L010RB
+    STM32L011D3
+    STM32L011D4
+    STM32L011E3
+    STM32L011E4
+    STM32L011F3
+    STM32L011F4
+    STM32L011G3
+    STM32L011G4
+    STM32L011K3
+    STM32L011K4
+    STM32L021D4
+    STM32L021F4
+    STM32L021G4
+    STM32L021K4
+    STM32L031C4
+    STM32L031C6
+    STM32L031E4
+    STM32L031E6
+    STM32L031F4
+    STM32L031F6
+    STM32L031G4
+    STM32L031G6
+    STM32L031K4
+    STM32L031K6
+    STM32L041C6
+    STM32L041E6
+    STM32L041F6
+    STM32L041G6
+    STM32L041K6
+    STM32L051C6
+    STM32L051C8
+    STM32L051K6
+    STM32L051K8
+    STM32L051R6
+    STM32L051R8
+    STM32L051T6
+    STM32L051T8
+    STM32L052C6
+    STM32L052C8
+    STM32L052K6
+    STM32L052K8
+    STM32L052R6
+    STM32L052R8
+    STM32L052T6
+    STM32L052T8
+    STM32L053C6
+    STM32L053C8
+    STM32L053R6
+    STM32L053R8
+    STM32L062C8
+    STM32L062K8
+    STM32L063C8
+    STM32L063R8
+    STM32L071C8
+    STM32L071CB
+    STM32L071CZ
+    STM32L071K8
+    STM32L071KB
+    STM32L071KZ
+    STM32L071RB
+    STM32L071RZ
+    STM32L071V8
+    STM32L071VB
+    STM32L071VZ
+    STM32L072CB
+    STM32L072CZ
+    STM32L072KB
+    STM32L072KZ
+    STM32L072RB
+    STM32L072RZ
+    STM32L072V8
+    STM32L072VB
+    STM32L072VZ
+    STM32L073CB
+    STM32L073CZ
+    STM32L073RB
+    STM32L073RZ
+    STM32L073V8
+    STM32L073VB
+    STM32L073VZ
+    STM32L081CB
+    STM32L081CZ
+    STM32L081KZ
+    STM32L082CZ
+    STM32L082KZ
+    STM32L083CB
+    STM32L083CZ
+    STM32L083RB
+    STM32L083RZ
+    STM32L083V8
+    STM32L083VB
+    STM32L083VZ
+    STM32L100C6
+    STM32L100R8
+    STM32L100RB
+    STM32L100RC
+    STM32L151C6
+    STM32L151C8
+    STM32L151CB
+    STM32L151CC
+    STM32L151QC
+    STM32L151QD
+    STM32L151QE
+    STM32L151R6
+    STM32L151R8
+    STM32L151RB
+    STM32L151RC
+    STM32L151RD
+    STM32L151RE
+    STM32L151UC
+    STM32L151V8
+    STM32L151VB
+    STM32L151VC
+    STM32L151VD
+    STM32L151VE
+    STM32L151ZC
+    STM32L151ZD
+    STM32L151ZE
+    STM32L152C6
+    STM32L152C8
+    STM32L152CB
+    STM32L152CC
+    STM32L152QC
+    STM32L152QD
+    STM32L152QE
+    STM32L152R6
+    STM32L152R8
+    STM32L152RB
+    STM32L152RC
+    STM32L152RD
+    STM32L152RE
+    STM32L152UC
+    STM32L152V8
+    STM32L152VB
+    STM32L152VC
+    STM32L152VD
+    STM32L152VE
+    STM32L152ZC
+    STM32L152ZD
+    STM32L152ZE
+    STM32L162QC
+    STM32L162QD
+    STM32L162RC
+    STM32L162RD
+    STM32L162RE
+    STM32L162VC
+    STM32L162VD
+    STM32L162VE
+    STM32L162ZC
+    STM32L162ZD
+    STM32L162ZE
+    STM32L412C8
+    STM32L412CB
+    STM32L412K8
+    STM32L412KB
+    STM32L412R8
+    STM32L412RB
+    STM32L412T8
+    STM32L412TB
+    STM32L422CB
+    STM32L422KB
+    STM32L422RB
+    STM32L422TB
+    STM32L431CB
+    STM32L431CC
+    STM32L431KB
+    STM32L431KC
+    STM32L431RB
+    STM32L431RC
+    STM32L431VC
+    STM32L432KB
+    STM32L432KC
+    STM32L433CB
+    STM32L433CC
+    STM32L433RB
+    STM32L433RC
+    STM32L433VC
+    STM32L442KC
+    STM32L443CC
+    STM32L443RC
+    STM32L443VC
+    STM32L451CC
+    STM32L451CE
+    STM32L451RC
+    STM32L451RE
+    STM32L451VC
+    STM32L451VE
+    STM32L452CC
+    STM32L452CE
+    STM32L452RC
+    STM32L452RE
+    STM32L452VC
+    STM32L452VE
+    STM32L462CE
+    STM32L462RE
+    STM32L462VE
+    STM32L471QE
+    STM32L471QG
+    STM32L471RE
+    STM32L471RG
+    STM32L471VE
+    STM32L471VG
+    STM32L471ZE
+    STM32L471ZG
+    STM32L475RC
+    STM32L475RE
+    STM32L475RG
+    STM32L475VC
+    STM32L475VE
+    STM32L475VG
+    STM32L476JE
+    STM32L476JG
+    STM32L476ME
+    STM32L476MG
+    STM32L476QE
+    STM32L476QG
+    STM32L476RC
+    STM32L476RE
+    STM32L476RG
+    STM32L476VC
+    STM32L476VE
+    STM32L476VG
+    STM32L476ZE
+    STM32L476ZG
+    STM32L486JG
+    STM32L486QG
+    STM32L486RG
+    STM32L486VG
+    STM32L486ZG
+    STM32L496AE
+    STM32L496AG
+    STM32L496QE
+    STM32L496QG
+    STM32L496RE
+    STM32L496RG
+    STM32L496VE
+    STM32L496VG
+    STM32L496ZE
+    STM32L496ZG
+    STM32L4A6AG
+    STM32L4A6QG
+    STM32L4A6RG
+    STM32L4A6VG
+    STM32L4A6ZG
+    STM32L4P5AE
+    STM32L4P5AG
+    STM32L4P5CE
+    STM32L4P5CG
+    STM32L4P5QE
+    STM32L4P5QG
+    STM32L4P5RE
+    STM32L4P5RG
+    STM32L4P5VE
+    STM32L4P5VG
+    STM32L4P5ZE
+    STM32L4P5ZG
+    STM32L4Q5AG
+    STM32L4Q5CG
+    STM32L4Q5QG
+    STM32L4Q5RG
+    STM32L4Q5VG
+    STM32L4Q5ZG
+    STM32L4R5AG
+    STM32L4R5AI
+    STM32L4R5QG
+    STM32L4R5QI
+    STM32L4R5VG
+    STM32L4R5VI
+    STM32L4R5ZG
+    STM32L4R5ZI
+    STM32L4R7AI
+    STM32L4R7VI
+    STM32L4R7ZI
+    STM32L4R9AG
+    STM32L4R9AI
+    STM32L4R9VG
+    STM32L4R9VI
+    STM32L4R9ZG
+    STM32L4R9ZI
+    STM32L4S5AI
+    STM32L4S5QI
+    STM32L4S5VI
+    STM32L4S5ZI
+    STM32L4S7AI
+    STM32L4S7VI
+    STM32L4S7ZI
+    STM32L4S9AI
+    STM32L4S9VI
+    STM32L4S9ZI
+    STM32L552CC
+    STM32L552CE
+    STM32L552ME
+    STM32L552QC
+    STM32L552QE
+    STM32L552RC
+    STM32L552RE
+    STM32L552VC
+    STM32L552VE
+    STM32L552ZC
+    STM32L552ZE
+    STM32L562CE
+    STM32L562ME
+    STM32L562QE
+    STM32L562RE
+    STM32L562VE
+    STM32L562ZE
+    STM32MP151A
+    STM32MP151C
+    STM32MP153A
+    STM32MP153C
+    STM32MP157A
+    STM32MP157C
+    STM32WB50CG
+    STM32WB55CC
+    STM32WB55CE
+    STM32WB55CG
+    STM32WB55RC
+    STM32WB55RE
+    STM32WB55RG
+    STM32WB55VC
+    STM32WB55VE
+    STM32WB55VG
+    STM32WLE5J8
+    STM32WLE5JB
+    STM32WLE5JC
+)
+
+function(stm32_get_devices_by_family FAMILY DEVICES)
+    set(LIST ${STM32_ALL_DEVICES})
+    list(FILTER LIST INCLUDE REGEX "^STM32${FAMILY}")
+    set(${DEVICES} ${LIST} PARENT_SCOPE)
+endfunction()
+