ALPAKA/sta-core
1
0
Fork 0
mirror of https://git.intern.spaceteamaachen.de/ALPAKA/sta-core.git synced 2025-09-28 21:17:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename SPI classes

Browse Source
This commit is contained in:
Henrik Stickann
2023-02-02 22:23:44 +01:00
parent 59585b2ae5
commit fdf5b4890d
10 changed files with 630 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
src/spi/device.cpp
View File

@@ -5,84 +5,84 @@
namespace sta
{
SpiDevice::SpiDevice(SpiInterface * intf, GpioPin * csPin)
: intf_{intf}, csPin_{csPin}
{
STA_ASSERT(intf != nullptr);
STA_ASSERT(csPin != nullptr);
}
SPIDevice::SPIDevice(SPI * intf, GpioPin * csPin)
: intf_{intf}, csPin_{csPin}
{
STA_ASSERT(intf != nullptr);
STA_ASSERT(csPin != nullptr);
}
void SpiDevice::beginTransmission()
{
// Acquire SPI access and activate device
intf_->acquire();
select();
}
void SPIDevice::beginTransmission()
{
// Acquire SPI access and activate device
intf_->acquire();
select();
}
void SpiDevice::endTransmission()
{
// Deactivate device and release SPI access
deselect();
intf_->release();
}
void SPIDevice::endTransmission()
{
// Deactivate device and release SPI access
deselect();
intf_->release();
}
// Forward I/O operations to SPI interface
// Forward I/O operations to SPI interface
void SpiDevice::transfer(uint8_t data)
{
intf_->transfer(data);
}
void SPIDevice::transfer(uint8_t data)
{
intf_->transfer(data);
}
void SpiDevice::transfer16(uint16_t data)
{
intf_->transfer16(data);
}
void SPIDevice::transfer16(uint16_t data)
{
intf_->transfer16(data);
}
void SpiDevice::transfer(const uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
void SPIDevice::transfer(const uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
intf_->transfer(buffer, size);
}
intf_->transfer(buffer, size);
}
void SpiDevice::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
{
STA_ASSERT(txBuffer != nullptr);
STA_ASSERT(rxBuffer != nullptr);
STA_ASSERT(size != 0);
void SPIDevice::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
{
STA_ASSERT(txBuffer != nullptr);
STA_ASSERT(rxBuffer != nullptr);
STA_ASSERT(size != 0);
intf_->transfer(txBuffer, rxBuffer, size);
}
intf_->transfer(txBuffer, rxBuffer, size);
}
void SpiDevice::receive(uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
void SPIDevice::receive(uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
intf_->receive(buffer, size);
}
intf_->receive(buffer, size);
}
void SpiDevice::fill(uint8_t value, size_t count)
{
STA_ASSERT(count != 0);
void SPIDevice::fill(uint8_t value, size_t count)
{
STA_ASSERT(count != 0);
intf_->fill(value, count);
}
intf_->fill(value, count);
}
const SpiSettings & SpiDevice::settings() const
{
return intf_->settings();
}
const SpiSettings & SPIDevice::settings() const
{
return intf_->settings();
}
void SpiDevice::select()
{
csPin_->setState(GpioPinState::LOW);
}
void SPIDevice::select()
{
csPin_->setState(GpioPinState::LOW);
}
void SpiDevice::deselect()
{
csPin_->setState(GpioPinState::HIGH);
}
void SPIDevice::deselect()
{
csPin_->setState(GpioPinState::HIGH);
}
} // namespace sta

21
src/spi/interface.cpp
View File

@@ -1,21 +0,0 @@
#include <sta/spi/interface.hpp>
namespace sta
{
SpiInterface::SpiInterface(Mutex * mutex /* = nullptr */)
: mutex_{mutex}
{}
void SpiInterface::acquire()
{
if (mutex_ != nullptr)
mutex_->acquire();
}
void SpiInterface::release()
{
if (mutex_ != nullptr)
mutex_->release();
}
} // namespace sta

114
src/spi/settings.cpp
View File

@@ -6,67 +6,67 @@
namespace sta
{
SpiClkPolarity getSpiClkPolarity(SpiMode mode)
{
switch (mode)
{
case SpiMode::MODE_0:
case SpiMode::MODE_1:
return SpiClkPolarity::LOW;
SPIClkPolarity getSPIClkPolarity(SPIMode mode)
{
switch (mode)
{
case SPIMode::MODE_0:
case SPIMode::MODE_1:
return SPIClkPolarity::LOW;
case SpiMode::MODE_2:
case SpiMode::MODE_3:
return SpiClkPolarity::HIGH;
case SPIMode::MODE_2:
case SPIMode::MODE_3:
return SPIClkPolarity::HIGH;
default:
// Unreachable case
STA_ASSERT_MSG(false, "Case for SpiMode enum not handled");
STA_UNREACHABLE();
}
}
default:
// Unreachable case
STA_ASSERT_MSG(false, "Case for SPIMode enum not handled");
STA_UNREACHABLE();
}
}
SpiClkPhase getSpiClkPhase(SpiMode mode)
{
switch (mode)
{
case SpiMode::MODE_0:
case SpiMode::MODE_2:
return SpiClkPhase::EDGE_1;
SPIClkPhase getSPIClkPhase(SPIMode mode)
{
switch (mode)
{
case SPIMode::MODE_0:
case SPIMode::MODE_2:
return SPIClkPhase::EDGE_1;
case SpiMode::MODE_1:
case SpiMode::MODE_3:
return SpiClkPhase::EDGE_2;
case SPIMode::MODE_1:
case SPIMode::MODE_3:
return SPIClkPhase::EDGE_2;
default:
// Unreachable case
STA_ASSERT_MSG(false, "Case for SpiMode enum not handled");
STA_UNREACHABLE();
}
}
default:
// Unreachable case
STA_ASSERT_MSG(false, "Case for SPIMode enum not handled");
STA_UNREACHABLE();
}
}
SpiMode getSpiMode(SpiClkPolarity polarity, SpiClkPhase phase)
{
if (polarity == SpiClkPolarity::LOW)
{
if (phase == SpiClkPhase::EDGE_1)
{
return SpiMode::MODE_0;
}
else
{
return SpiMode::MODE_1;
}
}
else
{
if (phase == SpiClkPhase::EDGE_1)
{
return SpiMode::MODE_2;
}
else
{
return SpiMode::MODE_3;
}
}
}
SPIMode getSPIMode(SPIClkPolarity polarity, SPIClkPhase phase)
{
if (polarity == SPIClkPolarity::LOW)
{
if (phase == SPIClkPhase::EDGE_1)
{
return SPIMode::MODE_0;
}
else
{
return SPIMode::MODE_1;
}
}
else
{
if (phase == SPIClkPhase::EDGE_1)
{
return SPIMode::MODE_2;
}
else
{
return SPIMode::MODE_3;
}
}
}
} // namespace sta

26
src/spi/spi.cpp Normal file
View File

@@ -0,0 +1,26 @@
#include <sta/spi/spi.hpp>
namespace sta
{
SPI::SPI(const SPISettings & settings, Mutex * mutex /* = nullptr */)
: settings_{settings}, mutex_{mutex}
{}
const SPISettings & SPI::settings() const
{
return settings_;
}
void SPI::acquire()
{
if (mutex_ != nullptr)
mutex_->acquire();
}
void SPI::release()
{
if (mutex_ != nullptr)
mutex_->release();
}
} // namespace sta

257
src/stm32/spi.cpp
View File

@@ -7,168 +7,161 @@
#ifdef STA_MCU_LITTLE_ENDIAN
# define STA_STM32_SPI_REVERSE_BIT_ORDER SpiBitOrder::MSB
# define STA_STM32_SPI_REVERSE_BIT_ORDER SPIBitOrder::MSB
#elif STA_MCU_BIG_ENDIAN
# define STA_STM32_SPI_REVERSE_BIT_ORDER SpiBitOrder::LSB
# define STA_STM32_SPI_REVERSE_BIT_ORDER SPIBitOrder::LSB
#endif
namespace sta
{
static SpiSettings getSpiSettings(SPI_HandleTypeDef * handle, uint32_t pclkFreq)
{
SpiSettings settings;
static SPISettings getSPISettings(SPI_HandleTypeDef * handle, uint32_t pclkFreq)
{
SPISettings settings;
settings.mode = getSpiMode(
(handle->Init.CLKPolarity == SPI_POLARITY_LOW) ? SpiClkPolarity::LOW : SpiClkPolarity::HIGH,
(handle->Init.CLKPhase == SPI_PHASE_1EDGE) ? SpiClkPhase::EDGE_1 : SpiClkPhase::EDGE_2
);
settings.dataSize = (handle->Init.DataSize == SPI_DATASIZE_8BIT) ? SpiDataSize::SIZE_8 : SpiDataSize::SIZE_16;
settings.bitOrder = (handle->Init.FirstBit == SPI_FIRSTBIT_MSB) ? SpiBitOrder::MSB : SpiBitOrder::LSB;
settings.mode = getSPIMode(
(handle->Init.CLKPolarity == SPI_POLARITY_LOW) ? SPIClkPolarity::LOW : SPIClkPolarity::HIGH,
(handle->Init.CLKPhase == SPI_PHASE_1EDGE) ? SPIClkPhase::EDGE_1 : SPIClkPhase::EDGE_2
);
settings.dataSize = (handle->Init.DataSize == SPI_DATASIZE_8BIT) ? SPIDataSize::SIZE_8 : SPIDataSize::SIZE_16;
settings.bitOrder = (handle->Init.FirstBit == SPI_FIRSTBIT_MSB) ? SPIBitOrder::MSB : SPIBitOrder::LSB;
uint32_t prescaler = 1;
switch (handle->Init.BaudRatePrescaler)
{
case SPI_BAUDRATEPRESCALER_2:
prescaler = 2;
break;
case SPI_BAUDRATEPRESCALER_4:
prescaler = 4;
break;
case SPI_BAUDRATEPRESCALER_8:
prescaler = 8;
break;
case SPI_BAUDRATEPRESCALER_16:
prescaler = 16;
break;
case SPI_BAUDRATEPRESCALER_32:
prescaler = 32;
break;
case SPI_BAUDRATEPRESCALER_64:
prescaler = 64;
break;
case SPI_BAUDRATEPRESCALER_128:
prescaler = 128;
break;
case SPI_BAUDRATEPRESCALER_256:
prescaler = 256;
break;
default:
// Unreachable case
STA_ASSERT_MSG(false, "Case for SPI_BAUDRATEPRESCALER not handled");
STA_UNREACHABLE();
}
uint32_t prescaler = 1;
switch (handle->Init.BaudRatePrescaler)
{
case SPI_BAUDRATEPRESCALER_2:
prescaler = 2;
break;
case SPI_BAUDRATEPRESCALER_4:
prescaler = 4;
break;
case SPI_BAUDRATEPRESCALER_8:
prescaler = 8;
break;
case SPI_BAUDRATEPRESCALER_16:
prescaler = 16;
break;
case SPI_BAUDRATEPRESCALER_32:
prescaler = 32;
break;
case SPI_BAUDRATEPRESCALER_64:
prescaler = 64;
break;
case SPI_BAUDRATEPRESCALER_128:
prescaler = 128;
break;
case SPI_BAUDRATEPRESCALER_256:
prescaler = 256;
break;
default:
// Unreachable case
STA_ASSERT_MSG(false, "Case for SPI_BAUDRATEPRESCALER not handled");
STA_UNREACHABLE();
}
// SPI clock speed is based of PCLK
settings.clkSpeed = pclkFreq / prescaler;
// SPI clock speed is based of PCLK
settings.clkSpeed = pclkFreq / prescaler;
return settings;
}
return settings;
}
STM32SpiInterface::STM32SpiInterface(const STM32SpiInterfaceInfo & info, Mutex * mutex /* = nullptr */)
: SpiInterface(mutex), info_{info}
{
STA_ASSERT(info.handle != nullptr);
STA_ASSERT(info.getPCLKFreq != nullptr);
}
STM32SPI::STM32SPI(SPI_HandleTypeDef * handle, uint32_t pclkFreq, Mutex * mutex = nullptr)
: SPI(getSPISettings(handle, pclkFreq), mutex), handle_{handle}
{
STA_ASSERT(handle != nullptr);
}
STM32SPI::STM32SPI(const Info & info, Mutex * mutex /* = nullptr */)
: STM32SPI(info.handle, info.pclkFreq, mutex)
{}
void STM32SpiInterface::transfer(uint8_t value)
{
if (settings().dataSize == SpiDataSize::SIZE_8)
{
HAL_SPI_Transmit(info_.handle, &value, 1, HAL_MAX_DELAY);
}
else
{
// Required since tx buffer is cast to uint16_t * internally
uint16_t dummy = value;
HAL_SPI_Transmit(info_.handle, reinterpret_cast<uint8_t *>(&dummy), 1, HAL_MAX_DELAY);
}
}
void STM32SPI::transfer(uint8_t value)
{
if (settings().dataSize == SPIDataSize::SIZE_8)
{
HAL_SPI_Transmit(handle_, &value, 1, HAL_MAX_DELAY);
}
else
{
// Required since tx buffer is cast to uint16_t * internally
uint16_t dummy = value;
HAL_SPI_Transmit(handle_, reinterpret_cast<uint8_t *>(&dummy), 1, HAL_MAX_DELAY);
}
}
void STM32SpiInterface::transfer16(uint16_t value)
{
uint16_t size = 1;
void STM32SPI::transfer16(uint16_t value)
{
uint16_t size = 1;
// Send as two bytes if data size is 8-bit
if (settings().dataSize == SpiDataSize::SIZE_8)
{
size = 2;
// Send as two bytes if data size is 8-bit
if (settings().dataSize == SPIDataSize::SIZE_8)
{
size = 2;
if (settings().bitOrder == STA_STM32_SPI_REVERSE_BIT_ORDER)
{
// Reverse byte order from internal representation
value = STA_UINT16_SWAP_BYTE_ORDER(value);
}
}
if (settings().bitOrder == STA_STM32_SPI_REVERSE_BIT_ORDER)
{
// Reverse byte order from internal representation
value = STA_UINT16_SWAP_BYTE_ORDER(value);
}
}
HAL_SPI_Transmit(info_.handle, reinterpret_cast<uint8_t *>(&value), size, HAL_MAX_DELAY);
}
HAL_SPI_Transmit(handle_, reinterpret_cast<uint8_t *>(&value), size, HAL_MAX_DELAY);
}
void STM32SpiInterface::transfer(const uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
STA_ASSERT(size != 0);
void STM32SPI::transfer(const uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
STA_ASSERT(size != 0);
HAL_SPI_Transmit(info_.handle, const_cast<uint8_t *>(buffer), size, HAL_MAX_DELAY);
}
HAL_SPI_Transmit(handle_, const_cast<uint8_t *>(buffer), size, HAL_MAX_DELAY);
}
void STM32SpiInterface::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
{
STA_ASSERT(txBuffer != nullptr);
STA_ASSERT(rxBuffer != nullptr);
STA_ASSERT(size != 0);
void STM32SPI::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
{
STA_ASSERT(txBuffer != nullptr);
STA_ASSERT(rxBuffer != nullptr);
STA_ASSERT(size != 0);
HAL_SPI_TransmitReceive(info_.handle, const_cast<uint8_t *>(txBuffer), rxBuffer, size, HAL_MAX_DELAY);
}
HAL_SPI_TransmitReceive(handle_, const_cast<uint8_t *>(txBuffer), rxBuffer, size, HAL_MAX_DELAY);
}
void STM32SpiInterface::receive(uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
void STM32SPI::receive(uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
HAL_SPI_Receive(info_.handle, buffer, size, HAL_MAX_DELAY);
}
HAL_SPI_Receive(handle_, buffer, size, HAL_MAX_DELAY);
}
void STM32SpiInterface::fill(uint8_t value, size_t count)
{
STA_ASSERT(count != 0);
void STM32SPI::fill(uint8_t value, size_t count)
{
STA_ASSERT(count != 0);
if (settings().dataSize == SpiDataSize::SIZE_8)
{
for (size_t i = 0; i < count; ++i)
{
HAL_SPI_Transmit(info_.handle, &value, 1, HAL_MAX_DELAY);
}
}
else
{
// Required since tx buffer is cast to uint16_t * internally
uint16_t dummy = value;
for (size_t i = 0; i < count; ++i)
{
HAL_SPI_Transmit(info_.handle, reinterpret_cast<uint8_t *>(&dummy), 1, HAL_MAX_DELAY);
}
}
}
const SpiSettings & STM32SpiInterface::settings() const
{
// Cache settings
static SpiSettings settings = getSpiSettings(info_.handle, info_.getPCLKFreq());
return settings;
}
if (settings().dataSize == SPIDataSize::SIZE_8)
{
for (size_t i = 0; i < count; ++i)
{
HAL_SPI_Transmit(handle_, &value, 1, HAL_MAX_DELAY);
}
}
else
{
// Required since tx buffer is cast to uint16_t * internally
uint16_t dummy = value;
for (size_t i = 0; i < count; ++i)
{
HAL_SPI_Transmit(handle_, reinterpret_cast<uint8_t *>(&dummy), 1, HAL_MAX_DELAY);
}
}
}
STM32SpiDevice::STM32SpiDevice(STM32SpiInterface * intf, STM32GpioPin csPin)
: SpiDevice(intf, &csPin_), csPin_{csPin}
{}
STM32SPIDevice::STM32SPIDevice(STM32SPI * intf, STM32GpioPin csPin)
: SPIDevice(intf, &csPin_), csPin_{csPin}
{}
} // namespace sta