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

Move STM32 implementations into sta-stm32-core repository

Browse Source
This commit is contained in:
Henrik Stickann
2022-05-09 21:14:05 +02:00
parent 7c0c05d296
commit 92e3dd474b
14 changed files with 0 additions and 902 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/hal/delay.cpp
View File

@@ -1,65 +0,0 @@
#include <sta/hal/delay.hpp>
#ifdef STA_HAL_DELAY_ENABLE
#include <sta/assert.hpp>
#include <sta/hal.hpp>
#include <sta/lang.hpp>
#include <sta/hal/clocks.hpp>
namespace sta
{
void delayMs(uint32_t ms)
{
HAL_Delay(ms);
}
} // namespace sta
#ifdef STA_HAL_DELAY_US_TIM
#include <tim.h>
namespace sta
{
void delayUs(uint32_t us)
{
__HAL_TIM_SET_COUNTER(&STA_HAL_DELAY_US_TIM, 0);
while (__HAL_TIM_GET_COUNTER(&STA_HAL_DELAY_US_TIM) < us);
}
bool isValidDelayUsTIM()
{
// Get PCLK multiplier for TIM clock
uint32_t pclkMul = 1;
switch (STA_HAL_DELAY_US_TIM.Init.ClockDivision)
{
case TIM_CLOCKDIVISION_DIV1:
pclkMul = 1;
break;
case TIM_CLOCKDIVISION_DIV2:
pclkMul = 2;
break;
case TIM_CLOCKDIVISION_DIV4:
pclkMul = 4;
break;
default:
STA_ASSERT(false);
STA_UNREACHABLE();
}
// Calculate TIM clock frequency
uint32_t clkFreq = pclkMul * STA_HAL_GET_HANDLE_PCLK_FREQ_FN(STA_HAL_DELAY_US_TIM)();
// Calculate update frequency based on prescaler value
uint32_t updateFreq = clkFreq / STA_HAL_DELAY_US_TIM.Init.Prescaler;
// TIM must have at least microsecond precision (>= 1 MHz frequency)
return (updateFreq == 1000000);
}
} // namespace sta
#endif // STA_HAL_DELAY_US_TIM
#endif // STA_HAL_DELAY_ENABLE

37
src/hal/gpio_pin.cpp
View File

@@ -1,37 +0,0 @@
#include <sta/hal/gpio_pin.hpp>
#ifdef STA_HAL_GPIO_ENABLE
#include <sta/assert.hpp>
namespace sta
{
HalGpioPin::HalGpioPin(GPIO_TypeDef * port, uint16_t pin)
: port_{port}, pin_{pin}
{
STA_ASSERT(port != nullptr);
}
void HalGpioPin::setState(GpioPinState state)
{
HAL_GPIO_WritePin(port_, pin_, (state == GpioPinState::LOW) ? GPIO_PIN_RESET : GPIO_PIN_SET);
}
GPIO_TypeDef * HalGpioPin::getPort() const
{
return port_;
}
uint16_t HalGpioPin::getPin() const
{
return pin_;
}
uint8_t HalGpioPin::getIndex() const
{
return GPIO_GET_INDEX(port_);
}
} // namespace sta
#endif // STA_HAL_GPIO_ENABLE

22
src/hal/init.cpp
View File

@@ -1,22 +0,0 @@
#include <sta/hal/init.hpp>
#include <sta/assert.hpp>
#ifdef STA_HAL_DELAY_US_TIM
#include <tim.h>
#endif // STA_HAL_DELAY_US_TIM
namespace sta
{
void initHAL()
{
#ifdef STA_HAL_DELAY_US_TIM
// Validate TIM used for delayUs
extern bool isValidDelayUsTIM();
STA_ASSERT(isValidDelayUsTIM());
// Start timer base
HAL_TIM_Base_Start(&STA_HAL_DELAY_US_TIM);
#endif // STA_HAL_DELAY_US_TIM
}
}

193
src/hal/spi.cpp
View File

@@ -1,193 +0,0 @@
#include <sta/hal/spi.hpp>
#ifdef STA_HAL_SPI_ENABLE
#include <sta/assert.hpp>
#include <sta/endian.hpp>
#include <sta/lang.hpp>
#ifdef STA_MCU_LITTLE_ENDIAN
# define STA_HAL_SPI_REVERSE_BIT_ORDER SpiBitOrder::MSB
#elif STA_MCU_BIG_ENDIAN
# define STA_HAL_SPI_REVERSE_BIT_ORDER SpiBitOrder::LSB
#else // !STA_MCU_LITTLE_ENDIAN && !STA_MCU_BIG_ENDIAN
# ifdef STA_HAL_SPI_REVERSE_BIT_ORDER
# warning "Internal STA_HAL_SPI_REVERSE_BIT_ORDER macro manually defined! Better now what you are doing!!!"
# else // !STA_HAL_SPI_REVERSE_BIT_ORDER
# error "Unknown endian-ness. Define STA_MCU_LITTLE_ENDIAN or STA_MCU_BIG_ENDIAN in <sta/config.hpp>"
# endif // !STA_HAL_SPI_REVERSE_BIT_ORDER
#endif // !STA_MCU_LITTLE_ENDIAN && !STA_MCU_BIG_ENDIAN
namespace sta
{
static SpiSettings getHalSpiSettings(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;
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;
return settings;
}
HalSpiInterface::HalSpiInterface(const HalSpiInterfaceInfo & info, Mutex * mutex /* = nullptr */)
: SpiInterface(mutex), info_{info}
{
STA_ASSERT(info.handle != nullptr);
STA_ASSERT(info.getPCLKFreq != nullptr);
}
void HalSpiInterface::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 HalSpiInterface::transfer16(uint16_t value)
{
static_assert(sizeof(value) == 2, "Unexpected uint16_t size");
uint16_t size = 1;
// Send as two bytes if data size is 8-bit
if (settings().dataSize == SpiDataSize::SIZE_8)
{
size = 2;
if (settings().bitOrder == STA_HAL_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);
}
void HalSpiInterface::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);
}
void HalSpiInterface::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);
}
void HalSpiInterface::receive(uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
HAL_SPI_Receive(info_.handle, buffer, size, HAL_MAX_DELAY);
}
void HalSpiInterface::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 & HalSpiInterface::settings() const
{
// Cache settings
static SpiSettings settings = getHalSpiSettings(info_.handle, info_.getPCLKFreq());
return settings;
}
HalSpiDevice::HalSpiDevice(SpiInterface * intf, HalGpioPin csPin)
: SpiDevice(intf), csPin_{csPin}
{}
void HalSpiDevice::select()
{
csPin_.setState(GpioPinState::LOW);
}
void HalSpiDevice::deselect()
{
csPin_.setState(GpioPinState::HIGH);
}
} // namespace sta
#endif // STA_HAL_SPI_ENABLE

43
src/hal/uart.cpp
View File

@@ -1,43 +0,0 @@
#include <sta/hal/uart.hpp>
#ifdef STA_HAL_UART_ENABLE
#include <sta/assert.hpp>
namespace sta
{
HalUART::HalUART(UART_HandleTypeDef * handle)
: handle_{handle}
{
STA_ASSERT(handle != nullptr);
}
void HalUART::write(const uint8_t * buffer, size_t size)
{
STA_ASSERT(buffer != nullptr);
HAL_UART_Transmit(handle_, const_cast<uint8_t *>(buffer), size, HAL_MAX_DELAY);
}
} // namespace sta
#ifdef STA_HAL_UART_DEBUG_SERIAL
// Get extern declaration for DebugSerial because const namespace level variables have internal linkage by default
#include <sta/debug_serial.hpp>
#include <usart.h>
namespace sta
{
HalUART gHalDebugSerial(&STA_HAL_UART_DEBUG_SERIAL);
// Used by <sta/debug.hpp>
PrintableUART DebugSerial(&gHalDebugSerial);
} // namespace sta
#endif // STA_HAL_UART_DEBUG_SERIAL
#endif // STA_HAL_UART_ENABLE