File content as of revision 4:76ea7cc8fdbc:

#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

//**********Declaraciones devariables para la silla****************

DigitalOut menos(D2);//Salida que habilitara o deshabilitara el puente H de la llanta izquierda
DigitalOut afinado(D3);
DigitalOut mas(D4);//Salida que habilitara o deshabilitara el puente H de la llanta derecha

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

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 = 4000;       // Frecuencian de muestreo en HZ del sistema
const int FFT_SIZE = 1024;           // Número de valores para la transformada rápida
float freq = 4000.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
char blue_freq=0;                    // Variable que almacena el valor que se envia por bluetooth de los BPM

////////////////////////////////////////////////////////////////////////////////
// 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 (38400); //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;
    }
    pc.printf("hola");

    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 = 1; 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
                }
            }
             //pc.printf("%f, %f\r\n",max[0], max[1]);
            //Dependiendo del valor de max[0], que representa la frecuencia natural, indicara la persona
            //que esta chiflando y la silla ejecutara una rutina especifica
            if ((max[0]<=113 && max[0]>= 107) || (max[0]<=225 && max[0]>= 215) || (max[0]<=335 && max[0]>= 325)){
                
                pc.printf("\n %f\n", max[0]); 
                pc.printf("\nafinado\n");
                afinado=1;
                wait(1);
                afinado=0;
              
                
            } 
            else if ((max[0]<=106 && max[0]>= 86) || (max[0]<=215 && max[0]>= 175) || (max[0]<=325 && max[0]>= 265)){
                   
                pc.printf("\n %f\n", max[0]); 
                pc.printf("\n abajo \n");
                menos=1;
                wait(1);
                menos=0;
            }
            else if ((max[0]<=134 && max[0]>= 114) || (max[0]<=265 && max[0]>= 226) || (max[0]<=395 && max[0]>= 326)){
                   
                pc.printf("\n %f\n", max[0]); 
                pc.printf("\n arriba \n");
                mas=1;
                wait(1);
                mas=0;
            }
            

            //Se reinician las variables máximas
            max[0]=0;
            max[1]=0;
            
            // Se vuelve a incertar la interrupción de muestreo
            samplingBegin();
        }
    }
}