File content as of revision 7:e0452337a3d1:

#include "mbed.h"
#include "math.h"
#include "TextLCD.h"

#define datoTension 725.331071
#define datoIntensidad 29.4943123
#define constanteTension 1.4709e-06
#define constanteIntensidad 1.423595702690060e-09
#define vectormuestras 100
#define offsetTension 0.50369472
#define offsetIntensidad 0.5040785
#define eps 2.220446049250313e-016

TextLCD lcd(D8, D9, D2, D3, D4, D5, TextLCD::LCD16x2); // rs, e, d4-d7
Serial pc(USBTX, USBRX); // tx, rx

InterruptIn button(PC_13); 
AnalogIn tension(A0);
AnalogIn intensidad(A1);


struct Vectores{
    float  vTensionA[vectormuestras];
    float  vTensionB[vectormuestras];
    
    float  vIntensidadA[vectormuestras];
    float  vIntensidadB[vectormuestras];
}vectores;

struct Medidas{
    float medidaTension;
    float medidaIntensidad;
}medidas;

int contador=0;
int pulsador=0;
int bufferActivo=0;
int flag=0;
int16_t measV=0;
int16_t measI=0;
int32_t producto=0;
int64_t sumatorioV=0;
int64_t sumatorioI=0;
int64_t sumatorioPA=0;

float VRMS=0;
float IRMS=0;
float P_activa=0;
float P_reactiva=0;
float P_aparente=0;
float Consumo_Pact=0;
float Consumo_Preact=0;
float FP=0;

//Captura de valores mediante muestreo
void captura() //función muestreo
{
    float medidaTension=tension.read();
    medidaTension=medidaTension-offsetTension*datoTension;
    
    float medidaIntensidad=intensidad.read();
    medidaIntensidad=medidaIntensidad-offsetIntensidad*datoIntensidad;
    
    if(bufferActivo==1) {
        vectores.vTensionA[contador] = medidaTension;
        vectores.vIntensidadA[contador] = medidaIntensidad;
        
    } else {
        vectores.vTensionB[contador] = medidaTension;
        vectores.vIntensidadB[contador] = medidaIntensidad;
    }
    
    contador++;
    if(contador==vectormuestras){
        contador=0;
        bufferActivo=!bufferActivo;
        flag=1;//buffer lleno
    }
}

//Visualización por pantalla
void visualizacion()//función mostrar
{
    lcd.cls();
    if(pulsador==0){
        lcd.printf("VRMS:\n %f", VRMS);
    }
    
    else if (pulsador ==1) {
        lcd.printf("IRMS:\n %f", IRMS);
    }
        
    else if (pulsador ==2) {
        lcd.printf("Pot. activa:\n %f", P_activa);
    }
    
    else if (pulsador ==3) {
        lcd.printf("Pot. reactiva:\n %f", P_reactiva);
    }
    
    else if (pulsador ==4) {
        lcd.printf("Pot. aparente:\n %f", P_aparente);
    }
    
    else if (pulsador ==5) {
        lcd.printf("Consumo Pot. A:\n %f", Consumo_Pact);
    }
    
    else if (pulsador ==6) {
        lcd.printf("Consumo Pot. R:\n %f", Consumo_Preact);
    }
    
    else if (pulsador ==7) {
        lcd.printf("Factor de potencia:\n\r %f", FP);
    }
    
}

//Cambio de boton
void cambio_boton() 
{ 
    pulsador++; 
    if(pulsador>8) { 
    pulsador=0;
   } 
} 

int main()
{
    Ticker timerCaptura;
    Ticker timerVisualizacion;
    timerCaptura.attach_us(&captura,200);//Hace que la función muestreo se ejecute cada 200us
    timerVisualizacion.attach(&visualizacion,1.0);//Hace que la función mostrar se ejecute cada segundo
    button.rise(&cambio_boton);//Hace que la función boton se ejecute cada vez que se pulse el botón
    
    while(1) {//bucle para siempre
        if(flag) {//mira si el buffer esta lleno
            flag=0;//Borra la variable buffer lleno
            measV=0;
            measI=0;
            producto=0;
            sumatorioV=0;
            sumatorioI=0;
            sumatorioPA=0;

            for (int b=0; b<vectormuestras; b++) {//VRMS
                if (!bufferActivo) {
                    measV=vectores.vTensionA[b];
                    measI=vectores.vIntensidadA[b];
                } else {
                    measV=vectores.vTensionB[b];
                    measI=vectores.vIntensidadB[b];
                }
                producto=measV*measV;
                sumatorioV+=producto;//calcula el valor VPP
                producto=measI*measI;
                sumatorioI+=producto;
                producto=measV*measI;
                sumatorioPA+=producto;
            }

            VRMS=sqrt(sumatorioV)/vectormuestras;        
            IRMS=sqrt(sumatorioI);
            P_activa=sqrt(constanteTension*constanteIntensidad)*sumatorioPA;
            P_aparente=VRMS*IRMS;
            P_reactiva=sqrt(P_aparente*P_aparente)-(P_aparente*P_aparente);
            Consumo_Pact=Consumo_Pact+P_activa*20e-3/(3600*1000);
            Consumo_Preact=Consumo_Preact+P_reactiva*20e-3/(3600*1000);
            FP=P_activa/(P_aparente+eps);
        }
    }        
}