CCS/MSP432P401R: Issues Compiling the project (unresolved symbols)

#include <ti/devices/msp432p4xx/inc/msp.h>
#include <ti/devices/msp432p4xx/driverlib/driverlib.h>
#include <stdio.h>
#include <arm_math.h>
#include <arm_const_structs.h>

static DMA_ControlTable MSP_EXP432P401RLP_DMAControlTable[32];
/* DMA Control Table */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_ALIGN(MSP_EXP432P401RLP_DMAControlTable, 1024)
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma data_alignment=1024
#elif defined(__GNUC__)
__attribute__ ((aligned (1024)))
#elif defined(__CC_ARM)
__align(1024)
#endif

// ---------- Variables generales----------- //
const char digits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
#define SAMPLE_FREQUENCY    1000
#define SMCLK_FREQUENCY     48000000
static volatile uint16_t DMA_counter = 0;
static volatile uint16_t ADC_counter = 0;
static volatile uint16_t UART_counter = 0;
volatile int mode = 1;
volatile int size = 0;
volatile int change_array = 0;
// ---------- FFT Parámetros ----------- //
#define N_MUESTRAS 1024
uint32_t fftSize = N_MUESTRAS;
uint32_t ifftFlag = 0;
uint32_t BitReverse = 1;
uint32_t max_freq_bin = 0;
volatile arm_status status;
// ---------- Inicialización de BUFFERS ----------- //
float hamming[N_MUESTRAS];
int16_t data_buffer1[N_MUESTRAS];
int16_t data_buffer2[N_MUESTRAS];
int16_t data_fft[N_MUESTRAS*2];
int16_t data_out[N_MUESTRAS];
int16_t prueba[N_MUESTRAS];

int main(void)
{
    // ---------- Funciones de configuración e inicialización del sistema ---------- //
    //Parar el reloj WDT.
    MAP_WDT_A_holdTimer();
    MAP_Interrupt_disableMaster();
    CLOCK_Config();
    GPIO_Config();
    UART_Config();
    TIMER_Config();
    ADC_Config();
    DMA_Config();
    MAP_Interrupt_enableMaster();
    MAP_DMA_enableChannel(7);
    MAP_ADC14_enableConversion();

    //Inicializar Filtro FIR de tipo Hamming Window:
    //Referencia:www.allaboutcircuits.com/.../
    int n;
    for(n = 0; n < N_MUESTRAS; n++)
    {
        hamming[n] = 0.5 - 0.5 * cosf((2 * PI * n) / (N_MUESTRAS - 1));
    }

    while(1)
    {
        //Duerme hasta la interrupción del DMA.
        //Medido con el Ociloscoipo: Se envía el buffer de datos cada 1000ms.
        //P1->OUT = BIT0;
        MAP_PCM_gotoLPM0();
        //P1->OUT &= ~BIT0;
        int i = 0;
        
        switch (mode)
        {
            case 1:
            {
                size = N_MUESTRAS;
                /*for(i=0;i<N_MUESTRAS;i++)
                {
                    prueba[i] = i;
                }*/
                if(change_array & 1)
                {
                    for(i = 0; i < N_MUESTRAS; i++)
                    {
                    //data_out[i] = prueba[i];
                    data_out[i] = data_buffer1[i];
                    }
                    TransmitirDatos();
                }
                else
                {
                    for(i = 0; i < N_MUESTRAS; i++)
                    {
                    //data_out[i] = prueba[i];
                    data_out[i] =  data_buffer2[i];
                    }
                    TransmitirDatos();
                }
                break;
            }
            case 2:
            {
                size = N_MUESTRAS;
                if(change_array & 1)
                {
                    arm_fir_instance_q15 instance_fir;
                    arm_fir_init_q15(&instance_fir, N_TAPS, (q15_t *)coeffs_q15, &firState[0], STATE_BUFFER_SIZE);
                    for(i=0; i < N_MUESTRAS/STATE_BUFFER_SIZE; i++)
                    {
                        arm_fir_q15(&instance_fir, &data_buffer1[0] + (i * STATE_BUFFER_SIZE), &data_out[0] + (i * STATE_BUFFER_SIZE), STATE_BUFFER_SIZE);
                    }
                    TransmitirDatos();
                }
                else
                {
                    arm_fir_instance_q15 instance_fir;
                    arm_fir_init_q15(&instance_fir, N_TAPS, (q15_t *)coeffs_q15, &firState[0], STATE_BUFFER_SIZE);
                    for(i=0; i < N_MUESTRAS/STATE_BUFFER_SIZE; i++)
                    {
                        arm_fir_q15(&instance_fir, &data_buffer2[0] + (i * STATE_BUFFER_SIZE), &data_out[0] + (i * STATE_BUFFER_SIZE), STATE_BUFFER_SIZE);
                    }
                    TransmitirDatos();
                }
                break;
            }
            case 3:
            {
            // Calcular la FFT del buffer 1 o 2 que ha sido llenado.
            // Si el buffer 1 ha sido llenado primero, se utiliza para aplicar el filtro Hann y despues calcular la FFT, si no, se utiliza el buffer 2.
            if(change_array & 1)
            {
                //Medido el pulso con ociloscopio: 1.38ms
                //P1->OUT = BIT0;
                for(i = 0; i < N_MUESTRAS; i++)
                {
                    data_buffer1[i] = (int16_t)(hamming[i] * data_buffer1[i]);
                }
                //P1->OUT &= ~BIT0;
                arm_rfft_instance_q15 instance;
                status = arm_rfft_init_q15(&instance, fftSize, ifftFlag, BitReverse);
                //Medido el pulso con ociloscopio: 5.4ms
                //P1->OUT = BIT0;                     // pin a osciloscopio para ver frecuencia de muestreo
                arm_rfft_q15(&instance, data_buffer1, data_fft);
                //P1->OUT &= ~BIT0;
            }
            else
            {
                for(i = 0; i < N_MUESTRAS; i++)
                {
                    data_buffer2[i] = (int16_t)(hamming[i] * data_buffer2[i]);
                }
                arm_rfft_instance_q15 instance;
                status = arm_rfft_init_q15(&instance, fftSize, ifftFlag, BitReverse);
                arm_rfft_q15(&instance, data_buffer2, data_fft);
            }
            //Calcular magnitud de la FFT del buffer en cuestión.
            //El arreglo de salida tiene el doble de tamaño que el de entrada por que se incluye la parte real e imaginaria. n=real, n+1= imaginaria.
            //Medido el pulso con ociloscopio: 2.620ms
            //P1->OUT = BIT0;
            for(i = 0; i < (N_MUESTRAS*2); i = i+2)
            {
                data_out[i/2] = (int16_t)(sqrtf((data_fft[i] * data_fft[i]) + (data_fft[i+1] * data_fft[i+1])));
            }
            data_out[0]=0;
            data_out[1]=0;
            //P1->OUT &= ~BIT0;
            //q15_t maxValue;
            //uint32_t maxIndex = 0;
            //Calcular máximo pico de magnitud de la FFT.
            //arm_max_q15(data_output, fftSize, &maxValue, &maxIndex);
            //max_freq_bin = maxIndex;
            //Transmitir máximo pico de magnitud de la FFT.
            //TransmitirDatos(max_freq_bin);
            //Transmitir toda la FFT.
            //Medido el pulso con ociloscopio si se envia 1024 datos: 448ms
            //para enviar FFT (50 datos): 42.8ms
            //P1->OUT = BIT0;
            size = 50;
            TransmitirDatos();
            //P1->OUT &= ~BIT0;
            break;
            }
        }
    }
}