CDMS_PL.h

00001 int pl_next_index=-1;   
00002 uint8_t pl_main_flag=0;
00003 uint8_t PL_PREV_STATE=0x00;
00004 uint8_t POWER_LEVEL = 3;                                //Would be present in HK data extracted 
00005 uint32_t pl_block[192]={0};
00006 uint32_t pl_time;
00007 uint32_t TIME_LATEST_PL=0;
00008 uint8_t i;
00009 //extern uint8_t PL_BEE_SW_STATUS=0;
00010 
00011 //Serial pc(USBTX,USBRX);
00012 
00013 #define PL_MAIN_STATUS              0x01
00014 #define PL_LOW_POWER                0x02
00015 #define STATE_OFF                   0x00
00016 #define STATE_STANDBY               0x04
00017 #define STATE_HIBERNATE             0x08
00018 #define STATE_SCIENCE               0x0C            //also used as mask for PL_STATE
00019 #define PL_OFF                      0x00
00020 #define PL_STANDBY                  0x10
00021 #define PL_HIBERNATE                0x20
00022 #define PL_SCIENCE                  0x30
00023 #define PL_SUCCESS_I2C              0x40
00024 #define PL_ERR_I2C                  0x50
00025 #define PL_INVALID_STATE            0x60
00026 #define PL_DISABLED                 0x70            //also used as mask for PL_STATUS
00027 #define EXECUTED                    0x00000001
00028 #define RETRY                       0x00000002
00029 #define UNEXECUTED                  0x00000003      //also used as mask for EXEC_STATUS
00030 
00031 
00032 Base_tm* FCTN_CDMS_RLY_TMTC(Base_tc *tc_ptr);
00033 
00034 // waiting 1us for setup time,hold time and propagation delay
00035 #define SET_PL_BEE_OFF {\
00036     PYLD_DFF_CLK = 0;\
00037     PYLD_DFF = 0;\
00038     wait_us(1);\
00039     PYLD_DFF_CLK = 1;\
00040     wait_us(1);\
00041     PYLD_DFF_CLK = 0;\
00042     wait_us(1);\
00043 }
00044 #define SET_PL_BEE_ON {\
00045     PYLD_DFF_CLK = 0;\
00046     PYLD_DFF = 1;\
00047     wait_us(1);\
00048     PYLD_DFF_CLK = 1;\
00049     wait_us(1);\
00050     PYLD_DFF_CLK = 0;\
00051     wait_us(1);\
00052 }
00053 
00054 //TC_string[0] should not be 0x00
00055 
00056 #define SET_PL_BEE_STANDBY(tm_ptr_standby) {\
00057     Base_tc *pl_tc_standby = new Short_tc;\
00058     pl_tc_standby->next_TC = NULL;\
00059     PUTshort_or_long(pl_tc_standby,0);\
00060     PUTcrc_pass(pl_tc_standby,0x1);\
00061     PUTexec_status(pl_tc_standby,0);\
00062     pl_tc_standby->TC_string[0] = 0x01;\
00063     pl_tc_standby->TC_string[1] = 0xE1;\
00064     pl_tc_standby->TC_string[2] = 0x81;\
00065     pl_tc_standby->TC_string[3] = 0x02;\
00066     pl_tc_standby->TC_string[4] = 0;\
00067     pl_tc_standby->TC_string[5] = 0;\
00068     pl_tc_standby->TC_string[6] = 0;\
00069     pl_tc_standby->TC_string[7] = 0;\
00070     pl_tc_standby->TC_string[8] = 0;\
00071     uint16_t crc16 = crc16_gen(pl_tc_standby->TC_string, 9);\
00072     pl_tc_standby->TC_string[9]  = (uint8_t)(crc16 & 0xFF00)>>8;\
00073     pl_tc_standby->TC_string[10] = (uint8_t)(crc16 & 0x00FF);\
00074     tm_ptr_standby =  FCTN_CDMS_RLY_TMTC(pl_tc_standby);\
00075     VERIFY_TM(tm_ptr_standby);\
00076     delete pl_tc_standby;\
00077     Base_tm *temp;\
00078     temp = tm_ptr_standby;\
00079     while(tm_ptr_standby!=NULL)\
00080     {\
00081         temp = temp->next_TM;\
00082         delete tm_ptr_standby;\
00083         tm_ptr_standby = temp;\
00084     }\
00085 }
00086 
00087 //TC_string[0] should not be 0x00
00088 
00089 #define SET_PL_BEE_HIBERNATE(tm_ptr_hibernate) {\
00090     Base_tc *pl_tc_hibernate = new Short_tc;\
00091     pl_tc_hibernate->next_TC = NULL;\
00092     PUTshort_or_long(pl_tc_hibernate,0);\
00093     PUTcrc_pass(pl_tc_hibernate,0x1);\
00094     PUTexec_status(pl_tc_hibernate,0);\
00095     pl_tc_hibernate->TC_string[0] = 0x01;\
00096     pl_tc_hibernate->TC_string[1] = 0xE1;\
00097     pl_tc_hibernate->TC_string[2] = 0x81;\
00098     pl_tc_hibernate->TC_string[3] = 0x03;\
00099     pl_tc_hibernate->TC_string[4] = 0;\
00100     pl_tc_hibernate->TC_string[5] = 0;\
00101     pl_tc_hibernate->TC_string[6] = 0;\
00102     pl_tc_hibernate->TC_string[7] = 0;\
00103     pl_tc_hibernate->TC_string[8] = 0;\
00104     uint16_t crc16 = crc16_gen(pl_tc_hibernate->TC_string, 9);\
00105     pl_tc_hibernate->TC_string[9]  = (uint8_t)(crc16 & 0xFF00)>>8;\
00106     pl_tc_hibernate->TC_string[10] = (uint8_t)(crc16 & 0x00FF);\
00107     tm_ptr_hibernate =  FCTN_CDMS_RLY_TMTC(pl_tc_hibernate);\
00108     VERIFY_TM(tm_ptr_hibernate);\
00109     delete pl_tc_hibernate;\
00110     Base_tm *temp;\
00111     temp = tm_ptr_hibernate;\
00112     while(tm_ptr_hibernate!=NULL)\
00113     {\
00114         temp = temp->next_TM;\
00115         delete tm_ptr_hibernate;\
00116         tm_ptr_hibernate = temp;\
00117     }\
00118 }
00119 
00120 //TC_string[0] should not be 0x00
00121 /*
00122 PUTshort_or_long(pl_tc_science,0);\
00123     PUTcrc_pass(pl_tc_science,0x1);\
00124     PUTexec_status(pl_tc_science,0);\*/
00125     
00126 #define SET_PL_BEE_SCIENCE(tm_ptr_science) {\
00127     Base_tc *pl_tc_science = new Short_tc;\
00128     pl_tc_science->next_TC = NULL;\
00129     pl_tc_science->TC_string[0] = 0x01;\
00130     pl_tc_science->TC_string[1] = 0xE1;\
00131     pl_tc_science->TC_string[2] = 0x81;\
00132     pl_tc_science->TC_string[3] = 0x04;\
00133     pl_tc_science->TC_string[4] = 0;\
00134     pl_tc_science->TC_string[5] = 0;\
00135     pl_tc_science->TC_string[6] = 0;\
00136     pl_tc_science->TC_string[7] = 0;\
00137     pl_tc_science->TC_string[8] = 0;\
00138     uint16_t crc16 = crc16_gen(pl_tc_science->TC_string, 9);\
00139     pl_tc_science->TC_string[9]  = (uint8_t)(crc16 & 0xFF00)>>8;\
00140     pl_tc_science->TC_string[10] = (uint8_t)(crc16 & 0x00FF);\
00141     tm_ptr_science =  FCTN_CDMS_RLY_TMTC(pl_tc_science);\
00142     VERIFY_TM(tm_ptr_science);\
00143     delete pl_tc_science;\
00144     Base_tm *temp;\
00145     temp = tm_ptr_science;\
00146     while(tm_ptr_science!=NULL)\
00147     {\
00148         temp = temp->next_TM;\
00149         delete tm_ptr_science;\
00150         tm_ptr_science = temp;\
00151     }\
00152 }
00153 void print_processed_block(uint8_t index)
00154 {
00155     gPC.printf("\n\n\rBlock after processing:");
00156     gPC.printf("\n\rTime of block:");
00157     gPC.printf("\n\rYear :%d",((((pl_block[index]&0xFFFFFFF0)>>4) & 0x0C000000)>>26)+2016);
00158     gPC.printf("\tMonth  :%d",((((pl_block[index]&0xFFFFFFF0)>>4) & 0x03C00000)>>22));
00159     gPC.printf("\tDay    :%d",((((pl_block[index]&0xFFFFFFF0)>>4) & 0x003E0000)>>17));
00160     gPC.printf("\n\rHours  :%d",((((pl_block[index]&0xFFFFFFF0)>>4) & 0x0001F000)>>12));
00161     gPC.printf("\tMin    :%d",((((pl_block[index]&0xFFFFFFF0)>>4) & 0x00000FC0)>>6));
00162     gPC.printf("\tSec    :%d",(((pl_block[index]&0xFFFFFFF0)>>4) & 0x0000003F));
00163     gPC.printf("\n\rSID    :%d",(pl_block[index] & 0x0000000C)>>2);
00164     gPC.printf("\tExecution Status :%d",pl_block[index] & UNEXECUTED);
00165 }
00166 void print_exit(uint8_t* temp)
00167 {    
00168     uint8_t temp2[3];
00169     temp2[0] = (pl_main_flag&STATE_SCIENCE)>>2;
00170     temp2[1] = (pl_main_flag&PL_DISABLED)>>4;
00171     temp2[2] = (PL_PREV_STATE & STATE_SCIENCE)>>2;
00172     gPC.printf("\n\rAt exit");
00173     char state[][17] = {"STATE_OFF","STATE_STANDBY","STATE_HIBERNATE","STATE_SCIENCE"};
00174     char status[][17] = {"PL_OFF","PL_STANDBY","PL_HIBERNATE","PL_SCIENCE","PL_SUCCESS_I2C","PL_ERR_I2C","PL_INVALID_STATE","PL_DISABLED"};
00175     gPC.printf("\n\rPL_state:%s -> %s",state[(uint8_t)temp[0]],state[(uint8_t)temp2[0]]);
00176     gPC.printf("\n\rPL_status:%s -> %s",status[(uint8_t)temp[1]],status[(uint8_t)temp2[1]]);
00177     gPC.printf("\n\rPL_PREV_state:%s -> %s",state[(uint8_t)temp[2]],state[(uint8_t)temp2[2]]);
00178 }
00179 void VERIFY_TM(Base_tm *tm_ptr)
00180 {
00181     uint8_t temp = tm_ptr->TM_string[2];            //Obatining ACK_CODE
00182     if(GETshort_or_long_tm(tm_ptr)==1)              //short TM
00183     {
00184         gPC.printf("\n\rSHORT TM received");
00185         uint16_t crc16 = crc16_gen(tm_ptr->TM_string, 11);        
00186         if(tm_ptr->TM_string[12]==((uint8_t)(crc16 & 0x00FF)) && tm_ptr->TM_string[11]==((uint8_t)((crc16 & 0xFF00)>>8)))        
00187         {            
00188             if(temp!=0x00 && temp!=0x01 && temp!=0x02 && temp!=0x03 && temp!=0x84 && temp!=0x85)
00189             {
00190                 gPC.printf("\n\rTime_Latest_PL Updated");
00191                 TIME_LATEST_PL = pl_time;                  //update latest time when I2C communication was successful
00192             }
00193             if(temp==0xA0 || temp==0xC0)
00194             {
00195                 gPC.printf("\n\rACK_CODE Success");
00196                 if(temp==0xA0)
00197                     gPC.printf("\n\rACK_CODE = 0x%02X",temp);
00198                 else
00199                     gPC.printf("\n\rACK_CODE = 0x%02X",temp);
00200                 pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00201                 pl_main_flag |= PL_SUCCESS_I2C;
00202                 pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00203                 pl_block[pl_next_index-1] |= EXECUTED;
00204             }
00205             else
00206             {
00207                 gPC.printf("\n\rACK_CODE failure (0x%02X)",temp);
00208                 //gPC.printf("\n\rACK_CODE = 0x%02X",temp);
00209                 pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00210                 pl_main_flag |= PL_ERR_I2C;
00211                 pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00212                 pl_block[pl_next_index-1] |= RETRY;   
00213             }
00214         }
00215         else
00216         {
00217             gPC.printf("\n\rShort_TM CRC failed");
00218             pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00219             pl_main_flag |= PL_ERR_I2C;
00220             pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00221             pl_block[pl_next_index-1] |= RETRY;
00222         }
00223     }
00224     else if(GETshort_or_long_tm(tm_ptr)==0)                  //LONG TM
00225     {
00226         gPC.printf("\n\rLONG TM received");
00227         uint16_t crc16 = crc16_gen(tm_ptr->TM_string,132);        
00228         if(tm_ptr->TM_string[133]==((uint8_t)(crc16 & 0x00FF)) && tm_ptr->TM_string[132]==((uint8_t)((crc16 & 0xFF00)>>8)))        
00229         {
00230             if(temp!=0x00 && temp!=0x01 && temp!=0x02 && temp!=0x03 && temp!=0x84 && temp!=0x85)
00231             {
00232                 gPC.printf("\n\rTime_Latest_PL Updated");
00233                 TIME_LATEST_PL = pl_time;                  //update latest time when I2C communication was successful
00234             }
00235             if(temp==0xA0 || temp==0xC0)
00236             {
00237                 gPC.printf("\n\rACK_CODE Success");
00238                 if(temp==0xA0)
00239                     gPC.printf("\n\rACK_CODE = 0x%02X",temp);
00240                 else
00241                     gPC.printf("\n\rACK_CODE = 0x%02X",temp);
00242                 pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00243                 pl_main_flag |= PL_SUCCESS_I2C;
00244                 pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00245                 pl_block[pl_next_index-1] |= EXECUTED;
00246             }
00247             else
00248             {
00249                 gPC.printf("\n\rACK_CODE failure (0x%02X)",temp);
00250                 pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00251                 pl_main_flag |= PL_ERR_I2C;
00252                 pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00253                 pl_block[pl_next_index-1] |= RETRY;   
00254             }   
00255         }
00256         else
00257         {
00258             gPC.printf("\n\rLong_TM CRC failed");
00259             pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00260             pl_main_flag |= PL_ERR_I2C;        
00261             pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00262             pl_block[pl_next_index-1] |= RETRY;   
00263         }
00264     }    
00265 }
00266 void test1(uint8_t t)
00267 {
00268     //Output should be PL_STATUS = PL_DISABLED
00269     if(t!=0)
00270     {
00271         gPC.printf("\n\rTesting OC protection");
00272         PL_BEE_SW_STATUS = 2;   //OC protection
00273     }
00274 }
00275 void test2(uint8_t t)
00276 {
00277     //output should be same as test1()
00278     if(t!=0)    
00279     {
00280         gPC.printf("\n\rTesting Deviced Disabled case");
00281         PL_BEE_SW_STATUS = 3;   //Device DISABLED 
00282     }
00283 }
00284 void test3(uint8_t t)
00285 {
00286     if(t!=0)
00287     {
00288         gPC.printf("\n\rTesting RTC failed case");
00289         pl_time = 0;            //RTC failed
00290     }
00291 }
00292 /*void test4(uint8_t t)
00293 {
00294     if(t!=0)
00295     {
00296         gPC.printf("\n\rTesting No future blocks available");
00297         schedule1[0] = {0,0,0,0,0,0,0,0};
00298     }
00299 }*/
00300 void FCTN_CDMS_PL_MAIN(void const *args)
00301 {
00302     uint8_t temp[3];
00303     pl_main_flag|=PL_MAIN_STATUS;                       //Setting PL_MAIN_STATUS
00304     PL_MAIN_COUNTER++;                                  
00305     pl_main_flag&=~(PL_LOW_POWER);                      //Clearing PL_LOW_POWER
00306     temp[0] = (pl_main_flag&STATE_SCIENCE)>>2;
00307     temp[1] = (pl_main_flag&PL_DISABLED)>>4;
00308     temp[2] = (PL_PREV_STATE & STATE_SCIENCE)>>2;
00309     //test2(1);
00310 
00311     if(PL_BEE_SW_STATUS==2 || PL_BEE_SW_STATUS==3)
00312     {
00313         gPC.printf("\n\rDevice Disabled or OC Fault");
00314         pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00315         pl_main_flag |= PL_DISABLED;                        //setting PL_STATUS as PL_DISABLED
00316         pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);    //Clearing pl_main status
00317         print_exit(temp);
00318         return;
00319     }
00320     PL_PREV_STATE = (pl_main_flag & STATE_SCIENCE);         //saving current pl_state
00321     uint64_t temp_time;
00322     temp_time=FCTN_CDMS_RD_RTC();
00323     pl_time = (uint32_t)((temp_time>>7) & 0x000000000FFFFFFF);
00324 
00325     //call test3() here
00326     //test3(1);
00327 
00328     //gPC.printf("\n\rprev_state    :%d",(PL_PREV_STATE)>>4);
00329     gPC.printf("\n\n\rtTime_RTC:");
00330     gPC.printf("\n\rYear :%d\t",((pl_time & 0x0C000000)>>26)+2016);
00331     gPC.printf("Month :%d\t",((pl_time & 0x03C00000)>>22));
00332     gPC.printf("Day :%d",((pl_time & 0x003E0000)>>17));
00333     gPC.printf("\n\rHours :%d",((pl_time & 0x0001F000)>>12));
00334     gPC.printf("\tMin :%d",((pl_time & 0x00000FC0)>>6));
00335     gPC.printf("\t\tSec :%d",(pl_time & 0x0000003F));
00336     if(pl_time!=0)                             //RTC read successful 
00337     {
00338         // run the loop until end of schedule is reached or month and day are both zeros or future block is found
00339         gPC.printf("\n\rRTC read success");
00340         for(i=0;(i<192)&&(((uint16_t)((pl_block[i] & 0x3FE00000)>>21))!=0);i++)     
00341         {   
00342             if(((pl_block[i]>>4) & 0x0FFFFFFF)>pl_time)     //Checking for future blocks       
00343             {
00344                 pl_next_index=i;
00345                 gPC.printf("\n\rFuture block found at index = %d",pl_next_index);
00346                 break;
00347             }
00348         }
00349     }
00350     if((pl_next_index==-1) || pl_time==0)           //RTC read failed or Future block not found
00351     {       
00352         if(PL_PREV_STATE==STATE_SCIENCE)
00353         {
00354             pl_main_flag  = pl_main_flag & (~STATE_SCIENCE);
00355             pl_main_flag |= STATE_HIBERNATE;
00356         } 
00357         else
00358         {                        
00359             pl_main_flag  = pl_main_flag & (~STATE_SCIENCE);
00360             pl_main_flag |= PL_PREV_STATE;
00361         }        
00362         if(pl_time==0)
00363         {
00364             gPC.printf("\n\rRTC read failed");
00365         }
00366         if(pl_next_index==-1)
00367         {
00368             gPC.printf("\n\rFuture block not found");
00369             gPC.printf("\n\rpl_next_index = %d",pl_next_index);
00370         }
00371         gPC.printf("\n\rNew pl_state  = %d",(pl_main_flag&(~STATE_SCIENCE))>>2);
00372     }           
00373     
00374     //Processing the PL schedule
00375     if(((pl_block[pl_next_index-1] & UNEXECUTED)==3)||((pl_block[pl_next_index-1] & UNEXECUTED)==2))
00376     {        
00377         if(((pl_block[pl_next_index-1] & UNEXECUTED)==3))
00378             gPC.printf("\n\rElapsed blocked not executed");
00379         else
00380             gPC.printf("\n\rElapsed block marked for retry");
00381 
00382         gPC.printf("\n\r Retrieving pl_state from schedule");
00383         if((pl_block[pl_next_index-1] & 0x0000000C)==0)                
00384         {            
00385             pl_main_flag  = pl_main_flag & (~STATE_SCIENCE);
00386             pl_main_flag |= STATE_OFF;
00387         }
00388         if((pl_block[pl_next_index-1] & 0x0000000C)==4)
00389         {
00390             pl_main_flag  = pl_main_flag & (~STATE_SCIENCE);
00391             pl_main_flag |= STATE_STANDBY;
00392         }
00393         if((pl_block[pl_next_index-1] & 0x0000000C)==8)
00394         {
00395             pl_main_flag  = pl_main_flag & (~STATE_SCIENCE);
00396             pl_main_flag |= STATE_HIBERNATE;
00397         }
00398         if((pl_block[pl_next_index-1] & 0x0000000C)==12)
00399         {
00400             pl_main_flag  = pl_main_flag & (~STATE_SCIENCE);
00401             pl_main_flag |= STATE_SCIENCE;
00402         }
00403     }
00404     else if((pl_block[pl_next_index-1] & UNEXECUTED)==1)
00405     {
00406         gPC.printf("\n\rElapsed block is executed");
00407         pl_main_flag = pl_main_flag & (~PL_MAIN_STATUS);                  //Clearing pl_main status
00408         print_exit(temp);
00409         return;   
00410     }      
00411     else if((pl_block[pl_next_index-1] & UNEXECUTED)==0)  
00412     {
00413         gPC.printf("\n\rEmpty Schedule Block");        
00414         pl_main_flag = pl_main_flag & (~PL_MAIN_STATUS);                  //Clearing pl_main status
00415         print_exit(temp);
00416         return;
00417     }
00418     switch(pl_main_flag & STATE_SCIENCE)                                  //Checking PL_STATE
00419     {
00420         case STATE_OFF: 
00421         {
00422             gPC.printf("\n\rEntered PL_OFF case");
00423             if(PL_BEE_SW_STATUS!=0) 
00424             {
00425                 gPC.printf("\n\rCommanding PL_BEE to go to Standby State");
00426                 Base_tm *tm_ptr_standby;
00427                 SET_PL_BEE_STANDBY(tm_ptr_standby);                             //No ack needed now
00428                 gPC.printf("\n\rPowering OFF PL_BEE");
00429                 SET_PL_BEE_OFF;
00430                 PL_BEE_SW_STATUS=0;    
00431             }           
00432             pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00433             pl_main_flag |= PL_OFF;    
00434             pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00435             pl_block[pl_next_index-1] |= EXECUTED;                              
00436             pl_main_flag = pl_main_flag & (~PL_MAIN_STATUS);                    //Clearing PL_MAIN_STATUS
00437             print_processed_block(pl_next_index-1);
00438             print_exit(temp);
00439             return;
00440         }
00441         case STATE_STANDBY: 
00442         {            
00443             gPC.printf("\n\rEntered PL_STANDBY case");
00444             if(PL_BEE_SW_STATUS==0) 
00445             {
00446                 gPC.printf("\n\rPowering on PL_BEE");
00447                 SET_PL_BEE_ON;
00448                 PL_BEE_SW_STATUS=1;
00449             }
00450             gPC.printf("\n\rCommanding PL_BEE to go to Standby State");  
00451             Base_tm *tm_ptr_standby;
00452             SET_PL_BEE_STANDBY(tm_ptr_standby);
00453             if((pl_main_flag & PL_DISABLED)==PL_SUCCESS_I2C)
00454             {
00455                 pl_main_flag = pl_main_flag & (~PL_DISABLED);
00456                 pl_main_flag |= PL_STANDBY; 
00457             }        
00458             pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS 
00459             print_processed_block(pl_next_index-1);
00460             print_exit(temp);
00461             return;                                                   
00462                                                                             //////DELETE THE TM AND TC LATER
00463         }
00464         case STATE_HIBERNATE: 
00465         {
00466             gPC.printf("\n\rEntered PL_HIBERNATE case");
00467             if(POWER_LEVEL==2 || POWER_LEVEL==3 || POWER_LEVEL==0)
00468             {                
00469                 if(PL_BEE_SW_STATUS==0) 
00470                 {
00471                     gPC.printf("Powering on PL_BEE\r\n");                    
00472                     SET_PL_BEE_ON;
00473                     PL_BEE_SW_STATUS=1;
00474                 }
00475                 gPC.printf("\n\rCommanding PL_BEE to go to Hibernate State");  
00476                 Base_tm *tm_ptr_hibernate;
00477                 SET_PL_BEE_HIBERNATE(tm_ptr_hibernate);
00478                 if((pl_main_flag & PL_DISABLED)==PL_SUCCESS_I2C)
00479                 {
00480                     pl_main_flag = pl_main_flag & (~PL_DISABLED);
00481                     pl_main_flag |= PL_HIBERNATE; 
00482                 }
00483             }
00484             else 
00485             {
00486                 pl_main_flag |= PL_LOW_POWER;
00487                 if(PL_BEE_SW_STATUS==0) 
00488                 {
00489                     gPC.printf("\n\rPowering on PL_BEE");
00490                     SET_PL_BEE_ON;
00491                     PL_BEE_SW_STATUS=1;
00492                 }
00493                 gPC.printf("\n\rCommanding PL_BEE to go to Standby State");
00494                 Base_tm *tm_ptr_standby;
00495                 SET_PL_BEE_STANDBY(tm_ptr_standby);
00496                 if((pl_main_flag & PL_DISABLED)==PL_SUCCESS_I2C)
00497                 {
00498                     pl_main_flag = pl_main_flag & (~PL_DISABLED);
00499                     pl_main_flag |= PL_STANDBY; 
00500                 }        
00501                 pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS 
00502                 print_processed_block(pl_next_index-1);
00503                 print_exit(temp);
00504                 return;
00505                                                                                 //////DELETE THE TM AND TC LATER
00506             }            
00507             pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS
00508             print_processed_block(pl_next_index-1);
00509             print_exit(temp);
00510             return;
00511                                                                             //////DELETE THE TM LATER
00512         }
00513         case STATE_SCIENCE:
00514         {
00515             gPC.printf("\n\rEntered PL_SCIENCE case");
00516             if(POWER_LEVEL==3 || POWER_LEVEL==0)                            //POWER_LEVEL = 0 = NA
00517             {
00518                 gPC.printf("\n\rPOWER_LEVEL = 3 or NA");
00519                 if(PL_BEE_SW_STATUS==0)
00520                 {
00521                     gPC.printf("\n\rPowering on PL_BEE");
00522                     SET_PL_BEE_ON;
00523                     PL_BEE_SW_STATUS=1;
00524                 }
00525                 gPC.printf("\n\rCommanding PL_BEE to go to Science State");  
00526                 Base_tm *tm_ptr_science;
00527                 SET_PL_BEE_SCIENCE(tm_ptr_science);
00528                 if((pl_main_flag & PL_DISABLED)==PL_SUCCESS_I2C)
00529                 {
00530                     pl_main_flag = pl_main_flag & (~PL_DISABLED);
00531                     pl_main_flag |= PL_SCIENCE; 
00532                 }
00533                 pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS
00534                 print_processed_block(pl_next_index-1);
00535                 print_exit(temp);
00536                 return;
00537             }
00538             else
00539             {   
00540                 gPC.printf("\n\rPower level = 2,3 or NA");
00541                 pl_main_flag |= PL_LOW_POWER;
00542                 if(POWER_LEVEL==2 || POWER_LEVEL==3 || POWER_LEVEL==0)
00543                 {                
00544                     if(PL_BEE_SW_STATUS==0) 
00545                     {
00546                         gPC.printf("\n\rPowering on PL_BEE");
00547                         SET_PL_BEE_ON;
00548                         PL_BEE_SW_STATUS=1;
00549                     }
00550                     gPC.printf("\n\rCommanding PL_BEE to go to Hibernate State");  
00551                     Base_tm *tm_ptr_hibernate;
00552                     SET_PL_BEE_HIBERNATE(tm_ptr_hibernate);
00553                     if((pl_main_flag & PL_DISABLED)==PL_SUCCESS_I2C)
00554                     {
00555                         pl_main_flag = pl_main_flag & (~PL_DISABLED);
00556                         pl_main_flag |= PL_HIBERNATE; 
00557                     }
00558                 }
00559                 else 
00560                 {
00561                     pl_main_flag |= PL_LOW_POWER;
00562                     if(PL_BEE_SW_STATUS==0) 
00563                     {
00564                         gPC.printf("\n\rPowering on PL_BEE");
00565                         SET_PL_BEE_ON;
00566                         PL_BEE_SW_STATUS=1;
00567                     }
00568                     gPC.printf("\n\rCommanding PL_BEE to go to Standby State");  
00569                     Base_tm *tm_ptr_standby;
00570                     SET_PL_BEE_STANDBY(tm_ptr_standby);
00571                     if((pl_main_flag & PL_DISABLED)==PL_SUCCESS_I2C)
00572                     {
00573                         pl_main_flag = pl_main_flag & (~PL_DISABLED);
00574                         pl_main_flag |= PL_STANDBY; 
00575                     }        
00576                     pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS 
00577                     print_processed_block(pl_next_index-1);
00578                     print_exit(temp);
00579                     return;                                               
00580                                                                                     //////DELETE THE TM AND TC LATER
00581                 }            
00582                 pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS
00583                 print_processed_block(pl_next_index-1);
00584                 print_exit(temp);
00585                 return;
00586                                                                                 //////DELETE THE TM LATER
00587             }
00588         }
00589         default:
00590         {
00591             gPC.printf("\n\rInvalid PL_STATE in block at index = %d",pl_next_index-1);
00592             pl_main_flag  = pl_main_flag & (~PL_DISABLED);
00593             pl_main_flag |= PL_INVALID_STATE;
00594             pl_block[pl_next_index-1] &= (~UNEXECUTED);                         //changing exec_status                    
00595             pl_block[pl_next_index-1] |= EXECUTED;
00596             pl_main_flag  = pl_main_flag & (~PL_MAIN_STATUS);               //Clearing PL_MAIN_STATUS
00597             print_processed_block(pl_next_index-1);
00598             print_exit(temp);
00599             return;
00600         }
00601     }    
00602 }