Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-21 01:01:43 +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

116
hal/src/main/native/sim/mockdata/AnalogInDataInternal.h
View File

@@ -7,107 +7,35 @@
#pragma once
#include <atomic>
#include <memory>
#include <wpi/mutex.h>
#include "mockdata/AnalogInData.h"
#include "mockdata/NotifyListenerVector.h"
#include "mockdata/SimDataValue.h"
namespace hal {
class AnalogInData {
HAL_SIMDATAVALUE_DEFINE_NAME(Initialized)
HAL_SIMDATAVALUE_DEFINE_NAME(AverageBits)
HAL_SIMDATAVALUE_DEFINE_NAME(OversampleBits)
HAL_SIMDATAVALUE_DEFINE_NAME(Voltage)
HAL_SIMDATAVALUE_DEFINE_NAME(AccumulatorInitialized)
HAL_SIMDATAVALUE_DEFINE_NAME(AccumulatorValue)
HAL_SIMDATAVALUE_DEFINE_NAME(AccumulatorCount)
HAL_SIMDATAVALUE_DEFINE_NAME(AccumulatorCenter)
HAL_SIMDATAVALUE_DEFINE_NAME(AccumulatorDeadband)
public:
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 RegisterAverageBitsCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelAverageBitsCallback(int32_t uid);
void InvokeAverageBitsCallback(HAL_Value value);
int32_t GetAverageBits();
void SetAverageBits(int32_t averageBits);
int32_t RegisterOversampleBitsCallback(HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify);
void CancelOversampleBitsCallback(int32_t uid);
void InvokeOversampleBitsCallback(HAL_Value value);
int32_t GetOversampleBits();
void SetOversampleBits(int32_t oversampleBits);
int32_t RegisterVoltageCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelVoltageCallback(int32_t uid);
void InvokeVoltageCallback(HAL_Value value);
double GetVoltage();
void SetVoltage(double voltage);
int32_t RegisterAccumulatorInitializedCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify);
void CancelAccumulatorInitializedCallback(int32_t uid);
void InvokeAccumulatorInitializedCallback(HAL_Value value);
HAL_Bool GetAccumulatorInitialized();
void SetAccumulatorInitialized(HAL_Bool accumulatorInitialized);
int32_t RegisterAccumulatorValueCallback(HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify);
void CancelAccumulatorValueCallback(int32_t uid);
void InvokeAccumulatorValueCallback(HAL_Value value);
int64_t GetAccumulatorValue();
void SetAccumulatorValue(int64_t accumulatorValue);
int32_t RegisterAccumulatorCountCallback(HAL_NotifyCallback callback,
void* param, HAL_Bool initialNotify);
void CancelAccumulatorCountCallback(int32_t uid);
void InvokeAccumulatorCountCallback(HAL_Value value);
int64_t GetAccumulatorCount();
void SetAccumulatorCount(int64_t accumulatorCount);
int32_t RegisterAccumulatorCenterCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify);
void CancelAccumulatorCenterCallback(int32_t uid);
void InvokeAccumulatorCenterCallback(HAL_Value value);
int32_t GetAccumulatorCenter();
void SetAccumulatorCenter(int32_t accumulatorCenter);
int32_t RegisterAccumulatorDeadbandCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify);
void CancelAccumulatorDeadbandCallback(int32_t uid);
void InvokeAccumulatorDeadbandCallback(HAL_Value value);
int32_t GetAccumulatorDeadband();
void SetAccumulatorDeadband(int32_t accumulatorDeadband);
SimDataValue<HAL_Bool, MakeBoolean, GetInitializedName> initialized{false};
SimDataValue<int32_t, MakeInt, GetAverageBitsName> averageBits{7};
SimDataValue<int32_t, MakeInt, GetOversampleBitsName> oversampleBits{0};
SimDataValue<double, MakeDouble, GetVoltageName> voltage{0.0};
SimDataValue<HAL_Bool, MakeBoolean, GetAccumulatorInitializedName>
accumulatorInitialized{false};
SimDataValue<int64_t, MakeLong, GetAccumulatorValueName> accumulatorValue{0};
SimDataValue<int64_t, MakeLong, GetAccumulatorCountName> accumulatorCount{0};
SimDataValue<int32_t, MakeInt, GetAccumulatorCenterName> accumulatorCenter{0};
SimDataValue<int32_t, MakeInt, GetAccumulatorDeadbandName>
accumulatorDeadband{0};
virtual void ResetData();
private:
wpi::mutex m_registerMutex;
std::atomic<HAL_Bool> m_initialized{false};
std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
std::atomic<int32_t> m_averageBits{7};
std::shared_ptr<NotifyListenerVector> m_averageBitsCallbacks = nullptr;
std::atomic<int32_t> m_oversampleBits{0};
std::shared_ptr<NotifyListenerVector> m_oversampleBitsCallbacks = nullptr;
std::atomic<double> m_voltage{0.0};
std::shared_ptr<NotifyListenerVector> m_voltageCallbacks = nullptr;
std::atomic<HAL_Bool> m_accumulatorInitialized{false};
std::shared_ptr<NotifyListenerVector> m_accumulatorInitializedCallbacks =
nullptr;
std::atomic<int64_t> m_accumulatorValue{0};
std::shared_ptr<NotifyListenerVector> m_accumulatorValueCallbacks = nullptr;
std::atomic<int64_t> m_accumulatorCount{0};
std::shared_ptr<NotifyListenerVector> m_accumulatorCountCallbacks = nullptr;
std::atomic<int32_t> m_accumulatorCenter{0};
std::shared_ptr<NotifyListenerVector> m_accumulatorCenterCallbacks = nullptr;
std::atomic<int32_t> m_accumulatorDeadband{0};
std::shared_ptr<NotifyListenerVector> m_accumulatorDeadbandCallbacks =
nullptr;
};
extern AnalogInData* SimAnalogInData;
} // namespace hal