Kategorie: Embedded (page 1 of 2)

STM32 SAI Konfiguration

15. Dezember 2019 / solocan / Noch kein Kommentar

STM32 besitzt je nach Chipvariante eine serielle Audio-Schnittstelle SAI. Durch diese Schnittstelle kann über übliche Protokolle mit Audio-Codecs kommuniziert werden.

Audio-Clocks

Das Codec und die SAI-Schnittstelle müssen synchronisiert werden. Dabei gibt es konkrete Vorgaben bzw. Randbedingungen seitens Codecs.

Audio-Abtastfrequenz $F_s$ wählen.
Den Multiplikator $k_{MCLK}$ (Codecs haben oft Multiplikatortabellen z.B. 256 oder 512 bei 48kHz) wählen.
Daraus die erforderliche Master-Clock-Frequenz berechnen. (Oft $F_{MCLK}F_s \cdot k_{MCLK}$ )
Master-Clock-Quelle konfigurieren (Externer Quarz bzw. interne Clockquellen)

Übertragung

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

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

Bei einer echtzeitkritischen Audio-DSP-Anwendung kommt nur DMA-Schnittstelle in Frage. Die Konfiguration der Software und Hardware ist hier beschrieben.

SAI und DMA Konfiguration

Beim Flex 500 ist feste 48kHz Abtastrate gewählt. Bei CS4272 kann der Multiplikator 256 oder 512 gewählt werden. Um auch zukünftig 96kHz zu unterstützen wurde hierbei 512 gewählt. Zu Stabilitätszwecken wurde für einen externen Quarz entschieden. Die Frequenz des Quarzes berechnet sich also als

(1) $\begin{equation*} F_{MCLK}=F_S \cdot k_{MCLK} = 48000 \cdot 512 = 24,576 MHz \end{equation*}$

In dem Fall ist der Codec der Master und generiert den Bitclock. Der DSP ist Slave und erhält den Bitclock und dazugehörige Streams.

Die Konfiguration sieht folgendermaßen aus:

Low level Treiber: (*_hal_msp.c)

void HAL_SAI_MspInit(SAI_HandleTypeDef* hsai)
{

  GPIO_InitTypeDef GPIO_InitStruct;
/* SAI1 */
    if(hsai->Instance==SAI1_Block_A)
    {
    /* Peripheral clock enable */
    if (SAI1_client == 0)
    {
       __HAL_RCC_SAI1_CLK_ENABLE();
    }
    SAI1_client ++;
    
    /**SAI1_A_Block_A GPIO Configuration    
    PE4     ------> SAI1_FS_A
    PE5     ------> SAI1_SCK_A
    PE6     ------> SAI1_SD_A 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF6_SAI1;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

    /* Peripheral DMA init*/
    /* DMA controller clock enable */
    __HAL_RCC_DMA2_CLK_ENABLE();
    
    hdma_sai1_a.Instance = DMA2_Stream1;
    hdma_sai1_a.Init.Request = DMA_REQUEST_SAI1_A;
    hdma_sai1_a.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_sai1_a.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_sai1_a.Init.MemInc = DMA_MINC_ENABLE;
    hdma_sai1_a.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
    hdma_sai1_a.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    hdma_sai1_a.Init.Mode = DMA_CIRCULAR;
    hdma_sai1_a.Init.Priority = DMA_PRIORITY_HIGH;
    hdma_sai1_a.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
//    hdma_sai1_a.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
//	hdma_sai1_a.Init.MemBurst = DMA_MBURST_SINGLE;
//	hdma_sai1_a.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_Init(&hdma_sai1_a) != HAL_OK)
    {
//      _Error_Handler(__FILE__, __LINE__);
    }

    /* DMA2_Stream1_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 1, 0);
    HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);

    /* Several peripheral DMA handle pointers point to the same DMA handle.
     Be aware that there is only one channel to perform all the requested DMAs. */
    __HAL_LINKDMA(hsai,hdmarx,hdma_sai1_a);

    __HAL_LINKDMA(hsai,hdmatx,hdma_sai1_a);

    }
    if(hsai->Instance==SAI1_Block_B)
    {
      /* Peripheral clock enable */
      if (SAI1_client == 0)
      {
       __HAL_RCC_SAI1_CLK_ENABLE();
      }
    SAI1_client ++;
    
    /**SAI1_B_Block_B GPIO Configuration    
    PE3     ------> SAI1_SD_B 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF6_SAI1;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

    /* Peripheral DMA init*/
    
    hdma_sai1_b.Instance = DMA2_Stream0;
    hdma_sai1_b.Init.Request = DMA_REQUEST_SAI1_B;
    hdma_sai1_b.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_sai1_b.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_sai1_b.Init.MemInc = DMA_MINC_ENABLE;
    hdma_sai1_b.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
    hdma_sai1_b.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    hdma_sai1_b.Init.Mode = DMA_CIRCULAR;
    hdma_sai1_b.Init.Priority = DMA_PRIORITY_HIGH;
    hdma_sai1_b.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
//    hdma_sai1_b.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
//    hdma_sai1_b.Init.MemBurst = DMA_MBURST_SINGLE;
//    hdma_sai1_b.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_Init(&hdma_sai1_b) != HAL_OK)
    {
//      _Error_Handler(__FILE__, __LINE__);
    }

    /* DMA interrupt init */
    /* DMA2_Stream0_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0);
    HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);

    /* Several peripheral DMA handle pointers point to the same DMA handle.
     Be aware that there is only one channel to perform all the requested DMAs. */
    __HAL_LINKDMA(hsai,hdmarx,hdma_sai1_b);
    __HAL_LINKDMA(hsai,hdmatx,hdma_sai1_b);
    }
}

100

101

102

103

104

105

106

107

108

109

void HAL_SAI_MspInit(SAI_HandleTypeDef* hsai)

{

GPIO_InitTypeDef GPIO_InitStruct;

/* SAI1 */

if(hsai->Instance==SAI1_Block_A)

{

/* Peripheral clock enable */

if (SAI1_client == 0)

{

__HAL_RCC_SAI1_CLK_ENABLE();

}

SAI1_client ++;

/**SAI1_A_Block_A GPIO Configuration

PE4 ------> SAI1_FS_A

PE5 ------> SAI1_SCK_A

PE6 ------> SAI1_SD_A

GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6;

GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

GPIO_InitStruct.Pull = GPIO_NOPULL;

GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

GPIO_InitStruct.Alternate = GPIO_AF6_SAI1;

HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

/* Peripheral DMA init*/

/* DMA controller clock enable */

__HAL_RCC_DMA2_CLK_ENABLE();

hdma_sai1_a.Instance = DMA2_Stream1;

hdma_sai1_a.Init.Request = DMA_REQUEST_SAI1_A;

hdma_sai1_a.Init.Direction = DMA_PERIPH_TO_MEMORY;

hdma_sai1_a.Init.PeriphInc = DMA_PINC_DISABLE;

hdma_sai1_a.Init.MemInc = DMA_MINC_ENABLE;

hdma_sai1_a.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;

hdma_sai1_a.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;

hdma_sai1_a.Init.Mode = DMA_CIRCULAR;

hdma_sai1_a.Init.Priority = DMA_PRIORITY_HIGH;

hdma_sai1_a.Init.FIFOMode = DMA_FIFOMODE_DISABLE;

// hdma_sai1_a.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;

// hdma_sai1_a.Init.MemBurst = DMA_MBURST_SINGLE;

// hdma_sai1_a.Init.PeriphBurst = DMA_PBURST_SINGLE;

if (HAL_DMA_Init(&hdma_sai1_a) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

/* DMA2_Stream1_IRQn interrupt configuration */

HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 1, 0);

HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);

/* Several peripheral DMA handle pointers point to the same DMA handle.

Be aware that there is only one channel to perform all the requested DMAs. */

__HAL_LINKDMA(hsai,hdmarx,hdma_sai1_a);

__HAL_LINKDMA(hsai,hdmatx,hdma_sai1_a);

}

if(hsai->Instance==SAI1_Block_B)

{

/* Peripheral clock enable */

if (SAI1_client == 0)

{

__HAL_RCC_SAI1_CLK_ENABLE();

}

SAI1_client ++;

/**SAI1_B_Block_B GPIO Configuration

PE3 ------> SAI1_SD_B

GPIO_InitStruct.Pin = GPIO_PIN_3;

GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

GPIO_InitStruct.Pull = GPIO_NOPULL;

GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

GPIO_InitStruct.Alternate = GPIO_AF6_SAI1;

HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

/* Peripheral DMA init*/

hdma_sai1_b.Instance = DMA2_Stream0;

hdma_sai1_b.Init.Request = DMA_REQUEST_SAI1_B;

hdma_sai1_b.Init.Direction = DMA_MEMORY_TO_PERIPH;

hdma_sai1_b.Init.PeriphInc = DMA_PINC_DISABLE;

hdma_sai1_b.Init.MemInc = DMA_MINC_ENABLE;

hdma_sai1_b.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;

hdma_sai1_b.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;

hdma_sai1_b.Init.Mode = DMA_CIRCULAR;

hdma_sai1_b.Init.Priority = DMA_PRIORITY_HIGH;

hdma_sai1_b.Init.FIFOMode = DMA_FIFOMODE_DISABLE;

// hdma_sai1_b.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;

// hdma_sai1_b.Init.MemBurst = DMA_MBURST_SINGLE;

// hdma_sai1_b.Init.PeriphBurst = DMA_PBURST_SINGLE;

if (HAL_DMA_Init(&hdma_sai1_b) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

/* DMA interrupt init */

/* DMA2_Stream0_IRQn interrupt configuration */

HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0);

HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);

/* Several peripheral DMA handle pointers point to the same DMA handle.

Be aware that there is only one channel to perform all the requested DMAs. */

__HAL_LINKDMA(hsai,hdmarx,hdma_sai1_b);

__HAL_LINKDMA(hsai,hdmatx,hdma_sai1_b);

}

SAI Konfiguration

void c_sai::MX_SAI1_Init(void)
{

  hsai_BlockA1.Instance = SAI1_Block_A;
  hsai_BlockA1.Init.AudioMode = SAI_MODESLAVE_RX;
  hsai_BlockA1.Init.Synchro = SAI_ASYNCHRONOUS;
  hsai_BlockA1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;
  hsai_BlockA1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;
hsai_BlockA1.Init.AudioFrequency = SAI_AUDIO_FREQUENCY_48K;
  hsai_BlockA1.Init.SynchroExt = SAI_SYNCEXT_OUTBLOCKA_ENABLE;
  hsai_BlockA1.Init.MonoStereoMode = SAI_STEREOMODE;
  hsai_BlockA1.Init.CompandingMode = SAI_NOCOMPANDING;
  hsai_BlockA1.Init.TriState = SAI_OUTPUT_NOTRELEASED;
  if (HAL_SAI_InitProtocol(&hsai_BlockA1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)
  {
//    _Error_Handler(__FILE__, __LINE__);
  }

  hsai_BlockB1.Instance = SAI1_Block_B;
  hsai_BlockB1.Init.AudioMode = SAI_MODESLAVE_TX;
  hsai_BlockB1.Init.Synchro = SAI_SYNCHRONOUS;
  hsai_BlockB1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;
  hsai_BlockB1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;
  hsai_BlockB1.Init.SynchroExt = SAI_SYNCEXT_DISABLE;
  hsai_BlockB1.Init.MonoStereoMode = SAI_STEREOMODE;
  hsai_BlockB1.Init.CompandingMode = SAI_NOCOMPANDING;
  hsai_BlockB1.Init.TriState = SAI_OUTPUT_NOTRELEASED;
  if (HAL_SAI_InitProtocol(&hsai_BlockB1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)
  {
//    _Error_Handler(__FILE__, __LINE__);
  }

}

void c_sai::MX_SAI1_Init(void)

{

hsai_BlockA1.Instance = SAI1_Block_A;

hsai_BlockA1.Init.AudioMode = SAI_MODESLAVE_RX;

hsai_BlockA1.Init.Synchro = SAI_ASYNCHRONOUS;

hsai_BlockA1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;

hsai_BlockA1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;

hsai_BlockA1.Init.AudioFrequency = SAI_AUDIO_FREQUENCY_48K;

hsai_BlockA1.Init.SynchroExt = SAI_SYNCEXT_OUTBLOCKA_ENABLE;

hsai_BlockA1.Init.MonoStereoMode = SAI_STEREOMODE;

hsai_BlockA1.Init.CompandingMode = SAI_NOCOMPANDING;

hsai_BlockA1.Init.TriState = SAI_OUTPUT_NOTRELEASED;

if (HAL_SAI_InitProtocol(&hsai_BlockA1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

hsai_BlockB1.Instance = SAI1_Block_B;

hsai_BlockB1.Init.AudioMode = SAI_MODESLAVE_TX;

hsai_BlockB1.Init.Synchro = SAI_SYNCHRONOUS;

hsai_BlockB1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;

hsai_BlockB1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;

hsai_BlockB1.Init.SynchroExt = SAI_SYNCEXT_DISABLE;

hsai_BlockB1.Init.MonoStereoMode = SAI_STEREOMODE;

hsai_BlockB1.Init.CompandingMode = SAI_NOCOMPANDING;

hsai_BlockB1.Init.TriState = SAI_OUTPUT_NOTRELEASED;

if (HAL_SAI_InitProtocol(&hsai_BlockB1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

Starten vom Treiber

void c_sai::start(void){

	//Start SAI and DMA Streams
	printf("Initializing SAI DMA Receive stream...\n");
//	printf("Initializing SAI DMA Receive stream...\n");
	HAL_SAI_Receive_DMA(&hsai_BlockA1, (uint8_t*)&rx_buf, 4*buf_size);
	printf("SAI DMA Receive stream initialized!\n");
//	printf("Initializing SAI DMA transmit stream...\n");
	HAL_SAI_Transmit_DMA(&hsai_BlockB1, (uint8_t*)&tx_buf, 4*buf_size);
	printf("SAI DMA transmit stream initialized!\n");

}

void c_sai::start(void){

//Start SAI and DMA Streams

printf("Initializing SAI DMA Receive stream...\n");

// printf("Initializing SAI DMA Receive stream...\n");

HAL_SAI_Receive_DMA(&hsai_BlockA1, (uint8_t*)&rx_buf, 4*buf_size);

printf("SAI DMA Receive stream initialized!\n");

// printf("Initializing SAI DMA transmit stream...\n");

HAL_SAI_Transmit_DMA(&hsai_BlockB1, (uint8_t*)&tx_buf, 4*buf_size);

printf("SAI DMA transmit stream initialized!\n");

}

DMA Interrupts setzen die Flags. Die Software Architektur ist hier beschrieben.

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;

}

Die CODEC-Treiber sind hier beschrieben:

CS4272 CODEC-Schnittstelle für Nucleo H743

WM8731 CODEC-Schnittstelle für Nucleo H743

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

DSP<->Controller Kommunikation

14. Dezember 2019 / solocan / Noch kein Kommentar

Die Hardwarearchitektur vom Flex 500 ist hier beschrieben. Die Kommunikation zwischen DSP und Controller läuft über eine SPI-Schnittstelle. Auf der Controller-Seite werden Mitteilungen interrupt-gesteuert gesendet, da die Mitteilungen von mehreren Instanzen aus geschickt werden können und DMA zu ständigen Unterbrechungen auf der DSP Seite führen würde.

Auf der DSP-Seite wird die Mitteilung, die über SPI-Schnittstelle erhalten werden, mit DMA an den Programmspeicher kopiert. Danach wird ein Interrupt ausgelöst, wonach der DSP den Befehl verarbeiten kann.

Die Struktur der Mitteilung

Die Struktur der Mitteilung ist im folgenden dargestellt.

Bank Id: Die ID der Effekt-Bank.
Type: Der UI-Controller type, der sich geändert hat: Encoder oder Button
Id: Der ID des UI-Controllers (Button number oder Encoder number)
Data: Data in (Float, 32bit, 16bit, 8bit mit oder ohne Vorzeichen)

Die Übertragung der Mitteilung

Die Mitteilung liegt im Programm im Typ „union“, der die Typen

Float
32bit unsigned
16bit unsigned
8bit unsigned

beinhaltet.

union ctrltypes{
	float f32;
	uint32_t u32;
	uint16_t u16[2];
	uint8_t u8[4];
};

union ctrltypes{

float f32;

uint32_t u32;

uint16_t u16[2];

uint8_t u8[4];

};

Daten dieses Typs müssen über SPI übertragen werden. Dabei wird der Vorteil genutzt, dass sowohl Sender als auch der Empfänger gleiche Endianness benutzt. (Beide Cortex-M7) Das heißt, wir können einfach den Speicherbereich, wo die Mitteilung liegt, schicken. Dann castet der Empfänger auf dieselbe Union zurück und die Daten liegen in der erwünschten Struktur beim Empfänger an.

Code vom Sender

HAL_SPI_Transmit(&hspi5, (uint8_t*) ctrl_tx, l_ctrl*4, SPI_TIMEOUT);

1	HAL_SPI_Transmit(&hspi5, (uint8_t) ctrl_tx, l_ctrl4, SPI_TIMEOUT);

wobei ctrl_tx des Typs „Unions“ ist.

Code vom Empfänger

void c_com_ctrl::apply_update(void)
{
	//Copy incoming message to union
	memcpy(rx_com,ctrl_rx,4*l_ctrl);
        //Applying the update
        //...
}

void c_com_ctrl::apply_update(void)

{

//Copy incoming message to union

memcpy(rx_com,ctrl_rx,4*l_ctrl);

//Applying the update

//...

}

Ressourcen

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

DSP – Targetcode vom herunterladen

Controller- Targetcode vom herunterladen

Hardware Architektur – Verteiltes System

14. Dezember 2019 / solocan / Noch kein Kommentar

Übliche Systemarchitektur eines Audioprozessorsystems wie das vom Flex 500 ist ein verteiltes System. Die Aufgaben werden dabei auf mehrere Prozessoren verteilt. Bei einer leistungs- und echtzeitkritischen Anwendung wie ein Audio-Prozessor ist das oft unverzichtbar.

Hardware-Architektur

Die Hardware-Architektur vom Flex 500 ist im folgenden Bild gezeigt:

Audio-DSP

Spezialisierte Audio-DSP-Chips

Der Kern eines typischen Audio-Prozessors ist ein DSP-Chip. Lange Zeit wurden dafür ausschließlich dafür konzipierte Audio-DSPs, wie z.B. die von Texas Instruments und Analog devices eingesetzt. Die Audio-DSPs haben Befehlsätze, die für Audiodatenverarbeitung typisch sind und eine effiziente hardwaregestütze Verarbeitung der Daten ermöglichen. Dazu gehören viele spezialisierte SIMD-Befehle. (Single Instruction Multiple data) wie MACs (Multiplier+Accumulator). Diese ermöglichen schnelle Verarbeitung von z.B. Biquad-Filtern, ein sehr verbreitetes digitales Filter oder aber auch viele andere Algorithmen, wo sequentielle Multiplikation und Addition-Folgen größerer Daten nötig ist.

MehrZweck-Mikroprozessoren (General purpose Microprocessors)

Mittlerweile sind die Leistung und die Befehlssätze der Mikroprozessoren rasant gestiegen. Heutzutage sind viele Prozessoren mehrere Hundert Megahertz schnell getaktet und bieten u. a. DSP-Einheiten für SIMDs und Gleitkommazahl-Einheiten (FPUs). Aufgrund ihrer breiten Verfügbarkeit und vielseitiger Einsatzmöglichkeiten jenseits der Audio-Verarbeitung, sind die Mehrzweck-Mikroprozessoren zu einer echten Alternative gegenüber der herkömmlichen Audio-DSPs geworden.

Ein Spitzenreiter unter denen ist die Prozessoren auf Basis von ARM Cortex-M7. Diese Prozessoren sind bis zu 600MHz getaktet, besitzen DSP und FPU Einheiten. Ein Vergleich von Cortex-basierten Prozessoren gegenüber der herkömmlichen, verbreiteten Produkte von Texas Instruments und Analog devices ist im folgenden Artikel detailliert aufgeführt:

Choosing the best processor for your DSP application

DSP capabilities of Cortex Processors

In diesen Studien ist sichtbar, dass die High-End Spezialprozessoren für manche spezialisierte Tasks wie MAC-Leistung immer noch die Nase vorne haben. Allerdings sind die Cortex Prozessoren auch sehr leistungsfähig und können ihre Stärken bei allgemeineren Tasks spielen, wofür die Spezialprozessoren keine HW-Unterstützung anbieten.

Aus den genannten Aspekten wurde für den Flex 500 ein STM32H743 mit 400MHz Taktrate, DSP und FPU-Einheiten gewählt.

Controller-Chip

Ein Controller-Chip übernimmt oft alle sonstigen Aufgaben wie die allgemeinen Verwaltungsaufgaben, GUI-Steuerung, Anzeige etc. Die Echtzeitansprüche an den Controller-Chip ist niedrig, dafür muss er viele Tasks abarbeiten. DSP und Controller-Chips unterscheiden sich voneinander vor allem in deren Softwarearchitektur.

Der DSP-Chip muss mehrere Tasks schedulen und abarbeiten. Eine Middleware wie FreeRTOS ist dafür sehr gut geeignet, wenn die Komplexität und die Tasks steigt. Man kann auch „Bare-metal“ programmieren und eigenen Scheduler schreiben.

Je nach benötigter Leistung und Peripherien kann man einen Mikroprozessor wählen, der diese Aufgaben erledigt. Auch hierbei ist ARM Cortex-M sehr gut geeignet und verbreitet.

Beim Flex 500 muss der Mikrocontroller

GUI Inputs und Outpus managen
Eine kleine Grafikbibliothek treiben
Kommunikation zum DSP aufbauen.
Expression-Pedal und Fußschalter treiben
Sonstige HW steuern (Leistungsstufe etc.)

Als Controller von Flex 500 ist der STM32F767 von ST gewählt, der mit 216MHz Taktfrequenz und zahlreiche Schnittstellen all diese Aufgaben erledigen kann. Für diesen Zweck ist vermutlich auch ein kleinerer Cortex-M4 vollständig ausreichend.

Display-Treiber

Der Controller-Chip ist von der Prozessorleistung her sehr stark und besitzt auch ein Display-Treiber. Allerdings ist die verfügbare interne RAM mit 512 sehr knapp für Grafikanwendungen. Um die interne RAM für sonstige Aufgaben freizuhalten, ist ein externer Display-Treiber gewählt.

Die Lösung für Display hängt stark von Anforderungen an. Eine sehr gute Übersicht ist im folgenden Paper von ST verfügbar:

LCD-TFT display controller (LTDC) on STM32 MCUs

Beim Flex 500 ist ein Display mit integriertem Chip ILI9341 eingesetzt.

DSP Architektur

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.

WM8731 CODEC-Schnittstelle für Nucleo H743

7. Dezember 2019 / solocan / Noch kein Kommentar

Die WM8731 ist ein Budget-Klasse-Stereo Audio-CODEC von Cirrus Logic für mobile Applikationen. Es unterstützt 24bit Bittiefe, bis zu 96kHzAbtastrate und besitzt einen dynamischen Bereich vom 90db für ADC und 100dB für DAC .

Für Flex 500 wurde ein Breakout-Board für WM8731 entwickelt, das man direkt auf ein Nucleo Board stecken kann.

Board-Design

Folgendes auf Referenzdesign basiertes Design wurde für das Breakout board entwickelt.

Analoge Ein- und Ausgänge

Da WM8731 für mobile Anwendungen mit knappem Platz entwickelt ist, kommt es ohne zusätzlichen Eingangs- und Ausgangsstufen klar. Dafür unterstützt es nur unsymmetrische Ein- und Ausgänge.

Dafür hat es einen integrierten Kopfhörerverstärker. Auf dem Board befinden sich Line-In/Out und Kopfhörer-Anschlüsse.

Oszillator

Ein 24,576 MHz Oszillator ist eingebaut und gibt den Takt an den Master-Clock.

Ressourcen

Die KiCad Schaltung- und PCB-Designdaten herunterladen

Kompletter Programmcode für H743-Target

CS4272 CODEC-Schnittstelle für Nucleo H743

7. Dezember 2019 / solocan / Noch kein Kommentar

Die CS4272 ist ein hochwertiges Stereo Audio-CODEC von Cirrus Logic für anspruchsvolle Implementierungen. Es unterstützt 24bit Bittiefe, bis zu 192kHz Abtastrate und besitzt einen dynamischen Bereich vom 114dB.

Für Flex 500 wurde ein Breakout-Board für CS4272 entwickelt, das man direkt auf ein Nucleo Board stecken kann.

PCB Design

CS4272 CODEC- Breakout board im Betrieb

Board-Design

CS4272 unterstützt 2x symmetrische Eingänge und hat 2x symmetrische Ausgänge.

Symmetrische Eingänge

Die Nutzsignale vom analogen Preamp-Board sind Wechselspannungen, da Preamp-Board symmetrische Spannungsversorgung von $+-15V$ hat. Für die symmetrischen Eingänge muss das Signal vom Preamp-Board in einen Pegel von $V_{pp}<5V$ gebracht werden. Danach muss eine Gleichspannung $V_{alias}=2,5V$ addiert werden, damit das Eingangssignal in den erlaubten Bereich vom CS4272 $0V\leq V_{i} \leq5V$ gebracht werden. Das wird in der untenstehenden Schaltung realisiert:

Bei diesem Design handelt es sich um das Referenzdesign von CS4272. Hierbei wird die Alias-Spannung $V_{com}=2,5V$ auf die durch die Kondensatoren C_INAx entkoppelte Eingangsspannung addiert und ein Eingangspuffer hinzugefügt.

Symmetrische Ausgänge

Die analogen Ausgänge vom CS4272 symmetrisch und für weitere Verarbeitung desymmetriert werden. Das wurde mit folgender Schaltung realisiert.

Hierbei werden die symmetrischen Signale $V_{OUT,A+}$ und $V_{OUT,A-}$ in einer Stufe voneinander abgezogen. Danach wird mit dem Ausgangskondesator C_OUTA6 der Gleichstrom herausgefiltert. Schließlich arbeitet die ganze Schaltung auf einen Lastwiderstand von $R_L=47k\Omega$ . Hierbei handelt es sich um das Referenz Design von CS4272.

Digitale Schnittstellen

Das Breakout-Board unterstützt SPI und I2C Schnittstellen zum Controller.

Initialisierungssequenz

Die Initialisierungssequenz von CS4272 ist im folgenden Code gezeigt.

void cs4272::init(void){


	//Initialize SPI
	printf("Initing SPI5\n");
	MX_SPI5_Init();


	printf("Initing codec\n");

	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_0,(GPIO_PinState)0); //RST low

		uint8_t i=0;
		uint8_t reg[8][3];
		uint8_t adr=0b00100000;

		//Init address
		for(i=0;i<sizeof(reg)/3;i++){
			reg[i][0]=adr;
		}

		//Define startup sequence
		reg[0][1]=0x7; //Power down control
		reg[0][2]=0b00000011; //Set Serial mode + power down

		reg[1][1]=0x1; //Mode control 1
		reg[1][2]=0b00101001; //48kHz Master

		reg[2][1]=0x2;	//DAC Control
		reg[2][2]=0b00000000;

		reg[3][1]=0x3; //DAC Volume control
		reg[3][2]=0b00001001;

		reg[4][1]=0x4;	//DAC Volume A
		reg[4][2]=0b10000000; //No mute + 0dB

		reg[5][1]=0x5;	//DAC Volume B
		reg[5][2]=0b10000000; //No mute + 0dB

		reg[6][1]=0x6;	//ADC Control
		reg[6][2]=0b00010000;

		reg[7][1]=0x7;	//Mode control 2
		reg[7][2]=0b00001010;
	//	reg[7][2]=0b00010010;//Loop ADC->DAC


		HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)1); //MS high: SPI Unselect device
		HAL_GPIO_WritePin(GPIOG,GPIO_PIN_0,(GPIO_PinState)1); //RST High
		HAL_Delay(2); //Wait
		//HAL_GPIO_WritePin(GPIOG,GPIO_PIN_0,0); //RST Low

		for(i=0;i<sizeof(reg)/3;i++){
			HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)0); //MS low: SPI Select device
			HAL_SPI_Transmit(&hspi5,(uint8_t *)&reg[i],3,1000); //Send config register
			HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)1);//MS high: SPI Unselect device
			HAL_Delay(1); //Wait

		}
}

void cs4272::init(void){

//Initialize SPI

printf("Initing SPI5\n");

MX_SPI5_Init();

printf("Initing codec\n");

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_0,(GPIO_PinState)0); //RST low

uint8_t i=0;

uint8_t reg[8][3];

uint8_t adr=0b00100000;

//Init address

for(i=0;i<sizeof(reg)/3;i++){

reg[i][0]=adr;

}

//Define startup sequence

reg[0][1]=0x7; //Power down control

reg[0][2]=0b00000011; //Set Serial mode + power down

reg[1][1]=0x1; //Mode control 1

reg[1][2]=0b00101001; //48kHz Master

reg[2][1]=0x2; //DAC Control

reg[2][2]=0b00000000;

reg[3][1]=0x3; //DAC Volume control

reg[3][2]=0b00001001;

reg[4][1]=0x4; //DAC Volume A

reg[4][2]=0b10000000; //No mute + 0dB

reg[5][1]=0x5; //DAC Volume B

reg[5][2]=0b10000000; //No mute + 0dB

reg[6][1]=0x6; //ADC Control

reg[6][2]=0b00010000;

reg[7][1]=0x7; //Mode control 2

reg[7][2]=0b00001010;

// reg[7][2]=0b00010010;//Loop ADC->DAC

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)1); //MS high: SPI Unselect device

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_0,(GPIO_PinState)1); //RST High

HAL_Delay(2); //Wait

//HAL_GPIO_WritePin(GPIOG,GPIO_PIN_0,0); //RST Low

for(i=0;i<sizeof(reg)/3;i++){

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)0); //MS low: SPI Select device

HAL_SPI_Transmit(&hspi5,(uint8_t *)&reg[i],3,1000); //Send config register

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)1);//MS high: SPI Unselect device

HAL_Delay(1); //Wait

}

Nach der Initialisierung kann das CODEC aktiviert und deaktiviert werden.

void cs4272::set_status(bool flag){
	uint8_t mutereg[3];
	mutereg[0]=0b00100000;
	mutereg[1]=0x4; //DAC Volume control A register (MUTECA=B is on)

	if(flag){
		mutereg[2]=0b00000000;
	}else{
		mutereg[2]=0b10000000;
	}

	//Send SPI command to CODEC
	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)0); //MS low: SPI Select device
	HAL_SPI_Transmit(&hspi5,(uint8_t *)&mutereg,3,1000); //Send config register
	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)1);//MS high: SPI Unselect device
}

void cs4272::set_status(bool flag){

uint8_t mutereg[3];

mutereg[0]=0b00100000;

mutereg[1]=0x4; //DAC Volume control A register (MUTECA=B is on)

if(flag){

mutereg[2]=0b00000000;

}else{

mutereg[2]=0b10000000;

}

//Send SPI command to CODEC

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)0); //MS low: SPI Select device

HAL_SPI_Transmit(&hspi5,(uint8_t *)&mutereg,3,1000); //Send config register

HAL_GPIO_WritePin(GPIOG,GPIO_PIN_1,(GPIO_PinState)1);//MS high: SPI Unselect device

}

Der SAI von H743 muss folgendermaßen konfiguriert sein:

void c_sai::MX_SAI1_Init(void)
{

  hsai_BlockA1.Instance = SAI1_Block_A;
  hsai_BlockA1.Init.AudioMode = SAI_MODESLAVE_RX;
  hsai_BlockA1.Init.Synchro = SAI_ASYNCHRONOUS;
  hsai_BlockA1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;
  hsai_BlockA1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;
hsai_BlockA1.Init.AudioFrequency = SAI_AUDIO_FREQUENCY_48K;
  hsai_BlockA1.Init.SynchroExt = SAI_SYNCEXT_OUTBLOCKA_ENABLE;
  hsai_BlockA1.Init.MonoStereoMode = SAI_STEREOMODE;
  hsai_BlockA1.Init.CompandingMode = SAI_NOCOMPANDING;
  hsai_BlockA1.Init.TriState = SAI_OUTPUT_NOTRELEASED;
  if (HAL_SAI_InitProtocol(&hsai_BlockA1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)
  {
//    _Error_Handler(__FILE__, __LINE__);
  }

  hsai_BlockB1.Instance = SAI1_Block_B;
  hsai_BlockB1.Init.AudioMode = SAI_MODESLAVE_TX;
  hsai_BlockB1.Init.Synchro = SAI_SYNCHRONOUS;
  hsai_BlockB1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;
  hsai_BlockB1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;
  hsai_BlockB1.Init.SynchroExt = SAI_SYNCEXT_DISABLE;
  hsai_BlockB1.Init.MonoStereoMode = SAI_STEREOMODE;
  hsai_BlockB1.Init.CompandingMode = SAI_NOCOMPANDING;
  hsai_BlockB1.Init.TriState = SAI_OUTPUT_NOTRELEASED;
  if (HAL_SAI_InitProtocol(&hsai_BlockB1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)
  {
//    _Error_Handler(__FILE__, __LINE__);
  }

}

void c_sai::start(void){

	//Start DMA Streams
	printf("Initializing SAI DMA Receive stream...\n");
//	printf("Initializing SAI DMA Receive stream...\n");
	HAL_SAI_Receive_DMA(&hsai_BlockA1, (uint8_t*)&rx_buf, 4*buf_size);
	printf("SAI DMA Receive stream initialized!\n");
//	printf("Initializing SAI DMA transmit stream...\n");
	HAL_SAI_Transmit_DMA(&hsai_BlockB1, (uint8_t*)&tx_buf, 4*buf_size);
	printf("SAI DMA transmit stream initialized!\n");

}

void c_sai::MX_SAI1_Init(void)

{

hsai_BlockA1.Instance = SAI1_Block_A;

hsai_BlockA1.Init.AudioMode = SAI_MODESLAVE_RX;

hsai_BlockA1.Init.Synchro = SAI_ASYNCHRONOUS;

hsai_BlockA1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;

hsai_BlockA1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;

hsai_BlockA1.Init.AudioFrequency = SAI_AUDIO_FREQUENCY_48K;

hsai_BlockA1.Init.SynchroExt = SAI_SYNCEXT_OUTBLOCKA_ENABLE;

hsai_BlockA1.Init.MonoStereoMode = SAI_STEREOMODE;

hsai_BlockA1.Init.CompandingMode = SAI_NOCOMPANDING;

hsai_BlockA1.Init.TriState = SAI_OUTPUT_NOTRELEASED;

if (HAL_SAI_InitProtocol(&hsai_BlockA1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

hsai_BlockB1.Instance = SAI1_Block_B;

hsai_BlockB1.Init.AudioMode = SAI_MODESLAVE_TX;

hsai_BlockB1.Init.Synchro = SAI_SYNCHRONOUS;

hsai_BlockB1.Init.OutputDrive = SAI_OUTPUTDRIVE_DISABLE;

hsai_BlockB1.Init.FIFOThreshold = SAI_FIFOTHRESHOLD_EMPTY;

hsai_BlockB1.Init.SynchroExt = SAI_SYNCEXT_DISABLE;

hsai_BlockB1.Init.MonoStereoMode = SAI_STEREOMODE;

hsai_BlockB1.Init.CompandingMode = SAI_NOCOMPANDING;

hsai_BlockB1.Init.TriState = SAI_OUTPUT_NOTRELEASED;

if (HAL_SAI_InitProtocol(&hsai_BlockB1, SAI_I2S_STANDARD, SAI_PROTOCOL_DATASIZE_32BIT, 2) != HAL_OK)

{

// _Error_Handler(__FILE__, __LINE__);

}

void c_sai::start(void){

//Start DMA Streams

printf("Initializing SAI DMA Receive stream...\n");

// printf("Initializing SAI DMA Receive stream...\n");

HAL_SAI_Receive_DMA(&hsai_BlockA1, (uint8_t*)&rx_buf, 4*buf_size);

printf("SAI DMA Receive stream initialized!\n");

// printf("Initializing SAI DMA transmit stream...\n");

HAL_SAI_Transmit_DMA(&hsai_BlockB1, (uint8_t*)&tx_buf, 4*buf_size);

printf("SAI DMA transmit stream initialized!\n");

}

Oszillator

Ein 24,576 MHz Oszillator ist eingebaut und gibt den Takt an den Master-Clock.

Ressourcen

SPICE-Simulationsdateien zu analogen Schnittstellen für CS4272 herunterladen

Die KiCad Schaltung- und PCB-Designdaten herunterladen

Kompletter Programmcode für H743-Target

Digitaler Distortion-Effekt

6. Dezember 2019 / solocan / Noch kein Kommentar

Der Distortion (dt. Verzerrung)-Effekt basiert auf starkem Übersteuern und/oder Limitieren eines Signals. Er ist ein sehr beliebter und verbreiteter E-Gitarreneffekt. Mit dem Effekt kann man sowohl mildere „Overdrive“ als auch starke „Metal“-Sounds erreichen.

Technisch basiert es in analoger Ausführung auf hartem Limitieren des Signals (Clipping) mit Hilfe von Dioden oder Übersteuern von Röhren. Davor und danach werden Filter und sonstige Effekte eingebaut, um einen guten Klang zu erzielen.

In digitaler Ausführung kann hingegen mit verschiedenen mathematischen Ansätzen gearbeitet werden, die analog schwer bis unmöglich umzusetzen sind., wie z.B. Parabeln und exponentiellen Funktionen.

Das harte Limitieren eines 1kHz Sinussignals kann man sich folgendermaßen vorstellen.

Rendered by QuickLaTeX.com

Mathematisch lässt sich das als

(1) $\begin{equation*} \begin{aligned} y=-y_{th} \quad &wenn\quad \sin(x)<-y_{th} \\ y=\sin(x) \quad &wenn\quad -y_{th}< \sin(x)< y_{th} \\ y=y_{th} \quad &wenn\quad \sin(x)>y_{th} \end{aligned} \end{equation*}$

beschreiben, wobei $y_{th}$ der Threshold-Wert ist, ab dem das Clipping erfolgt.

Auf dieser Grafik fallen zwei Sachen auf:

Ab dem Clipping stellt man den Pegel auf einen konstanten Wert : Gleichstrom!
Die Übergänge haben einen Knick =>Sehr hohe Frequenzen

Die Verzerrung tiefe Verzerrung wird als sehr unangenehm empfungen. Der Gleichstrom ( $f=0$ ) ist sogar schädlich für die Lautsprecher (wobei der üblicherweise von der Leistungselektronik herausgefiltert wird)

Das heißt, das einfache Clipping erzeugt zwar einen Distortion-Sound aber keinen Guten. Eine bessere Möglichkeit zum Verzerren ist die Anwendung von Soft-Clipping mit mathematischen Funktionen. Ein weicher Übergang zum Clipping und danach ein leichtes Überschwingen ist wünschenswert, um Gleichstrom zu vermeiden. Das kann mit folgender exponentiellen Funktion erreicht werden.

(2) $\begin{equation*} y=sgn(x) [1-e^{-k x sgn(x)}] \end{equation*}$

oder als teilweise Funktion

(3) $\begin{equation*} \begin{aligned} y=1-e^{-k x} \quad& \text{wenn} \quad x\geq0 \\ y=-1+e^{k x} \quad& \text{wenn} \quad x<0 \end{aligned} \end{equation*}$

,wobei der Skalierungsfaktor $k$ als Vorverstärkung gesehen werden kann.

Im folgenden ist diese Signalform mit den Verstärkungsfaktoren $k=1$ und $k=5$ dargestellt.

Rendered by QuickLaTeX.com

Es gibt auch andere mathematische Ansätze, die ein Soft-Clipping modellieren und oft Zusammensetzung gestückelter Polynome sind.

Das Herzstück der Verzerrung ist also das Clipping, wobei dies noch lange nicht alles bei einem guten Distortion-Sound ist. Es gibt noch etwas unvernachlässigbares bei einem Distortion-Algorithmus: Die Frequenzfilter.

Hochpassfilter/Kuhschwanzfilter für Tiefen

Verzerrung von tiefen Frequenzen werden als sehr unangenehm empfunden. Daher möchte man oft einen Hochpassfilter vor dem Clipping-Block einschalten, um die tiefen Frequenzen herauszufiltern. Zudem entsteht bei Clipping sogar noch zusätzlich tiefe Frequnzen, Diese müssen dann nach dem Clipping herausgefiltert werden.

Tiefpassfilter / Kuhschwanzfilter für Höhen

Nach dem Clipping erhalten wir oft einen Sound, der je nach Clipping sehr kratzig klingen kann, weil erstens verzerrte Hochfrequenzen unangenehm empfunden werden als auch wir durch Clipping zusätzlich Hochfrequenzen erzeugen. Deshalb können wir nach dem Clipping auch einen Tiefpassfilter schalten und alle hohe Frequenzen dämpfen, um einen „runderen“ und weniger „kratzigen“ Klang zu erzielen.

Sonstige Bestandteile der Verzerrung

Oft haben schöne Distortion-Sounds viel mehr Komponenten als nur Clipping. Diese sind v.a.

Kompressoren vor und/oder nach dem Clipping
Zusätzliche Frequenzfilter für die Betonung
Zusätzliche Polynomfilter (Röhrensimulation)
Phaser / Doubler (Frequenzauslöschungen)
Asymmetrische Clipper (Röhren-ähnliche Distortion / Overdrive Sounds)

Die Zusammensetzung des Distortion Sounds hängt also neben dem Clipping-Algorithmus auch von anderen Komponenten, die für einen angenehmen verzerrten Sound sorgen.

Parameter

Folgende Kontrollparameter sind für einen Flanger-Effekt üblich:

Vorverstärkung (Gain)

Die Stärke des Clippings hängt hauptsächlich vor unserer Vorskalierung $k$ ab. Das ist der Hauptparameter einer Distortion. Alles andere ist im Grunde optional. In der Benutzeroberfläche befinden sich nicht die Parameter einzelner Komponenten, sondern verschiedene künstliche Parameter wie „Presence“ oder gar Verstärkertypen „Brit, Vox, Marshall, etc.“, wobei diese empirisch ermittelter Parametersätze für die verwendeten Blöcke sind.

Nachverstärkung/Korrektur (Post-gain/Volume)

Dieser Parameter ist dafür da, um wieder auf den Pegel zurückzukommen von dem man sich durch das Clipping ggf. entfernt hat. Manchmal ist dieser Parameter nicht an den Endbenutzer weitergegeben, sondern durch Vorverstärkung berechnet.

Implementierung

Im folgenden ist ein grundlegender Distortion/Overdrive mit einem vorgeschalteten Hochpassfilter und nachgeschaltetem Tiefpassfilter implementiert.

/*
Main process of overdrive
*/
float c_overdrive::process(float x){

	float y;

	x=pre_filter.process(x);

	x=x*downscaler*gain;

	//Algorithm 1: y=sign(x)*(1-e(-1*sign(x)*x))
	if(x>0){
		y=1-exp(-1*x);
	}else{
		y=-1+exp(x);
	}

	y=y*upscaler;

	y=post_filter.process(y);

	return y;
}

Main process of overdrive

float c_overdrive::process(float x){

float y;

x=pre_filter.process(x);

x=x*downscaler*gain;

//Algorithm 1: y=sign(x)*(1-e(-1*sign(x)*x))

if(x>0){

y=1-exp(-1*x);

}else{

y=-1+exp(x);

}

y=y*upscaler;

y=post_filter.process(y);

return y;

}

Klangbeispiele

Anbei ist dieser Algorithmus mit ein paar verschiedenen Parametern zu hören.

Gitarre - Rythmus trocken

Gitarre - Distortion - Kein Hochpass, kein Tiefpass

Gitarre - Distortion - Hochpass: 350Hz - Kein Tiefpass

Gitarre - Distortion - Hochpass: 350Hz - Tiefpass 4500Hz

Gitarre - Distortion - Hochpass: 350Hz - Tiefpass 3500Hz

Gitarre - Distortion - Hochpass: 350Hz - Tiefpass 2500Hz

Overdrive - Synthy

Flex 500 – Controller

5. Dezember 2019 / solocan / Noch kein Kommentar

GUI
- Display
  - Steuerung eines Display-Moduls mit ILI9341
  - Ein einfacher Grafikprozessor
- Benutzereingaben
  - Architektur einer bare-metal-GUI
  - Auslesen der Drehgeber
    - Gray code
  - Auslesen der Buttons
    - Tastenentprellung
- Kommunikationsarchitektur zweier Prozessoren
  - Serielle Kommunikation
  - SPI DMA
  - Startup / Handshake
  - (Pipelining)
- Externe Controller
  - Expressionpedal über STM32-ADC einlesen
  - Fußschalterinterface

Flex 500 – DSP Übersicht

5. Dezember 2019 / solocan / Noch kein Kommentar

Der Flex 500 besitzt einen DSP auf Basis vom Nucleo Board STM32H743 und ein selbstentwickeltes Breakoutboard auf Basis CS4272 (HQ Variante) oder WM8731 (Cost-opt Variante).

Es ist eine eigene Simulationsumgebung für die DSP-Entwicklung verfügbar.

Übersicht der technischen Dokus

Echtzeit-Audiodatenverarbeitung
Digitale Filter
Digitale Effekte
- Chorus
- Flanger
- Rotary
Dynamik

Digitaler Dynamikkompressor

29. November 2019 / solocan / Noch kein Kommentar

Die Dynamikkompression (engl. Dynamic range compression) ist ein Prozess, der die Dynamik komprimiert bzw. reduziert. Das wird gemacht, indem die lauten Bereiche, die einen Schwellwert überschreiten, leiser gemacht werden, während die leiseren Bereiche unreduziert passieren. Die Charakteristik der Kompression lässt sich am Besten in einer Dynamikkurve darstellen, die die Beziehung zwischen der Einganglautstärke und Ausgangslautstärke beschreibt.

Die Steigung $\frac{b}{a}$ beschreibt die Kompressionsrate, mit der das Signal abgeschwächt wird. Dies greift ab dem Überschreiten eines Threshold-Werts.

Digitale Realisierung

Das Herzstück eines Kompressors ist ein spannungskontrollierter Verstärker (VCA). Im analogen Design, wird das mit komplexen Schaltungen realisiert. In der Digitaltechnik ist dies ein simpler Verstärkungsfaktor, mit dem das Signal multipliziert wird. Dieser Verstärkungsfaktor wird in einem parallelen Pfad berechnet. Der parallele Pfad besteht aus einem Lautstärkendetektor (in der Regel realisiert mit Effektivleistung, RMS) und einer Logik, die die Reduktion aus der Lautstärke berechnet (Gain computer).

Loudness detector

Einer der wichtigsten Bestandteile einer Kompression ist die Berechnung der Lautstärke, Hier wird kontinuierlich ermittelt, wie hoch die empfundene Lautstärke ist. Gängigste Methode dafür ist der Effektivwert als quadratischer Mittelwert des relevanten Sampleabschnitts.

(1) $\begin{equation*} RMS=\sqrt{\frac{1}{n}\sum_{i=1}^{n}x_i^2} \end{equation*}$

Der RMS-Wert dient als Eingang für den Gain-Computer. Der Gain-Computer berechnet daraus die Verstärkung, die dem Signal appliziert werden soll. Es appliziert die Dynamikkurve, s. oben.

Parameter

Folgende Kontrollparameter sind für einen Kompressor Effekt üblich:

Input gain

Die Eingangsverstärkung wird auf das Eingangssignal appliziert, um das Signalniveau in einen gewünschten Platz in der Dynamikkurve zu platzieren. Alternativ kann man auch Threshold verschieben.

Threshold

Der Threshold (dt. für Schranke/Grenze) ist der Grenzwert, ab dessen Überschreitung eine Gain-Reduktion erfolgt, s. Diagramm.

Kompressionsrate

Sie beschreibt die Stärke der Gain-Reduktion nach Threshold, in der Dynamikkurve ist dies als Tangenzwert $\frac{b}{a}$ gezeigt.

Ab einem Wert von 60:1 wird von einem Limiter gesprochen.

Make-Up Gain

Der Gain-Computer appliziert eine Gain-Reduktion. Das bedeutet, die gesamte Lautstärke des Signals sinkt. Um das ältere Lautstärkenniveau zu erreichen, wird ein Make-Up Gain am Ausgang appliziert.

Soft-Knee / Hard-Knee

Ab dem Threshold ändert sich die Verstärkung, die man appliziert. Dieser Übergang, der in der Dynamikkurve oben scharf gezeichnet wurde, kann auch mild erfolgen. So dass die Gain-Reduktion langsam eintritt.

Attack

Der Attack-Wert bestimmt, wann die Gain-Reduktion nach einer Überschreitung eintreten soll. Sie liegt im Bereich von 5 bis 250 ms.

Release

Der Release-Wert bestimmt, wann nach einer Unterschreitung des Tresholds die Gain-Reduktion wieder aussetzen soll. Sie liegt üblicherweise im Bereich von 5 bis 100ms.

Implementierung

Im folgenden ist die Prozessroutine eines Kompressors gezeigt:

/*
Compressor main process
*/
float c_compressor::process(float x){

 	x*=input_gain;

	//Calculate RMS

	//Subtract oldest the value (rmsbuf[rptr]) from the sum
	rms_sum-=(rmsbuf[rptr]*rmsbuf[rptr])/(float)rms_len;

	//Add the newest value to the sum
	rms_sum+=(x*x)/rms_len;

	if(rms_sum<0){
		printf("Warning: RMS sum negaive %f\n",rms_sum);
		rms_sum=0;
	}


	//Update the RMS Value
	c_rms=fast_sqroot(rms_sum);

	//Get logarithmic value
	c_rms=fast_log2(c_rms);

	//Update the buffer
	rmsbuf[rptr]=x;

	//Increment
	rptr++;

	if(rptr>=rms_len){
		rptr=0;;
	}

	//Update main buf

	//Output is the last value on the buffer
	float y;
	y=buf[ptr];

	//Set the new value to the buffer
	buf[ptr]=x;

	//Increment
	ptr++;

	if(ptr>=delay_len){
		ptr=0;;
	}

	//Calculating attenuation
	float exponent;

	if(c_rms>threshold){

		//Calculating exponent according Udo Zölzer
		exponent=-1*(c_rms-threshold)*slope;

		//Exponents smaller than -1500 are making fast algorithms unstable
		if(exponent<-100){
			target_gain=0;
		}else{
			target_gain=fastPow(2,exponent);
//			target_gain=pow(2,exponent);

		}
	}else{
		target_gain=1;
	}

	//Attack and release
	if(comp_gain>target_gain){

		//Attack
		comp_gain-=stepsize_attack;

		//Break decreasing
		if(comp_gain<=target_gain){
			comp_gain=target_gain;
		}
	}else{

		//Release
		comp_gain+=stepsize_release;

		//Break increasing
		if(comp_gain>=1){
			comp_gain=1;
		}

         }

	return y*comp_gain;;
}

Compressor main process

float c_compressor::process(float x){

x*=input_gain;

//Calculate RMS

//Subtract oldest the value (rmsbuf[rptr]) from the sum

rms_sum-=(rmsbuf[rptr]*rmsbuf[rptr])/(float)rms_len;

//Add the newest value to the sum

rms_sum+=(x*x)/rms_len;

if(rms_sum<0){

printf("Warning: RMS sum negaive %f\n",rms_sum);

rms_sum=0;

}

//Update the RMS Value

c_rms=fast_sqroot(rms_sum);

//Get logarithmic value

c_rms=fast_log2(c_rms);

//Update the buffer

rmsbuf[rptr]=x;

//Increment

rptr++;

if(rptr>=rms_len){

rptr=0;;

}

//Update main buf

//Output is the last value on the buffer

float y;

y=buf[ptr];

//Set the new value to the buffer

buf[ptr]=x;

//Increment

ptr++;

if(ptr>=delay_len){

ptr=0;;

}

//Calculating attenuation

float exponent;

if(c_rms>threshold){

//Calculating exponent according Udo Zölzer

exponent=-1*(c_rms-threshold)*slope;

//Exponents smaller than -1500 are making fast algorithms unstable

if(exponent<-100){

target_gain=0;

}else{

target_gain=fastPow(2,exponent);

// target_gain=pow(2,exponent);

}

}else{

target_gain=1;

}

//Attack and release

if(comp_gain>target_gain){

//Attack

comp_gain-=stepsize_attack;

//Break decreasing

if(comp_gain<=target_gain){

comp_gain=target_gain;

}

}else{

//Release

comp_gain+=stepsize_release;

//Break increasing

if(comp_gain>=1){

comp_gain=1;

}

return y*comp_gain;;

}

Quadratwurzel (Root square) Implementierung

Eine der wichtigsten Komponenten des Kompressors ist der RMS-Rechner. Der Aufwand der Berechnung der Quadratsumme ist eine Multiplikation und eine Addition. Hingegen ist die Quadratwurzelberechnung eine sehr aufwändige Berechnung, die den Flaschenhals darstellt. Hierzu gibt es effiziente Algorithmen, die dies übernehmen. Ein davon (hier eingesetzter) Algorithmus ist der berühmte „fastsqroot„-Algorithmus. Dieser Algorithmus ist ursprünglich für Videoverarbeitung entwickelt und mittlerweile gut analysiert und breit eingesetzt.

inline double fastPow(double a, double b) {
   union {
      double d;
      int x[2];
   } u = { a };
   u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447);
   u.x[0] = 0;
   return u.d;
};

inline double fastPow(double a, double b) {

union {

double d;

int x[2];

} u = { a };

u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447);

u.x[0] = 0;

return u.d;

};

Potenzimplementierung

Der berechnete RMS-Wert wird in einen logarithmischen Wert umgerechnet, woraus sich die wahrgenommene Lautstärke $\overline{RMS}$ ergibt. Jeder Mensch empfindet die Lautstärke anders. Mann kann den Logarithmus auf 2 Basis, 10 Basis oder natürlichen Logarithmus nehmen.

(2) $\begin{equation*} \overline{RMS}={Base}^{RMS} \end{equation*}$

Die Potenzberechnung der Gleitkommazahlen ist auch eine teure Operation. Die Funktion pow() der Mathe-Bibliothek ist selbst auf FPUs sehr langsam, da es für alle Zahlen eine gute Genauigkeit liefern muss. Wir brauchen aber keine sehr Hohe Genauigkeit, da wir nur ein Verstärkungsfaktor berechnen. Dafür gibt es schnellere Funktion, wie z.B. fastPow

		inline double fastPow(double a, double b) {
			union {
				double d;
				int x[2];
			} u = { a };
			u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447);
			u.x[0] = 0;
			return u.d;
		};

inline double fastPow(double a, double b) {

union {

double d;

int x[2];

} u = { a };

u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447);

u.x[0] = 0;

return u.d;

};

Klangbeispiele

Den Klang eines Kompressors sollte man im Optimalfall nicht hören. Dennoch hier ein paar Beispiele der sehr starken Komprimierung, wo die Kompression im Vergleich zum trockenen Signal erkennbar ist.

Gitarre - Rythmus trocken

Gitarre-Rythmus Compressor - Threshold: -20dB - Ratio: 4:1 - Attack: 10ms

Gitarre-Rythmus Compressor - Threshold: -30dB - Ratio: 4:1 - Attack: 10ms

Gitarre-Rythmus Compressor - Threshold: -40dB - Ratio: 4:1 - Attack: 10ms

Gitarre-Rythmus Compressor - Threshold: -30dB - Ratio: 10:1 - Attack: 10ms

Gitarre-Rythmus Compressor - Threshold: -30dB - Ratio: 100:1 - Attack: 10ms

Gitarre-Rythmus Compressor - Threshold: -35dB - Ratio: 10:1 - Attack: 10ms

Gitarre-Rythmus Compressor - Threshold: -35dB - Ratio: 10:1 - Attack: 50ms

Gitarre-Rythmus Compressor - Threshold: -35dB - Ratio: 10:1 - Attack: 100ms