samp Srinivasan
Latest FM Code with EEPROM
Dependencies: FreescaleIAP SimpleDMA eeprom mbed-rtos mbed
Fork of
CDMS_QM_03MAR2017_Flash_with_obsrs
by 
Team Fox
COM_MNG_TMTC.h
- Committer:
- aniruddhv
- Date:
- 2016-01-17
- Revision:
- 69:20f09a0c3fd2
- Parent:
- 58:5c59f28620bc
- Child:
- 73:6c99294b7802
- Child:
- 75:d03b5d6ef269
- Child:
- 107:396aa26f3fff
File content as of revision 69:20f09a0c3fd2:
// 8 Jul
// did flowchart of states
// handle sd card with cdms team
// Jun 6
// WHAT IS TC exec code in L1 ack ?
//Jan 7
//added RLY_TMTC function
//added included related files
#include "pinconfig.h"
#include "i2c.h"
#include "Flash.h"
#include "cdms_rtc.h"
DigitalIn tm_status_4m_slv(PIN39); //I2C interrupt to CDMS from BAE
//DigitalIn tm_status_4m_pl(PIN61); //I2C interrupt to CDMS from PL
uint8_t received = 0;
uint16_t mid1;
uint16_t mid2;
uint16_t Nbytes;
uint32_t Data[2];
uint16_t nbytes;
uint8_t flash_counter = 0;
uint16_t crc16;
uint16_t mid;
uint32_t block;
#define delete_TC(tc_ptr) {\
if(tc_ptr == gHEAD_NODE_TCL){\
gHEAD_NODE_TCL = tc_ptr->next_TC;\
}\
delete tc_ptr;\
}
#define delete_all_tm(tm_ptr_head){\
/*DELETE THE TM AFTER USE*/\
Base_tm *temp_tm_ptr = tm_ptr_head;\
int overflowCountExecute = 0;\
while(temp_tm_ptr != NULL){\
if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\
Base_tm *temp = temp_tm_ptr->next_TM;\
delete temp_tm_ptr;\
temp_tm_ptr = temp;\
++overflowCountExecute;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
}
// typeof tm_ptr: Base_tm
// typeof tc_ptr: Base_tc
// typeof temp_xxxx: uint8_t
#define fill_l1_ack(tm_ptr) {\
uint8_t temp8;\
tm_ptr->next_TM = NULL;\
temp8 = TMID_ACK_L1;\
PUTtmid(tm_ptr->fields, temp8);\
temp8 = SHORT_TM_CODE;\
PUTshort_or_long_tm(tm_ptr->fields, temp8);\
tm_ptr->TM_string[0] = TMID_ACK_L1 << 4;\
/*PENDING: PA TEMPERATURE*/\
tm_ptr->TM_string[1] = gTOTAL_INCORRECT_SIZE_TC & 0xFF;\
tm_ptr->TM_string[2] = gTOTAL_CRC_FAIL_TC & 0xFF;\
}
#define put_crc_l1_ack(tm_ptr) {\
tm_ptr->TM_string[2] = gTOTAL_CRC_FAIL_TC & 0xFF;\
/*TC LIST STATUS*/\
tm_ptr->TM_string[3] |= (gMASTER_STATE << 5) & 0xE0;\
/*PA HOT*/\
if( gFLAGS & COM_PA_HOT_FLAG ){\
tm_ptr->TM_string[3] |= (1 << 4);\
}\
else{\
tm_ptr->TM_string[3] &= ~(1 << 4);\
}\
uint16_t crc_checksum = crc16_gen(tm_ptr->TM_string, TM_SHORT_SIZE-2);\
tm_ptr->TM_string[TM_SHORT_SIZE-2] = (crc_checksum >> 8) & 0xFF;\
tm_ptr->TM_string[TM_SHORT_SIZE-1] = crc_checksum & 0xFF;\
}
#define detect_ack(tm_ptr, temp_ack, tc_psc) {\
if( tm_ptr != NULL ){\
int length = TM_SHORT_SIZE;\
if( GETshort_or_long_tm(tm_ptr->fields) == SHORT_TM_CODE ){\
length = TM_SHORT_SIZE;\
}\
else{\
length = TM_LONG_SIZE;\
}\
uint16_t crc = crc16_gen(tm_ptr->TM_string, length-2);\
if( (((crc & 0xFF00) >> 8) == tm_ptr->TM_string[length-2]) && ( (crc & 0x00FF) == tm_ptr->TM_string[length-1] ) ){\
uint8_t temp8;\
temp8 = tm_ptr->TM_string[TM_ACK_CODE_INDEX];\
temp8 = temp8 & 0xE0;\
if( (temp8 == 0xC0) || (temp8 == 0xA0) )\
temp_ack = 0x01;\
else{\
temp_ack = 0x00;\
/*CHECK FOR NACK CODE: CRC FAIL NACK*/\
temp8 = tm_ptr->TM_string[TM_ACK_CODE_INDEX];\
temp8 = temp8 & 0x0F;\
if( temp8 == CRC_FAIL_NACK_CODE ){\
tm_ptr->TM_string[2] = tc_psc;\
}\
}\
}\
else\
temp_ack = 0x00;\
}\
else{\
temp_ack = 0x00;\
}\
}
#define isit_obosc(tc_ptr, temp_obosc) {\
temp_obosc = 0x00;\
if( GETapid(tc_ptr) == APID_COM ){\
if( ((tc_ptr->TC_string[2]) >> 4) == SERVICE_OBOSC ){\
temp_obosc = 0x01;\
}\
}\
}
#define isit_sdcard(tc_ptr, temp_sdcard) {\
temp_sdcard = 0x00;\
if( GETapid(tc_ptr) == APID_COM ){\
if( ( (tc_ptr->TC_string[2]) >> 4) == SERVICE_OBSRS ){\
temp_sdcard = 0x01;\
}\
}\
}
#define isPAhot(returnHere){\
/*PENDING : COMPLETE THIS FUNCTION*/\
returnHere = 0xFF;\
}
void after_cooling_pa(){
gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
}
/*
@brief: check for missing tc, also check crc, i.e.
if true execution can be started else have to wait
decide the next state
@param: none
@return: bool indicating whether there are missing tc
*/
// PENDING: LAST FRAME BIT
/*
for loop: check for missing tc
if: check for incorrect sized tc
if: check for last frame bit
*/
#define continueToExecute(returnHere) {\
uint8_t tempReturn = 0x00;\
/*search for missing psc*/\
for(uint8_t p = 0x00 ; p < (gTOTAL_VALID_TC) ; ++p){\
bool flag = false;\
Base_tc *node_ptr = gHEAD_NODE_TCL;\
while(node_ptr != NULL){\
if( (GETpacket_seq_count(node_ptr) == p) && (GETcrc_pass(node_ptr) == 1) ){\
flag = true;\
break;\
}\
else{\
node_ptr = node_ptr->next_TC;\
}\
}\
if(flag == false){\
tempReturn = 0x02;\
break;\
}\
}\
/*search for last packet bit*/\
tempReturn = tempReturn + 0x01;\
Base_tc *tcp = gHEAD_NODE_TCL;\
while(tcp != NULL){\
if(GETpacket_seq_count(tcp) == (gTOTAL_VALID_TC - 1)){\
if( ( (tcp->TC_string[1]) & 0x20 ) == 0x20 ){\
tempReturn = tempReturn - 0x01;\
}\
break;\
}\
tcp = tcp->next_TC;\
}\
returnHere = tempReturn;\
/*UPDATE gMASTER STATE*/\
if( (returnHere == 0x00) ){\
if( (gMASTER_STATE == TCL_STATE_INCOMPLETE) || (gMASTER_STATE == TCL_STATE_COMPLETED) || (gMASTER_STATE == TCL_STATE_ABORTED) ){\
gMASTER_STATE = TCL_STATE_EXECUTING;\
}\
}\
else{\
if( (gMASTER_STATE == TCL_STATE_INCOMPLETE) || (gMASTER_STATE == TCL_STATE_COMPLETED) ){\
gMASTER_STATE = TCL_STATE_INCOMPLETE;\
}\
}\
}
/*
return 1 if code match
return 0 if code mismatch
*/
#define GScodeVerification(returnHere){\
Base_tc *testTC = gHEAD_NODE_TCL;\
uint16_t overflowCount = 0;\
returnHere = 0xFF;\
while( (overflowCount < TCL_OVERFLOW_CONSTANT) && (testTC != NULL) ){\
if( (GETpacket_seq_count(testTC) == PSC_CALLSIGN) && (GETapid(testTC) == APID_CALLSIGN) ){\
/*uint8_t temp8 = testTC->TC_string[1];*/\
if( true ){\
for( int i = 2 ; i <= 8 ; ++i ){\
if( testTC->TC_string[i] != gGSCODE[i-2] ){\
returnHere = 0;\
break;\
}\
}\
}\
break;\
}\
testTC = testTC->next_TC;\
++overflowCount;\
}\
}
/*
@brief: DELETE THE CRC FAILED TC FROM THE LIST TO FREE-UP MEMORY AND UPDATE
THE TOTAL VALID TC AND GENERATE L1_ACK_TM
@param: none
@return: none
*/
/*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 */
#define get_ack_l1( tm_ptr ){\
Base_tc *current_TC = gHEAD_NODE_TCL;\
Base_tm *l1_ack = new Short_tm;\
/*APPEND TO THE tm_ptr HERE*/\
tm_ptr = l1_ack;\
fill_l1_ack(l1_ack);\
int TC_count = 0;\
int overflowCountL1 = 0;\
while(current_TC != NULL){\
if( overflowCountL1 < TCL_OVERFLOW_CONSTANT ){\
/*IF CRC PASS*/\
if( (GETcrc_pass(current_TC) == 1) ){\
if(TC_count > 4){\
/*PENDING: FILL TC_EXEC_CODE, APPEND CRC TO THE TM*/\
put_crc_l1_ack( l1_ack );\
/*extend the TM linked list*/\
TC_count = 0;\
l1_ack->next_TM = new Short_tm;\
l1_ack = l1_ack->next_TM;\
fill_l1_ack(l1_ack);\
}\
/*PSC starts from 7th byte*/\
l1_ack->TM_string[6+TC_count] = GETpacket_seq_count(current_TC);\
/*TC exec status*/\
switch(TC_count){\
case 0:\
l1_ack->TM_string[3] = (GETexec_status(current_TC)) & 0x0F;\
break;\
case 1:\
l1_ack->TM_string[4] = (GETexec_status(current_TC) << 4) & 0xF0;\
break;\
case 2:\
l1_ack->TM_string[4] |= (GETexec_status(current_TC)) & 0x0F;\
break;\
case 3:\
l1_ack->TM_string[5] = (GETexec_status(current_TC) << 4) & 0xF0;\
break;\
case 4:\
l1_ack->TM_string[5] |= (GETexec_status(current_TC)) & 0x0F;\
}\
++TC_count;\
}\
current_TC = current_TC->next_TC;\
++overflowCountL1;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
/*FILL UP THE REMAINING FIELDS WITH 0x00 as PSC, AND 0xF as tc exec status*/\
if( (TC_count < 5) && (TC_count != 0) ){\
while(TC_count < 5){\
l1_ack->TM_string[6+TC_count] = 0x00;\
switch(TC_count){\
case 1:\
l1_ack->TM_string[4] = 0xF0;\
break;\
case 2:\
l1_ack->TM_string[4] |= 0x0F;\
break;\
case 3:\
l1_ack->TM_string[5] = 0xF0;\
break;\
case 4:\
l1_ack->TM_string[5] |= 0x0F;\
}\
++TC_count;\
}\
}\
put_crc_l1_ack(l1_ack);\
}
/*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 */
#define get_tc_list(tm_ptr, thePSC){\
uint8_t TM_PSC = 0xFF;\
uint8_t TC_PSC = thePSC;\
int overflowCount = 0;\
uint8_t TC_LIST_TAG = 0x00;\
Base_tc *temp_tc = gHEAD_NODE_TCL;\
bool first_time = true;\
Base_tm *current_tm = NULL;\
while( temp_tc != NULL ){\
if( overflowCount < TCL_OVERFLOW_CONSTANT ){\
TM_PSC = TM_PSC + 1;\
/*Increment TM_PSC for every new TM pointer created*/\
Base_tm *temp_tm = new Long_tm;\
temp_tm->next_TM = NULL;\
uint8_t temp8 = LONG_TM_CODE;\
PUTshort_or_long_tm(temp_tm->fields, temp8);\
temp8 = TMID_TCL;\
PUTtmid((temp_tm->fields), temp8);\
temp_tm->TM_string[0] = 0x38;\
/*Frame type(1) = 0; TMID = 0111; Spare = 000*/\
temp_tm->TM_string[1] = TC_PSC;\
temp_tm->TM_string[3] = TM_PSC;\
int indexCustom = 4, num_of_short_tc = 0;\
while(temp_tc != NULL){\
if( overflowCount < TCL_OVERFLOW_CONSTANT ){\
if( GETshort_or_long_tc(temp_tc) == SHORT_TC_CODE ){\
for( int i = 0 ; i < TC_SHORT_SIZE ; ++i ){\
temp_tm->TM_string[indexCustom + i] = temp_tc->TC_string[i];\
}\
indexCustom = indexCustom + TC_SHORT_SIZE;\
++overflowCount;\
/*INCREMENT STUFF*/\
temp_tc = temp_tc->next_TC;\
num_of_short_tc = num_of_short_tc + 1;\
if (temp_tc == NULL){\
for (int i = indexCustom ; i < TM_LONG_SIZE-2 ; ++i){\
temp_tm->TM_string[i] = 0;\
/*Fill remaining values with 0*/\
}\
TC_LIST_TAG = num_of_short_tc;\
break;\
}\
if( (GETshort_or_long_tc(temp_tc) == LONG_TC_CODE) || (num_of_short_tc == OBOSC_TCL_MAX_SHORT_SIZE) ){\
/*Next TC is long or memory is filled*/\
for(int i = indexCustom; i < TM_LONG_SIZE-2 ; ++i){\
temp_tm->TM_string[i] = 0;\
/*Fill remaining values with 0*/\
}\
TC_LIST_TAG = num_of_short_tc;\
break;\
}\
}\
else if (TC_LIST_TAG == OBOSC_TCL_TAG_LONG_FIRST_HALF){\
/*Long TC, 2nd half*/\
for (int i = 0; i < OBOSC_LONG_TC_SECOND_HALF_SIZE ; ++i){\
temp_tm->TM_string[indexCustom + i] = temp_tc->TC_string[OBOSC_LONG_TC_FIRST_HALF_SIZE + i];\
/*Fill the TM with TC_values*/\
}\
for (int i = OBOSC_LONG_TC_SECOND_HALF_SIZE + indexCustom ; i < TM_LONG_SIZE-2 ; ++i ){\
temp_tm->TM_string[i] = 0;\
/*Fill remaining values with 0*/\
}\
temp_tc = temp_tc->next_TC;\
TC_LIST_TAG = OBOSC_TCL_TAG_LONG_SECOND_HALF;\
++overflowCount;\
break;\
}\
else{\
/*Long TC, 1st half */\
for (int i = 0; i < OBOSC_LONG_TC_FIRST_HALF_SIZE; ++i){\
/*gPC.printf("indexCustom = %d\r\n", indexCustom);*/\
temp_tm->TM_string[indexCustom + i] = temp_tc->TC_string[i];\
/*Fill the TM with TC_values*/\
}\
for (int i = OBOSC_LONG_TC_FIRST_HALF_SIZE + indexCustom ; i < TM_LONG_SIZE-2 ; ++i ){\
temp_tm->TM_string[i] = 0;\
/*Fill remaining values with 0*/\
}\
TC_LIST_TAG = OBOSC_TCL_TAG_LONG_FIRST_HALF;\
break;\
}\
}\
else{\
/*PENDING: reset cdms*/\
break;\
}\
}\
temp_tm->TM_string[2] = TC_LIST_TAG;\
/*TC_LIST_TAG as is updated in the inner while loop*/\
uint16_t crc16 = crc16_gen(temp_tm->TM_string, TM_LONG_SIZE-2);\
temp_tm->TM_string[TM_LONG_SIZE-2] = (crc16 & 0xFF00) >> 8 ;\
temp_tm->TM_string[TM_LONG_SIZE-1] = crc16 & 0x00FF;\
/*Attach this new node to the TM linked list*/\
if( first_time ){\
first_time = false;\
tm_ptr = temp_tm;\
current_tm = temp_tm;\
}\
else{\
current_tm->next_TM = temp_tm;\
current_tm = current_tm->next_TM;\
}\
/*Attach this new node at the end*/\
}\
else{\
/*PENDING: reset CDMS*/\
break;\
}\
}\
}
// CDMS TEAM CODE START
inline Base_tm* FCTN_CDMS_RLY_TMTC(Base_tc *tc_ptr){
uint8_t ACKCODE = 0x00;
//gPC.printf("\rTC execution in progress\r\n");
Base_tm *tm_pointer = new Long_tm;
Base_tm *tm_ptr = tm_pointer;
received = 0;
switch(GETapid(tc_ptr))
{
case 1: //apid=01 implies it corresponds to bae
{
//gPC.printf("Telecommand is for BAE\r\n");
//gPC.printf("Sending TC to BAE...\r\n"); //interrupt to be sent to the bae
FCTN_I2C_WRITE((char*)tc_ptr->TC_string);
while(1)
{
wait(1); //TimeOut instead of wait
if(tm_status_4m_slv == 1)
{
//gPC.printf("receiving...\r\n");
FCTN_I2C_READ((char*)tm_pointer->TM_string);
//gPC.printf("%s", tm_pointer->TM_string);
received+=1;
tm_pointer = tm_pointer->next_TM;
break; //only for testing purpose
}
else
{
break;
}
}
if(received >= 1 )
{
//gPC.printf("Telemetry is received from BAE\r\n");
Base_tm *tm_print = tm_ptr;
for(uint8_t i=0;i<received;i++)
{
//gPC.printf("%s", tm_print->TM_string);
tm_print = tm_print->next_TM; //for check
}
received = 0;
tm_pointer->next_TM = NULL; return tm_ptr;
}
else
{
//gPC.printf("Telemetry is not received from BAE\r\n");
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
tm_pointer->TM_string[3] = ACKCODE; //ackcode to be decided
tm_pointer->TM_string[4] = 0x01;
for(uint8_t i=0;i<6;i++)
{
tm_pointer->TM_string[i+5] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
}
break;
}
case 2:
{
//gPC.printf("Telecommand is for CDMS\r\n"); //apid = 10 corresponds to cdms
switch(GETservice_type(tc_ptr))
{
case 0x60:
{
//gPC.printf("service:MMS\r\n");
switch(GETservice_subtype(tc_ptr))
{
case 0x1:
{
//gPC.printf("sub_service:Read from RAM_Memory\r\n");
mid=(uint16_t)(tc_ptr->TC_string[3]<<4)+(uint16_t)(tc_ptr->TC_string[4]);
Data[0] = FCTN_CDMS_RD_FLASH(0);
Data[1] = FCTN_CDMS_RD_FLASH(1);
//tm_pointer = new Long_tm;
tm_pointer->TM_string[0] = 0x30;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = (uint8_t)(flash_counter);
for(uint8_t i=0;i<4;i++)
{
tm_pointer->TM_string[3+i] = (uint8_t)((Data[0]>>(8*i))&0x00FF);
}
for(uint8_t i=4;i<8;i++)
{
tm_pointer->TM_string[3+i] = (uint8_t)((Data[1]>>(8*i))&0x00FF);
}
crc16 = crc16_gen(tm_ptr->TM_string,9);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
}
case 0x2:
{
//gPC.printf("sub_service:Read from Flash_Memory\r\n");
mid=(uint16_t)(tc_ptr->TC_string[3]<<4)+(uint16_t)(tc_ptr->TC_string[4]);
Data[0] = FCTN_CDMS_RD_FLASH(0);
Data[1] = FCTN_CDMS_RD_FLASH(1);
//tm_pointer = new Long_tm;
tm_pointer->TM_string[0] = 0x30;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = (uint8_t)(flash_counter);
for(uint8_t i=0;i<4;i++)
{
tm_pointer->TM_string[3+i] = (uint8_t)((Data[0]>>(8*i))&0x00FF);
}
for(uint8_t i=4;i<8;i++)
{
tm_pointer->TM_string[3+i] = (uint8_t)((Data[1]>>(8*i))&0x00FF);
}
crc16 = crc16_gen(tm_ptr->TM_string,9);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
}
case 0x5:
{
//gPC.printf("WRITE ON FLASH_MEMORY\r\n");
mid=(uint16_t)(tc_ptr->TC_string[3]<<4)+(uint16_t)(tc_ptr->TC_string[4]);
block = (((uint32_t)(tc_ptr->TC_string[5])<<24)|((uint32_t)(tc_ptr->TC_string[5])<<16)|((uint32_t)(tc_ptr->TC_string[5])<<8)|((uint32_t)(tc_ptr->TC_string[5])));
FCTN_CDMS_WR_FLASH(mid,block);
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
tm_pointer->TM_string[3] = ACKCODE; //ackcode to be decided
tm_pointer->TM_string[4] = 0x01;
for(uint8_t i=0;i<6;i++)
{
tm_pointer->TM_string[i+5] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
default:
{
//gPC.printf("INVALID TC\r\n"); //Send Invalid TC Telemetry
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
tm_pointer->TM_string[3] = ACKCODE; //ackcode to be decided
tm_pointer->TM_string[4] = 0x01;
for(uint8_t i=0;i<6;i++)
{
tm_pointer->TM_string[i+5] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
}
break;
}
}
case 0x8:
{
//gPC.printf("service:FUNCTION MANAGEMENT SERVICE\r\n");
if(GETservice_subtype(tc_ptr)==0x1)
{
if(GETpid(tc_ptr)==0x01)
{
//gPC.printf("TC_PL_INIT\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x02)
{
//gPC.printf("TC_PL_MAIN\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x03)
{
//gPC.printf("TC_COM_INIT\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x04)
{
//gPC.printf("TC_CDMS_HK_MAIN\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x11)
{
//gPC.printf("TC_SW_ON_SD\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x12)
{
//gPC.printf("TC_SW_ON_RTC\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x13)
{
//gPC.printf("TC_SW_ON_BAE\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x14)
{
//gPC.printf("TC_SW_ON_PL_DL\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x15)
{
//gPC.printf("TC_SW_ON_PL_AG_HV\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x16)
{
//gPC.printf("TC_SW_ON_V_A_EN\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x21)
{
//gPC.printf("TC_SW_OFF_SD\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x22)
{
//gPC.printf("TC_SW_OFF_RTC\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x23)
{
//gPC.printf("TC_SW_OFF_BAE\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x24)
{
//gPC.printf("TC_SW_OFF_PL_DL\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x25)
{
//gPC.printf("TC_SW_OFF_PL_AG_HV\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x26)
{
//gPC.printf("TC_SW_OFF_V_A_EN\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x31)
{
//gPC.printf("TC_RST_SD\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x32)
{
//gPC.printf("TC_RST_RTC\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x33)
{
//gPC.printf("TC_RST_BAE\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0x34)
{
//gPC.printf("TC_RST_PL_DL\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
break;
}
else if(GETpid(tc_ptr)==0xC1)
{
//gPC.printf("RESET_HK_COUNTER\r\n"); // call PWR_SWCH_ON function
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = ACKCODE;
for(uint8_t i=3;i<11;i++)
{
tm_pointer->TM_string[i] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
else if(GETpid(tc_ptr)==0xF1)
{
//gPC.printf("RD_RTC\r\n"); //call RD_RTC
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xD0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
uint64_t time = FCTN_CDMS_RD_RTC();
tm_pointer->TM_string[3] = (uint8_t)((time&0xFF00000000000000)>>56);
tm_pointer->TM_string[4] = (uint8_t)((time&0x00FF000000000000)>>48);
tm_pointer->TM_string[5] = (uint8_t)((time&0x0000FF0000000000)>>40);
tm_pointer->TM_string[6] = (uint8_t)((time&0x000000FF00000000)>>32);
tm_pointer->TM_string[7] = (uint8_t)((time&0x00000000FF000000)>>24);
tm_pointer->TM_string[8] = (uint8_t)((time&0x0000000000FF0000)>>16);
tm_pointer->TM_string[9] = (uint8_t)((time&0x000000000000FF00)>>8);
tm_pointer->TM_string[10] = (uint8_t)(time&0x00000000000000FF);
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
}
else
{
//gPC.printf("INVALID TC\r\n");
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
tm_pointer->TM_string[3] = ACKCODE; //ackcode to be decided
tm_pointer->TM_string[4] = 0x01;
for(uint8_t i=0;i<6;i++)
{
tm_pointer->TM_string[i+5] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
}
}
}
default:
{
//gPC.printf("INVALID TC"); //send invalid TC TM
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
tm_pointer->TM_string[3] = ACKCODE; //ackcode to be decided
tm_pointer->TM_string[4] = 0x01;
for(uint8_t i=0;i<6;i++)
{
tm_pointer->TM_string[i+5] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
}
}
case 3:
{
//gPC.printf("Telecommand is for PL\r\n");
// gPC.printf("Informing PL about TC using I2C\r\n"); //interrupt to be sent to the bae
// FCTN_I2C_WRITE((char*)tc_ptr->TC_string);
// //gPC.printf("sent the Telecommand to BAE\r\n"); //packet along with crc will be sent when bae is ready
// wait(1); //wait time is to be optimised
// if(tm_status_4m_slv == 1)
// {
// FCTN_I2C_READ((char*)tm_ptr->TM_string);
// received = 1;
// }
// if(received == 1 )
// {
// //gPC.printf("Telemetry is received from BAE\r\n");
// //gPC.printf("%s", tm_ptr->TM_string);
// received = 0;
// } // similar to BAE functions
break;
}
default: //invalid TC
{
//gPC.printf("INVALID TC\r\n");
//tm_pointer = new Short_tm;
tm_pointer->TM_string[0] = 0xB0;
tm_pointer->TM_string[1] = GETpacket_seq_count(tc_ptr);
tm_pointer->TM_string[2] = 0x01;
tm_pointer->TM_string[3] = ACKCODE; //ackcode to be decided
tm_pointer->TM_string[4] = 0x01;
for(uint8_t i=0;i<6;i++)
{
tm_pointer->TM_string[i+5] = 0;
}
crc16 = crc16_gen(tm_ptr->TM_string,11);
tm_pointer->TM_string[11] = (uint8_t)((crc16&0xFF00)>>8);
tm_pointer->TM_string[12] = (uint8_t)(crc16&0x00FF);
tm_pointer->next_TM = NULL; return tm_ptr;
break;
}
}
}
// CDMS TEAM CODE END
// EXECUTE OBOSC
#define execute_obosc_core(tc_ptr, tm_ptr, reset_flag) {\
uint8_t service_subtype = (tc_ptr->TC_string[2]) & 0x0F;\
uint8_t temp8 = 0x00;\
Base_tc *modify_this = gHEAD_NODE_TCL;\
int modify_overflow = 0x00;\
switch( service_subtype ){\
case OBOSC_SUB_DISABLE:\
/*gPC.puts("target psc are ");*/\
for(int i = 3 ; i < 9 ; ++i){\
/*gPC.printf("%u ", tc_ptr->TC_string[i]);*/\
}\
/*gPC.puts("\r\n");*/\
/*gPC.puts("disable type obosc\r\n");*/\
while( modify_this != NULL ){\
if( modify_overflow < TCL_OVERFLOW_CONSTANT ){\
uint8_t modify_psc = GETpacket_seq_count(modify_this);\
/*gPC.printf("mosify_psc = %u\r\n", modify_psc);*/\
for( int i = 3 ; i < 9 ; ++i ){\
uint8_t target_psc = tc_ptr->TC_string[i];\
if( (target_psc == modify_psc) && (target_psc != 0) ){\
uint16_t tempExec = TC_STATE_DISABLED;\
PUTexec_status( modify_this, tempExec );\
break;\
}\
}\
modify_this = modify_this->next_TC;\
++modify_overflow;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
break;\
case OBOSC_SUB_RETRY:\
/*gPC.puts("retry type obosc\r\n");*/\
while( modify_this != NULL ){\
if( modify_overflow < TCL_OVERFLOW_CONSTANT ){\
uint8_t modify_psc = GETpacket_seq_count(modify_this);\
for( int i = 3 ; i < 9 ; ++i ){\
uint8_t target_psc = tc_ptr->TC_string[i];\
if( (target_psc == modify_psc) && (target_psc != 0) ){\
uint16_t tempExec = TC_STATE_MARKED_RETRY;\
PUTexec_status( modify_this, tempExec );\
/*gPC.puts("reqquired tc found: disable\r\n");*/\
break;\
}\
}\
modify_this = modify_this->next_TC;\
++modify_overflow;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
break;\
}\
Base_tm *ackl234new = new Short_tm;\
ackl234new->next_TM = NULL;\
/*return telemetry pointer here*/\
tm_ptr = ackl234new;\
temp8 = SHORT_TM_CODE;\
PUTshort_or_long_tm(ackl234new->fields, temp8);\
temp8 = TMID_ACK_L234;\
PUTtmid((ackl234new->fields), temp8);\
ackl234new->TM_string[0] = TMID_ACK_L234 << 4;\
ackl234new->TM_string[1] = GETpacket_seq_count(tc_ptr);\
ackl234new->TM_string[2] = 0xA0;\
for(int i = 3; i < 11; ++i){\
ackl234new->TM_string[i] = 0x00;\
}\
uint16_t crc = crc16_gen(ackl234new->TM_string, TM_SHORT_SIZE-2);\
ackl234new->TM_string[11] = (crc & 0xFF00) >> 8;\
ackl234new->TM_string[12] = crc & 0x00FF;\
/*ack l234 old*/\
if( service_subtype == OBOSC_SUB_REP_LE ){\
if( gLAST_TM_SHORT_OR_LONG == SHORT_TM_CODE ){\
Base_tm *ackl234old = new Short_tm;\
ackl234old->next_TM = NULL;\
/*APPEND TO ACK L234 NEW HERE*/\
ackl234new->next_TM = ackl234old;\
uint8_t temp82 = TM_SHORT_SIZE;\
PUTshort_or_long_tm(ackl234old->fields, temp82);\
/*TMID FOR SHORT TM*/\
uint8_t y = (gLAST_TM[0] & 0xF0) >> 4;\
PUTtmid((ackl234old->fields), y);\
for( int i = 0 ; i < TM_SHORT_SIZE ; ++i ){\
ackl234old->TM_string[i] = gLAST_TM[i];\
}\
}\
else{\
Base_tm *tempLongTM = new Long_tm;\
tempLongTM->next_TM = NULL;\
/*APPEND TO ACK L234 NEW HERE*/\
ackl234new->next_TM = tempLongTM;\
uint8_t temp82 = TM_LONG_SIZE;\
PUTshort_or_long_tm(tempLongTM->fields, temp82);\
/*TMID FOR LONG TM*/\
uint8_t y = (gLAST_TM[0] & 0x78) >> 3;\
PUTtmid((tempLongTM->fields), y);\
for( int i = 0 ; i < TM_LONG_SIZE ; ++i ){\
tempLongTM->TM_string[i] = gLAST_TM[i];\
}\
}\
}\
else if( service_subtype == OBOSC_SUB_REP_TCLD ){\
get_tc_list(ackl234new->next_TM, GETpacket_seq_count(tc_ptr));\
}\
else if( service_subtype == OBOSC_SUB_RESET ){\
/*reset_all;*/\
reset_flag = 1;\
/*PENDING: VERIFY reset_all, RESET CDMS*/\
}\
else if( (service_subtype != OBOSC_SUB_DISABLE) && (service_subtype != OBOSC_SUB_RETRY) ){\
/*CHANGE THE ACK CODE TO INVALID TC*/\
ackl234new->TM_string[2] = 0xA2;\
}\
/*gPC.puts("completed obosc\r\n");*/\
}
/*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 */
#define get_call_sign(tm_ptr) {\
Base_tm* call_sign_tm = new Short_tm;\
call_sign_tm->next_TM = NULL;\
tm_ptr = call_sign_tm;\
uint8_t temp8 = TMID_CALL_SIGN;\
PUTtmid(call_sign_tm->fields, temp8);\
temp8 = SHORT_TM_CODE;\
PUTshort_or_long_tm(call_sign_tm->fields, temp8);\
for( int i = 0 ; i < TM_SHORT_SIZE ; ++i ){\
call_sign_tm->TM_string[i] = gCALL_SIGN_STRING[i];\
}\
}
#define EXECUTE_OBOSC_ONLY {\
int reset_flag = 0;\
Base_tm *obosc_tm_head = NULL;\
get_call_sign(obosc_tm_head);\
Base_tm *obosc_tm_current = obosc_tm_head;\
get_ack_l1(obosc_tm_current->next_TM);\
int overflowCountOBONLY = 0;\
while( obosc_tm_current->next_TM != NULL ){\
if( overflowCountOBONLY < TM_OVERFLOW_CONSTANT ){\
obosc_tm_current = obosc_tm_current->next_TM;\
++overflowCountOBONLY;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
uint8_t obosc_executed_count = 0;\
for(uint8_t execute_psc = PSC_START_VALUE ; execute_psc < gTOTAL_VALID_TC ; ++execute_psc){\
Base_tc* current_TC = gHEAD_NODE_TCL;\
int overCount = 0;\
while( current_TC != NULL ){\
if( overCount < TCL_OVERFLOW_CONSTANT ){\
if( (GETcrc_pass(current_TC) == 1) && (GETpacket_seq_count(current_TC) == execute_psc) ){\
/*CHECK FOR OBOSC*/\
uint8_t temp82 = 0x00;\
isit_obosc(current_TC, temp82);\
if(temp82 == 0x01){\
uint16_t current_exec_status = GETexec_status(current_TC);\
if( (current_exec_status == TC_STATE_SUCCESSFULLY_EXECUTED) || (current_exec_status == TC_STATE_DISABLED) )\
break;\
else if( (current_exec_status == TC_STATE_UNEXECUTED) || (current_exec_status == TC_STATE_MARKED_RETRY) ){\
/*gPC.printf("It is obosc: %u\r\n", execute_psc);*/\
/*EXECUTION OF OBOSC TC*/\
/*WARNING: LARGE MEMORY UTILIZATION FOR TC-LIST-REPORT */\
execute_obosc_core(current_TC, obosc_tm_current->next_TM, reset_flag);\
++obosc_executed_count;\
/*INCREMENT POINTER TO THE LAST NODE*/\
int overflowCountOBinside = 0;\
while( obosc_tm_current->next_TM != NULL ){\
if( overflowCountOBinside < TM_OVERFLOW_CONSTANT ){\
obosc_tm_current = obosc_tm_current->next_TM;\
++overflowCountOBinside;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
uint16_t temp16 = TC_STATE_SUCCESSFULLY_EXECUTED;\
PUTexec_status(current_TC, temp16);\
}\
}\
}\
current_TC = current_TC->next_TC;\
++overCount;\
}\
else{\
/*PENDING: REST CDMS: MEMORY LEAK FOUND*/\
break;\
}\
}\
}\
if( obosc_executed_count != 0 ){\
snd_tm.head_pointer(obosc_tm_head);\
adf_not_SDcard;\
}\
delete_all_tm(obosc_tm_head);\
if ( reset_flag == 1 ){\
reset_all;\
break;\
}\
}
#define EXECUTE_TC {\
gMASTER_STATE = TCL_STATE_EXECUTING;\
/*gPC.printf("%u\r\n", gTOTAL_VALID_TC);*/\
for(uint8_t execute_psc = PSC_START_VALUE ; execute_psc < gTOTAL_VALID_TC ; ++execute_psc ){\
/*gPC.printf("executing normal %u\r\n", execute_psc);*/\
/*gLEDG = !gLEDG;*/\
/*gLEDR = !gLEDR;*/\
Base_tc* current_TC = gHEAD_NODE_TCL;\
int overflowCount = 0;\
while(current_TC != NULL){\
if( overflowCount < TCL_OVERFLOW_CONSTANT ){\
if( (GETcrc_pass(current_TC) == 1) && (GETpacket_seq_count(current_TC) == execute_psc) ){\
uint8_t current_exec_status = GETexec_status(current_TC);\
if( (current_exec_status == TC_STATE_SUCCESSFULLY_EXECUTED) || (current_exec_status == TC_STATE_DISABLED) ){\
/*gPC.printf("disabled or completed at %u\n", execute_psc);*/\
if( execute_psc == (gTOTAL_VALID_TC-1) ){\
gMASTER_STATE = TCL_STATE_COMPLETED;\
Base_tm *tm_ptr_head = NULL;\
get_call_sign(tm_ptr_head);\
Base_tm *tm_ptr = tm_ptr_head;\
get_ack_l1(tm_ptr->next_TM);\
/*Send only call sign, ACK_L1*/\
snd_tm.head_pointer(tm_ptr_head);\
adf_not_SDcard;\
delete_all_tm(tm_ptr_head);\
}\
break;\
}\
else if( (current_exec_status == TC_STATE_EXECUTION_FAILED) && (GETabort_on_nack(current_TC) == 1) ){\
/*gPC.printf("abort on nack at %u psc\r\n", execute_psc);*/\
gMASTER_STATE = TCL_STATE_ABORTED;\
Base_tm *tm_ptr_head = NULL;\
get_call_sign(tm_ptr_head);\
Base_tm *tm_ptr = tm_ptr_head;\
get_ack_l1(tm_ptr->next_TM);\
/*Send only call sign, ACK_L1*/\
snd_tm.head_pointer(tm_ptr_head);\
adf_not_SDcard;\
delete_all_tm(tm_ptr_head);\
break;\
}\
else if( (current_exec_status == TC_STATE_UNEXECUTED) || (current_exec_status == TC_STATE_MARKED_RETRY) ){\
/*EXECUTION OF TC START*/\
uint8_t temp81 = 0x00;\
isit_sdcard(current_TC, temp81);\
if( temp81 == 0x00 ){\
/*gPC.printf("non sd card at %u\r\n", execute_psc);*/\
/*EXECUTION OF NON SD-CARD (BOTH OBOSC and CDMS functions)*/\
Base_tm *tm_ptr_head = NULL;\
get_call_sign(tm_ptr_head);\
Base_tm *put_tm_here = NULL;\
uint8_t temp82 = 0x00;\
uint8_t tempPAhot = 0x00;\
isit_obosc(current_TC, temp82);\
if(temp82 == 0x01){\
/*gPC.printf("obosc tc inside normal tc at %u\r\n", execute_psc);*/\
/*EXECUTION OF OBOSC TC*/\
/*SKIP EXECUTION OF OBOSC HERE*/\
if( execute_psc == (gTOTAL_VALID_TC-1) ){\
gMASTER_STATE = TCL_STATE_COMPLETED;\
}\
break;\
}\
else{\
/*gPC.printf("cdms relay tmtc at %u\r\n", execute_psc);*/\
/*call CDMS_RLY_TMTC*/\
/*CDMS_RLY_TMTC(current_TC, put_tm_here);*/\
put_tm_here = FCTN_CDMS_RLY_TMTC(current_TC);\
}\
/*DETECT ACK OR NACK*/\
uint8_t temp83 = 0x00;\
uint8_t temp84 = GETpacket_seq_count(current_TC);\
detect_ack(put_tm_here, temp83, temp84);\
if( temp83 == 0x01){\
uint16_t temp16 = TC_STATE_SUCCESSFULLY_EXECUTED;\
PUTexec_status(current_TC, temp16);\
}\
else{\
/*gPC.puts("TC_STATE_EXECUTION_FAILED");*/\
uint16_t temp16 = TC_STATE_EXECUTION_FAILED;\
PUTexec_status(current_TC, temp16);\
}\
/*ABORT ON NACK AND TC LIST COMPLETED: UPDATE IN gMASTERSTATE*/\
if( (GETexec_status(current_TC) == TC_STATE_EXECUTION_FAILED) && (GETabort_on_nack(current_TC) == 1) ){\
gMASTER_STATE = TCL_STATE_ABORTED;\
}\
else if( execute_psc == (gTOTAL_VALID_TC-1) ){\
/*LAST TC IS EXECUTED*/\
gMASTER_STATE = TCL_STATE_COMPLETED;\
}\
/*update last executed L1_ack*/\
if( put_tm_here != NULL ){\
if( GETshort_or_long_tm(put_tm_here->fields) == SHORT_TM_CODE ){\
for(int i = 0 ; i < TM_SHORT_SIZE ; ++i){\
gLAST_TM[i] = put_tm_here->TM_string[i];\
gLAST_TM_SHORT_OR_LONG = SHORT_TM_CODE;\
}\
}\
else{\
for( int i = 0 ; i < TM_LONG_SIZE ; ++i ){\
gLAST_TM[i] = put_tm_here->TM_string[i];\
gLAST_TM_SHORT_OR_LONG = LONG_TM_CODE;\
}\
}\
}\
/*PENDING: APPEND ACK L1*/\
Base_tm *tm_ptr = tm_ptr_head;\
get_ack_l1(tm_ptr->next_TM);\
int overflowCountExecute = 0;\
while( tm_ptr->next_TM != NULL ){\
if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\
tm_ptr = tm_ptr->next_TM;\
++overflowCountExecute;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
tm_ptr->next_TM = put_tm_here;\
/*CHECK FOR HOT PA*/\
isPAhot(tempPAhot);\
if( tempPAhot == 0x00 ){\
gFLAGS = gFLAGS | COM_PA_HOT_FLAG;\
}\
/*Send call sign, ACK_L1, NON OBSRS TM*/\
snd_tm.head_pointer(tm_ptr_head);\
adf_not_SDcard;\
delete_all_tm(tm_ptr_head);\
}\
else{\
/*gPC.printf("sd card at %u\r\n", execute_psc);*/\
/*EXECUTION OF SD-CARD DATA SENDING (OBSRS)*/\
Base_tm *tm_ptr_head = NULL;\
get_call_sign(tm_ptr_head);\
Base_tm *put_tm_here = NULL;\
/*execute_obsrs(current_TC, put_tm_here)*/\
/*read_TC(current_TC);*/\
uint8_t tempExec = TC_STATE_SUCCESSFULLY_EXECUTED;\
PUTexec_status(current_TC, tempExec);\
/*PENDING: ABORT ON NACK CHECK, gMASTER_STATE VERIFICATION WITH SD CARD,PA hot and session timeout, last executed ack l234*/\
if( (GETexec_status(current_TC) == TC_STATE_EXECUTION_FAILED) && (GETabort_on_nack(current_TC) == 1) ){\
gMASTER_STATE = TCL_STATE_ABORTED;\
}\
else if( execute_psc == (gTOTAL_VALID_TC-1) ){\
gMASTER_STATE = TCL_STATE_COMPLETED;\
}\
/*PENDING: APPEND ACK L1*/\
Base_tm *tm_ptr = tm_ptr_head;\
get_ack_l1(tm_ptr->next_TM);\
int overflowCountExecute = 0;\
while( tm_ptr->next_TM != NULL ){\
if( overflowCountExecute < TM_OVERFLOW_CONSTANT ){\
tm_ptr = tm_ptr->next_TM;\
++overflowCountExecute;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
tm_ptr->next_TM = put_tm_here;\
/*CHECK FOR HOT PA*/\
uint8_t tempPAhot = 0x00;\
isPAhot(tempPAhot);\
if( tempPAhot == 0x00 ){\
gFLAGS = gFLAGS | COM_PA_HOT_FLAG;\
}\
/*Send only call sign, ACK_L1, OBSRS TM*/\
snd_tm.head_pointer(tm_ptr_head);\
adf_not_SDcard;\
delete_all_tm(tm_ptr_head);\
}\
}\
break;\
}\
current_TC = current_TC->next_TC;\
++overflowCount;\
}\
else{\
/*PENDING: RESET CDMS*/\
break;\
}\
}\
if( gFLAGS & COM_SESSION_TIMEOUT_FLAG ){\
break;\
}\
else if( gMASTER_STATE == TCL_STATE_ABORTED ){\
/*gPC.puts("ABORTING DUE TO ABORT ON NACK\r\n");*/\
/*EXITED DUE TO ABORT ON NACK:*/\
/*PENDING : POWER OFF COM TX*/\
RX1M.attach(&rx_read, Serial::RxIrq);\
gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\
break;\
}\
else if( gFLAGS & COM_PA_HOT_FLAG ){\
/*PA HOT: WAIT FOR TIMEOUT*/\
gCOM_PA_COOLING_TIMEOUT.attach(&after_cooling_pa, COM_PA_COOLING_TIME_LIMIT);\
/*PENDING : POWER OFF COMM TX*/\
RX1M.attach(&rx_read, Serial::RxIrq);\
gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\
break;\
}\
/*gPC.printf("successflly executed %u tc\r\n", execute_psc);*/\
}\
if( (gMASTER_STATE == TCL_STATE_COMPLETED) || (gFLAGS & COM_SESSION_TIMEOUT_FLAG) ){\
/*gPC.printf("completed or session timed out: %x\r\n", gMASTER_STATE);*/\
/*COMPLETED EXECUTION OF TC*/\
gMASTER_STATE = TCL_STATE_COMPLETED;\
COM_POWER_OFF_TX;\
reset_all;\
/*PENDING : ENABLE THREADS*/\
gSESSION_TIMEOUT.detach();\
gFLAGS = gFLAGS & (~COM_MNG_TMTC_RUNNING_FLAG);\
gFLAGS = gFLAGS & (~COM_SESSION_FLAG);\
}\
}