Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2025-12-10 12:14:36 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Documentation/guides: Update CMake C++ guide

Browse Source 
Use the exported CMake toolchain file instead of a  custom and broken one.
Slightly modify the C++ example code to introduce modern tools like auto keyword and shared_ptr

Signed-off-by: Philippe Leduc <philippe.leduc@mailfence.com>
This commit is contained in:
Philippe Leduc
2025-09-03 09:50:12 +02:00
committed by Alan C. Assis
parent 3eb1c21807
commit 1daa2d54e3
1 changed files with 69 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
Documentation/guides/cpp_cmake.rst
View File

@@ -29,18 +29,27 @@ Preparation
#. Base NuttX compilation changes
For this example, load the configuration 'stm32f4discovery:testlibcxx' for building
For this example, load the configuration 'stm32f4discovery:nsh' for building (Linux host)
.. code-block:: console
$ cd nuttx
$ ./tools/configure.sh stm32f4discovery:testlibcxx
$ ./tools/configure.sh -l stm32f4discovery:nsh
See :ref:`quickstart/compiling_make:Initialize Configuration` for more information about configure.sh tool.
In menuconfig, the main points to be changed on a typical NuttX configuration are the following:
* Set RTOS Features -> Tasks and Scheduling -> Application entry point to 'hellocpp_main'
* RTOS Features -> Tasks and Scheduling -> Application entry point to 'main'
* Library Routines -> Have C++ compiler
* Library Routines -> Have C++ initialization -> C++ Library -> Toolchain C++ support (you can also choose the basic version or the LLVM one)
* Library Routines -> Have C++ initialization -> C++ Library -> C++ low level library select -> GNU low level libsupc++
* Library Routines -> Language standard -> choose the version you want - for this example we will use "c++17"
* Library Routines -> Enable Exception Support -> to enable to support C++ exceptions - for this example we will select it
* Library Routines -> Enable RTTI Support -> to enable to support C++ RTTI features (like dynamic_cast()/typeid()) - for this example we will not enable it
* Build NuttX and generate the export
Build NuttX and generate the export
.. code-block:: console
@@ -57,14 +66,12 @@ Creating the project
hellocpp/
hellocpp/CMakeLists.txt
hellocpp/cmake/stm32f4discovery.cmake
hellocpp/nuttx-export-10.0.1/
hellocpp/src/CMakeLists.txt
hellocpp/src/main.cpp
hellocpp/src/HelloWorld.h
hellocpp/src/HelloWorld.cpp
hellocpp/nuttx-export-12.10.0/
hellocpp/main.cpp
hellocpp/HelloWorld.h
hellocpp/HelloWorld.cpp
The directory 'nuttx-export-10.0.1' is the unzipped content from the file created during
The directory 'nuttx-export-12.10.0' is the unzipped content from the file created during
make export procedure done before.
#. File contents
@@ -73,7 +80,7 @@ Creating the project
.. code-block:: cmake
cmake_minimum_required(VERSION 3.2...3.15)
cmake_minimum_required(VERSION 3.12...3.31)
project(HelloCpp
VERSION 1.0
@@ -82,159 +89,63 @@ Creating the project
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_C_STANDARD 99)
set(NUTTX_PATH "${CMAKE_SOURCE_DIR}/nuttx-export-10.0.1")
include(cmake/stm32f4discovery.cmake)
set(AC_COMMON_FLAGS "${AC_COMMON_FLAGS} -Wall -Wshadow -Wundef -fno-strict-aliasing -Os")
set(AC_COMMON_FLAGS "${AC_COMMON_FLAGS} -D_DEBUG -D_LIBCPP_BUILD_STATIC -D_LIBCPP_NO_EXCEPTIONS ")
set(AC_COMMON_FLAGS "${AC_COMMON_FLAGS} -fno-exceptions -fcheck-new -fno-rtti -pedantic ")
set(AC_COMMON_FLAGS "${AC_COMMON_FLAGS} -nostdinc++")
set(AC_DEFINES "${AC_DEFINES} -DCONFIG_WCHAR_BUILTIN")
include_directories(
src
${NUTTX_PATH}/include
${NUTTX_PATH}/include/libcxx
${NUTTX_PATH}/arch/chip
)
set(EXE_NAME hellocpp)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${AC_HW_FLAGS} ${AC_DEFINES}")
set(CMAKE_CXX_FLAGS "${AC_HW_FLAGS} ${AC_DEFINES} ${AC_COMMON_FLAGS} ${AC_CXX_EXTRA_FLAGS}")
if (PARAM_DEBUG)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
endif()
set(CMAKE_SKIP_RPATH ON)
set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_LINKER} ${AC_LINKER_FLAGS} -o ${EXE_NAME}.elf <OBJECTS> <LINK_LIBRARIES>")
set(BUILD_SHARED_LIBS OFF)
add_subdirectory(src)
* hellocpp/cmake/stm32f4discovery.cmake
.. code-block:: cmake
set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR arm)
set(MCU_LINKER_SCRIPT "${NUTTX_PATH}/scripts/ld.script")
set(COMPILER_PREFIX arm-none-eabi-)
# cmake-format: off
set(CMAKE_C_COMPILER ${COMPILER_PREFIX}gcc)
set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}g++)
set(CMAKE_AR ${COMPILER_PREFIX}ar)
set(CMAKE_RANLIB ${COMPILER_PREFIX}ranlib)
set(CMAKE_LINKER ${COMPILER_PREFIX}ld)
set(CMAKE_ASM_COMPILER ${COMPILER_PREFIX}gcc)
set(CMAKE_OBJCOPY ${COMPILER_PREFIX}objcopy)
set(CMAKE_OBJDUMP ${COMPILER_PREFIX}objdump)
set(CMAKE_SIZE ${COMPILER_PREFIX}size)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
set(AC_HW_FLAGS "-mcpu=cortex-m4 -mthumb -mfloat-abi=soft ")
set(AC_HW_FLAGS "${AC_HW_FLAGS} -isystem ${NUTTX_PATH}/include")
set(AC_HW_FLAGS "${AC_HW_FLAGS} -pipe")
set(AC_LINKER_FLAGS "--entry=__start -nostdlib -T${MCU_LINKER_SCRIPT}")
* hellocpp/src/CMakeLists.txt
.. code-block:: cmake
set(HEADER_FILES
HelloWorld.h
)
set(SOURCE_FILES
HelloWorld.cpp
${CMAKE_CURRENT_SOURCE_DIR}/HelloWorld.cpp
${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
)
link_directories(${EXE_NAME} ${NUTTX_PATH}/libs)
add_executable(${EXE_NAME} ${SOURCE_FILES} main.cpp ${HEADER_FILES})
set(EXE_NAME "hello")
add_executable(${EXE_NAME} ${SOURCE_FILES})
add_custom_command(
TARGET ${EXE_NAME}
POST_BUILD
COMMAND ${CMAKE_OBJCOPY} ARGS -S -O binary ${CMAKE_BINARY_DIR}/${EXE_NAME}.elf ${CMAKE_BINARY_DIR}/${EXE_NAME}.bin
)
COMMAND ${CMAKE_OBJCOPY} ARGS -S -O binary ${CMAKE_BINARY_DIR}/${EXE_NAME} ${CMAKE_BINARY_DIR}/${EXE_NAME}.bin
target_link_libraries(${EXE_NAME} --start-group)
target_link_libraries(${EXE_NAME} sched)
target_link_libraries(${EXE_NAME} drivers)
target_link_libraries(${EXE_NAME} boards)
target_link_libraries(${EXE_NAME} c)
target_link_libraries(${EXE_NAME} mm)
target_link_libraries(${EXE_NAME} arch)
target_link_libraries(${EXE_NAME} xx)
target_link_libraries(${EXE_NAME} apps)
target_link_libraries(${EXE_NAME} fs)
target_link_libraries(${EXE_NAME} binfmt)
target_link_libraries(${EXE_NAME} board)
target_link_libraries(${EXE_NAME} gcc)
target_link_libraries(${EXE_NAME} supc++)
target_link_libraries(${EXE_NAME} --end-group)
* hellocpp/src/main.cpp
* hellocpp/main.cpp
.. code-block:: c++
#include <memory>
#include "HelloWorld.h"
#include <nuttx/config.h>
extern "C"
extern "C" int main(int, char*[])
{
int hellocpp_main(void)
{
auto pHelloWorld = std::make_shared<CHelloWorld>();
pHelloWorld->HelloWorld();
CHelloWorld *pHelloWorld = new CHelloWorld();
pHelloWorld->HelloWorld();
CHelloWorld helloWorld;
helloWorld.HelloWorld();
CHelloWorld helloWorld;
helloWorld.HelloWorld();
delete pHelloWorld;
return 0;
}
return 0;
}
* hellocpp/src/HelloWorld.h
* hellocpp/HelloWorld.h
.. code-block:: c++
#ifndef HELLOWORLD_H_
#define HELLOWORLD_H_
#include "nuttx/config.h"
#ifndef HELLOWORLD_H
#define HELLOWORLD_H
class CHelloWorld
{
public:
CHelloWorld();
~CHelloWorld();
bool HelloWorld(void);
private:
int mSecret;
public:
CHelloWorld();
~CHelloWorld() = default;
bool HelloWorld();
private:
int mSecret;
};
#endif
* hellocpp/src/HelloWorld.cpp
* hellocpp/HelloWorld.cpp
.. code-block:: c++
@@ -243,30 +154,32 @@ Creating the project
#include "HelloWorld.h"
CHelloWorld::CHelloWorld() {
mSecret = 42;
std::printf("Constructor: mSecret=%d\n",mSecret);
CHelloWorld::CHelloWorld()
{
mSecret = 42;
std::printf("Constructor: mSecret=%d\n",mSecret);
}
CHelloWorld::~CHelloWorld() {
bool CHelloWorld::HelloWorld()
{
std::printf("HelloWorld: mSecret=%d\n",mSecret);
std::string sentence = "Hello";
std::printf("TEST=%s\n",sentence.c_str());
if (mSecret == 42)
{
std::printf("CHelloWorld: HelloWorld: Hello, world!\n");
return true;
}
else
{
std::printf("CHelloWorld: HelloWorld: CONSTRUCTION FAILED!\n");
return false;
}
}
bool CHelloWorld::HelloWorld(void) {
std::printf("HelloWorld: mSecret=%d\n",mSecret);
std::string sentence = "Hello";
std::printf("TEST=%s\n",sentence.c_str());
if (mSecret == 42) {
std::printf("CHelloWorld: HelloWorld: Hello, world!\n");
return true;
}
else {
std::printf("CHelloWorld: HelloWorld: CONSTRUCTION FAILED!\n");
return false;
}
}
Building
========
@@ -277,7 +190,7 @@ To launch build, you use the cmake procedure:
$ mkdir build
$ cd build
$ cmake ..
$ cmake .. -DCMAKE_TOOLCHAIN_FILE=../nuttx-export-12.10.0/scripts/toolchain.cmake
$ make
And finally a bin file will be created to be loaded on the board.
Two binaries are generated: an elf one - useful for debug purpose - and a binary one to be flashed on the board