Tag: STM32

STM32 ADC: Expression-Pedal Steuerung

STM32 hat je nach Chipvariante einen oder mehrere Analog-Digital-Wandler (ADC).

Der ADC konvertiert die am analogen Eingang anliegende Spannung in einen binären Wert. Dafür braucht er allerdings ein Paar Zyklen- je nach Einstellung aber mindestens um die 3 Zyklen. Zudem läuft ADC mit niedrigerer Frequenz als der Cortex-Kern. Man muss also wissen, dass eine Konvertierung einige Prozessorzyklen lang dauert.

Unter dem Aspekt gibt es (wie für viele andere Hardwarekomponenten) hauptsächlich drei Möglichkeiten einen Analog-Digital-Wandler zu steuern bzw. auszulesen:

Normaler Modus (Blockierend)
Interrupt-Modus (Nicht-blockierend)
Per DMA auslesen (Nicht-blockierend)

Normaler Modus

In diesem Modus läuft das Sampling im Hauptprogramm. Das heisst, man triggert das Sampling an, wartet(!) darauf, dass das Sampling fertig ist und macht weiter im Hauptprogramm. Das bedeutet viele verlorene Zyklen und darf nur in Ausnahmefällen bzw. in nicht leistungskritischen Applikationen eingesetzt werden.

Interrupt Modus

Im Interrupt-Modus stößt das Hauptprogramm das Sampling an und macht weiter mit seinen Aufgaben. Wenn das Sampling fertig ist, löst die ADC-Hardware einen Interrupt aus. Mit Hilfe dieses Interrupts kann dann dem Hauptprogramm mitgeteilt werden, dass nun das Register den neuen Digitalwert beinhaltet.

DMA MODUS

Im DMA-Modus schaufelt die DMA-Hardware im Hintergrund die ADC-Werte. Dabei wird die ADC-Hardware in den kontinuierlichen Modus gesetzt. Das heißt, sie fängt gleich mit dem nächsten Sampling an, wenn sie mit einem fertig ist. Das ist oft der effizienteste Modus.

Beim Projekt Flex 500 wird z. B. das Expression-Pedal mit einem ADC interrupt-gesteuert gelesen. Der Grund dafür ist, dass man die Frequenz mit einem Timer einstellen möchte. Die ADC-Hardware ist folgendermaßen konfiguriert. Das

void c_sysconfig::MX_ADC1_Init(void)
{

  ADC_ChannelConfTypeDef sConfig;

    /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV8;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.ContinuousConvMode = ENABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
//    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
    */
  sConfig.Channel = ADC_CHANNEL_3;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
//    _Error_Handler(__FILE__, __LINE__);
  }

}

void c_sysconfig::MX_ADC1_Init(void)

{

ADC_ChannelConfTypeDef sConfig;

/**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

hadc1.Instance = ADC1;

hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV8;

hadc1.Init.Resolution = ADC_RESOLUTION_12B;

hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;

hadc1.Init.ContinuousConvMode = ENABLE;

hadc1.Init.DiscontinuousConvMode = DISABLE;

hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;

hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;

hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;

hadc1.Init.NbrOfConversion = 1;

hadc1.Init.DMAContinuousRequests = ENABLE;

hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;

if (HAL_ADC_Init(&hadc1) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

/**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

sConfig.Channel = ADC_CHANNEL_3;

sConfig.Rank = ADC_REGULAR_RANK_1;

sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;

if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

Nach jedem Lesezyklus triggert man dabei das nächste Sampling. Das Interrupt wird dabei allerdings nicht benutzt, da der Zyklus kurz ist und das Interrupt sonst das Hauptprogramm unnötig oft unterbrechen würde.

uint16_t c_exppedal::get_value(void){

	//Interrupt mode
	HAL_ADC_Start_IT(&hadc1);
	adc_val=HAL_ADC_GetValue(&hadc1);

	return (uint16_t) adc_val;

}

uint16_t c_exppedal::get_value(void){

//Interrupt mode

HAL_ADC_Start_IT(&hadc1);

adc_val=HAL_ADC_GetValue(&hadc1);

return (uint16_t) adc_val;

}

Andere Möglichkeit wäre eben per DMA, dass man dabei die Hardware nur starten und stoppen muss:

void c_exppedal::start(void){

	//Request using interrupt mode
	HAL_ADC_Start_DMA(&hadc1, &adc_val,1);


}

void c_exppedal::stop(void){

	//Request using interrupt mode
	HAL_ADC_Stop_DMA(&hadc1);

}

void c_exppedal::start(void){

//Request using interrupt mode

HAL_ADC_Start_DMA(&hadc1, &adc_val,1);

}

void c_exppedal::stop(void){

//Request using interrupt mode

HAL_ADC_Stop_DMA(&hadc1);

}

Die Konfiguration des Timers ist folgendermaßen. Bei einer CPU-Frequenz von 216MHz ergibt sich eine Timerfrequenz von:

(1) $\begin{equation*} f_{TIM3}= \frac{216\cdot 10^6}{(1600+1)*(10000+1)} \approx 13.5Hz \end{equation*}$

void c_sysconfig::MX_TIM3_Init(void)
  {

    TIM_ClockConfigTypeDef sClockSourceConfig;
    TIM_MasterConfigTypeDef sMasterConfig;

    htim3.Instance = TIM3;
    htim3.Init.Prescaler = 10000;
    htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim3.Init.Period = 1600;
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;


    if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
    {
//      _Error_Handler(__FILE__, __LINE__);
    }

    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
    {
//      _Error_Handler(__FILE__, __LINE__);
    }

    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
    {
//      _Error_Handler(__FILE__, __LINE__);
    }

  }

void c_sysconfig::MX_TIM3_Init(void)

{

TIM_ClockConfigTypeDef sClockSourceConfig;

TIM_MasterConfigTypeDef sMasterConfig;

htim3.Instance = TIM3;

htim3.Init.Prescaler = 10000;

htim3.Init.CounterMode = TIM_COUNTERMODE_UP;

htim3.Init.Period = 1600;

htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

if (HAL_TIM_Base_Init(&htim3) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

Ressourcen

Der vollständige Code vom Communication Stack befindet sich auf den Repositories vom Controller und DSP unter den Ordnern „hw„.

DSP – Targetcode vom herunterladen

Controller- Targetcode vom herunterladen

Digitaler Tuner (Stimmgerät)

12. Dezember 2019 / solocan / Noch kein Kommentar

Ein Effektgerät besteht hauptsächlich aus den Komponenten

Im Falle von einem verteilten System wird die Frequenzerkennung auf dem DSP durchgeführt. Die erkannte Frequenz wird dem Controller mitgeteilt, der dann Korrektur-/Stimmhilfe gibt. Dazu gehört

die Erkennung/Vermutung der Soll-Note
Die Abweichung von der vermuteten Soll-Note.

Die Erkennung der Frequenz bzw. die Darstellung der Abweichung ist in obigen Kapiteln ausführlich beschrieben.

DSP Architektur

11. Dezember 2019 / solocan / Noch kein Kommentar

Ein DSP-FX benötigt jitter-freie Verarbeitung der Audiodaten in Echtzeit. Echtzeit ist ein theoretischer und dehnbarer Begriff, der die erforderliche Systemlatenz beschreibt. Beim Audio beruht diese Feststellung auf die Latenzwahrnehmung des Menschen. Wir nehmen die Latenzen unter 10ms als Echtzeit wahr. Die Latenz der gesamten Kette (Roundtriplatenz) ist die Zeit zwischen dem Eintreten des Signals in die Codec-Eingänge bis zur Bereitstehung des verarbeiteten Signals an Codec-Ausgängen. Diese Zeit darf 10ms nicht überschreiten. Am besten soll diese Zeit sogar noch unter 10ms liegen, da auch der Schall zwischen den Lautsprechern und dem Ohr zusätzlich große Latenz erzeugt und Echtzeiterlebnis schnell beeinflusst werden kann.

Systemarchitektur

Die Übersicht der Systemarchitektur des DSPs vom Flex 500 ist im folgenden Diagramm gezeigt:

Codec

Ein Audio- Codec (Coder, decoder) ist die Komponente, die die analogen Audio-Signale ins Digitale wandelt und die digitalen Audio-Signale ins Analoge wandelt. (Sampling) Er besteht aus einem oder mehreren Analog-Digital-Wandlern (ADC) und ein Digital-Analog-Wandlern (DAC). Nach diesem Schritt liegen die Audio-Signale in einem digitalen Audio-Format vor, im vorliegenden Fall als I2S-Format (Intersound).

Die Codecs müssen konfiguriert und initialisiert werden. Das erfolgt über eine andere serielle Schnittstelle, üblicherweise SPI oder I2C. Das heißt, der Codec hat auch eine Steuerschnittstelle zum DSP. Beim Flex 500 stehen beide Schnittstellen zur Verfügung.

SAI

SAI (Serial Audio Interface) ist eine Schnittstelle, über die digitale Audio-Daten ausgetauscht werden können. Der Codec kommuniziert mit der SAI-Schnittstelle vom DSP-Chip, in dem Fall STM32H743. Diese Schnittstelle serialisiert und deserialisiert die Audiodaten, D.h. er schreibt/liest die in den bzw. von dem Arbeitsspeicher.

DMA

Das Schreiben bzw. Lesen muss über eine DMA (DIrect memory access)-Hardware-Komponente erfolgen. DMA ist eine einfache Hardware, die die Aufgabe hat, ein Register in das andere zu kopieren. Die Startaddresse, FIFO, IRQs und die Länge müssen dabei konfiguriert werden. Dadurch dass DMA die Datenübertragungsaufgabe übernimmt, kann sich DSP auf die Datenverarbeitung konzentrieren.

DMA muss so konfiguriert werden, dass er ein Interrupt auslöst, wenn die Puffer

halb voll und
ganz voll

sind. Dadurch können die Flags der Zustandsmaschine (State machine) gesetzt werden.

Puffer

Das vom Audio-Codec ins digitale I2S-Format gewandelte Audio-Signal muss in einem Eingangspuffer zwischengespeichert werden. Dann wird dieses Puffer vom DSP verarbeitet und das Ergebnis in ein Ausgangspuffer geschrieben. Die Größe der Puffer ergibt sich aus dem Kompromiss aus zwei Anforderungen:

Die Puffer muss so klein wie möglich sein, um eine nicht-wahrnehmbare Latenz zu erreichen.
Die Puffer müssen so groß wie möglich sein, um eine effiziente blockweise Datenverarbeitung zu ermöglichen (Overhead muss reduziert werden)

Bei den Anforderungen

Roundtrip-Latenz = 10ms
Abtastrate $f_S$ = 48kHz
Bittiefe = 32bit

ergibt sich eine Puffergröße von 240 für jeweils Eingangs- und Ausgangspuffer mit 32bit Registern, da Eingangslatenz und Ausgangslatenz 5ms betragen müssen.

Für die Verarbeitung mit DMA-Interrupts wird ein Doppelpuffer der Größe 480 verwendet. Für genaue Erkläreung, siehe unten.

Zustandsmaschine

Die Zustandsmaschine ist die Hauptsteuerungskomponente in der Software. Durch die Interrupts von DMA wird der Software mitgeteilt, dass das Puffer halb oder ganz voll ist. Nun kann die Zustandsmaschine, die in Endlosschleife läuft, entscheiden, ob der Prozess getriggert werden soll.

Die auf STM32 eingesetzter DMA unterstützt Double-buffering. Das heißt, er kann auf der Hälfte und am Ende der Übertragung ein Interrupt auslösen. Deshalb müssen wir das Doppelpuffer nicht selbst managen.

Der Ablauf sieht folgendermaßen aus:

Erste Hälfte vom RX fertig ( Ab nun beschreibt DMA die zweite Hälfte)
Erste Hälfte vom TX fertig ( Ab nun beschreibt DMA die zweite Hälfte)
Zustandsmaschine löst die Verarbeitung der ersten Hälfte aus. Jetzt liest DSP von der ersten Hälfte von RX und beschreibt die erste Hälfte von TX.
Zweite Hälfte vom RX fertig ( Ab nun beschreibt DMA die erste Hälfte)
Zweite Hälfte vom TX fertig ( Ab nun beschreibt DMA die erste Hälfte)
Zustandsmaschine löst die Verarbeitung der zweiten Hälfte aus. Jetzt liest DSP von der zweiten Hälfte von RX und beschreibt die zweite Hälfte von TX.
Zurück zu 1.

Man erkennt, dass zwischen den RX und TX interrupts ein kleiner Versatz ist. Zwar synchronisiert der Codec die ADCs und DACs aber trotzdem entstehen ein kleines Offset von ein paar Samples. Um den Jitter zu verhindern, müssen beide Interrupts ausgewertet werden, um sicherzugehen, dass in der zu verarbeitenden Hälfte wirklich nichts mehr beschrieben bzw. gelesen wird.

Implementierung

Zuerst müssen die Stati initialisiert werden.

/*Init routine*/
void c_ser::init(void){

	tx_status=0;
	rx_status=0;


	//Initialize DSP
	dsp.init();

}

/*Init routine*/

void c_ser::init(void){

tx_status=0;

rx_status=0;

//Initialize DSP

dsp.init();

}

Die Hauptroutine, die Endlosschleife der Verarbeitung wird folgendermaßen implementiert:

/*
 * Main loop for the state machine
 * */
void c_ser::start(void){

	bool old_pos=1;
	unsigned i;
	//Endless main loop
	while(1){

		if((tx_status && rx_status)&&old_pos){ //When pointer is on the second half of the buffer

			for(i=0;i<buf_size*2;i+=2){
				tx_buf[i]=dsp.process(&rx_buf[i]); //(mono right)

			}
			old_pos=0;

		}else if(!(tx_status || rx_status)&&!old_pos){//When pointer is on the first half of the buffer

			for(i=buf_size*2;i<buf_size*4;i+=2){
				tx_buf[i]=dsp.process(&rx_buf[i]); //(mono right)
			}
			old_pos=1;
		}else{
			//Can measure idle here
		}

	}
}

* Main loop for the state machine

* */

void c_ser::start(void){

bool old_pos=1;

unsigned i;

//Endless main loop

while(1){

if((tx_status && rx_status)&&old_pos){ //When pointer is on the second half of the buffer

for(i=0;i<buf_size*2;i+=2){

tx_buf[i]=dsp.process(&rx_buf[i]); //(mono right)

}

old_pos=0;

}else if(!(tx_status || rx_status)&&!old_pos){//When pointer is on the first half of the buffer

for(i=buf_size*2;i<buf_size*4;i+=2){

tx_buf[i]=dsp.process(&rx_buf[i]); //(mono right)

}

old_pos=1;

}else{

//Can measure idle here

}

Die Flags tx_status und rx_status wurden in Interrupt Routinen gesetzt und hier (nach der Verarbeitung) wieder geresettet.

void HAL_SAI_TxCpltCallback(SAI_HandleTypeDef *hsai)
{
	tx_status=0;
}

void HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef *hsai){
	tx_status=1;
}

void HAL_SAI_RxCpltCallback(SAI_HandleTypeDef *hsai){
	rx_status=0;
}

void HAL_SAI_RxHalfCpltCallback(SAI_HandleTypeDef *hsai){
	rx_status=1;
}

void HAL_SAI_TxCpltCallback(SAI_HandleTypeDef *hsai)

{

tx_status=0;

}

void HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef *hsai){

tx_status=1;

}

void HAL_SAI_RxCpltCallback(SAI_HandleTypeDef *hsai){

rx_status=0;

}

void HAL_SAI_RxHalfCpltCallback(SAI_HandleTypeDef *hsai){

rx_status=1;

}

Wichtig: Die Interruptroutine muss so schnell wie möglich ablaufen, da diese höchste Priorität hat und alles pausiert. Hier nichts verarbeiten, sondern nur Flags setzen, die dann in der Hauptschleife verarbeitet werden.

Can Kosar

Tag: STM32

STM32 ADC: Expression-Pedal Steuerung

Normaler Modus

Interrupt Modus

DMA MODUS

Ressourcen

Digitaler Tuner (Stimmgerät)

DSP Architektur

Systemarchitektur

Codec

SAI

DMA

Puffer

Zustandsmaschine

Implementierung