DMA UART mit Parity bit

#include <stm32f30x.h>

#include <stm32f30x_gpio.h>

#include <stm32f30x_rcc.h>

#include <stm32f30x_usart.h>

#include <stm32f30x_misc.h>     //for NVIC

#include <core_cm4.h>

#include <stm32f30x_dma.h>

#include <stm32f30x_debug.h>

#define TXnumber 8             USART gesendet werden sollen

#define RXnumber 16            // Anzahl der 8bit Werte die über USART empfangen werden sollen

//###### global variables ########

uint8_t send_buffer[TXnumber] = {0x55, 0x0, 0x55, 0x0, 0x55, 0x0, 0x55, 0x0};    

// prototypes

void RCC_Configuration(void);

void USART3_Configuration();

void DMA_UART3_transmit_Configuration();

void send_with_DMA_UART3(uint8_t buffer[], uint8_t size);

void RCC_Configuration(void)

{   

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);     // Enable peripheral clock for GPIOB for USART3

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);  // Enable peripheral clock for USART3

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);      // Enable peripheral clock for DMA1

}

void USART3_Configuration()

{ 

    gpioConfig.GPIO_Mode = GPIO_Mode_AF;            // Alternate function mode  page: 237

    gpioConfig.GPIO_OType = GPIO_OType_PP;          // Output Push-Pull         page: 237

    gpioConfig.GPIO_Speed = GPIO_Speed_10MHz;       // Medium speed             page: 238

    gpioConfig.GPIO_PuPd = GPIO_PuPd_NOPULL;        // No pull-up, pull down    page: 239

    gpioConfig.GPIO_Pin = (uint32_t)(GPIO_Pin_10 | GPIO_Pin_11);

    GPIO_Init(GPIOB, &gpioConfig);                  // pin initialization

    GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_7);    

    GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_7);    

    USART_InitTypeDef usartConfig;

    RCC->CFGR3   |= RCC_CFGR3_USART3SW_0;         // UART3 clock nun SYSCLK (72MHz)

    usartConfig.USART_BaudRate = 57600;           

    usartConfig.USART_WordLength = USART_WordLength_9b;         // 9th bit = parity bit

    usartConfig.USART_StopBits = USART_StopBits_2;

    usartConfig.USART_Parity = USART_Parity_Even;

    usartConfig.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

    usartConfig.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

    USART_Init(USART3, &usartConfig);

    USART_ClearITPendingBit(USART3, USART_IT_RXNE);                 // Clear interrupt flag

    USART_ClearITPendingBit(USART3, USART_IT_TXE);

    USART_ITConfig(USART3, USART_IT_TXE, DISABLE);                  // disable Transmit Data Register empty interrupt

    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);                  // Enable the USART RX Interrupt (without enabling it, no interrupt will occur when receiving)

    NVIC_EnableIRQ(USART3_IRQn);                                    // Enable USART3 global interrupt

    USART_Cmd(USART3, ENABLE);      // UART3 enable             

}

void DMA_UART3_transmit_Configuration()

{

    // DMA1 Channel 2 - UART3 TX

    DMA_Cmd(DMA1_Channel2, DISABLE);                                    

    DMA_InitTypeDef DMA_InitStruct;

    //DMA_StructInit(&DMA_InitStruct);

    //DMA_InitStruct.DMA_Channel = DMA1_Channel2;

    DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&(USART3->TDR);   

    DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)&send_buffer[0];        // 32-Bit Basis Adresse im Speicher (Adresse der Speicherzelle, wo das erste Byte vorhanden ist).

    DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;                     

    DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;                           

    DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;        

    DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;                

    DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;                          

    DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;       

    DMA_InitStruct.DMA_Priority = DMA_Priority_Low;

    DMA_InitStruct.DMA_BufferSize = 0;                                  

    DMA_Init(DMA1_Channel2, &DMA_InitStruct);

    DMA_ClearFlag(DMA1_FLAG_TE2);

    DMA_ClearFlag(DMA1_FLAG_TC2);

    DMA_ClearFlag(DMA1_FLAG_HT2);

    //DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);                     // Interrupt will occur when Transmission complete (TC)

    //NVIC_EnableIRQ(DMA1_Channel2_IRQn);                               // Enable DMA1 Chan2 global interrupt

    USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);                      // Enable USARTy DMA TX request

    DMA_Cmd(DMA1_Channel2, ENABLE);

}

void send_with_DMA_UART3(uint8_t buffer[], uint8_t size)

{

    // buffer = Array, das gesendet werden soll (ein Element hat 16bit)

    // size = Anzahl der Elemente, die gesendet werden (Größe des Arrays)

    DMA_Cmd(DMA1_Channel2, DISABLE);

    DMA_SetCurrDataCounter(DMA1_Channel2, size);          // Anzahl der Bytes die gesendet werden sollen

    DMA1_Channel2->CMAR = (uint32_t)&(send_buffer[0]);  // Pointer zeigt auf Adresse des ersten Bytes, das gesendet werden soll

    DMA_Cmd(DMA1_Channel2, ENABLE);

} // void send_with_DMA

int main ()

{

    RCC_Configuration();

    USART3_Configuration();

    DMA_UART3_transmit_Configuration();

    RXcounter = 2;

    while(1)

        {

        send_with_DMA_UART3(send_buffer,8);      // 1st parameter: array which should be sent; 2nd parameter: number of the arrays that should be sent

        } //while(1)

} //main