sta-core/src/hal/spi.cpp

#include <sta/hal/spi.hpp>

#ifdef STA_HAL_SPI_ENABLE


namespace sta
{
	HalSpiInterface::HalSpiInterface(SPI_HandleTypeDef * handle, Mutex * mutex /* = nullptr */)
		: SpiInterface(mutex), handle_{handle}
	{}


	void HalSpiInterface::transfer(uint8_t data)
	{
		HAL_SPI_Transmit(handle_, &data, 1, HAL_MAX_DELAY);
	}

	void HalSpiInterface::transfer(const uint8_t * buffer, size_t size)
	{
		HAL_SPI_Transmit(handle_, const_cast<uint8_t *>(buffer), size, HAL_MAX_DELAY);
	}

	void HalSpiInterface::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
	{
		HAL_SPI_TransmitReceive(handle_, const_cast<uint8_t *>(txBuffer), rxBuffer, size, HAL_MAX_DELAY);
	}


	void HalSpiInterface::transfer16(uint16_t value)
	{
		static_assert(sizeof(uint16_t) == 2);

		HAL_SPI_Transmit(handle_, reinterpret_cast<uint8_t *>(&value), 2, HAL_MAX_DELAY);
	}


	void HalSpiInterface::fill(uint8_t value, size_t count)
	{
		for (size_t i = 0; i < count; ++i)
		{
			transfer(value);
		}
	}

	void HalSpiInterface::fill32(uint32_t value, size_t count)
	{
		static_assert(sizeof(uint32_t) == 4);

		for (size_t i = 0; i < count; ++i)
		{
			HAL_SPI_Transmit(handle_, reinterpret_cast<uint8_t *>(&value), 4, HAL_MAX_DELAY);
		}
	}


	void HalSpiInterface::receive(uint8_t * data, size_t size)
	{
		HAL_SPI_Receive(handle_, data, size, HAL_MAX_DELAY);
	}



	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