CMake - Primary build system for IDE integration (CLion, VS Code) and project management
PlatformIO - Arduino firmware building and library management
Unity - Unit testing framework for native development

Key Benefits

CLion Tier 1 Support - Full CMake integration for the best IDE experience
Cross-platform compatibility - Works on macOS, Linux, and Windows
Multiple build configurations - Presets for different use cases
Modern C++ standards - C++17 support with proper toolchain
Maintainable architecture - Standard CMake practices

📋 Prerequisites

Required

CMake 3.20+ - Modern build system
Make - Build tool (usually comes with CMake)
C++17 compatible compiler - For native builds and testing
PlatformIO - For Arduino development

Optional

SimulIDE - For simulation testing
clang-format - For code formatting

Installation

macOS

# Install CMake
brew install cmake

# Install PlatformIO
pip install platformio

# Install SimulIDE (optional)
brew install --cask simulide

# Install clang-format (optional)
brew install clang-format

Ubuntu/Debian

# Install CMake and build tools
sudo apt update
sudo apt install cmake build-essential

# Install PlatformIO
pip install platformio

# Install SimulIDE (optional)
sudo apt install simulide

# Install clang-format (optional)
sudo apt install clang-format

Windows

Download and install CMake
Install PlatformIO: pip install platformio
Download and install SimulIDE (optional)

🚀 Quick Start

1. Clone and Navigate

git clone <your-repo-url>
cd RocketLauncher

2. Build Everything

# Using the build script (recommended)
./scripts/build.sh

# Or using CMake directly
cmake --preset default
cmake --build --preset default

3. Run Tests

./scripts/build.sh test

🛠️ Build Commands

Using the Build Script (Recommended)

The scripts/build.sh script provides a familiar interface:

# Full build (configure + build + test)
./scripts/build.sh

# Configure only
./scripts/build.sh configure

# Build only (assumes already configured)
./scripts/build.sh build

# Run tests
./scripts/build.sh test

# Clean build files
./scripts/build.sh clean

# Build specific firmware
./scripts/build.sh firmware-sim    # Simulation firmware
./scripts/build.sh firmware-hw     # Hardware firmware
./scripts/build.sh all-firmware    # Both firmwares

# Arduino operations
./scripts/build.sh upload          # Upload to Arduino
./scripts/build.sh monitor         # Start serial monitor

# Utilities
./scripts/build.sh format          # Format source code
./scripts/build.sh status          # Show project status
./scripts/build.sh help            # Get help

Using CMake Directly

# Configure with default preset
cmake --preset default

# Build with default preset
cmake --build --preset default

# Run tests
ctest --preset default

# Build specific targets
cmake --build . --target firmware_sim
cmake --build . --target firmware_hw
cmake --build . --target rocket_tests

⚙️ Build Presets

The project includes several pre-configured build presets:

Preset	Description	Tests	PlatformIO	Optimization
`default`	Full development build	✅	✅	Debug
`release`	Production build	❌	✅	Release
`tests-only`	Unit tests only	✅	❌	Debug
`minimal`	Minimal build	❌	❌	Debug

Using Presets

# Configure with specific preset
cmake --preset release

# Build with specific preset
cmake --build --preset tests-only

# Using build script with preset
./scripts/build.sh --preset release

📁 Project Structure

RocketLauncher/
├── CMakeLists.txt              # Main CMake configuration
├── CMakePresets.json           # Build presets for CLion
├── platformio.ini              # PlatformIO configuration
├── cmake/                      # CMake modules
│   └── FindUnity.cmake        # Unity test framework finder
├── lib/Unity/                  # Unity test framework
│   ├── unity.h                 # Test framework header
│   └── unity.cpp               # Test framework implementation
├── scripts/                    # Build helper scripts
│   └── build.sh                # Main build script
├── src/                        # Source code
│   ├── main.cpp                # Arduino main program
│   ├── RocketController.cpp    # Rocket control logic
│   ├── RocketController.h      # Rocket control interface
│   └── ArduinoInterface.h      # Arduino abstraction
├── test/                       # Unit tests
│   └── test_rocket_controller.cpp
├── lib/                        # External libraries
├── include/                    # Header files
└── .vscode/                    # VS Code configuration
    └── settings.json          # Editor settings

🔧 Configuration

Environment Variables

ARDUINO_HOME - Path to Arduino installation (optional, auto-detected)

CMake Options

# Configure with custom options
cmake -DBUILD_TESTS=OFF -DPLATFORMIO_INTEGRATION=OFF ..

# Available options:
# BUILD_TESTS          - Enable/disable unit tests (default: ON)
# PLATFORMIO_INTEGRATION - Enable/disable PlatformIO integration (default: ON)
# ENABLE_FORMATTING    - Enable/disable code formatting (default: ON)

🧪 Testing

Running Tests

# Run all tests
./scripts/build.sh test

# Run tests with verbose output
ctest --preset default --output-on-failure

# Run specific test
ctest --preset default -R RocketControllerTests

Test Framework

The project uses the Unity test framework for unit testing. Tests are automatically discovered and run during the build process.

📱 Arduino Development

Building Firmware

# Build for Arduino Uno
./scripts/build.sh firmware-hw

# Build for simulation
./scripts/build.sh firmware-sim

# Build both
./scripts/build.sh all-firmware

Uploading to Arduino

# Upload hardware firmware (requires Arduino connection)
./scripts/build.sh upload

Note: Upload functionality requires proper Arduino connection and may need configuration for your specific setup.

Arduino Libraries

The project automatically includes these Arduino libraries via PlatformIO:

LiquidCrystal - LCD display support
Bounce2 - Button debouncing

🎮 Simulation

SimulIDE Integration

The simulation build creates firmware compatible with SimulIDE:

Build simulation firmware: ./scripts/build.sh firmware-sim
Open SimulIDE
Load your simulation file (.sim1)
Firmware will auto-load from the PlatformIO build output

🚀 Migration from Makefile

Old Makefile Commands → New CMake Commands

Old Makefile	New CMake	Description
`make all`	`./scripts/build.sh`	Full build
`make build-only`	`./scripts/build.sh build`	Build only
`make test`	`./scripts/build.sh test`	Run tests
`make clean`	`./scripts/build.sh clean`	Clean build
`make build-sim`	`./scripts/build.sh firmware-sim`	Simulation build
`make build-hw`	`./scripts/build.sh firmware-hw`	Hardware build
`make upload`	`./scripts/build.sh upload`	Upload to Arduino
`make format`	`./scripts/build.sh format`	Format code
`make status`	`./scripts/build.sh status`	Show status

Key Benefits of CMake

Cross-platform: Works on macOS, Linux, and Windows
IDE integration: Better support in CLion, VS Code, etc.
Presets: Multiple build configurations without reconfiguration
Modular: Reusable build components
Standards: Follows modern C++ build practices
Maintainable: Easier to extend and modify

🐛 Troubleshooting

Common Issues

CMake not found

# Install CMake
# macOS
brew install cmake

# Ubuntu
sudo apt install cmake

# Windows
# Download from cmake.org

PlatformIO not found

# Install PlatformIO
pip install platformio

Build failures

# Clean and rebuild
./scripts/build.sh clean
./scripts/build.sh

# Check dependencies
./scripts/build.sh status

Getting Help

Check the project status: ./scripts/build.sh status
Verify dependencies are installed
Check build logs in the build directory
Ensure you're using CMake 3.20+

🤝 Contributing

Fork the repository
Create a feature branch
Make your changes
Test with: ./scripts/build.sh test
Submit a pull request

📄 License

[Your License Here]

🙏 Acknowledgments

Luke - Original rocket launcher design
Arduino community - Hardware platform
PlatformIO community - Arduino development tools
CMake community - Build system
Unity framework - Testing framework