Ss_Energia.cpp

Go to the documentation of this file.

#include "Ss_Energia.h"

/** \brief Read voltage and current data from sensors. This function calculates apparent power, real power, rms current and voltage.
 * \param V is the pointer to voltage sensor. If NULL, Energia uses default voltage (see Ss_Global.h)
 * \param I is the pointer to current sensor
 * \param wavenumber number of scanned waves
 */
void Energia::ReadPowerData(struct Mc_AnalogSensor * V,struct Mc_AnalogSensor * I,uint8_t wavenumber)
{
   //se V è posto a null viene usata la tensione di default
   unsigned long tstart;
   bool st=false;
   tstart = micros();
   minV=minI=Mc_High_ADC_Value;
   maxV=maxI=-Mc_High_ADC_Value;

   ReadMiddlePoint(100);

   float istV=0,istI=0,istP=0,sqrV=0,sqrI=0,sum_sqrV=0,sum_sqrI=0,sum_inst_power=0;
   int soglia=(1<<Mc_ADC_extended_bits)/150;

   double timelen=(double)wavenumber*1/Mc_voltage_freq*1000*1000; //0.02sec...è la lunghezza in microsecondi dell'onda completa.

   while(st==false) // aspetta di essere intorno allo zero per iniziare a campionare.                                   
   {
    istV=Mc_SampleAnalogAvg(V->pin,2)-midpoint; // A2 legge l'onda che arriva dal trasformatore
    if (istV<soglia && istV>-soglia) st=true;  //check its within range
    if ((micros()-tstart)>10*timelen)
    {
      st = true;
#  ifdef ENERGIA_DEBUG
     Serial.print("Not 0 wave cross!");
#  endif
    }
  }
     tstart=micros();

  counter=0;
  float sensorIstep=I->sensor_step;
  float sensorVstep=V->sensor_step;
  while(micros()-tstart<timelen)
  {
   istI=RippleRemover(Mc_SampleAnalogAvg(I->pin,1)-midpoint);         // corrente
   if(V) istV=(Mc_SampleAnalogAvg(V->pin,1)-midpoint);                // tensione
   else istV=Mc_default_voltage;


   /*istI=(Mc_SampleAnalogAvg(I->pin,1)-midpoint);         // corrente
   if(V) istV=(Mc_SampleAnalogAvg(V->pin,1)-midpoint);                // tensione
   else istV=Mc_default_voltage; 
     */
   istP=istV*istI;
   sqrV=istV*istV;
   sqrI=istI*istI;
   sum_sqrV+=sqrV;
   sum_sqrI+=sqrI;
   sum_inst_power+=istP;

   if(minV>istV) minV=istV;
   if(minI>istI) minI=istI;

   if(maxV<istV) maxV=istV;
   if(maxI<istI) maxI=istI;
   counter++;
  }
  rmsI=sqrt(sum_sqrI/counter)*sensorIstep;
  rmsV=sqrt(sum_sqrV/counter)*sensorVstep;
  rP=sensorIstep*sensorVstep*sum_inst_power/counter;
  aP=rmsV*rmsI;
}


//==============================================================================

Energia::Energia()
{

}
//==============================================================================  

/** \brief Inizialize Energia
 * \param mp is the analogic pin to read middle point. If not specificated Energia uses perfect half scale as middle point.
 */
void Energia::Start(int mp)
{
  Mc_Analog_Inist();
  int midpoint=(1<<(Mc_ADC_extended_bits-1)); // da tenere se non fai la lettura analogica;
  Pin_MiddlePoint=mp;
}
//==============================================================================
  /** \brief Set ripple noise
 * \param mp is the analogic pin to read middle point. If not specified Energia uses perfect half scale as middle point.
 * \param num specify the number of samples. If not specificated is set to 450.
 */
void Energia::SetRipple(float rip,uint16_t num)
{
  if(rip>=0) ripple=rip;
  else
  {
    struct Mc_AnalogLine MidLine;
    MidLine=CheckAnalogLine(Pin_MiddlePoint,num);
    ripple=abs(MidLine.rms-MidLine.klm);

  }

}
//==============================================================================

/** \brief Remove ripple value from specified value
 * \param value is the value you want to clean from ripple
 * \return filtered value
 */
float Energia::RippleRemover(float value)
{
 if(abs(value)<=ripple) value=0;
 return(value);
}

//==============================================================================
/** \brief Read middle point: this function uses Kalman filter to reduce the noise. 
 * \param campioni is the number of samples
 */
void Energia::ReadMiddlePoint(uint16_t campioni)
{
 //midpoint=Mc_SampleAnalogAvg(Pin_MiddlePoint,campioni);
 midpoint=Mc_KalmanAnalogAvg(Pin_MiddlePoint,campioni);

}
//==============================================================================
/** \brief Sample waves
 * \param S is the sensor connected to source
 * \param wavenumber is the number of waves you want to sample. If not specified it's setted to 1
 */

void Energia::GetWaveValue(struct Mc_AnalogSensor * S,uint8_t wavenumber)
{
   unsigned long tstart;
   float istS,sqrS,sum_sqrS;
   bool st=false;
   tstart = millis();
   int soglia=(1<<Mc_ADC_extended_bits)/10;

   double timelen=(double)wavenumber*1/Mc_voltage_freq*1000*1000; //0.02sec...è la lunghezza in microsecondi dell'onda completa.
    counter=0;
  while(st==false) // aspetta di essere intorno allo zero per iniziare a campionare.                                   
  {

    istS=Mc_SampleAnalogAvg(S->pin,2)-midpoint; // A2 legge l'onda che arriva dal trasformatore
    if (istS<soglia && istS>-soglia) st=true;  //check its within range
    if ((micros()-tstart)>5*timelen)
    {
      st = true;
#  ifdef ENERGIA_DEBUG
     if(counter)
     {
        Serial.print("Not 0 wave cross: ");
        Serial.println(counter);
     }
#  endif
     }
     counter++;
  }
  counter=0;
  tstart=micros();

  float sensorSstep=S->sensor_step;
  while(micros()-tstart<timelen)
  {
   istS=(Mc_SampleAnalogAvg(S->pin,2)-midpoint); // pinza amperometrica. 

   if(minS>istS) minS=istS;
   if(maxS<istS) maxS=istS;
   sqrS=istS*istS;
   sum_sqrS+=sqrS;
   counter++;
  }
  rmsS=sqrt(sum_sqrS/counter)*sensorSstep;


}
//==============================================================================