CDMS_HK.h

00001 void FCTN_CDMS_HK_MAIN();
00002 void FCTN_CDMS_HK();
00003 void VERIFY_COMRX();
00004 void VERIFY_RTC();
00005 void CDMS_HK_SD();
00006 void HANDLE_HW_FAULTS();
00007 void HANDLE_HW_FAULT_SD();
00008 void HANDLE_HW_FAULT_BAE();
00009 void HANDLE_HW_FAULT_PL();
00010 void FUNC_CDMS_GPIO_STATUS();
00011 void minMaxHkData();
00012 void COLLECT_CDMS_RAM();
00013 
00014 extern uint8_t beacon_array[134];
00015 
00016 AnalogIn TempInput(PIN27);          // Input from Current Multiplexer
00017 AnalogIn CDMS_temp_sensor(PIN53);
00018 AnalogIn COMRX_RSSI_VOLTAGE(PIN70);
00019 AnalogIn EPS_BTRY_VOLT (PIN54);
00020 
00021 DigitalOut SelectLinec3 (PIN79); // MSB of Select Lines
00022 DigitalOut SelectLinec2 (PIN78);
00023 DigitalOut SelectLinec1 (PIN76);
00024 DigitalOut SelectLinec0 (PIN77); // LSB of Select Lines
00025 
00026 /*
00027 Before SBC. To be restored in FM model
00028 DigitalOut SelectLinec1 (PIN77);
00029 DigitalOut SelectLinec0 (PIN76); // LSB of Select Lines
00030 */
00031 
00032 Convolution CDMS_HEALTH;
00033 Convolution BAE_HEALTH;
00034 unsigned char CDMS_HK_FRAME[134] = {0};
00035 char BAE_HK[134] = {0};
00036 uint8_t convoluted_CDMS_HK[270];
00037 uint8_t interleave_CDMS_HK[288];
00038 uint8_t CDMS_HEALTH_FINAL[512] = {0};
00039 uint8_t convoluted_BAE_HK[270];
00040 uint8_t interleave_BAE_HK[288];
00041 uint8_t BAE_HEALTH_FINAL[512] = {0};
00042 unsigned char BAE_HK_FRAME[134] = {0};
00043 
00044 
00045 
00046 void FCTN_CDMS_HK_MAIN(void const *args)
00047 {
00048     uint8_t sd_stat = 0;
00049     uint8_t hk_count=0;
00050     while(1) {
00051         gPC.printf("waiting for HK sig\n\r");
00052         gHK_THREAD->signal_wait(HK_SIGNAL);
00053         gPC.printf("checking mutex in HK\n\r");
00054         gMutex.lock();
00055       SCI_LED1 =1;
00056         gPC.printf("locked mutex, entered in HK \n\r");
00057         if(hk_count == 1 || hk_count == 2) {
00058             FCTN_CDMS_PL_MAIN((void const *)NULL);
00059             hk_count--;
00060             gPC.printf("releasing mutex for HK_PL \n\r");
00061            SCI_LED1 =0;
00062            PL_GPIO_1_STATUS=0;
00063             gMutex.unlock();
00064             continue;
00065         } else if(hk_count == 0) {
00066             FCTN_CDMS_PL_MAIN((void const *)NULL);
00067             hk_count = 2;
00068         }
00069           
00070         //gPC.printf("\n\r%d\n",CDMS_WR_SD_FAULT_COUNTER);
00071         if(EN_CDMS_HK == 0x00)
00072             continue;
00073         CDMS_HK_MAIN_STATUS = 0x01;
00074         CDMS_HK_MAIN_COUNTER++;
00075 
00076        
00077         FCTN_CDMS_HK();         //collects temperatures
00078        
00079         if(!COM_RSSI_SET)
00080         {
00081             RSSI_VOLTAGE = COMRX_RSSI_VOLTAGE.read() * 3.3;//to be checked
00082         }
00083         else COM_RSSI_SET = 0;
00084         //VERIFY_COMRX();
00085         VERIFY_RTC();
00086         HANDLE_HW_FAULTS();
00087         FUNC_CDMS_GPIO_STATUS();
00088 
00089         uint8_t CDMS_quant[20];
00090         CDMS_quant[0]= COM_ADF_TMP+40;
00091         CDMS_quant[1]= (uint8_t)quant_data.CDMS_temp_quant;
00092         CDMS_quant[2]= (uint8_t)(RSSI_VOLTAGE*10);
00093         CDMS_quant[3]= (uint8_t)(EPS_BTRY_VOLT*33*(62.0/11));
00094         for(int i=0; i<16; i++) {
00095             CDMS_quant[i+4]= (uint8_t)quant_data.temp_quant[i];
00096         }
00097         minMaxHkData();
00098 
00099         CDMS_HEALTH_DATA[1] = GPIO_STATUS;            //Reading GPIO Pins
00100         CDMS_HEALTH_DATA[0] = GPIO_STATUS >> 8;
00101         COLLECT_CDMS_RAM();
00102         for(int i = 0; i<84; i++)
00103             CDMS_HEALTH_DATA[2+i] = CDMS_RAM[i];                  //Reading RAM parameters
00104         for(int i = 0; i<20; i++)                                 //Collecting Data from Temp sensors
00105             CDMS_HEALTH_DATA[86+i] = CDMS_quant[i];
00106 
00107         // Here: Have to FIT flash data.
00108         CDMS_HEALTH_DATA[106] = (EPS_V_A_EN_STATUS<<7) | ((BAE_STATUS<<5)&0x60) | ((SD_STATUS<<3)&0x18) | ((PL_STATUS<<1)&0x06) | (PL_EPS_LATCH_SW_EN & 0x01);
00109         CDMS_HEALTH_DATA[107] = (RTC_INIT_STATUS<<6) | ((CDMS_RTC_DISABLE<<5)&0x20);
00110         CDMS_HEALTH_DATA[108] = CDMS_RESET_COUNTER >>8;
00111         CDMS_HEALTH_DATA[109] = CDMS_RESET_COUNTER;
00112         CDMS_HEALTH_DATA[110] = TIME_LATEST_CDSMS_RESET >>24;
00113         CDMS_HEALTH_DATA[111] = TIME_LATEST_CDSMS_RESET >>16;
00114         CDMS_HEALTH_DATA[112] = TIME_LATEST_CDSMS_RESET >>8;
00115         CDMS_HEALTH_DATA[113] = TIME_LATEST_CDSMS_RESET;
00116         COM_TC_BYTES_LIMIT = BYTE_OVERFLOW_CONSTANT;
00117         CDMS_HEALTH_DATA[114] = COM_TC_BYTES_LIMIT>>8;
00118         CDMS_HEALTH_DATA[115] = COM_TC_BYTES_LIMIT;
00119         CDMS_HEALTH_DATA[116] = COM_RX_CURRENT_MAX;
00120         CDMS_HEALTH_DATA[117] = COM_RX_DISABLE_TIMEOUT;
00121         CDMS_HEALTH_DATA[118] = COM_PA_TMP_HIGH;
00122         CDMS_HEALTH_DATA[119] = COM_PA_RECOVERY_TIMEOUT;
00123         CDMS_HEALTH_DATA[120] = COM_SESSION_TIMEOUT/60;
00124         CDMS_HEALTH_DATA[121] = COM_RSSI_MIN;
00125         CDMS_HEALTH_DATA[122] = SD_LIB_BLK_CURRENT>>8;
00126         CDMS_HEALTH_DATA[122] = SD_LIB_BLK_CURRENT;
00127 
00128         uint32_t time = FCTN_CDMS_RD_RTC() >> 7;             //Reading Time from RTC
00129         for(int i = 124; i<128; i++)
00130             CDMS_HEALTH_DATA[i] = time >> (127-i)*8;
00131 
00132         gPC.printf("\t\t%d/%d/%d  ",((time & 0x003E0000)>>17),((time & 0x03C00000)>>22),((time & 0x0C000000)>>26)+2016);
00133         gPC.printf("%d:%d:%d\n",((time & 0x0001F000)>>12),((time & 0x00000FC0)>>6),(time & 0x0000003F));
00134        if(CDMS_HK_SD_DATA_READY==1||BAE_HK_SD_DATA_READY==1) 
00135         {
00136         FCTN_SD_MNGR();
00137         gPC.printf("endHK_SD");  
00138         }
00139   //      gPC.printf("endHK_SD");                                 //Adding FSC & TMID to TM frame
00140        
00141         CDMS_HK_FRAME[0] = 0x20;
00142         CDMS_HK_FRAME[1] = (FSC_CURRENT[4]+1) >> 16;
00143         CDMS_HK_FRAME[2] = (FSC_CURRENT[4]+1) >> 8;
00144         CDMS_HK_FRAME[3] = FSC_CURRENT[4]+1;
00145         // gPC.printf("\n");
00146         for(int i = 0; i<128; i++) {                      /*Adding actual CDMS Health data to TM frame*/
00147             CDMS_HK_FRAME[i+4] = CDMS_HEALTH_DATA[i];
00148             //gPC.printf("%02x",CDMS_HEALTH_DATA[i]);
00149         }
00150 //   gPC.printf("\n");
00151         uint16_t crc = crc16_gen(CDMS_HK_FRAME,132);      /*Adding CRC to TM frame*/
00152         CDMS_HK_FRAME[132] = crc >> 8;
00153         CDMS_HK_FRAME[133] = crc;
00154 
00155         exor(CDMS_HK_FRAME);
00156         CDMS_HEALTH.convolutionEncode(CDMS_HK_FRAME , convoluted_CDMS_HK);
00157         CDMS_HEALTH.convolutionEncode(CDMS_HK_FRAME + 67, convoluted_CDMS_HK + 135);
00158         //gPC.printf("\n\r reached here");
00159         interleave(convoluted_CDMS_HK ,  interleave_CDMS_HK);
00160         interleave(convoluted_CDMS_HK +135, interleave_CDMS_HK + 144);
00161         //gPC.printf("\n\r reached here");
00162      //   gPC.printf("enterdHK_SD");
00163         
00164         if(CDMS_HK_SD_DATA_READY==1)
00165         {
00166         for(int i=0; i<288; i++)
00167             CDMS_HEALTH_FINAL[i] = interleave_CDMS_HK[i];
00168         //gPC.printf("\n\r reached here");
00169         sd_stat = SD_WRITE(CDMS_HEALTH_FINAL,FSC_CURRENT[4]+1,4);
00170         
00171         if(sd_stat) {
00172             gPC.puts("sd write failure $*&^@!~!");
00173         }
00174         }
00175 //        }
00176         CDMS_HK_SD_DATA_READY=1;    
00177         
00178         // gPC.printf("Completed CDMS HK\t");
00179 
00180         /*---------------------------------- BAE HK --------------------------------------------*/
00181         
00182     //    gPC.printf("endHK_SD2");
00183         BAE_HK_I2C = FCTN_I2C_READ(BAE_HK,134);
00184         //  gPC.printf("\nEntering BAE HK\t");
00185         if(BAE_HK_I2C == 0) {
00186      //  gPC.printf("BAE_HK_");
00187             crc = crc16_gen((unsigned char *)BAE_HK,132);
00188             if(crc == ((uint16_t)BAE_HK[132] << 8) | (uint16_t)BAE_HK[133]) {
00189                 //gPC.printf("BAE HK data recieved through I2C\t");
00190                 TIME_LATEST_I2C_BAE = FCTN_CDMS_RD_RTC() >> 7;
00191                 /*for(int i = 0; i<15; i++)
00192                     gPC.printf("\r 0x%02X\n",BAE_HK[i]);*/
00193                 for(int i = 0; i<4; i++)
00194                     BAE_HK[i] = time >> (3-i)*8;
00195                 BAE_HK_FRAME[0] = 0x28;
00196                 BAE_HK_FRAME[1] = (FSC_CURRENT[5]+1) >> 16;
00197                 BAE_HK_FRAME[2] = (FSC_CURRENT[5]+1) >> 8;
00198                 BAE_HK_FRAME[3] = FSC_CURRENT[5]+1;
00199                 for(int i = 0; i<128; i++)                       /*Adding actual CDMS Health data to TM frame*/
00200                     BAE_HK_FRAME[4+i] = BAE_HK[i];
00201                 crc = crc16_gen(BAE_HK_FRAME,132);               /*Adding CRC to TM frame*/
00202                 BAE_HK_FRAME[132] = crc >> 8;
00203                 BAE_HK_FRAME[133] = crc;
00204                 exor(BAE_HK_FRAME);
00205                 BAE_HEALTH.convolutionEncode(BAE_HK_FRAME , convoluted_BAE_HK);
00206                 BAE_HEALTH.convolutionEncode(BAE_HK_FRAME + 67, convoluted_BAE_HK + 135);
00207                 interleave(convoluted_BAE_HK ,  interleave_BAE_HK);
00208                 interleave(convoluted_BAE_HK +135, interleave_BAE_HK + 144);
00209                
00210      //           gPC.printf("enterHK_SD3");
00211                 
00212                 if(BAE_HK_SD_DATA_READY==1)
00213                 {
00214         
00215                 for(int i=0; i<288; i++)
00216                     BAE_HEALTH_FINAL[i] = interleave_BAE_HK[i];
00217                 sd_stat = SD_WRITE(BAE_HEALTH_FINAL,FSC_CURRENT[5]+1,5);
00218                 if(sd_stat) {
00219                     gPC.puts("BAE_HK sd write fail");
00220                     //break;
00221                 }
00222                 }
00223                 BAE_HK_SD_DATA_READY = 1;
00224     //            gPC.printf("endHK_SD4");
00225             }
00226 
00227         } else {
00228             gPC.printf("BAE HK data not recieved through I2C\t");
00229             for(int i = 0; i<134; i++)
00230                 BAE_HK[i] = 0;
00231         }
00232         // gPC.printf("Completed BAE HK\n");
00233 
00234         /*----------------------------------Beacon message--------------------------------------*/
00235 
00236 
00237         // Add HK bits
00238         beacon_array[0] = 0x00;
00239         beacon_array[1] = time >> 32;
00240         beacon_array[2] = time >> 24;
00241         beacon_array[3] = time >> 16;
00242         beacon_array[4] = time >> 8;
00243         beacon_array[5] = time;
00244         beacon_array[6] = SD_FAULTCOUNT >> 8;
00245         beacon_array[7] = SD_FAULTCOUNT;
00246         beacon_array[8] = RTC_FAULTCOUNT >> 8;
00247         beacon_array[9] = RTC_FAULTCOUNT;
00248         if(!COM_OC_SET)
00249         beacon_array[10] = (((SD_STATUS == DEVICE_DISABLED || SD_STATUS == DEVICE_OC_FAULT)?1:0)<<7)|(RTC_STATUS <<6)|(COM_RX_STATUS<<3)|(0<<2)|(COMRX_OC_FAULT<<1)|(COM_TX_OC_FAULT);
00250         else
00251         {
00252             beacon_array[10] = (((SD_STATUS == DEVICE_DISABLED || SD_STATUS == DEVICE_OC_FAULT)?1:0)<<7)|(RTC_STATUS <<6)|(COM_RX_STATUS<<3)|(0<<2)|(COMRX_OC_FAULT<<1)|(com_oc_sw_status);
00253             COM_OC_SET = 0;
00254         }
00255         beacon_array[11] = (COM_RX_CNTRL <<7)|(COM_TX_CNTRL);
00256         beacon_array[12] = CDMS_HK_MAIN_COUNTER >>8;
00257         beacon_array[13] = CDMS_HK_MAIN_COUNTER;
00258         beacon_array[14] = PL_MAIN_COUNTER >>8;
00259         beacon_array[15] = PL_MAIN_COUNTER;
00260         beacon_array[16] = PL_RCV_SC_DATA_COUNTER >>8;
00261         beacon_array[17] = PL_RCV_SC_DATA_COUNTER;
00262         beacon_array[18] = TIME_LATEST_SPI_SPEED >>24;
00263         beacon_array[19] = TIME_LATEST_SPI_SPEED >>16;
00264         beacon_array[20] = TIME_LATEST_SPI_SPEED >>8;
00265         beacon_array[21] = TIME_LATEST_SPI_SPEED;
00266         beacon_array[22] = (uint8_t)(RSSI_VOLTAGE*10);
00267 
00268         // Add SC bits
00269         crc = crc16_gen(beacon_array,132);
00270         beacon_array[132] = crc;
00271         beacon_array[133] = crc >> 8;
00272         bool y;
00273         y = FCTN_I2C_WRITE((char *)beacon_array,134);
00274         if(y == 0) {
00275             TIME_LATEST_I2C_BAE = FCTN_CDMS_RD_RTC() >> 7;
00276             //gPC.printf("long Bcn sent\n\r");
00277         } else
00278             gPC.printf("long Bcn not sent\r\n");
00279         //gPC.printf("\rCompleted Beacon\n");
00280         gPC.printf("\rreleasing mutex for HK_MAIN \n\r");
00281       SCI_LED1 =0;
00282        gMutex.unlock();
00283     }
00284 }
00285 
00286 int quantiz(float start,float step,float x)
00287 {
00288     int y=(x-start)/step;
00289     if(y<=0)y=0;
00290     if(y>=255)y=255;
00291     return y;
00292 }
00293 
00294 char saveMin(char x,char y)
00295 {
00296     return (y<x)?y:x;
00297 }
00298 
00299 char saveMax(char x,char y)
00300 {
00301     return (y>x)?y:x;
00302 }
00303 
00304 void minMaxHkData()
00305 {
00306     MAX_COM_ADF_TMP = (MAX_COM_ADF_TMP < COM_ADF_TMP)?COM_ADF_TMP:MAX_COM_ADF_TMP;
00307     MIN_COM_ADF_TMP = (MIN_COM_ADF_TMP > COM_ADF_TMP)?COM_ADF_TMP:MIN_COM_ADF_TMP;
00308     
00309     MAX_RSSI_VOLTAGE = (MAX_RSSI_VOLTAGE < RSSI_VOLTAGE)?RSSI_VOLTAGE:MAX_RSSI_VOLTAGE;
00310     MIN_RSSI_VOLTAGE = (MIN_RSSI_VOLTAGE > RSSI_VOLTAGE)?RSSI_VOLTAGE:MIN_RSSI_VOLTAGE;
00311     
00312     if(firstCount==true) {
00313         for (int i = 0; i < 16; ++i) {
00314             min_max_data.temp_min[i] = quant_data.temp_quant[i];
00315             min_max_data.temp_max[i] = quant_data.temp_quant[i];
00316         }
00317 
00318         min_max_data.CDMS_temp_min=quant_data.CDMS_temp_quant;
00319         min_max_data.CDMS_temp_max=quant_data.CDMS_temp_quant;
00320     } else {
00321         for (int i = 0; i < 16; ++i) {
00322             min_max_data.temp_min[i] = saveMin(min_max_data.temp_min[i],quant_data.temp_quant[i]);
00323             min_max_data.temp_max[i] = saveMax(min_max_data.temp_max[i],quant_data.temp_quant[i]);
00324         }
00325 
00326         min_max_data.CDMS_temp_min = saveMin(min_max_data.CDMS_temp_min,quant_data.CDMS_temp_quant);
00327         min_max_data.CDMS_temp_max = saveMax(min_max_data.CDMS_temp_max,quant_data.CDMS_temp_quant);
00328     }
00329     firstCount=false;
00330 }
00331 
00332 void FCTN_CDMS_HK()
00333 {
00334 
00335     int Iteration=0;
00336     float resistance;
00337 
00338     SelectLinec0=0;
00339     SelectLinec1=0;
00340     SelectLinec2=0;
00341     SelectLinec3=0;
00342     wait_ms(1);
00343     //gPC.printf("\r%d %d %d %d\n",SelectLinec3.read(),SelectLinec2.read(),SelectLinec1.read(),SelectLinec0.read());
00344     for(Iteration=0; Iteration<16; Iteration++) {
00345 
00346         actual_data.temp_actual[Iteration]=TempInput.read();
00347 
00348         SelectLinec0=!(SelectLinec0);
00349         if(Iteration%2==1)
00350             SelectLinec1=!(SelectLinec1);
00351         if(Iteration%4==3)
00352             SelectLinec2=!(SelectLinec2);
00353         if(Iteration%8==7)
00354             SelectLinec3=!(SelectLinec3);
00355         wait_ms(1);
00356         //  gPC.printf("\r%d %d %d %d\n",SelectLinec3.read(),SelectLinec2.read(),SelectLinec1.read(),SelectLinec0.read());
00357     }
00358 
00359     actual_data.CDMS_temp_actual=(-90.7*3.3*CDMS_temp_sensor.read())+190.1543;
00360 
00361 
00362 
00363     for(Iteration=0; Iteration<16; Iteration++) {
00364 
00365         if(Iteration<4) {
00366             actual_data.temp_actual[Iteration]=actual_data.temp_actual[Iteration]*3.3*2*10;
00367         } else if(Iteration<14) {
00368             resistance=22000*actual_data.temp_actual[Iteration]*3.3/(3.3-actual_data.temp_actual[Iteration]*3.3);
00369 
00370             if(actual_data.temp_actual[Iteration]*3.3<1.47)      //Document says 1.378 .Pls Check
00371 
00372                 actual_data.temp_actual[Iteration]=(3694/log(24.032242*resistance))-273;
00373             else
00374 
00375                 actual_data.temp_actual[Iteration]=(3365.4/log(7.60573*resistance))-273;
00376 
00377         } else
00378             actual_data.temp_actual[Iteration]=(-90.7*3.3*actual_data.temp_actual[Iteration])+190.1543;
00379     }
00380     for(Iteration=0; Iteration<16; Iteration++) {
00381 
00382         if(Iteration<4) {
00383             quant_data.temp_quant[Iteration]=actual_data.temp_actual[Iteration];
00384             wait(0.001);
00385         } else if(Iteration<14)
00386             quant_data.temp_quant[Iteration]=quantiz(tstart_thermistor,tstep_thermistor,actual_data.temp_actual[Iteration]);
00387         // quant_data.temp_quant[Iteration]=quantiz(0,1,actual_data.temp_actual[Iteration]);
00388         else
00389             // quant_data.temp_quant[Iteration]=quantiz(tstart,tstep,actual_data.temp_actual[Iteration]);
00390             quant_data.temp_quant[Iteration]=quantiz(tstart,tstep,actual_data.temp_actual[Iteration]);
00391     }
00392     quant_data.CDMS_temp_quant=quantiz(tstart,tstep,actual_data.CDMS_temp_actual);
00393 
00394     minMaxHkData();
00395 }
00396 
00397 void FUNC_CDMS_GPIO_STATUS()       //Polls the status of Input GPIO PINS
00398 {
00399     /*
00400     //V_A_PGOOD //TRZ EN
00401     GPIO_STATUS=(V_A_PGOOD)?(GPIO_STATUS)|((uint16_t)(0x1<<15)):(GPIO_STATUS)&(~((uint16_t)(0x1<<15)));
00402     //V_B_PGOOD_1 //3V3BPGOOD //$
00403     GPIO_STATUS=(V_B_PGOOD_1)?(GPIO_STATUS)|((uint16_t)(0x1<<14)):(GPIO_STATUS)&(~((uint16_t)(0x1<<14)));
00404     //V_B_PGOOD_2 //3V3BEN //$
00405     GPIO_STATUS=(V_B_PGOOD_2)?(GPIO_STATUS)|((uint16_t)(0x1<<13)):(GPIO_STATUS)&(~((uint16_t)(0x1<<13)));
00406     //V_C_PGOOD //3V3CPGOOD //$
00407     GPIO_STATUS=(V_C_PGOOD)?(GPIO_STATUS)|((uint16_t)(0x1<<12)):(GPIO_STATUS)&(~((uint16_t)(0x1<<12)));
00408     */
00409 
00410     //COMRX_OC_FAULT //$
00411     GPIO_STATUS=(COMRX_OC_FAULT)?(GPIO_STATUS)|((uint16_t)(0x1<<11)):(GPIO_STATUS)&(~((uint16_t)(0x1<<11)));
00412     // COMTX_OC_FAULT //$
00413     GPIO_STATUS=(COM_TX_OC_FAULT)?(GPIO_STATUS)|((uint16_t)(0x1<<10)):(GPIO_STATUS)&(~((uint16_t)(0x1<<10)));
00414     // CDMS_SD_OC_FAULT
00415     GPIO_STATUS=(SD_OC_FAULT)?(GPIO_STATUS)|((uint16_t)(0x1<<9)):(GPIO_STATUS)&(~((uint16_t)(0x1<<9)));
00416     //BAE_OC_FAULT //$
00417     GPIO_STATUS=(BAE_OC_FAULT)?(GPIO_STATUS)|((uint16_t)(0x1<<8)):(GPIO_STATUS)&(~((uint16_t)(0x1<<8)));
00418 
00419     /*
00420     //PL_GPIO_1_STATUS //$
00421     GPIO_STATUS=(PL_GPIO_1_STATUS)?(GPIO_STATUS)|((uint16_t)(0x1<<8)):(GPIO_STATUS)&(~((uint16_t)(0x1<<8)));
00422     //PL_GPIO_2_STATUS //$
00423     GPIO_STATUS=(PL_GPIO_2_STATUS)?(GPIO_STATUS)|((uint16_t)(0x1<<7)):(GPIO_STATUS)&(~((uint16_t)(0x1<<7)));
00424     //PL_GPIO_3_STATUS //$
00425     GPIO_STATUS=(PL_GPIO_3_STATUS)?(GPIO_STATUS)|((uint16_t)(0x1<<6)):(GPIO_STATUS)&(~((uint16_t)(0x1<<6)));
00426     */
00427 
00428     //PL_BEE_SW_OC_FAULT //to be verified
00429     GPIO_STATUS=(PL_BEE_SW_OC_FAULT)?(GPIO_STATUS)|((uint16_t)(0x1<<4)):(GPIO_STATUS)&(~((uint16_t)(0x1<<4)));
00430     //PL_EPS_LATCH_SW_OC_FAULT // to be verified
00431     GPIO_STATUS=(PL_EPS_LATCH_SW_OC_FAULT)?(GPIO_STATUS)|((uint16_t)(0x1<<3)):(GPIO_STATUS)&(~((uint16_t)(0x1<<3)));
00432     //EPS_V_C_EN_STATUS
00433     GPIO_STATUS=(COM_RX_CNTRL)?(GPIO_STATUS)|((uint16_t)(0x1<<2)):(GPIO_STATUS)&(~((uint16_t)(0x1<<2)));
00434     //EPS_V_D_EN_STATUS
00435     GPIO_STATUS=(COM_TX_CNTRL)?(GPIO_STATUS)|((uint16_t)(0x1<<1)):(GPIO_STATUS)&(~((uint16_t)(0x1<<1)));
00436     //  gPC.printf("%04x\n",GPIO_STATUS);
00437     gPC.printf("\n\rBAE_OC STATE = %04x",GPIO_STATUS);
00438 }
00439 
00440 void VERIFY_COMRX()
00441 {
00442     //COMRX_OC_FAULT //$
00443     if(COMRX_OC_FAULT==0 && RSSI_VOLTAGE > 0.4) {
00444         COMRX_STATUS = COMRX_ALIVE;
00445     } else {
00446         //RESET_COMRX();
00447         COMRX_RESET_COUNTER++;
00448         if(COMRX_OC_FAULT==0 && RSSI_VOLTAGE > 0.4)
00449             COMRX_STATUS = COMRX_ALIVE;
00450         else
00451             COMRX_STATUS = COMRX_DEAD;
00452     }
00453 }
00454 
00455 void VERIFY_RTC()
00456 {
00457     uint8_t response;
00458     if(EN_RTC == 0x00)
00459         return;
00460     gCS_RTC=1;
00461     gCS_RTC=0;
00462     spi.write(0x0F);
00463     response = spi.write(0x00);
00464     CDMS_RTC_BL = (response & 0x10) >>4;
00465     if(response & 0x04 == 0x04) {
00466         //RESET_RTC();
00467         RTC_STATUS = 0x01;
00468         RTC_FAULTCOUNT++;
00469     }
00470     gCS_RTC=1;
00471 }
00472 
00473 void HANDLE_HW_FAULTS()
00474 {
00475     HANDLE_HW_FAULT_SD();
00476     HANDLE_HW_FAULT_BAE();
00477     HANDLE_HW_FAULT_PL();
00478 }
00479 
00480 void HANDLE_HW_FAULT_SD()
00481 {
00482     if(SD_STATUS != DEVICE_DISABLED) {
00483         if(SD_STATUS == DEVICE_OC_FAULT) {
00484             gPC.printf("Switching on SD card");
00485             SD_SW_EN_DS = 1; //powering on SD
00486             wait_ms(10);
00487         }
00488 
00489         if(SD_OC_FAULT == 0) {
00490             gPC.printf("Switching off SD card");
00491             SD_SW_EN_DS = 0; //switching off SD card
00492             SD_FAULTCOUNT++;
00493             SD_STATUS = (SD_FAULTCOUNT == 3) ? DEVICE_DISABLED :DEVICE_OC_FAULT;
00494             if(SD_FAULTCOUNT == 3) {
00495                 FCTN_CDMS_WR_FLASH(2,DEVICE_DISABLED);
00496                 gPC.printf("Declaring SD card permanantly Disabled");
00497             }
00498         } else {
00499             SD_STATUS = DEVICE_POWERED;
00500             if(SD_STATUS != DEVICE_POWERED)
00501                 FCTN_CDMS_WR_FLASH(2,DEVICE_POWERED);
00502             SD_FAULTCOUNT = 0;
00503         }
00504     }
00505 }
00506 
00507 void HANDLE_HW_FAULT_BAE()
00508 {
00509     if(BAE_STATUS != DEVICE_DISABLED) {
00510         if(BAE_STATUS == DEVICE_OC_FAULT) {
00511             gPC.printf("Switching on BAE");
00512             BAE_SW_EN_DS = 1; //Power ON BAE
00513             wait_ms(10);
00514         }
00515 
00516         if(BAE_OC_FAULT == 0) {
00517             gPC.printf("Switching off BAE");
00518             BAE_SW_EN_DS = 0; //Switch OFF BAE
00519             BAE_FAULTCOUNT++;
00520             BAE_STATUS = (BAE_FAULTCOUNT == 3)?DEVICE_DISABLED:DEVICE_OC_FAULT;
00521             if(BAE_FAULTCOUNT == 3) {
00522                 FCTN_CDMS_WR_FLASH(1,DEVICE_DISABLED);
00523                 gPC.printf("Declaring BAE permanantly Disabled");
00524             }
00525         } else {
00526             BAE_STATUS = DEVICE_POWERED;
00527             if(SD_STATUS != DEVICE_POWERED);
00528             FCTN_CDMS_WR_FLASH(1,DEVICE_POWERED);
00529             BAE_FAULTCOUNT = 0;
00530         }
00531     }
00532 }
00533 
00534 void HANDLE_HW_FAULT_PL()
00535 {
00536     if(PL_STATUS != DEVICE_DISABLED) {
00537         if(PL_STATUS == DEVICE_OC_FAULT) {
00538             gPC.printf("Switching on PL_BEE");
00539             PYLD_DFF_CLK = 0;
00540             PYLD_DFF = 1;           // Switching ON PL
00541             wait_us(1);
00542             PYLD_DFF_CLK = 1;
00543             wait_us(1);
00544             PYLD_DFF_CLK = 0;
00545             wait_us(1);
00546         }
00547         if(PL_BEE_SW_OC_FAULT == 0) { // if OC Fault
00548             gPC.printf("Switching off PL_BEE");
00549             PYLD_DFF_CLK = 0;
00550             PYLD_DFF = 0;             //Switching OFF PL
00551             wait_us(1);
00552             PYLD_DFF_CLK = 1;
00553             wait_us(1);
00554             PYLD_DFF_CLK = 0;
00555             wait_us(1);
00556             PL_FAULTCOUNT++;
00557             PL_STATUS = (PL_FAULTCOUNT == 3)?DEVICE_DISABLED:DEVICE_OC_FAULT;
00558             if(PL_FAULTCOUNT == 3) {
00559                 FCTN_CDMS_WR_FLASH(3,DEVICE_DISABLED);
00560                 gPC.printf("Declaring PL_BEE permanantly Disabled");
00561             }
00562         } else {
00563             if(PL_STATUS == DEVICE_OC_FAULT) {
00564                 gPC.printf("Switching off PL_BEE");
00565                 PYLD_DFF_CLK = 0;
00566                 PYLD_DFF = 0;             //Switching OFF PL
00567                 wait_us(1);
00568                 PYLD_DFF_CLK = 1;
00569                 wait_us(1);
00570                 PYLD_DFF_CLK = 0;
00571                 wait_us(1);
00572             }
00573             PL_STATUS = DEVICE_ENABLED;
00574             if(PL_STATUS != DEVICE_ENABLED)
00575                 FCTN_CDMS_WR_FLASH(3,DEVICE_ENABLED);
00576             PL_FAULTCOUNT = 0;
00577         }
00578     }
00579 }
00580 
00581 void COLLECT_CDMS_RAM()
00582 {
00583     CDMS_RAM[0] = ((PL_INIT_STATUS<<7)&0x80)|((PL_MAIN_status<<6)&0x40)|((PL_LOW_power<<5)&0x20)|((PL_STATE<<3)&0x18)|(PL_STATUS&0x07);
00584 
00585     CDMS_RAM[1] = ( (PL_RCV_SC_DATA_STATUS<<7) & 0x80 )|
00586                   ( ((gFLAGS & COM_SESSION_FLAG)<<3) & 0x40 )|
00587                   ( ((gFLAGS & COM_RX_FLAG)<<1) & 0x20 )|
00588                   ( ((gFLAGS & RF_SW_STATUS_FLAG)>>8)&0x10 )|
00589                   ( ((gFLAGS & COM_TX_FLAG)>>5)&0x08 )|
00590                   ( (COM_TX_STATUS<<2)&0x04 )|
00591                   ( ((gFLAGS & COM_MNG_TMTC_RUNNING_FLAG)>>3) & 0x02 )|
00592                   (EN_CDMS_HK&0x01);
00593     CDMS_RAM[2] = ((EN_PL<<7)&0x80)|((EN_RCV_SC<<6)&0x40)|
00594                   ((CDMS_INIT_STATUS<<5)&0x20)|
00595                   ((CDMS_HK_MAIN_STATUS<<4)&0x10)|
00596                   ((CDMS_HK_STATUS<<2)&0x0C)|
00597                   ((COM_RX_STATUS<<1)&0x02)|
00598                   (CDMS_RTC_BL&0x01);
00599     CDMS_RAM[3] = CDMS_I2C_ERR_SPEED_COUNTER >> 8;
00600     CDMS_RAM[4] = CDMS_I2C_ERR_SPEED_COUNTER;
00601     CDMS_RAM[5] = CDMS_I2C_ERR_BAE_COUNTER >> 8;
00602     CDMS_RAM[6] = CDMS_I2C_ERR_BAE_COUNTER;
00603     CDMS_RAM[7] = CDMS_HK_MAIN_COUNTER >> 8;
00604     CDMS_RAM[8] = CDMS_HK_MAIN_COUNTER;
00605     CDMS_RAM[9] = PL_MAIN_COUNTER >> 8;
00606     CDMS_RAM[10] = PL_MAIN_COUNTER;
00607     CDMS_RAM[11] = PL_RCV_SC_DATA_COUNTER >> 8;
00608     CDMS_RAM[12] = PL_RCV_SC_DATA_COUNTER;
00609     CDMS_RAM[13] = COMRX_RESET_COUNTER >> 8;
00610     CDMS_RAM[14] = COMRX_RESET_COUNTER;
00611     CDMS_RAM[15] = CDMS_WR_SD_FAULT_COUNTER >> 8;
00612     CDMS_RAM[16] = CDMS_WR_SD_FAULT_COUNTER;
00613     CDMS_RAM[17] = SD_LIB_WRITES >> 8;
00614     CDMS_RAM[18] = SD_LIB_WRITES;
00615     TIME_LATEST_RTC= FCTN_CDMS_RD_RTC() >> 7; // added by samp
00616     for(int i = 0; i<4; i++)
00617         CDMS_RAM[19+i] = TIME_LATEST_RTC >> (3-i)*8;
00618     for(int i = 0; i<4; i++)
00619         CDMS_RAM[23+i] = TIME_LATEST_I2C_BAE >> (3-i)*8;
00620     for(int i = 0; i<4; i++)
00621         CDMS_RAM[27+i] = TIME_LATEST_I2C_SPEED >> (3-i)*8;
00622     for(int i = 0; i<4; i++)
00623         CDMS_RAM[31+i] = TIME_LATEST_SD_WR >> (3-i)*8;
00624     for(int i = 0; i<4; i++)
00625         CDMS_RAM[35+i] = TIME_LATEST_SD_RD >> (3-i)*8;
00626     for(int i = 0; i<4; i++)
00627         CDMS_RAM[39+i] = TIME_LATEST_SPI_SPEED >> (3-i)*8;
00628     for(int i = 0; i<4; i++)
00629         CDMS_RAM[43+i] = FSC_CURRENT[1] >> (3-i)*8;
00630     for(int i = 0; i<4; i++)
00631         CDMS_RAM[47+i] = FSC_OLD[1] >> (3-i)*8;
00632     for(int i = 0; i<4; i++)
00633         CDMS_RAM[51+i] = FSC_CURRENT[2] >> (3-i)*8;
00634     for(int i = 0; i<4; i++)
00635         CDMS_RAM[55+i] = FSC_OLD[2] >> (3-i)*8;
00636     for(int i = 0; i<4; i++)
00637         CDMS_RAM[59+i] = FSC_CURRENT[3] >> (3-i)*8;
00638     for(int i = 0; i<4; i++)
00639         CDMS_RAM[63+i] = FSC_OLD[3] >> (3-i)*8;
00640     for(int i = 0; i<4; i++)
00641         CDMS_RAM[67+i] = FSC_CURRENT[4] >> (3-i)*8;
00642     for(int i = 0; i<4; i++)
00643         CDMS_RAM[71+i] = FSC_OLD[4] >> (3-i)*8;
00644     for(int i = 0; i<4; i++)
00645         CDMS_RAM[75+i] = FSC_CURRENT[5] >> (3-i)*8;
00646     for(int i = 0; i<4; i++)
00647         CDMS_RAM[79+i] = FSC_OLD[5] >> (3-i)*8;
00648     CDMS_RAM[83] = 0x00;
00649     gPC.printf("\n\r%u %u %u %u %u",FSC_CURRENT[1],FSC_CURRENT[2],FSC_CURRENT[3],FSC_CURRENT[4],FSC_CURRENT[5]);
00650 }