Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-30 02:31:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

[hal, wpilib] Update Addressable LED support (#8100)

Browse Source
This commit is contained in:
Peter Johnson
2025-07-21 21:52:10 -07:00
committed by GitHub
parent 8aa312fb6f
commit f3af50fc8e
40 changed files with 857 additions and 1104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
hal/src/main/native/sim/AddressableLED.cpp
View File

@@ -12,108 +12,90 @@
#include "PortsInternal.h"
#include "hal/Errors.h"
#include "hal/handles/HandlesInternal.h"
#include "hal/handles/LimitedHandleResource.h"
#include "hal/handles/IndexedHandleResource.h"
#include "mockdata/AddressableLEDDataInternal.h"
using namespace hal;
namespace {
struct AddressableLED {
uint8_t index;
};
} // namespace
static LimitedHandleResource<HAL_AddressableLEDHandle, AddressableLED,
kNumAddressableLEDs,
HAL_HandleEnum::AddressableLED>* ledHandles;
namespace hal::init {
void InitializeAddressableLED() {
static LimitedHandleResource<HAL_AddressableLEDHandle, AddressableLED,
kNumAddressableLEDs,
HAL_HandleEnum::AddressableLED>
dcH;
ledHandles = &dcH;
}
void InitializeAddressableLED() {}
} // namespace hal::init
extern "C" {
HAL_AddressableLEDHandle HAL_InitializeAddressableLED(
HAL_DigitalHandle outputPort, int32_t* status) {
int32_t channel, const char* allocationLocation, int32_t* status) {
hal::init::CheckInit();
auto digitalPort =
hal::digitalChannelHandles->Get(outputPort, hal::HAL_HandleEnum::PWM);
if (channel < 0 || channel >= kNumAddressableLEDs) {
*status = RESOURCE_OUT_OF_RANGE;
hal::SetLastErrorIndexOutOfRange(status, "Invalid Index for AddressableLED",
0, kNumAddressableLEDs, channel);
return HAL_kInvalidHandle;
}
if (!digitalPort) {
// If DIO was passed, channel error, else generic error
if (getHandleType(outputPort) == hal::HAL_HandleEnum::DIO) {
*status = HAL_LED_CHANNEL_ERROR;
HAL_DigitalHandle handle;
auto port = digitalChannelHandles->Allocate(
channel, HAL_HandleEnum::AddressableLED, &handle, status);
if (*status != 0) {
if (port) {
hal::SetLastErrorPreviouslyAllocated(status, "PWM or DIO", channel,
port->previousAllocation);
} else {
*status = HAL_HANDLE_ERROR;
hal::SetLastErrorIndexOutOfRange(status,
"Invalid Index for AddressableLED", 0,
kNumAddressableLEDs, channel);
}
return HAL_kInvalidHandle;
return HAL_kInvalidHandle; // failed to allocate. Pass error back.
}
if (digitalPort->channel >= kNumPWMHeaders) {
*status = HAL_LED_CHANNEL_ERROR;
return HAL_kInvalidHandle;
}
port->channel = static_cast<uint8_t>(channel);
HAL_AddressableLEDHandle handle = ledHandles->Allocate();
if (handle == HAL_kInvalidHandle) {
*status = NO_AVAILABLE_RESOURCES;
return HAL_kInvalidHandle;
}
SimAddressableLEDData[channel].start = 0;
SimAddressableLEDData[channel].length = 0;
SimAddressableLEDData[channel].initialized = true;
port->previousAllocation = allocationLocation ? allocationLocation : "";
auto led = ledHandles->Get(handle);
if (!led) { // would only occur on thread issue
*status = HAL_HANDLE_ERROR;
return HAL_kInvalidHandle;
}
int16_t index = getHandleIndex(handle);
SimAddressableLEDData[index].outputPort = digitalPort->channel;
SimAddressableLEDData[index].length = 1;
SimAddressableLEDData[index].running = false;
SimAddressableLEDData[index].initialized = true;
led->index = index;
return handle;
}
void HAL_FreeAddressableLED(HAL_AddressableLEDHandle handle) {
auto led = ledHandles->Get(handle);
ledHandles->Free(handle);
if (!led) {
auto port =
digitalChannelHandles->Get(handle, HAL_HandleEnum::AddressableLED);
// no status, so no need to check for a proper free.
digitalChannelHandles->Free(handle, HAL_HandleEnum::AddressableLED);
if (port == nullptr) {
return;
}
SimAddressableLEDData[led->index].running = false;
SimAddressableLEDData[led->index].initialized = false;
SimAddressableLEDData[port->channel].initialized = false;
}
void HAL_SetAddressableLEDColorOrder(HAL_AddressableLEDHandle handle,
HAL_AddressableLEDColorOrder colorOrder,
int32_t* status) {}
void HAL_SetAddressableLEDOutputPort(HAL_AddressableLEDHandle handle,
HAL_DigitalHandle outputPort,
int32_t* status) {
auto led = ledHandles->Get(handle);
if (!led) {
void HAL_SetAddressableLEDStart(HAL_AddressableLEDHandle handle, int32_t start,
int32_t* status) {
auto port =
digitalChannelHandles->Get(handle, HAL_HandleEnum::AddressableLED);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
if (auto port = digitalChannelHandles->Get(outputPort, HAL_HandleEnum::PWM)) {
SimAddressableLEDData[led->index].outputPort = port->channel;
} else {
SimAddressableLEDData[led->index].outputPort = -1;
if (start > HAL_kAddressableLEDMaxLength || start < 0) {
*status = PARAMETER_OUT_OF_RANGE;
hal::SetLastError(
status,
fmt::format(
"LED start must be less than or equal to {}. {} was requested",
HAL_kAddressableLEDMaxLength, start));
return;
}
SimAddressableLEDData[port->channel].start = start;
}
void HAL_SetAddressableLEDLength(HAL_AddressableLEDHandle handle,
int32_t length, int32_t* status) {
auto led = ledHandles->Get(handle);
if (!led) {
auto port =
digitalChannelHandles->Get(handle, HAL_HandleEnum::AddressableLED);
if (!port) {
*status = HAL_HANDLE_ERROR;
return;
}
@@ -126,54 +108,13 @@ void HAL_SetAddressableLEDLength(HAL_AddressableLEDHandle handle,
HAL_kAddressableLEDMaxLength, length));
return;
}
SimAddressableLEDData[led->index].length = length;
SimAddressableLEDData[port->channel].length = length;
}
void HAL_WriteAddressableLEDData(HAL_AddressableLEDHandle handle,
const struct HAL_AddressableLEDData* data,
int32_t length, int32_t* status) {
auto led = ledHandles->Get(handle);
if (!led) {
*status = HAL_HANDLE_ERROR;
return;
}
if (length > SimAddressableLEDData[led->index].length) {
*status = PARAMETER_OUT_OF_RANGE;
hal::SetLastError(
status,
fmt::format(
"Data length must be less than or equal to {}. {} was requested",
SimAddressableLEDData[led->index].length.Get(), length));
return;
}
SimAddressableLEDData[led->index].SetData(data, length);
}
void HAL_SetAddressableLEDBitTiming(HAL_AddressableLEDHandle handle,
int32_t highTime0, int32_t lowTime0,
int32_t highTime1, int32_t lowTime1,
int32_t* status) {}
void HAL_SetAddressableLEDSyncTime(HAL_AddressableLEDHandle handle,
int32_t syncTime, int32_t* status) {}
void HAL_StartAddressableLEDOutput(HAL_AddressableLEDHandle handle,
int32_t* status) {
auto led = ledHandles->Get(handle);
if (!led) {
*status = HAL_HANDLE_ERROR;
return;
}
SimAddressableLEDData[led->index].running = true;
}
void HAL_StopAddressableLEDOutput(HAL_AddressableLEDHandle handle,
int32_t* status) {
auto led = ledHandles->Get(handle);
if (!led) {
*status = HAL_HANDLE_ERROR;
return;
}
SimAddressableLEDData[led->index].running = false;
void HAL_SetAddressableLEDData(int32_t start, int32_t length,
HAL_AddressableLEDColorOrder colorOrder,
const struct HAL_AddressableLEDData* data,
int32_t* status) {
SimAddressableLEDDataBuffer->SetData(start, length, data);
}
} // extern "C"

2
hal/src/main/native/sim/PortsInternal.h
View File

@@ -32,7 +32,7 @@ constexpr int32_t kNumREVPDHChannels = 24;
constexpr int32_t kNumPDSimModules = kNumREVPDHModules;
constexpr int32_t kNumPDSimChannels = kNumREVPDHChannels;
constexpr int32_t kNumDutyCycles = 6;
constexpr int32_t kNumAddressableLEDs = 1;
constexpr int32_t kNumAddressableLEDs = 6;
constexpr int32_t kNumREVPHModules = 63;
constexpr int32_t kNumREVPHChannels = 16;
constexpr int32_t kSPIAccelerometers = 5;

67
hal/src/main/native/sim/mockdata/AddressableLEDData.cpp
View File

@@ -14,62 +14,64 @@ namespace hal::init {
void InitializeAddressableLEDData() {
static AddressableLEDData sad[kNumAddressableLEDs];
::hal::SimAddressableLEDData = sad;
static AddressableLEDDataBuffer buf;
::hal::SimAddressableLEDDataBuffer = &buf;
}
} // namespace hal::init
AddressableLEDData* hal::SimAddressableLEDData;
AddressableLEDDataBuffer* hal::SimAddressableLEDDataBuffer;
void AddressableLEDData::ResetData() {
initialized.Reset(false);
outputPort.Reset(-1);
length.Reset(1);
running.Reset(false);
data.Reset();
start.Reset(0);
length.Reset(0);
}
void AddressableLEDData::SetData(const HAL_AddressableLEDData* d, int32_t len) {
len = (std::min)(HAL_kAddressableLEDMaxLength, len);
void AddressableLEDDataBuffer::SetData(int32_t start, int32_t len,
const HAL_AddressableLEDData* d) {
if ((start + len) > HAL_kAddressableLEDMaxLength) {
len = HAL_kAddressableLEDMaxLength - start;
}
if (len <= 0) {
return;
}
{
std::scoped_lock lock(m_dataMutex);
std::memcpy(m_data, d, len * sizeof(d[0]));
std::memcpy(&m_data[start], d, len * sizeof(d[0]));
}
data(reinterpret_cast<const uint8_t*>(d), len * sizeof(d[0]));
}
int32_t AddressableLEDData::GetData(HAL_AddressableLEDData* d) {
int32_t AddressableLEDDataBuffer::GetData(int32_t start, int32_t len,
HAL_AddressableLEDData* d) {
if ((start + len) > HAL_kAddressableLEDMaxLength) {
len = HAL_kAddressableLEDMaxLength - start;
}
if (len <= 0) {
return 0;
}
std::scoped_lock lock(m_dataMutex);
int32_t len = length;
if (d) {
std::memcpy(d, m_data, len * sizeof(d[0]));
std::memcpy(d, &m_data[start], len * sizeof(d[0]));
}
return len;
}
extern "C" {
int32_t HALSIM_FindAddressableLEDForChannel(int32_t channel) {
for (int i = 0; i < kNumAddressableLEDs; ++i) {
if (SimAddressableLEDData[i].initialized &&
SimAddressableLEDData[i].outputPort == channel) {
return i;
}
}
return -1;
}
void HALSIM_ResetAddressableLEDData(int32_t index) {
SimAddressableLEDData[index].ResetData();
}
int32_t HALSIM_GetAddressableLEDData(int32_t index,
int32_t HALSIM_GetAddressableLEDData(int32_t start, int32_t length,
struct HAL_AddressableLEDData* data) {
return SimAddressableLEDData[index].GetData(data);
return SimAddressableLEDDataBuffer->GetData(start, length, data);
}
void HALSIM_SetAddressableLEDData(int32_t index,
const struct HAL_AddressableLEDData* data,
int32_t length) {
SimAddressableLEDData[index].SetData(data, length);
void HALSIM_SetAddressableLEDData(int32_t start, int32_t length,
const struct HAL_AddressableLEDData* data) {
SimAddressableLEDDataBuffer->SetData(start, length, data);
}
#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \
@@ -77,14 +79,14 @@ void HALSIM_SetAddressableLEDData(int32_t index,
SimAddressableLEDData, LOWERNAME)
DEFINE_CAPI(HAL_Bool, Initialized, initialized)
DEFINE_CAPI(int32_t, OutputPort, outputPort)
DEFINE_CAPI(int32_t, Start, start)
DEFINE_CAPI(int32_t, Length, length)
DEFINE_CAPI(HAL_Bool, Running, running)
#undef DEFINE_CAPI
#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \
HAL_SIMCALLBACKREGISTRY_DEFINE_CAPI(TYPE, HALSIM, AddressableLED##CAPINAME, \
SimAddressableLEDData, LOWERNAME)
#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \
HAL_SIMCALLBACKREGISTRY_DEFINE_CAPI_NOINDEX( \
TYPE, HALSIM, AddressableLED##CAPINAME, SimAddressableLEDDataBuffer, \
LOWERNAME)
DEFINE_CAPI(HAL_ConstBufferCallback, Data, data)
@@ -97,8 +99,7 @@ void HALSIM_RegisterAddressableLEDAllCallbacks(int32_t index,
void* param,
HAL_Bool initialNotify) {
REGISTER(initialized);
REGISTER(outputPort);
REGISTER(start);
REGISTER(length);
REGISTER(running);
}
} // extern "C"

29
hal/src/main/native/sim/mockdata/AddressableLEDDataInternal.h
View File

@@ -15,26 +15,29 @@
namespace hal {
class AddressableLEDData {
HAL_SIMDATAVALUE_DEFINE_NAME(Initialized)
HAL_SIMDATAVALUE_DEFINE_NAME(OutputPort)
HAL_SIMDATAVALUE_DEFINE_NAME(Start)
HAL_SIMDATAVALUE_DEFINE_NAME(Length)
HAL_SIMDATAVALUE_DEFINE_NAME(Running)
public:
SimDataValue<HAL_Bool, HAL_MakeBoolean, GetInitializedName> initialized{
false};
SimDataValue<int32_t, HAL_MakeInt, GetStartName> start{0};
SimDataValue<int32_t, HAL_MakeInt, GetLengthName> length{0};
void ResetData();
};
extern AddressableLEDData* SimAddressableLEDData;
class AddressableLEDDataBuffer {
HAL_SIMDATAVALUE_DEFINE_NAME(Data)
wpi::recursive_spinlock m_dataMutex;
HAL_AddressableLEDData m_data[HAL_kAddressableLEDMaxLength];
public:
void SetData(const HAL_AddressableLEDData* d, int32_t len);
int32_t GetData(HAL_AddressableLEDData* d);
SimDataValue<HAL_Bool, HAL_MakeBoolean, GetInitializedName> initialized{
false};
SimDataValue<int32_t, HAL_MakeInt, GetOutputPortName> outputPort{-1};
SimDataValue<int32_t, HAL_MakeInt, GetLengthName> length{1};
SimDataValue<HAL_Bool, HAL_MakeBoolean, GetRunningName> running{false};
void SetData(int32_t start, int32_t len, const HAL_AddressableLEDData* d);
int32_t GetData(int32_t start, int32_t len, HAL_AddressableLEDData* d);
SimCallbackRegistry<HAL_ConstBufferCallback, GetDataName> data;
void ResetData();
};
extern AddressableLEDData* SimAddressableLEDData;
extern AddressableLEDDataBuffer* SimAddressableLEDDataBuffer;
} // namespace hal