#include <modm/platform/spi/spi_master_2_dma.hpp>

Inheritance diagram for modm::platform::SpiMaster2_Dma< DmaChannelRx, DmaChannelTx >:

Public Typedefs
using	ConfigurationHandler = void (*)()
	The signature of the configuration function.

using	DataSize = Hal::DataSize

using	Hal = SpiHal2

Public Types
enum	DataMode : uint32_t { DataMode::Mode0 = 0b00, DataMode::Mode1 = SPI_CR1_CPHA, DataMode::Mode2 = SPI_CR1_CPOL, DataMode::Mode3 = SPI_CR1_CPOL \| SPI_CR1_CPHA }
	Spi Data Mode, Mode0 is the most common mode. More...

enum	DataMode : uint8_t { DataMode::Mode0 = 0b00, DataMode::Mode1 = 0b01, DataMode::Mode2 = 0b10, DataMode::Mode3 = 0b11 }
	Spi Data Mode, Mode0 is the most common mode. More...

enum	DataOrder : uint32_t { MsbFirst = 0b0, LsbFirst = SPI_CR1_LSBFIRST }
	Spi Data Order, MsbFirst is the most common mode.

enum	DataOrder : uint8_t { MsbFirst = 0b0, LsbFirst = 0b1 }
	Spi Data Order, MsbFirst is the most common mode.

Static Public Member Functions
template<class SystemClock , baudrate_t baudrate, percent_t tolerance = pct(5)>
static void	initialize ()

static uint8_t	transferBlocking (uint8_t data)

static void	transferBlocking (const uint8_t tx, uint8_t rx, std::size_t length)

static modm::ResumableResult< uint8_t >	transfer (uint8_t data)

static modm::ResumableResult< void >	transfer (const uint8_t tx, uint8_t rx, std::size_t length)

static void	acknowledgeInterruptFlag ()

static uint8_t	acquire (void *ctx, ConfigurationHandler handler=nullptr)

static uint8_t	acquire (void *ctx, Spi::ConfigurationHandler handler)

template<uint64_t available, uint64_t requested, percent_t tolerance>
static void	assertBaudrateInTolerance ()

template<double available, double requested, percent_t tolerance>
static void	assertDurationInTolerance ()

static void	configurePurpose ()
	configures a peripheral for a specific purpose

template<class... Signals>
static void	connect ()

template<class... Signals>
static void	connect ()

static bool	getInterruptFlag ()
	Read an interrupt flag.

static void	getParameter ()
	returns a parameter

template<class SystemClock , baudrate_t baudrate, percent_t tolerance = 5_pct>
static void	initialize ()

static void	initialize ()
	initializes the peripheral, must be called before use.

static uint8_t	release (void *ctx)

static uint8_t	release (void *ctx)

static void	setDataMode (DataMode mode)

static void	setDataMode (DataMode mode)
	Sets a new data mode.

static void	setDataOrder (DataOrder order)

static void	setDataOrder (DataOrder order)
	Sets a new data order.

static void	setDataSize (DataSize size)

static void	setParameter ()
	sets a parameter

static modm::ResumableResult< uint8_t >	transfer (uint8_t data)

static modm::ResumableResult< void >	transfer (const uint8_t tx, uint8_t rx, std::size_t length)

Static Protected Attributes
static uint8_t	state {0}

Detailed Description

template<class DmaChannelRx, class DmaChannelTx>
class modm::platform::SpiMaster2_Dma< DmaChannelRx, DmaChannelTx >

Serial peripheral interface (SPI2) with DMA support.

This class uses the DMA controller for sending and receiving data, which greatly reduces the CPU load. Beside passing the DMA channels as template parameters the class can be used in the same way like the SpiMaster2.

Template Parameters

DmaChannelRX	DMA channel for receiving
DmaChannelTX	DMA channel for sending

Author: Mike Wolfram

Member Enumeration Documentation

enum modm::Spi::DataMode : uint8_t

inheritedstrong

Spi Data Mode, Mode0 is the most common mode.

Enum Values	Documentation
Mode0	clock normal, sample on rising edge
Mode1	clock normal, sample on falling edge
Mode2	clock inverted, sample on falling edge
Mode3	clock inverted, sample on rising edge

enum modm::platform::SpiMaster2::DataMode : uint32_t

inheritedstrong

Spi Data Mode, Mode0 is the most common mode.

Enum Values	Documentation
Mode0	clock normal, sample on rising edge
Mode1	clock normal, sample on falling edge
Mode2	clock inverted, sample on falling edge
Mode3	clock inverted, sample on rising edge

Member Function Documentation

static void modm::PeripheralDriver::acknowledgeInterruptFlag ( )

inheritedstatic

Acknowledge an interrupt flag.

We use acknowledge here, since it describes the intention rather than the actual implementation.

static uint8_t modm::SpiMaster::acquire	(	void *	ctx,
		ConfigurationHandler	handler = `nullptr`
	)

inheritedstatic

Request access to the SPI master within a context. You may acquire the SPI master multiple times within the same context.

The configuration handler will only be called when acquiring the SPI master for the first time (if it is not a nullptr).

Warning: Acquires must be balanced with releases of the same context!; Acquires are persistent even after calling initialize()!

Returns: 0 if another context is using the SPI master, otherwise >0 as the number of times this context acquired the master.

template<uint64_t available, uint64_t requested, percent_t tolerance>

static void modm::PeripheralDriver::assertBaudrateInTolerance ( )

inheritedinlinestatic

Since baudrates are usually generated by prescaling a system clock, only several distinct values can be generated. This method checks if the user requested baudrate is within error tolerance of the system achievable baudrate.

template<class... Signals>

static void modm::SpiMaster::connect ( )

inheritedstatic

Connect GPIOs to the peripheral and configure them.

This configures the Sck, Mosi and Miso signals and connects them.

Template Parameters

Signals One Scl and one Mosi signal are required (one Miso signal is optional) and can be passed out-of-order.

template<class DmaChannelRx , class DmaChannelTx >

template<class SystemClock , baudrate_t baudrate, percent_t tolerance = pct(5)>

static void modm::platform::SpiMaster2_Dma< DmaChannelRx, DmaChannelTx >::initialize ( )

static

Initialize DMA and SPI2

template<class SystemClock , baudrate_t baudrate, percent_t tolerance = 5_pct>

static void modm::SpiMaster::initialize ( )

inheritedstatic

Initializes the hardware and sets the baudrate.

Template Parameters

SystemClock	the currently active system clock
baudrate	the desired baudrate in Hz
tolerance	the allowed relative tolerance for the resulting baudrate

static uint8_t modm::SpiMaster::release ( void * ctx )

inheritedstatic

Release access to the SPI master within a context.

Warning: Releases must be balanced with acquires of the same context!; Releases are persistent even after calling initialize()!

Returns: 0 if nothing can be released anymore (for any context) >0 as the number of times this context can still release the master.

static modm::ResumableResult<void> modm::SpiMaster::transfer	(	const uint8_t *	tx,
		uint8_t *	rx,
		std::size_t	length
	)

inheritedstatic

Set the data buffers and length with options and starts a non-blocking transfer. This may be hardware accelerated (DMA or Interrupt), but not guaranteed.

Warning: You must ensure that only one driver is accessing this resumable function by using acquire(ctx) and release(ctx).

Parameters

[in]	tx	pointer to transmit buffer, set to `nullptr` to send dummy bytes
[out]	rx	pointer to receive buffer, set to `nullptr` to discard received bytes
	length	number of bytes to be shifted out

static modm::ResumableResult<uint8_t> modm::SpiMaster::transfer ( uint8_t data )

inheritedstatic

Swap a single byte and wait for completion non-blocking!.

Warning: You must ensure that only one driver is accessing this resumable function by using acquire(ctx) and release(ctx).

Parameters

data	data to be sent

Returns: received data

The documentation for this class was generated from the following file:

spi_master_2_dma.hpp

Public Typedefs

Public Types

Static Public Member Functions

Static Protected Attributes

Detailed Description

template<class DmaChannelRx, class DmaChannelTx> class modm::platform::SpiMaster2_Dma< DmaChannelRx, DmaChannelTx >

Member Enumeration Documentation

Member Function Documentation

template<class DmaChannelRx, class DmaChannelTx>
class modm::platform::SpiMaster2_Dma< DmaChannelRx, DmaChannelTx >