WPILib

https://github.com/wpilibsuite/allwpilib
Admin
WPILib is a comprehensive robotics library that provides core functionality for FIRST Robotics teams...
Tokens:96,462
Snippets:672
Trust Score:9.7
Update:7 months ago
Show doc for...
Tokens:
Raw
### Example build.gradle for Development Build (C++)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/DevelopmentBuilds.md

An example of a complete build.gradle file for a C++ project configured to use a development build of WPILib. It includes the necessary plugins and the development build configuration.

```groovy
plugins {
  id "cpp"
  id "google-test-test-suite"
  id "edu.wpi.first.GradleRIO" version "2026.1.1"
}

wpi.maven.useLocal = false
wpi.maven.useDevelopment = true
wpi.versions.wpilibVersion = '2026.+'
wpi.versions.wpimathVersion = '2026.+'
```

--------------------------------

### Example build.gradle for Local Build (C++)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/DevelopmentBuilds.md

An example of a complete build.gradle file for a C++ project configured to use a local build of WPILib. It includes the necessary plugins and the local build configuration.

```groovy
plugins {
  id "cpp"
  id "google-test-test-suite"
  id "edu.wpi.first.GradleRIO" version "2026.1.1"
}

wpi.maven.useLocal = false
wpi.maven.useFrcMavenLocalDevelopment = true
wpi.versions.wpilibVersion = 'YEAR.424242.+'
wpi.versions.wpimathVersion = 'YEAR.424242.+'
```

--------------------------------

### Example build.gradle for Local Build (Java)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/DevelopmentBuilds.md

An example of a complete build.gradle file for a Java project configured to use a local build of WPILib. It includes the necessary plugins and the local build configuration.

```groovy
plugins {
  id "java"
  id "edu.wpi.first.GradleRIO" version "2026.1.1"
}

wpi.maven.useLocal = false
wpi.maven.useFrcMavenLocalDevelopment = true
wpi.versions.wpilibVersion = 'YEAR.424242.+'
wpi.versions.wpimathVersion = 'YEAR.424242.+'
```

--------------------------------

### Example build.gradle for Development Build (Java)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/DevelopmentBuilds.md

An example of a complete build.gradle file for a Java project configured to use a development build of WPILib. It includes the necessary plugins and the development build configuration.

```groovy
plugins {
  id "java"
  id "edu.wpi.first.GradleRIO" version "2026.1.1"
}

wpi.maven.useLocal = false
wpi.maven.useDevelopment = true
wpi.versions.wpilibVersion = '2026.+'
wpi.versions.wpimathVersion = '2026.+'
```

--------------------------------

### Compile WPILibJava Examples with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This command compiles the Java examples for the desktop target. The compiled results cannot be run directly but serve to verify the compilation process.

```bash
./gradlew buildDesktopJava
```

--------------------------------

### Compile WPILibC++ Examples with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This command compiles the C++ examples for the desktop target. The compiled results cannot be run directly but serve to verify the compilation process.

```bash
./gradlew buildDesktopCpp
```

--------------------------------

### Build MultiCameraServer Example Executable

Source: https://github.com/wpilibsuite/allwpilib/blob/main/cameraserver/CMakeLists.txt

This CMake code builds the MultiCameraServer example executable. It compiles the C++ sources for the example and links it against the previously built cameraserver library.

```cmake
file(GLOB multiCameraServer_src multiCameraServer/src/main/native/cpp/*.cpp)
add_executable(multiCameraServer ${multiCameraServer_src})
wpilib_target_warnings(multiCameraServer)
target_link_libraries(multiCameraServer cameraserver)

set_property(TARGET multiCameraServer PROPERTY FOLDER "examples")
```

--------------------------------

### Building wpiutil Examples (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/CMakeLists.txt

This CMake code iterates through example directories, compiles each C++ example into a separate executable, and links them against the wpiutil library. Examples are organized under an 'examples' folder in the build output.

```cmake
subdir_list(wpiutil_examples "${CMAKE_CURRENT_SOURCE_DIR}/examples")
foreach(example ${wpiutil_examples})
    file(GLOB wpiutil_example_src examples/${example}/*.cpp)
    if(wpiutil_example_src)
        add_executable(wpiutil_${example} ${wpiutil_example_src})
        wpilib_target_warnings(wpiutil_${example})
        target_link_libraries(wpiutil_${example} wpiutil)
        set_property(TARGET wpiutil_${example} PROPERTY FOLDER "examples")
    endif()
endforeach()
```

--------------------------------

### Install WPILib Libraries

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README-CMake.md

This command installs the built WPILib libraries to a location where they can be used by external CMake projects. This is typically done after a successful build.

```bash
sudo cmake --build . --target install
```

--------------------------------

### Build wpinet Example Executables (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpinet/CMakeLists.txt

This CMake script iterates through example directories, finds C++ source files, and creates executable targets for each example. It links these examples against the 'wpinet' library and applies common warnings.

```cmake
subdir_list(wpinet_examples "${CMAKE_CURRENT_SOURCE_DIR}/examples")
foreach(example ${wpinet_examples})
    file(GLOB wpinet_example_src examples/${example}/*.cpp)
    if(wpinet_example_src)
        add_executable(wpinet_${example} ${wpinet_example_src})
        wpilib_target_warnings(wpinet_${example})
        target_link_libraries(wpinet_${example} wpinet)
        set_property(TARGET wpinet_${example} PROPERTY FOLDER "examples")
    endif()
endforeach()
```

--------------------------------

### Install and Include Third-Party Headers for WPILib Math

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpimath/CMakeLists.txt

This section details the installation of header files for third-party libraries like gcem and sleipnir into the wpimath include directory. It also configures the include paths for the wpimath target, making these headers accessible during build and installation.

```cmake
install(
    DIRECTORY src/main/native/thirdparty/gcem/include/ src/main/native/thirdparty/sleipnir/include/
    DESTINATION "${include_dest}/wpimath"
)
target_include_directories(
    wpimath
    SYSTEM
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/gcem/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/sleipnir/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/sleipnir/src>
)
```

--------------------------------

### Bit-Field Packing Example 3

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Illustrates bit-field packing where bit-fields of the same int8 type are packed together, and a subsequent int16 starts a new type.

```C++
uint8 a:4;
int8 b:2;
bool c:1;
int16 d:1;

```

--------------------------------

### Bit-Field Packing Example 2

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Shows bit-field packing where a boolean bit-field is packed into a preceding int16, and a subsequent int16 starts a new type due to size.

```C++
int16 a:4;
uint16 b:5;
bool c:1;
int16 d:7;

```

--------------------------------

### Install and Export googletest Library (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/thirdparty/googletest/CMakeLists.txt

This CMake snippet handles the installation and export of the googletest library. It installs the target and exports it for use in other projects, creating a CMake configuration file.

```cmake
install(TARGETS googletest EXPORT googletest)
export(TARGETS googletest FILE googletest.cmake NAMESPACE googletest::)
```

--------------------------------

### Install Benchmark Include Directories

Source: https://github.com/wpilibsuite/allwpilib/blob/main/benchmark/CMakeLists.txt

This CMake snippet defines the installation rules for the benchmark header files, placing them in a 'benchmark' subdirectory within the main include destination. It also sets up system include directories for the benchmark source and include paths, ensuring they are correctly found during the build process.

```cmake
install(
    DIRECTORY src/main/native/thirdparty/benchmark/include/
    DESTINATION "${include_dest}/benchmark"
)
target_include_directories(
    benchmarkCpp
    SYSTEM
    PRIVATE
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/benchmark/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/benchmark/src>
)
```

--------------------------------

### Installing wpiutil Headers and Library (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/CMakeLists.txt

This CMake code defines the installation rules for the wpiutil library, including its header files from various directories and the compiled library target. It also sets up CMake export files for consumers.

```cmake
install(
    DIRECTORY
        src/main/native/include/
        src/main/native/thirdparty/argparse/include/
        src/main/native/thirdparty/debugging/include/
        src/main/native/thirdparty/expected/include/
        src/main/native/thirdparty/json/include/
        src/main/native/thirdparty/llvm/include/
        src/main/native/thirdparty/mpack/include/
        src/main/native/thirdparty/nanopb/include/
        src/main/native/thirdparty/sigslot/include/
    DESTINATION "${include_dest}/wpiutil"
)
target_include_directories(
    wpiutil
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/argparse/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/debugging/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/expected/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/json/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/llvm/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/mpack/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/nanopb/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/sigslot/include>
        $<INSTALL_INTERFACE:${include_dest}/wpiutil>
)

install(TARGETS wpiutil EXPORT wpiutil)
export(TARGETS wpiutil FILE wpiutil.cmake NAMESPACE wpiutil::)

configure_file(wpiutil-config.cmake.in ${WPILIB_BINARY_DIR}/wpiutil-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/wpiutil-config.cmake DESTINATION share/wpiutil)
install(EXPORT wpiutil DESTINATION share/wpiutil)
```

--------------------------------

### Basic Data Layout Example

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Demonstrates the byte encoding of simple data types (boolean and int16) stored consecutively without padding.

```C++
bool b;
int16 i;

```

--------------------------------

### Install WPILib Math Library Headers and Target

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpimath/CMakeLists.txt

This snippet focuses on installing the generated and main native header files for the wpimath library. It configures the public include directories for the wpimath target, ensuring that both build-time and install-time headers are correctly referenced.

```cmake
install(
    DIRECTORY src/generated/main/native/cpp/
    DESTINATION "${include_dest}/wpimath"
    FILES_MATCHING
    PATTERN "*.h"
)
install(DIRECTORY src/main/native/include/ DESTINATION "${include_dest}/wpimath")
target_include_directories(
    wpimath
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/generated/main/native/cpp>
        $<INSTALL_INTERFACE:${include_dest}/wpimath>
)
```

--------------------------------

### Install GLFW Targets

Source: https://github.com/wpilibsuite/allwpilib/blob/main/thirdparty/imgui_suite/glfw/src/CMakeLists.txt

This code block defines the installation rules for the GLFW library targets. It specifies the destinations for runtime files, archives, and libraries based on the build configuration and installation prefix.

```cmake
if (GLFW_INSTALL)
    install(TARGETS glfw
            EXPORT glfwTargets
            RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
            ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
            LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
endif()
```

--------------------------------

### Array Data Layout Example

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Shows the byte encoding for an array of int16, where elements are stored consecutively without padding.

```C++
int16 i[2];

```

--------------------------------

### Bit-Field Packing Example 1

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Demonstrates bit-field packing where adjacent bit-fields of different integer types are packed into separate underlying types.

```C++
int8 a:4;
int16 b:4;

```

--------------------------------

### Install wpinet Headers and Libraries (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpinet/CMakeLists.txt

This CMake code block handles the installation of the 'wpinet' library's header files and the library itself. It specifies destination directories for headers and exports the target for use in other projects.

```cmake
install(
    DIRECTORY src/main/native/include/ src/main/native/thirdparty/tcpsockets/include/ 
    DESTINATION "${include_dest}/wpinet"
)
target_include_directories(
    wpinet
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/thirdparty/tcpsockets/include>
        $<INSTALL_INTERFACE:${include_dest}/wpinet>
)

install(TARGETS wpinet EXPORT wpinet)
export(TARGETS wpinet FILE wpinet.cmake NAMESPACE wpinet::)

configure_file(wpinet-config.cmake.in ${WPILIB_BINARY_DIR}/wpinet-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/wpinet-config.cmake DESTINATION share/wpinet)
install(EXPORT wpinet DESTINATION share/wpinet)
```

--------------------------------

### Export and Install WPILib Math Target and Configuration

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpimath/CMakeLists.txt

This code block handles the installation and export of the wpimath target. It creates a CMake configuration file (wpimath-config.cmake) and exports the target for use by other projects, ensuring proper integration within the build system.

```cmake
install(TARGETS wpimath EXPORT wpimath)
export(TARGETS wpimath FILE wpimath.cmake NAMESPACE wpimath::)

configure_file(wpimath-config.cmake.in ${WPILIB_BINARY_DIR}/wpimath-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/wpimath-config.cmake DESTINATION share/wpimath)
install(EXPORT wpimath DESTINATION share/wpimath)
```

--------------------------------

### Bit-Field Packing Example 5 (Different Underlying Type)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Demonstrates bit-field packing where boolean bit-fields are packed into separate int16 types.

```C++
bool a:1;
bool b:1;
int16 c:2;

```

--------------------------------

### Create and Install wpiunits Java Source JAR

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiunits/CMakeLists.txt

This CMake snippet handles the creation and installation of a source JAR for the wpiunits Java library. It requires the UseJava and CreateSourceJar CMake modules. The function `add_source_jar` is used to bundle the source files, which are then installed to the specified destination.

```cmake
if(WITH_JAVA_SOURCE)
    include(UseJava)
    include(CreateSourceJar)
    add_source_jar(
        wpiunits_src_jar
        BASE_DIRECTORIES
            ${CMAKE_CURRENT_SOURCE_DIR}/src/main/java
            ${CMAKE_CURRENT_SOURCE_DIR}/src/generated/main/java
        OUTPUT_NAME wpiunits-sources
    )
    set_property(TARGET wpiunits_src_jar PROPERTY FOLDER "java")

    install_jar(wpiunits_src_jar DESTINATION ${java_lib_dest})
endif()
```

--------------------------------

### Build Specific WPILib Subproject with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

To build a specific subproject, such as WPILibC, use the Gradle wrapper with the subproject name and task. For example, to build only WPILibC, use ':wpilibc:build'. All commands must be run from the root directory.

```bash
./gradlew :wpilibc:build
```

--------------------------------

### Create and Install Java Source JAR for WPILib Annotations

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiannotations/CMakeLists.txt

This CMake snippet handles the creation and installation of a source JAR for the WPILib annotations project. It utilizes the 'CreateSourceJar' module to bundle the Java source files. The resulting JAR is installed to the specified destination. This is conditional on WITH_JAVA_SOURCE being enabled.

```cmake
if(WITH_JAVA_SOURCE)
    include(UseJava)
    include(CreateSourceJar)
    add_source_jar(
        wpiannotations_src_jar
        BASE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/src/main/java
        OUTPUT_NAME wpiannotations-sources
    )
    set_property(TARGET wpiannotations_src_jar PROPERTY FOLDER "java")

    install_jar(wpiannotations_src_jar DESTINATION ${java_lib_dest})
endif()
```

--------------------------------

### Character Array (String) Data Layout Example (Short String)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Shows the byte encoding of a fixed-length character array containing a string shorter than its capacity, with padding.

```C++
char s[4];

```

--------------------------------

### Nested Structure Data Layout Example

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Illustrates the byte encoding of a nested structure, showing that no padding is added around the nested structure.

```C++
int16 i;
int8 x;

```

```C++
char c;
Inner s;
bool b;

```

--------------------------------

### Configure and Install XRP Vendordep CMake Package

Source: https://github.com/wpilibsuite/allwpilib/blob/main/xrpVendordep/CMakeLists.txt

This snippet configures the `xrpvendordep-config.cmake` file and installs it along with the exported targets. This allows other CMake projects to find and use the XRP Vendordep library.

```cmake
configure_file(xrpvendordep-config.cmake.in ${WPILIB_BINARY_DIR}/xrpvendordep-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/xrpvendordep-config.cmake DESTINATION share/xrpVendordep)
install(EXPORT xrpvendordep DESTINATION share/xrpVendordep)
```

--------------------------------

### Native Artifact Examples

Source: https://github.com/wpilibsuite/allwpilib/blob/main/MavenArtifacts.md

These examples illustrate Maven artifact coordinates for native libraries. They include the base artifact name, version, platform-specific classifiers (e.g., 'windowsx86-64staticdebug'), and the artifact type ('@zip'). Native artifacts often use '-cpp' in their artifactId.

```text
edu.wpi.first.wpimath:wpimath-cpp:version:classifier@zip
```

```text
edu.wpi.first.wpimath:wpimath-cpp:version:windowsx86-64staticdebug@zip
```

--------------------------------

### Install GLFW Headers and CMake Configuration

Source: https://github.com/wpilibsuite/allwpilib/blob/main/thirdparty/imgui_suite/glfw/CMakeLists.txt

Installs GLFW header files and CMake configuration files. This ensures that other projects can find and use the GLFW library. It targets specific header files and CMake scripts for proper integration.

```cmake
if (GLFW_INSTALL)
    install(DIRECTORY include/GLFW DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
            FILES_MATCHING PATTERN glfw3.h PATTERN glfw3native.h)

    install(FILES "${GLFW_BINARY_DIR}/src/glfw3Config.cmake"
                  "${GLFW_BINARY_DIR}/src/glfw3ConfigVersion.cmake"
            DESTINATION "${GLFW_CONFIG_PATH}")

    install(EXPORT glfwTargets FILE glfw3Targets.cmake
            EXPORT_LINK_INTERFACE_LIBRARIES
            DESTINATION "${GLFW_CONFIG_PATH}")
    install(FILES "${GLFW_BINARY_DIR}/src/glfw3.pc"
            DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")

    if (DOXYGEN_FOUND AND GLFW_BUILD_DOCS)
        install(DIRECTORY "${GLFW_BINARY_DIR}/docs/html"
                DESTINATION "${CMAKE_INSTALL_DOCDIR}")
    endif()

    # Only generate this target if no higher-level project already has
    if (NOT TARGET uninstall)
        configure_file(CMake/cmake_uninstall.cmake.in
                       cmake_uninstall.cmake IMMEDIATE @ONLY)

        add_custom_target(uninstall
                          "${CMAKE_COMMAND}" -P
                          "${GLFW_BINARY_DIR}/cmake_uninstall.cmake")
        set_target_properties(uninstall PROPERTIES FOLDER "GLFW3")
    endif()
endif()
```

--------------------------------

### Configure Development Build in Gradle (Java/C++)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/DevelopmentBuilds.md

This configuration snippet is added to the build.gradle file to enable the use of per-commit development builds from Artifactory. It sets flags to use development builds and specifies the WPILib and WPIMath versions to use. Ensure the YEAR is replaced with the appropriate development version year.

```groovy
wpi.maven.useLocal = false
wpi.maven.useDevelopment = true
wpi.versions.wpilibVersion = 'YEAR.+'
wpi.versions.wpimathVersion = 'YEAR.+'
```

--------------------------------

### Configure Java Camera Server JAR

Source: https://github.com/wpilibsuite/allwpilib/blob/main/cameraserver/CMakeLists.txt

This snippet configures the build process for the Java Camera Server JAR. It finds the OpenCV Java library, collects Java sources, and creates a JAR file including necessary WPILib dependencies. The JAR is then installed for use.

```cmake
project(cameraserver)

include(CompileWarnings)
include(AddTest)

# Java bindings
if(WITH_JAVA)
    include(UseJava)

    #find JAR file, copy it locally
    set(OPENCV_JAVA_INSTALL_DIR ${OpenCV_INSTALL_PATH}/share/java/opencv4)

    find_file(
        OPENCV_JAR_FILE
        NAMES opencv-${OpenCV_VERSION_MAJOR}${OpenCV_VERSION_MINOR}${OpenCV_VERSION_PATCH}.jar
        PATHS
            ${OPENCV_JAVA_INSTALL_DIR}
            ${OpenCV_INSTALL_PATH}/bin
            ${OpenCV_INSTALL_PATH}/share/java
            ${OpenCV_INSTALL_PATH}/share/OpenCV/java
        NO_DEFAULT_PATH
    )

    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java)

    add_jar(
        cameraserver_jar
        ${JAVA_SOURCES}
        INCLUDE_JARS wpiutil_jar cscore_jar ntcore_jar ${OPENCV_JAR_FILE}
        OUTPUT_NAME cameraserver
        OUTPUT_DIR ${WPILIB_BINARY_DIR}/${java_lib_dest}
    )
    set_property(TARGET cameraserver_jar PROPERTY FOLDER "java")

    install_jar(cameraserver_jar DESTINATION ${java_lib_dest})
    install_jar_exports(
        TARGETS cameraserver_jar
        FILE cameraserver_jar.cmake
        DESTINATION share/cameraserver
    )
endif()
```

--------------------------------

### Configure Native C++ Library (ntcore)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/ntcore/CMakeLists.txt

This snippet configures the native C++ library 'ntcore'. It includes source files, sets target properties like debug postfix, defines include directories for build and installation, applies compiler warnings, sets the C++ standard to C++20, and links against necessary libraries (wpinet, wpiutil). Finally, it installs the library and exports its targets.

```cmake
project(ntcore)

include(CompileWarnings)
include(AddTest)

file(
    GLOB ntcore_native_src
    src/main/native/cpp/*.cpp
    src/generated/main/native/cpp/*.cpp
    src/main/native/cpp/local/*.cpp
    src/main/native/cpp/net/*.cpp
    src/main/native/cpp/net3/*.cpp
    src/main/native/cpp/networktables/*.cpp
    src/main/native/cpp/server/*.cpp
    src/main/native/cpp/tables/*.cpp
)
add_library(ntcore ${ntcore_native_src})
set_target_properties(ntcore PROPERTIES DEBUG_POSTFIX "d")
target_include_directories(
    ntcore
    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/cpp
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/generated/main/native/include>
        $<INSTALL_INTERFACE:${include_dest}/ntcore>
)
wpilib_target_warnings(ntcore)
target_compile_features(ntcore PUBLIC cxx_std_20)
target_link_libraries(ntcore PUBLIC wpinet wpiutil)

set_property(TARGET ntcore PROPERTY FOLDER "libraries")

install(TARGETS ntcore EXPORT ntcore)
export(TARGETS ntcore FILE ntcore.cmake NAMESPACE ntcore::)
install(DIRECTORY src/main/native/include/ DESTINATION "${include_dest}/ntcore")
install(DIRECTORY src/generated/main/native/include/ DESTINATION "${include_dest}/ntcore")

configure_file(ntcore-config.cmake.in ${WPILIB_BINARY_DIR}/ntcore-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/ntcore-config.cmake DESTINATION share/ntcore)
install(EXPORT ntcore DESTINATION share/ntcore)
```

--------------------------------

### Bit-Field Declaration Examples

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiutil/doc/struct.adoc

Illustrates valid and invalid declarations for bit-fields, specifying rules for integer types, boolean types, array types, and size constraints.

```C++
bool value : 1
enum{a=1,b=2}int8 value:2

```

```C++
double val:2
int32 val[2]:2
bool val:3
int16 val:17

```

--------------------------------

### Build netconsoleTee Executable (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpinet/CMakeLists.txt

This CMake snippet defines and builds the 'netconsoleTee' executable. It collects C++ source files from its directory, links against the 'wpinet' library, and applies standard warnings. The executable is categorized under 'examples'.

```cmake
file(GLOB netconsoleTee_src src/netconsoleTee/native/cpp/*.cpp)
add_executable(netconsoleTee ${netconsoleTee_src})
wpilib_target_warnings(netconsoleTee)
target_link_libraries(netconsoleTee wpinet)

set_property(TARGET netconsoleTee PROPERTY FOLDER "examples")
```

--------------------------------

### Configure Local Build in Gradle (Java/C++)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/DevelopmentBuilds.md

This configuration snippet is added to the build.gradle file to enable the use of a locally built version of WPILib. It sets flags to use the local development build and specifies the WPILib and WPIMath versions. Ensure the YEAR is replaced with the appropriate local version year.

```groovy
wpi.maven.useLocal = false
wpi.maven.useFrcMavenLocalDevelopment = true
wpi.versions.wpilibVersion = 'YEAR.424242.+'
wpi.versions.wpimathVersion = 'YEAR.424242.+'
```

--------------------------------

### Build Native Camera Server Library

Source: https://github.com/wpilibsuite/allwpilib/blob/main/cameraserver/CMakeLists.txt

This CMake snippet defines the native library for the Camera Server. It compiles C++ source files, sets debug postfixes, configures include directories for build and installation, applies warnings, and links against necessary WPILib modules and OpenCV.

```cmake
file(GLOB_RECURSE cameraserver_native_src src/main/native/cpp/*.cpp)
add_library(cameraserver ${cameraserver_native_src})
set_target_properties(cameraserver PROPERTIES DEBUG_POSTFIX "d")
target_include_directories(
    cameraserver
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/include>
        $<INSTALL_INTERFACE:${include_dest}/cameraserver>
)
wpilib_target_warnings(cameraserver)
target_link_libraries(cameraserver PUBLIC ntcore cscore wpiutil ${OpenCV_LIBS})

set_property(TARGET cameraserver PROPERTY FOLDER "libraries")

install(TARGETS cameraserver EXPORT cameraserver)
export(TARGETS cameraserver FILE cameraserver.cmake NAMESPACE cameraserver::)
install(DIRECTORY src/main/native/include/ DESTINATION "${include_dest}/cameraserver")

configure_file(cameraserver-config.cmake.in ${WPILIB_BINARY_DIR}/cameraserver-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/cameraserver-config.cmake DESTINATION share/cameraserver)
install(EXPORT cameraserver DESTINATION share/cameraserver)
```

--------------------------------

### Set up C++ Project with WPILib Libraries

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README-CMake.md

This CMakeLists.txt file sets up a basic C++ project that uses WPILib libraries. It specifies the minimum CMake version, project name, finds the WPILib package, defines an executable, and links against essential WPILib libraries like cameraserver, ntcore, cscore, and wpiutil.

```cmake
cmake_minimum_required(VERSION 3.11)
project(vision_app) # Project Name Here

find_package(wpilib REQUIRED)

add_executable(my_vision_app main.cpp) # executable name as first parameter
target_link_libraries(my_vision_app cameraserver ntcore cscore wpiutil)
```

--------------------------------

### Define and Configure `halsim_xrp` Library (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/simulation/halsim_xrp/CMakeLists.txt

This snippet defines the `halsim_xrp` shared library using CMake. It globbs C++ source files, sets compile warnings, configures debug postfix, links necessary libraries (`hal`, `halsim_ws_core`), specifies include directories, and sets the target folder. Finally, it handles installation and export for build system integration.

```cmake
project(halsim_xrp)

include(CompileWarnings)

file(GLOB halsim_xrp_src src/main/native/cpp/*.cpp)

add_library(halsim_xrp SHARED ${halsim_xrp_src})
wpilib_target_warnings(halsim_xrp)
set_target_properties(halsim_xrp PROPERTIES DEBUG_POSTFIX "d")
target_link_libraries(halsim_xrp PUBLIC hal halsim_ws_core)

target_include_directories(halsim_xrp PRIVATE src/main/native/include)

set_property(TARGET halsim_xrp PROPERTY FOLDER "libraries")

install(TARGETS halsim_xrp EXPORT halsim_xrp)
export(TARGETS halsim_xrp FILE halsim_xrp.cmake NAMESPACE halsim_xrp::)
```

--------------------------------

### Benchmark Library Setup and Platform-Specific Linking

Source: https://github.com/wpilibsuite/allwpilib/blob/main/benchmark/CMakeLists.txt

This CMake code configures the benchmark library by setting a compile definition and conditionally linking the 'shlwapi' library on Windows systems. It also defines 'BENCHMARK_STATIC_DEFINE' if shared libraries are not being built, which is crucial for static linking scenarios.

```cmake
# benchmark library setup
target_compile_definitions(benchmarkCpp PRIVATE benchmark_EXPORTS)

if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
    target_link_libraries(benchmarkCpp PRIVATE shlwapi)
endif()

if(NOT BUILD_SHARED_LIBS)
    target_compile_definitions(benchmarkCpp PUBLIC -DBENCHMARK_STATIC_DEFINE)
endif()
```

--------------------------------

### Configure HALSim GUI Library (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/simulation/halsim_gui/CMakeLists.txt

Defines the `halsim_gui` shared library using CMake. It includes source files, sets build warnings, configures debug postfix, links necessary libraries (hal, wpimath, libglassnt, libglass), and specifies include directories. Finally, it sets the target folder and defines installation and export rules.

```cmake
project(halsim_gui)

include(CompileWarnings)
include(LinkMacOSGUI)

file(GLOB halsim_gui_src src/main/native/cpp/*.cpp)

add_library(halsim_gui SHARED ${halsim_gui_src})
wpilib_target_warnings(halsim_gui)
set_target_properties(halsim_gui PROPERTIES DEBUG_POSTFIX "d")

wpilib_link_macos_gui(halsim_gui)
target_link_libraries(halsim_gui PUBLIC hal wpimath PRIVATE libglassnt libglass)

target_include_directories(halsim_gui PRIVATE src/main/native/include)

set_property(TARGET halsim_gui PROPERTY FOLDER "libraries")

install(TARGETS halsim_gui EXPORT halsim_gui)
export(TARGETS halsim_gui FILE halsim_gui.cmake NAMESPACE halsim_gui::)
```

--------------------------------

### Configure Java Bindings and JNI Library (ntcore)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/ntcore/CMakeLists.txt

This snippet sets up the Java bindings for the ntcore library, conditional on WITH_JAVA being enabled. It finds necessary JARs, collects Java and JNI source files, compiles the Java code into a JAR, generates native headers, and builds a JNI shared library. It also handles installation of the JAR and JNI library, along with their CMake export files.

```cmake
if(WITH_JAVA)
    include(UseJava)

    file(GLOB QUICKBUF_JAR ${WPILIB_BINARY_DIR}/wpiutil/thirdparty/quickbuf/*.jar)

    file(GLOB ntcore_jni_src src/main/native/cpp/jni/*.cpp src/generated/main/native/cpp/jni/*.cpp)

    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java src/generated/main/java/*.java)
    set(CMAKE_JNI_TARGET true)

    add_jar(
        ntcore_jar
        ${JAVA_SOURCES}
        INCLUDE_JARS wpiutil_jar ${QUICKBUF_JAR}
        OUTPUT_NAME ntcore
        OUTPUT_DIR ${WPILIB_BINARY_DIR}/${java_lib_dest}
        GENERATE_NATIVE_HEADERS ntcore_jni_headers
    )
    set_property(TARGET ntcore_jar PROPERTY FOLDER "java")

    install_jar(ntcore_jar DESTINATION ${java_lib_dest})
    install_jar_exports(TARGETS ntcore_jar FILE ntcore_jar.cmake DESTINATION share/ntcore)

    add_library(ntcorejni ${ntcore_jni_src})
    wpilib_target_warnings(ntcorejni)
    target_link_libraries(ntcorejni PUBLIC ntcore wpiutil)

    set_property(TARGET ntcorejni PROPERTY FOLDER "libraries")

    target_link_libraries(ntcorejni PRIVATE ntcore_jni_headers)
    add_dependencies(ntcorejni ntcore_jar)

    install(TARGETS ntcorejni EXPORT ntcorejni)
    export(TARGETS ntcorejni FILE ntcorejni.cmake NAMESPACE ntcorejni::)
endif()
```

--------------------------------

### Configure HALSIM WebSocket Server Library (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/simulation/halsim_ws_server/CMakeLists.txt

This snippet details the CMake configuration for the `halsim_ws_server` library. It includes setting the project name, including compile warnings, defining source files, adding the library, setting target properties like debug postfix, linking dependencies, specifying include directories, setting the target folder, and configuring installation and export rules.

```cmake
project(halsim_ws_server)

include(CompileWarnings)

file(GLOB halsim_ws_server_src src/main/native/cpp/*.cpp)

add_library(halsim_ws_server SHARED ${halsim_ws_server_src})
wpilib_target_warnings(halsim_ws_server)
set_target_properties(halsim_ws_server PROPERTIES DEBUG_POSTFIX "d")
target_link_libraries(halsim_ws_server PUBLIC hal halsim_ws_core)

target_include_directories(halsim_ws_server PRIVATE src/main/native/include)

set_property(TARGET halsim_ws_server PROPERTY FOLDER "libraries")

install(TARGETS halsim_ws_server EXPORT halsim_ws_server)
export(TARGETS halsim_ws_server FILE halsim_ws_server.cmake NAMESPACE halsim_ws_server::)
```

--------------------------------

### Build and Test Desktop Components (C++ and Java) with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This task executes both './gradlew testDesktopJava' and './gradlew testDesktopCpp', running tests for both Java and C++ desktop components. It compiles the minimal required components for testing.

```bash
./gradlew testDesktop
```

--------------------------------

### Create and Compose Commands in Java

Source: https://context7.com/wpilibsuite/allwpilib/llms.txt

Demonstrates creating various types of commands, including instant, run, custom lifecycle, and composed commands using decorators. It covers basic command execution, sequential and parallel execution, and conditional command logic. Dependencies include WPILib command classes.

```java
import edu.wpi.first.wpilibj2.command.Command;
import edu.wpi.first.wpilibj2.command.Commands;
import edu.wpi.first.wpilibj2.command.InstantCommand;
import edu.wpi.first.wpilibj2.command.RunCommand;
import edu.wpi.first.wpilibj2.command.WaitCommand;

public class ExampleCommands {
  private DriveSubsystem m_drive;
  private ArmSubsystem m_arm;

  // Simple instant command (runs once)
  public Command stopDrive() {
    return new InstantCommand(() -> m_drive.stop(), m_drive);
  }

  // Run command (runs repeatedly until interrupted)
  public Command driveForward() {
    return new RunCommand(() -> m_drive.arcadeDrive(0.5, 0), m_drive);
  }

  // Custom command with full lifecycle
  public Command driveDistance(double meters) {
    return new Command() {
      @Override
      public void initialize() {
        m_drive.resetEncoders();
      }

      @Override
      public void execute() {
        m_drive.arcadeDrive(0.5, 0);
      }

      @Override
      public void end(boolean interrupted) {
        m_drive.stop();
      }

      @Override
      public boolean isFinished() {
        return m_drive.getAverageEncoderDistance() >= meters;
      }
    }.withName("DriveDistance");
  }

  // Command composition using decorators
  public Command complexAuto() {
    return Commands.sequence(
        // Drive forward for 2 seconds
        driveForward().withTimeout(2.0),
        // Wait 0.5 seconds
        new WaitCommand(0.5),
        // Raise arm while driving (parallel)
        Commands.parallel(
            driveForward().withTimeout(1.0),
            m_arm.raiseCommand()
        ),
        // Stop everything
        Commands.runOnce(() -> {
            m_drive.stop();
            m_arm.stop();
        }, m_drive, m_arm)
    );
  }

  // Command with conditions
  public Command conditionalCommand() {
    return driveForward()
        .withTimeout(5.0)              // Stop after 5 seconds
        .until(() -> m_drive.atWall()) // Or when at wall
        .andThen(stopDrive());         // Then stop
  }
}

```

--------------------------------

### Build and Test Desktop C++ Components with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This task builds and runs the tests for the 'wpilibc' project, specifically for desktop C++. It compiles only the minimum necessary components required to execute the tests.

```bash
./gradlew testDesktopCpp
```

--------------------------------

### Build and Test Desktop Java Components with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This task builds and runs the tests for the 'wpilibj' project, specifically for desktop Java. It compiles only the minimum necessary components required to execute the tests.

```bash
./gradlew testDesktopJava
```

--------------------------------

### Build Native C++ Library for XRP Vendordep

Source: https://github.com/wpilibsuite/allwpilib/blob/main/xrpVendordep/CMakeLists.txt

This snippet defines the build process for the native C++ XRP Vendordep library. It compiles C++ source files and links against the `wpilibc` library. It also sets the C++ standard to C++20, applies compile warnings, and configures include directories for build and installation.

```cmake
file(GLOB_RECURSE xrpVendordep_native_src src/main/native/cpp/*.cpp)
add_library(xrpVendordep ${xrpVendordep_native_src})
set_target_properties(xrpVendordep PROPERTIES DEBUG_POSTFIX "d")
set_property(TARGET xrpVendordep PROPERTY FOLDER "libraries")

target_compile_features(xrpVendordep PUBLIC cxx_std_20)
wpilib_target_warnings(xrpVendordep)
target_link_libraries(xrpVendordep wpilibc)

target_include_directories(
    xrpVendordep
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/main/native/include>
        $<INSTALL_INTERFACE:${include_dest}/xrpVendordep>
)

install(TARGETS xrpVendordep EXPORT xrpvendordep)
export(TARGETS xrpVendordep FILE xrpvendordep.cmake NAMESPACE xrpvendordep::)
install(DIRECTORY src/main/native/include/ DESTINATION "${include_dest}/xrpVendordep")

configure_file(xrpvendordep-config.cmake.in ${WPILIB_BINARY_DIR}/xrpvendordep-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/xrpvendordep-config.cmake DESTINATION share/xrpVendordep)
install(EXPORT xrpvendordep DESTINATION share/xrpVendordep)
```

--------------------------------

### Configure C++ Static Library: halsim_ws_core (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/simulation/halsim_ws_core/CMakeLists.txt

This snippet configures a C++ static library named 'halsim_ws_core' using CMake. It includes source files from a specific directory, applies compile warnings, sets a debug postfix, links against 'hal' and 'wpinet' libraries, and specifies include directories. Finally, it sets the target folder and handles installation and export for CMake.

```cmake
project(halsim_ws_core)

include(CompileWarnings)

file(GLOB halsim_ws_core_src src/main/native/cpp/*.cpp)

add_library(halsim_ws_core STATIC ${halsim_ws_core_src})
wpilib_target_warnings(halsim_ws_core)
set_target_properties(halsim_ws_core PROPERTIES DEBUG_POSTFIX "d")
target_link_libraries(halsim_ws_core PUBLIC hal wpinet)

target_include_directories(halsim_ws_core PUBLIC src/main/native/include)

set_property(TARGET halsim_ws_core PROPERTY FOLDER "libraries")

install(TARGETS halsim_ws_core EXPORT halsim_ws_core)
export(TARGETS halsim_ws_core FILE halsim_ws_core.cmake NAMESPACE halsim_ws_core::)
```

--------------------------------

### Install and Export Field Images C++ Library

Source: https://github.com/wpilibsuite/allwpilib/blob/main/fieldImages/CMakeLists.txt

This CMake snippet handles the installation and export of the 'fieldImages' C++ library. It installs the target and creates CMake configuration files for external projects to find and use the library.

```cmake
install(TARGETS fieldImages EXPORT fieldimages)
export(TARGETS fieldImages FILE fieldimages.cmake NAMESPACE fieldimages::)

configure_file(fieldimages-config.cmake.in ${WPILIB_BINARY_DIR}/fieldimages-config.cmake)
install(FILES ${WPILIB_BINARY_DIR}/fieldimages-config.cmake DESTINATION share/fieldImages)
install(EXPORT fieldimages DESTINATION share/fieldImages)
```

--------------------------------

### Build Java Library for WPILib Annotations

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpiannotations/CMakeLists.txt

This snippet configures the build process for creating a Java JAR file for WPILib annotations. It includes finding Java sources, adding the JAR target, and installing it to the specified output directory and CMake export directory. Dependencies include CMake's 'UseJava' module.

```cmake
project(wpiannotations)

# Java bindings
if(WITH_JAVA)
    include(UseJava)

    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java)

    add_jar(
        wpiannotations_jar
        ${JAVA_SOURCES}
        OUTPUT_NAME wpiannotations
        OUTPUT_DIR ${WPILIB_BINARY_DIR}/${java_lib_dest}
    )
    set_property(TARGET wpiannotations_jar PROPERTY FOLDER "java")

    install_jar(wpiannotations_jar DESTINATION ${java_lib_dest})
    install_jar_exports(
        TARGETS wpiannotations_jar
        FILE wpiannotations.cmake
        DESTINATION share/wpiannotations
    )
    install(FILES wpiannotations-config.cmake DESTINATION share/wpiannotations)
endif()
```

--------------------------------

### Execute Java Application with WPILib Classpath

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README-CMake.md

This command demonstrates how to execute a Java application built with WPILib. It includes the necessary JARs for your robot code and WPILib libraries in the classpath. Adjust the paths to your robot JAR, library JARs, and main class according to your project structure and operating system.

```bash
# Linux example:
LD_LIBRARY_PATH=/path/to/libraries java -cp robot.jar:/path/to/library_jars/* main.package.Main

# Windows example:
java -cp "robot.jar;C:\path\to\library_jars\*" main.package.Main
```

--------------------------------

### List All Available Gradle Tasks

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This command lists all available Gradle tasks and provides a description for each. It is useful for discovering different build and utility tasks within the WPILib project.

```bash
./gradlew tasks
```

--------------------------------

### Build WPILib with Parallel Jobs

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README-CMake.md

This command builds the configured WPILib project. The '--parallel x' option allows for multi-job builds, where 'x' is the number of parallel jobs. It's recommended to use one job per 2 GB of RAM. For memory-intensive targets like wpimath, consider building them separately with fewer jobs.

```bash
cmake --build . --parallel x
```

--------------------------------

### Build All WPILib Projects with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This command builds all outputs created by WPILib. It is the most common Gradle task to use. Ensure you are in the root of the cloned WPILib directory before running.

```bash
./gradlew build
```

--------------------------------

### RPATH Configuration (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/CMakeLists.txt

Configures the RPATH (Run-time Search Path) settings for the build and installation. This ensures that libraries can be found at runtime, both within the build tree and after installation.

```cmake
set(CMAKE_SKIP_BUILD_RPATH FALSE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
```

--------------------------------

### Add Subdirectories for Build Targets

Source: https://github.com/wpilibsuite/allwpilib/blob/main/thirdparty/imgui_suite/glfw/CMakeLists.txt

Includes subdirectories for building the main source code, examples, tests, and documentation. The inclusion of examples, tests, and docs is conditional based on CMake options.

```cmake
add_subdirectory(src)

if (GLFW_BUILD_EXAMPLES)
    add_subdirectory(examples)
endif()

if (GLFW_BUILD_TESTS)
    add_subdirectory(tests)
endif()

if (DOXYGEN_FOUND AND GLFW_BUILD_DOCS)
    add_subdirectory(docs)
endif()
```

--------------------------------

### Java Artifact Example

Source: https://github.com/wpilibsuite/allwpilib/blob/main/MavenArtifacts.md

This example shows the Maven artifact coordinate for a Java library. It follows the pattern 'groupId:artifactId:version'. The artifactId typically includes '-java' for Java-specific libraries.

```text
edu.wpi.first.wpilibj:wpilibj-java:version
```

--------------------------------

### Create WPIGUI Development Executable (CMake)

Source: https://github.com/wpilibsuite/allwpilib/blob/main/wpigui/CMakeLists.txt

This snippet creates a development executable named 'wpiguidev'. It links against the 'wpigui' library, applies warnings, and includes macOS GUI linking if applicable.

```cmake
add_executable(wpiguidev src/dev/native/cpp/main.cpp)
wpilib_link_macos_gui(wpiguidev)
wpilib_target_warnings(wpiguidev)
target_link_libraries(wpiguidev wpigui)
```

--------------------------------

### Run Java Code Quality Tools with Gradle

Source: https://github.com/wpilibsuite/allwpilib/blob/main/README.md

This command runs the Checkstyle, PMD, and Spotless tools for Java code quality. These are automatically run by the 'build' task but can be executed individually. The '-PskipJavaFormat' flag can disable this behavior.

```bash
./gradlew javaFormat
```

--------------------------------

### Create Advanced Dashboards with Shuffleboard in Java

Source: https://context7.com/wpilibsuite/allwpilib/llms.txt

Illustrates how to use Shuffleboard in Java to create organized dashboard tabs and display various types of data. It shows how to add entire subsystems, individual values with custom widgets (like sliders and combo boxes), and configure their properties and layout.

```java
import edu.wpi.first.wpilibj.shuffleboard.Shuffleboard;
import edu.wpi.first.wpilibj.shuffleboard.ShuffleboardTab;
import edu.wpi.first.wpilibj.shuffleboard.BuiltInWidgets;
import edu.wpi.first.wpilibj.smartdashboard.SendableChooser;
import edu.wpi.first.wpilibj2.command.Command;

public class RobotContainer {
  private final DriveSubsystem m_drive = new DriveSubsystem();
  private final SendableChooser<Command> m_autoChooser = new SendableChooser<>();

  public RobotContainer() {
    // Create organized tabs
    ShuffleboardTab driveTab = Shuffleboard.getTab("Drivetrain");
    ShuffleboardTab autoTab = Shuffleboard.getTab("Autonomous");

    // Add subsystem to tab (displays all Sendable properties)
    driveTab.add("Drive Subsystem", m_drive);

    // Add individual values with specific widgets
    driveTab.add("Speed", 0.0)
        .withWidget(BuiltInWidgets.kNumberSlider)
        .withProperties(java.util.Map.of("min", -1.0, "max", 1.0))
        .withPosition(0, 0)
        .withSize(2, 1);

    // Configure autonomous chooser
    m_autoChooser.setDefaultOption("Simple Auto", simpleAuto());
    m_autoChooser.addOption("Complex Auto", complexAuto());
    m_autoChooser.addOption("Do Nothing", Commands.none());

    // Add chooser to dashboard
    autoTab.add("Auto Selection", m_autoChooser)
        .withWidget(BuiltInWidgets.kComboBoxChooser)
        .withSize(2, 1);
  }

  public Command getAutonomousCommand() {
    return m_autoChooser.getSelected();
  }
}
```
Tokens:
Raw