From 8d2f3212e7c9c9ed5cc6c447d6b186f295b2ea03 Mon Sep 17 00:00:00 2001 From: Thad House Date: Fri, 19 Jun 2026 14:53:41 -0700 Subject: [PATCH] [wpilib,cmd2] Fix up issues with generated gamepads (#8985) There were a few issues with the generated classes. Python had a __getattr__ forwarder that we defintely did not want. C++ was using a struct with constexpr values, and not an enum class for button types. In all 3, the forwarders from gamepad didn't exist on the generated types. This fixes all 3. --------- Co-authored-by: David Vo --- .../main/java/first_ds_commandhid.java.jinja | 141 +++++++++++++- .../button/first_ds_commandhid.cpp.jinja | 53 +++++- .../button/first_ds_commandhid.hpp.jinja | 82 +++++++- .../main/python/first_ds_commandhid.py.jinja | 112 +++++++++-- .../button/CommandDualSenseController.java | 176 +++++++++++++++-- .../button/CommandXboxController.java | 172 +++++++++++++++-- .../button/CommandDualSenseController.cpp | 128 ++++++++----- .../button/CommandXboxController.cpp | 120 ++++++++---- .../button/CommandDualSenseController.hpp | 81 +++++++- .../button/CommandXboxController.hpp | 81 +++++++- .../command2/button/CommandGamepad.java | 11 ++ .../main/native/cpp/button/CommandGamepad.cpp | 7 + .../wpi/commands2/button/CommandGamepad.hpp | 15 +- .../button/commanddualsensecontroller.py | 179 +++++++++++------- .../python/commands2/button/commandgamepad.py | 15 +- .../commands2/button/commandgenerichid.py | 12 +- .../commands2/button/commandxboxcontroller.py | 171 ++++++++++------- .../main/java/first_ds_commandhid.java.jinja | 24 +++ .../button/CommandDualSenseController.java | 24 +++ .../button/CommandXboxController.java | 24 +++ .../command3/button/CommandGamepad.java | 23 +++ wpilibc/robotpy_pybind_build_info.bzl | 4 - .../cpp/driverstation/first_ds_hid.cpp.jinja | 28 +-- .../cpp/simulation/first_ds_hidsim.cpp.jinja | 4 +- .../wpi/driverstation/first_ds_hid.hpp.jinja | 46 ++--- .../cpp/driverstation/DualSenseController.cpp | 28 +-- .../cpp/driverstation/XboxController.cpp | 28 +-- .../cpp/simulation/DualSenseControllerSim.cpp | 46 ++--- .../cpp/simulation/XboxControllerSim.cpp | 42 ++-- .../wpi/driverstation/DualSenseController.hpp | 122 ++++++------ .../wpi/driverstation/XboxController.hpp | 114 +++++------ .../python/semiwrap/DualSenseController.yml | 30 +-- .../main/python/semiwrap/XboxController.yml | 28 +-- 33 files changed, 1571 insertions(+), 600 deletions(-) diff --git a/commandsv2/src/generate/main/java/first_ds_commandhid.java.jinja b/commandsv2/src/generate/main/java/first_ds_commandhid.java.jinja index e9d09c2621..9484651cdd 100644 --- a/commandsv2/src/generate/main/java/first_ds_commandhid.java.jinja +++ b/commandsv2/src/generate/main/java/first_ds_commandhid.java.jinja @@ -6,6 +6,7 @@ package org.wpilib.command2.button; +import java.util.Objects; import org.wpilib.command2.CommandScheduler; import org.wpilib.driverstation.{{ ClassName }}Controller; import org.wpilib.event.EventLoop; @@ -30,6 +31,17 @@ public class Command{{ ClassName }}Controller { m_controller = new {{ ClassName }}Controller(m_hid.getHID()); } + /** + * Construct an instance of a controller with a {{ ClassName }}Controller object. + * + * @param controller The {{ ClassName }}Controller object to use for this controller. + */ + public Command{{ ClassName }}Controller({{ ClassName }}Controller controller) { + m_controller = + Objects.requireNonNull(controller, "Provided {{ ClassName }}Controller cannot be null"); + m_hid = new CommandGenericHID(m_controller.getHID()); + } + /** * Get the underlying CommandGenericHID object. * @@ -47,6 +59,29 @@ public class Command{{ ClassName }}Controller { public {{ ClassName }}Controller getController() { return m_controller; } + + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @return an event instance representing the button's digital signal attached to the {@link + * CommandScheduler#getDefaultButtonLoop() default scheduler button loop}. + * @see #button({{ ClassName }}Controller.Button, EventLoop) + */ + public Trigger button({{ ClassName }}Controller.Button button) { + return button(button, CommandScheduler.getInstance().getDefaultButtonLoop()); + } + + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @param loop the event loop instance to attach the event to. + * @return an event instance representing the button's digital signal attached to the given loop. + */ + public Trigger button({{ ClassName }}Controller.Button button, EventLoop loop) { + return m_hid.button(button.value, loop); + } {% for button in buttons %} /** * Constructs a Trigger instance around the {{ button.DocName }} button's digital signal. @@ -67,7 +102,7 @@ public class Command{{ ClassName }}Controller { * to the given loop. */ public Trigger {{ button.Name }}(EventLoop loop) { - return m_hid.button({{ ClassName }}Controller.Button.{{ button.ConstantName }}.value, loop); + return button({{ ClassName }}Controller.Button.{{ button.ConstantName }}, loop); } {% endfor -%} {% for trigger in triggerAxes %} @@ -82,8 +117,8 @@ public class Command{{ ClassName }}Controller { * threshold, attached to the given event loop */ public Trigger {{ trigger.Name }}(double threshold, EventLoop loop) { - return m_hid.axisGreaterThan( - {{ ClassName }}Controller.Axis.{{ trigger.AxisConstantName }}.value, threshold, loop); + return axisGreaterThan( + {{ ClassName }}Controller.Axis.{{ trigger.AxisConstantName }}, threshold, loop); } /** @@ -112,8 +147,104 @@ public class Command{{ ClassName }}Controller { public Trigger {{ trigger.Name }}() { return {{ trigger.Name }}(0.5); } -{% endif -%} -{% endfor -%} +{% endif %} +{% endfor %} + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to {@link CommandScheduler#getDefaultButtonLoop() the default command scheduler button + * loop}. + * + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @return a Trigger instance that is true when the axis value is less than the provided + * threshold. + */ + public Trigger axisLessThan({{ ClassName }}Controller.Axis axis, double threshold) { + return m_hid.axisLessThan(axis.value, threshold); + } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the trigger to + * @return a Trigger instance that is true when the axis value is less than the provided + * threshold. + */ + public Trigger axisLessThan( + {{ ClassName }}Controller.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisLessThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to {@link CommandScheduler#getDefaultButtonLoop() the default command scheduler button + * loop}. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @return a Trigger instance that is true when the axis value is greater than the provided + * threshold. + */ + public Trigger axisGreaterThan({{ ClassName }}Controller.Axis axis, double threshold) { + return m_hid.axisGreaterThan(axis.value, threshold); + } + + /** + * Constructs a Trigger instance that is true when the axis value is greater than {@code + * threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis value is greater than the provided + * threshold. + */ + public Trigger axisGreaterThan( + {{ ClassName }}Controller.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisGreaterThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is greater than {@code + * threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis magnitude value is greater than the + * provided threshold. + */ + public Trigger axisMagnitudeGreaterThan( + {{ ClassName }}Controller.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisMagnitudeGreaterThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is greater than {@code + * threshold}, attached to {@link CommandScheduler#getDefaultButtonLoop() the default command + * scheduler button loop}. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @return a Trigger instance that is true when the deadbanded axis value is active (non-zero). + */ + public Trigger axisMagnitudeGreaterThan({{ ClassName }}Controller.Axis axis, double threshold) { + return m_hid.axisMagnitudeGreaterThan(axis.value, threshold); + } + + /** + * Get the value of the axis. + * + * @param axis The axis to read + * @return The value of the axis. + */ + public double getAxis({{ ClassName }}Controller.Axis axis) { + return m_hid.getRawAxis(axis.value); + } + {% for axis in axes %} /** * Get the {{ axis.DocName }} value of the controller. diff --git a/commandsv2/src/generate/main/native/cpp/wpi/commands2/button/first_ds_commandhid.cpp.jinja b/commandsv2/src/generate/main/native/cpp/wpi/commands2/button/first_ds_commandhid.cpp.jinja index 3f91237113..ea4d497652 100644 --- a/commandsv2/src/generate/main/native/cpp/wpi/commands2/button/first_ds_commandhid.cpp.jinja +++ b/commandsv2/src/generate/main/native/cpp/wpi/commands2/button/first_ds_commandhid.cpp.jinja @@ -8,8 +8,17 @@ using namespace wpi::cmd; Command{{ ClassName }}Controller::Command{{ ClassName }}Controller(int port) - : m_hid{&CommandGenericHID::GetCommandGenericHID(port)}, - m_controller{m_hid->GetHID()} {} + : m_hid{&CommandGenericHID::GetCommandGenericHID(port)} { + m_ownedController = + std::make_unique(m_hid->GetHID()); + m_controller = m_ownedController.get(); +} + +Command{{ ClassName }}Controller::Command{{ ClassName }}Controller( + wpi::{{ ClassName }}Controller* controller) + : m_ownedHid{std::make_unique(controller->GetHID())}, + m_hid{m_ownedHid.get()}, + m_controller{controller} {} CommandGenericHID& Command{{ ClassName }}Controller::GetHID() { return *m_hid; @@ -17,30 +26,56 @@ CommandGenericHID& Command{{ ClassName }}Controller::GetHID() { wpi::{{ ClassName }}Controller& Command{{ ClassName }}Controller::GetController() { - return m_controller; + return *m_controller; } const wpi::{{ ClassName }}Controller& Command{{ ClassName }}Controller::GetController() const { - return m_controller; + return *m_controller; } + +Trigger Command{{ ClassName }}Controller::Button( + enum wpi::{{ ClassName }}Controller::Button button, + wpi::EventLoop* loop) const { + return m_hid->Button(static_cast(button), loop); +} + {% for button in buttons %} Trigger Command{{ ClassName }}Controller::{{ button.MethodName }}( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::{{ ClassName }}Controller::Button::{{ button.ConstantName }}, - loop); + return Button(wpi::{{ ClassName }}Controller::Button::{{ button.ConstantName }}, + loop); } {% endfor -%} {% for trigger in triggerAxes %} Trigger Command{{ ClassName }}Controller::{{ trigger.MethodName }}( double threshold, wpi::EventLoop* loop) const { - return m_hid->AxisGreaterThan( + return AxisGreaterThan( wpi::{{ ClassName }}Controller::Axis::{{ trigger.AxisConstantName }}, threshold, loop); } -{% endfor -%} +{% endfor %} +Trigger Command{{ ClassName }}Controller::AxisLessThan( + wpi::{{ ClassName }}Controller::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisLessThan(static_cast(axis), threshold, loop); +} + +Trigger Command{{ ClassName }}Controller::AxisGreaterThan( + wpi::{{ ClassName }}Controller::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisGreaterThan(static_cast(axis), threshold, loop); +} + +Trigger Command{{ ClassName }}Controller::AxisMagnitudeGreaterThan( + wpi::{{ ClassName }}Controller::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisMagnitudeGreaterThan(static_cast(axis), threshold, + loop); +} + {% for axis in axes %} double Command{{ ClassName }}Controller::Get{{ axis.MethodName }}() const { - return m_controller.Get{{ axis.MethodName }}(); + return m_controller->Get{{ axis.MethodName }}(); } {% endfor -%} diff --git a/commandsv2/src/generate/main/native/include/wpi/commands2/button/first_ds_commandhid.hpp.jinja b/commandsv2/src/generate/main/native/include/wpi/commands2/button/first_ds_commandhid.hpp.jinja index aebc4c2be0..2ee837929e 100644 --- a/commandsv2/src/generate/main/native/include/wpi/commands2/button/first_ds_commandhid.hpp.jinja +++ b/commandsv2/src/generate/main/native/include/wpi/commands2/button/first_ds_commandhid.hpp.jinja @@ -5,6 +5,8 @@ // THIS FILE WAS AUTO-GENERATED BY ./commandsv2/generate_hids.py. DO NOT MODIFY #pragma once +#include + #include "wpi/driverstation/{{ ClassName }}Controller.hpp" #include "wpi/commands2/CommandScheduler.hpp" @@ -28,6 +30,13 @@ class Command{{ ClassName }}Controller { */ explicit Command{{ ClassName }}Controller(int port); + /** + * Construct an instance of a controller with a {{ ClassName }}Controller object. + * + * @param controller The {{ ClassName }}Controller object to use for this controller. + */ + explicit Command{{ ClassName }}Controller(wpi::{{ ClassName }}Controller* controller); + /** * Get the underlying CommandGenericHID object. * @@ -48,6 +57,20 @@ class Command{{ ClassName }}Controller { * @return the wrapped controller object */ const wpi::{{ ClassName }}Controller& GetController() const; + + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @param loop the event loop instance to attach the event to. Defaults to the + * CommandScheduler's default loop. + * @return an event instance representing the button's digital signal attached + * to the given loop. + */ + Trigger Button(enum wpi::{{ ClassName }}Controller::Button button, + wpi::EventLoop* loop = CommandScheduler::GetInstance() + .GetDefaultButtonLoop()) const; + {% for button in buttons %} /** * Constructs a Trigger instance around the {{ button.DocName }} button's @@ -80,7 +103,58 @@ class Command{{ ClassName }}Controller { double threshold{% if trigger.HasDefaultThresholdMethod %} = 0.5{% endif %}, wpi::EventLoop* loop = CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; -{% endfor -%} +{% endfor %} + /** + * Constructs a Trigger instance that is true when the axis value is less than + * {@code threshold}, attached to {@link + * CommandScheduler::GetDefaultButtonLoop() the default command scheduler + * button loop}. + * @param axis The axis to read, starting at 0. + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the event to. Defaults to + * {@link CommandScheduler::GetDefaultButtonLoop() the default command + * scheduler button loop}. + * @return a Trigger instance that is true when the axis value is less than + * the provided threshold. + */ + Trigger AxisLessThan( + wpi::{{ ClassName }}Controller::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** + * Constructs a Trigger instance that is true when the axis value is greater + * than {@code threshold}, attached to {@link + * CommandScheduler::GetDefaultButtonLoop() the default command scheduler + * button loop}. + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the event to. Defaults to + * {@link CommandScheduler::GetDefaultButtonLoop() the default command + * scheduler button loop}. + * @return a Trigger instance that is true when the axis value is greater than + * the provided threshold. + */ + Trigger AxisGreaterThan( + wpi::{{ ClassName }}Controller::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is + * greater than {@code threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis magnitude value is + * greater than the provided threshold. + */ + Trigger AxisMagnitudeGreaterThan( + wpi::{{ ClassName }}Controller::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + {% for axis in axes %} /** * Get the {{ axis.DocName }} value of the controller. @@ -90,7 +164,9 @@ class Command{{ ClassName }}Controller { double Get{{ axis.MethodName }}() const; {% endfor %} private: - CommandGenericHID* m_hid; - wpi::{{ ClassName }}Controller m_controller; + std::unique_ptr m_ownedHid; + CommandGenericHID* m_hid = nullptr; + std::unique_ptr m_ownedController; + wpi::{{ ClassName }}Controller* m_controller = nullptr; }; } // namespace wpi::cmd diff --git a/commandsv2/src/generate/main/python/first_ds_commandhid.py.jinja b/commandsv2/src/generate/main/python/first_ds_commandhid.py.jinja index 68b674b393..8d2a947d20 100644 --- a/commandsv2/src/generate/main/python/first_ds_commandhid.py.jinja +++ b/commandsv2/src/generate/main/python/first_ds_commandhid.py.jinja @@ -1,6 +1,6 @@ # THIS FILE WAS AUTO-GENERATED BY ./commandsv2/generate_hids.py. DO NOT MODIFY -from typing import Optional +from typing import Optional, Union from wpilib import EventLoop, {{ ClassName }}Controller @@ -8,13 +8,6 @@ from .commandgenerichid import CommandGenericHID from .trigger import Trigger -def _enum_value(value) -> int: - try: - return int(value) - except TypeError: - return value.value - - class Command{{ ClassName }}Controller: """ A version of :class:`wpilib.{{ ClassName }}Controller` with :class:`.Trigger` factories for command-based. @@ -23,17 +16,19 @@ class Command{{ ClassName }}Controller: _hid: CommandGenericHID _controller: {{ ClassName }}Controller - def __init__(self, port: int): + def __init__(self, hid: Union[int, {{ ClassName }}Controller]): """ Construct an instance of a controller. - :param port: The port index on the Driver Station that the controller is plugged into. + :param hid: The port index on the Driver Station that the controller is plugged into, + or the {{ ClassName }}Controller object to use for this controller. """ - self._hid = CommandGenericHID.getCommandGenericHID(port) - self._controller = {{ ClassName }}Controller(self._hid.getHID()) - - def __getattr__(self, name: str): - return getattr(self._hid, name) + if isinstance(hid, int): + self._hid = CommandGenericHID.getCommandGenericHID(hid) + self._controller = {{ ClassName }}Controller(self._hid.getHID()) + else: + self._hid = CommandGenericHID(hid.getHID()) + self._controller = hid def getHID(self) -> CommandGenericHID: """ @@ -50,6 +45,19 @@ class Command{{ ClassName }}Controller: :returns: the wrapped controller object """ return self._controller + + def button( + self, + button: {{ ClassName }}Controller.Button, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs an event instance around this button's digital signal. + + :param button: the :class:`wpilib.{{ ClassName }}Controller.Button` to read + :param loop: the event loop instance to attach the event to + """ + return self._hid.button(button.value, loop) {% for button in buttons %} def {{ button.Name }}(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -61,9 +69,7 @@ class Command{{ ClassName }}Controller: :returns: a Trigger instance representing the {{ button.DocName }} button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value({{ ClassName }}Controller.Button.{{ button.ConstantName }}), loop - ) + return self.button({{ ClassName }}Controller.Button.{{ button.ConstantName }}, loop) {% endfor -%} {% for trigger in triggerAxes %} def {{ trigger.Name }}( @@ -83,12 +89,76 @@ class Command{{ ClassName }}Controller: :returns: a Trigger instance that is true when the {{ trigger.DocName }} axis exceeds the provided threshold, attached to the given event loop. """ - return self._hid.axisGreaterThan( - _enum_value({{ ClassName }}Controller.Axis.{{ trigger.AxisConstantName }}), + return self.axisGreaterThan( + {{ ClassName }}Controller.Axis.{{ trigger.AxisConstantName }}, threshold, loop, ) -{% endfor -%} +{% endfor %} + def axisLessThan( + self, + axis: {{ ClassName }}Controller.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis value is less than + ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.{{ ClassName }}Controller.Axis` to read + :param threshold: the value below which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to + + :returns: a Trigger instance that is true when the axis value is less than + the provided threshold. + """ + return self._hid.axisLessThan(axis.value, threshold, loop) + + def axisGreaterThan( + self, + axis: {{ ClassName }}Controller.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis value is greater + than ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.{{ ClassName }}Controller.Axis` to read + :param threshold: the value above which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to. + + :returns: a Trigger instance that is true when the axis value is greater + than the provided threshold. + """ + return self._hid.axisGreaterThan(axis.value, threshold, loop) + + def axisMagnitudeGreaterThan( + self, + axis: {{ ClassName }}Controller.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis magnitude is + greater than ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.{{ ClassName }}Controller.Axis` to read + :param threshold: the value above which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to. + + :returns: a Trigger instance that is true when the axis magnitude is + greater than the provided threshold. + """ + return self._hid.axisMagnitudeGreaterThan(axis.value, threshold, loop) + + def getAxis(self, axis: {{ ClassName }}Controller.Axis) -> float: + """ + Get the value of the axis. + + :param axis: the :class:`wpilib.{{ ClassName }}Controller.Axis` to read + """ + return self._hid.getRawAxis(axis.value) {% for axis in axes %} def get{{ axis.MethodName }}(self) -> float: """ diff --git a/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandDualSenseController.java b/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandDualSenseController.java index 9d0a934f23..98a7546e6f 100644 --- a/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandDualSenseController.java +++ b/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandDualSenseController.java @@ -6,6 +6,7 @@ package org.wpilib.command2.button; +import java.util.Objects; import org.wpilib.command2.CommandScheduler; import org.wpilib.driverstation.DualSenseController; import org.wpilib.event.EventLoop; @@ -30,6 +31,17 @@ public class CommandDualSenseController { m_controller = new DualSenseController(m_hid.getHID()); } + /** + * Construct an instance of a controller with a DualSenseController object. + * + * @param controller The DualSenseController object to use for this controller. + */ + public CommandDualSenseController(DualSenseController controller) { + m_controller = + Objects.requireNonNull(controller, "Provided DualSenseController cannot be null"); + m_hid = new CommandGenericHID(m_controller.getHID()); + } + /** * Get the underlying CommandGenericHID object. * @@ -48,6 +60,29 @@ public class CommandDualSenseController { return m_controller; } + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @return an event instance representing the button's digital signal attached to the {@link + * CommandScheduler#getDefaultButtonLoop() default scheduler button loop}. + * @see #button(DualSenseController.Button, EventLoop) + */ + public Trigger button(DualSenseController.Button button) { + return button(button, CommandScheduler.getInstance().getDefaultButtonLoop()); + } + + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @param loop the event loop instance to attach the event to. + * @return an event instance representing the button's digital signal attached to the given loop. + */ + public Trigger button(DualSenseController.Button button, EventLoop loop) { + return m_hid.button(button.value, loop); + } + /** * Constructs a Trigger instance around the Cross button's digital signal. * @@ -67,7 +102,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger cross(EventLoop loop) { - return m_hid.button(DualSenseController.Button.CROSS.value, loop); + return button(DualSenseController.Button.CROSS, loop); } /** @@ -89,7 +124,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger circle(EventLoop loop) { - return m_hid.button(DualSenseController.Button.CIRCLE.value, loop); + return button(DualSenseController.Button.CIRCLE, loop); } /** @@ -111,7 +146,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger square(EventLoop loop) { - return m_hid.button(DualSenseController.Button.SQUARE.value, loop); + return button(DualSenseController.Button.SQUARE, loop); } /** @@ -133,7 +168,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger triangle(EventLoop loop) { - return m_hid.button(DualSenseController.Button.TRIANGLE.value, loop); + return button(DualSenseController.Button.TRIANGLE, loop); } /** @@ -155,7 +190,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger create(EventLoop loop) { - return m_hid.button(DualSenseController.Button.CREATE.value, loop); + return button(DualSenseController.Button.CREATE, loop); } /** @@ -177,7 +212,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger PS(EventLoop loop) { - return m_hid.button(DualSenseController.Button.PS.value, loop); + return button(DualSenseController.Button.PS, loop); } /** @@ -199,7 +234,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger options(EventLoop loop) { - return m_hid.button(DualSenseController.Button.OPTIONS.value, loop); + return button(DualSenseController.Button.OPTIONS, loop); } /** @@ -221,7 +256,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger L3(EventLoop loop) { - return m_hid.button(DualSenseController.Button.L3.value, loop); + return button(DualSenseController.Button.L3, loop); } /** @@ -243,7 +278,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger R3(EventLoop loop) { - return m_hid.button(DualSenseController.Button.R3.value, loop); + return button(DualSenseController.Button.R3, loop); } /** @@ -265,7 +300,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger L1(EventLoop loop) { - return m_hid.button(DualSenseController.Button.L1.value, loop); + return button(DualSenseController.Button.L1, loop); } /** @@ -287,7 +322,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger R1(EventLoop loop) { - return m_hid.button(DualSenseController.Button.R1.value, loop); + return button(DualSenseController.Button.R1, loop); } /** @@ -309,7 +344,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger dpadUp(EventLoop loop) { - return m_hid.button(DualSenseController.Button.DPAD_UP.value, loop); + return button(DualSenseController.Button.DPAD_UP, loop); } /** @@ -331,7 +366,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger dpadDown(EventLoop loop) { - return m_hid.button(DualSenseController.Button.DPAD_DOWN.value, loop); + return button(DualSenseController.Button.DPAD_DOWN, loop); } /** @@ -353,7 +388,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger dpadLeft(EventLoop loop) { - return m_hid.button(DualSenseController.Button.DPAD_LEFT.value, loop); + return button(DualSenseController.Button.DPAD_LEFT, loop); } /** @@ -375,7 +410,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger dpadRight(EventLoop loop) { - return m_hid.button(DualSenseController.Button.DPAD_RIGHT.value, loop); + return button(DualSenseController.Button.DPAD_RIGHT, loop); } /** @@ -397,7 +432,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger microphone(EventLoop loop) { - return m_hid.button(DualSenseController.Button.MICROPHONE.value, loop); + return button(DualSenseController.Button.MICROPHONE, loop); } /** @@ -419,7 +454,7 @@ public class CommandDualSenseController { * to the given loop. */ public Trigger touchpad(EventLoop loop) { - return m_hid.button(DualSenseController.Button.TOUCHPAD.value, loop); + return button(DualSenseController.Button.TOUCHPAD, loop); } /** @@ -433,8 +468,8 @@ public class CommandDualSenseController { * threshold, attached to the given event loop */ public Trigger L2(double threshold, EventLoop loop) { - return m_hid.axisGreaterThan( - DualSenseController.Axis.L2.value, threshold, loop); + return axisGreaterThan( + DualSenseController.Axis.L2, threshold, loop); } /** @@ -464,6 +499,7 @@ public class CommandDualSenseController { return L2(0.5); } + /** * Constructs a Trigger instance around the axis value of the R 2. The returned * trigger will be true when the axis value is greater than {@code threshold}. @@ -475,8 +511,8 @@ public class CommandDualSenseController { * threshold, attached to the given event loop */ public Trigger R2(double threshold, EventLoop loop) { - return m_hid.axisGreaterThan( - DualSenseController.Axis.R2.value, threshold, loop); + return axisGreaterThan( + DualSenseController.Axis.R2, threshold, loop); } /** @@ -506,6 +542,104 @@ public class CommandDualSenseController { return R2(0.5); } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to {@link CommandScheduler#getDefaultButtonLoop() the default command scheduler button + * loop}. + * + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @return a Trigger instance that is true when the axis value is less than the provided + * threshold. + */ + public Trigger axisLessThan(DualSenseController.Axis axis, double threshold) { + return m_hid.axisLessThan(axis.value, threshold); + } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the trigger to + * @return a Trigger instance that is true when the axis value is less than the provided + * threshold. + */ + public Trigger axisLessThan( + DualSenseController.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisLessThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to {@link CommandScheduler#getDefaultButtonLoop() the default command scheduler button + * loop}. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @return a Trigger instance that is true when the axis value is greater than the provided + * threshold. + */ + public Trigger axisGreaterThan(DualSenseController.Axis axis, double threshold) { + return m_hid.axisGreaterThan(axis.value, threshold); + } + + /** + * Constructs a Trigger instance that is true when the axis value is greater than {@code + * threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis value is greater than the provided + * threshold. + */ + public Trigger axisGreaterThan( + DualSenseController.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisGreaterThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is greater than {@code + * threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis magnitude value is greater than the + * provided threshold. + */ + public Trigger axisMagnitudeGreaterThan( + DualSenseController.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisMagnitudeGreaterThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is greater than {@code + * threshold}, attached to {@link CommandScheduler#getDefaultButtonLoop() the default command + * scheduler button loop}. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @return a Trigger instance that is true when the deadbanded axis value is active (non-zero). + */ + public Trigger axisMagnitudeGreaterThan(DualSenseController.Axis axis, double threshold) { + return m_hid.axisMagnitudeGreaterThan(axis.value, threshold); + } + + /** + * Get the value of the axis. + * + * @param axis The axis to read + * @return The value of the axis. + */ + public double getAxis(DualSenseController.Axis axis) { + return m_hid.getRawAxis(axis.value); + } + + /** * Get the Left X value of the controller. * diff --git a/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandXboxController.java b/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandXboxController.java index 4c5ec6a172..605d8d31f3 100644 --- a/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandXboxController.java +++ b/commandsv2/src/generated/main/java/org/wpilib/command2/button/CommandXboxController.java @@ -6,6 +6,7 @@ package org.wpilib.command2.button; +import java.util.Objects; import org.wpilib.command2.CommandScheduler; import org.wpilib.driverstation.XboxController; import org.wpilib.event.EventLoop; @@ -30,6 +31,17 @@ public class CommandXboxController { m_controller = new XboxController(m_hid.getHID()); } + /** + * Construct an instance of a controller with a XboxController object. + * + * @param controller The XboxController object to use for this controller. + */ + public CommandXboxController(XboxController controller) { + m_controller = + Objects.requireNonNull(controller, "Provided XboxController cannot be null"); + m_hid = new CommandGenericHID(m_controller.getHID()); + } + /** * Get the underlying CommandGenericHID object. * @@ -48,6 +60,29 @@ public class CommandXboxController { return m_controller; } + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @return an event instance representing the button's digital signal attached to the {@link + * CommandScheduler#getDefaultButtonLoop() default scheduler button loop}. + * @see #button(XboxController.Button, EventLoop) + */ + public Trigger button(XboxController.Button button) { + return button(button, CommandScheduler.getInstance().getDefaultButtonLoop()); + } + + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @param loop the event loop instance to attach the event to. + * @return an event instance representing the button's digital signal attached to the given loop. + */ + public Trigger button(XboxController.Button button, EventLoop loop) { + return m_hid.button(button.value, loop); + } + /** * Constructs a Trigger instance around the A button's digital signal. * @@ -67,7 +102,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger a(EventLoop loop) { - return m_hid.button(XboxController.Button.A.value, loop); + return button(XboxController.Button.A, loop); } /** @@ -89,7 +124,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger b(EventLoop loop) { - return m_hid.button(XboxController.Button.B.value, loop); + return button(XboxController.Button.B, loop); } /** @@ -111,7 +146,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger x(EventLoop loop) { - return m_hid.button(XboxController.Button.X.value, loop); + return button(XboxController.Button.X, loop); } /** @@ -133,7 +168,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger y(EventLoop loop) { - return m_hid.button(XboxController.Button.Y.value, loop); + return button(XboxController.Button.Y, loop); } /** @@ -155,7 +190,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger view(EventLoop loop) { - return m_hid.button(XboxController.Button.VIEW.value, loop); + return button(XboxController.Button.VIEW, loop); } /** @@ -177,7 +212,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger xbox(EventLoop loop) { - return m_hid.button(XboxController.Button.XBOX.value, loop); + return button(XboxController.Button.XBOX, loop); } /** @@ -199,7 +234,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger menu(EventLoop loop) { - return m_hid.button(XboxController.Button.MENU.value, loop); + return button(XboxController.Button.MENU, loop); } /** @@ -221,7 +256,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger leftStick(EventLoop loop) { - return m_hid.button(XboxController.Button.LEFT_STICK.value, loop); + return button(XboxController.Button.LEFT_STICK, loop); } /** @@ -243,7 +278,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger rightStick(EventLoop loop) { - return m_hid.button(XboxController.Button.RIGHT_STICK.value, loop); + return button(XboxController.Button.RIGHT_STICK, loop); } /** @@ -265,7 +300,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger leftBumper(EventLoop loop) { - return m_hid.button(XboxController.Button.LEFT_BUMPER.value, loop); + return button(XboxController.Button.LEFT_BUMPER, loop); } /** @@ -287,7 +322,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger rightBumper(EventLoop loop) { - return m_hid.button(XboxController.Button.RIGHT_BUMPER.value, loop); + return button(XboxController.Button.RIGHT_BUMPER, loop); } /** @@ -309,7 +344,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger dpadUp(EventLoop loop) { - return m_hid.button(XboxController.Button.DPAD_UP.value, loop); + return button(XboxController.Button.DPAD_UP, loop); } /** @@ -331,7 +366,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger dpadDown(EventLoop loop) { - return m_hid.button(XboxController.Button.DPAD_DOWN.value, loop); + return button(XboxController.Button.DPAD_DOWN, loop); } /** @@ -353,7 +388,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger dpadLeft(EventLoop loop) { - return m_hid.button(XboxController.Button.DPAD_LEFT.value, loop); + return button(XboxController.Button.DPAD_LEFT, loop); } /** @@ -375,7 +410,7 @@ public class CommandXboxController { * to the given loop. */ public Trigger dpadRight(EventLoop loop) { - return m_hid.button(XboxController.Button.DPAD_RIGHT.value, loop); + return button(XboxController.Button.DPAD_RIGHT, loop); } /** @@ -389,8 +424,8 @@ public class CommandXboxController { * threshold, attached to the given event loop */ public Trigger leftTrigger(double threshold, EventLoop loop) { - return m_hid.axisGreaterThan( - XboxController.Axis.LEFT_TRIGGER.value, threshold, loop); + return axisGreaterThan( + XboxController.Axis.LEFT_TRIGGER, threshold, loop); } /** @@ -420,6 +455,7 @@ public class CommandXboxController { return leftTrigger(0.5); } + /** * Constructs a Trigger instance around the axis value of the Right Trigger. The returned * trigger will be true when the axis value is greater than {@code threshold}. @@ -431,8 +467,8 @@ public class CommandXboxController { * threshold, attached to the given event loop */ public Trigger rightTrigger(double threshold, EventLoop loop) { - return m_hid.axisGreaterThan( - XboxController.Axis.RIGHT_TRIGGER.value, threshold, loop); + return axisGreaterThan( + XboxController.Axis.RIGHT_TRIGGER, threshold, loop); } /** @@ -462,6 +498,104 @@ public class CommandXboxController { return rightTrigger(0.5); } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to {@link CommandScheduler#getDefaultButtonLoop() the default command scheduler button + * loop}. + * + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @return a Trigger instance that is true when the axis value is less than the provided + * threshold. + */ + public Trigger axisLessThan(XboxController.Axis axis, double threshold) { + return m_hid.axisLessThan(axis.value, threshold); + } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the trigger to + * @return a Trigger instance that is true when the axis value is less than the provided + * threshold. + */ + public Trigger axisLessThan( + XboxController.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisLessThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis value is less than {@code threshold}, + * attached to {@link CommandScheduler#getDefaultButtonLoop() the default command scheduler button + * loop}. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @return a Trigger instance that is true when the axis value is greater than the provided + * threshold. + */ + public Trigger axisGreaterThan(XboxController.Axis axis, double threshold) { + return m_hid.axisGreaterThan(axis.value, threshold); + } + + /** + * Constructs a Trigger instance that is true when the axis value is greater than {@code + * threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis value is greater than the provided + * threshold. + */ + public Trigger axisGreaterThan( + XboxController.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisGreaterThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is greater than {@code + * threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis magnitude value is greater than the + * provided threshold. + */ + public Trigger axisMagnitudeGreaterThan( + XboxController.Axis axis, double threshold, EventLoop loop) { + return m_hid.axisMagnitudeGreaterThan(axis.value, threshold, loop); + } + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is greater than {@code + * threshold}, attached to {@link CommandScheduler#getDefaultButtonLoop() the default command + * scheduler button loop}. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @return a Trigger instance that is true when the deadbanded axis value is active (non-zero). + */ + public Trigger axisMagnitudeGreaterThan(XboxController.Axis axis, double threshold) { + return m_hid.axisMagnitudeGreaterThan(axis.value, threshold); + } + + /** + * Get the value of the axis. + * + * @param axis The axis to read + * @return The value of the axis. + */ + public double getAxis(XboxController.Axis axis) { + return m_hid.getRawAxis(axis.value); + } + + /** * Get the Left X value of the controller. * diff --git a/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandDualSenseController.cpp b/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandDualSenseController.cpp index 3eeec0720c..2e31ee1b06 100644 --- a/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandDualSenseController.cpp +++ b/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandDualSenseController.cpp @@ -8,8 +8,17 @@ using namespace wpi::cmd; CommandDualSenseController::CommandDualSenseController(int port) - : m_hid{&CommandGenericHID::GetCommandGenericHID(port)}, - m_controller{m_hid->GetHID()} {} + : m_hid{&CommandGenericHID::GetCommandGenericHID(port)} { + m_ownedController = + std::make_unique(m_hid->GetHID()); + m_controller = m_ownedController.get(); +} + +CommandDualSenseController::CommandDualSenseController( + wpi::DualSenseController* controller) + : m_ownedHid{std::make_unique(controller->GetHID())}, + m_hid{m_ownedHid.get()}, + m_controller{controller} {} CommandGenericHID& CommandDualSenseController::GetHID() { return *m_hid; @@ -17,150 +26,177 @@ CommandGenericHID& CommandDualSenseController::GetHID() { wpi::DualSenseController& CommandDualSenseController::GetController() { - return m_controller; + return *m_controller; } const wpi::DualSenseController& CommandDualSenseController::GetController() const { - return m_controller; + return *m_controller; } +Trigger CommandDualSenseController::Button( + enum wpi::DualSenseController::Button button, + wpi::EventLoop* loop) const { + return m_hid->Button(static_cast(button), loop); +} + + Trigger CommandDualSenseController::Cross( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::CROSS, - loop); + return Button(wpi::DualSenseController::Button::CROSS, + loop); } Trigger CommandDualSenseController::Circle( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::CIRCLE, - loop); + return Button(wpi::DualSenseController::Button::CIRCLE, + loop); } Trigger CommandDualSenseController::Square( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::SQUARE, - loop); + return Button(wpi::DualSenseController::Button::SQUARE, + loop); } Trigger CommandDualSenseController::Triangle( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::TRIANGLE, - loop); + return Button(wpi::DualSenseController::Button::TRIANGLE, + loop); } Trigger CommandDualSenseController::Create( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::CREATE, - loop); + return Button(wpi::DualSenseController::Button::CREATE, + loop); } Trigger CommandDualSenseController::PS( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::PS, - loop); + return Button(wpi::DualSenseController::Button::PS, + loop); } Trigger CommandDualSenseController::Options( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::OPTIONS, - loop); + return Button(wpi::DualSenseController::Button::OPTIONS, + loop); } Trigger CommandDualSenseController::L3( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::L3, - loop); + return Button(wpi::DualSenseController::Button::L3, + loop); } Trigger CommandDualSenseController::R3( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::R3, - loop); + return Button(wpi::DualSenseController::Button::R3, + loop); } Trigger CommandDualSenseController::L1( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::L1, - loop); + return Button(wpi::DualSenseController::Button::L1, + loop); } Trigger CommandDualSenseController::R1( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::R1, - loop); + return Button(wpi::DualSenseController::Button::R1, + loop); } Trigger CommandDualSenseController::DpadUp( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::DPAD_UP, - loop); + return Button(wpi::DualSenseController::Button::DPAD_UP, + loop); } Trigger CommandDualSenseController::DpadDown( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::DPAD_DOWN, - loop); + return Button(wpi::DualSenseController::Button::DPAD_DOWN, + loop); } Trigger CommandDualSenseController::DpadLeft( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::DPAD_LEFT, - loop); + return Button(wpi::DualSenseController::Button::DPAD_LEFT, + loop); } Trigger CommandDualSenseController::DpadRight( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::DPAD_RIGHT, - loop); + return Button(wpi::DualSenseController::Button::DPAD_RIGHT, + loop); } Trigger CommandDualSenseController::Microphone( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::MICROPHONE, - loop); + return Button(wpi::DualSenseController::Button::MICROPHONE, + loop); } Trigger CommandDualSenseController::Touchpad( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::DualSenseController::Button::TOUCHPAD, - loop); + return Button(wpi::DualSenseController::Button::TOUCHPAD, + loop); } Trigger CommandDualSenseController::L2( double threshold, wpi::EventLoop* loop) const { - return m_hid->AxisGreaterThan( + return AxisGreaterThan( wpi::DualSenseController::Axis::L2, threshold, loop); } Trigger CommandDualSenseController::R2( double threshold, wpi::EventLoop* loop) const { - return m_hid->AxisGreaterThan( + return AxisGreaterThan( wpi::DualSenseController::Axis::R2, threshold, loop); } +Trigger CommandDualSenseController::AxisLessThan( + wpi::DualSenseController::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisLessThan(static_cast(axis), threshold, loop); +} + +Trigger CommandDualSenseController::AxisGreaterThan( + wpi::DualSenseController::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisGreaterThan(static_cast(axis), threshold, loop); +} + +Trigger CommandDualSenseController::AxisMagnitudeGreaterThan( + wpi::DualSenseController::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisMagnitudeGreaterThan(static_cast(axis), threshold, + loop); +} + + double CommandDualSenseController::GetLeftX() const { - return m_controller.GetLeftX(); + return m_controller->GetLeftX(); } double CommandDualSenseController::GetLeftY() const { - return m_controller.GetLeftY(); + return m_controller->GetLeftY(); } double CommandDualSenseController::GetRightX() const { - return m_controller.GetRightX(); + return m_controller->GetRightX(); } double CommandDualSenseController::GetRightY() const { - return m_controller.GetRightY(); + return m_controller->GetRightY(); } double CommandDualSenseController::GetL2() const { - return m_controller.GetL2(); + return m_controller->GetL2(); } double CommandDualSenseController::GetR2() const { - return m_controller.GetR2(); + return m_controller->GetR2(); } diff --git a/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandXboxController.cpp b/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandXboxController.cpp index 3d9320036a..59e59b7981 100644 --- a/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandXboxController.cpp +++ b/commandsv2/src/generated/main/native/cpp/wpi/commands2/button/CommandXboxController.cpp @@ -8,8 +8,17 @@ using namespace wpi::cmd; CommandXboxController::CommandXboxController(int port) - : m_hid{&CommandGenericHID::GetCommandGenericHID(port)}, - m_controller{m_hid->GetHID()} {} + : m_hid{&CommandGenericHID::GetCommandGenericHID(port)} { + m_ownedController = + std::make_unique(m_hid->GetHID()); + m_controller = m_ownedController.get(); +} + +CommandXboxController::CommandXboxController( + wpi::XboxController* controller) + : m_ownedHid{std::make_unique(controller->GetHID())}, + m_hid{m_ownedHid.get()}, + m_controller{controller} {} CommandGenericHID& CommandXboxController::GetHID() { return *m_hid; @@ -17,138 +26,165 @@ CommandGenericHID& CommandXboxController::GetHID() { wpi::XboxController& CommandXboxController::GetController() { - return m_controller; + return *m_controller; } const wpi::XboxController& CommandXboxController::GetController() const { - return m_controller; + return *m_controller; } +Trigger CommandXboxController::Button( + enum wpi::XboxController::Button button, + wpi::EventLoop* loop) const { + return m_hid->Button(static_cast(button), loop); +} + + Trigger CommandXboxController::A( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::A, - loop); + return Button(wpi::XboxController::Button::A, + loop); } Trigger CommandXboxController::B( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::B, - loop); + return Button(wpi::XboxController::Button::B, + loop); } Trigger CommandXboxController::X( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::X, - loop); + return Button(wpi::XboxController::Button::X, + loop); } Trigger CommandXboxController::Y( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::Y, - loop); + return Button(wpi::XboxController::Button::Y, + loop); } Trigger CommandXboxController::View( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::VIEW, - loop); + return Button(wpi::XboxController::Button::VIEW, + loop); } Trigger CommandXboxController::Xbox( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::XBOX, - loop); + return Button(wpi::XboxController::Button::XBOX, + loop); } Trigger CommandXboxController::Menu( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::MENU, - loop); + return Button(wpi::XboxController::Button::MENU, + loop); } Trigger CommandXboxController::LeftStick( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::LEFT_STICK, - loop); + return Button(wpi::XboxController::Button::LEFT_STICK, + loop); } Trigger CommandXboxController::RightStick( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::RIGHT_STICK, - loop); + return Button(wpi::XboxController::Button::RIGHT_STICK, + loop); } Trigger CommandXboxController::LeftBumper( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::LEFT_BUMPER, - loop); + return Button(wpi::XboxController::Button::LEFT_BUMPER, + loop); } Trigger CommandXboxController::RightBumper( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::RIGHT_BUMPER, - loop); + return Button(wpi::XboxController::Button::RIGHT_BUMPER, + loop); } Trigger CommandXboxController::DpadUp( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::DPAD_UP, - loop); + return Button(wpi::XboxController::Button::DPAD_UP, + loop); } Trigger CommandXboxController::DpadDown( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::DPAD_DOWN, - loop); + return Button(wpi::XboxController::Button::DPAD_DOWN, + loop); } Trigger CommandXboxController::DpadLeft( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::DPAD_LEFT, - loop); + return Button(wpi::XboxController::Button::DPAD_LEFT, + loop); } Trigger CommandXboxController::DpadRight( wpi::EventLoop* loop) const { - return m_hid->Button(wpi::XboxController::Button::DPAD_RIGHT, - loop); + return Button(wpi::XboxController::Button::DPAD_RIGHT, + loop); } Trigger CommandXboxController::LeftTrigger( double threshold, wpi::EventLoop* loop) const { - return m_hid->AxisGreaterThan( + return AxisGreaterThan( wpi::XboxController::Axis::LEFT_TRIGGER, threshold, loop); } Trigger CommandXboxController::RightTrigger( double threshold, wpi::EventLoop* loop) const { - return m_hid->AxisGreaterThan( + return AxisGreaterThan( wpi::XboxController::Axis::RIGHT_TRIGGER, threshold, loop); } +Trigger CommandXboxController::AxisLessThan( + wpi::XboxController::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisLessThan(static_cast(axis), threshold, loop); +} + +Trigger CommandXboxController::AxisGreaterThan( + wpi::XboxController::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisGreaterThan(static_cast(axis), threshold, loop); +} + +Trigger CommandXboxController::AxisMagnitudeGreaterThan( + wpi::XboxController::Axis axis, double threshold, + wpi::EventLoop* loop) const { + return m_hid->AxisMagnitudeGreaterThan(static_cast(axis), threshold, + loop); +} + + double CommandXboxController::GetLeftX() const { - return m_controller.GetLeftX(); + return m_controller->GetLeftX(); } double CommandXboxController::GetLeftY() const { - return m_controller.GetLeftY(); + return m_controller->GetLeftY(); } double CommandXboxController::GetRightX() const { - return m_controller.GetRightX(); + return m_controller->GetRightX(); } double CommandXboxController::GetRightY() const { - return m_controller.GetRightY(); + return m_controller->GetRightY(); } double CommandXboxController::GetLeftTrigger() const { - return m_controller.GetLeftTrigger(); + return m_controller->GetLeftTrigger(); } double CommandXboxController::GetRightTrigger() const { - return m_controller.GetRightTrigger(); + return m_controller->GetRightTrigger(); } diff --git a/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandDualSenseController.hpp b/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandDualSenseController.hpp index 298fc73597..6476c1965c 100644 --- a/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandDualSenseController.hpp +++ b/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandDualSenseController.hpp @@ -5,6 +5,8 @@ // THIS FILE WAS AUTO-GENERATED BY ./commandsv2/generate_hids.py. DO NOT MODIFY #pragma once +#include + #include "wpi/driverstation/DualSenseController.hpp" #include "wpi/commands2/CommandScheduler.hpp" @@ -28,6 +30,13 @@ class CommandDualSenseController { */ explicit CommandDualSenseController(int port); + /** + * Construct an instance of a controller with a DualSenseController object. + * + * @param controller The DualSenseController object to use for this controller. + */ + explicit CommandDualSenseController(wpi::DualSenseController* controller); + /** * Get the underlying CommandGenericHID object. * @@ -49,6 +58,20 @@ class CommandDualSenseController { */ const wpi::DualSenseController& GetController() const; + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @param loop the event loop instance to attach the event to. Defaults to the + * CommandScheduler's default loop. + * @return an event instance representing the button's digital signal attached + * to the given loop. + */ + Trigger Button(enum wpi::DualSenseController::Button button, + wpi::EventLoop* loop = CommandScheduler::GetInstance() + .GetDefaultButtonLoop()) const; + + /** * Constructs a Trigger instance around the Cross button's * digital signal. @@ -306,6 +329,58 @@ class CommandDualSenseController { wpi::EventLoop* loop = CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + /** + * Constructs a Trigger instance that is true when the axis value is less than + * {@code threshold}, attached to {@link + * CommandScheduler::GetDefaultButtonLoop() the default command scheduler + * button loop}. + * @param axis The axis to read, starting at 0. + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the event to. Defaults to + * {@link CommandScheduler::GetDefaultButtonLoop() the default command + * scheduler button loop}. + * @return a Trigger instance that is true when the axis value is less than + * the provided threshold. + */ + Trigger AxisLessThan( + wpi::DualSenseController::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** + * Constructs a Trigger instance that is true when the axis value is greater + * than {@code threshold}, attached to {@link + * CommandScheduler::GetDefaultButtonLoop() the default command scheduler + * button loop}. + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the event to. Defaults to + * {@link CommandScheduler::GetDefaultButtonLoop() the default command + * scheduler button loop}. + * @return a Trigger instance that is true when the axis value is greater than + * the provided threshold. + */ + Trigger AxisGreaterThan( + wpi::DualSenseController::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is + * greater than {@code threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis magnitude value is + * greater than the provided threshold. + */ + Trigger AxisMagnitudeGreaterThan( + wpi::DualSenseController::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** * Get the Left X value of the controller. * @@ -349,7 +424,9 @@ class CommandDualSenseController { double GetR2() const; private: - CommandGenericHID* m_hid; - wpi::DualSenseController m_controller; + std::unique_ptr m_ownedHid; + CommandGenericHID* m_hid = nullptr; + std::unique_ptr m_ownedController; + wpi::DualSenseController* m_controller = nullptr; }; } // namespace wpi::cmd diff --git a/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandXboxController.hpp b/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandXboxController.hpp index 9a3a6fc6cb..23be4420e3 100644 --- a/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandXboxController.hpp +++ b/commandsv2/src/generated/main/native/include/wpi/commands2/button/CommandXboxController.hpp @@ -5,6 +5,8 @@ // THIS FILE WAS AUTO-GENERATED BY ./commandsv2/generate_hids.py. DO NOT MODIFY #pragma once +#include + #include "wpi/driverstation/XboxController.hpp" #include "wpi/commands2/CommandScheduler.hpp" @@ -28,6 +30,13 @@ class CommandXboxController { */ explicit CommandXboxController(int port); + /** + * Construct an instance of a controller with a XboxController object. + * + * @param controller The XboxController object to use for this controller. + */ + explicit CommandXboxController(wpi::XboxController* controller); + /** * Get the underlying CommandGenericHID object. * @@ -49,6 +58,20 @@ class CommandXboxController { */ const wpi::XboxController& GetController() const; + /** + * Constructs an event instance around this button's digital signal. + * + * @param button the button + * @param loop the event loop instance to attach the event to. Defaults to the + * CommandScheduler's default loop. + * @return an event instance representing the button's digital signal attached + * to the given loop. + */ + Trigger Button(enum wpi::XboxController::Button button, + wpi::EventLoop* loop = CommandScheduler::GetInstance() + .GetDefaultButtonLoop()) const; + + /** * Constructs a Trigger instance around the A button's * digital signal. @@ -280,6 +303,58 @@ class CommandXboxController { wpi::EventLoop* loop = CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + /** + * Constructs a Trigger instance that is true when the axis value is less than + * {@code threshold}, attached to {@link + * CommandScheduler::GetDefaultButtonLoop() the default command scheduler + * button loop}. + * @param axis The axis to read, starting at 0. + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the event to. Defaults to + * {@link CommandScheduler::GetDefaultButtonLoop() the default command + * scheduler button loop}. + * @return a Trigger instance that is true when the axis value is less than + * the provided threshold. + */ + Trigger AxisLessThan( + wpi::XboxController::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** + * Constructs a Trigger instance that is true when the axis value is greater + * than {@code threshold}, attached to {@link + * CommandScheduler::GetDefaultButtonLoop() the default command scheduler + * button loop}. + * @param axis The axis to read + * @param threshold The value below which this trigger should return true. + * @param loop the event loop instance to attach the event to. Defaults to + * {@link CommandScheduler::GetDefaultButtonLoop() the default command + * scheduler button loop}. + * @return a Trigger instance that is true when the axis value is greater than + * the provided threshold. + */ + Trigger AxisGreaterThan( + wpi::XboxController::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** + * Constructs a Trigger instance that is true when the axis magnitude value is + * greater than {@code threshold}, attached to the given loop. + * + * @param axis The axis to read + * @param threshold The value above which this trigger should return true. + * @param loop the event loop instance to attach the trigger to. + * @return a Trigger instance that is true when the axis magnitude value is + * greater than the provided threshold. + */ + Trigger AxisMagnitudeGreaterThan( + wpi::XboxController::Axis axis, double threshold, + wpi::EventLoop* loop = + CommandScheduler::GetInstance().GetDefaultButtonLoop()) const; + + /** * Get the Left X value of the controller. * @@ -323,7 +398,9 @@ class CommandXboxController { double GetRightTrigger() const; private: - CommandGenericHID* m_hid; - wpi::XboxController m_controller; + std::unique_ptr m_ownedHid; + CommandGenericHID* m_hid = nullptr; + std::unique_ptr m_ownedController; + wpi::XboxController* m_controller = nullptr; }; } // namespace wpi::cmd diff --git a/commandsv2/src/main/java/org/wpilib/command2/button/CommandGamepad.java b/commandsv2/src/main/java/org/wpilib/command2/button/CommandGamepad.java index 464ab5bcec..f5fa9925be 100644 --- a/commandsv2/src/main/java/org/wpilib/command2/button/CommandGamepad.java +++ b/commandsv2/src/main/java/org/wpilib/command2/button/CommandGamepad.java @@ -4,6 +4,7 @@ package org.wpilib.command2.button; +import java.util.Objects; import org.wpilib.command2.CommandScheduler; import org.wpilib.driverstation.DriverStation; import org.wpilib.driverstation.Gamepad; @@ -29,6 +30,16 @@ public class CommandGamepad { m_gamepad = DriverStation.getGamepad(port); } + /** + * Construct an instance of a controller with a Gamepad object. + * + * @param gamepad The Gamepad object to use for this controller. + */ + public CommandGamepad(Gamepad gamepad) { + m_gamepad = Objects.requireNonNull(gamepad, "Provided gamepad cannot be null"); + m_hid = new CommandGenericHID(m_gamepad.getHID()); + } + /** * Get the underlying CommandGenericHID object. * diff --git a/commandsv2/src/main/native/cpp/button/CommandGamepad.cpp b/commandsv2/src/main/native/cpp/button/CommandGamepad.cpp index c4d113a391..5cbf89a824 100644 --- a/commandsv2/src/main/native/cpp/button/CommandGamepad.cpp +++ b/commandsv2/src/main/native/cpp/button/CommandGamepad.cpp @@ -4,6 +4,8 @@ #include "wpi/commands2/button/CommandGamepad.hpp" +#include + #include "wpi/commands2/button/CommandGenericHID.hpp" using namespace wpi::cmd; @@ -12,6 +14,11 @@ CommandGamepad::CommandGamepad(int port) : m_hid{&CommandGenericHID::GetCommandGenericHID(port)}, m_gamepad{&wpi::DriverStation::GetGamepad(port)} {} +CommandGamepad::CommandGamepad(wpi::Gamepad* gamepad) + : m_ownedHid{std::make_unique(gamepad->GetHID())}, + m_hid{m_ownedHid.get()}, + m_gamepad{gamepad} {} + CommandGenericHID& CommandGamepad::GetHID() { return *m_hid; } diff --git a/commandsv2/src/main/native/include/wpi/commands2/button/CommandGamepad.hpp b/commandsv2/src/main/native/include/wpi/commands2/button/CommandGamepad.hpp index 7cd65fd471..0a73c6e859 100644 --- a/commandsv2/src/main/native/include/wpi/commands2/button/CommandGamepad.hpp +++ b/commandsv2/src/main/native/include/wpi/commands2/button/CommandGamepad.hpp @@ -3,6 +3,9 @@ // the WPILib BSD license file in the root directory of this project. #pragma once + +#include + #include "wpi/commands2/CommandScheduler.hpp" #include "wpi/commands2/button/CommandGenericHID.hpp" #include "wpi/commands2/button/Trigger.hpp" @@ -25,6 +28,13 @@ class CommandGamepad { */ explicit CommandGamepad(int port); + /** + * Construct an instance of a controller with a Gamepad object. + * + * @param gamepad The Gamepad object to use for this controller. + */ + explicit CommandGamepad(wpi::Gamepad* gamepad); + /** * Get the underlying CommandGenericHID object. * @@ -510,7 +520,8 @@ class CommandGamepad { double GetRightTrigger() const; private: - CommandGenericHID* m_hid; - wpi::Gamepad* m_gamepad; + std::unique_ptr m_ownedHid; + CommandGenericHID* m_hid = nullptr; + wpi::Gamepad* m_gamepad = nullptr; }; } // namespace wpi::cmd diff --git a/commandsv2/src/main/python/commands2/button/commanddualsensecontroller.py b/commandsv2/src/main/python/commands2/button/commanddualsensecontroller.py index 7957f71857..408bd454db 100644 --- a/commandsv2/src/main/python/commands2/button/commanddualsensecontroller.py +++ b/commandsv2/src/main/python/commands2/button/commanddualsensecontroller.py @@ -1,6 +1,6 @@ # THIS FILE WAS AUTO-GENERATED BY ./commandsv2/generate_hids.py. DO NOT MODIFY -from typing import Optional +from typing import Optional, Union from wpilib import EventLoop, DualSenseController @@ -8,13 +8,6 @@ from .commandgenerichid import CommandGenericHID from .trigger import Trigger -def _enum_value(value) -> int: - try: - return int(value) - except TypeError: - return value.value - - class CommandDualSenseController: """ A version of :class:`wpilib.DualSenseController` with :class:`.Trigger` factories for command-based. @@ -23,17 +16,19 @@ class CommandDualSenseController: _hid: CommandGenericHID _controller: DualSenseController - def __init__(self, port: int): + def __init__(self, hid: Union[int, DualSenseController]): """ Construct an instance of a controller. - :param port: The port index on the Driver Station that the controller is plugged into. + :param hid: The port index on the Driver Station that the controller is plugged into, + or the DualSenseController object to use for this controller. """ - self._hid = CommandGenericHID.getCommandGenericHID(port) - self._controller = DualSenseController(self._hid.getHID()) - - def __getattr__(self, name: str): - return getattr(self._hid, name) + if isinstance(hid, int): + self._hid = CommandGenericHID.getCommandGenericHID(hid) + self._controller = DualSenseController(self._hid.getHID()) + else: + self._hid = CommandGenericHID(hid.getHID()) + self._controller = hid def getHID(self) -> CommandGenericHID: """ @@ -51,6 +46,19 @@ class CommandDualSenseController: """ return self._controller + def button( + self, + button: DualSenseController.Button, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs an event instance around this button's digital signal. + + :param button: the :class:`wpilib.DualSenseController.Button` to read + :param loop: the event loop instance to attach the event to + """ + return self._hid.button(button.value, loop) + def cross(self, loop: Optional[EventLoop] = None) -> Trigger: """ Constructs a Trigger instance around the Cross button's digital signal. @@ -61,9 +69,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Cross button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.CROSS), loop - ) + return self.button(DualSenseController.Button.CROSS, loop) def circle(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -75,9 +81,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Circle button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.CIRCLE), loop - ) + return self.button(DualSenseController.Button.CIRCLE, loop) def square(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -89,9 +93,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Square button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.SQUARE), loop - ) + return self.button(DualSenseController.Button.SQUARE, loop) def triangle(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -103,9 +105,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Triangle button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.TRIANGLE), loop - ) + return self.button(DualSenseController.Button.TRIANGLE, loop) def create(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -117,9 +117,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Create button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.CREATE), loop - ) + return self.button(DualSenseController.Button.CREATE, loop) def PS(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -131,9 +129,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the PS button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.PS), loop - ) + return self.button(DualSenseController.Button.PS, loop) def options(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -145,9 +141,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Options button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.OPTIONS), loop - ) + return self.button(DualSenseController.Button.OPTIONS, loop) def L3(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -159,9 +153,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the L 3 button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.L3), loop - ) + return self.button(DualSenseController.Button.L3, loop) def R3(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -173,9 +165,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the R 3 button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.R3), loop - ) + return self.button(DualSenseController.Button.R3, loop) def L1(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -187,9 +177,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the L 1 button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.L1), loop - ) + return self.button(DualSenseController.Button.L1, loop) def R1(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -201,9 +189,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the R 1 button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.R1), loop - ) + return self.button(DualSenseController.Button.R1, loop) def dpadUp(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -215,9 +201,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Dpad Up button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.DPAD_UP), loop - ) + return self.button(DualSenseController.Button.DPAD_UP, loop) def dpadDown(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -229,9 +213,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Dpad Down button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.DPAD_DOWN), loop - ) + return self.button(DualSenseController.Button.DPAD_DOWN, loop) def dpadLeft(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -243,9 +225,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Dpad Left button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.DPAD_LEFT), loop - ) + return self.button(DualSenseController.Button.DPAD_LEFT, loop) def dpadRight(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -257,9 +237,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Dpad Right button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.DPAD_RIGHT), loop - ) + return self.button(DualSenseController.Button.DPAD_RIGHT, loop) def microphone(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -271,9 +249,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Microphone button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.MICROPHONE), loop - ) + return self.button(DualSenseController.Button.MICROPHONE, loop) def touchpad(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -285,9 +261,7 @@ class CommandDualSenseController: :returns: a Trigger instance representing the Touchpad button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(DualSenseController.Button.TOUCHPAD), loop - ) + return self.button(DualSenseController.Button.TOUCHPAD, loop) def L2( self, @@ -306,8 +280,8 @@ class CommandDualSenseController: :returns: a Trigger instance that is true when the L 2 axis exceeds the provided threshold, attached to the given event loop. """ - return self._hid.axisGreaterThan( - _enum_value(DualSenseController.Axis.L2), + return self.axisGreaterThan( + DualSenseController.Axis.L2, threshold, loop, ) @@ -329,12 +303,77 @@ class CommandDualSenseController: :returns: a Trigger instance that is true when the R 2 axis exceeds the provided threshold, attached to the given event loop. """ - return self._hid.axisGreaterThan( - _enum_value(DualSenseController.Axis.R2), + return self.axisGreaterThan( + DualSenseController.Axis.R2, threshold, loop, ) + def axisLessThan( + self, + axis: DualSenseController.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis value is less than + ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.DualSenseController.Axis` to read + :param threshold: the value below which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to + + :returns: a Trigger instance that is true when the axis value is less than + the provided threshold. + """ + return self._hid.axisLessThan(axis.value, threshold, loop) + + def axisGreaterThan( + self, + axis: DualSenseController.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis value is greater + than ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.DualSenseController.Axis` to read + :param threshold: the value above which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to. + + :returns: a Trigger instance that is true when the axis value is greater + than the provided threshold. + """ + return self._hid.axisGreaterThan(axis.value, threshold, loop) + + def axisMagnitudeGreaterThan( + self, + axis: DualSenseController.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis magnitude is + greater than ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.DualSenseController.Axis` to read + :param threshold: the value above which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to. + + :returns: a Trigger instance that is true when the axis magnitude is + greater than the provided threshold. + """ + return self._hid.axisMagnitudeGreaterThan(axis.value, threshold, loop) + + def getAxis(self, axis: DualSenseController.Axis) -> float: + """ + Get the value of the axis. + + :param axis: the :class:`wpilib.DualSenseController.Axis` to read + """ + return self._hid.getRawAxis(axis.value) + def getLeftX(self) -> float: """ Get the Left X value of the controller. diff --git a/commandsv2/src/main/python/commands2/button/commandgamepad.py b/commandsv2/src/main/python/commands2/button/commandgamepad.py index f92f779ff3..87b5b2f05b 100644 --- a/commandsv2/src/main/python/commands2/button/commandgamepad.py +++ b/commandsv2/src/main/python/commands2/button/commandgamepad.py @@ -1,5 +1,5 @@ # validated: 2024-01-20 DS 92149efa11fa button/CommandGamepad.java -from typing import Optional +from typing import Optional, Union from wpilib import DriverStation, EventLoop, Gamepad @@ -22,15 +22,20 @@ class CommandGamepad: _hid: CommandGenericHID _gamepad: Gamepad - def __init__(self, port: int): + def __init__(self, hid: Union[int, Gamepad]): """ Construct an instance of a controller. - :param port: The port index on the Driver Station that the controller is plugged into. + :param hid: The port index on the Driver Station that the controller is plugged into, + or the Gamepad object to use for this controller. """ - self._hid = CommandGenericHID.getCommandGenericHID(port) - self._gamepad = DriverStation.getGamepad(port) + if isinstance(hid, int): + self._hid = CommandGenericHID.getCommandGenericHID(hid) + self._gamepad = DriverStation.getGamepad(hid) + else: + self._hid = CommandGenericHID(hid.getHID()) + self._gamepad = hid def __getattr__(self, name: str): return getattr(self._hid, name) diff --git a/commandsv2/src/main/python/commands2/button/commandgenerichid.py b/commandsv2/src/main/python/commands2/button/commandgenerichid.py index a27d57a6ff..ef8dbd6645 100644 --- a/commandsv2/src/main/python/commands2/button/commandgenerichid.py +++ b/commandsv2/src/main/python/commands2/button/commandgenerichid.py @@ -1,6 +1,6 @@ # validated: 2024-01-20 DS 92149efa11fa button/CommandGenericHID.java import threading -from typing import ClassVar, Optional, final +from typing import ClassVar, Optional, Union, final from wpilib import DriverStation, EventLoop, GenericHID @@ -17,13 +17,17 @@ class CommandGenericHID: _hids: ClassVar[dict[int, "CommandGenericHID"]] = {} _hids_lock = threading.Lock() - def __init__(self, port: int): + def __init__(self, hid: Union[int, GenericHID]): """ Construct an instance of a device. - :param port: The port on the Driver Station that the device is plugged into. + :param hid: The port on the Driver Station that the device is plugged into, + or the GenericHID object to use for this command HID. """ - self._hid = DriverStation.getGenericHID(port) + if isinstance(hid, int): + self._hid = DriverStation.getGenericHID(hid) + else: + self._hid = hid @classmethod def getCommandGenericHID(cls, port: int) -> "CommandGenericHID": diff --git a/commandsv2/src/main/python/commands2/button/commandxboxcontroller.py b/commandsv2/src/main/python/commands2/button/commandxboxcontroller.py index 35f694a4e6..0eac920a9d 100644 --- a/commandsv2/src/main/python/commands2/button/commandxboxcontroller.py +++ b/commandsv2/src/main/python/commands2/button/commandxboxcontroller.py @@ -1,6 +1,6 @@ # THIS FILE WAS AUTO-GENERATED BY ./commandsv2/generate_hids.py. DO NOT MODIFY -from typing import Optional +from typing import Optional, Union from wpilib import EventLoop, XboxController @@ -8,13 +8,6 @@ from .commandgenerichid import CommandGenericHID from .trigger import Trigger -def _enum_value(value) -> int: - try: - return int(value) - except TypeError: - return value.value - - class CommandXboxController: """ A version of :class:`wpilib.XboxController` with :class:`.Trigger` factories for command-based. @@ -23,17 +16,19 @@ class CommandXboxController: _hid: CommandGenericHID _controller: XboxController - def __init__(self, port: int): + def __init__(self, hid: Union[int, XboxController]): """ Construct an instance of a controller. - :param port: The port index on the Driver Station that the controller is plugged into. + :param hid: The port index on the Driver Station that the controller is plugged into, + or the XboxController object to use for this controller. """ - self._hid = CommandGenericHID.getCommandGenericHID(port) - self._controller = XboxController(self._hid.getHID()) - - def __getattr__(self, name: str): - return getattr(self._hid, name) + if isinstance(hid, int): + self._hid = CommandGenericHID.getCommandGenericHID(hid) + self._controller = XboxController(self._hid.getHID()) + else: + self._hid = CommandGenericHID(hid.getHID()) + self._controller = hid def getHID(self) -> CommandGenericHID: """ @@ -51,6 +46,19 @@ class CommandXboxController: """ return self._controller + def button( + self, + button: XboxController.Button, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs an event instance around this button's digital signal. + + :param button: the :class:`wpilib.XboxController.Button` to read + :param loop: the event loop instance to attach the event to + """ + return self._hid.button(button.value, loop) + def a(self, loop: Optional[EventLoop] = None) -> Trigger: """ Constructs a Trigger instance around the A button's digital signal. @@ -61,9 +69,7 @@ class CommandXboxController: :returns: a Trigger instance representing the A button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.A), loop - ) + return self.button(XboxController.Button.A, loop) def b(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -75,9 +81,7 @@ class CommandXboxController: :returns: a Trigger instance representing the B button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.B), loop - ) + return self.button(XboxController.Button.B, loop) def x(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -89,9 +93,7 @@ class CommandXboxController: :returns: a Trigger instance representing the X button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.X), loop - ) + return self.button(XboxController.Button.X, loop) def y(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -103,9 +105,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Y button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.Y), loop - ) + return self.button(XboxController.Button.Y, loop) def view(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -117,9 +117,7 @@ class CommandXboxController: :returns: a Trigger instance representing the View button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.VIEW), loop - ) + return self.button(XboxController.Button.VIEW, loop) def xbox(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -131,9 +129,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Xbox button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.XBOX), loop - ) + return self.button(XboxController.Button.XBOX, loop) def menu(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -145,9 +141,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Menu button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.MENU), loop - ) + return self.button(XboxController.Button.MENU, loop) def leftStick(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -159,9 +153,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Left Stick button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.LEFT_STICK), loop - ) + return self.button(XboxController.Button.LEFT_STICK, loop) def rightStick(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -173,9 +165,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Right Stick button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.RIGHT_STICK), loop - ) + return self.button(XboxController.Button.RIGHT_STICK, loop) def leftBumper(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -187,9 +177,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Left Bumper button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.LEFT_BUMPER), loop - ) + return self.button(XboxController.Button.LEFT_BUMPER, loop) def rightBumper(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -201,9 +189,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Right Bumper button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.RIGHT_BUMPER), loop - ) + return self.button(XboxController.Button.RIGHT_BUMPER, loop) def dpadUp(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -215,9 +201,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Dpad Up button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.DPAD_UP), loop - ) + return self.button(XboxController.Button.DPAD_UP, loop) def dpadDown(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -229,9 +213,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Dpad Down button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.DPAD_DOWN), loop - ) + return self.button(XboxController.Button.DPAD_DOWN, loop) def dpadLeft(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -243,9 +225,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Dpad Left button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.DPAD_LEFT), loop - ) + return self.button(XboxController.Button.DPAD_LEFT, loop) def dpadRight(self, loop: Optional[EventLoop] = None) -> Trigger: """ @@ -257,9 +237,7 @@ class CommandXboxController: :returns: a Trigger instance representing the Dpad Right button's digital signal attached to the given loop. """ - return self._hid.button( - _enum_value(XboxController.Button.DPAD_RIGHT), loop - ) + return self.button(XboxController.Button.DPAD_RIGHT, loop) def leftTrigger( self, @@ -278,8 +256,8 @@ class CommandXboxController: :returns: a Trigger instance that is true when the Left Trigger axis exceeds the provided threshold, attached to the given event loop. """ - return self._hid.axisGreaterThan( - _enum_value(XboxController.Axis.LEFT_TRIGGER), + return self.axisGreaterThan( + XboxController.Axis.LEFT_TRIGGER, threshold, loop, ) @@ -301,12 +279,77 @@ class CommandXboxController: :returns: a Trigger instance that is true when the Right Trigger axis exceeds the provided threshold, attached to the given event loop. """ - return self._hid.axisGreaterThan( - _enum_value(XboxController.Axis.RIGHT_TRIGGER), + return self.axisGreaterThan( + XboxController.Axis.RIGHT_TRIGGER, threshold, loop, ) + def axisLessThan( + self, + axis: XboxController.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis value is less than + ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.XboxController.Axis` to read + :param threshold: the value below which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to + + :returns: a Trigger instance that is true when the axis value is less than + the provided threshold. + """ + return self._hid.axisLessThan(axis.value, threshold, loop) + + def axisGreaterThan( + self, + axis: XboxController.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis value is greater + than ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.XboxController.Axis` to read + :param threshold: the value above which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to. + + :returns: a Trigger instance that is true when the axis value is greater + than the provided threshold. + """ + return self._hid.axisGreaterThan(axis.value, threshold, loop) + + def axisMagnitudeGreaterThan( + self, + axis: XboxController.Axis, + threshold: float, + loop: Optional[EventLoop] = None, + ) -> Trigger: + """ + Constructs a Trigger instance that is true when the axis magnitude is + greater than ``threshold``, attached to the given loop. + + :param axis: the :class:`wpilib.XboxController.Axis` to read + :param threshold: the value above which this Trigger should return true. + :param loop: the event loop instance to attach the Trigger to. + + :returns: a Trigger instance that is true when the axis magnitude is + greater than the provided threshold. + """ + return self._hid.axisMagnitudeGreaterThan(axis.value, threshold, loop) + + def getAxis(self, axis: XboxController.Axis) -> float: + """ + Get the value of the axis. + + :param axis: the :class:`wpilib.XboxController.Axis` to read + """ + return self._hid.getRawAxis(axis.value) + def getLeftX(self) -> float: """ Get the Left X value of the controller. diff --git a/commandsv3/src/generate/main/java/first_ds_commandhid.java.jinja b/commandsv3/src/generate/main/java/first_ds_commandhid.java.jinja index b9a1a2ee42..a0a9eb9930 100644 --- a/commandsv3/src/generate/main/java/first_ds_commandhid.java.jinja +++ b/commandsv3/src/generate/main/java/first_ds_commandhid.java.jinja @@ -6,6 +6,7 @@ package org.wpilib.command3.button; +import java.util.Objects; import org.wpilib.command3.Scheduler; import org.wpilib.command3.Trigger; import org.wpilib.driverstation.{{ ClassName }}Controller; @@ -31,6 +32,16 @@ public class Command{{ ClassName }}Controller { this(Scheduler.getDefault(), port); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the {@link Scheduler#getDefault() default scheduler} using its default event loop. + * + * @param controller The {{ ClassName }}Controller object to use for this controller. + */ + public Command{{ ClassName }}Controller({{ ClassName }}Controller controller) { + this(Scheduler.getDefault(), controller); + } + /** * Construct an instance of a controller. Commands bound to buttons on the controller will be * scheduled on the given scheduler using its default event loop. @@ -43,6 +54,19 @@ public class Command{{ ClassName }}Controller { m_controller = new {{ ClassName }}Controller(m_hid.getHID()); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the given scheduler using its default event loop. + * + * @param scheduler The scheduler that should execute the triggered commands. + * @param controller The {{ ClassName }}Controller object to use for this controller. + */ + public Command{{ ClassName }}Controller(Scheduler scheduler, {{ ClassName }}Controller controller) { + m_controller = + Objects.requireNonNull(controller, "Provided {{ ClassName }}Controller cannot be null"); + m_hid = new CommandGenericHID(scheduler, m_controller.getHID()); + } + /** * Get the underlying CommandGenericHID object. * diff --git a/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandDualSenseController.java b/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandDualSenseController.java index d8eccd5aa0..18915d59fb 100644 --- a/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandDualSenseController.java +++ b/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandDualSenseController.java @@ -6,6 +6,7 @@ package org.wpilib.command3.button; +import java.util.Objects; import org.wpilib.command3.Scheduler; import org.wpilib.command3.Trigger; import org.wpilib.driverstation.DualSenseController; @@ -31,6 +32,16 @@ public class CommandDualSenseController { this(Scheduler.getDefault(), port); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the {@link Scheduler#getDefault() default scheduler} using its default event loop. + * + * @param controller The DualSenseController object to use for this controller. + */ + public CommandDualSenseController(DualSenseController controller) { + this(Scheduler.getDefault(), controller); + } + /** * Construct an instance of a controller. Commands bound to buttons on the controller will be * scheduled on the given scheduler using its default event loop. @@ -43,6 +54,19 @@ public class CommandDualSenseController { m_controller = new DualSenseController(m_hid.getHID()); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the given scheduler using its default event loop. + * + * @param scheduler The scheduler that should execute the triggered commands. + * @param controller The DualSenseController object to use for this controller. + */ + public CommandDualSenseController(Scheduler scheduler, DualSenseController controller) { + m_controller = + Objects.requireNonNull(controller, "Provided DualSenseController cannot be null"); + m_hid = new CommandGenericHID(scheduler, m_controller.getHID()); + } + /** * Get the underlying CommandGenericHID object. * diff --git a/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandXboxController.java b/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandXboxController.java index ebde4acad3..915ee6d1ae 100644 --- a/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandXboxController.java +++ b/commandsv3/src/generated/main/java/org/wpilib/command3/button/CommandXboxController.java @@ -6,6 +6,7 @@ package org.wpilib.command3.button; +import java.util.Objects; import org.wpilib.command3.Scheduler; import org.wpilib.command3.Trigger; import org.wpilib.driverstation.XboxController; @@ -31,6 +32,16 @@ public class CommandXboxController { this(Scheduler.getDefault(), port); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the {@link Scheduler#getDefault() default scheduler} using its default event loop. + * + * @param controller The XboxController object to use for this controller. + */ + public CommandXboxController(XboxController controller) { + this(Scheduler.getDefault(), controller); + } + /** * Construct an instance of a controller. Commands bound to buttons on the controller will be * scheduled on the given scheduler using its default event loop. @@ -43,6 +54,19 @@ public class CommandXboxController { m_controller = new XboxController(m_hid.getHID()); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the given scheduler using its default event loop. + * + * @param scheduler The scheduler that should execute the triggered commands. + * @param controller The XboxController object to use for this controller. + */ + public CommandXboxController(Scheduler scheduler, XboxController controller) { + m_controller = + Objects.requireNonNull(controller, "Provided XboxController cannot be null"); + m_hid = new CommandGenericHID(scheduler, m_controller.getHID()); + } + /** * Get the underlying CommandGenericHID object. * diff --git a/commandsv3/src/main/java/org/wpilib/command3/button/CommandGamepad.java b/commandsv3/src/main/java/org/wpilib/command3/button/CommandGamepad.java index 1de551e14d..b1d99bb717 100644 --- a/commandsv3/src/main/java/org/wpilib/command3/button/CommandGamepad.java +++ b/commandsv3/src/main/java/org/wpilib/command3/button/CommandGamepad.java @@ -4,6 +4,7 @@ package org.wpilib.command3.button; +import java.util.Objects; import org.wpilib.command3.Scheduler; import org.wpilib.command3.Trigger; import org.wpilib.driverstation.DriverStation; @@ -29,6 +30,16 @@ public class CommandGamepad { this(Scheduler.getDefault(), port); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the {@link Scheduler#getDefault() default scheduler} using its default event loop. + * + * @param gamepad The Gamepad object to use for this controller. + */ + public CommandGamepad(Gamepad gamepad) { + this(Scheduler.getDefault(), gamepad); + } + /** * Construct an instance of a controller. * @@ -40,6 +51,18 @@ public class CommandGamepad { m_gamepad = DriverStation.getGamepad(port); } + /** + * Construct an instance of a controller. Commands bound to buttons on the controller will be + * scheduled on the given scheduler using its default event loop. + * + * @param scheduler The scheduler that should execute the triggered commands. + * @param gamepad The Gamepad object to use for this controller. + */ + public CommandGamepad(Scheduler scheduler, Gamepad gamepad) { + m_gamepad = Objects.requireNonNull(gamepad, "Provided gamepad cannot be null"); + m_hid = new CommandGenericHID(scheduler, m_gamepad.getHID()); + } + /** * Get the underlying CommandGenericHID object. * diff --git a/wpilibc/robotpy_pybind_build_info.bzl b/wpilibc/robotpy_pybind_build_info.bzl index 5599718d67..6164e8b22f 100644 --- a/wpilibc/robotpy_pybind_build_info.bzl +++ b/wpilibc/robotpy_pybind_build_info.bzl @@ -239,8 +239,6 @@ def wpilib_extension(srcs = [], header_to_dat_deps = [], extra_hdrs = [], includ tmpl_class_names = [], trampolines = [ ("wpi::DualSenseController", "wpi__DualSenseController.hpp"), - ("wpi::DualSenseController::Button", "wpi__DualSenseController__Button.hpp"), - ("wpi::DualSenseController::Axis", "wpi__DualSenseController__Axis.hpp"), ], ), struct( @@ -251,8 +249,6 @@ def wpilib_extension(srcs = [], header_to_dat_deps = [], extra_hdrs = [], includ tmpl_class_names = [], trampolines = [ ("wpi::XboxController", "wpi__XboxController.hpp"), - ("wpi::XboxController::Button", "wpi__XboxController__Button.hpp"), - ("wpi::XboxController::Axis", "wpi__XboxController__Axis.hpp"), ], ), struct( diff --git a/wpilibc/src/generate/main/native/cpp/driverstation/first_ds_hid.cpp.jinja b/wpilibc/src/generate/main/native/cpp/driverstation/first_ds_hid.cpp.jinja index 44b5a36c87..e14bd1e954 100644 --- a/wpilibc/src/generate/main/native/cpp/driverstation/first_ds_hid.cpp.jinja +++ b/wpilibc/src/generate/main/native/cpp/driverstation/first_ds_hid.cpp.jinja @@ -40,18 +40,18 @@ double {{ ClassName }}Controller::Get{{ axis.MethodName }}() const { return GetAxis(Axis::{{ axis.ConstantName }}); } {% endfor %} -double {{ ClassName }}Controller::GetAxis(int axis) const { - return m_hid->GetRawAxis(axis); +double {{ ClassName }}Controller::GetAxis(Axis axis) const { + return m_hid->GetRawAxis(static_cast(axis)); } -BooleanEvent {{ ClassName }}Controller::AxisLessThan(int axis, double threshold, +BooleanEvent {{ ClassName }}Controller::AxisLessThan(Axis axis, double threshold, EventLoop* loop) const { - return m_hid->AxisLessThan(axis, threshold, loop); + return m_hid->AxisLessThan(static_cast(axis), threshold, loop); } BooleanEvent {{ ClassName }}Controller::AxisGreaterThan( - int axis, double threshold, EventLoop* loop) const { - return m_hid->AxisGreaterThan(axis, threshold, loop); + Axis axis, double threshold, EventLoop* loop) const { + return m_hid->AxisGreaterThan(static_cast(axis), threshold, loop); } {% for button in buttons %} bool {{ ClassName }}Controller::Get{{ button.MethodName }}Button() const { @@ -70,21 +70,21 @@ BooleanEvent {{ ClassName }}Controller::{{ button.MethodName }}(EventLoop* loop) return ButtonEvent(Button::{{ button.ConstantName }}, loop); } {% endfor %} -bool {{ ClassName }}Controller::GetButton(int button) const { - return m_hid->GetRawButton(button); +bool {{ ClassName }}Controller::GetButton(Button button) const { + return m_hid->GetRawButton(static_cast(button)); } -bool {{ ClassName }}Controller::GetButtonPressed(int button) { - return m_hid->GetRawButtonPressed(button); +bool {{ ClassName }}Controller::GetButtonPressed(Button button) { + return m_hid->GetRawButtonPressed(static_cast(button)); } -bool {{ ClassName }}Controller::GetButtonReleased(int button) { - return m_hid->GetRawButtonReleased(button); +bool {{ ClassName }}Controller::GetButtonReleased(Button button) { + return m_hid->GetRawButtonReleased(static_cast(button)); } -BooleanEvent {{ ClassName }}Controller::ButtonEvent(int button, +BooleanEvent {{ ClassName }}Controller::ButtonEvent(Button button, EventLoop* loop) const { - return m_hid->Button(button, loop); + return m_hid->Button(static_cast(button), loop); } void {{ ClassName }}Controller::SetLeds(int r, int g, int b) { diff --git a/wpilibc/src/generate/main/native/cpp/simulation/first_ds_hidsim.cpp.jinja b/wpilibc/src/generate/main/native/cpp/simulation/first_ds_hidsim.cpp.jinja index 182a6eb448..8ad89bf408 100644 --- a/wpilibc/src/generate/main/native/cpp/simulation/first_ds_hidsim.cpp.jinja +++ b/wpilibc/src/generate/main/native/cpp/simulation/first_ds_hidsim.cpp.jinja @@ -28,11 +28,11 @@ using namespace wpi::sim; } {% for axis in axes %} void {{ ClassName }}ControllerSim::Set{{ axis.MethodName }}(double value) { - SetRawAxis({{ ClassName }}Controller::Axis::{{ axis.ConstantName }}, value); + SetRawAxis(static_cast({{ ClassName }}Controller::Axis::{{ axis.ConstantName }}), value); } {% endfor -%} {% for button in buttons %} void {{ ClassName }}ControllerSim::Set{{ button.MethodName }}Button(bool value) { - SetRawButton({{ ClassName }}Controller::Button::{{ button.ConstantName }}, value); + SetRawButton(static_cast({{ ClassName }}Controller::Button::{{ button.ConstantName }}), value); } {% endfor -%} diff --git a/wpilibc/src/generate/main/native/include/wpi/driverstation/first_ds_hid.hpp.jinja b/wpilibc/src/generate/main/native/include/wpi/driverstation/first_ds_hid.hpp.jinja index 9b1f28c823..4dc99473e3 100644 --- a/wpilibc/src/generate/main/native/include/wpi/driverstation/first_ds_hid.hpp.jinja +++ b/wpilibc/src/generate/main/native/include/wpi/driverstation/first_ds_hid.hpp.jinja @@ -46,6 +46,22 @@ class {{ ClassName }}Controller static constexpr GenericHID::SupportedOutputs SUPPORTED_OUTPUTS = static_cast({{ SupportedOutputsValue }}); + /** Represents a digital button on a {{ ClassName }}Controller. */ + enum class Button { +{%- for button in buttons %} + /// {{ button.DocName }} button. + {{ button.ConstantName }} = {{ button.value }}, +{%- endfor %} + }; + + /** Represents an axis on a {{ ClassName }}Controller. */ + enum class Axis { +{%- for axis in axes %} + /// {{ axis.DocName }}. + {{ axis.ConstantName }} = {{ axis.value }}, +{%- endfor %} + }; + /** * Construct an instance of a controller. * @@ -109,7 +125,7 @@ class {{ ClassName }}Controller * @param axis The axis to read * @return the axis value. */ - double GetAxis(int axis) const; + double GetAxis(Axis axis) const; /** * Constructs an event instance that is true when the axis value is less than @@ -121,7 +137,7 @@ class {{ ClassName }}Controller * @return an event instance that is true when the axis value is less than the * provided threshold. */ - BooleanEvent AxisLessThan(int axis, double threshold, EventLoop* loop) const; + BooleanEvent AxisLessThan(Axis axis, double threshold, EventLoop* loop) const; /** * Constructs an event instance that is true when the axis value is greater @@ -133,7 +149,7 @@ class {{ ClassName }}Controller * @return an event instance that is true when the axis value is greater than * the provided threshold. */ - BooleanEvent AxisGreaterThan(int axis, double threshold, + BooleanEvent AxisGreaterThan(Axis axis, double threshold, EventLoop* loop) const; {% for button in buttons %} /** @@ -173,7 +189,7 @@ class {{ ClassName }}Controller * @param button The button to read * @return The state of the button. */ - bool GetButton(int button) const; + bool GetButton(Button button) const; /** * Whether the button was pressed since the last check. @@ -181,7 +197,7 @@ class {{ ClassName }}Controller * @param button The button to read * @return Whether the button was pressed since the last check. */ - bool GetButtonPressed(int button); + bool GetButtonPressed(Button button); /** * Whether the button was released since the last check. @@ -189,7 +205,7 @@ class {{ ClassName }}Controller * @param button The button to read * @return Whether the button was released since the last check. */ - bool GetButtonReleased(int button); + bool GetButtonReleased(Button button); /** * Constructs an event instance around this button's digital signal. @@ -199,7 +215,7 @@ class {{ ClassName }}Controller * @return an event instance representing the button's digital signal attached * to the given loop. */ - BooleanEvent ButtonEvent(int button, EventLoop* loop) const; + BooleanEvent ButtonEvent(Button button, EventLoop* loop) const; /** * Set leds on the controller. @@ -250,22 +266,6 @@ class {{ ClassName }}Controller TouchpadFinger GetTouchpadFinger(int touchpad, int finger) const; {%- endif %} - /** Represents a digital button on a {{ ClassName }}Controller. */ - struct Button { -{%- for button in buttons %} - /// {{ button.DocName }} button. - static constexpr int {{ button.ConstantName }} = {{ button.value }}; -{%- endfor %} - }; - - /** Represents an axis on a {{ ClassName }}Controller. */ - struct Axis { -{%- for axis in axes %} - /// {{ axis.DocName }}. - static constexpr int {{ axis.ConstantName }} = {{ axis.value }}; -{%- endfor %} - }; - void InitSendable(wpi::util::SendableBuilder& builder) override; private: diff --git a/wpilibc/src/generated/main/native/cpp/driverstation/DualSenseController.cpp b/wpilibc/src/generated/main/native/cpp/driverstation/DualSenseController.cpp index f0d13f353c..3e05beaf33 100644 --- a/wpilibc/src/generated/main/native/cpp/driverstation/DualSenseController.cpp +++ b/wpilibc/src/generated/main/native/cpp/driverstation/DualSenseController.cpp @@ -60,18 +60,18 @@ double DualSenseController::GetR2() const { return GetAxis(Axis::R2); } -double DualSenseController::GetAxis(int axis) const { - return m_hid->GetRawAxis(axis); +double DualSenseController::GetAxis(Axis axis) const { + return m_hid->GetRawAxis(static_cast(axis)); } -BooleanEvent DualSenseController::AxisLessThan(int axis, double threshold, +BooleanEvent DualSenseController::AxisLessThan(Axis axis, double threshold, EventLoop* loop) const { - return m_hid->AxisLessThan(axis, threshold, loop); + return m_hid->AxisLessThan(static_cast(axis), threshold, loop); } BooleanEvent DualSenseController::AxisGreaterThan( - int axis, double threshold, EventLoop* loop) const { - return m_hid->AxisGreaterThan(axis, threshold, loop); + Axis axis, double threshold, EventLoop* loop) const { + return m_hid->AxisGreaterThan(static_cast(axis), threshold, loop); } bool DualSenseController::GetCrossButton() const { @@ -346,21 +346,21 @@ BooleanEvent DualSenseController::Touchpad(EventLoop* loop) const { return ButtonEvent(Button::TOUCHPAD, loop); } -bool DualSenseController::GetButton(int button) const { - return m_hid->GetRawButton(button); +bool DualSenseController::GetButton(Button button) const { + return m_hid->GetRawButton(static_cast(button)); } -bool DualSenseController::GetButtonPressed(int button) { - return m_hid->GetRawButtonPressed(button); +bool DualSenseController::GetButtonPressed(Button button) { + return m_hid->GetRawButtonPressed(static_cast(button)); } -bool DualSenseController::GetButtonReleased(int button) { - return m_hid->GetRawButtonReleased(button); +bool DualSenseController::GetButtonReleased(Button button) { + return m_hid->GetRawButtonReleased(static_cast(button)); } -BooleanEvent DualSenseController::ButtonEvent(int button, +BooleanEvent DualSenseController::ButtonEvent(Button button, EventLoop* loop) const { - return m_hid->Button(button, loop); + return m_hid->Button(static_cast(button), loop); } void DualSenseController::SetLeds(int r, int g, int b) { diff --git a/wpilibc/src/generated/main/native/cpp/driverstation/XboxController.cpp b/wpilibc/src/generated/main/native/cpp/driverstation/XboxController.cpp index 45061e750d..f941d53ac6 100644 --- a/wpilibc/src/generated/main/native/cpp/driverstation/XboxController.cpp +++ b/wpilibc/src/generated/main/native/cpp/driverstation/XboxController.cpp @@ -60,18 +60,18 @@ double XboxController::GetRightTrigger() const { return GetAxis(Axis::RIGHT_TRIGGER); } -double XboxController::GetAxis(int axis) const { - return m_hid->GetRawAxis(axis); +double XboxController::GetAxis(Axis axis) const { + return m_hid->GetRawAxis(static_cast(axis)); } -BooleanEvent XboxController::AxisLessThan(int axis, double threshold, +BooleanEvent XboxController::AxisLessThan(Axis axis, double threshold, EventLoop* loop) const { - return m_hid->AxisLessThan(axis, threshold, loop); + return m_hid->AxisLessThan(static_cast(axis), threshold, loop); } BooleanEvent XboxController::AxisGreaterThan( - int axis, double threshold, EventLoop* loop) const { - return m_hid->AxisGreaterThan(axis, threshold, loop); + Axis axis, double threshold, EventLoop* loop) const { + return m_hid->AxisGreaterThan(static_cast(axis), threshold, loop); } bool XboxController::GetAButton() const { @@ -314,21 +314,21 @@ BooleanEvent XboxController::DpadRight(EventLoop* loop) const { return ButtonEvent(Button::DPAD_RIGHT, loop); } -bool XboxController::GetButton(int button) const { - return m_hid->GetRawButton(button); +bool XboxController::GetButton(Button button) const { + return m_hid->GetRawButton(static_cast(button)); } -bool XboxController::GetButtonPressed(int button) { - return m_hid->GetRawButtonPressed(button); +bool XboxController::GetButtonPressed(Button button) { + return m_hid->GetRawButtonPressed(static_cast(button)); } -bool XboxController::GetButtonReleased(int button) { - return m_hid->GetRawButtonReleased(button); +bool XboxController::GetButtonReleased(Button button) { + return m_hid->GetRawButtonReleased(static_cast(button)); } -BooleanEvent XboxController::ButtonEvent(int button, +BooleanEvent XboxController::ButtonEvent(Button button, EventLoop* loop) const { - return m_hid->Button(button, loop); + return m_hid->Button(static_cast(button), loop); } void XboxController::SetLeds(int r, int g, int b) { diff --git a/wpilibc/src/generated/main/native/cpp/simulation/DualSenseControllerSim.cpp b/wpilibc/src/generated/main/native/cpp/simulation/DualSenseControllerSim.cpp index 32890b28e9..c410ee96e3 100644 --- a/wpilibc/src/generated/main/native/cpp/simulation/DualSenseControllerSim.cpp +++ b/wpilibc/src/generated/main/native/cpp/simulation/DualSenseControllerSim.cpp @@ -28,93 +28,93 @@ DualSenseControllerSim::DualSenseControllerSim(int port) : GenericHIDSim{port} { } void DualSenseControllerSim::SetLeftX(double value) { - SetRawAxis(DualSenseController::Axis::LEFT_X, value); + SetRawAxis(static_cast(DualSenseController::Axis::LEFT_X), value); } void DualSenseControllerSim::SetLeftY(double value) { - SetRawAxis(DualSenseController::Axis::LEFT_Y, value); + SetRawAxis(static_cast(DualSenseController::Axis::LEFT_Y), value); } void DualSenseControllerSim::SetRightX(double value) { - SetRawAxis(DualSenseController::Axis::RIGHT_X, value); + SetRawAxis(static_cast(DualSenseController::Axis::RIGHT_X), value); } void DualSenseControllerSim::SetRightY(double value) { - SetRawAxis(DualSenseController::Axis::RIGHT_Y, value); + SetRawAxis(static_cast(DualSenseController::Axis::RIGHT_Y), value); } void DualSenseControllerSim::SetL2(double value) { - SetRawAxis(DualSenseController::Axis::L2, value); + SetRawAxis(static_cast(DualSenseController::Axis::L2), value); } void DualSenseControllerSim::SetR2(double value) { - SetRawAxis(DualSenseController::Axis::R2, value); + SetRawAxis(static_cast(DualSenseController::Axis::R2), value); } void DualSenseControllerSim::SetCrossButton(bool value) { - SetRawButton(DualSenseController::Button::CROSS, value); + SetRawButton(static_cast(DualSenseController::Button::CROSS), value); } void DualSenseControllerSim::SetCircleButton(bool value) { - SetRawButton(DualSenseController::Button::CIRCLE, value); + SetRawButton(static_cast(DualSenseController::Button::CIRCLE), value); } void DualSenseControllerSim::SetSquareButton(bool value) { - SetRawButton(DualSenseController::Button::SQUARE, value); + SetRawButton(static_cast(DualSenseController::Button::SQUARE), value); } void DualSenseControllerSim::SetTriangleButton(bool value) { - SetRawButton(DualSenseController::Button::TRIANGLE, value); + SetRawButton(static_cast(DualSenseController::Button::TRIANGLE), value); } void DualSenseControllerSim::SetCreateButton(bool value) { - SetRawButton(DualSenseController::Button::CREATE, value); + SetRawButton(static_cast(DualSenseController::Button::CREATE), value); } void DualSenseControllerSim::SetPSButton(bool value) { - SetRawButton(DualSenseController::Button::PS, value); + SetRawButton(static_cast(DualSenseController::Button::PS), value); } void DualSenseControllerSim::SetOptionsButton(bool value) { - SetRawButton(DualSenseController::Button::OPTIONS, value); + SetRawButton(static_cast(DualSenseController::Button::OPTIONS), value); } void DualSenseControllerSim::SetL3Button(bool value) { - SetRawButton(DualSenseController::Button::L3, value); + SetRawButton(static_cast(DualSenseController::Button::L3), value); } void DualSenseControllerSim::SetR3Button(bool value) { - SetRawButton(DualSenseController::Button::R3, value); + SetRawButton(static_cast(DualSenseController::Button::R3), value); } void DualSenseControllerSim::SetL1Button(bool value) { - SetRawButton(DualSenseController::Button::L1, value); + SetRawButton(static_cast(DualSenseController::Button::L1), value); } void DualSenseControllerSim::SetR1Button(bool value) { - SetRawButton(DualSenseController::Button::R1, value); + SetRawButton(static_cast(DualSenseController::Button::R1), value); } void DualSenseControllerSim::SetDpadUpButton(bool value) { - SetRawButton(DualSenseController::Button::DPAD_UP, value); + SetRawButton(static_cast(DualSenseController::Button::DPAD_UP), value); } void DualSenseControllerSim::SetDpadDownButton(bool value) { - SetRawButton(DualSenseController::Button::DPAD_DOWN, value); + SetRawButton(static_cast(DualSenseController::Button::DPAD_DOWN), value); } void DualSenseControllerSim::SetDpadLeftButton(bool value) { - SetRawButton(DualSenseController::Button::DPAD_LEFT, value); + SetRawButton(static_cast(DualSenseController::Button::DPAD_LEFT), value); } void DualSenseControllerSim::SetDpadRightButton(bool value) { - SetRawButton(DualSenseController::Button::DPAD_RIGHT, value); + SetRawButton(static_cast(DualSenseController::Button::DPAD_RIGHT), value); } void DualSenseControllerSim::SetMicrophoneButton(bool value) { - SetRawButton(DualSenseController::Button::MICROPHONE, value); + SetRawButton(static_cast(DualSenseController::Button::MICROPHONE), value); } void DualSenseControllerSim::SetTouchpadButton(bool value) { - SetRawButton(DualSenseController::Button::TOUCHPAD, value); + SetRawButton(static_cast(DualSenseController::Button::TOUCHPAD), value); } diff --git a/wpilibc/src/generated/main/native/cpp/simulation/XboxControllerSim.cpp b/wpilibc/src/generated/main/native/cpp/simulation/XboxControllerSim.cpp index 18d0b08ee6..ae6d2e6201 100644 --- a/wpilibc/src/generated/main/native/cpp/simulation/XboxControllerSim.cpp +++ b/wpilibc/src/generated/main/native/cpp/simulation/XboxControllerSim.cpp @@ -28,85 +28,85 @@ XboxControllerSim::XboxControllerSim(int port) : GenericHIDSim{port} { } void XboxControllerSim::SetLeftX(double value) { - SetRawAxis(XboxController::Axis::LEFT_X, value); + SetRawAxis(static_cast(XboxController::Axis::LEFT_X), value); } void XboxControllerSim::SetLeftY(double value) { - SetRawAxis(XboxController::Axis::LEFT_Y, value); + SetRawAxis(static_cast(XboxController::Axis::LEFT_Y), value); } void XboxControllerSim::SetRightX(double value) { - SetRawAxis(XboxController::Axis::RIGHT_X, value); + SetRawAxis(static_cast(XboxController::Axis::RIGHT_X), value); } void XboxControllerSim::SetRightY(double value) { - SetRawAxis(XboxController::Axis::RIGHT_Y, value); + SetRawAxis(static_cast(XboxController::Axis::RIGHT_Y), value); } void XboxControllerSim::SetLeftTrigger(double value) { - SetRawAxis(XboxController::Axis::LEFT_TRIGGER, value); + SetRawAxis(static_cast(XboxController::Axis::LEFT_TRIGGER), value); } void XboxControllerSim::SetRightTrigger(double value) { - SetRawAxis(XboxController::Axis::RIGHT_TRIGGER, value); + SetRawAxis(static_cast(XboxController::Axis::RIGHT_TRIGGER), value); } void XboxControllerSim::SetAButton(bool value) { - SetRawButton(XboxController::Button::A, value); + SetRawButton(static_cast(XboxController::Button::A), value); } void XboxControllerSim::SetBButton(bool value) { - SetRawButton(XboxController::Button::B, value); + SetRawButton(static_cast(XboxController::Button::B), value); } void XboxControllerSim::SetXButton(bool value) { - SetRawButton(XboxController::Button::X, value); + SetRawButton(static_cast(XboxController::Button::X), value); } void XboxControllerSim::SetYButton(bool value) { - SetRawButton(XboxController::Button::Y, value); + SetRawButton(static_cast(XboxController::Button::Y), value); } void XboxControllerSim::SetViewButton(bool value) { - SetRawButton(XboxController::Button::VIEW, value); + SetRawButton(static_cast(XboxController::Button::VIEW), value); } void XboxControllerSim::SetXboxButton(bool value) { - SetRawButton(XboxController::Button::XBOX, value); + SetRawButton(static_cast(XboxController::Button::XBOX), value); } void XboxControllerSim::SetMenuButton(bool value) { - SetRawButton(XboxController::Button::MENU, value); + SetRawButton(static_cast(XboxController::Button::MENU), value); } void XboxControllerSim::SetLeftStickButton(bool value) { - SetRawButton(XboxController::Button::LEFT_STICK, value); + SetRawButton(static_cast(XboxController::Button::LEFT_STICK), value); } void XboxControllerSim::SetRightStickButton(bool value) { - SetRawButton(XboxController::Button::RIGHT_STICK, value); + SetRawButton(static_cast(XboxController::Button::RIGHT_STICK), value); } void XboxControllerSim::SetLeftBumperButton(bool value) { - SetRawButton(XboxController::Button::LEFT_BUMPER, value); + SetRawButton(static_cast(XboxController::Button::LEFT_BUMPER), value); } void XboxControllerSim::SetRightBumperButton(bool value) { - SetRawButton(XboxController::Button::RIGHT_BUMPER, value); + SetRawButton(static_cast(XboxController::Button::RIGHT_BUMPER), value); } void XboxControllerSim::SetDpadUpButton(bool value) { - SetRawButton(XboxController::Button::DPAD_UP, value); + SetRawButton(static_cast(XboxController::Button::DPAD_UP), value); } void XboxControllerSim::SetDpadDownButton(bool value) { - SetRawButton(XboxController::Button::DPAD_DOWN, value); + SetRawButton(static_cast(XboxController::Button::DPAD_DOWN), value); } void XboxControllerSim::SetDpadLeftButton(bool value) { - SetRawButton(XboxController::Button::DPAD_LEFT, value); + SetRawButton(static_cast(XboxController::Button::DPAD_LEFT), value); } void XboxControllerSim::SetDpadRightButton(bool value) { - SetRawButton(XboxController::Button::DPAD_RIGHT, value); + SetRawButton(static_cast(XboxController::Button::DPAD_RIGHT), value); } diff --git a/wpilibc/src/generated/main/native/include/wpi/driverstation/DualSenseController.hpp b/wpilibc/src/generated/main/native/include/wpi/driverstation/DualSenseController.hpp index c1368626c5..a6702d655e 100644 --- a/wpilibc/src/generated/main/native/include/wpi/driverstation/DualSenseController.hpp +++ b/wpilibc/src/generated/main/native/include/wpi/driverstation/DualSenseController.hpp @@ -46,6 +46,60 @@ class DualSenseController static constexpr GenericHID::SupportedOutputs SUPPORTED_OUTPUTS = static_cast(26); + /** Represents a digital button on a DualSenseController. */ + enum class Button { + /// Cross button. + CROSS = 0, + /// Circle button. + CIRCLE = 1, + /// Square button. + SQUARE = 2, + /// Triangle button. + TRIANGLE = 3, + /// Create button. + CREATE = 4, + /// PS button. + PS = 5, + /// Options button. + OPTIONS = 6, + /// L 3 button. + L3 = 7, + /// R 3 button. + R3 = 8, + /// L 1 button. + L1 = 9, + /// R 1 button. + R1 = 10, + /// Dpad Up button. + DPAD_UP = 11, + /// Dpad Down button. + DPAD_DOWN = 12, + /// Dpad Left button. + DPAD_LEFT = 13, + /// Dpad Right button. + DPAD_RIGHT = 14, + /// Microphone button. + MICROPHONE = 15, + /// Touchpad button. + TOUCHPAD = 20, + }; + + /** Represents an axis on a DualSenseController. */ + enum class Axis { + /// Left X. + LEFT_X = 0, + /// Left Y. + LEFT_Y = 1, + /// Right X. + RIGHT_X = 2, + /// Right Y. + RIGHT_Y = 3, + /// L 2. + L2 = 4, + /// R 2. + R2 = 5, + }; + /** * Construct an instance of a controller. * @@ -144,7 +198,7 @@ class DualSenseController * @param axis The axis to read * @return the axis value. */ - double GetAxis(int axis) const; + double GetAxis(Axis axis) const; /** * Constructs an event instance that is true when the axis value is less than @@ -156,7 +210,7 @@ class DualSenseController * @return an event instance that is true when the axis value is less than the * provided threshold. */ - BooleanEvent AxisLessThan(int axis, double threshold, EventLoop* loop) const; + BooleanEvent AxisLessThan(Axis axis, double threshold, EventLoop* loop) const; /** * Constructs an event instance that is true when the axis value is greater @@ -168,7 +222,7 @@ class DualSenseController * @return an event instance that is true when the axis value is greater than * the provided threshold. */ - BooleanEvent AxisGreaterThan(int axis, double threshold, + BooleanEvent AxisGreaterThan(Axis axis, double threshold, EventLoop* loop) const; /** @@ -704,7 +758,7 @@ class DualSenseController * @param button The button to read * @return The state of the button. */ - bool GetButton(int button) const; + bool GetButton(Button button) const; /** * Whether the button was pressed since the last check. @@ -712,7 +766,7 @@ class DualSenseController * @param button The button to read * @return Whether the button was pressed since the last check. */ - bool GetButtonPressed(int button); + bool GetButtonPressed(Button button); /** * Whether the button was released since the last check. @@ -720,7 +774,7 @@ class DualSenseController * @param button The button to read * @return Whether the button was released since the last check. */ - bool GetButtonReleased(int button); + bool GetButtonReleased(Button button); /** * Constructs an event instance around this button's digital signal. @@ -730,7 +784,7 @@ class DualSenseController * @return an event instance representing the button's digital signal attached * to the given loop. */ - BooleanEvent ButtonEvent(int button, EventLoop* loop) const; + BooleanEvent ButtonEvent(Button button, EventLoop* loop) const; /** * Set leds on the controller. @@ -762,60 +816,6 @@ class DualSenseController */ TouchpadFinger GetTouchpadFinger(int finger) const; - /** Represents a digital button on a DualSenseController. */ - struct Button { - /// Cross button. - static constexpr int CROSS = 0; - /// Circle button. - static constexpr int CIRCLE = 1; - /// Square button. - static constexpr int SQUARE = 2; - /// Triangle button. - static constexpr int TRIANGLE = 3; - /// Create button. - static constexpr int CREATE = 4; - /// PS button. - static constexpr int PS = 5; - /// Options button. - static constexpr int OPTIONS = 6; - /// L 3 button. - static constexpr int L3 = 7; - /// R 3 button. - static constexpr int R3 = 8; - /// L 1 button. - static constexpr int L1 = 9; - /// R 1 button. - static constexpr int R1 = 10; - /// Dpad Up button. - static constexpr int DPAD_UP = 11; - /// Dpad Down button. - static constexpr int DPAD_DOWN = 12; - /// Dpad Left button. - static constexpr int DPAD_LEFT = 13; - /// Dpad Right button. - static constexpr int DPAD_RIGHT = 14; - /// Microphone button. - static constexpr int MICROPHONE = 15; - /// Touchpad button. - static constexpr int TOUCHPAD = 20; - }; - - /** Represents an axis on a DualSenseController. */ - struct Axis { - /// Left X. - static constexpr int LEFT_X = 0; - /// Left Y. - static constexpr int LEFT_Y = 1; - /// Right X. - static constexpr int RIGHT_X = 2; - /// Right Y. - static constexpr int RIGHT_Y = 3; - /// L 2. - static constexpr int L2 = 4; - /// R 2. - static constexpr int R2 = 5; - }; - void InitSendable(wpi::util::SendableBuilder& builder) override; private: diff --git a/wpilibc/src/generated/main/native/include/wpi/driverstation/XboxController.hpp b/wpilibc/src/generated/main/native/include/wpi/driverstation/XboxController.hpp index 14849dfc7f..b67909b376 100644 --- a/wpilibc/src/generated/main/native/include/wpi/driverstation/XboxController.hpp +++ b/wpilibc/src/generated/main/native/include/wpi/driverstation/XboxController.hpp @@ -46,6 +46,56 @@ class XboxController static constexpr GenericHID::SupportedOutputs SUPPORTED_OUTPUTS = static_cast(24); + /** Represents a digital button on a XboxController. */ + enum class Button { + /// A button. + A = 0, + /// B button. + B = 1, + /// X button. + X = 2, + /// Y button. + Y = 3, + /// View button. + VIEW = 4, + /// Xbox button. + XBOX = 5, + /// Menu button. + MENU = 6, + /// Left Stick button. + LEFT_STICK = 7, + /// Right Stick button. + RIGHT_STICK = 8, + /// Left Bumper button. + LEFT_BUMPER = 9, + /// Right Bumper button. + RIGHT_BUMPER = 10, + /// Dpad Up button. + DPAD_UP = 11, + /// Dpad Down button. + DPAD_DOWN = 12, + /// Dpad Left button. + DPAD_LEFT = 13, + /// Dpad Right button. + DPAD_RIGHT = 14, + }; + + /** Represents an axis on a XboxController. */ + enum class Axis { + /// Left X. + LEFT_X = 0, + /// Left Y. + LEFT_Y = 1, + /// Right X. + RIGHT_X = 2, + /// Right Y. + RIGHT_Y = 3, + /// Left Trigger. + LEFT_TRIGGER = 4, + /// Right Trigger. + RIGHT_TRIGGER = 5, + }; + /** * Construct an instance of a controller. * @@ -144,7 +194,7 @@ class XboxController * @param axis The axis to read * @return the axis value. */ - double GetAxis(int axis) const; + double GetAxis(Axis axis) const; /** * Constructs an event instance that is true when the axis value is less than @@ -156,7 +206,7 @@ class XboxController * @return an event instance that is true when the axis value is less than the * provided threshold. */ - BooleanEvent AxisLessThan(int axis, double threshold, EventLoop* loop) const; + BooleanEvent AxisLessThan(Axis axis, double threshold, EventLoop* loop) const; /** * Constructs an event instance that is true when the axis value is greater @@ -168,7 +218,7 @@ class XboxController * @return an event instance that is true when the axis value is greater than * the provided threshold. */ - BooleanEvent AxisGreaterThan(int axis, double threshold, + BooleanEvent AxisGreaterThan(Axis axis, double threshold, EventLoop* loop) const; /** @@ -642,7 +692,7 @@ class XboxController * @param button The button to read * @return The state of the button. */ - bool GetButton(int button) const; + bool GetButton(Button button) const; /** * Whether the button was pressed since the last check. @@ -650,7 +700,7 @@ class XboxController * @param button The button to read * @return Whether the button was pressed since the last check. */ - bool GetButtonPressed(int button); + bool GetButtonPressed(Button button); /** * Whether the button was released since the last check. @@ -658,7 +708,7 @@ class XboxController * @param button The button to read * @return Whether the button was released since the last check. */ - bool GetButtonReleased(int button); + bool GetButtonReleased(Button button); /** * Constructs an event instance around this button's digital signal. @@ -668,7 +718,7 @@ class XboxController * @return an event instance representing the button's digital signal attached * to the given loop. */ - BooleanEvent ButtonEvent(int button, EventLoop* loop) const; + BooleanEvent ButtonEvent(Button button, EventLoop* loop) const; /** * Set leds on the controller. @@ -687,56 +737,6 @@ class XboxController */ void SetRumble(GenericHID::RumbleType type, double value); - /** Represents a digital button on a XboxController. */ - struct Button { - /// A button. - static constexpr int A = 0; - /// B button. - static constexpr int B = 1; - /// X button. - static constexpr int X = 2; - /// Y button. - static constexpr int Y = 3; - /// View button. - static constexpr int VIEW = 4; - /// Xbox button. - static constexpr int XBOX = 5; - /// Menu button. - static constexpr int MENU = 6; - /// Left Stick button. - static constexpr int LEFT_STICK = 7; - /// Right Stick button. - static constexpr int RIGHT_STICK = 8; - /// Left Bumper button. - static constexpr int LEFT_BUMPER = 9; - /// Right Bumper button. - static constexpr int RIGHT_BUMPER = 10; - /// Dpad Up button. - static constexpr int DPAD_UP = 11; - /// Dpad Down button. - static constexpr int DPAD_DOWN = 12; - /// Dpad Left button. - static constexpr int DPAD_LEFT = 13; - /// Dpad Right button. - static constexpr int DPAD_RIGHT = 14; - }; - - /** Represents an axis on a XboxController. */ - struct Axis { - /// Left X. - static constexpr int LEFT_X = 0; - /// Left Y. - static constexpr int LEFT_Y = 1; - /// Right X. - static constexpr int RIGHT_X = 2; - /// Right Y. - static constexpr int RIGHT_Y = 3; - /// Left Trigger. - static constexpr int LEFT_TRIGGER = 4; - /// Right Trigger. - static constexpr int RIGHT_TRIGGER = 5; - }; - void InitSendable(wpi::util::SendableBuilder& builder) override; private: diff --git a/wpilibc/src/main/python/semiwrap/DualSenseController.yml b/wpilibc/src/main/python/semiwrap/DualSenseController.yml index cb74f4836e..73d2e9d606 100644 --- a/wpilibc/src/main/python/semiwrap/DualSenseController.yml +++ b/wpilibc/src/main/python/semiwrap/DualSenseController.yml @@ -8,6 +8,9 @@ classes: force_no_trampoline: true ignored_bases: - wpi::util::SendableHelper + enums: + Button: + Axis: attributes: TOUCHPAD_COUNT: SUPPORTS_RUMBLE: @@ -115,30 +118,3 @@ classes: InitSendable: GetL2: GetR2: - wpi::DualSenseController::Button: - attributes: - CROSS: - CIRCLE: - SQUARE: - TRIANGLE: - CREATE: - PS: - OPTIONS: - L3: - R3: - L1: - R1: - DPAD_UP: - DPAD_DOWN: - DPAD_LEFT: - DPAD_RIGHT: - MICROPHONE: - TOUCHPAD: - wpi::DualSenseController::Axis: - attributes: - LEFT_X: - LEFT_Y: - RIGHT_X: - RIGHT_Y: - L2: - R2: diff --git a/wpilibc/src/main/python/semiwrap/XboxController.yml b/wpilibc/src/main/python/semiwrap/XboxController.yml index f1edba54d0..d51f3e806e 100644 --- a/wpilibc/src/main/python/semiwrap/XboxController.yml +++ b/wpilibc/src/main/python/semiwrap/XboxController.yml @@ -8,6 +8,9 @@ classes: force_no_trampoline: true ignored_bases: - wpi::util::SendableHelper + enums: + Button: + Axis: attributes: TOUCHPAD_COUNT: SUPPORTS_RUMBLE: @@ -105,28 +108,3 @@ classes: InitSendable: GetLeftTrigger: GetRightTrigger: - wpi::XboxController::Button: - attributes: - A: - B: - X: - Y: - VIEW: - XBOX: - MENU: - LEFT_STICK: - RIGHT_STICK: - LEFT_BUMPER: - RIGHT_BUMPER: - DPAD_UP: - DPAD_DOWN: - DPAD_LEFT: - DPAD_RIGHT: - wpi::XboxController::Axis: - attributes: - LEFT_X: - LEFT_Y: - RIGHT_X: - RIGHT_Y: - LEFT_TRIGGER: - RIGHT_TRIGGER: