Added STM32G041xx and STM32G031xx series chips.

Also merged in changes from up-stream.
Implemented suggestions from the merge request.

README.md

@@ -6,7 +6,7 @@ This project is used to develop applications for the STM32 - ST's ARM Cortex-Mx
 
 * cmake >= 3.0
 * GCC toolchain with newlib (optional).
-* STM32CubeMX package for STM32F0, STM32F1, STM32F2, STM32F3, STM32F4, STM32F7, STM32G0 STM32L0, STM32L1, STM32L4 families.
+* STM32CubeMX package for STM32F0, STM32F1, STM32F2, STM32F3, STM32F4, STM32F7, STM32G0, STM32H7, STM32L0, STM32L1, STM32L4 families.
 
 ## Project contains
 
@@ -32,8 +32,8 @@ First of all you need to configure toolchain and libraries, you can do this by e
 * `TOOLCHAIN_PREFIX` - where toolchain is located, **default**: `/usr`
 * `TARGET_TRIPLET` - toolchain target triplet, **default**: `arm-none-eabi`
 * `STM32_CHIP` - STM32 device code, e.g. `STM32F407VG` or `STM32F103VG`
-* `STM32_FAMILY` - STM32 family (F0, F1, F4, etc.) currently, F0, F1, F2, F4, F7, G0, L0, L1 and L4 families are supported. **Note:** If `STM32_CHIP` variable is set, `STM32_FAMILY` is optional.
-* `STM32Cube_DIR` - path to STM32CubeMX directory **default**: `/opt/STM32Cube_FW_F0_V1.4.0 /opt/STM32Cube_FW_F1_V1.1.0 /opt/STM32Cube_FW_F2_V1.1.0 /opt/STM32Cube_FW_F4_V1.6.0 /opt/STM32Cube_FW_G0_V1.1.0``
+* `STM32_FAMILY` - STM32 family (F0, F1, F4, etc.) currently, F0, F1, F2, F4, F7, G0, H7, L0, L1 and L4 families are supported. **Note:** If `STM32_CHIP` variable is set, `STM32_FAMILY` is optional.
+* `STM32Cube_DIR` - path to STM32CubeMX directory **default**: `/opt/STM32Cube_FW_F0_V1.4.0 /opt/STM32Cube_FW_F1_V1.1.0 /opt/STM32Cube_FW_F2_V1.1.0 /opt/STM32Cube_FW_F4_V1.6.0`
 
 To use the toolchain, you'll need to copy contents of the `cmake` folder into cmake's modules path, or use the `CMAKE_MODULE_PATH` variable.
 

cmake/FindCMSIS.cmake

@@ -79,19 +79,32 @@ ELSEIF(STM32_FAMILY STREQUAL "F0")
     LIST(APPEND CMSIS_COMMON_HEADERS core_cm3.h)
     SET(CMSIS_DEVICE_HEADERS stm32f0xx.h system_stm32f0xx.h)
     SET(CMSIS_DEVICE_SOURCES system_stm32f0xx.c)
-
 ELSEIF(STM32_FAMILY STREQUAL "G0")
     IF(NOT STM32Cube_DIR)
         SET(STM32Cube_DIR "/opt/STM32Cube_FW_G0_V1.1.0")
         MESSAGE(STATUS "No STM32Cube_DIR specified, using default: " ${STM32Cube_DIR})
     ENDIF()
 
-    LIST(APPEND CMSIS_COMMON_HEADERS core_m0plus.h)
+    LIST(APPEND CMSIS_COMMON_HEADERS core_cm0plus.h)
     SET(CMSIS_DEVICE_HEADERS stm32g0xx.h system_stm32g0xx.h)
     SET(CMSIS_DEVICE_SOURCES system_stm32g0xx.c)
 
-    STRING(REGEX REPLACE "^(0[78][01]).[BCDEFG8]" "\\1" STM32_DEVICE_NUM ${STM32_CHIP_TYPE})
+    STRING(REGEX REPLACE "^(0[3478][01]).[BCDEFG468]" "\\1" STM32_DEVICE_NUM ${STM32_CHIP_TYPE})
     SET(CMSIS_STARTUP_SOURCE startup_stm32g${STM32_DEVICE_NUM}xx.s)
+
+ELSEIF(STM32_FAMILY STREQUAL "H7")
+    IF(NOT STM32Cube_DIR)
+        SET(STM32Cube_DIR "/opt/STM32Cube_FW_H7_V1.3.0")
+        MESSAGE(STATUS "No STM32Cube_DIR specified, using default: " ${STM32Cube_DIR})
+    ENDIF()
+
+    LIST(APPEND CMSIS_COMMON_HEADERS core_cm7.h)
+    SET(CMSIS_DEVICE_HEADERS stm32h7xx.h system_stm32h7xx.h)
+    SET(CMSIS_DEVICE_SOURCES system_stm32h7xx.c)
+	IF(NOT CMSIS_STARTUP_SOURCE)
+        SET(CMSIS_STARTUP_SOURCE startup_stm32h${STM32_CHIP_TYPE_LOWER}.s)
+    ENDIF()
+	message(STATUS "CMSIS_STARTUP_SOURCE @@@@@@ ${CMSIS_STARTUP_SOURCE}")
 ELSEIF(STM32_FAMILY STREQUAL "L0")
     IF(NOT STM32Cube_DIR)
         SET(STM32Cube_DIR "/opt/STM32Cube_FW_L0_V1.7.0")
@@ -109,11 +122,9 @@ ELSEIF(STM32_FAMILY STREQUAL "L1")
         SET(STM32Cube_DIR "/opt/STM32Cube_FW_L1_V1.8.0")
         MESSAGE(WARNING "No STM32Cube_DIR specified, using default: " ${STM32Cube_DIR})
     ENDIF()
-
     LIST(APPEND CMSIS_COMMON_HEADERS core_cm3.h)
     SET(CMSIS_DEVICE_HEADERS stm32l1xx.h system_stm32l1xx.h)
     SET(CMSIS_DEVICE_SOURCES system_stm32l1xx.c)
-
     IF(NOT CMSIS_STARTUP_SOURCE)
         SET(CMSIS_STARTUP_SOURCE startup_stm32l${STM32_CHIP_TYPE_LOWER}.s)
     ENDIF()
@@ -125,10 +136,10 @@ ELSEIF(STM32_FAMILY STREQUAL "L4")
 
     LIST(APPEND CMSIS_COMMON_HEADERS core_cm4.h)
     SET(CMSIS_DEVICE_HEADERS stm32l4xx.h system_stm32l4xx.h)
-    SET(CMSIS_DEVICE_SOURCES system_stm32l4xx.c)
+    SET(CMSIS_DEVICE_SOURCES system_stm32l4xx.c) 
     IF(NOT CMSIS_STARTUP_SOURCE)
         SET(CMSIS_STARTUP_SOURCE startup_stm32l${STM32_CHIP_TYPE_LOWER}.s)
-    ENDIF()
+    ENDIF()   
 ENDIF()
 
 IF(NOT CMSIS_STARTUP_SOURCE)
@@ -173,6 +184,12 @@ IF(STM32_CHIP_TYPE)
     LIST(APPEND CMSIS_SOURCES ${CMSIS_STARTUP_SOURCE_FILE})
 ENDIF()
 
+IF(CMSIS_FIND_COMPONENTS STREQUAL NN)
+    FIND_PACKAGE(CMSISNN)
+    LIST(APPEND CMSIS_SOURCES ${CMSISNN_SOURCES})
+    LIST(APPEND CMSIS_INCLUDE_DIRS ${CMSISNN_INCLUDE_DIRS})
+ENDIF()
+
 INCLUDE(FindPackageHandleStandardArgs)
 
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(CMSIS DEFAULT_MSG CMSIS_INCLUDE_DIRS CMSIS_SOURCES)

cmake/FindCMSISNN.cmake

@@ -0,0 +1,157 @@
+INCLUDE(FetchContent)
+
+SET(FETCHCONTENT_UPDATES_DISCONNECTED ON)
+FetchContent_Declare(
+    arm_cmsis
+    GIT_REPOSITORY https://github.com/ARM-software/CMSIS_5.git
+    )
+
+FetchContent_GetProperties(arm_cmsis)
+IF(NOT arm_cmsis_POPULATED)
+    MESSAGE(STATUS "Getting most recent ARM CMSIS sources")
+    FetchContent_Populate(arm_cmsis)
+    EXECUTE_PROCESS(COMMAND git -C ${arm_cmsis_SOURCE_DIR} checkout develop)
+ENDIF()
+
+# FIND_PACKAGE(Fixedpoint)
+
+SET(ARM_CMSIS_DIR ${arm_cmsis_SOURCE_DIR}/CMSIS)
+
+SET(CMSIS_NN_HEADERS
+    arm_nnfunctions.h
+    arm_nnsupportfunctions.h
+    arm_nn_tables.h
+    )
+
+FILE(GLOB CMSIS_NN_SOURCES ${ARM_CMSIS_DIR}/NN/Source/*/*.c)
+
+FIND_PATH(CMSIS_NN_INC_DIR ${CMSIS_NN_HEADERS}
+    PATHS ${ARM_CMSIS_DIR}/NN/Include
+    CMAKE_FIND_ROOT_PATH_BOTH
+    )
+
+SET(CMSIS_DSP_HEADERS
+    arm_common_tables.h
+    arm_const_structs.h
+    arm_helium_utils.h
+    arm_math.h
+    arm_mve_tables.h
+    arm_vec_math.h
+    )
+
+SET(CMSIS_DSP_PRIVATE_HEADERS
+    arm_sorting.h
+    arm_vec_fft.h
+    arm_vec_filtering.h
+    )
+
+SET(CMSIS_DSP_SRCS
+    BasicMathFunctions.c
+    arm_gaussian_naive_bayes_predict_f32.c
+    CommonTables.c
+    ComplexMathFunctions.c
+    ControllerFunctions.c
+    arm_boolean_distance.c
+    arm_boolean_distance_template.h
+    arm_braycurtis_distance_f32.c
+    arm_canberra_distance_f32.c
+    arm_chebyshev_distance_f32.c
+    arm_cityblock_distance_f32.c
+    arm_correlation_distance_f32.c
+    arm_cosine_distance_f32.c
+    arm_dice_distance.c
+    arm_euclidean_distance_f32.c
+    arm_hamming_distance.c
+    arm_jaccard_distance.c
+    arm_jensenshannon_distance_f32.c
+    arm_kulsinski_distance.c
+    arm_minkowski_distance_f32.c
+    arm_rogerstanimoto_distance.c
+    arm_russellrao_distance.c
+    arm_sokalmichener_distance.c
+    arm_sokalsneath_distance.c
+    arm_yule_distance.c
+    FastMathFunctions.c
+    FilteringFunctions.c
+    MatrixFunctions.c
+    StatisticsFunctions.c
+    SupportFunctions.c
+    arm_svm_linear_init_f32.c
+    arm_svm_linear_predict_f32.c
+    arm_svm_polynomial_init_f32.c
+    arm_svm_polynomial_predict_f32.c
+    arm_svm_rbf_init_f32.c
+    arm_svm_rbf_predict_f32.c
+    arm_svm_sigmoid_init_f32.c
+    arm_svm_sigmoid_predict_f32.c
+    TransformFunctions.c
+    )
+
+FOREACH(SRC ${CMSIS_DSP_SRCS})
+    STRING(MAKE_C_IDENTIFIER "${SRC}" SRC_CLEAN)
+    SET(CMSIS_DSP_${SRC_CLEAN}_FILE ${SRC_CLEAN}-NOTFOUND)
+    FIND_FILE(CMSIS_DSP_${SRC_CLEAN}_FILE ${SRC}
+        PATH_SUFFIXES
+        BasicMathFunctions
+        BayesFunctions
+        CommonTables
+        ComplexMathFunctions
+        ControllerFunctions
+        DistanceFunctions
+        FastMathFunctions
+        FilteringFunctions
+        MatrixFunctions
+        StatisticsFunctions
+        SupportFunctions
+        SVMFunctions
+        TransformFunctions
+        PATHS ${ARM_CMSIS_DIR}/DSP/Source
+        CMAKE_FIND_ROOT_PATH_BOTH
+        )
+    LIST(APPEND CMSIS_DSP_SOURCES ${CMSIS_DSP_${SRC_CLEAN}_FILE})
+ENDFOREACH()
+
+FIND_PATH(CMSIS_DSP_PRIVATE_INC_DIR ${CMSIS_DSP_PRIVATE_HEADERS}
+    PATHS ${ARM_CMSIS_DIR}/DSP/PrivateInclude
+    CMAKE_FIND_ROOT_PATH_BOTH
+    )
+
+FIND_PATH(CMSIS_DSP_INC_DIR ${CMSIS_DSP_HEADERS}
+    PATHS ${ARM_CMSIS_DIR}/DSP/Include
+    CMAKE_FIND_ROOT_PATH_BOTH
+    )
+
+SET(CMSIS_DSP_INC_DIRS
+    ${CMSIS_DSP_PRIVATE_INC_DIR}
+    ${CMSIS_DSP_INC_DIR}
+    )
+
+SET(CMSISNN_INCLUDE_DIRS
+    ${CMSIS_DSP_INC_DIRS}
+    ${CMSIS_NN_INC_DIR}
+    )
+
+SET(CMSISNN_SOURCES
+    ${CMSIS_DSP_SOURCES}
+    ${CMSIS_NN_SOURCES}
+    )
+
+IF(STM32_FAMILY STREQUAL "F0")
+    ADD_DEFINITIONS(-DARM_MATH_CM0)
+ELSEIF(STM32_FAMILY STREQUAL "F3")
+    ADD_DEFINITIONS(-DARM_MATH_CM3)
+ELSEIF(STM32_FAMILY STREQUAL "F4")
+    #TODO find better solution to this
+    ADD_DEFINITIONS(-D__FPU_PRESENT=1)
+    ADD_DEFINITIONS(-DARM_MATH_CM4)
+ELSEIF(STM32_FAMILY STREQUAL "F7")
+    ADD_DEFINITIONS(-DARM_MATH_CM7)
+ELSEIF(STM32_FAMILY STREQUAL "L0")
+    ADD_DEFINITIONS(-DARM_MATH_CM0PLUS)
+ELSE()
+    MESSAGE(STATUS "ARM_MATH define not found, see arm_math.h")
+ENDIF()
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CMSISNN DEFAULT_MSG CMSISNN_INCLUDE_DIRS CMSISNN_SOURCES)

cmake/FindFATFS.cmake

@@ -9,8 +9,10 @@ SET(FATFS_COMMON_SOURCES
     ff_gen_drv.c
 )
 
+CMAKE_POLICY(SET CMP0057 NEW)
+
 IF(NOT STORAGE_DRIVER)
-    MESSAGE(STATUS "No storage driver specified")
+    MESSAGE(STATUS "No storage driver specified, please SET STORAGE_DRIVER to {SDCARD, SDRAM, SRAM, USBH}")
 else()
     if("SDCARD" IN_LIST STORAGE_DRIVER)
         LIST(APPEND FATFS_DRIVER_SOURCES sd_diskio.c)
@@ -25,8 +27,6 @@ else()
         LIST(APPEND FATFS_DRIVER_SOURCES usbh_diskio.c)
     endif()
 endif()
-MESSAGE(STATUS "debug1 : " ${STORAGE_DRIVER})
-MESSAGE(STATUS "debug2 : " ${FATFS_DRIVER_SOURCES})
 
 SET(FATFS_OPTION_SOURCES syscall.c unicode.c)
 #if(CODE_PAGE EQUAL CP932)
@@ -63,10 +63,17 @@ FIND_PATH(FATFS_DRIVER_INCLUDE_DIR ${FATFS_DRIVER_HEADERS}
     CMAKE_FIND_ROOT_PATH_BOTH
 )
 
+IF(${FATFS_DRIVER_INCLUDE_DIR} STREQUAL FATFS_DRIVER_INCLUDE_DIR-NOTFOUND)
+    MESSAGE("Driver header files not located in STM firemware, please manually include the appropriate X_diskio.h directory")
+    SET(FATFS_INCLUDE_DIRS
+    ${FATFS_COMMON_INCLUDE_DIR}
+        )
+ELSE()
 SET(FATFS_INCLUDE_DIRS
     ${FATFS_COMMON_INCLUDE_DIR}
     ${FATFS_DRIVER_INCLUDE_DIR}
 )
+ENDIF()
 
 FOREACH(SRC ${FATFS_COMMON_SOURCES})
     SET(SRC_FILE SRC_FILE-NOTFOUND)
@@ -83,7 +90,12 @@ FOREACH(SRC ${FATFS_DRIVER_SOURCES})
         HINTS ${STM32Cube_DIR}/Middlewares/Third_Party/FatFs/src/drivers/
         CMAKE_FIND_ROOT_PATH_BOTH
     )
+STRING(FIND ${SRC_FILE} "NOTFOUND" SRC_FILE_NOTFOUND)
+IF(NOT ${SRC_FILE_NOTFOUND} EQUAL -1)
+    MESSAGE("Driver source files not located in STM firemware, please manually source the appropriate X_diskio.c files")
+ELSE()
     LIST(APPEND FATFS_SOURCES ${SRC_FILE})
+ENDIF()
 ENDFOREACH()
 
 FOREACH(SRC ${FATFS_OPTION_SOURCES})

cmake/FindFreeRTOS.cmake

@@ -10,6 +10,8 @@ ELSEIF(STM32_FAMILY STREQUAL "F4")
 	SET(PORT_GCC_DIR_SUFFIX "CM4F")
 ELSEIF(STM32_FAMILY STREQUAL "F7")
 	SET(PORT_GCC_DIR_SUFFIX "CM7")
+ELSEIF(STM32_FAMILY STREQUAL "H7")
+	SET(PORT_GCC_DIR_SUFFIX "CM7/r0p1")
 ELSEIF(STM32_FAMILY STREQUAL "L0")
 	SET(PORT_GCC_DIR_SUFFIX "CM0")
 ELSEIF(STM32_FAMILY STREQUAL "L1")

cmake/FindSTM32BSP.cmake

@@ -1,6 +1,8 @@
+MESSAGE("STM Board: ${STM_BOARD}")
 IF(STM32_FAMILY STREQUAL "F4")
 	IF(STM_BOARD STREQUAL "STM32F429I-Discovery")
-		SET(BSP_COMPONENTS eeprom
+		SET(BSP_COMPONENTS 
+                eeprom
 			    gyroscope
 			    io
 			    lcd
@@ -10,6 +12,19 @@ IF(STM32_FAMILY STREQUAL "F4")
 		SET(BSP_HEADERS stm32f429i_discovery.h)
 		SET(BSP_SRC stm32f429i_discovery.c)
 	ENDIF()
+    IF(STM_BOARD STREQUAL "STM324xG_EVAL")
+        SET(BSP_COMPONENTS 
+            lcd 
+            camera 
+            eeprom 
+            io 
+            sd 
+            sram 
+            ts)
+        SET(BSP_PREFIX stm324xg_eval_)
+        SET(BSP_HEADERS stm324xg_eval.h)
+        SET(BSP_SRC stm324xg_eval.c)
+    ENDIF()
 	set(COMMON_COMPONENTS ampire480272
 			      ampire640480
 			      cs43l22

cmake/FindSTM32HAL.cmake

@@ -51,8 +51,7 @@ ELSEIF(STM32_FAMILY STREQUAL "F4")
     SET(HAL_COMPONENTS adc can cec cortex crc cryp dac dcmi dma dma2d eth flash
                        flash_ramfunc fmpi2c gpio hash hcd i2c i2s irda iwdg ltdc
                        nand nor pccard pcd pwr qspi rcc rng rtc sai sd sdram
-                       smartcard spdifrx spi sram tim uart usart wwdg fmc fsmc
-                       sdmmc usb)
+                       smartcard spdifrx spi sram tim uart usart wwdg)
 
     SET(HAL_REQUIRED_COMPONENTS cortex pwr rcc)
 
@@ -76,6 +75,20 @@ ELSEIF(STM32_FAMILY STREQUAL "F7")
 
     SET(HAL_PREFIX stm32f7xx_)
 
+ELSEIF(STM32_FAMILY STREQUAL "H7")
+    SET(HAL_COMPONENTS adc can cec cortex crc cryp dac dcmi dma dma2d eth flash
+                       gpio hash hcd i2c i2s irda iwdg lptim ltdc nand nor pcd
+                       pwr qspi rcc rng rtc sai sd sdram smartcard spdifrx spi
+                       sram tim uart usart wwdg fmc sdmmc usb)
+
+    SET(HAL_REQUIRED_COMPONENTS cortex pwr rcc)
+
+    # Components that have _ex sources
+    SET(HAL_EX_COMPONENTS adc crc cryp dac dcmi dma flash hash i2c pcd
+                          pwr rcc rtc sai tim)
+
+    SET(HAL_PREFIX stm32h7xx_)
+
 ELSEIF(STM32_FAMILY STREQUAL "G0")
     SET(HAL_COMPONENTS adc cec comp cortex crc cryp dac dma exti flash gpio i2c i2c i2s irda iwdg sptim pwr rcc rng rtc smartcard smbus spi tim uart usart wwdg)
 
@@ -86,6 +99,7 @@ ELSEIF(STM32_FAMILY STREQUAL "G0")
 
     SET(HAL_PREFIX stm32g0xx_)
 
+
 ELSEIF(STM32_FAMILY STREQUAL "L0")
     SET(HAL_COMPONENTS adc comp cortex crc crs cryp dac dma exti firewall flash gpio i2c
                        i2s irda iwdg lcd lptim lpuart pcd pwr rcc rng rtc smartcard

cmake/FindSTM32LL.cmake

@@ -47,6 +47,14 @@ ELSEIF(STM32_FAMILY STREQUAL "F7")
     SET(LL_REQUIRED_COMPONENTS bus cortex pwr rcc system utils)
 
     SET(LL_PREFIX stm32f7xx_)
+	
+ELSEIF(STM32_FAMILY STREQUAL "H7")
+    SET(LL_COMPONENTS	adc bus cortex crc dac dma2d dma exti gpio i2c i2s iwdg
+						lptim pwr rcc rng rtc spi system tim usart usb utils wwdg)
+
+    SET(LL_REQUIRED_COMPONENTS bus cortex pwr rcc system utils)
+
+    SET(LL_PREFIX stm32h7xx_)
 
 ELSEIF(STM32_FAMILY STREQUAL "L0")
     SET(LL_COMPONENTS	adc bus comp cortex crc crs dac dma exti gpio i2c i2s

cmake/FindSTM32STD.cmake

@@ -0,0 +1,91 @@
+IF(STM32_FAMILY STREQUAL "F4")
+    SET(STD_COMPONENTS adc can cec crc cryp dac dbgmcu dcmi dfsdm dma2d dma dsi
+        exti flash flash_ramfunc fmc fmpi2c fsmc gpio hash i2c iwdg lptim ltdc pwr qspi rcc
+        rng rtc sai sdio spdifrx spi syscfg tim usart wwdg)
+
+    SET(STD_REQUIRED_COMPONENTS dma dma2d fmc i2c ltdc gpio rcc spi usart adc tim exti syscfg)
+
+    SET(STD_EX_COMPONENTS cryp hash)
+
+    SET(STD_PREFIX stm32f4xx_)
+ENDIF()
+
+SET(STD_HEADERS
+    misc.h
+    stm32f4xx.h
+    core_cm4.h
+    )
+
+SET(STD_SRCS
+    misc.c
+    )
+
+IF(NOT STM32STDPERIPH_FIND_COMPONENTS)
+    SET(STM32STDPERIPH_FIND_COMPONENTS ${STD_COMPONENTS})
+    MESSAGE(STATUS "No STM32STD components selected, using all: ${STM32STD_FIND_COMPONENTS}")
+ENDIF()
+
+FOREACH(cmp ${STD_REQUIRED_COMPONENTS})
+    LIST(FIND STM32STDPERIPH_FIND_COMPONENTS ${cmp} STM32STD_FOUND_INDEX)
+    IF(${STM32STD_FOUND_INDEX} LESS 0)
+        LIST(APPEND STM32STDPERIPH_FIND_COMPONENTS ${cmp})
+    ENDIF()
+ENDFOREACH()
+
+FOREACH(cmp ${STM32STD_FIND_COMPONENTS})
+    LIST(FIND STD_COMPONENTS ${cmp} STM32STD_FOUND_INDEX)
+    IF($STM32STD_FOUND_INDEX LESS 0)
+        MESSAGE(FATAL_ERROR "Unknown STM32STD Peripheral component: ${cmp}. Available components: ${STD_COMPONENTS}")
+    ELSE()
+        LIST(APPEND STD_HEADERS ${STD_PREFIX}${cmp}.h)
+        LIST(APPEND STD_SRCS ${STD_PREFIX}${cmp}.c)
+    ENDIF()
+    LIST(FIND STD_EX_COMPONENTS ${cmp} STM32STD_FOUND_INDEX)
+    if(NOT (${STM32STD_FOUND_INDEX} LESS 0))
+        STRING(COMPARE EQUAL ${cmp} "cryp" STM32_EQUAL)
+        if(${STM32_EQUAL})
+            LIST(APPEND STD_SRCS ${STD_PREFIX}${cmp}_aes.c)
+            LIST(APPEND STD_SRCS ${STD_PREFIX}${cmp}_des.c)
+            LIST(APPEND STD_SRCS ${STD_PREFIX}${cmp}_tdes.c)
+        ENDIF()
+        STRING(COMPARE EQUAL ${cmp} "hash" STM32_EQUAL)
+        if(${STM32_EQUAL})
+            LIST(APPEND STD_SRCS ${STD_PREFIX}${cmp}_md5.c)
+            LIST(APPEND STD_SRCS ${STD_PREFIX}${cmp}_sha1.c)
+        ENDIF()
+    ENDIF()
+ENDFOREACH()
+
+LIST(REMOVE_DUPLICATES STD_HEADERS)
+LIST(REMOVE_DUPLICATES STD_SRCS)
+
+FOREACH(HEADER ${STD_HEADERS})
+    FIND_PATH(STM32STD_${HEADER}_INCLUDE_DIR
+        NAMES ${HEADER}
+        PATHS
+        ${STM32STD_DIR}/Libraries/CMSIS/Device/ST/STM32F4xx/Include
+        ${STM32STD_DIR}/Libraries/CMSIS/Include
+        ${STM32STD_DIR}/Libraries/STM32F4xx_StdPeriph_Driver/inc
+        CMAKE_FIND_ROOT_PATH_BOTH
+        )
+    LIST(APPEND STM32STD_INCLUDE_DIR ${STM32STD_${HEADER}_INCLUDE_DIR})
+ENDFOREACH()
+
+SET(SRC_HINTS_DIR ${STM32STD_DIR}/Libraries/STM32${STM32_FAMILY}xx_StdPeriph_Driver/src)
+
+FOREACH(STD_SRC ${STD_SRCS})
+    STRING(MAKE_C_IDENTIFIER "${STD_SRC}" STD_SRC_CLEAN)
+    SET(STD_${STD_SRC_CLEAN}_FILE STD_SRC_FILE-NOTFOUND)
+    FIND_FILE(STD_${STD_SRC_CLEAN}_FILE ${STD_SRC}
+        PATH_SUFFIXES src
+        HINTS ${SRC_HINTS_DIR}
+        CMAKE_FIND_ROOT_PATH_BOTH
+        )
+    LIST(APPEND STM32STD_SOURCES ${STD_${STD_SRC_CLEAN}_FILE})
+ENDFOREACH()
+
+LIST(REMOVE_DUPLICATES STM32STD_INCLUDE_DIR)
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(STM32STD DEFAULT_MSG STM32STD_INCLUDE_DIR STM32STD_SOURCES)

cmake/gcc_stm32.cmake

@@ -1,7 +1,7 @@
 GET_FILENAME_COMPONENT(STM32_CMAKE_DIR ${CMAKE_CURRENT_LIST_FILE} DIRECTORY)
 SET(CMAKE_MODULE_PATH ${STM32_CMAKE_DIR} ${CMAKE_MODULE_PATH})
 
-SET(STM32_SUPPORTED_FAMILIES L0 L1 L4 F0 F1 F2 F3 F4 F7 G0 CACHE INTERNAL "stm32 supported families")
+SET(STM32_SUPPORTED_FAMILIES L0 L1 L4 F0 F1 F2 F3 F4 F7 G0 H7 CACHE INTERNAL "stm32 supported families")
 IF(STM32_CHIP)
 	 SET(STM32_CHIP "${STM32_CHIP}" CACHE STRING "STM32 chip to build for")
 ENDIF()
@@ -24,7 +24,7 @@ IF(NOT STM32_FAMILY)
         SET(STM32_FAMILY "F1" CACHE INTERNAL "stm32 family")
         MESSAGE(STATUS "Neither STM32_FAMILY nor STM32_CHIP specified, using default STM32_FAMILY: ${STM32_FAMILY}")
     ELSE()
-        STRING(REGEX REPLACE "^[sS][tT][mM]32(([fF][0-47])|([gG][0])|([lL][0-14])|([tT])|([wW])).+$" "\\1" STM32_FAMILY ${STM32_CHIP})
+        STRING(REGEX REPLACE "^[sS][tT][mM]32(([fF][0-47])|([gG][0])|([hH]7)|([lL][0-14])|([tT])|([wW])).+$" "\\1" STM32_FAMILY ${STM32_CHIP})
         STRING(TOUPPER ${STM32_FAMILY} STM32_FAMILY)
         MESSAGE(STATUS "Selected STM32 family: ${STM32_FAMILY}")
     ENDIF()
@@ -69,12 +69,12 @@ SET(CMAKE_CPPFILT "${TOOLCHAIN_BIN_DIR}/${TARGET_TRIPLET}-c++filt${TOOL_EXECUTAB
 SET(CMAKE_C_FLAGS_DEBUG "-Og -g" CACHE INTERNAL "c compiler flags debug")
 SET(CMAKE_CXX_FLAGS_DEBUG "-Og -g" CACHE INTERNAL "cxx compiler flags debug")
 SET(CMAKE_ASM_FLAGS_DEBUG "-g" CACHE INTERNAL "asm compiler flags debug")
-SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "" CACHE INTERNAL "linker flags debug")
+SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "-Xlinker -Map=output.map" CACHE INTERNAL "linker flags debug")
 
 SET(CMAKE_C_FLAGS_RELEASE "-Os -flto" CACHE INTERNAL "c compiler flags release")
 SET(CMAKE_CXX_FLAGS_RELEASE "-Os -flto" CACHE INTERNAL "cxx compiler flags release")
 SET(CMAKE_ASM_FLAGS_RELEASE "" CACHE INTERNAL "asm compiler flags release")
-SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "-flto" CACHE INTERNAL "linker flags release")
+SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "-Xlinker -Map=output.map -s -flto" CACHE INTERNAL "linker flags release")
 
 SET(CMAKE_FIND_ROOT_PATH "${TOOLCHAIN_PREFIX}/${TARGET_TRIPLET}" ${EXTRA_FIND_PATH})
 SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

cmake/gcc_stm32f3.cmake

@@ -27,32 +27,38 @@ MACRO(STM32_GET_CHIP_PARAMETERS CHIP FLASH_SIZE RAM_SIZE CCRAM_SIZE)
 
     IF(STM32_SIZE_CODE STREQUAL "6")
         SET(FLASH "32K")
-        SET(CCRAM "4K")
+        SET(CCRAM_SIZE_IN_K "4")
     ELSEIF(STM32_SIZE_CODE STREQUAL "8")
         SET(FLASH "64K")
-        SET(CCRAM "4K")
+        SET(CCRAM_SIZE_IN_K "4")
     ELSEIF(STM32_SIZE_CODE STREQUAL "B")
         SET(FLASH "128K")
-        SET(CCRAM "8K")
+        SET(CCRAM_SIZE_IN_K "8")
     ELSEIF(STM32_SIZE_CODE STREQUAL "C")
         SET(FLASH "256K")
-        SET(CCRAM "8K")
+        SET(CCRAM_SIZE_IN_K "8")
     ENDIF()
 
     STM32_GET_CHIP_TYPE(${CHIP} TYPE)
 
     IF(${TYPE} STREQUAL "301xx")
-        SET(RAM "16K")
+        SET(RAM_SIZE_IN_K "16")
     ELSEIF(${TYPE} STREQUAL "302xx")
-        SET(RAM "256K")
+        SET(RAM_SIZE_IN_K "256")
     ELSEIF(${TYPE} STREQUAL "303xx")
-        SET(RAM "48K")
+        SET(RAM_SIZE_IN_K "48")
     ELSEIF(${TYPE} STREQUAL "334xx")
-        SET(RAM "16K")
+        SET(RAM_SIZE_IN_K "16")
     ELSEIF(${TYPE} STREQUAL "373xx")
-        SET(RAM "128K")
+        SET(RAM_SIZE_IN_K "128")
     ENDIF()
 
+    # RAM size = total RAM - CCRAM
+    MATH(EXPR RAM_SIZE_IN_K "${RAM_SIZE_IN_K}-${CCRAM_SIZE_IN_K}")
+    # Append the 'K' literal to the numbers
+    SET(RAM "${RAM_SIZE_IN_K}K")
+    SET(CCRAM "${CCRAM_SIZE_IN_K}K")
+    
     SET(${FLASH_SIZE} ${FLASH})
     SET(${RAM_SIZE} ${RAM})
     SET(${CCRAM_SIZE} ${CCRAM})

cmake/gcc_stm32f7.cmake

@@ -5,8 +5,8 @@ SET(CMAKE_ASM_FLAGS "-mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softf
 SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--gc-sections -mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -mabi=aapcs" CACHE INTERNAL "executable linker flags")
 SET(CMAKE_MODULE_LINKER_FLAGS "-mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -mabi=aapcs" CACHE INTERNAL "module linker flags")
 SET(CMAKE_SHARED_LINKER_FLAGS "-mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -mabi=aapcs" CACHE INTERNAL "shared linker flags")
-SET(STM32_CHIP_TYPES 745xx 746xx 756xx 767xx 777xx 769xx 779xx CACHE INTERNAL "stm32f7 chip types")
-SET(STM32_CODES "745.." "746.." "756.." "767.." "777.." "769.." "779..")
+SET(STM32_CHIP_TYPES 745xx 746xx 756xx 765xx 767xx 777xx 769xx 779xx CACHE INTERNAL "stm32f7 chip types")
+SET(STM32_CODES "745.." "746.." "756.." "765.." "767.." "777.." "769.." "779..")
 
 MACRO(STM32_GET_CHIP_TYPE CHIP CHIP_TYPE)
     STRING(REGEX REPLACE "^[sS][tT][mM]32[fF](7[4567][5679].[EGI]).*$" "\\1" STM32_CODE ${CHIP})
@@ -41,6 +41,8 @@ MACRO(STM32_GET_CHIP_PARAMETERS CHIP FLASH_SIZE RAM_SIZE CCRAM_SIZE)
         SET(RAM "320K")
     ELSEIF(${TYPE} STREQUAL "756xx")
         SET(RAM "320K")
+    ELSEIF(${TYPE} STREQUAL "765xx")
+        SET(RAM "512K")
     ELSEIF(${TYPE} STREQUAL "767xx")
         SET(RAM "512K")
     ELSEIF(${TYPE} STREQUAL "777xx")

cmake/gcc_stm32g0.cmake

@@ -7,11 +7,11 @@ SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--gc-sections -mthumb -mcpu=cortex-m0 -mabi=aapc
 SET(CMAKE_MODULE_LINKER_FLAGS "-mthumb -mcpu=cortex-m0plus -mabi=aapcs" CACHE INTERNAL "module linker flags")
 SET(CMAKE_SHARED_LINKER_FLAGS "-mthumb -mcpu=cortex-m0plus -mabi=aapcs" CACHE INTERNAL "shared linker flags")
 
-SET(STM32_CHIP_TYPES 070xB 071x8 071xB 081xB   CACHE INTERNAL "stm32g0 chip types")
-SET(STM32_CODES     "070.B" "071.8" "071.B" "081.B" )
+SET(STM32_CHIP_TYPES 070xB 071x8 071xB 081xB 041x8 031x8 041x6 031x6 031x4  CACHE INTERNAL "stm32g0 chip types")
+SET(STM32_CODES     "070.B" "071.8" "071.B" "081.B" "041.8" "031.8" "041.6" "031.6" "031.4")
 
 MACRO(STM32_GET_CHIP_TYPE CHIP CHIP_TYPE)
-    STRING(REGEX REPLACE "^[sS][tT][mM]32[gG]((070[CKR]B)|(071[CGKR]8)|(071[CEGKR]B)|(081[CEGKR]B)).+$" "\\1" STM32_CODE ${CHIP})
+    STRING(SUBSTRING ${CHIP} 6 5 STM32_CODE)
     SET(INDEX 0)
     FOREACH(C_TYPE ${STM32_CHIP_TYPES})
         LIST(GET STM32_CODES ${INDEX} CHIP_TYPE_REGEXP)
@@ -24,8 +24,8 @@ MACRO(STM32_GET_CHIP_TYPE CHIP CHIP_TYPE)
 ENDMACRO()
 
 MACRO(STM32_GET_CHIP_PARAMETERS CHIP FLASH_SIZE RAM_SIZE)
-    STRING(REGEX REPLACE "^[sS][tT][mM]32[gG](1[056][012]).([68BCDE]$|[68BCDE][AX]$)" "\\1" STM32_CODE ${CHIP})
-    STRING(REGEX REPLACE "^[sS][tT][mM]32[gG](1[056][012]).([68BCDE]$|[68BCDE][AX]$)" "\\2" STM32_SIZE_CODE ${CHIP})
+    STRING(REGEX REPLACE "^[sS][tT][mM]32[gG](0[3478][1]).([468BJ]$|[68BCDE][AX]$)" "\\1" STM32_CODE ${CHIP})
+    STRING(REGEX REPLACE "^[sS][tT][mM]32[gG](0[3478][1]).([468BJ]$|[68BCDE][AX]$)" "\\2" STM32_SIZE_CODE ${CHIP})
 
     STM32_GET_CHIP_TYPE(${CHIP} TYPE)
 
@@ -41,6 +41,21 @@ MACRO(STM32_GET_CHIP_PARAMETERS CHIP FLASH_SIZE RAM_SIZE)
     ELSEIF(${TYPE} STREQUAL 081xB)
         SET(RAM "36K")
         SET(FLASH "128K")
+    ELSEIF(${TYPE} STREQUAL 041x8)
+        SET(RAM "8K")
+        SET(FLASH "64K")
+    ELSEIF(${TYPE} STREQUAL 031x8)
+        SET(RAM "8K")
+        SET(FLASH "64K")
+    ELSEIF(${TYPE} STREQUAL 041x6)
+        SET(RAM "8K")
+        SET(FLASH "32K")
+    ELSEIF(${TYPE} STREQUAL 031x6)
+        SET(RAM "8K")
+        SET(FLASH "32K")
+    ELSEIF(${TYPE} STREQUAL 031x4)
+        SET(RAM "8K")
+        SET(FLASH "16K")
     ENDIF()
 
     SET(${FLASH_SIZE} ${FLASH})
@@ -53,7 +68,7 @@ FUNCTION(STM32_SET_CHIP_DEFINITIONS TARGET CHIP_TYPE)
         MESSAGE(FATAL_ERROR "Invalid/unsupported STM32G0 chip type: ${CHIP_TYPE}")
     ENDIF()
     GET_TARGET_PROPERTY(TARGET_DEFS ${TARGET} COMPILE_DEFINITIONS)
-    STRING(REGEX REPLACE "^(0[78][01]).[BCDEFG8]" "\\1" STM32_DEVICE_NUM ${STM32_CHIP_TYPE})
+    STRING(REGEX REPLACE "^(0[3478][01]).[BCDEFGJ468]" "\\1" STM32_DEVICE_NUM ${STM32_CHIP_TYPE})
     IF(TARGET_DEFS)
         SET(TARGET_DEFS "STM32${STM32_FAMILY};STM32G${STM32_DEVICE_NUM}xx;${TARGET_DEFS}")
     ELSE()

cmake/gcc_stm32h7.cmake

@@ -0,0 +1,63 @@
+SET(CMAKE_C_FLAGS "-mthumb -fno-builtin -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -Wall -std=gnu99 -ffunction-sections -fdata-sections -fomit-frame-pointer -mabi=aapcs -fno-unroll-loops -ffast-math -ftree-vectorize" CACHE INTERNAL "c compiler flags")
+SET(CMAKE_CXX_FLAGS "-mthumb -fno-builtin -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -Wall -std=c++11 -ffunction-sections -fdata-sections -fomit-frame-pointer -mabi=aapcs -fno-unroll-loops -ffast-math -ftree-vectorize" CACHE INTERNAL "cxx compiler flags")
+SET(CMAKE_ASM_FLAGS "-mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -x assembler-with-cpp" CACHE INTERNAL "asm compiler flags")
+
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--gc-sections -mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -mabi=aapcs" CACHE INTERNAL "executable linker flags")
+SET(CMAKE_MODULE_LINKER_FLAGS "-mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -mabi=aapcs" CACHE INTERNAL "module linker flags")
+SET(CMAKE_SHARED_LINKER_FLAGS "-mthumb -mcpu=cortex-m7 -mfpu=fpv5-sp-d16 -mfloat-abi=softfp -mabi=aapcs" CACHE INTERNAL "shared linker flags")
+SET(STM32_CHIP_TYPES 743xx 750xx 753xx CACHE INTERNAL "stm32h7 chip types")
+SET(STM32_CODES "743.." "750.." "753..")
+
+MACRO(STM32_GET_CHIP_TYPE CHIP CHIP_TYPE)
+    STRING(REGEX REPLACE "^[sS][tT][mM]32[hH](7[45][03].[BI]).*$" "\\1" STM32_CODE ${CHIP})
+    SET(INDEX 0)
+    FOREACH(C_TYPE ${STM32_CHIP_TYPES})
+        LIST(GET STM32_CODES ${INDEX} CHIP_TYPE_REGEXP)
+        IF(STM32_CODE MATCHES ${CHIP_TYPE_REGEXP})
+            SET(RESULT_TYPE ${C_TYPE})
+        ENDIF()
+        MATH(EXPR INDEX "${INDEX}+1")
+    ENDFOREACH()
+    SET(${CHIP_TYPE} ${RESULT_TYPE})
+ENDMACRO()
+
+MACRO(STM32_GET_CHIP_PARAMETERS CHIP FLASH_SIZE RAM_SIZE CCRAM_SIZE)
+    STRING(REGEX REPLACE "^[sS][tT][mM]32[hH](7[45][03].[BI]).*$" "\\1" STM32_CODE ${CHIP})
+    STRING(REGEX REPLACE "^[sS][tT][mM]32[hH]7[45][03].([BI]).*$" "\\1" STM32_SIZE_CODE ${CHIP})
+    
+    IF(STM32_SIZE_CODE STREQUAL "B")
+        SET(FLASH "128K")
+    ELSEIF(STM32_SIZE_CODE STREQUAL "I")
+        SET(FLASH "2048K")
+    ENDIF()
+    
+    STM32_GET_CHIP_TYPE(${CHIP} TYPE)
+    
+    IF(${TYPE} STREQUAL "743xx")
+        SET(RAM "1024K")
+    ELSEIF(${TYPE} STREQUAL "750xx")
+        SET(RAM "1024K")
+    ELSEIF(${TYPE} STREQUAL "753xx")
+        SET(RAM "1024K")
+    ENDIF()
+    
+    SET(${FLASH_SIZE} ${FLASH})
+    SET(${RAM_SIZE} ${RAM})
+    # First 64K of RAM are already CCM...
+    SET(${CCRAM_SIZE} "0K")
+ENDMACRO()
+
+FUNCTION(STM32_SET_CHIP_DEFINITIONS TARGET CHIP_TYPE)
+    LIST(FIND STM32_CHIP_TYPES ${CHIP_TYPE} TYPE_INDEX)
+    IF(TYPE_INDEX EQUAL -1)
+        MESSAGE(FATAL_ERROR "Invalid/unsupported STM32H7 chip type: ${CHIP_TYPE}")
+    ENDIF()
+    GET_TARGET_PROPERTY(TARGET_DEFS ${TARGET} COMPILE_DEFINITIONS)
+    IF(TARGET_DEFS)
+        SET(TARGET_DEFS "STM32H7;STM32H${CHIP_TYPE};${TARGET_DEFS}")
+    ELSE()
+        SET(TARGET_DEFS "STM32H7;STM32H${CHIP_TYPE}")
+    ENDIF()
+        
+    SET_TARGET_PROPERTIES(${TARGET} PROPERTIES COMPILE_DEFINITIONS "${TARGET_DEFS}")
+ENDFUNCTION()

stm32-blinky/main.c

@@ -1,14 +1,11 @@
 #if defined STM32F1
-#include <stm32f1xx_hal.h>
+# include <stm32f1xx_hal.h>
 #elif defined STM32F2
-#include <stm32f2xx_hal.h>
+# include <stm32f2xx_hal.h>
 #elif defined STM32F4
-#include <stm32f4xx_hal.h>
+# include <stm32f4xx_hal.h>
 #elif defined STM32G0
-#include <stm32g0xx_hal.h>
-#include <stm32g0xx_hal_gpio_ex.h>
-#include <stm32g0xx_hal_rcc.h>
-
+# include <stm32g0xx_hal.h>
 #endif
 
 void initGPIO()
@@ -70,6 +67,7 @@ void initTimers()
 #elif defined STM32F4
     __TIM3_CLK_ENABLE();
     TIM_Handle.Instance = TIM3;
+    // TIM3 Clocked from SYSCLK = 168 MHz
     TIM_Handle.Init.Prescaler = (uint16_t)(HAL_RCC_GetSysClockFreq() / 10000) - 1;
 #elif defined STM32G0
 

stm32-newlib/main.c

@@ -85,8 +85,8 @@ void initUART()
     __USART3_CLK_ENABLE();
     UART_Handle.Instance = USART3;
 #elif defined STM32G0
-    __HAL_RCC_USART2_CLK_ENABLE();
-    UART_Handle.Instance = USART2;
+    __HAL_RCC_USART1_CLK_ENABLE();
+    UART_Handle.Instance = USART1;
 
 #endif
 
@@ -220,8 +220,8 @@ void initClock(void)
     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0);
 
-    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
-    PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
+    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1;
+    PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1;
     HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
 
 #endif
@@ -253,7 +253,7 @@ int main(void)
         switch (c)
         {
         case 's':
-            scanf("%d", &t);
+            scanf("%lld", &t);
             setTime(t);
             printf("Current time changed: %d - %s\r", t, ctime(&t));
             break;

stm32-template/CMakeLists.txt

@@ -4,12 +4,12 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 ENABLE_LANGUAGE(ASM)
 
 FIND_PACKAGE(CMSIS REQUIRED)
-#FIND_PACKAGE(STM32HAL REQUIRED)
+FIND_PACKAGE(STM32HAL REQUIRED)
 
 INCLUDE_DIRECTORIES(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMSIS_INCLUDE_DIRS}
-    #${STM32HAL_INCLUDE_DIR}
+    ${STM32HAL_INCLUDE_DIR}
 )
 
 SET(PROJECT_SOURCES
@@ -18,7 +18,7 @@ SET(PROJECT_SOURCES
 
 SET(STM32_LINKER_SCRIPT ${CMSIS_LINKER_SCRIPT})
 
-ADD_EXECUTABLE(${CMAKE_PROJECT_NAME} ${PROJECT_SOURCES} ${CMSIS_SOURCES}) # ${STM32HAL_SOURCES}
+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})