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