Ss_Analogico.cpp

Go to the documentation of this file.

#include "Ss_Analogico.h"


//==============================================================================
/** \brief Inizialize McMajanLibrary analogic section
 */
void Mc_Analog_Inist()
{
#if defined ARDUINO_ARCH_AVR
  ADCSRA &= ~Mc_PS_128;  //Set up the ADC: remove bits set by Arduino library
  ADCSRA |= Mc_DEFAULT_AVR_ADC_PRESCALER;    // set our own prescaler to SCR_XX
#else
  analogReadResolution(12);
#endif
}


//==============================================================================
/** \brief Calcolate internal parameters to give you values in original units as Ampere, Volt, etc and not only a raw value.
 * \param sensore is the pointer to the sensor 
 */
void Mc_CalculateSensorStep(struct Mc_AnalogSensor* sensore)
{
  sensore->sensorunit=(((int)(1<<Mc_ADC_extended_bits))*(float)sensore->sensor_voltage_range/(float)Mc_ArduinoVoltageRange);
  sensore->sensor_step=((float)sensore->sensor_range/(float)sensore->sensorunit); // questo moltiplicato per la "lettura grezza" ti fornisce il valore "fisico"  
}
//==============================================================================
/** \brief This function is useful if you need to do a "manual calibration" of the sensor
 * \param sensore is the sensor pointer you want to calibrate
 * \param value is the manual calibration of the sensor
 */
void Mc_SetSensorStep(struct Mc_AnalogSensor* sensore,float value)
{
 sensore->sensor_step=value/(1<<Mc_ADC_bit_extension);
}
//==============================================================================
/** \brief This function sample an analogic input and return the averange value
 * \param localpin is the input pin of Arduino
 * \param campioni is the number of samples you want to do.
 * \return this function return the averange value of the samples. 
 */
float Mc_SampleAnalogAvg(int localpin,uint16_t campioni)
{
  float valore=Mc_OversampledAnalogRead(localpin);
  for(int i=0;i<campioni;i++) valore=(valore+Mc_OversampledAnalogRead(localpin))/2;
  return(valore);

}

//==============================================================================
/** \brief This function return the kalman filtered value of samples on an analogic pin.
 * Note: the voltage of input pin must be stable. This function is useful to read the right value removing the background noise. 
 * \param localpin is the input pin of Arduino
 * \param campioni is the number of samples you want to do.
 * \return this function return the kalman filtered value of the samples. 
 */

float Mc_KalmanAnalogAvg(int localpin,uint16_t campioni)
{
  campioni=(campioni>>1);
  kalman_state K1,K2;
  float valore=Mc_OversampledAnalogRead(localpin);
  K1=kalman_init(2,50, valore, valore); //0.1 -4
  for(uint8_t i=0;i<campioni;i++) kalman_update(&K1,Mc_OversampledAnalogRead(localpin));

  K2=kalman_init(1,80, K1.value, K1.value); //0.1 -4
  for(uint8_t i=0;i<campioni;i++) kalman_update(&K2,Mc_OversampledAnalogRead(localpin));

  return(K2.value);

}
//==============================================================================
/** \brief This function sample an analogic input using oversample algorithm
 * \param pin is the input pin of Arduino
 * \return this function return the reded value
 */
inline double Mc_OversampledAnalogRead(int pin)
{         // al posto di overbit ci metto Mc_ADC_bit_extension
 unsigned int val=0;
 unsigned int misureoversample=pow(4,Mc_ADC_bit_extension);
 for(unsigned char z=0;z<misureoversample;z++) val+=analogRead(pin);

 return(val>>Mc_ADC_bit_extension); //2^n
}
//==============================================================================
/** \brief This function initialize a Kalman filter
 * \param q process noise covariance
 * \param r measurement noise covariance
 * \param p estimation error covariance
 * \param value initial value
 * \return initialized kalman filter. 
 */
kalman_state kalman_init(double q, double r, double p, double intial_value)
{
  kalman_state result;
  result.q = q;
  result.r = r;
  result.p = p;
  result.value = intial_value;

  return result;
}
//==============================================================================
/** \brief This function updates a Kalman filter
 * \param state is the actual kalman filter pointer
 * \param measurement is the new value you want to filter
 * \return this funtion DON'T retrun nothing because the original filter is modificated
 */

void kalman_update(kalman_state* state, double measurement)
{
  //prediction update
  state->p = state->p + state->q;

  //measurement update
  if((state->p + state->r)!=0) state->k = state->p / (state->p + state->r);
  else state->k = state->p / 0.00001;
  state->value = state->value + state->k * (measurement - state->value);
  state->p = (1 - state->k) * state->p;
}
//==============================================================================  
/** \brief Test analogic line
 *
 * This function samples an analogic input to read lower, higher , mean and, rms values. inoltre - althought you can see the number of samples and the kalmann filtered value. This last value is useful to test
 * lines wich signal is stable (or may be it).
 * \param pin is the analogic pin you want to test
 * \param num is the number of "grid waves" you want to sample (default 450 if you don't specify values). 
 * \return this funtion return a Mc_AnalogLine structure.
 */
struct Mc_AnalogLine CheckAnalogLine(int pin,uint16_t num)
{
 struct Mc_AnalogLine Local;

 kalman_state KK;

 unsigned long LocalTime=0;
 float value=0;
 double sum_radice=0;

  Local.min=Mc_High_ADC_Value;
  Local.max=-Mc_High_ADC_Value;

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

   Local.mean=Mc_SampleAnalogAvg(pin,1);

    KK=kalman_init(1,80, Local.mean, Local.mean);


  Local.counter=0;
  LocalTime=micros();
  while(micros()-LocalTime<timelen)
  {

   value=(Mc_SampleAnalogAvg(pin,1));         // corrente

   kalman_update(&KK,value);
   if(value<Local.min) Local.min=value;
   if(value>Local.max) Local.max=value;
   Local.mean=(Local.mean+value)/2;


   sum_radice+=(value*value);
   Local.counter++;
   }

   Local.rms=sqrt(sum_radice/Local.counter);
   Local.klm=KK.value;



 return(Local);

}