DeviceRepeater.cpp

00001 /** --- Includes --- */
00002 #include "mbed.h"
00003 #include "global.h"
00004 #include "string.h"
00005 #include "DeviceRepeater.h"
00006 
00007 void repeater_basetick(void)
00008 {
00009     pDevRept->tick();
00010 }
00011 
00012 DeviceRepeater::DeviceRepeater(int setDeviceID, DeviceDriver *setDriver)
00013 {
00014     deviceID = setDeviceID;
00015     pClock = new Ticker();
00016     selected_id = NOT_ID_SELECTED;
00017     pDriver = setDriver;
00018     stat = DEV_NOT_INIT;
00019     repeat_max_count = DEFAULT_REPEAT_MAX_COUNT;
00020     repeat_stride_sec = DEFAULT_REPEAT_STRIDE;
00021     repeat_singleshot = DEFAULT_REPEAT_SINGLESHOT;
00022 }
00023 
00024 bool DeviceRepeater::readyToStart(void)
00025 {
00026     bool ret;
00027     switch(stat) {
00028     case DEV_READY:
00029         ret = true;
00030         break;
00031     case DEV_NOT_INIT:
00032         ret = true;
00033         break;
00034     case DEV_RUNNING:
00035         ret = false;
00036         break;
00037     default:
00038         ret = false;
00039         break;
00040     }
00041     return ret;
00042 }
00043 
00044 bool DeviceRepeater::setRepeatCount(int maxcount)
00045 {
00046     /* never accept in Not Ready To Run */
00047     if (!this->readyToStart()) {
00048         return false;
00049     }
00050     /* invalid arguments */
00051     if (maxcount < 0) {
00052         return false;
00053     }
00054     repeat_max_count = maxcount;
00055     return true;    
00056 }
00057 
00058 bool DeviceRepeater::setRepeatStride(int sec)
00059 {
00060     /* never accept in Not Ready To Run */
00061     if (!this->readyToStart()) {
00062         return false;
00063     }
00064     /* invalid arguments */
00065     if (sec < 0) {
00066         return false;
00067     } else if (sec == 0) {
00068         return false;
00069     }
00070     repeat_stride_sec = sec;
00071     return true;
00072 }
00073 
00074 bool DeviceRepeater::setRepeatSingleShot(bool setMode)
00075 {
00076     /* never accept in Not Ready To Run */
00077     if (!this->readyToStart()) {
00078         return false;
00079     }
00080     /* TODO */
00081     repeat_singleshot = setMode; 
00082     return true;
00083 }
00084 
00085 bool DeviceRepeater::start(void)
00086 {
00087     bool ret;
00088     switch(stat) {
00089     case DEV_READY:
00090         break;
00091     case DEV_NOT_INIT:
00092         ret = this->init();
00093         if (ret != true) {
00094             return false;
00095         }
00096         break;
00097     case DEV_RUNNING:
00098         return false;
00099     case DEV_FATAL:
00100     default:
00101         return false;
00102     }
00103     // Device is in DEV_READY
00104 
00105     /* TODO - add callback for changing READY to RUNNING */
00106     pDriver->ready2run();
00107     pSds->syncFile();
00108     
00109     // start Runnig
00110     // Device is in DEV_RUNNING
00111     stat = DEV_RUNNING;
00112     repeat_remain_cnt = repeat_max_count;
00113     repeat_remain_sec = repeat_stride_sec;
00114     pClock->attach(repeater_basetick, 1.0);
00115     return true;
00116 }
00117 
00118 bool DeviceRepeater::stop(void)
00119 {
00120     if (stat != DEV_RUNNING) {
00121         return false;
00122     }
00123     
00124     /* Delaied Stop */
00125     stat = DEV_REQ_STOP;
00126     repeat_remain_sec = 0;
00127     stat = DEV_READY;
00128     return true;
00129 }
00130 
00131 void DeviceRepeater::tick(void)
00132 {
00133     if (stat != DEV_RUNNING) {
00134         /* Delaied Stop */
00135         if (stat == DEV_REQ_STOP) {
00136             /*****************************************************/
00137             /* TODO - add callback for changing RUNNING to READY */
00138             /*****************************************************/
00139             pDriver->run2ready();
00140             pSds->syncFile();
00141             repeat_remain_sec = 0;
00142             stat = DEV_READY;
00143             return;
00144         }        
00145         return;
00146     }
00147     if (repeat_remain_sec > 0) {
00148         repeat_remain_sec--;
00149     }
00150     if (repeat_remain_sec == 0) {
00151         bool procRun;
00152         FILE *pSDFile = pSds->getFilePointer();
00153         /*****************************************************/
00154         /* TODO - kick Senser and send XFD/XDS Data */
00155         /*****************************************************/
00156         /** Sensing and Sending Data **/
00157         procRun = pDriver->exec(deviceID, pUR->getCurrentUart(), pSDFile);
00158         pSds->syncFile();
00159         if (repeat_singleshot) {
00160             /* Check Exec Sigle On */
00161             if (procRun == true) {
00162                 /* Already - Executed Mesurement in exec */
00163                 /** GOTO Shutdown */
00164                 /* STOP ticking (0->1) */
00165                 /*****************************************************/
00166                 /* TODO - add callback for changing RUNNING to READY */
00167                 /*****************************************************/
00168                 repeat_remain_cnt = 0;
00169                 pDriver->run2ready();
00170                 pSds->syncFile();
00171                 repeat_remain_sec = 0;
00172                 stat = DEV_READY;
00173                 pClock->detach();
00174                 return;
00175             } else {
00176                 /* Not Yet - NO Execution in exec */
00177             }
00178         }        
00179     }
00180     if (repeat_remain_sec <= 0) {
00181         if (repeat_remain_cnt > 0) {
00182             repeat_remain_cnt--;
00183             if (repeat_remain_cnt == 0) {
00184                 /* STOP ticking (0->1) */
00185                 /*****************************************************/
00186                 /* TODO - add callback for changing RUNNING to READY */
00187                 /*****************************************************/
00188                 pDriver->run2ready();
00189                 pSds->syncFile();
00190                 repeat_remain_sec = 0;
00191                 stat = DEV_READY;
00192                 pClock->detach();
00193                 return;
00194             }
00195             /* REFILL */
00196         } else if (repeat_remain_cnt == 0) {
00197             /* REFILL */
00198         } else {
00199             /*****************************************************/
00200             /* TODO : FATAL */
00201             /*****************************************************/
00202             while(1);
00203         }
00204         repeat_remain_sec = repeat_stride_sec;
00205     }
00206 }
00207 
00208 bool DeviceRepeater::init(void)
00209 {
00210     int ret;
00211     selected_id = NOT_ID_SELECTED;
00212     ret = pDriver->init();
00213     if (ret == 0) {
00214         stat = DEV_READY;
00215     } else {
00216         stat = DEV_FATAL;
00217     }
00218     return (stat == DEV_READY)? true : false;
00219 }
00220 
00221 bool DeviceRepeater::resetAllStatus(void)
00222 {
00223     /* TODO */
00224     int ret;
00225     ret = pDriver->reset();
00226     if (ret == 0) {
00227         /* SUCCESS */
00228         /* TODO */  
00229     } else {
00230         /* ERROR */
00231         /* TODO */
00232     }
00233     return false;
00234 }
00235 
00236 bool DeviceRepeater::setConfigId(int id)
00237 {
00238     /* never accept in Not Ready To Run */
00239     if (!this->readyToStart()) {
00240         return false;
00241     }
00242     if (selected_id != NOT_ID_SELECTED) {
00243         return false;
00244     }
00245     selected_id = id;
00246     return true;
00247 }
00248 
00249 bool DeviceRepeater::setConfigValue(int setValue)
00250 {
00251     bool ret;
00252     /* never accept in Not Ready To Run */
00253     if (!this->readyToStart()) {
00254         return false;
00255     }
00256     /* not set config ID before Set */
00257     if (selected_id == NOT_ID_SELECTED) {
00258         return false;
00259     }
00260     ret = pDriver->set_config(selected_id, setValue);
00261     selected_id = NOT_ID_SELECTED;
00262     return ret;
00263 }
00264 
00265 bool DeviceRepeater::getConfigValue(int *retValue)
00266 {
00267     bool ret;
00268     /* never accept in Not Ready To Run */
00269     if (!this->readyToStart()) {
00270         return false;
00271     }
00272     /* not set config ID before Get */
00273     if (selected_id == NOT_ID_SELECTED) {
00274         return false;
00275     }
00276     ret = pDriver->get_config(selected_id, retValue);
00277     selected_id = NOT_ID_SELECTED;
00278     return ret;
00279 }