STM32 Interrupts

[Peter K. (mikro1111)]

Ich möchte eine AD-Wandlung durchführen. Die gelesenen Daten sollen dann 
via USART2 an den PC übertragen werden. Das langsamste an dem ganzen 
system ist ja der USART und deshalb möchte ich einen Interrupt einbauen, 
dass immer wenn dieser mit einer übertragung fertig ist die nächste 
gestartet werden kann. Übertragen werden soll mein kleines Protokoll.

USART_ITConfig function(USART2, USART_IT_TC, ENABLE);

Dies sollte die Interrupt Konfiguration sein. Aber wie nutzt man das nun 
genau.

Im Anhang befindet sich mein aktueller Quellcode.

Vielen dank schonmal

[Ulf (Gast)]

Du musst die STM LIB für die STM32 einbinden, oder alles auf SFR-Ebene 
selber umsetzen ---> Datenblatt/Usermanual lesen. LIB findest Du auf den 
STM Seiten zum Download. Version 3.3.0 ist glaub ich die aktuelle. Ist 
auche eine Hilfedatei bei.

[Peter K. (mikro1111)]

ja die habe ich implementiert. bräuchte ein bischen beispielcode

[Mehmet K. (mkmk)]

Bin zwar auch nur ein blutiger STM32-Anfaenger, aber USART-Interrupt 
habe ich auf meiner ToDo-Liste schon mal abgehakt :)

Die Initialisierung:

//*********************************
// MyUsart_1
//*********************************
MyUsart_1::MyUsart_1( void )
{

  USART_InitTypeDef  USART_InitStructure;
  GPIO_InitTypeDef   GPIO_InitStructure;
  NVIC_InitTypeDef   NVIC_InitStructure;

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

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

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

  USART_InitStructure.USART_BaudRate = 9600;
  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 the USART */
  USART_Init(USART1, &USART_InitStructure);

 
  USART_Cmd(USART1, ENABLE);  /* Enable the USART */
  //USART_ITConfig(USART1, USART_IT_TXE, ENABLE);  // enable intterupt

  /* Enable the USARTy Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel            = USART1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd         = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

Der Interrupt Handler:

//=============================================
// USART1_IRQHandler
//=============================================
void USART1_IRQHandler(void)
{
  if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
  {
    /* Read one byte from the receive data register */
    RxBuffer1[RxCounter1++] = USART_ReceiveData(USART1);

    if(RxCounter1 == NbrOfDataToRead1)
    {
      /* Disable the USARTy Receive interrupt */
      USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    }
  }
  
  if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
  {   
    /* Write one byte to the transmit data register */
    USART_SendData(USART1, TxBuffer1[TxCounter1++]);

    if(TxCounter1 == NbrOfDataToTransfer1)
    {
      /* Disable the USART1 Transmit interrupt */
      USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
    }    
  }
}

[Peter K. (mikro1111)]

In ähnlicher weise habe ich es auch implementiert. verstehe aber den 
ablauf noch nicht so ganz.

bei mir sollen immer 4 bytes nacheinander übertragen werden. bis jetzt 
hatte ich es einfach immer in einer while schleife. verstehe noch nicht 
wie das mit dem interrupt genau geht.

es soll nach möglichkeit gleich nach abschluss der übertragung eines 
bytes das nächste übertragen werden

[Gebhard R. (Firma: Raich Gerätebau & Entwicklung) (geb)]

Hab das mit einer Uart Struktur mit Lese und Schreib-pointern gelöst.

Grüße