Instituto Federal de Educao, Cincia e Tecnologia de Santa Catarina

DEPARTAMENTO ACADMICO DE ELETRNICA

ESPECIALIZAO EM DESENVOLVIMENTO DE PRODUTOS
ELETRNICOS
SISTEMAS EMBARCADOS II

PROJETO FINAL

Professores: Fernando Pacheco

Renan Starke

Alunos: Marcio de Andrade Vogt

Ricardo do Nascimento
1. Projeto do filtro
Para o projeto do filtro, utilizou-se a ferramenta Filter Design and Analysis
Tool do Matlab.
a. Especificao
As especificaes do filtro foram determinadas a partir da amostra de
udio fornecida, onde o primeiro passo era identificar a frequncia do rudo que
interferia no sinal de interesse. A Figura 1 mostra o espectro de frequncia do
sinal de udio, onde pode-se perceber um pico de sinal na frequncia de 60 Hz
e no seu 3 harmnico (180 Hz).

Figura 1 - FFT do sinal de udio a ser filtrado.

Logo, pode-se inferir que um filtro passa altas, sintonizado na frequncia
de 180 Hz seria suficiente para eliminar o rudo do sinal em questo.
Na janela do FDATool representada na Figura 2, preciso definir os
parmetros do tipo de filtro, F , F , A e A para que ento a aplicao projete
stop pass stop pass

o filtro. O filtro projetado neste trabalho possui os parmetros descritos na Tabela

1- Parmetros do filtro para o FDATool..
 Figura 2 - Janela FDATool.

Tabela 1- Parmetros do filtro para o FDATool.

Tipo de Filtro Highpass FIR Window

F stop 500
F pass 200
A stop 40
A pass 1
A utilizao dos parmetros descritos acima, produz o projeto de filtro
exibido na Figura 3, onde o filtro projetado possui 358 coeficientes.

Figura 3- Resultado do projeto do filtro no FDATool.

b. Simulao no Matlab
Utilizando o Matlab, feita a simulao do filtro primeiro com um sinal de
sweep com frequncia variando at 20 kHz e na sequncia com o sinal de udio
como entrada. Os resultados das ffts dos sinais filtrados podem ser visualizados
na Figura 4 e Figura 5, onde pode-se perceber a atenuao dos sinais de baixa
frequncia, preservando os de mais frequncia acima a da utilizada no projeto
do filtro.
 Figura 4 - FFT do sinal de sweep filtrado.

Figura 5 - FFT da simulao do filtro.

2. Implementao em FPGA
c. Descrio do funcionamento dos dois componentes IPs
A implementao do filtro feita utilizando dois componentes IP, sendo eles
uma memria RAM e um filtro digital do tipo FIR. A memria responsvel pelo
armazenamento do sinal de udio a ser filtrado e o componente FIR a
implementao em VHDL do filtro FIR.
Memria RAM
Caractersticas
Descrever as caractersticas do componentes (Tamanho da memria, etc.)
O componente memria RAM desempenha a funo de armazenar os dados
de entrada a serem utilizados no filtro. A memria possui 16 bits de endereo
com um tamanho de palavra de 16 bits, perfazendo assim 1 Gbyte de memria.
Quanto aos dados de entrada do filtro so deslocados de seis amostras (so
includos zeros nas primeiras 6 amostras) de forma que o arquivo de sada fique
compatvel com o gerado no filtro de mdia movel implementado no DSP.
O componente possui as portas de entrada e sada descritas na Tabela 2.
Tabela 2 - Portas de entrada e sada do componente.

Porta Tipo e Tamanho Descrio

Porta de entrada com o
address std_logic_vector de 16 bits endereo dos dados de
memria
Porta de entrada de clock do
clock std_logic de 1 bit
componente
Porta de entrada das
data std_logic_vector de 16 bits informaes a serem
armazenadas.
Porta de entrada para habilitar
wren std_logic de 1 bit
escrita ou leitura na memria.
Porta de sada dos dados
armazenados na memria e
Q std_logic_vector de 16 bits
que serve como entrada para
o componente FIR

Parmetros de configurao
Arquivo de amostras, utilizados para inicializar a memria. Pode-se citar
como parmetro de configurao, o tamanho dos vetores que por fim definem o
tamanho da memria RAM.

Filtro FIR
Caractersticas
O filtro FIR consiste de basicamente trs componentes, sendo o primeiro um
contador que responsvel pela gerao dos endereos de leitura da memria,
o segundo so unidades de multiplicao e acumulao (MAC) similar s que
so implementadas em um DSP e por fim uma mquina de estados que controla
o funcionamento do filtro.
 No componente so implementadas tantas unidades de MAC quanto o
nmero de coeficientes utilizados no filtro FIR. Na implementao, a topologia
do filtro utilizado um filtro de mdia mvel com 6 coeficientes.
O componente possui os parmetros de configurao descritos na Tabela 3
e as portas de entrada e sada descritas na Tabela 4.
Tabela 3 - Parmetros de configurao.

Nome Tipo Descrio

ADDR_BUS Inteiro Tamanho do barramento
de endereos.
DATA_BUS Inteiro Tamanho do barramento
de dados.
COEF_BIT Inteiro Quantidade de bits dos
coeficientes.
N_COEF Inteiro Nmero de Coeficientes
do filtro
N_SAMPLES Inteiro Nmero de amostras a
serem filtradas.
Tabela 4 - Portas de entrada e sada do componente FIR.

Porta Tipo e Tamanho Descrio

Porta de entrada de clock do
clock std_logic de 1 bit
componente
Porta de entrada para o sinal
Rst std_logic de 1 bit
de reset.
Porta de entrada do sinal de
en_in std_logic de 1 bit
enable do componente.
Porta de entrada para os
b0...b5 std_logic_vector de N_Coef bits
coeficientes do filtro.
data_in std_logic_vector de DATA_BUS- Porta de entrada de dados a
1 bits serem filtrados
Porta de sada responsvel
std_logic_vector de ADDR_BUS-
addr_out dos endereos para leitura da
1 bits
memria RAM.
std_logic_vector de DATA_BUS- Porta de sada do sinal filtrado
y_out
1 bits. com 16 bits.
valid_out std_logic de 1 bit Porta de sada.
done_out std_logic de 1 bit Porta de sada.
 Limitaes em relao a implementao em C/DSP (Comparao entre
as duas abordagens)
Numa anlise macro pode-se apontar como principal desvantagem entre as
duas formas de implementao do filtro FIR utilizando um DSP se comparada
com a implementao em PLD ou FPGA refere-se a complexidade de
desenvolvimento, programao e sintetizao dos componentes usando
linguagem de descrio de hardware, principalmente se considerarmos que o
desenvolvimento em C uma abordagem mais tradicional o que por si s torna
a compreenso do processo de desenvolvimento mais simples. Outro ponto que
cabe destacar refere-se a facilidade de visualizao do resultado da filtragem,
sobretudo pela placa de desenvolvimento utilizada na implementao do filtro
FIR em DSP dado que essa placa contava com perifricos que tornam possvel
verificar o resultado da filtragem de forma audvel tornando-se assim mais
didtico.
Muito embora tenham sido apresentadas desvantagens ou limitaes da
implementao utilizando PLDs, existem pontos onde este tipo de
implementao apresenta vantagem em relao a abordagem mais tradicional
utilizando DSPs.
A possibilidade de implementao de tantas unidades de MAC na FPGA
quantos sejam o nmero de coeficientes do filtro pode trazer um ganho de
desempenho que pode ser determinante na escolha em algumas aplicaes.
Outra vantagem refere-se disponibilidade de um software de simulao que
permite analisar o comportamento do componente ou projeto a ser sintetizado
sem a necessidade de testes em hardware. Este tipo de software de simulao
pode trazer ganhos no desenvolvimento do projeto, j que em aplicaes
complexas facilita (ou ainda torna vivel) a depurao do projeto e tambm reduz
o tempo de desenvolvimento, dado que faz com que no seja necessrio todo o
processo de sintetizao do circuito no PLD quando se est nos estgios iniciais
de desenvolvimento de um projeto.

d. Descrio do funcionamento do sistema como um todo

Descrio do cdigo VHDL
O cdigo VHDL composto de dois blocos, sendo eles: memria RAM e FIR.
O bloco do filtro FIR ainda composto por 4 componentes, sendo eles: contador,
mquina de estados de controle do filtro, multiplicador, acumulador.
A memria RAM inicializada com os valores de um arquivo de udio em
hexadecimal contendo os dados de um sinal do tipo sweep. Aps a inicializao
dos dados, o controle de acesso a memria feito pelo filtro FIR e seus
componentes.
J o componente FIR um pouco mais complexo e ser explicado em
maiores detalhes, tratando dos componentes internos individualmente.
A mquina de estados, denominado fir_control, responsvel por controlar
a transio de estados do filtro FIR de um estado de idle at o processo de
filtragem (operaes de multiplicao e acumulao). Se o sinal de entrada rst
do componente FIR mantido em 1, a mquina de estados mantm o filtro em
idle, caso contrrio na prxima borda de clock a mquina de estados testa a
condio da entrada de enable do bloco estar em nvel alto, caso sim ento o
filtro passa para o estado de inicializao (Init). Aps entrar no estado Init, a cada
borda de clock a mquina de estados muda seu estado at chegar no estado de
acumulao, onde fica at que se atinja o nmero de amostras ajustados na
configurao do filtro (dados setados na parte do cdigo denominada Generics).
O contador simplesmente um contador de 16 bits, cuja funo
incrementar as posies de memria at atingir o limite de amostras configurado.
A cada borda de clock, o contador incrementado de uma posio e essa
posio serve de entrada para o barramento de endereos da memria RAM.
O acumulador um somador com 32 bits, onde calculado a soma dos
dados da multiplicao dos coeficientes com o do sinal proveniente da memria
para cada um dos instantes de tempo (ou posies da memria), sempre
pegando valor da amostra n at n+5 (referente aos seis coeficientes do filtro de
mdia mvel de 6 amostras).
O multiplicador realiza a operao de multiplicao dos coeficientes do filtro
e sua respectiva amostra e o resultado da multiplicao utilizado ento no
acumulador.
O componente FIR agrega todos os outros componentes (com exceo da
memria RAM). Nele so instanciados tantos multiplicadores quanto seja o
nmero de coeficientes utilizados no filtro.
A Figura 6 apresenta o resultado de simulao do testbench na ferramenta
de simulao modelsim.

Figura 6- Formas de onda da simulao do testbench.

3. Implementao na placa Cortex-M4

Para a implementao fsica do filtro, ser utilizada a placa de
desenvolvimento STM32F4Discovery composta por um microprocessador cortex
M4 e pela placa Wolfson Audio Card como uma interface para entrada de sinais
de udio via I2C.
 a. Estrutura utilizada
O filtro implementado utilizando a funo FIR32 disponvel na biblioteca de
funes da placa de desenvolvimento, utilizando os coeficientes projetados no
FDATool do Matlab. Para a implementao do cdigo foi utilizado um exemplo
disponibilizado em sala de aula, cujo estrutura pode ser vista no anexo 1.
b. Resultados com sinal de teste padro
Para o teste com o sinal de teste padro foi utilizado um sinal de sweep de
at a frequncia de 20 kHz. Na Figura 7 apresentado o resultado da filtragem
do sinal, onde na parte superior est o sinal filtrado e na parte inferior o sinal pr-
filtro. visvel na FFT do sinal a atenuao dos sinais de mais baixa frequncia,
comportamento este esperado para o filtro projetado.

Figura 7 - Resultado do filtrado usando como sinal de entrada um sweep.

c. Resultados com sinal de udio

O resultado do teste com o sinal de udio fornecido apresentado na Figura
8, onde a parte superior mostra a FFT do sinal filtrado enquanto que a parte
inferior mostra o sinal original. Novamente possvel perceber a atenuao dos
rudos de 60 Hz e 180 Hz (ou de baixa frequncia) conforme esperado para este
projeto de filtros.
 Figura 8 - Resultado do filtro com o sinal de udio com rudo em 60 Hz e 180 Hz

d. Anlise de desempenho
Estimativa de complexidade
O desenvolvimento e implementao do cdigo muito facilitado pela pr-
existncia de uma funo no dsp que implementa a funo de um filtro FIR.
Entretanto, o uso desta funo implica no conhecimento do seus parmetros de
entrada e funcionamento, de forma a tornar sua utilizao efetiva. Como exemplo
de problema passvel de ocorrer, pode-se citar o fato de os coeficientes do filtro
serem passados invertidos dentro da funo FIR32.
Outro ponto em relao a complexidade que muito embora o DSP seja
capaz de implementar filtros de ordem elevada, tentou-se limitar a ordem do filtro
a algo em torno de 300 coeficientes (no caso deste projeto, exatamente 358
coeficientes) de forma a no tornar muito oneroso o processo de filtragem.
Verificao do nmero de ciclos gastos no processamento
4. Anexo
/******************************************************************
* Filtro FIR usando CMSIS-DSP (implement. ponto fixo e flutuante)
* Acessa udio usando Wolfson Pi
*
* Fernando S. Pacheco
* Fbio Cabral Pacheco
* IFSC 2017
********************************************************************/

#include <stm32f4xx.h>
#include <arm_math.h>
#include <stm32f4_discovery.h>
#include <stm32f4_discovery_accelerometer.h>
#include <wolfson_pi_audio.h>
#include <diag/Trace.h>
#include <tests.h>
#include <dwt.h>
#include "filter.h"
//#include "math_helper.h"

#define NUM_TAPS 359

#define BLOCK_SIZE (WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE)/4

#undef CYCLE_COUNTER

int16_t TxBuffer[WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE];
int16_t RxBuffer[WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE];

__IO BUFFER_StateTypeDef buffer_offset = BUFFER_OFFSET_NONE;

__IO uint8_t Volume = 70;

uint32_t AcceleroTicks;
int16_t AcceleroAxis[3];

/* -------------------------------------------------------------------
* Declare State buffer of size (numTaps + blockSize - 1)
* ------------------------------------------------------------------- */
static float32_t firStateF32[BLOCK_SIZE + NUM_TAPS - 1];
static q15_t firStateQ15[BLOCK_SIZE + NUM_TAPS - 1];

/* ----------------------------------------------------------------------
** FIR Coefficients buffer. Moving average.
** ------------------------------------------------------------------- */
const float32_t firCoeffs32[NUM_TAPS] = {-0.000247389974359297,-0.000260815639562801,-
0.000274162804122007,-0.000287372293767833,-0.000300382791186509,-0.000313130977126562,-
0.000325551682902149,-0.000337578054091672,-0.000349141725185149,-0.000360173004896661,-
0.000370601071813108,-0.000380354180012535,-0.000389359874242516,-0.000397545214210297,-
0.000404837007496750,-0.000411162050567322,-0.000416447377315747,-0.000420620514541311,-
0.000423609743721635,-0.000425344368414368,-0.000425754986583481,-0.000424773767119915,-
0.000422334729793877,-0.000418374027851738,-0.000412830232443354,-0.000405644618045301,-
0.000396761448021658,-0.000386128259449246,-0.000373696146315129,-0.000359420040183731,-
0.000343258987416851,-0.000325176422025874,-0.000305140433225629,-0.000283124026760571,-
0.000259105379071508,-0.000233068083376280,-0.000205001386741351,-0.000174900417233662,-
0.000142766400250213,-0.000108606863141047,-7.24358272562506e-05,-3.42739865717632e-
05,5.85112793198369e-06,4.79049989331206e-05,9.18459892421712e-
05,0.000137625224821003,0.000185186495047934,0.000234466170890219,0.000285393141608277,0
.000337888770569439,0.000391866870707068,0.000447233700110846,0.000503887978187604,0.000
561720922775860,0.000620616308548631,0.000680450546979315,0.000741092788092066,0.000802
405044155056,0.000864242335421021,0.000926452857951809,0.000988878173507272,0.001051353
42141083,0.00111370755224619,0.00117576358316809,0.00123733887455366,0.0012982454276496
2,0.00135829020281066,0.00141727545785695,0.00147499910601899,0.00153125509286918,0.0015
8583379158388,0.00163852241581311,0.00168910544937966,0.00173736509196554,0.00178308171
989452,0.00182603436105605,0.00186600118296952,0.00190275999293351,0.00193608874915792,0
.00196576608172824,0.00199157182221298,0.00201328754067891,0.00203069708884594,0.0020435
8714807572,0.00205174778086148,0.00205497298445191,0.00205306124522563,0.00204581609240
578,0.00203304664969221,0.00201456818336972,0.00199020264545020,0.00195977921039118,0.00
192313480394069,0.00188011462265338,0.00183057264263873,0.00177437211610043,0.001711386
05425470,0.00164149769522299,0.00156460095552392,0.00148060086381289,0.0013894139755532
2,0.00129096876732968,0.00118520600956381,0.00107207911642407,0.000951554471777768,0.000
823611730073447,0.000688244091105476,0.000545458547658511,0.000395276105100021,0.000237
731972042283,7.28757212701298e-05,-9.92285798083822e-05,-0.000278502269853134,-
0.000464852026021663,-0.000658169828653527,-0.000858332958651623,-0.00106520402791759,-
0.00127863104312430,-0.00149844750301713,-0.00172447252935988,-0.00195651103154806,-
0.00219435390483628,-0.00243777826202815,-0.00268654769840409,-0.00294041258956298,-
0.00319911042177922,-0.00346236615438049,-0.00372989261357538,-0.00400139091706868,-
0.00427655092872509,-0.00455505174245627,-0.00483656219443030,-0.00512074140261895,-
0.00540723933263122,-0.00569569738869791,-0.00598574902861037,-0.00627702040134024,-
0.00656913100601169,-0.00686169437082251,-0.00715431875046695,-0.00744660784054354,-
0.00773816150739330,-0.00802857653175215,-0.00831744736457308,-0.00860436689331875,-
0.00888892721700411,-0.00917072042822613,-0.00944933940040089,-0.00972437857839931,-
0.00999543477076167,-0.0102621079416515,-0.0105240020007129,-0.0107807255889784,-
0.0110318928589902,-0.0112771242472934,-0.0115160472374805,-0.0117482971119758,-
0.0119735176907748,-0.0121913620553736,-0.0124014932561658,-0.0126035850016015,-
0.0127973223274625,-0.0129824022446355,-0.0131585343638268,-0.0133254414957033,-
0.0134828602250113,-0.0136305414572771,-0.0137682509367649,-0.0138957697344292,-
0.0140128947046764,-0.0141194389098168,-0.0142152320111781,-0.0143001206259168,-
0.0143739686486612,-0.0144366575371943,-0.0144880865614796,-0.0145281730154166,-
0.0145568523908111,-0.0145740785131274,0.985179511586105,-0.0145740785131274,-
0.0145568523908111,-0.0145281730154166,-0.0144880865614796,-0.0144366575371943,-
0.0143739686486612,-0.0143001206259168,-0.0142152320111781,-0.0141194389098168,-
0.0140128947046764,-0.0138957697344292,-0.0137682509367649,-0.0136305414572771,-
0.0134828602250113,-0.0133254414957033,-0.0131585343638268,-0.0129824022446355,-
0.0127973223274625,-0.0126035850016015,-0.0124014932561658,-0.0121913620553736,-
0.0119735176907748,-0.0117482971119758,-0.0115160472374805,-0.0112771242472934,-
0.0110318928589902,-0.0107807255889784,-0.0105240020007129,-0.0102621079416515,-
0.00999543477076167,-0.00972437857839931,-0.00944933940040089,-0.00917072042822613,-
0.00888892721700411,-0.00860436689331875,-0.00831744736457308,-0.00802857653175215,-
0.00773816150739330,-0.00744660784054354,-0.00715431875046695,-0.00686169437082251,-
0.00656913100601169,-0.00627702040134024,-0.00598574902861037,-0.00569569738869791,-
0.00540723933263122,-0.00512074140261895,-0.00483656219443030,-0.00455505174245627,-
0.00427655092872509,-0.00400139091706868,-0.00372989261357538,-0.00346236615438049,-
0.00319911042177922,-0.00294041258956298,-0.00268654769840409,-0.00243777826202815,-
0.00219435390483628,-0.00195651103154806,-0.00172447252935988,-0.00149844750301713,-
0.00127863104312430,-0.00106520402791759,-0.000858332958651623,-0.000658169828653527,-
0.000464852026021663,-0.000278502269853134,-9.92285798083822e-05,7.28757212701298e-
05,0.000237731972042283,0.000395276105100021,0.000545458547658511,0.000688244091105476,0
.000823611730073447,0.000951554471777768,0.00107207911642407,0.00118520600956381,0.00129
096876732968,0.00138941397555322,0.00148060086381289,0.00156460095552392,0.001641497695
22299,0.00171138605425470,0.00177437211610043,0.00183057264263873,0.00188011462265338,0.
00192313480394069,0.00195977921039118,0.00199020264545020,0.00201456818336972,0.0020330
4664969221,0.00204581609240578,0.00205306124522563,0.00205497298445191,0.00205174778086
148,0.00204358714807572,0.00203069708884594,0.00201328754067891,0.00199157182221298,0.00
196576608172824,0.00193608874915792,0.00190275999293351,0.00186600118296952,0.001826034
36105605,0.00178308171989452,0.00173736509196554,0.00168910544937966,0.0016385224158131
1,0.00158583379158388,0.00153125509286918,0.00147499910601899,0.00141727545785695,0.0013
5829020281066,0.00129824542764962,0.00123733887455366,0.00117576358316809,0.00111370755
224619,0.00105135342141083,0.000988878173507272,0.000926452857951809,0.0008642423354210
21,0.000802405044155056,0.000741092788092066,0.000680450546979315,0.000620616308548631,0
.000561720922775860,0.000503887978187604,0.000447233700110846,0.000391866870707068,0.000
337888770569439,0.000285393141608277,0.000234466170890219,0.000185186495047934,0.000137
625224821003,9.18459892421712e-05,4.79049989331206e-05,5.85112793198369e-06,-
3.42739865717632e-05,-7.24358272562506e-05,-0.000108606863141047,-0.000142766400250213,-
0.000174900417233662,-0.000205001386741351,-0.000233068083376280,-0.000259105379071508,-
0.000283124026760571,-0.000305140433225629,-0.000325176422025874,-0.000343258987416851,-
0.000359420040183731,-0.000373696146315129,-0.000386128259449246,-0.000396761448021658,-
0.000405644618045301,-0.000412830232443354,-0.000418374027851738,-0.000422334729793877,-
0.000424773767119915,-0.000425754986583481,-0.000425344368414368,-0.000423609743721635,-
0.000420620514541311,-0.000416447377315747,-0.000411162050567322,-0.000404837007496750,-
0.000397545214210297,-0.000389359874242516,-0.000380354180012535,-0.000370601071813108,-
0.000360173004896661,-0.000349141725185149,-0.000337578054091672,-0.000325551682902149,-
0.000313130977126562,-0.000300382791186509,-0.000287372293767833,-0.000274162804122007,-
0.000260815639562801,-0.000247389974359297};
//const q15_t firCoeffsQ15[NUM_TAPS] = {6553, 6553, 6553, 6553, 6553, 0}; //NUM_TAPS deve ser
>= 4 para arm_filter_q15 (INFORMAES NO MANUAL!)

/* ------------------------------------------------------------------
* Global variables for FIR LPF Example
* ------------------------------------------------------------------- */
FilterTypeDef filterType=FIR_FLOAT32;

int main(int argc, char* argv[])

{
UNUSED(argc);
UNUSED(argv);

uint32_t cycleCount;
uint32_t i, k;

float32_t inputF32Buffer[BLOCK_SIZE];
float32_t outputF32Buffer[BLOCK_SIZE];

//q15_t inputQ15Buffer[BLOCK_SIZE];
//q15_t outputQ15Buffer[BLOCK_SIZE];

#ifdef OS_USE_SEMIHOSTING
//Semihosting example
FILE *CoefficientsFile;
FILE *CycleFile;
float Coefficients[NUM_TAPS];
#endif

// Initialise the HAL Library; it must be the first

// instruction to be executed in the main program.
HAL_Init();

DWT_Enable();
 #ifdef OS_USE_SEMIHOSTING
//Semihosting example
CoefficientsFile = fopen("coefficients.txt", "r");
if (!CoefficientsFile) {
trace_printf("Error trying to open CoefficientsFile. Check the name/location.\n");
while(1);
}

for(i=0; i<5; i++)

fscanf(CoefficientsFile, "%f", &Coefficients[i]);

for(i=0; i<5; i++)

trace_printf("Coefficient %d: %f\n", i, Coefficients[i]);

fclose(CoefficientsFile);

#ifdef CYCLE_COUNTER
CycleFile = fopen("cyclecounter.txt", "w");
if (!CycleFile) {
trace_printf("Error trying to open cycle counter file\n.");
while(1);
}
#endif

#endif

WOLFSON_PI_AUDIO_Init((INPUT_DEVICE_LINE_IN << 8) | OUTPUT_DEVICE_BOTH, 80,

AUDIO_FREQUENCY_48K);

WOLFSON_PI_AUDIO_SetInputMode(INPUT_DEVICE_LINE_IN);

WOLFSON_PI_AUDIO_SetMute(AUDIO_MUTE_ON);

WOLFSON_PI_AUDIO_Play(TxBuffer, RxBuffer, WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE);

WOLFSON_PI_AUDIO_SetVolume(Volume);

BSP_ACCELERO_Init();

TEST_Init();

arm_fir_instance_f32 S;
float32_t *inputF32, *outputF32;

//arm_fir_instance_q15 S15;
//q15_t *inputQ15, *outputQ15;
arm_status status;

/* Initialize input and output buffer pointers */

inputF32 = &inputF32Buffer[0];
outputF32 = &outputF32Buffer[0];

//inputQ15 = &inputQ15Buffer[0];
//outputQ15 = &outputQ15Buffer[0];

/* Call FIR init function to initialize the instance structure. */

arm_fir_init_f32(&S, NUM_TAPS, (float32_t *)&firCoeffs32[0], &firStateF32[0], BLOCK_SIZE);
 //status=arm_fir_init_q15(&S15, NUM_TAPS, (q15_t *)&firCoeffsQ15[0], &firStateQ15[0],
BLOCK_SIZE);
if (status==ARM_MATH_ARGUMENT_ERROR) {
trace_printf("Problem at arm_fir_init_q15. Check if num_taps is even and greater than
4.\n");
while(1);
}

trace_printf("End of filter initialization.\n filterType is %d\n", filterType);

while (1) {
// Add your code here.
if(buffer_offset == BUFFER_OFFSET_HALF)
{
DWT_Reset();

cycleCount = DWT_GetValue();

if (filterType==FIR_FLOAT32) {
for(i=0, k=0; i<(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2); i++) {
if(i%2) {
inputF32Buffer[k] =
(float32_t)(RxBuffer[i]/32768.0);//convert to float LEFT
k++;
}
else {
TxBuffer[i] = RxBuffer[i];// RIGHT (canal de baixo no
OcenAudio)
}
}
arm_fir_f32(&S, inputF32, outputF32, BLOCK_SIZE);
for(i=0, k=0; i<(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2); i++) {
if(i%2) {
TxBuffer[i] =
(int16_t)(outputF32Buffer[k]*32768);//back to 1.15
k++;
}
}
}

if (filterType==FIR_Q15) {
for(i=0, k=0; i<(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2); i++) {
if(i%2) {
//inputQ15Buffer[k] = (q15_t)(RxBuffer[i]);
k++;
}
else {
TxBuffer[i] = RxBuffer[i];//pass-through
}
}
//arm_fir_q15(&S15, inputQ15, outputQ15, BLOCK_SIZE);
for(i=0, k=0; i<(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2); i++) {
if(i%2) {
// TxBuffer[i] = (int16_t)(outputQ15Buffer[k]);//back
to 1.15
k++;
 }
}
}

#ifdef CYCLE_COUNTER
fprintf(CycleFile, "\nHALF: %lu", (DWT_GetValue()- cycleCount));
#endif

buffer_offset = BUFFER_OFFSET_NONE;
}

if(buffer_offset == BUFFER_OFFSET_FULL)
{
DWT_Reset();

cycleCount = DWT_GetValue();

if (filterType==FIR_FLOAT32) {
for(i=(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2), k=0;
i<WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE; i++) {
if(i%2) {
inputF32Buffer[k] =
(float32_t)(RxBuffer[i]/32768.0);//convert to float
k++;
}
else {
TxBuffer[i] = RxBuffer[i];//pass-
through(int16_t)0.3*32768;//
}
}

arm_fir_f32(&S, inputF32, outputF32, BLOCK_SIZE);

for(i=(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2), k=0;
i<WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE; i++) {
if(i%2) {
TxBuffer[i] =
(int16_t)(outputF32Buffer[k]*32768.0);//back to 1.15
k++;
}
}
}

if (filterType==FIR_Q15) {
for(i=(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2), k=0;
i<WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE; i++) {
if(i%2) {
//inputQ15Buffer[k] = (q15_t)(RxBuffer[i]);
k++;
}
else {
//TxBuffer[i] = RxBuffer[i];//pass-through
}
}

//arm_fir_q15(&S15, inputQ15, outputQ15, BLOCK_SIZE);

for(i=(WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE/2), k=0;
i<WOLFSON_PI_AUDIO_TXRX_BUFFER_SIZE; i++) {
 if(i%2) {
//TxBuffer[i] = (int16_t)(outputQ15Buffer[k]);//back
to 1.15
k++;
}
}
}

#ifdef CYCLE_COUNTER
fprintf(CycleFile, "\nFULL: %lu", (DWT_GetValue()- cycleCount));
#endif

buffer_offset = BUFFER_OFFSET_NONE;
}
TEST_Main();
}
fclose(CycleFile);
return 0;
}

/*--------------------------------
Callbacks implementation:
--------------------------------------------------------*/

/**
* @brief Manages the DMA full Transfer complete event.
*/
void WOLFSON_PI_AUDIO_TransferComplete_CallBack(void)
{
buffer_offset = BUFFER_OFFSET_FULL;
}

/**
* @brief Manages the DMA Half Transfer complete event.
*/
void WOLFSON_PI_AUDIO_HalfTransfer_CallBack(void)
{
buffer_offset = BUFFER_OFFSET_HALF;
}

/**
* @brief Manages the DMA FIFO error interrupt.
* @param None
* @retval None
*/
void WOLFSON_PI_AUDIO_OUT_Error_CallBack(void)
{
/* Stop the program with an infinite loop */
while (1);
}