Index: firmware/App/Services/SystemCommMessages.c
===================================================================
diff -u -r8592c629e9e6e212c1325239a21ceb641f9dc1fe -r90f6438e80dbe0a32472a076a0d1bc54db65d15a
--- firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 8592c629e9e6e212c1325239a21ceb641f9dc1fe)
+++ firmware/App/Services/SystemCommMessages.c	(.../SystemCommMessages.c)	(revision 90f6438e80dbe0a32472a076a0d1bc54db65d15a)
@@ -34,7 +34,7 @@
 typedef struct
 {
     U08 confirmed;                              // 1 = confirmed, 0 = rejected/timed out
-} OFF_BUTTON_MESSAGE_FROM_UI_CARGO_T;
+} OFF_BUTTON_MESSAGE_FROM_UI_PAYLOAD_T;
 
 #pragma pack(pop)
 
@@ -74,16 +74,16 @@
     memcpy( &data[msgSize], &(msg.hdr), sizeof(MESSAGE_HEADER_T) );
     msgSize += sizeof(MESSAGE_HEADER_T);
 
-    // serialize message cargo (only used bytes per cargoLen field)
-    memcpy( &data[msgSize], &(msg.cargo), msg.hdr.cargoLen );
-    msgSize += msg.hdr.cargoLen;
+    // serialize message payload (only used bytes per payloadLen field)
+    memcpy( &data[msgSize], &(msg.payload), msg.hdr.payloadLen );
+    msgSize += msg.hdr.payloadLen;
 
     // TODO - calculate 8-bit CRC
     data[msgSize++] = 0;  // TODO - s/b 8-bit CRC when calc is available
 
-    // pad with zero bytes to get length a multiple of CAN_MESSAGE_CARGO_SIZE (8)
-    sizeMod = msgSize % CAN_MESSAGE_CARGO_SIZE;
-    sizePad = ( sizeMod == 0 ? 0 : CAN_MESSAGE_CARGO_SIZE - sizeMod );
+    // 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;
@@ -111,12 +111,12 @@
     BOOL result;
     MESSAGE_T msg;
     U32 msgSize;
-    U08  data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_CARGO_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
+    U08  data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_PAYLOAD_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
 
     // create a message record
     blankMessage( &msg );
     msg.hdr.msgID = MSG_ID_OFF_BUTTON_PRESS;
-    msg.hdr.cargoLen = 0;
+    msg.hdr.payloadLen = 0;
 
     // serialize the message (w/ sync, CRC, and appropriate CAN padding)
     msgSize = serializeMessage( msg, data );
@@ -139,10 +139,10 @@
  *************************************************************************/
 void handleOffButtonConfirmMsgFromUI( MESSAGE_T *message )
 {
-    OFF_BUTTON_MESSAGE_FROM_UI_CARGO_T cargo;
+    OFF_BUTTON_MESSAGE_FROM_UI_PAYLOAD_T payload;
 
-    memcpy( &cargo, message->cargo, sizeof(OFF_BUTTON_MESSAGE_FROM_UI_CARGO_T) );
-    userConfirmOffButton( cargo.confirmed );
+    memcpy( &payload, message->payload, sizeof(OFF_BUTTON_MESSAGE_FROM_UI_PAYLOAD_T) );
+    userConfirmOffButton( payload.confirmed );
 }
 
 /*************************************************************************
@@ -162,19 +162,19 @@
     BOOL result;
     MESSAGE_T msg;
     U32 msgSize;
-    U08 data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_CARGO_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
-    U08 *cargoPtr = msg.cargo;
+    U08 data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_PAYLOAD_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
+    U08 *payloadPtr = msg.payload;
 
     // create a message record
     blankMessage( &msg );
     msg.hdr.msgID = MSG_ID_ALARM_TRIGGERED;
-    msg.hdr.cargoLen = sizeof(ALARM_ID_T) + sizeof(ALARM_DATA_T) + sizeof(ALARM_DATA_T);
+    msg.hdr.payloadLen = sizeof(ALARM_ID_T) + sizeof(ALARM_DATA_T) + sizeof(ALARM_DATA_T);
 
-    memcpy( cargoPtr, &alarm, sizeof(ALARM_ID_T) );
-    cargoPtr += sizeof(ALARM_ID_T);
-    memcpy( cargoPtr, &almData1, sizeof(ALARM_DATA_T) );
-    cargoPtr += sizeof(ALARM_DATA_T);
-    memcpy( cargoPtr, &almData2, sizeof(ALARM_DATA_T) );
+    memcpy( payloadPtr, &alarm, sizeof(ALARM_ID_T) );
+    payloadPtr += sizeof(ALARM_ID_T);
+    memcpy( payloadPtr, &almData1, sizeof(ALARM_DATA_T) );
+    payloadPtr += sizeof(ALARM_DATA_T);
+    memcpy( payloadPtr, &almData2, sizeof(ALARM_DATA_T) );
 
     // serialize the message (w/ sync, CRC, and appropriate CAN padding)
     msgSize = serializeMessage( msg, data );
@@ -199,15 +199,15 @@
     BOOL result;
     MESSAGE_T msg;
     U32 msgSize;
-    U08 data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_CARGO_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
-    U08 *cargoPtr = msg.cargo;
+    U08 data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_PAYLOAD_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
+    U08 *payloadPtr = msg.payload;
 
     // create a message record
     blankMessage( &msg );
     msg.hdr.msgID = MSG_ID_ALARM_CLEARED;
-    msg.hdr.cargoLen = sizeof(ALARM_ID_T);
+    msg.hdr.payloadLen = sizeof(ALARM_ID_T);
 
-    memcpy( cargoPtr, &alarm, sizeof(ALARM_ID_T) );
+    memcpy( payloadPtr, &alarm, sizeof(ALARM_ID_T) );
 
     // serialize the message (w/ sync, CRC, and appropriate CAN padding)
     msgSize = serializeMessage( msg, data );
@@ -236,21 +236,21 @@
     BOOL result;
     MESSAGE_T msg;
     U32 msgSize;
-    U08 data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_CARGO_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
-    U08 *cargoPtr = msg.cargo;
+    U08 data[sizeof(MESSAGE_WRAPPER_T)+1+CAN_MESSAGE_PAYLOAD_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
+    U08 *payloadPtr = msg.payload;
 
     // create a message record
     blankMessage( &msg );
     msg.hdr.msgID = MSG_ID_BLOOD_FLOW_DATA;
-    msg.hdr.cargoLen = sizeof(U32) + sizeof(F32) + sizeof(F32) + sizeof(F32);
+    msg.hdr.payloadLen = sizeof(U32) + sizeof(F32) + sizeof(F32) + sizeof(F32);
 
-    memcpy( cargoPtr, &flowStPt, sizeof(U32) );
-    cargoPtr += sizeof(U32);
-    memcpy( cargoPtr, &measFlow, sizeof(F32) );
-    cargoPtr += sizeof(F32);
-    memcpy( cargoPtr, &measSpd, sizeof(F32) );
-    cargoPtr += sizeof(F32);
-    memcpy( cargoPtr, &measCurr, sizeof(F32) );
+    memcpy( payloadPtr, &flowStPt, sizeof(U32) );
+    payloadPtr += sizeof(U32);
+    memcpy( payloadPtr, &measFlow, sizeof(F32) );
+    payloadPtr += sizeof(F32);
+    memcpy( payloadPtr, &measSpd, sizeof(F32) );
+    payloadPtr += sizeof(F32);
+    memcpy( payloadPtr, &measCurr, sizeof(F32) );
 
     // serialize the message (w/ sync, CRC, and appropriate CAN padding)
     msgSize = serializeMessage( msg, data );
@@ -283,13 +283,13 @@
     BOOL result;
     MESSAGE_T msg;
     U32 msgSize;
-    U08  data[sizeof(MESSAGE_WRAPPER_T) + 1 + CAN_MESSAGE_CARGO_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
+    U08  data[sizeof(MESSAGE_WRAPPER_T) + 1 + CAN_MESSAGE_PAYLOAD_SIZE];  // must hold full (wrapped) message + sync + any CAN padding
 
     // create a message record
     blankMessage( &msg );
     msg.hdr.msgID = 2;
-    msg.hdr.cargoLen = len;
-    memcpy( msg.cargo, dbgData, len );
+    msg.hdr.payloadLen = len;
+    memcpy( msg.payload, dbgData, len );
 
     // serialize the message (w/ sync, CRC, and appropriate CAN padding)
     msgSize = serializeMessage( msg, data );
@@ -337,8 +337,8 @@
     // create a message record
     blankMessage( &msg );
     msg.hdr.msgID = msgID;
-    msg.hdr.cargoLen = 1;
-    msg.cargo[0] = (U08)ack;
+    msg.hdr.payloadLen = 1;
+    msg.payload[0] = (U08)ack;
 
     // serialize the message (w/ sync, CRC, and appropriate CAN padding)
     msgSize = serializeMessage( msg, data );
@@ -363,7 +363,7 @@
 {
     // verify pass code
     // TODO - placeholder - how do we want to authenticate tester?
-    if ( ( 3 == message->hdr.cargoLen ) && ( 0x31 == message->cargo[0] ) && ( 0x32 == message->cargo[1] ) && ( 0x33 == message->cargo[2] ) )
+    if ( ( 3 == message->hdr.payloadLen ) && ( 0x31 == message->payload[0] ) && ( 0x32 == message->payload[1] ) && ( 0x33 == message->payload[2] ) )
     {
         testerLoggedIn = TRUE;
     }
@@ -388,11 +388,11 @@
 void handleTestHDMessageRequest( MESSAGE_T *message )
 {
     MESSAGE_WRAPPER_T hdMessage;
-    U32 msgLen = (U32)(message->hdr.cargoLen);
+    U32 msgLen = (U32)(message->hdr.payloadLen);
     U08 *msgBytes = (U08*)(&(hdMessage));
     BOOL result;
 
-    memcpy( msgBytes, message->cargo, msgLen );
+    memcpy( msgBytes, message->payload, msgLen );
 
     // add HD message to received message queue
     result = addToMsgQueue( MSG_Q_IN, &hdMessage );