shubham c
/
SBC_TEST_CDMS_CODE
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: FreescaleIAP SimpleDMA mbed-rtos mbed
Fork of
CDMS_CODE
by 
shubham c
Embed:
(wiki syntax)
Show/hide line numbers
COM_MNG_TMTC.h
00001 // 8 Jul 00002 // did flowchart of states 00003 00004 // handle sd card with cdms team 00005 00006 // Jun 6 00007 // WHAT IS TC exec code in L1 ack ? 00008 00009 //Jan 7 00010 //added RLY_TMTC function 00011 //added included related files 00012 00013 //#include "Flash.h" 00014 00015 //DigitalIn tm_status_4m_slv(PIN39); //I2C interrupt to CDMS from BAE 00016 //DigitalIn tm_status_4m_pl(PIN61); //I2C interrupt to CDMS from PL 00017 #define RESET_CDMS NVIC_SystemReset() 00018 00019 00020 uint8_t received = 0; 00021 uint16_t mid1; 00022 uint16_t mid2; 00023 uint16_t Nbytes; 00024 uint32_t Data[2]; 00025 uint16_t nbytes; 00026 uint8_t flash_counter = 0; 00027 uint16_t crc16; 00028 uint16_t mid; 00029 uint32_t block; 00030 00031 uint8_t ACK_CODE; 00032 00033 void TM_PMS_PL_SCHEDULE(Base_tm* tm_pointer1,uint8_t psc); 00034 void ACK_L234(Base_tm* tm_pointer_short1,uint8_t ackCode,uint8_t psc); 00035 00036 #define delete_TC(tc_ptr) {\ 00037 if(tc_ptr == gHEAD_NODE_TCL){\ 00038 gHEAD_NODE_TCL = tc_ptr->next_TC;\ 00039 }\ 00040 delete tc_ptr;\ 00041 } 00042 00043 // typeof tm_ptr: Base_tm 00044 // typeof tc_ptr: Base_tc 00045 // typeof temp_xxxx: uint8_t 00046 00047 00048 00049 00050 #define detect_ack(tm_ptr, temp_ack) {\ 00051 if( tm_ptr != NULL ){\ 00052 int length = TM_SHORT_SIZE;\ 00053 if( GETshort_or_long_tm(tm_ptr) == SHORT_TM_CODE ){\ 00054 length = TM_SHORT_SIZE;\ 00055 }\ 00056 else{\ 00057 length = TM_LONG_SIZE;\ 00058 }\ 00059 uint16_t crc = crc16_gen(tm_ptr->TM_string, length-2);\ 00060 if( (((crc & 0xFF00) >> 8) == tm_ptr->TM_string[length-2]) && ( (crc & 0x00FF) == tm_ptr->TM_string[length-1] ) ){\ 00061 uint8_t temp8;\ 00062 temp8 = tm_ptr->TM_string[TM_ACK_CODE_INDEX];\ 00063 temp8 = temp8 & 0xE0;\ 00064 if( (temp8 == 0xC0) || (temp8 == 0xA0) )\ 00065 temp_ack = 0x01;\ 00066 else{\ 00067 temp_ack = 0x02;\ 00068 /*CHECK FOR NACK CODE: CRC FAIL NACK*/\ 00069 temp8 = tm_ptr->TM_string[TM_ACK_CODE_INDEX];\ 00070 temp8 = temp8 & 0x0F;\ 00071 if( temp8 == CRC_FAIL_NACK_CODE ){\ 00072 temp_ack = 0x04;\ 00073 }\ 00074 }\ 00075 }\ 00076 else\ 00077 temp_ack = 0x03;\ 00078 }\ 00079 else{\ 00080 temp_ack = 0x02;\ 00081 }\ 00082 } 00083 00084 #define isit_obosc(tc_ptr, temp_obosc) {\ 00085 temp_obosc = 0x00;\ 00086 if( GETapid(tc_ptr) == APID_COM ){\ 00087 if( ((tc_ptr->TC_string[2]) >> 4) == SERVICE_OBOSC ){\ 00088 temp_obosc = 0x01;\ 00089 }\ 00090 }\ 00091 } 00092 00093 #define isit_sdcard(tc_ptr, temp_sdcard) {\ 00094 temp_sdcard = 0x00;\ 00095 if( GETapid(tc_ptr) == APID_COM ){\ 00096 if( ( (tc_ptr->TC_string[2]) >> 4) == SERVICE_OBSRS ){\ 00097 temp_sdcard = 0x01;\ 00098 }\ 00099 }\ 00100 } 00101 00102 00103 00104 void after_cooling_pa(){ 00105 gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT); 00106 } 00107 00108 /* 00109 @brief: check for missing tc, also check crc, i.e. 00110 if true execution can be started else have to wait 00111 decide the next state 00112 @param: none 00113 @return: bool indicating whether there are missing tc 00114 */ 00115 // PENDING: LAST FRAME BIT 00116 /* 00117 for loop: check for missing tc 00118 if: check for incorrect sized tc 00119 if: check for last frame bit 00120 */ 00121 #define continueToExecute(returnHere) {\ 00122 uint8_t tempReturn = 0x00;\ 00123 /*search for missing psc*/\ 00124 for(uint8_t p = 0x00 ; p < (gTOTAL_VALID_TC) ; ++p){\ 00125 bool flag = false;\ 00126 Base_tc *node_ptr = gHEAD_NODE_TCL;\ 00127 while(node_ptr != NULL){\ 00128 if( (GETpacket_seq_count(node_ptr) == p) && (GETcrc_pass(node_ptr) == 1) ){\ 00129 flag = true;\ 00130 break;\ 00131 }\ 00132 else{\ 00133 node_ptr = node_ptr->next_TC;\ 00134 }\ 00135 }\ 00136 if(flag == false){\ 00137 tempReturn = 0x02;\ 00138 break;\ 00139 }\ 00140 }\ 00141 /*search for last packet bit*/\ 00142 tempReturn = tempReturn + 0x01;\ 00143 Base_tc *tcp = gHEAD_NODE_TCL;\ 00144 while(tcp != NULL){\ 00145 if(GETpacket_seq_count(tcp) == (gTOTAL_VALID_TC - 1)){\ 00146 if( ( (tcp->TC_string[1]) & 0x20 ) == 0x20 ){\ 00147 tempReturn = tempReturn - 0x01;\ 00148 }\ 00149 break;\ 00150 }\ 00151 tcp = tcp->next_TC;\ 00152 }\ 00153 returnHere = tempReturn;\ 00154 /*UPDATE gMASTER STATE*/\ 00155 if( (returnHere == 0x00) ){\ 00156 if( (gMASTER_STATE == TCL_STATE_INCOMPLETE) || (gMASTER_STATE == TCL_STATE_COMPLETED) || (gMASTER_STATE == TCL_STATE_ABORTED) ){\ 00157 gMASTER_STATE = TCL_STATE_EXECUTING;\ 00158 }\ 00159 }\ 00160 else{\ 00161 if( (gMASTER_STATE == TCL_STATE_INCOMPLETE) || (gMASTER_STATE == TCL_STATE_COMPLETED) || (gMASTER_STATE == TCL_STATE_ABORTED) ){\ 00162 gMASTER_STATE = TCL_STATE_INCOMPLETE;\ 00163 }\ 00164 }\ 00165 } 00166 00167 /* 00168 return 1 if code match 00169 return 0 if code mismatch 00170 */ 00171 #define GScodeVerification(returnHere){\ 00172 Base_tc *testTC = gHEAD_NODE_TCL;\ 00173 uint16_t overflowCount = 0;\ 00174 returnHere = 0xFF;\ 00175 while( (overflowCount < TCL_OVERFLOW_CONSTANT) && (testTC != NULL) ){\ 00176 if( (GETpacket_seq_count(testTC) == PSC_CALLSIGN) && (GETapid(testTC) == APID_CALLSIGN) ){\ 00177 /*uint8_t temp8 = testTC->TC_string[1];*/\ 00178 if( true ){\ 00179 for( int i = 2 ; i <= 8 ; ++i ){\ 00180 if( testTC->TC_string[i] != gGSCODE[i-2] ){\ 00181 returnHere = 0;\ 00182 break;\ 00183 }\ 00184 }\ 00185 }\ 00186 break;\ 00187 }\ 00188 testTC = testTC->next_TC;\ 00189 ++overflowCount;\ 00190 }\ 00191 } 00192 00193 /* 00194 @brief: DELETE THE CRC FAILED TC FROM THE LIST TO FREE-UP MEMORY AND UPDATE 00195 THE TOTAL VALID TC AND GENERATE L1_ACK_TM 00196 @param: none 00197 @return: none 00198 */ 00199 /*tm_ptr is the next_TM of a linked list, and should have the value NULL, i.e. tm_ptr should be the next_TM pointer of thte last node */ 00200 00201 /*tm_ptr is the next_TM of a linked list, and should have the value NULL, i.e. tm_ptr should be the next_TM pointer of thte last node */ 00202 00203 // CDMS TEAM CODE START 00204 void ACK_L234(Base_tm* tm_pointer_short1,uint8_t ackCode,uint8_t psc) 00205 { 00206 tm_pointer_short1->TM_string[0] = 0xB0; 00207 tm_pointer_short1->TM_string[1] = psc; 00208 tm_pointer_short1->TM_string[2] = ackCode; 00209 tm_pointer_short1->TM_string[3] = 0x00; 00210 tm_pointer_short1->TM_string[4] = 0x00; 00211 for(uint8_t i=0;i<6;i++) 00212 tm_pointer_short1->TM_string[i+5] = 0; 00213 crc16 = crc16_gen(tm_pointer_short1->TM_string,11); 00214 tm_pointer_short1->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8); 00215 tm_pointer_short1->TM_string[12] = (uint8_t)(crc16&0x00FF); 00216 tm_pointer_short1->next_TM = NULL; 00217 } 00218 void TM_PMS_PL_SCHEDULE(Base_tm *tm_pointer1,uint8_t psc) 00219 { 00220 Base_tm *tm_pointer2 = NULL; 00221 if(!(tm_pointer2 = new Long_tm)) 00222 { 00223 gPC.printf("\n\rError: out of memory"); 00224 return; 00225 } 00226 Base_tm *tm_pointer3 = NULL; 00227 if(!(tm_pointer3 = new Long_tm)) 00228 { 00229 gPC.printf("\n\rError: out of memory"); 00230 return; 00231 } 00232 Base_tm *tm_pointer4 = NULL; 00233 if(!(tm_pointer4 = new Long_tm)) 00234 { 00235 gPC.printf("\n\rError: out of memory"); 00236 return; 00237 } 00238 Base_tm *tm_pointer5 = NULL; 00239 if(!(tm_pointer5 = new Long_tm)) 00240 { 00241 gPC.printf("\n\rError: out of memory"); 00242 return; 00243 } 00244 Base_tm *tm_pointer6 = NULL; 00245 if(!(tm_pointer6 = new Long_tm)) 00246 { 00247 gPC.printf("\n\rError: out of memory"); 00248 return; 00249 } 00250 tm_pointer1->TM_string[0] = 0x48; 00251 tm_pointer1->TM_string[1] = psc; 00252 tm_pointer1->TM_string[2] = 0xA0; 00253 tm_pointer1->TM_string[3] = 0x01; 00254 for(uint8_t i=0;i<128;i+=4) 00255 { 00256 tm_pointer1->TM_string[i+4] = (uint8_t)((pl_block[i/4] & 0xFF000000)>>24); 00257 tm_pointer1->TM_string[i+5] = (uint8_t)((pl_block[i/4] & 0x00FF0000)>>16); 00258 tm_pointer1->TM_string[i+6] = (uint8_t)((pl_block[i/4] & 0x0000FF00)>>8); 00259 tm_pointer1->TM_string[i+7] = (uint8_t)((pl_block[i/4] & 0x000000FF)); 00260 } 00261 crc16 = crc16_gen(tm_pointer1->TM_string,132); 00262 tm_pointer1->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00263 tm_pointer1->TM_string[133] = (uint8_t)(crc16&0x00FF); 00264 tm_pointer1->next_TM = tm_pointer2; 00265 00266 tm_pointer2->TM_string[0] = 0x48; 00267 tm_pointer2->TM_string[1] = psc; 00268 tm_pointer2->TM_string[2] = 0xA0; 00269 tm_pointer2->TM_string[3] = 0x02; 00270 for(uint8_t i=0;i<128;i+=4) 00271 { 00272 tm_pointer2->TM_string[i+4] = (uint8_t)((pl_block[(i/4)+32] & 0xFF000000)>>24); 00273 tm_pointer2->TM_string[i+5] = (uint8_t)((pl_block[(i/4)+32] & 0x00FF0000)>>16); 00274 tm_pointer2->TM_string[i+6] = (uint8_t)((pl_block[(i/4)+32] & 0x0000FF00)>>8); 00275 tm_pointer2->TM_string[i+7] = (uint8_t)((pl_block[(i/4)+32] & 0x000000FF)); 00276 } 00277 crc16 = crc16_gen(tm_pointer2->TM_string,132); 00278 tm_pointer2->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00279 tm_pointer2->TM_string[133] = (uint8_t)(crc16&0x00FF); 00280 tm_pointer2->next_TM = tm_pointer3; 00281 00282 tm_pointer3->TM_string[0] = 0x48; 00283 tm_pointer3->TM_string[1] = psc; 00284 tm_pointer3->TM_string[2] = 0xA0; 00285 tm_pointer3->TM_string[3] = 0x03; 00286 for(uint8_t i=0;i<128;i+=4) 00287 { 00288 tm_pointer3->TM_string[i+4] = (uint8_t)((pl_block[(i/4)+64] & 0xFF000000)>>24); 00289 tm_pointer3->TM_string[i+5] = (uint8_t)((pl_block[(i/4)+64] & 0x00FF0000)>>16); 00290 tm_pointer3->TM_string[i+6] = (uint8_t)((pl_block[(i/4)+64] & 0x0000FF00)>>8); 00291 tm_pointer3->TM_string[i+7] = (uint8_t)((pl_block[(i/4)+64] & 0x000000FF)); 00292 } 00293 crc16 = crc16_gen(tm_pointer3->TM_string,132); 00294 tm_pointer3->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00295 tm_pointer3->TM_string[133] = (uint8_t)(crc16&0x00FF); 00296 tm_pointer3->next_TM = tm_pointer4; 00297 00298 tm_pointer4->TM_string[0] = 0x48; 00299 tm_pointer4->TM_string[1] = psc; 00300 tm_pointer4->TM_string[2] = 0xA0; 00301 tm_pointer4->TM_string[3] = 0x04; 00302 for(uint8_t i=0;i<128;i+=4) 00303 { 00304 tm_pointer4->TM_string[i+4] = (uint8_t)((pl_block[(i/4)+96] & 0xFF000000)>>24); 00305 tm_pointer4->TM_string[i+5] = (uint8_t)((pl_block[(i/4)+96] & 0x00FF0000)>>16); 00306 tm_pointer4->TM_string[i+6] = (uint8_t)((pl_block[(i/4)+96] & 0x0000FF00)>>8); 00307 tm_pointer4->TM_string[i+7] = (uint8_t)((pl_block[(i/4)+96] & 0x000000FF)); 00308 } 00309 crc16 = crc16_gen(tm_pointer4->TM_string,132); 00310 tm_pointer4->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00311 tm_pointer4->TM_string[133] = (uint8_t)(crc16&0x00FF); 00312 tm_pointer4->next_TM = tm_pointer5; 00313 00314 tm_pointer5->TM_string[0] = 0x48; 00315 tm_pointer5->TM_string[1] = psc; 00316 tm_pointer5->TM_string[2] = 0xA0; 00317 tm_pointer5->TM_string[3] = 0x05; 00318 for(uint8_t i=0;i<128;i+=4) 00319 { 00320 tm_pointer5->TM_string[i+4] = (uint8_t)((pl_block[(i/4)+128] & 0xFF000000)>>24); 00321 tm_pointer5->TM_string[i+5] = (uint8_t)((pl_block[(i/4)+128] & 0x00FF0000)>>16); 00322 tm_pointer5->TM_string[i+6] = (uint8_t)((pl_block[(i/4)+128] & 0x0000FF00)>>8); 00323 tm_pointer5->TM_string[i+7] = (uint8_t)((pl_block[(i/4)+128] & 0x000000FF)); 00324 } 00325 crc16 = crc16_gen(tm_pointer5->TM_string,132); 00326 tm_pointer5->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00327 tm_pointer5->TM_string[133] = (uint8_t)(crc16&0x00FF); 00328 tm_pointer5->next_TM = tm_pointer6; 00329 00330 tm_pointer6->TM_string[0] = 0x48; 00331 tm_pointer6->TM_string[1] = psc; 00332 tm_pointer6->TM_string[2] = 0xA0; 00333 tm_pointer6->TM_string[3] = 0x06; 00334 for(uint8_t i=0;i<128;i+=4) 00335 { 00336 tm_pointer6->TM_string[i+4] = (uint8_t)((pl_block[(i/4)+160] & 0xFF000000)>>24); 00337 tm_pointer6->TM_string[i+5] = (uint8_t)((pl_block[(i/4)+160] & 0x00FF0000)>>16); 00338 tm_pointer6->TM_string[i+6] = (uint8_t)((pl_block[(i/4)+160] & 0x0000FF00)>>8); 00339 tm_pointer6->TM_string[i+7] = (uint8_t)((pl_block[(i/4)+160] & 0x000000FF)); 00340 } 00341 crc16 = crc16_gen(tm_pointer6->TM_string,132); 00342 tm_pointer6->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00343 tm_pointer6->TM_string[133] = (uint8_t)(crc16&0x00FF); 00344 tm_pointer6->next_TM = NULL; 00345 } 00346 Base_tm* FCTN_CDMS_RLY_TMTC(Base_tc *tc_ptr) 00347 { 00348 //uint8_t ACKCODE = 0xB0; 00349 bool y; 00350 //gPC.printf("\rTC execution in progress\r\n"); 00351 received = 0; 00352 switch(GETapid(tc_ptr)) //checking APID's 00353 { 00354 case 1: //apid=01 implies it corresponds to bae 00355 { 00356 BAE_I2C_mutex.lock(); 00357 //BAE_TC; 00358 gPC.printf("Telecommand is for BAE\r\n"); 00359 gPC.printf("Sending TC to BAE...\r\n"); //interrupt to be sent to the bae 00360 y = FCTN_I2C_WRITE((char*)tc_ptr->TC_string,TC_LONG_SIZE); // Check for SHORT and LONG TC and then send 00361 00362 if(y==1) 00363 { 00364 gPC.printf("Write fail\r\n"); 00365 Base_tm *tm_ptr_short = new Short_tm; 00366 ACK_L234(tm_ptr_short,0x03,GETpacket_seq_count(tc_ptr)); 00367 return tm_ptr_short; 00368 } 00369 else if(y==0) 00370 { 00371 gPC.printf("Write success\r\n"); 00372 //wait(0.2); 00373 int poll=0; 00374 while(poll<20000 && BAE_I2C_GPIO==0) 00375 { 00376 wait_us(10); 00377 poll+=1; 00378 } 00379 if(BAE_I2C_GPIO == 1) 00380 { 00381 //gPC.printf("BAE_I2C_GPIO is high\r\n"); 00382 Base_tm *tm_ptr = new Long_tm; 00383 y=FCTN_I2C_READ((char*)tm_ptr->TM_string,TM_LONG_SIZE); 00384 if(y==0) 00385 { 00386 gPC.printf("Read success\r\n"); 00387 tm_ptr->next_TM=NULL; 00388 return tm_ptr; 00389 } 00390 else if(y==1) 00391 { 00392 delete tm_ptr; 00393 Base_tm *tm_ptr_short = new Short_tm; 00394 gPC.printf("Read fail\r\n"); 00395 ACK_L234(tm_ptr_short,0x85,GETpacket_seq_count(tc_ptr)); 00396 //gPC.printf("\n\rPTE->PDIR = 0x%08X",PTE->PDIR); 00397 return tm_ptr_short; 00398 } 00399 } 00400 else if(BAE_I2C_GPIO == 0) 00401 { 00402 gPC.printf("BAE_I2C_GPIO is not high\r\n"); 00403 Base_tm *tm_ptr_short = new Short_tm; 00404 ACK_L234(tm_ptr_short,0x84,GETpacket_seq_count(tc_ptr)); 00405 return tm_ptr_short; 00406 } 00407 } 00408 BAE_I2C_mutex.unlock(); 00409 } 00410 00411 case 2: // APID = 2 corresponds to CDMS 00412 { 00413 //gPC.printf("Telecommand is for CDMS\r\n"); //apid = 10 corresponds to cdms 00414 switch(GETservice_type(tc_ptr)) 00415 { 00416 case 0x60: //service type = 0x6 00417 { 00418 gPC.printf("service:MMS\r\n"); 00419 switch(GETservice_subtype(tc_ptr)) 00420 { 00421 case 0x2: //service subtye 00422 { 00423 //gPC.printf("sub_service:Read LONG_RAM_Memory\r\n"); 00424 mid=((uint16_t)(tc_ptr->TC_string[3]<<4))+((uint16_t)(tc_ptr->TC_string[4])); 00425 if(mid!=0x0000 && mid!=0x0001) 00426 { 00427 Base_tm *tm_ptr_short = new Short_tm; 00428 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00429 return tm_ptr_short; 00430 } 00431 Base_tm *tm_ptr = new Long_tm; 00432 tm_ptr->TM_string[0] = 0x30; 00433 tm_ptr->TM_string[1] = GETpacket_seq_count(tc_ptr); 00434 tm_ptr->TM_string[2] = 0xA0; 00435 tm_ptr->TM_string[3] = 0x00; //spare bits 00436 FCTN_CDMS_RD_L_RAM(tm_ptr); 00437 crc16 = crc16_gen(tm_ptr->TM_string,132); 00438 tm_ptr->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00439 tm_ptr->TM_string[133] = (uint8_t)(crc16&0x00FF); 00440 tm_ptr->next_TM = NULL; 00441 return tm_ptr; 00442 } 00443 case 0x5: // change the cases appropriately 00444 { 00445 //gPC.printf("WRITE ON SHORT_FLASH_MEMORY\r\n"); 00446 mid=(uint16_t)(tc_ptr->TC_string[3]<<4)+(uint16_t)(tc_ptr->TC_string[4]); 00447 //32 bits at a time 00448 Base_tm *tm_ptr_short = new Short_tm; 00449 if(mid == 0x0101 || mid==0x0102 || mid == 0x0103 || mid == 0x0100) //allowable MID values? 00450 { 00451 00452 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00453 return tm_ptr_short; 00454 } 00455 00456 FCTN_CDMS_WR_S_FLASH(mid,(uint32_t)(tc_ptr->TC_string[5]<<24)+(uint32_t)(tc_ptr->TC_string[6]<<16)+(uint32_t)(tc_ptr->TC_string[7]<<8)+(uint32_t)(tc_ptr->TC_string[8])); 00457 00458 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00459 00460 return tm_ptr_short; 00461 } 00462 case 0x6: //service subtye = WR_L_FLASH 00463 { 00464 mid=((uint16_t)(tc_ptr->TC_string[3]<<8))+((uint16_t)(tc_ptr->TC_string[4])); 00465 if(mid == 0x0002) 00466 { 00467 for(uint8_t z=0;z<24;z++) 00468 scp_threshold_m0[z] = tc_ptr->TC_string[z+5]; 00469 for(uint8_t z=24;z<32;z++) 00470 scp_threshold_m0[z+8] = tc_ptr->TC_string[z+5]; 00471 //int strt_add = flash_size() - (11*SECTOR_SIZE); 00472 //uint32_t flasharray[32] = {0}; 00473 for(uint8_t z=0;z<24;z++) 00474 flasharray_thres[z] = scp_threshold_m0[z]; 00475 for(uint8_t z=24;z<32;z++) 00476 flasharray_thres[z] = scp_threshold_m0[z+8]; 00477 erase_sector(strt_add_thres); 00478 program_flash(strt_add_thres, (char*)flasharray_thres,32); 00479 Base_tm *tm_ptr_short = new Short_tm; 00480 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00481 return tm_ptr_short; 00482 } 00483 else if(mid == 0x0003) 00484 { 00485 for(uint8_t z=0;z<12;z++) 00486 scp_threshold_m0[z+40] = tc_ptr->TC_string[z+5]; 00487 //int strt_add = flash_size() - (10*SECTOR_SIZE); 00488 //uint32_t flasharray[32] = {0}; 00489 for(uint8_t z=0;z<12;z++) 00490 flasharray_thres[z] = scp_threshold_m0[z+40]; 00491 erase_sector(strt_add_thres+SECTOR_SIZE); 00492 program_flash(strt_add_thres+SECTOR_SIZE, (char*)flasharray_thres,32); 00493 Base_tm *tm_ptr_short = new Short_tm; 00494 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00495 return tm_ptr_short; 00496 } 00497 else if(mid == 0x0004) 00498 { 00499 for(uint8_t z=0;z<32;z++) 00500 scp_threshold_m1[z] = tc_ptr->TC_string[z+5]; 00501 //int strt_add = flash_size() - (9*SECTOR_SIZE); 00502 //uint32_t flasharray[32] = {0}; 00503 for(uint8_t z=0;z<32;z++) 00504 flasharray_thres[z] = scp_threshold_m1[z]; 00505 erase_sector(strt_add_thres+(2*SECTOR_SIZE)); 00506 program_flash(strt_add_thres+(2*SECTOR_SIZE), (char*)flasharray_thres,32); 00507 Base_tm *tm_ptr_short = new Short_tm; 00508 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00509 return tm_ptr_short; 00510 } 00511 else if(mid == 0x0005) 00512 { 00513 for(uint8_t z=0;z<20;z++) 00514 scp_threshold_m1[z+32] = tc_ptr->TC_string[z+5]; 00515 //int strt_add = flash_size() - (8*SECTOR_SIZE); 00516 //uint32_t flasharray[32] = {0}; 00517 for(uint8_t z=0;z<20;z++) 00518 flasharray_thres[z] = scp_threshold_m1[z+32]; 00519 erase_sector(strt_add_thres+(3*SECTOR_SIZE)); 00520 program_flash(strt_add_thres+(3*SECTOR_SIZE), (char*)flasharray_thres,32); 00521 Base_tm *tm_ptr_short = new Short_tm; 00522 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00523 return tm_ptr_short; 00524 } 00525 else if(mid == 0x0006) 00526 { 00527 scp_threshold_m0_1[7] = tc_ptr->TC_string[5]; 00528 scp_threshold_m0_1[5] = tc_ptr->TC_string[6]; 00529 scp_threshold_m0_1[8] = tc_ptr->TC_string[7]; 00530 scp_threshold_m0_1[6] = tc_ptr->TC_string[8]; 00531 for(uint8_t z=0;z<5;z++) 00532 scp_threshold_m0_1[z] = tc_ptr->TC_string[z+9]; 00533 scp_sfp_threshold_m0_2[0] = tc_ptr->TC_string[14]; 00534 scp_sfp_threshold_m0_2[1] = tc_ptr->TC_string[15]; 00535 scp_sfp_threshold_m0_2[2] = tc_ptr->TC_string[16]; 00536 //int strt_add = flash_size() - (7*SECTOR_SIZE); 00537 //uint32_t flasharray[32] = {0}; 00538 flasharray_thres[0] = scp_threshold_m0_1[7]; 00539 flasharray_thres[1] = scp_threshold_m0_1[5]; 00540 flasharray_thres[2] = scp_threshold_m0_1[8]; 00541 flasharray_thres[3] = scp_threshold_m0_1[6]; 00542 for(uint8_t z=0;z<5;z++) 00543 flasharray_thres[z+4] = scp_threshold_m0_1[z]; 00544 flasharray_thres[9] = scp_sfp_threshold_m0_2[0]; 00545 flasharray_thres[10] = scp_sfp_threshold_m0_2[1]; 00546 flasharray_thres[11] = scp_sfp_threshold_m0_2[2]; 00547 erase_sector(strt_add_thres+(4*SECTOR_SIZE)); 00548 program_flash(strt_add_thres+(4*SECTOR_SIZE), (char*)flasharray_thres,32); 00549 Base_tm *tm_ptr_short = new Short_tm; 00550 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00551 return tm_ptr_short; 00552 } 00553 else if(mid == 0x0007) 00554 { 00555 for(uint8_t z=0;z<24;z++) 00556 sfp_threshold_m0[z] = tc_ptr->TC_string[z+5]; 00557 for(uint8_t z=24;z<32;z++) 00558 sfp_threshold_m0[z+8] = tc_ptr->TC_string[z+5]; 00559 //int strt_add_thres = flash_size() - (6*SECTOR_SIZE); 00560 //uint32_t flasharray_thres[32] = {0}; 00561 for(uint8_t z=0;z<24;z++) 00562 flasharray_thres[z] = sfp_threshold_m0[z]; 00563 for(uint8_t z=24;z<32;z++) 00564 flasharray_thres[z] = sfp_threshold_m0[z+8]; 00565 erase_sector(strt_add_thres+(5*SECTOR_SIZE)); 00566 program_flash(strt_add_thres+(5*SECTOR_SIZE), (char*)flasharray_thres,32); 00567 Base_tm *tm_ptr_short = new Short_tm; 00568 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00569 return tm_ptr_short; 00570 } 00571 else if(mid == 0x0008) 00572 { 00573 for(uint8_t z=0;z<12;z++) 00574 sfp_threshold_m0[z+40] = tc_ptr->TC_string[z+5]; 00575 //int strt_add_thres = flash_size() - (5*SECTOR_SIZE); 00576 //uint32_t flasharray_thres[32] = {0}; 00577 for(uint8_t z=0;z<12;z++) 00578 flasharray_thres[z] = sfp_threshold_m0[z+40]; 00579 erase_sector(strt_add_thres+(6*SECTOR_SIZE)); 00580 program_flash(strt_add_thres+(6*SECTOR_SIZE), (char*)flasharray_thres,32); 00581 Base_tm *tm_ptr_short = new Short_tm; 00582 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00583 return tm_ptr_short; 00584 } 00585 else if(mid == 0x0009) 00586 { 00587 for(uint8_t z=0;z<32;z++) 00588 sfp_threshold_m1[z] = tc_ptr->TC_string[z+5]; 00589 //int strt_add_thres = flash_size() - (4*SECTOR_SIZE); 00590 //uint32_t flasharray_thres[32] = {0}; 00591 for(uint8_t z=0;z<32;z++) 00592 flasharray_thres[z] = sfp_threshold_m1[z]; 00593 erase_sector(strt_add_thres+(7*SECTOR_SIZE)); 00594 program_flash(strt_add_thres+(7*SECTOR_SIZE), (char*)flasharray_thres,32); 00595 Base_tm *tm_ptr_short = new Short_tm; 00596 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00597 return tm_ptr_short; 00598 } 00599 else if(mid == 0x000A) 00600 { 00601 for(uint8_t z=0;z<20;z++) 00602 sfp_threshold_m1[z+32] = tc_ptr->TC_string[z+5]; 00603 //int strt_add_thres = flash_size() - (3*SECTOR_SIZE); 00604 //uint32_t flasharray_thres[32] = {0}; 00605 for(uint8_t z=0;z<20;z++) 00606 flasharray_thres[z] = sfp_threshold_m1[z+32]; 00607 erase_sector(strt_add_thres+(8*SECTOR_SIZE)); 00608 program_flash(strt_add_thres+(8*SECTOR_SIZE), (char*)flasharray_thres,32); 00609 Base_tm *tm_ptr_short = new Short_tm; 00610 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00611 return tm_ptr_short; 00612 } 00613 } 00614 default: 00615 { 00616 gPC.printf("INVALID SERVICE SUBTYPE\r\n"); 00617 Base_tm *tm_ptr_short = new Short_tm; 00618 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00619 return tm_ptr_short; 00620 } 00621 } 00622 } 00623 case 0x80: 00624 { 00625 gPC.printf("service:FUNCTION MANAGEMENT SERVICE\r\n"); 00626 if(GETservice_subtype(tc_ptr)==0x1) 00627 { 00628 if(GETpid(tc_ptr)==0x01) 00629 { 00630 Base_tm *tm_ptr_short = new Short_tm; 00631 if(CDMS_STANDBY==1) 00632 { 00633 //gPC.printf("TC_PL_INIT\r\n"); // call PWR_SWCH_ON function 00634 00635 P_PL_INIT(); 00636 00637 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00638 return tm_ptr_short; 00639 } 00640 else if(CDMS_STANDBY==0) 00641 { 00642 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00643 return tm_ptr_short; 00644 } 00645 } 00646 else if(GETpid(tc_ptr)==0x02) 00647 { 00648 Base_tm *tm_ptr_short = new Short_tm; 00649 if(CDMS_STANDBY==1) 00650 { 00651 //gPC.printf("TC_PL_MAIN\r\n"); // call PWR_SWCH_ON function 00652 00653 P_PL_MAIN(); 00654 00655 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00656 return tm_ptr_short; 00657 } 00658 else if(CDMS_STANDBY==0) 00659 { 00660 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00661 return tm_ptr_short; 00662 } 00663 } 00664 else if(GETpid(tc_ptr)==0x03) 00665 { 00666 Base_tm *tm_ptr_short = new Short_tm; 00667 if(CDMS_STANDBY==1) 00668 { 00669 //gPC.printf("PL_COM_INIT\r\n"); // call PWR_SWCH_ON function 00670 00671 P_COM_INIT(); 00672 00673 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00674 return tm_ptr_short; 00675 } 00676 else if(CDMS_STANDBY==0) 00677 { 00678 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00679 return tm_ptr_short; 00680 } 00681 } 00682 else if(GETpid(tc_ptr)==0x04) 00683 { 00684 Base_tm *tm_ptr_short = new Short_tm; 00685 if(CDMS_STANDBY==1) 00686 { 00687 //gPC.printf("TC_P_CDMS_HK_MAIN\r\n"); // call PWR_SWCH_ON function 00688 00689 //gHK_THREAD->signal_set(HK_SIGNAL); 00690 00691 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00692 return tm_ptr_short; 00693 } 00694 else if(CDMS_STANDBY==0) 00695 { 00696 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00697 return tm_ptr_short; 00698 } 00699 } 00700 else if(GETpid(tc_ptr)==0x05) 00701 { 00702 Base_tm *tm_ptr_short = new Short_tm; 00703 if(CDMS_STANDBY==1) 00704 { 00705 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00706 00707 P_PL_RCV_SC_DATA(); 00708 00709 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00710 return tm_ptr_short; 00711 } 00712 else if(CDMS_STANDBY==0) 00713 { 00714 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00715 return tm_ptr_short; 00716 } 00717 } 00718 else if(GETpid(tc_ptr)==0x06) 00719 { 00720 Base_tm *tm_ptr_short = new Short_tm; 00721 if(CDMS_STANDBY==1) 00722 { 00723 //gPC.printf("TC_SW_ON_RTC\r\n"); // call PWR_SWCH_ON function 00724 gPC.printf("SD _INIT\r\n"); 00725 P_CDMS_INIT_SD(); 00726 00727 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00728 return tm_ptr_short; 00729 } 00730 else if(CDMS_STANDBY==0) 00731 { 00732 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00733 return tm_ptr_short; 00734 } 00735 } 00736 else if(GETpid(tc_ptr)==0x11) 00737 { 00738 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00739 00740 CDMS_SD_SW_ON(); 00741 Base_tm *tm_ptr_short = new Short_tm; 00742 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00743 return tm_ptr_short; 00744 } 00745 else if(GETpid(tc_ptr)==0x21) 00746 { 00747 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00748 00749 CDMS_SD_SW_OFF(); 00750 Base_tm *tm_ptr_short = new Short_tm; 00751 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00752 return tm_ptr_short; 00753 } 00754 else if(GETpid(tc_ptr)==0x12) 00755 { 00756 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00757 00758 CDMS_RTC_ON(); 00759 Base_tm *tm_ptr_short = new Short_tm; 00760 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00761 return tm_ptr_short; 00762 } 00763 else if(GETpid(tc_ptr)==0x22) 00764 { 00765 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00766 00767 CDMS_RTC_OFF(); 00768 Base_tm *tm_ptr_short = new Short_tm; 00769 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00770 return tm_ptr_short; 00771 } 00772 else if(GETpid(tc_ptr)==0x13) 00773 { 00774 //gPC.printf("TC_SW_ON_BAE\r\n"); // call PWR_SWCH_ON function 00775 00776 SW_ON_BAE(); 00777 Base_tm *tm_ptr_short = new Short_tm; 00778 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00779 return tm_ptr_short; 00780 } 00781 else if(GETpid(tc_ptr)==0x23) 00782 { 00783 //gPC.printf("TC_SW_OFF_BAE\r\n"); // call PWR_SWCH_ON function 00784 00785 SW_OFF_BAE(); 00786 Base_tm *tm_ptr_short = new Short_tm; 00787 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00788 return tm_ptr_short; 00789 } 00790 else if(GETpid(tc_ptr)==0x14) 00791 { 00792 //gPC.printf("TC_SW_ON_PL_BEE\r\n"); // call PWR_SWCH_ON function 00793 00794 SW_ON_PL_BEE(); 00795 Base_tm *tm_ptr_short = new Short_tm; 00796 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00797 return tm_ptr_short; 00798 } 00799 else if(GETpid(tc_ptr)==0x24) 00800 { 00801 //gPC.printf("TC_SW_OFF_PL_BEE\r\n"); // call PWR_SWCH_ON function 00802 00803 SW_OFF_PL_BEE(); 00804 Base_tm *tm_ptr_short = new Short_tm; 00805 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00806 return tm_ptr_short; 00807 } 00808 else if(GETpid(tc_ptr)==0x15) 00809 { 00810 //gPC.printf("TC_SW_ON_PL_EPS\r\n"); // call PWR_SWCH_ON function 00811 00812 SW_ON_PL_EPS(); 00813 Base_tm *tm_ptr_short = new Short_tm; 00814 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00815 return tm_ptr_short; 00816 } 00817 else if(GETpid(tc_ptr)==0x25) 00818 { 00819 //gPC.printf("TC_SW_OFF_PL_EPS\r\n"); // call PWR_SWCH_ON function 00820 00821 SW_OFF_PL_EPS(); 00822 Base_tm *tm_ptr_short = new Short_tm; 00823 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00824 return tm_ptr_short; 00825 } 00826 else if(GETpid(tc_ptr)==0x16) 00827 { 00828 00829 //gPC.printf("TC_SW_ON_V_A_EN\r\n"); // call PWR_SWCH_ON function 00830 00831 SW_ON_V_A_EN(); 00832 Base_tm *tm_ptr_short = new Short_tm; 00833 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00834 return tm_ptr_short; 00835 } 00836 else if(GETpid(tc_ptr)==0x26) 00837 { 00838 //gPC.printf("TC_SW_OFF_V_A_EN\r\n"); // call PWR_SWCH_ON function 00839 00840 SW_OFF_V_A_EN(); 00841 Base_tm *tm_ptr_short = new Short_tm; 00842 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00843 return tm_ptr_short; 00844 } 00845 else if(GETpid(tc_ptr)==0x31) 00846 { 00847 //gPC.printf("TC_RST_SD\r\n"); // call PWR_SWCH_ON function 00848 00849 RST_SD(); 00850 Base_tm *tm_ptr_short = new Short_tm; 00851 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00852 return tm_ptr_short; 00853 } 00854 else if(GETpid(tc_ptr)==0x33) 00855 { 00856 //gPC.printf("TC_RST_BAE\r\n"); // call PWR_SWCH_ON function 00857 00858 RST_BAE(); 00859 Base_tm *tm_ptr_short = new Short_tm; 00860 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00861 return tm_ptr_short; 00862 } 00863 else if(GETpid(tc_ptr)==0x34) 00864 { 00865 //gPC.printf("TC_RST_PL_BEE\r\n"); // call PWR_SWCH_ON function 00866 00867 RST_PL_BEE(); 00868 Base_tm *tm_ptr_short = new Short_tm; 00869 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00870 return tm_ptr_short; 00871 } 00872 else if(GETpid(tc_ptr)==0x38) 00873 { 00874 //gPC.printf() 00875 00876 CDMS_INTERNAL_RESET(); 00877 Base_tm *tm_ptr_short = new Short_tm; 00878 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00879 } 00880 else if(GETpid(tc_ptr)==0x40) 00881 { 00882 //gPC.printf("RESET_HK_COUNTER\r\n"); // call PWR_SWCH_ON function 00883 00884 STANDBY_PRCS(); 00885 Base_tm *tm_ptr_short = new Short_tm; 00886 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00887 return tm_ptr_short; 00888 } 00889 else if(GETpid(tc_ptr)==0x41) 00890 { 00891 //gPC.printf("RESET_HK_COUNTER\r\n"); // call PWR_SWCH_ON function 00892 00893 RST_HK_COUNTER(); 00894 Base_tm *tm_ptr_short = new Short_tm; 00895 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00896 return tm_ptr_short; 00897 } 00898 else if(GETpid(tc_ptr)==0xF1) 00899 { 00900 //gPC.printf("TC_CDMS_RD_RTC\r\n"); // call PWR_SWCH_ON function 00901 00902 uint32_t time_temp = FCTN_CDMS_RD_RTC(); //RTC_RD_EROR has to incorporated 00903 Base_tm *tm_ptr = new Long_tm; 00904 tm_ptr->TM_string[0] = 0x78; 00905 tm_ptr->TM_string[1] = GETpacket_seq_count(tc_ptr); 00906 tm_ptr->TM_string[2] = 0xA0; 00907 tm_ptr->TM_string[3] = 0x00; 00908 tm_ptr->TM_string[4] = (uint8_t)((time_temp & 0xFF000000)>>24); 00909 tm_ptr->TM_string[5] = (uint8_t)((time_temp & 0x00FF0000)>>16); 00910 tm_ptr->TM_string[6] = (uint8_t)((time_temp & 0x0000FF00)>>8); 00911 tm_ptr->TM_string[7] = (uint8_t)((time_temp & 0x000000FF)); 00912 for(uint8_t i=0;i<124;i++) 00913 { 00914 tm_ptr->TM_string[i+8] = 0x00; 00915 } 00916 crc16 = crc16_gen(tm_ptr->TM_string,132); 00917 tm_ptr->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00918 tm_ptr->TM_string[133] = (uint8_t)(crc16&0x00FF); 00919 tm_ptr->next_TM = NULL; 00920 return tm_ptr; //incomplete 00921 } 00922 else if(GETpid(tc_ptr)==0xF0) 00923 { 00924 uint8_t statusbits[64]; 00925 if( CDMS_RD_SD_HK(statusbits) != 0){ 00926 Base_tm *tm_ptr_short = new Short_tm; 00927 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00928 return tm_ptr_short; 00929 } 00930 else 00931 { 00932 uint32_t time_temp = FCTN_CDMS_RD_RTC(); //RTC_RD_EROR has to incorporated 00933 Base_tm *tm_ptr = new Long_tm; 00934 tm_ptr->TM_string[0] = 0x78; 00935 tm_ptr->TM_string[1] = GETpacket_seq_count(tc_ptr); 00936 tm_ptr->TM_string[2] = 0xA0; // ACK CODE 00937 tm_ptr->TM_string[3] = 0x00; 00938 for(int i=4;i<64;i++) 00939 { 00940 tm_ptr->TM_string[i+4] = (i<68)?statusbits[i]:0x00; 00941 } 00942 for(uint8_t i=68;i<132;i++) 00943 { 00944 tm_ptr->TM_string[i] = 0x00; 00945 } 00946 crc16 = crc16_gen(tm_ptr->TM_string,132); 00947 tm_ptr->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00948 tm_ptr->TM_string[133] = (uint8_t)(crc16&0x00FF); 00949 tm_ptr->next_TM = NULL; //incomplete 00950 return tm_ptr; 00951 } 00952 } 00953 else if(GETpid(tc_ptr)==0xF1) 00954 { 00955 CDMS_CALIB_RTC((uint64_t)(tc_ptr->TC_string[4])<<32 + (uint64_t)(tc_ptr->TC_string[5])<<24 + (uint64_t)(tc_ptr->TC_string[5])<<16 + (uint64_t)(tc_ptr->TC_string[6])<<8 +(uint64_t)(tc_ptr->TC_string[7])); 00956 Base_tm *tm_ptr_short = new Short_tm; 00957 ACK_L234(tm_ptr_short,0xC0,GETpacket_seq_count(tc_ptr)); 00958 return tm_ptr_short; 00959 } 00960 else 00961 { 00962 gPC.printf("INVALID FID\r\n"); 00963 Base_tm *tm_ptr_short = new Short_tm; 00964 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00965 return tm_ptr_short; 00966 } 00967 } 00968 else 00969 { 00970 gPC.printf("INVALID SERVICE SUBTYPE\r\n"); 00971 Base_tm *tm_ptr_short = new Short_tm; 00972 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00973 return tm_ptr_short; 00974 } 00975 } 00976 case 0x70: 00977 { 00978 gPC.printf("\n\n\rService:PAYLOAD MANAGEMENT SERVICE"); 00979 if(GETservice_subtype(tc_ptr)==0x1) //make sure it is LONG TC before executing else INVALID TC 00980 { 00981 gPC.printf("\n\rTC with subtype = 0x1"); 00982 Base_tm *tm_ptr = new Long_tm; 00983 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 00984 for(uint8_t i=0,j=0;i<32;i++) 00985 { 00986 pl_block[i] &= 0x00000000; 00987 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 00988 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 00989 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 00990 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 00991 j+=4; 00992 } 00993 return tm_ptr; 00994 } 00995 else if(GETservice_subtype(tc_ptr)==0x2) 00996 { 00997 gPC.printf("\n\rTC with subtype = 0x2"); 00998 Base_tm *tm_ptr = new Long_tm; 00999 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01000 for(uint8_t i=32,j=0;i<64;i++,j+=4) 01001 { 01002 pl_block[i] &= 0x00000000; 01003 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01004 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01005 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01006 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01007 } 01008 return tm_ptr; 01009 } 01010 else if(GETservice_subtype(tc_ptr)==0x3) 01011 { 01012 gPC.printf("\n\rTC with subtype = 0x3"); 01013 Base_tm *tm_ptr = new Long_tm; 01014 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01015 for(uint8_t i=64,j=0;i<96;i++,j+=4) 01016 { 01017 pl_block[i] &= 0x00000000; 01018 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01019 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01020 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01021 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01022 } 01023 return tm_ptr; 01024 } 01025 else if(GETservice_subtype(tc_ptr)==0x4) 01026 { 01027 gPC.printf("\n\rTC with subtype = 0x4"); 01028 Base_tm *tm_ptr = new Long_tm; 01029 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01030 for(uint8_t i=96,j=0;i<128;i++,j+=4) 01031 { 01032 pl_block[i] &= 0x00000000; 01033 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01034 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01035 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01036 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01037 } 01038 return tm_ptr; 01039 } 01040 else if(GETservice_subtype(tc_ptr)==0x5) 01041 { 01042 gPC.printf("\n\rTC with subtype = 0x5"); 01043 Base_tm *tm_ptr = new Long_tm; 01044 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01045 for(uint8_t i=128,j=0;i<160;i++,j+=4) 01046 { 01047 pl_block[i] &= 0x00000000; 01048 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01049 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01050 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01051 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01052 } 01053 return tm_ptr; 01054 } 01055 else if(GETservice_subtype(tc_ptr)==0x6) 01056 { 01057 gPC.printf("\n\rTC with subtype = 0x6"); 01058 Base_tm *tm_ptr = new Long_tm; 01059 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01060 for(uint8_t i=160,j=0;i<192;i++,j+=4) 01061 { 01062 pl_block[i] &= 0x00000000; 01063 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01064 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01065 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01066 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01067 } 01068 return tm_ptr; 01069 } 01070 else if(GETservice_subtype(tc_ptr)==0xF) 01071 { 01072 gPC.printf("\n\rTC with subtype = 0xF"); 01073 Base_tm *tm_ptr = new Long_tm; 01074 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01075 return tm_ptr; 01076 } 01077 else 01078 { 01079 gPC.printf("INVALID SERVICE SUBTYPE\r\n"); 01080 Base_tm *tm_ptr_short = new Short_tm; 01081 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 01082 return tm_ptr_short; 01083 } 01084 } 01085 default: 01086 { 01087 gPC.printf("ILLEGAL TC"); 01088 Base_tm *tm_ptr_short = new Short_tm; 01089 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 01090 return tm_ptr_short; 01091 } 01092 } 01093 } 01094 case 3: 01095 { 01096 //#if DEBUG 01097 gPC.printf("\n\rTelecommand is for PL\r\n"); 01098 //#endif 01099 if(GETshort_or_long_tc(tc_ptr) == LONG_TC_CODE) 01100 y=FCTN_I2C_WRITE_PL((char*)tc_ptr->TC_string,TC_LONG_SIZE); 01101 else if(GETshort_or_long_tc(tc_ptr) == SHORT_TC_CODE) 01102 y=FCTN_I2C_WRITE_PL((char*)tc_ptr->TC_string,TC_SHORT_SIZE); 01103 01104 if(y==1) 01105 { 01106 Base_tm *tm_ptr_short = new Short_tm; 01107 ACK_L234(tm_ptr_short,0x03,GETpacket_seq_count(tc_ptr)); 01108 return tm_ptr_short; 01109 } 01110 else if(y==0) 01111 { 01112 //wait(0.2); 01113 int poll=0; 01114 while(poll<2000 && PL_I2C_Intr==0) 01115 { 01116 wait_us(10); 01117 poll+=1; 01118 } 01119 if(PL_I2C_Intr == 1) 01120 { 01121 gPC.printf("PL_I2C_Intr is high\r\n"); 01122 Base_tm *tm_ptr = new Long_tm; 01123 y=FCTN_I2C_READ_PL((char*)tm_ptr->TM_string,TM_LONG_SIZE); 01124 if(y==0) 01125 { 01126 tm_ptr->next_TM=NULL; 01127 return tm_ptr; 01128 } 01129 else if(y==1) 01130 { 01131 delete tm_ptr; 01132 Base_tm *tm_ptr_short = new Short_tm; 01133 ACK_L234(tm_ptr_short,0x85,GETpacket_seq_count(tc_ptr)); 01134 //gPC.printf("\n\rPTE->PDIR = 0x%08X",PTE->PDIR); 01135 return tm_ptr_short; 01136 } 01137 } 01138 else if(PL_I2C_Intr == 0) //name to be changed later 01139 { 01140 gPC.printf("PL_I2C_Intr is not high\r\n"); 01141 Base_tm *tm_ptr_short = new Short_tm; 01142 ACK_L234(tm_ptr_short,0x84,GETpacket_seq_count(tc_ptr)); 01143 return tm_ptr_short; 01144 } 01145 } 01146 } 01147 default: //invalid TC 01148 { 01149 gPC.printf("INVALID TC\r\n"); 01150 Base_tm *tm_ptr_short = new Short_tm; 01151 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 01152 return tm_ptr_short; 01153 } 01154 } 01155 //return NULL; 01156 } 01157 // CDMS TEAM CODE END 01158 // EXECUTE OBOSC 01159 #define execute_obosc_core(tc_ptr, tm_ptr, reset_flag) {\ 01160 if (DEBUG)\ 01161 gPC.puts("Inside execute_obosc_core\r\n");\ 01162 uint8_t service_subtype = (tc_ptr->TC_string[2]) & 0x0F;\ 01163 uint8_t temp8 = 0x00;\ 01164 Base_tc *modify_this = gHEAD_NODE_TCL;\ 01165 int modify_overflow = 0x00;\ 01166 switch( service_subtype ){\ 01167 case OBOSC_SUB_DISABLE:\ 01168 /*gPC.puts("target psc are ");*/\ 01169 for(int i = 3 ; i < 9 ; ++i){\ 01170 /*gPC.printf("%u ", tc_ptr->TC_string[i]);*/\ 01171 }\ 01172 /*gPC.puts("\r\n");*/\ 01173 /*gPC.puts("disable type obosc\r\n");*/\ 01174 while( modify_this != NULL ){\ 01175 if( modify_overflow < TCL_OVERFLOW_CONSTANT ){\ 01176 uint8_t modify_psc = GETpacket_seq_count(modify_this);\ 01177 /*gPC.printf("mosify_psc = %u\r\n", modify_psc);*/\ 01178 for( int i = 3 ; i < 9 ; ++i ){\ 01179 uint8_t target_psc = tc_ptr->TC_string[i];\ 01180 if( (target_psc == modify_psc) && (target_psc != 0) ){\ 01181 uint16_t tempExec = TC_STATE_DISABLED;\ 01182 PUTexec_status( modify_this, tempExec );\ 01183 break;\ 01184 }\ 01185 }\ 01186 modify_this = modify_this->next_TC;\ 01187 ++modify_overflow;\ 01188 }\ 01189 else{\ 01190 RESET_CDMS;\ 01191 break;\ 01192 }\ 01193 }\ 01194 break;\ 01195 case OBOSC_SUB_RETRY:\ 01196 /*gPC.puts("retry type obosc\r\n");*/\ 01197 while( modify_this != NULL ){\ 01198 if( modify_overflow < TCL_OVERFLOW_CONSTANT ){\ 01199 uint8_t modify_psc = GETpacket_seq_count(modify_this);\ 01200 for( int i = 3 ; i < 9 ; ++i ){\ 01201 uint8_t target_psc = tc_ptr->TC_string[i];\ 01202 if( (target_psc == modify_psc) && (target_psc != 0) ){\ 01203 uint16_t tempExec = TC_STATE_MARKED_RETRY;\ 01204 PUTexec_status( modify_this, tempExec );\ 01205 /*gPC.puts("reqquired tc found: disable\r\n");*/\ 01206 break;\ 01207 }\ 01208 }\ 01209 modify_this = modify_this->next_TC;\ 01210 ++modify_overflow;\ 01211 }\ 01212 else{\ 01213 RESET_CDMS;\ 01214 break;\ 01215 }\ 01216 }\ 01217 break;\ 01218 }\ 01219 Base_tm *ackl234new = new Short_tm;\ 01220 ackl234new->next_TM = NULL;\ 01221 /*return telemetry pointer here*/\ 01222 tm_ptr = ackl234new;\ 01223 ackl234new->TM_string[0] = TMID_ACK_L234 << 4;\ 01224 ackl234new->TM_string[1] = GETpacket_seq_count(tc_ptr);\ 01225 ackl234new->TM_string[2] = 0xA0;\ 01226 for(int i = 3; i < 11; ++i){\ 01227 ackl234new->TM_string[i] = 0x00;\ 01228 }\ 01229 uint16_t crc = crc16_gen(ackl234new->TM_string, TM_SHORT_SIZE-2);\ 01230 ackl234new->TM_string[11] = (crc & 0xFF00) >> 8;\ 01231 ackl234new->TM_string[12] = crc & 0x00FF;\ 01232 /*ack l234 old*/\ 01233 if( service_subtype == OBOSC_SUB_REP_LE ){\ 01234 if( gLAST_TM_SHORT_OR_LONG == SHORT_TM_CODE ){\ 01235 Base_tm *ackl234old = new Short_tm;\ 01236 ackl234old->next_TM = NULL;\ 01237 /*APPEND TO ACK L234 NEW HERE*/\ 01238 ackl234new->next_TM = ackl234old;\ 01239 for( int i = 0 ; i < TM_SHORT_SIZE ; ++i ){\ 01240 ackl234old->TM_string[i] = gLAST_TM[i];\ 01241 }\ 01242 }\ 01243 else{\ 01244 Base_tm *tempLongTM = new Long_tm;\ 01245 tempLongTM->next_TM = NULL;\ 01246 /*APPEND TO ACK L234 NEW HERE*/\ 01247 ackl234new->next_TM = tempLongTM;\ 01248 for( int i = 0 ; i < TM_LONG_SIZE ; ++i ){\ 01249 tempLongTM->TM_string[i] = gLAST_TM[i];\ 01250 }\ 01251 }\ 01252 }\ 01253 else if( service_subtype == OBOSC_SUB_REP_TCLD ){\ 01254 get_tc_list(ackl234new->next_TM, GETpacket_seq_count(tc_ptr));\ 01255 }\ 01256 else if( service_subtype == OBOSC_SUB_RESET ){\ 01257 /*reset_all;*/\ 01258 reset_flag = 1;\ 01259 /*PENDING: VERIFY reset_all, RESET CDMS*/\ 01260 }\ 01261 else if( (service_subtype != OBOSC_SUB_DISABLE) && (service_subtype != OBOSC_SUB_RETRY) ){\ 01262 /*CHANGE THE ACK CODE TO INVALID TC*/\ 01263 ackl234new->TM_string[2] = 0xAF;\ 01264 }\ 01265 if (DEBUG)\ 01266 gPC.puts("completed obosc\r\n");\ 01267 } 01268 01269 /*tm_ptr is the next_TM of a linked list, and should have the value NULL, i.e. tm_ptr should be the next_TM pointer of thte last node */ 01270 01271 01272 #define EXECUTE_OBOSC_ONLY {\ 01273 gMASTER_STATE = TCL_STATE_EXECUTING;\ 01274 int reset_flag = 0;\ 01275 if (DEBUG)\ 01276 gPC.puts("iNSIDE EXECUTE_OBOSC_ONLY\r\n");\ 01277 Base_tm *obosc_tm_core = NULL;\ 01278 Base_tm *obosc_tm = obosc_tm_core;\ 01279 for(uint8_t execute_psc = PSC_START_VALUE ; execute_psc < gTOTAL_VALID_TC ; ++execute_psc){\ 01280 Base_tc* current_TC = gHEAD_NODE_TCL;\ 01281 int overCount = 0;\ 01282 while( current_TC != NULL ){\ 01283 if( overCount < TCL_OVERFLOW_CONSTANT ){\ 01284 if( (GETcrc_pass(current_TC) == 1) && (GETpacket_seq_count(current_TC) == execute_psc) ){\ 01285 /*CHECK FOR OBOSC*/\ 01286 uint8_t temp82 = 0x00;\ 01287 isit_obosc(current_TC, temp82);\ 01288 if(temp82 == 0x01){\ 01289 uint16_t current_exec_status = GETexec_status(current_TC);\ 01290 if( (current_exec_status == TC_STATE_SUCCESSFULLY_EXECUTED) || (current_exec_status == TC_STATE_DISABLED) )\ 01291 break;\ 01292 else if( (current_exec_status == TC_STATE_UNEXECUTED) || (current_exec_status == TC_STATE_MARKED_RETRY) ){\ 01293 if (DEBUG)\ 01294 gPC.printf("It is obosc: %u\r\n", execute_psc);\ 01295 /*EXECUTION OF OBOSC TC*/\ 01296 /*WARNING: LARGE MEMORY UTILIZATION FOR TC-LIST-REPORT */\ 01297 execute_obosc_core(current_TC, obosc_tm_core, reset_flag);\ 01298 Base_tm *obosc_tm_current = obosc_tm_core;\ 01299 while(obosc_tm_core != NULL){\ 01300 obosc_tm_core = obosc_tm_core->next_TM;\ 01301 }\ 01302 if(obosc_tm_current->TM_string[2] == 0xA0){\ 01303 uint16_t temp16 = TC_STATE_SUCCESSFULLY_EXECUTED;\ 01304 PUTexec_status(current_TC, temp16);\ 01305 }\ 01306 else{\ 01307 uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\ 01308 PUTexec_status(current_TC, temp16);\ 01309 }\ 01310 while( obosc_tm_current != NULL ){\ 01311 int length = TM_SHORT_SIZE;\ 01312 if( GETshort_or_long_tm(obosc_tm_current) == SHORT_TM_CODE ){\ 01313 length = TM_SHORT_SIZE;\ 01314 }\ 01315 else{\ 01316 length = TM_LONG_SIZE;\ 01317 }\ 01318 for(int i = 0 ; i < length ; ++i){\ 01319 /*gPC.putc(obosc_tm_current->TM_string[i]);*/\ 01320 }\ 01321 obosc_tm_current = obosc_tm_current->next_TM;\ 01322 }\ 01323 }\ 01324 }\ 01325 }\ 01326 current_TC = current_TC->next_TC;\ 01327 ++overCount;\ 01328 }\ 01329 else{\ 01330 RESET_CDMS;\ 01331 break;\ 01332 }\ 01333 }\ 01334 }\ 01335 if(obosc_tm_core != NULL){\ 01336 Base_tm *obosc_tm_head = NULL;\ 01337 get_call_sign(obosc_tm_head);\ 01338 Base_tm *obosc_tm_current = obosc_tm_head;\ 01339 get_ack_l1(obosc_tm_current->next_TM);\ 01340 int overflowCountOBONLY = 0;\ 01341 while( obosc_tm_current->next_TM != NULL ){\ 01342 if( overflowCountOBONLY < TM_OVERFLOW_CONSTANT ){\ 01343 obosc_tm_current = obosc_tm_current->next_TM;\ 01344 ++overflowCountOBONLY;\ 01345 }\ 01346 else{\ 01347 RESET_CDMS;\ 01348 break;\ 01349 }\ 01350 }\ 01351 obosc_tm_current->next_TM = obosc_tm;\ 01352 /*Sending OBOSC TM to GS*/\ 01353 /*snd_tm.head_pointer(obosc_tm_head);*/\ 01354 /*transmit_adf;*/\ 01355 /*DELETE THE TM AFTER USE*/\ 01356 obosc_tm_current = obosc_tm_head;\ 01357 int overCount = 0;\ 01358 while( obosc_tm_current != NULL ){\ 01359 if( (overCount < TM_OVERFLOW_CONSTANT) ){\ 01360 Base_tm *temp = obosc_tm_current->next_TM;\ 01361 delete obosc_tm_current;\ 01362 obosc_tm_current = temp;\ 01363 ++overCount;\ 01364 }\ 01365 else{\ 01366 RESET_CDMS;\ 01367 break;\ 01368 }\ 01369 }\ 01370 }\ 01371 if ( reset_flag == 1 ){\ 01372 reset_all;\ 01373 /*Enable threads*/\ 01374 gPAY_SPI->bulkRead_resume(&payload_isr_fun);\ 01375 HK_counter->start(10000);\ 01376 gSESSION_TIMEOUT.detach();\ 01377 }\ 01378 } 01379 01380 #define EXECUTE_TC {\ 01381 gMASTER_STATE = TCL_STATE_EXECUTING;\ 01382 if (DEBUG)\ 01383 gPC.puts("iNSIDE EXECUTE_TC\r\n");\ 01384 /*gPC.printf("%u\r\n", gTOTAL_VALID_TC);*/\ 01385 for(uint8_t execute_psc = PSC_START_VALUE ; execute_psc < gTOTAL_VALID_TC ; ++execute_psc ){\ 01386 if (DEBUG)\ 01387 gPC.printf("executing normal %u\r\n", execute_psc);\ 01388 /*gLEDG = !gLEDG;*/\ 01389 /*gLEDR = !gLEDR;*/\ 01390 Base_tc* current_TC = gHEAD_NODE_TCL;\ 01391 int overflowCount = 0;\ 01392 while(current_TC != NULL){\ 01393 if( overflowCount < TCL_OVERFLOW_CONSTANT ){\ 01394 if( (GETcrc_pass(current_TC) == 1) && (GETpacket_seq_count(current_TC) == execute_psc) ){\ 01395 uint8_t current_exec_status = GETexec_status(current_TC);\ 01396 if( (current_exec_status == TC_STATE_SUCCESSFULLY_EXECUTED) || (current_exec_status == TC_STATE_DISABLED) ){\ 01397 /*gPC.printf("disabled or completed at %u\n", execute_psc);*/\ 01398 if( execute_psc == (gTOTAL_VALID_TC-1) ){\ 01399 /*LAST TC IS EXECUTED*/\ 01400 gMASTER_STATE = TCL_STATE_COMPLETED;\ 01401 }\ 01402 break;\ 01403 }\ 01404 else if( (current_exec_status == TC_STATE_EXECUTION_FAILED) && (GETabort_on_nack(current_TC) == 1) ){\ 01405 /*gPC.printf("abort on nack at %u psc\r\n", execute_psc);*/\ 01406 gMASTER_STATE = TCL_STATE_ABORTED;\ 01407 Base_tm *tm_ptr_head = NULL;\ 01408 get_call_sign(tm_ptr_head);\ 01409 Base_tm *tm_ptr = tm_ptr_head;\ 01410 get_ack_l1(tm_ptr->next_TM);\ 01411 tm_ptr = tm_ptr_head;\ 01412 while( tm_ptr != NULL ){\ 01413 int length = TM_SHORT_SIZE;\ 01414 if( GETshort_or_long_tm(tm_ptr) == SHORT_TM_CODE ){\ 01415 length = TM_SHORT_SIZE;\ 01416 }\ 01417 else{\ 01418 length = TM_LONG_SIZE;\ 01419 }\ 01420 /*gPC.puts("Printing Call Sign, ACK_L1, TM list");*/\ 01421 for(int i = 0 ; i < length ; ++i){\ 01422 /*gPC.putc(tm_ptr->TM_string[i]);*/\ 01423 }\ 01424 tm_ptr = tm_ptr->next_TM;\ 01425 }\ 01426 /*Send only call sign, ACK_L1 to GS*/\ 01427 /*snd_tm.head_pointer(tm_ptr_head);*/\ 01428 /*transmit_adf;*/\ 01429 /*DELETE THE TM AFTER USE*/\ 01430 tm_ptr = tm_ptr_head;\ 01431 int overflowCountExecute = 0;\ 01432 while(tm_ptr != NULL){\ 01433 if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\ 01434 Base_tm *temp = tm_ptr->next_TM;\ 01435 delete tm_ptr;\ 01436 tm_ptr = temp;\ 01437 ++overflowCountExecute;\ 01438 }\ 01439 else{\ 01440 RESET_CDMS;\ 01441 break;\ 01442 }\ 01443 }\ 01444 break;\ 01445 }\ 01446 else if( (current_exec_status == TC_STATE_UNEXECUTED) || (current_exec_status == TC_STATE_MARKED_RETRY) ){\ 01447 /*EXECUTION OF TC START*/\ 01448 uint8_t temp81 = 0x00;\ 01449 isit_sdcard(current_TC, temp81);\ 01450 if( temp81 == 0x00 ){\ 01451 if (DEBUG)\ 01452 gPC.printf("non sd card at %u\r\n", execute_psc);\ 01453 /*EXECUTION OF NON SD-CARD (BOTH OBOSC and CDMS functions)*/\ 01454 Base_tm *tm_ptr_head = NULL;\ 01455 get_call_sign(tm_ptr_head);\ 01456 Base_tm *put_tm_here = NULL;\ 01457 uint8_t temp82 = 0x00;\ 01458 uint8_t tempPAhot = 0x00;\ 01459 isit_obosc(current_TC, temp82);\ 01460 if(temp82 == 0x01){\ 01461 /*gPC.printf("obosc tc inside normal tc at %u\r\n", execute_psc);*/\ 01462 /*EXECUTION OF OBOSC TC*/\ 01463 /*SKIP EXECUTION OF OBOSC HERE*/\ 01464 break;\ 01465 }\ 01466 else{\ 01467 /*gPC.printf("cdms relay tmtc at %u\r\n", execute_psc);*/\ 01468 /*call CDMS_RLY_TMTC*/\ 01469 /*CDMS_RLY_TMTC(current_TC, put_tm_here);*/\ 01470 put_tm_here = FCTN_CDMS_RLY_TMTC(current_TC);\ 01471 }\ 01472 /*DETECT ACK OR NACK*/\ 01473 uint8_t temp83 = 0x00;\ 01474 detect_ack(put_tm_here, temp83);\ 01475 if( temp83 == 0x01){\ 01476 uint16_t temp16 = TC_STATE_SUCCESSFULLY_EXECUTED;\ 01477 PUTexec_status(current_TC, temp16);\ 01478 }\ 01479 else if( temp83 == 0x03){\ 01480 /*gPC.puts("TC_STATE_EXECUTION_UNKNOWN");*/\ 01481 uint16_t temp16 = TC_STATE_EXECUTION_UNKNOWN;\ 01482 PUTexec_status(current_TC, temp16);\ 01483 }\ 01484 else if( temp83 == 0x04){\ 01485 /*gPC.puts("TC_STATE_EXECUTION_UNKNOWN");*/\ 01486 uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\ 01487 PUTexec_status(current_TC, temp16);\ 01488 uint8_t temp84 = GETpacket_seq_count(current_TC);\ 01489 put_tm_here->TM_string[2] = temp84;\ 01490 uint16_t crc16 = crc16_gen(put_tm_here->TM_string, 11);\ 01491 put_tm_here->TM_string[11] = (crc16 & 0xFF00)>>8;\ 01492 put_tm_here->TM_string[12] = (crc16 & 0x00FF);\ 01493 }\ 01494 else{\ 01495 /*gPC.puts("TC_STATE_EXECUTION_FAILED");*/\ 01496 uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\ 01497 PUTexec_status(current_TC, temp16);\ 01498 }\ 01499 /*ABORT ON NACK AND TC LIST COMPLETED: UPDATE IN gMASTERSTATE*/\ 01500 if( ((GETexec_status(current_TC) == TC_STATE_EXECUTION_FAILED) || (GETexec_status(current_TC) == TC_STATE_EXECUTION_UNKNOWN)) && (GETabort_on_nack(current_TC) == 1) ){\ 01501 gMASTER_STATE = TCL_STATE_ABORTED;\ 01502 }\ 01503 else if( execute_psc == (gTOTAL_VALID_TC-1) ){\ 01504 /*LAST TC IS EXECUTED*/\ 01505 gMASTER_STATE = TCL_STATE_COMPLETED;\ 01506 }\ 01507 /*update last executed L1_ack*/\ 01508 if( put_tm_here != NULL ){\ 01509 Base_tm *ptr_tm = put_tm_here;\ 01510 while(ptr_tm->next_TM != NULL)\ 01511 ptr_tm = ptr_tm->next_TM;\ 01512 if( GETshort_or_long_tm(ptr_tm) == SHORT_TM_CODE ){\ 01513 for(int i = 0 ; i < TM_SHORT_SIZE ; ++i){\ 01514 gLAST_TM[i] = ptr_tm->TM_string[i];\ 01515 gLAST_TM_SHORT_OR_LONG = SHORT_TM_CODE;\ 01516 }\ 01517 }\ 01518 else{\ 01519 for( int i = 0 ; i < TM_LONG_SIZE ; ++i ){\ 01520 gLAST_TM[i] = ptr_tm->TM_string[i];\ 01521 gLAST_TM_SHORT_OR_LONG = LONG_TM_CODE;\ 01522 }\ 01523 }\ 01524 }\ 01525 P_COM_HK;\ 01526 Base_tm *tm_ptr = tm_ptr_head;\ 01527 get_ack_l1(tm_ptr->next_TM);\ 01528 int overflowCountExecute = 0;\ 01529 while( tm_ptr->next_TM != NULL ){\ 01530 if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\ 01531 tm_ptr = tm_ptr->next_TM;\ 01532 ++overflowCountExecute;\ 01533 }\ 01534 else{\ 01535 RESET_CDMS;\ 01536 break;\ 01537 }\ 01538 }\ 01539 tm_ptr->next_TM = put_tm_here;\ 01540 tm_ptr = tm_ptr_head;\ 01541 while( tm_ptr != NULL ){\ 01542 int length = TM_SHORT_SIZE;\ 01543 if( GETshort_or_long_tm(tm_ptr) == SHORT_TM_CODE ){\ 01544 length = TM_SHORT_SIZE;\ 01545 }\ 01546 else{\ 01547 length = TM_LONG_SIZE;\ 01548 }\ 01549 /*gPC.puts("Printing Call Sign, ACK_L1, TM list");*/\ 01550 for(int i = 0 ; i < length ; ++i){\ 01551 /*gPC.putc(tm_ptr->TM_string[i]);*/\ 01552 }\ 01553 tm_ptr = tm_ptr->next_TM;\ 01554 }\ 01555 /*SEND call sign, ACK_L1, NON OBSRS TM TO GS*/\ 01556 snd_tm.head_pointer(tm_ptr_head);\ 01557 gPC.puts("enter_adf\r\n");\ 01558 transmit_adf;\ 01559 gPC.puts("exit_adf\r\n");\ 01560 /*DELETE THE TM AFTER USE*/\ 01561 tm_ptr = tm_ptr_head;\ 01562 overflowCountExecute = 0;\ 01563 while(tm_ptr != NULL){\ 01564 if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\ 01565 Base_tm *temp = tm_ptr->next_TM;\ 01566 delete tm_ptr;\ 01567 tm_ptr = temp;\ 01568 ++overflowCountExecute;\ 01569 }\ 01570 else{\ 01571 RESET_CDMS;\ 01572 break;\ 01573 }\ 01574 }\ 01575 }\ 01576 else{\ 01577 if (DEBUG)\ 01578 gPC.printf("sd card at %u\r\n", execute_psc);\ 01579 /*EXECUTION OF SD-CARD DATA SENDING (OBSRS)*/\ 01580 execute_OBSRS_TC(current_TC);\ 01581 gPC.puts("en_adf");\ 01582 transmit_adf;\ 01583 gPC.puts("ex_adf");\ 01584 }\ 01585 }\ 01586 break;\ 01587 }\ 01588 current_TC = current_TC->next_TC;\ 01589 ++overflowCount;\ 01590 }\ 01591 else{\ 01592 RESET_CDMS;\ 01593 break;\ 01594 }\ 01595 }\ 01596 if( gFLAGS & COM_SESSION_TIMEOUT_FLAG ){\ 01597 break;\ 01598 }\ 01599 else if( gMASTER_STATE == TCL_STATE_ABORTED ){\ 01600 if (DEBUG)\ 01601 gPC.puts("ABORTING DUE TO ABORT ON NACK\r\n");\ 01602 /*EXITED DUE TO ABORT ON NACK:*/\ 01603 COM_TX_CNTRL = 0;\ 01604 RX1M.attach(&rx_read, Serial::RxIrq);\ 01605 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\ 01606 break;\ 01607 }\ 01608 else if( (gFLAGS & COM_PA_HOT_FLAG) || (gFLAGS & COM_PA_OC_FLAG) ){\ 01609 /*PA HOT: WAIT FOR TIMEOUT*/\ 01610 gCOM_PA_COOLING_TIMEOUT.attach(&after_cooling_pa, COM_PA_COOLING_TIME_LIMIT);\ 01611 COM_TX_CNTRL = 0;\ 01612 RX1M.attach(&rx_read, Serial::RxIrq);\ 01613 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\ 01614 break;\ 01615 }\ 01616 if (DEBUG)\ 01617 gPC.printf("successflly executed %u tc\r\n", execute_psc);\ 01618 }\ 01619 if( (gMASTER_STATE == TCL_STATE_COMPLETED) || (gFLAGS & COM_SESSION_TIMEOUT_FLAG) ){\ 01620 if (DEBUG)\ 01621 gPC.printf("completed or session timed out: %x\r\n", gMASTER_STATE);\ 01622 /*COMPLETED EXECUTION OF TC*/\ 01623 gMASTER_STATE = TCL_STATE_COMPLETED;\ 01624 COM_POWER_OFF_TX;\ 01625 reset_all;\ 01626 /*ENABLE THREADS*/\ 01627 gPAY_SPI->bulkRead_resume(&payload_isr_fun);\ 01628 HK_counter->start(10000);\ 01629 gSESSION_TIMEOUT.detach();\ 01630 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\ 01631 gFLAGS = gFLAGS & (~COM_SESSION_FLAG);\ 01632 }\ 01633 }
Generated on Fri Jul 15 2022 20:36:46 by
1.7.2