src/W1Device.cc

   1 /*
   2  * W1Device.cc
   3  *
   4  *  Created on: Oct 20, 2010
   5  *      Author: lamikr
   6  */
   7 #include <iostream>
   8 #include <fstream>
   9 #include <sstream>
  10 #include <iomanip>
  11
  12 #include <time.h>
  13 #include <plp/log.h>
  14
  15 #include <plp/DeviceConfig.hh>
  16 #include <plp/StoreDay.hh>
  17
  18 #include "Factory.hh"
  19 #include "W1Device.hh"
  20
  21 using namespace std;
  22 using namespace w1;
  23 using namespace plp;
  24
  25 W1Device::W1Device(string device_id_param,
  26                 string device_type_param,
  27                 dirent *direntry_param) : SensorDevice(device_id_param, device_type_param) {
  28         string rootdir;
  29         string device_dir;
  30         string temp_str;
  31
  32         pthread_mutex_init(&plock, NULL);
  33         type    = device_type_param;
  34         id      = device_id_param;
  35         if (direntry_param != NULL) {
  36                 rootdir                 = W1_SCAN_ROOTDIR;
  37                 temp_str                = W1_SLAVE_FILE;
  38                 dir_path                = rootdir + "/" + direntry_param->d_name;
  39                 slave_file              = dir_path + "/" + temp_str;
  40                 lifecycle_status        = LIFECYCLE_STATUS__AVAILABLE;
  41                 log_debug("1-wire device's data file: %s\n", slave_file.c_str());
  42         }
  43         else {
  44                 lifecycle_status        = LIFECYCLE_STATUS__UNAVAILABLE;
  45         }
  46         reader  = new DataReader(id);
  47         name    = "";
  48 }
  49
  50 W1Device::~W1Device() {
  51         log_debug("W1Device destructor\n");
  52         save_and_clean_cache();
  53         if (reader != NULL) {
  54                 delete(reader);
  55                 reader  = NULL;
  56         }
  57 }
  58
  59 string W1Device::get_name() {
  60         DeviceConfig    *cfg;
  61
  62         if (name.empty() == true) {
  63                 cfg     = DeviceConfig::get_device_config(id);
  64                 if (cfg != NULL) {
  65                         name    = cfg->get_config_value(DEVICE_CONFIG_VALUE_KEY__NAME);
  66                         delete(cfg);
  67                 }
  68         }
  69         return name;
  70 }
  71
  72 void W1Device::set_name(string name_param) {
  73         DeviceConfig    *cfg;
  74
  75         if (name.compare(name_param) != 0) {
  76                 name    = name_param;
  77                 cfg     = DeviceConfig::get_device_config(id);
  78                 if (cfg != NULL) {
  79                         cfg->set_config_value(DEVICE_CONFIG_VALUE_KEY__NAME, name_param);
  80                         delete(cfg);
  81                 }
  82         }
  83 }
  84
  85 void W1Device::printout() {
  86         Data    *data;
  87         string  text;
  88         string  type;
  89         string  name;
  90
  91         data    = get_data();
  92         if (data != NULL) {
  93                 text    = data->to_string();
  94                 cout << text << endl;
  95                 delete(data);
  96         }
  97         else {
  98                 type    = get_type();
  99                 name    = get_name();
 100                 log_error("Could not read data for %s device: %s\n", type.c_str(), name.c_str());
 101         }
 102 }
 103
 104 string W1Device::to_string(double dbl_val, int digit_count) {
 105         string          ret_val;
 106         ostringstream   out;
 107
 108         out << fixed << setprecision(digit_count) << dbl_val;
 109         ret_val = out.str();
 110         return ret_val;
 111 }
 112
 113 Data *W1Device::get_data() {
 114         Data            *ret_val;
 115         vector<double>  *vect;
 116
 117         log_debug("get_data() started\n");
 118         ret_val = NULL;
 119         vect    = get_raw_data();
 120         if (vect != NULL) {
 121                 log_debug("get_data() got raw data\n");
 122                 ret_val = new Data(vect, get_unit());
 123                 cache(ret_val);
 124                 delete(vect);
 125                 log_debug("get_data() got raw data done\n");
 126         }
 127         else {
 128                 log_debug("get_data() try to read old already saved data\n");
 129                 // read old data already saved
 130                 ret_val = reader->get_latest_data();
 131                 log_debug("get_data() try to read old already saved data done\n");
 132         }
 133         return ret_val;
 134 }
 135
 136 void W1Device::cache(Data *new_data) {
 137         Data    *data;
 138         int     dec_precision;
 139
 140         data    = new_data->clone();
 141         pthread_mutex_lock(&plock);
 142         memory_cache.push_back(data);
 143         if (memory_cache.size() > 5) {
 144                 dec_precision   = get_data_decimal_precision();
 145                 StoreDay::save(id, &memory_cache, dec_precision);
 146                 while(memory_cache.empty() == false) {
 147                         data    = memory_cache.back();
 148                         memory_cache.pop_back();
 149                         delete(data);
 150                 }
 151         }
 152         pthread_mutex_unlock(&plock);
 153 }
 154
 155 void W1Device::save_and_clean_cache() {
 156         Data    *data;
 157         int     dec_precision;
 158
 159         dec_precision   = get_data_decimal_precision();
 160         pthread_mutex_lock(&plock);
 161         log_debug("save_and_clean_cache(): memory cache size: %d\n", memory_cache.size());
 162         StoreDay::save(id, &memory_cache, dec_precision);
 163         while(memory_cache.empty() == false) {
 164                 data    = memory_cache.back();
 165                 memory_cache.pop_back();
 166                 delete(data);
 167         }
 168         pthread_mutex_unlock(&plock);
 169 }
 170
 171 const DataReader *W1Device::get_device_data() {
 172         return reader;
 173 }