ThreadsAndFunctions.h

00001 //Science Thread
00002 //SPI ISR
00003 
00004 #include "COM_MNG_TMTC.h"
00005 #include "adf.h"
00006 #include "dmaSPIslave.h"
00007 
00008 
00009 
00010 dmaSPISlave *gPAY_SPI;
00011 
00012 void payload_isr_fun(){
00013     gSCIENCE_THREAD->signal_set(SCIENCE_SIGNAL);
00014   
00015 }
00016 
00017 void payload_isr_fun_dma(void const *args ){
00018     gSCIENCE_THREAD->signal_set(SCIENCE_SIGNAL);
00019 }
00020 
00021 void SCIENCE_FUN(void const *args){
00022    // gPAY_SPI->frequency(1000000);   //1000000
00023     gPAY_SPI->format(8,0); 
00024     gPC.printf("\n\rTest...........................");
00025     gPAY_SPI->bulkRead_init(gPAYLOAD_BUFFER, PAYLOAD_BUFFER_LENGTH, &payload_isr_fun);    //commented 2day
00026     gPAY_SPI->bulkRead_start();       //commented 2day
00027     
00028     //AY_SPI->bulkRead_pause();
00029     //AY_SPI->bulkRead_resume(&payload_isr_fun);
00030     while(true){
00031         gPC.printf("waiting for Sci sig\n\r");
00032         gSCIENCE_THREAD->signal_wait(SCIENCE_SIGNAL);
00033         gPC.printf("got signal\n\r");
00034         if(EN_RCV_SC == 0x00)
00035             continue;
00036         gPC.printf("checking mutex in Sci\n\r");
00037         gMutex.lock();
00038         gPC.printf("locked mutex,entered in Sci thread\n\r"); 
00039         
00040         WRITE_TO_EEPROM(1,DEVICE_POWERED);
00041         DMA_LED1 = 1;
00042         PL_RCV_SC_DATA_STATUS = 1;
00043         
00044         //gPC.puts("sig_set\r\n");
00045         //for(int i =0; i<PAYLOAD_BUFFER_LENGTH; i++)
00046         //if (gPAYLOAD_BUFFER[i] != 0x01) gPC.printf("%d = 0x%02X\n\r",i,gPAYLOAD_BUFFER[i]);  
00047         //gPAY_SPI->bulkRead_start();
00048         //srp(gPAYLOAD_BUFFER);//skip one apcket when cdms resets
00049         //gPC.puts("exit_srp\r\n");
00050         //wait(2);/*timeout to be decided*/
00051         if(dma)  //something wrong here
00052         {
00053      //       TIME_LATEST_I2C_SPEED = FCTN_CDMS_RD_RTC() >> 7;   
00054             PL_RCV_SC_DATA_COUNTER++;
00055             gPC.printf("dma activatedi\n\r");
00056             gPAY_SPI->bulkRead_start();//something wrong here  //commented 2day
00057          //     DMA_LED1 = !DMA_LED1; // added by samp
00058             //gPAY_SPI->bulkRead_pause();
00059             //gPAY_SPI->bulkRead_resume(&payload_isr_fun);
00060         }
00061        // DMA_LED1 = !DMA_LED1; // added by samp
00062        //__disable_irq();  
00063         srp(gPAYLOAD_BUFFER);//skip one apcket when cdms resets
00064 
00065         uint8_t sd_stat1 = 0;
00066         if(BAE_HK_SD_DATA_READY==1)
00067                 {
00068                 for(int i=0; i<288; i++)
00069                     BAE_HEALTH_FINAL[i] = interleave_BAE_HK[i];
00070                 sd_stat1 = SD_WRITE(BAE_HEALTH_FINAL,FSC_CURRENT[5]+1,5);
00071                 if(sd_stat1) {
00072                     gPC.puts("BAE_HK sd write fail");
00073                     //break;
00074                 }
00075                 
00076                 }
00077                 BAE_HK_SD_DATA_READY = 0;
00078         if(CDMS_HK_SD_DATA_READY==1)
00079         {
00080         for(int i=0; i<288; i++)
00081             CDMS_HEALTH_FINAL[i] = interleave_CDMS_HK[i];
00082         //gPC.printf("\n\r reached here");
00083         sd_stat1 = SD_WRITE(CDMS_HEALTH_FINAL,FSC_CURRENT[4]+1,4);
00084         
00085         if(sd_stat1) {
00086             gPC.puts("sd write failure $*&^@!~!");
00087         }
00088         }
00089         CDMS_HK_SD_DATA_READY= 0;
00090         /*else
00091         gPC.printf("\n\rDMA error");*/
00092         gPC.printf("\r\nreleasing mutex for Sci\n\r");
00093         DMA_LED1 =0;
00094         //__enable_irq();
00095         gMutex.unlock(); 
00096     }
00097 }
00098 
00099 //HK Thread(Contains HK_main() and PL_main())
00100 //RTOS timer calllback func
00101 void hk_isr(void const *args){
00102     //gPC.printf("\r\n HK isr \n\r");
00103     gHK_THREAD->signal_set(HK_SIGNAL);
00104     // gPC.printf("\r\n HK 1 \n\r");
00105 }
00106 
00107 
00108 //COM THREAD
00109 // UART ISR
00110 void rx_read(){
00111     gRX_CURRENT_DATA_NODE->values[gRX_COUNT] = RX1M.getc();
00112     //Checking RSSI
00113     if(!COM_RSSI_SET)
00114     RSSI_VOLTAGE = COMRX_RSSI_VOLTAGE.read() * 3.3;//to be checked
00115     RSSI_MAX = RSSI_VOLTAGE;
00116     COM_RSSI_SET = 1;
00117     gFLAGS = gFLAGS | UART_INT_FLAG;
00118     
00119     gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
00120 }
00121 
00122 // COM_RX_DISABLE ISR
00123 void after_com_disable(){
00124     gCOM_RX_DISABLE.detach();
00125     RX1M.attach(&rx_read, Serial::RxIrq);
00126 }
00127 
00128 // RX_TIMEOUT ISR
00129 void after_receive(){
00130     gRX_TIMEOUT.detach();
00131     gFLAGS = gFLAGS | NEW_TC_RECEIVED;
00132     gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
00133 }
00134 
00135 // SESSION_TIMOUT ISR
00136 void after_session(){
00137     gSESSION_TIMEOUT.detach();
00138     gFLAGS = gFLAGS | COM_SESSION_TIMEOUT_FLAG;
00139     //if( gMASTER_STATE != TCL_STATE_EXECUTING ){
00140         gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
00141     //}
00142 }
00143 
00144 #define reset_all {\
00145     Base_tc *tcp = gHEAD_NODE_TCL;\
00146     /*gPC.puts("inside reset\r\n");*/\
00147     gFLAGS = 0x0000;\
00148     while(tcp != NULL){\
00149         Base_tc *temp = tcp->next_TC;\
00150         delete tcp;\
00151         tcp = temp;\
00152     }\
00153     gHEAD_NODE_TCL = NULL;\
00154     gLAST_NODE_TCL = NULL;\
00155     gMASTER_STATE = TCL_STATE_COMPLETED;\
00156     gTOTAL_INCORRECT_SIZE_TC = 0;\
00157     gTOTAL_CRC_FAIL_TC = 0;\
00158     gTOTAL_REPEATED_TC = 0;\
00159     gTOTAL_VALID_TC = 0;\
00160     for(int i = 0 ; i < TM_LONG_SIZE ; ++i){\
00161         /*gLAST_TM[i] = 0x00;*/\
00162     }\
00163     /*gLAST_TM_SHORT_OR_LONG = SHORT_TM_CODE;*/\
00164     COM_RX_DATA_NODE *dataptr = gRX_HEAD_DATA_NODE;\
00165     while( dataptr != NULL ){\
00166         COM_RX_DATA_NODE *temp = dataptr->next_node;\
00167         delete dataptr;\
00168         dataptr = temp;\
00169     }\
00170     gRX_HEAD_DATA_NODE = new COM_RX_DATA_NODE;\
00171     gRX_HEAD_DATA_NODE->next_node = NULL;\
00172     gRX_CURRENT_DATA_NODE = gRX_HEAD_DATA_NODE;\
00173     gRX_COUNT = 0;\
00174     gTOTAL_RAW_BYTES = 0;\
00175     /*PENDING : ALL GLOBAL VAARIABLES AND FLAGS*/\
00176     /*gPC.puts("finished reset all\r\n");*/\
00177 }
00178 
00179 #define PUT_RAW_BYTE {\
00180     if( gRX_COUNT < (RX_BUFFER_LENGTH-1) ){\
00181         ++gRX_COUNT;\
00182     }\
00183     else{\
00184         gRX_COUNT = 0;\
00185         gRX_CURRENT_DATA_NODE->next_node = new COM_RX_DATA_NODE;\
00186         gRX_CURRENT_DATA_NODE = gRX_CURRENT_DATA_NODE->next_node;\
00187         gRX_CURRENT_DATA_NODE->next_node = NULL;\
00188     }\
00189     ++gTOTAL_RAW_BYTES;\
00190     gRX_TIMEOUT.attach(&after_receive, RX_TIMEOUT_LIMIT);\
00191 }
00192 
00193 void COM_MNG_TMTC_FUN(void const *args){
00194     if( !(gFLAGS & COM_SESSION_FLAG) ){
00195         //gLEDR = 1;
00196         //gLEDG = 1;
00197     }
00198     while(true){
00199         Thread::signal_wait( COM_MNG_TMTC_SIGNAL_UART_INT );
00200 //        RSSI_MAX = 0;
00201         if( gFLAGS & UART_INT_FLAG ){
00202             gFLAGS = gFLAGS & (~UART_INT_FLAG);
00203             //gPC.puts("in uart");
00204             if( !(gFLAGS & COM_SESSION_FLAG) ){
00205                 // DISABLE THREADS
00206                // gPC.puts("1\r\n");
00207                 HK_counter->stop();
00208                 resume_pl_dma = 0;
00209                 PL_GPIO_2_STATUS = 1;//STOP SCIENCE TRANSFER &  CONTROL pin NOT STATUS
00210                 gPAY_SPI->bulkRead_pause();
00211                  PL_GPIO_3_STATUS=1;//problem with this
00212                 gFLAGS = gFLAGS | COM_SESSION_FLAG;
00213                 gSESSION_TIMEOUT.attach(&after_session, 14*COM_SESSION_TIMEOUT);
00214                 gFLAGS = gFLAGS | COM_RX_FLAG;
00215                 gTOTAL_RAW_BYTES = 0;
00216                 PUT_RAW_BYTE;
00217                 // PENDING : MEASURE RSSI
00218                 if( gFLAGS & COM_SESSION_FLAG ){
00219                     //gLEDR = 0;
00220                     //gLEDG = 0;
00221                 }
00222             }
00223             else if( gFLAGS & COM_RX_FLAG ){
00224                 //gLEDR = 0;
00225                 //gLEDG = 1;
00226                                 //gPC.puts("2\r\n");
00227 
00228                 PUT_RAW_BYTE;
00229             }
00230             else{
00231                 //gLEDR = 1;
00232                 //gLEDG = 0;
00233                                // gPC.puts("3\r\n");
00234 
00235                 gFLAGS = gFLAGS | COM_RX_FLAG;
00236                 PUT_RAW_BYTE;
00237             }
00238             if(gTOTAL_RAW_BYTES > BYTE_OVERFLOW_CONSTANT){
00239                                 //gPC.puts("4\r\n");
00240 
00241                 RX1M.attach(NULL);
00242                 gCOM_RX_DISABLE.attach(&after_com_disable, COM_RX_DISABLE_TIMEOUT);
00243                 after_receive();
00244             }
00245         }
00246         else if( gFLAGS & NEW_TC_RECEIVED ){
00247             gFLAGS = gFLAGS & (~NEW_TC_RECEIVED);
00248             // DISABLE THE RX1M INTERRUPT
00249             RX1M.attach(NULL);
00250             gPC.printf("RSSI  =  %f",RSSI_MAX);
00251             /*Thread::wait(2000);*/
00252             gFLAGS = gFLAGS & (~COM_RX_FLAG);//CHanged but not tested
00253             gFLAGS = gFLAGS | COM_MNG_TMTC_RUNNING_FLAG;
00254 
00255             
00256             //gPC.printf("\n flags = %u \n", gFLAGS);
00257             gPC.puts("\n\n\n\r\rNEW TC RECEIVED\r\n");
00258             //gPC.printf("\n %u \n", gFLAGS);
00259             // VERIFY CRC, REPEATED PSC AND UPDATE TOTAL_VALID_TC, INCORRECT SIZE TC, CRC FAIL TC
00260             while(gRX_COUNT < (RX_BUFFER_LENGTH)){
00261                 gRX_CURRENT_DATA_NODE->values[gRX_COUNT] = 0x00;
00262                 ++gRX_COUNT;
00263             }
00264             gRX_COUNT = 0;
00265             raw_data_to_tc();
00266             //gFLAGS = gFLAGS & (~COM_RX_FLAG);
00267             
00268             //Mutex
00269             gMutex.lock();
00270             
00271             if( gTOTAL_VALID_TC > 1 ){
00272                 gPC.printf("valid TC rx: %u\r\n", gTOTAL_VALID_TC);
00273                 TC_count += gTOTAL_VALID_TC;
00274                 //gTOTAL_VALID_TC = 1;
00275                 if( gTOTAL_VALID_TC < COM_MAX_TC_LIMIT ){
00276                     // CHECK WEATHER TC LIST HAS MISSING TC OR WEATHER LAST FRAME BIT IS HIGH IN THE LAST PSC-TC
00277                     //gPC.puts("checking for tc list complete\r\n");
00278                     uint8_t tempContinue = 0xFF;
00279                     continueToExecute(tempContinue);
00280                     if(tempContinue == 0x00){
00281                         gPC.puts("tc list is complete\r\n");
00282                         // CHECK WEATHER GS VERIFICATION CODE MATCHES
00283                         uint8_t tempGSver = 0x00;
00284                         GScodeVerification(tempGSver);
00285                         /*PENDING: INCLUDE GS VERIFICATION CODE*/
00286                         if( tempGSver == 0xFF ){
00287                             //gPC.puts("GS code match !!\r\n");
00288                             gFLAGS = gFLAGS | COM_SESSION_VALIDITY;
00289                             //sys_reset_cdms_timer->start(cdms_reset_timeout);
00290                             COM_POWER_ON_TX();
00291 //                            gPC.puts("P_com_hk !!\r\n");
00292                             P_COM_HK;
00293 //                            gPC.puts("P_com_hk !!\r\n");
00294                             if( (gFLAGS & COM_PA_HOT_FLAG) || ( gFLAGS & COM_PA_OC_FLAG ) ){
00295                                 gPC.puts("Pahot or paoc !!\r\n");
00296                                 COM_DATA_fromuC_ENAIN = 0;
00297                                 COM_DATA_fromISO_ENAOUT=0;
00298                                 COM_TX_CNTRL = 0;
00299                                 gCOM_PA_COOLING_TIMEOUT.attach(&after_cooling_pa, COM_PA_COOLING_TIME_LIMIT);
00300                                 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);
00301                                 RX1M.attach(&rx_read, Serial::RxIrq);
00302                             }
00303                             else{
00304                                 gCOM_PA_COOLING_TIMEOUT.detach();
00305                                 gPC.puts("EXECUTING TELECOMMANDS\r\n");
00306                                 EXECUTE_OBOSC_ONLY;
00307                                 EXECUTE_TC;
00308                                 gPC.puts("COMPLETED EXECUTION\r\n");
00309                                 gPC.printf("master_state : %d\n",gMASTER_STATE);
00310                             }
00311                         }
00312                         else{
00313                             gPC.puts("GS code mismatch !!\r\n");
00314                             RX1M.attach(&rx_read, Serial::RxIrq);
00315                             reset_all;
00316                             gFLAGS = gFLAGS & (~COM_SESSION_VALIDITY);
00317                             // ENABLE THREADS
00318                           
00319                             HK_counter->start(10000);
00320                             
00321                            
00322                             resume_pl_dma = 1;
00323                             //gPAY_SPI->bulkRead_resume(&payload_isr_fun);
00324                             gSESSION_TIMEOUT.detach();
00325                             gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
00326                             // WARNING: clear COM_MNG_TMTC ?
00327                             gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);
00328                         }
00329                     }
00330                     else{
00331                         gPC.puts("tc list is not complete\r\n");
00332                         if(tempContinue & 0x01){
00333                             gPC.puts("last packet bit not found\r\n");
00334                         }
00335                         if( tempContinue & 0x02 ){
00336                             gPC.puts("missing psc found\r\n");
00337                         }
00338                         //gPC.printf("crc fail tc = %u\r\n", gTOTAL_CRC_FAIL_TC);
00339                         //gPC.printf("incorrect size tc = %u\r\n", gTOTAL_INCORRECT_SIZE_TC);
00340                         //gPC.printf("repeated psc = %u\r\n", gTOTAL_REPEATED_TC);
00341                         Base_tc *test_tc = gHEAD_NODE_TCL;
00342                         while( test_tc != NULL ){
00343                             int length = 0;
00344                             if( GETshort_or_long_tc(test_tc) == SHORT_TC_CODE ){
00345                                 length = TC_SHORT_SIZE;
00346                             }
00347                             else{
00348                                 length = TC_LONG_SIZE;
00349                             }
00350                             for(int i = 0 ; i < length ; ++i ){
00351                                 //gPC.printf("%x ", test_tc->TC_string[i]);
00352                             }
00353                             //gPC.puts("\r\n");
00354                             test_tc = test_tc->next_TC;
00355                         }
00356                         //gPC.puts("\r\n");
00357                         COM_POWER_ON_TX();
00358                         // PENDING : POWER OFF TX
00359                         COM_DATA_fromuC_ENAIN = 0;
00360                         COM_DATA_fromISO_ENAOUT=0;
00361                         COM_TX_CNTRL = 0;
00362                         COM_POWER_OFF_TX;
00363                         //reset_all;
00364                         RX1M.attach(&rx_read, Serial::RxIrq);
00365                         gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);
00366                         //resume_pl_dma = 1;
00367                         //HK_counter->start(10000);
00368                         
00369                     }
00370                 }
00371                 else{
00372                     COM_POWER_ON_TX();
00373                     // POWER OFF TX transmitter only
00374                     // WARNING: reset_all ? clear com_session ?
00375                     COM_DATA_fromuC_ENAIN = 0;
00376                     COM_DATA_fromISO_ENAOUT=0;
00377                     COM_TX_CNTRL = 0;
00378                     reset_all;
00379                     gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
00380                     RX1M.attach(&rx_read, Serial::RxIrq);
00381                     gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);
00382                 }
00383             }
00384             else{
00385                 gPC.puts("No valid TC received\r\n");
00386                 RX1M.attach(&rx_read, Serial::RxIrq);
00387                 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);
00388                 reset_all;
00389                 // ENABLE THREADS
00390                 HK_counter->start(10000);
00391                 resume_pl_dma = 1;
00392                 gSESSION_TIMEOUT.detach();
00393                 gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
00394             }
00395         }
00396         else if( gFLAGS & COM_PA_HOT_FLAG ){
00397             gPC.puts("checking for PA hot in main\r\n");
00398             P_COM_HK;
00399             if((gFLAGS & COM_PA_HOT_FLAG) || (gFLAGS & COM_PA_OC_FLAG)){
00400                 COM_DATA_fromuC_ENAIN = 0;
00401                 COM_DATA_fromISO_ENAOUT=0;
00402                 COM_TX_CNTRL = 0;
00403                 gCOM_PA_COOLING_TIMEOUT.attach(&after_cooling_pa, COM_PA_COOLING_TIME_LIMIT);
00404             }
00405             else{
00406                 gCOM_PA_COOLING_TIMEOUT.detach();
00407                 if( !(gFLAGS & COM_RX_FLAG) ){
00408                     gPC.puts("PA IS COOLED DOWN\r\n");
00409                     gFLAGS = gFLAGS | COM_MNG_TMTC_RUNNING_FLAG;
00410                     RX1M.attach(NULL);
00411                     COM_POWER_ON_TX();
00412                     EXECUTE_OBOSC_ONLY;
00413                     EXECUTE_TC;
00414                 }
00415             }
00416         }
00417         else if( gFLAGS & COM_SESSION_TIMEOUT_FLAG ){
00418             gPC.puts("session timeout: resetting in main\r\n");
00419             COM_POWER_OFF_TX;
00420             /*ENABLE THREADS*/
00421             HK_counter->start(10000);
00422             resume_pl_dma = 1;
00423             gSESSION_TIMEOUT.detach();
00424             gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);
00425             gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
00426             reset_all;
00427         }
00428         else{
00429             gPC.puts("INVALID SIGNAL RECEIVED IN MAIN\r\n");
00430             // SOME INVALID SIGNAL RECEIVED
00431             COM_POWER_OFF_TX;
00432             reset_all;
00433             // ENABLE THREADS
00434             HK_counter->start(10000);
00435             resume_pl_dma = 1;
00436             gSESSION_TIMEOUT.detach();
00437             gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
00438         }
00439         if(resume_pl_dma)
00440         {
00441             
00442             PL_GPIO_2_STATUS=0;
00443            // resume_pl_dma = 0;
00444         }
00445         gPAY_SPI->bulkRead_resume(&payload_isr_fun);
00446         gMutex.unlock();
00447         
00448     }
00449 }
00450 /*
00451 void st_up_isr(void const *args){
00452     gST_UP->signal_set(ST_UP_SIGNAL);\
00453 }
00454 */