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

Fix bugs in simulation libraries (#853)

Browse Source 
Some thing got broken in the past couple of weeks with updates to the
HAL.
This commit is contained in:
PJ Reiniger
2017-12-31 15:37:14 -05:00
committed by Peter Johnson
parent 2c4faee667
commit 55b6764d50
14 changed files with 201 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
hal/src/main/native/sim/MockData/SPIData.cpp
View File

@@ -13,6 +13,21 @@
using namespace hal;
void InvokeCallback(
std::shared_ptr<SpiAutoReceiveDataListenerVector> currentVector,
const char* name, uint8_t* buffer, int32_t numToRead,
int32_t* outputCount) {
// Return if no callbacks are assigned
if (currentVector == nullptr) return;
// Get a copy of the shared_ptr, then iterate and callback listeners
auto newCallbacks = currentVector;
for (size_t i = 0; i < newCallbacks->size(); ++i) {
if (!(*newCallbacks)[i]) continue; // callback was removed
auto listener = (*newCallbacks)[i];
listener.callback(name, listener.param, buffer, numToRead, outputCount);
}
}
namespace hal {
namespace init {
void InitializeSPIData() {
@@ -25,12 +40,10 @@ void InitializeSPIData() {
SPIData* hal::SimSPIData;
void SPIData::ResetData() {
m_initialized = false;
m_accumulatorValue = 0;
m_initializedCallbacks = nullptr;
m_readCallbacks = nullptr;
m_writeCallbacks = nullptr;
m_resetAccumulatorCallback = nullptr;
m_setAccumulatorCallback = nullptr;
m_autoReceiveDataCallbacks = nullptr;
}
SPIData::SPIData() {}
@@ -108,66 +121,26 @@ void SPIData::CancelWriteCallback(int32_t uid) {
m_writeCallbacks = CancelCallback(m_writeCallbacks, uid);
}
int32_t SPIData::RegisterResetAccumulatorCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
int32_t SPIData::RegisterReadAutoReceivedDataCallback(
HAL_SpiReadAutoReceiveBufferCallback callback, void* param) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<wpi::mutex> lock(m_registerMutex);
m_resetAccumulatorCallback =
RegisterCallback(m_resetAccumulatorCallback, "ResetAccumulator",
callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeBoolean(GetInitialized());
callback("ResetAccumulator", param, &value);
m_autoReceiveDataCallbacks = RegisterCallbackImpl(
m_autoReceiveDataCallbacks, "AutoReceive", callback, param, &newUid);
}
return newUid;
}
void SPIData::CancelResetAccumulatorCallback(int32_t uid) {
m_resetAccumulatorCallback = CancelCallback(m_resetAccumulatorCallback, uid);
void SPIData::CancelReadAutoReceivedDataCallback(int32_t uid) {
m_autoReceiveDataCallbacks =
CancelCallbackImpl<SpiAutoReceiveDataListenerVector,
HAL_SpiReadAutoReceiveBufferCallback>(
m_autoReceiveDataCallbacks, uid);
}
int32_t SPIData::RegisterAccumulatorCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<wpi::mutex> lock(m_registerMutex);
m_setAccumulatorCallback = RegisterCallback(
m_setAccumulatorCallback, "SetAccumulator", callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeInt(GetAccumulatorValue());
callback("SetAccumulator", param, &value);
}
return newUid;
}
void SPIData::CancelAccumulatorCallback(int32_t uid) {
m_setAccumulatorCallback = CancelCallback(m_setAccumulatorCallback, uid);
}
void SPIData::InvokeSetAccumulatorCallback(HAL_Value value) {
InvokeCallback(m_setAccumulatorCallback, "SetAccumulator", &value);
}
void SPIData::SetAccumulatorValue(int64_t value) {
int64_t oldValue = m_accumulatorValue.exchange(value);
if (oldValue != value) {
InvokeSetAccumulatorCallback(MakeLong(value));
}
}
int64_t SPIData::GetAccumulatorValue() { return m_accumulatorValue; }
int32_t SPIData::Read(uint8_t* buffer, int32_t count) {
std::lock_guard<wpi::mutex> lock(m_dataMutex);
InvokeCallback(m_readCallbacks, "Read", buffer, count);
@@ -192,9 +165,13 @@ int32_t SPIData::Transaction(const uint8_t* dataToSend, uint8_t* dataReceived,
return size;
}
void SPIData::ResetAccumulator() {
HAL_Value value = MakeInt(0);
InvokeCallback(m_resetAccumulatorCallback, "ResetAccumulator", &value);
int32_t SPIData::ReadAutoReceivedData(uint8_t* buffer, int32_t numToRead,
double timeout, int32_t* status) {
int32_t outputCount = 0;
InvokeCallback(m_autoReceiveDataCallbacks, "AutoReceive",
const_cast<uint8_t*>(buffer), numToRead, &outputCount);
return outputCount;
}
extern "C" {
@@ -238,22 +215,14 @@ void HALSIM_CancelSPIWriteCallback(int32_t index, int32_t uid) {
SimSPIData[index].CancelWriteCallback(uid);
}
int32_t HALSIM_RegisterSPIResetAccumulatorCallback(int32_t index,
HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
return SimSPIData[index].RegisterResetAccumulatorCallback(callback, param,
initialNotify);
}
void HALSIM_CancelSPIResetAccumulatorCallback(int32_t index, int32_t uid) {
SimSPIData[index].CancelResetAccumulatorCallback(uid);
int32_t HALSIM_RegisterSPIReadAutoReceivedDataCallback(
int32_t index, HAL_SpiReadAutoReceiveBufferCallback callback, void* param) {
return SimSPIData[index].RegisterReadAutoReceivedDataCallback(callback,
param);
}
void HALSIM_SetSPISetAccumulatorValue(int32_t index, int64_t value) {
SimSPIData[index].SetAccumulatorValue(value);
}
int64_t HALSIM_GetSPIGetAccumulatorValue(int32_t index) {
return SimSPIData[index].GetAccumulatorValue();
void HALSIM_CancelSPIReadAutoReceivedDataCallback(int32_t index, int32_t uid) {
SimSPIData[index].CancelReadAutoReceivedDataCallback(uid);
}
} // extern "C"