Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-22 01:11:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change hal sim to use spinlocks (#1291)

Browse Source 
This makes callback registration completely thread safe.

This patch also uses templates and macros to dramatically reduce the amount of
manual boilerplate.
This commit is contained in:
Peter Johnson
2018-09-03 16:08:07 -07:00
committed by GitHub
parent 67b1c85315
commit c0ff6198b3
65 changed files with 1305 additions and 7639 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
hal/src/main/native/sim/mockdata/EncoderDataInternal.h
View File

@@ -9,105 +9,37 @@
#include <atomic>
#include <limits>
#include <memory>
#include <wpi/mutex.h>
#include "mockdata/EncoderData.h"
#include "mockdata/NotifyListenerVector.h"
#include "mockdata/SimDataValue.h"
namespace hal {
class EncoderData {
HAL_SIMDATAVALUE_DEFINE_NAME(Initialized)
HAL_SIMDATAVALUE_DEFINE_NAME(Count)
HAL_SIMDATAVALUE_DEFINE_NAME(Period)
HAL_SIMDATAVALUE_DEFINE_NAME(Reset)
HAL_SIMDATAVALUE_DEFINE_NAME(MaxPeriod)
HAL_SIMDATAVALUE_DEFINE_NAME(Direction)
HAL_SIMDATAVALUE_DEFINE_NAME(ReverseDirection)
HAL_SIMDATAVALUE_DEFINE_NAME(SamplesToAverage)
HAL_SIMDATAVALUE_DEFINE_NAME(DistancePerPulse)
public:
void SetDigitalChannelA(int16_t channel);
int16_t GetDigitalChannelA() const;
int32_t RegisterInitializedCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelInitializedCallback(int32_t uid);
void InvokeInitializedCallback(HAL_Value value);
HAL_Bool GetInitialized();
void SetInitialized(HAL_Bool initialized);
int32_t RegisterCountCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelCountCallback(int32_t uid);
void InvokeCountCallback(HAL_Value value);
int32_t GetCount();
void SetCount(int32_t count);
int32_t RegisterPeriodCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelPeriodCallback(int32_t uid);
void InvokePeriodCallback(HAL_Value value);
double GetPeriod();
void SetPeriod(double period);
int32_t RegisterResetCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelResetCallback(int32_t uid);
void InvokeResetCallback(HAL_Value value);
HAL_Bool GetReset();
void SetReset(HAL_Bool reset);
int32_t RegisterMaxPeriodCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelMaxPeriodCallback(int32_t uid);
void InvokeMaxPeriodCallback(HAL_Value value);
double GetMaxPeriod();
void SetMaxPeriod(double maxPeriod);
int32_t RegisterDirectionCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelDirectionCallback(int32_t uid);
void InvokeDirectionCallback(HAL_Value value);
HAL_Bool GetDirection();
void SetDirection(HAL_Bool direction);
int32_t RegisterReverseDirectionCallback(HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify);
void CancelReverseDirectionCallback(int32_t uid);
void InvokeReverseDirectionCallback(HAL_Value value);
HAL_Bool GetReverseDirection();
void SetReverseDirection(HAL_Bool reverseDirection);
int32_t RegisterSamplesToAverageCallback(HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify);
void CancelSamplesToAverageCallback(int32_t uid);
void InvokeSamplesToAverageCallback(HAL_Value value);
int32_t GetSamplesToAverage();
void SetSamplesToAverage(int32_t samplesToAverage);
int32_t RegisterDistancePerPulseCallback(HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify);
void CancelDistancePerPulseCallback(int32_t uid);
void InvokeDistancePerPulseCallback(HAL_Value value);
double GetDistancePerPulse();
void SetDistancePerPulse(double distancePerPulse);
std::atomic<int16_t> digitalChannelA{0};
SimDataValue<HAL_Bool, MakeBoolean, GetInitializedName> initialized{false};
SimDataValue<int32_t, MakeInt, GetCountName> count{0};
SimDataValue<double, MakeDouble, GetPeriodName> period{
std::numeric_limits<double>::max()};
SimDataValue<HAL_Bool, MakeBoolean, GetResetName> reset{false};
SimDataValue<double, MakeDouble, GetMaxPeriodName> maxPeriod{0};
SimDataValue<HAL_Bool, MakeBoolean, GetDirectionName> direction{false};
SimDataValue<HAL_Bool, MakeBoolean, GetReverseDirectionName> reverseDirection{
false};
SimDataValue<int32_t, MakeInt, GetSamplesToAverageName> samplesToAverage{0};
SimDataValue<double, MakeDouble, GetDistancePerPulseName> distancePerPulse{1};
virtual void ResetData();
private:
wpi::mutex m_registerMutex;
std::atomic<int16_t> m_digitalChannelA{0};
std::atomic<HAL_Bool> m_initialized{false};
std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
std::atomic<int32_t> m_count{0};
std::shared_ptr<NotifyListenerVector> m_countCallbacks = nullptr;
std::atomic<double> m_period{std::numeric_limits<double>::max()};
std::shared_ptr<NotifyListenerVector> m_periodCallbacks = nullptr;
std::atomic<HAL_Bool> m_reset{false};
std::shared_ptr<NotifyListenerVector> m_resetCallbacks = nullptr;
std::atomic<double> m_maxPeriod{0};
std::shared_ptr<NotifyListenerVector> m_maxPeriodCallbacks = nullptr;
std::atomic<HAL_Bool> m_direction{false};
std::shared_ptr<NotifyListenerVector> m_directionCallbacks = nullptr;
std::atomic<HAL_Bool> m_reverseDirection{false};
std::shared_ptr<NotifyListenerVector> m_reverseDirectionCallbacks = nullptr;
std::atomic<int32_t> m_samplesToAverage{0};
std::shared_ptr<NotifyListenerVector> m_samplesToAverageCallbacks = nullptr;
std::atomic<double> m_distancePerPulse{1};
std::shared_ptr<NotifyListenerVector> m_distancePerPulseCallbacks = nullptr;
};
extern EncoderData* SimEncoderData;
} // namespace hal