Here’s an example of a working setup for a project for an STM32L4P5. Since you are using an STM32F407 you’ll obviously have to change some include paths and defines as appropriate.

First a note on directory structure. Here I have a top-level git repository. Within are two directories containing my application/driver specific code (in MyApp and MyDrivers). You probably want to choose better names, I’ve renamed these from project-specific names just as an example. These directories contain the code that will be unit tested. You might only have one such directory, or more than two, depending on your project.

Then there is the STM32 project (created with STM32CubeIDE or STM32CubeMX, for example). I did not add any of my code into this directory. I changed main.c to call out my project-specific app_main() function.

Lastly there is the unit_test directory, where you will construct the unit-test framework.

It looks like this:

repo_root/
├─ MpApp/
│  ├─ Src/
│  │  ├─ app_file.c
│  ├─ Inc/
│  │  ├─ app_file.h
├─ MyDrivers/
│  ├─ Src/
│  │  ├─ foo_driver.c
│  ├─ Inc/
│  │  ├─ foo_driver.h
├─ STMProject/
│  ├─ Core/
│  ├─ Drivers/
│  ├─ ...etc.../
├─ unit_test/
│  ├─ build/
│  ├─ test/
│  │  ├─ test_app_file.c
│  │  ├─ test_foo_driver.c
│  │  ├─ support/
│  ├─ project.yml

You’ll see that the project contains two files that will be unit tested: app_file.c and foo_driver.c. Hence there are only two files in the unit_test/test directory, one for each file to test.

The unit_test directory contains a build directory, which is where build artifacts will be placed during the test process.

Here is the project.yml file that lives in unit_test:

---

# Notes:
# Sample project C code is not presently written to produce a release artifact.
# As such, release build options are disabled.
# This sample, therefore, only demonstrates running a collection of unit tests.

:project:
  :use_exceptions: TRUE
  :use_test_preprocessor: TRUE
  :use_auxiliary_dependencies: TRUE
  :build_root: build
#  :release_build: TRUE
  :test_file_prefix: test_
  :which_ceedling: gem
  :ceedling_version: 0.31.1
  :default_tasks:
    - test:all

:test_build:
  :use_assembly: FALSE

#:release_build:
#  :output: MyApp.out
#  :use_assembly: FALSE

:environment:

:extension:
  :executable: .out

:paths:
  :test:
    - +:test/**
    - -:test/support
  :source:
    - ../STMProject/Core/Inc/
    - ../MyApp/Src/
    - ../MyApp/Inc/
    - ../MyDrivers/Src/
    - ../MyDrivers/Inc
    - ../STMProject/Drivers/STM32L4xx_HAL_Driver/Inc
    - ../STMProject/Drivers/STM32L4xx_HAL_Driver/Inc/Legacy/
    - ../STMProject/Drivers/CMSIS/Device/ST/STM32L4xx/Include/
    - ../STMProject/Drivers/CMSIS/Include
  :support:
    - test/support
  :libraries: []

:defines:
  # in order to add common defines:
  #  1) remove the trailing [] from the :common: section
  #  2) add entries to the :common: section (e.g. :test: has TEST defined)
  :common: &common_defines
    - STM32L4P5xx
    - USE_HAL_DRIVER
    - TEST
    - CMOCK_MEM_DYNAMIC
  :test:
    - *common_defines
  :test_preprocess:
    - *common_defines

:flags:
  :test:
    :compile:
      :*:
        - -Wno-int-to-pointer-cast
        - -Wno-pointer-to-int-cast
#        - -O0
#        - -g

:cmock:
  :mock_prefix: mock_
  :when_no_prototypes: :warn
  :enforce_strict_ordering: TRUE
  :plugins:
    - :ignore
    - :callback
    - :expect_any_args
    - :ignore_arg
  :includes:
    - stm32l4xx_hal.h
  :includes_h_pre_orig_header:
    - stm32l4xx_hal.h
  :includes_c_pre_header:
    - stm32l4xx_hal.h
  :treat_as:
    uint8:    HEX8
    uint16:   HEX16
    uint32:   UINT32
    int8:     INT8
    bool:     UINT8
  :strippables:
    - '__NO_RETURN'

# Add -gcov to the plugins list to make sure of the gcov plugin
# You will need to have gcov and gcovr both installed to make it work.
# For more information on these options, see docs in plugins/gcov
:gcov:
  :reports:
    - HtmlDetailed
    - Text
  :gcovr:
    :html_medium_threshold: 75
    :html_high_threshold: 90
    :print_summary: true

#:tools:
# Ceedling defaults to using gcc for compiling, linking, etc.
# As [:tools] is blank, gcc will be used (so long as it's in your system path)
# See documentation to configure a given toolchain for use


# LIBRARIES
# These libraries are automatically injected into the build process. Those specified as
# common will be used in all types of builds. Otherwise, libraries can be injected in just
# tests or releases. These options are MERGED with the options in supplemental yaml files.
:libraries:
  :placement: :end
  :flag: "-l${1}"
  :path_flag: "-L ${1}"
  :system: []    # for example, you might list 'm' to grab the math library
  :test: []
  :release: []

:plugins:
  :load_paths:
    - "#{Ceedling.load_path}"
  :enabled:
    - stdout_pretty_tests_report
    - module_generator
    - gcov
...

I’m not sure I can give a line-by-line breakdown of what all that means, this was made over time as a collective effort until it worked.

The interesting part, probably, is the :paths:source: directive. This has to include all the directories that contain source code to be tested, and directories containing header files that can be mocked. Don’t include paths to source code that you don’t want to test.