File content as of revision 0:ebc3999f6ef4:

#include "mbed.h"
#define bufferLength 500
#include "math.h"
#include "TextLCD.h"
 
#define muestras 100
TextLCD lcd(D8, D9, D2, D3, D4, D5, TextLCD::LCD16x2); // rs, e, d4-d7
Serial pc(USBTX, USBRX); // tx, rx
struct eResultados {
    float Vrms;
    float Vmax;
    float Vmin;
};
struct estructuraMedidas 
{ 
   float vrms; 
   float irms;  
   float potenciaActiva; 
   float potenciaReactiva;  
   float potenciaAparente;  
   float energiaConsumida;
   float factorDePotencia;
};
//struct Vectores{
  //  float  vTensionA[muestras];
  //float  vTensionB[muestras];
  //  float  vIntensidadA[muestras];
  //  float  vIntensidadB[muestras];
}vectores;
AnalogIn    adc_in(A0);
AnalogIn    int_in(A1);
AnalogOut   dac_out(A2);
AnalogOut   int_out(A3);
InterruptIn boton(USER_BUTTON);

Ticker tMuestrea;
Ticker tVisualiza;
void visualiza();
void procesado(int length,  uint16_t *entrada, uint16_t *entrada2);
void calcularRMS(uint16_t *buffer, int longitud,eResultados *resul);
int flag=0;
int contador=0;
int bufferActivo=0;

struct buffers {
    uint16_t 1A[muestras];
    uint16_t 1B[muestras];
    uint16_t 2A[muestras];
    uint16_t 2B[muestras];
};

bool bufferActivo=0;
void muestrea();

buffers bufferEntrada;
buffers bufferSalida;

eResultados resultados;

int main()
{

    tMuestrea.attach_us(&muestrea, 100);
    tVisualiza.attach(&visualiza, 5);
    
    while(1) {
        if (flag) {
            flag=0;
            if(bufferActivo==1) {
                procesado(muestras,(uint16_t *)&bufferEntrada.1A,(uint16_t *)&bufferEntrada.2A);
            } else {
                procesado(muestras,(uint16_t *)&bufferEntrada.1B,(uint16_t *)&bufferEntrada.2B);
            }
            

        }


        wait_us(1);
    }
}

void muestrea()
{
    uint16_t dato=adc_in.read_u16();
        uint16_t dato2=int_in.read_u16();
    if (bufferActivo==0) {

        bufferEntrada.1A[contador]=dato;

        bufferEntrada.2A[contador]=dato2;

    }

    else {

        bufferEntrada.1B[contador]=dato;

        bufferEntrada.2B[contador]=dato2;

    }

    contador++;
    if(contador==muestras) {
        bufferActivo=!bufferActivo;
        contador=0;
        flag=1;
    }

}
void procesado(int length, uint16_t *entrada, uint16_t *entrada2)
//{
  //  for (int i=0; i<length; i++) {
    //    salida[i]=entrada[i];
    //}

//    calcularRMS(entrada,length,&resultados);
     void calcularDatos(int16_t *entrada, int16_t *entrada2, int longitud, estructuraMedidas *medidas);


}
void calcularRMS(uint16_t *buffer, int longitud,eResultados *resul)
{
    float cons=0.00005035400390625;
    float cons1=1.007080078125e-4;
    float cons2=cons*cons;

    float res;
    float Vmax=0;
    float Vmin=65535;

    uint64_t suma=0;



    for (int i=0; i<longitud; i++) {

        suma+=buffer[i]*buffer[i];
        if (Vmax<buffer[i]) {
            Vmax=buffer[i];
        }
        if (Vmin>buffer[i]) {
            Vmin=buffer[i];
        }
    }


    res=cons1*sqrt(((float)suma)/longitud);
    resul->Vrms=res;
    resul->Vmax=Vmax*cons;
    resul->Vmin=Vmin*cons;
}

void visualiza(){
    printf ("El valor maxima es %f\n",resultados.Vmax);
    printf ("El valor minimo es %f\n",resultados.Vmin);
    printf ("El valor RMS es %f\n\n",resultados.Vrms);
    
    }
    void calcularDatos(int16_t *datosV, int16_t *datosI, int longitud, estructuraMedidas *medidas)
{
    float cons=1.007080078125e-4;
    float cons2=cons*cons;

    int64_t sumaV=0;
    int64_t sumaI=0;
    int64_t sumaP=0;
   


    float datoV;
    float datoI;
    float datoP;
    float datoS;
    float datoQ;
 

    for (int i=0; i<longitud; i++) {

        sumaV+=datosV[i]*datosV[i];
        sumaI+=datosI[i]*datosI[i];
        sumaP+=datosV[i]*datosI[i];
    }

    datoV = cons*sqrt(((float)sumaV)/longitud);
    datoI = cons*sqrt(((float)sumaI)/longitud);
    datoP = cons2*((float)sumaP)/longitud;
    datoS=datoV*datoI;
    datoQ = sqrt((datoS*datoS)-(datoP*datoP)); 

        (*medidas).energiaConsumida = datoP/datoI;     
        (*medidas).factorDePotencia = datoP/datoS;
        (*medidas).potenciaAparente = datoS;
        (*medidas).potenciaActiva = datoP;
        (*medidas).potenciaReactiva = datoQ;
        (*medidas).vrms = datoV;
        (*medidas).irms = datoI;
        (*medidas).factorDePotencia = datoP/datoS;
}