Comunicazione USART con STM32f1xx

Question

Provo a raggiungere una comunicazione USART. Quindi collego l'RX del mio STM32f1 con il suo TX. Inoltre scrivo un programma per questa comunicazione. Questo codice è composto dai seguenti componenti:

1. configurazione RCC
2. configurazione GPIO
3. configurazione USART
4. trasmissione e ricezione di una stringa
5. Confronto tra la stringa inviata e la stringa ricevuta
6. Test se la comunicazione è riuscita => LED4 accendi altrimenti il ​​LED3 si accende

Il problema è in tutti i casi in cui il LED3 si accende. Significa che la trasmissione dei dati non è andata a buon fine.

Con il mio IDE (Embedded Workbench di IAR) compilo il codice del programma:

/* Includes ------------------------------------------------------------------*/ 
#include "stm32f10x.h" 
#include "stm32_eval.h" 


/* Private typedef -----------------------------------------------------------*/ 
typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus; 

/* Private define ------------------------------------------------------------*/ 
#define USARTy     USART1 
#define USARTy_GPIO    GPIOA /* PORT name*/ 
#define USARTy_CLK    RCC_APB2Periph_USART1 
#define USARTy_GPIO_CLK   RCC_APB2Periph_GPIOA 
#define USARTy_RxPin    GPIO_Pin_10/* pin Rx name*/ 
#define USARTy_TxPin    GPIO_Pin_9 /* pin Tx name*/ 

#define USARTz     USART2 
#define USARTz_GPIO    GPIOA/* PORT name*/ 
#define USARTz_CLK    RCC_APB1Periph_USART2 
#define USARTz_GPIO_CLK   RCC_APB2Periph_GPIOA 
#define USARTz_RxPin    GPIO_Pin_3/* pin Rx name*/ 
#define USARTz_TxPin    GPIO_Pin_2/* pin Tx name*/ 

#define TxBufferSize (countof(TxBuffer)) 

/* Private macro -------------------------------------------------------------*/ 
#define countof(a) (sizeof(a)/sizeof(*(a))) 

/* Private variables ---------------------------------------------------------*/ 
USART_InitTypeDef USART_InitStructure; 
uint8_t TxBuffer[] = "Bufferrr"; 
uint8_t RxBuffer[8]; 
__IO uint8_t TxConteur = 0, RxConteur = 0; 
volatile TestStatus TransferStatus = FAILED; 

/* Private function prototypes -----------------------------------------------*/ 
void RCC_Configuration(void); 
void GPIO_Configuration(void); 
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength); 
__IO uint8_t index = 0; 

GPIO_InitTypeDef GPIO_InitStructure; 

int main(void) 
{ 
    STM_EVAL_LEDInit(LED1); 
    STM_EVAL_LEDInit(LED2); 
    STM_EVAL_LEDInit(LED3); 
    STM_EVAL_LEDInit(LED4); 

/* System Clocks Configuration */ 
RCC_Configuration(); 
/* Configure the GPIO ports */ 
GPIO_Configuration(); 

USART_InitStructure.USART_BaudRate = 230400 /*115200*/; 
    USART_InitStructure.USART_WordLength =USART_WordLength_8b ; 
    USART_InitStructure.USART_StopBits = USART_StopBits_1; 
    USART_InitStructure.USART_Parity = USART_Parity_No; 
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; 
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; 

    /* Configure USARTy */ 
    USART_Init(USART1,&USART_InitStructure); 

    /* Enable the USARTy */ 
    USART_Cmd(USART1,ENABLE); 

    while(TxConteur < TxBufferSize) 
    { 
    /* Send one byte from USARTy to USARTz */ 
    USART_SendData(USARTy, TxBuffer[TxConteur++]); 
    /* Loop until USARTy DR register is empty */ 
    while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) 
    { 
    } 
    /* Store the received byte in RxBuffer */ 
    RxBuffer[RxConteur++] = USART_ReceiveData(USARTy) & 0xFF; 
    } 

    /* Check the received data with the send ones */ 
    TransferStatus = Buffercmp(TxBuffer, RxBuffer, TxBufferSize); 
    /* TransferStatus = FAILED, if the data transmitted from USARTy and 
    received by USARTz are different */ 
    if (TransferStatus == FAILED) 
    { 
     STM_EVAL_LEDOn(LED3); 

    } 
    else 
    { 

    STM_EVAL_LEDOn(LED4); 
    } 

    while (1) 
    { 
    } 
} 

void RCC_Configuration(void) 
{  

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE); 

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE); 
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE); 
} 

void GPIO_Configuration(void) 
{ 
    GPIO_InitTypeDef GPIO_InitStructure1,GPIO_InitStructure2; 

    /* Configure USARTy Rx as input floating */ 
    GPIO_InitStructure1.GPIO_Pin =GPIO_Pin_10; 
    GPIO_InitStructure1.GPIO_Speed = GPIO_Speed_50MHz; 
    GPIO_InitStructure1.GPIO_Mode = GPIO_Mode_IN_FLOATING; 
    GPIO_Init(GPIOA, &GPIO_InitStructure1); 

    /* Configure USARTy Tx as alternate function push-pull */ 
    GPIO_InitStructure2.GPIO_Pin =GPIO_Pin_9; 
    GPIO_InitStructure2.GPIO_Speed = GPIO_Speed_50MHz; 
    GPIO_InitStructure2.GPIO_Mode = GPIO_Mode_AF_PP; 
    GPIO_Init(GPIOA, &GPIO_InitStructure2); 
    /* Configure USARTz Tx as alternate function push-pull */ 


} 


TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength) 
{ 
    while(BufferLength--) 
    { 
    if(*pBuffer1 != *pBuffer2) 
    { 
     return FAILED; 
    } 

    pBuffer1++; 
    pBuffer2++; 
    } 

    return PASSED; 
} 

Answer 1

Come spiegato in un commento di Hans Passant, l'OP stava testando la bandiera USART_FLAG_TC (Transmission Completato) al posto della bandiera USART_FLAG_RXNE (Buffer RX non vuoto).