File Directory Structure - MatthewMArnold/taproot GitHub Wiki
Here is the project structure. Code in the modm directory is omitted for brevity.
All module.lb files are script files that generate files when lbuild build
is ran by the user. A module.lb file might contain logic that says "generate
file 'A' with the given user-specified substitutions." Using a code generation
tool, this allows taproot to support multiple development platforms and generate
user-specific software based on their needs.
.
├── build-tools // Build scripts that will be generated into a user's project that support building taproot
│ ├── module.lb
│ └── SConscript
├── CHANGELOG.md
├── COPYING
├── docs // Tooling for generating Doxygen code documentation. This is generated into a user's project
│ ├── conf.py
│ ├── conf.py.in
│ ├── Doxyfile
│ ├── Doxyfile.in
│ ├── index.rst
│ ├── make.bat
│ ├── Makefile
│ ├── module.lb
│ └── module.rst
├── ext // External libraries that taproot depends on.
│ ├── littlefs-project // LittleFS library, a file system that sits on flash
│ │ ├── littlefs
│ │ └── module.lb
│ ├── module.lb
│ ├── README.md
│ └── SConscript
├── lbuild-scripts // Scripts used during code generation
│ ├── add_immutable_warning.py
│ ├── board_info_parser.py
│ ├── hosted_platforms.py
│ └── lbuild_utils.py
├── modm // Repository that contains low level HALs that taproot builds upon.
├── modm-project-files // project.xml files that are generated into a user's project. These generated files are then ran to generate modm files.
│ ├── module.lb
│ ├── project.xml.in
│ └── sim-modm
│ └── project.xml.in
├── README.generation.md // File that is generated into the uesr's project to inform them that they should not modify generated code.
├── README.md
├── repo.lb // Top level file that is referenced when `lbuild build` is ran by the user.
├── src
│ ├── drivers.hpp.in
│ ├── drivers.py
│ ├── module.lb
│ └── tap
│ ├── algorithms // Hardware-agnostic utility algorithms.
│ │ ├── ballistics.cpp
│ │ ├── ballistics.hpp
│ │ ├── cmsis_mat.hpp // Custom C++ matrix that lives on top of CMSIS matricies that provides C++ operators to make matrix math easy to understand.
│ │ ├── contiguous_float.cpp // A float wrapped around some [min, max]
│ │ ├── contiguous_float.hpp
│ │ ├── crc.cpp
│ │ ├── crc.hpp // CRC protocol used by RoboMaster referee system.
│ │ ├── extended_kalman.cpp // 1D extended KF
│ │ ├── extended_kalman.hpp
│ │ ├── fuzzy_pd.cpp // Custom fuzzy-PID algorithm that allows PID to be used on dynamic systems where things such as weight are not consistent.
│ │ ├── fuzzy_pd.hpp
│ │ ├── fuzzy_pd_rule_table.cpp
│ │ ├── fuzzy_pd_rule_table.hpp
│ │ ├── fuzzy_rule_table.hpp
│ │ ├── kalman_filter.hpp // Custom kalman filter built on top of CMSIS digital signal processing library to support fast embedded matrix computations
│ │ ├── linear_interpolation_predictor_contiguous.cpp // Linear interpolation that performs lookahead on a contiguous float
│ │ ├── linear_interpolation_predictor_contiguous.hpp
│ │ ├── linear_interpolation_predictor.cpp
│ │ ├── linear_interpolation_predictor.hpp
│ │ ├── MahonyAHRS.cpp // Open source IMU attitude calculation algorithm
│ │ ├── MahonyAHRS.h
│ │ ├── math_user_utils.cpp // Various random utilities.
│ │ ├── math_user_utils.hpp
│ │ ├── odometry // Odometry interfaces and simple 2D odometry implementation.
│ │ │ ├── chassis_displacement_observer_interface.hpp
│ │ │ ├── chassis_world_yaw_observer_interface.hpp
│ │ │ ├── odometry_2d_interface.hpp
│ │ │ ├── odometry_2d_tracker.cpp
│ │ │ └── odometry_2d_tracker.hpp
│ │ ├── ramp.cpp
│ │ ├── ramp.hpp
│ │ ├── smooth_pid.cpp // Custom PID with KF smoothing and various other modifications.
│ │ ├── smooth_pid.hpp
│ │ ├── strtok.cpp // strtok since arm-none-eabi-g++ doesn't support this function
│ │ └── strtok.hpp
│ ├── architecture
│ │ ├── clock.cpp // Provides millisecond and microsecond level precision clocks and support for mocking time during testing.
│ │ ├── clock.hpp
│ │ ├── conditional_timer.hpp // Timer that only executes when a condition is met
│ │ ├── endianness_wrappers.hpp // Wrappers for converting to and from little/big endian
│ │ ├── periodic_timer.hpp // Timer that executes periodically
│ │ ├── profiler.cpp // Utility that can be enabled during runtime that computes the time it takes various profiled functions to run.
│ │ ├── profiler.hpp
│ │ └── timeout.hpp // Simple timer that times out a single time
│ ├── board // Generates hardware clock and pin specifications based on which RoboMaster board is being used
│ │ ├── board.cpp
│ │ ├── module.lb
│ │ ├── rm-dev-board-a
│ │ │ └── board.hpp.in
│ │ └── rm-dev-board-c
│ │ └── board.hpp.in
│ ├── communication
│ │ ├── can // CAN primitives for making it easy to interact with CAN
│ │ │ ├── can_bus.hpp
│ │ │ ├── can.cpp.in
│ │ │ ├── can.hpp
│ │ │ ├── can_rx_handler.cpp
│ │ │ ├── can_rx_handler.hpp // Singleton responsible for recveiving and forwarding CAN messages
│ │ │ ├── can_rx_listener.cpp
│ │ │ ├── can_rx_listener.hpp // Interface that provides a callback to children when new CAN messages arrive
│ │ │ └── module.lb
│ │ ├── gpio // Custom generated GPIO classes based on which peripherals the user has configured
│ │ │ ├── analog.cpp.in
│ │ │ ├── analog.hpp.in
│ │ │ ├── digital.cpp.in
│ │ │ ├── digital.hpp.in
│ │ │ ├── leds.cpp.in
│ │ │ ├── leds.hpp.in
│ │ │ ├── module.lb
│ │ │ ├── pwm.cpp.in
│ │ │ └── pwm.hpp.in
│ │ ├── module.lb
│ │ ├── referee
│ │ │ └── state_hud_indicator.hpp // Object that updates a HUD object based on some state change and draws the object
│ │ ├── sensors
│ │ │ ├── buzzer
│ │ │ │ ├── buzzer.cpp.in // HAL for interacting with the RoboMaster buzzer
│ │ │ │ ├── buzzer.hpp
│ │ │ │ └── module.lb
│ │ │ ├── current
│ │ │ │ ├── analog_current_sensor.cpp // HAL for interacting with generic linear analog current sensor
│ │ │ │ ├── analog_current_sensor.hpp
│ │ │ │ ├── current_sensor_interface.hpp // Interface for generic current sensor
│ │ │ │ └── module.lb
│ │ │ ├── distance // Interfaces and HALs for various distance sensors
│ │ │ │ ├── analog_distance_sensor.cpp
│ │ │ │ ├── analog_distance_sensor.hpp
│ │ │ │ ├── distance_sensor.cpp
│ │ │ │ ├── distance_sensor.hpp
│ │ │ │ ├── module.lb
│ │ │ │ ├── sharp_ir_GP2Y0A41.cpp
│ │ │ │ └── sharp_ir_GP2Y0A41.hpp
│ │ │ ├── imu
│ │ │ │ ├── bmi088 // Driver for BMI088 (for type C board)
│ │ │ │ │ ├── bmi088.cpp
│ │ │ │ │ ├── bmi088_data.hpp
│ │ │ │ │ ├── bmi088_hal.cpp
│ │ │ │ │ ├── bmi088_hal.hpp
│ │ │ │ │ ├── bmi088.hpp
│ │ │ │ │ └── module.lb
│ │ │ │ ├── imu_interface.hpp // Interface that allows one to interact with the Mpu6500 or Bmi088 interchangably
│ │ │ │ ├── imu_menu.cpp
│ │ │ │ ├── imu_menu.hpp // OLED menu for IMU
│ │ │ │ ├── imu_terminal_serial_handler.cpp
│ │ │ │ ├── imu_terminal_serial_handler.hpp // Terminal for interacting with IMU
│ │ │ │ ├── module.lb
│ │ │ │ └── mpu6500 // Driver for MPU6500 (for type A board)
│ │ │ │ ├── module.lb
│ │ │ │ ├── mpu6500_config.hpp
│ │ │ │ ├── mpu6500.cpp
│ │ │ │ ├── mpu6500.hpp
│ │ │ │ └── mpu6500_reg.hpp
│ │ │ ├── imu_heater // Driver for heart located near the IMU on the type A and C boards
│ │ │ │ ├── imu_heater_constants.hpp.in
│ │ │ │ ├── imu_heater.cpp
│ │ │ │ ├── imu_heater.hpp
│ │ │ │ └── module.lb
│ │ │ ├── limit_switch
│ │ │ │ ├── limit_switch_interface.hpp // Interface for limit switch
│ │ │ │ └── module.lb
│ │ │ ├── module.lb
│ │ │ └── sensor_interface.hpp // Interface for simple sensor (analog, digital sensors, etc)
│ │ ├── serial
│ │ │ ├── dji_serial.cpp.in
│ │ │ ├── dji_serial.hpp // Serial interface with a generic serial protocol that supports the referee system as well as vision system serial
│ │ │ ├── hosted_terminal_device.cpp
│ │ │ ├── hosted_terminal_device.hpp // Used for simulating a terminal on the hosted environment.
│ │ │ ├── module.lb
│ │ │ ├── ref_serial_constants.hpp.in // Referee system serial driver
│ │ │ ├── ref_serial.cpp
│ │ │ ├── ref_serial_data.hpp
│ │ │ ├── ref_serial.hpp
│ │ │ ├── ref_serial_transmitter.cpp // Protothread-based transmitter that sends information via serial to the referee system. Multiple transmitters may be instantiated and used at the same time and the user does not have to worry about transmission synchronicity
│ │ │ ├── ref_serial_transmitter.hpp
│ │ │ ├── remote.cpp
│ │ │ ├── remote.hpp // Driver for DR16 remote receiver
│ │ │ ├── remote_serial_constants.hpp.in
│ │ │ ├── terminal_serial.cpp
│ │ │ ├── terminal_serial.hpp // Terminal interface that the user may connect various driver-dependent terminal handlers to
│ │ │ ├── uart.cpp.in
│ │ │ ├── uart.hpp.in // Generic hardware-dependent UART driver
│ │ │ ├── uart_terminal_device_constants.hpp.in
│ │ │ ├── uart_terminal_device.cpp
│ │ │ └── uart_terminal_device.hpp
│ │ └── tcp-server // Simulation-based TCP socket implementation
│ │ ├── json_messages.cpp
│ │ ├── json_messages.hpp
│ │ ├── module.lb
│ │ ├── tcp_server.cpp
│ │ └── tcp_server.hpp
│ ├── control
│ │ ├── chassis
│ │ │ ├── chassis_subsystem_interface.hpp
│ │ │ ├── power_limiter.cpp // Custom easy-to-use power limiting software
│ │ │ └── power_limiter.hpp
│ │ ├── command.cpp // A basic control building block, an action that a robot should perform
│ │ ├── command.hpp
│ │ ├── command_mapper.cpp // Singleton that handles the scheduling of commands based on remote input
│ │ ├── command_mapper_format_generator.cpp
│ │ ├── command_mapper_format_generator.hpp
│ │ ├── command_mapper.hpp
│ │ ├── command_mapping.cpp
│ │ ├── command_mapping.hpp
│ │ ├── command_scheduler.cpp // Singleton that manages safe scheduling, resolving scheduling conflicts
│ │ ├── command_scheduler.hpp
│ │ ├── command_scheduler_types.hpp
│ │ ├── comprised_command.hpp // A command made up of multiple commands
│ │ ├── governor
│ │ │ ├── command_governor_interface.hpp
│ │ │ ├── governor_limited_command.hpp
│ │ │ └── governor_with_fallback_command.hpp
│ │ ├── hold_command_mapping.cpp
│ │ ├── hold_command_mapping.hpp
│ │ ├── hold_repeat_command_mapping.cpp
│ │ ├── hold_repeat_command_mapping.hpp
│ │ ├── press_command_mapping.cpp
│ │ ├── press_command_mapping.hpp
│ │ ├── remote_map_state.cpp
│ │ ├── remote_map_state.hpp
│ │ ├── scheduler_terminal_handler.cpp
│ │ ├── scheduler_terminal_handler.hpp
│ │ ├── setpoint // Various setpoint-specific commands and subsystems to make designing velocity and position based systems easy
│ │ │ ├── algorithms
│ │ │ │ └── setpoint_continuous_jam_checker.hpp // Performs jam checking on a setpoint subsystem
│ │ │ ├── commands
│ │ │ │ ├── calibrate_command.cpp
│ │ │ │ ├── calibrate_command.hpp // Calibrates the subsystem
│ │ │ │ ├── move_absolute_command.cpp
│ │ │ │ ├── move_absolute_command.hpp // Moves the subsystem to some absolute position
│ │ │ │ ├── move_command.cpp
│ │ │ │ ├── move_command.hpp // Moves relative to current position.
│ │ │ │ ├── move_integral_command.cpp
│ │ │ │ ├── move_integral_command.hpp // Moves until the subsystem's integral of the setpoint is at some value
│ │ │ │ ├── move_unjam_comprised_command.cpp
│ │ │ │ ├── move_unjam_comprised_command.hpp // Moves and unjams if required
│ │ │ │ ├── move_unjam_integral_comprised_command.cpp
│ │ │ │ ├── move_unjam_integral_comprised_command.hpp
│ │ │ │ ├── unjam_command.cpp
│ │ │ │ ├── unjam_command.hpp // Unjams the setpoint subsystem by moving it back and forth
│ │ │ │ ├── unjam_integral_command.cpp
│ │ │ │ └── unjam_integral_command.hpp
│ │ │ └── interfaces
│ │ │ ├── integrable_setpoint_subsystem.hpp
│ │ │ └── setpoint_subsystem.hpp
│ │ ├── subsystem.cpp
│ │ ├── subsystem.hpp // An organizational unit that encapsulates robot hardware
│ │ ├── toggle_command_mapping.cpp
│ │ ├── toggle_command_mapping.hpp
│ │ └── turret_subsystem_interface.hpp // Interface for a generic turret
│ ├── display // Menu primitives for displaying information on the RoboMaster OLED.
│ │ ├── command_scheduler_menu.cpp
│ │ ├── command_scheduler_menu.hpp
│ │ ├── dummy_allocator.hpp
│ │ ├── hardware_test_menu.cpp
│ │ ├── hardware_test_menu.hpp
│ │ ├── module.lb
│ │ ├── motor_menu.cpp
│ │ ├── motor_menu.hpp
│ │ ├── motor_specific_menu.cpp
│ │ ├── motor_specific_menu.hpp
│ │ ├── oled_button_handler.cpp
│ │ ├── oled_button_handler.hpp
│ │ ├── ref_serial_menu.cpp
│ │ ├── ref_serial_menu.hpp
│ │ ├── sh1106_defines.hpp
│ │ ├── sh1106.hpp
│ │ ├── sh1106_impl.hpp
│ │ ├── sh1106_mock_impl.hpp
│ │ ├── vertical_scroll_logic_handler.cpp
│ │ └── vertical_scroll_logic_handler.hpp
│ ├── errors // Driver for storing and displaying errors on the OLED and terminal serial
│ │ ├── create_errors.hpp
│ │ ├── error_controller.cpp
│ │ ├── error_controller.hpp
│ │ ├── module.lb
│ │ └── system_error.hpp
│ ├── motor
│ │ ├── dji_motor.cpp
│ │ ├── dji_motor.hpp // Object that supports interacting with various DJI style motors
│ │ ├── dji_motor_terminal_serial_handler.cpp
│ │ ├── dji_motor_terminal_serial_handler.hpp // Displays motor information to terminal
│ │ ├── dji_motor_tx_handler.cpp
│ │ ├── dji_motor_tx_handler.hpp // Handles sending motor request to DJI motors
│ │ ├── double_dji_motor.cpp
│ │ ├── double_dji_motor.hpp // Encapsulates two DJI motors that are connected to a single shaft so they are a single control unit
│ │ ├── m3508_constants.hpp
│ │ ├── motor_constants.hpp // Generic interface for various DJI motor constants
│ │ ├── motor_interface.hpp
│ │ ├── motorsim // Simulation-based motor control
│ │ │ ├── can_serializer.cpp
│ │ │ ├── can_serializer.hpp
│ │ │ ├── dji_motor_sim_handler.cpp
│ │ │ ├── dji_motor_sim_handler.hpp
│ │ │ ├── motor_sim.cpp
│ │ │ └── motor_sim.hpp
│ │ ├── servo.cpp // Driver for PWM-controlled servo
│ │ └── servo.hpp
│ ├── storage
│ │ ├── littlefs-internal // Driver for interacting with LittleFS file system
│ │ │ ├── littlefs_internal.cpp
│ │ │ ├── littlefs_internal.hpp
│ │ │ └── module.lb
│ │ └── module.lb
│ └── util_macros.hpp // Build macros
├── supported-devices // Each XML file is associated with a supported device. Each XML file contains hardware specifics that are used during code generation
│ ├── rm-dev-board-a.xml
│ └── rm-dev-board-c.xml
├── taproot-scripts // A repository that contains scripts that are critical for continuous integration
├── test // Directory structure that mostly mirrors the src directory and contains Google tests for the majority of all drivers and HALs
│ ├── module.lb
│ └── tap
│ ├── algorithms
│ │ ├── ballistics_tests.cpp
│ │ ├── cmsis_mat_tests.cpp
│ │ ├── contiguous_float_tests.cpp
│ │ ├── linear_interpolation_predictor_contiguous_tests.cpp
│ │ ├── linear_interpolation_predictor_tests.cpp
│ │ └── math_user_utils_tests.cpp
│ ├── architecture
│ │ ├── endian_wrappers_test.cpp
│ │ └── profiler_tests.cpp
│ ├── communication
│ │ ├── can
│ │ │ └── can_rx_handler_tests.cpp
│ │ ├── sensors
│ │ │ ├── imu
│ │ │ │ ├── bmi088
│ │ │ │ │ └── bmi088_tests.cpp
│ │ │ │ └── imu_terminal_serial_handler_tests.cpp
│ │ │ └── imu_heater
│ │ │ └── imu_heater_tests.cpp
│ │ ├── serial
│ │ │ ├── dji_serial_tests.cpp
│ │ │ ├── ref_serial_tests.cpp
│ │ │ ├── ref_serial_transmitter_tests.cpp
│ │ │ ├── remote_tests.cpp
│ │ │ ├── terminal_device_stub_tests.cpp
│ │ │ └── terminal_serial_tests.cpp
│ │ └── tcp-server
│ │ ├── json_generation_tests.cpp
│ │ ├── tcp_server_tests.cpp
│ │ ├── tcp_test_client.cpp
│ │ └── tcp_test_client.hpp
│ ├── control
│ │ ├── command_mapper_format_generator_tests.cpp
│ │ ├── command_mapper_tests.cpp
│ │ ├── command_scheduler_tests.cpp
│ │ ├── governor
│ │ │ └── command_governor_limited_command_tests.cpp
│ │ ├── hold_command_mapping_tests.cpp
│ │ ├── hold_repeat_command_mapping_tests.cpp
│ │ ├── press_command_mapping_tests.cpp
│ │ ├── remote_map_state_tests.cpp
│ │ ├── scheduler_terminal_handler_tests.cpp
│ │ ├── setpoint
│ │ │ ├── algorithms
│ │ │ │ └── setpoint_continuous_jam_checker_tests.cpp
│ │ │ └── commands
│ │ │ ├── calibrate_command_tests.cpp
│ │ │ ├── move_absolute_command_tests.cpp
│ │ │ ├── move_command_tests.cpp
│ │ │ ├── move_integral_command_tests.cpp
│ │ │ ├── move_unjam_comprised_command_tests.cpp
│ │ │ ├── move_unjam_integral_comprised_command_tests.cpp
│ │ │ ├── unjam_command_tests.cpp
│ │ │ └── unjam_integral_command_tests.cpp
│ │ ├── test_command.hpp
│ │ ├── test_subsystem.hpp
│ │ └── toggle_command_mapping_tests.cpp
│ ├── display
│ │ └── vertical_scroll_logic_handler_tests.cpp
│ ├── errors
│ │ └── error_controller_tests.cpp
│ ├── mock // GoogleMock mocks used during taproot testing and also generated for users to use during their testing
│ │ ├── analog_mock.cpp
│ │ ├── analog_mock.hpp
│ │ ├── bmi088_mock.cpp
│ │ ├── bmi088_mock.hpp
│ │ ├── can_mock.cpp
│ │ ├── can_mock.hpp
│ │ ├── can_rx_handler_mock.cpp
│ │ ├── can_rx_handler_mock.hpp
│ │ ├── can_rx_listener_mock.cpp
│ │ ├── can_rx_listener_mock.hpp
│ │ ├── command_governor_interface_mock.cpp
│ │ ├── command_governor_interface_mock.hpp
│ │ ├── command_mapper_mock.cpp
│ │ ├── command_mapper_mock.hpp
│ │ ├── command_mock.cpp
│ │ ├── command_mock.hpp
│ │ ├── command_scheduler_mock.cpp
│ │ ├── command_scheduler_mock.hpp
│ │ ├── digital_mock.cpp
│ │ ├── digital_mock.hpp
│ │ ├── dji_motor_mock.cpp
│ │ ├── dji_motor_mock.hpp
│ │ ├── dji_motor_terminal_serial_handler_mock.cpp
│ │ ├── dji_motor_terminal_serial_handler_mock.hpp
│ │ ├── dji_motor_tx_handler_mock.cpp
│ │ ├── dji_motor_tx_handler_mock.hpp
│ │ ├── error_controller_mock.cpp
│ │ ├── error_controller_mock.hpp
│ │ ├── hold_repeat_command_mapping_mock.cpp
│ │ ├── hold_repeat_command_mapping_mock.hpp
│ │ ├── imu_interface_mock.cpp
│ │ ├── imu_interface_mock.hpp
│ │ ├── imu_terminal_serial_handler_mock.cpp
│ │ ├── imu_terminal_serial_handler_mock.hpp
│ │ ├── integrable_setpoint_subsystem_mock.cpp
│ │ ├── integrable_setpoint_subsystem_mock.hpp
│ │ ├── leds_mock.cpp
│ │ ├── leds_mock.hpp
│ │ ├── motor_interface_mock.cpp
│ │ ├── motor_interface_mock.hpp
│ │ ├── move_integral_command_mock.cpp
│ │ ├── move_integral_command_mock.hpp
│ │ ├── mpu6500_mock.cpp
│ │ ├── mpu6500_mock.hpp
│ │ ├── odometry_2d_interface_mock.hpp
│ │ ├── pwm_mock.cpp
│ │ ├── pwm_mock.hpp
│ │ ├── ref_serial_mock.cpp
│ │ ├── ref_serial_mock.hpp
│ │ ├── ref_serial_transmitter_mock.cpp
│ │ ├── ref_serial_transmitter_mock.hpp
│ │ ├── remote_mock.cpp
│ │ ├── remote_mock.hpp
│ │ ├── robot_to_robot_message_handler_mock.cpp
│ │ ├── robot_to_robot_message_handler_mock.hpp
│ │ ├── scheduler_terminal_handler_mock.cpp
│ │ ├── scheduler_terminal_handler_mock.hpp
│ │ ├── setpoint_subsystem_mock.cpp
│ │ ├── setpoint_subsystem_mock.hpp
│ │ ├── subsystem_mock.cpp
│ │ ├── subsystem_mock.hpp
│ │ ├── terminal_serial_callback_interface_mock.cpp
│ │ ├── terminal_serial_callback_interface_mock.hpp
│ │ ├── terminal_serial_mock.cpp
│ │ ├── terminal_serial_mock.hpp
│ │ ├── uart_mock.cpp
│ │ ├── uart_mock.hpp
│ │ ├── unjam_integral_command_mock.cpp
│ │ └── unjam_integral_command_mock.hpp
│ ├── motor
│ │ ├── dji_motor_terminal_serial_handler_tests.cpp
│ │ ├── dji_motor_tests.cpp
│ │ ├── dji_motor_tx_handler_tests.cpp
│ │ ├── double_dji_motor_tests.cpp
│ │ └── motorsim
│ │ ├── dji_motor_sim_handler_tests.cpp
│ │ └── motor_sim_tests.cpp
│ └── stub
│ ├── terminal_device_stub.cpp
│ └── terminal_device_stub.hpp
└── test-project // A simple taproot project that is used by taproot developers to test features on hardware without integrating into a child repository.
├── build_tools
│ ├── __init__.py
│ └── parse_args.py
├── clean_test_project.sh
├── Pipfile
├── project.xml
├── SConstruct
└── src
└── main.cpp