chaithanya rss
for frequency correction testing
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<3000 && BAE_I2C_GPIO==0) 00375 { 00376 wait_ms(1); 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 00437 if(mid == 0x0000) 00438 FCTN_CDMS_RD_L_RAM(tm_ptr); 00439 if(mid == 0x0001) 00440 FCTN_CDMS_MAX_MIN(tm_ptr); 00441 00442 crc16 = crc16_gen(tm_ptr->TM_string,132); 00443 tm_ptr->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00444 tm_ptr->TM_string[133] = (uint8_t)(crc16&0x00FF); 00445 tm_ptr->next_TM = NULL; 00446 return tm_ptr; 00447 } 00448 case 0x5: // change the cases appropriately 00449 { 00450 //gPC.printf("WRITE ON SHORT_FLASH_MEMORY\r\n"); 00451 mid=(uint16_t)(tc_ptr->TC_string[3]<<4)+(uint16_t)(tc_ptr->TC_string[4]); 00452 //32 bits at a time 00453 Base_tm *tm_ptr_short = new Short_tm; 00454 if(mid == 0x0101 || mid==0x0102 || mid == 0x0103 || mid == 0x0100) //allowable MID values? 00455 { 00456 00457 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00458 return tm_ptr_short; 00459 } 00460 00461 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])); 00462 00463 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00464 00465 return tm_ptr_short; 00466 } 00467 case 0x6: //service subtye = WR_L_FLASH 00468 { 00469 mid=((uint16_t)(tc_ptr->TC_string[3]<<8))+((uint16_t)(tc_ptr->TC_string[4])); 00470 if(mid == 0x0002) 00471 { 00472 for(uint8_t z=0;z<24;z++) 00473 scp_threshold_m0[z] = tc_ptr->TC_string[z+5]; 00474 for(uint8_t z=24;z<32;z++) 00475 scp_threshold_m0[z+8] = tc_ptr->TC_string[z+5]; 00476 //int strt_add = flash_size() - (11*SECTOR_SIZE); 00477 //uint32_t flasharray[32] = {0}; 00478 for(uint8_t z=0;z<24;z++) 00479 flasharray_thres[z] = scp_threshold_m0[z]; 00480 for(uint8_t z=24;z<32;z++) 00481 flasharray_thres[z] = scp_threshold_m0[z+8]; 00482 erase_sector(strt_add_thres); 00483 program_flash(strt_add_thres, (char*)flasharray_thres,32); 00484 Base_tm *tm_ptr_short = new Short_tm; 00485 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00486 return tm_ptr_short; 00487 } 00488 else if(mid == 0x0003) 00489 { 00490 for(uint8_t z=0;z<12;z++) 00491 scp_threshold_m0[z+40] = tc_ptr->TC_string[z+5]; 00492 //int strt_add = flash_size() - (10*SECTOR_SIZE); 00493 //uint32_t flasharray[32] = {0}; 00494 for(uint8_t z=0;z<12;z++) 00495 flasharray_thres[z] = scp_threshold_m0[z+40]; 00496 erase_sector(strt_add_thres+SECTOR_SIZE); 00497 program_flash(strt_add_thres+SECTOR_SIZE, (char*)flasharray_thres,32); 00498 Base_tm *tm_ptr_short = new Short_tm; 00499 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00500 return tm_ptr_short; 00501 } 00502 else if(mid == 0x0004) 00503 { 00504 for(uint8_t z=0;z<32;z++) 00505 scp_threshold_m1[z] = tc_ptr->TC_string[z+5]; 00506 //int strt_add = flash_size() - (9*SECTOR_SIZE); 00507 //uint32_t flasharray[32] = {0}; 00508 for(uint8_t z=0;z<32;z++) 00509 flasharray_thres[z] = scp_threshold_m1[z]; 00510 erase_sector(strt_add_thres+(2*SECTOR_SIZE)); 00511 program_flash(strt_add_thres+(2*SECTOR_SIZE), (char*)flasharray_thres,32); 00512 Base_tm *tm_ptr_short = new Short_tm; 00513 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00514 return tm_ptr_short; 00515 } 00516 else if(mid == 0x0005) 00517 { 00518 for(uint8_t z=0;z<20;z++) 00519 scp_threshold_m1[z+32] = tc_ptr->TC_string[z+5]; 00520 //int strt_add = flash_size() - (8*SECTOR_SIZE); 00521 //uint32_t flasharray[32] = {0}; 00522 for(uint8_t z=0;z<20;z++) 00523 flasharray_thres[z] = scp_threshold_m1[z+32]; 00524 erase_sector(strt_add_thres+(3*SECTOR_SIZE)); 00525 program_flash(strt_add_thres+(3*SECTOR_SIZE), (char*)flasharray_thres,32); 00526 Base_tm *tm_ptr_short = new Short_tm; 00527 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00528 return tm_ptr_short; 00529 } 00530 else if(mid == 0x0006) 00531 { 00532 scp_threshold_m0_1[7] = tc_ptr->TC_string[5]; 00533 scp_threshold_m0_1[5] = tc_ptr->TC_string[6]; 00534 scp_threshold_m0_1[8] = tc_ptr->TC_string[7]; 00535 scp_threshold_m0_1[6] = tc_ptr->TC_string[8]; 00536 for(uint8_t z=0;z<5;z++) 00537 scp_threshold_m0_1[z] = tc_ptr->TC_string[z+9]; 00538 scp_sfp_threshold_m0_2[0] = tc_ptr->TC_string[14]; 00539 scp_sfp_threshold_m0_2[1] = tc_ptr->TC_string[15]; 00540 scp_sfp_threshold_m0_2[2] = tc_ptr->TC_string[16]; 00541 //int strt_add = flash_size() - (7*SECTOR_SIZE); 00542 //uint32_t flasharray[32] = {0}; 00543 flasharray_thres[0] = scp_threshold_m0_1[7]; 00544 flasharray_thres[1] = scp_threshold_m0_1[5]; 00545 flasharray_thres[2] = scp_threshold_m0_1[8]; 00546 flasharray_thres[3] = scp_threshold_m0_1[6]; 00547 for(uint8_t z=0;z<5;z++) 00548 flasharray_thres[z+4] = scp_threshold_m0_1[z]; 00549 flasharray_thres[9] = scp_sfp_threshold_m0_2[0]; 00550 flasharray_thres[10] = scp_sfp_threshold_m0_2[1]; 00551 flasharray_thres[11] = scp_sfp_threshold_m0_2[2]; 00552 erase_sector(strt_add_thres+(4*SECTOR_SIZE)); 00553 program_flash(strt_add_thres+(4*SECTOR_SIZE), (char*)flasharray_thres,32); 00554 Base_tm *tm_ptr_short = new Short_tm; 00555 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00556 return tm_ptr_short; 00557 } 00558 else if(mid == 0x0007) 00559 { 00560 for(uint8_t z=0;z<24;z++) 00561 sfp_threshold_m0[z] = tc_ptr->TC_string[z+5]; 00562 for(uint8_t z=24;z<32;z++) 00563 sfp_threshold_m0[z+8] = tc_ptr->TC_string[z+5]; 00564 //int strt_add_thres = flash_size() - (6*SECTOR_SIZE); 00565 //uint32_t flasharray_thres[32] = {0}; 00566 for(uint8_t z=0;z<24;z++) 00567 flasharray_thres[z] = sfp_threshold_m0[z]; 00568 for(uint8_t z=24;z<32;z++) 00569 flasharray_thres[z] = sfp_threshold_m0[z+8]; 00570 erase_sector(strt_add_thres+(5*SECTOR_SIZE)); 00571 program_flash(strt_add_thres+(5*SECTOR_SIZE), (char*)flasharray_thres,32); 00572 Base_tm *tm_ptr_short = new Short_tm; 00573 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00574 return tm_ptr_short; 00575 } 00576 else if(mid == 0x0008) 00577 { 00578 for(uint8_t z=0;z<12;z++) 00579 sfp_threshold_m0[z+40] = tc_ptr->TC_string[z+5]; 00580 //int strt_add_thres = flash_size() - (5*SECTOR_SIZE); 00581 //uint32_t flasharray_thres[32] = {0}; 00582 for(uint8_t z=0;z<12;z++) 00583 flasharray_thres[z] = sfp_threshold_m0[z+40]; 00584 erase_sector(strt_add_thres+(6*SECTOR_SIZE)); 00585 program_flash(strt_add_thres+(6*SECTOR_SIZE), (char*)flasharray_thres,32); 00586 Base_tm *tm_ptr_short = new Short_tm; 00587 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00588 return tm_ptr_short; 00589 } 00590 else if(mid == 0x0009) 00591 { 00592 for(uint8_t z=0;z<32;z++) 00593 sfp_threshold_m1[z] = tc_ptr->TC_string[z+5]; 00594 //int strt_add_thres = flash_size() - (4*SECTOR_SIZE); 00595 //uint32_t flasharray_thres[32] = {0}; 00596 for(uint8_t z=0;z<32;z++) 00597 flasharray_thres[z] = sfp_threshold_m1[z]; 00598 erase_sector(strt_add_thres+(7*SECTOR_SIZE)); 00599 program_flash(strt_add_thres+(7*SECTOR_SIZE), (char*)flasharray_thres,32); 00600 Base_tm *tm_ptr_short = new Short_tm; 00601 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00602 return tm_ptr_short; 00603 } 00604 else if(mid == 0x000A) 00605 { 00606 for(uint8_t z=0;z<20;z++) 00607 sfp_threshold_m1[z+32] = tc_ptr->TC_string[z+5]; 00608 //int strt_add_thres = flash_size() - (3*SECTOR_SIZE); 00609 //uint32_t flasharray_thres[32] = {0}; 00610 for(uint8_t z=0;z<20;z++) 00611 flasharray_thres[z] = sfp_threshold_m1[z+32]; 00612 erase_sector(strt_add_thres+(8*SECTOR_SIZE)); 00613 program_flash(strt_add_thres+(8*SECTOR_SIZE), (char*)flasharray_thres,32); 00614 Base_tm *tm_ptr_short = new Short_tm; 00615 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00616 return tm_ptr_short; 00617 } 00618 } 00619 default: 00620 { 00621 gPC.printf("INVALID SERVICE SUBTYPE\r\n"); 00622 Base_tm *tm_ptr_short = new Short_tm; 00623 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00624 return tm_ptr_short; 00625 } 00626 } 00627 } 00628 case 0x80: 00629 { 00630 gPC.printf("service:FUNCTION MANAGEMENT SERVICE\r\n"); 00631 if(GETservice_subtype(tc_ptr)==0x1) 00632 { 00633 if(GETpid(tc_ptr)==0x01) 00634 { 00635 Base_tm *tm_ptr_short = new Short_tm; 00636 if(CDMS_STANDBY==1) 00637 { 00638 //gPC.printf("TC_PL_INIT\r\n"); // call PWR_SWCH_ON function 00639 00640 P_PL_INIT(); 00641 00642 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00643 return tm_ptr_short; 00644 } 00645 else if(CDMS_STANDBY==0) 00646 { 00647 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00648 return tm_ptr_short; 00649 } 00650 } 00651 else if(GETpid(tc_ptr)==0x02) 00652 { 00653 Base_tm *tm_ptr_short = new Short_tm; 00654 if(CDMS_STANDBY==1) 00655 { 00656 //gPC.printf("TC_PL_MAIN\r\n"); // call PWR_SWCH_ON function 00657 00658 P_PL_MAIN(); 00659 00660 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00661 return tm_ptr_short; 00662 } 00663 else if(CDMS_STANDBY==0) 00664 { 00665 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00666 return tm_ptr_short; 00667 } 00668 } 00669 else if(GETpid(tc_ptr)==0x03) 00670 { 00671 Base_tm *tm_ptr_short = new Short_tm; 00672 if(CDMS_STANDBY==1) 00673 { 00674 //gPC.printf("PL_COM_INIT\r\n"); // call PWR_SWCH_ON function 00675 00676 P_COM_INIT(); 00677 00678 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00679 return tm_ptr_short; 00680 } 00681 else if(CDMS_STANDBY==0) 00682 { 00683 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00684 return tm_ptr_short; 00685 } 00686 } 00687 else if(GETpid(tc_ptr)==0x04) 00688 { 00689 Base_tm *tm_ptr_short = new Short_tm; 00690 if(CDMS_STANDBY==1) 00691 { 00692 //gPC.printf("TC_P_CDMS_HK_MAIN\r\n"); // call PWR_SWCH_ON function 00693 00694 //gHK_THREAD->signal_set(HK_SIGNAL); 00695 00696 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00697 return tm_ptr_short; 00698 } 00699 else if(CDMS_STANDBY==0) 00700 { 00701 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00702 return tm_ptr_short; 00703 } 00704 } 00705 else if(GETpid(tc_ptr)==0x05) 00706 { 00707 Base_tm *tm_ptr_short = new Short_tm; 00708 if(CDMS_STANDBY==1) 00709 { 00710 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00711 00712 P_PL_RCV_SC_DATA(); 00713 00714 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00715 return tm_ptr_short; 00716 } 00717 else if(CDMS_STANDBY==0) 00718 { 00719 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00720 return tm_ptr_short; 00721 } 00722 } 00723 else if(GETpid(tc_ptr)==0x06) 00724 { 00725 Base_tm *tm_ptr_short = new Short_tm; 00726 if(CDMS_STANDBY==1) 00727 { 00728 //gPC.printf("TC_SW_ON_RTC\r\n"); // call PWR_SWCH_ON function 00729 gPC.printf("SD _INIT\r\n"); 00730 P_CDMS_INIT_SD(); 00731 00732 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00733 return tm_ptr_short; 00734 } 00735 else if(CDMS_STANDBY==0) 00736 { 00737 ACK_L234(tm_ptr_short,0x87,GETpacket_seq_count(tc_ptr)); //TC cannot be processed now 00738 return tm_ptr_short; 00739 } 00740 } 00741 else if(GETpid(tc_ptr)==0x11) 00742 { 00743 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00744 00745 CDMS_SD_SW_ON(); 00746 Base_tm *tm_ptr_short = new Short_tm; 00747 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00748 return tm_ptr_short; 00749 } 00750 else if(GETpid(tc_ptr)==0x21) 00751 { 00752 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00753 00754 CDMS_SD_SW_OFF(); 00755 Base_tm *tm_ptr_short = new Short_tm; 00756 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00757 return tm_ptr_short; 00758 } 00759 else if(GETpid(tc_ptr)==0x12) 00760 { 00761 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00762 00763 CDMS_RTC_ON(); 00764 Base_tm *tm_ptr_short = new Short_tm; 00765 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00766 return tm_ptr_short; 00767 } 00768 else if(GETpid(tc_ptr)==0x22) 00769 { 00770 //gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function 00771 00772 CDMS_RTC_OFF(); 00773 Base_tm *tm_ptr_short = new Short_tm; 00774 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00775 return tm_ptr_short; 00776 } 00777 else if(GETpid(tc_ptr)==0x13) 00778 { 00779 //gPC.printf("TC_SW_ON_BAE\r\n"); // call PWR_SWCH_ON function 00780 00781 SW_ON_BAE(); 00782 Base_tm *tm_ptr_short = new Short_tm; 00783 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00784 return tm_ptr_short; 00785 } 00786 else if(GETpid(tc_ptr)==0x23) 00787 { 00788 //gPC.printf("TC_SW_OFF_BAE\r\n"); // call PWR_SWCH_ON function 00789 00790 SW_OFF_BAE(); 00791 Base_tm *tm_ptr_short = new Short_tm; 00792 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00793 return tm_ptr_short; 00794 } 00795 else if(GETpid(tc_ptr)==0x14) 00796 { 00797 //gPC.printf("TC_SW_ON_PL_BEE\r\n"); // call PWR_SWCH_ON function 00798 00799 SW_ON_PL_BEE(); 00800 Base_tm *tm_ptr_short = new Short_tm; 00801 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00802 return tm_ptr_short; 00803 } 00804 else if(GETpid(tc_ptr)==0x24) 00805 { 00806 //gPC.printf("TC_SW_OFF_PL_BEE\r\n"); // call PWR_SWCH_ON function 00807 00808 SW_OFF_PL_BEE(); 00809 Base_tm *tm_ptr_short = new Short_tm; 00810 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00811 return tm_ptr_short; 00812 } 00813 else if(GETpid(tc_ptr)==0x15) 00814 { 00815 //gPC.printf("TC_SW_ON_PL_EPS\r\n"); // call PWR_SWCH_ON function 00816 00817 SW_ON_PL_EPS(); 00818 Base_tm *tm_ptr_short = new Short_tm; 00819 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00820 return tm_ptr_short; 00821 } 00822 else if(GETpid(tc_ptr)==0x25) 00823 { 00824 //gPC.printf("TC_SW_OFF_PL_EPS\r\n"); // call PWR_SWCH_ON function 00825 00826 SW_OFF_PL_EPS(); 00827 Base_tm *tm_ptr_short = new Short_tm; 00828 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00829 return tm_ptr_short; 00830 } 00831 else if(GETpid(tc_ptr)==0x16) 00832 { 00833 00834 //gPC.printf("TC_SW_ON_V_A_EN\r\n"); // call PWR_SWCH_ON function 00835 00836 SW_ON_V_A_EN(); 00837 Base_tm *tm_ptr_short = new Short_tm; 00838 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00839 return tm_ptr_short; 00840 } 00841 else if(GETpid(tc_ptr)==0x26) 00842 { 00843 //gPC.printf("TC_SW_OFF_V_A_EN\r\n"); // call PWR_SWCH_ON function 00844 00845 SW_OFF_V_A_EN(); 00846 Base_tm *tm_ptr_short = new Short_tm; 00847 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00848 return tm_ptr_short; 00849 } 00850 else if(GETpid(tc_ptr)==0x31) 00851 { 00852 //gPC.printf("TC_RST_SD\r\n"); // call PWR_SWCH_ON function 00853 00854 RST_SD(); 00855 Base_tm *tm_ptr_short = new Short_tm; 00856 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00857 return tm_ptr_short; 00858 } 00859 else if(GETpid(tc_ptr)==0x33) 00860 { 00861 //gPC.printf("TC_RST_BAE\r\n"); // call PWR_SWCH_ON function 00862 00863 RST_BAE(); 00864 Base_tm *tm_ptr_short = new Short_tm; 00865 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00866 return tm_ptr_short; 00867 } 00868 else if(GETpid(tc_ptr)==0x34) 00869 { 00870 //gPC.printf("TC_RST_PL_BEE\r\n"); // call PWR_SWCH_ON function 00871 00872 RST_PL_BEE(); 00873 Base_tm *tm_ptr_short = new Short_tm; 00874 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00875 return tm_ptr_short; 00876 } 00877 else if(GETpid(tc_ptr)==0x38) 00878 { 00879 //gPC.printf() 00880 00881 CDMS_INTERNAL_RESET(); 00882 Base_tm *tm_ptr_short = new Short_tm; 00883 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00884 } 00885 else if(GETpid(tc_ptr)==0x40) 00886 { 00887 //gPC.printf("RESET_HK_COUNTER\r\n"); // call PWR_SWCH_ON function 00888 00889 if(tc_ptr->TC_string[4] == 0x00 || tc_ptr->TC_string[4] == 0x01) 00890 EN_PL = tc_ptr->TC_string[4]; 00891 else if(tc_ptr->TC_string[5] == 0x00 || tc_ptr->TC_string[5] == 0x01) 00892 EN_CDMS_HK = tc_ptr->TC_string[5]; 00893 else if(tc_ptr->TC_string[6] == 0x00 || tc_ptr->TC_string[6] == 0x01) 00894 EN_RCV_SC = tc_ptr->TC_string[6]; 00895 00896 Base_tm *tm_ptr_short = new Short_tm; 00897 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00898 return tm_ptr_short; 00899 } 00900 else if(GETpid(tc_ptr)==0x41) 00901 { 00902 //gPC.printf("RESET_HK_COUNTER\r\n"); // call PWR_SWCH_ON function 00903 00904 RST_HK_COUNTER(); 00905 Base_tm *tm_ptr_short = new Short_tm; 00906 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00907 return tm_ptr_short; 00908 } 00909 else if(GETpid(tc_ptr)==0xF1) 00910 { 00911 //gPC.printf("TC_CDMS_RD_RTC\r\n"); // call PWR_SWCH_ON function 00912 00913 uint32_t time_temp = FCTN_CDMS_RD_RTC(); //RTC_RD_EROR has to incorporated 00914 Base_tm *tm_ptr = new Long_tm; 00915 tm_ptr->TM_string[0] = 0x78; 00916 tm_ptr->TM_string[1] = GETpacket_seq_count(tc_ptr); 00917 tm_ptr->TM_string[2] = 0xA0; 00918 tm_ptr->TM_string[3] = 0x00; 00919 tm_ptr->TM_string[4] = (uint8_t)((time_temp & 0xFF000000)>>24); 00920 tm_ptr->TM_string[5] = (uint8_t)((time_temp & 0x00FF0000)>>16); 00921 tm_ptr->TM_string[6] = (uint8_t)((time_temp & 0x0000FF00)>>8); 00922 tm_ptr->TM_string[7] = (uint8_t)((time_temp & 0x000000FF)); 00923 for(uint8_t i=0;i<124;i++) 00924 { 00925 tm_ptr->TM_string[i+8] = 0x00; 00926 } 00927 crc16 = crc16_gen(tm_ptr->TM_string,132); 00928 tm_ptr->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00929 tm_ptr->TM_string[133] = (uint8_t)(crc16&0x00FF); 00930 tm_ptr->next_TM = NULL; 00931 return tm_ptr; //incomplete 00932 } 00933 else if(GETpid(tc_ptr)==0xF0) 00934 { 00935 uint8_t statusbits[64]; 00936 if( CDMS_RD_SD_HK(statusbits) != 0){ 00937 Base_tm *tm_ptr_short = new Short_tm; 00938 ACK_L234(tm_ptr_short,0xA0,GETpacket_seq_count(tc_ptr)); 00939 return tm_ptr_short; 00940 } 00941 else 00942 { 00943 uint32_t time_temp = FCTN_CDMS_RD_RTC(); //RTC_RD_EROR has to incorporated 00944 Base_tm *tm_ptr = new Long_tm; 00945 tm_ptr->TM_string[0] = 0x78; 00946 tm_ptr->TM_string[1] = GETpacket_seq_count(tc_ptr); 00947 tm_ptr->TM_string[2] = 0xA0; // ACK CODE 00948 tm_ptr->TM_string[3] = 0x00; 00949 for(int i=4;i<64;i++) 00950 { 00951 tm_ptr->TM_string[i+4] = (i<68)?statusbits[i]:0x00; 00952 } 00953 for(uint8_t i=68;i<132;i++) 00954 { 00955 tm_ptr->TM_string[i] = 0x00; 00956 } 00957 crc16 = crc16_gen(tm_ptr->TM_string,132); 00958 tm_ptr->TM_string[132] = (uint8_t)((crc16&0xFF00)>>8); 00959 tm_ptr->TM_string[133] = (uint8_t)(crc16&0x00FF); 00960 tm_ptr->next_TM = NULL; //incomplete 00961 return tm_ptr; 00962 } 00963 } 00964 else if(GETpid(tc_ptr)==0xF1) 00965 { 00966 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])); 00967 Base_tm *tm_ptr_short = new Short_tm; 00968 ACK_L234(tm_ptr_short,0xC0,GETpacket_seq_count(tc_ptr)); 00969 return tm_ptr_short; 00970 } 00971 else 00972 { 00973 gPC.printf("INVALID FID\r\n"); 00974 Base_tm *tm_ptr_short = new Short_tm; 00975 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00976 return tm_ptr_short; 00977 } 00978 } 00979 else 00980 { 00981 gPC.printf("INVALID SERVICE SUBTYPE\r\n"); 00982 Base_tm *tm_ptr_short = new Short_tm; 00983 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 00984 return tm_ptr_short; 00985 } 00986 } 00987 case 0x70: 00988 { 00989 gPC.printf("\n\n\rService:PAYLOAD MANAGEMENT SERVICE"); 00990 if(GETservice_subtype(tc_ptr)==0x1) //make sure it is LONG TC before executing else INVALID TC 00991 { 00992 gPC.printf("\n\rTC with subtype = 0x1"); 00993 Base_tm *tm_ptr = new Long_tm; 00994 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 00995 for(uint8_t i=0,j=0;i<32;i++) 00996 { 00997 pl_block[i] &= 0x00000000; 00998 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 00999 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01000 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01001 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01002 j+=4; 01003 } 01004 return tm_ptr; 01005 } 01006 else if(GETservice_subtype(tc_ptr)==0x2) 01007 { 01008 gPC.printf("\n\rTC with subtype = 0x2"); 01009 Base_tm *tm_ptr = new Long_tm; 01010 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01011 for(uint8_t i=32,j=0;i<64;i++,j+=4) 01012 { 01013 pl_block[i] &= 0x00000000; 01014 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01015 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01016 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01017 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01018 } 01019 return tm_ptr; 01020 } 01021 else if(GETservice_subtype(tc_ptr)==0x3) 01022 { 01023 gPC.printf("\n\rTC with subtype = 0x3"); 01024 Base_tm *tm_ptr = new Long_tm; 01025 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01026 for(uint8_t i=64,j=0;i<96;i++,j+=4) 01027 { 01028 pl_block[i] &= 0x00000000; 01029 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01030 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01031 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01032 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01033 } 01034 return tm_ptr; 01035 } 01036 else if(GETservice_subtype(tc_ptr)==0x4) 01037 { 01038 gPC.printf("\n\rTC with subtype = 0x4"); 01039 Base_tm *tm_ptr = new Long_tm; 01040 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01041 for(uint8_t i=96,j=0;i<128;i++,j+=4) 01042 { 01043 pl_block[i] &= 0x00000000; 01044 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01045 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01046 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01047 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01048 } 01049 return tm_ptr; 01050 } 01051 else if(GETservice_subtype(tc_ptr)==0x5) 01052 { 01053 gPC.printf("\n\rTC with subtype = 0x5"); 01054 Base_tm *tm_ptr = new Long_tm; 01055 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01056 for(uint8_t i=128,j=0;i<160;i++,j+=4) 01057 { 01058 pl_block[i] &= 0x00000000; 01059 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01060 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01061 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01062 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01063 } 01064 return tm_ptr; 01065 } 01066 else if(GETservice_subtype(tc_ptr)==0x6) 01067 { 01068 gPC.printf("\n\rTC with subtype = 0x6"); 01069 Base_tm *tm_ptr = new Long_tm; 01070 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01071 for(uint8_t i=160,j=0;i<192;i++,j+=4) 01072 { 01073 pl_block[i] &= 0x00000000; 01074 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[3+j]))<<24); 01075 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[4+j]))<<16); 01076 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[5+j]))<<8); 01077 pl_block[i] |= (((uint32_t)(tc_ptr->TC_string[6+j]))); 01078 } 01079 return tm_ptr; 01080 } 01081 else if(GETservice_subtype(tc_ptr)==0xF) 01082 { 01083 gPC.printf("\n\rTC with subtype = 0xF"); 01084 Base_tm *tm_ptr = new Long_tm; 01085 TM_PMS_PL_SCHEDULE(tm_ptr,GETpacket_seq_count(tc_ptr)); 01086 return tm_ptr; 01087 } 01088 else 01089 { 01090 gPC.printf("INVALID SERVICE SUBTYPE\r\n"); 01091 Base_tm *tm_ptr_short = new Short_tm; 01092 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 01093 return tm_ptr_short; 01094 } 01095 } 01096 default: 01097 { 01098 gPC.printf("ILLEGAL TC"); 01099 Base_tm *tm_ptr_short = new Short_tm; 01100 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 01101 return tm_ptr_short; 01102 } 01103 } 01104 } 01105 case 3: 01106 { 01107 //#if DEBUG 01108 gPC.printf("\n\rTelecommand is for PL\r\n"); 01109 //#endif 01110 if(GETshort_or_long_tc(tc_ptr) == LONG_TC_CODE) 01111 y=FCTN_I2C_WRITE_PL((char*)tc_ptr->TC_string,TC_LONG_SIZE); 01112 else if(GETshort_or_long_tc(tc_ptr) == SHORT_TC_CODE) 01113 y=FCTN_I2C_WRITE_PL((char*)tc_ptr->TC_string,TC_SHORT_SIZE); 01114 01115 if(y==1) 01116 { 01117 Base_tm *tm_ptr_short = new Short_tm; 01118 ACK_L234(tm_ptr_short,0x03,GETpacket_seq_count(tc_ptr)); 01119 return tm_ptr_short; 01120 } 01121 else if(y==0) 01122 { 01123 //wait(0.2); 01124 int poll=0; 01125 while(poll<2000 && PL_I2C_Intr==0) 01126 { 01127 wait_us(10); 01128 poll+=1; 01129 } 01130 if(PL_I2C_Intr == 1) 01131 { 01132 gPC.printf("\n\rPL_I2C_Intr is high"); 01133 Base_tm *tm_ptr = new Long_tm; 01134 y=FCTN_I2C_READ_PL((char*)tm_ptr->TM_string,TM_LONG_SIZE); 01135 gPC.printf("\n\r"); 01136 for(int i = 0;i<134;i++) 01137 gPC.printf("%X",(int)(tm_ptr->TM_string[i])); 01138 if(y==0) 01139 { 01140 tm_ptr->next_TM=NULL; 01141 return tm_ptr; 01142 } 01143 else if(y==1) 01144 { 01145 gPC.printf("\n\rPL_TM read failure"); 01146 delete tm_ptr; 01147 Base_tm *tm_ptr_short = new Short_tm; 01148 ACK_L234(tm_ptr_short,0x85,GETpacket_seq_count(tc_ptr)); 01149 gPC.printf("\n\r0x85"); 01150 return tm_ptr_short; 01151 } 01152 } 01153 else if(PL_I2C_Intr == 0) //name to be changed later 01154 { 01155 gPC.printf("\n\rPL_I2C_Intr is not high"); 01156 Base_tm *tm_ptr_short = new Short_tm; 01157 ACK_L234(tm_ptr_short,0x84,GETpacket_seq_count(tc_ptr)); 01158 return tm_ptr_short; 01159 } 01160 } 01161 } 01162 default: //invalid TC 01163 { 01164 gPC.printf("\n\rINVALID TC"); 01165 Base_tm *tm_ptr_short = new Short_tm; 01166 ACK_L234(tm_ptr_short,0x02,GETpacket_seq_count(tc_ptr)); 01167 return tm_ptr_short; 01168 } 01169 } 01170 //return NULL; 01171 } 01172 // CDMS TEAM CODE END 01173 // EXECUTE OBOSC 01174 #define execute_obosc_core(tc_ptr, tm_ptr, reset_flag) {\ 01175 if (DEBUG)\ 01176 /*gPC.puts("Inside execute_obosc_core\r\n")*/;\ 01177 uint8_t service_subtype = (tc_ptr->TC_string[2]) & 0x0F;\ 01178 uint8_t temp8 = 0x00;\ 01179 Base_tc *modify_this = gHEAD_NODE_TCL;\ 01180 int modify_overflow = 0x00;\ 01181 switch( service_subtype ){\ 01182 case OBOSC_SUB_DISABLE:\ 01183 /*gPC.puts("target psc are ");*/\ 01184 for(int i = 3 ; i < 9 ; ++i){\ 01185 /*gPC.printf("%u ", tc_ptr->TC_string[i]);*/\ 01186 }\ 01187 /*gPC.puts("\r\n");*/\ 01188 /*gPC.puts("disable type obosc\r\n");*/\ 01189 while( modify_this != NULL ){\ 01190 if( modify_overflow < TCL_OVERFLOW_CONSTANT ){\ 01191 uint8_t modify_psc = GETpacket_seq_count(modify_this);\ 01192 /*gPC.printf("mosify_psc = %u\r\n", modify_psc);*/\ 01193 for( int i = 3 ; i < 9 ; ++i ){\ 01194 uint8_t target_psc = tc_ptr->TC_string[i];\ 01195 if( (target_psc == modify_psc) && (target_psc != 0) ){\ 01196 uint16_t tempExec = TC_STATE_DISABLED;\ 01197 PUTexec_status( modify_this, tempExec );\ 01198 break;\ 01199 }\ 01200 }\ 01201 modify_this = modify_this->next_TC;\ 01202 ++modify_overflow;\ 01203 }\ 01204 else{\ 01205 RESET_CDMS;\ 01206 break;\ 01207 }\ 01208 }\ 01209 break;\ 01210 case OBOSC_SUB_RETRY:\ 01211 /*gPC.puts("retry type obosc\r\n");*/\ 01212 while( modify_this != NULL ){\ 01213 if( modify_overflow < TCL_OVERFLOW_CONSTANT ){\ 01214 uint8_t modify_psc = GETpacket_seq_count(modify_this);\ 01215 for( int i = 3 ; i < 9 ; ++i ){\ 01216 uint8_t target_psc = tc_ptr->TC_string[i];\ 01217 if( (target_psc == modify_psc) && (target_psc != 0) ){\ 01218 uint16_t tempExec = TC_STATE_MARKED_RETRY;\ 01219 PUTexec_status( modify_this, tempExec );\ 01220 /*gPC.puts("reqquired tc found: disable\r\n");*/\ 01221 break;\ 01222 }\ 01223 }\ 01224 modify_this = modify_this->next_TC;\ 01225 ++modify_overflow;\ 01226 }\ 01227 else{\ 01228 RESET_CDMS;\ 01229 break;\ 01230 }\ 01231 }\ 01232 break;\ 01233 }\ 01234 Base_tm *ackl234new = new Short_tm;\ 01235 ackl234new->next_TM = NULL;\ 01236 /*return telemetry pointer here*/\ 01237 tm_ptr = ackl234new;\ 01238 ackl234new->TM_string[0] = TMID_ACK_L234 << 4;\ 01239 ackl234new->TM_string[1] = GETpacket_seq_count(tc_ptr);\ 01240 ackl234new->TM_string[2] = 0xA0;\ 01241 for(int i = 3; i < 11; ++i){\ 01242 ackl234new->TM_string[i] = 0x00;\ 01243 }\ 01244 uint16_t crc = crc16_gen(ackl234new->TM_string, TM_SHORT_SIZE-2);\ 01245 ackl234new->TM_string[11] = (crc & 0xFF00) >> 8;\ 01246 ackl234new->TM_string[12] = crc & 0x00FF;\ 01247 /*ack l234 old*/\ 01248 if( service_subtype == OBOSC_SUB_REP_LE ){\ 01249 if( gLAST_TM_SHORT_OR_LONG == SHORT_TM_CODE ){\ 01250 Base_tm *ackl234old = new Short_tm;\ 01251 ackl234old->next_TM = NULL;\ 01252 /*APPEND TO ACK L234 NEW HERE*/\ 01253 ackl234new->next_TM = ackl234old;\ 01254 for( int i = 0 ; i < TM_SHORT_SIZE ; ++i ){\ 01255 ackl234old->TM_string[i] = gLAST_TM[i];\ 01256 }\ 01257 }\ 01258 else{\ 01259 Base_tm *tempLongTM = new Long_tm;\ 01260 tempLongTM->next_TM = NULL;\ 01261 /*APPEND TO ACK L234 NEW HERE*/\ 01262 ackl234new->next_TM = tempLongTM;\ 01263 for( int i = 0 ; i < TM_LONG_SIZE ; ++i ){\ 01264 tempLongTM->TM_string[i] = gLAST_TM[i];\ 01265 }\ 01266 }\ 01267 }\ 01268 else if( service_subtype == OBOSC_SUB_REP_TCLD ){\ 01269 get_tc_list(ackl234new->next_TM, GETpacket_seq_count(tc_ptr));\ 01270 }\ 01271 else if( service_subtype == OBOSC_SUB_RESET ){\ 01272 /*reset_all;*/\ 01273 reset_flag = 1;\ 01274 /*PENDING: VERIFY reset_all, RESET CDMS*/\ 01275 }\ 01276 else if( (service_subtype != OBOSC_SUB_DISABLE) && (service_subtype != OBOSC_SUB_RETRY) ){\ 01277 /*CHANGE THE ACK CODE TO INVALID TC*/\ 01278 ackl234new->TM_string[2] = 0xAF;\ 01279 }\ 01280 if (DEBUG)\ 01281 gPC.puts("completed obosc\r\n");\ 01282 } 01283 01284 /*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 */ 01285 01286 01287 #define EXECUTE_OBOSC_ONLY {\ 01288 gMASTER_STATE = TCL_STATE_EXECUTING;\ 01289 int reset_flag = 0;\ 01290 if (DEBUG)\ 01291 /*gPC.puts("iNSIDE EXECUTE_OBOSC_ONLY\r\n")*/;\ 01292 Base_tm *obosc_tm_core = NULL;\ 01293 Base_tm *obosc_tm = obosc_tm_core;\ 01294 for(uint8_t execute_psc = PSC_START_VALUE ; execute_psc < gTOTAL_VALID_TC ; ++execute_psc){\ 01295 Base_tc* current_TC = gHEAD_NODE_TCL;\ 01296 int overCount = 0;\ 01297 while( current_TC != NULL ){\ 01298 if( overCount < TCL_OVERFLOW_CONSTANT ){\ 01299 if( (GETcrc_pass(current_TC) == 1) && (GETpacket_seq_count(current_TC) == execute_psc) ){\ 01300 /*CHECK FOR OBOSC*/\ 01301 uint8_t temp82 = 0x00;\ 01302 isit_obosc(current_TC, temp82);\ 01303 if(temp82 == 0x01){\ 01304 uint16_t current_exec_status = GETexec_status(current_TC);\ 01305 if( (current_exec_status == TC_STATE_SUCCESSFULLY_EXECUTED) || (current_exec_status == TC_STATE_DISABLED) )\ 01306 break;\ 01307 else if( (current_exec_status == TC_STATE_UNEXECUTED) || (current_exec_status == TC_STATE_MARKED_RETRY) ){\ 01308 if (DEBUG)\ 01309 gPC.printf("It is obosc: %u\r\n", execute_psc);\ 01310 /*EXECUTION OF OBOSC TC*/\ 01311 /*WARNING: LARGE MEMORY UTILIZATION FOR TC-LIST-REPORT */\ 01312 execute_obosc_core(current_TC, obosc_tm_core, reset_flag);\ 01313 Base_tm *obosc_tm_current = obosc_tm_core;\ 01314 while(obosc_tm_core != NULL){\ 01315 obosc_tm_core = obosc_tm_core->next_TM;\ 01316 }\ 01317 if(obosc_tm_current->TM_string[2] == 0xA0){\ 01318 uint16_t temp16 = TC_STATE_SUCCESSFULLY_EXECUTED;\ 01319 PUTexec_status(current_TC, temp16);\ 01320 }\ 01321 else{\ 01322 uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\ 01323 PUTexec_status(current_TC, temp16);\ 01324 }\ 01325 while( obosc_tm_current != NULL ){\ 01326 int length = TM_SHORT_SIZE;\ 01327 if( GETshort_or_long_tm(obosc_tm_current) == SHORT_TM_CODE ){\ 01328 length = TM_SHORT_SIZE;\ 01329 }\ 01330 else{\ 01331 length = TM_LONG_SIZE;\ 01332 }\ 01333 for(int i = 0 ; i < length ; ++i){\ 01334 /*gPC.putc(obosc_tm_current->TM_string[i]);*/\ 01335 }\ 01336 obosc_tm_current = obosc_tm_current->next_TM;\ 01337 }\ 01338 }\ 01339 }\ 01340 }\ 01341 current_TC = current_TC->next_TC;\ 01342 ++overCount;\ 01343 }\ 01344 else{\ 01345 RESET_CDMS;\ 01346 break;\ 01347 }\ 01348 }\ 01349 }\ 01350 if(obosc_tm_core != NULL){\ 01351 Base_tm *obosc_tm_head = NULL;\ 01352 get_call_sign(obosc_tm_head);\ 01353 Base_tm *obosc_tm_current = obosc_tm_head;\ 01354 get_ack_l1(obosc_tm_current->next_TM);\ 01355 int overflowCountOBONLY = 0;\ 01356 while( obosc_tm_current->next_TM != NULL ){\ 01357 if( overflowCountOBONLY < TM_OVERFLOW_CONSTANT ){\ 01358 obosc_tm_current = obosc_tm_current->next_TM;\ 01359 ++overflowCountOBONLY;\ 01360 }\ 01361 else{\ 01362 RESET_CDMS;\ 01363 break;\ 01364 }\ 01365 }\ 01366 obosc_tm_current->next_TM = obosc_tm;\ 01367 /*Sending OBOSC TM to GS*/\ 01368 /*snd_tm.head_pointer(obosc_tm_head);*/\ 01369 /*transmit_adf;*/\ 01370 /*DELETE THE TM AFTER USE*/\ 01371 obosc_tm_current = obosc_tm_head;\ 01372 int overCount = 0;\ 01373 while( obosc_tm_current != NULL ){\ 01374 if( (overCount < TM_OVERFLOW_CONSTANT) ){\ 01375 Base_tm *temp = obosc_tm_current->next_TM;\ 01376 delete obosc_tm_current;\ 01377 obosc_tm_current = temp;\ 01378 ++overCount;\ 01379 }\ 01380 else{\ 01381 RESET_CDMS;\ 01382 break;\ 01383 }\ 01384 }\ 01385 }\ 01386 if ( reset_flag == 1 ){\ 01387 reset_all;\ 01388 /*Enable threads*/\ 01389 gPAY_SPI->bulkRead_resume(&payload_isr_fun);\ 01390 HK_counter->start(10000);\ 01391 gSESSION_TIMEOUT.detach();\ 01392 }\ 01393 } 01394 01395 #define EXECUTE_TC {\ 01396 gMASTER_STATE = TCL_STATE_EXECUTING;\ 01397 if (DEBUG)\ 01398 /*gPC.puts("iNSIDE EXECUTE_TC\r\n")*/;\ 01399 /*gPC.printf("%u\r\n", gTOTAL_VALID_TC);*/\ 01400 for(uint8_t execute_psc = PSC_START_VALUE ; execute_psc < gTOTAL_VALID_TC ; ++execute_psc ){\ 01401 if (DEBUG)\ 01402 gPC.printf("executing normal %u\r\n", execute_psc);\ 01403 /*gLEDG = !gLEDG;*/\ 01404 /*gLEDR = !gLEDR;*/\ 01405 Base_tc* current_TC = gHEAD_NODE_TCL;\ 01406 int overflowCount = 0;\ 01407 while(current_TC != NULL){\ 01408 if( overflowCount < TCL_OVERFLOW_CONSTANT ){\ 01409 if( (GETcrc_pass(current_TC) == 1) && (GETpacket_seq_count(current_TC) == execute_psc) ){\ 01410 uint8_t current_exec_status = GETexec_status(current_TC);\ 01411 if( (current_exec_status == TC_STATE_SUCCESSFULLY_EXECUTED) || (current_exec_status == TC_STATE_DISABLED) ){\ 01412 /*gPC.printf("disabled or completed at %u\n", execute_psc);*/\ 01413 if( execute_psc == (gTOTAL_VALID_TC-1) ){\ 01414 /*LAST TC IS EXECUTED*/\ 01415 gMASTER_STATE = TCL_STATE_COMPLETED;\ 01416 }\ 01417 break;\ 01418 }\ 01419 else if( (current_exec_status == TC_STATE_EXECUTION_FAILED) && (GETabort_on_nack(current_TC) == 1) ){\ 01420 /*gPC.printf("abort on nack at %u psc\r\n", execute_psc);*/\ 01421 gMASTER_STATE = TCL_STATE_ABORTED;\ 01422 Base_tm *tm_ptr_head = NULL;\ 01423 get_call_sign(tm_ptr_head);\ 01424 Base_tm *tm_ptr = tm_ptr_head;\ 01425 get_ack_l1(tm_ptr->next_TM);\ 01426 tm_ptr = tm_ptr_head;\ 01427 while( tm_ptr != NULL ){\ 01428 int length = TM_SHORT_SIZE;\ 01429 if( GETshort_or_long_tm(tm_ptr) == SHORT_TM_CODE ){\ 01430 length = TM_SHORT_SIZE;\ 01431 }\ 01432 else{\ 01433 length = TM_LONG_SIZE;\ 01434 }\ 01435 /*gPC.puts("Printing Call Sign, ACK_L1, TM list");*/\ 01436 for(int i = 0 ; i < length ; ++i){\ 01437 /*gPC.putc(tm_ptr->TM_string[i]);*/\ 01438 }\ 01439 tm_ptr = tm_ptr->next_TM;\ 01440 }\ 01441 /*Send only call sign, ACK_L1 to GS*/\ 01442 /*snd_tm.head_pointer(tm_ptr_head);*/\ 01443 /*transmit_adf;*/\ 01444 /*DELETE THE TM AFTER USE*/\ 01445 tm_ptr = tm_ptr_head;\ 01446 int overflowCountExecute = 0;\ 01447 while(tm_ptr != NULL){\ 01448 if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\ 01449 Base_tm *temp = tm_ptr->next_TM;\ 01450 delete tm_ptr;\ 01451 tm_ptr = temp;\ 01452 ++overflowCountExecute;\ 01453 }\ 01454 else{\ 01455 RESET_CDMS;\ 01456 break;\ 01457 }\ 01458 }\ 01459 break;\ 01460 }\ 01461 else if( (current_exec_status == TC_STATE_UNEXECUTED) || (current_exec_status == TC_STATE_MARKED_RETRY) ){\ 01462 /*EXECUTION OF TC START*/\ 01463 uint8_t temp81 = 0x00;\ 01464 isit_sdcard(current_TC, temp81);\ 01465 if( temp81 == 0x00 ){\ 01466 if (DEBUG)\ 01467 gPC.printf("non sd card at %u\r\n", execute_psc);\ 01468 /*EXECUTION OF NON SD-CARD (BOTH OBOSC and CDMS functions)*/\ 01469 Base_tm *tm_ptr_head = NULL;\ 01470 get_call_sign(tm_ptr_head);\ 01471 Base_tm *put_tm_here = NULL;\ 01472 uint8_t temp82 = 0x00;\ 01473 uint8_t tempPAhot = 0x00;\ 01474 isit_obosc(current_TC, temp82);\ 01475 if(temp82 == 0x01){\ 01476 /*gPC.printf("obosc tc inside normal tc at %u\r\n", execute_psc);*/\ 01477 /*EXECUTION OF OBOSC TC*/\ 01478 /*SKIP EXECUTION OF OBOSC HERE*/\ 01479 break;\ 01480 }\ 01481 else{\ 01482 /*gPC.printf("cdms relay tmtc at %u\r\n", execute_psc);*/\ 01483 /*call CDMS_RLY_TMTC*/\ 01484 /*CDMS_RLY_TMTC(current_TC, put_tm_here);*/\ 01485 put_tm_here = FCTN_CDMS_RLY_TMTC(current_TC);\ 01486 }\ 01487 /*DETECT ACK OR NACK*/\ 01488 uint8_t temp83 = 0x00;\ 01489 detect_ack(put_tm_here, temp83);\ 01490 if( temp83 == 0x01){\ 01491 uint16_t temp16 = TC_STATE_SUCCESSFULLY_EXECUTED;\ 01492 PUTexec_status(current_TC, temp16);\ 01493 }\ 01494 else if( temp83 == 0x03){\ 01495 /*gPC.puts("TC_STATE_EXECUTION_UNKNOWN");*/\ 01496 uint16_t temp16 = TC_STATE_EXECUTION_UNKNOWN;\ 01497 PUTexec_status(current_TC, temp16);\ 01498 }\ 01499 else if( temp83 == 0x04){\ 01500 /*gPC.puts("TC_STATE_EXECUTION_UNKNOWN");*/\ 01501 uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\ 01502 PUTexec_status(current_TC, temp16);\ 01503 uint8_t temp84 = GETpacket_seq_count(current_TC);\ 01504 put_tm_here->TM_string[2] = temp84;\ 01505 uint16_t crc16 = crc16_gen(put_tm_here->TM_string, 11);\ 01506 put_tm_here->TM_string[11] = (crc16 & 0xFF00)>>8;\ 01507 put_tm_here->TM_string[12] = (crc16 & 0x00FF);\ 01508 }\ 01509 else{\ 01510 /*gPC.puts("TC_STATE_EXECUTION_FAILED");*/\ 01511 uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\ 01512 PUTexec_status(current_TC, temp16);\ 01513 }\ 01514 /*ABORT ON NACK AND TC LIST COMPLETED: UPDATE IN gMASTERSTATE*/\ 01515 if( ((GETexec_status(current_TC) == TC_STATE_EXECUTION_FAILED) || (GETexec_status(current_TC) == TC_STATE_EXECUTION_UNKNOWN)) && (GETabort_on_nack(current_TC) == 1) ){\ 01516 gMASTER_STATE = TCL_STATE_ABORTED;\ 01517 }\ 01518 else if( execute_psc == (gTOTAL_VALID_TC-1) ){\ 01519 /*LAST TC IS EXECUTED*/\ 01520 gMASTER_STATE = TCL_STATE_COMPLETED;\ 01521 }\ 01522 /*update last executed L1_ack*/\ 01523 if( put_tm_here != NULL ){\ 01524 Base_tm *ptr_tm = put_tm_here;\ 01525 while(ptr_tm->next_TM != NULL)\ 01526 ptr_tm = ptr_tm->next_TM;\ 01527 if( GETshort_or_long_tm(ptr_tm) == SHORT_TM_CODE ){\ 01528 for(int i = 0 ; i < TM_SHORT_SIZE ; ++i){\ 01529 gLAST_TM[i] = ptr_tm->TM_string[i];\ 01530 gLAST_TM_SHORT_OR_LONG = SHORT_TM_CODE;\ 01531 }\ 01532 }\ 01533 else{\ 01534 for( int i = 0 ; i < TM_LONG_SIZE ; ++i ){\ 01535 gLAST_TM[i] = ptr_tm->TM_string[i];\ 01536 gLAST_TM_SHORT_OR_LONG = LONG_TM_CODE;\ 01537 }\ 01538 }\ 01539 }\ 01540 P_COM_HK;\ 01541 Base_tm *tm_ptr = tm_ptr_head;\ 01542 get_ack_l1(tm_ptr->next_TM);\ 01543 int overflowCountExecute = 0;\ 01544 while( tm_ptr->next_TM != NULL ){\ 01545 if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\ 01546 tm_ptr = tm_ptr->next_TM;\ 01547 ++overflowCountExecute;\ 01548 }\ 01549 else{\ 01550 RESET_CDMS;\ 01551 break;\ 01552 }\ 01553 }\ 01554 tm_ptr->next_TM = put_tm_here;\ 01555 tm_ptr = tm_ptr_head;\ 01556 while( tm_ptr != NULL ){\ 01557 int length = TM_SHORT_SIZE;\ 01558 if( GETshort_or_long_tm(tm_ptr) == SHORT_TM_CODE ){\ 01559 length = TM_SHORT_SIZE;\ 01560 }\ 01561 else{\ 01562 length = TM_LONG_SIZE;\ 01563 }\ 01564 /*gPC.puts("Printing Call Sign, ACK_L1, TM list");*/\ 01565 for(int i = 0 ; i < length ; ++i){\ 01566 /*gPC.putc(tm_ptr->TM_string[i]);*/\ 01567 }\ 01568 tm_ptr = tm_ptr->next_TM;\ 01569 }\ 01570 /*SEND call sign, ACK_L1, NON OBSRS TM TO GS*/\ 01571 snd_tm.head_pointer(tm_ptr_head);\ 01572 gPC.puts("enter_adf\r\n");\ 01573 transmit_adf;\ 01574 gPC.puts("exit_adf\r\n");\ 01575 /*DELETE THE TM AFTER USE*/\ 01576 tm_ptr = tm_ptr_head;\ 01577 overflowCountExecute = 0;\ 01578 while(tm_ptr != NULL){\ 01579 if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\ 01580 Base_tm *temp = tm_ptr->next_TM;\ 01581 delete tm_ptr;\ 01582 tm_ptr = temp;\ 01583 ++overflowCountExecute;\ 01584 }\ 01585 else{\ 01586 RESET_CDMS;\ 01587 break;\ 01588 }\ 01589 }\ 01590 }\ 01591 else{\ 01592 if (DEBUG)\ 01593 gPC.printf("sd card at %u\r\n", execute_psc);\ 01594 /*EXECUTION OF SD-CARD DATA SENDING (OBSRS)*/\ 01595 execute_OBSRS_TC(current_TC);\ 01596 gPC.puts("en_adf");\ 01597 transmit_adf;\ 01598 gPC.puts("ex_adf");\ 01599 }\ 01600 }\ 01601 break;\ 01602 }\ 01603 current_TC = current_TC->next_TC;\ 01604 ++overflowCount;\ 01605 }\ 01606 else{\ 01607 RESET_CDMS;\ 01608 break;\ 01609 }\ 01610 }\ 01611 if( gFLAGS & COM_SESSION_TIMEOUT_FLAG ){\ 01612 break;\ 01613 }\ 01614 else if( gMASTER_STATE == TCL_STATE_ABORTED ){\ 01615 if (DEBUG)\ 01616 gPC.puts("ABORTING DUE TO ABORT ON NACK\r\n");\ 01617 /*EXITED DUE TO ABORT ON NACK:*/\ 01618 COM_TX_CNTRL = 0;\ 01619 RX1M.attach(&rx_read, Serial::RxIrq);\ 01620 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\ 01621 break;\ 01622 }\ 01623 else if( (gFLAGS & COM_PA_HOT_FLAG) || (gFLAGS & COM_PA_OC_FLAG) ){\ 01624 /*PA HOT: WAIT FOR TIMEOUT*/\ 01625 gCOM_PA_COOLING_TIMEOUT.attach(&after_cooling_pa, COM_PA_COOLING_TIME_LIMIT);\ 01626 COM_TX_CNTRL = 0;\ 01627 RX1M.attach(&rx_read, Serial::RxIrq);\ 01628 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\ 01629 break;\ 01630 }\ 01631 if (DEBUG)\ 01632 gPC.printf("successflly executed %u tc\r\n", execute_psc);\ 01633 }\ 01634 if( (gMASTER_STATE == TCL_STATE_COMPLETED) || (gFLAGS & COM_SESSION_TIMEOUT_FLAG) ){\ 01635 if (DEBUG)\ 01636 gPC.printf("completed or session timed out: %x\r\n", gMASTER_STATE);\ 01637 /*COMPLETED EXECUTION OF TC*/\ 01638 gMASTER_STATE = TCL_STATE_COMPLETED;\ 01639 COM_POWER_OFF_TX;\ 01640 reset_all;\ 01641 /*ENABLE THREADS*/\ 01642 /*gPAY_SPI->bulkRead_resume(&payload_isr_fun)*/;\ 01643 HK_counter->start(10000);\ 01644 gSESSION_TIMEOUT.detach();\ 01645 gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\ 01646 gFLAGS = gFLAGS & (~COM_SESSION_FLAG);\ 01647 }\ 01648 }
Generated on Sat Jul 16 2022 01:27:53 by
1.7.2