Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -recf20c9111729fe3264aa381ccb06cdd695bf98a -r35a33f10e1c5bb5abde9d98236e7945e2ace981b
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision ecf20c9111729fe3264aa381ccb06cdd695bf98a)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 35a33f10e1c5bb5abde9d98236e7945e2ace981b)
@@ -59,10 +59,22 @@
     #define DEBUG_EVENT_MAX_TEXT_LEN    40
 #endif
 
+#define MAX_MSGS_BLOCKED_FOR_XMIT       8           ///< Maximum number of messages to block transmission for.
+
+#pragma pack(push,1)
+/// Payload record structure for block message transmission request.
+typedef struct
+{
+    U16 blockedMessages[ MAX_MSGS_BLOCKED_FOR_XMIT ];
+} BLOCKED_MSGS_DATA_T;
+#pragma pack(pop)
+
 // ********** private data **********
 
 static BOOL testerLoggedIn = FALSE;                 ///< Flag indicates whether tester logged in or not.
 static volatile U16 nextSeqNo = 1;                  ///< Next sequence number.
+/// List of message IDs that are requested not to be transmitted.
+static BLOCKED_MSGS_DATA_T blockedMessagesForXmit = { 0, 0, 0, 0, 0, 0, 0, 0 };
 
 // ********** private function prototypes **********
 
@@ -88,66 +100,89 @@
 {
     BOOL result = FALSE;
     BOOL error = FALSE;
+    BOOL blocked = FALSE;
     U32 msgSize = 0;
     U32 sizeMod, sizePad;
     U32 i;
     U08 crc;
     U08 data[ MAX_ACK_MSG_SIZE ];  // byte array to populate with message data
 
-    // prefix data with message sync byte
-    data[ msgSize++ ] = MESSAGE_SYNC_BYTE;
+    // Check to see if tester has requested this message not be transmited
+    if ( TRUE == isTestingActivated() )
+    {
+        U32 i;
+
+        for ( i = 0; i < MAX_MSGS_BLOCKED_FOR_XMIT; i++ )
+        {
+            if ( msg.hdr.msgID == blockedMessagesForXmit.blockedMessages[ i ] )
+            {
+                blocked = TRUE;
+                break;
+            }
+        }
+    }
+    // Serialize and queue message for transmission unless this message is blocked
+    if ( blocked != TRUE )
+    {
+        // prefix data with message sync byte
+        data[ msgSize++ ] = MESSAGE_SYNC_BYTE;
 
-    // set sequence # and ACK bit (unless this is an ACK to a received message)
-    if ( msg.hdr.msgID != MSG_ID_ACK )
-    {
-        // thread protect next sequence # access & increment
-        _disable_IRQ();
-            msg.hdr.seqNo = nextSeqNo;
-            nextSeqNo = INC_WRAP( nextSeqNo, MIN_MSG_SEQ_NO, MAX_MSG_SEQ_NO );
-        _enable_IRQ();
-        if ( TRUE == ackReq )
+        // set sequence # and ACK bit (unless this is an ACK to a received message)
+        if ( msg.hdr.msgID != MSG_ID_ACK )
         {
-            msg.hdr.seqNo *= -1;
+            // thread protect next sequence # access & increment
+            _disable_IRQ();
+                msg.hdr.seqNo = nextSeqNo;
+                nextSeqNo = INC_WRAP( nextSeqNo, MIN_MSG_SEQ_NO, MAX_MSG_SEQ_NO );
+            _enable_IRQ();
+            if ( TRUE == ackReq )
+            {
+                msg.hdr.seqNo *= -1;
+            }
         }
-    }
 
-    // calculate message CRC
-    crc = crc8( (U08*)(&msg), sizeof( MESSAGE_HEADER_T ) + msg.hdr.payloadLen );
+        // calculate message CRC
+        crc = crc8( (U08*)(&msg), sizeof( MESSAGE_HEADER_T ) + msg.hdr.payloadLen );
 
-    // serialize message header data
-    memcpy( &data[ msgSize ], &( msg.hdr ), sizeof( MESSAGE_HEADER_T ) );
-    msgSize += sizeof( MESSAGE_HEADER_T );
+        // serialize message header data
+        memcpy( &data[ msgSize ], &( msg.hdr ), sizeof( MESSAGE_HEADER_T ) );
+        msgSize += sizeof( MESSAGE_HEADER_T );
 
-    // serialize message payload (only used bytes per payloadLen field)
-    memcpy( &data[ msgSize ], &( msg.payload ), msg.hdr.payloadLen );
-    msgSize += msg.hdr.payloadLen;
+        // serialize message payload (only used bytes per payloadLen field)
+        memcpy( &data[ msgSize ], &( msg.payload ), msg.hdr.payloadLen );
+        msgSize += msg.hdr.payloadLen;
 
-    // add 8-bit CRC
-    data[ msgSize++ ] = crc;
+        // add 8-bit CRC
+        data[ msgSize++ ] = crc;
 
-    // pad with zero bytes to get length a multiple of CAN_MESSAGE_PAYLOAD_SIZE (8)
-    sizeMod = msgSize % CAN_MESSAGE_PAYLOAD_SIZE;
-    sizePad = ( sizeMod == 0 ? 0 : CAN_MESSAGE_PAYLOAD_SIZE - sizeMod );
-    for ( i = 0; i < sizePad; i++ )
-    {
-        data[ msgSize++ ] = 0;
-    }
+        // pad with zero bytes to get length a multiple of CAN_MESSAGE_PAYLOAD_SIZE (8)
+        sizeMod = msgSize % CAN_MESSAGE_PAYLOAD_SIZE;
+        sizePad = ( sizeMod == 0 ? 0 : CAN_MESSAGE_PAYLOAD_SIZE - sizeMod );
+        for ( i = 0; i < sizePad; i++ )
+        {
+            data[ msgSize++ ] = 0;
+        }
 
-    // if ACK required, add to pending ACK list
-    if ( TRUE == ackReq )
-    {
-        if ( FALSE == addMsgToPendingACKList( &msg, buffer, data, msgSize ) )
+        // if ACK required, add to pending ACK list
+        if ( TRUE == ackReq )
         {
-            error = TRUE;
-            SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_MSG_PENDING_ACK_LIST_FULL )
+            if ( FALSE == addMsgToPendingACKList( &msg, buffer, data, msgSize ) )
+            {
+                error = TRUE;
+                SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_MSG_PENDING_ACK_LIST_FULL )
+            }
         }
-    }
 
-    if ( FALSE == error )
-    {
-        // add serialized message data to appropriate out-going comm buffer
-        result = addToCommBuffer( buffer, data, msgSize );
-    }
+        if ( FALSE == error )
+        {
+            // add serialized message data to appropriate out-going comm buffer
+            result = addToCommBuffer( buffer, data, msgSize );
+        }
+    }
+    else
+    {
+        result = TRUE;  // If message blocked, return successful transmission
+    }
 
     return result;
 }
@@ -3673,4 +3708,31 @@
     return result;
 }
 
+/*********************************************************************//**
+ * @brief
+ * The handleTestBlockMessagesRequest function handles a request to
+ * block transmission of specific message(s).
+ * @details Inputs: none
+ * @details Outputs: message handled
+ * @param message : a pointer to the message to handle
+ * @return none
+ *************************************************************************/
+void handleTestBlockMessagesRequest( MESSAGE_T *message )
+{
+    BOOL result = FALSE;
+
+    // Verify payload length
+    if ( sizeof(BLOCKED_MSGS_DATA_T) == message->hdr.payloadLen )
+    {
+        if ( TRUE == isTestingActivated() )
+        {
+            result = TRUE;
+            memcpy( &blockedMessagesForXmit.blockedMessages[0], message->payload, sizeof(BLOCKED_MSGS_DATA_T) );
+        }
+    }
+
+    // Respond to request
+    sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result );
+}
+
 /**@}*/