SCRIPT Move subprojects

commandsv2/src/main/native/cpp/frc2/command/button/CommandGamepad.cpp

@@ -0,0 +1,156 @@
+// 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 "frc2/command/button/CommandGamepad.h"
+
+using namespace frc2;
+
+CommandGamepad::CommandGamepad(int port)
+    : CommandGenericHID(port), m_hid{frc::Gamepad(port)} {}
+
+frc::Gamepad& CommandGamepad::GetHID() {
+  return m_hid;
+}
+
+Trigger CommandGamepad::SouthFace(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kSouthFace, loop);
+}
+
+Trigger CommandGamepad::EastFace(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kEastFace, loop);
+}
+
+Trigger CommandGamepad::WestFace(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kWestFace, loop);
+}
+
+Trigger CommandGamepad::NorthFace(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kNorthFace, loop);
+}
+
+Trigger CommandGamepad::Back(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kBack, loop);
+}
+
+Trigger CommandGamepad::Guide(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kGuide, loop);
+}
+
+Trigger CommandGamepad::Start(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kStart, loop);
+}
+
+Trigger CommandGamepad::LeftStick(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kLeftStick, loop);
+}
+
+Trigger CommandGamepad::RightStick(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kRightStick, loop);
+}
+
+Trigger CommandGamepad::LeftShoulder(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kLeftShoulder, loop);
+}
+
+Trigger CommandGamepad::RightShoulder(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kRightShoulder, loop);
+}
+
+Trigger CommandGamepad::DpadUp(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kDpadUp, loop);
+}
+
+Trigger CommandGamepad::DpadDown(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kDpadDown, loop);
+}
+
+Trigger CommandGamepad::DpadLeft(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kDpadLeft, loop);
+}
+
+Trigger CommandGamepad::DpadRight(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kDpadRight, loop);
+}
+
+Trigger CommandGamepad::Misc1(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kMisc1, loop);
+}
+
+Trigger CommandGamepad::RightPaddle1(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kRightPaddle1, loop);
+}
+
+Trigger CommandGamepad::LeftPaddle1(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kLeftPaddle1, loop);
+}
+
+Trigger CommandGamepad::RightPaddle2(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kRightPaddle2, loop);
+}
+
+Trigger CommandGamepad::LeftPaddle2(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kLeftPaddle2, loop);
+}
+
+Trigger CommandGamepad::Touchpad(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kTouchpad, loop);
+}
+
+Trigger CommandGamepad::Misc2(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kMisc2, loop);
+}
+
+Trigger CommandGamepad::Misc3(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kMisc3, loop);
+}
+
+Trigger CommandGamepad::Misc4(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kMisc4, loop);
+}
+
+Trigger CommandGamepad::Misc5(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kMisc5, loop);
+}
+
+Trigger CommandGamepad::Misc6(frc::EventLoop* loop) const {
+  return Button(frc::Gamepad::Button::kMisc6, loop);
+}
+
+Trigger CommandGamepad::LeftTrigger(double threshold,
+                                    frc::EventLoop* loop) const {
+  return Trigger(loop, [this, threshold] {
+    return m_hid.GetLeftTriggerAxis() > threshold;
+  });
+}
+
+Trigger CommandGamepad::RightTrigger(double threshold,
+                                     frc::EventLoop* loop) const {
+  return Trigger(loop, [this, threshold] {
+    return m_hid.GetRightTriggerAxis() > threshold;
+  });
+}
+
+double CommandGamepad::GetLeftX() const {
+  return m_hid.GetLeftX();
+}
+
+double CommandGamepad::GetLeftY() const {
+  return m_hid.GetLeftY();
+}
+
+double CommandGamepad::GetRightX() const {
+  return m_hid.GetRightX();
+}
+
+double CommandGamepad::GetRightY() const {
+  return m_hid.GetRightY();
+}
+
+double CommandGamepad::GetLeftTriggerAxis() const {
+  return m_hid.GetLeftTriggerAxis();
+}
+
+double CommandGamepad::GetRightTriggerAxis() const {
+  return m_hid.GetRightTriggerAxis();
+}

commandsv2/src/main/native/cpp/frc2/command/button/CommandGenericHID.cpp

@@ -0,0 +1,94 @@
+// 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 "frc2/command/button/CommandGenericHID.h"
+
+using namespace frc2;
+
+CommandGenericHID::CommandGenericHID(int port) : m_hid{port} {}
+
+frc::GenericHID& CommandGenericHID::GetHID() {
+  return m_hid;
+}
+
+Trigger CommandGenericHID::Button(int button, frc::EventLoop* loop) const {
+  return Trigger(loop, [this, button] { return m_hid.GetRawButton(button); });
+}
+
+Trigger CommandGenericHID::POV(frc::DriverStation::POVDirection angle,
+                               frc::EventLoop* loop) const {
+  return POV(0, angle, loop);
+}
+
+Trigger CommandGenericHID::POV(int pov, frc::DriverStation::POVDirection angle,
+                               frc::EventLoop* loop) const {
+  return Trigger(loop,
+                 [this, pov, angle] { return m_hid.GetPOV(pov) == angle; });
+}
+
+Trigger CommandGenericHID::POVUp(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kUp, loop);
+}
+
+Trigger CommandGenericHID::POVUpRight(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kUpRight, loop);
+}
+
+Trigger CommandGenericHID::POVRight(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kRight, loop);
+}
+
+Trigger CommandGenericHID::POVDownRight(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kDownRight, loop);
+}
+
+Trigger CommandGenericHID::POVDown(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kDown, loop);
+}
+
+Trigger CommandGenericHID::POVDownLeft(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kDownLeft, loop);
+}
+
+Trigger CommandGenericHID::POVLeft(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kLeft, loop);
+}
+
+Trigger CommandGenericHID::POVUpLeft(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kUpLeft, loop);
+}
+
+Trigger CommandGenericHID::POVCenter(frc::EventLoop* loop) const {
+  return POV(frc::DriverStation::POVDirection::kCenter, loop);
+}
+
+Trigger CommandGenericHID::AxisLessThan(int axis, double threshold,
+                                        frc::EventLoop* loop) const {
+  return Trigger(loop, [this, axis, threshold]() {
+    return m_hid.GetRawAxis(axis) < threshold;
+  });
+}
+
+Trigger CommandGenericHID::AxisGreaterThan(int axis, double threshold,
+                                           frc::EventLoop* loop) const {
+  return Trigger(loop, [this, axis, threshold]() {
+    return m_hid.GetRawAxis(axis) > threshold;
+  });
+}
+
+Trigger CommandGenericHID::AxisMagnitudeGreaterThan(
+    int axis, double threshold, frc::EventLoop* loop) const {
+  return Trigger(loop, [this, axis, threshold]() {
+    return std::abs(m_hid.GetRawAxis(axis)) > threshold;
+  });
+}
+
+void CommandGenericHID::SetRumble(frc::GenericHID::RumbleType type,
+                                  double value) {
+  m_hid.SetRumble(type, value);
+}
+
+bool CommandGenericHID::IsConnected() const {
+  return m_hid.IsConnected();
+}

commandsv2/src/main/native/cpp/frc2/command/button/CommandJoystick.cpp

@@ -0,0 +1,38 @@
+// 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 "frc2/command/button/CommandJoystick.h"
+
+using namespace frc2;
+
+CommandJoystick::CommandJoystick(int port)
+    : CommandGenericHID(port), m_hid{frc::Joystick(port)} {}
+
+frc::Joystick& CommandJoystick::GetHID() {
+  return m_hid;
+}
+
+Trigger CommandJoystick::Trigger(frc::EventLoop* loop) const {
+  return Button(frc::Joystick::ButtonType::kTriggerButton, loop);
+}
+
+Trigger CommandJoystick::Top(frc::EventLoop* loop) const {
+  return Button(frc::Joystick::ButtonType::kTopButton, loop);
+}
+
+double CommandJoystick::GetMagnitude() const {
+  return m_hid.GetMagnitude();
+}
+
+units::radian_t CommandJoystick::GetDirection() const {
+  // https://docs.wpilib.org/en/stable/docs/software/basic-programming/coordinate-system.html#joystick-and-controller-coordinate-system
+  // A positive rotation around the X axis moves the joystick right, and a
+  // positive rotation around the Y axis moves the joystick backward. When
+  // treating them as translations, 0 radians is measured from the right
+  // direction, and angle increases clockwise.
+  //
+  // It's rotated 90 degrees CCW (y is negated and the arguments are reversed)
+  // so that 0 radians is forward.
+  return m_hid.GetDirection();
+}

commandsv2/src/main/native/cpp/frc2/command/button/NetworkButton.cpp

@@ -0,0 +1,29 @@
+// 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 "frc2/command/button/NetworkButton.h"
+
+#include <memory>
+#include <utility>
+
+using namespace frc2;
+
+NetworkButton::NetworkButton(nt::BooleanTopic topic)
+    : NetworkButton(topic.Subscribe(false)) {}
+
+NetworkButton::NetworkButton(nt::BooleanSubscriber sub)
+    : Trigger([sub = std::make_shared<nt::BooleanSubscriber>(std::move(sub))] {
+        return sub->GetTopic().GetInstance().IsConnected() && sub->Get();
+      }) {}
+
+NetworkButton::NetworkButton(std::shared_ptr<nt::NetworkTable> table,
+                             std::string_view field)
+    : NetworkButton(table->GetBooleanTopic(field)) {}
+
+NetworkButton::NetworkButton(std::string_view table, std::string_view field)
+    : NetworkButton(nt::NetworkTableInstance::GetDefault(), table, field) {}
+
+NetworkButton::NetworkButton(nt::NetworkTableInstance inst,
+                             std::string_view table, std::string_view field)
+    : NetworkButton(inst.GetTable(table), field) {}

commandsv2/src/main/native/cpp/frc2/command/button/RobotModeTriggers.cpp

@@ -0,0 +1,25 @@
+// 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 "frc2/command/button/RobotModeTriggers.h"
+
+#include <frc/DriverStation.h>
+
+using namespace frc2;
+
+Trigger RobotModeTriggers::Autonomous() {
+  return Trigger{&frc::DriverStation::IsAutonomousEnabled};
+}
+
+Trigger RobotModeTriggers::Teleop() {
+  return Trigger{&frc::DriverStation::IsTeleopEnabled};
+}
+
+Trigger RobotModeTriggers::Disabled() {
+  return Trigger{&frc::DriverStation::IsDisabled};
+}
+
+Trigger RobotModeTriggers::Test() {
+  return Trigger{&frc::DriverStation::IsTestEnabled};
+}

commandsv2/src/main/native/cpp/frc2/command/button/Trigger.cpp

@@ -0,0 +1,189 @@
+// 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 "frc2/command/button/Trigger.h"
+
+#include <utility>
+
+#include <frc/filter/Debouncer.h>
+
+#include "frc2/command/CommandPtr.h"
+
+using namespace frc;
+using namespace frc2;
+
+Trigger::Trigger(const Trigger& other) = default;
+
+void Trigger::AddBinding(wpi::unique_function<void(bool, bool)>&& body) {
+  m_loop->Bind([condition = m_condition, previous = m_condition(),
+                body = std::move(body)]() mutable {
+    bool current = condition();
+
+    body(previous, current);
+
+    previous = current;
+  });
+}
+
+Trigger Trigger::OnChange(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (previous != current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::OnChange(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (previous != current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::OnTrue(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (!previous && current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::OnTrue(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (!previous && current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::OnFalse(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (previous && !current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::OnFalse(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (previous && !current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::WhileTrue(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (!previous && current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    } else if (previous && !current) {
+      command->Cancel();
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::WhileTrue(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (!previous && current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    } else if (previous && !current) {
+      command.Cancel();
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::WhileFalse(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (previous && !current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    } else if (!previous && current) {
+      command->Cancel();
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::WhileFalse(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (!previous && current) {
+      frc2::CommandScheduler::GetInstance().Schedule(command);
+    } else if (previous && !current) {
+      command.Cancel();
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::ToggleOnTrue(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (!previous && current) {
+      if (command->IsScheduled()) {
+        command->Cancel();
+      } else {
+        frc2::CommandScheduler::GetInstance().Schedule(command);
+      }
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::ToggleOnTrue(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (!previous && current) {
+      if (command.IsScheduled()) {
+        command.Cancel();
+      } else {
+        frc2::CommandScheduler::GetInstance().Schedule(command);
+      }
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::ToggleOnFalse(Command* command) {
+  AddBinding([command](bool previous, bool current) {
+    if (previous && !current) {
+      if (command->IsScheduled()) {
+        command->Cancel();
+      } else {
+        frc2::CommandScheduler::GetInstance().Schedule(command);
+      }
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::ToggleOnFalse(CommandPtr&& command) {
+  AddBinding([command = std::move(command)](bool previous, bool current) {
+    if (previous && !current) {
+      if (command.IsScheduled()) {
+        command.Cancel();
+      } else {
+        frc2::CommandScheduler::GetInstance().Schedule(command);
+      }
+    }
+  });
+  return *this;
+}
+
+Trigger Trigger::Debounce(units::second_t debounceTime,
+                          frc::Debouncer::DebounceType type) {
+  return Trigger(m_loop, [debouncer = frc::Debouncer(debounceTime, type),
+                          condition = m_condition]() mutable {
+    return debouncer.Calculate(condition());
+  });
+}
+
+bool Trigger::Get() const {
+  return m_condition();
+}