Arduino for STM32

Code: Select all

#include "stm32f4xx_hal.h"

class SPI_DMA {
public:
    SPI_DMA(SPI_HandleTypeDef* spiHandle, DMA_HandleTypeDef* dmaTxHandle, DMA_HandleTypeDef* dmaRxHandle)
        : hspi(spiHandle), hdma_tx(dmaTxHandle), hdma_rx(dmaRxHandle) {}

    void init() {
        // Initialize the SPI peripheral
        initSPI();

        // Initialize the DMA for TX
        initDMA();

        // Initialize the NVIC for DMA
        initNVIC();
    }

    void transmit(uint8_t* data, uint16_t size) {
        HAL_SPI_Transmit_DMA(hspi, data, size);
    }

    void receive(uint8_t* data, uint16_t size) {
        HAL_SPI_Receive_DMA(hspi, data, size);
    }

    void transmitReceive(uint8_t* txData, uint8_t* rxData, uint16_t size) {
        HAL_SPI_TransmitReceive_DMA(hspi, txData, rxData, size);
    }

private:
    SPI_HandleTypeDef* hspi;
    DMA_HandleTypeDef* hdma_tx;
    DMA_HandleTypeDef* hdma_rx;

    void initSPI() {
        hspi->Instance = SPI1;
        hspi->Init.Mode = SPI_MODE_MASTER;
        hspi->Init.Direction = SPI_DIRECTION_2LINES;
        hspi->Init.DataSize = SPI_DATASIZE_8BIT;
        hspi->Init.CLKPolarity = SPI_POLARITY_LOW;
        hspi->Init.CLKPhase = SPI_PHASE_1EDGE;
        hspi->Init.NSS = SPI_NSS_SOFT;
        hspi->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
        hspi->Init.FirstBit = SPI_FIRSTBIT_MSB;
        hspi->Init.TIMode = SPI_TIMODE_DISABLE;
        hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
        hspi->Init.CRCPolynomial = 10;

        if (HAL_SPI_Init(hspi) != HAL_OK) {
            // Initialization Error
            Error_Handler();
        }
    }

    void initDMA() {
        // Initialize DMA for TX
        hdma_tx->Instance = DMA2_Stream3;
        hdma_tx->Init.Channel = DMA_CHANNEL_3;
        hdma_tx->Init.Direction = DMA_MEMORY_TO_PERIPH;
        hdma_tx->Init.PeriphInc = DMA_PINC_DISABLE;
        hdma_tx->Init.MemInc = DMA_MINC_ENABLE;
        hdma_tx->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
        hdma_tx->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
        hdma_tx->Init.Mode = DMA_NORMAL;
        hdma_tx->Init.Priority = DMA_PRIORITY_LOW;
        hdma_tx->Init.FIFOMode = DMA_FIFOMODE_DISABLE;

        if (HAL_DMA_Init(hdma_tx) != HAL_OK) {
            // Initialization Error
            Error_Handler();
        }

        __HAL_LINKDMA(hspi, hdmatx, *hdma_tx);

        // Initialize DMA for RX
        hdma_rx->Instance = DMA2_Stream0;
        hdma_rx->Init.Channel = DMA_CHANNEL_3;
        hdma_rx->Init.Direction = DMA_PERIPH_TO_MEMORY;
        hdma_rx->Init.PeriphInc = DMA_PINC_DISABLE;
        hdma_rx->Init.MemInc = DMA_MINC_ENABLE;
        hdma_rx->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
        hdma_rx->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
        hdma_rx->Init.Mode = DMA_NORMAL;
        hdma_rx->Init.Priority = DMA_PRIORITY_HIGH;
        hdma_rx->Init.FIFOMode = DMA_FIFOMODE_DISABLE;

        if (HAL_DMA_Init(hdma_rx) != HAL_OK) {
            // Initialization Error
            Error_Handler();
        }

        __HAL_LINKDMA(hspi, hdmarx, *hdma_rx);
    }

    void initNVIC() {
        // Configure NVIC for DMA
        HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);

        HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
    }

    void Error_Handler() {
        // User can add their own implementation to report the HAL error return state
        while(1) {
        }
    }
};

// Example usage
SPI_HandleTypeDef hspi1;
DMA_HandleTypeDef hdma_spi1_tx;
DMA_HandleTypeDef hdma_spi1_rx;

SPI_DMA spi1(&hspi1, &hdma_spi1_tx, &hdma_spi1_rx);

void SystemClock_Config();

int main() {
    // Initialize the HAL Library
    HAL_Init();

    // Configure the system clock
    SystemClock_Config();

    // Initialize SPI, DMA, and NVIC
    spi1.init();

    // Transmit and receive data
    uint8_t txData[] = {0x01, 0x02, 0x03};
    uint8_t rxData[3];
    spi1.transmitReceive(txData, rxData, sizeof(txData));

    while (1) {
        // Main loop
    }
}

Code: Select all

<Mode Name="DMA1_Channel5">
                    <ModeLogicOperator Name="XOR">
                        <Mode Name="MEMTOMEM"/>
                        <Mode Name="SPI2_TX">
                            <Condition Diagnostic="" Expression="SPI2_DmaTransmit|I2S2_TX"/>
                        </Mode>
                        <Mode Name="USART1_RX">
                            <Condition Diagnostic="" Expression="S_USART1_TX_RX|S_USART1_RX"/>
                        </Mode>
                        <Mode Name="I2C2_RX">
                            <Condition Diagnostic="" Expression="I2C2_Dma"/>
                        </Mode>
                        <Mode Name="TIM1_UP"/>
                        <Mode Name="TIM2_CH1">
                            <Condition Diagnostic="" Expression="Semaphore_CaptureCompare_1_DMA_EnableTIM2"/>
                        </Mode>
                        <Mode Name="TIM4_CH3">
                            <Condition Diagnostic="" Expression="Semaphore_CaptureCompare_3_DMA_EnableTIM4"/>
                        </Mode>
                    </ModeLogicOperator>
                </Mode>

Code: Select all

SPIClass spi = SPI_DMA(init_parameters);

#define BUFSIZE 256
uint8_t rx_buf{BUFSIZE];
uint8_t tx_buf{BUFSIZE];

void setup() {
	spi.begin();
	memset(tx_buf,0); 
};

void loop() {
	spi.transfer(tx_buf, rx_buf, BUFSIZE);
	// copy received stuff back to tx buff
	memcpy(tx_buf, rx_buf, BUFSIZE);
}

Code: Select all

    /* Expand SPI API
     * https://github.com/arduino/ArduinoCore-API/discussions/189
     */
    void transfer(const void *tx_buf, void *rx_buf, size_t count);

Code: Select all

#include "SPIDMA_F4XX.h" /* !!!! */

SPIClass spi1 = SPI_DMAF4_SPI1( ... parameters);
SPIClass spi2 = SPI_DMAF4_SPI2( ... parameters);

void setup() {
	spi1.begin();
	spi2.begin();
}

void loop() {
	uint8_t a = 1, b = 2;
	spi1.transfer(a);
	spi2.transfer(b);
}

Code: Select all

inline void SPI_DMA::transfer_async(const void *tx_buf, void *rx_buf, size_t count) {
	HAL_SPI_DMAResume(&_spi.handle);
	HAL_SPI_TransmitReceive_DMA(&_spi.handle, (uint8_t*) tx_buf, (uint8_t*) rx_buf, count);
}

Code: Select all

#if defined(STM32F4XX)

#include "SPIDMA_F4XX.h"
SPIClass SPI = SPI_DMAF4(parameters);

#elif defined(STM32F1XX)
...
#endif

Code: Select all

if ( spi == SPI1 ) {
// do this
} else if ( spi == SPI2 ) {
// do that
} else ...

Code: Select all

typedef class SPI_DMAF4 SPI_DMAF4_SPI1;

SPIClass myspi = SPI_DMAF4_SPI1( ... parameters);