STM32 baremetal ADC

[Marc (Gast)]

Nachdem die Baremetal-Implementierung auf einem Nucleo F303K8 so gut 
geklappt hat
Beitrag "STM32Duino DMA DAC"

Versuche ich mich an einer baremetal ADC Implementierung.

Leider tut sich bis jetzt da gar nichts.
Hat jemand eine Idee, woran es liegen könnte?

// F303 baremetal ADC
//
// References:
// https://www.youtube.com/watch?v=Zq4Ixz6mFDE
// https://github.com/DK7IH/STM32-F4-Demos/blob/main/_ADC/adc_port_pb1_as_analog_input.c

void initAdc()
{
  RCC->AHBENR  |= (1 << RCC_AHBENR_GPIOAEN); // enable clock for Port A
  GPIOA->MODER |= (3 << 0); //PA0 as analog
  //analogRead(A0);
  RCC->AHBENR  |= (1 << RCC_AHBENR_ADC12EN); // enable clock for ADC12
  ADC1->CFGR &= ~(0x07 << ADC_CFGR_RES); // 12bit resolution
  
  // disable voltage regulator
  ADC1->CR &= ~(0x07 << ADC_CR_ADVREGEN); // Intermediate state required when moving the ADC voltage regulator from the enabled to the disabled state or from the disabled to the enabled state.
  ADC1->CR |= (0x02 << ADC_CR_ADVREGEN); // ADC Voltage regulator disabled (Reset state)
  
  ADC1->CR |= (1 << ADC_CR_ADDIS); // ADC disable command

  ADC1->SQR1 &= ~(0x1F << ADC_SQR1_SQ1); // select channel 0 in seuqence 0

  // enable voltage regulator
  ADC1->CR &= ~(0x07 << ADC_CR_ADVREGEN); // Intermediate state required when moving the ADC voltage regulator from the enabled to the disabled state or from the disabled to the enabled state.
  ADC1->CR |= (0x01 << ADC_CR_ADVREGEN); // ADC Voltage regulator enabled

  delay(10);

  ADC1->CR |= (1 << ADC_CR_ADEN); // ADC enable command
}

uint16_t readAdc()
{
  uint16_t adcval;
  
  ADC1->CR |= (1 << ADC_CR_ADSTART); // start conversion
  
  while (!(ADC1->ISR & (1 << ADC_ISR_ADRDY))); //Wait until conversion is complete
  adcval = ADC1->DR;             //Read value from register
  return adcval;
}

void setup()
{
  Serial.begin(115200);
  delay(3000);
  Serial.println("Hello");
  delay(1000);
  Serial.println("initADC");
  initAdc();
  delay(1000);
  Serial.println("done .. start sampling");
}

void loop()
{
  Serial.println(readAdc());
  delay(100);
}

[N. M. (mani)]

Vergleich doch einfach Mal mit anderen wo es zu funktionieren scheint.

Hier ein Beispiel:
http://stefanfrings.de/stm32/stm32f3.html#analog

[M. Н. (Gast)]

Marc schrieb:
> (1 << RCC_AHBENR_GPIOAEN);

und Konsorten sehen falsch aus. Wenn deine Header aussehen, wie üblich, 
sind das bereits "Bitmasken" und du müsstest

RCC->AHBENR |= RCC_AHBENR_GPIOAEN;

schreiben. Selbiges gilt für die anderen Felder.

[Marc (Gast)]

>Wenn deine Header aussehen, wie üblich,
>sind das bereits "Bitmasken" und du müsstest

Oha, du hast recht .. das geht natürlich gewaltig schief.

N. M. (mani)
08.11.2022 08:23
>Vergleich doch einfach Mal mit anderen wo es zu funktionieren scheint.
>Hier ein Beispiel:
>http://stefanfrings.de/stm32/stm32f3.html#analog

Super .. das geht fast "out of the box". Nur mein "Speed-Test" zeigt 
irgendwie Müll an. Ich will eigentlich wissen, wie schnell der ADC in 
der Schleife ist.

// F303 baremetal ADC
//
// References:
// http://stefanfrings.de/stm32/stm32f3.html#analog

// Initialize the ADC1 for single conversion mode
void init_analog()
{
  // Enable clock for ADC
  SET_BIT(RCC->AHBENR, RCC_AHBENR_ADC12EN);

  // Disable the ADC
  if (READ_BIT(ADC1->ISR, ADC_ISR_ADRDY))
  {
    SET_BIT(ADC1->ISR, ADC_ISR_ADRDY);
  }
  if (READ_BIT(ADC1->CR, ADC_CR_ADEN))
  {
    SET_BIT(ADC1->CR, ADC_CR_ADDIS);
  }

  // Wait until ADC is disabled
  while (READ_BIT(ADC1->CR, ADC_CR_ADEN));

  // Enable ADC voltage regulator
  MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, 0);
  MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, ADC_CR_ADVREGEN_0);

  // Delay 1-2 ms
  //delay_ms(2);
  delay(2);

  // ADC Clock = HCLK/4
  MODIFY_REG(ADC12_COMMON->CCR, ADC12_CCR_CKMODE, ADC12_CCR_CKMODE_0 + ADC12_CCR_CKMODE_1);

  // Single ended mode for all channels
  WRITE_REG(ADC1->DIFSEL, 0);

  // Start calibration for single ended mode
  CLEAR_BIT(ADC1->CR, ADC_CR_ADCALDIF);
  SET_BIT(ADC1->CR, ADC_CR_ADCAL);

  // Wait until the calibration is finished
  while (READ_BIT(ADC1->CR, ADC_CR_ADCAL));

  // Clear the ready flag
  SET_BIT(ADC1->ISR, ADC_ISR_ADRDY);

  // Enable the ADC repeatedly until success (workaround from errata)
  do
  {
    SET_BIT(ADC1->CR, ADC_CR_ADEN);
  }
  while (!READ_BIT(ADC1->ISR, ADC_ISR_ADRDY));

  // Select software start trigger
  MODIFY_REG(ADC1->CFGR, ADC_CFGR_EXTEN, 0);

  // Select single conversion mode
  CLEAR_BIT(ADC1->CFGR, ADC_CFGR_CONT);

  // Set sample time to 32 cycles
  MODIFY_REG(ADC1->SMPR1, ADC_SMPR1_SMP1, ADC_SMPR1_SMP1_2);
}

// Read from an analog input of ADC1
uint32_t read_analog(uint32_t channel)
{
  // Number of channels to convert: 1
  MODIFY_REG(ADC1->SQR1, ADC_SQR1_L, 0);
  // Select the channel
  MODIFY_REG(ADC1->SQR1, ADC_SQR1_SQ1, channel << ADC_SQR1_SQ1_Pos);
  // Clear the finish flag
  CLEAR_BIT(ADC1->ISR, ADC_ISR_EOC);
  // Start a conversion
  SET_BIT(ADC1->CR, ADC_CR_ADSTART);
  // Wait until the conversion is finished
  while (!READ_BIT(ADC1->ISR, ADC_ISR_EOC));
  while (READ_BIT(ADC1->CR, ADC_CR_ADSTART));
  // Return the lower 12 bits of the result
  return ADC1->DR & 0b111111111111;
}

#define CHANNEL 1 // PA0

void speedTest()
{
  uint32_t duration_ms = 1000;
  uint32_t endTime = millis() + 1000;
  uint32_t n = 0;
  uint32_t value;
  while (millis() < endTime)
  {
    value += read_analog(CHANNEL);
    n++;
  }
  //delay(1000);
  Serial.print('samples per second: '); 
  Serial.println(n);
  delay(1000);
  Serial.print('ADC mean value: '); Serial.println((float)value / n);
  delay(5000);
}

void setup()
{
  Serial.begin(115200);
  delay(3000);
  Serial.println("Hello");
  delay(1000);
  Serial.println("initADC");
  init_analog();
  delay(1000);
  Serial.println("done .. run speed test");
  speedTest();
}

void loop()
{
  Serial.println(read_analog(CHANNEL));
  delay(100);

}

[[e-mail] (Gast)]

Mal DMA-Sektion durchlesen, wenn es um Speedtest geht. Und die 
Implikationen der ADC-Realisierung.

[N. M. (mani)]

Bis zu 4 Kanäle bekommt man glaube ich sogar noch ohne DMA hin. Der ADC 
hat meine ich 1 Result und 3 injected Result Register.

Wenn es mehr Kanäle oder spezielle Anforderungen gibt geht natürlich mit 
DMA noch viel mehr.

[Marc (Gast)]

DMA wäre schon nicht schlecht, aber bis die Konfiguration steht, würde 
das vermutlich noch einmal ein paar Tag dauern.

Oben im Code im Code waren im "speedTest" kleine Fehler. Hier der 
richtige Code:

#define CHANNEL 1 // PA0

void speedTest()
{
  uint32_t n;
  float value;
  int32_t startTime = micros();

  for (n = 0; n < 1000; n++)
  {
    read_analog(CHANNEL);
  }
  
  int32_t duration1000samples_us = micros() - startTime;
  
  Serial.print("1000 samples duration: ");
  Serial.print(duration1000samples_us); Serial.println("us");
  Serial.print("samples per second: ");
  Serial.println((int)(1000 / ((float)duration1000samples_us/1e6)));

  delay(5000);
}

Ergebnis:

Hello
initADC
done .. run speed test
1000 samples duration: 3203us
samples per second: 312207

Laut Datenblatt sollten die Wandler ~5MSPs können. Mit der jetzigen 
Einstellung sind es aber nur ~300kSps. Immerhin .. das Original 
analogRead(A0) des STM32Duino (Arduino) Frameworks läuft mit 5kSps.
Da liegen als bei dieser "baremetal" Implementierung als Welten.
Als Desktop-Oscilloscope für Audiosignale würde das schon reichen.

[N. M. (mani)]

Marc schrieb:
> Laut Datenblatt sollten die Wandler ~5MSPs können.

Das kann er auch. Deine Software ist schlicht zu langsam. Man könnte das 
jetzt noch optimieren mit Inline Funktion usw, aber es wird nichts 
ändern. Die 5 MSPS wirst du nur mit Hardware Unterstützung zuverlässig 
hinbekommen.

Marc schrieb:
> Als Desktop-Oscilloscope für Audiosignale würde das schon reichen.

Naja, je nach dem auch nicht schön da du mit dieser Implementierung 
keine äquidistante Abtastung hast.
Da würde man eher einen Timer nehmen der dem ADC in einem festen Raster 
(z.B 48kHz) triggert. Ein DMA schaufelt dann die Daten vom ADC Register 
in einen Zwischenpuffer.
Oft nimmt man dabei 2 Puffer die man wechselt sobald der andere voll 
ist, damit man immer etwas Zeit hat den gerade voll gewordenen Puffer 
weiter zu verbreiten.
Ich kenne das unter "Ping Pong Buffer" Mehrfach-Puffer.

Der F3 hat glaube ich auch einstellbare analoge Komperatoren im Gepäck. 
Damit könnte man dann evtl noch den Triggerzeitpunkt in Hardware machen 
indem der DMA erst kopiert wenn der Interrupt des Komparator kam.

[Marc (Gast)]

Dank eines kleine "Überspannungsexperimentes" ist mir der zweite DAC 
Kanal meines Nucleo F303 abgeraucht :-(

Aber .. ich habe noch ein Nucleo L432KC.

Ich habe jetzt schon eine Weile probiert, aber irgend etwas fehlt noch 
in der Initialisierung. Ich vermute, der ADC Block bekommt noch keine 
Takt o.ä. weil bei der folgenden Zeile das Enable Bit nicht gesetzt wird 
(sieht man im Debugger):

  SET_BIT(RCC->AHB2ENR, RCC_AHB2ENR_ADCEN);

Hat jemand eine Idee, woran es liegen könnte? Hier der noch nicht 
funktionierende Code. Er funktioniert, wenn man die HAL bassiert 
Funktion "analog.cpp" voranstellt und dort drinnen das 
"HAL_DAC_MspDeInit" auskommentiert, damit die ADC Initialisierung 
erhalten bleibt. Das ist aber natürlich nicht der Sinn der Sache.

#include <Arduino.h>

#include "analog2.h"

// /home/christoph/.arduino15/packages/STMicroelectronics/hardware/stm32/2.3.0/libraries/SrcWrapper/src/stm32
//  analog.cpp
// /home/christoph/.arduino15/packages/STMicroelectronics/hardware/stm32/2.3.0/system/Drivers

#ifdef __cplusplus
extern "C" {
#endif
uint16_t adc_read_value2(PinName pin, uint32_t resolution);
#ifdef __cplusplus
}
#endif

#define CHANNEL 5 // PA0 -> A0
//#define CHANNEL 6 // PA1 -> A1
//#define CHANNEL 8 // PA3 -> A2

// Initialize the ADC1 for single conversion mode
void init_analog()
{
  // something is missing in the following initialization
  // thererfore we need to call the HALL funktions
  // tbd: find the missing register 
  // hint: the error might be in a missing clock initialization of the ADC
  adc_read_value2(PA_0, 12); 
  // Enable clock for ADC
  //SET_BIT(RCC->AHBENR, RCC_AHBENR_ADC12EN);
  SET_BIT(RCC->AHB2ENR, RCC_AHB2ENR_ADCEN);

  // Disable the ADC
  if (READ_BIT(ADC1->ISR, ADC_ISR_ADRDY))
  {
    SET_BIT(ADC1->ISR, ADC_ISR_ADRDY);
  }
  if (READ_BIT(ADC1->CR, ADC_CR_ADEN))
  {
    SET_BIT(ADC1->CR, ADC_CR_ADDIS);
  }

  // Wait until ADC is disabled
  while (READ_BIT(ADC1->CR, ADC_CR_ADEN));

  // Enable ADC voltage regulator
  MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, 0);
  //MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, ADC_CR_ADVREGEN_0);
  MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, ADC_CR_ADVREGEN);
  // Delay 1-2 ms
  //delay_ms(2);
  delay(2);

  // ADC Clock = HCLK/4
  //MODIFY_REG(ADC12_COMMON->CCR, ADC12_CCR_CKMODE, ADC12_CCR_CKMODE_0 + ADC12_CCR_CKMODE_1);
  MODIFY_REG(ADC1_COMMON->CCR, ADC_CCR_CKMODE, ADC_CCR_CKMODE_0 + ADC_CCR_CKMODE_1);

  // Single ended mode for all channels
  WRITE_REG(ADC1->DIFSEL, 0);

  // Start calibration for single ended mode
  CLEAR_BIT(ADC1->CR, ADC_CR_ADCALDIF);
  SET_BIT(ADC1->CR, ADC_CR_ADCAL);

  // Wait until the calibration is finished
  while (READ_BIT(ADC1->CR, ADC_CR_ADCAL));

  // Clear the ready flag
  SET_BIT(ADC1->ISR, ADC_ISR_ADRDY);

  // Enable the ADC repeatedly until success (workaround from errata)
  do
  {
    SET_BIT(ADC1->CR, ADC_CR_ADEN);
  }
  while (!READ_BIT(ADC1->ISR, ADC_ISR_ADRDY));

  // Select software start trigger
  MODIFY_REG(ADC1->CFGR, ADC_CFGR_EXTEN, 0);

  // Select single conversion mode
  CLEAR_BIT(ADC1->CFGR, ADC_CFGR_CONT);

  // Set sample time to 32 cycles
  MODIFY_REG(ADC1->SMPR1, ADC_SMPR1_SMP1, ADC_SMPR1_SMP1_2);
}

// Read from an analog input of ADC1
uint32_t read_analog(uint32_t channel)
{
  // Number of channels to convert: 1
  MODIFY_REG(ADC1->SQR1, ADC_SQR1_L, 0);
  // Select the channel
  MODIFY_REG(ADC1->SQR1, ADC_SQR1_SQ1, channel << ADC_SQR1_SQ1_Pos);
  // Clear the finish flag
  CLEAR_BIT(ADC1->ISR, ADC_ISR_EOC);
  // Start a conversion
  SET_BIT(ADC1->CR, ADC_CR_ADSTART);
  // Wait until the conversion is finished
  while (!READ_BIT(ADC1->ISR, ADC_ISR_EOC));
  while (READ_BIT(ADC1->CR, ADC_CR_ADSTART));
  // Return the lower 12 bits of the result
  return ADC1->DR & 0b111111111111;
}

void speedTest()
{
  uint32_t n;
  float value;

  Serial.print("channel: ");
  Serial.print((int)CHANNEL);
  Serial.println("");

  int32_t startTime = micros();

  for (n = 0; n < 1000; n++)
  {
    read_analog(CHANNEL);
  }

  int32_t duration1000samples_us = micros() - startTime;

  Serial.print("1000 samples duration: ");
  Serial.print(duration1000samples_us); Serial.println("us");
  Serial.print("samples per second: ");
  Serial.println((int)(1000 / ((float)duration1000samples_us / 1e6)));

  delay(5000);
}

void setup()
{
  Serial.begin(115200);

  init_analog();
  speedTest();
}

void loop()
{
  uint16_t v;
  // uint16_t adc_read_value2(PinName pin, uint32_t resolution);
  //v=adc_read_value2(PA_0, 12);
  v = read_analog(CHANNEL);
  Serial.println(v);
  delay(1);

}