www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik STM32 Interrupts


Autor: Peter K. (mikro1111)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Ulf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Peter K. (mikro1111)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ja die habe ich implementiert. bräuchte ein bischen beispielcode

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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);
    }    
  }
}

Autor: Peter K. (mikro1111)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Gebhard Raich (geb)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hab das mit einer Uart Struktur mit Lese und Schreib-pointern gelöst.

Grüße

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.