STM32F4 ADC und USART Interrupt

[Ahmet G. (korkmaz)]

Hallo,

ich beschäftige mich zur Zeit mit dem STM32F407VG und betreibe einen 
ADC, der Werte Analog einließt und diese dann über UART verschickt.

Funktionieren tut das ganze eigentlich ganz gut, jedoch ist ja bekannt 
das das Senden zeitlich über UART um ein vielfaches größer ist als das 
Konvertieren eines Analogwertes.

Nun habe ich das Ganze etwas umgebaut und für den ADC und USART eine 
Interruptroutine verwendet. Ich möchte so vorgehen das der ADC einen 
Wert Puffert, dieser dann über USART versendet wird , in der 
Zwischenzeit des sendens schreibt der ADC den Wert in einen zweiten 
Puffer. Ist der erste Puffer versendet, versendet USART den zweiten und 
der ADC liest in der zwischenzeit einen Wert in Puffer eins wieder ein.

Programmiert habe ich das ganze so:

#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_adc.h"
#include "stm32f4xx_usart.h"
#include "misc.h"


void interruptConfig();
void adcConfig();
void usartConfig();
void ledConfig();


typedef struct{
  uint16_t buffer;
  int lock;
}bufferStruct;

bufferStruct bufferOne;
bufferStruct bufferTwo;


int main(void)
{
  ledConfig();
  usartConfig();
  adcConfig();

  ADC_SoftwareStartConv(ADC3);


  ADC_ITConfig(ADC3, ADC_IT_EOC, ENABLE);
  USART_ITConfig(USART3, USART_IT_TXE, ENABLE);


    while(1)
    {
    }
}

void ADC_IRQHandler()
{
  GPIO_ToggleBits(GPIOD, GPIO_Pin_12);

  if(bufferOne.lock== 0)
  {
    bufferOne.buffer =ADC_GetConversionValue(ADC3);
    bufferOne.lock = 1;
  }
  else if(bufferTwo.lock == 0)
  {
    bufferTwo.buffer = ADC_GetConversionValue(ADC3);
    bufferTwo.lock = 1;
  }
  ADC_ClearFlag(ADC3, ADC_FLAG_EOC);
}


void USART3_IRQHandler()
{
  GPIO_ToggleBits(GPIOD, GPIO_Pin_13);

  if(bufferOne.lock== 1)
  {
    USART_SendData(USART3, (uint8_t) bufferOne.buffer );
    bufferOne.lock = 0;
  }
  else if(bufferTwo.lock == 1)
  {
    USART_SendData(USART3, (uint8_t) bufferTwo.buffer );
    bufferTwo.lock = 0;
  }
  USART_ClearFlag(USART3, USART_IT_TXE);
}




void ledConfig()
{
  GPIO_InitTypeDef led_gpio;

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

  led_gpio.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13;
  led_gpio.GPIO_Mode = GPIO_Mode_OUT;
  led_gpio.GPIO_OType = GPIO_OType_PP;
  led_gpio.GPIO_Speed = GPIO_Speed_50MHz;
  led_gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOD, &led_gpio);
}

void adcConfig()
{
  ADC_InitTypeDef       ADC_InitStructure;
    ADC_CommonInitTypeDef ADC_CommonInitStructure;
    GPIO_InitTypeDef      GPIO_InitStructure;
  NVIC_InitTypeDef    NVIC_adc;


  RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOC, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC3, ENABLE);


  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
  GPIO_Init(GPIOC, &GPIO_InitStructure);


  ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
  ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
  ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
  ADC_CommonInit(&ADC_CommonInitStructure);


  ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
  ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfConversion = 1;
  ADC_Init(ADC3, &ADC_InitStructure);


  ADC_RegularChannelConfig(ADC3, ADC_Channel_12, 1, ADC_SampleTime_3Cycles);

  ADC_Cmd(ADC3, ENABLE);

  NVIC_adc.NVIC_IRQChannel = ADC_IRQn;
  NVIC_adc.NVIC_IRQChannelCmd = ENABLE;
  NVIC_adc.NVIC_IRQChannelPreemptionPriority = 0x0F;
  NVIC_adc.NVIC_IRQChannelSubPriority = 0x01;
  NVIC_Init(&NVIC_adc);

}

void usartConfig()
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_usart;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);

    GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);

    GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);

    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    USART_InitStructure.USART_BaudRate = 11500;
    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_Tx;


    USART_Init(USART3, &USART_InitStructure);


    USART_Cmd(USART3, ENABLE);

    NVIC_usart.NVIC_IRQChannel = USART3_IRQn;
    NVIC_usart.NVIC_IRQChannelCmd= ENABLE;
    NVIC_usart.NVIC_IRQChannelPreemptionPriority = 0x01;
    NVIC_usart.NVIC_IRQChannelSubPriority = 0x01;
    NVIC_Init(&NVIC_usart);
}

Nun habe ich das Problem, wenn ich den Interrupt für den ADC als erstes 
aktiviere komme ich nur noch in die Interrupt Routine des ADC´s aber nie 
in die des USART´s. Ich möchte im Prinzip immer prüfen, das wenn das TX 
Register leer ist das ein Interrupt ausgelöst wird und etwas versendet 
wird, ist wiederum eine Konvertierung des ADC´s fertig so gucke ich ob 
noch ein Puffer frei ist und speichere diesen zwischen.

Was mache ich Falsch?

Gruß.

[Uwe B. (derexponent)]

Hi Ahmet Gee,

>Was mache ich Falsch?

der "USART_IT_TXE"-Interrupt bekommst du, wenn das senden eines Bytes 
per UART fertig ist...du sendest aber nie ein Byte
(das senden passiert ja auch im Interrupt)

versuche mal kurz vor der While(1) einen "Dummy-Wert"
zu senden um damit die ganze Kette anzutriggern

nachtrag...

das ganze wird trotzdem stehenbleiben

weil des senden eines wertes länger dauert
als das wandeln von zwei werten
und dann wird der ADC nicht mehr getriggert
(und in folge dann der UART nicht mehr)

mach das ganze entweder per DMA oder im Injected-Group-Mode
(oder wandle zyklisch und frag ab ob das senden fertig ist)

oder noch eine Möglichkeit :

1. Puffer = Dummy-Wert; // Dummy Wert
   UART = Puffer; // Puffer senden

2. Innerhalb vom UART-Interrupt :
   UART = Puffer;
   Trigger ADC;

3. Innerhalb vom ADC-Interrupt :
   Puffer = ADC;


Gruss Uwe