STM32F3 ADC (ohne STD-Lib)

[Daniel F. (franky55555)]

Hi,
ich versuche mich gerade an einer Programmierung eines ADCs für das 
STM32F3. Soweit habe ich dies auch geschafft, jedoch funktioniert es 
nicht wie erwartet ^^ Mein Problem:
Der Code bleibt in dieser Zeile stecken:

while((ADC3->ISR & ADC_ISR_EOC)==0);// wait until conversion is complete

Hat irgendjemand eine Idee, warum dies passiert?
Ich möchte aber nicht auf die STD-Lib umsteigen, sondern auf 
Registerebene bleiben.

LG


Hier ist der gesamte Code:

/* Includes */
#include "stm32f30x.h"
#include "GPIO.h"
#include "clock.h"

uint32_t timerFlag=0;
uint16_t value=0;


int main(void)
{
  GPIO_CLKconfig();
  clock_config();
  //-----ADC_GPIO
  GPIOB->MODER |= GPIO_MODER_MODER1_1;
  GPIOB->MODER |= GPIO_MODER_MODER1_0; // Analoge MODE
  /* Analog mode 11
  *   Alternate   10
  *  GPIO     01
  *   Input       00
  */

 // GPIOB -> OSPEEDR |=  GPIO_OSPEEDER_OSPEEDR1_1| GPIO_OSPEEDER_OSPEEDR1_0;// 50 MHZ GPIO
  //------------

  //----LED_GPIO
  GPIOE->MODER |=GPIO_MODER_MODER8_0; // GPIO MODE
  GPIOE->MODER &=~GPIO_MODER_MODER8_1;

  /* Analog mode 11
  *   Alternate   10
  *  GPIO     01
  *   Input       00
  */

  GPIOE -> OSPEEDR |=  GPIO_OSPEEDER_OSPEEDR8_1| GPIO_OSPEEDER_OSPEEDR8_0;// 50 MHZ GPIO

  GPIOE->MODER |=GPIO_MODER_MODER9_0;
  GPIOE -> OSPEEDR |=  GPIO_OSPEEDER_OSPEEDR9_1| GPIO_OSPEEDER_OSPEEDR9_0;
  //--------


  // ADC init
  RCC -> AHBENR |= RCC_AHBENR_ADC34EN; //CLockenable for ADC 3 und 4
  ADC3 -> CR &= ~ ADC_CR_ADEN; //disable AD
  /*calibration*/
  ADC3 -> CR &=~ADC_CR_ADCALDIF;
  ADC3 -> CR |=(1<<28);// voltage regulator 01
       //voltage regulator
  ADC3 -> CR |= ADC_CR_ADCAL;     //starting calibration

  while((ADC3->CR & ADC_CR_ADCAL)==0); //wait until calibration is ready
  /*end calibration*/




  ADC3 -> CR |= ADC_CR_ADEN; //enable AD
  while((ADC3 -> ISR & ADC_ISR_ADRD)==1);//
  
  /*conversion and channel selection*/
  ADC3-> SQR1 = 0;
  ADC3-> SQR1 |=ADC_SQR1_SQ1_0; //channel 1
  ADC3-> CFGR &= ~ADC_CFGR_RES;
  ADC3-> CFGR |= ADC_CFGR_RES_0; // 10 bit resolution
  /*
   * 00 => 12 bit
   * 01 => 10 bit
   * 10 => 8 bit
   * 11 => 6 bit
   */
  while(1)
  {
  ADC3-> SMPR1 |= ADC_SMPR1_SMP1_2; //sampling time to 19.5 clock cycles
  //SMPR1....for channel 1
  ADC3-> CFGR &= ~ADC_CFGR_CONT;
  ADC3-> CR |= ADC_CR_ADSTART; // ADC start
  while((ADC3->ISR & ADC_ISR_EOC)==0);// wait until conversion is complete
  GPIOE-> BSRR = GPIO_Pin_9;

  value=ADC_DR_RDATA;        //get value of the ADC
  ADC3-> CR |= ADC_CR_ADSTP;    // stop conversion

  if(value>=512)
  {
  GPIOE-> BRR = GPIO_Pin_8;   // low
  }
  else
  {
  GPIOE-> BSRR = GPIO_Pin_8;   //high
  }

  }
  
  return 0;
}

Hier sind noch die oben eingebunden Bibliotheken:

#include "clock.h"
void clock_config(void)
{
  /*
   * ================================================================================
   * Initializing of PLL for using a higher internal clock-speed (64MHz)
   * ================================================================================
   */
  /* Enable Prefetch Buffer and set Flash Latency */
  /*These bits represent the ratio of the SYSCLK (system clock) period to the Flash
  access time. */
  /*Siehe RM0316 Seite 62 */
  FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY_1;

  /*configure prescaler */
  RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1 | //HCLK = SYSCLK
         (uint32_t)RCC_CFGR_PPRE1_DIV2 | // prescaler APB1 = 2
         (uint32_t)RCC_CFGR_PPRE2_DIV1; // prescaler APB2 =2

  /* PLL configuration */
  RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL));//clear register
  RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSI_Div2 | //PLL gets HSI/2
              RCC_CFGR_PLLMULL16); //PLL-factor is 16 => 64MHz

  RCC->CR |= RCC_CR_PLLON; /* Enable PLL */
  while((RCC->CR & RCC_CR_PLLRDY) == 0);/* Wait till PLL is ready */

  /* Select PLL as system clock source */
  RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));//clear register
  RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
  /* Wait till PLL is used as system clock source */
  while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_PLL);
}

zweite Bibliothek:

#include "GPIO.h"
void GPIO_CLKconfig()
{
  RCC -> AHBENR |= RCC_AHBENR_GPIOAEN | //enable clock for GPIOA
           RCC_AHBENR_GPIOBEN | //enable clock for GPIOB
           RCC_AHBENR_GPIOCEN | //enable clock for GPIOC
           RCC_AHBENR_GPIODEN | //enable clock for GPIOD
           RCC_AHBENR_GPIOEEN | //enable clock for GPIOE
           RCC_AHBENR_GPIOFEN ; //enable clock for GPIOF
}

[Kindergärtner (Gast)]

Du hast den Interrupt überhaupt nicht eingeschaltet:

ADC3->IER |= ADC_IER_EOC;

[Daniel F. (franky55555)]

Aber wird nicht die End of Conversion - Flag trotzdem gesetzt?
Weil ich ja nur die abfrage, und nicht auf den Interrupt reagiere.

[Kindergärtner (Gast)]

Daniel Frank schrieb:
> Aber wird nicht die End of Conversion - Flag trotzdem gesetzt?
Die Doku schweigt dazu, aber bei vielen STM32-Peripherieeinheiten muss 
der Interrupt (im jeweiligen _IER) eingeschaltet sein, damit das 
Interruptflag (im _ISR) gesetzt wird; daher verhält es sich beim 
STM32F30x-ADC vermutlich genau so.
> Weil ich ja nur die abfrage, und nicht auf den Interrupt reagiere.
Doch, im ISR stehen Interrupt-Flags. Es wird lediglich keine ISR 
aufgerufen; dazu müsstest du den IRQ erst im Core über NVIC_* Funktionen 
aktivieren.

[Daniel F. (franky55555)]

Ich habe die Codezeile hinzugefügt, jedoch hat sich an der Situation 
nichts geändert. Der Code bleibt weiterhin an dieser Stelle hängen...

Könnte ich noch etwas vergessen haben?

LG

[Christopher B. (chrimbo)]

Hi, warum nimmst du nicht einfach das EOC-Flag im SR-Register?

while((ADC3->SR & ADC_SR_EOC)==0);// wait until conversion is complete

gruß
Christopher

[Daniel F. (franky55555)]

Hi Christopher

diese Codezeile schluckt der Compiler nicht, da er dieses Register im 
Zusammenhang mit dem ADC nicht kennt.

LG

[Christopher B. (chrimbo) (Gast)]

Hallo Daniel,

ups, sorry. Hab ins falsche RefMan geschaut.
Sonst seh ich leider keinen Fehler, der Interrupt muss für das Flag 
nicht eingschaltet sein, zumindest steht da kein besonderer Hinweis zu.

lg

[Daniel F. (franky55555)]

Ich habe es geschafft die Fehlerquelle einzugrenzen.
Ich versuchte die vorgefertigte Funktion für das Abfragen des EOC-Flags 
zu verwenden und bemerkte, dass es nie zu dem Ende der Konvertierung 
kommt.
Das heißt es muss irgendein Fehler in der Initialisierung des gesamten 
ADCs sein.

Daher nochmal meine Frage: hat jemand eine Idee, was das Problem sein 
könnte?

MfG

[Kindergärtner (Gast)]

Nimm den Beispielcode von ST mit Standard Periphal Library, und ersetze
ihn nach und nach durch die direkten Register-Zugriffe. Wenn es an einer
Stelle nicht mehr funktioniert weißt du warum.

[Christopher B. (chrimbo)]

Hi ich nochmal, schusss ins Blaue,
DISCEN = 1?

[Daniel F. (franky55555)]

Danke für deine Hilfe, aber leider ist auch dies nicht der Fehler.

MfG

[geb (Gast)]

Vor der Kalibration muss der ADC "enabelt" sein!

Grüsse

[geb (Gast)]

Ich habs so gemacht:
/* ADC3 configuration 
------------------------------------------------------*/
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 1;
  ADC_Init(ADC3, &ADC_InitStructure);
  // ADC3 regular channels configuration
  ADC_RegularChannelConfig(ADC3, ADC_Channel_5, 1, 
ADC_SampleTime_239Cycles5);
   // Enable ADC3
  ADC_Cmd(ADC3, ENABLE);
  // Enable ADC3 reset calibaration register
  ADC_ResetCalibration(ADC3);
  // Check the end of ADC3 reset calibration register
  //ADC3->CR2 &=0xFF7FFFFF;
  // ADC3->CR2 |=0x00800000;
 while(ADC_GetResetCalibrationStatus(ADC3));


ADC_StartCalibration(ADC3);
while(ADC_GetCalibrationStatus(ADC3));

[Daniel F. (franky55555)]

Dies war nicht der Fehler, aber danke für deine Antwort :)
Der ADC benötigt einen gesetzten Prescaler (scheint zumindest so, denn 
nachdem dieser gesetzt wurde funktionierte es :D )

Jedoch habe ich immer noch ein kleines Problem:
schreibe ich die Prescaler-configuration nicht dort, wo ich sie habe, so 
funktioniert der ADC nicht mehr

  
RCC->CFGR2 &= ~RCC_CFGR2_ADCPRE34; //erase register
RCC->CFGR2 |= RCC_CFGR2_ADCPRE34_DIV2; // set precaler; division 2

ein weiteres Problem entsteht, wenn ich den ADC3 und den ADC4 verwenden 
möchte. Der ADC, der als "erster" initialisiert wird, funktioniert. Der 
zweite jedoch nicht. Verwende ich jedoch ADC2 und ADC3/ADC4 funktioniert 
es einwandfrei. Ich denke, dass sich somit ADC3 und ADC4 irgendwie 
gegeneinander behindern.

Hat jemand mögliche Lösungsvorschläge um die Probleme zu verhindert? :)
mfG

Hier ist der gesamte Init-Code:

void adc2_init()
{
  //**************************************************
  //--------ADC2 INIT-------------
  //**************************************************
  RCC -> AHBENR |= RCC_AHBENR_ADC12EN;

  ADC2 -> CR &= ~ (ADC_CR_ADEN);// ADEN disable
  ADC2 -> CR &=~(ADC_CR_ADVREGEN); // set reg to 00
  ADC2 -> CR |= ADC_CR_ADVREGEN_0; // ADVREGEN 01

  ADC2 -> CR &=~(ADC_CR_ADCALDIF);// single ended
  ADC2 -> CFGR |=(1<<13); //set to continous mode
  ADC2 -> CR |= ADC_CR_ADCAL; // calibration

  while((ADC2-> CR & ADC_CR_ADCAL) ==1);//wait until calibration is ready

  ADC2-> CR &=~ ADC_CR_ADSTART;// ADSTART disabled
  ADC2->IER |= ADC_IER_EOC;// enable end of conversion flag
  ADC2-> SQR1 &=~(ADC_SQR1_SQ1);
  ADC2->SQR1&=~(ADC_SQR1_L);// 1 sequenz

  ADC2-> SMPR1 &= (ADC_SMPR1_SMP1);
  ADC2-> SMPR1 |= ADC_SMPR1_SMP1_0;
  ADC2-> SMPR1 |= ADC_SMPR1_SMP1_1;
  //ADC2-> SMPR1 |= ADC_SMPR1_SMP1_2;
  /*
   * SMP = 000: 1.5 ADC clock cycles
   * SMP = 001: 2.5 ADC clock cycles
   * SMP = 010: 4.5 ADC clock cycles
   * SMP = 011: 7.5 ADC clock cycles => chosen
   * SMP = 100: 19.5 ADC clock cycles
   * SMP = 101: 61.5 ADC clock cycles
   * SMP = 110: 181.5 ADC clock cycles
   * SMP = 111: 601.5 ADC clock cycles
   */

  ADC2-> CFGR &=~ (ADC_CFGR_RES);
  //clock prescaler, must be there!!
  RCC->CFGR2 &= ~RCC_CFGR2_ADCPRE12;
  RCC->CFGR2 |= RCC_CFGR2_ADCPRE12_DIV2;

  ADC2 -> CR |= ADC_CR_ADEN;// enable ADC
  while((ADC2 -> ISR & ADC_ISR_ADRD)==0);//wait until ADC is ready
}
void adc3_init()
{

  //**************************************
  //--------ADC3 Init------------
  //**************************************
  RCC -> AHBENR |= RCC_AHBENR_ADC34EN;

  ADC3 -> CR &= ~ (ADC_CR_ADEN);// ADEN disable
  ADC3 -> CR &=~(ADC_CR_ADVREGEN); // set reg to 00
  ADC3 -> CR |= ADC_CR_ADVREGEN_0; // ADVREGEN 0

  ADC3 -> CR &=~(ADC_CR_ADCALDIF);// single ended
  ADC3 -> CFGR |=(1<<13); //set to continous mode
  ADC3 -> CR |= ADC_CR_ADCAL; // calibration

  while((ADC3-> CR & ADC_CR_ADCAL) ==1);//wait until calibration is ready

  ADC3-> CR &=~ ADC_CR_ADSTART;// ADSTART disabled
  ADC3->IER |= ADC_IER_EOC;// enable end of conversion flag
  ADC3-> SQR1 &=~(ADC_SQR1_SQ1);
  ADC3->SQR1&=~(ADC_SQR1_L);// 1 sequenz

  ADC3-> SMPR1 &= (ADC_SMPR1_SMP1);
  ADC3-> SMPR1 |= ADC_SMPR1_SMP1_0;
  ADC3-> SMPR1 |= ADC_SMPR1_SMP1_1;
  //ADC3-> SMPR1 |= ADC_SMPR1_SMP1_2;
  /*
   * SMP = 000: 1.5 ADC clock cycles
   * SMP = 001: 2.5 ADC clock cycles
   * SMP = 010: 4.5 ADC clock cycles
   * SMP = 011: 7.5 ADC clock cycles => chosen
   * SMP = 100: 19.5 ADC clock cycles
   * SMP = 101: 61.5 ADC clock cycles
   * SMP = 110: 181.5 ADC clock cycles
   * SMP = 111: 601.5 ADC clock cycles
   */


  ADC3-> CFGR &=~ (ADC_CFGR_RES); //data resolution
  //clock prescaler, must be there!!
  RCC->CFGR2 &= ~RCC_CFGR2_ADCPRE34; //erase register
  RCC->CFGR2 |= RCC_CFGR2_ADCPRE34_DIV2; // set precaler; division 2
  //RCC->CFGR2 |= RCC_CFGR2_ADCPRE34_NO;//use AHB clock

  ADC3 -> CR |= ADC_CR_ADEN;// enable ADC
  while((ADC3 -> ISR & ADC_ISR_ADRD)==0);//wait until ADC is ready

}
void adc4_init()
{
  //**************************************************
  //--------ADC4 INIT-------------
  //**************************************************
  RCC -> AHBENR |= RCC_AHBENR_ADC34EN;

  ADC4 -> CR &= ~ (ADC_CR_ADEN);// ADEN disable
  ADC4 -> CR &=~(ADC_CR_ADVREGEN); // set reg to 00
  ADC4 -> CR |= ADC_CR_ADVREGEN_0; // ADVREGEN 0

  ADC4 -> CR &=~(ADC_CR_ADCALDIF);// single ended
  ADC4 -> CFGR |=(1<<13); //set to continous mode
  ADC4 -> CR |= ADC_CR_ADCAL; // calibration

  while((ADC4-> CR & ADC_CR_ADCAL) ==1);//wait until calibration is ready

  ADC4-> CR &=~ ADC_CR_ADSTART;// ADSTART disabled
  ADC4->IER |= ADC_IER_EOC;// enable end of conversion flag
  ADC4-> SQR1 &=~(ADC_SQR1_SQ1);
  ADC4->SQR1&=~(ADC_SQR1_L);// 1 sequenz

  ADC4-> SMPR1 &= (ADC_SMPR1_SMP1);
  ADC4-> SMPR1 |= ADC_SMPR1_SMP1_0;
  ADC4-> SMPR1 |= ADC_SMPR1_SMP1_1;
  //ADC3-> SMPR1 |= ADC_SMPR1_SMP1_2;
  /*
   * SMP = 000: 1.5 ADC clock cycles
   * SMP = 001: 2.5 ADC clock cycles
   * SMP = 010: 4.5 ADC clock cycles
   * SMP = 011: 7.5 ADC clock cycles => chosen
   * SMP = 100: 19.5 ADC clock cycles
   * SMP = 101: 61.5 ADC clock cycles
   * SMP = 110: 181.5 ADC clock cycles
   * SMP = 111: 601.5 ADC clock cycles
   */

  ADC4-> CFGR &=~ (ADC_CFGR_RES);
  //clock prescaler, must be there!!
  RCC->CFGR2 &= ~RCC_CFGR2_ADCPRE34;
  RCC->CFGR2 |= RCC_CFGR2_ADCPRE34_DIV2;


  ADC4 -> CR |= ADC_CR_ADEN;// enable ADC
  while((ADC4 -> ISR & ADC_ISR_ADRD)==0);//wait until ADC is ready

}

Ich habe auch eigene Funktionen für das Auslesen der ADC-Werte:

int adc3_value(uint8_t channel)
{
  uint16_t value=0;
  ADC3-> SQR1 |= (channel<<6);
  //ADC3-> SQR1 |=ADC_SQR1_SQ1_3|ADC_SQR1_SQ1_2; //set channel 12
  ADC3-> CR |= ADC_CR_ADSTART; // ADC start
    while((ADC3 -> ISR & ADC_ISR_EOC) == 0); //wait until ADC conversion is ready
  value=ADC3 -> DR;// write into buffer
    ADC3->CR |= ADC_CR_ADSTP;//stopping ADC
    return value;
}

int adc2_value(uint8_t channel)
{
  uint16_t value=0;
  ADC2-> SQR1 |= (channel<<6);
  //ADC3-> SQR1 |=ADC_SQR1_SQ1_3|ADC_SQR1_SQ1_2; //set channel 12
  ADC2-> CR |= ADC_CR_ADSTART; // ADC start
    while((ADC2 -> ISR & ADC_ISR_EOC) == 0); //wait until ADC conversion is ready
  value=ADC2 -> DR;// write into buffer
    ADC2->CR |= ADC_CR_ADSTP;//stopping ADC
    return value;
}

int adc4_value(uint8_t channel)
{
  uint16_t value=0;
  ADC4-> SQR1 |= (channel<<6);
  //ADC3-> SQR1 |=ADC_SQR1_SQ1_3|ADC_SQR1_SQ1_2; //set channel 12
  ADC4-> CR |= ADC_CR_ADSTART; // ADC start
    while((ADC4 -> ISR & ADC_ISR_EOC) == 0); //wait until ADC conversion is ready
  value=ADC4 -> DR;// write into buffer
    ADC4->CR |= ADC_CR_ADSTP;//stopping ADC
    return value;
}