From c2cc90b27dfead8720c8c1f91cdc036fab7d320b Mon Sep 17 00:00:00 2001 From: Peter Johnson Date: Wed, 15 Jul 2020 23:48:09 -0700 Subject: [PATCH] [sim] Move WPILib C++ sim implementations out of line (#2598) This makes the sim classes consistent with the rest of the WPILibC classes. --- .../cpp/frc2/command/CommandTestBase.cpp | 10 +- .../native/cpp/frc2/command/CommandTestBase.h | 1 - .../native/cpp/frc2/command/POVButtonTest.cpp | 15 +- .../cpp/simulation/AddressableLEDSim.cpp | 119 ++++++++ .../native/cpp/simulation/AnalogGyroSim.cpp | 77 ++++++ .../native/cpp/simulation/AnalogInputSim.cpp | 182 +++++++++++++ .../native/cpp/simulation/AnalogOutputSim.cpp | 59 ++++ .../cpp/simulation/AnalogTriggerSim.cpp | 89 ++++++ .../simulation/BuiltInAccelerometerSim.cpp | 112 ++++++++ .../native/cpp/simulation/CallbackStore.cpp | 60 +++++ .../src/main/native/cpp/simulation/DIOSim.cpp | 104 +++++++ .../native/cpp/simulation/DigitalPWMSim.cpp | 81 ++++++ .../cpp/simulation/DriverStationSim.cpp | 255 ++++++++++++++++++ .../native/cpp/simulation/DutyCycleSim.cpp | 85 ++++++ .../main/native/cpp/simulation/EncoderSim.cpp | 189 +++++++++++++ .../native/cpp/simulation/GenericHIDSim.cpp | 74 +++++ .../native/cpp/simulation/JoystickSim.cpp | 63 +++++ .../src/main/native/cpp/simulation/PCMSim.cpp | 158 +++++++++++ .../src/main/native/cpp/simulation/PDPSim.cpp | 98 +++++++ .../src/main/native/cpp/simulation/PWMSim.cpp | 114 ++++++++ .../main/native/cpp/simulation/RelaySim.cpp | 88 ++++++ .../main/native/cpp/simulation/RoboRioSim.cpp | 255 ++++++++++++++++++ .../cpp/simulation/SPIAccelerometerSim.cpp | 107 ++++++++ .../native/cpp/simulation/SimDeviceSim.cpp | 47 ++++ .../main/native/cpp/simulation/SimHooks.cpp | 34 +++ .../cpp/simulation/XboxControllerSim.cpp | 90 +++++++ .../frc/simulation/AddressableLEDSim.h | 105 ++------ .../include/frc/simulation/AnalogGyroSim.h | 57 ++-- .../include/frc/simulation/AnalogInputSim.h | 156 +++-------- .../include/frc/simulation/AnalogOutputSim.h | 46 +--- .../include/frc/simulation/AnalogTriggerSim.h | 76 ++---- .../frc/simulation/BuiltInAccelerometerSim.h | 82 ++---- .../include/frc/simulation/CallbackStore.h | 67 +---- .../native/include/frc/simulation/DIOSim.h | 85 ++---- .../include/frc/simulation/DigitalPWMSim.h | 67 ++--- .../include/frc/simulation/DriverStationSim.h | 220 ++++----------- .../include/frc/simulation/DutyCycleSim.h | 63 ++--- .../include/frc/simulation/EncoderSim.h | 159 +++-------- .../include/frc/simulation/GenericHIDSim.h | 64 ++--- .../include/frc/simulation/JoystickSim.h | 53 +--- .../native/include/frc/simulation/PCMSim.h | 145 +++------- .../native/include/frc/simulation/PDPSim.h | 80 ++---- .../native/include/frc/simulation/PWMSim.h | 95 ++----- .../native/include/frc/simulation/RelaySim.h | 71 ++--- .../include/frc/simulation/RoboRioSim.h | 221 ++++----------- .../frc/simulation/SPIAccelerometerSim.h | 71 ++--- .../include/frc/simulation/SimDeviceSim.h | 34 +-- .../native/include/frc/simulation/SimHooks.h | 24 +- .../frc/simulation/XboxControllerSim.h | 82 ++---- 49 files changed, 3068 insertions(+), 1621 deletions(-) create mode 100644 wpilibc/src/main/native/cpp/simulation/AddressableLEDSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/AnalogGyroSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/AnalogInputSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/AnalogOutputSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/AnalogTriggerSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/BuiltInAccelerometerSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/DIOSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/DigitalPWMSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/DriverStationSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/DutyCycleSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/EncoderSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/GenericHIDSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/JoystickSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/PCMSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/PDPSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/PWMSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/RelaySim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/RoboRioSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/SPIAccelerometerSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/SimDeviceSim.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/SimHooks.cpp create mode 100644 wpilibc/src/main/native/cpp/simulation/XboxControllerSim.cpp diff --git a/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.cpp b/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.cpp index 0429c625d4..a73dff3c3a 100644 --- a/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.cpp +++ b/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.cpp @@ -1,5 +1,5 @@ /*----------------------------------------------------------------------------*/ -/* Copyright (c) 2019 FIRST. All Rights Reserved. */ +/* Copyright (c) 2019-2020 FIRST. All Rights Reserved. */ /* Open Source Software - may be modified and shared by FRC teams. The code */ /* must be accompanied by the FIRST BSD license file in the root directory of */ /* the project. */ @@ -19,8 +19,8 @@ CommandTestBase::CommandTestBase() { CommandScheduler CommandTestBase::GetScheduler() { return CommandScheduler(); } void CommandTestBase::SetUp() { - HALSIM_SetDriverStationEnabled(true); - while (!HALSIM_GetDriverStationEnabled()) { + frc::sim::DriverStationSim::SetEnabled(true); + while (!frc::sim::DriverStationSim::GetEnabled()) { std::this_thread::sleep_for(std::chrono::milliseconds(1)); } } @@ -30,8 +30,8 @@ void CommandTestBase::TearDown() { } void CommandTestBase::SetDSEnabled(bool enabled) { - HALSIM_SetDriverStationEnabled(enabled); - while (HALSIM_GetDriverStationEnabled() != static_cast(enabled)) { + frc::sim::DriverStationSim::SetEnabled(enabled); + while (frc::sim::DriverStationSim::GetEnabled() != enabled) { std::this_thread::sleep_for(std::chrono::milliseconds(1)); } } diff --git a/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.h b/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.h index 6cdf6bf584..c6400a8b56 100644 --- a/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.h +++ b/wpilibNewCommands/src/test/native/cpp/frc2/command/CommandTestBase.h @@ -11,7 +11,6 @@ #include #include -#include #include "ErrorConfirmer.h" #include "frc2/command/CommandGroupBase.h" diff --git a/wpilibNewCommands/src/test/native/cpp/frc2/command/POVButtonTest.cpp b/wpilibNewCommands/src/test/native/cpp/frc2/command/POVButtonTest.cpp index 2f3976abe0..2a1646df96 100644 --- a/wpilibNewCommands/src/test/native/cpp/frc2/command/POVButtonTest.cpp +++ b/wpilibNewCommands/src/test/native/cpp/frc2/command/POVButtonTest.cpp @@ -6,7 +6,7 @@ /*----------------------------------------------------------------------------*/ #include -#include +#include #include "CommandTestBase.h" #include "frc2/command/CommandScheduler.h" @@ -19,11 +19,9 @@ using namespace frc2; class POVButtonTest : public CommandTestBase {}; TEST_F(POVButtonTest, SetPOVTest) { - HAL_JoystickPOVs povs; - povs.count = 1; - povs.povs[0] = 0; - HALSIM_SetJoystickPOVs(1, &povs); - HALSIM_NotifyDriverStationNewData(); + frc::sim::JoystickSim joysim(1); + joysim.SetPOV(0); + joysim.NotifyNewData(); auto& scheduler = CommandScheduler::GetInstance(); bool finished = false; @@ -35,9 +33,8 @@ TEST_F(POVButtonTest, SetPOVTest) { scheduler.Run(); EXPECT_FALSE(scheduler.IsScheduled(&command)); - povs.povs[0] = 90; - HALSIM_SetJoystickPOVs(1, &povs); - HALSIM_NotifyDriverStationNewData(); + joysim.SetPOV(90); + joysim.NotifyNewData(); scheduler.Run(); EXPECT_TRUE(scheduler.IsScheduled(&command)); diff --git a/wpilibc/src/main/native/cpp/simulation/AddressableLEDSim.cpp b/wpilibc/src/main/native/cpp/simulation/AddressableLEDSim.cpp new file mode 100644 index 0000000000..743c51d66b --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/AddressableLEDSim.cpp @@ -0,0 +1,119 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/AddressableLEDSim.h" + +#include +#include +#include + +#include + +using namespace frc; +using namespace frc::sim; + +AddressableLEDSim::AddressableLEDSim() : m_index{0} {} + +AddressableLEDSim::AddressableLEDSim(const AddressableLED& addressableLED) + : m_index{0} {} + +AddressableLEDSim AddressableLEDSim::CreateForChannel(int pwmChannel) { + int index = HALSIM_FindAddressableLEDForChannel(pwmChannel); + if (index < 0) + throw std::out_of_range("no addressable LED found for PWM channel"); + return AddressableLEDSim{index}; +} + +AddressableLEDSim AddressableLEDSim::CreateForIndex(int index) { + return AddressableLEDSim{index}; +} + +std::unique_ptr AddressableLEDSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAddressableLEDInitializedCallback); + store->SetUid(HALSIM_RegisterAddressableLEDInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool AddressableLEDSim::GetInitialized() const { + return HALSIM_GetAddressableLEDInitialized(m_index); +} + +void AddressableLEDSim::SetInitialized(bool initialized) { + HALSIM_SetAddressableLEDInitialized(m_index, initialized); +} + +std::unique_ptr AddressableLEDSim::RegisterOutputPortCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAddressableLEDOutputPortCallback); + store->SetUid(HALSIM_RegisterAddressableLEDOutputPortCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AddressableLEDSim::GetOutputPort() const { + return HALSIM_GetAddressableLEDOutputPort(m_index); +} + +void AddressableLEDSim::SetOutputPort(int outputPort) { + HALSIM_SetAddressableLEDOutputPort(m_index, outputPort); +} + +std::unique_ptr AddressableLEDSim::RegisterLengthCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAddressableLEDLengthCallback); + store->SetUid(HALSIM_RegisterAddressableLEDLengthCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AddressableLEDSim::GetLength() const { + return HALSIM_GetAddressableLEDLength(m_index); +} + +void AddressableLEDSim::SetLength(int length) { + HALSIM_SetAddressableLEDLength(m_index, length); +} + +std::unique_ptr AddressableLEDSim::RegisterRunningCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAddressableLEDRunningCallback); + store->SetUid(HALSIM_RegisterAddressableLEDRunningCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AddressableLEDSim::GetRunning() const { + return HALSIM_GetAddressableLEDRunning(m_index); +} + +void AddressableLEDSim::SetRunning(bool running) { + HALSIM_SetAddressableLEDRunning(m_index, running); +} + +std::unique_ptr AddressableLEDSim::RegisterDataCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAddressableLEDDataCallback); + store->SetUid(HALSIM_RegisterAddressableLEDDataCallback( + m_index, &ConstBufferCallbackStoreThunk, store.get())); + return store; +} + +int AddressableLEDSim::GetData(struct HAL_AddressableLEDData* data) const { + return HALSIM_GetAddressableLEDData(m_index, data); +} + +void AddressableLEDSim::SetData(struct HAL_AddressableLEDData* data, + int length) { + HALSIM_SetAddressableLEDData(m_index, data, length); +} diff --git a/wpilibc/src/main/native/cpp/simulation/AnalogGyroSim.cpp b/wpilibc/src/main/native/cpp/simulation/AnalogGyroSim.cpp new file mode 100644 index 0000000000..b7cab6b56b --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/AnalogGyroSim.cpp @@ -0,0 +1,77 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/AnalogGyroSim.h" + +#include +#include + +#include + +#include "frc/AnalogGyro.h" +#include "frc/AnalogInput.h" + +using namespace frc; +using namespace frc::sim; + +AnalogGyroSim::AnalogGyroSim(const AnalogGyro& gyro) + : m_index{gyro.GetAnalogInput()->GetChannel()} {} + +AnalogGyroSim::AnalogGyroSim(int channel) : m_index{channel} {} + +std::unique_ptr AnalogGyroSim::RegisterAngleCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogGyroAngleCallback); + store->SetUid(HALSIM_RegisterAnalogGyroAngleCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double AnalogGyroSim::GetAngle() const { + return HALSIM_GetAnalogGyroAngle(m_index); +} + +void AnalogGyroSim::SetAngle(double angle) { + HALSIM_SetAnalogGyroAngle(m_index, angle); +} + +std::unique_ptr AnalogGyroSim::RegisterRateCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogGyroRateCallback); + store->SetUid(HALSIM_RegisterAnalogGyroRateCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double AnalogGyroSim::GetRate() const { + return HALSIM_GetAnalogGyroRate(m_index); +} + +void AnalogGyroSim::SetRate(double rate) { + HALSIM_SetAnalogGyroRate(m_index, rate); +} + +std::unique_ptr AnalogGyroSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogGyroInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogGyroInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool AnalogGyroSim::GetInitialized() const { + return HALSIM_GetAnalogGyroInitialized(m_index); +} + +void AnalogGyroSim::SetInitialized(bool initialized) { + HALSIM_SetAnalogGyroInitialized(m_index, initialized); +} + +void AnalogGyroSim::ResetData() { HALSIM_ResetAnalogGyroData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/AnalogInputSim.cpp b/wpilibc/src/main/native/cpp/simulation/AnalogInputSim.cpp new file mode 100644 index 0000000000..057a1883f0 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/AnalogInputSim.cpp @@ -0,0 +1,182 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/AnalogInputSim.h" + +#include +#include + +#include + +#include "frc/AnalogInput.h" + +using namespace frc; +using namespace frc::sim; + +AnalogInputSim::AnalogInputSim(const AnalogInput& analogInput) + : m_index{analogInput.GetChannel()} {} + +AnalogInputSim::AnalogInputSim(int channel) : m_index{channel} {} + +std::unique_ptr AnalogInputSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogInInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool AnalogInputSim::GetInitialized() const { + return HALSIM_GetAnalogInInitialized(m_index); +} + +void AnalogInputSim::SetInitialized(bool initialized) { + HALSIM_SetAnalogInInitialized(m_index, initialized); +} + +std::unique_ptr AnalogInputSim::RegisterAverageBitsCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAverageBitsCallback); + store->SetUid(HALSIM_RegisterAnalogInAverageBitsCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AnalogInputSim::GetAverageBits() const { + return HALSIM_GetAnalogInAverageBits(m_index); +} + +void AnalogInputSim::SetAverageBits(int averageBits) { + HALSIM_SetAnalogInAverageBits(m_index, averageBits); +} + +std::unique_ptr AnalogInputSim::RegisterOversampleBitsCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInOversampleBitsCallback); + store->SetUid(HALSIM_RegisterAnalogInOversampleBitsCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AnalogInputSim::GetOversampleBits() const { + return HALSIM_GetAnalogInOversampleBits(m_index); +} + +void AnalogInputSim::SetOversampleBits(int oversampleBits) { + HALSIM_SetAnalogInOversampleBits(m_index, oversampleBits); +} + +std::unique_ptr AnalogInputSim::RegisterVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInVoltageCallback); + store->SetUid(HALSIM_RegisterAnalogInVoltageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double AnalogInputSim::GetVoltage() const { + return HALSIM_GetAnalogInVoltage(m_index); +} + +void AnalogInputSim::SetVoltage(double voltage) { + HALSIM_SetAnalogInVoltage(m_index, voltage); +} + +std::unique_ptr +AnalogInputSim::RegisterAccumulatorInitializedCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogInAccumulatorInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool AnalogInputSim::GetAccumulatorInitialized() const { + return HALSIM_GetAnalogInAccumulatorInitialized(m_index); +} + +void AnalogInputSim::SetAccumulatorInitialized(bool accumulatorInitialized) { + HALSIM_SetAnalogInAccumulatorInitialized(m_index, accumulatorInitialized); +} + +std::unique_ptr AnalogInputSim::RegisterAccumulatorValueCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorValueCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorValueCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int64_t AnalogInputSim::GetAccumulatorValue() const { + return HALSIM_GetAnalogInAccumulatorValue(m_index); +} + +void AnalogInputSim::SetAccumulatorValue(int64_t accumulatorValue) { + HALSIM_SetAnalogInAccumulatorValue(m_index, accumulatorValue); +} + +std::unique_ptr AnalogInputSim::RegisterAccumulatorCountCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCountCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorCountCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int64_t AnalogInputSim::GetAccumulatorCount() const { + return HALSIM_GetAnalogInAccumulatorCount(m_index); +} + +void AnalogInputSim::SetAccumulatorCount(int64_t accumulatorCount) { + HALSIM_SetAnalogInAccumulatorCount(m_index, accumulatorCount); +} + +std::unique_ptr +AnalogInputSim::RegisterAccumulatorCenterCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCenterCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorCenterCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AnalogInputSim::GetAccumulatorCenter() const { + return HALSIM_GetAnalogInAccumulatorCenter(m_index); +} + +void AnalogInputSim::SetAccumulatorCenter(int accumulatorCenter) { + HALSIM_SetAnalogInAccumulatorCenter(m_index, accumulatorCenter); +} + +std::unique_ptr +AnalogInputSim::RegisterAccumulatorDeadbandCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorDeadbandCallback); + store->SetUid(HALSIM_RegisterAnalogInAccumulatorDeadbandCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int AnalogInputSim::GetAccumulatorDeadband() const { + return HALSIM_GetAnalogInAccumulatorDeadband(m_index); +} + +void AnalogInputSim::SetAccumulatorDeadband(int accumulatorDeadband) { + HALSIM_SetAnalogInAccumulatorDeadband(m_index, accumulatorDeadband); +} + +void AnalogInputSim::ResetData() { HALSIM_ResetAnalogInData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/AnalogOutputSim.cpp b/wpilibc/src/main/native/cpp/simulation/AnalogOutputSim.cpp new file mode 100644 index 0000000000..4de9082424 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/AnalogOutputSim.cpp @@ -0,0 +1,59 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/AnalogOutputSim.h" + +#include +#include + +#include + +#include "frc/AnalogOutput.h" + +using namespace frc; +using namespace frc::sim; + +AnalogOutputSim::AnalogOutputSim(const AnalogOutput& analogOutput) + : m_index{analogOutput.GetChannel()} {} + +AnalogOutputSim::AnalogOutputSim(int channel) : m_index{channel} {} + +std::unique_ptr AnalogOutputSim::RegisterVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogOutVoltageCallback); + store->SetUid(HALSIM_RegisterAnalogOutVoltageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double AnalogOutputSim::GetVoltage() const { + return HALSIM_GetAnalogOutVoltage(m_index); +} + +void AnalogOutputSim::SetVoltage(double voltage) { + HALSIM_SetAnalogOutVoltage(m_index, voltage); +} + +std::unique_ptr AnalogOutputSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogOutInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogOutInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool AnalogOutputSim::GetInitialized() const { + return HALSIM_GetAnalogOutInitialized(m_index); +} + +void AnalogOutputSim::SetInitialized(bool initialized) { + HALSIM_SetAnalogOutInitialized(m_index, initialized); +} + +void AnalogOutputSim::ResetData() { HALSIM_ResetAnalogOutData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/AnalogTriggerSim.cpp b/wpilibc/src/main/native/cpp/simulation/AnalogTriggerSim.cpp new file mode 100644 index 0000000000..3325827728 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/AnalogTriggerSim.cpp @@ -0,0 +1,89 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/AnalogTriggerSim.h" + +#include +#include +#include + +#include + +#include "frc/AnalogTrigger.h" + +using namespace frc; +using namespace frc::sim; + +AnalogTriggerSim::AnalogTriggerSim(const AnalogTrigger& analogTrigger) + : m_index{analogTrigger.GetIndex()} {} + +AnalogTriggerSim AnalogTriggerSim::CreateForChannel(int channel) { + int index = HALSIM_FindAnalogTriggerForChannel(channel); + if (index < 0) throw std::out_of_range("no analog trigger found for channel"); + return AnalogTriggerSim{index}; +} + +AnalogTriggerSim AnalogTriggerSim::CreateForIndex(int index) { + return AnalogTriggerSim{index}; +} + +std::unique_ptr AnalogTriggerSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAnalogTriggerInitializedCallback); + store->SetUid(HALSIM_RegisterAnalogTriggerInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool AnalogTriggerSim::GetInitialized() const { + return HALSIM_GetAnalogTriggerInitialized(m_index); +} + +void AnalogTriggerSim::SetInitialized(bool initialized) { + HALSIM_SetAnalogTriggerInitialized(m_index, initialized); +} + +std::unique_ptr +AnalogTriggerSim::RegisterTriggerLowerBoundCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogTriggerTriggerLowerBoundCallback); + store->SetUid(HALSIM_RegisterAnalogTriggerTriggerLowerBoundCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double AnalogTriggerSim::GetTriggerLowerBound() const { + return HALSIM_GetAnalogTriggerTriggerLowerBound(m_index); +} + +void AnalogTriggerSim::SetTriggerLowerBound(double triggerLowerBound) { + HALSIM_SetAnalogTriggerTriggerLowerBound(m_index, triggerLowerBound); +} + +std::unique_ptr +AnalogTriggerSim::RegisterTriggerUpperBoundCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, + &HALSIM_CancelAnalogTriggerTriggerUpperBoundCallback); + store->SetUid(HALSIM_RegisterAnalogTriggerTriggerUpperBoundCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double AnalogTriggerSim::GetTriggerUpperBound() const { + return HALSIM_GetAnalogTriggerTriggerUpperBound(m_index); +} + +void AnalogTriggerSim::SetTriggerUpperBound(double triggerUpperBound) { + HALSIM_SetAnalogTriggerTriggerUpperBound(m_index, triggerUpperBound); +} + +void AnalogTriggerSim::ResetData() { HALSIM_ResetAnalogTriggerData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/BuiltInAccelerometerSim.cpp b/wpilibc/src/main/native/cpp/simulation/BuiltInAccelerometerSim.cpp new file mode 100644 index 0000000000..601ee6e8c5 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/BuiltInAccelerometerSim.cpp @@ -0,0 +1,112 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/BuiltInAccelerometerSim.h" + +#include +#include + +#include + +#include "frc/BuiltInAccelerometer.h" + +using namespace frc; +using namespace frc::sim; + +BuiltInAccelerometerSim::BuiltInAccelerometerSim() : m_index{0} {} + +BuiltInAccelerometerSim::BuiltInAccelerometerSim(const BuiltInAccelerometer&) + : m_index{0} {} + +std::unique_ptr BuiltInAccelerometerSim::RegisterActiveCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerActiveCallback); + store->SetUid(HALSIM_RegisterAccelerometerActiveCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool BuiltInAccelerometerSim::GetActive() const { + return HALSIM_GetAccelerometerActive(m_index); +} + +void BuiltInAccelerometerSim::SetActive(bool active) { + HALSIM_SetAccelerometerActive(m_index, active); +} + +std::unique_ptr BuiltInAccelerometerSim::RegisterRangeCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerRangeCallback); + store->SetUid(HALSIM_RegisterAccelerometerRangeCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +HAL_AccelerometerRange BuiltInAccelerometerSim::GetRange() const { + return HALSIM_GetAccelerometerRange(m_index); +} + +void BuiltInAccelerometerSim::SetRange(HAL_AccelerometerRange range) { + HALSIM_SetAccelerometerRange(m_index, range); +} + +std::unique_ptr BuiltInAccelerometerSim::RegisterXCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerXCallback); + store->SetUid(HALSIM_RegisterAccelerometerXCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double BuiltInAccelerometerSim::GetX() const { + return HALSIM_GetAccelerometerX(m_index); +} + +void BuiltInAccelerometerSim::SetX(double x) { + HALSIM_SetAccelerometerX(m_index, x); +} + +std::unique_ptr BuiltInAccelerometerSim::RegisterYCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerYCallback); + store->SetUid(HALSIM_RegisterAccelerometerYCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double BuiltInAccelerometerSim::GetY() const { + return HALSIM_GetAccelerometerY(m_index); +} + +void BuiltInAccelerometerSim::SetY(double y) { + HALSIM_SetAccelerometerY(m_index, y); +} + +std::unique_ptr BuiltInAccelerometerSim::RegisterZCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelAccelerometerZCallback); + store->SetUid(HALSIM_RegisterAccelerometerZCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double BuiltInAccelerometerSim::GetZ() const { + return HALSIM_GetAccelerometerZ(m_index); +} + +void BuiltInAccelerometerSim::SetZ(double z) { + HALSIM_SetAccelerometerZ(m_index, z); +} + +void BuiltInAccelerometerSim::ResetData() { + HALSIM_ResetAccelerometerData(m_index); +} diff --git a/wpilibc/src/main/native/cpp/simulation/CallbackStore.cpp b/wpilibc/src/main/native/cpp/simulation/CallbackStore.cpp index a9e2de8f3c..5c38372785 100644 --- a/wpilibc/src/main/native/cpp/simulation/CallbackStore.cpp +++ b/wpilibc/src/main/native/cpp/simulation/CallbackStore.cpp @@ -7,6 +7,9 @@ #include "frc/simulation/CallbackStore.h" +using namespace frc; +using namespace frc::sim; + void frc::sim::CallbackStoreThunk(const char* name, void* param, const HAL_Value* value) { reinterpret_cast(param)->callback(name, value); @@ -18,3 +21,60 @@ void frc::sim::ConstBufferCallbackStoreThunk(const char* name, void* param, reinterpret_cast(param)->constBufferCallback(name, buffer, count); } + +CallbackStore::CallbackStore(int32_t i, NotifyCallback cb, + CancelCallbackNoIndexFunc ccf) + : index(i), callback(cb), cancelType(NoIndex) { + this->ccnif = ccf; +} + +CallbackStore::CallbackStore(int32_t i, int32_t u, NotifyCallback cb, + CancelCallbackFunc ccf) + : index(i), uid(u), callback(cb), cancelType(Normal) { + this->ccf = ccf; +} + +CallbackStore::CallbackStore(int32_t i, int32_t c, int32_t u, NotifyCallback cb, + CancelCallbackChannelFunc ccf) + : index(i), channel(c), uid(u), callback(cb), cancelType(Channel) { + this->cccf = ccf; +} + +CallbackStore::CallbackStore(int32_t i, ConstBufferCallback cb, + CancelCallbackNoIndexFunc ccf) + : index(i), constBufferCallback(cb), cancelType(NoIndex) { + this->ccnif = ccf; +} + +CallbackStore::CallbackStore(int32_t i, int32_t u, ConstBufferCallback cb, + CancelCallbackFunc ccf) + : index(i), uid(u), constBufferCallback(cb), cancelType(Normal) { + this->ccf = ccf; +} + +CallbackStore::CallbackStore(int32_t i, int32_t c, int32_t u, + ConstBufferCallback cb, + CancelCallbackChannelFunc ccf) + : index(i), + channel(c), + uid(u), + constBufferCallback(cb), + cancelType(Channel) { + this->cccf = ccf; +} + +CallbackStore::~CallbackStore() { + switch (cancelType) { + case Normal: + ccf(index, uid); + break; + case Channel: + cccf(index, channel, uid); + break; + case NoIndex: + ccnif(uid); + break; + } +} + +void CallbackStore::SetUid(int32_t uid) { this->uid = uid; } diff --git a/wpilibc/src/main/native/cpp/simulation/DIOSim.cpp b/wpilibc/src/main/native/cpp/simulation/DIOSim.cpp new file mode 100644 index 0000000000..9330735145 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/DIOSim.cpp @@ -0,0 +1,104 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/DIOSim.h" + +#include +#include + +#include + +#include "frc/DigitalInput.h" +#include "frc/DigitalOutput.h" + +using namespace frc; +using namespace frc::sim; + +DIOSim::DIOSim(const DigitalInput& input) : m_index{input.GetChannel()} {} + +DIOSim::DIOSim(const DigitalOutput& output) : m_index{output.GetChannel()} {} + +DIOSim::DIOSim(int channel) : m_index{channel} {} + +std::unique_ptr DIOSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOInitializedCallback); + store->SetUid(HALSIM_RegisterDIOInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DIOSim::GetInitialized() const { + return HALSIM_GetDIOInitialized(m_index); +} + +void DIOSim::SetInitialized(bool initialized) { + HALSIM_SetDIOInitialized(m_index, initialized); +} + +std::unique_ptr DIOSim::RegisterValueCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique(m_index, -1, callback, + &HALSIM_CancelDIOValueCallback); + store->SetUid(HALSIM_RegisterDIOValueCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return store; +} + +bool DIOSim::GetValue() const { return HALSIM_GetDIOValue(m_index); } + +void DIOSim::SetValue(bool value) { HALSIM_SetDIOValue(m_index, value); } + +std::unique_ptr DIOSim::RegisterPulseLengthCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOPulseLengthCallback); + store->SetUid(HALSIM_RegisterDIOPulseLengthCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double DIOSim::GetPulseLength() const { + return HALSIM_GetDIOPulseLength(m_index); +} + +void DIOSim::SetPulseLength(double pulseLength) { + HALSIM_SetDIOPulseLength(m_index, pulseLength); +} + +std::unique_ptr DIOSim::RegisterIsInputCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOIsInputCallback); + store->SetUid(HALSIM_RegisterDIOIsInputCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return store; +} + +bool DIOSim::GetIsInput() const { return HALSIM_GetDIOIsInput(m_index); } + +void DIOSim::SetIsInput(bool isInput) { + HALSIM_SetDIOIsInput(m_index, isInput); +} + +std::unique_ptr DIOSim::RegisterFilterIndexCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDIOFilterIndexCallback); + store->SetUid(HALSIM_RegisterDIOFilterIndexCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int DIOSim::GetFilterIndex() const { return HALSIM_GetDIOFilterIndex(m_index); } + +void DIOSim::SetFilterIndex(int filterIndex) { + HALSIM_SetDIOFilterIndex(m_index, filterIndex); +} + +void DIOSim::ResetData() { HALSIM_ResetDIOData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/DigitalPWMSim.cpp b/wpilibc/src/main/native/cpp/simulation/DigitalPWMSim.cpp new file mode 100644 index 0000000000..2ee55cefac --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/DigitalPWMSim.cpp @@ -0,0 +1,81 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/DigitalPWMSim.h" + +#include +#include +#include + +#include + +#include "frc/DigitalOutput.h" + +using namespace frc; +using namespace frc::sim; + +DigitalPWMSim::DigitalPWMSim(const DigitalOutput& digitalOutput) + : m_index{digitalOutput.GetChannel()} {} + +DigitalPWMSim DigitalPWMSim::CreateForChannel(int channel) { + int index = HALSIM_FindDigitalPWMForChannel(channel); + if (index < 0) throw std::out_of_range("no digital PWM found for channel"); + return DigitalPWMSim{index}; +} + +DigitalPWMSim DigitalPWMSim::CreateForIndex(int index) { + return DigitalPWMSim{index}; +} + +std::unique_ptr DigitalPWMSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDigitalPWMInitializedCallback); + store->SetUid(HALSIM_RegisterDigitalPWMInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DigitalPWMSim::GetInitialized() const { + return HALSIM_GetDigitalPWMInitialized(m_index); +} + +void DigitalPWMSim::SetInitialized(bool initialized) { + HALSIM_SetDigitalPWMInitialized(m_index, initialized); +} + +std::unique_ptr DigitalPWMSim::RegisterDutyCycleCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDigitalPWMDutyCycleCallback); + store->SetUid(HALSIM_RegisterDigitalPWMDutyCycleCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double DigitalPWMSim::GetDutyCycle() const { + return HALSIM_GetDigitalPWMDutyCycle(m_index); +} + +void DigitalPWMSim::SetDutyCycle(double dutyCycle) { + HALSIM_SetDigitalPWMDutyCycle(m_index, dutyCycle); +} + +std::unique_ptr DigitalPWMSim::RegisterPinCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDigitalPWMPinCallback); + store->SetUid(HALSIM_RegisterDigitalPWMPinCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int DigitalPWMSim::GetPin() const { return HALSIM_GetDigitalPWMPin(m_index); } + +void DigitalPWMSim::SetPin(int pin) { HALSIM_SetDigitalPWMPin(m_index, pin); } + +void DigitalPWMSim::ResetData() { HALSIM_ResetDigitalPWMData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/DriverStationSim.cpp b/wpilibc/src/main/native/cpp/simulation/DriverStationSim.cpp new file mode 100644 index 0000000000..8c0bf70076 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/DriverStationSim.cpp @@ -0,0 +1,255 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/DriverStationSim.h" + +#include +#include + +#include +#include + +#include "frc/DriverStation.h" + +using namespace frc; +using namespace frc::sim; + +std::unique_ptr DriverStationSim::RegisterEnabledCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationEnabledCallback); + store->SetUid(HALSIM_RegisterDriverStationEnabledCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DriverStationSim::GetEnabled() { return HALSIM_GetDriverStationEnabled(); } + +void DriverStationSim::SetEnabled(bool enabled) { + HALSIM_SetDriverStationEnabled(enabled); +} + +std::unique_ptr DriverStationSim::RegisterAutonomousCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationAutonomousCallback); + store->SetUid(HALSIM_RegisterDriverStationAutonomousCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DriverStationSim::GetAutonomous() { + return HALSIM_GetDriverStationAutonomous(); +} + +void DriverStationSim::SetAutonomous(bool autonomous) { + HALSIM_SetDriverStationAutonomous(autonomous); +} + +std::unique_ptr DriverStationSim::RegisterTestCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationTestCallback); + store->SetUid(HALSIM_RegisterDriverStationTestCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DriverStationSim::GetTest() { return HALSIM_GetDriverStationTest(); } + +void DriverStationSim::SetTest(bool test) { HALSIM_SetDriverStationTest(test); } + +std::unique_ptr DriverStationSim::RegisterEStopCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationEStopCallback); + store->SetUid(HALSIM_RegisterDriverStationEStopCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DriverStationSim::GetEStop() { return HALSIM_GetDriverStationEStop(); } + +void DriverStationSim::SetEStop(bool eStop) { + HALSIM_SetDriverStationEStop(eStop); +} + +std::unique_ptr DriverStationSim::RegisterFmsAttachedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationFmsAttachedCallback); + store->SetUid(HALSIM_RegisterDriverStationFmsAttachedCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DriverStationSim::GetFmsAttached() { + return HALSIM_GetDriverStationFmsAttached(); +} + +void DriverStationSim::SetFmsAttached(bool fmsAttached) { + HALSIM_SetDriverStationFmsAttached(fmsAttached); +} + +std::unique_ptr DriverStationSim::RegisterDsAttachedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationDsAttachedCallback); + store->SetUid(HALSIM_RegisterDriverStationDsAttachedCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DriverStationSim::GetDsAttached() { + return HALSIM_GetDriverStationDsAttached(); +} + +void DriverStationSim::SetDsAttached(bool dsAttached) { + HALSIM_SetDriverStationDsAttached(dsAttached); +} + +std::unique_ptr +DriverStationSim::RegisterAllianceStationIdCallback(NotifyCallback callback, + bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationAllianceStationIdCallback); + store->SetUid(HALSIM_RegisterDriverStationAllianceStationIdCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +HAL_AllianceStationID DriverStationSim::GetAllianceStationId() { + return HALSIM_GetDriverStationAllianceStationId(); +} + +void DriverStationSim::SetAllianceStationId( + HAL_AllianceStationID allianceStationId) { + HALSIM_SetDriverStationAllianceStationId(allianceStationId); +} + +std::unique_ptr DriverStationSim::RegisterMatchTimeCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelDriverStationMatchTimeCallback); + store->SetUid(HALSIM_RegisterDriverStationMatchTimeCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double DriverStationSim::GetMatchTime() { + return HALSIM_GetDriverStationMatchTime(); +} + +void DriverStationSim::SetMatchTime(double matchTime) { + HALSIM_SetDriverStationMatchTime(matchTime); +} + +void DriverStationSim::NotifyNewData() { + HALSIM_NotifyDriverStationNewData(); + DriverStation::GetInstance().WaitForData(); +} + +void DriverStationSim::SetSendError(bool shouldSend) { + if (shouldSend) { + HALSIM_SetSendError(nullptr); + } else { + HALSIM_SetSendError([](HAL_Bool isError, int32_t errorCode, + HAL_Bool isLVCode, const char* details, + const char* location, const char* callStack, + HAL_Bool printMsg) { return 0; }); + } +} + +void DriverStationSim::SetSendConsoleLine(bool shouldSend) { + if (shouldSend) { + HALSIM_SetSendConsoleLine(nullptr); + } else { + HALSIM_SetSendConsoleLine([](const char* line) { return 0; }); + } +} + +int64_t DriverStationSim::GetJoystickOutputs(int stick) { + int64_t outputs = 0; + int32_t leftRumble; + int32_t rightRumble; + HALSIM_GetJoystickOutputs(stick, &outputs, &leftRumble, &rightRumble); + return outputs; +} + +int DriverStationSim::GetJoystickRumble(int stick, int rumbleNum) { + int64_t outputs; + int32_t leftRumble = 0; + int32_t rightRumble = 0; + HALSIM_GetJoystickOutputs(stick, &outputs, &leftRumble, &rightRumble); + return rumbleNum == 0 ? leftRumble : rightRumble; +} + +void DriverStationSim::SetJoystickButton(int stick, int button, bool state) { + HALSIM_SetJoystickButton(stick, button, state); +} + +void DriverStationSim::SetJoystickAxis(int stick, int axis, double value) { + HALSIM_SetJoystickAxis(stick, axis, value); +} + +void DriverStationSim::SetJoystickPOV(int stick, int pov, int value) { + HALSIM_SetJoystickPOV(stick, pov, value); +} + +void DriverStationSim::SetJoystickButtons(int stick, uint32_t buttons) { + HALSIM_SetJoystickButtonsValue(stick, buttons); +} + +void DriverStationSim::SetJoystickAxisCount(int stick, int count) { + HALSIM_SetJoystickAxisCount(stick, count); +} + +void DriverStationSim::SetJoystickPOVCount(int stick, int count) { + HALSIM_SetJoystickPOVCount(stick, count); +} + +void DriverStationSim::SetJoystickButtonCount(int stick, int count) { + HALSIM_SetJoystickButtonCount(stick, count); +} + +void DriverStationSim::SetJoystickIsXbox(int stick, bool isXbox) { + HALSIM_SetJoystickIsXbox(stick, isXbox); +} + +void DriverStationSim::SetJoystickType(int stick, int type) { + HALSIM_SetJoystickType(stick, type); +} + +void DriverStationSim::SetJoystickName(int stick, const char* name) { + HALSIM_SetJoystickName(stick, name); +} + +void DriverStationSim::SetJoystickAxisType(int stick, int axis, int type) { + HALSIM_SetJoystickAxisType(stick, axis, type); +} + +void DriverStationSim::SetGameSpecificMessage(const char* message) { + HALSIM_SetGameSpecificMessage(message); +} + +void DriverStationSim::SetEventName(const char* name) { + HALSIM_SetEventName(name); +} + +void DriverStationSim::SetMatchType(DriverStation::MatchType type) { + HALSIM_SetMatchType(static_cast(static_cast(type))); +} + +void DriverStationSim::SetMatchNumber(int matchNumber) { + HALSIM_SetMatchNumber(matchNumber); +} + +void DriverStationSim::SetReplayNumber(int replayNumber) { + HALSIM_SetReplayNumber(replayNumber); +} + +void DriverStationSim::ResetData() { HALSIM_ResetDriverStationData(); } diff --git a/wpilibc/src/main/native/cpp/simulation/DutyCycleSim.cpp b/wpilibc/src/main/native/cpp/simulation/DutyCycleSim.cpp new file mode 100644 index 0000000000..7ec19fd9ac --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/DutyCycleSim.cpp @@ -0,0 +1,85 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2019-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/DutyCycleSim.h" + +#include +#include +#include + +#include + +#include "frc/DutyCycle.h" + +using namespace frc; +using namespace frc::sim; + +DutyCycleSim::DutyCycleSim(const DutyCycle& dutyCycle) + : m_index{dutyCycle.GetFPGAIndex()} {} + +DutyCycleSim DutyCycleSim::CreateForChannel(int channel) { + int index = HALSIM_FindDutyCycleForChannel(channel); + if (index < 0) throw std::out_of_range("no duty cycle found for channel"); + return DutyCycleSim{index}; +} + +DutyCycleSim DutyCycleSim::CreateForIndex(int index) { + return DutyCycleSim{index}; +} + +std::unique_ptr DutyCycleSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDutyCycleInitializedCallback); + store->SetUid(HALSIM_RegisterDutyCycleInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool DutyCycleSim::GetInitialized() const { + return HALSIM_GetDutyCycleInitialized(m_index); +} + +void DutyCycleSim::SetInitialized(bool initialized) { + HALSIM_SetDutyCycleInitialized(m_index, initialized); +} + +std::unique_ptr DutyCycleSim::RegisterFrequencyCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDutyCycleFrequencyCallback); + store->SetUid(HALSIM_RegisterDutyCycleFrequencyCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int DutyCycleSim::GetFrequency() const { + return HALSIM_GetDutyCycleFrequency(m_index); +} + +void DutyCycleSim::SetFrequency(int count) { + HALSIM_SetDutyCycleFrequency(m_index, count); +} + +std::unique_ptr DutyCycleSim::RegisterOutputCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelDutyCycleOutputCallback); + store->SetUid(HALSIM_RegisterDutyCycleOutputCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double DutyCycleSim::GetOutput() const { + return HALSIM_GetDutyCycleOutput(m_index); +} + +void DutyCycleSim::SetOutput(double period) { + HALSIM_SetDutyCycleOutput(m_index, period); +} + +void DutyCycleSim::ResetData() { HALSIM_ResetDutyCycleData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/EncoderSim.cpp b/wpilibc/src/main/native/cpp/simulation/EncoderSim.cpp new file mode 100644 index 0000000000..5bc5d52e60 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/EncoderSim.cpp @@ -0,0 +1,189 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/EncoderSim.h" + +#include +#include +#include + +#include + +#include "frc/Encoder.h" + +using namespace frc; +using namespace frc::sim; + +EncoderSim::EncoderSim(const Encoder& encoder) + : m_index{encoder.GetFPGAIndex()} {} + +EncoderSim EncoderSim::CreateForChannel(int channel) { + int index = HALSIM_FindEncoderForChannel(channel); + if (index < 0) throw std::out_of_range("no encoder found for channel"); + return EncoderSim{index}; +} + +EncoderSim EncoderSim::CreateForIndex(int index) { return EncoderSim{index}; } + +std::unique_ptr EncoderSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderInitializedCallback); + store->SetUid(HALSIM_RegisterEncoderInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool EncoderSim::GetInitialized() const { + return HALSIM_GetEncoderInitialized(m_index); +} + +void EncoderSim::SetInitialized(bool initialized) { + HALSIM_SetEncoderInitialized(m_index, initialized); +} + +std::unique_ptr EncoderSim::RegisterCountCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderCountCallback); + store->SetUid(HALSIM_RegisterEncoderCountCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int EncoderSim::GetCount() const { return HALSIM_GetEncoderCount(m_index); } + +void EncoderSim::SetCount(int count) { HALSIM_SetEncoderCount(m_index, count); } + +std::unique_ptr EncoderSim::RegisterPeriodCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderPeriodCallback); + store->SetUid(HALSIM_RegisterEncoderPeriodCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double EncoderSim::GetPeriod() const { + return HALSIM_GetEncoderPeriod(m_index); +} + +void EncoderSim::SetPeriod(double period) { + HALSIM_SetEncoderPeriod(m_index, period); +} + +std::unique_ptr EncoderSim::RegisterResetCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderResetCallback); + store->SetUid(HALSIM_RegisterEncoderResetCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool EncoderSim::GetReset() const { return HALSIM_GetEncoderReset(m_index); } + +void EncoderSim::SetReset(bool reset) { + HALSIM_SetEncoderReset(m_index, reset); +} + +std::unique_ptr EncoderSim::RegisterMaxPeriodCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderMaxPeriodCallback); + store->SetUid(HALSIM_RegisterEncoderMaxPeriodCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double EncoderSim::GetMaxPeriod() const { + return HALSIM_GetEncoderMaxPeriod(m_index); +} + +void EncoderSim::SetMaxPeriod(double maxPeriod) { + HALSIM_SetEncoderMaxPeriod(m_index, maxPeriod); +} + +std::unique_ptr EncoderSim::RegisterDirectionCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderDirectionCallback); + store->SetUid(HALSIM_RegisterEncoderDirectionCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool EncoderSim::GetDirection() const { + return HALSIM_GetEncoderDirection(m_index); +} + +void EncoderSim::SetDirection(bool direction) { + HALSIM_SetEncoderDirection(m_index, direction); +} + +std::unique_ptr EncoderSim::RegisterReverseDirectionCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderReverseDirectionCallback); + store->SetUid(HALSIM_RegisterEncoderReverseDirectionCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool EncoderSim::GetReverseDirection() const { + return HALSIM_GetEncoderReverseDirection(m_index); +} + +void EncoderSim::SetReverseDirection(bool reverseDirection) { + HALSIM_SetEncoderReverseDirection(m_index, reverseDirection); +} + +std::unique_ptr EncoderSim::RegisterSamplesToAverageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderSamplesToAverageCallback); + store->SetUid(HALSIM_RegisterEncoderSamplesToAverageCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int EncoderSim::GetSamplesToAverage() const { + return HALSIM_GetEncoderSamplesToAverage(m_index); +} + +void EncoderSim::SetSamplesToAverage(int samplesToAverage) { + HALSIM_SetEncoderSamplesToAverage(m_index, samplesToAverage); +} + +std::unique_ptr EncoderSim::RegisterDistancePerPulseCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelEncoderDistancePerPulseCallback); + store->SetUid(HALSIM_RegisterEncoderDistancePerPulseCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double EncoderSim::GetDistancePerPulse() const { + return HALSIM_GetEncoderDistancePerPulse(m_index); +} + +void EncoderSim::SetDistancePerPulse(double distancePerPulse) { + HALSIM_SetEncoderDistancePerPulse(m_index, distancePerPulse); +} + +void EncoderSim::ResetData() { HALSIM_ResetEncoderData(m_index); } + +void EncoderSim::SetDistance(double distance) { + HALSIM_SetEncoderDistance(m_index, distance); +} + +double EncoderSim::GetDistance() { return HALSIM_GetEncoderDistance(m_index); } + +void EncoderSim::SetRate(double rate) { HALSIM_SetEncoderRate(m_index, rate); } + +double EncoderSim::GetRate() { return HALSIM_GetEncoderRate(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/GenericHIDSim.cpp b/wpilibc/src/main/native/cpp/simulation/GenericHIDSim.cpp new file mode 100644 index 0000000000..8df265a488 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/GenericHIDSim.cpp @@ -0,0 +1,74 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/GenericHIDSim.h" + +#include "frc/GenericHID.h" +#include "frc/simulation/DriverStationSim.h" + +using namespace frc; +using namespace frc::sim; + +GenericHIDSim::GenericHIDSim(const GenericHID& joystick) + : m_port{joystick.GetPort()} {} + +GenericHIDSim::GenericHIDSim(int port) : m_port{port} {} + +void GenericHIDSim::NotifyNewData() { DriverStationSim::NotifyNewData(); } + +void GenericHIDSim::SetRawButton(int button, bool value) { + DriverStationSim::SetJoystickButton(m_port, button, value); +} + +void GenericHIDSim::SetRawAxis(int axis, double value) { + DriverStationSim::SetJoystickAxis(m_port, axis, value); +} + +void GenericHIDSim::SetPOV(int pov, int value) { + DriverStationSim::SetJoystickPOV(m_port, pov, value); +} + +void GenericHIDSim::SetPOV(int value) { SetPOV(0, value); } + +void GenericHIDSim::SetAxisCount(int count) { + DriverStationSim::SetJoystickAxisCount(m_port, count); +} + +void GenericHIDSim::SetPOVCount(int count) { + DriverStationSim::SetJoystickPOVCount(m_port, count); +} + +void GenericHIDSim::SetButtonCount(int count) { + DriverStationSim::SetJoystickButtonCount(m_port, count); +} + +void GenericHIDSim::SetType(GenericHID::HIDType type) { + DriverStationSim::SetJoystickType(m_port, type); +} + +void GenericHIDSim::SetName(const char* name) { + DriverStationSim::SetJoystickName(m_port, name); +} + +void GenericHIDSim::SetAxisType(int axis, int type) { + DriverStationSim::SetJoystickAxisType(m_port, axis, type); +} + +bool GenericHIDSim::GetOutput(int outputNumber) { + int64_t outputs = GetOutputs(); + return (outputs & (static_cast(1) << (outputNumber - 1))) != 0; +} + +int64_t GenericHIDSim::GetOutputs() { + return DriverStationSim::GetJoystickOutputs(m_port); +} + +double GenericHIDSim::GetRumble(GenericHID::RumbleType type) { + int value = DriverStationSim::GetJoystickRumble( + m_port, type == GenericHID::kLeftRumble ? 0 : 1); + return value / 65535.0; +} diff --git a/wpilibc/src/main/native/cpp/simulation/JoystickSim.cpp b/wpilibc/src/main/native/cpp/simulation/JoystickSim.cpp new file mode 100644 index 0000000000..55f60897bc --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/JoystickSim.cpp @@ -0,0 +1,63 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/JoystickSim.h" + +#include "frc/Joystick.h" +#include "frc/simulation/GenericHIDSim.h" + +using namespace frc; +using namespace frc::sim; + +JoystickSim::JoystickSim(const Joystick& joystick) + : GenericHIDSim{joystick}, m_joystick{&joystick} { + // default to a reasonable joystick configuration + SetAxisCount(5); + SetButtonCount(12); + SetPOVCount(1); +} + +JoystickSim::JoystickSim(int port) : GenericHIDSim{port} { + // default to a reasonable joystick configuration + SetAxisCount(5); + SetButtonCount(12); + SetPOVCount(1); +} + +void JoystickSim::SetX(double value) { + SetRawAxis( + m_joystick ? m_joystick->GetXChannel() : Joystick::kDefaultXChannel, + value); +} + +void JoystickSim::SetY(double value) { + SetRawAxis( + m_joystick ? m_joystick->GetYChannel() : Joystick::kDefaultYChannel, + value); +} + +void JoystickSim::SetZ(double value) { + SetRawAxis( + m_joystick ? m_joystick->GetZChannel() : Joystick::kDefaultZChannel, + value); +} + +void JoystickSim::SetTwist(double value) { + SetRawAxis(m_joystick ? m_joystick->GetTwistChannel() + : Joystick::kDefaultTwistChannel, + value); +} + +void JoystickSim::SetThrottle(double value) { + SetRawAxis(m_joystick ? m_joystick->GetThrottleChannel() + : Joystick::kDefaultThrottleChannel, + value); +} + +void JoystickSim::SetTrigger(bool state) { SetRawButton(1, state); } + +void JoystickSim::SetTop(bool state) { SetRawButton(2, state); } diff --git a/wpilibc/src/main/native/cpp/simulation/PCMSim.cpp b/wpilibc/src/main/native/cpp/simulation/PCMSim.cpp new file mode 100644 index 0000000000..5d0566af1a --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/PCMSim.cpp @@ -0,0 +1,158 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/PCMSim.h" + +#include +#include + +#include + +#include "frc/Compressor.h" +#include "frc/SensorUtil.h" + +using namespace frc; +using namespace frc::sim; + +PCMSim::PCMSim() : m_index{SensorUtil::GetDefaultSolenoidModule()} {} + +PCMSim::PCMSim(int module) : m_index{module} {} + +PCMSim::PCMSim(const Compressor& compressor) + : m_index{compressor.GetModule()} {} + +std::unique_ptr PCMSim::RegisterSolenoidInitializedCallback( + int channel, NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, channel, -1, callback, + &HALSIM_CancelPCMSolenoidInitializedCallback); + store->SetUid(HALSIM_RegisterPCMSolenoidInitializedCallback( + m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PCMSim::GetSolenoidInitialized(int channel) const { + return HALSIM_GetPCMSolenoidInitialized(m_index, channel); +} + +void PCMSim::SetSolenoidInitialized(int channel, bool solenoidInitialized) { + HALSIM_SetPCMSolenoidInitialized(m_index, channel, solenoidInitialized); +} + +std::unique_ptr PCMSim::RegisterSolenoidOutputCallback( + int channel, NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, channel, -1, callback, &HALSIM_CancelPCMSolenoidOutputCallback); + store->SetUid(HALSIM_RegisterPCMSolenoidOutputCallback( + m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PCMSim::GetSolenoidOutput(int channel) const { + return HALSIM_GetPCMSolenoidOutput(m_index, channel); +} + +void PCMSim::SetSolenoidOutput(int channel, bool solenoidOutput) { + HALSIM_SetPCMSolenoidOutput(m_index, channel, solenoidOutput); +} + +std::unique_ptr PCMSim::RegisterCompressorInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMCompressorInitializedCallback); + store->SetUid(HALSIM_RegisterPCMCompressorInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PCMSim::GetCompressorInitialized() const { + return HALSIM_GetPCMCompressorInitialized(m_index); +} + +void PCMSim::SetCompressorInitialized(bool compressorInitialized) { + HALSIM_SetPCMCompressorInitialized(m_index, compressorInitialized); +} + +std::unique_ptr PCMSim::RegisterCompressorOnCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMCompressorOnCallback); + store->SetUid(HALSIM_RegisterPCMCompressorOnCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PCMSim::GetCompressorOn() const { + return HALSIM_GetPCMCompressorOn(m_index); +} + +void PCMSim::SetCompressorOn(bool compressorOn) { + HALSIM_SetPCMCompressorOn(m_index, compressorOn); +} + +std::unique_ptr PCMSim::RegisterClosedLoopEnabledCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMClosedLoopEnabledCallback); + store->SetUid(HALSIM_RegisterPCMClosedLoopEnabledCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PCMSim::GetClosedLoopEnabled() const { + return HALSIM_GetPCMClosedLoopEnabled(m_index); +} + +void PCMSim::SetClosedLoopEnabled(bool closedLoopEnabled) { + HALSIM_SetPCMClosedLoopEnabled(m_index, closedLoopEnabled); +} + +std::unique_ptr PCMSim::RegisterPressureSwitchCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMPressureSwitchCallback); + store->SetUid(HALSIM_RegisterPCMPressureSwitchCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PCMSim::GetPressureSwitch() const { + return HALSIM_GetPCMPressureSwitch(m_index); +} + +void PCMSim::SetPressureSwitch(bool pressureSwitch) { + HALSIM_SetPCMPressureSwitch(m_index, pressureSwitch); +} + +std::unique_ptr PCMSim::RegisterCompressorCurrentCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPCMCompressorCurrentCallback); + store->SetUid(HALSIM_RegisterPCMCompressorCurrentCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double PCMSim::GetCompressorCurrent() const { + return HALSIM_GetPCMCompressorCurrent(m_index); +} + +void PCMSim::SetCompressorCurrent(double compressorCurrent) { + HALSIM_SetPCMCompressorCurrent(m_index, compressorCurrent); +} + +uint8_t PCMSim::GetAllSolenoidOutputs() const { + uint8_t ret = 0; + HALSIM_GetPCMAllSolenoids(m_index, &ret); + return ret; +} + +void PCMSim::SetAllSolenoidOutputs(uint8_t outputs) { + HALSIM_SetPCMAllSolenoids(m_index, outputs); +} + +void PCMSim::ResetData() { HALSIM_ResetPCMData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/PDPSim.cpp b/wpilibc/src/main/native/cpp/simulation/PDPSim.cpp new file mode 100644 index 0000000000..26d6a45464 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/PDPSim.cpp @@ -0,0 +1,98 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/PDPSim.h" + +#include +#include + +#include + +#include "frc/PowerDistributionPanel.h" + +using namespace frc; +using namespace frc::sim; + +PDPSim::PDPSim(int module) : m_index{module} {} + +PDPSim::PDPSim(const PowerDistributionPanel& pdp) : m_index{pdp.GetModule()} {} + +std::unique_ptr PDPSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPDPInitializedCallback); + store->SetUid(HALSIM_RegisterPDPInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PDPSim::GetInitialized() const { + return HALSIM_GetPDPInitialized(m_index); +} + +void PDPSim::SetInitialized(bool initialized) { + HALSIM_SetPDPInitialized(m_index, initialized); +} + +std::unique_ptr PDPSim::RegisterTemperatureCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPDPTemperatureCallback); + store->SetUid(HALSIM_RegisterPDPTemperatureCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double PDPSim::GetTemperature() const { + return HALSIM_GetPDPTemperature(m_index); +} + +void PDPSim::SetTemperature(double temperature) { + HALSIM_SetPDPTemperature(m_index, temperature); +} + +std::unique_ptr PDPSim::RegisterVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPDPVoltageCallback); + store->SetUid(HALSIM_RegisterPDPVoltageCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return store; +} + +double PDPSim::GetVoltage() const { return HALSIM_GetPDPVoltage(m_index); } + +void PDPSim::SetVoltage(double voltage) { + HALSIM_SetPDPVoltage(m_index, voltage); +} + +std::unique_ptr PDPSim::RegisterCurrentCallback( + int channel, NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, channel, -1, callback, &HALSIM_CancelPDPCurrentCallback); + store->SetUid(HALSIM_RegisterPDPCurrentCallback( + m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double PDPSim::GetCurrent(int channel) const { + return HALSIM_GetPDPCurrent(m_index, channel); +} + +void PDPSim::SetCurrent(int channel, double current) { + HALSIM_SetPDPCurrent(m_index, channel, current); +} + +void PDPSim::GetAllCurrents(double* currents) const { + HALSIM_GetPDPAllCurrents(m_index, currents); +} + +void PDPSim::SetAllCurrents(const double* currents) { + HALSIM_SetPDPAllCurrents(m_index, currents); +} + +void PDPSim::ResetData() { HALSIM_ResetPDPData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/PWMSim.cpp b/wpilibc/src/main/native/cpp/simulation/PWMSim.cpp new file mode 100644 index 0000000000..2fae8fb73f --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/PWMSim.cpp @@ -0,0 +1,114 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/PWMSim.h" + +#include +#include + +#include + +#include "frc/PWM.h" + +using namespace frc; +using namespace frc::sim; + +PWMSim::PWMSim(const PWM& pwm) : m_index{pwm.GetChannel()} {} + +PWMSim::PWMSim(int channel) : m_index{channel} {} + +std::unique_ptr PWMSim::RegisterInitializedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMInitializedCallback); + store->SetUid(HALSIM_RegisterPWMInitializedCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PWMSim::GetInitialized() const { + return HALSIM_GetPWMInitialized(m_index); +} + +void PWMSim::SetInitialized(bool initialized) { + HALSIM_SetPWMInitialized(m_index, initialized); +} + +std::unique_ptr PWMSim::RegisterRawValueCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMRawValueCallback); + store->SetUid(HALSIM_RegisterPWMRawValueCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return store; +} + +int PWMSim::GetRawValue() const { return HALSIM_GetPWMRawValue(m_index); } + +void PWMSim::SetRawValue(int rawValue) { + HALSIM_SetPWMRawValue(m_index, rawValue); +} + +std::unique_ptr PWMSim::RegisterSpeedCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique(m_index, -1, callback, + &HALSIM_CancelPWMSpeedCallback); + store->SetUid(HALSIM_RegisterPWMSpeedCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return store; +} + +double PWMSim::GetSpeed() const { return HALSIM_GetPWMSpeed(m_index); } + +void PWMSim::SetSpeed(double speed) { HALSIM_SetPWMSpeed(m_index, speed); } + +std::unique_ptr PWMSim::RegisterPositionCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMPositionCallback); + store->SetUid(HALSIM_RegisterPWMPositionCallback(m_index, &CallbackStoreThunk, + store.get(), initialNotify)); + return store; +} + +double PWMSim::GetPosition() const { return HALSIM_GetPWMPosition(m_index); } + +void PWMSim::SetPosition(double position) { + HALSIM_SetPWMPosition(m_index, position); +} + +std::unique_ptr PWMSim::RegisterPeriodScaleCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMPeriodScaleCallback); + store->SetUid(HALSIM_RegisterPWMPeriodScaleCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int PWMSim::GetPeriodScale() const { return HALSIM_GetPWMPeriodScale(m_index); } + +void PWMSim::SetPeriodScale(int periodScale) { + HALSIM_SetPWMPeriodScale(m_index, periodScale); +} + +std::unique_ptr PWMSim::RegisterZeroLatchCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelPWMZeroLatchCallback); + store->SetUid(HALSIM_RegisterPWMZeroLatchCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool PWMSim::GetZeroLatch() const { return HALSIM_GetPWMZeroLatch(m_index); } + +void PWMSim::SetZeroLatch(bool zeroLatch) { + HALSIM_SetPWMZeroLatch(m_index, zeroLatch); +} + +void PWMSim::ResetData() { HALSIM_ResetPWMData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/RelaySim.cpp b/wpilibc/src/main/native/cpp/simulation/RelaySim.cpp new file mode 100644 index 0000000000..7f7aa65c55 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/RelaySim.cpp @@ -0,0 +1,88 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/RelaySim.h" + +#include +#include + +#include + +#include "frc/Relay.h" + +using namespace frc; +using namespace frc::sim; + +RelaySim::RelaySim(const Relay& relay) : m_index{relay.GetChannel()} {} + +RelaySim::RelaySim(int channel) : m_index{channel} {} + +std::unique_ptr RelaySim::RegisterInitializedForwardCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayInitializedForwardCallback); + store->SetUid(HALSIM_RegisterRelayInitializedForwardCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RelaySim::GetInitializedForward() const { + return HALSIM_GetRelayInitializedForward(m_index); +} + +void RelaySim::SetInitializedForward(bool initializedForward) { + HALSIM_SetRelayInitializedForward(m_index, initializedForward); +} + +std::unique_ptr RelaySim::RegisterInitializedReverseCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayInitializedReverseCallback); + store->SetUid(HALSIM_RegisterRelayInitializedReverseCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RelaySim::GetInitializedReverse() const { + return HALSIM_GetRelayInitializedReverse(m_index); +} + +void RelaySim::SetInitializedReverse(bool initializedReverse) { + HALSIM_SetRelayInitializedReverse(m_index, initializedReverse); +} + +std::unique_ptr RelaySim::RegisterForwardCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayForwardCallback); + store->SetUid(HALSIM_RegisterRelayForwardCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RelaySim::GetForward() const { return HALSIM_GetRelayForward(m_index); } + +void RelaySim::SetForward(bool forward) { + HALSIM_SetRelayForward(m_index, forward); +} + +std::unique_ptr RelaySim::RegisterReverseCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelRelayReverseCallback); + store->SetUid(HALSIM_RegisterRelayReverseCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RelaySim::GetReverse() const { return HALSIM_GetRelayReverse(m_index); } + +void RelaySim::SetReverse(bool reverse) { + HALSIM_SetRelayReverse(m_index, reverse); +} + +void RelaySim::ResetData() { HALSIM_ResetRelayData(m_index); } diff --git a/wpilibc/src/main/native/cpp/simulation/RoboRioSim.cpp b/wpilibc/src/main/native/cpp/simulation/RoboRioSim.cpp new file mode 100644 index 0000000000..0c7a88e02b --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/RoboRioSim.cpp @@ -0,0 +1,255 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/RoboRioSim.h" + +#include +#include + +#include + +using namespace frc; +using namespace frc::sim; + +std::unique_ptr RoboRioSim::RegisterFPGAButtonCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioFPGAButtonCallback); + store->SetUid(HALSIM_RegisterRoboRioFPGAButtonCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RoboRioSim::GetFPGAButton() { return HALSIM_GetRoboRioFPGAButton(); } + +void RoboRioSim::SetFPGAButton(bool fPGAButton) { + HALSIM_SetRoboRioFPGAButton(fPGAButton); +} + +std::unique_ptr RoboRioSim::RegisterVInVoltageCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioVInVoltageCallback); + store->SetUid(HALSIM_RegisterRoboRioVInVoltageCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetVInVoltage() { return HALSIM_GetRoboRioVInVoltage(); } + +void RoboRioSim::SetVInVoltage(double vInVoltage) { + HALSIM_SetRoboRioVInVoltage(vInVoltage); +} + +std::unique_ptr RoboRioSim::RegisterVInCurrentCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioVInCurrentCallback); + store->SetUid(HALSIM_RegisterRoboRioVInCurrentCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetVInCurrent() { return HALSIM_GetRoboRioVInCurrent(); } + +void RoboRioSim::SetVInCurrent(double vInCurrent) { + HALSIM_SetRoboRioVInCurrent(vInCurrent); +} + +std::unique_ptr RoboRioSim::RegisterUserVoltage6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserVoltage6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserVoltage6VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetUserVoltage6V() { + return HALSIM_GetRoboRioUserVoltage6V(); +} + +void RoboRioSim::SetUserVoltage6V(double userVoltage6V) { + HALSIM_SetRoboRioUserVoltage6V(userVoltage6V); +} + +std::unique_ptr RoboRioSim::RegisterUserCurrent6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserCurrent6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserCurrent6VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetUserCurrent6V() { + return HALSIM_GetRoboRioUserCurrent6V(); +} + +void RoboRioSim::SetUserCurrent6V(double userCurrent6V) { + HALSIM_SetRoboRioUserCurrent6V(userCurrent6V); +} + +std::unique_ptr RoboRioSim::RegisterUserActive6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserActive6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserActive6VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RoboRioSim::GetUserActive6V() { return HALSIM_GetRoboRioUserActive6V(); } + +void RoboRioSim::SetUserActive6V(bool userActive6V) { + HALSIM_SetRoboRioUserActive6V(userActive6V); +} + +std::unique_ptr RoboRioSim::RegisterUserVoltage5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserVoltage5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserVoltage5VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetUserVoltage5V() { + return HALSIM_GetRoboRioUserVoltage5V(); +} + +void RoboRioSim::SetUserVoltage5V(double userVoltage5V) { + HALSIM_SetRoboRioUserVoltage5V(userVoltage5V); +} + +std::unique_ptr RoboRioSim::RegisterUserCurrent5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserCurrent5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserCurrent5VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetUserCurrent5V() { + return HALSIM_GetRoboRioUserCurrent5V(); +} + +void RoboRioSim::SetUserCurrent5V(double userCurrent5V) { + HALSIM_SetRoboRioUserCurrent5V(userCurrent5V); +} + +std::unique_ptr RoboRioSim::RegisterUserActive5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserActive5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserActive5VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RoboRioSim::GetUserActive5V() { return HALSIM_GetRoboRioUserActive5V(); } + +void RoboRioSim::SetUserActive5V(bool userActive5V) { + HALSIM_SetRoboRioUserActive5V(userActive5V); +} + +std::unique_ptr RoboRioSim::RegisterUserVoltage3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserVoltage3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserVoltage3V3Callback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetUserVoltage3V3() { + return HALSIM_GetRoboRioUserVoltage3V3(); +} + +void RoboRioSim::SetUserVoltage3V3(double userVoltage3V3) { + HALSIM_SetRoboRioUserVoltage3V3(userVoltage3V3); +} + +std::unique_ptr RoboRioSim::RegisterUserCurrent3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserCurrent3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserCurrent3V3Callback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double RoboRioSim::GetUserCurrent3V3() { + return HALSIM_GetRoboRioUserCurrent3V3(); +} + +void RoboRioSim::SetUserCurrent3V3(double userCurrent3V3) { + HALSIM_SetRoboRioUserCurrent3V3(userCurrent3V3); +} + +std::unique_ptr RoboRioSim::RegisterUserActive3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserActive3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserActive3V3Callback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool RoboRioSim::GetUserActive3V3() { return HALSIM_GetRoboRioUserActive3V3(); } + +void RoboRioSim::SetUserActive3V3(bool userActive3V3) { + HALSIM_SetRoboRioUserActive3V3(userActive3V3); +} + +std::unique_ptr RoboRioSim::RegisterUserFaults6VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserFaults6VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserFaults6VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int RoboRioSim::GetUserFaults6V() { return HALSIM_GetRoboRioUserFaults6V(); } + +void RoboRioSim::SetUserFaults6V(int userFaults6V) { + HALSIM_SetRoboRioUserFaults6V(userFaults6V); +} + +std::unique_ptr RoboRioSim::RegisterUserFaults5VCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserFaults5VCallback); + store->SetUid(HALSIM_RegisterRoboRioUserFaults5VCallback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int RoboRioSim::GetUserFaults5V() { return HALSIM_GetRoboRioUserFaults5V(); } + +void RoboRioSim::SetUserFaults5V(int userFaults5V) { + HALSIM_SetRoboRioUserFaults5V(userFaults5V); +} + +std::unique_ptr RoboRioSim::RegisterUserFaults3V3Callback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + -1, callback, &HALSIM_CancelRoboRioUserFaults3V3Callback); + store->SetUid(HALSIM_RegisterRoboRioUserFaults3V3Callback( + &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int RoboRioSim::GetUserFaults3V3() { return HALSIM_GetRoboRioUserFaults3V3(); } + +void RoboRioSim::SetUserFaults3V3(int userFaults3V3) { + HALSIM_SetRoboRioUserFaults3V3(userFaults3V3); +} + +void ResetData() { HALSIM_ResetRoboRioData(); } diff --git a/wpilibc/src/main/native/cpp/simulation/SPIAccelerometerSim.cpp b/wpilibc/src/main/native/cpp/simulation/SPIAccelerometerSim.cpp new file mode 100644 index 0000000000..b71f99d7e4 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/SPIAccelerometerSim.cpp @@ -0,0 +1,107 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/SPIAccelerometerSim.h" + +#include +#include + +#include + +using namespace frc; +using namespace frc::sim; + +SPIAccelerometerSim::SPIAccelerometerSim(int index) { m_index = index; } + +std::unique_ptr SPIAccelerometerSim::RegisterActiveCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerActiveCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerActiveCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +bool SPIAccelerometerSim::GetActive() const { + return HALSIM_GetSPIAccelerometerActive(m_index); +} + +void SPIAccelerometerSim::SetActive(bool active) { + HALSIM_SetSPIAccelerometerActive(m_index, active); +} + +std::unique_ptr SPIAccelerometerSim::RegisterRangeCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerRangeCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerRangeCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +int SPIAccelerometerSim::GetRange() const { + return HALSIM_GetSPIAccelerometerRange(m_index); +} + +void SPIAccelerometerSim::SetRange(int range) { + HALSIM_SetSPIAccelerometerRange(m_index, range); +} + +std::unique_ptr SPIAccelerometerSim::RegisterXCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerXCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerXCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double SPIAccelerometerSim::GetX() const { + return HALSIM_GetSPIAccelerometerX(m_index); +} + +void SPIAccelerometerSim::SetX(double x) { + HALSIM_SetSPIAccelerometerX(m_index, x); +} + +std::unique_ptr SPIAccelerometerSim::RegisterYCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerYCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerYCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double SPIAccelerometerSim::GetY() const { + return HALSIM_GetSPIAccelerometerY(m_index); +} + +void SPIAccelerometerSim::SetY(double y) { + HALSIM_SetSPIAccelerometerY(m_index, y); +} + +std::unique_ptr SPIAccelerometerSim::RegisterZCallback( + NotifyCallback callback, bool initialNotify) { + auto store = std::make_unique( + m_index, -1, callback, &HALSIM_CancelSPIAccelerometerZCallback); + store->SetUid(HALSIM_RegisterSPIAccelerometerZCallback( + m_index, &CallbackStoreThunk, store.get(), initialNotify)); + return store; +} + +double SPIAccelerometerSim::GetZ() const { + return HALSIM_GetSPIAccelerometerZ(m_index); +} + +void SPIAccelerometerSim::SetZ(double z) { + HALSIM_SetSPIAccelerometerZ(m_index, z); +} + +void SPIAccelerometerSim::ResetData() { + HALSIM_ResetSPIAccelerometerData(m_index); +} diff --git a/wpilibc/src/main/native/cpp/simulation/SimDeviceSim.cpp b/wpilibc/src/main/native/cpp/simulation/SimDeviceSim.cpp new file mode 100644 index 0000000000..3d52cdff27 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/SimDeviceSim.cpp @@ -0,0 +1,47 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2019-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/SimDeviceSim.h" + +#include +#include + +#include +#include + +using namespace frc; +using namespace frc::sim; + +SimDeviceSim::SimDeviceSim(const char* name) + : m_handle{HALSIM_GetSimDeviceHandle(name)} {} + +hal::SimValue SimDeviceSim::GetValue(const char* name) const { + return HALSIM_GetSimValueHandle(m_handle, name); +} + +hal::SimDouble SimDeviceSim::GetDouble(const char* name) const { + return HALSIM_GetSimValueHandle(m_handle, name); +} + +hal::SimEnum SimDeviceSim::GetEnum(const char* name) const { + return HALSIM_GetSimValueHandle(m_handle, name); +} + +hal::SimBoolean SimDeviceSim::GetBoolean(const char* name) const { + return HALSIM_GetSimValueHandle(m_handle, name); +} + +std::vector SimDeviceSim::GetEnumOptions(hal::SimEnum val) { + int32_t numOptions; + const char** options = HALSIM_GetSimValueEnumOptions(val, &numOptions); + std::vector rv; + rv.reserve(numOptions); + for (int32_t i = 0; i < numOptions; ++i) rv.emplace_back(options[i]); + return rv; +} + +void SimDeviceSim::ResetData() { HALSIM_ResetSimDeviceData(); } diff --git a/wpilibc/src/main/native/cpp/simulation/SimHooks.cpp b/wpilibc/src/main/native/cpp/simulation/SimHooks.cpp new file mode 100644 index 0000000000..97c3aeac16 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/SimHooks.cpp @@ -0,0 +1,34 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/SimHooks.h" + +#include + +namespace frc { +namespace sim { + +void SetRuntimeType(HAL_RuntimeType type) { HALSIM_SetRuntimeType(type); } + +void WaitForProgramStart() { HALSIM_WaitForProgramStart(); } + +void SetProgramStarted() { HALSIM_SetProgramStarted(); } + +bool GetProgramStarted() { return HALSIM_GetProgramStarted(); } + +void RestartTiming() { HALSIM_RestartTiming(); } + +void PauseTiming() { HALSIM_PauseTiming(); } + +void ResumeTiming() { HALSIM_ResumeTiming(); } + +bool IsTimingPaused() { return HALSIM_IsTimingPaused(); } + +void StepTiming(uint64_t delta) { HALSIM_StepTiming(delta); } + +} // namespace sim +} // namespace frc diff --git a/wpilibc/src/main/native/cpp/simulation/XboxControllerSim.cpp b/wpilibc/src/main/native/cpp/simulation/XboxControllerSim.cpp new file mode 100644 index 0000000000..e3bbdce786 --- /dev/null +++ b/wpilibc/src/main/native/cpp/simulation/XboxControllerSim.cpp @@ -0,0 +1,90 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) 2020 FIRST. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in the root directory of */ +/* the project. */ +/*----------------------------------------------------------------------------*/ + +#include "frc/simulation/XboxControllerSim.h" + +#include "frc/XboxController.h" + +using namespace frc; +using namespace frc::sim; + +XboxControllerSim::XboxControllerSim(const XboxController& joystick) + : GenericHIDSim{joystick} { + SetAxisCount(6); + SetButtonCount(10); +} + +XboxControllerSim::XboxControllerSim(int port) : GenericHIDSim{port} { + SetAxisCount(6); + SetButtonCount(10); +} + +void XboxControllerSim::SetX(GenericHID::JoystickHand hand, double value) { + if (hand == GenericHID::kLeftHand) { + SetRawAxis(static_cast(XboxController::Axis::kLeftX), value); + } else { + SetRawAxis(static_cast(XboxController::Axis::kRightX), value); + } +} + +void XboxControllerSim::SetY(GenericHID::JoystickHand hand, double value) { + if (hand == GenericHID::kLeftHand) { + SetRawAxis(static_cast(XboxController::Axis::kLeftY), value); + } else { + SetRawAxis(static_cast(XboxController::Axis::kRightY), value); + } +} + +void XboxControllerSim::SetTriggerAxis(GenericHID::JoystickHand hand, + double value) { + if (hand == GenericHID::kLeftHand) { + SetRawAxis(static_cast(XboxController::Axis::kLeftTrigger), value); + } else { + SetRawAxis(static_cast(XboxController::Axis::kRightTrigger), value); + } +} + +void XboxControllerSim::SetBumper(GenericHID::JoystickHand hand, bool state) { + if (hand == GenericHID::kLeftHand) { + SetRawButton(static_cast(XboxController::Button::kBumperLeft), state); + } else { + SetRawButton(static_cast(XboxController::Button::kBumperRight), state); + } +} + +void XboxControllerSim::SetStickButton(GenericHID::JoystickHand hand, + bool state) { + if (hand == GenericHID::kLeftHand) { + SetRawButton(static_cast(XboxController::Button::kStickLeft), state); + } else { + SetRawButton(static_cast(XboxController::Button::kStickRight), state); + } +} + +void XboxControllerSim::SetAButton(bool state) { + SetRawButton(static_cast(XboxController::Button::kA), state); +} + +void XboxControllerSim::SetBButton(bool state) { + SetRawButton(static_cast(XboxController::Button::kB), state); +} + +void XboxControllerSim::SetXButton(bool state) { + SetRawButton(static_cast(XboxController::Button::kX), state); +} + +void XboxControllerSim::SetYButton(bool state) { + SetRawButton(static_cast(XboxController::Button::kY), state); +} + +void XboxControllerSim::SetBackButton(bool state) { + SetRawButton(static_cast(XboxController::Button::kBack), state); +} + +void XboxControllerSim::SetStartButton(bool state) { + SetRawButton(static_cast(XboxController::Button::kStart), state); +} diff --git a/wpilibc/src/main/native/include/frc/simulation/AddressableLEDSim.h b/wpilibc/src/main/native/include/frc/simulation/AddressableLEDSim.h index d5d5fa6828..0c578f4dde 100644 --- a/wpilibc/src/main/native/include/frc/simulation/AddressableLEDSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/AddressableLEDSim.h @@ -7,17 +7,16 @@ #pragma once -#include #include -#include -#include -#include +#include "frc/simulation/CallbackStore.h" -#include "CallbackStore.h" -#include "frc/AddressableLED.h" +struct HAL_AddressableLEDData; namespace frc { + +class AddressableLED; + namespace sim { /** @@ -28,15 +27,14 @@ class AddressableLEDSim { /** * Constructs for the first addressable LED. */ - AddressableLEDSim() : m_index{0} {} + AddressableLEDSim(); /** * Constructs from an AddressableLED object. * * @param addressableLED AddressableLED to simulate */ - explicit AddressableLEDSim(const AddressableLED& addressableLED) - : m_index{0} {} + explicit AddressableLEDSim(const AddressableLED& addressableLED); /** * Creates an AddressableLEDSim for a PWM channel. @@ -46,12 +44,7 @@ class AddressableLEDSim { * @throws std::out_of_range if no AddressableLED is configured for that * channel */ - static AddressableLEDSim CreateForChannel(int pwmChannel) { - int index = HALSIM_FindAddressableLEDForChannel(pwmChannel); - if (index < 0) - throw std::out_of_range("no addressable LED found for PWM channel"); - return AddressableLEDSim{index}; - } + static AddressableLEDSim CreateForChannel(int pwmChannel); /** * Creates an AddressableLEDSim for a simulated index. @@ -60,90 +53,42 @@ class AddressableLEDSim { * @param index simulator index * @return Simulated object */ - static AddressableLEDSim CreateForIndex(int index) { - return AddressableLEDSim{index}; - } + static AddressableLEDSim CreateForIndex(int index); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAddressableLEDInitializedCallback); - store->SetUid(HALSIM_RegisterAddressableLEDInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { - return HALSIM_GetAddressableLEDInitialized(m_index); - } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetAddressableLEDInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); - std::unique_ptr registerOutputPortCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAddressableLEDOutputPortCallback); - store->SetUid(HALSIM_RegisterAddressableLEDOutputPortCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + std::unique_ptr RegisterOutputPortCallback( + NotifyCallback callback, bool initialNotify); - int GetOutputPort() const { - return HALSIM_GetAddressableLEDOutputPort(m_index); - } + int GetOutputPort() const; - void SetOutputPort(int outputPort) { - HALSIM_SetAddressableLEDOutputPort(m_index, outputPort); - } + void SetOutputPort(int outputPort); std::unique_ptr RegisterLengthCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAddressableLEDLengthCallback); - store->SetUid(HALSIM_RegisterAddressableLEDLengthCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - int GetLength() const { return HALSIM_GetAddressableLEDLength(m_index); } + int GetLength() const; - void SetLength(int length) { - HALSIM_SetAddressableLEDLength(m_index, length); - } + void SetLength(int length); std::unique_ptr RegisterRunningCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAddressableLEDRunningCallback); - store->SetUid(HALSIM_RegisterAddressableLEDRunningCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetRunning() const { return HALSIM_GetAddressableLEDRunning(m_index); } + int GetRunning() const; - void SetRunning(bool running) { - HALSIM_SetAddressableLEDRunning(m_index, running); - } + void SetRunning(bool running); std::unique_ptr RegisterDataCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAddressableLEDDataCallback); - store->SetUid(HALSIM_RegisterAddressableLEDDataCallback( - m_index, &ConstBufferCallbackStoreThunk, store.get())); - return store; - } + bool initialNotify); - int GetData(struct HAL_AddressableLEDData* data) const { - return HALSIM_GetAddressableLEDData(m_index, data); - } + int GetData(struct HAL_AddressableLEDData* data) const; - void SetData(struct HAL_AddressableLEDData* data, int length) { - HALSIM_SetAddressableLEDData(m_index, data, length); - } + void SetData(struct HAL_AddressableLEDData* data, int length); private: explicit AddressableLEDSim(int index) : m_index{index} {} diff --git a/wpilibc/src/main/native/include/frc/simulation/AnalogGyroSim.h b/wpilibc/src/main/native/include/frc/simulation/AnalogGyroSim.h index a1d26c95ca..685e3ed340 100644 --- a/wpilibc/src/main/native/include/frc/simulation/AnalogGyroSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/AnalogGyroSim.h @@ -8,15 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/AnalogGyro.h" -#include "frc/AnalogInput.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class AnalogGyro; + namespace sim { /** @@ -29,60 +27,37 @@ class AnalogGyroSim { * * @param gyro AnalogGyro to simulate */ - explicit AnalogGyroSim(const AnalogGyro& gyro) - : m_index{gyro.GetAnalogInput()->GetChannel()} {} + explicit AnalogGyroSim(const AnalogGyro& gyro); /** * Constructs from an analog input channel number. * * @param channel Channel number */ - explicit AnalogGyroSim(int channel) : m_index{channel} {} + explicit AnalogGyroSim(int channel); std::unique_ptr RegisterAngleCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogGyroAngleCallback); - store->SetUid(HALSIM_RegisterAnalogGyroAngleCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetAngle() const { return HALSIM_GetAnalogGyroAngle(m_index); } + double GetAngle() const; - void SetAngle(double angle) { HALSIM_SetAnalogGyroAngle(m_index, angle); } + void SetAngle(double angle); std::unique_ptr RegisterRateCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogGyroRateCallback); - store->SetUid(HALSIM_RegisterAnalogGyroRateCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetRate() const { return HALSIM_GetAnalogGyroRate(m_index); } + double GetRate() const; - void SetRate(double rate) { HALSIM_SetAnalogGyroRate(m_index, rate); } + void SetRate(double rate); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogGyroInitializedCallback); - store->SetUid(HALSIM_RegisterAnalogGyroInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { - return HALSIM_GetAnalogGyroInitialized(m_index); - } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetAnalogGyroInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); - void ResetData() { HALSIM_ResetAnalogGyroData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/AnalogInputSim.h b/wpilibc/src/main/native/include/frc/simulation/AnalogInputSim.h index f975c218a1..a52cec46f8 100644 --- a/wpilibc/src/main/native/include/frc/simulation/AnalogInputSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/AnalogInputSim.h @@ -8,14 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/AnalogInput.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class AnalogInput; + namespace sim { /** @@ -28,166 +27,79 @@ class AnalogInputSim { * * @param analogInput AnalogInput to simulate */ - explicit AnalogInputSim(const AnalogInput& analogInput) - : m_index{analogInput.GetChannel()} {} + explicit AnalogInputSim(const AnalogInput& analogInput); /** * Constructs from an analog input channel number. * * @param channel Channel number */ - explicit AnalogInputSim(int channel) : m_index{channel} {} + explicit AnalogInputSim(int channel); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInInitializedCallback); - store->SetUid(HALSIM_RegisterAnalogInInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { return HALSIM_GetAnalogInInitialized(m_index); } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetAnalogInInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterAverageBitsCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInAverageBitsCallback); - store->SetUid(HALSIM_RegisterAnalogInAverageBitsCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetAverageBits() const { return HALSIM_GetAnalogInAverageBits(m_index); } + int GetAverageBits() const; - void SetAverageBits(int averageBits) { - HALSIM_SetAnalogInAverageBits(m_index, averageBits); - } + void SetAverageBits(int averageBits); std::unique_ptr RegisterOversampleBitsCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInOversampleBitsCallback); - store->SetUid(HALSIM_RegisterAnalogInOversampleBitsCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetOversampleBits() const { - return HALSIM_GetAnalogInOversampleBits(m_index); - } + int GetOversampleBits() const; - void SetOversampleBits(int oversampleBits) { - HALSIM_SetAnalogInOversampleBits(m_index, oversampleBits); - } + void SetOversampleBits(int oversampleBits); std::unique_ptr RegisterVoltageCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInVoltageCallback); - store->SetUid(HALSIM_RegisterAnalogInVoltageCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetVoltage() const { return HALSIM_GetAnalogInVoltage(m_index); } + double GetVoltage() const; - void SetVoltage(double voltage) { - HALSIM_SetAnalogInVoltage(m_index, voltage); - } + void SetVoltage(double voltage); std::unique_ptr RegisterAccumulatorInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, - &HALSIM_CancelAnalogInAccumulatorInitializedCallback); - store->SetUid(HALSIM_RegisterAnalogInAccumulatorInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetAccumulatorInitialized() const { - return HALSIM_GetAnalogInAccumulatorInitialized(m_index); - } + bool GetAccumulatorInitialized() const; - void SetAccumulatorInitialized(bool accumulatorInitialized) { - HALSIM_SetAnalogInAccumulatorInitialized(m_index, accumulatorInitialized); - } + void SetAccumulatorInitialized(bool accumulatorInitialized); std::unique_ptr RegisterAccumulatorValueCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorValueCallback); - store->SetUid(HALSIM_RegisterAnalogInAccumulatorValueCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int64_t GetAccumulatorValue() const { - return HALSIM_GetAnalogInAccumulatorValue(m_index); - } + int64_t GetAccumulatorValue() const; - void SetAccumulatorValue(int64_t accumulatorValue) { - HALSIM_SetAnalogInAccumulatorValue(m_index, accumulatorValue); - } + void SetAccumulatorValue(int64_t accumulatorValue); std::unique_ptr RegisterAccumulatorCountCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCountCallback); - store->SetUid(HALSIM_RegisterAnalogInAccumulatorCountCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int64_t GetAccumulatorCount() const { - return HALSIM_GetAnalogInAccumulatorCount(m_index); - } + int64_t GetAccumulatorCount() const; - void SetAccumulatorCount(int64_t accumulatorCount) { - HALSIM_SetAnalogInAccumulatorCount(m_index, accumulatorCount); - } + void SetAccumulatorCount(int64_t accumulatorCount); std::unique_ptr RegisterAccumulatorCenterCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCenterCallback); - store->SetUid(HALSIM_RegisterAnalogInAccumulatorCenterCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetAccumulatorCenter() const { - return HALSIM_GetAnalogInAccumulatorCenter(m_index); - } + int GetAccumulatorCenter() const; - void SetAccumulatorCenter(int accumulatorCenter) { - HALSIM_SetAnalogInAccumulatorCenter(m_index, accumulatorCenter); - } + void SetAccumulatorCenter(int accumulatorCenter); std::unique_ptr RegisterAccumulatorDeadbandCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, - &HALSIM_CancelAnalogInAccumulatorDeadbandCallback); - store->SetUid(HALSIM_RegisterAnalogInAccumulatorDeadbandCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetAccumulatorDeadband() const { - return HALSIM_GetAnalogInAccumulatorDeadband(m_index); - } + int GetAccumulatorDeadband() const; - void SetAccumulatorDeadband(int accumulatorDeadband) { - HALSIM_SetAnalogInAccumulatorDeadband(m_index, accumulatorDeadband); - } + void SetAccumulatorDeadband(int accumulatorDeadband); - void ResetData() { HALSIM_ResetAnalogInData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/AnalogOutputSim.h b/wpilibc/src/main/native/include/frc/simulation/AnalogOutputSim.h index a72f59febc..e468fa59c2 100644 --- a/wpilibc/src/main/native/include/frc/simulation/AnalogOutputSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/AnalogOutputSim.h @@ -8,14 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/AnalogOutput.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class AnalogOutput; + namespace sim { /** @@ -28,49 +27,30 @@ class AnalogOutputSim { * * @param analogOutput AnalogOutput to simulate */ - explicit AnalogOutputSim(const AnalogOutput& analogOutput) - : m_index{analogOutput.GetChannel()} {} + explicit AnalogOutputSim(const AnalogOutput& analogOutput); /** * Constructs from an analog output channel number. * * @param channel Channel number */ - explicit AnalogOutputSim(int channel) : m_index{channel} {} + explicit AnalogOutputSim(int channel); std::unique_ptr RegisterVoltageCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogOutVoltageCallback); - store->SetUid(HALSIM_RegisterAnalogOutVoltageCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetVoltage() const { return HALSIM_GetAnalogOutVoltage(m_index); } + double GetVoltage() const; - void SetVoltage(double voltage) { - HALSIM_SetAnalogOutVoltage(m_index, voltage); - } + void SetVoltage(double voltage); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogOutInitializedCallback); - store->SetUid(HALSIM_RegisterAnalogOutInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { - return HALSIM_GetAnalogOutInitialized(m_index); - } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetAnalogOutInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); - void ResetData() { HALSIM_ResetAnalogOutData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/AnalogTriggerSim.h b/wpilibc/src/main/native/include/frc/simulation/AnalogTriggerSim.h index 8dc41a55f2..60d62e14f9 100644 --- a/wpilibc/src/main/native/include/frc/simulation/AnalogTriggerSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/AnalogTriggerSim.h @@ -7,16 +7,14 @@ #pragma once -#include #include -#include -#include - -#include "CallbackStore.h" -#include "frc/AnalogTrigger.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class AnalogTrigger; + namespace sim { /** @@ -29,8 +27,7 @@ class AnalogTriggerSim { * * @param analogTrigger AnalogTrigger to simulate */ - explicit AnalogTriggerSim(const AnalogTrigger& analogTrigger) - : m_index{analogTrigger.GetIndex()} {} + explicit AnalogTriggerSim(const AnalogTrigger& analogTrigger); /** * Creates an AnalogTriggerSim for an analog input channel. @@ -40,12 +37,7 @@ class AnalogTriggerSim { * @throws std::out_of_range if no AnalogTrigger is configured for that * channel */ - static AnalogTriggerSim CreateForChannel(int channel) { - int index = HALSIM_FindAnalogTriggerForChannel(channel); - if (index < 0) - throw std::out_of_range("no analog trigger found for channel"); - return AnalogTriggerSim{index}; - } + static AnalogTriggerSim CreateForChannel(int channel); /** * Creates an AnalogTriggerSim for a simulated index. @@ -54,64 +46,30 @@ class AnalogTriggerSim { * @param index simulator index * @return Simulated object */ - static AnalogTriggerSim CreateForIndex(int index) { - return AnalogTriggerSim{index}; - } + static AnalogTriggerSim CreateForIndex(int index); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAnalogTriggerInitializedCallback); - store->SetUid(HALSIM_RegisterAnalogTriggerInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { - return HALSIM_GetAnalogTriggerInitialized(m_index); - } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetAnalogTriggerInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterTriggerLowerBoundCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, - &HALSIM_CancelAnalogTriggerTriggerLowerBoundCallback); - store->SetUid(HALSIM_RegisterAnalogTriggerTriggerLowerBoundCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetTriggerLowerBound() const { - return HALSIM_GetAnalogTriggerTriggerLowerBound(m_index); - } + double GetTriggerLowerBound() const; - void SetTriggerLowerBound(double triggerLowerBound) { - HALSIM_SetAnalogTriggerTriggerLowerBound(m_index, triggerLowerBound); - } + void SetTriggerLowerBound(double triggerLowerBound); std::unique_ptr RegisterTriggerUpperBoundCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, - &HALSIM_CancelAnalogTriggerTriggerUpperBoundCallback); - store->SetUid(HALSIM_RegisterAnalogTriggerTriggerUpperBoundCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetTriggerUpperBound() const { - return HALSIM_GetAnalogTriggerTriggerUpperBound(m_index); - } + double GetTriggerUpperBound() const; - void SetTriggerUpperBound(double triggerUpperBound) { - HALSIM_SetAnalogTriggerTriggerUpperBound(m_index, triggerUpperBound); - } + void SetTriggerUpperBound(double triggerUpperBound); - void ResetData() { HALSIM_ResetAnalogTriggerData(m_index); } + void ResetData(); private: explicit AnalogTriggerSim(int index) : m_index{index} {} diff --git a/wpilibc/src/main/native/include/frc/simulation/BuiltInAccelerometerSim.h b/wpilibc/src/main/native/include/frc/simulation/BuiltInAccelerometerSim.h index e3b816a197..49a581c13b 100644 --- a/wpilibc/src/main/native/include/frc/simulation/BuiltInAccelerometerSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/BuiltInAccelerometerSim.h @@ -8,14 +8,15 @@ #pragma once #include -#include -#include +#include -#include "CallbackStore.h" -#include "frc/BuiltInAccelerometer.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class BuiltInAccelerometer; + namespace sim { /** @@ -26,88 +27,51 @@ class BuiltInAccelerometerSim { /** * Constructs for the first built-in accelerometer. */ - BuiltInAccelerometerSim() : m_index{0} {} + BuiltInAccelerometerSim(); /** * Constructs from a BuiltInAccelerometer object. * * @param accel BuiltInAccelerometer to simulate */ - explicit BuiltInAccelerometerSim(const BuiltInAccelerometer& accel) - : m_index{0} {} + explicit BuiltInAccelerometerSim(const BuiltInAccelerometer& accel); std::unique_ptr RegisterActiveCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAccelerometerActiveCallback); - store->SetUid(HALSIM_RegisterAccelerometerActiveCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - bool GetActive() const { return HALSIM_GetAccelerometerActive(m_index); } + bool GetActive() const; - void SetActive(bool active) { - HALSIM_SetAccelerometerActive(m_index, active); - } + void SetActive(bool active); std::unique_ptr RegisterRangeCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAccelerometerRangeCallback); - store->SetUid(HALSIM_RegisterAccelerometerRangeCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - HAL_AccelerometerRange GetRange() const { - return HALSIM_GetAccelerometerRange(m_index); - } + HAL_AccelerometerRange GetRange() const; - void SetRange(HAL_AccelerometerRange range) { - HALSIM_SetAccelerometerRange(m_index, range); - } + void SetRange(HAL_AccelerometerRange range); std::unique_ptr RegisterXCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAccelerometerXCallback); - store->SetUid(HALSIM_RegisterAccelerometerXCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetX() const { return HALSIM_GetAccelerometerX(m_index); } + double GetX() const; - void SetX(double x) { HALSIM_SetAccelerometerX(m_index, x); } + void SetX(double x); std::unique_ptr RegisterYCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAccelerometerYCallback); - store->SetUid(HALSIM_RegisterAccelerometerYCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetY() const { return HALSIM_GetAccelerometerY(m_index); } + double GetY() const; - void SetY(double y) { HALSIM_SetAccelerometerY(m_index, y); } + void SetY(double y); std::unique_ptr RegisterZCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelAccelerometerZCallback); - store->SetUid(HALSIM_RegisterAccelerometerZCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetZ() const { return HALSIM_GetAccelerometerZ(m_index); } + double GetZ() const; - void SetZ(double z) { HALSIM_SetAccelerometerZ(m_index, z); } + void SetZ(double z); - void ResetData() { HALSIM_ResetAccelerometerData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/CallbackStore.h b/wpilibc/src/main/native/include/frc/simulation/CallbackStore.h index f41742b911..379296a923 100644 --- a/wpilibc/src/main/native/include/frc/simulation/CallbackStore.h +++ b/wpilibc/src/main/native/include/frc/simulation/CallbackStore.h @@ -30,74 +30,29 @@ void ConstBufferCallbackStoreThunk(const char* name, void* param, class CallbackStore { public: - CallbackStore(int32_t i, NotifyCallback cb, CancelCallbackNoIndexFunc ccf) { - index = i; - callback = cb; - this->ccnif = ccf; - cancelType = NoIndex; - } + CallbackStore(int32_t i, NotifyCallback cb, CancelCallbackNoIndexFunc ccf); CallbackStore(int32_t i, int32_t u, NotifyCallback cb, - CancelCallbackFunc ccf) { - index = i; - uid = u; - callback = cb; - this->ccf = ccf; - cancelType = Normal; - } + CancelCallbackFunc ccf); CallbackStore(int32_t i, int32_t c, int32_t u, NotifyCallback cb, - CancelCallbackChannelFunc ccf) { - index = i; - channel = c; - uid = u; - callback = cb; - this->cccf = ccf; - cancelType = Channel; - } + CancelCallbackChannelFunc ccf); CallbackStore(int32_t i, ConstBufferCallback cb, - CancelCallbackNoIndexFunc ccf) { - index = i; - constBufferCallback = cb; - this->ccnif = ccf; - cancelType = NoIndex; - } + CancelCallbackNoIndexFunc ccf); CallbackStore(int32_t i, int32_t u, ConstBufferCallback cb, - CancelCallbackFunc ccf) { - index = i; - uid = u; - constBufferCallback = cb; - this->ccf = ccf; - cancelType = Normal; - } + CancelCallbackFunc ccf); CallbackStore(int32_t i, int32_t c, int32_t u, ConstBufferCallback cb, - CancelCallbackChannelFunc ccf) { - index = i; - channel = c; - uid = u; - constBufferCallback = cb; - this->cccf = ccf; - cancelType = Channel; - } + CancelCallbackChannelFunc ccf); - ~CallbackStore() { - switch (cancelType) { - case Normal: - ccf(index, uid); - break; - case Channel: - cccf(index, channel, uid); - break; - case NoIndex: - ccnif(uid); - break; - } - } + CallbackStore(const CallbackStore&) = delete; + CallbackStore& operator=(const CallbackStore&) = delete; - void SetUid(int32_t uid) { this->uid = uid; } + ~CallbackStore(); + + void SetUid(int32_t uid); friend void CallbackStoreThunk(const char* name, void* param, const HAL_Value* value); diff --git a/wpilibc/src/main/native/include/frc/simulation/DIOSim.h b/wpilibc/src/main/native/include/frc/simulation/DIOSim.h index 6985ecb9ce..f6edb39b35 100644 --- a/wpilibc/src/main/native/include/frc/simulation/DIOSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/DIOSim.h @@ -8,15 +8,14 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/DigitalInput.h" -#include "frc/DigitalOutput.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class DigitalInput; +class DigitalOutput; + namespace sim { /** @@ -29,94 +28,58 @@ class DIOSim { * * @param input DigitalInput to simulate */ - explicit DIOSim(const DigitalInput& input) : m_index{input.GetChannel()} {} + explicit DIOSim(const DigitalInput& input); /** * Constructs from a DigitalOutput object. * * @param output DigitalOutput to simulate */ - explicit DIOSim(const DigitalOutput& output) : m_index{output.GetChannel()} {} + explicit DIOSim(const DigitalOutput& output); /** * Constructs from an digital I/O channel number. * * @param channel Channel number */ - explicit DIOSim(int channel) : m_index{channel} {} + explicit DIOSim(int channel); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDIOInitializedCallback); - store->SetUid(HALSIM_RegisterDIOInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { return HALSIM_GetDIOInitialized(m_index); } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetDIOInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterValueCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDIOValueCallback); - store->SetUid(HALSIM_RegisterDIOValueCallback(m_index, &CallbackStoreThunk, - store.get(), initialNotify)); - return store; - } + bool initialNotify); - bool GetValue() const { return HALSIM_GetDIOValue(m_index); } + bool GetValue() const; - void SetValue(bool value) { HALSIM_SetDIOValue(m_index, value); } + void SetValue(bool value); std::unique_ptr RegisterPulseLengthCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDIOPulseLengthCallback); - store->SetUid(HALSIM_RegisterDIOPulseLengthCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetPulseLength() const { return HALSIM_GetDIOPulseLength(m_index); } + double GetPulseLength() const; - void SetPulseLength(double pulseLength) { - HALSIM_SetDIOPulseLength(m_index, pulseLength); - } + void SetPulseLength(double pulseLength); std::unique_ptr RegisterIsInputCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDIOIsInputCallback); - store->SetUid(HALSIM_RegisterDIOIsInputCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetIsInput() const { return HALSIM_GetDIOIsInput(m_index); } + bool GetIsInput() const; - void SetIsInput(bool isInput) { HALSIM_SetDIOIsInput(m_index, isInput); } + void SetIsInput(bool isInput); std::unique_ptr RegisterFilterIndexCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDIOFilterIndexCallback); - store->SetUid(HALSIM_RegisterDIOFilterIndexCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetFilterIndex() const { return HALSIM_GetDIOFilterIndex(m_index); } + int GetFilterIndex() const; - void SetFilterIndex(int filterIndex) { - HALSIM_SetDIOFilterIndex(m_index, filterIndex); - } + void SetFilterIndex(int filterIndex); - void ResetData() { HALSIM_ResetDIOData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/DigitalPWMSim.h b/wpilibc/src/main/native/include/frc/simulation/DigitalPWMSim.h index b9e8c6a5b8..2ff8a12cad 100644 --- a/wpilibc/src/main/native/include/frc/simulation/DigitalPWMSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/DigitalPWMSim.h @@ -7,16 +7,14 @@ #pragma once -#include #include -#include -#include - -#include "CallbackStore.h" -#include "frc/DigitalOutput.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class DigitalOutput; + namespace sim { /** @@ -32,8 +30,7 @@ class DigitalPWMSim { * * @param digitalOutput DigitalOutput to simulate */ - explicit DigitalPWMSim(const DigitalOutput& digitalOutput) - : m_index{digitalOutput.GetChannel()} {} + explicit DigitalPWMSim(const DigitalOutput& digitalOutput); /** * Creates an DigitalPWMSim for a digital I/O channel. @@ -42,11 +39,7 @@ class DigitalPWMSim { * @return Simulated object * @throws std::out_of_range if no Digital PWM is configured for that channel */ - static DigitalPWMSim CreateForChannel(int channel) { - int index = HALSIM_FindDigitalPWMForChannel(channel); - if (index < 0) throw std::out_of_range("no digital PWM found for channel"); - return DigitalPWMSim{index}; - } + static DigitalPWMSim CreateForChannel(int channel); /** * Creates an DigitalPWMSim for a simulated index. @@ -55,56 +48,30 @@ class DigitalPWMSim { * @param index simulator index * @return Simulated object */ - static DigitalPWMSim CreateForIndex(int index) { - return DigitalPWMSim{index}; - } + static DigitalPWMSim CreateForIndex(int index); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDigitalPWMInitializedCallback); - store->SetUid(HALSIM_RegisterDigitalPWMInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { - return HALSIM_GetDigitalPWMInitialized(m_index); - } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetDigitalPWMInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterDutyCycleCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDigitalPWMDutyCycleCallback); - store->SetUid(HALSIM_RegisterDigitalPWMDutyCycleCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetDutyCycle() const { return HALSIM_GetDigitalPWMDutyCycle(m_index); } + double GetDutyCycle() const; - void SetDutyCycle(double dutyCycle) { - HALSIM_SetDigitalPWMDutyCycle(m_index, dutyCycle); - } + void SetDutyCycle(double dutyCycle); std::unique_ptr RegisterPinCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDigitalPWMPinCallback); - store->SetUid(HALSIM_RegisterDigitalPWMPinCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - int GetPin() const { return HALSIM_GetDigitalPWMPin(m_index); } + int GetPin() const; - void SetPin(int pin) { HALSIM_SetDigitalPWMPin(m_index, pin); } + void SetPin(int pin); - void ResetData() { HALSIM_ResetDigitalPWMData(m_index); } + void ResetData(); private: explicit DigitalPWMSim(int index) : m_index{index} {} diff --git a/wpilibc/src/main/native/include/frc/simulation/DriverStationSim.h b/wpilibc/src/main/native/include/frc/simulation/DriverStationSim.h index 942e8973af..80cf942b3a 100644 --- a/wpilibc/src/main/native/include/frc/simulation/DriverStationSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/DriverStationSim.h @@ -8,13 +8,11 @@ #pragma once #include -#include -#include -#include +#include -#include "CallbackStore.h" #include "frc/DriverStation.h" +#include "frc/simulation/CallbackStore.h" namespace frc { namespace sim { @@ -25,160 +23,80 @@ namespace sim { class DriverStationSim { public: static std::unique_ptr RegisterEnabledCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationEnabledCallback); - store->SetUid(HALSIM_RegisterDriverStationEnabledCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetEnabled() { return HALSIM_GetDriverStationEnabled(); } + static bool GetEnabled(); - static void SetEnabled(bool enabled) { - HALSIM_SetDriverStationEnabled(enabled); - } + static void SetEnabled(bool enabled); static std::unique_ptr RegisterAutonomousCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationAutonomousCallback); - store->SetUid(HALSIM_RegisterDriverStationAutonomousCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetAutonomous() { return HALSIM_GetDriverStationAutonomous(); } + static bool GetAutonomous(); - static void SetAutonomous(bool autonomous) { - HALSIM_SetDriverStationAutonomous(autonomous); - } + static void SetAutonomous(bool autonomous); static std::unique_ptr RegisterTestCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationTestCallback); - store->SetUid(HALSIM_RegisterDriverStationTestCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetTest() { return HALSIM_GetDriverStationTest(); } + static bool GetTest(); - static void SetTest(bool test) { HALSIM_SetDriverStationTest(test); } + static void SetTest(bool test); static std::unique_ptr RegisterEStopCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationEStopCallback); - store->SetUid(HALSIM_RegisterDriverStationEStopCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetEStop() { return HALSIM_GetDriverStationEStop(); } + static bool GetEStop(); - static void SetEStop(bool eStop) { HALSIM_SetDriverStationEStop(eStop); } + static void SetEStop(bool eStop); static std::unique_ptr RegisterFmsAttachedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationFmsAttachedCallback); - store->SetUid(HALSIM_RegisterDriverStationFmsAttachedCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetFmsAttached() { return HALSIM_GetDriverStationFmsAttached(); } + static bool GetFmsAttached(); - static void SetFmsAttached(bool fmsAttached) { - HALSIM_SetDriverStationFmsAttached(fmsAttached); - } + static void SetFmsAttached(bool fmsAttached); static std::unique_ptr RegisterDsAttachedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationDsAttachedCallback); - store->SetUid(HALSIM_RegisterDriverStationDsAttachedCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetDsAttached() { return HALSIM_GetDriverStationDsAttached(); } + static bool GetDsAttached(); - static void SetDsAttached(bool dsAttached) { - HALSIM_SetDriverStationDsAttached(dsAttached); - } + static void SetDsAttached(bool dsAttached); static std::unique_ptr RegisterAllianceStationIdCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationAllianceStationIdCallback); - store->SetUid(HALSIM_RegisterDriverStationAllianceStationIdCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static HAL_AllianceStationID GetAllianceStationId() { - return HALSIM_GetDriverStationAllianceStationId(); - } + static HAL_AllianceStationID GetAllianceStationId(); - static void SetAllianceStationId(HAL_AllianceStationID allianceStationId) { - HALSIM_SetDriverStationAllianceStationId(allianceStationId); - } + static void SetAllianceStationId(HAL_AllianceStationID allianceStationId); static std::unique_ptr RegisterMatchTimeCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelDriverStationMatchTimeCallback); - store->SetUid(HALSIM_RegisterDriverStationMatchTimeCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetMatchTime() { return HALSIM_GetDriverStationMatchTime(); } + static double GetMatchTime(); - static void SetMatchTime(double matchTime) { - HALSIM_SetDriverStationMatchTime(matchTime); - } + static void SetMatchTime(double matchTime); /** * Updates DriverStation data so that new values are visible to the user * program. */ - static void NotifyNewData() { - HALSIM_NotifyDriverStationNewData(); - DriverStation::GetInstance().WaitForData(); - } + static void NotifyNewData(); /** * Sets suppression of DriverStation::ReportError and ReportWarning messages. * * @param shouldSend If false then messages will be suppressed. */ - static void SetSendError(bool shouldSend) { - if (shouldSend) { - HALSIM_SetSendError(nullptr); - } else { - HALSIM_SetSendError([](HAL_Bool isError, int32_t errorCode, - HAL_Bool isLVCode, const char* details, - const char* location, const char* callStack, - HAL_Bool printMsg) { return 0; }); - } - } + static void SetSendError(bool shouldSend); /** * Sets suppression of DriverStation::SendConsoleLine messages. * * @param shouldSend If false then messages will be suppressed. */ - static void SetSendConsoleLine(bool shouldSend) { - if (shouldSend) { - HALSIM_SetSendConsoleLine(nullptr); - } else { - HALSIM_SetSendConsoleLine([](const char* line) { return 0; }); - } - } + static void SetSendConsoleLine(bool shouldSend); /** * Gets the joystick outputs. @@ -186,13 +104,7 @@ class DriverStationSim { * @param stick The joystick number * @return The joystick outputs */ - static int64_t GetJoystickOutputs(int stick) { - int64_t outputs = 0; - int32_t leftRumble; - int32_t rightRumble; - HALSIM_GetJoystickOutputs(stick, &outputs, &leftRumble, &rightRumble); - return outputs; - } + static int64_t GetJoystickOutputs(int stick); /** * Gets the joystick rumble. @@ -201,13 +113,7 @@ class DriverStationSim { * @param rumbleNum Rumble to get (0=left, 1=right) * @return The joystick rumble value */ - static int GetJoystickRumble(int stick, int rumbleNum) { - int64_t outputs; - int32_t leftRumble = 0; - int32_t rightRumble = 0; - HALSIM_GetJoystickOutputs(stick, &outputs, &leftRumble, &rightRumble); - return rumbleNum == 0 ? leftRumble : rightRumble; - } + static int GetJoystickRumble(int stick, int rumbleNum); /** * Sets the state of one joystick button. Button indexes begin at 1. @@ -216,9 +122,7 @@ class DriverStationSim { * @param button The button index, beginning at 1 * @param state The state of the joystick button */ - static void SetJoystickButton(int stick, int button, bool state) { - HALSIM_SetJoystickButton(stick, button, state); - } + static void SetJoystickButton(int stick, int button, bool state); /** * Gets the value of the axis on a joystick. @@ -227,9 +131,7 @@ class DriverStationSim { * @param axis The analog axis number * @param value The value of the axis on the joystick */ - static void SetJoystickAxis(int stick, int axis, double value) { - HALSIM_SetJoystickAxis(stick, axis, value); - } + static void SetJoystickAxis(int stick, int axis, double value); /** * Gets the state of a POV on a joystick. @@ -238,9 +140,7 @@ class DriverStationSim { * @param pov The POV number * @param value the angle of the POV in degrees, or -1 for not pressed */ - static void SetJoystickPOV(int stick, int pov, int value) { - HALSIM_SetJoystickPOV(stick, pov, value); - } + static void SetJoystickPOV(int stick, int pov, int value); /** * Sets the state of all the buttons on a joystick. @@ -248,9 +148,7 @@ class DriverStationSim { * @param stick The joystick number * @param buttons The bitmap state of the buttons on the joystick */ - static void SetJoystickButtons(int stick, uint32_t buttons) { - HALSIM_SetJoystickButtonsValue(stick, buttons); - } + static void SetJoystickButtons(int stick, uint32_t buttons); /** * Sets the number of axes for a joystick. @@ -258,9 +156,7 @@ class DriverStationSim { * @param stick The joystick number * @param count The number of axes on the indicated joystick */ - static void SetJoystickAxisCount(int stick, int count) { - HALSIM_SetJoystickAxisCount(stick, count); - } + static void SetJoystickAxisCount(int stick, int count); /** * Sets the number of POVs for a joystick. @@ -268,9 +164,7 @@ class DriverStationSim { * @param stick The joystick number * @param count The number of POVs on the indicated joystick */ - static void SetJoystickPOVCount(int stick, int count) { - HALSIM_SetJoystickPOVCount(stick, count); - } + static void SetJoystickPOVCount(int stick, int count); /** * Sets the number of buttons for a joystick. @@ -278,9 +172,7 @@ class DriverStationSim { * @param stick The joystick number * @param count The number of buttons on the indicated joystick */ - static void SetJoystickButtonCount(int stick, int count) { - HALSIM_SetJoystickButtonCount(stick, count); - } + static void SetJoystickButtonCount(int stick, int count); /** * Sets the value of isXbox for a joystick. @@ -288,9 +180,7 @@ class DriverStationSim { * @param stick The joystick number * @param isXbox The value of isXbox */ - static void SetJoystickIsXbox(int stick, bool isXbox) { - HALSIM_SetJoystickIsXbox(stick, isXbox); - } + static void SetJoystickIsXbox(int stick, bool isXbox); /** * Sets the value of type for a joystick. @@ -298,9 +188,7 @@ class DriverStationSim { * @param stick The joystick number * @param type The value of type */ - static void SetJoystickType(int stick, int type) { - HALSIM_SetJoystickType(stick, type); - } + static void SetJoystickType(int stick, int type); /** * Sets the name of a joystick. @@ -308,9 +196,7 @@ class DriverStationSim { * @param stick The joystick number * @param name The value of name */ - static void SetJoystickName(int stick, const char* name) { - HALSIM_SetJoystickName(stick, name); - } + static void SetJoystickName(int stick, const char* name); /** * Sets the types of Axes for a joystick. @@ -319,54 +205,44 @@ class DriverStationSim { * @param axis The target axis * @param type The type of axis */ - static void SetJoystickAxisType(int stick, int axis, int type) { - HALSIM_SetJoystickAxisType(stick, axis, type); - } + static void SetJoystickAxisType(int stick, int axis, int type); /** * Sets the game specific message. * * @param message the game specific message */ - static void SetGameSpecificMessage(const char* message) { - HALSIM_SetGameSpecificMessage(message); - } + static void SetGameSpecificMessage(const char* message); /** * Sets the event name. * * @param name the event name */ - static void SetEventName(const char* name) { HALSIM_SetEventName(name); } + static void SetEventName(const char* name); /** * Sets the match type. * * @param type the match type */ - static void SetMatchType(DriverStation::MatchType type) { - HALSIM_SetMatchType(static_cast(static_cast(type))); - } + static void SetMatchType(DriverStation::MatchType type); /** * Sets the match number. * * @param matchNumber the match number */ - static void SetMatchNumber(int matchNumber) { - HALSIM_SetMatchNumber(matchNumber); - } + static void SetMatchNumber(int matchNumber); /** * Sets the replay number. * * @param replayNumber the replay number */ - static void SetReplayNumber(int replayNumber) { - HALSIM_SetReplayNumber(replayNumber); - } + static void SetReplayNumber(int replayNumber); - static void ResetData() { HALSIM_ResetDriverStationData(); } + static void ResetData(); }; } // namespace sim } // namespace frc diff --git a/wpilibc/src/main/native/include/frc/simulation/DutyCycleSim.h b/wpilibc/src/main/native/include/frc/simulation/DutyCycleSim.h index 03b0f9ac24..40dad13893 100644 --- a/wpilibc/src/main/native/include/frc/simulation/DutyCycleSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/DutyCycleSim.h @@ -7,16 +7,14 @@ #pragma once -#include #include -#include -#include - -#include "CallbackStore.h" -#include "frc/DutyCycle.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class DutyCycle; + namespace sim { /** @@ -29,8 +27,7 @@ class DutyCycleSim { * * @param dutyCycle DutyCycle to simulate */ - explicit DutyCycleSim(const DutyCycle& dutyCycle) - : m_index{dutyCycle.GetFPGAIndex()} {} + explicit DutyCycleSim(const DutyCycle& dutyCycle); /** * Creates a DutyCycleSim for a digital input channel. @@ -39,11 +36,7 @@ class DutyCycleSim { * @return Simulated object * @throws std::out_of_range if no DutyCycle is configured for that channel */ - static DutyCycleSim CreateForChannel(int channel) { - int index = HALSIM_FindDutyCycleForChannel(channel); - if (index < 0) throw std::out_of_range("no duty cycle found for channel"); - return DutyCycleSim{index}; - } + static DutyCycleSim CreateForChannel(int channel); /** * Creates a DutyCycleSim for a simulated index. @@ -52,52 +45,30 @@ class DutyCycleSim { * @param index simulator index * @return Simulated object */ - static DutyCycleSim CreateForIndex(int index) { return DutyCycleSim{index}; } + static DutyCycleSim CreateForIndex(int index); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDutyCycleInitializedCallback); - store->SetUid(HALSIM_RegisterDutyCycleInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { - return HALSIM_GetDutyCycleInitialized(m_index); - } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetDutyCycleInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterFrequencyCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDutyCycleFrequencyCallback); - store->SetUid(HALSIM_RegisterDutyCycleFrequencyCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetFrequency() const { return HALSIM_GetDutyCycleFrequency(m_index); } + int GetFrequency() const; - void SetFrequency(int count) { HALSIM_SetDutyCycleFrequency(m_index, count); } + void SetFrequency(int count); std::unique_ptr RegisterOutputCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelDutyCycleOutputCallback); - store->SetUid(HALSIM_RegisterDutyCycleOutputCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetOutput() const { return HALSIM_GetDutyCycleOutput(m_index); } + double GetOutput() const; - void SetOutput(double period) { HALSIM_SetDutyCycleOutput(m_index, period); } + void SetOutput(double period); - void ResetData() { HALSIM_ResetDutyCycleData(m_index); } + void ResetData(); private: explicit DutyCycleSim(int index) : m_index{index} {} diff --git a/wpilibc/src/main/native/include/frc/simulation/EncoderSim.h b/wpilibc/src/main/native/include/frc/simulation/EncoderSim.h index 12eaadb6ff..4049ab8eb0 100644 --- a/wpilibc/src/main/native/include/frc/simulation/EncoderSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/EncoderSim.h @@ -7,16 +7,14 @@ #pragma once -#include #include -#include -#include - -#include "CallbackStore.h" -#include "frc/Encoder.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class Encoder; + namespace sim { /** @@ -29,8 +27,7 @@ class EncoderSim { * * @param encoder Encoder to simulate */ - explicit EncoderSim(const Encoder& encoder) - : m_index{encoder.GetFPGAIndex()} {} + explicit EncoderSim(const Encoder& encoder); /** * Creates an EncoderSim for a digital input channel. Encoders take two @@ -40,11 +37,7 @@ class EncoderSim { * @return Simulated object * @throws NoSuchElementException if no Encoder is configured for that channel */ - static EncoderSim CreateForChannel(int channel) { - int index = HALSIM_FindEncoderForChannel(channel); - if (index < 0) throw std::out_of_range("no encoder found for channel"); - return EncoderSim{index}; - } + static EncoderSim CreateForChannel(int channel); /** * Creates an EncoderSim for a simulated index. @@ -53,154 +46,80 @@ class EncoderSim { * @param index simulator index * @return Simulated object */ - static EncoderSim CreateForIndex(int index) { return EncoderSim{index}; } + static EncoderSim CreateForIndex(int index); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderInitializedCallback); - store->SetUid(HALSIM_RegisterEncoderInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { return HALSIM_GetEncoderInitialized(m_index); } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetEncoderInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterCountCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderCountCallback); - store->SetUid(HALSIM_RegisterEncoderCountCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - int GetCount() const { return HALSIM_GetEncoderCount(m_index); } + int GetCount() const; - void SetCount(int count) { HALSIM_SetEncoderCount(m_index, count); } + void SetCount(int count); std::unique_ptr RegisterPeriodCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderPeriodCallback); - store->SetUid(HALSIM_RegisterEncoderPeriodCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetPeriod() const { return HALSIM_GetEncoderPeriod(m_index); } + double GetPeriod() const; - void SetPeriod(double period) { HALSIM_SetEncoderPeriod(m_index, period); } + void SetPeriod(double period); std::unique_ptr RegisterResetCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderResetCallback); - store->SetUid(HALSIM_RegisterEncoderResetCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - bool GetReset() const { return HALSIM_GetEncoderReset(m_index); } + bool GetReset() const; - void SetReset(bool reset) { HALSIM_SetEncoderReset(m_index, reset); } + void SetReset(bool reset); std::unique_ptr RegisterMaxPeriodCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderMaxPeriodCallback); - store->SetUid(HALSIM_RegisterEncoderMaxPeriodCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetMaxPeriod() const { return HALSIM_GetEncoderMaxPeriod(m_index); } + double GetMaxPeriod() const; - void SetMaxPeriod(double maxPeriod) { - HALSIM_SetEncoderMaxPeriod(m_index, maxPeriod); - } + void SetMaxPeriod(double maxPeriod); std::unique_ptr RegisterDirectionCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderDirectionCallback); - store->SetUid(HALSIM_RegisterEncoderDirectionCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetDirection() const { return HALSIM_GetEncoderDirection(m_index); } + bool GetDirection() const; - void SetDirection(bool direction) { - HALSIM_SetEncoderDirection(m_index, direction); - } + void SetDirection(bool direction); std::unique_ptr RegisterReverseDirectionCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderReverseDirectionCallback); - store->SetUid(HALSIM_RegisterEncoderReverseDirectionCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetReverseDirection() const { - return HALSIM_GetEncoderReverseDirection(m_index); - } + bool GetReverseDirection() const; - void SetReverseDirection(bool reverseDirection) { - HALSIM_SetEncoderReverseDirection(m_index, reverseDirection); - } + void SetReverseDirection(bool reverseDirection); std::unique_ptr RegisterSamplesToAverageCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderSamplesToAverageCallback); - store->SetUid(HALSIM_RegisterEncoderSamplesToAverageCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetSamplesToAverage() const { - return HALSIM_GetEncoderSamplesToAverage(m_index); - } + int GetSamplesToAverage() const; - void SetSamplesToAverage(int samplesToAverage) { - HALSIM_SetEncoderSamplesToAverage(m_index, samplesToAverage); - } + void SetSamplesToAverage(int samplesToAverage); std::unique_ptr RegisterDistancePerPulseCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelEncoderDistancePerPulseCallback); - store->SetUid(HALSIM_RegisterEncoderDistancePerPulseCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetDistancePerPulse() const { - return HALSIM_GetEncoderDistancePerPulse(m_index); - } + double GetDistancePerPulse() const; - void SetDistancePerPulse(double distancePerPulse) { - HALSIM_SetEncoderDistancePerPulse(m_index, distancePerPulse); - } + void SetDistancePerPulse(double distancePerPulse); - void ResetData() { HALSIM_ResetEncoderData(m_index); } + void ResetData(); - void SetDistance(double distance) { - HALSIM_SetEncoderDistance(m_index, distance); - } + void SetDistance(double distance); - double GetDistance() { return HALSIM_GetEncoderDistance(m_index); } + double GetDistance(); - void SetRate(double rate) { HALSIM_SetEncoderRate(m_index, rate); } + void SetRate(double rate); - double GetRate() { return HALSIM_GetEncoderRate(m_index); } + double GetRate(); private: explicit EncoderSim(int index) : m_index{index} {} diff --git a/wpilibc/src/main/native/include/frc/simulation/GenericHIDSim.h b/wpilibc/src/main/native/include/frc/simulation/GenericHIDSim.h index 402f5db3ed..17052005c8 100644 --- a/wpilibc/src/main/native/include/frc/simulation/GenericHIDSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/GenericHIDSim.h @@ -7,10 +7,14 @@ #pragma once +#include + #include "frc/GenericHID.h" -#include "frc/simulation/DriverStationSim.h" namespace frc { + +class GenericHID; + namespace sim { /** @@ -23,71 +27,45 @@ class GenericHIDSim { * * @param joystick joystick to simulate */ - explicit GenericHIDSim(const GenericHID& joystick) - : m_port{joystick.GetPort()} {} + explicit GenericHIDSim(const GenericHID& joystick); /** * Constructs from a joystick port number. * * @param port port number */ - explicit GenericHIDSim(int port) : m_port{port} {} + explicit GenericHIDSim(int port); /** * Updates joystick data so that new values are visible to the user program. */ - void NotifyNewData() { DriverStationSim::NotifyNewData(); } + void NotifyNewData(); - void SetRawButton(int button, bool value) { - DriverStationSim::SetJoystickButton(m_port, button, value); - } + void SetRawButton(int button, bool value); - void SetRawAxis(int axis, double value) { - DriverStationSim::SetJoystickAxis(m_port, axis, value); - } + void SetRawAxis(int axis, double value); - void SetPOV(int pov, int value) { - DriverStationSim::SetJoystickPOV(m_port, pov, value); - } + void SetPOV(int pov, int value); - void SetPOV(int value) { SetPOV(0, value); } + void SetPOV(int value); - void SetAxisCount(int count) { - DriverStationSim::SetJoystickAxisCount(m_port, count); - } + void SetAxisCount(int count); - void SetPOVCount(int count) { - DriverStationSim::SetJoystickPOVCount(m_port, count); - } + void SetPOVCount(int count); - void SetButtonCount(int count) { - DriverStationSim::SetJoystickButtonCount(m_port, count); - } + void SetButtonCount(int count); - void SetType(GenericHID::HIDType type) { - DriverStationSim::SetJoystickType(m_port, type); - } + void SetType(GenericHID::HIDType type); - void SetName(const char* name) { - DriverStationSim::SetJoystickName(m_port, name); - } + void SetName(const char* name); - void SetAxisType(int axis, int type) { - DriverStationSim::SetJoystickAxisType(m_port, axis, type); - } + void SetAxisType(int axis, int type); - bool GetOutput(int outputNumber) { - int64_t outputs = GetOutputs(); - return (outputs & (static_cast(1) << (outputNumber - 1))) != 0; - } + bool GetOutput(int outputNumber); - int64_t GetOutputs() { return DriverStationSim::GetJoystickOutputs(m_port); } + int64_t GetOutputs(); - double GetRumble(GenericHID::RumbleType type) { - int value = DriverStationSim::GetJoystickRumble( - m_port, type == GenericHID::kLeftRumble ? 0 : 1); - return value / 65535.0; - } + double GetRumble(GenericHID::RumbleType type); protected: int m_port; diff --git a/wpilibc/src/main/native/include/frc/simulation/JoystickSim.h b/wpilibc/src/main/native/include/frc/simulation/JoystickSim.h index f0d07f99e1..5735728da1 100644 --- a/wpilibc/src/main/native/include/frc/simulation/JoystickSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/JoystickSim.h @@ -7,10 +7,12 @@ #pragma once -#include "frc/Joystick.h" #include "frc/simulation/GenericHIDSim.h" namespace frc { + +class Joystick; + namespace sim { /** @@ -23,59 +25,28 @@ class JoystickSim : public GenericHIDSim { * * @param joystick joystick to simulate */ - explicit JoystickSim(const Joystick& joystick) - : GenericHIDSim{joystick}, m_joystick{&joystick} { - // default to a reasonable joystick configuration - SetAxisCount(5); - SetButtonCount(12); - SetPOVCount(1); - } + explicit JoystickSim(const Joystick& joystick); /** * Constructs from a joystick port number. * * @param port port number */ - explicit JoystickSim(int port) : GenericHIDSim{port} { - // default to a reasonable joystick configuration - SetAxisCount(5); - SetButtonCount(12); - SetPOVCount(1); - } + explicit JoystickSim(int port); - void SetX(double value) { - SetRawAxis( - m_joystick ? m_joystick->GetXChannel() : Joystick::kDefaultXChannel, - value); - } + void SetX(double value); - void SetY(double value) { - SetRawAxis( - m_joystick ? m_joystick->GetYChannel() : Joystick::kDefaultYChannel, - value); - } + void SetY(double value); - void SetZ(double value) { - SetRawAxis( - m_joystick ? m_joystick->GetZChannel() : Joystick::kDefaultZChannel, - value); - } + void SetZ(double value); - void SetTwist(double value) { - SetRawAxis(m_joystick ? m_joystick->GetTwistChannel() - : Joystick::kDefaultTwistChannel, - value); - } + void SetTwist(double value); - void SetThrottle(double value) { - SetRawAxis(m_joystick ? m_joystick->GetThrottleChannel() - : Joystick::kDefaultThrottleChannel, - value); - } + void SetThrottle(double value); - void SetTrigger(bool state) { SetRawButton(1, state); } + void SetTrigger(bool state); - void SetTop(bool state) { SetRawButton(2, state); } + void SetTop(bool state); private: const Joystick* m_joystick = nullptr; diff --git a/wpilibc/src/main/native/include/frc/simulation/PCMSim.h b/wpilibc/src/main/native/include/frc/simulation/PCMSim.h index 84f52672fd..2e3ed5e135 100644 --- a/wpilibc/src/main/native/include/frc/simulation/PCMSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/PCMSim.h @@ -8,15 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/Compressor.h" -#include "frc/SensorUtil.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class Compressor; + namespace sim { /** @@ -24,152 +22,79 @@ namespace sim { */ class PCMSim { public: + /** + * Constructs with the default PCM module number (CAN ID). + */ + PCMSim(); + /** * Constructs from a PCM module number (CAN ID). * * @param module module number */ - explicit PCMSim(int module = SensorUtil::GetDefaultSolenoidModule()) - : m_index{module} {} + explicit PCMSim(int module); /** * Constructs from a Compressor object. * * @param compressor Compressor connected to PCM to simulate */ - explicit PCMSim(const Compressor& compressor) - : m_index{compressor.GetModule()} {} + explicit PCMSim(const Compressor& compressor); std::unique_ptr RegisterSolenoidInitializedCallback( - int channel, NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, channel, -1, callback, - &HALSIM_CancelPCMSolenoidInitializedCallback); - store->SetUid(HALSIM_RegisterPCMSolenoidInitializedCallback( - m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + int channel, NotifyCallback callback, bool initialNotify); - bool GetSolenoidInitialized(int channel) const { - return HALSIM_GetPCMSolenoidInitialized(m_index, channel); - } + bool GetSolenoidInitialized(int channel) const; - void SetSolenoidInitialized(int channel, bool solenoidInitialized) { - HALSIM_SetPCMSolenoidInitialized(m_index, channel, solenoidInitialized); - } + void SetSolenoidInitialized(int channel, bool solenoidInitialized); std::unique_ptr RegisterSolenoidOutputCallback( - int channel, NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, channel, -1, callback, - &HALSIM_CancelPCMSolenoidOutputCallback); - store->SetUid(HALSIM_RegisterPCMSolenoidOutputCallback( - m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + int channel, NotifyCallback callback, bool initialNotify); - bool GetSolenoidOutput(int channel) const { - return HALSIM_GetPCMSolenoidOutput(m_index, channel); - } + bool GetSolenoidOutput(int channel) const; - void SetSolenoidOutput(int channel, bool solenoidOutput) { - HALSIM_SetPCMSolenoidOutput(m_index, channel, solenoidOutput); - } + void SetSolenoidOutput(int channel, bool solenoidOutput); std::unique_ptr RegisterCompressorInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPCMCompressorInitializedCallback); - store->SetUid(HALSIM_RegisterPCMCompressorInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetCompressorInitialized() const { - return HALSIM_GetPCMCompressorInitialized(m_index); - } + bool GetCompressorInitialized() const; - void SetCompressorInitialized(bool compressorInitialized) { - HALSIM_SetPCMCompressorInitialized(m_index, compressorInitialized); - } + void SetCompressorInitialized(bool compressorInitialized); std::unique_ptr RegisterCompressorOnCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPCMCompressorOnCallback); - store->SetUid(HALSIM_RegisterPCMCompressorOnCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetCompressorOn() const { return HALSIM_GetPCMCompressorOn(m_index); } + bool GetCompressorOn() const; - void SetCompressorOn(bool compressorOn) { - HALSIM_SetPCMCompressorOn(m_index, compressorOn); - } + void SetCompressorOn(bool compressorOn); std::unique_ptr RegisterClosedLoopEnabledCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPCMClosedLoopEnabledCallback); - store->SetUid(HALSIM_RegisterPCMClosedLoopEnabledCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetClosedLoopEnabled() const { - return HALSIM_GetPCMClosedLoopEnabled(m_index); - } + bool GetClosedLoopEnabled() const; - void SetClosedLoopEnabled(bool closedLoopEnabled) { - HALSIM_SetPCMClosedLoopEnabled(m_index, closedLoopEnabled); - } + void SetClosedLoopEnabled(bool closedLoopEnabled); std::unique_ptr RegisterPressureSwitchCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPCMPressureSwitchCallback); - store->SetUid(HALSIM_RegisterPCMPressureSwitchCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetPressureSwitch() const { - return HALSIM_GetPCMPressureSwitch(m_index); - } + bool GetPressureSwitch() const; - void SetPressureSwitch(bool pressureSwitch) { - HALSIM_SetPCMPressureSwitch(m_index, pressureSwitch); - } + void SetPressureSwitch(bool pressureSwitch); std::unique_ptr RegisterCompressorCurrentCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPCMCompressorCurrentCallback); - store->SetUid(HALSIM_RegisterPCMCompressorCurrentCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetCompressorCurrent() const { - return HALSIM_GetPCMCompressorCurrent(m_index); - } + double GetCompressorCurrent() const; - void SetCompressorCurrent(double compressorCurrent) { - HALSIM_SetPCMCompressorCurrent(m_index, compressorCurrent); - } + void SetCompressorCurrent(double compressorCurrent); - uint8_t GetAllSolenoidOutputs() { - uint8_t ret = 0; - HALSIM_GetPCMAllSolenoids(m_index, &ret); - return ret; - } + uint8_t GetAllSolenoidOutputs() const; - void SetAllSolenoidOutputs(uint8_t outputs) { - HALSIM_SetPCMAllSolenoids(m_index, outputs); - } + void SetAllSolenoidOutputs(uint8_t outputs); - void ResetData() { HALSIM_ResetPCMData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/PDPSim.h b/wpilibc/src/main/native/include/frc/simulation/PDPSim.h index 76cd408be5..c67815f9cd 100644 --- a/wpilibc/src/main/native/include/frc/simulation/PDPSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/PDPSim.h @@ -8,14 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/PowerDistributionPanel.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class PowerDistributionPanel; + namespace sim { /** @@ -28,85 +27,48 @@ class PDPSim { * * @param module module number */ - explicit PDPSim(int module = 0) : m_index{module} {} + explicit PDPSim(int module = 0); /** * Constructs from a PowerDistributionPanel object. * * @param pdp PowerDistributionPanel to simulate */ - explicit PDPSim(const PowerDistributionPanel& pdp) - : m_index{pdp.GetModule()} {} + explicit PDPSim(const PowerDistributionPanel& pdp); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPDPInitializedCallback); - store->SetUid(HALSIM_RegisterPDPInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { return HALSIM_GetPDPInitialized(m_index); } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetPDPInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterTemperatureCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPDPTemperatureCallback); - store->SetUid(HALSIM_RegisterPDPTemperatureCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetTemperature() const { return HALSIM_GetPDPTemperature(m_index); } + double GetTemperature() const; - void SetTemperature(double temperature) { - HALSIM_SetPDPTemperature(m_index, temperature); - } + void SetTemperature(double temperature); std::unique_ptr RegisterVoltageCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPDPVoltageCallback); - store->SetUid(HALSIM_RegisterPDPVoltageCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetVoltage() const { return HALSIM_GetPDPVoltage(m_index); } + double GetVoltage() const; - void SetVoltage(double voltage) { HALSIM_SetPDPVoltage(m_index, voltage); } + void SetVoltage(double voltage); std::unique_ptr RegisterCurrentCallback( - int channel, NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, channel, -1, callback, &HALSIM_CancelPDPCurrentCallback); - store->SetUid(HALSIM_RegisterPDPCurrentCallback( - m_index, channel, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + int channel, NotifyCallback callback, bool initialNotify); - double GetCurrent(int channel) const { - return HALSIM_GetPDPCurrent(m_index, channel); - } + double GetCurrent(int channel) const; - void SetCurrent(int channel, double current) { - HALSIM_SetPDPCurrent(m_index, channel, current); - } + void SetCurrent(int channel, double current); - void GetAllCurrents(double* currents) { - HALSIM_GetPDPAllCurrents(m_index, currents); - } + void GetAllCurrents(double* currents) const; - void SetAllCurrents(const double* currents) { - HALSIM_SetPDPAllCurrents(m_index, currents); - } + void SetAllCurrents(const double* currents); - void ResetData() { HALSIM_ResetPDPData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/PWMSim.h b/wpilibc/src/main/native/include/frc/simulation/PWMSim.h index 8b950e796a..ca2dfca193 100644 --- a/wpilibc/src/main/native/include/frc/simulation/PWMSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/PWMSim.h @@ -8,14 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/PWM.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class PWM; + namespace sim { /** @@ -28,102 +27,58 @@ class PWMSim { * * @param pwm PWM to simulate */ - explicit PWMSim(const PWM& pwm) : m_index{pwm.GetChannel()} {} + explicit PWMSim(const PWM& pwm); /** * Constructs from a PWM channel number. * * @param channel Channel number */ - explicit PWMSim(int channel) : m_index{channel} {} + explicit PWMSim(int channel); std::unique_ptr RegisterInitializedCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPWMInitializedCallback); - store->SetUid(HALSIM_RegisterPWMInitializedCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitialized() const { return HALSIM_GetPWMInitialized(m_index); } + bool GetInitialized() const; - void SetInitialized(bool initialized) { - HALSIM_SetPWMInitialized(m_index, initialized); - } + void SetInitialized(bool initialized); std::unique_ptr RegisterRawValueCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPWMRawValueCallback); - store->SetUid(HALSIM_RegisterPWMRawValueCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetRawValue() const { return HALSIM_GetPWMRawValue(m_index); } + int GetRawValue() const; - void SetRawValue(int rawValue) { HALSIM_SetPWMRawValue(m_index, rawValue); } + void SetRawValue(int rawValue); std::unique_ptr RegisterSpeedCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPWMSpeedCallback); - store->SetUid(HALSIM_RegisterPWMSpeedCallback(m_index, &CallbackStoreThunk, - store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetSpeed() const { return HALSIM_GetPWMSpeed(m_index); } + double GetSpeed() const; - void SetSpeed(double speed) { HALSIM_SetPWMSpeed(m_index, speed); } + void SetSpeed(double speed); std::unique_ptr RegisterPositionCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPWMPositionCallback); - store->SetUid(HALSIM_RegisterPWMPositionCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - double GetPosition() const { return HALSIM_GetPWMPosition(m_index); } + double GetPosition() const; - void SetPosition(double position) { - HALSIM_SetPWMPosition(m_index, position); - } + void SetPosition(double position); std::unique_ptr RegisterPeriodScaleCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPWMPeriodScaleCallback); - store->SetUid(HALSIM_RegisterPWMPeriodScaleCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - int GetPeriodScale() const { return HALSIM_GetPWMPeriodScale(m_index); } + int GetPeriodScale() const; - void SetPeriodScale(int periodScale) { - HALSIM_SetPWMPeriodScale(m_index, periodScale); - } + void SetPeriodScale(int periodScale); std::unique_ptr RegisterZeroLatchCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelPWMZeroLatchCallback); - store->SetUid(HALSIM_RegisterPWMZeroLatchCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetZeroLatch() const { return HALSIM_GetPWMZeroLatch(m_index); } + bool GetZeroLatch() const; - void SetZeroLatch(bool zeroLatch) { - HALSIM_SetPWMZeroLatch(m_index, zeroLatch); - } + void SetZeroLatch(bool zeroLatch); - void ResetData() { HALSIM_ResetPWMData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/RelaySim.h b/wpilibc/src/main/native/include/frc/simulation/RelaySim.h index 99ef8b70aa..99a8eef8d0 100644 --- a/wpilibc/src/main/native/include/frc/simulation/RelaySim.h +++ b/wpilibc/src/main/native/include/frc/simulation/RelaySim.h @@ -8,14 +8,13 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" -#include "frc/Relay.h" +#include "frc/simulation/CallbackStore.h" namespace frc { + +class Relay; + namespace sim { /** @@ -28,76 +27,44 @@ class RelaySim { * * @param relay Relay to simulate */ - explicit RelaySim(const Relay& relay) : m_index{relay.GetChannel()} {} + explicit RelaySim(const Relay& relay); /** * Constructs from a relay channel number. * * @param channel Channel number */ - explicit RelaySim(int channel) : m_index{channel} {} + explicit RelaySim(int channel); std::unique_ptr RegisterInitializedForwardCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRelayInitializedForwardCallback); - store->SetUid(HALSIM_RegisterRelayInitializedForwardCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitializedForward() const { - return HALSIM_GetRelayInitializedForward(m_index); - } + bool GetInitializedForward() const; - void SetInitializedForward(bool initializedForward) { - HALSIM_SetRelayInitializedForward(m_index, initializedForward); - } + void SetInitializedForward(bool initializedForward); std::unique_ptr RegisterInitializedReverseCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRelayInitializedReverseCallback); - store->SetUid(HALSIM_RegisterRelayInitializedReverseCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetInitializedReverse() const { - return HALSIM_GetRelayInitializedReverse(m_index); - } + bool GetInitializedReverse() const; - void SetInitializedReverse(bool initializedReverse) { - HALSIM_SetRelayInitializedReverse(m_index, initializedReverse); - } + void SetInitializedReverse(bool initializedReverse); std::unique_ptr RegisterForwardCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRelayForwardCallback); - store->SetUid(HALSIM_RegisterRelayForwardCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetForward() const { return HALSIM_GetRelayForward(m_index); } + bool GetForward() const; - void SetForward(bool forward) { HALSIM_SetRelayForward(m_index, forward); } + void SetForward(bool forward); std::unique_ptr RegisterReverseCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRelayReverseCallback); - store->SetUid(HALSIM_RegisterRelayReverseCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - bool GetReverse() const { return HALSIM_GetRelayReverse(m_index); } + bool GetReverse() const; - void SetReverse(bool reverse) { HALSIM_SetRelayReverse(m_index, reverse); } + void SetReverse(bool reverse); - void ResetData() { HALSIM_ResetRelayData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h b/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h index 12db613ff8..5da668a941 100644 --- a/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h @@ -8,11 +8,8 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" +#include "frc/simulation/CallbackStore.h" namespace frc { namespace sim { @@ -23,235 +20,111 @@ namespace sim { class RoboRioSim { public: static std::unique_ptr RegisterFPGAButtonCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioFPGAButtonCallback); - store->SetUid(HALSIM_RegisterRoboRioFPGAButtonCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetFPGAButton() { return HALSIM_GetRoboRioFPGAButton(); } + static bool GetFPGAButton(); - static void SetFPGAButton(bool fPGAButton) { - HALSIM_SetRoboRioFPGAButton(fPGAButton); - } + static void SetFPGAButton(bool fPGAButton); static std::unique_ptr RegisterVInVoltageCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioVInVoltageCallback); - store->SetUid(HALSIM_RegisterRoboRioVInVoltageCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetVInVoltage() { return HALSIM_GetRoboRioVInVoltage(); } + static double GetVInVoltage(); - static void SetVInVoltage(double vInVoltage) { - HALSIM_SetRoboRioVInVoltage(vInVoltage); - } + static void SetVInVoltage(double vInVoltage); static std::unique_ptr RegisterVInCurrentCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioVInCurrentCallback); - store->SetUid(HALSIM_RegisterRoboRioVInCurrentCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetVInCurrent() { return HALSIM_GetRoboRioVInCurrent(); } + static double GetVInCurrent(); - static void SetVInCurrent(double vInCurrent) { - HALSIM_SetRoboRioVInCurrent(vInCurrent); - } + static void SetVInCurrent(double vInCurrent); static std::unique_ptr RegisterUserVoltage6VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserVoltage6VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserVoltage6VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetUserVoltage6V() { return HALSIM_GetRoboRioUserVoltage6V(); } + static double GetUserVoltage6V(); - static void SetUserVoltage6V(double userVoltage6V) { - HALSIM_SetRoboRioUserVoltage6V(userVoltage6V); - } + static void SetUserVoltage6V(double userVoltage6V); static std::unique_ptr RegisterUserCurrent6VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserCurrent6VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserCurrent6VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetUserCurrent6V() { return HALSIM_GetRoboRioUserCurrent6V(); } + static double GetUserCurrent6V(); - static void SetUserCurrent6V(double userCurrent6V) { - HALSIM_SetRoboRioUserCurrent6V(userCurrent6V); - } + static void SetUserCurrent6V(double userCurrent6V); static std::unique_ptr RegisterUserActive6VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserActive6VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserActive6VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetUserActive6V() { return HALSIM_GetRoboRioUserActive6V(); } + static bool GetUserActive6V(); - static void SetUserActive6V(bool userActive6V) { - HALSIM_SetRoboRioUserActive6V(userActive6V); - } + static void SetUserActive6V(bool userActive6V); static std::unique_ptr RegisterUserVoltage5VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserVoltage5VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserVoltage5VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetUserVoltage5V() { return HALSIM_GetRoboRioUserVoltage5V(); } + static double GetUserVoltage5V(); - static void SetUserVoltage5V(double userVoltage5V) { - HALSIM_SetRoboRioUserVoltage5V(userVoltage5V); - } + static void SetUserVoltage5V(double userVoltage5V); static std::unique_ptr RegisterUserCurrent5VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserCurrent5VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserCurrent5VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetUserCurrent5V() { return HALSIM_GetRoboRioUserCurrent5V(); } + static double GetUserCurrent5V(); - static void SetUserCurrent5V(double userCurrent5V) { - HALSIM_SetRoboRioUserCurrent5V(userCurrent5V); - } + static void SetUserCurrent5V(double userCurrent5V); static std::unique_ptr RegisterUserActive5VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserActive5VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserActive5VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetUserActive5V() { return HALSIM_GetRoboRioUserActive5V(); } + static bool GetUserActive5V(); - static void SetUserActive5V(bool userActive5V) { - HALSIM_SetRoboRioUserActive5V(userActive5V); - } + static void SetUserActive5V(bool userActive5V); static std::unique_ptr RegisterUserVoltage3V3Callback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserVoltage3V3Callback); - store->SetUid(HALSIM_RegisterRoboRioUserVoltage3V3Callback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetUserVoltage3V3() { - return HALSIM_GetRoboRioUserVoltage3V3(); - } + static double GetUserVoltage3V3(); - static void SetUserVoltage3V3(double userVoltage3V3) { - HALSIM_SetRoboRioUserVoltage3V3(userVoltage3V3); - } + static void SetUserVoltage3V3(double userVoltage3V3); static std::unique_ptr RegisterUserCurrent3V3Callback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserCurrent3V3Callback); - store->SetUid(HALSIM_RegisterRoboRioUserCurrent3V3Callback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static double GetUserCurrent3V3() { - return HALSIM_GetRoboRioUserCurrent3V3(); - } + static double GetUserCurrent3V3(); - static void SetUserCurrent3V3(double userCurrent3V3) { - HALSIM_SetRoboRioUserCurrent3V3(userCurrent3V3); - } + static void SetUserCurrent3V3(double userCurrent3V3); static std::unique_ptr RegisterUserActive3V3Callback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserActive3V3Callback); - store->SetUid(HALSIM_RegisterRoboRioUserActive3V3Callback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static bool GetUserActive3V3() { return HALSIM_GetRoboRioUserActive3V3(); } + static bool GetUserActive3V3(); - static void SetUserActive3V3(bool userActive3V3) { - HALSIM_SetRoboRioUserActive3V3(userActive3V3); - } + static void SetUserActive3V3(bool userActive3V3); static std::unique_ptr RegisterUserFaults6VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserFaults6VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserFaults6VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static int GetUserFaults6V() { return HALSIM_GetRoboRioUserFaults6V(); } + static int GetUserFaults6V(); - static void SetUserFaults6V(int userFaults6V) { - HALSIM_SetRoboRioUserFaults6V(userFaults6V); - } + static void SetUserFaults6V(int userFaults6V); static std::unique_ptr RegisterUserFaults5VCallback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserFaults5VCallback); - store->SetUid(HALSIM_RegisterRoboRioUserFaults5VCallback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static int GetUserFaults5V() { return HALSIM_GetRoboRioUserFaults5V(); } + static int GetUserFaults5V(); - static void SetUserFaults5V(int userFaults5V) { - HALSIM_SetRoboRioUserFaults5V(userFaults5V); - } + static void SetUserFaults5V(int userFaults5V); static std::unique_ptr RegisterUserFaults3V3Callback( - NotifyCallback callback, bool initialNotify) { - auto store = std::make_unique( - -1, callback, &HALSIM_CancelRoboRioUserFaults3V3Callback); - store->SetUid(HALSIM_RegisterRoboRioUserFaults3V3Callback( - &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + NotifyCallback callback, bool initialNotify); - static int GetUserFaults3V3() { return HALSIM_GetRoboRioUserFaults3V3(); } + static int GetUserFaults3V3(); - static void SetUserFaults3V3(int userFaults3V3) { - HALSIM_SetRoboRioUserFaults3V3(userFaults3V3); - } + static void SetUserFaults3V3(int userFaults3V3); - static void ResetData() { HALSIM_ResetRoboRioData(); } + static void ResetData(); }; } // namespace sim } // namespace frc diff --git a/wpilibc/src/main/native/include/frc/simulation/SPIAccelerometerSim.h b/wpilibc/src/main/native/include/frc/simulation/SPIAccelerometerSim.h index 94d407203c..f2e32492cc 100644 --- a/wpilibc/src/main/native/include/frc/simulation/SPIAccelerometerSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/SPIAccelerometerSim.h @@ -8,86 +8,51 @@ #pragma once #include -#include -#include - -#include "CallbackStore.h" +#include "frc/simulation/CallbackStore.h" namespace frc { namespace sim { class SPIAccelerometerSim { public: - explicit SPIAccelerometerSim(int index) { m_index = index; } + explicit SPIAccelerometerSim(int index); std::unique_ptr RegisterActiveCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelSPIAccelerometerActiveCallback); - store->SetUid(HALSIM_RegisterSPIAccelerometerActiveCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - bool GetActive() const { return HALSIM_GetSPIAccelerometerActive(m_index); } + bool GetActive() const; - void SetActive(bool active) { - HALSIM_SetSPIAccelerometerActive(m_index, active); - } + void SetActive(bool active); std::unique_ptr RegisterRangeCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelSPIAccelerometerRangeCallback); - store->SetUid(HALSIM_RegisterSPIAccelerometerRangeCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - int GetRange() const { return HALSIM_GetSPIAccelerometerRange(m_index); } + int GetRange() const; - void SetRange(int range) { HALSIM_SetSPIAccelerometerRange(m_index, range); } + void SetRange(int range); std::unique_ptr RegisterXCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelSPIAccelerometerXCallback); - store->SetUid(HALSIM_RegisterSPIAccelerometerXCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetX() const { return HALSIM_GetSPIAccelerometerX(m_index); } + double GetX() const; - void SetX(double x) { HALSIM_SetSPIAccelerometerX(m_index, x); } + void SetX(double x); std::unique_ptr RegisterYCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelSPIAccelerometerYCallback); - store->SetUid(HALSIM_RegisterSPIAccelerometerYCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetY() const { return HALSIM_GetSPIAccelerometerY(m_index); } + double GetY() const; - void SetY(double y) { HALSIM_SetSPIAccelerometerY(m_index, y); } + void SetY(double y); std::unique_ptr RegisterZCallback(NotifyCallback callback, - bool initialNotify) { - auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelSPIAccelerometerZCallback); - store->SetUid(HALSIM_RegisterSPIAccelerometerZCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); - return store; - } + bool initialNotify); - double GetZ() const { return HALSIM_GetSPIAccelerometerZ(m_index); } + double GetZ() const; - void SetZ(double z) { HALSIM_SetSPIAccelerometerZ(m_index, z); } + void SetZ(double z); - void ResetData() { HALSIM_ResetSPIAccelerometerData(m_index); } + void ResetData(); private: int m_index; diff --git a/wpilibc/src/main/native/include/frc/simulation/SimDeviceSim.h b/wpilibc/src/main/native/include/frc/simulation/SimDeviceSim.h index 6765721078..640cc0ecc2 100644 --- a/wpilibc/src/main/native/include/frc/simulation/SimDeviceSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/SimDeviceSim.h @@ -8,16 +8,12 @@ #pragma once #include -#include #include -#include #include #include #include -#include "CallbackStore.h" - namespace frc { namespace sim { @@ -31,33 +27,17 @@ class SimDeviceSim { * * @param name name of the SimDevice */ - explicit SimDeviceSim(const char* name) - : m_handle{HALSIM_GetSimDeviceHandle(name)} {} + explicit SimDeviceSim(const char* name); - hal::SimValue GetValue(const char* name) const { - return HALSIM_GetSimValueHandle(m_handle, name); - } + hal::SimValue GetValue(const char* name) const; - hal::SimDouble GetDouble(const char* name) const { - return HALSIM_GetSimValueHandle(m_handle, name); - } + hal::SimDouble GetDouble(const char* name) const; - hal::SimEnum GetEnum(const char* name) const { - return HALSIM_GetSimValueHandle(m_handle, name); - } + hal::SimEnum GetEnum(const char* name) const; - hal::SimBoolean GetBoolean(const char* name) const { - return HALSIM_GetSimValueHandle(m_handle, name); - } + hal::SimBoolean GetBoolean(const char* name) const; - static std::vector GetEnumOptions(hal::SimEnum val) { - int32_t numOptions; - const char** options = HALSIM_GetSimValueEnumOptions(val, &numOptions); - std::vector rv; - rv.reserve(numOptions); - for (int32_t i = 0; i < numOptions; ++i) rv.emplace_back(options[i]); - return rv; - } + static std::vector GetEnumOptions(hal::SimEnum val); template void EnumerateValues(F callback) const { @@ -80,7 +60,7 @@ class SimDeviceSim { }); } - static void ResetData() { HALSIM_ResetSimDeviceData(); } + static void ResetData(); private: HAL_SimDeviceHandle m_handle; diff --git a/wpilibc/src/main/native/include/frc/simulation/SimHooks.h b/wpilibc/src/main/native/include/frc/simulation/SimHooks.h index 9bbe104dd4..fa6aeeb71a 100644 --- a/wpilibc/src/main/native/include/frc/simulation/SimHooks.h +++ b/wpilibc/src/main/native/include/frc/simulation/SimHooks.h @@ -7,30 +7,30 @@ #pragma once -#include +#include + +#include namespace frc { namespace sim { -inline void SetRuntimeType(HAL_RuntimeType type) { - HALSIM_SetRuntimeType(type); -} +void SetRuntimeType(HAL_RuntimeType type); -inline void WaitForProgramStart() { HALSIM_WaitForProgramStart(); } +void WaitForProgramStart(); -inline void SetProgramStarted() { HALSIM_SetProgramStarted(); } +void SetProgramStarted(); -inline bool GetProgramStarted() { return HALSIM_GetProgramStarted(); } +bool GetProgramStarted(); -inline void RestartTiming() { HALSIM_RestartTiming(); } +void RestartTiming(); -inline void PauseTiming() { HALSIM_PauseTiming(); } +void PauseTiming(); -inline void ResumeTiming() { HALSIM_ResumeTiming(); } +void ResumeTiming(); -inline bool IsTimingPaused() { return HALSIM_IsTimingPaused(); } +bool IsTimingPaused(); -inline void StepTiming(uint64_t delta) { HALSIM_StepTiming(delta); } +void StepTiming(uint64_t delta); } // namespace sim } // namespace frc diff --git a/wpilibc/src/main/native/include/frc/simulation/XboxControllerSim.h b/wpilibc/src/main/native/include/frc/simulation/XboxControllerSim.h index 3aff21505c..d98111139e 100644 --- a/wpilibc/src/main/native/include/frc/simulation/XboxControllerSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/XboxControllerSim.h @@ -7,10 +7,12 @@ #pragma once -#include "frc/XboxController.h" #include "frc/simulation/GenericHIDSim.h" namespace frc { + +class XboxController; + namespace sim { /** @@ -23,88 +25,36 @@ class XboxControllerSim : public GenericHIDSim { * * @param joystick controller to simulate */ - explicit XboxControllerSim(const XboxController& joystick) - : GenericHIDSim{joystick} { - SetAxisCount(6); - SetButtonCount(10); - } + explicit XboxControllerSim(const XboxController& joystick); /** * Constructs from a joystick port number. * * @param port port number */ - explicit XboxControllerSim(int port) : GenericHIDSim{port} { - SetAxisCount(6); - SetButtonCount(10); - } + explicit XboxControllerSim(int port); - void SetX(GenericHID::JoystickHand hand, double value) { - if (hand == GenericHID::kLeftHand) { - SetRawAxis(static_cast(XboxController::Axis::kLeftX), value); - } else { - SetRawAxis(static_cast(XboxController::Axis::kRightX), value); - } - } + void SetX(GenericHID::JoystickHand hand, double value); - void SetY(GenericHID::JoystickHand hand, double value) { - if (hand == GenericHID::kLeftHand) { - SetRawAxis(static_cast(XboxController::Axis::kLeftY), value); - } else { - SetRawAxis(static_cast(XboxController::Axis::kRightY), value); - } - } + void SetY(GenericHID::JoystickHand hand, double value); - void SetTriggerAxis(GenericHID::JoystickHand hand, double value) { - if (hand == GenericHID::kLeftHand) { - SetRawAxis(static_cast(XboxController::Axis::kLeftTrigger), value); - } else { - SetRawAxis(static_cast(XboxController::Axis::kRightTrigger), value); - } - } + void SetTriggerAxis(GenericHID::JoystickHand hand, double value); - void SetBumper(GenericHID::JoystickHand hand, bool state) { - if (hand == GenericHID::kLeftHand) { - SetRawButton(static_cast(XboxController::Button::kBumperLeft), - state); - } else { - SetRawButton(static_cast(XboxController::Button::kBumperRight), - state); - } - } + void SetBumper(GenericHID::JoystickHand hand, bool state); - void SetStickButton(GenericHID::JoystickHand hand, bool state) { - if (hand == GenericHID::kLeftHand) { - SetRawButton(static_cast(XboxController::Button::kStickLeft), state); - } else { - SetRawButton(static_cast(XboxController::Button::kStickRight), - state); - } - } + void SetStickButton(GenericHID::JoystickHand hand, bool state); - void SetAButton(bool state) { - SetRawButton(static_cast(XboxController::Button::kA), state); - } + void SetAButton(bool state); - void SetBButton(bool state) { - SetRawButton(static_cast(XboxController::Button::kB), state); - } + void SetBButton(bool state); - void SetXButton(bool state) { - SetRawButton(static_cast(XboxController::Button::kX), state); - } + void SetXButton(bool state); - void SetYButton(bool state) { - SetRawButton(static_cast(XboxController::Button::kY), state); - } + void SetYButton(bool state); - void SetBackButton(bool state) { - SetRawButton(static_cast(XboxController::Button::kBack), state); - } + void SetBackButton(bool state); - void SetStartButton(bool state) { - SetRawButton(static_cast(XboxController::Button::kStart), state); - } + void SetStartButton(bool state); }; } // namespace sim