Diff: ThreadsAndFunctions.h

Revision:

2:2caf2a9a13aa

Parent:

1:a0055b3280c8

Child:

3:6c81fc8834e2

diff -r a0055b3280c8 -r 2caf2a9a13aa ThreadsAndFunctions.h
--- a/ThreadsAndFunctions.h	Mon Dec 14 12:04:01 2015 +0000
+++ b/ThreadsAndFunctions.h	Tue Dec 22 06:09:48 2015 +0000
@@ -1,21 +1,22 @@
 // UART ISR
 void rx_read(){
-    *gRX_CURRENT_PTR = RX1M.getc();
-    gFLAGS = gFLAGS | (0xFF & UART_INT_FLAG);
+    gRX_CURRENT_DATA_NODE->values[gRX_COUNT] = RX1M.getc();
+    gFLAGS = gFLAGS | UART_INT_FLAG;
     gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
 }
 
 // RX_TIMEOUT ISR
 void after_receive(){
     gRX_TIMEOUT.detach();
-    gFLAGS = gFLAGS | (0xFF & NEW_TC_RECEIVED);
+    gFLAGS = gFLAGS | NEW_TC_RECEIVED;
     gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
 }
 
 // SESSION_TIMOUT ISR
 void after_session(){
     gSESSION_TIMEOUT.detach();
-    gFLAGS = gFLAGS | (0xFF & END_SESSION);
+    gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
+    gCOM_MNG_TMTC_THREAD->signal_set(COM_MNG_TMTC_SIGNAL_UART_INT);
 }
 
 #define reset_all {\
@@ -29,6 +30,7 @@
     rx_tc_frames = 0;\
     gTOTAL_INCORRECT_SIZE_TC = 0;\
     gTOTAL_CRC_FAIL_TC = 0;\
+    gTOTAL_REPEATED_TC = 0;\
     COM_RX_DATA_NODE *dataptr = gRX_HEAD_DATA_NODE;\
     while( dataptr != NULL ){\
         COM_RX_DATA_NODE *temp = dataptr->next_node;\
@@ -38,8 +40,21 @@
     gRX_HEAD_DATA_NODE = new COM_RX_DATA_NODE;\
     gRX_HEAD_DATA_NODE->next_node = NULL;\
     gRX_CURRENT_DATA_NODE = gRX_HEAD_DATA_NODE;\
-    gRX_CURRENT_PTR = gRX_HEAD_DATA_NODE->values;\
     gRX_COUNT = 0;\
+    /*PENDING : ALL GLOBAL VAARIABLES AND FLAGS*/\
+}
+
+#define PUT_RAW_BYTE {\
+    if( gRX_COUNT < (RX_BUFFER_LENGTH-1) ){\
+        ++gRX_COUNT;\
+    }\
+    else{\
+        gRX_COUNT = 0;\
+        gRX_CURRENT_DATA_NODE->next_node = new COM_RX_DATA_NODE;\
+        gRX_CURRENT_DATA_NODE = gRX_CURRENT_DATA_NODE->next_node;\
+        gRX_CURRENT_DATA_NODE->next_node = NULL;\
+    }\
+    gRX_TIMEOUT.attach(&after_receive, RX_TIMEOUT_LIMIT);\
 }
 
 void COM_MNG_TMTC_FUN(void const *args){
@@ -47,63 +62,93 @@
         Thread::signal_wait( COM_MNG_TMTC_SIGNAL_UART_INT );
         if( gFLAGS & UART_INT_FLAG ){
             gFLAGS = gFLAGS & (~UART_INT_FLAG);
-            if( gRX_COUNT < (RX_BUFFER_LENGTH-1) ){
-                ++gRX_CURRENT_PTR;
-                ++gRX_COUNT;
+            if( !(gFLAGS & COM_SESSION_FLAG) ){
+                // PENDING : DISABLE THREADS
+                gFLAGS = gFLAGS | COM_SESSION_FLAG;
+                gSESSION_TIMEOUT.attach(&after_session, SESSION_TIME_LIMIT);
+                gFLAGS = gFLAGS | COM_RX_FLAG;
+                PUT_RAW_BYTE;
+                // PENDING : MEASURE RSSI
+            }
+            else if( gFLAGS & COM_RX_FLAG ){
+                PUT_RAW_BYTE;
             }
             else{
-                gLEDG = !gLEDG;
-                gRX_COUNT = 0;
-                gRX_CURRENT_DATA_NODE->next_node = new COM_RX_DATA_NODE;
-                gRX_CURRENT_DATA_NODE = gRX_CURRENT_DATA_NODE->next_node;
-                gRX_CURRENT_DATA_NODE->next_node = NULL;
-                gRX_CURRENT_PTR = gRX_CURRENT_DATA_NODE->values;
+                gFLAGS = gFLAGS | COM_RX_FLAG;
+                PUT_RAW_BYTE;
             }
-            gRX_TIMEOUT.attach(&after_receive, RX_TIMEOUT_LIMIT);
         }
-        else if( gFLAGS & NEW_TC_RECEIVED ){
+        else if( (gFLAGS & NEW_TC_RECEIVED) && (gFLAGS & COM_MNG_TMTC_RUNNING_FLAG) ){
             gFLAGS = gFLAGS & (~NEW_TC_RECEIVED);
-            
+            gFLAGS = gFLAGS & (~COM_RX_FLAG);
+
             // DISABLE THE RX1M INTERRUPT
             RX1M.attach(NULL);
             
-            // PENDING: BEACON
-            while(gRX_COUNT < (RX_BUFFER_LENGTH-1)){
-                *gRX_CURRENT_PTR = 0x00;
-                ++gRX_CURRENT_PTR;
+            while(gRX_COUNT < (RX_BUFFER_LENGTH)){
+                gRX_CURRENT_DATA_NODE->values[gRX_COUNT] = 0x00;
                 ++gRX_COUNT;
             }
             gRX_COUNT = 0;
-            
-            if( (gMASTER_STATE == TCL_STATE_IDLE) || (gMASTER_STATE == TCL_STATE_ABORTED) || (gMASTER_STATE == TCL_STATE_COMPLETED)){
-                raw_data_to_tc();
-                if( (gTOTAL_VALID_TC > 0) && (gFLAGS & START_SESSION) ){
-                    gFLAGS = gFLAGS & (~START_SESSION);
-                    gSESSION_TIMEOUT.attach(&after_session, SESSION_TIME_LIMIT);
-                }
+
+            // VERIFY CRC, REPEATED PSC AND UPDATE TOTAL_VALID_TC, INCORRECT SIZE TC, CRC FAIL TC
+            raw_data_to_tc();
+            if( gTOTAL_VALID_TC > 0 ){
+                // CHECK WEATHER TC LIST HAS MISSING TC OR WEATHER LAST FRAME BIT IS HIGH IN THE LAST PSC-TC
                 uint8_t tempContinue = 0xFF;
                 continueToExecute(tempContinue);
-                if( tempContinue == 0x00 ){
-                    if(gMASTER_STATE == TCL_STATE_ABORTED){
-                        gMASTER_STATE = TCL_STATE_EXECUTING;
-                        send_l1_ack;
+                if(tempContinue == 0x00){
+                    // CHECK WEATHER GS VERIFICATION CODE MATCHES
+                    uint8_t tempGSver = 0x00;
+                    GScodeVerification(tempGSver);
+                    if( tempGSver ){
+                        gFLAGS = gFLAGS | COM_SESSION_VALIDITY;
+                        // PENDING : COM_POWER_ON_TX
                         EXECUTE_OBOSC_ONLY;
+                        EXECUTE_TC;
                     }
-                    send_l1_ack;
-                    EXECUTE_TC;
+                    else{
+                        gFLAGS = gFLAGS & (~COM_SESSION_VALIDITY);
+                        // PENDING : ENABLE THREADS
+                        gSESSION_TIMEOUT.detach();
+                        gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
+                    }
                 }
                 else{
-                    send_l1_ack;
+                    // PENDING : COM_POWER_ON_TX
+                    // PENDING : POWER OFF TX
+                    RX1M.attach(&rx_read, Serial::RxIrq);
                 }
-                gPC.puts("Completed Execution\r\n");
+            }
+            else if( !(gFLAGS & COM_TX_FLAG) ){
+                RX1M.attach(&rx_read, Serial::RxIrq);
+                // PENDING : ENABLE THREADS
+                gSESSION_TIMEOUT.detach();
+                gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
+            }
+        }
+        else if( gFLAGS & COM_PA_HOT_FLAG ){
+            uint8_t tempPA = 0xFF;
+            isPAhot(tempPA);
+            if( tempPA == 0x00 ){
+                gCOM_PA_COOLING_TIMER.attach(&after_cooling_pa, COM_PA_COOLING_TIME_LIMIT);
             }
             else{
-                // invalid state found - reset
-                reset_all;
+                gFLAGS = gFLAGS & (~COM_PA_HOT_FLAG);
+                gCOM_PA_COOLING_TIMER.detach();
+                // PENDING : COM POWER ON TX
+                EXECUTE_OBOSC_ONLY;
+                EXECUTE_TC;
             }
+        }
+        else{
+            // SOME INVALID SIGNAL RECEIVED
             
-            // PENDING: BEACON
-            RX1M.attach(&rx_read, Serial::RxIrq);
+            // PENDING : COM_POWER_OFF_TX
+            reset_all;
+            // PENDING : ENABLE THREADS
+            gSESSION_TIMEOUT.detach();
+            gFLAGS = gFLAGS & (~COM_SESSION_FLAG);
         }
     }
 }
\ No newline at end of file