File content as of revision 1:df31097c8442:

// Apil 15
//added back printf statements
//added back delete TC_string for debugging

// add number of tm packets while calling snd 
// function overloading z

#include "SND_TM.h"

// starting value of packet sequence count at each pass 
#define PSC_START_VALUE 1

// APID list
#define APID_CALLSIGN 0
#define APID_BAE 1
#define APID_CDMS 2
#define APID_SPEED 3

// HIGH PRIORITY TC - priority list
// not correct values here
#define HPTC1 5
#define HPTC2 6
// Add more entries above

// size of short TM without CRC - in bytes
#define TM_SHORT_SIZE 14
#define TM_LONG_SIZE 131

// TMID list
#define TMID_ACK_L1 10

typedef struct TC_list{
    // received from the RCV_TC
    unsigned char *TC_string;
    bool short_or_long; //'true' for short
    bool crc_pass;

    // updated info - updated in MNG_TC
    unsigned char packet_seq_count;
    unsigned char apid;
    bool abort_on_nack;
    bool enabled;
    bool valid_execution;

    struct TC_list *next_TC;
}TC_list;

//typedef struct TM_list{
//
//    unsigned char *TM_string;
//    // bool short_or_long; // true for short
//    // pass while calling the function
//    unsigned char tmid;
//
//    struct TM_list *next_TM;
//}TM_List;

class MNG_TC
{
private:

    // private variables and flags
    int total_valid_TC;
    TC_list *TC_list_header;
    bool all_crc_pass;
    bool no_missing_TC;
    bool stop_after_current_TC;
    bool execute_high_priority_TC;

    // private functions
    void delete_TC(TC_list *tc_ptr, TC_list* previous_tc){
        // stitch the previous and next node
        TC_list *temp_n = tc_ptr->next_TC;
        
        if( (previous_tc != NULL) && (temp_n != NULL) ){
            previous_tc->next_TC = temp_n;
        }
        else if( (previous_tc == NULL) && (temp_n != NULL) ){
            // delete head node
            TC_list_header = temp_n;
        }
        else if( (previous_tc != NULL) && (temp_n == NULL) ){
            // delete last node
            previous_tc->next_TC = NULL;
        }
        else{
            // delete the only single node present
            // in which case head is the only node
            TC_list_header = NULL;
        }

        // delete the string
        delete tc_ptr->TC_string;
        // delete the node
        delete tc_ptr;
    }

    void generate_L1_ack_TM(TM_list *tm_ptr){
        tm_ptr->next_TM = NULL;
        tm_ptr->TM_string = new unsigned char[TM_SHORT_SIZE];
        // TMID
        tm_ptr->TM_string[0] = 0xaf;
        tm_ptr->TM_string[1] = 0xff;
        tm_ptr->TM_string[2] = 0xff;
        tm_ptr->TM_string[3] = 0xff;
    }
    
    TM_list* manage_process(TC_list *ptr_tc){
        TM_list *test_TM = new TM_list;
        test_TM->next_TM = NULL;
        unsigned char *str = new unsigned char[TM_LONG_SIZE];
        //ping the TC
        test_TM->tmid = 0xa;

        // 4 bit TMID
        str[0] = (0xa) << 4;
        
        // 20 bit seq. count
        str[0] += 0xf;
        str[1] = 0xff;
        str[2] = 0xff;

        // return data and append zeroes
        for(int i = 3 ; i < 9 ; ++i ){
            str[i] = ptr_tc->TC_string[i];
        }
        for(int i = 9 ; i < TM_LONG_SIZE ; ++i){
            str[i] = 0;
        }

        test_TM->TM_string = str;

        return test_TM;
    }
    
    bool detect_nack(TM_list *ptr_tm){
        bool bluff = false;
        return bluff;
    }

public:
    // Constructor
    MNG_TC(TC_list *head){
        total_valid_TC = 0;
        TC_list_header = head;
        all_crc_pass = true;
        no_missing_TC = true;
        stop_after_current_TC = false;
        execute_high_priority_TC = false;
    };

    // delete the crc failed TC from the list to free-up memory
    // and update the total valid TC
    // and GENERATE L1_ACK_TM
    void TC_list_cleanup(){
//        printf("Inside cleanup\r\n");
        TC_list *current_TC = TC_list_header;
        TC_list *previous_TC = NULL;
        
        total_valid_TC = 0;
        all_crc_pass = true;

        TM_List *l1_ack = new TM_List;
        TM_List *l1_ack_head = l1_ack;
        generate_L1_ack_TM(l1_ack);
        
        int TC_count = 0;
        
        l1_ack->TM_string[4] = 0x01;
        l1_ack->TM_string[5] = 0xff;

        while(current_TC != NULL){
//            printf("Inside null\r\n");
            
//            printf("TC_count = %u\r\npsc = %u\r\n", TC_count, current_TC->TC_string[0]);
            // don't care : crc pass or fail
            l1_ack->TM_string[6+TC_count] = current_TC->TC_string[0];

            if( current_TC->crc_pass ){
                ++total_valid_TC;

                // set the crc pass field
//                l1_ack->TM_string[2] |= ( 1 << (7-TC_count) );

                // advance to the next node
                previous_TC = current_TC;
                current_TC = current_TC->next_TC;
            }
            // crc fail
            else{
                // unset the crc pass field
//                l1_ack->TM_string[2] &= ~( 1 << (7-TC_count) );

                // delete and advance to the next node
                TC_list *next = current_TC->next_TC;
//                delete_TC(current_TC, previous_TC);
                current_TC = next;
                all_crc_pass = false;
            }
            ++TC_count;

            // extend the linked list if TC_count > 7
//            if(TC_count > 7){
//                TC_count = 0;
//
//                l1_ack->next_TM = new TM_List;
//                l1_ack = l1_ack->next_TM;
//                generate_L1_ack_TM(l1_ack);
//            }
        }
        
        for(int i = 0 ; i < 7 ; ++i){
            l1_ack->TM_string[7+i] = 0x00;
        }

//        printf("Sending data\r\n");
        SND_TM(l1_ack, false, 1);
//        printf("finished sending data\r\n");

        // delete the TM
//        l1_ack = l1_ack_head;
//        while(l1_ack != NULL){
//            TM_List *temp = l1_ack->next_TM;
////            delete l1_ack->TM_string;
////            delete l1_ack;
//            l1_ack = temp;
//        }

//        if(all_crc_pass == false){
//            // exit
//        }
//        printf("Completed cleanup\r\n");
//        printf("valid TC = %d\r\n", total_valid_TC);
    }

    // At this stage ALL NODES ARE CRC PASS
    // decode the TCs and fill in the values in the tc-node
    void decode_TC(){
        printf("Inside decode tc\r\n");
        TC_list *node_ptr = TC_list_header;

        while( node_ptr != NULL ){

            unsigned char temp;

            // PSC
            node_ptr->packet_seq_count = node_ptr->TC_string[0];
            // APID
            temp = node_ptr->TC_string[1];
            printf("chr for apid is %d\r\n", temp);
            node_ptr->apid = (temp >> 6) & 3;
            printf("apid = %d\r\n", node_ptr->apid);
            // Abort On Nack
            node_ptr->abort_on_nack = (temp >> 3) & 1;
            // default values of enable and execution
            node_ptr->enabled = true;
            node_ptr->valid_execution = false;

            node_ptr = node_ptr->next_TC;
        }
        printf("completed decode\r\n");
    }

    // check for missing tc
    // run TC_list_cleanup() before running this function
    void check_for_missing_tc(){
        printf("inside check for missing\r\n");
        no_missing_TC = true;
        for(unsigned char psc = PSC_START_VALUE ; psc < (total_valid_TC+PSC_START_VALUE) ; ++psc ) {
            bool flag = false;
            TC_list *node_ptr = TC_list_header;
            while(node_ptr != NULL){
                if( node_ptr->packet_seq_count == psc ){
                    flag = true;
                    break;
                }
                else{
                    node_ptr = node_ptr->next_TC;
                }
            }
            if( flag == false ){
                no_missing_TC = false;
                // packet with PSC = psc is missing !!
                // exit
                printf("exit\r\n");
            }
        }
        printf("Completed check for missing\r\n");
    }


    // At this stage ALL NODE ARE CRC PASS and NO MISSING PACKETS
    // function : send TC to the target wait and receive from target
    void execute_TC(){
        printf("inside execute tc\r\n");
        unsigned char psc = PSC_START_VALUE;
        while( psc < (total_valid_TC+PSC_START_VALUE) ){
            printf("psc = %d\r\n", psc);
            if(stop_after_current_TC){
                // exit
                printf("exit stop after current TC\r\n");
            }
            else if(execute_high_priority_TC){
                printf("Inside hptc\r\n");
                TC_list *tc_ptr = TC_list_header;
                while(tc_ptr != NULL){
                    // high priority TC belong APID_CDMS
                    if( tc_ptr->apid == APID_CDMS ){
                        // setup the priority order in nested if else
                        unsigned char temp = tc_ptr->TC_string[2];
                        unsigned char service = ( temp >> 4 ) & 0xf;
                        TM_List *tm_ptr;
                        if(service == HPTC1){
                            tm_ptr = manage_process(tc_ptr); 
                        }
                        else if(service == HPTC2){
                            tm_ptr = manage_process(tc_ptr);
                        }
                        // add more entries above

                        // add number of tm packets also while calling snd 
                        // tc_ptr : SND_TM to GS
                        // delete tm

                        if( detect_nack(tm_ptr) ){
                            if(tc_ptr->abort_on_nack){
                                // exit
                                printf("exit");
                            }
                        }
                        else{
                            tc_ptr->valid_execution = true;
                            // delete the tc string to free up memory
                            delete tc_ptr->TC_string;
                        }
                    }
                }
                execute_high_priority_TC = false;
            }
            else{
                printf("executing normal TC\r\n");
                TC_list *current_TC = TC_list_header;
                // find the tc corresponding to the psc
                while(current_TC != NULL){
                    printf("while : finding tc with psc : %d\r\n", psc);
                    if( current_TC->packet_seq_count == psc ){
                        printf("inside IF\r\n");
                        TM_List *tm_ptr;
                        printf("apid = %d\r\n", current_TC->apid);
                        if(current_TC->apid == APID_CDMS){
                            printf("CDMS APID found!\r\n");
                            tm_ptr = manage_process(current_TC);
                        }
                        else{
                            // call RLY_TMTC
                            // wait and receive for TM
                            tm_ptr = tm_ptr;
                        }

                        // add number of tm packets also
                        printf("sending data\r\n");
                        SND_TM(tm_ptr, false, 1);
                        printf("\r\nfinished sending data\r\n");

                        if( detect_nack(tm_ptr) ){
                            if(current_TC->abort_on_nack){
                                // exit
                                printf("exit");
                            }
                        }
                        else{
                            current_TC->valid_execution = true;
                            // delete the tc string to free up memory
                            printf("deleting TC string\r\n");
//                            delete current_TC->TC_string;
                            printf("finished deleting TC string\r\n");
                        }

                        // delete the TM received after sending to GS
                        printf("deleting TM received\r\n");
                        delete tm_ptr->TM_string;
                        delete tm_ptr;

                        // found the tc with psc hence break
                        break;
                    }

                    current_TC = current_TC->next_TC;
                }
                ++psc;
            }
        }
        printf("completed execute tc\r\n");
    }

//    ~MNG_TC();
 
    /* data */
};