sev_server, linkear regr for boolean added

sev/lib/sev/src/sev_db.h

@@ -128,7 +128,17 @@ class sev_item {
     strncpy( oname, x.oname, sizeof(oname)); 
     strncpy( description, x.description, sizeof(description));
     if ( x.cache)
-      cache = new sev_valuecache(*x.cache);
+      switch ( attr[0].type) {
+      case pwr_eType_Float32:
+      case pwr_eType_Float64:
+      case pwr_eType_Int32:
+	cache = new sev_valuecache_double(*(sev_valuecache_double *)x.cache);
+	break;
+      case pwr_eType_Boolean:
+	cache = new sev_valuecache_bool(*(sev_valuecache_bool *)x.cache);
+	break;
+      default: ;
+      }
   }
   ~sev_item() {
     if ( cache)

sev/lib/sev/src/sev_dbms.cpp

@@ -1015,16 +1015,25 @@ int sev_dbms::store_value( pwr_tStatus *sts, int item_idx, int attr_idx,
                            pwr_tTime time, void *buf, unsigned int size)
 {
   if ( m_items[item_idx].options & pwr_mSevOptionsMask_DeadBandLinearRegr) {
-    double value;
+    void *value;
+    double dval;
+    pwr_tBoolean bval;
     switch ( m_items[item_idx].attr[0].type) {
     case pwr_eType_Float32:
-      value = *(pwr_tFloat32 *)buf;
+      dval = *(pwr_tFloat32 *)buf;
+      value = &dval;
       break;
     case pwr_eType_Float64:
-      value = *(pwr_tFloat64 *)buf;
+      dval = *(pwr_tFloat64 *)buf;
+      value = &dval;
       break;
     case pwr_eType_Int32:
-      value = *(pwr_tInt32 *)buf;
+      dval = *(pwr_tInt32 *)buf;
+      value = &dval;
+      break;
+    case pwr_eType_Boolean:
+      bval = *(pwr_tBoolean *)buf;
+      value = &bval;
       break;
     default:
       return 0;
@@ -4015,24 +4024,29 @@ int sev_dbms::store_stat( sev_sStat *stat)
   return 1;
 }
 
-void sev_dbms::write_db_cb( void *data, int idx, double value, pwr_tTime *time)
+void sev_dbms::write_db_cb( void *data, int idx, void *value, pwr_tTime *time)
 {
   pwr_tStatus sts;
   sev_dbms *dbms = (sev_dbms *)data;
 
   switch( dbms->m_items[idx].attr[0].type) {
   case pwr_eType_Float32: {
-    pwr_tFloat32 v = value;
+    pwr_tFloat32 v = *(double *)value;
     dbms->write_value( &sts, idx, 0, *time, &v, sizeof(v));
     break;
   }
   case pwr_eType_Float64: {
-    pwr_tFloat64 v = value;
+    pwr_tFloat64 v = *(double *)value;
     dbms->write_value( &sts, idx, 0, *time, &v, sizeof(v));
     break;
   }
   case pwr_eType_Int32: {
-    pwr_tInt32 v = value;
+    pwr_tInt32 v = *(double *)value;
+    dbms->write_value( &sts, idx, 0, *time, &v, sizeof(v));
+    break;
+  }
+  case pwr_eType_Boolean: {
+    pwr_tBoolean v = *(pwr_tBoolean *)value;
     dbms->write_value( &sts, idx, 0, *time, &v, sizeof(v));
     break;
   }
@@ -4042,13 +4056,24 @@ void sev_dbms::write_db_cb( void *data, int idx, double value, pwr_tTime *time)
 
 void sev_dbms::add_cache( int item_idx)
 {
+  switch ( m_items[item_idx].attr[0].type) {
+  case pwr_eType_Float32:
+  case pwr_eType_Float64:
+  case pwr_eType_Int32:
     if ( m_items[item_idx].options & pwr_mSevOptionsMask_DeadBandMeanValue)
-    m_items[item_idx].cache = new sev_valuecache( sev_eCvType_Mean, m_items[item_idx].deadband, 
+      m_items[item_idx].cache = new sev_valuecache_double( sev_eCvType_Mean, m_items[item_idx].deadband, 
 							   m_items[item_idx].scantime);
     else
-    m_items[item_idx].cache = new sev_valuecache( sev_eCvType_Point, m_items[item_idx].deadband, 
+      m_items[item_idx].cache = new sev_valuecache_double( sev_eCvType_Point, m_items[item_idx].deadband, 
 							   m_items[item_idx].scantime);
     m_items[item_idx].cache->set_write_cb( write_db_cb, this, item_idx);
+    break;
+  case pwr_eType_Boolean:
+    m_items[item_idx].cache = new sev_valuecache_bool( sev_eCvType_Point);
+    m_items[item_idx].cache->set_write_cb( write_db_cb, this, item_idx);
+    break;
+  default: ;
+  }
 }
 
 int sev_dbms::begin_transaction()

sev/lib/sev/src/sev_dbms.h

@@ -163,7 +163,7 @@ class sev_dbms : public sev_db {
   char *dbName() { return sev_dbms_env::dbName();}
   char *pwrtype_to_type( pwr_eType type, unsigned int size);
   static int timestr_to_time( char *tstr, pwr_tTime *ts);
-  static void write_db_cb( void *data, int idx, double value, pwr_tTime *time);
+  static void write_db_cb( void *data, int idx, void *value, pwr_tTime *time);
   int check_objectitem( pwr_tStatus *sts, char *tablename, pwr_tOid oid, char *oname, char *aname, 
                          pwr_tDeltaTime storagetime,
 			char *description, pwr_tFloat32 scantime, 

sev/lib/sev/src/sev_valuecache.cpp

@@ -45,9 +45,9 @@
 #include "pwr_baseclasses.h"
 #include "sev_valuecache.h"
 
-const int sev_valuecache::m_size = VALUECACHE_SIZE;
+const int sev_valuecache_double::m_size = VALUECACHE_SIZE;
 
-int sev_valuecache::idx( int index)
+int sev_valuecache_double::idx( int index)
 {
   if ( !m_length)
     return 0;
@@ -59,13 +59,14 @@ int sev_valuecache::idx( int index)
   return i;  
 }
 
-sev_sCacheValue& sev_valuecache::operator[]( const int index)
+sev_sCacheValueDouble& sev_valuecache_double::operator[]( const int index)
 {
   return m_val[idx(index)];
 }
 
-void sev_valuecache::add( double val, pwr_tTime *t)
+void sev_valuecache_double::add( void *value, pwr_tTime *t)
 {
+  double val = *(double *)value;
   double time;
   pwr_tDeltaTime dt;
 
@@ -109,7 +110,7 @@ void sev_valuecache::add( double val, pwr_tTime *t)
     calculate_epsilon(0);
 }
 
-void sev_valuecache::evaluate() 
+void sev_valuecache_double::evaluate() 
 {
   int value_added = 1;
 
@@ -128,7 +129,7 @@ void sev_valuecache::evaluate()
   }
 }
 
-void sev_valuecache::calculate_k()
+void sev_valuecache_double::calculate_k()
 {
   double xysum = 0;
   double x2sum = 0;  
@@ -151,7 +152,7 @@ void sev_valuecache::calculate_k()
   }
 }
 
-void sev_valuecache::write( int index) 
+void sev_valuecache_double::write( int index) 
 {
   int ii = idx(index);
   double wval, wtime;
@@ -189,12 +190,12 @@ void sev_valuecache::write( int index)
   if ( m_write_cb) {
     pwr_tTime time;
     time_Aadd( &time, &m_start_time, time_Float64ToD( 0, wtime));
-    (m_write_cb)( m_userdata, m_useridx, wval, &time);
+    (m_write_cb)( m_userdata, m_useridx, &wval, &time);
   }
 }
 
 // Calculate epsilon for all
-void sev_valuecache::calculate_epsilon()
+void sev_valuecache_double::calculate_epsilon()
 {
   if ( m_length == 1) {
     m_val[m_first].epsilon = 0;
@@ -206,7 +207,7 @@ void sev_valuecache::calculate_epsilon()
 }
  
 // Calculate epsilon for one index
-void sev_valuecache::calculate_epsilon( int index)
+void sev_valuecache_double::calculate_epsilon( int index)
 {
   int ii = idx(index);
   if ( m_k >= 1E32) {
@@ -219,7 +220,7 @@ void sev_valuecache::calculate_epsilon( int index)
 
 // Check deadband for one index
 // Returns true if all values inside deadband.
-bool sev_valuecache::check_deadband( int index)
+bool sev_valuecache_double::check_deadband( int index)
 {
   if ( m_val[idx(index)].epsilon > m_deadband)
     return false;
@@ -228,7 +229,7 @@ bool sev_valuecache::check_deadband( int index)
 
 // Check deadband for all values
 // Returns true if all values inside deadband.
-bool sev_valuecache::check_deadband()
+bool sev_valuecache_double::check_deadband()
 {
   for ( int i = 0; i < m_length; i++) {
     int ii = idx(i);
@@ -238,7 +239,7 @@ bool sev_valuecache::check_deadband()
   return true;
 }
 
-int sev_valuecache::get_optimal_write()
+int sev_valuecache_double::get_optimal_write()
 {
   if ( m_type == sev_eCvType_Mean) {
     m_last_k = m_k;
@@ -267,3 +268,30 @@ int sev_valuecache::get_optimal_write()
   return min_idx;
 }
 
+void sev_valuecache_bool::add( void *value, pwr_tTime *t)
+{
+  m_val.val = *(pwr_tBoolean *)value;
+  m_val.time = *t;
+
+  if ( m_inited) {
+    // Store valeu
+    write( 0);
+    m_inited = true;
+  }
+}
+
+void sev_valuecache_bool::evaluate() 
+{
+  if ( m_val.val != m_wval.val) {
+    write(0);
+  }
+}
+
+void sev_valuecache_bool::write( int index) 
+{
+  m_wval.val = m_val.val;
+  m_wval.time = m_val.time;
+  if ( m_write_cb)
+    (m_write_cb)( m_userdata, m_useridx, &m_wval.val, &m_wval.time);
+}
+

sev/lib/sev/src/sev_valuecache.h

@@ -49,21 +49,45 @@ typedef struct {
   double val;
   double time;
   double epsilon;
-} sev_sCacheValue;
+} sev_sCacheValueDouble;
+
+typedef struct {
+  pwr_tBoolean val;
+  pwr_tTime time;
+} sev_sCacheValueBool;
 
 #define VALUECACHE_SIZE 20
 
 class sev_valuecache {
-  static const int m_size;
+ public:
   sev_eCvType m_type;
   void *m_userdata;
   int m_useridx;
+  void (*m_write_cb)( void *, int , void *, pwr_tTime *);
+
+  sev_valuecache( sev_eCvType type) : m_type(type), m_userdata(0), m_useridx(0), m_write_cb(0) {}
+  sev_valuecache( const sev_valuecache& x) : m_type(x.m_type), m_userdata(x.m_userdata), m_useridx(x.m_useridx), 
+    m_write_cb(x.m_write_cb) {}
+  virtual ~sev_valuecache() {};
+  virtual void add( void *value, pwr_tTime *time) {};
+  virtual void evaluate() {};
+  virtual void write( int index) {};
+  virtual void set_write_cb( void (*write_cb)( void *, int, void *, pwr_tTime *), void *userdata, int idx) {
+    m_write_cb = write_cb;
+    m_userdata = userdata;
+    m_useridx = idx;
+  }
+};
+
+
+class sev_valuecache_double : public sev_valuecache  {
+  static const int m_size;
   int m_length;
   int m_first;
   int m_last;
   bool m_inited;
-  sev_sCacheValue m_val[VALUECACHE_SIZE];
-  sev_sCacheValue m_wval;
+  sev_sCacheValueDouble m_val[VALUECACHE_SIZE];
+  sev_sCacheValueDouble m_wval;
   double m_k;
   double m_m;
   double m_deadband;
@@ -72,29 +96,28 @@ class sev_valuecache {
   int m_last_opt_write;
   pwr_tTime m_start_time;
   double m_last_k;
-  void (*m_write_cb)( void *, int , double, pwr_tTime *);
 
  public:
-  sev_valuecache( sev_eCvType type, double deadband_value, double deadband_time) : 
-    m_type(type), m_userdata(0), m_useridx(0), m_length(0), m_first(0), m_last(0), m_inited(false), 
-    m_deadband_value(deadband_value), m_deadband_time(deadband_time), m_write_cb(0) {
+  sev_valuecache_double( sev_eCvType type, double deadband_value, double deadband_time) : 
+    sev_valuecache(type), m_length(0), m_first(0), m_last(0), m_inited(false), 
+    m_deadband_value(deadband_value), m_deadband_time(deadband_time) {
     memset( &m_wval, 0, sizeof(m_wval));
     time_GetTime(&m_start_time);
   }
-  sev_valuecache( const sev_valuecache& x) : m_type(x.m_type), m_userdata(x.m_userdata), m_useridx(x.m_useridx),
-    m_length(x.m_length),
+  sev_valuecache_double( const sev_valuecache_double& x) : 
+    sev_valuecache(x), m_length(x.m_length),
     m_first(x.m_first), m_last(x.m_last), m_inited(x.m_inited), m_k(x.m_k), m_deadband(x.m_deadband), 
     m_deadband_value(x.m_deadband_value), m_deadband_time(x.m_deadband_time), m_last_opt_write(x.m_last_opt_write),
-    m_start_time(x.m_start_time), m_last_k(x.m_last_k), m_write_cb(x.m_write_cb) {
+    m_start_time(x.m_start_time), m_last_k(x.m_last_k) {
     memcpy( m_val, x.m_val, sizeof(m_val));
     memcpy( &m_wval, &x.m_wval, sizeof(m_wval));
   }
-  ~sev_valuecache() {}
+  ~sev_valuecache_double() {}
   int length() { return m_length;}
   int idx( int index);
-  sev_sCacheValue& operator[]( const int index);
-  sev_sCacheValue& wval() { return m_wval;}
-  void add( double value, pwr_tTime *time);
+  sev_sCacheValueDouble& operator[]( const int index);
+  sev_sCacheValueDouble& wval() { return m_wval;}
+  void add( void *value, pwr_tTime *time);
   void evaluate();
   void calculate_k();
   void write( int index);
@@ -105,11 +128,27 @@ class sev_valuecache {
   int get_optimal_write();
   double epsilon(int index) { return m_val[idx(index)].epsilon;}
   double get_k() { return m_k;}
-  void set_write_cb( void (*write_cb)( void *, int, double, pwr_tTime *), void *userdata, int idx) {
-    m_write_cb = write_cb;
-    m_userdata = userdata;
-    m_useridx = idx;
+};
+
+class sev_valuecache_bool : public sev_valuecache  {
+  bool m_inited;
+  sev_sCacheValueBool m_val;
+  sev_sCacheValueBool m_wval;
+
+ public:
+  sev_valuecache_bool( sev_eCvType type) : 
+    sev_valuecache(type), m_inited(false) {
+    memset( &m_wval, 0, sizeof(m_wval));
   }
+  sev_valuecache_bool( const sev_valuecache_bool& x) : 
+    sev_valuecache(x), m_inited(x.m_inited) {
+    memcpy( &m_wval, &x.m_wval, sizeof(m_wval));
+  }
+  ~sev_valuecache_bool() {}
+  sev_sCacheValueBool& wval() { return m_wval;}
+  void add( void *value, pwr_tTime *time);
+  void evaluate();
+  void write( int index);
 };