MFCC On Tiva

/*
* MFCC.h
*
* Created on: Dec 4, 2014
*
Author: Loc Le
*/
#ifndef MFCC_H_
#define MFCC_H_
#define PART_TM4C123GH6PM
#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_adc.h"
#include "inc/hw_gpio.h"
#include "driverlib/adc.h"
#include "driverlib/gpio.h"
#include "driverlib/rom.h"
#include "driverlib/ssi.h"
#include "driverlib/timer.h"
#include "driverlib/interrupt.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/fpu.h"
#include "driverlib/uart.h"
#include "utils/uartstdio.h"
#include "math_helper.h"
#include <math.h>
#include "arm_math.h"
#ifdef DEBUG
void
__error__(char *pcFilename, unsigned long ulLine)
{
}
#endif
#define NUM_SAMPLES
me samples
#define NUM_ADC
es (32 Frames)
#define NUM_FRAME
me
#define NUM_POINT
points
#define NUM_FILTER
filter
#define NUM_CEPSTRUM
CC
#define
#define
#define
#define
SAMPLING_FREQ
BIT_ORDER_FFT
iFFTflag
DECAY_FACTOR
80
4000
// Number of fra
// Number of voice sampl
50
// Number of fra
128
// Number of FFT
23
// Number of Mel
12
// Number of pfeature MF
8000
1
// Fs = 8kHz
0
0.992
#define M_PI 3.14159265358979323846
#define
#define
#define
#define
#define
do_not_run 2
yes 1
no 0
mode_training 0
mode_run 1
#define
#define
#define
#define
#define
INT_MIN
INT_MAX
X_array
Y_array
Length
0
65535
12
12
12
extern float ti_hamming_window_vector[NUM_SAMPLES];

extern float cos_dct[NUM_CEPSTRUM][NUM_FILTER];
extern const float num1_1[588];
//*****************************************************************************
// GLOBAL VARIABLES
//*****************************************************************************
arm_rfft_instance_f32 fftStructure;
arm_cfft_radix4_instance_f32 cfftStructure;
arm_status status;
float
float
float
float
float
g_ADCOutput [NUM_ADC];
g_fFFTInput[NUM_POINT];
g_fFFTResult[NUM_POINT*2];
g_MELoutput[NUM_FRAME][NUM_FILTER];
g_MFCCoutput[NUM_FRAME - 1][NUM_CEPSTRUM];
uint32_t g_ulADCValue;
d ADC Value
uint32_t g_ulCount = 0;
nt samples
uint32_t g_ulCount_1 = 0;
nt frame
volatile uint8_t DataReady;
n full samples
//ADC voice value
//The buffer hol

//The buffer cou
//The buffer cou
//Flag ready whe
float DataRecieve;
float ground;
volatile uint8_t slince = do_not_run;
volatile uint8_t ready = do_not_run;
char mode[11];
int i = 0;
int j = 0;
int k = 0;
int t = 0;
int p;
float temp;
float temp0;
float sum_FFT;
float energy;
char test[20];
float matrix[X_array][Y_array];
float data[Length];
float templates[Length];
float result[40];
float result_1[10];
//*****************************************************************************
// SUBROUTINE HEADER
//*****************************************************************************
void SysCtl_Config();
void FPU_Config();
void LED_Config();
void BUTTON_Config();
void TIMER_Config();
void ADC_Config();
void UART_Config();
void Clear();
float cal_energy (float input[NUM_SAMPLES]);
void cal_pre_emphasis(void);
void DSP_init(void);
void DSP_process(void);
void Mel_filter_bank(void);
void Normalized_FFT(void);
void overlap(void);
//void Log_operation(void);
void cepstrum_calculation(void);
void ftoa(float f,char *buf);
void MFCC_run(void);
float min( float x, float y, float z );

float min_4( float x1, float x2, float x3, float x4);
void Total_cost(void);
void DTW_run(void);
//*****************************************************************************
// PROGRAM SUBROUTINE
//*****************************************************************************
//-------System---------------------------------------------------------------void SysCtl_Config()
{
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_O
SC_MAIN);
//fclk= 200/4=50MHz
}
void FPU_Config()
{
FPULazyStackingEnable();
FPUEnable();
}
void LED_Config()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//enable GPIO po
rt F
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0);
// turn off all led
}
void BUTTON_Config()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0|GPIO_PIN_4);
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;
GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_DIR_MODE_IN)
;
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_STRENGTH_4
MA, GPIO_PIN_TYPE_STD_WPU);
}
void TIMER_Config()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet()/(SAMPLING_FREQ - 1))
;
IntEnable(INT_TIMER0A);
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerEnable(TIMER0_BASE, TIMER_A);
IntMasterEnable();
}
void ADC_Config()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralReset(SYSCTL_PERIPH_ADC0);
ADCSequenceDisable(ADC0_BASE, 3);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH2 | ADC_CTL_IE | ADC
_CTL_END );
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntEnable(ADC0_BASE, 3);
IntEnable(INT_ADC0SS3);
IntMasterEnable();
}
void UART_Config()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//Enable UART0
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//Enable GPIO Port A
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//PA0,PA
1: UART 0 Pins
GPIOPinConfigure(GPIO_PA0_U0RX);
//PA0-UART0-RX
GPIOPinConfigure(GPIO_PA1_U0TX);
//PA1-UART0-TX
UARTConfigSetExpClk(UART0_BASE,
//UART0
SysCtlClockGet(),
//Processor Clock
9600,
//Baud rate 9600
UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_
NONE);
//Data 8 bit,1 Stop bit, no Parity
UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8); //set FI
FO level to 8 characters
UARTFIFOEnable(UART0_BASE); //enable FIFOs
IntEnable(INT_UART0); //cho php ngt UART
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); //ch cho php RX v TX ng
UARTStdioConfig(0,9600,SysCtlClockGet()); //tells uartstdio functions to
use UART0
}
//-------MFCC-----------------------------------------------------------------void Clear()
{
for(t=0 ; t<sizeof(mode);t++)
mode[t] = 0;
for(t=0 ; t<NUM_ADC;t++)
g_ADCOutput[t] = 0;
for(t=0 ; t<NUM_POINT;t++)
g_fFFTInput[t] = 0;
for(t=0 ; t<NUM_POINT*2;t++)
g_fFFTResult[t] = 0;
for (t=0; t<NUM_FRAME; t++)
{
for(k=0; k<NUM_FILTER; k++)
{
g_MELoutput[t][k] = 0;
}
}
sum_FFT = 0;
{
for(k=0; k<NUM_CEPSTRUM; k++)
{
g_MFCCoutput[t][k] = 0;
}
}
}
float cal_energy (float input[NUM_ADC])
{
int t;
temp = 0;
float output;
for (t=0; t<NUM_ADC; t++)
{
temp = temp + input[t] * input[t];
}
output = log(temp);
return(output);
}
void cal_pre_emphasis (void)
{
temp = 0;
temp0 = 0;
for (t=0; t<NUM_ADC ; t++)
{
temp = temp0;
temp0 = g_ADCOutput[t];
g_ADCOutput[t] = temp0 - 0.97*temp;
}
}
void DSP_init(void)
{
status = arm_rfft_init_f32(&fftStructure, &cfftStructure, NUM_POINT, iFF
Tflag,BIT_ORDER_FFT);
}
void DSP_process(void)
{
//temp = 0;
// And do the forward FFT transform
//
arm_rfft_f32(&fftStructure, g_fFFTInput, g_fFFTResult);
//
// Calculate the complex magnitude of the reusult
//
arm_cmplx_mag_f32(g_fFFTResult, g_fFFTResult, NUM_POINT);
for(t=0; t<NUM_POINT; t++)
{
sum_FFT = sum_FFT + g_fFFTResult[t] * g_fFFTResult[t];
}
/*for(t=0; t<NUM_POINT; t++)
{
g_fFFTResult[t] = g_fFFTResult[t] / temp;
}*/
}
void Mel_filter_bank(void)
{
g_MELoutput[g_ulCount_1][0] = g_fFFTResult[0] + g_fFFTResult[1];
g_MELoutput[g_ulCount_1][1] = g_fFFTResult[0] + g_fFFTResult[1] + g_fFFT
Result[2];
Result[3] + g_fFFTResult[4];

Result[6];
g_MELoutput[g_ulCount_1][8] = g_fFFTResult[9] + g_fFFTResult[10] + g_fFF
TResult[11] + g_fFFTResult[12] + g_fFFTResult[13];
g_MELoutput[g_ulCount_1][9] = g_fFFTResult[11] + g_fFFTResult[12] + g_fF
FTResult[13] + g_fFFTResult[14] + g_fFFTResult[15];
g_MELoutput[g_ulCount_1][10] = g_fFFTResult[13] + g_fFFTResult[14] + g_f
FFTResult[15] + g_fFFTResult[16] + g_fFFTResult[17];
FFTResult[17] + g_fFFTResult[18] + g_fFFTResult[19];
FFTResult[19] + g_fFFTResult[20] + g_fFFTResult[21] + g_fFFTResult[22];
FFTResult[21] + g_fFFTResult[22] + g_fFFTResult[23] + g_fFFTResult[24] + g_fFFTR
esult[25];
esult[28];
esult[31];
esult[34];
esult[37] + g_fFFTResult[38];
esult[40] + g_fFFTResult[41] + g_fFFTResult[42];
esult[44] + g_fFFTResult[45] + g_fFFTResult[46] + g_fFFTResult[47];
esult[48] + g_fFFTResult[49] + g_fFFTResult[50] + g_fFFTResult[51] + g_fFFTResul
t[52];
t[57];
t[62] + g_fFFTResult[63];
}
void Normalized_FFT(void)
{
{
{
g_MELoutput[t][k] = sqrt((g_MELoutput[t][k]*g_MELoutput[
t][k])/(sum_FFT*sum_FFT));
}
}
}
void overlap(void)
{
for (t=0; t<NUM_FRAME - 1; t++)
{
{
g_MELoutput[t][k] = g_MELoutput[t][k] + g_MELoutput[t+1]
[k];
}
}
}
/*void Log_operation(void)
{
{
for (k=0; k<NUM_FILTER; k++)
{
g_MELoutput[t][k] = log(g_MELoutput[t][k]);
}
}
}*/
void cepstrum_calculation(void)
{
temp = 0;
{
for (p=0; p<NUM_CEPSTRUM; p++)
{
g_MFCCoutput[t][p] = 0;
for (k=0; k<NUM_FILTER; k++)
{
//rad = (k-0.5)*p*PI/k;
temp = log(g_MELoutput[t][k]) * cos_dct[p][k];
//temp = input[n][k] * cos(rad);
g_MFCCoutput[t][p]= g_MFCCoutput[t][p] + temp;
}
}
}
}
void ftoa(float f,char *buf)
{
int pos=0,ix,dp,num;
if(f <= -100000000 || f >= 100000000)
buf[pos++]='0';
else
{
if (f<0)
{
buf[pos++]='-';
f = -f;
}
dp=0;
while (f>=10.0)
{
f=f/10.0;
dp++;
}
for (ix=1;ix<8;ix++)
{
num = (int)f;
f=f-num;
if (num>9)
buf[pos++]='#';
else
buf[pos++]='0'+num;
if (dp==0) buf[pos++]='.';
f=f*10.0;
dp--;
}
}
}
void MFCC_run(void)
{
while(DataReady == 0);
if(DataReady == 1)
{
//energy = cal_energy(g_ADCInput);
cal_pre_emphasis();
// calculate energy
// calculate emphasis
for(g_ulCount_1 = 0; g_ulCount_1 < NUM_FRAME; g_ulCount_1++)

{
for(g_ulCount=0; g_ulCount<NUM_SAMPLES; g_ulCount++)
// Frame block 10ms
{
g_fFFTInput[g_ulCount]=g_ADCOutput[g_ulCount + 8
0*g_ulCount_1];
}
for(g_ulCount=NUM_SAMPLES; g_ulCount<NUM_POINT; g_ulCoun
t++)
g_fFFTInput[g_ulCount] = 0;
arm_mult_f32(g_fFFTInput, ti_hamming_window_vector, g_fF
FTInput, NUM_SAMPLES); //windowing
DSP_init();
//FFT 128 points
DSP_process();
// real FFT value
Mel_filter_bank();
//mel filter
}
Normalized_FFT();
//Normalized_FFT
overlap();
//overlap
cepstrum_calculation(); //cepstrum
/*
//print data
{
for (k=0; k<NUM_CEPSTRUM; k++)
{
ftoa(g_MFCCoutput[t][k],&test[0]);
UARTprintf("%s\n",test);
test[0] = 0;
test[1] = 0;
test[2] = 0;
test[3] = 0;
test[4] = 0;
test[5] = 0;
test[6] = 0;
test[7] = 0;
test[8] = 0;
test[9] = 0;
test[10]
test[11]
test[12]
test[13]
test[14]
test[15]
test[16]
test[17]
test[18]
test[19]
=
=
=
=
=
=
=
=
=
=
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
}
}*/
g_ulCount=0;
DataReady = 0;
for(t=0 ; t<sizeof(mode);t++)
mode[t] = 0;
for(t=0 ; t<NUM_ADC;t++)
g_ADCOutput[t] = 0;
for(t=0 ; t<NUM_POINT;t++)
g_fFFTInput[t] = 0;
for(t=0 ; t<NUM_POINT*2;t++)
g_fFFTResult[t] = 0;
{
{
g_MELoutput[t][k] = 0;
}
}
sum_FFT = 0;
}
}
//-------DTW------------------------------------------------------------------float min( float x, float y, float z ) // return minimum among integer x, y and
z
{
float min = 0;
if( ( x <= y ) && ( x <= z ) ) min = x;
if( ( y <= x ) && ( y <= z ) ) min = y;
if( ( z <= x ) && ( z <= y ) ) min = z;
return min;
}
float min_4( float x1, float x2, float x3, float x4 ) // return minimum among in
teger x, y and z
{
float min = 0;
if(( x1 <= x2 ) && ( x1 <= x3 ) && ( x1 <= x4 )) min = x1;
if(( x2 <= x1 ) && ( x2 <= x3 ) && ( x2 <= x4 )) min = x2;
if(( x3 <= x1 ) && ( x3 <= x2 ) && ( x3 <= x4 )) min = x3;
if(( x4 <= x1 ) && ( x4 <= x2 ) && ( x4 <= x3 )) min = x4;
return min;
}
void Total_cost(void)
{
int x,y;
for(x=0; x < X_array; x++)
// local-cost matrix
{
for(y=0; y < Y_array; y++)
{
matrix[x][y] = (templates[x]-data[y])*(templates[x]-data
[y]) ;
}
}
for(x=1; x < X_array; x++) // global-cost of first column (predCol[0])
matrix[x][0] = matrix[x][0] + matrix[x-1][0];
for(y=1; y < Y_array; y++)
// global-cost
{
matrix[0][y] = matrix[0][y] + matrix[0][y-1];
for(x=1; x < X_array; x++)
{
matrix[x][y] = matrix[x][y] + min(matrix[x-1][y-1],matri
x[x][y-1],matrix[x-1][y]);
}
}
}
void DTW_run(void)
{
for (k=0; k<sizeof(result); k++)
{
result[k] = 0;
}
{
{
if(g_MFCCoutput[t][k] <= -1000 || g_MFCCoutput[t][k] >=
1000)
data[k] = 0;
else
data[k] = g_MFCCoutput[t][k];
templates[k] = num1_1[t*NUM_CEPSTRUM + k];
}
Total_cost();
result[0] = result[0] + matrix[X_array-1][Y_array-1];
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else

}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
{
{
1000)
data[k] = 0;
else
}
Total_cost();
}
}
#endif /* MFCC_H_ */

MFCC On Tiva

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

MFCC On Tiva

Uploaded by

Copyright:

Available Formats

/*

#define M_PI 3.14159265358979323846

extern float ti_hamming_window_vector[NUM_SAMPLES];

//ADC voice value

//The buffer hol

float min( float x, float y, float z );

g_MELoutput[g_ulCount_1][4] = g_fFFTResult[4] + g_fFFTResult[5] + g_fFFT

for(g_ulCount_1 = 0; g_ulCount_1 < NUM_FRAME; g_ulCount_1++)

templates[k] = num4_4[t*NUM_CEPSTRUM + k];

You might also like