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

76
hal/src/main/native/sim/mockdata/PWMDataInternal.h
View File

@@ -7,75 +7,27 @@
#pragma once
#include <atomic>
#include <memory>
#include <wpi/mutex.h>
#include "mockdata/NotifyListenerVector.h"
#include "mockdata/PWMData.h"
#include "mockdata/SimDataValue.h"
namespace hal {
class PWMData {
HAL_SIMDATAVALUE_DEFINE_NAME(Initialized)
HAL_SIMDATAVALUE_DEFINE_NAME(RawValue)
HAL_SIMDATAVALUE_DEFINE_NAME(Speed)
HAL_SIMDATAVALUE_DEFINE_NAME(Position)
HAL_SIMDATAVALUE_DEFINE_NAME(PeriodScale)
HAL_SIMDATAVALUE_DEFINE_NAME(ZeroLatch)
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 RegisterRawValueCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelRawValueCallback(int32_t uid);
void InvokeRawValueCallback(HAL_Value value);
int32_t GetRawValue();
void SetRawValue(int32_t rawValue);
int32_t RegisterSpeedCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelSpeedCallback(int32_t uid);
void InvokeSpeedCallback(HAL_Value value);
double GetSpeed();
void SetSpeed(double speed);
int32_t RegisterPositionCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelPositionCallback(int32_t uid);
void InvokePositionCallback(HAL_Value value);
double GetPosition();
void SetPosition(double position);
int32_t RegisterPeriodScaleCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelPeriodScaleCallback(int32_t uid);
void InvokePeriodScaleCallback(HAL_Value value);
int32_t GetPeriodScale();
void SetPeriodScale(int32_t periodScale);
int32_t RegisterZeroLatchCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelZeroLatchCallback(int32_t uid);
void InvokeZeroLatchCallback(HAL_Value value);
HAL_Bool GetZeroLatch();
void SetZeroLatch(HAL_Bool zeroLatch);
SimDataValue<HAL_Bool, MakeBoolean, GetInitializedName> initialized{false};
SimDataValue<int32_t, MakeInt, GetRawValueName> rawValue{0};
SimDataValue<double, MakeDouble, GetSpeedName> speed{0};
SimDataValue<double, MakeDouble, GetPositionName> position{0};
SimDataValue<int32_t, MakeInt, GetPeriodScaleName> periodScale{0};
SimDataValue<HAL_Bool, MakeBoolean, GetZeroLatchName> zeroLatch{false};
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_rawValue{0};
std::shared_ptr<NotifyListenerVector> m_rawValueCallbacks = nullptr;
std::atomic<double> m_speed{0};
std::shared_ptr<NotifyListenerVector> m_speedCallbacks = nullptr;
std::atomic<double> m_position{0};
std::shared_ptr<NotifyListenerVector> m_positionCallbacks = nullptr;
std::atomic<int32_t> m_periodScale{0};
std::shared_ptr<NotifyListenerVector> m_periodScaleCallbacks = nullptr;
std::atomic<HAL_Bool> m_zeroLatch{false};
std::shared_ptr<NotifyListenerVector> m_zeroLatchCallbacks = nullptr;
};
extern PWMData* SimPWMData;
} // namespace hal