ThreadsAndFunctions.h

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