File content as of revision 6:84f33f8a9c9d:

#include "mbed.h"
#include "arm_math.h"
#include "TextLCD.h"

Ticker timerCapturaMuestreo;
Ticker timerMostrar;

Serial pc(USBTX, USBRX); // tx, rx

#define longitud 360

float Vrms;
float Irms;
float P;
float Q;
float S;
float FDP;

//BUFFERS DE VOLTAJE
int16_t bufferA[longitud];
int16_t bufferB[longitud];

//BUFFERS DE INTENSIDAD
int16_t bufferC [longitud];
int16_t bufferD [longitud];

//
int contador=0 ;
int nbuffer=1 ;
int bufferlleno ;
int mostrarDato=1 ;
float rms ;
float Vpp ;

//punteros
int16_t *pA ;
int16_t *pB ;

AnalogIn voltaje (A0); //ENTRADA DE VOLTAJE
AnalogIn intensidad (A5); //ENTRADA DE INTENSIDAD

void muestreo () //hay que programar que se ejecute la funcion cada X tiempo (siendo X el tiempo de muestreo)
{
    if (nbuffer==1) { //si nbuffer=1 entonces se guardan los datos en el buffer A, else buffer B
        bufferA[contador]=voltaje.read ()*197-325 ; //VOLTAJE
        bufferC[contador]=intensidad.read ()*8-14 ;  //INTENSIDAD
        contador=contador+1 ;
        if (contador==longitud) {
            nbuffer=0 ;
            contador=0 ;
            bufferlleno=1;
        }
    } else {
        bufferB[contador]=voltaje.read ()*197-325 ; //VOLTAJE ;
        bufferD[contador]=intensidad.read ()*8-14 ;  //INTENSIDAD ;
        contador=contador+1 ;
        if (contador==longitud) {
            nbuffer=1 ;
            contador=0 ;
            bufferlleno=1;
        }
    }
}


// vamos a programar un boton como una entrada digital que nos permita seleccionar
// el tipo de dato que queremos visualizar en la lcd

//primero definimos como digitales las entradas en las que estarán los pulsadores

InterruptIn pulsador1(PC_13);
InterruptIn pulsador2 (D2);

void botonUP ()
{
        mostrarDato+=1;
        if (mostrarDato==9) {
            mostrarDato=1;
        } 
}

void botonDOWN ()
{
            mostrarDato-=1;
            if (mostrarDato==0) {
                mostrarDato=8;
            }
}

void mostrar ()
{
    if (mostrarDato==1) {
        pc.printf("voltaje:\n%f",Vrms);
    } else if (mostrarDato==2) {
        pc.printf("intensidad:\n%f",Irms);
    } else if  (mostrarDato==3) {
        pc.printf("potencia activa:\n%f",P);
    } else if (mostrarDato==4) {
        pc.printf("potencia reactiva:\n%f",Q);
    } else if (mostrarDato==5) {
        pc.printf("potencia aparente:\n%f",S);
    } else if (mostrarDato==6) {
        pc.printf("energia activa:\n%f",0);
    } else if (mostrarDato==7) {
        pc.printf("energia reactiva:\n%f",0);
    } else if (mostrarDato==8) {
        pc.printf("factor de potencia:\n%f",FDP);
    }
}


float calcularRMS(int16_t *datos, int N); //definicion del tipo de variable que devuelve la funcion
float calcularRMS(int16_t *datos, int N)   // definicion de los estamentos de la funcion
{
    float32_t k=5.035400390625000e-05;
    int64_t producto=0;

    for (int n=0; n<N; n++) {
        producto+=datos[n]*datos[n];
    }
    return sqrt((float(producto)/N))*k;

}

float calcular_potencia_activa(int16_t *datos1,int16_t *datos2, int N);
float calcular_potencia_activa(int16_t *datos1,int16_t *datos2, int N)
{
    int32_t sumatorio=0;
    for (int16_t n=0; n<N; n++)
    {
        sumatorio+=sumatorio+datos1[N]*datos2[N];
    }
    return datos1[N]*datos2[N]/N;
}
    
float calcular_potencia_reactiva_MAL(float Vrms,float Irms,float P,float S);
float calcular_potencia_reactiva_MAL(float Vrms,float Irms,float P,float S)    
{
    float Q=sqrt(S-P);
    return Q;
}
    
    
float calcular_potencia_aparente(float Vrms,float Irms);
float calcular_potencia_aparente(float Vrms,float Irms)
{
    float S=Vrms*Irms;
    return S;
}
    
    
float calcular_potencia_reactiva(int16_t *datos1,int16_t *datos2, int N);
float calcular_potencia_reactiva(int16_t *datos1,int16_t *datos2, int N)
{
    return 0;
}

float fdp (float S,float P);
float fdp (float S,float P)
{
    float fdp=P/S;
    return fdp;
}


int main()
{
    pulsador1.rise(&botonUP);
    pulsador2.rise(&botonDOWN);
    timerCapturaMuestreo.attach_us(&muestreo,200);
    timerMostrar.attach(&mostrar,1.0);
    while(1) {
        if (bufferlleno==1) {
            bufferlleno=0;
            if (nbuffer==0) 
            {
                float Vrms=calcularRMS(bufferA,longitud);
                float Irms=calcularRMS(bufferC,longitud);
                float P=calcular_potencia_activa(bufferA,bufferC,longitud);    
            }
             
            else
             
            {
                float Vrms=calcularRMS(bufferB,longitud);
                float Irms=calcularRMS(bufferD,longitud);
                float P=calcular_potencia_activa(bufferB,bufferD,longitud);
            }
            
            float S=calcular_potencia_aparente(Vrms,Irms);
            float Q=calcular_potencia_reactiva_MAL(Vrms,Irms,P,S);
            float FDP=fdp(S,P);
        }
    }
}