STM32 -. Usart Interrupt

[peter m. (bastler788)]

Hallo,

ich verwende den Usart3 eines STM32f100RB, daten senden ist kein 
problem, aber das Empfangen.
den Interupt hab ich wie folgt konfiguriert:

// Enable the USART3 RX Interrupt
  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

und die Interruptroutine sieht wie folgt aus:

void USART3_IRQHandler(void)
{
    byte bufferRx[5];
   if(USART_GetITStatus(USART3, USART_IT_RXNE) == RESET)
  {
   USART_ITConfig(USART3, USART_IT_RXNE, DISABLE);
    /* Read one byte from the receive data register */
    bufferRx[0] = USART_ReceiveData(USART3);
    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
  }
 }


Leider wird der Interrupt nicht ausgelöst. kann mir jemand helfen? danke

[Mike R. (thesealion)]

Und wie konfigurierst du die USART? Das verrätst du uns in deinem 
Code-Schnipsel leider nicht.

Ansonsten ist das Disablen des RXNE IRQ auch völlig unnötig. Sieh dir 
doch einfach mal das Beispiel von ST an. Vergleiche das evtl. mit der 
Lib von Peter und dann kannst du das ganze noch mal versuchen.

[Jo D. (Firma: Jo) (discovery)]

Dieser code funktioniert bei mir - vielleicht hilft es dir weiter:
ist allerdings für den Usart1

#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_usart.h"
#include "stm32f10x_tim.h"
#include "misc.h"

GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
USART_InitTypeDef USART_InitStructure;

#define READ_BUFFER_SIZE 20

volatile char read_buffer[READ_BUFFER_SIZE];
volatile char read_buffer_single = 0;
volatile char string_complete = 0;
volatile int uart_str_count = 0;

void Delay(__IO uint32_t nCount)
{
  while(nCount--)
  {
  }
}

void nvic_initialisierung(uint16_t IRQ)
{
       NVIC_InitTypeDef NVIC_InitStructure; //create NVIC structure
         NVIC_InitStructure.NVIC_IRQChannel = IRQ;
         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
         NVIC_Init(&NVIC_InitStructure);
}

void UARTSend(const unsigned char *pucBuffer)
{

    while(*pucBuffer)
    {
        USART_SendData(USART1, (uint16_t) *pucBuffer++);
        /* Loop until the end of transmission */
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
        {
        }
    }
}

void USART_Configuration(void)
{

   // Enable USART1 and GPIOA clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

    /* Configure USART1 Tx (PA.09) as alternate function push-pull */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* Configure USART1 Rx (PA.10) as input floating */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

/* USART1 configuration ------------------------------------------------------*/
  /* USART1 configured as follow:
        - BaudRate = 19200 baud
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - Hardware flow control disabled (RTS and CTS signals)
        - Receive and transmit enabled
        - USART Clock disabled
        - USART CPOL: Clock is active low
        - USART CPHA: Data is captured on the middle
        - USART LastBit: The clock pulse of the last data bit is not output to
                         the SCLK pin
  */
  USART_InitStructure.USART_BaudRate = 19200;
  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;

  USART_Init(USART1, &USART_InitStructure);

  /* Enable the USART1 Receive interrupt: this interrupt is generated when the
     USART1 receive data register is not empty */
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

  /* Enable USART1 */
  USART_Cmd(USART1, ENABLE);
}


void USART1_IRQHandler(void)
{
  if (USART_GetITStatus(USART1,USART_IT_RXNE) == SET)
    {
        USART_ClearITPendingBit(USART1,USART_IT_RXNE);

         // Daten aus dem Puffer lesen
          read_buffer_single = (USART1->DR & (uint16_t)0x01FF);

          if ( string_complete==0 )
               {
                //Bedingungen für ein Ende des Strings
                     if (read_buffer_single!='\n' && read_buffer_single!='\r' && uart_str_count<READ_BUFFER_SIZE-1)
                     {
                       read_buffer[uart_str_count]=read_buffer_single;
                         uart_str_count++;
                     }
                     else
                     {
                       read_buffer[uart_str_count]='\0';
                         uart_str_count=0;
                         string_complete=1;
                     }
               }
    }
}


int main(void)
{

    SystemInit();
    nvic_initialisierung(USART1_IRQn);
    USART_Configuration();

    while(1){
      if (string_complete)
          {
            // Echo des gesendeten Strings erzeugen
            // Achtung der String muss mit '\n' oder '\r' abgeschlossen werden beim Sender
              UARTSend(read_buffer);
              UARTSend("\n\r");
            string_complete = 0;
          }
            }
}

[peter m. (bastler788)]

DANKE  Jo discovery

es hat geklappt, jetzt probier ich des ganze mal mit dem empfang über 
DMA. hast du da auch noch ein beispiel?