DMA UART mit Parity bit

[har (Gast)]

Hallo Forum,

zu allererst: Ich verwende einen STM32F303!
Ich möchte 8-bit-Werte, welche im Array "send_buffer" vorhanden sind 
über UART und DMA schicken. Wenn ich in der UART-Konfiguration folgende 
Einstellungen durchführe: Wort-Länge = 8 und kein Parity-Bit soll 
gesendet werden, dann werden alle 8 Elemente im Array korrekt gesendet.

Ich möchte allerdings ein Parity Bit dabei haben (Even). Das heißt, ich 
stelle in der Einstellung die Wort-Länge auf 9 bzw. Parity-Bit = Even 
ein.
Nun habe ich das Problem, dass jede zweite Element vom Array NICHT 
gesendet wird und die letzten 4 gesendete Werte sind "irgendwelche" 
Werte. (mit Oszi angesehen)

Weiß jemand, welche Einstellung fehlt?

Der Code sieht wie folgt aus:

#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

[da1l6 (Gast)]

Hallo

Das Parity Bit zählt nicht zur Wortlänge.

Also so:

usartConfig.USART_WordLength = USART_WordLength_8b; //8 data bits
usartConfig.USART_StopBits = USART_StopBits_2;
usartConfig.USART_Parity = USART_Parity_Even;

da1l6

[har (Gast)]

da1l6 schrieb:
> Das Parity Bit zählt nicht zur Wortlänge.

Hallo, danke für deine Antwort!

Doch das zählt! Habs ausprobiert und im Datenblatt steht es auch! siehe 
Anhang...