Kategorie: DSP (page 2 of 4)

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

Flex 500 – Analoger Equaliser / Tone stack

7. Dezember 2019 / solocan / Noch kein Kommentar

Der analoge EQ-Abschnitt besteht aus

Ein Tonestack mit zwei einstellbaren Kuhschwanzfiltern
- Low-Shelf
- High-Shelf
Drei parametrischen Equalisern
- Low-Mid-EQ
- Mid-EQ
- High-Mid-EQ

Die Schaltungskomponenten ist im folgenden gezeigt.

High-Low-Shelvingfilter Stack

Die Dimensionierung der Schaltung ist hier beschrieben.

Parametrischer Equalizer

Die Dimensionierung der Schaltungen ist hier beschrieben.

KiCAD-Schaltung und PCB-Design herunterladen

Vorverstärker für Gitarre und Bass

7. Dezember 2019 / solocan / Noch kein Kommentar

Elektrogitarren als Signalquelle

Die passiven Tonabnehmer der Gitarren brauchen einen Eingang am Verstärker mit hoher Eingangsimpedanz. Das bedeutet, die Gitarre muss an einen sehr hohen Eingangswiderstand vom Verstärker arbeiten. Wenn dieser Widerstand nämlich niedrig wäre, würde dies dazu führen, dass mehr Strom an Spulen fließt, was dazu führen würde, dass

der Spannungspegel sinkt und
das Signal verzerrt wird.

Die aktiven Tonabnehmer hingegen (dieser Begriff wird benutzt für die Gitarren die auch eine aktive Vorverstärkungs- und EQ-Elektronik für die Tonabnehmer haben) könnten auch an niedrigen Eingangsimpedanzen arbeiten. (wie z.B. ein aktives Gerät wie MP3-Player, Handy etc. auch) Das bedeutet, sie können mehr Strom an den Verbraucher (also in dem Fall der Verstärkereingang) speisen. Denn der niedrige Ströme können auch Geräusche verursachen (was zwar bei einem einzigen Metallschichtwiderstand am Eingang vernachlässigbar ist). Die aktiven Tonabnehmer haben zudem den Vorteil, dass das Signal auf dem Kabel etwas weniger gestört wird. Aber auch dieser Vorteil ist nicht wirklich von Bedeutung, da es immer noch ein asymmetrisches Signal ist und asymmetrische Übertraung allgemeine keine gute Idee ist, auf langen Kabeln analoge Signale zu übertragen. Denn viel mehr Geräuschunterdrückung könnte man mit der sofortigen Symmetrierung des Signals (am Besten schon in der aktiven Elektronik der Gitarre) erreichen. Solche Gitarren sind aber aus historischen Gründen immer noch nicht verbreitet. Hingegen ist der Einsatz von einer separaten DI-Box üblich.

DI Boxen (Direct-Injection Boxen)

Die Problematik, dass die Gitarrensignale an langen Kabeln von der Gitarre bis zum Verstärker rapide an der Qualität verlieren, ist nicht neu. Zwar ist der Qualitätsverlust an kurzen Kabeln hinnehmbar; aber an großen Konzerten, wo auch viel Störquellen sind, und lange Kabeln braucht, ist eine Lösung notwendig. Diese lautet heutzutage immer noch die DI-Box. Diese ist nichts anderes als ein Symmetrierer. Dabei wird die Gitarre mit einem so kurzen Kabel wie möglich an eine DI-Box angeschlossen, Diese symmetriert das Gitarrensignal, am Besten auch aktiv, dass die Ausgangsimpedanz gleich mit erhöht wird. Dann wird das Signal viel immuner gegen Störungen und kann als symmetrisches Signal über viel längere Kabel übertragen werden. An dem Zielgerät (üblicherweise ein Mischpult) mit symmetrischem Eingang wird das Signal dann weiterverarbeitet/verstärkt.

Heute gibt es drei verbreitete Ansätze für die Umsetzung einer Vorverstärkerschaltung.

Integrierte Schaltungen(IC) von Operationsverstärkern (Opamp)
Diskrete Schaltungen mit Transistoren
Diskrete Schaltungen mit Röhren

Und jetzt vergessen Sie, was Sie bisher für Mythen gehört haben: Die beste Möglichkeit für die Umsetzung eines Vorverstärkers ist eine Schaltung mit Operationsverstärker-ICs. Diese haben ein Signal-Noise-Ratio (SNR) von jenseits von 100dB, sind billig, leicht umzusetzen, haben bauartbedingt viel weniger Geräusch und Fehlerquellen, gut abgeschirmt, benötigen kaum externe Komponenten etc. Es gibt Opamps , die extra für die Audiosignale optimiert sind, die man direkt einsetzen kann, z.B. u.A. von Burr-Brown-Serie von Texas Instruments.

Man kann natürlich eine Verstärkungsvorstufe mit Transistoren diskret bauen. Jedoch braucht man dafür um die hundert Bauteile und v. a. sehr viel Know-How. Ein guter Opamp besitzt u. a. auch viele Schutzmechanismen für Operationsfehler etc.

Bei den Gitarrenverstärkern sind die diskreten Röhrenvorstufen immer noch sehr beliebt und teuer bezahlt. Einige von den Anwendern würden Einspruch erheben und sagen, dass die Röhrenverstärker viel „besser klingen“. Das mag ja durchaus sein. Das liegt daran, dass die Röhren das Signal auch angenehm verzerren. Jedoch geht es um eine reine „Vorverstärkung“ ohne Änderung von Signaleigenschaften. In dieser Stufe ist noch keine Signalveränderung vorgenommen werden und nichts anders klingen. Es muss lediglich der Spannungspegel und Impedanz für die nächsten Stufen angepasst werden. Für diese Aufgabe ist eine gut gedesignte Opamp-basierte Schaltung deutlich überlegen.

Vorverstärkerschaltung mit Operationsverstärkern

Im folgenden wird die Vorverstärkerschaltung von Flex 500 erläutert. Er besteht aus

einer opamp-basierten Verstärkungsstufe mit einstellbarem Pegel (Gain-Einstellung)
Aktiv/Passiv Schalter
einem 2-stufigen, steilen (12dB/Dekade) aktiven Hochpassfilter
einem optional zuschaltbaren Tiefpassfilter für hohe Frequenzen ab 8kHz

Hier sieht man, dass die Gitarre an einen sehr hohen Widerstand mit $1M\Omega$ arbeitet. Danach wird die Impedanz vom Signal mit dem Opamp U_Inp1A angepasst und 11-fach verstärkt (Passive Gitarre). Mit dem Aktiv/Passiv-Schalter SW1 wird in die Rückkopplungsschleife zusätzlich der Widerstand R_I3 zugeschaltet, der den effektiven Widerstand der Rückkopplung von $10k\Omega$ auf $5k\Omega$ senkt. Die Verstärkung sinkt dadurch also auf das 6-fache (aktive Gitarre).

Der Kondensator C_INP_MIL1 sorgt für die Millerkompensation und dass die hochfrequenten Schwingungen/Oszillationen gedämpft werden. Dadurch wird der Opamp stabil.

Die Versorgung des Vorverstärkers erfolgt mit +-15V symmetrischer Spannung. Das heißt, man braucht das Wechselsignal nicht in einen positiven Bereich verschieben (Aliasing). Das erhöht die Qualität des Signals. Zur Stabilisierung der Versorgungspannung an den Eingängen vom Opamp werden zwei Kondensatoren als Vorspeicher und Glätter (C_Inp1 und C_Inp2) gelegt. 100nF Kondensatoren sind für diesen Zweck vollkommen ausreichend.

Am Ende der Schaltung wird die Spannung mit einem einstellbarem Spannungsteiler, der an einen Potentiometer gelegt ist, mit beliebigem Pegel an den Hochpassfilter weitergegeben. Dieses ist ein Butterworth-Filter, das die Frequenzen unter 10Hz , also praktisch den Gleichstrom, herausfiltert.

Für die Dimensionierung der Filterkomponenten können zahlreiche Fachquellen oder Simulationssoftware wie Webench Filter Designer von TI verwendet werden.

Dann geht es weiter zum nächsten Butterworth-Tiefpassstufe, die ab um 13kHz herausfiltert. Diese Stufe ist zuschaltbar.

KiCAD-Schaltung und PCB-Design herunterladen

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 Lautstärkenregelung

29. November 2019 / solocan / Noch kein Kommentar

Die Lautstärkenregelung basiert auf logarithmischen Ansatz, weil der Mensch die Schallstärke logaritmisch wahrnimmt. Im Folgenden wird eine Eingabe zwischen 0 und 100 auf einen Verstärkungswert zwischen 0 und 2 skaliert.

Rendered by QuickLaTeX.com

Bei beliebigem Maximalwert der Verstärkung $g_{max}$ kann die Gleichung kann als

(1) $\begin{equation*} \begin{aligned} g&=\frac{g_{max}}{9} [ 10^{v/100}-1] \\ x& \in \{0 ... 100\} \end{aligned} \end{equation*}$

gestellt werden.

Implementierung

Berechnung der Verstärkung

Der Verstärkungsfaktor ergibt sich aus der erwünschten Lautstärke. Diese Routine wird nach jedem Lautstärkenupdate durchgeführt.

/*Calculate gain out of volume
*/
void c_volume::set_volume(float *v){

	if(*v>1){
		gain=pregain*(fastPow(10,(double)*v*0.01)-1);
	}else{
		//Absolute silence
		gain=0;
	}

	printf("Volume:%f \t Gain: %f\n",*v,gain);
}

/*
Main process
*/
float c_volume::process(float x){

	return x*gain;

}

/*Calculate gain out of volume

void c_volume::set_volume(float *v){

if(*v>1){

gain=pregain*(fastPow(10,(double)*v*0.01)-1);

}else{

//Absolute silence

gain=0;

}

printf("Volume:%f \t Gain: %f\n",*v,gain);

}

Main process

float c_volume::process(float x){

return x*gain;

}

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

Digitales Tiefpass-Kammfilter

27. November 2019 / solocan / Noch kein Kommentar

Das Kammfilter ist ein Frequenzfilter, das das verzögerte Signal zum nichtverzögerten Signal mischt und dadurch bestimmte Frequenzen auslöscht. (Kammeffekt). Im Grunde ist das Kammfilter eine Verzögerungslinie mit Rückkopplung.

Die diskrete Übertragungsfunktion H(z) eines Feedback-Kammfilters M-ter Ordnung kann als

(1) $\begin{equation*} H(z)=\frac{z^{-M}}{1-G_{FB}z^{-M}} \end{equation*}$

beschrieben werden.

Kammfilter mit Tiefpass

Man kann die Rückkopplung nur auf bestimmte Frequenzen begrenzen, in dem man ein Frequenzfilter in die Rückkopplungsbahn einbaut. Das ist für Reverb-Implementierung wichtig, da in der Realität die Schallenergie der höheren Frequenzen schneller abgedämpft wird. Um dies nachzubilden, kann ein Tiefpassfilter erster Ordnung eingebaut werden:

(2) $\begin{equation*} H_{LP}(z)=\frac{1-d}{1-d z^{-1}} \end{equation*}$

oder noch einfacher eine Glättung:

(3) $\begin{equation*} H_{LP}(z)=\frac{1}{1-d z^{-1}} \end{equation*}$

Wird dies in die Rückkopplungsbahn integriert, sieht es folgendermaßen aus:

Hierbei wurden zwei Dämpfungskoeffizienten $d_1$ und $d_2$ hinzugefügt.

Implementierung

Die Implementierung des Kammfilters mit Tiefpass ist im Folgenden gezeigt:

/*
Main process comb filter with low pass
*/
float c_comb::process(float x){

	float y;

	y = buffer[cptr];

	filterstore = (y*damp2) + (filterstore*damp1);

	buffer[cptr] = x + (filterstore*feedback);

	if(++cptr>=bufsize) cptr = 0;

	return y;
}

Main process comb filter with low pass

float c_comb::process(float x){

float y;

y = buffer[cptr];

filterstore = (y*damp2) + (filterstore*damp1);

buffer[cptr] = x + (filterstore*feedback);

if(++cptr>=bufsize) cptr = 0;

return y;

}

Digitales Allpassfilter höherer Ordnung

27. November 2019 / solocan / Noch kein Kommentar

Das Allpassfilter ist ein Frequenzfilter, das alle Frequenzen durchlässt und nur ihre Phasen verschiebt. Diese Phasenverschiebung kann man sich als Verzögerung (Delay) vorstellen.

Die diskrete Übertragungsfunktion H(z) eines Allpassfilters M-ter Ordnung kann als

(1) $\begin{equation*} H(z)=\frac{z^{-M}-G_{FB}}{1-G_{FB}z^{-M}} \end{equation*}$

beschrieben werden, wobei $G_{FB}$ komplex konjugierte Pol-Nullstelle ist. Zieht man das $z^{-M}$ heraus, erhält man

(2) $\begin{equation*} y(n) = z^{-M} [x(n)+y(n) G_{FB} ]-x(n) G_{FB}} \end{equation*}$

Das ist im folgenden Regelkreis veranschaulicht.

Implementierung

Die Implementierung des Allpassfilters ist im Folgenden gezeigt:

/*
Main process alpass
*/
float c_allpass::process(float x){

	float y;
	y=buffer[aptr]-feedback*x;
	buffer[aptr]=y*feedback+x;
/*
//Original implementation of Freeverb is not consistent
	float bufout;
 	y = -x + bufout;
 	buffer[aptr] = x + (bufout*feedback);
*/

	if(++aptr>=bufsize) aptr = 0;

	return y;
}

Main process alpass

float c_allpass::process(float x){

float y;

y=buffer[aptr]-feedback*x;

buffer[aptr]=y*feedback+x;

//Original implementation of Freeverb is not consistent

float bufout;

y = -x + bufout;

buffer[aptr] = x + (bufout*feedback);

if(++aptr>=bufsize) aptr = 0;

return y;

}

Im Freeverb ist eine Kombination aus Feedforward- und feedback-Kammfilter implementiert als eine Allpassfilter-Approximation. Diese wird oben auskommentiert gezeigt.