[wpimath] Add ChassisAccelerations and drivetrain accelerations classes and add forward and inverse kinematics for accelerations to the interface (#8185)

ChassisAccelerations and the drivetrain acceleration types are added in
both Java and C++. `ChassisAccelerations` is basically just
`ChassisSpeeds` but for accelerations!
`DifferentialDriveWheelAccelerations`, `MecanumDriveWheelAccelerations`,
and `SwerveModuleAccelerations` are the acceleration equivalent of the
drivetrain speeds types.

In Java, the `Kinematics` interface now has an additional generic
parameter `A` which represents the accelerations, and
`toChassisAccelerations` and `toWheelAccelerations` methods, which are
implemented the same way as `toChassisSpeeds` and `toWheelSpeeds`.

Protobuf and struct classes were also added for all four classes in Java
and C++.

---------

Signed-off-by: Zach Harel <zach@zharel.me>
Co-authored-by: Joseph Eng <91924258+KangarooKoala@users.noreply.github.com>
Co-authored-by: Tyler Veness <calcmogul@gmail.com>

wpimath/src/main/native/cpp/kinematics/struct/ChassisAccelerationsStruct.cpp

@@ -0,0 +1,33 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/math/kinematics/struct/ChassisAccelerationsStruct.hpp"
+
+#include "wpi/math/kinematics/ChassisAccelerations.hpp"
+#include "wpi/util/struct/Struct.hpp"
+
+wpi::math::ChassisAccelerations wpi::util::Struct<
+    wpi::math::ChassisAccelerations>::Unpack(std::span<const uint8_t> data) {
+  constexpr size_t kAxOff = 0;
+  constexpr size_t kAyOff = kAxOff + 8;
+  constexpr size_t kAlphaOff = kAyOff + 8;
+  return wpi::math::ChassisAccelerations{
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kAxOff>(data)},
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kAyOff>(data)},
+      units::radians_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kAlphaOff>(data)},
+  };
+}
+
+void wpi::util::Struct<wpi::math::ChassisAccelerations>::Pack(
+    std::span<uint8_t> data, const wpi::math::ChassisAccelerations& value) {
+  constexpr size_t kAxOff = 0;
+  constexpr size_t kAyOff = kAxOff + 8;
+  constexpr size_t kAlphaOff = kAyOff + 8;
+  wpi::util::PackStruct<kAxOff>(data, value.ax.value());
+  wpi::util::PackStruct<kAyOff>(data, value.ay.value());
+  wpi::util::PackStruct<kAlphaOff>(data, value.alpha.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/DifferentialDriveWheelAccelerationsStruct.cpp

@@ -0,0 +1,30 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/math/kinematics/struct/DifferentialDriveWheelAccelerationsStruct.hpp"
+
+#include "wpi/math/kinematics/DifferentialDriveWheelAccelerations.hpp"
+#include "wpi/util/struct/Struct.hpp"
+
+wpi::math::DifferentialDriveWheelAccelerations
+wpi::util::Struct<wpi::math::DifferentialDriveWheelAccelerations>::Unpack(
+    std::span<const uint8_t> data) {
+  constexpr size_t kLeftOff = 0;
+  constexpr size_t kRightOff = kLeftOff + 8;
+  return wpi::math::DifferentialDriveWheelAccelerations{
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kLeftOff>(data)},
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kRightOff>(data)},
+  };
+}
+
+void wpi::util::Struct<wpi::math::DifferentialDriveWheelAccelerations>::Pack(
+    std::span<uint8_t> data,
+    const wpi::math::DifferentialDriveWheelAccelerations& value) {
+  constexpr size_t kLeftOff = 0;
+  constexpr size_t kRightOff = kLeftOff + 8;
+  wpi::util::PackStruct<kLeftOff>(data, value.left.value());
+  wpi::util::PackStruct<kRightOff>(data, value.right.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/MecanumDriveWheelAccelerationsStruct.cpp

@@ -0,0 +1,40 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/math/kinematics/struct/MecanumDriveWheelAccelerationsStruct.hpp"
+
+#include "wpi/math/kinematics/MecanumDriveWheelAccelerations.hpp"
+#include "wpi/util/struct/Struct.hpp"
+
+wpi::math::MecanumDriveWheelAccelerations
+wpi::util::Struct<wpi::math::MecanumDriveWheelAccelerations>::Unpack(
+    std::span<const uint8_t> data) {
+  constexpr size_t kFrontLeftOff = 0;
+  constexpr size_t kFrontRightOff = kFrontLeftOff + 8;
+  constexpr size_t kRearLeftOff = kFrontRightOff + 8;
+  constexpr size_t kRearRightOff = kRearLeftOff + 8;
+  return wpi::math::MecanumDriveWheelAccelerations{
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kFrontLeftOff>(data)},
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kFrontRightOff>(data)},
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kRearLeftOff>(data)},
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kRearRightOff>(data)},
+  };
+}
+
+void wpi::util::Struct<wpi::math::MecanumDriveWheelAccelerations>::Pack(
+    std::span<uint8_t> data,
+    const wpi::math::MecanumDriveWheelAccelerations& value) {
+  constexpr size_t kFrontLeftOff = 0;
+  constexpr size_t kFrontRightOff = kFrontLeftOff + 8;
+  constexpr size_t kRearLeftOff = kFrontRightOff + 8;
+  constexpr size_t kRearRightOff = kRearLeftOff + 8;
+  wpi::util::PackStruct<kFrontLeftOff>(data, value.frontLeft.value());
+  wpi::util::PackStruct<kFrontRightOff>(data, value.frontRight.value());
+  wpi::util::PackStruct<kRearLeftOff>(data, value.rearLeft.value());
+  wpi::util::PackStruct<kRearRightOff>(data, value.rearRight.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/SwerveModuleAccelerationStruct.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/math/kinematics/struct/SwerveModuleAccelerationStruct.hpp"
+
+#include "wpi/math/kinematics/SwerveModuleAcceleration.hpp"
+#include "wpi/util/struct/Struct.hpp"
+
+wpi::math::SwerveModuleAcceleration
+wpi::util::Struct<wpi::math::SwerveModuleAcceleration>::Unpack(
+    std::span<const uint8_t> data) {
+  constexpr size_t kAccelerationOff = 0;
+  constexpr size_t kAngleOff = kAccelerationOff + 8;
+  return wpi::math::SwerveModuleAcceleration{
+      units::meters_per_second_squared_t{
+          wpi::util::UnpackStruct<double, kAccelerationOff>(data)},
+      wpi::util::UnpackStruct<wpi::math::Rotation2d, kAngleOff>(data)};
+}
+
+void wpi::util::Struct<wpi::math::SwerveModuleAcceleration>::Pack(
+    std::span<uint8_t> data, const wpi::math::SwerveModuleAcceleration& value) {
+  constexpr size_t kAccelerationOff = 0;
+  constexpr size_t kAngleOff = kAccelerationOff + 8;
+  wpi::util::PackStruct<kAccelerationOff>(data, value.acceleration.value());
+  wpi::util::PackStruct<kAngleOff>(data, value.angle);
+}