Korr 4

acronyms.aux

@@ -7,7 +7,7 @@
 \newacro{FIR}[\AC@hyperlink{FIR}{FIR}]{Finite Impulse Response}
 \newacro{IIR}[\AC@hyperlink{IIR}{IIR}]{Infinite Impulse Response}
 \newacro{LMS}[\AC@hyperlink{LMS}{LMS}]{Least Mean Squares}
-\newacro{MSE}[\AC@hyperlink{MSE}{MSE}]{Mean Square Error}
+\newacro{MSE}[\AC@hyperlink{MSE}{MSE}]{Mean Squared Error}
 \newacro{ALU}[\AC@hyperlink{ALU}{ALU}]{Arithmetic Logic Unit}
 \newacro{NLMS}[\AC@hyperlink{NLMS}{NLMS}]{Normalized Least Mean Squares}
 \newacro{RLS}[\AC@hyperlink{RLS}{RLS}]{Recursive Least Squares}

acronyms.tex

@@ -8,7 +8,7 @@
   \acro{FIR}{Finite Impulse Response}
   \acro{IIR}{Infinite Impulse Response}
   \acro{LMS}{Least Mean Squares}
-  \acro{MSE}{Mean Square Error}
+  \acro{MSE}{Mean Squared Error}
   \acro{ALU}{Arithmetic Logic Unit}
   \acro{NLMS}{Normalized Least Mean Squares}
   \acro{RLS}{Recursive Least Squares}

chapter_01.tex

@@ -22,7 +22,7 @@ Usually, a \ac{CI} system consists out of an external processor with a microphon
 \noindent As for any head worn hearing aid, the audio processor of a \ac{CI} system does not only pick up the desired ambient audio signal, but also any sort of interference noises from different sources. This circumstance leads to a decrease in the quality of the final audio signal for the user. Reducing this interference noise through adaptive noise reduction, implemented on a low-power digital signal processor, which can be powered within the electrical limitations of a CI system, is the topic of this master's thesis.
 \subsection{Implementation of Adaptive Noise Reduction in Cochlear Implant Systems}
 The above problem description of noise interference shows the need of further improvement of \ac{CI} systems in this regard. For persons with a healthy hearing sense, the addition of noise to an observed signal may just mean a decrease in hearing comfort, whereas for aurally impaired people it can make the difference in the basic understanding of information. As everyday environments present fluctuating background noise - from static crowd chatter to sudden sounds of different characteristics — that can severely degrade speech perception, the ability to suppress noise is a crucial benefit for users of cochlear implant systems. \\ \\
-\ac{ANR} (also commonly referred as \ac{ANC}), is an advanced signal processing technique that adjusts the parameters of a digital filter to suppress unwanted noise from a signal while preserving the desired target signal. In contrary to static filters (like a high- or low-pass filter), \ac{ANR} uses real-time feedback to adjust said digital filter to adapt to the current circumstances.\\ \\
+\ac{ANR} (also commonly referred as \ac{ANC}), is an advanced signal processing technique that adjusts the parameters of a digital filter to suppress unwanted noise from a signal while preserving the desired signal. In contrary to static filters (like a high- or low-pass filter), \ac{ANR} uses real-time feedback to adjust said digital filter to adapt to the current circumstances.\\ \\
 The challenge in the implementation of \ac{ANR} in \ac{CI} systems lies in the limited capacities. As the \ac{CI} system is powered by a small battery located in the audio processor, energy efficiency is crucial for a possible solution of the described problem of noise interference. Any approach to a reduction of interference noise must be highly optimized with regard to computing power and implemented on dedicated low-power hardware, being able to be powered within the limitations of a \ac{CI} system.\\ \\
 The main topic of this thesis is the optimization of the adaptive filter of the \ac{ANR} algorithm in combination with the used low-power hardware. Its goal is, to deliver the best possible result in interference noise reduction while still being able to be powered by the limited resources of a \ac{CI} system. Different optimization strategies of the adaptive filter algorithm shall be evaluated and compared in regard of their performance and their required computing power.\\ \\
 Due to the fact, that the \ac{CI} system is powered by a battery with a relatively small capacity, the firmware is required to work with the least power possible, while maintaining the required performance. Therefore, optimization in regard of a minimization of needed processor clocks is aimed for.

chapter_02.tex

@@ -2,12 +2,12 @@
 The following subchapters shall supply the reader with the theoretical foundation of digital signal processing to better understand the following implementation of \ac{ANR} on a low-power signal processor.\\ \\
 The chapter begins with the description of signals, the problem of them interfering and the basics of digital signal processing in general, covering fundamental topics like signal representation, transfer functions and filters.\\
 Filters are used in various functional designs, therefore a short explanation into the concepts of Finite Impulse Response- and Infinite Impulse Response filters is indispensable.\\
-At this point an introduction into \ac{ANR} follows, including a short overview of the most important steps in history, the general concept of \ac{ANR}, its design possibilities and its optimization possibilities in regard of error calculation.\\
+At this point an introduction into \ac{ANR} follows, including a short overview of the most important steps in history, the general concept of \ac{ANR} and its design- and optimization possibilities in regard of error calculation.\\
 With this knowledge covered, a realistic signal flow diagram of an implanted \ac{CI} system with corresponding transfer functions is designed, essential to implement \ac{ANR} on a low-power digital signal processor.\\ \\
-Throughout this thesis, sampled signals are denoted in lowercase with square brackets (e.g. {x[n]}) to distinguish them from time-continuous signals (e.g. {x(t)}). Vectors are notated in lowercase bold font, whereas matrix are notated in uppercase bold font. Scalars are notated in normal lowercase font.\\ 
+Throughout this thesis, sampled signals are denoted in lowercase with square brackets (e.g. {x[n]}) to distinguish them from time-continuous signals (e.g. {x(t)}). Vectors are notated in lowercase bold font, whereas matrix are notated in uppercase bold font. Scalars are notated in normal lowercase font.
 \subsection{Signals and signal interference}
 A signal is a physical parameter (e.g. pressure, voltage) changing its value over time. Whereas in nature, a signal is always analog, meaning continuous in both time and amplitude, a digital signal is represented in a discrete form, being sampled at specific time intervals and quantized to finite amplitude levels.\\ \\
-The term "signal interference" describes the overlapping of unwanted signals or noise with the desired signal, degrading the overall quality and intelligibility of the processed information. A simple example of signal interference is shown in Figure \ref{fig:fig_interference} - the noisy signal (top) consists out of several signals of different frequencies, representing both the desired signal and unwanted noise. The cleaned signal (bottom) shows the desired signal after unwanted frequencies has been cut off by a filter.\\ \\
+The term ``signal interference'' describes the overlapping of unwanted signals or noise with the desired signal, degrading the overall quality and intelligibility of the processed information. A simple example of signal interference is shown in Figure \ref{fig:fig_interference} - the noisy signal (top) consists out of several signals of different frequencies, representing both the desired signal and unwanted noise. The cleaned signal (bottom) shows the signal after unwanted frequencies has been cut off by a filter.\\ \\
 \begin{figure}[H]
     \centering
     \includegraphics[width=0.8\linewidth]{Bilder/fig_interference.jpg}
@@ -39,7 +39,7 @@ Before digital signal processing can be applied to an analog signal like human v
 \end{equation}
 where x[n] is the current sample and x[n-1] is the preceding sample. 
 \subsubsection{Time domain vs. frequency domain}
-A signal (either analog or digital) can be displayed and analyzed in two ways: the time domain and the frequency domain. The time domain shows the amplitude of the signal over time - like the sine waves from Figure \ref{fig:fig_interference}. If a Fast Fourier Transformation (FFT) is applied to the signal in the time spectrum, we receive the same signal in the frequency spectrum, now showing the spectral power present in the signal (refer to Figure \ref{fig:fig_fft}).\\ \\
+A signal (either analog or digital) can be displayed and analyzed in two ways: the time domain and the frequency domain. The time domain shows the amplitude of the signal over time - like the sine waves from Figure \ref{fig:fig_interference}. If a Fourier Transformation is applied to the signal in the time spectrum, we receive the same signal in the frequency spectrum, now showing the spectral power present in the signal (refer to Figure \ref{fig:fig_fft}).\\ \\
 \begin{figure}[H]
     \centering
     \includegraphics[width=0.8\linewidth]{Bilder/fig_fft.jpg}
@@ -63,7 +63,7 @@ During the description of transfer functions, the term ``filter'' was used but n
     \label{fig:fig_lowpass}
 \end{figure}
 \subsection{Filter designs}
-Before we continue with the introduction to the actual topic of this thesis, \ac{ANR}, two very essential filter designs need further explanation - the Finite Impulse Response- and Infinite Impulse Response filter. 
+Before we continue with the introduction of \ac{ANR}, two very essential filter designs need further explanation - the Finite Impulse Response- and Infinite Impulse Response filter. 
 \subsubsection{Finite Impulse Response filters}
 A \ac{FIR} filter, commonly referred to as a ``Feedforward Filter'' is defined through the property, that it uses only input values and not feedback from output samples to determine its filtering behavior - therefore, if the input signal is reduced to zero, the response of a \ac{FIR} filter reaches zero after a finite number of samples.\\ \\
 Equation \ref{equation_fir} specifies the input-output relationship of a \ac{FIR} filter - $x[n]$ is the input sample, $y[n]$ is output sample, and $b_0$ to $b_M$ the filter coefficients and M the length of the filter
@@ -112,7 +112,7 @@ In the 1930s, the first real concept of active noise cancellation was proposed b
 \noindent In contrary to the static filters in the beginning of the century, the active noise cancellation approach of Lueg and Widrow was far more advanced than just reducing a signal by a specific frequency portion like with the use of static filters, yet this technique still has their limitations as it is designed only to work within to a certain environment.\\ \\
 With the rapid advancement of digital signal processing technologies, noise cancellation techniques evolved from static, hardware-based filters and physical soundwave cancellation towards more sophisticated approaches. In the then 1970s, the concept of digital adaptive filtering arose, allowing digital filters to adjust their parameters in real-time based on the characteristics of the incoming signal and noise. This marked a significant leap forward, as it enabled systems to deal with dynamic and unpredictable noise environments - the concept of adaptive noise reduction was born.
 \subsubsection{The concept of adaptive filtering}
-Adaptive noise reduction describes an advanced filtering method based on an error-metric and represents a significant advancement over these earlier methods by allowing the filter parameters to continuously adapt to the changing acoustic environment in real-time. This adaptability makes \ac{ANR} particularly suitable for hearing devices, where environmental noise characteristics vary constantly.\\ \\
+\ac{ANR} describes an advanced filtering method based on an error metric and represents a significant advancement over these earlier methods by allowing the filter parameters to continuously adapt to the changing acoustic environment in real-time. This adaptability makes \ac{ANR} particularly suitable for hearing devices, where environmental noise characteristics vary constantly.\\ \\
 Static filters, like low- and high-pass filters, as described in the previous subchapter, feature coefficients that remain constant over time. They are designed for known, predictable noise conditions (e.g. removing a steady 50 Hz hum originating from a power supply). While these filters are efficient and easy to implement, they fail to function when noise characteristics change dynamically.\\ \\
 Although active noise cancellation and adaptive noise reduction share obvious similarities, they differ fundamentally in their application and signal structure. While active noise cancellation aims to physically cancel noise in the acoustic domain — typically before, or at the time, the signal reaches the ear — \ac{ANR} operates within the signal processing chain, attempting to extract the noisy component from the digital signal. In cochlear implant systems, the latter is more practical because the acoustic waveform is converted into electrical stimulation signals; thus, signal-domain filtering is the only feasible approach.
 \begin{figure}[H]
@@ -151,7 +151,7 @@ The goal of the adaptive filter is therefore to minimize this error signal over
 The minimization of the error signal $e[n]$ can be achieved by applying different error metrics and algorithms used to evaluate the performance of an adaptive filter, including:
 \begin{itemize}
 \item \ac{MSE}: This metric calculates the averaged square of the error between the expected value and the observed value over a predefined period. It is sensitive to large errors and is commonly used in adaptive filtering applications.
-\item \ac{LMS}: The \ac{LMS} is an algorithm, focused on minimizing the mean squared error by adjusting the filter coefficients iteratively based on the error signal by applying the gradient descent method. It is computationally efficient and widely used in real-time applications.
+\item \ac{LMS}: The \ac{LMS} is an algorithm, focused on minimizing the \ac{MSE} by adjusting the filter coefficients iteratively based on the error signal by applying the gradient descent method. It is computationally efficient and widely used in real-time applications.
 \item \ac{NLMS}: An extension of the \ac{LMS} algorithm that normalizes the step size based on the input signal, improving convergence speed.
 \item \ac{RLS}: This algorithm aims to minimize the weighted sum of squared errors, providing faster convergence than the \ac{LMS} algorithm but at the cost of higher computational effort.
 \end{itemize}
@@ -266,7 +266,7 @@ The \ac{LMS} algorithm therefore updates the filter coefficients $w[n]$ after ev
 \noindent Figure \ref{fig:fig_anr_hybrid} showed us the basic concept of an \ac{ANR} implementation, without a detailed description how the corrupted signal $d[n]$ and the reference noise signal $x[n]$ are formed. Figure \ref{fig:fig_anr_implant} now shows a more complete and realistic signal flow diagram of an implanted cochlear implant system, with two signal sensors and an adaptive noise reduction circuit afterwards. \\ \\
 The following definitions of the involved signals shall help to better understand the involved signals and their interactions:
 \begin{itemize}
-\item Desired signal: The wanted signal, like human voice, which shall be preserved.
+\item Desired signal: The wanted signal, like human voice, which shall be restored.
 \item Noise signal: The unwanted signal, like background noise, which shall be reduced.
 \item Recorded desired signal: The desired signal after passing the transfer function to the primary sensor.
 \item Corruption noise signal: The noise signal after passing the transfer function to the primary sensor.
@@ -288,7 +288,7 @@ x[n] = v[n] * (E_nB)
 \end{equation}
 where $v[n]$ is the noise signal at its source.\\ \\
 Another possible signal interaction could be the leakage of the desired signal into the secondary sensor, leading to the partial removal of the desired signal from the output signal. This case is not illustrated in Figure \ref{fig:fig_anr_implant} as it won't be further evaluated in this thesis, but shall be mentioned for the sake of completeness.\\ \\ 
-At this point, the theoretical background and the fundamentals of adaptive noise reduction have been adequately introduced and explained as necessary for the understanding of the following chapters of this thesis. The next chapter will now focus on practical high-level simulations of the \ac{ANR} algorithm under different circumstances to evaluate their performance in regard of noise reduction quality before the actual implementation on a low-power \ac{DSP} is conducted. 
+At this point, the theoretical background and the fundamentals of \ac{ANR} have been adequately introduced and explained as necessary for the understanding of the following chapters of this thesis. The next chapter will now focus on practical high-level simulations of the \ac{ANR} algorithm under different circumstances to evaluate their performance in regard of noise reduction quality before the actual implementation on a low-power \ac{DSP} is conducted. 
 
 
 

chapter_03.tex

@@ -46,11 +46,11 @@ def anr_function(input, ref_noise, coefficients, mu, adaption_step=1):
 \noindent The algorithm implementation shall now be put under test by different use cases to demonstrate the functionality and performance under different scenarios, varying from simple to complex ones. Every use case includes graphical representations of the desired signal, the corrupted signal, the reference noise signal, the filter output, the error signal and the evolution of selected filter coefficients over time. In contrary to a realistic setup, the desired signal is available, allowing to evaluate the performance of the algorithm based on the \ac{SNR}-Gain in dB and also visually by the amplitude of the error signal (difference between the desired signal and the filter output). The error signal and the \ac{SNR}-Gain are calculated as follows:
 \begin{gather}
     \label{equation_snr_gain_error}
-    \text{P}_{\text{Error-signal}} = \text{P}_{\text{Desired-signal}} - \text{P}_{\text{Filter-output}} \\
+    \text{P}_{\text{Error signal}} = \text{P}_{\text{Desired signal}} - \text{P}_{\text{Filter-output}} \\
     \label{equation_snr_gain}
-    \text{SNR-Gain} = 10 \cdot \log_{10}\frac{\text{P}_{\text{Desired-signal}}}{\text{P}_{\text{Noise-signal}}} - 10 \cdot \log_{10}\frac{\text{P}_{\text{Desired-signal}}}{\text{P}_{\text{Error-signal}}} 
+    \text{SNR-Gain} = 10 \cdot \log_{10}\frac{\text{P}_{\text{Desired signal}}}{\text{P}_{\text{Noise signal}}} - 10 \cdot \log_{10}\frac{\text{P}_{\text{Desired signal}}}{\text{P}_{\text{Error signal}}} 
 \end{gather}
-with $\text{P}_{\text{Desired-signal}}$ being the power of the desired signal, $\text{P}_{\text{Noise-signal}}$ being the power of the noise signal and $\text{P}_{\text{Error-signal}}$ being the power of the error signal, which is the difference between the desired signal and the filter output. A positive \ac{SNR}-Gain indicates an improvement in signal quality, while a negative \ac{SNR}-Gain indicates a degradation in signal quality after applying the \ac{ANR} algorithm.
+with $\text{P}_{\text{Desired signal}}$ being the power of the desired signal, $\text{P}_{\text{Noise signal}}$ being the power of the noise signal and $\text{P}_{\text{Error signal}}$ being the power of the error signal, which is the difference between the desired signal and the filter output. A positive \ac{SNR}-Gain indicates an improvement in signal quality, while a negative \ac{SNR}-Gain indicates a degradation in signal quality after applying the \ac{ANR} algorithm.
 \subsection{Simple ANR use cases}
 To evaluate the general functionality and performance of the \ac{ANR} algorithm from Listing \ref{lst:lst_anr_code}, a set of three simple, artificial scenarios are introduced. These examples shall serve as a showcase to demonstrate the general functionality, the possibilities and the limitations of the \ac{ANR} algorithm.\\ \\
 In all three scenarios, a chirp signal with a frequency range from 100-1000 Hz is used as the desired signal, which is then corrupted with a sine wave (Use case 1 and 2) or a Gaussian white noise (Use case 3) as noise signal respectively. In this simple setup, the corruption noise signal is also available as the reference noise signal. Every approach is conducted with 16 filter coefficients and a step size of 0.01. The four graphs in the respective first plot show the desired signal, the corrupted signal, the reference noise signal and the filter output. The two graphs in the respective second plot show the performance of the filter in form of the resulting error signal and the evolution of three exemplary filter coefficients over time.\\ \\
@@ -78,7 +78,7 @@ The second use case resembles the first one, but instead of a 2000 Hz sine wave,
     \caption{Desired signal, corrupted signal, reference noise signal and filter output of simple use case 2}
     \label{fig:fig_plot_1_sine_2.png}
 \end{figure}
-\noindent Figure \ref{fig:fig_plot_2_sine_2.png} shows a significant increase of the amplitude of the error signal compared to Use case 1, especially around the 500 Hz frequency of the noise signal. Also, the adaption of the coefficients shows far more variance compared to use case 1, with a complete rearrangement in the area of 500 Hz. This indicates that the \ac{ANR} algorithm is struggling to adapt effectively in a scenario, where the noise signal overlaps with the desired signal.
+\noindent Figure \ref{fig:fig_plot_2_sine_2.png} shows a significant increase of the amplitude of the error signal compared to use case 1, especially around the 500 Hz frequency of the noise signal. Also, the adaption of the coefficients shows far more variance compared to use case 1, with a complete rearrangement in the area of 500 Hz. This indicates that the \ac{ANR} algorithm is struggling to adapt effectively in a scenario, where the noise signal overlaps with the desired signal.
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_2_sine_2.png}
@@ -119,14 +119,14 @@ After the general functionality of the \ac{ANR} algorithm has been verified with
 \subsection{Complex ANR use case}
 To close the topic of high-level simulations of the \ac{ANR} algorithm, a more complex and realistic use case is finally introduced. In this scenario, the same two audio tracks of the previous use case are utilized - but now they pass different transfer functions, which mimic the case that the sensor recording the corrupted signal, shows another frequency response characteristic as the one recording the reference noise signal. Additionaly, a delay of 2 ms between the corruption noise signal and the reference noise signal is introduced - this simulates the realsitic case, that the microphones are located on different locations, leading to a small delay due to traveling time of the signal. Now, an analytical solution is not possible anymore, as the signals are affected in different ways, making it impossible to simply subtract the noise signal from the corrupted signal. This scenario represents a realistic application of the \ac{ANR} algorithm, as it involves complex audio signals as well as signals passing different signal paths while being delayed.\\ \\
 Using  a sampling frequency of 20 kHz, a delay of 2 ms represents a shift of 40 samples. As the corrpution noise signal, which the alorithm tries to filter out of the corrupoted signal, is now delayed by these 40 samples, the filter needs more coefficients to aqquire a certain ``memory'' - this means, that the used 16 tap filter is not sufficient anymore. To prove the correct function of the \ac{ANR} algorithm, the filter length is increased by 40 taps up to 56 taps. \\ \\
-The now introduced challenges ae making adaptive noise reduction the only feasible approach to reduce the noise from the corrupted signal.
+The now introduced challenges are making adaptive noise reduction the only feasible approach to reduce the noise from the corrupted signal.
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_3_wav_complex.png}
     \caption{Two different sensor sensitivity curves used for recording the corrupted signal and the reference noise signal}
     \label{fig:fig_plot_3_wav_complex.png}
 \end{figure}
-\noindent Figure \ref{fig:fig_plot_3_wav_complex.png} illustrates the sensitivity curve of two different microphones used to record the corrupted signal and the reference noise signal respectively, resulting in two different transfer functions applied to the signals. The effect of transfer functions on the noise signal is shown in Figure \ref{fig:fig_plot_4_wav_complex.png}, where the top graph shows the noise signal at it's source, while the second and third graph show the effect of the two different transfer functions resulting in the corruption noise signal and the reference noise signal respectively.
+\noindent Figure \ref{fig:fig_plot_3_wav_complex.png} illustrates the sensitivity curve of two different microphones used to record the corrupted signal and the reference noise signal respectively, resulting in two different transfer functions applied to the signals. The effect of transfer functions on the noise signal is shown in Figure \ref{fig:fig_plot_4_wav_complex.png}, where the top graph shows the noise signal at its source, while the second and third graph show the effect of the two different transfer functions resulting in the corruption noise signal and the reference noise signal respectively.
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_4_wav_complex.png}

chapter_04.aux

@@ -196,17 +196,17 @@
 \newlabel{lst:lst_dsp_code_apply_fir_filter}{{6}{53}{}{listing.6}{}}
 \acronymused{MAC}
 \acronymused{DSP}
-\@writefile{lof}{\contentsline {figure}{\numberline {36}{\ignorespaces Visualization of the FIR filter calculation in the $apply\_fir\_filter()$-function during the 2nd cyclce of a calculation loop. The reference noise signal samples are stored in the sample line, while the filter coefficients are stored in a separate memory section (filter line).}}{53}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {36}{\ignorespaces Visualization of the FIR filter calculation in the $apply\_fir\_filter()$-function during the 2nd cyclce of a calculation loop. The reference noise signal samples are stored in the Sample Line, while the filter coefficients are stored in a separate memory section, called Filter line.}}{53}{}\protected@file@percent }
 \newlabel{fig:fig_dsp_fir_cycle.jpg}{{36}{53}{}{figure.36}{}}
 \@writefile{toc}{\contentsline {paragraph}{update\_output()}{54}{}\protected@file@percent }
 \@writefile{toc}{\contentsline {paragraph}{update\_filter\_coefficient()}{54}{}\protected@file@percent }
 \acronymused{DSP}
 \acronymused{MAC}
-\@writefile{lol}{\contentsline {listing}{\numberline {7}{\ignorespaces Code snippet of the $update\_filter\_coefficient()$-function, again making use of the dual \ac {MAC} architecture of the \ac {DSP} and the fractional multiplication function. Additionaly, 32-bit values are loaded and stored as 64-bit values, using two also intrinisc functions, allowing to update two filter coefficients in a single cycle.}}{54}{}\protected@file@percent }
+\@writefile{lol}{\contentsline {listing}{\numberline {7}{\ignorespaces Code snippet of the $update\_filter\_coefficient()$-function, again making use of the dual \ac {MAC} architecture of the \ac {DSP} and the fractional multiplication function. Additionaly, 32-bit values are loaded and stored as 64-bit values, using two also intrinsic functions, allowing to update two filter coefficients in a single cycle.}}{54}{}\protected@file@percent }
 \newlabel{lst:lst_dsp_code_update_filter_coefficients}{{7}{54}{}{listing.7}{}}
 \acronymused{MAC}
 \acronymused{DSP}
-\@writefile{lof}{\contentsline {figure}{\numberline {37}{\ignorespaces Visualization of the coefficient calculation in the $update\_filter\_coefficient()$-function during the 2nd cyclce of a calculation loop. The output is multiplied with the step size and the corresponding sample from the sample line, before being added to the current filter coefficient.}}{55}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {37}{\ignorespaces Visualization of the coefficient calculation in the $update\_filter\_coefficient()$-function during the 2nd cyclce of a calculation loop. The output is multiplied with the step size and the corresponding sample from the Sample Line, before being added to the current filter coefficient.}}{55}{}\protected@file@percent }
 \newlabel{fig:fig_dsp_coefficient_cycle.jpg}{{37}{55}{}{figure.37}{}}
 \@writefile{toc}{\contentsline {paragraph}{update\_output()}{55}{}\protected@file@percent }
 \newlabel{equation_computing}{{24}{55}{}{equation.24}{}}
@@ -219,8 +219,34 @@
 \acronymused{DSP}
 \@writefile{lof}{\contentsline {figure}{\numberline {38}{\ignorespaces Dependence of the total computing effort on the filter length $\text  {N}$ and update rate $\text  {1/U}$.}}{56}{}\protected@file@percent }
 \newlabel{fig:fig_c_total.png}{{38}{56}{}{figure.38}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.4}Verification of the DSP implementation}{56}{}\protected@file@percent }
+\acronymused{DSP}
+\acronymused{ANR}
+\acronymused{FIR}
+\acronymused{ANR}
+\acronymused{SNR}
+\@writefile{lof}{\contentsline {figure}{\numberline {39}{\ignorespaces Desired signal, corrupted signal, reference noise signal and filter output of the complex \ac {ANR} use case, simulated on the \ac {DSP}}}{57}{}\protected@file@percent }
+\acronymused{ANR}
+\acronymused{DSP}
+\newlabel{fig:fig_plot_1_dsp_complex.png}{{39}{57}{}{figure.39}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {40}{\ignorespaces Error signal of the complex \ac {ANR} use case, simulated on the \ac {DSP}}}{57}{}\protected@file@percent }
+\acronymused{ANR}
+\acronymused{DSP}
+\newlabel{fig:fig_plot_2_dsp_complex.png}{{40}{57}{}{figure.40}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {41}{\ignorespaces Comparison of the high- and low-level simulation output.}}{58}{}\protected@file@percent }
+\newlabel{fig:fig_high_low_comparison.png}{{41}{58}{}{figure.41}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {42}{\ignorespaces Histogram of the error amplitude between the high- and low-level simulation output.}}{58}{}\protected@file@percent }
+\newlabel{fig:fig_high_low_comparison_hist.png}{{42}{58}{}{figure.42}{}}
+\acronymused{ANR}
+\acronymused{DSP}
+\acronymused{SNR}
+\acronymused{DSP}
+\acronymused{DSP}
+\acronymused{DSP}
+\acronymused{ANR}
+\acronymused{DSP}
 \@setckpt{chapter_04}{
-\setcounter{page}{57}
+\setcounter{page}{60}
 \setcounter{equation}{31}
 \setcounter{enumi}{0}
 \setcounter{enumii}{0}
@@ -230,11 +256,11 @@
 \setcounter{mpfootnote}{0}
 \setcounter{part}{0}
 \setcounter{section}{4}
-\setcounter{subsection}{3}
+\setcounter{subsection}{4}
-\setcounter{subsubsection}{2}
+\setcounter{subsubsection}{0}
 \setcounter{paragraph}{0}
 \setcounter{subparagraph}{0}
-\setcounter{figure}{38}
+\setcounter{figure}{42}
 \setcounter{table}{0}
 \setcounter{float@type}{16}
 \setcounter{tabx@nest}{0}
@@ -355,7 +381,7 @@
 \setcounter{lstnumber}{15}
 \setcounter{FancyVerbLine}{0}
 \setcounter{linenumber}{1}
-\setcounter{LN@truepage}{56}
+\setcounter{LN@truepage}{59}
 \setcounter{FancyVerbWriteLine}{0}
 \setcounter{FancyVerbBufferLine}{0}
 \setcounter{FV@TrueTabGroupLevel}{0}

chapter_04.tex

@@ -3,8 +3,8 @@ Now, with a functioning high-level implementation in place, the focus shifts to
 \subsection{Low-power system architecture and integration}
 This thesis considers a low-power \ac{SOC} architecture that integrates a general-purpose \ac{ARM} core with a dedicated \ac{DSP} core. The system combines the flexibility of an \ac{ARM}-based control processor with the computational efficiency of a specialized \ac{DSP}, splitting general computing tasks from real-time signal processing workloads.
 \subsubsection{ARM and DSP hardware architecture overview}
-A 32-bit \ac{ARM} core serves as the primary control unit of the system. It is responsible for high-level application logic, system configuration, peripheral management as also scheduling and serves as a general-purpose processing unit. Due to its universal instruction set and extensive input/output interface, the \ac{ARM} core is well suited for handling general tasks and the interaction with the \ac{CI} system. Time-critical numerical processing is intentionally offloaded to the \ac{DSP} core in order to reduce computational load and power consumption on the control processor.\\ \\
+A 32-bit \ac{ARM} core serves as the primary control unit of the system. It is responsible for high-level application logic, system configuration, peripheral management, scheduling and serves as a general-purpose processing unit. Due to its extensive input/output interface, the \ac{ARM} core is well suited for handling general tasks and the interaction with the \ac{CI} system. Time-critical numerical processing is offloaded to the \ac{DSP} core in order to reduce computational load and power consumption on the main processor.\\ \\
-The \ac{DSP} used for the implementation features a 32-bit dual Harvard, dual \ac{MAC} architecture primarily designed for audio signal-processing applications in low-power embedded systems. It doesn't feature a designated boot ROM, as it is initialized and managed by the \ac{ARM} core. The firmware executing the \ac{ANR} algorithm is developed and programmed in the C programming language. The used proprietary compiler offers highly efficient functions and generates optimized assembler code, which is then translated in machine code to execute the \ac{ANR} algorithm on incoming samples.\\ \\
+The \ac{DSP} used for the implementation features a 32-bit dual Harvard, dual \ac{MAC} architecture primarily designed for audio signal processing applications in low-power embedded systems. It doesn't feature a designated boot ROM, as it is initialized and managed by the \ac{ARM} core. The firmware executing the \ac{ANR} algorithm is developed and programmed in the C programming language. The used proprietary compiler offers highly efficient functions and generates optimized assembler code, which is then translated in machine code to execute the \ac{ANR} algorithm on incoming samples.\\ \\
 All memory instances and registers of the \ac{SOC} are directly addressable by the \ac{ARM} through the standard buses, also enabling a simplified control of the \ac{DSP} through a shared memory section. The memory consists mainly out of the two following parts:
 \begin{itemize}
     \item \textbf{Program Memory:} This memory section stores the executable code for both the \ac{ARM} core and the \ac{DSP} core. It contains the compiled instructions that define the behavior of the system, including the \ac{ANR} algorithm implemented on the \ac{DSP}.
@@ -13,7 +13,7 @@ All memory instances and registers of the \ac{SOC} are directly addressable by t
 The data memory is supported by an integrated \ac{DMA} controller, which allows efficient data transfers between peripherals and memory without burdening the processing cores. This is particularly needed for transferring audio samples from the \ac{PCM} interface to the shared memory section for further processing by the \ac{DSP}, as well as transferring processed samples back to the \ac{PCM} interface for playback. The shared memory section is crucial for enabling efficient communication and data exchange between the two processing units, further described in the following subchapter.\\ \\
 When the \ac{DSP} is not required to process audio data, it can be put to sleep by halting the clock provided to the \ac{DSP} core. When halted, the \ac{DSP} core enters a low-power state, still allowing the \ac{ARM} core to access its shared memory and wake up the \ac{DSP} core when needed. This mechanism helps to reduce overall power consumption, which is crucial for battery-operated devices like cochlear implants.\\ \\
 The processing unit of the \ac{DSP} is equipped with load/store architecture, meaning that, initially all operands need to be moved from the memory to the registers, before any operation can be performed. After this task is performed, the execution units (\ac{ALU} and multiplier) can perform their operations on the data and write back the results into the registers. Finally, the results need to be explicitly moved back to the memory.\\ \\
-Processor-wise, the \ac{DSP} includes a three stage pipeline consisting of fetch, decode, and execute stages, allowing for overlapping instruction execution and improved throughput. The architecture is optimized for high cycle efficiency when executing computationally intensive signal-processing workloads. The featured dual Harvard, dual \ac{MAC} architecture (two separate \ac{ALU}s) enables the execution of two \ac{MAC} operations, two memory operations (load/store) and two pointer updates in a single processor cycle.
+Inside the \ac{DSP}, a three stage pipeline consisting of fetch, decode, and execute stages, allows overlapping instruction execution and improved throughput. The architecture is optimized for high cycle efficiency when executing computationally intensive signal processing workloads. The featured dual Harvard, dual \ac{MAC} architecture (two separate \ac{ALU}s) enables the execution of two \ac{MAC} operations, two memory operations (load/store) and two pointer updates in a single processor cycle.
 \subsubsection{Intercore communication mechanisms}
 In order to ensure a smooth, but power-efficient, operation together with the \ac{CI} system, an interrupt-driven communication between the \ac{ARM} core and the \ac{DSP} core is crucial. Center of communication between the cores is the already mentioned shared memory region accessible by both processing units. This shared memory enables the exchange of data without the need for separate communication protocols or input/output interfaces (refer to Figure \ref{fig:fig_dsp_setup.jpg}). Synchronization between the cores is achieved using interrupt-based signaling: the \ac{ARM} core initiates processing requests by waking up the \ac{DSP} and triggering an interrupt which sets an action flag, while the \ac{DSP} notifies the \ac{ARM} core upon completion of a task also by changing an interrupt register (for simplicity reasons, this behavior will be just called ``interrupts'' in the remaining thesis). This approach ensures efficient coordination while minimizing active waiting (polling) and therefore unnecessary power consumption.
 \begin{figure}[H]
@@ -138,7 +138,7 @@ The ability to process audio samples in real-time on the \ac{DSP} core is strong
 \subsubsection{DSP-specific optimizations for real-time processing}
 In the following, some examples of optimization possibilities shall be outlined, before the entire \ac{ANR} implementation on the \ac{DSP} is analyzed in regard of its performance.
 \paragraph{Logic operations}
-Logic operations, such as finding the maximum or minimum of two values, are quite common in signal processing algorithms. However, their implementation in C usually involves conditional statements (if-else), which can be inefficient on certain architectures due to pipeline stalls.\\ \\
+Logic operations, such as finding the maximum or minimum of two values, are quite common in signal processing algorithms. However, their implementation in C usually involves conditional statements, which can be inefficient on certain architectures.\\ \\
 The simple function shown in Listing \ref{lst:lst_dsp_code_find_max} returns the maximum of two given integer values. Processing this manual implementation on the \ac{DSP} takes 12 cycles to execute, while the intrinsic function of the \ac{DSP} compiler allows a 4-cycle execution.
 \begin{listing}[H]
 \centering
@@ -186,8 +186,8 @@ The $calculate\_output()$ functions consists out of the following five main part
     \item $write\_output()$: Writing the output sample back to the output port in the shared memory section
 \end{itemize}
 These sub-functions feature \ac{DSP}-specific optimizations and are partly depenend on the setable parameters like the filter length in regard of their computational cost. The following paragraphs will analyze the computational efficiency of these sub-functions in detail.
-\paragraph{write\_buffer()}The $write\_buffer()$-function is responsible for managing the sample line, where the samples of the reference noise signal are stored for further processing. The buffer management mainly consists out of a cyclic pointer increase operation and a pointer dereference operation to write the new sample into the buffer. The cyclic pointer increase operation is implemented using the already mentioned intrinsic function of the \ac{DSP} compiler, while the pointer dereference operation takes 15 cycles to execute. This results in a total duration of 16 cycles for the $write\_buffer()$-function to process, indipendent of the filter length or other parameters.
+\paragraph{write\_buffer()}The $write\_buffer()$-function is responsible for managing the Sample Line, where the samples of the reference noise signal are stored for further processing. The buffer management mainly consists out of a cyclic pointer increase operation and a pointer dereference operation to write the new sample into the buffer. The cyclic pointer increase operation is implemented using the already mentioned intrinsic function of the \ac{DSP} compiler, while the pointer dereference operation takes 15 cycles to execute. This results in a total duration of 16 cycles for the $write\_buffer()$-function to process, indipendent of the filter length or other parameters.
-\paragraph{apply\_fir\_filter()} The $apply\_fir\_filter()$-function is responsible for applying the coefficients of the \ac{FIR} filter on the reference noise signal samples stored in the sample line. The needed cycles for this function are mainly depenendent on the length of the filter, as the number of multiplications and additions increase with the filter length. To increase the performance, the dual \ac{MAC} architecture of the \ac{DSP} is utilized, allowing two multiplications and two additions to be performed in a single cycle. Another \ac{DSP}-specific optimization is the use of the already introduced 72-bit accumulators and the fractional multiplication function, which allow performing multiplications on two 32-bit integers without losing precision or the need for manual bit-shifting operations.
+\paragraph{apply\_fir\_filter()} The $apply\_fir\_filter()$-function is responsible for applying the coefficients of the \ac{FIR} filter on the reference noise signal samples stored in the Sample Line. The needed cycles for this function are mainly depenendent on the length of the filter, as the number of multiplications and additions increase with the filter length. To increase the performance, the dual \ac{MAC} architecture of the \ac{DSP} is utilized, allowing two multiplications and two additions to be performed in a single cycle. Another \ac{DSP}-specific optimization is the use of the already introduced 72-bit accumulators and the fractional multiplication function, which allow performing multiplications on two 32-bit integers without losing precision or the need for manual bit-shifting operations.
 \begin{listing}[H]
 \centering
 \begin{lstlisting}[style=cstyle]
@@ -211,12 +211,12 @@ for (int i=0; i < n_coeff; i+=2) chess_loop_range(1,){
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_dsp_fir_cycle.jpg}
-    \caption{Visualization of the FIR filter calculation in the $apply\_fir\_filter()$-function during the 2nd cyclce of a calculation loop. The reference noise signal samples are stored in the sample line, while the filter coefficients are stored in a separate memory section (filter line).}
+    \caption{Visualization of the FIR filter calculation in the $apply\_fir\_filter()$-function during the 2nd cyclce of a calculation loop. The reference noise signal samples are stored in the Sample Line, while the filter coefficients are stored in a separate memory section, called Filter line.}
     \label{fig:fig_dsp_fir_cycle.jpg}
 \end{figure}
-\noindent The final result is represented in a computing effort of 1 cycle per item in the sample line buffer (which equals the filter length) plus 12 cycles for general function overhead, resulting in a total of $\text{N+12}$ cycles for the $apply\_fir\_filter()$-function, with $N$ being the filter length.
+\noindent The final result is represented in a computing effort of 1 cycle per item in the Sample Line buffer (which equals the filter length) plus 12 cycles for general function overhead, resulting in a total of $\text{N+12}$ cycles for the $apply\_fir\_filter()$-function, with $N$ being the filter length.
 \paragraph{update\_output()} The $update\_output()$-function is responsible for calculating the output sample based on the error signal and the accumulated filter output. The calculation is a simple subtraction and only takes 1 cycle to execute, independent of the filter length or other parameters.
-\paragraph{update\_filter\_coefficient()} The $update\_filter\_coefficient()$-function represents the second computationally expensive part of the $calculate\_output()$-function. The calculated output from the previous function is now multiplied with the step size and the corresponding sample from the reference noise signal, which is stored in the sample line buffer. The result is then added to the current filter coefficient to update it for the next cycle. Again, \ac{DSP}-specific optimizations, like the dual \ac{MAC} architecture, are used, resulting in a computing effort of 6 cycles per filter coeffcient. Per function call, an overhead of 8 cycles is added, resulting in a total of $\text{6*N+8}$ cycles for the $update\_filter\_coefficient()$-function, with $\text{N}$ again being the filter length.
+\paragraph{update\_filter\_coefficient()} The $update\_filter\_coefficient()$-function represents the second computationally expensive part of the $calculate\_output()$-function. The calculated output from the previous function is now multiplied with the step size and the corresponding sample from the reference noise signal, which is stored in the Sample Line buffer. The result is then added to the current filter coefficient to update it for the next cycle. Again, \ac{DSP}-specific optimizations, like the dual \ac{MAC} architecture, are used, resulting in a computing effort of 6 cycles per filter coeffcient. Per function call, an overhead of 8 cycles is added, resulting in a total of $\text{6*N+8}$ cycles for the $update\_filter\_coefficient()$-function, with $\text{N}$ again being the filter length.
 \begin{listing}[H]
 \centering
 \begin{lstlisting}[style=cstyle]
@@ -235,13 +235,13 @@ for (int i=0; i< n_coeff; i+=2) chess_loop_range(1,){
     p_w0+=2; 
     }   
     \end{lstlisting}
-    \caption{Code snippet of the $update\_filter\_coefficient()$-function, again making use of the dual \ac{MAC} architecture of the \ac{DSP} and the fractional multiplication function. Additionaly,  32-bit values are loaded and stored as 64-bit values, using two also intrinisc functions, allowing to update two filter coefficients in a single cycle.}
+    \caption{Code snippet of the $update\_filter\_coefficient()$-function, again making use of the dual \ac{MAC} architecture of the \ac{DSP} and the fractional multiplication function. Additionaly,  32-bit values are loaded and stored as 64-bit values, using two also intrinsic functions, allowing to update two filter coefficients in a single cycle.}
     \label{lst:lst_dsp_code_update_filter_coefficients}
 \end{listing}
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_dsp_coefficient_cycle.jpg}
-    \caption{Visualization of the coefficient calculation in the $update\_filter\_coefficient()$-function during the 2nd cyclce of a calculation loop. The output is multiplied with the step size and the corresponding sample from the sample line, before being added to the current filter coefficient.}
+    \caption{Visualization of the coefficient calculation in the $update\_filter\_coefficient()$-function during the 2nd cyclce of a calculation loop. The output is multiplied with the step size and the corresponding sample from the Sample Line, before being added to the current filter coefficient.}
     \label{fig:fig_dsp_coefficient_cycle.jpg}
 \end{figure}
 \paragraph{update\_output()} The $update\_output()$-function is responsible for writing the  calculated output sample back into the shared memory section. The operation takes 5 cycles to execute, independent of the filter length or other parameters.
@@ -253,7 +253,7 @@ for (int i=0; i< n_coeff; i+=2) chess_loop_range(1,){
     \text{C}_{\text{update\_filter\_coefficient}} + \text{C}_{\text{write\_output}}
     \end{aligned}
 \end{equation}
-The sub-functions can seperatly be expressed in dependency of the filter length $\text{N}$ and also in dependency of the update rate of the filter coefficients, which is represented by the parameter $\text{1/U}$ (e.g., if the coefficients are updated every 2 cycles, $\text{1/U}$ would result in a vaule of 0.5):
+The sub-functions can seperatly be expressed in dependency of the filter length $\text{N}$ and also in dependency of the update rate of the filter coefficients, which is represented by the parameter $\text{1/U}$ (e.g. if the coefficients are updated every two cycles, $\text{1/U}$ would result in a vaule of 0.5):
 \begin{gather}
 \label{equation_c_1}
  \text{C}_{\text{write\_buffer()}} = 16 \\
@@ -278,5 +278,31 @@ Equation \ref{equation_computing_final} now provides an estimation of the necess
     \caption{Dependence of the total computing effort on the filter length $\text{N}$ and update rate $\text{1/U}$.}
     \label{fig:fig_c_total.png}
 \end{figure}
-
+\subsection{Verification of the DSP implementation}
+To verify the general performance of the \ac{DSP}-implemented \ac{ANR} algorithm, the complex usecase of the high-level implemenation is utilized, which includes, again, a 56-tap \ac{FIR} filter and an update of the filter coefficients every cycle. In contary to the high-level implementation, the coeffcient convergence is now not included in the evaluation anymore, but the metric for the \ac{ANR} performance stays the same as for the \ac{SNR}  improvement.
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_1_dsp_complex.png}
+    \caption{Desired signal, corrupted signal, reference noise signal and filter output of the complex \ac{ANR} use case, simulated on the \ac{DSP}}
+    \label{fig:fig_plot_1_dsp_complex.png}
+\end{figure}
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_2_dsp_complex.png}
+    \caption{Error signal of the complex \ac{ANR} use case, simulated on the \ac{DSP}}
+    \label{fig:fig_plot_2_dsp_complex.png}
+\end{figure}
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=1.0\linewidth]{Bilder/fig_high_low_comparison.png}
+\caption{Comparison of the high- and low-level simulation output.}
+    \label{fig:fig_high_low_comparison.png}
+\end{figure}  
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=1.0\linewidth]{Bilder/fig_high_low_comparison_hist.png}
+\caption{Histogram of the error amplitude between the high- and low-level simulation output.}
+    \label{fig:fig_high_low_comparison_hist.png}
+\end{figure}  
+\noindent Figure \ref{fig:fig_plot_1_dsp_complex.png} and \ref{fig:fig_plot_2_dsp_complex.png} show the results of the complex \ac{ANR} use case, simulated on the \ac{DSP} - with a \ac{SNR}-Gain of 10.26 dB it performs equivalent sucessful as the one of the high-level implementation. Figure \ref{fig:fig_high_low_comparison.png} shows both outputs seperately and then together in one subfigure, together with the plotted error amplitude. Lastly, Figure \ref{fig:fig_high_low_comparison_hist.png} features a histogram of the error amplitude between the high- and low-level implemenation, indicating the correct functionality of the \ac{DSP} implementation. The small deviations can be explained by the fact that the \ac{DSP} implementation is based on fixed-point arithmetic, which leads to a slightly different convergence behavior. Nevertheless, the results show that the \ac{DSP} implementation of the \ac{ANR} algorithm is able to achieve the same performance as the high-level implementation. The next step is of evaluate the performance of the \ac{DSP} implementation in terms of computational efficiency under different scenarios and non-synchrone signals.
 

chapter_05.aux

@@ -1,129 +1,102 @@
 \relax 
-\@writefile{toc}{\contentsline {section}{\numberline {5}Performance evaluation of different implementation variants}{57}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {5}Performance evaluation of different implementation variants}{60}{}\protected@file@percent }
-\acronymused{DSP}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.1}Determination of the optimal filter length}{60}{}\protected@file@percent }
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.1}Verification of the \ac {DSP} implementation}{57}{}\protected@file@percent }
-\acronymused{DSP}
-\acronymused{ANR}
-\acronymused{FIR}
-\acronymused{ANR}
-\acronymused{SNR}
-\@writefile{lof}{\contentsline {figure}{\numberline {39}{\ignorespaces Desired signal, corrupted signal, reference noise signal and filter output of the complex \ac {ANR} use case, simulated on the \ac {DSP}}}{57}{}\protected@file@percent }
-\acronymused{ANR}
-\acronymused{DSP}
-\newlabel{fig:fig_plot_1_dsp_complex.png}{{39}{57}{}{figure.39}{}}
-\@writefile{lof}{\contentsline {figure}{\numberline {40}{\ignorespaces Error signal of the complex \ac {ANR} use case, simulated on the \ac {DSP}}}{58}{}\protected@file@percent }
-\acronymused{ANR}
-\acronymused{DSP}
-\newlabel{fig:fig_plot_2_dsp_complex.png}{{40}{58}{}{figure.40}{}}
-\@writefile{lof}{\contentsline {figure}{\numberline {41}{\ignorespaces Comparison of the high- and low-level simulation output.}}{58}{}\protected@file@percent }
-\newlabel{fig:fig_high_low_comparison.png}{{41}{58}{}{figure.41}{}}
-\@writefile{lof}{\contentsline {figure}{\numberline {42}{\ignorespaces Histogram of the error amplitude between the high- and low-level simulation output.}}{59}{}\protected@file@percent }
-\newlabel{fig:fig_high_low_comparison_hist.png}{{42}{59}{}{figure.42}{}}
-\acronymused{ANR}
-\acronymused{DSP}
-\acronymused{SNR}
-\acronymused{DSP}
-\acronymused{DSP}
-\acronymused{DSP}
-\acronymused{ANR}
-\acronymused{DSP}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.2}Determination of the optimal filter length}{59}{}\protected@file@percent }
 \acronymused{CI}
 \acronymused{ANR}
 \acronymused{CI}
-\@writefile{lof}{\contentsline {figure}{\numberline {43}{\ignorespaces Noise signals used to corrupt the desired signal in the computational efficiency evaluation}}{60}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {43}{\ignorespaces Noise signals used to corrupt the desired signal in the computational efficiency evaluation}}{61}{}\protected@file@percent }
-\newlabel{fig:fig_noise_signals.png}{{43}{60}{}{figure.43}{}}
+\newlabel{fig:fig_noise_signals.png}{{43}{61}{}{figure.43}{}}
 \acronymused{ANR}
 \acronymused{SNR}
-\@writefile{lof}{\contentsline {figure}{\numberline {44}{\ignorespaces Simulation of the to be expected \ac {SNR}-Gain for different noise signals and filter lengths applied to the desired signal of a male speaker. The applied delay between the signals amounts 2ms. The graphs are smoothed by a third order savigol filter.}}{61}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {44}{\ignorespaces Simulation of the to be expected \ac {SNR}-Gain for different noise signals and filter lengths applied to the desired signal of a male speaker. The applied delay between the signals amounts 2ms. The graphs are smoothed by a third order savigol filter.}}{62}{}\protected@file@percent }
 \acronymused{SNR}
-\newlabel{fig:fig_snr_comparison.png}{{44}{61}{}{figure.44}{}}
+\newlabel{fig:fig_snr_comparison.png}{{44}{62}{}{figure.44}{}}
 \acronymused{SNR}
 \acronymused{SNR}
 \acronymused{SNR}
+\acronymused{ANR}
 \acronymused{SNR}
 \acronymused{SNR}
 \acronymused{SNR}
 \acronymused{ANR}
 \acronymused{SNR}
 \acronymused{ANR}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.3}Evaluation of the Full-update implementation}{61}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.2}Evaluation of a Full-update implementation}{62}{}\protected@file@percent }
-\newlabel{equation_computing_calculation_full_update}{{32}{61}{}{equation.32}{}}
+\newlabel{equation_computing_calculation_full_update}{{32}{62}{}{equation.32}{}}
 \acronymused{PCM}
 \acronymused{DSP}
 \acronymused{DSP}
-\newlabel{equation_cycle_budget}{{33}{62}{}{equation.33}{}}
+\newlabel{equation_cycle_budget}{{33}{63}{}{equation.33}{}}
 \acronymused{DSP}
-\newlabel{equation_load_calculation_full_update}{{34}{62}{}{equation.34}{}}
+\newlabel{equation_load_calculation_full_update}{{34}{63}{}{equation.34}{}}
 \acronymused{ANR}
 \acronymused{SNR}
 \acronymused{DSP}
 \acronymused{DSP}
 \acronymused{SNR}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.4}Evaluation of a Reduced-update implementation}{62}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.3}Evaluation of a Reduced-update implementation}{63}{}\protected@file@percent }
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.4.1}Reduced-update implementation for the benchmark case}{62}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.1}Reduced-update implementation for the benchmark case}{63}{}\protected@file@percent }
 \acronymused{DSP}
 \acronymused{SNR}
-\@writefile{lof}{\contentsline {figure}{\numberline {45}{\ignorespaces Relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the update rate for the benchmark case. The baseline of 100\% is the full update implementation. The marked dots represent the results of the simulation for an explicit setup.}}{63}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {45}{\ignorespaces Relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the update rate for the benchmark case. The baseline of 100\% is the full update implementation. The marked dots represent the results of the simulation for an explicit setup.}}{64}{}\protected@file@percent }
-\newlabel{fig:fig_snr_update_rate.png}{{45}{63}{}{figure.45}{}}
+\newlabel{fig:fig_snr_update_rate.png}{{45}{64}{}{figure.45}{}}
 \acronymused{SNR}
 \acronymused{DSP}
 \acronymused{SNR}
 \acronymused{SNR}
 \acronymused{DSP}
-\newlabel{equation_computing_calculation_reduced_update_1}{{35}{63}{}{equation.35}{}}
+\newlabel{equation_computing_calculation_reduced_update_1}{{35}{64}{}{equation.35}{}}
-\newlabel{equation_load_calculation_reduced_update_1}{{36}{63}{}{equation.36}{}}
+\newlabel{equation_load_calculation_reduced_update_1}{{36}{64}{}{equation.36}{}}
 \acronymused{DSP}
 \acronymused{SNR}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.4.2}Reduced-update implementation for multiple noise signals}{63}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.2}Reduced-update implementation for multiple noise signals}{64}{}\protected@file@percent }
 \acronymused{SNR}
-\@writefile{lof}{\contentsline {figure}{\numberline {46}{\ignorespaces Performance gain (distance between relative SNR-Gain and needed relative cycles/sample) in relation to the update rate of the ANR algorithm for different noise signals.}}{64}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {46}{\ignorespaces Performance gain (distance between relative SNR-Gain and needed relative cycles/sample) in relation to the update rate of the ANR algorithm for different noise signals.}}{65}{}\protected@file@percent }
-\newlabel{fig:fig_gain_update_rate.png}{{46}{64}{}{figure.46}{}}
+\newlabel{fig:fig_gain_update_rate.png}{{46}{65}{}{figure.46}{}}
-\@writefile{lof}{\contentsline {figure}{\numberline {47}{\ignorespaces Absolute \ac {DSP} load in relation to the update rate of the ANR algorithm for different noise signals.}}{64}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {47}{\ignorespaces Absolute \ac {DSP} load in relation to the update rate of the ANR algorithm for different noise signals.}}{65}{}\protected@file@percent }
 \acronymused{DSP}
-\newlabel{fig:fig_load_update_rate.png}{{47}{64}{}{figure.47}{}}
+\newlabel{fig:fig_load_update_rate.png}{{47}{65}{}{figure.47}{}}
 \acronymused{DSP}
-\newlabel{equation_computing_calculation_reduced_update_2}{{37}{64}{}{equation.37}{}}
+\newlabel{equation_computing_calculation_reduced_update_2}{{37}{65}{}{equation.37}{}}
-\newlabel{equation_load_calculation_reduced_update_2}{{38}{65}{}{equation.38}{}}
+\newlabel{equation_load_calculation_reduced_update_2}{{38}{66}{}{equation.38}{}}
 \acronymused{DSP}
 \acronymused{SNR}
 \acronymused{DSP}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.4.3}Computational load of the reduced-update implementation}{65}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.3}Computational load of the reduced-update implementation}{66}{}\protected@file@percent }
-\newlabel{equation_update_1}{{39}{65}{}{equation.39}{}}
+\newlabel{equation_update_1}{{39}{66}{}{equation.39}{}}
-\newlabel{equation_update_2}{{40}{65}{}{equation.40}{}}
+\newlabel{equation_update_2}{{40}{66}{}{equation.40}{}}
 \acronymused{DSP}
-\newlabel{equation_computing_calculation_reduced_update_3}{{41}{65}{}{equation.41}{}}
+\newlabel{equation_computing_calculation_reduced_update_3}{{41}{66}{}{equation.41}{}}
-\newlabel{equation_load_calculation_reduced_update_3}{{42}{65}{}{equation.42}{}}
+\newlabel{equation_load_calculation_reduced_update_3}{{42}{66}{}{equation.42}{}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.5}Evaluation of an error driven implementation}{65}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.4}Evaluation of an error-driven implementation}{66}{}\protected@file@percent }
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.1}Error threshold implementation for the benchmark case}{66}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.4.1}Error-driven implementation for the benchmark case}{67}{}\protected@file@percent }
-\@writefile{lof}{\contentsline {figure}{\numberline {48}{\ignorespaces Relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the error threshold for the benchmark case. The baseline of 100\% is the full update implementation. The marked dots represent the results of the simulation for an explicit setup.}}{66}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {48}{\ignorespaces Relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the error threshold for the benchmark case. The baseline of 100\% is the full update implementation. The marked dots represent the results of the simulation for an explicit setup.}}{67}{}\protected@file@percent }
-\newlabel{fig:fig_snr_error_threshold.png}{{48}{66}{}{figure.48}{}}
+\newlabel{fig:fig_snr_error_threshold.png}{{48}{67}{}{figure.48}{}}
 \acronymused{SNR}
 \acronymused{DSP}
-\newlabel{equation_computing_calculation_error threshold_1}{{43}{67}{}{equation.43}{}}
+\newlabel{equation_computing_calculation_error threshold_1}{{43}{68}{}{equation.43}{}}
-\newlabel{equation_load_calculation_error threshold_1}{{44}{67}{}{equation.44}{}}
+\newlabel{equation_load_calculation_error threshold_1}{{44}{68}{}{equation.44}{}}
 \acronymused{DSP}
 \acronymused{SNR}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.2}Error threshold implementaion for multiple noise signals}{67}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.4.2}Error-driven implementation for multiple noise signals}{68}{}\protected@file@percent }
 \acronymused{SNR}
-\@writefile{lof}{\contentsline {figure}{\numberline {49}{\ignorespaces Performance gain (distance between relative SNR-Gain and needed relative cycles/sample) in relation to the error threshold for different noise signals.}}{67}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {49}{\ignorespaces Performance gain (distance between relative SNR-Gain and needed relative cycles/sample) in relation to the error threshold for different noise signals.}}{68}{}\protected@file@percent }
-\newlabel{fig:fig_gain_error_threshold.png}{{49}{67}{}{figure.49}{}}
+\newlabel{fig:fig_gain_error_threshold.png}{{49}{68}{}{figure.49}{}}
-\@writefile{lof}{\contentsline {figure}{\numberline {50}{\ignorespaces Absolute \ac {DSP} load in relation to the error threshold for different noise signals.}}{68}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {50}{\ignorespaces Absolute \ac {DSP} load in relation to the error threshold for different noise signals.}}{69}{}\protected@file@percent }
 \acronymused{DSP}
-\newlabel{fig:fig_load_error_threshold.png}{{50}{68}{}{figure.50}{}}
+\newlabel{fig:fig_load_error_threshold.png}{{50}{69}{}{figure.50}{}}
 \acronymused{DSP}
-\acronymused{DSP}
+\newlabel{equation_computing_calculation_error_threshold_2}{{45}{69}{}{equation.45}{}}
-\newlabel{equation_computing_calculation_error_threshold_2}{{45}{68}{}{equation.45}{}}
+\newlabel{equation_load_calculation_error_threshold_2}{{46}{69}{}{equation.46}{}}
-\newlabel{equation_load_calculation_error_threshold_2}{{46}{68}{}{equation.46}{}}
 \acronymused{DSP}
 \acronymused{SNR}
 \acronymused{DSP}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.3}Computational load of the error threshold implementation}{68}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.4.3}Computational load of the error-driven implementation}{69}{}\protected@file@percent }
 \newlabel{equation_update_3}{{47}{69}{}{equation.47}{}}
 \acronymused{DSP}
-\newlabel{equation_computing_calculation_error_threshold_3}{{48}{69}{}{equation.48}{}}
+\newlabel{equation_computing_calculation_error_threshold_3}{{48}{70}{}{equation.48}{}}
-\newlabel{equation_load_calculation_error_threshold_3}{{49}{69}{}{equation.49}{}}
+\newlabel{equation_load_calculation_error_threshold_3}{{49}{70}{}{equation.49}{}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.6}Summary of the performance evaluation}{69}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.5}Summary of the performance evaluation}{70}{}\protected@file@percent }
 \acronymused{ANR}
 \acronymused{SNR}
 \acronymused{DSP}
@@ -131,8 +104,8 @@
 \acronymused{SNR}
 \acronymused{SNR}
 \acronymused{DSP}
-\@writefile{lof}{\contentsline {figure}{\numberline {51}{\ignorespaces Updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the update rate for the benchmark case. The higher load is indicated by the newly added continuous lines.}}{70}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {51}{\ignorespaces Updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the update rate for the benchmark case. The higher load is indicated by the newly added continuous lines.}}{71}{}\protected@file@percent }
-\newlabel{fig:fig_snr_update_rate_new.png}{{51}{70}{}{figure.51}{}}
+\newlabel{fig:fig_snr_update_rate_new.png}{{51}{71}{}{figure.51}{}}
 \acronymused{DSP}
 \acronymused{DSP}
 \acronymused{SNR}
@@ -140,15 +113,15 @@
 \acronymused{DSP}
 \acronymused{ANR}
 \acronymused{CI}
-\@writefile{lof}{\contentsline {figure}{\numberline {52}{\ignorespaces Updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the error threshold for the benchmark case. The higher load is indicated by the newly added continuous lines.}}{71}{}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {52}{\ignorespaces Updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the error threshold for the benchmark case. The higher load is indicated by the newly added continuous lines.}}{72}{}\protected@file@percent }
-\newlabel{fig:fig_snr_error_threshold_new.png}{{52}{71}{}{figure.52}{}}
+\newlabel{fig:fig_snr_error_threshold_new.png}{{52}{72}{}{figure.52}{}}
 \acronymused{ANR}
 \acronymused{SNR}
 \acronymused{DSP}
-\@writefile{lot}{\contentsline {table}{\numberline {1}{\ignorespaces Summary of the performance evaluation for the different implementations of the ANR algorithm. The load of the DSP core is calculated with the additional computational effort of the optimization.}}{71}{}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {1}{\ignorespaces Summary of the performance evaluation for the different implementations of the ANR algorithm. The load of the DSP core is calculated with the additional computational effort of the optimization.}}{72}{}\protected@file@percent }
-\newlabel{tab:summary_performance_evaluation}{{1}{71}{}{table.1}{}}
+\newlabel{tab:summary_performance_evaluation}{{1}{72}{}{table.1}{}}
 \@setckpt{chapter_05}{
-\setcounter{page}{72}
+\setcounter{page}{73}
 \setcounter{equation}{49}
 \setcounter{enumi}{0}
 \setcounter{enumii}{0}
@@ -158,7 +131,7 @@
 \setcounter{mpfootnote}{0}
 \setcounter{part}{0}
 \setcounter{section}{5}
-\setcounter{subsection}{6}
+\setcounter{subsection}{5}
 \setcounter{subsubsection}{0}
 \setcounter{paragraph}{0}
 \setcounter{subparagraph}{0}
@@ -283,7 +256,7 @@
 \setcounter{lstnumber}{15}
 \setcounter{FancyVerbLine}{0}
 \setcounter{linenumber}{1}
-\setcounter{LN@truepage}{71}
+\setcounter{LN@truepage}{72}
 \setcounter{FancyVerbWriteLine}{0}
 \setcounter{FancyVerbBufferLine}{0}
 \setcounter{FV@TrueTabGroupLevel}{0}

chapter_05.tex

@@ -1,57 +1,30 @@
 \section{Performance evaluation of different implementation variants}
-\subsection{Verification of the \ac{DSP} implementation}
-To verify the general performance of the \ac{DSP}-implemented \ac{ANR} algorithm, the complex usecase of the high-level implemenation is utilized, which includes, again, a 56-tap \ac{FIR} filter and an update of the filter coefficients every cycle. In contary to the high-level implementation, the coeffcient convergence is now not included in the evaluation anymore, but the metric for the \ac{ANR} performance stays the same as for the \ac{SNR}  improvement.
-\begin{figure}[H]
-    \centering
-    \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_1_dsp_complex.png}
-    \caption{Desired signal, corrupted signal, reference noise signal and filter output of the complex \ac{ANR} use case, simulated on the \ac{DSP}}
-    \label{fig:fig_plot_1_dsp_complex.png}
-\end{figure}
-\begin{figure}[H]
-    \centering
-    \includegraphics[width=1.0\linewidth]{Bilder/fig_plot_2_dsp_complex.png}
-    \caption{Error signal of the complex \ac{ANR} use case, simulated on the \ac{DSP}}
-    \label{fig:fig_plot_2_dsp_complex.png}
-\end{figure}
-\begin{figure}[H]
-    \centering
-    \includegraphics[width=1.0\linewidth]{Bilder/fig_high_low_comparison.png}
-\caption{Comparison of the high- and low-level simulation output.}
-    \label{fig:fig_high_low_comparison.png}
-\end{figure}  
-\begin{figure}[H]
-    \centering
-    \includegraphics[width=1.0\linewidth]{Bilder/fig_high_low_comparison_hist.png}
-\caption{Histogram of the error amplitude between the high- and low-level simulation output.}
-    \label{fig:fig_high_low_comparison_hist.png}
-\end{figure}  
-\noindent Figure \ref{fig:fig_plot_1_dsp_complex.png} and \ref{fig:fig_plot_2_dsp_complex.png} show the results of the complex \ac{ANR} use case, simulated on the \ac{DSP} - with a \ac{SNR}-Gain of 10.26 dB it performs equivalent sucessful as the one of the high-level implementation. Figure \ref{fig:fig_high_low_comparison.png} shows both outputs seperately and then together in one subfigure, together with the plotted error amplitude. Lastly, Figure \ref{fig:fig_high_low_comparison_hist.png} features a histogram of the error amplitude between the high- and low-level implemenation, indicating the correct functionality of the \ac{DSP} implementation. The small deviations can be explained by the fact that the \ac{DSP} implementation is based on fixed-point arithmetic, which leads to a slightly different convergence behavior. Nevertheless, the results show that the \ac{DSP} implementation of the \ac{ANR} algorithm is able to achieve the same performance as the high-level implementation. The next step is of evaluate the performance of the \ac{DSP} implementation in terms of computational efficiency under different scenarios and non-synchrone signals.
 \subsection{Determination of the optimal filter length}
 \noindent The main focus for evaluating the computational efficiency is the determination of the optimal filter length. To achieve this goal, different signal combinations, which are to be expected every day situiations for a \ac{CI} patient, are considered. Again, a delay of 2 ms bewteen the corruption noise signal and the reference noise signal is applied, increasing the need for a longer filter. The desired signal of a male voice is now corrupted with 5 different noise signals, ruling out, that a certain combination of signals is not representative for the overall performance of the \ac{ANR} algorithm:
 \begin{itemize}
     \item Breathing noise: Already used in the high-level implementation, this noise signal is a typical noise source for \ac{CI} patients, especially in quiet environments. It consists out of slowly rising and falling maxima.
-    \item Coughing noise: This noise signal is generated by coughing and consists out few, but long-lasting maxima, showing similarities to a rectangular function.
+    \item Coughing noise: This noise signal is generated by coughing out loud and consists out few, but long-lasting maxima, showing similarities to a rectangular function.
-    \item Scratching noise: This noise signal is generated by scratching some material with finger nails, like the hair or clothes. It consists out of a high number of sharp peaks.
+    \item Scratching noise: Generated by scratching some material with finger nails, like the hair or clothes, this noise signal consists out of a high number of sharp peaks.
-    \item Drinking Noise: This noise signal is generated by swallowing a liquid and consists out of a low number of sharp peaks, featuring long pauses between them.
+    \item Drinking Noise: Swallowing a liquid generates a noise signal consisting out of a low number of sharp peaks, featuring long pauses between them.
-    \item Chewing Noise: This noise signal is generated by consuming food and consists out of a high number of peaks of different amplitude.
+    \item Chewing Noise: Lastly, a chewing noise is generated by consuming food and consists out of a high number of peaks of different amplitude.
 \end{itemize}
-The vizualization of the noise signals is shown in Figure \ref{fig:fig_noise_signals.png}.
+The vizualization of the five described noise signals is shown in Figure \ref{fig:fig_noise_signals.png}.
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_noise_signals.png}
     \caption{Noise signals used to corrupt the desired signal in the computational efficiency evaluation}
     \label{fig:fig_noise_signals.png}
 \end{figure}  
-\noindent The combination of stated sets delivers five different scenarious, everyone different in regard of it's challenges for the \ac{ANR} algorithm. For every scenario, the \ac{SNR}-Gain is calculated with an increasing set of filter coeffcients, ranging from 16 to 64.
+\noindent The combination of stated sets delivers five different scenarios, everyone different in regard of its challenges for the \ac{ANR} algorithm. For every scenario, the \ac{SNR}-Gain is calculated with an increasing set of filter coeffcients, ranging from 16 to 64.
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_snr_comparison.png}
     \caption{Simulation of the to be expected \ac{SNR}-Gain for different noise signals and filter lengths applied to the desired signal of a male speaker. The applied delay between the signals amounts 2ms. The graphs are smoothed by a third order savigol filter.}
     \label{fig:fig_snr_comparison.png}
 \end{figure}  
-\noindent Figure \ref{fig:fig_snr_comparison.png} shows the expected \ac{SNR}-Gain for the different noise signals and filter lengths. The result confirms, that a minimum filter length of about 32 taps is required, before (in any case) a significant rise in the \ac{SNR}-Gain can be observed - this is highly contrary to the synchrone intermediate high level simulation, where a filter length of only 16 taps provided sufficent noise reduction. This circumstance can be explained by the fact, that the corruption noise signal is now delayed to the reference noise signal, meaning, that the filter needs a certain length before it can be sufficently adapted. The results also show, that the \ac{SNR}-Gain is different for the different noise signals, indicating, that the noise signals have different characteristics, like the number of peaks, their frequency spectrum and their amplitude.\\ \\
+\noindent Figure \ref{fig:fig_snr_comparison.png} shows the expected \ac{SNR}-Gain for the different noise signals and filter lengths. The result confirms, that a minimum filter length of about 32 taps is required, before (in any case) a significant rise in the \ac{SNR}-Gain can be observed - this is highly contrary to the synchrone intermediate high level simulation, where a filter length of only 16 taps provided sufficient noise reduction. This circumstance can be explained by the fact, that the corruption noise signal is now delayed to the reference noise signal, meaning, that the filter needs a certain length before it can be sufficiently adapted. The results also show, that the \ac{SNR}-Gain is different for the different noise signals, indicating, that the noise signal´s different characteristics, like the number and duration of peaks, propose differing challenges for the \ac{ANR} algorithm.\\ \\
 The mean \ac{SNR}-Gain of the different noise signals, also shown in Figure \ref{fig:fig_snr_comparison.png}, signals, that after reaching 95\% of the maximum \ac{SNR}-Gain, the \ac{SNR}-Gain increase is slowing down - that threshold is reached at a filter length of 45 taps. This means, that a filter length of 45 taps represents an optimal solution for a statisfying performance of the \ac{ANR} algorithm, while a further increase of the filter length does not lead to a significant increase of the \ac{SNR}-Gain in this setup. This is an important finding, as it allows optimizing the computational efficiency of the \ac{ANR} algorithm by choosing an appropriate filter length.
-\subsection{Evaluation of the Full-update implementation}
+\subsection{Evaluation of a Full-update implementation}
 \noindent Equation \ref{equation_computing_final} can now be utilized to calculate the needed cycles for the calculation of one sample of the filter output, using a filter length of 45 taps and an update of the filter coefficients every cycle. The needed cycles are calculated as follows:
 \begin{equation}
 \label{equation_computing_calculation_full_update}
@@ -117,7 +90,7 @@ Now the same evaluation as in the previous subchapter is conducted for the five
 \end{equation}
 Equation \ref{equation_computing_calculation_reduced_update_2} and \ref{equation_load_calculation_reduced_update_2} confirm, that for an update rate of 0.32, a reduction of the \ac{DSP} load to 20.8\% can be achieved, correlating with a performance gain of 24.9\%. This means, that for all viewed scenarios, an update rate of 0.32 represents the best cost-value ratio, for reducing the load while geting the best possible noise reduction. The relative performance for all scenarios results in a mean \ac{SNR}-Gain reduction of 24.5\% from 11.54 dB to 8.72 dB, while the load of the \ac{DSP} core is reduced by about 53.4\% from 44.6\% to 20.8\%.
 \subsubsection{Computational load of the reduced-update implementation}
-The most straight forward implmementation of a reduced update rate is through the use of a counter and a modulo operation, which checks, if for the current sample the filter coefficients has to be updated or not. The code must therefore be extended by two blocks which are responsible for additional computational load: 
+The most straight forward implementation of a reduced-update rate is through the use of a counter and a modulo operation, which checks if for the current sample the filter coefficients has to be updated or not. The code must therefore be extended by two blocks which are responsible for additional computational load: 
 \begin{gather}
 \label{equation_update_1}
  \text{C}_{\text{increment\_counter}} = 5 \text{ cycles} \\
@@ -133,13 +106,13 @@ Incrementing the counter and checking if the counter has reached the update rate
 \label{equation_load_calculation_reduced_update_3}
     \text{Load}_{\text{DSP}} = \frac{\text{C}_{\text{total}}}{\text{C}_{\text{budget}}} = \frac{197 \text{ cycles}}{800 \text{ cycles}} = 24.6 \%
 \end{equation}
-The results from the updated equations show, that the computational load for an update rate of 0.32 increase substantially from 20.8\% to 24.6\% through the use of a counter and a modulo operation, as the latter is computational quite expensive. A better alternative would be the use of a bitwise check, but this would reduce the possible update rates to powers of 2. In the case of the benchmark track, the load rises from 23.5\% to 27.1\%.
+The results from the updated equations show, that the computational load for an update rate of 0.32 increase substantially from 20.8\% to 24.6\% through the use of a counter and a modulo operation, as the latter is computational quite expensive. A better alternative would be the use of a bitwise check, but this approach reduces the possible update rates to powers of 2. In the case of the benchmark track, the load rises from 23.5\% to 27.1\%.
-\subsection{Evaluation of an error driven implementation}
+\subsection{Evaluation of an error-driven implementation}
 In contrary to the fixed update implementation of the previous chapter, the error-driven implementation is a more sophisticated approach, which focuses on an error metric, over which the decision for a coefficient update is made. 
 The idea is, as the update size of the filter coefficients gets smaller, the benefit of updating them decreases. In practice, a closer look at the update of the filter coefficients is taken: As shown in Equation \ref{equation_lms}, the size of the update of the filter coefficients is directly related to the error signal - if the error signal decreases, the update-size of the filter coefficients also decreases. \\ \\
 As the fixed update implementation is not able to detect such changes, the reduction in update frequency is applied in a static way, which means, that there are situations were it is beneficial and situations where it is not. The error-driven implementation, on the other hand, is able to detect such changing behavior and therefore can adapt the update frequency accordingly. Therefore, the error-driven implementation is expected to deliver a better cost-value ratio than the fixed update implementation.
-\subsubsection{Error threshold implementation for the benchmark case}
+\subsubsection{Error-driven implementation for the benchmark case}
-The chosen approach for this thessis the use a fixed error threshold. This means, that if the error signal remains below an in advance set, certain threshold, the filter coefficients remain unchanged and are not updated. If the error signal exceeds the threshold, the filter coefficients are updated as in the full-update implementation.\\ \\ The crucial aspect of this approach, is the right choise of the error threshold, which is expected to be highly dependent on the acoustic situation. To get an idea of a beneficial error threshold, different values are initially evaluated for the already used benchmark case.\\ \\ The reduction in computational load must now be calculated for the whole audio track by the percentage of samples, where the error signal exceeds the threshold and therefore the coefficients are adapted. This means in detail, that if for a certain error threshold, 50000 of 200000 samples exceed said threshold, the filter coefficients are updated in 25\% of the samples - therefore the update rate of the filter coefficients amounts to 0.25. The result can therefore be expressed in the same way as for the fixed update implementation, where the update rate is directly calculated for one sample.
+The chosen approach for an error-driven implementation is the use a fixed error threshold. This means, that if the error signal remains below an in advance set, certain threshold, the filter coefficients remain unchanged and are not updated. If the error signal exceeds the threshold, the filter coefficients are updated as in the full-update implementation.\\ \\ The crucial aspect of this approach, is the right choise of the error threshold, which is expected to be highly dependent on the acoustic situation. To get an idea of a beneficial error threshold, different values are initially evaluated for the already used benchmark case.\\ \\ The reduction in computational load must now be calculated for the whole audio track by the percentage of samples, where the error signal exceeds the threshold and therefore the coefficients are adapted. This means in detail, that if for a certain error threshold, 50000 of 200000 samples exceed said threshold, the filter coefficients are updated in 25\% of the samples - therefore the update rate of the filter coefficients amounts to 0.25. The result can therefore be expressed in the same way as for the fixed update implementation, where the update rate is directly calculated for one sample.
 \begin{figure}[H]
     \centering
     \includegraphics[width=1.0\linewidth]{Bilder/fig_snr_error_threshold.png}
@@ -156,7 +129,7 @@ The chosen approach for this thessis the use a fixed error threshold. This means
     \text{Load}_{\text{DSP}} = \frac{\text{C}_{\text{total}}}{\text{C}_{\text{budget}}} = \frac{193 \text{ cycles}}{800 \text{ cycles}} = 24.1 \%
 \end{equation}
 The performance difference to reducing the update rate is already clearly for the benchmark track: With a similar \ac{DSP} load of 24.1\% (again, nearly half the load of the full update implementation), the \ac{SNR}-Gain is reduced by only 8.9\% from 9.47dB to 8.63 dB. The same analysis will be applied on all introduced noise signal, to get an idea of the general validity of the made observation. 
-\subsubsection{Error threshold implementaion for multiple noise signals}
+\subsubsection{Error-driven implementation for multiple noise signals}
 Again, the same evaluation as for the benchmark track is conducted for the five introduced noise signals, featuring the performance gain instead of the \ac{SNR}-Gain as an evaluation metric.
 \begin{figure}[H]
     \centering
@@ -170,8 +143,8 @@ Again, the same evaluation as for the benchmark track is conducted for the five
 \caption{Absolute \ac{DSP} load in relation to the error threshold for different noise signals.}
     \label{fig:fig_load_error_threshold.png}
 \end{figure}
-\noindent Similar to the reduced update rate implementation, the observation made for every signal/noise combination is comparable to the benchmark case, but not the same. Figure \ref{fig:fig_gain_error_threshold.png} shows the performance gain for the five different scenarios. The most beneficial error threshold shifted noticeable to a value of 0.07. It's interesting to notice, that the benchmark case seems to be a bit of an exception compared to the behavior of the other scenarios.\\ \\
+\noindent Similar to the reduced-update rate implementation, the observation made for every signal/noise combination is similar to the benchmark case. Figure \ref{fig:fig_gain_error_threshold.png} shows the performance gain for the five different scenarios. The most beneficial error threshold shifted noticeable to a value of 0.07. It's interesting to notice, that the benchmark case seems to be a bit of an exception compared to the behavior of the other scenarios.\\ \\
-A mean error threshold of 0.07 results in a mean update of 38244 out of 200000 samples, which equivalents an update rate of 19.1\%. The \ac{DSP} load for all scenarios is now not the same anymore, but still quite similar - Figure \ref{fig:fig_load_error_threshold.png} shows the absolute load of the \ac{DSP} core for an error threshold of 0.07 results in only 16.6\%.
+A mean error threshold of 0.07 results in a mean update of 38244 out of 200000 samples, which equivalents an update rate of 19.1\%. Figure \ref{fig:fig_load_error_threshold.png} shows, that the absolute load of the \ac{DSP} core for an error threshold of 0.07 results in only 16.6\%.
 \begin{equation}
 \label{equation_computing_calculation_error_threshold_2}
  \text{C}_{\text{total}} = 45 + (6*45+8)*0.191 + 34 = 132 \text{ cycles}
@@ -181,8 +154,8 @@ A mean error threshold of 0.07 results in a mean update of 38244 out of 200000 s
     \text{Load}_{\text{DSP}} = \frac{\text{C}_{\text{total}}}{\text{C}_{\text{budget}}} = \frac{132 \text{ cycles}}{800 \text{ cycles}} = 16.6 \%
 \end{equation}
 Equation \ref{equation_computing_calculation_error_threshold_2} and \ref{equation_load_calculation_error_threshold_2} confirm, that for an error threshold of 0.07, a reduction of the \ac{DSP} load to 16.6\% can be achieved, correlating with a performance gain of 48.4\%. This means, that for all viewed scenarios, an error threshold of 0.07 represents the best cost-value ratio, for reducing the load while geting the best possible noise reduction. The relative performance for all scenarios results in a mean \ac{SNR}-Gain reduction of 11.7\% from 11.54 dB to 10.19 dB, while the load of the \ac{DSP} core is reduced by about 62.8\% from 44.6\% to 16.6\%.
-\subsubsection{Computational load of the error threshold implementation}
+\subsubsection{Computational load of the error-driven implementation}
-In contrary to the fixed update implementation, the error threshold implementation for a fixed error threshold does not require computational expensive operations: The threshold is implemented as a 32-bit integer which is simply checked for every sample by a single if-clause.
+In contrary to the reduced-update implementation, the error-driven implementation does not require computational expensive operations: The error threshold is implemented as a 32-bit integer which is simply checked for every sample by a single if-clause.
 \begin{gather}
  \label{equation_update_3}
 \text{C}_{\text{check\_threshold}} = 10 \text{ cycles}
@@ -197,7 +170,7 @@ Equation \ref{equation_computing_calculation_error_threshold_3} and \ref{equatio
 \label{equation_load_calculation_error_threshold_3}
     \text{Load}_{\text{DSP}} = \frac{\text{C}_{\text{total}}}{\text{C}_{\text{budget}}} = \frac{142 \text{ cycles}}{800 \text{ cycles}} = 17.8 \%
 \end{equation}
-Contrary to the fixed update implementation, the computational load for an error threshold of 0.07 shows only a minimal increase from 16.6\% to 17.8\% through the use of a computational cheap if-clause. This is a clear advantage compared to the fixed update implementation. In the case of the benchmark track, the load rises from 24.1\% to 25.7\%.
+Contrary to the reduced-update implementation, the computational load for an error threshold of 0.07 shows only a minimal increase from 16.6\% to 17.8\% through the use of a computational cheap if-clause. This is a clear advantage compared to the fixed update implementation. In the case of the benchmark track, the load rises from 24.1\% to 25.7\%.
 \subsection{Summary of the performance evaluation}
 The results of two analysis can be summarized as follows: \\ \\ With the optimal filter length of 45 taps and an update rate of the filter coefficients every cycle, the \ac{ANR} algorithm is able to achieve a \ac{SNR}-Gain of about 11.54 dB, averaged over all different signal/noise combinations. Under these circumstances, the computational load of the \ac{DSP} core amounts about 45\%, which means that 55\% of the time, which a new sample takes to arrive, it can be halted, and therefore, the overall power consumption can be reduced.\\ \\
 A simple method to further reduce the load of the \ac{DSP} core is to reduce the update frequency of the filter coeffcients. For the benchmark signal/noise combination, an update rate of 0.39 nearly halfs the processor load from 44.6\% to 23.5\%, while only reducing the \ac{SNR}-Gain by rougly 31 \% from 9.47 dB to 6.40 dB. For all viewed scenarios, an update rate of 0.32 represents the best cost-value ratio, for reducing the load while geting the best possible noise reduction - with a mean \ac{SNR}-Gain reduction of 24.5\% from 11.54 dB to 8.72 dB, while the load of the \ac{DSP} core is reduced by about 53.4\% from 44.6\% to 20.8\%. While the perfromance benefit of this approach is reasonable, the computanional effort of the implementation is significant -  the 20.8\% total load rise to 24.6\%. Figure \ref{fig:fig_snr_update_rate_new.png} shows the updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the update rate for the benchmark case, where the higher load is indicated by the newly added continuous grahps. The initial graphs are still slightly visible allowing a better comparison of the two implementations.
@@ -207,7 +180,7 @@ A simple method to further reduce the load of the \ac{DSP} core is to reduce the
     \caption{Updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the update rate for the benchmark case. The higher load is indicated by the newly added continuous lines.}
     \label{fig:fig_snr_update_rate_new.png}
 \end{figure}
-\noindent A more sophisticated method to reduce the load of the \ac{DSP} core is to use an error-driven implementation, where the update of the filter coefficients is only conducted, if the error signal exceeds a certain threshold. For the benchmark case, with a similar \ac{DSP} load of 24.1\% (compared to the reduce update implementation), the \ac{SNR}-Gain is reduced by only 8.9\% from 9.47 dB to 8.63 dB. For all viewed scenarios, an error threshold of 0.07 represents the best cost-value ratio - with a mean \ac{SNR}-Gain reduction of 11.7\% from 11.54 dB to 10.19 dB, while the load of the \ac{DSP} core is reduced by about 62.8\% from 44.6\% to 16.6\%. This substentional performance gain is bought by only a slight increase in computing effort - the 16.6\% total load rise only to 17.8\%\\ \\
+\noindent A more sophisticated method to reduce the load of the \ac{DSP} core is to use an error-driven implementation, where the update of the filter coefficients is only conducted, if the error signal exceeds a certain threshold. For the benchmark case, with a similar \ac{DSP} load of 24.1\% (compared to the reduced-update implementation), the \ac{SNR}-Gain is reduced by only 8.9\% from 9.47 dB to 8.63 dB. For all viewed scenarios, an error threshold of 0.07 represents the best cost-value ratio - with a mean \ac{SNR}-Gain reduction of 11.7\% from 11.54 dB to 10.19 dB, while the load of the \ac{DSP} core is reduced by about 62.8\% from 44.6\% to 16.6\%. This substentional performance gain is bought by only a slight increase in computing effort - the 16.6\% total load rise only to 17.8\%\\ \\
 This result proofes, that an error-driven implementation of the \ac{ANR} algorithm is highly suitable to reduce the load needed for adaptive noise reduction in a \ac{CI} application, while still providing nearly 90\% of the maximum achievable performance under the viewed circumstances. Again, Figure \ref{fig:fig_snr_error_threshold_new.png} shows the updated plot of the relative performance of the SNR-Gain, the cycles per samples and the DSP load in regard of the error threshold for the benchmark case.
 \begin{figure}[H]
     \centering
@@ -220,7 +193,7 @@ This result proofes, that an error-driven implementation of the \ac{ANR} algorit
 \centering
 \begin{tabular}{|c|c|c|c|}
 \hline
- & \textbf{Full Update} & \textbf{Reduced Update} & \textbf{Error-Driven} \\ \hline
+ & \textbf{Full-Update} & \textbf{Reduced-Update} & \textbf{Error-Driven} \\ \hline
 \textbf{SNR-Gain Benchmark} &9.47 dB  &6.40 dB  &8.63 dB  \\ \hline
 \textbf{DSP Load Benchmark} &44.6\%  &27.1\%  &25.7\%  \\ \hline
 \textbf{SNR-Gain All Scenarios} &11.54 dB  &8.72 dB  &10.19 dB  \\ \hline

chapter_06.aux

@@ -1,5 +1,5 @@
 \relax 
-\@writefile{toc}{\contentsline {section}{\numberline {6}Conclusion and outlook}{72}{}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {6}Conclusion and outlook}{73}{}\protected@file@percent }
 \acronymused{ANR}
 \acronymused{CI}
 \acronymused{LMS}
@@ -17,7 +17,7 @@
 \acronymused{CI}
 \acronymused{CI}
 \@setckpt{chapter_06}{
-\setcounter{page}{74}
+\setcounter{page}{75}
 \setcounter{equation}{49}
 \setcounter{enumi}{0}
 \setcounter{enumii}{0}
@@ -152,7 +152,7 @@
 \setcounter{lstnumber}{15}
 \setcounter{FancyVerbLine}{0}
 \setcounter{linenumber}{1}
-\setcounter{LN@truepage}{73}
+\setcounter{LN@truepage}{74}
 \setcounter{FancyVerbWriteLine}{0}
 \setcounter{FancyVerbBufferLine}{0}
 \setcounter{FV@TrueTabGroupLevel}{0}

drawio/fig_anr.drawio

@@ -1,6 +1,6 @@
 <mxfile host="app.diagrams.net" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36">
   <diagram name="Seite-1" id="BWOSVWQKrhK0Pcg9Olm2">
-    <mxGraphModel dx="2241" dy="743" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+    <mxGraphModel dx="2241" dy="759" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
       <root>
         <mxCell id="0" />
         <mxCell id="1" parent="0" />
@@ -88,15 +88,6 @@
         <mxCell id="ngw2JN3qWJ9t0b-mEEB_-6" parent="1" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" value="&lt;span style=&quot;font-size: 20px;&quot;&gt;e&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt; = d&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt;-y&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt; =&amp;nbsp;&lt;/span&gt;&lt;span style=&quot;color: rgb(32, 33, 34); font-family: sans-serif; font-size: 16px; text-align: start; text-wrap-mode: wrap; background-color: rgb(255, 255, 255);&quot;&gt;Š&lt;/span&gt;&lt;span style=&quot;font-size: 20px;&quot;&gt;&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt;&lt;/span&gt;" vertex="1">
           <mxGeometry height="40" width="190" x="520" y="227.5" as="geometry" />
         </mxCell>
-        <mxCell id="ngw2JN3qWJ9t0b-mEEB_-8" edge="1" parent="1" source="ngw2JN3qWJ9t0b-mEEB_-4" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=1.025;exitDx=0;exitDy=0;exitPerimeter=0;strokeWidth=2;" value="">
-          <mxGeometry height="50" relative="1" width="50" as="geometry">
-            <Array as="points">
-              <mxPoint x="330" y="560" />
-            </Array>
-            <mxPoint x="390" y="410" as="sourcePoint" />
-            <mxPoint x="410" y="560" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
         <mxCell id="ngw2JN3qWJ9t0b-mEEB_-9" parent="1" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;strokeWidth=2;" value="&lt;font style=&quot;font-size: 15px;&quot;&gt;Error&lt;br&gt;Metric&lt;/font&gt;" vertex="1">
           <mxGeometry height="60" width="120" x="410" y="530" as="geometry" />
         </mxCell>

drawio/fig_anr_hybrid.drawio

@@ -1,6 +1,6 @@
 <mxfile host="app.diagrams.net" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36">
   <diagram name="Seite-1" id="BWOSVWQKrhK0Pcg9Olm2">
-    <mxGraphModel dx="2241" dy="743" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+    <mxGraphModel dx="2241" dy="759" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
       <root>
         <mxCell id="0" />
         <mxCell id="1" parent="0" />
@@ -95,15 +95,6 @@
         <mxCell id="ngw2JN3qWJ9t0b-mEEB_-6" parent="1" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" value="&lt;span style=&quot;font-size: 20px;&quot;&gt;e&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt; = d&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt;-y&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt; =&amp;nbsp;&lt;/span&gt;&lt;span style=&quot;color: rgb(32, 33, 34); font-family: sans-serif; font-size: 16px; text-align: start; text-wrap-mode: wrap; background-color: rgb(255, 255, 255);&quot;&gt;Š&lt;/span&gt;&lt;span style=&quot;font-size: 20px;&quot;&gt;&lt;sub&gt;[&lt;i&gt;n&lt;/i&gt;]&lt;/sub&gt;&lt;/span&gt;" vertex="1">
           <mxGeometry height="40" width="190" x="520" y="227.5" as="geometry" />
         </mxCell>
-        <mxCell id="ngw2JN3qWJ9t0b-mEEB_-8" edge="1" parent="1" style="endArrow=classic;html=1;rounded=0;strokeWidth=2;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" target="ngw2JN3qWJ9t0b-mEEB_-9" value="">
-          <mxGeometry height="50" relative="1" width="50" as="geometry">
-            <Array as="points">
-              <mxPoint x="310" y="610" />
-            </Array>
-            <mxPoint x="310" y="460" as="sourcePoint" />
-            <mxPoint x="410" y="560" as="targetPoint" />
-          </mxGeometry>
-        </mxCell>
         <mxCell id="ngw2JN3qWJ9t0b-mEEB_-9" parent="1" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;strokeWidth=2;" value="&lt;font style=&quot;font-size: 15px;&quot;&gt;Error&lt;br&gt;Metric&lt;/font&gt;" vertex="1">
           <mxGeometry height="60" width="120" x="410" y="580" as="geometry" />
         </mxCell>

main.tex

@@ -111,14 +111,14 @@ by \par
 \newpage
 \begin{abstract}
     \noindent The goal of this thesis is the implementation, followed by the investigation of improvement options, of a real-time capable Adaptive Noise Reduction (ANR) algorithm in Cochlear Implant (CI) systems. The focus lies on the reduction of the computational load, and subsequently the power consumption, of the used Digital Signal Processor (DSP) core, while still keeping the noise reduction performance as high as possible.\\ \\
-    \noindent The chosen method for noise reduction is the use of an adaptive filter combined with the Least Mean Square algorithm, which is a widely utilized method in this context. The evaluation of the performance is conducted via the Signal-Noise-Ratio (SNR)-Gain, which serves as a metric for the quality of the noise reduction. Several use cases (from simple to realistic) are analyzed to evaluate qualitiy of the output under different conditions.\\ \\
+    \noindent The chosen method for noise reduction is the use of an adaptive filter combined with the Least Mean Square algorithm, which is a widely utilized method in this context. The evaluation of the performance is conducted via the Signal-Noise-Ratio (SNR)-Gain, which serves as a metric for the quality of the noise reduction. Several use cases (from simple to realistic) are analyzed to evaluate the output qualitiy under different conditions.\\ \\
-    \noindent After confirming the general feasibility of the proposed method in a high-level Python-implementation, the algorithm is implemented in C, using DSP compiler instrinsic functions to achieve real-time capability. The performance of the C-implementation is then sucessfully compared to the initial high-level implementation, showing only minor deviations.\\ \\
+    \noindent After confirming the general feasibility of the proposed method in a high-level Python implementation, the algorithm is implemented in C, using DSP compiler instrinsic functions to achieve real-time capability. The performance of the C implementation is then sucessfully compared to the initial high-level variant, showing only minor deviations.\\ \\
-    \noindent With a working C-implementation in place, a closer look on the achievable performance under full-update settings is taken, which serves as a benchmark-setting for the remaining thesis. The computational cost of the algorithm is evaluated in terms of the needed cycles to compute one audio sample, which can be expressed as a function of the filter length and the update rate.\\ \\
+    \noindent With a working C implementation in place, a closer look on the achievable performance under full-update settings is taken, which serves as a benchmark-setting for the remaining thesis. The computational cost of the algorithm is evaluated in terms of the needed cycles to compute one audio sample, which can be expressed as a function of the filter length and the update rate.\\ \\
-    \noindent With this formula developed, several noise sources are put under test, to evaluatue the optimal filter length, which is a trade-off between the performance improvement and the computational cost. The ideal filter length is determined at 45 coeffcients, where about 95\% averaged \ac{SNR}-Gain can be achieved.\\ \\
+    \noindent With a feasibile equation developed, several noise sources are put under test, to evaluatue the optimal filter length, which is a trade-off between the performance improvement and the computational cost. The ideal filter length is determined at 45 coeffcients, where about 95\% averaged \ac{SNR}-Gain can be achieved.\\ \\
     \noindent With the filter lenght set, the improvement of the algorithm is tackled, both for a benchmark track and different signal/noise scenarios.\\ \\
     \noindent The first approach is a reduction of the update rate. This strategy is able to significantly reduce the needed cycles, but with a simultanious considerable decrease in the SNR-Gain.\\ \\
     \noindent The second approach is an error driven optimization, utilizing the idea of a fixed threshold for the error signal, over which the decision over an upgrade of the filter coefficients is made. This approach turns out to be a success, as it is able to achieve a significant reduction in the needed cycles, while only reducing the SNR-Gain by a small amount.\\ \\
-    \noindent Therefore, the error driven optimization approach can be seen as the sucessful result of this thesis, as it is able to further improve an already real-time capable ANR algorithm by significantly reducing the computational load of the DSP core, while only slightly reducing the performance improvement in terms of the SNR-Gain.\\ \\
+    \noindent Therefore, the error driven optimization approach can be seen as the sucessful result of this thesis, as it is able to further improve an already real-time capable ANR algorithm by significantly reducing the computational load of the DSP core, while only slightly decreasing the performance improvement in terms of the SNR-Gain.\\ \\
 
 \end{abstract}
 \include{chapter_01}