Index: App/Contollers/Buttons.c
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Contollers/Buttons.c	(.../Buttons.c)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Contollers/Buttons.c	(.../Buttons.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -43,6 +43,9 @@
 #define STOP_BUTTON_PENDING_TIMEOUT     500     // ms
 #define STUCK_BUTTON_TIMEOUT            1000    // ms
 
+#define USER_CONFIRMED                  1
+#define USER_REJECTED                   0
+
 // ********** private data **********
 
 static BUTTON_STATE_T offButtonState = BUTTON_STATE_RELEASED;
@@ -188,7 +191,7 @@
 void userConfirmOffButton( U08 response )
 {
     // did user confirm?
-    if ( 1 == response )
+    if ( USER_CONFIRMED == response )
     {
         if ( TRUE == isCurrentOpModeOkToTurnOff() )
         {
@@ -297,9 +300,14 @@
             // if off request in a valid mode, send to UI for user confirmation
             if ( TRUE == isCurrentOpModeOkToTurnOff() )
             {
-                // TODO - send off button to UI for user confirmation
-                // TODO - remove later (just pretend user confirmed for now)
-                userConfirmOffButton(1);
+                // send off button to UI for user confirmation
+                sendOffButtonMsgToUI();
+// ***************************** TEST CODE ******************************
+// TODO - remove later (just pretend user confirmed for now)
+#if 1
+                userConfirmOffButton( USER_CONFIRMED );
+#endif
+// ************************** END TEST CODE ******************************
             }
         }
         prevOffButtonState = offButtonState;
Index: App/Drivers/CPLD.c
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Drivers/CPLD.c	(.../CPLD.c)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Drivers/CPLD.c	(.../CPLD.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -47,15 +47,15 @@
 #define TGL_OFF_REQ()      gioToggleBit( gioPORTB, OFF_REQUEST_GIO_PORT_PIN)
 #define SET_WD_PET()       gioSetBit( gioPORTB, WD_PET_GIO_PORT_PIN, PIN_SIGNAL_HIGH )
 #define SET_OFF_REQ()      gioSetBit( gioPORTB, OFF_REQUEST_GIO_PORT_PIN, PIN_SIGNAL_HIGH )
-#define SET_GREEN()        mibspiREG5->PC3 |= GREEN_SPI5_PORT_MASK
-#define SET_BLUE()         mibspiREG5->PC3 |= BLUE_SPI5_PORT_MASK
-#define SET_RED()          mibspiREG5->PC3 |= RED_SPI5_PORT_MASK
+#define SET_GREEN()        {mibspiREG5->PC3 |= GREEN_SPI5_PORT_MASK;}
+#define SET_BLUE()         {mibspiREG5->PC3 |= BLUE_SPI5_PORT_MASK;}
+#define SET_RED()          {mibspiREG5->PC3 |= RED_SPI5_PORT_MASK;}
 
 #define CLR_WD_PET()       gioSetBit( gioPORTB, WD_PET_GIO_PORT_PIN, PIN_SIGNAL_LOW )
 #define CLR_OFF_REQ()      gioSetBit( gioPORTB, OFF_REQUEST_GIO_PORT_PIN, PIN_SIGNAL_LOW )
-#define CLR_GREEN()        mibspiREG5->PC3 &= ~GREEN_SPI5_PORT_MASK
-#define CLR_BLUE()         mibspiREG5->PC3 &= ~BLUE_SPI5_PORT_MASK
-#define CLR_RED()          mibspiREG5->PC3 &= ~RED_SPI5_PORT_MASK
+#define CLR_GREEN()        {mibspiREG5->PC3 &= ~GREEN_SPI5_PORT_MASK;}
+#define CLR_BLUE()         {mibspiREG5->PC3 &= ~BLUE_SPI5_PORT_MASK;}
+#define CLR_RED()          {mibspiREG5->PC3 &= ~RED_SPI5_PORT_MASK;}
 
 // ***************************** TEST CODE ******************************
 // TODO - remove later
Index: App/Services/CommBuffers.c
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/CommBuffers.c	(.../CommBuffers.c)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/CommBuffers.c	(.../CommBuffers.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -25,19 +25,20 @@
 
 // ********** private definitions **********
 
-#define COMM_BUFFER_LENGTH      128     // bytes
+#define COMM_BUFFER_LENGTH              512     // max bytes in each comm buffer (double if you count double buffers)
+#define DOUBLE_BUFFERS                  2       // need 2 buffers for double buffering
 
 // ********** private data **********
 
-static U32 commBufferByteCount[NUM_OF_COMM_BUFFERS][2];             // for each buffer, how many bytes does it contain?  (also index to next available)
-static U32 activeDoubleBuffers[NUM_OF_COMM_BUFFERS];                // for each buffer, which double buffer is being fed right now?
-static U08 commBuffers[NUM_OF_COMM_BUFFERS][2][COMM_BUFFER_LENGTH]; // each is double buffered to avoid thread contention
+static U32 commBufferByteCount[NUM_OF_COMM_BUFFERS][DOUBLE_BUFFERS];             // for each buffer, how many bytes does it contain?  (also index to next available)
+static U32 activeDoubleBuffers[NUM_OF_COMM_BUFFERS];                             // for each buffer, which double buffer is being fed right now?
+static U08 commBuffers[NUM_OF_COMM_BUFFERS][DOUBLE_BUFFERS][COMM_BUFFER_LENGTH]; // each is double buffered to avoid thread contention
 
 // ********** private function prototypes **********
 
 static U32 switchDoubleBuffer( COMM_BUFFER_T buffer );
+static void getDataFromInactiveBuffer( COMM_BUFFER_T buffer, U08 *data, U32 len );
 static U32 getRemainingByteCapacity( COMM_BUFFER_T buffer );
-static BOOL isCommBufferEmpty( COMM_BUFFER_T buffer );
 
 /*************************************************************************
  * @brief initCommBuffers
@@ -50,7 +51,7 @@
  *************************************************************************/
 void initCommBuffers( void )
 {
-    S32 b,l,d;
+    S32 b,d,i;
 
     // reset and zero out all buffers
     for ( b = 0; b < NUM_OF_COMM_BUFFERS; b++ )
@@ -59,9 +60,9 @@
         for ( d = 0; d < 2; d++ )
         {
             commBufferByteCount[b][d] = 0;
-            for ( l = 0; l < COMM_BUFFER_LENGTH; l++ )
+            for ( i = 0; i < COMM_BUFFER_LENGTH; i++ )
             {
-                commBuffers[b][d][l] = 0;
+                commBuffers[b][d][i] = 0;
             }
         }
     }
@@ -129,16 +130,15 @@
  * @brief getFromCommBuffer
  * The getFromCommBuffer function fills a given byte array with a given \n
  * number of bytes from a given buffer and returns the number of bytes \n
- * retrieved from the buffer. This function will always draw from the \n
- * inactive double buffer.  If some of the requested data is in the active \n
- * double buffer, the double buffers will be switched when the inactive \n
- * double buffer is emptied and the retrieve will continue to the requested \n
- * number of bytes.
+ * retrieved from the buffer. This function will draw from the inactive \n
+ * double buffer first and, if needed, switch double buffers to draw the \n
+ * reset of the requested data.
  * Only one function in one thread should be calling this function for a given \n
  * buffer.
  * @details
- * Inputs : commBuffers[], commBufferByteCount[]
- * Outputs : commBufferByteCount[], activeDoubleBuffers[]
+ * Inputs : commBuffers[], commBufferByteCount[], activeDoubleBuffers[]
+ * Outputs : commBuffers[], commBufferByteCount[], activeDoubleBuffers[], \n
+ * and the given data array is populated with data from the buffer.
  * @param buffer : which comm buffer to retrieve data from
  * @param data : pointer to byte array to stuff data into
  * @param len : # of bytes to retrieve into given data array.
@@ -151,56 +151,104 @@
     // verify given buffer
     if ( buffer < NUM_OF_COMM_BUFFERS )
     {
-        // check to see if requested # of bytes is in given buffer
-        if ( getNumberOfBytesInCommBuffer( buffer ) >= len )
+        // verify size of peek
+        if ( ( len <= ( COMM_BUFFER_LENGTH * DOUBLE_BUFFERS ) ) && ( len <= numberOfBytesInCommBuffer( buffer ) ) )
         {
-            // switch double buffer (now we'll read from what was active buffer and Rx interrupts will feed new active buffer)
-            U32 activeBuffer = switchDoubleBuffer( buffer );
+            U32 activeBuffer = activeDoubleBuffers[buffer];
             U32 inactiveBuffer = ( activeBuffer == 0 ? 1 : 0 );
-            U32 bytesRetrieved = commBufferByteCount[buffer][inactiveBuffer];
+            U32 bytesInInactiveBuffer = commBufferByteCount[buffer][inactiveBuffer];
+            U32 sizeOfFirstConsumption = ( len <= bytesInInactiveBuffer ? len : bytesInInactiveBuffer );
 
-            // ensure caller's data buffer can hold the data we have to retrieve
-            if ( bytesRetrieved <= 1000 )  // was maxLen
+            // see what we can get from inactive buffer
+            getDataFromInactiveBuffer( buffer, data, sizeOfFirstConsumption );  // will switch double buffers if we empty inactive buffer
+            // will return # of bytes consumed
+            result = sizeOfFirstConsumption;
+            // do we need more from active buffer?
+            if ( len > bytesInInactiveBuffer )
             {
-                U08 *buffPtr;  // buffer source for retrieved data
-                U08 *dstPtr;   // buffer destination for retrieved data
-                U32 i;
+                U32 remNumOfBytes = len - sizeOfFirstConsumption;
+                U08 *remPtr = data + sizeOfFirstConsumption;
 
-                // get source pointer to start of comm buffer
-                buffPtr = &commBuffers[buffer][inactiveBuffer][0];
-                // get destination pointer to start of given data array
-                dstPtr = data;
-                // copy source data to destination buffer
-                for ( i = 0; i < bytesRetrieved; i++ )
-                {
-                    *dstPtr++ = *buffPtr++;
-                }
-                // reset inactive buffer after data retrieved from it
-                commBufferByteCount[buffer][inactiveBuffer] = 0;
-                // set result to # of bytes received
-                result = bytesRetrieved;
+                getDataFromInactiveBuffer( buffer, remPtr, remNumOfBytes );
+                // will return # of bytes consumed
+                result += remNumOfBytes;
             }
-            else // not enough space in caller's buffer
+        }
+        else // invalid peek size given
+        {
+            // TODO - s/w fault
+        }
+    }
+    else // invalid buffer given
+    {
+        // TODO - s/w fault
+    }
+
+    return result;
+}
+
+/*************************************************************************
+ * @brief peekFromCommBuffer
+ * The peekFromCommBuffer function fills a given byte array with a given \n
+ * number of bytes from a given buffer.  This function does NOT consume \n
+ * the bytes - it only peeks at them. A call to numberOfBytesInCommBuffer() \n
+ * should be made before calling this function to determine how many bytes \n
+ * are currently in the buffer.  Do not call this function with a "len" \n
+ * longer than what is currently in the buffer.
+ * @details
+ * Inputs : commBuffers[], commBufferByteCount[], activeDoubleBuffers[]
+ * Outputs : given array populated with requested # of bytes from the buffer.
+ * @param buffer : which comm buffer to retrieve data from
+ * @param data : pointer to byte array to stuff data into
+ * @param len : # of bytes to retrieve into given data array.
+ * @return the number of bytes retrieved.
+ *************************************************************************/
+U32 peekFromCommBuffer( COMM_BUFFER_T buffer, U08 *data, U32 len )
+{
+    U32  numOfBytesPeeked = 0;
+
+    // verify given buffer
+    if ( buffer < NUM_OF_COMM_BUFFERS )
+    {
+        // verify size of peek
+        if ( ( len <= ( COMM_BUFFER_LENGTH * DOUBLE_BUFFERS ) ) && ( len <= numberOfBytesInCommBuffer( buffer ) ) )
+        {
+            U32 activeBuffer = activeDoubleBuffers[buffer];
+            U32 inactiveBuffer = ( activeBuffer == 0 ? 1 : 0 );
+            U32 bytesInInactiveBuffer = commBufferByteCount[buffer][inactiveBuffer];
+
+            if ( len <= bytesInInactiveBuffer )
             {
-                // TODO - s/w fault?
+                memcpy( data, &commBuffers[buffer][inactiveBuffer][0], len );
+                numOfBytesPeeked = len;
             }
+            else // will need to get the rest from active buffer
+            {
+                U32 remNumOfBytes = len - bytesInInactiveBuffer;
+                U08 *remPtr = data + bytesInInactiveBuffer;
+
+                memcpy( data, &commBuffers[buffer][inactiveBuffer][0], bytesInInactiveBuffer );
+                memcpy( remPtr, &commBuffers[buffer][activeBuffer][0], remNumOfBytes );
+                numOfBytesPeeked = bytesInInactiveBuffer + remNumOfBytes;
+            }
         }
-        else // buffer contains insufficient data to satisfy the request
+        else // invalid peek size given
         {
-            // result already set to zero
+            // TODO - s/w fault
         }
     }
     else // invalid buffer given
     {
         // TODO - s/w fault
     }
 
-    return result;
+    return numOfBytesPeeked;
 }
 
+
 /*************************************************************************
- * @brief getNumberOfBytesInCommBuffer
- * The getNumberOfBytesInCommBuffer function determines how many bytes \n
+ * @brief numberOfBytesInCommBuffer
+ * The numberOfBytesInCommBuffer function determines how many bytes \n
  * are currently contained in a given comm buffer.  Both double buffers \n
  * are considered for this.
  * @details
@@ -209,7 +257,7 @@
  * @param buffer : which comm buffer to get byte count for
  * @return the number of bytes in the given comm buffer.
  *************************************************************************/
-U32 getNumberOfBytesInCommBuffer( COMM_BUFFER_T buffer )
+U32 numberOfBytesInCommBuffer( COMM_BUFFER_T buffer )
 {
     U32 result = 0;
 
@@ -251,44 +299,59 @@
 }
 
 /*************************************************************************
- * @brief getRemainingByteCapacity
- * The getRemainingByteCapacity function determines the remaining capacity \n
- * of the given buffer.
+ * @brief getDataFromInactiveBuffer
+ * The getDataFromInactiveBuffer function retrieves a given number of bytes \n
+ * from the inactive buffer of a given buffer.  This function should only be \n
+ * called by getFromCommBuffer().  Params will be pre-validated.
  * @details
- * Inputs : commBufferByteCount[], activeDoubleBuffers[]
- * Outputs : none
- * @param buffer : which comm buffer to check the capacity of
- * @return the number of bytes of capacity remaining in the buffer.
+ * Inputs : commBuffers[], activeDoubleBuffers[], commBufferByteCount[]
+ * Outputs : commBuffers[], activeDoubleBuffers[], commBufferByteCount[]
+ * @param buffer : which comm buffer get data from
+ * @param data : pointer to byte array to populate with data
+ * @param len : # of bytes to get from comm buffer
+ * @return none
  *************************************************************************/
-static U32 getRemainingByteCapacity( COMM_BUFFER_T buffer )
+static void getDataFromInactiveBuffer( COMM_BUFFER_T buffer, U08 *data, U32 len )
 {
-    U32 result;
     U32 activeBuffer = activeDoubleBuffers[buffer];
+    U32 inactiveBuffer = ( activeBuffer == 0 ? 1 : 0 );
+    U32 bytesInInactiveBuffer = commBufferByteCount[buffer][inactiveBuffer];
 
-    result = COMM_BUFFER_LENGTH - commBufferByteCount[buffer][activeBuffer];
+    // get the requested data from inactive buffer
+    memcpy( data, &commBuffers[buffer][inactiveBuffer][0], len );
 
-    return result;
+    if ( len < bytesInInactiveBuffer )
+    {
+        U08 *endPtr = (&commBuffers[buffer][inactiveBuffer][0] + len);
+
+        // move un-consumed data in inactive buffer to start of inactive buffer
+        memcpy( &commBuffers[buffer][inactiveBuffer][0], endPtr, (bytesInInactiveBuffer - len) );
+        // reduce byte count for inactive buffer by # of bytes consumed
+        commBufferByteCount[buffer][inactiveBuffer] -= len;
+    }
+    else
+    {
+        // inactive buffer has been emptied so switch double buffers
+        switchDoubleBuffer( buffer );  // switch will zero count off inactive buffer
+    }
 }
 
 /*************************************************************************
- * @brief isCommBufferEmpty
- * The isCommBufferEmpty function determines whether a given comm buffer \n
- * is empty.
+ * @brief getRemainingByteCapacity
+ * The getRemainingByteCapacity function determines the remaining capacity \n
+ * of the given buffer.
  * @details
  * Inputs : commBufferByteCount[], activeDoubleBuffers[]
  * Outputs : none
- * @param buffer : which comm buffer to check for empty
- * @return TRUE if the given comm buffer is empty, FALSE if not
+ * @param buffer : which comm buffer to check the capacity of
+ * @return the number of bytes of capacity remaining in the buffer.
  *************************************************************************/
-static BOOL isCommBufferEmpty( COMM_BUFFER_T buffer )
+static U32 getRemainingByteCapacity( COMM_BUFFER_T buffer )
 {
-    BOOL result = FALSE;
+    U32 result;
     U32 activeBuffer = activeDoubleBuffers[buffer];
 
-    if ( commBufferByteCount[buffer][activeBuffer] == 0 )
-    {
-        result = TRUE;
-    }
+    result = COMM_BUFFER_LENGTH - commBufferByteCount[buffer][activeBuffer];
 
     return result;
 }
Index: App/Services/CommBuffers.h
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/CommBuffers.h	(.../CommBuffers.h)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/CommBuffers.h	(.../CommBuffers.h)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -23,7 +23,8 @@
 
 typedef enum Comm_Buffers
 {
-    COMM_BUFFER_OUT_CAN_HD_ALARM = 0,
+    COMM_BUFFER_NOT_USED_1 = 0,         // CAN message boxes start at 1
+    COMM_BUFFER_OUT_CAN_HD_ALARM,
     COMM_BUFFER_IN_CAN_DG_ALARM,
     COMM_BUFFER_IN_CAN_UI_ALARM,
     COMM_BUFFER_OUT_CAN_HD_2_DG,
@@ -43,8 +44,9 @@
 // ********** public function prototypes **********
 
 void initCommBuffers( void );
-BOOL addToCommBuffer( COMM_BUFFER_T buffer, U08* data, U32 len );
-U32 getFromCommBuffer( COMM_BUFFER_T buffer, U08* data, U32 len );
-U32 getNumberOfBytesInCommBuffer( COMM_BUFFER_T buffer );
+BOOL addToCommBuffer( COMM_BUFFER_T buffer, U08 *data, U32 len );
+U32 getFromCommBuffer( COMM_BUFFER_T buffer, U08 *data, U32 len );
+U32 peekFromCommBuffer( COMM_BUFFER_T buffer, U08 *data, U32 len );
+U32 numberOfBytesInCommBuffer( COMM_BUFFER_T buffer );
 
 #endif
Index: App/Services/MsgQueues.c
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/MsgQueues.c	(.../MsgQueues.c)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/MsgQueues.c	(.../MsgQueues.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -19,7 +19,7 @@
 
 // ********** private definitions **********
 
-#define MAX_MSG_QUEUE_SIZE          25      // bytes
+#define MAX_MSG_QUEUE_SIZE          100      // messages
 
 // ********** private data **********
 
Index: App/Services/MsgQueues.h
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/MsgQueues.h	(.../MsgQueues.h)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/MsgQueues.h	(.../MsgQueues.h)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -21,16 +21,11 @@
 
 // ********** public definitions **********
 
-#define MAX_MSG_CARGO_SIZE          255     // bytes
+#define MAX_MSG_CARGO_SIZE          100     // bytes
 
 typedef enum Msg_Queues
 {
-    MSG_Q_IN_CAN_DG_ALARM = 0,
-    MSG_Q_IN_CAN_UI_ALARM,
-    MSG_Q_IN_CAN_DG_2_HD,
-    MSG_Q_IN_CAN_DG_BROADCAST,
-    MSG_Q_IN_CAN_UI_2_HD,
-    MSG_Q_IN_CAN_UI_BROADCAST,
+    MSG_Q_IN_CAN = 0,
     MSG_Q_IN_DBG,
     NUM_OF_MSG_QUEUES
 } MSG_QUEUE_T;
Index: App/Services/SystemComm.c
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/SystemComm.c	(.../SystemComm.c)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/SystemComm.c	(.../SystemComm.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -20,7 +20,6 @@
 
 #include "Common.h"
 #include "Buttons.h"
-#include "CommBuffers.h"
 #include "MsgQueues.h"
 #include "SystemComm.h"
 
@@ -43,13 +42,42 @@
     NUM_OF_MSG_IDS
 } MSG_ID_T;
 
+#define NUM_OF_CAN_OUT_BUFFERS          4       // # of CAN buffers for transmit
+#define NUM_OF_CAN_IN_BUFFERS           6       // # of CAN buffers for receiving
+
 // ********** private data **********
 
+const COMM_BUFFER_T CAN_OUT_BUFFERS[NUM_OF_CAN_OUT_BUFFERS] =
+{
+    COMM_BUFFER_OUT_CAN_HD_ALARM,
+    COMM_BUFFER_OUT_CAN_HD_2_DG,
+    COMM_BUFFER_OUT_CAN_HD_2_UI,
+    COMM_BUFFER_OUT_CAN_HD_BROADCAST
+};
 
+const COMM_BUFFER_T CAN_IN_BUFFERS[NUM_OF_CAN_IN_BUFFERS] =
+{
+    COMM_BUFFER_IN_CAN_DG_ALARM,
+    COMM_BUFFER_IN_CAN_UI_ALARM,
+    COMM_BUFFER_IN_CAN_DG_2_HD,
+    COMM_BUFFER_IN_CAN_DG_BROADCAST,
+    COMM_BUFFER_IN_CAN_UI_2_HD,
+    COMM_BUFFER_IN_CAN_UI_BROADCAST
+};
+
 // ********** private function prototypes **********
 
+static COMM_BUFFER_T findNextHighestPriorityCANPacketToTransmit( void );
+static void transmitNextCANPacket( void );
+static void transmitPendingUARTData( void );
 static U32 serializeMessage( MESSAGE_T msg, U08 *data );
 
+static void processIncomingData( void );
+static U32 parseMessageFromBuffer( U08 *data, U32 len );
+static void consumeBufferDataBeforeSync( COMM_BUFFER_T buffer );
+static void processReceivedMessages( void );
+static void processReceivedMessage( MESSAGE_T *message );
+
 /*************************************************************************
  * @brief initSystemComm
  * The initSystemComm function initializes the SystemComm module.
@@ -61,7 +89,7 @@
  *************************************************************************/
 void initSystemComm( void )
 {
-
+    // currently nothing to initialize
 }
 
 /*************************************************************************
@@ -75,74 +103,134 @@
  *************************************************************************/
 void execSystemCommRx( void )
 {
-    // TODO - this is ugly preliminary test code - nowhere near ready for code review
-    BOOL isThereMsgRcvd;
-    U08  data[sizeof(MESSAGE_WRAPPER_T)];
-    MESSAGE_WRAPPER_T msg;
+    // parse messages from comm buffers and queue them
+    processIncomingData();
 
-    // queue any received CAN messages
-    if ( FALSE != canIsRxMessageArrived( canREG1, canMESSAGE_BOX2 ) )
+    // process received messages in the queue
+    processReceivedMessages();
+}
+
+/*************************************************************************
+ * @brief execSystemCommTx
+ * The execSystemCommTx function manages data to be transmitted to other \n
+ * sub-systems.
+ * @details
+ * Inputs : none
+ * Outputs : none
+ * @param none
+ * @return none
+ *************************************************************************/
+void execSystemCommTx( void )
+{
+    // TODO - check to see if CAN transmitter is idle first
+    if ( 1 )  // for now, assume it's idle
     {
-        MESSAGE_WRAPPER_T rcvMsg;
-        U08 *dataPtr = data;
+        transmitNextCANPacket();
+    }
 
-        canGetData( canREG1, canMESSAGE_BOX2, data );
-        blankMessageInWrapper( &rcvMsg );
-        memcpy( &(rcvMsg.msg.hdr), dataPtr, sizeof(MESSAGE_HEADER_T) );
-        dataPtr += sizeof(MESSAGE_HEADER_T);
-        memcpy( &(rcvMsg.msg.cargo), dataPtr, rcvMsg.msg.hdr.cargoLen );
-        dataPtr += rcvMsg.msg.hdr.cargoLen;
-        rcvMsg.crc = *dataPtr;
-        addToMsgQueue( MSG_Q_IN_CAN_UI_2_HD, &rcvMsg );
+    // TODO - check to see if UART transmitter is idle first
+    if ( 1 )  // for now, assume it's idle
+    {
+        transmitPendingUARTData();
     }
+}
 
-    // see if any messages received
-    isThereMsgRcvd = getFromMsgQueue( MSG_Q_IN_CAN_UI_2_HD, &msg );
-    if ( TRUE == isThereMsgRcvd )
+
+/*************************************************************************
+********************** TRANSMIT SUPPORT FUNCTIONS ************************
+*************************************************************************/
+
+
+/*************************************************************************
+ * @brief handleCANXmitCompleteInt
+ * The handleCANXmitCompleteInt function handles a CAN Tx complete interrupt. \n
+ * A search for the next highest priority pack to transmit is made and a \n
+ * new packet transmit is initiated on the appropriate CAN message box if \n
+ * a CAN packet is found.
+ * @details
+ * Inputs : Comm buffers
+ * Outputs : new CAN packet transmission is initiated
+ * @param none
+ * @return none
+ *************************************************************************/
+void handleCANXmitCompleteInt( void )
+{
+    transmitNextCANPacket();
+}
+
+/*************************************************************************
+ * @brief findNextHighestPriorityCANPacketToTransmit
+ * The findNextHighestPriorityCANPacketToTransmit function gets the next \n
+ * 8 byte packet and initiates a CAN transmit on the appropriate CAN channel. \n
+ * @details
+ * Inputs : Output CAN Comm Buffer(s)
+ * Outputs : none
+ * @param msg : none
+ * @return buffer with highest priority CAN packet to transmit, \n
+ * COMM_BUFFER_NOT_USED_1 if not CAN packets pending transmit found
+ *************************************************************************/
+static COMM_BUFFER_T findNextHighestPriorityCANPacketToTransmit( void )
+{
+    COMM_BUFFER_T result = COMM_BUFFER_NOT_USED_1;
+    U32 i;
+
+    // search for next priority CAN packet to transmit
+    for ( i = 0; i < NUM_OF_CAN_OUT_BUFFERS; i++ )
     {
-        switch ( msg.msg.hdr.msgID )
+        if ( numberOfBytesInCommBuffer( CAN_OUT_BUFFERS[i] ) >= CAN_MESSAGE_CARGO_SIZE )
         {
-            case MSG_ID_OFF_BUTTON_PRESS:
-                userConfirmOffButton( msg.msg.cargo[0] );
-// ***************************** TEST CODE ******************************
-// TODO - remove later
-#if 1
-                setUserLED( TRUE );
-#endif
-// ************************** END TEST CODE ******************************
-                break;
-
-            default:
-                break;
+            result = CAN_OUT_BUFFERS[i];
+            break; // found highest priority packet to transmit - we're done
         }
     }
+
+    return result;
 }
 
 /*************************************************************************
- * @brief execSystemCommTx
- * The execSystemCommTx function manages data to be transmitted to other \n
- * sub-systems.
+ * @brief transmitNextCANPacket
+ * The transmitNextCANPacket function gets the next 8 byte packet and initiates \n
+ * a CAN transmit on the appropriate CAN channel.
  * @details
- * Inputs : none
- * Outputs : none
- * @param none
+ * Inputs : Output CAN Comm Buffers
+ * Outputs : CAN packet transmit initiated.
+ * @param msg : none
  * @return none
  *************************************************************************/
-void execSystemCommTx( void )
+static void transmitNextCANPacket( void )
 {
-    // TODO - this is ugly preliminary test code - nowhere near ready for code review
-    U08  data[sizeof(MESSAGE_WRAPPER_T)];
-    U32 dataSize;
+    COMM_BUFFER_T buffer = findNextHighestPriorityCANPacketToTransmit();
 
-    // actually transmit any pending messages
-    dataSize = getFromCommBuffer( COMM_BUFFER_OUT_CAN_HD_2_UI, data, CAN_MESSAGE_CARGO_SIZE );
-    if ( dataSize > 0 )
+    // if a buffer is found with a packet to transmit, get packet from buffer and transmit it
+    if ( buffer != COMM_BUFFER_NOT_USED_1 )
     {
-        canTransmit( canREG1, canMESSAGE_BOX1, data );
+        U08 data[CAN_MESSAGE_CARGO_SIZE];
+        U32 dataSize = getFromCommBuffer( buffer, data, CAN_MESSAGE_CARGO_SIZE );
+        CAN_MESSAGE_BOX_T mBox = buffer;  // CAN message boxes and comm buffers are aligned
+
+        if ( dataSize == CAN_MESSAGE_CARGO_SIZE )
+        {
+            canTransmit( canREG1, mBox, data );
+        }
     }
 }
 
 /*************************************************************************
+ * @brief transmitPendingUARTData
+ * The transmitPendingUARTData function sets up and initiates a DMA transmit \n
+ * of any data currently pending transmit via UART.
+ * @details
+ * Inputs : Output UART Comm Buffer(s)
+ * Outputs : UART DMA transmit initiated.
+ * @param msg : none
+ * @return none
+ *************************************************************************/
+static void transmitPendingUARTData( void )
+{
+    // TODO - implement
+}
+
+/*************************************************************************
  * @brief serializeMessage
  * The serializeMessage function serializes a given message into a given \n
  * array of bytes.  A sync byte is inserted at the beginning of the message \n
@@ -189,11 +277,227 @@
 
 
 /*************************************************************************
-*************** SUITE OFF SEND MESSAGE FUNCTIONS BELOW *******************
+********************** RECEIVE SUPPORT FUNCTIONS *************************
 *************************************************************************/
 
 
 /*************************************************************************
+ * @brief handleCANPacketReceivedInt
+ * The handleCANPacketReceivedInt function handles a CAN Rx interrupt.  \n
+ * A new CAN packet is added to the appropriate comm buffer based on the \n
+ * message box that it came in on.
+ * @details
+ * Inputs : none
+ * Outputs : new CAN packet added to associated comm buffer
+ * @param srcCANBox : CAN message box that the packet arrived in
+ * @return none
+ *************************************************************************/
+void handleCANPacketReceivedInt( CAN_MESSAGE_BOX_T srcCANBox )
+{
+    U08 data[CAN_MESSAGE_CARGO_SIZE];
+
+    // TODO - get received packets from any/all CAN message boxes that have a new packet
+    if ( FALSE != canIsRxMessageArrived( canREG1, srcCANBox ) )  // TODO - is this even necessary? when interrupt is calling, don't we already know it's arrived?
+    {
+        canGetData( canREG1, srcCANBox, data );
+        // TODO - select appropriate comm buffer based on the message box it came in on (s/b same #)
+        addToCommBuffer( srcCANBox, data, CAN_MESSAGE_CARGO_SIZE );
+    }
+}
+
+/*************************************************************************
+ * @brief processIncomingData
+ * The processIncomingData function parses out messages from the Input \n
+ * Comm Buffers and adds them to the Received Message Queue.
+ * @details
+ * Inputs : Input Comm Buffers
+ * Outputs : Parsed message(s) added to Received Message Queue
+ * @param msg : none
+ * @return none
+ *************************************************************************/
+static void processIncomingData( void )
+{
+    U08 data[sizeof(MESSAGE_WRAPPER_T)+1];
+    U32 i;
+
+    // TODO - remove this later - this should be called by CAN receive interrupt handler when implemented
+    handleCANPacketReceivedInt( COMM_BUFFER_IN_CAN_UI_2_HD );
+
+    // queue any received CAN messages
+    for ( i = 0; i < NUM_OF_CAN_IN_BUFFERS; i++ )
+    {
+        U32 numOfBytesInBuffer;
+
+        //consumeBufferDataBeforeSync( CAN_IN_BUFFERS[i] );  // TODO - call when sync implemented
+        numOfBytesInBuffer = numberOfBytesInCommBuffer( CAN_IN_BUFFERS[i] );
+        if ( numOfBytesInBuffer >= CAN_MESSAGE_CARGO_SIZE )
+        {
+            U32 bytesPeeked = peekFromCommBuffer( CAN_IN_BUFFERS[i], data, MIN(numOfBytesInBuffer,(sizeof(MESSAGE_WRAPPER_T)+1)) );
+            U32 msgSize = parseMessageFromBuffer( data, bytesPeeked );
+
+            if ( msgSize > 0 )
+            {
+                msgSize = getFromCommBuffer( CAN_IN_BUFFERS[i], data, msgSize );
+                if ( msgSize > 0 )
+                {
+                    MESSAGE_WRAPPER_T rcvMsg;
+                    U08 *dataPtr = data;
+
+                    blankMessageInWrapper( &rcvMsg );
+                    memcpy( &(rcvMsg.msg.hdr), dataPtr, sizeof(MESSAGE_HEADER_T) );
+                    dataPtr += sizeof(MESSAGE_HEADER_T);
+                    memcpy( &(rcvMsg.msg.cargo), dataPtr, rcvMsg.msg.hdr.cargoLen );
+                    dataPtr += rcvMsg.msg.hdr.cargoLen;
+                    rcvMsg.crc = *dataPtr;
+                    addToMsgQueue( MSG_Q_IN_CAN, &rcvMsg );
+                }
+            }
+
+
+//            MESSAGE_WRAPPER_T rcvMsg;
+//            U08 *dataPtr = data;
+//
+//            getFromCommBuffer( CAN_IN_BUFFERS[i], data, CAN_MESSAGE_CARGO_SIZE );
+//            blankMessageInWrapper( &rcvMsg );
+//            memcpy( &(rcvMsg.msg.hdr), dataPtr, sizeof(MESSAGE_HEADER_T) );
+//            dataPtr += sizeof(MESSAGE_HEADER_T);
+//            memcpy( &(rcvMsg.msg.cargo), dataPtr, rcvMsg.msg.hdr.cargoLen );
+//            dataPtr += rcvMsg.msg.hdr.cargoLen;
+//            rcvMsg.crc = *dataPtr;
+//            addToMsgQueue( MSG_Q_IN_CAN, &rcvMsg );
+        }
+    }
+}
+
+/*************************************************************************
+ * @brief consumeBufferDataBeforeSync
+ * The consumeBufferDataBeforeSync function removes any bytes in a given \n
+ * buffer that lie before a sync byte.
+ * @details
+ * Inputs : none
+ * Outputs : none
+ * @param msg : buffer : the comm buffer to process
+ * @return none
+ *************************************************************************/
+static void consumeBufferDataBeforeSync( COMM_BUFFER_T buffer )
+{
+    // TODO - implement
+}
+
+/*************************************************************************
+ * @brief parseMessageFromBuffer
+ * The parseMessageFromBuffer function looks for a complete message in a \n
+ * given comm buffer.  If found, the given buffer is populated with the \n
+ * message and its size is returned.
+ * @details
+ * Inputs : Comm Buffer
+ * Outputs : none
+ * @param msg : data : pointer to byte array to populate with a message if found
+ * @return size of message, zero if no complete message found.
+ *************************************************************************/
+static U32 parseMessageFromBuffer( U08 *data, U32 len )
+{
+    U32 i;
+    U32 cargoSize;
+    U32 msgSize;
+    U32 result = 0;
+
+    for ( i = 0; i < len; i++ )
+    {
+        // find sync byte
+        //if ( MESSAGE_SYNC_BYTE == data[i] )
+        if (1)  // TODO - find sync byte when implemented
+        {
+            U32 pos = i; // + 1;  // TODO - add one when sync byte implemented
+            U32 remSize = len - pos;
+            U32 minSize = sizeof(MESSAGE_HEADER_T) + sizeof(U08);
+
+            // if a minimum sized msg would fit in remaining
+            if ( remSize >= minSize )
+            {
+                cargoSize = data[pos+sizeof(U16)];
+                msgSize = minSize + cargoSize;
+                if ( msgSize <= remSize )
+                {
+                    result = msgSize;
+                }
+            }
+
+            break;
+        }
+    }
+
+    return result;
+}
+
+/*************************************************************************
+ * @brief processReceivedMessages
+ * The processReceivedMessages function processes any messages in the \n
+ * received message queues.
+ * @details
+ * Inputs : Received Message Queues
+ * Outputs : Message(s) processed.
+ * @param msg : none
+ * @return none
+ *************************************************************************/
+static void processReceivedMessages( void )
+{
+    BOOL isThereMsgRcvd;
+    MESSAGE_WRAPPER_T message;
+
+    // see if any messages received
+    isThereMsgRcvd = getFromMsgQueue( MSG_Q_IN_CAN, &message );
+    if ( TRUE == isThereMsgRcvd )
+    {
+        // TODO - check CRC before processing a message
+        if ( 1 )
+        {
+            processReceivedMessage( &message.msg );
+        }
+        else // CRC failed
+        {
+            // TODO - probably wouldn't want to fault on this.  ignore?
+        }
+    }
+
+    // TODO - process UART (script) messages too
+}
+
+/*************************************************************************
+ * @brief processReceivedMessage
+ * The processReceivedMessage function processes a given message.
+ * @details
+ * Inputs : none
+ * Outputs : message processed
+ * @param msg :
+ * @return none
+ *************************************************************************/
+static void processReceivedMessage( MESSAGE_T *message )
+{
+    switch ( message->hdr.msgID )
+    {
+        case MSG_ID_OFF_BUTTON_PRESS:
+            userConfirmOffButton( message->cargo[0] );
+// ***************************** TEST CODE ******************************
+// TODO - remove later
+#if 1
+            setUserLED( TRUE );
+#endif
+// ************************** END TEST CODE ******************************
+            break;
+
+        default:
+            // TODO - unrecognized message ID received - ignore
+            break;
+    }
+}
+
+
+/*************************************************************************
+**************** SUITE OF SEND MESSAGE FUNCTIONS BELOW *******************
+*************************************************************************/
+
+/*************************************************************************
  * @brief sendOffButtonMsgToUI
  * The sendOffButtonMsgToUI function constructs an off button msg to the UI \n
  * and queues the msg for transmit on the appropriate CAN channel.
Index: App/Services/SystemComm.h
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/SystemComm.h	(.../SystemComm.h)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/SystemComm.h	(.../SystemComm.h)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -18,14 +18,19 @@
 #define __SYSTEM_COMM_H__
 
 #include "Common.h"
+#include "CommBuffers.h"
 
 // ********** public definitions **********
 
+typedef COMM_BUFFER_T   CAN_MESSAGE_BOX_T;       // the first 10 comm buffers align with the 10 active CAN message boxes
+
 // ********** public function prototypes **********
 
 void initSystemComm( void );
 void execSystemCommRx( void );
 void execSystemCommTx( void );
+void handleCANPacketReceivedInt( CAN_MESSAGE_BOX_T srcCANBox );
+void handleCANXmitCompleteInt( void );
 
 BOOL sendOffButtonMsgToUI( void );
 
Index: App/Services/WatchdogMgmt.c
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- App/Services/WatchdogMgmt.c	(.../WatchdogMgmt.c)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ App/Services/WatchdogMgmt.c	(.../WatchdogMgmt.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -246,7 +246,7 @@
 static void petWatchdog( void )
 {
 // ***************************** TEST CODE ******************************
-// TODO - remove later
+// TODO - remove disabling of watchdog pet later
 #if 0     // TODO - this is temporary test code - restore watchdog pet later
     // pulse the watchdog signal
     toggleCPLDWatchdog();
Index: HD.dil
===================================================================
diff -u -rc91e9da338d92432930d3589a4055ebbb404c6cb -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- HD.dil	(.../HD.dil)	(revision c91e9da338d92432930d3589a4055ebbb404c6cb)
+++ HD.dil	(.../HD.dil)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -1,4 +1,4 @@
-# RM46L852PGE 10/09/19 13:45:05
+# RM46L852PGE 10/10/19 13:52:09
 # 
 ARCH=RM46L852PGE
 # 
@@ -3417,7 +3417,7 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_14_EOB.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_14_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_13_INT_ENA_REF.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_AUTO_BUS_ON.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_AUTO_BUS_ON.VALUE=0x00000200
 DRIVER.CAN.VAR.CAN_2_MESSAGE_63_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_55_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_47_INT_ENA.VALUE=0x00000000
@@ -3611,7 +3611,7 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_24_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_16_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_5_INT_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_4_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_4_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_3_MESSAGE_9_RTR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_51_ID.VALUE=51
 DRIVER.CAN.VAR.CAN_2_MESSAGE_43_ID.VALUE=43
@@ -3758,7 +3758,7 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_23_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_15_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_RAM_PARITY_ENA.VALUE=0x00000005
-DRIVER.CAN.VAR.CAN_1_MESSAGE_10_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_10_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_1_MESSAGE_1_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_5_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_PORT_TX_PDR.VALUE=0
@@ -3852,7 +3852,7 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_14_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_9_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_TQ.VALUE=181.818
-DRIVER.CAN.VAR.CAN_1_MESSAGE_7_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_7_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_1_BRPE.VALUE=0
 DRIVER.CAN.VAR.CAN_3_MESSAGE_7_ID.VALUE=7
 DRIVER.CAN.VAR.CAN_2_MESSAGE_4_RTR.VALUE=0x00000000
@@ -4002,7 +4002,7 @@
 DRIVER.CAN.VAR.CAN_3_ENABLE.VALUE=1
 DRIVER.CAN.VAR.CAN_2_MESSAGE_59_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_10_INT_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_3_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_3_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_1_PIN_MODE.VALUE=1
 DRIVER.CAN.VAR.CAN_2_MESSAGE_58_ID.VALUE=58
 DRIVER.CAN.VAR.CAN_2_SAMPLE_POINT_REFERENCE.VALUE=75
@@ -4018,8 +4018,8 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_34_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_26_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_18_INT_ENA_REF.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_3_EOB.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_3_DIR.VALUE=0x20000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_3_EOB.VALUE=0x00000080
+DRIVER.CAN.VAR.CAN_1_MESSAGE_3_DIR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_61_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_53_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_45_INT_ENA.VALUE=0x00000000
@@ -4138,7 +4138,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_12_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_21_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_13_MASK.VALUE=0x000007FF
-DRIVER.CAN.VAR.CAN_1_MESSAGE_4_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_4_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_31_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_23_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_15_INT_LEVEL.VALUE=0x00000000
@@ -4157,7 +4157,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_8_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_20_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_12_INT_ENA_REF.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_4_EOB.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_4_EOB.VALUE=0x00000080
 DRIVER.CAN.VAR.CAN_1_MESSAGE_4_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_30_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_3_MESSAGE_22_MASK.VALUE=0x000007FF
@@ -4249,9 +4249,9 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_13_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_11_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_11_BOOL_ENA.VALUE=0
-DRIVER.CAN.VAR.CAN_1_MESSAGE_5_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_5_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_3_INT_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_3_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_3_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_3_MESSAGE_58_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_PORT_RX_PSL.VALUE=1
 DRIVER.CAN.VAR.CAN_1_MESSAGE_62_DLC.VALUE=8
@@ -4266,8 +4266,8 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_12_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_SAMPLE_POINT.VALUE=72.727
 DRIVER.CAN.VAR.CAN_1_PORT_TX_DIR.VALUE=1
-DRIVER.CAN.VAR.CAN_1_MESSAGE_5_EOB.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_5_DIR.VALUE=0x20000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_5_EOB.VALUE=0x00000080
+DRIVER.CAN.VAR.CAN_1_MESSAGE_5_DIR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_2_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_1_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_RAM_PARITY_ENA.VALUE=0x00000005
@@ -4382,7 +4382,7 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_30_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_22_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_14_MASK.VALUE=0x000007FF
-DRIVER.CAN.VAR.CAN_1_MESSAGE_6_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_6_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_1_RTR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_1_ID.VALUE=1
 DRIVER.CAN.VAR.CAN_1_MESSAGE_63_DLC.VALUE=8
@@ -4395,7 +4395,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_22_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_14_EOB.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_14_DIR.VALUE=0x20000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_6_EOB.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_6_EOB.VALUE=0x00000080
 DRIVER.CAN.VAR.CAN_1_MESSAGE_6_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_3_PORT_TX_PULDIS.VALUE=0
 DRIVER.CAN.VAR.CAN_3_MESSAGE_61_BOOL_ENA.VALUE=0
@@ -4441,7 +4441,7 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_26_RTR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_18_RTR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_2_ID.VALUE=2
-DRIVER.CAN.VAR.CAN_1_AUTO_BUS_ON_TR.VALUE=0
+DRIVER.CAN.VAR.CAN_1_AUTO_BUS_ON_TR.VALUE=110
 DRIVER.CAN.VAR.CAN_3_MESSAGE_31_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_3_MESSAGE_23_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_3_MESSAGE_15_DLC.VALUE=8
@@ -4503,7 +4503,7 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_36_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_2_MESSAGE_28_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_2_MESSAGE_1_INT_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_7_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_7_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_51_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_43_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_35_INT_LEVEL.VALUE=0x00000000
@@ -4523,7 +4523,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_23_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_15_EOB.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_15_DIR.VALUE=0x20000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_7_EOB.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_7_EOB.VALUE=0x00000080
 DRIVER.CAN.VAR.CAN_1_MESSAGE_7_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_41_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_33_INT_ENA.VALUE=0x00000000
@@ -4537,7 +4537,7 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_56_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_48_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_9_INT_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_6_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_6_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_2_MESSAGE_21_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_13_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_4_INT_LEVEL.VALUE=0x00000000
@@ -4580,7 +4580,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_24_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_3_MESSAGE_16_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_1_MESSAGE_8_DLC.VALUE=8
-DRIVER.CAN.VAR.CAN_1_NOMINAL_AUTO_BUS_ON_TIME.VALUE=0.000
+DRIVER.CAN.VAR.CAN_1_NOMINAL_AUTO_BUS_ON_TIME.VALUE=1000.000
 DRIVER.CAN.VAR.CAN_2_SHIFT.VALUE=0
 DRIVER.CAN.VAR.CAN_1_MESSAGE_64_EOB.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_64_DIR.VALUE=0x20000000
@@ -4645,7 +4645,7 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_23_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_1_MESSAGE_15_INT_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_15_MASK.VALUE=0x000007FF
-DRIVER.CAN.VAR.CAN_1_MESSAGE_8_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_8_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_21_ID.VALUE=21
 DRIVER.CAN.VAR.CAN_3_MESSAGE_13_ID.VALUE=13
 DRIVER.CAN.VAR.CAN_3_MESSAGE_11_RTR.VALUE=0x00000000
@@ -4668,8 +4668,8 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_55_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_47_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_39_INT_ENA_REF.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_8_EOB.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_8_DIR.VALUE=0x20000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_8_EOB.VALUE=0x00000080
+DRIVER.CAN.VAR.CAN_1_MESSAGE_8_DIR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_40_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_3_MESSAGE_32_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_3_MESSAGE_24_MASK.VALUE=0x000007FF
@@ -4782,7 +4782,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_25_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_17_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_1_BOOL_ENA.VALUE=0
-DRIVER.CAN.VAR.CAN_1_MESSAGE_9_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_9_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_31_ID.VALUE=31
 DRIVER.CAN.VAR.CAN_3_MESSAGE_23_ID.VALUE=23
 DRIVER.CAN.VAR.CAN_3_MESSAGE_20_RTR.VALUE=0x00000000
@@ -4806,8 +4806,8 @@
 DRIVER.CAN.VAR.CAN_1_MESSAGE_33_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_25_INT_ENA_REF.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_17_INT_ENA_REF.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_9_EOB.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_9_DIR.VALUE=0x20000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_9_EOB.VALUE=0x00000080
+DRIVER.CAN.VAR.CAN_1_MESSAGE_9_DIR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_5_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_63_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_2_MESSAGE_55_BOOL_ENA.VALUE=0
@@ -4843,7 +4843,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_25_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_3_MESSAGE_17_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_1_MESSAGE_58_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_9_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_9_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_3_MESSAGE_40_ID.VALUE=40
 DRIVER.CAN.VAR.CAN_3_MESSAGE_32_ID.VALUE=32
 DRIVER.CAN.VAR.CAN_3_MESSAGE_24_ID.VALUE=24
@@ -4975,7 +4975,7 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_55_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_2_MESSAGE_47_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_2_MESSAGE_39_DLC.VALUE=8
-DRIVER.CAN.VAR.CAN_1_AUTO_BUS_ON_TIME.VALUE=0
+DRIVER.CAN.VAR.CAN_1_AUTO_BUS_ON_TIME.VALUE=1000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_6_EOB.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_6_DIR.VALUE=0x20000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_30_INT_ENA_REF.VALUE=0x00000000
@@ -5204,16 +5204,16 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_8_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_57_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_1_MESSAGE_49_BOOL_ENA.VALUE=0
-DRIVER.CAN.VAR.CAN_1_MESSAGE_10_ENA.VALUE=0x00000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_10_ENA.VALUE=0x80000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_10_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_3_RTR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_2_ID.VALUE=2
 DRIVER.CAN.VAR.CAN_2_MESSAGE_57_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_2_MESSAGE_49_DLC.VALUE=8
 DRIVER.CAN.VAR.CAN_3_MESSAGE_8_EOB.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_3_MESSAGE_8_DIR.VALUE=0x20000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_10_EOB.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_10_DIR.VALUE=0x20000000
+DRIVER.CAN.VAR.CAN_1_MESSAGE_10_EOB.VALUE=0x00000080
+DRIVER.CAN.VAR.CAN_1_MESSAGE_10_DIR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_SAMPLE_POINT.VALUE=63.636
 DRIVER.CAN.VAR.CAN_2_MESSAGE_51_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_2_MESSAGE_43_BOOL_ENA.VALUE=0
@@ -5250,7 +5250,7 @@
 DRIVER.CAN.VAR.CAN_2_MESSAGE_57_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_49_ENA.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_1_MESSAGE_7_INT_ENA.VALUE=0x00000000
-DRIVER.CAN.VAR.CAN_1_MESSAGE_5_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_5_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_3_MESSAGE_59_INT_LEVEL.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_60_RTR.VALUE=0x00000000
 DRIVER.CAN.VAR.CAN_2_MESSAGE_52_RTR.VALUE=0x00000000
@@ -5498,7 +5498,7 @@
 DRIVER.CAN.VAR.CAN_3_MESSAGE_24_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_3_MESSAGE_16_BOOL_ENA.VALUE=0
 DRIVER.CAN.VAR.CAN_3_MESSAGE_10_MASK.VALUE=0x000007FF
-DRIVER.CAN.VAR.CAN_1_MESSAGE_8_BOOL_ENA.VALUE=0
+DRIVER.CAN.VAR.CAN_1_MESSAGE_8_BOOL_ENA.VALUE=1
 DRIVER.CAN.VAR.CAN_1_MESSAGE_2_MASK.VALUE=0x000007FF
 DRIVER.CAN.VAR.CAN_3_MESSAGE_59_ID.VALUE=59
 DRIVER.CAN.VAR.CAN_3_MESSAGE_50_RTR.VALUE=0x00000000
Index: include/can.h
===================================================================
diff -u -ree310a2e5262c05bf0dc0eb0d84da0ee50bac7fe -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- include/can.h	(.../can.h)	(revision ee310a2e5262c05bf0dc0eb0d84da0ee50bac7fe)
+++ include/can.h	(.../can.h)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -630,7 +630,7 @@
 
 
 /* Configuration registers initial value for CAN1*/
-#define CAN1_CTL_CONFIGVALUE      ((uint32)0x00000000U \
+#define CAN1_CTL_CONFIGVALUE      ((uint32)0x00000200U \
                                  | (uint32)0x00000000U \
                                  | (uint32)((uint32)0x00000005U  << 10U) | 0x00020002U)
 #define CAN1_ES_CONFIGVALUE         0x00000007U 
@@ -639,7 +639,7 @@
                                  | (uint32)((uint32)((2U + 4U) - 1U) << 8U) \
                                  | (uint32)((uint32)(4U - 1U) << 6U) | (uint32)39U)
 #define CAN1_TEST_CONFIGVALUE       0x00000080U 
-#define CAN1_ABOTR_CONFIGVALUE    ((uint32)(0U))
+#define CAN1_ABOTR_CONFIGVALUE    ((uint32)(110U))
 #define CAN1_INTMUX0_CONFIGVALUE  ((uint32)0x00000000U \
                                  | (uint32)0x00000000U \
                                  | (uint32)0x00000000U \
Index: source/can.c
===================================================================
diff -u -rd298a85322169dcc173c6197682864c2e9dbcd24 -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- source/can.c	(.../can.c)	(revision d298a85322169dcc173c6197682864c2e9dbcd24)
+++ source/can.c	(.../can.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -104,7 +104,7 @@
     *     - Disable status interrupts
     *     - Enter initialization mode
     */
-    canREG1->CTL = (uint32)0x00000000U 
+    canREG1->CTL = (uint32)0x00000200U 
                  | (uint32)0x00000000U 
                  | (uint32)((uint32)0x00000005U  << 10U)
                  | (uint32)0x00020043U;
@@ -180,7 +180,7 @@
                          | (uint32)0x00000000U;
 
     /** - Setup auto bus on timer period */
-    canREG1->ABOTR = (uint32)0U;
+    canREG1->ABOTR = (uint32)110U;
 
     /** - Initialize message 1 
     *     - Wait until IF1 is ready for use 
@@ -221,6 +221,158 @@
     canREG1->IF2CMD  = (uint8) 0xF8U;
     canREG1->IF2NO   = 2U;
 
+    /** - Initialize message 3 
+    *     - Wait until IF1 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF1 control byte
+    *     - Set IF1 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF1STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF1MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)((uint32)((uint32)3U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF1CMD  = (uint8) 0xF8U;
+    canREG1->IF1NO   = 3U;
+
+    /** - Initialize message 4 
+    *     - Wait until IF2 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF2 control byte
+    *     - Set IF2 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF2STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF2MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x20000000U | (uint32)((uint32)((uint32)4U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF2CMD  = (uint8) 0xF8U;
+    canREG1->IF2NO   = 4U;
+
+    /** - Initialize message 5 
+    *     - Wait until IF1 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF1 control byte
+    *     - Set IF1 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF1STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF1MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)((uint32)((uint32)5U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF1CMD  = (uint8) 0xF8U;
+    canREG1->IF1NO   = 5U;
+
+    /** - Initialize message 6 
+    *     - Wait until IF2 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF2 control byte
+    *     - Set IF2 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF2STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF2MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x20000000U | (uint32)((uint32)((uint32)6U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF2CMD  = (uint8) 0xF8U;
+    canREG1->IF2NO   = 6U;
+
+    /** - Initialize message 7 
+    *     - Wait until IF1 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF1 control byte
+    *     - Set IF1 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF1STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF1MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x20000000U | (uint32)((uint32)((uint32)7U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF1CMD  = (uint8) 0xF8U;
+    canREG1->IF1NO   = 7U;
+
+    /** - Initialize message 8 
+    *     - Wait until IF2 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF2 control byte
+    *     - Set IF2 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF2STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF2MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)((uint32)((uint32)8U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF2CMD  = (uint8) 0xF8U;
+    canREG1->IF2NO   = 8U;
+
+    /** - Initialize message 9 
+    *     - Wait until IF1 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF1 control byte
+    *     - Set IF1 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF1STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF1MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)((uint32)((uint32)9U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF1MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF1CMD  = (uint8) 0xF8U;
+    canREG1->IF1NO   = 9U;
+
+    /** - Initialize message 10 
+    *     - Wait until IF2 is ready for use 
+    *     - Set message mask
+    *     - Set message control word
+    *     - Set message arbitration
+    *     - Set IF2 control byte
+    *     - Set IF2 message number
+    */
+    /*SAFETYMCUSW 28 D MR:NA <APPROVED> "Potentially infinite loop found - Hardware Status check for execution sequence" */
+    while ((canREG1->IF2STAT & 0x80U) ==0x80U)
+    { 
+    } /* Wait */
+
+    canREG1->IF2MSK  = 0xC0000000U | (uint32)((uint32)((uint32)0x000007FFU & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2ARB  = (uint32)0x80000000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)((uint32)((uint32)10U & (uint32)0x000007FFU) << (uint32)18U);
+    canREG1->IF2MCTL = 0x00001000U | (uint32)0x00000000U | (uint32)0x00000000U | (uint32)0x00000080U | (uint32)8U;
+    canREG1->IF2CMD  = (uint8) 0xF8U;
+    canREG1->IF2NO   = 10U;
+
     /** - Setup IF1 for data transmission 
     *     - Wait until IF1 is ready for use 
     *     - Set IF1 control byte
Index: source/sys_main.c
===================================================================
diff -u -ree310a2e5262c05bf0dc0eb0d84da0ee50bac7fe -r833095dbbe2b21a989b05f48bd7ddc390ad964cb
--- source/sys_main.c	(.../sys_main.c)	(revision ee310a2e5262c05bf0dc0eb0d84da0ee50bac7fe)
+++ source/sys_main.c	(.../sys_main.c)	(revision 833095dbbe2b21a989b05f48bd7ddc390ad964cb)
@@ -121,10 +121,10 @@
 
 static void initTasks( void )
 {
-    _enable_IRQ();
     rtiInit();
     rtiEnableNotification( rtiNOTIFICATION_COMPARE0 | rtiNOTIFICATION_COMPARE1 | rtiNOTIFICATION_COMPARE3 );
     rtiStartCounter( rtiCOUNTER_BLOCK0 );
+    _enable_IRQ();
 }
 
 /* USER CODE END */