Diff: MNG_TC.h

Revision:

0:b5b370873460

Child:

1:df31097c8442

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MNG_TC.h	Wed Apr 15 10:43:22 2015 +0000
@@ -0,0 +1,386 @@
+// 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 11
+#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] = (10 << 4) & 0xf0;
+        // fill EXEC CODE below
+    }
+    
+    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;
+
+        while(current_TC != NULL){
+            
+            // don't care : crc pass or fail
+            l1_ack->TM_string[3+TC_count] = current_TC->packet_seq_count;
+
+            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);
+            }
+        }
+
+        // SND_L1_ACK to GS
+
+        // 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 */
+};
\ No newline at end of file