src_test/test_w1_datalog_write.cc

   1 /*
   2  * test_w1.cc
   3  *
   4  *  Created on: Oct 20, 2010
   5  *      Author: lamikr
   6  */
   7 #include <list>
   8 #include <string>
   9 #include <iostream>
  10
  11 #include <errno.h>
  12 #include <stdlib.h>
  13
  14 #include <plp/log.h>
  15
  16 #include "DeviceConfig.hh"
  17 #include "Factory.hh"
  18
  19 using namespace w1;
  20 using namespace std;
  21
  22 #define DEFAULT_READ_INTERVAL_SECONDS   600
  23 #define DEFAULT_SAVE_INTERVAL_COUNT     5
  24 #define DEFAULT_MAX_READ_COUNT          -1
  25
  26 bool try_parse_long(const char *str, long *result) {
  27         int     new_result;
  28         char    *endptr;
  29         bool    ret_val;
  30
  31         ret_val         = false;
  32         errno           = 0;
  33         new_result      = strtol(str, &endptr, 10);
  34         if (errno != 0) {
  35                 log_error("invalid input %s, could not convert to integer.\n", str);
  36         }
  37         else {
  38                 if (endptr == str) {
  39                         log_error("invalid input %s, could not convert to integer.\n", str);
  40                 }
  41                 else {
  42                         *result = new_result;
  43                         ret_val = true;
  44                 }
  45         }
  46         return ret_val;
  47 }
  48
  49 int main(int argc, char** argv) {
  50         list<W1Device *>                device_list;
  51         int                             read_count_afer_save;
  52         int                             read_count_total;
  53         long                            cnt_max_scans;
  54         long                            read_interval_seconds;
  55         long                            save_interval_count;
  56         string                          loc;
  57         W1Device                        *device;
  58         list<W1Device *>::iterator      iter;
  59
  60         // default values than can be overwritten with parameters
  61         loc     = "/tmp/w1data";
  62         read_interval_seconds   = DEFAULT_READ_INTERVAL_SECONDS;
  63         save_interval_count     = DEFAULT_SAVE_INTERVAL_COUNT;
  64         cnt_max_scans           = DEFAULT_MAX_READ_COUNT;
  65         if (argc > 1) {
  66                 loc     = argv[1];
  67         }
  68         else {
  69                 log_info("no parameter given using default values:\n");
  70                 log_info("\ttest_w1_datalog_write %s %ld %ld %ld\n\n", loc.c_str(), read_interval_seconds, save_interval_count, cnt_max_scans);
  71                 log_info("usage:\n\ttest_w1_datalog_write <result_save_path> <read_interval_seconds> <save_interval_count> <max_read_count>\n");
  72                 log_info("\tsave_interval_count == -1: do not save data that is read\n");
  73                 log_info("\tmax_read_count == -1: read devices until application is terminated\n\n");
  74         }
  75         if (argc > 2) {
  76                 try_parse_long(argv[2], &read_interval_seconds);
  77         }
  78         if (argc > 3) {
  79                 try_parse_long(argv[3], &save_interval_count);
  80         }
  81         if (argc > 4) {
  82                 try_parse_long(argv[4], &cnt_max_scans);
  83         }
  84         log_info("searching 1-wire devices\n");
  85         if (read_interval_seconds == DEFAULT_READ_INTERVAL_SECONDS) {
  86                 log_info("\tdevice read interval: %ld seconds (default value)\n", read_interval_seconds);
  87         }
  88         else {
  89                 log_info("\tdevice read interval: %ld seconds\n", read_interval_seconds);
  90         }
  91         if (save_interval_count != -1) {
  92                 if (save_interval_count == DEFAULT_SAVE_INTERVAL_COUNT) {
  93                         log_info("\tsave interval: %ld (default value)\n", save_interval_count);
  94                 }
  95                 else {
  96                         log_info("\tsave interval: %ld\n", save_interval_count);
  97                 }
  98                 log_info("\tdata save dir: %s\n", loc.c_str());
  99         }
 100         else {
 101                 log_info("\tresults are not saved\n");
 102         }
 103         if (cnt_max_scans == DEFAULT_MAX_READ_COUNT) {
 104                 log_info("\tmax read count: %ld (default value, devices will be read until application is terminated)\n\n", cnt_max_scans);
 105         }
 106         else {
 107                 log_info("\tmax read count: %ld\n\n", cnt_max_scans);
 108         }
 109         DeviceConfig::set_base_dir_name(loc);
 110         device_list             = Factory::get_device_list();
 111         read_count_afer_save    = 0;
 112         read_count_total        = 0;
 113         if (device_list.size() > 0) {
 114                 while(1) {
 115                         read_count_afer_save++;
 116                         read_count_total++;
 117                         if ((cnt_max_scans != -1) &&
 118                             (read_count_total > cnt_max_scans)) {
 119                                 log_info("closing the application, max read count reached. (%ld)\n", cnt_max_scans);
 120                                 break;
 121                         }
 122                         for(iter = device_list.begin(); iter != device_list.end(); iter++) {
 123                                 device = (W1Device *)*iter;
 124                                 device->printout();
 125                                 sleep(1);
 126                                 if ((save_interval_count != -1) &&
 127                                     (read_count_afer_save >= save_interval_count)) {
 128                                         device->save_data();
 129                                 }
 130                         }
 131                         sleep(read_interval_seconds);
 132                         if ((save_interval_count != -1) &&
 133                             (read_count_afer_save >= save_interval_count)) {
 134                                 read_count_afer_save = 0;
 135                         }
 136                 }
 137         }
 138         else {
 139                 log_debug("could not find 1-wire devices.\n");
 140         }
 141         while (device_list.empty() == false) {
 142                 device  = device_list.back();
 143                 device_list.pop_back();
 144                 delete(device);
 145         }
 146         return 0;
 147 }