File content as of revision 2:6f99f6b825b8:

#include "mbed.h"
#include "NVIC_set_all_priorities.h"
#include <ctype.h>
#include "arm_math.h"
#include "arm_const_structs.h"
#include "FastAnalogIn.h"
#include <string>

//Luis Israel Rivera Rodriguez A01227916
//Jesus Alfonso Lopez Chin A01228531
//Jorge Alan Hernandez Torres A01228809
//Jorge Daniel Nuñez
//David Olide 

// Basado en el código de Frank Vannieuwkerke en KL25Z_FFT_Demo
// https://developer.mbed.org/users/frankvnk/code/KL25Z_FFT_Demo/

PwmOut myled(LED_GREEN);
Serial pc(USBTX, USBRX);
FastAnalogIn   Audio(PTC0);

////Parametros////
int SAMPLE_RATE_HZ = 4000;  
const int FFT_SIZE = 256;     

////Otras Variables para sampling y FFT////
const static arm_cfft_instance_f32 *S;
Ticker samplingTimer;
float samples[FFT_SIZE*2];
float magnitudes[FFT_SIZE];
int sampleCounter = 0;
//*********//

////Utilidades////
void printArr(int bigsize, float arr[]){ //Imprime un arreglo de valores
    int size = (bigsize/sizeof(arr[0]));
    pc.printf("\r\n [");
    int limit = size - 1;
    for (int i = 0; i < size; i++){
        i == limit ? pc.printf("%.3f", arr[i]): pc.printf("%.3f ,", arr[i]);
    }
    pc.printf("] \n");
}

int frequencyToBin(float frequency)
{
    float binFrequency = float(SAMPLE_RATE_HZ) / float(FFT_SIZE);
    return int(frequency / binFrequency);
}
//*********//

////Sampling////

void samplingCallback()
{
    // Read from the ADC and store the sample data
    samples[sampleCounter] = (1023 * Audio) - 511.0f;
    // Complex FFT functions require a coefficient for the imaginary part of the input.
    // Since we only have real data, set this coefficient to zero.
    samples[sampleCounter+1] = 0.0;
    // Update sample buffer position and stop after the buffer is filled
    sampleCounter += 2;
    if (sampleCounter >= FFT_SIZE*2) {
        samplingTimer.detach();
    }
}

void samplingBegin()
{
    // Reset sample buffer position and start callback at necessary rate.
    sampleCounter = 0;
    samplingTimer.attach_us(&samplingCallback, 1000000/SAMPLE_RATE_HZ);
}

bool samplingIsDone()
{
    return sampleCounter >= FFT_SIZE*2;
}

//**********//

//Funciones para detección de DTMF//
int col1 = frequencyToBin(1209);
int col2 = frequencyToBin(1336);
int col3 = frequencyToBin(1477);
int col4 = frequencyToBin(1633);
int row1 = frequencyToBin(697);
int row2 = frequencyToBin(770);
int row3 = frequencyToBin(852);
int row4 = frequencyToBin(941);
string valC1[] = {"1", "4", "7", "*"};
string valC2[] = {"2", "5", "8", "0"};
string valC3[] = {"3", "6", "9", "#"};
string valC4[] = {"A", "B", "C", "D"};

int maxCol(){ //Magnitud máxima en una columna
    int col = 0;
    float max = 0.0;
    if (magnitudes[col1] > max){
        max = magnitudes[col1];
        col = 1;    
    }
    if(magnitudes[col2] > max){
        max = magnitudes[col2];
        col = 2;   
    }  
    if(magnitudes[col3] > max){
        max = magnitudes[col3];
        col = 3;   
    }   
    if(magnitudes[col4] > max){
        col = 4;   
    }  
    return col;
}

int maxRow(){ //Magnitud máxima en una fila
    int row = 0;
    float max = 0.0;
    if (magnitudes[row1] > max){
        max = magnitudes[row1];
        row = 1;    
    }
    if(magnitudes[row2] > max){
        max = magnitudes[row2];
        row = 2;   
    }  
    if(magnitudes[row3] > max){
        max = magnitudes[row3];
        row = 3;   
    }   
    if(magnitudes[row4] > max){
        row = 4;   
    }   
    return row;
}

string valor(){ //Determina qué tecla se presiona
    int R = maxRow() - 1;
    int C = maxCol();
    //pc.printf("Las coordenadas son: %i, %i \n", R, C); //debug
    string salida = "---";
    switch (C){
        case 1:
            salida = valC1[R];
            break;
        case 2:
            salida = valC2[R];
            break;
        case 3:
            salida = valC3[R];
            break;
        case 4: 
            salida = valC4[R];
            break;
    }
    return salida;
}
//**********//

int main(){
    myled = 0.995;
    
    NVIC_set_all_irq_priorities(1);
    NVIC_SetPriority(UART0_IRQn, 0);
    
    // Begin sampling audio
    samplingBegin();

    // Init arm_ccft_32
    switch (FFT_SIZE)
    {
    case 16:
        S = & arm_cfft_sR_f32_len16;
        break;
    case 32:
        S = & arm_cfft_sR_f32_len32;
        break;
    case 64:
        S = & arm_cfft_sR_f32_len64;
        break;
    case 128:
        S = & arm_cfft_sR_f32_len128;
        break;
    case 256:
        S = & arm_cfft_sR_f32_len256;
        break;
    case 512:
        S = & arm_cfft_sR_f32_len512;
        break;
    case 1024:
        S = & arm_cfft_sR_f32_len1024;
        break;
    case 2048:
        S = & arm_cfft_sR_f32_len2048;
        break;
    case 4096:
        S = & arm_cfft_sR_f32_len4096;
        break;
    }
    int x=0;
    string valor1;
    string valor2;
    while(true){
        // Calculate FFT if a full sample is available.
        if (samplingIsDone()) {
            // Run FFT on sample data.
            arm_cfft_f32(S, samples, 0, 1);
            // Calculate magnitude of complex numbers output by the FFT.
            arm_cmplx_mag_f32(samples, magnitudes, FFT_SIZE);
            // Restart audio sampling.
            samplingBegin();
            if(x==0)
            {
                x=1;
                valor1=(valor().c_str()); 
                printf("Valor1:   "+valor1);   
                printf("\r\n"); 
            }
            else
            {
                x=0;
                valor2=(valor().c_str());
                printf("Valor 2:   "+valor2); 
                printf("\r\n");       
            }
            if(valor2==valor1)
            {
                printf(valor().c_str());
                printf("\r\n");  
            }
            valor1=8;
            valor2=6;
            //Correr identificacion de tonos
            
           
        }

        
    }
}