File content as of revision 7:6b8a1382b2ee:

#include "mbed.h" //Librería default de mbed
#include "NVIC_set_all_priorities.h" //Librería para modificar todas las solicitudes de interrupciones al mismo tiempo
#include <ctype.h>
#include "arm_math.h" //Librería que contiene funciones de tranformada de fourier
#include "arm_const_structs.h"
#include "FastAnalogIn.h" //Librería modificada basada en la función de AnalogIn que reduce el tiempo de procesamiento de las señales ADC
#include "TextLCD.h"
 
 
TextLCD lcd(PTA4, PTC8, PTA13, PTD5, PTD0, PTD2); // rs, e, d0, d1, d2, d3
 
char* x;
int lcd_count = 0;
Serial pc(USBTX, USBRX); //Se declaran los pines que se utilizarán para la comunicación serial mediante USB para debuggeo (PTA1 - RX, PTA2 - TX)
FastAnalogIn   segnal(PTC2); //Se declara el pin que recibirá la señal análoga del sensor
 
extern "C" void NMI_Handler()
{
}
 
////////////////////////////////////////////////////////////////////////////////
// CONFIGURACION
//Estos valores puedne modificarse para modificar los parametros de la transformada
////////////////////////////////////////////////////////////////////////////////
 
int SAMPLE_RATE_HZ = 40000;       // Frecuencian de muestreo en HZ del sistema
const int FFT_SIZE = 1024;           // Número de valores para la transformada rápida
float freq = 40000.0/1024.0;           // Frecuencia de activación de la interrupción de muestreo
float max[2];                        // Arreglo que almacena la frecuencia y magnitud mayores del espectro de Fourier
 
////////////////////////////////////////////////////////////////////////////////
// ESTADO INTERNO
// Configuraciones necesarias para el correcto funcionaiento del programa
////////////////////////////////////////////////////////////////////////////////
 
const static arm_cfft_instance_f32 *S;
Ticker samplingTimer;                       //objeto creado para habilitar las interrupciones con lso métodos de ticker
float samples[FFT_SIZE*2];                  //Arreglo en el que se almacenan las muestras del tomadas ADC
float magnitudes[FFT_SIZE];                 //Arreglo donde se almacenan las magnitudes de la FFT
int sampleCounter = 0;                      //Contador del número de muestras tomadas
 
////////////////////////////////////////////////////////////////////////////////
// FUNCIONES DE MUESTREO
////////////////////////////////////////////////////////////////////////////////
 
//Esta función permite realizar el muestreo de datos, se realiza como interrupción para asegurar el tiempo de muestreo deseado
void samplingCallback()
{
    // Lectura del ADC y almacenamiento del dato
    samples[sampleCounter] = (1023 * segnal) - 511.0f; //Se ajusta el valor de un rango de 0-1 a 0-511
    // La función que calcula la transformada requiere de un valor imaginario, en este caso se le asigna 0
    // ya que los valores muestreados son solamente reales.
    samples[sampleCounter+1] = 0.0;
    // Se ajusta la posición en el arreglo para almacenar el siguiente valor real
    sampleCounter += 2;
    //En caso de que el valor de sample counter sobrepase el tamaño del arreglo de almacenamiento se retira la interrupción
    //de muestreo del programa
    if (sampleCounter >= FFT_SIZE*2) {
        samplingTimer.detach();
    }
}
 
//Esta función permite reiniciar el contador de muestras e insertar nuevamente la interrupción de muestreo
void samplingBegin()
{
    sampleCounter = 0; //Se reinicia el contador de muestras
    samplingTimer.attach_us(&samplingCallback, 1000000/SAMPLE_RATE_HZ); //Se incertala interrupción de muestreo la cual es llamada con la frecuencia de Sample_rate_hz
}
 
//Función booleana que funciona como bandera para indicar que el meustreo de datos ha sido finalizado
bool samplingIsDone()
{
    return sampleCounter >= FFT_SIZE*2;
}
 
////////////////////////////////////////////////////////////////////////////////
// MAIN DEL PROGRAMA
////////////////////////////////////////////////////////////////////////////////
 
int main()
{
    //Configuración de las solicitudes de interrupción
    NVIC_set_all_irq_priorities(1);
 
    //Configuración de la velocidad de la comunicación serial
    pc.baud (115200); //Velocidad de la comunicación USB
 
    // Se incerta la interrupción de muestreo del ADC
    samplingBegin();
 
    // Init arm_ccft_32 el registro cambiara dependiendo de la variable FFT_SIZE
    switch (FFT_SIZE) {
        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;
    }
 
    while(1) {
        // Se calcula la FFT si se ha terminado el muestreo
        if (samplingIsDone()) {
 
            arm_cfft_f32(S, samples, 0, 1);
            arm_cmplx_mag_f32(samples, magnitudes, FFT_SIZE);
 
            for (int i = 0; i < FFT_SIZE/2+1; ++i) {
                //    pc.printf("%f, %f\r\n", i*freq, magnitudes[i]);  //Esta línea se activa solo si se desea conocer la magnitudes generada por la FFT
                //Sección de código que permite obtener el valor de frecuencia y magnitud mayor de los calculados
                if (magnitudes[i]>max[1]) {
                    max[0]=i*freq;
                    max[1]=magnitudes[i]; //Habilitar solo para debuggeo
                }
            }
            int test=  (int) (max[0] + 0.5); 
            printf("%i\r\n", test);
            
            if (25<max[0] && max[0]<260) {
                x="04,000 RPM";
            } else if (260<max[0] && max[0]<325) {
                x="05,000 RPM";
            } else if (600<max[0] && max[0]<780) {
                x="05,000 RPM";
            } else if (1301<max[0] && max[0]<1500) {
                x="05,000 RPM";
            } else if (326<max[0] && max[0]<392) {
                x="06,000 RPM";
            } else if (780<max[0] && max[0]<900) {
                x="06,000 RPM";
            } else if (2000<max[0] && max[0]<2800) {
                x="06,000 RPM";
            } else if (393<max[0] && max[0]<450) {
                x="07,000 RPM";
            } else if (900<max[0] && max[0]<1010) {
                x="07,000 RPM";
            } else if (451<max[0] && max[0]<519) {
                x="08,000 RPM";
            } else if (1010<max[0] && max[0]<1149) {
                x="08,000 RPM";
            } else if (520<max[0] && max[0]<584) {
                x="09,000 RPM";
            } else if (1150<max[0] && max[0]<1168) {
                x="09,000 RPM";
            } else if (584<max[0] && max[0]<700) {
                x="10,000 RPM";
            } else if (1168<max[0] && max[0]<1300) {
                x="10,000 RPM";
            } else if (max[0]==0) {
                x="00,000 RPM";
            }
            lcd_count++;
            if(lcd_count == 5){
                lcd.cls();
                int test=  (int) (max[0] + 0.5); 
                lcd.locate(0,0);
                lcd.printf("%s",x);
                //pc.printf("%s",x);
                lcd.locate(0,1);
                lcd.printf("%s","FFT: ");
                //pc.printf("%s","FFT: ");
                lcd.printf("%i",test);
                //pc.printf("%i",test);
                lcd_count = 0;
            }
            
            max[0]=0;
            max[1]=0;
 
            // Se vuelve a incertar la interrupción de muestreo
            samplingBegin();
        }
    }
}