*bugfix: correct register define

df_datalink_ge/src/config/app_config.h

@@ -93,9 +93,6 @@
 #if !defined(DATALINK_ENABLE_AUTOTIMESYNC)
 	#warning To enbale bit error rate test, auto time-sync should be enabled...
 #endif
-#if defined(DATALINK_ENABLE_AUTORECONNECT)
-	#error Do not support auto reconnnect in bit error rate test mode...
-#endif
 #endif
 
 #endif

df_datalink_sp/src/config/app_config.h

@@ -190,9 +190,6 @@ typedef enum
 #if !defined(DATALINK_ENABLE_AUTOTIMESYNC)
 	#warning To enbale bit error rate test, auto time-sync should be enabled...
 #endif
-#if defined(DATALINK_ENABLE_AUTORECONNECT)
-	#error Do not support auto reconnnect in bit error rate test mode...
-#endif
 #endif
 
 #endif //__APP_CONFIG_H_

df_datalink_sp/src/networking/link_layer/link_layer.c

@@ -333,7 +333,6 @@ void L2_FrameStateUpdate(L2_INST *instPtr)
 	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	bool isValid;
 	L2_FRAME_TYPE recvType = L2_GetLastOptFrameType(instPtr);
-	L2_FRAME_TYPE sendType = L2_GetNextFrameType(instPtr);
 	// Update frame state.
 	if (Phy_IsFrameValid(phyRef) == false)
 	{
@@ -347,7 +346,6 @@ void L2_FrameStateUpdate(L2_INST *instPtr)
 	instPtr->log.frameRecv++;
 
 	// Update frame state.
-	// FIXME: add log
 	switch (recvType)
 	{
 	case L2_SCAN_FRAME:
@@ -385,54 +383,6 @@ void L2_FrameStateUpdate(L2_INST *instPtr)
 		L2_DataAvailUpdate(instPtr, false);
 	}
 	}
-
-	// Logging status.
-	// -- send slot status
-	if (instPtr->tor.curr == L2_TOR_RX)
-	{
-		instPtr->rxSlotLog.tuNo = L2_GetCurrentFrameNum(instPtr);
-		instPtr->rxSlotLog.slotNo = L2_GetCurrentSlotNum(instPtr);
-		instPtr->rxSlotLog.frameType = recvType;
-		memset(instPtr->rxSlotLog.payload, 0x00, sizeof(instPtr->rxSlotLog.payload));
-		if (isValid == true)
-		{
-			memcpy(instPtr->rxSlotLog.payload,
-					instPtr->recvPktData,
-					Phy_GetFrameLen(L2_L2frame2L1frame(recvType)));
-			TIME_WORD timeWrod;
-			Phy_GetLastReceivedFrameSyncTimeStamp(phyRef, &timeWrod);
-			instPtr->rxSlotLog.tmStamp = timeWrod.frac_part;
-			instPtr->rxSlotLog.tmStamp += (uint64_t)timeWrod.int_part * TIME_FRAC_MAX;
-
-			// Log time deviation.
-			instPtr->txSlotLog.tmDevi = 0; // TODO:
-			// Log frequency deviation
-			instPtr->rxSlotLog.freqDevi = (uint32_t)Phy_GetFreqEst(phyRef);
-		}
-		else
-		{
-			instPtr->rxSlotLog.tmStamp = 0;
-			instPtr->rxSlotLog.tmDevi = 0;
-			instPtr->rxSlotLog.freqDevi = 0;
-			memset(instPtr->rxSlotLog.payload, 0x00, sizeof(instPtr->rxSlotLog.payload));
-		}
-		SysMonitor_UpdateRecvSlotLog(&(instPtr->rxSlotLog));
-	}
-	// -- send slot status
-	if (instPtr->tor.next == L2_TOR_TX)
-	{
-		instPtr->txSlotLog.tuNo = L2_GetCurrentFrameNum(instPtr);
-		instPtr->txSlotLog.slotNo = L2_GetCurrentSlotNum(instPtr);
-		instPtr->txSlotLog.frameType = sendType;
-		memset(instPtr->rxSlotLog.payload, 0x00, sizeof(instPtr->txSlotLog.payload));
-		memcpy(instPtr->txSlotLog.payload,
-			   instPtr->sendPktData,
-			   Phy_GetFrameLen(L2_L2frame2L1frame(sendType)));
-		instPtr->txSlotLog.tmStamp = 0;
-		instPtr->txSlotLog.tmDevi = 0;
-		instPtr->txSlotLog.freqDevi = 0;
-		SysMonitor_UpdateSendSlotLog(&(instPtr->txSlotLog));
-	}
 }
 
 /*****************************************************************************/
@@ -1276,25 +1226,32 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	// Check and execute scheduled event.
 	L2_EventPoolHandler(instPtr);
 
-	PHY_INST* phyRef = instPtr->config.phyInstPtr;
-	TMC_INST* tmcRef = instPtr->config.tmcInstPtr;
-
-	TIME_WORD timeWord;
-	// Update Protocol log
-	instPtr->prtcLog.tmSys = instPtr->frameNum.last * L2_SLOTS_PER_FRAME + instPtr->slotNum.last;
-	instPtr->prtcLog.phySt = 0; // TODO: Update physical state.
-	TimeCtrl_GetCurrentTime(tmcRef, &timeWord);
-	instPtr->prtcLog.tmLocal = timeWord.frac_part; // us
-	instPtr->prtcLog.tmLocal += (uint64_t)timeWord.int_part * TIME_FRAC_MAX; // us
-	instPtr->prtcLog.beamNo = phyRef->beamNo.last;
-	instPtr->prtcLog.beamNo = phyRef->beamWd.last;
-	instPtr->prtcLog.stage = instPtr->mainState;
-	instPtr->prtcLog.recvCnt = instPtr->log.frameRecv;
-	instPtr->prtcLog.recvCorrect = instPtr->log.frameCorrect;
-	SysMonitor_UpdateProtocolLog(&(instPtr->prtcLog));
-
-
 	// Update link layer state.
 	instPtr->mainState = instPtr->nextState;
+	
+	instPtr->linkLog.tuNum = instPtr->frameNum.curr;
+	instPtr->linkLog.slotNum = (uint8_t)instPtr->slotNum.curr;
+	instPtr->linkLog.nodeType = (instPtr->config.myType == L2_NODE_HEAD) ? 0xAA : 0xCC;
+	instPtr->linkLog.cxnStatus = (instPtr->cxn2Net) ? 0x11 : 0x00;
+	instPtr->linkLog.linkStage = (instPtr->mainState == L2_INIT_STATE) ? 0x00 : 0x11;
+	// TODO: 
+	// instPtr->linkLog.recxnCnt = 
+	// instPtr->linkLog.beamNo = 
+	// instPtr->linkLog.beamAz = 
+	// instPtr->linkLog.beamEl = 
+	instPtr->linkLog.advTxCnt = (uint16_t)instPtr->log.advTxCnt;
+	instPtr->linkLog.advRecvCnt = (uint16_t)instPtr->log.advRecvCnt;
+	instPtr->linkLog.advCorrectCnt = (uint16_t)instPtr->log.advCorrectCnt;
+	instPtr->linkLog.cfmTxCnt = instPtr->log.cfmTxCnt;
+	instPtr->linkLog.cfmRecvCnt = instPtr->log.cfmRecvCnt;
+	instPtr->linkLog.cfmCorrectCnt = instPtr->log.cfmCorrectCnt;
+	instPtr->linkLog.svcTxCnt = instPtr->log.svcTxCnt;
+	instPtr->linkLog.svcRecvCnt = instPtr->log.svcRecvCnt;
+	instPtr->linkLog.svcCorrectCnt = instPtr->log.svcCorrectCnt;
+	instPtr->linkLog.timeDev = instPtr->log.timeDev;
+	instPtr->linkLog.sendId = instPtr->serviceFSM->txLog.dataId;
+	instPtr->linkLog.recvId = instPtr->serviceFSM->rxLog.dataId;
+
+	SysMonitor_UpdateLinklayerLog(&(instPtr->linkLog));
 	return SUCCESS;
 }

df_datalink_sp/src/networking/link_layer/link_layer.h

@@ -64,6 +64,8 @@ typedef struct
 	uint32_t svcTxCnt;
 	uint32_t svcRecvCnt;
 	uint32_t svcCorrectCnt;
+
+	int64_t timeDev;
 } L2_LOG;
 
 typedef struct
@@ -90,9 +92,7 @@ typedef struct
 	L2_LOG log;
 	// for system log
 	SYSINFO sysInfo;
-	SLOTLOG txSlotLog;
+	LINKLOG linkLog;
-	SLOTLOG rxSlotLog;
-	PRTCLLOG prtcLog;
 } L2_INST;
 
 /************************** Variable Definitions *****************************/
@@ -166,7 +166,8 @@ L2_FRAME_TYPE L2_GetNextFrameType(L2_INST *instPtr);
 L2_TOR_TYPE L2_GetNextTor(L2_INST *instPtr);
 
 // Time syncronization
-int32_t L2_TimeAlign(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNum, bool relative);
+int32_t L2_GetTimeDeviation(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNum, bool relative, int64_t* timeDev);
+void L2_TimeAdjust(L2_INST *instPtr, const int64_t *timeDev);
 
 
 #endif /* __LINK_LAYER_H_ */

df_datalink_sp/src/networking/link_layer/link_layer_types.h

@@ -22,6 +22,9 @@
 #include "geometry/coord.h"
 #include "geometry/quaternion.h"
 #include "../phy_layer/phy_layer.h"
+#ifndef EMULATION 
+#include "../config/app_config.h"
+#endif
 /************************** Constant Definitions *****************************/
 // Common node ID definition
 #define L2_BROADCAST_ID 0xFF
@@ -210,6 +213,8 @@ typedef struct
 #ifdef DATALINK_ENABLE_BERTEST
 	uint32_t bitTotal;
 	uint32_t bitError;
+	double lossRate;
+	double errorRate;
 #endif
 } L2_SVC_FSM;
 

df_datalink_sp/src/networking/link_layer/scan.c

@@ -409,9 +409,7 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		// Reset node ttl
 		node->ttlCnt = 0;
 
-		if (L2_isCxn2Net(instPtr) == false)
+		uint32_t netstartTime;
-		{
-			uint32_t netstartTime, frameNum, slotNum = 0;
 		// Update net start time.
 		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_NETSTART_TIME, L2_MSG_ADV_SRC_NETSTART_TIME_LEN, &netstartTime);
 		L2_EVENT netSetupDoneEvent = {
@@ -419,12 +417,20 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			.msg = &netstartTime};
 		AssertL2Event(instPtr, &netSetupDoneEvent);
 
-			// Time sync.
+		// Calculate time deviation
+		uint32_t frameNum, slotNum = 0;
 		L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
 		L2_FrameGetChunk(msg, L2_MSG_SLOT_NUM, L2_MSG_SLOT_NUM_LEN, &slotNum);
-			// TODO: Check
+		Status = L2_GetTimeDeviation(instPtr, frameNum, slotNum, true, &(instPtr->log.timeDev));
-			L2_TimeAlign(instPtr, frameNum, slotNum, true);
+		if (Status != SUCCESS) 
+		{
+			DBG_ERROR("Failed to compute time deviation.\n")
+			break;
 		}
+		
+		// Time sync.
+		L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
+
 		// trigger flag
 		AdvRecvStateUpdate(scanFsmPtr, true);
 		Status = SUCCESS;
@@ -465,6 +471,17 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		// Reset node ttl
 		node->ttlCnt = 0;
 
+		// Calculate time deviation
+		uint32_t frameNum, slotNum = 0;
+		L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+		L2_FrameGetChunk(msg, L2_MSG_SLOT_NUM, L2_MSG_SLOT_NUM_LEN, &slotNum);
+		Status = L2_GetTimeDeviation(instPtr, frameNum, slotNum, true, &(instPtr->log.timeDev));
+		if (Status != SUCCESS) 
+		{
+			DBG_ERROR("Failed to compute time deviation.\n")
+			break;
+		}
+
 		if (L2_GetNodeType(instPtr) != L2_NODE_HEAD)
 		{
 			// check if net setup finished.
@@ -501,6 +518,8 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 				l2Event.msg = &newState;
 				AssertL2Event(instPtr, &l2Event);
 			}
+			// Time sync.
+			L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
 		}
 		Status = SUCCESS;
 		break;

df_datalink_sp/src/networking/link_layer/service.c

@@ -141,6 +141,9 @@ static int32_t Service_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 			DBG_ERROR("Fail to append CRC...\n");
 			return Status;
 		}
+
+		memcpy(instPtr->serviceFSM->txLog.data, buff, L2_SVC_PACK_LEN);
+		instPtr->serviceFSM->txLog.dataId = dataId;
 		break;
 	}
 	default:
@@ -227,8 +230,8 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 {
 	ASSERT(instPtr != NULL);
 	ASSERT(msg != NULL);
-#ifndef DATALINK_ENABLE_BERTEST
 	int32_t Status;
+#ifndef DATALINK_ENABLE_BERTEST
 	uint8_t frameType;
 	L2_FrameGetChunk(msg, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &frameType);
 	switch (frameType)
@@ -269,6 +272,17 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		// Reset node ttl
 		node->ttlCnt = 0;
 
+		// Calculate time deviation
+		uint32_t frameNum, slotNum = 0;
+		L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+		L2_FrameGetChunk(msg, L2_MSG_SLOT_NUM, L2_MSG_SLOT_NUM_LEN, &slotNum);
+		Status = L2_GetTimeDeviation(instPtr, frameNum, slotNum, true, &(instPtr->log.timeDev));
+		if (Status != SUCCESS) 
+		{
+			DBG_ERROR("Failed to compute time deviation.\n")
+			break;
+		}
+
 		uint32_t dataId;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_PAYLOAD_ID, L2_MSG_SVC_PAYLOAD_ID_LEN, &dataId);
 
@@ -284,14 +298,16 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			}
 		}
 
+		// Logging
+		memcpy(instPtr->serviceFSM->rxLog.data, msg, L2_SVC_PACK_LEN);
+		instPtr->serviceFSM->rxLog.dataId = dataId;
+		
 #ifdef DATALINK_ENABLE_AUTOTIMESYNC
 		// Implement a auto time sync.
 		if (L2_GetNodeType(instPtr) != L2_NODE_HEAD) 
 		{
-			uint32_t frameNum, slotNum;
+			// Time sync.
-			L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+			L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
-			L2_FrameGetChunk(msg, L2_MSG_SLOT_NUM, L2_MSG_SLOT_NUM_LEN, &slotNum);
-			L2_TimeAlign(instPtr, frameNum, slotNum, true);
 		}
 #endif
 		break;
@@ -303,22 +319,31 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 	return Status;
 #else 
 	uint32_t errorBits = 0;
-	for (int i = 0; i < SVC_PACK_LEN; i++)
+	for (int i = 0; i < L2_SVC_PACK_LEN; i++)
 	{
 		errorBits += count_ones(msg[i] ^ testData[i]);
 	}
 
-	instPtr->serviceFsm.bitError += errorBits;
+	instPtr->serviceFSM->bitError += errorBits;
-	instPtr->serviceFsm.bitTotal += SVC_PACK_LEN * 8;
+	instPtr->serviceFSM->bitTotal += L2_SVC_PACK_LEN * 8;
 
+	// Calculate time deviation
+	uint32_t frameNum, slotNum = 0;
+	L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+	L2_FrameGetChunk(msg, L2_MSG_SLOT_NUM, L2_MSG_SLOT_NUM_LEN, &slotNum);
+	Status = L2_GetTimeDeviation(instPtr, frameNum, slotNum, true, &(instPtr->log.timeDev));
+	if (Status != SUCCESS) 
+	{
+		DBG_ERROR("Failed to compute time deviation.\n")
+		return Status;
+	}
 	// Implement a auto time sync.
 	if (L2_GetNodeType(instPtr) != L2_NODE_HEAD) 
 	{
-		uint32_t frameNum, slotNum;
+		// Time sync.
-		L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+		L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
-		L2_FrameGetChunk(msg, L2_MSG_SLOT_NUM, L2_MSG_SLOT_NUM_LEN, &slotNum);
-		L2_TimeAlign(instPtr, frameNum, slotNum, true);
 	}
+	return SUCCESS;
 #endif
 }
 
@@ -366,7 +391,7 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 			// Packing service data
 			Service_Packing(instPtr, L2_SVC_FRAME, rtneEntry->dst);
 #else
-			memcpy(instPtr->sendPktData, testData, SVC_PACK_LEN);
+			memcpy(instPtr->sendPktData, testData, L2_SVC_PACK_LEN);
 #endif
 		}
 		// FIXME: Steer antenna to point to destination.
@@ -380,12 +405,11 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 	}
 #ifdef DATALINK_ENABLE_BERTEST
 	uint32_t pktLoss;
-	double errorRate, lossRate;
 	pktLoss = instPtr->log.svcRecvCnt - instPtr->log.svcCorrectCnt;
-	lossRate = (instPtr->log.svcRecvCnt == 0) ? 0 : (double)pktLoss / (double)instPtr->serviceFsm.pktRecv;
+	instPtr->serviceFSM->lossRate = (instPtr->log.svcRecvCnt == 0) ? 0 : (double)pktLoss / (double)instPtr->serviceFSM->pktRecv;
-	errorRate = (instPtr->serviceFsm.bitTotal == 0) ? 0 : (double)instPtr->serviceFsm.bitError / (double)instPtr->serviceFsm.bitTotal;
+	instPtr->serviceFSM->errorRate = (instPtr->serviceFSM->bitTotal == 0) ? 0 : (double)instPtr->serviceFSM->bitError / (double)instPtr->serviceFSM->bitTotal;
-	DBG_PRINT("Packet Loss Rate -- Total: %lu, Loss: %lu.\n", instPtr->serviceFsm.pktRecv, pktLoss);
+	DBG_PRINT("Packet Loss Rate -- Total: %lu, Loss: %lu.\n", instPtr->serviceFSM->pktRecv, pktLoss);
-	DBG_PRINT("Bit Error Rate -- Total:%lu, Error:%lu.\n", instPtr->serviceFsm.bitTotal, instPtr->serviceFsm.bitError);
+	DBG_PRINT("Bit Error Rate -- Total:%lu, Error:%lu.\n", instPtr->serviceFSM->bitTotal, instPtr->serviceFSM->bitError);
 #endif
 	return SUCCESS;
 }

df_datalink_sp/src/networking/link_layer/time_sync.c

@@ -32,20 +32,22 @@
 
 /*****************************************************************************/
 /**
- * @brief    a slot alignment, base on physical layer information.
+ * @brief    Get time deviation to the specified frame and slot number.
  *
  * @param   instPtr	a pointer to linklayer layer instance
  * @param   frameNum
  * @param   slotNum
+ * @param   relative
+ * @param   timeDev
  *
- * @return  SUCCESS Initialize successfully.
+ * @return  SUCCESS
- *          FAILURE Initialization failed, allocate memory fail or initial
+ * 			EIGNORE there is no received frame
- *          bram controller fail.
  *
  ******************************************************************************/
-// TODO: Check
+int32_t L2_GetTimeDeviation(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNum, bool relative, int64_t *timeDev)
-int32_t L2_TimeAlign(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNum, bool relative)
 {
+	ASSERT(instPtr != NULL);
+	ASSERT(timeDev != NULL);
 	L1_FRAME_TYPE lastRecvdFrame;
 	lastRecvdFrame = Phy_GetLastRecvFrameType(instPtr->config.phyInstPtr);
 	if (lastRecvdFrame == L1_NONE_FRAME)
@@ -57,8 +59,7 @@ int32_t L2_TimeAlign(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNum, bool
 	DBG_INFO("Starting TimeAlign operation...\n");
 	// read nextSendTime from physical layer
 	uint64_t currTime, expectTime;
-	int64_t timeDiff;
+	TIME_WORD timeStamp;
-	TIME_WORD timeStamp, slotTimerAdjmet;
 	expectTime = ((uint64_t)(frameNum * L2_SLOTS_PER_FRAME + slotNum)) * TIME_FRAC_MAX;
 	expectTime += Phy_GetTimeComp(lastRecvdFrame);
 
@@ -71,10 +72,27 @@ int32_t L2_TimeAlign(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNum, bool
 	currTime = (uint64_t)timeStamp.frac_part;
 	currTime += ((uint64_t)timeStamp.int_part) * TIME_FRAC_MAX;
 
-	timeDiff = (int64_t)(expectTime - currTime);
+	*timeDev = (int64_t)(expectTime - currTime);
-
-	slotTimerAdjmet.int_part = (uint32_t)(timeDiff / TIME_FRAC_MAX);
-	slotTimerAdjmet.frac_part = (uint32_t)(timeDiff % TIME_FRAC_MAX);
-	TimeCtrl_TimeAdjust(instPtr->config.tmcInstPtr, &slotTimerAdjmet, TM_ADJ_ADD);
 	return SUCCESS;
 }
+
+
+/*****************************************************************************/
+/**
+ * @brief    Implement time adjustment by applying time deviation.
+ *
+ * @param   instPtr	a pointer to linklayer layer instance
+ * @param   timeDev
+ *
+ * @return  NONE
+ *
+ ******************************************************************************/
+void L2_TimeAdjust(L2_INST *instPtr, const int64_t *timeDev) 
+{
+	ASSERT(instPtr != NULL);
+	ASSERT(timeDev != NULL);
+	TIME_WORD slotTimerAdjmet;
+	slotTimerAdjmet.int_part = (uint32_t)(*timeDev / TIME_FRAC_MAX);
+	slotTimerAdjmet.frac_part = (uint32_t)(*timeDev % TIME_FRAC_MAX);
+	TimeCtrl_TimeAdjust(instPtr->config.tmcInstPtr, &slotTimerAdjmet, TM_ADJ_ADD);
+}

df_datalink_sp/src/networking/phy_layer/phy_layer.c

@@ -311,6 +311,28 @@ void Phy_UpdateState(PHY_INST *instPtr)
 	instPtr->recvSlotTime.frac_part = PhyRead(instPtr, TM_TARGET_L);
 	instPtr->recvFsTime.int_part = PhyRead(instPtr, FSTIME_H);
 	instPtr->recvFsTime.frac_part = PhyRead(instPtr, FSTIME_L);
+
+	instPtr->phyLog.acqCnt = PhyRead(instPtr, PHY_ACQ_CNT);
+	instPtr->phyLog.fsyncCnt = PhyRead(instPtr, PHY_FRAME_SYNC_CNT);
+	instPtr->phyLog.decodeCnt = PhyRead(instPtr, PHY_DECODE_CNT);
+	instPtr->phyLog.crcCnt = PhyRead(instPtr, PHY_CRC_OK_CNT);
+	instPtr->phyLog.doppler = Phy_GetFreqEst(instPtr);
+	instPtr->phyLog.recvStamp = (uint64_t)instPtr->recvFsTime.frac_part * TIME_FRAC_MAX + instPtr->recvFsTime.int_part;
+	instPtr->phyLog.acqPeak = PhyRead(instPtr, PHY_ACQ_PEAK_L);
+	instPtr->phyLog.acqPeak = ((uint64_t)PhyRead(instPtr, PHY_ACQ_PEAK_H)) << 32;
+	instPtr->phyLog.acqMean = PhyRead(instPtr, PHY_ACQ_MEAN_L);
+	instPtr->phyLog.acqMean = ((uint64_t)PhyRead(instPtr, PHY_ACQ_MEAN_H)) << 32;
+	instPtr->phyLog.acqPhase = PhyRead(instPtr, PHY_ACQ_FREQEST) & PHY_ACQ_FREQEST_PHASE_MASK >> PHY_ACQ_FREQEST_PHASE_SHIFT;
+	instPtr->phyLog.acqFreqCh = PhyRead(instPtr, PHY_ACQ_FREQEST) & PHY_ACQ_FREQEST_CHANNEL_MASK >> PHY_ACQ_FREQEST_CHANNEL_SHIFT;
+	instPtr->phyLog.fsyncPeak = PhyRead(instPtr, PHY_FRAME_SYNC_PEAK_L);
+	instPtr->phyLog.fsyncPeak = ((uint64_t)PhyRead(instPtr, PHY_FRAME_SYNC_PEAK_H)) << 32;
+	instPtr->phyLog.fsyncMean = PhyRead(instPtr, PHY_FRAME_SYNC_MEAN_L);
+	instPtr->phyLog.fsyncMean = ((uint64_t)PhyRead(instPtr, PHY_FRAME_SYNC_MEAN_H)) << 32;
+	instPtr->phyLog.fsyncFreqCh = PhyRead(instPtr, PHY_FRAME_SYNC_FREQEST) & PHY_FRAME_SYNC_FREQEST_CHANNEL_MASK >> PHY_FRAME_SYNC_FREQEST_CHANNEL_SHIFT;
+	instPtr->phyLog.deintlvAmpEst = PhyRead(instPtr, PHY_DEINTLV_AMPEST) & PHY_DEINTLV_AMPEST_MASK;
+	instPtr->phyLog.reserve = 0;
+
+	SysMonitor_UpdatePhysicalLayerLog(&(instPtr->phyLog));
 }
 
 /*****************************************************************************/
@@ -357,6 +379,7 @@ int32_t Phy_InstInit(PHY_INST **instPtr, PHY_CONFIG *phyConfig)
 	memset(&((*instPtr)->beamNo), (int32_t)L1_INIT_ANT_NO, sizeof(PHY_RCD));
 	memset(&((*instPtr)->beamWd), (int32_t)L1_INIT_ANT_WD, sizeof(PHY_RCD));
 	memset(&((*instPtr)->hwSate), 0x00, sizeof(HWSTATE));
+	memset(&((*instPtr)->phyLog), 0x00, sizeof(PHYLOG));
 
 #ifndef EMULATION
 	XBram_Config *bramConfigPtr;
@@ -1174,34 +1197,34 @@ const HWSTATE* Phy_RefreshHwSate(PHY_INST *instPtr)
 	//    [2] - RF voltage status
 	//    [4] - NIL voltage status
 	//    [6] - Antenna status
-	instPtr->hwSate.antVolt = (rawData & ANT_STATUS_ANT_VOLT_MASK != 0) ? 0x01 : 0x00;
+	instPtr->hwSate.antVolt = ((rawData & ANT_STATUS_ANT_VOLT_MASK) == ANT_STATUS_ANT_VOLT_OK) ? 0x01 : 0x00;
-	instPtr->hwSate.antVolt |= (rawData & ANT_STATUS_RF_VOLT_MASK!= 0) ? 0x04 : 0x00;
+	instPtr->hwSate.antVolt |= ((rawData & ANT_STATUS_RF_VOLT_MASK) == ANT_STATUS_RF_VOLT_OK) ? 0x04 : 0x00;
-	instPtr->hwSate.antVolt |= (rawData & ANT_STATUS_NIL_VOLT_MASK!= 0) ? 0x10 : 0x00;
+	instPtr->hwSate.antVolt |= ((rawData & ANT_STATUS_NIL_VOLT_MASK) == ANT_STATUS_NIL_VOLT_OK) ? 0x10 : 0x00;
-	instPtr->hwSate.antVolt |= (rawData & ANT_STATUS_CODE_MASK!= 0) ? 0x40 : 0x00;
+	instPtr->hwSate.antVolt |= ((rawData & ANT_STATUS_CODE_MASK) == ANT_STATUS_CODE_OK) ? 0x40 : 0x00;
 
 	/*** Temperature and Lock Status ***/
-	rawData = PhyRead(instPtr, RF_STATUS);
+	rawData = PhyRead(instPtr, ANT_RF_STATUS);
 	//-- Update Antenna Temperature (signed 8bit integer, 1 centigrade per LSB)
-	instPtr->hwSate.antTemp = (uint8_t)(rawData & RF_STATUS_TEMP_MASK);
+	instPtr->hwSate.antTemp = (uint8_t)(rawData & ANT_RF_STATUS_TEMP_MASK);
 	// -- Update Antenna PLL Lock Status: 1 - normal, 0 - error
 	//    [0] - BASEBAND lock status
 	//    [2] - PLLA lock status
 	//    [4] - PLLB lock status
-	instPtr->hwSate.antPll = (rawData & RF_STATUS_BDLOCK_MASK) ? 0x01 : 0x00;
+	instPtr->hwSate.antPll = ((rawData & ANT_RF_STATUS_BBLOCK_MASK) == ANT_RF_STATUS_BBLOCK_OK) ? 0x01 : 0x00;
-	instPtr->hwSate.antPll |= (rawData & RF_STATUS_PLLA_MASK) ? 0x04 : 0x00;
+	instPtr->hwSate.antPll |= ((rawData & ANT_RF_STATUS_PLLA_MASK) == ANT_RF_STATUS_PLLA_OK) ? 0x04 : 0x00;
-	instPtr->hwSate.antPll |= (rawData & RF_STATUS_PLLB_MASK) ? 0x10 : 0x00;
+	instPtr->hwSate.antPll |= ((rawData & ANT_RF_STATUS_PLLB_MASK) == ANT_RF_STATUS_PLLB_OK) ? 0x10 : 0x00;
 
 	/*** MGCs ***/
-	rawData = PhyRead(instPtr, RF_MGC);
+	rawData = PhyRead(instPtr, ANT_RF_MGC);
 	// -- Update Antenna MGC (0~15 dB)
 	//    [3:0] - Channel 1 MGC
 	//    [7:4] - Channel 2 MGC
 	//    [11:8] - Channel 3 MGC
 	//    [15:12] - Channel 4 MGC
-	instPtr->hwSate.antMgc0 = (rawData & RF_MGC_CH1_MASK);
+	instPtr->hwSate.antMgc0 = (rawData & ANT_RF_MGC_CH1_MASK);
-	instPtr->hwSate.antMgc0 |= (rawData & RF_MGC_CH2_MASK) >> 4;
+	instPtr->hwSate.antMgc0 |= (rawData & ANT_RF_MGC_CH2_MASK) >> 4;
-	instPtr->hwSate.antMgc1 = (rawData & RF_MGC_CH3_MASK) >> 16;
+	instPtr->hwSate.antMgc1 = (rawData & ANT_RF_MGC_CH3_MASK) >> 16;
-	instPtr->hwSate.antMgc1 |= (rawData & RF_MGC_CH4_MASK) >> 24;
+	instPtr->hwSate.antMgc1 |= (rawData & ANT_RF_MGC_CH4_MASK) >> 24;
 
 	// Determin if antenna is ok.
 	if(instPtr->hwSate.antVolt != 0x55 //01010101

df_datalink_sp/src/networking/phy_layer/phy_layer.h

@@ -218,6 +218,7 @@ typedef struct
 	XAdcPs hwXadc;
 #endif
 	HWSTATE hwSate;
+	PHYLOG phyLog;
 } PHY_INST;
 
 /************************** Variable Definitions *****************************/

df_datalink_sp/src/networking/phy_layer/phy_reg.h

@@ -275,70 +275,216 @@
 #define BEAM_AXIS_AZ_MASK 0xFFFF0000U
 
 /**
- * Register: ANT_STATUS_0
+ * Register: ANT_STATUS
  */
-#define ANT_STATUS 0x00000048U
+#define ANT_STATUS 0x00000100U
-#define ANT_STATUS_CODE_SHIFT 0
+#define ANT_STATUS_ANT_VOLT_SHIFT 0
-#define ANT_STATUS_CODE_WIDTH 8
-#define ANT_STATUS_CODE_MASK 0x000000FFU
-#define ANT_STATUS_NIL_VOLT_SHIFT 8
-#define ANT_STATUS_NIL_VOLT_WIDTH 8
-#define ANT_STATUS_NIL_VOLT_MASK 0x0000FF00U
-#define ANT_STATUS_RF_VOLT_SHIFT 16
-#define ANT_STATUS_RF_VOLT_WIDTH 8
-#define ANT_STATUS_RF_VOLT_MASK 0x00FF0000U
-#define ANT_STATUS_ANT_VOLT_SHIFT 24
 #define ANT_STATUS_ANT_VOLT_WIDTH 8
-#define ANT_STATUS_ANT_VOLT_MASK 0xFF000000U
+#define ANT_STATUS_ANT_VOLT_MASK 0x000000FFU
+#define ANT_STATUS_ANT_VOLT_OK 0x00000001U
+
+#define ANT_STATUS_RF_VOLT_SHIFT 8
+#define ANT_STATUS_RF_VOLT_WIDTH 8
+#define ANT_STATUS_RF_VOLT_MASK 0x0000FF00U
+#define ANT_STATUS_RF_VOLT_OK 0x00000100U
+
+#define ANT_STATUS_NIL_VOLT_SHIFT 16
+#define ANT_STATUS_NIL_VOLT_WIDTH 8
+#define ANT_STATUS_NIL_VOLT_MASK 0x00FF0000U
+#define ANT_STATUS_NIL_VOLT_OK 0x00010000U
+
+#define ANT_STATUS_CODE_SHIFT 24
+#define ANT_STATUS_CODE_WIDTH 8
+#define ANT_STATUS_CODE_MASK 0xFF000000U
+#define ANT_STATUS_CODE_OK 0x01000000U
 
 /**
  * Register: ANT_FRAME_CNT
  */
-#define ANT_FRAME_CNT 0x0000004CU
+#define ANT_FRAME_CNT 0x00000104U
 #define ANT_FRAME_CNT_SHIFT 0
 #define ANT_FRAME_CNT_WIDTH 32
 #define ANT_FRAME_CNT_MASK 0xFFFFFFFFU
 
 /**
- * Register: RF_STATUS
+ * Register: ANT_RF_STATUS
  */
-#define RF_STATUS 0x00000050U
+#define ANT_RF_STATUS 0x00000108U
-#define RF_STATUS_TEMP_SHIFT 0
+#define ANT_RF_STATUS_TEMP_SHIFT 0
-#define RF_STATUS_TEMP_WIDTH 8
+#define ANT_RF_STATUS_TEMP_WIDTH 8
-#define RF_STATUS_TEMP_MASK 0x000000FFU
+#define ANT_RF_STATUS_TEMP_MASK 0x000000FFU
-#define RF_STATUS_BDLOCK_SHIFT 8
+
-#define RF_STATUS_BDLOCK_WIDTH 8
+#define ANT_RF_STATUS_BBLOCK_SHIFT 8
-#define RF_STATUS_BDLOCK_MASK 0x0000FF00U
+#define ANT_RF_STATUS_BBLOCK_WIDTH 8
-#define RF_STATUS_PLLA_SHIFT 16
+#define ANT_RF_STATUS_BBLOCK_MASK 0x0000FF00U
-#define RF_STATUS_PLLA_WIDTH 8
+#define ANT_RF_STATUS_BBLOCK_OK 0x00000100U
-#define RF_STATUS_PLLA_MASK 0x00FF0000U
+
-#define RF_STATUS_PLLB_SHIFT 24
+#define ANT_RF_STATUS_PLLA_SHIFT 16
-#define RF_STATUS_PLLB_WIDTH 8
+#define ANT_RF_STATUS_PLLA_WIDTH 8
-#define RF_STATUS_PLLB_MASK 0xFF000000U
+#define ANT_RF_STATUS_PLLA_MASK 0x00FF0000U
+#define ANT_RF_STATUS_PLLA_OK 0x00010000U
+
+#define ANT_RF_STATUS_PLLB_SHIFT 24
+#define ANT_RF_STATUS_PLLB_WIDTH 8
+#define ANT_RF_STATUS_PLLB_MASK 0xFF000000U
+#define ANT_RF_STATUS_PLLB_OK 0x01000000U
 
 /**
- * Register: RF_MGC
+ * Register: ANT_RF_MGC
  */
-#define RF_MGC 0x00000054U
+#define ANT_RF_MGC 0x0000010CU
-#define RF_MGC_CH1_SHIFT 0
+#define ANT_RF_MGC_CH1_SHIFT 0
-#define RF_MGC_CH1_WIDTH 4
+#define ANT_RF_MGC_CH1_WIDTH 4
-#define RF_MGC_CH1_MASK 0x0000000FU
+#define ANT_RF_MGC_CH1_MASK 0x0000000FU
-#define RF_MGC_CH2_SHIFT 8
+#define ANT_RF_MGC_CH2_SHIFT 8
-#define RF_MGC_CH2_WIDTH 4
+#define ANT_RF_MGC_CH2_WIDTH 4
-#define RF_MGC_CH2_MASK 0x00000F00U
+#define ANT_RF_MGC_CH2_MASK 0x00000F00U
-#define RF_MGC_CH3_SHIFT 16
+#define ANT_RF_MGC_CH3_SHIFT 16
-#define RF_MGC_CH3_WIDTH 4
+#define ANT_RF_MGC_CH3_WIDTH 4
-#define RF_MGC_CH3_MASK 0x000F0000U
+#define ANT_RF_MGC_CH3_MASK 0x000F0000U
-#define RF_MGC_CH4_SHIFT 24
+#define ANT_RF_MGC_CH4_SHIFT 24
-#define RF_MGC_CH4_WIDTH 4
+#define ANT_RF_MGC_CH4_WIDTH 4
-#define RF_MGC_CH4_MASK 0x0F000000U
+#define ANT_RF_MGC_CH4_MASK 0x0F000000U
 
 /**
- * Register: RF_FRAME_CNT
+ * Register: ANT_RF_FRAME_CNT
  */
-#define RF_FRAME_CNT 0x00000058U
+#define ANT_RF_FRAME_CNT 0x00000110U
-#define RF_FRAME_CNT_SHIFT 0
+#define ANT_RF_FRAME_CNT_SHIFT 0
-#define RF_FRAME_CNT_WIDTH 32
+#define ANT_RF_FRAME_CNT_WIDTH 32
-#define RF_FRAME_CNT_MASK 0xFFFFFFFFU
+#define ANT_RF_FRAME_CNT_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_ACQ_CNT
+ */
+#define PHY_ACQ_CNT 0x00000114U
+#define PHY_ACQ_CNT_SHIFT 0
+#define PHY_ACQ_CNT_WIDTH 32
+#define PHY_ACQ_CNT_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_FRAME_SYNC_CNT
+ */
+#define PHY_FRAME_SYNC_CNT 0x00000118U
+#define PHY_FRAME_SYNC_CNT_SHIFT 0
+#define PHY_FRAME_SYNC_CNT_WIDTH 32
+#define PHY_FRAME_SYNC_CNT_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_DECODE_CNT
+ */
+#define PHY_DECODE_CNT 0x0000011CU
+#define PHY_DECODE_CNT_SHIFT 0
+#define PHY_DECODE_CNT_WIDTH 32
+#define PHY_DECODE_CNT_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_CRC_OK_CNT
+ */
+#define PHY_CRC_OK_CNT 0x00000120U
+#define PHY_CRC_OK_CNT_SHIFT 0
+#define PHY_CRC_OK_CNT_WIDTH 32
+#define PHY_CRC_OK_CNT_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_ACQ_PEAK_H
+ */
+#define PHY_ACQ_PEAK_H 0x00000124U
+#define PHY_ACQ_PEAK_H_SHIFT 0
+#define PHY_ACQ_PEAK_H_WIDTH 32
+#define PHY_ACQ_PEAK_H_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_ACQ_PEAK_L
+ */
+#define PHY_ACQ_PEAK_L 0x00000128U
+#define PHY_ACQ_PEAK_L_SHIFT 0
+#define PHY_ACQ_PEAK_L_WIDTH 32
+#define PHY_ACQ_PEAK_L_MASK 0xFFFFFFFFU
+
+
+/**
+ * Register: PHY_ACQ_MEAN_H
+ */
+#define PHY_ACQ_MEAN_H 0x0000012CU
+#define PHY_ACQ_MEAN_H_SHIFT 0
+#define PHY_ACQ_MEAN_H_WIDTH 32
+#define PHY_ACQ_MEAN_H_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_ACQ_MEAN_L
+ */
+#define PHY_ACQ_MEAN_L 0x00000130U
+#define PHY_ACQ_MEAN_L_SHIFT 0
+#define PHY_ACQ_MEAN_L_WIDTH 32
+#define PHY_ACQ_MEAN_L_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_ACQ_FREQEST
+ */
+#define PHY_ACQ_FREQEST 0x00000134U
+#define PHY_ACQ_FREQEST_SHIFT 0
+#define PHY_ACQ_FREQEST_WIDTH 32
+#define PHY_ACQ_FREQEST_MASK 0xFFFFFFFFU
+
+#define PHY_ACQ_FREQEST_PHASE_SHIFT 0
+#define PHY_ACQ_FREQEST_PHASE_WIDTH 8
+#define PHY_ACQ_FREQEST_PHASE_MASK 0x000000FFU
+#define PHY_ACQ_FREQEST_CHANNEL_SHIFT 8
+#define PHY_ACQ_FREQEST_CHANNEL_WIDTH 8
+#define PHY_ACQ_FREQEST_CHANNEL_MASK 0x0000FF00U
+
+/**
+ * Register: PHY_FRAME_SYNC_PEAK_H
+ */
+#define PHY_FRAME_SYNC_PEAK_H 0x00000138U
+#define PHY_FRAME_SYNC_PEAK_H_SHIFT 0
+#define PHY_FRAME_SYNC_PEAK_H_WIDTH 32
+#define PHY_FRAME_SYNC_PEAK_H_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_FRAME_SYNC_PEAK_L
+ */
+#define PHY_FRAME_SYNC_PEAK_L 0x0000013CU
+#define PHY_FRAME_SYNC_PEAK_L_SHIFT 0
+#define PHY_FRAME_SYNC_PEAK_L_WIDTH 32
+#define PHY_FRAME_SYNC_PEAK_L_MASK 0xFFFFFFFFU
+
+
+/**
+ * Register: PHY_FRAME_SYNC_MEAN_H
+ */
+#define PHY_FRAME_SYNC_MEAN_H 0x00000140U
+#define PHY_FRAME_SYNC_MEAN_H_SHIFT 0
+#define PHY_FRAME_SYNC_MEAN_H_WIDTH 32
+#define PHY_FRAME_SYNC_MEAN_H_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_FRAME_SYNC_MEAN_L
+ */
+#define PHY_FRAME_SYNC_MEAN_L 0x00000144U
+#define PHY_FRAME_SYNC_MEAN_L_SHIFT 0
+#define PHY_FRAME_SYNC_MEAN_L_WIDTH 32
+#define PHY_FRAME_SYNC_MEAN_L_MASK 0xFFFFFFFFU
+
+/**
+ * Register: PHY_FRAME_SYNC_FREQEST
+ */
+#define PHY_FRAME_SYNC_FREQEST 0x00000148U
+#define PHY_FRAME_SYNC_FREQEST_SHIFT 0
+#define PHY_FRAME_SYNC_FREQEST_WIDTH 32
+#define PHY_FRAME_SYNC_FREQEST_MASK 0xFFFFFFFFU
+
+#define PHY_FRAME_SYNC_FREQEST_CHANNEL_SHIFT 0
+#define PHY_FRAME_SYNC_FREQEST_CHANNEL_WIDTH 8
+#define PHY_FRAME_SYNC_FREQEST_CHANNEL_MASK 0x000000FFU
+
+/**
+ * Register: PHY_DEINTLV_AMPEST
+ */
+#define PHY_DEINTLV_AMPEST 0x00000148U
+#define PHY_DEINTLV_AMPEST_SHIFT 0
+#define PHY_DEINTLV_AMPEST_WIDTH 16
+#define PHY_DEINTLV_AMPEST_MASK 0x0000FFFFU
 
 #endif /* PHY_REG_H_ */

df_datalink_sp/src/system_monitor.c

@@ -23,18 +23,16 @@ typedef struct
 
 typedef struct
 {
-	PINGPONG recvPLCtrl;
+	PINGPONG recvCtrl;
-	PAYLOAD recvPL[2];
+	PAYLOAD recv[2];
-	PINGPONG sendPLCtrl;
+	PINGPONG sendCtrl;
-	PAYLOAD sendPL[2];
+	PAYLOAD send[2];
 	PINGPONG sysInfoCtrl;
 	SYSINFO sysInfo[2];
-	PINGPONG sendLogCtrl;
+	PINGPONG linkLogCtrl;
-	SLOTLOG sendLog[2];
+	LINKLOG linkLog[2];
-	PINGPONG recvLogCtrl;
+	PINGPONG phyLogCtrl;
-	SLOTLOG recvLog[2];
+	PHYLOG phyLog[2];
-	PINGPONG protocolLogCtrl;
-	PRTCLLOG protocolLog[2];
 	PINGPONG hwStateCtrl;
 	HWSTATE hwState[2];
 } SYSMONITOR;
@@ -70,18 +68,17 @@ int32_t SysMonitor_Init(void)
 	{
 		return ENOMEM;
 	}
-	memset(&(sysMonitorInst->recvPLCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->recvCtrl), BUFF_NONE, sizeof(PINGPONG));
-	memset(&(sysMonitorInst->sendPLCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->sendCtrl), BUFF_NONE, sizeof(PINGPONG));
 	memset(&(sysMonitorInst->sysInfoCtrl), BUFF_NONE, sizeof(PINGPONG));
-	memset(&(sysMonitorInst->sendLogCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->linkLogCtrl), BUFF_NONE, sizeof(PINGPONG));
-	memset(&(sysMonitorInst->recvLogCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->phyLogCtrl), BUFF_NONE, sizeof(PINGPONG));
-	memset(&(sysMonitorInst->protocolLogCtrl), BUFF_NONE, sizeof(PINGPONG));
 	memset(&(sysMonitorInst->hwStateCtrl), BUFF_NONE, sizeof(PINGPONG));
 	
-	sysMonitorInst->recvPL[0].dataId = DATA_ID_NONE;
+	sysMonitorInst->recv[0].dataId = DATA_ID_NONE;
-	sysMonitorInst->recvPL[1].dataId = DATA_ID_NONE;
+	sysMonitorInst->recv[1].dataId = DATA_ID_NONE;
-	sysMonitorInst->sendPL[0].dataId = DATA_ID_NONE;
+	sysMonitorInst->send[0].dataId = DATA_ID_NONE;
-	sysMonitorInst->sendPL[1].dataId = DATA_ID_NONE;
+	sysMonitorInst->send[1].dataId = DATA_ID_NONE;
 	return SUCCESS;
 }
 
@@ -92,6 +89,9 @@ void SysMonitor_Destroy(void)
 }
 
 // @System Info
+/**
+ * Update system info.
+ */
 void SysMonitor_UpdateSysinfo(const SYSINFO *info)
 {
 	uint8_t buffIndx;
@@ -102,6 +102,9 @@ void SysMonitor_UpdateSysinfo(const SYSINFO *info)
 	sysMonitorInst->sysInfoCtrl.wBusy = BUFF_NONE;
 }
 
+/**
+ * Update system info by raw data.
+ */
 void SysMonitor_UpdateSysinfoRaw(const uint8_t *buff)
 {
 	ASSERT(sysMonitorInst != NULL);
@@ -145,6 +148,9 @@ void SysMonitor_UpdateSysinfoRaw(const uint8_t *buff)
 	sysMonitorInst->sysInfoCtrl.wBusy = BUFF_NONE;
 }
 
+/**
+ * Get system info.
+ */
 void SysMonitor_GetSysinfo(SYSINFO *info)
 {
 	ASSERT(sysMonitorInst != NULL);
@@ -159,6 +165,9 @@ void SysMonitor_GetSysinfo(SYSINFO *info)
 	sysMonitorInst->sysInfoCtrl.rBusy = buffIndex_old;
 }
 
+/**
+ * Get system info as raw data.
+ */
 void SysMonitor_GetSysinfoRaw(uint8_t *buff)
 {
 	uint8_t buffIndx, buffIndex_old;
@@ -204,6 +213,7 @@ void SysMonitor_GetSysinfoRaw(uint8_t *buff)
 	memcpy(buff, &(infoEntry->roll), sizeof(infoEntry->roll));
 	sysMonitorInst->sysInfoCtrl.rBusy = buffIndex_old;
 }
+
 // @Send Payload
 /**
  * Update send payload by raw data.
@@ -212,33 +222,33 @@ void SysMonitor_UpdateSendPayloadRaw(const uint8_t *buff, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx;
-	buffIndx = GetWritable(sysMonitorInst->sendPLCtrl);
+	buffIndx = GetWritable(sysMonitorInst->sendCtrl);
-	sysMonitorInst->sendPLCtrl.wBusy = buffIndx;
+	sysMonitorInst->sendCtrl.wBusy = buffIndx;
-	memcpy(sysMonitorInst->sendPL[buffIndx].data, buff, len);
+	memcpy(sysMonitorInst->send[buffIndx].data, buff, len);
-	sysMonitorInst->sendPL[buffIndx].dataId++;
+	sysMonitorInst->send[buffIndx].dataId++;
-	sysMonitorInst->sendPLCtrl.latest = buffIndx;
+	sysMonitorInst->sendCtrl.latest = buffIndx;
-	sysMonitorInst->sendPLCtrl.wBusy = BUFF_NONE;
+	sysMonitorInst->sendCtrl.wBusy = BUFF_NONE;
 }
 
 /**
- * Get send payload as raw data.
+ * Get the latest send payload as raw data.
  */
 void SysMonitor_GetSendPayloadRaw(uint8_t *buff, uint32_t *id, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->sendPLCtrl.rBusy;
+	buffIndex_old = sysMonitorInst->sendCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
 		buffIndx = buffIndex_old; // Keep it busy
 	else
-		buffIndx = GetReadable(sysMonitorInst->sendPLCtrl);
+		buffIndx = GetReadable(sysMonitorInst->sendCtrl);
-	sysMonitorInst->sendPLCtrl.rBusy = buffIndx;
+	sysMonitorInst->sendCtrl.rBusy = buffIndx;
-	if (sysMonitorInst->sendPL[buffIndx].dataId != DATA_ID_NONE)
+	if (sysMonitorInst->send[buffIndx].dataId != DATA_ID_NONE)
 	{
-		memcpy(buff, sysMonitorInst->sendPL[buffIndx].data, len);
+		memcpy(buff, sysMonitorInst->send[buffIndx].data, len);
 	}
-	*id = sysMonitorInst->sendPL[buffIndx].dataId;
+	*id = sysMonitorInst->send[buffIndx].dataId;
-	sysMonitorInst->sendPLCtrl.rBusy = buffIndex_old;
+	sysMonitorInst->sendCtrl.rBusy = buffIndex_old;
 }
 
 // @Receive Payload
@@ -249,226 +259,141 @@ void SysMonitor_UpdateRecvPayloadRaw(const uint8_t *buff, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx;
-	buffIndx = GetWritable(sysMonitorInst->recvPLCtrl);
+	buffIndx = GetWritable(sysMonitorInst->recvCtrl);
-	sysMonitorInst->recvPLCtrl.wBusy = buffIndx;
+	sysMonitorInst->recvCtrl.wBusy = buffIndx;
-	memcpy(sysMonitorInst->recvPL[buffIndx].data, buff, len);
+	memcpy(sysMonitorInst->recv[buffIndx].data, buff, len);
-	sysMonitorInst->recvPL[buffIndx].dataId++;
+	sysMonitorInst->recv[buffIndx].dataId++;
-	sysMonitorInst->recvPLCtrl.latest = buffIndx;
+	sysMonitorInst->recvCtrl.latest = buffIndx;
-	sysMonitorInst->recvPLCtrl.wBusy = BUFF_NONE;
+	sysMonitorInst->recvCtrl.wBusy = BUFF_NONE;
 }
 
 /**
- * Get send payload as raw data.
+ * Get the latest receive payload as raw data.
  */
 void SysMonitor_GetRecvPayloadRaw(uint8_t *buff, uint32_t *id, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->recvPLCtrl.rBusy;
+	buffIndex_old = sysMonitorInst->recvCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
 		buffIndx = buffIndex_old; // Keep it busy
 	else
-		buffIndx = GetReadable(sysMonitorInst->recvPLCtrl);
+		buffIndx = GetReadable(sysMonitorInst->recvCtrl);
-	sysMonitorInst->recvPLCtrl.rBusy = buffIndx;
+	sysMonitorInst->recvCtrl.rBusy = buffIndx;
-	if (sysMonitorInst->recvPL[buffIndx].dataId != DATA_ID_NONE)
+	if (sysMonitorInst->recv[buffIndx].dataId != DATA_ID_NONE)
 	{
-		memcpy(buff, sysMonitorInst->recvPL[buffIndx].data, len);
+		memcpy(buff, sysMonitorInst->recv[buffIndx].data, len);
 	}
-	*id = sysMonitorInst->recvPL[buffIndx].dataId;
+	*id = sysMonitorInst->recv[buffIndx].dataId;
-	sysMonitorInst->recvPLCtrl.rBusy = buffIndex_old;
+	sysMonitorInst->recvCtrl.rBusy = buffIndex_old;
 }
 
-//  @Send Slot log
+// @Link layer log
 /**
- * Log send slot information
+ * Update link layer log
  */
-void SysMonitor_UpdateSendSlotLog(const SLOTLOG *log)
+void SysMonitor_UpdateLinklayerLog(const LINKLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx;
-	buffIndx = GetWritable(sysMonitorInst->sendLogCtrl);
+	buffIndx = GetWritable(sysMonitorInst->linkLogCtrl);
-	sysMonitorInst->sendLogCtrl.wBusy = buffIndx;
+	sysMonitorInst->linkLogCtrl.wBusy = buffIndx;
-	memcpy(&(sysMonitorInst->sendLog[buffIndx]), log, sizeof(SLOTLOG));
+	memcpy(&(sysMonitorInst->linkLog[buffIndx]), log, sizeof(LINKLOG));
-	sysMonitorInst->sendLogCtrl.latest = buffIndx;
+	sysMonitorInst->linkLogCtrl.latest = buffIndx;
-	sysMonitorInst->sendLogCtrl.wBusy = BUFF_NONE;
+	sysMonitorInst->linkLogCtrl.wBusy = BUFF_NONE;
 }
 
 /**
- * Get the latest send slot log
+ * Get the latest link layer log
  */
-void SysMonitor_GetSendSlotLog(SLOTLOG *log)
+void SysMonitor_GetLinklayerLog(LINKLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->sendLogCtrl.rBusy;
+	buffIndex_old = sysMonitorInst->linkLogCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
 		buffIndx = buffIndex_old; // Keep it busy
 	else
-		buffIndx = GetReadable(sysMonitorInst->sendLogCtrl);
+		buffIndx = GetReadable(sysMonitorInst->linkLogCtrl);
-	sysMonitorInst->sendLogCtrl.rBusy = buffIndx;
+	sysMonitorInst->linkLogCtrl.rBusy = buffIndx;
-	memcpy(log, &(sysMonitorInst->sendLog[buffIndx]), sizeof(SLOTLOG));
+	memcpy(log, &(sysMonitorInst->linkLog[buffIndx]), sizeof(LINKLOG));
-	sysMonitorInst->sendLogCtrl.rBusy = buffIndex_old;
+	sysMonitorInst->linkLogCtrl.rBusy = buffIndex_old;
 }
 
 /**
- * Get the latest send slot log as raw data
+ * Get the latest link layer log as raw data
  */
-void SysMonitor_GetSendSlotLogRaw(uint8_t *buff)
+void SysMonitor_GetLinklayerLogRaw(uint8_t *buff)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->sendLogCtrl.rBusy;
+	buffIndex_old = sysMonitorInst->linkLogCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
 		buffIndx = buffIndex_old; // Keep it busy
 	else
-		buffIndx = GetReadable(sysMonitorInst->sendLogCtrl);
+		buffIndx = GetReadable(sysMonitorInst->linkLogCtrl);
-	sysMonitorInst->sendLogCtrl.rBusy = buffIndx;
+	sysMonitorInst->linkLogCtrl.rBusy = buffIndx;
 
 	// Encapsulate log
-	SLOTLOG *logEntry = &(sysMonitorInst->sendLog[buffIndx]);
+	LINKLOG *logEntry = &(sysMonitorInst->linkLog[buffIndx]);
-	memcpy(buff, &(logEntry->tuNo), sizeof(logEntry->tuNo));
+	
-	buff += sizeof(logEntry->tuNo);
+	// TODO:
-	memcpy(buff, &(logEntry->slotNo), sizeof(logEntry->slotNo));
+
-	buff += sizeof(logEntry->slotNo);
+	sysMonitorInst->linkLogCtrl.rBusy = buffIndex_old;
-	memcpy(buff, &(logEntry->frameType), sizeof(logEntry->frameType));
-	buff += sizeof(logEntry->frameType);
-	memcpy(buff, &(logEntry->payload), sizeof(logEntry->payload));
-	buff += sizeof(logEntry->payload);
-	memcpy(buff, &(logEntry->tmStamp), sizeof(logEntry->tmStamp));
-	buff += sizeof(logEntry->tmStamp);
-	memcpy(buff, &(logEntry->tmDevi), sizeof(logEntry->tmDevi));
-	buff += sizeof(logEntry->tmDevi);
-	memcpy(buff, &(logEntry->freqDevi), sizeof(logEntry->freqDevi));
-	sysMonitorInst->sendLogCtrl.rBusy = buffIndex_old;
 }
 
-// @Receive Slot log
+// @Physical layer log
 /**
- * Log receive slot information
+ * Update physical layer log
  */
-void SysMonitor_UpdateRecvSlotLog(const SLOTLOG *log)
+void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx;
-	buffIndx = GetWritable(sysMonitorInst->recvLogCtrl);
+	buffIndx = GetWritable(sysMonitorInst->phyLogCtrl);
-	sysMonitorInst->recvLogCtrl.wBusy = buffIndx;
+	sysMonitorInst->phyLogCtrl.wBusy = buffIndx;
-	memcpy(&(sysMonitorInst->recvLog[buffIndx]), log, sizeof(SLOTLOG));
+	memcpy(&(sysMonitorInst->phyLog[buffIndx]), log, sizeof(PHYLOG));
-	sysMonitorInst->recvLogCtrl.latest = buffIndx;
+	sysMonitorInst->phyLogCtrl.latest = buffIndx;
-	sysMonitorInst->recvLogCtrl.wBusy = BUFF_NONE;
+	sysMonitorInst->phyLogCtrl.wBusy = BUFF_NONE;
 }
 
 /**
- * Get the latest receive slot information
+ * Get the latest physical layer log
  */
-void SysMonitor_GetRecvSlotLog(SLOTLOG *log)
+void SysMonitor_GetPhysicalLayerLog(PHYLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->recvLogCtrl.rBusy;
+	buffIndex_old = sysMonitorInst->phyLogCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
 		buffIndx = buffIndex_old; // Keep it busy
 	else
-		buffIndx = GetReadable(sysMonitorInst->recvLogCtrl);
+		buffIndx = GetReadable(sysMonitorInst->phyLogCtrl);
-	sysMonitorInst->recvLogCtrl.rBusy = buffIndx;
+	sysMonitorInst->phyLogCtrl.rBusy = buffIndx;
-	memcpy(log, &(sysMonitorInst->recvLog[buffIndx]), sizeof(SLOTLOG));
+	memcpy(log, &(sysMonitorInst->phyLog[buffIndx]), sizeof(PHYLOG));
-	sysMonitorInst->recvLogCtrl.rBusy = buffIndex_old;
+	sysMonitorInst->phyLogCtrl.rBusy = buffIndex_old;
 }
 
 /**
- * Get the latest receive slot information as raw data
+ * Get the latest physical layer log as raw data
  */
-void SysMonitor_GetRecvSlotLogRaw(uint8_t *buff)
+void SysMonitor_GetPhysicalLayerLogRaw(uint8_t *buff)
 {
 	ASSERT(sysMonitorInst != NULL);
 	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->recvLogCtrl.rBusy;
+	buffIndex_old = sysMonitorInst->phyLogCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
 		buffIndx = buffIndex_old; // Keep it busy
 	else
-		buffIndx = GetReadable(sysMonitorInst->recvLogCtrl);
+		buffIndx = GetReadable(sysMonitorInst->phyLogCtrl);
-	sysMonitorInst->recvLogCtrl.rBusy = buffIndx;
+	sysMonitorInst->phyLogCtrl.rBusy = buffIndx;
 
 	// Encapsulate log
-	SLOTLOG *logEntry = &(sysMonitorInst->recvLog[buffIndx]);
+	PHYLOG *logEntry = &(sysMonitorInst->phyLog[buffIndx]);
-	memcpy(buff, &(logEntry->tuNo), sizeof(logEntry->tuNo));
-	buff += sizeof(logEntry->tuNo);
-	memcpy(buff, &(logEntry->slotNo), sizeof(logEntry->slotNo));
-	buff += sizeof(logEntry->slotNo);
-	memcpy(buff, &(logEntry->frameType), sizeof(logEntry->frameType));
-	buff += sizeof(logEntry->frameType);
-	memcpy(buff, &(logEntry->payload), sizeof(logEntry->payload));
-	buff += sizeof(logEntry->payload);
-	memcpy(buff, &(logEntry->tmStamp), sizeof(logEntry->tmStamp));
-	buff += sizeof(logEntry->tmStamp);
-	memcpy(buff, &(logEntry->tmDevi), sizeof(logEntry->tmDevi));
-	buff += sizeof(logEntry->tmDevi);
-	memcpy(buff, &(logEntry->freqDevi), sizeof(logEntry->freqDevi));
-	sysMonitorInst->recvLogCtrl.rBusy = buffIndex_old;
-}
 
-// @Protocol log
+	// TODO:
-/**
- * Log protocol running status.
- */
-void SysMonitor_UpdateProtocolLog(const PRTCLLOG *log)
-{
-	ASSERT(sysMonitorInst != NULL);
-	uint8_t buffIndx;
-	buffIndx = GetWritable(sysMonitorInst->protocolLogCtrl);
-	sysMonitorInst->protocolLogCtrl.wBusy = buffIndx;
-	memcpy(&(sysMonitorInst->protocolLog[buffIndx]), log, sizeof(PRTCLLOG));
-	sysMonitorInst->protocolLogCtrl.latest = buffIndx;
-	sysMonitorInst->protocolLogCtrl.wBusy = BUFF_NONE;
-}
 
-/**
+	sysMonitorInst->phyLogCtrl.rBusy = buffIndex_old;
- * Get the protocol running log.
- */
-void SysMonitor_GetProtocolLog(PRTCLLOG *log)
-{
-	ASSERT(sysMonitorInst != NULL);
-	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->protocolLogCtrl.rBusy;
-	if (buffIndex_old != BUFF_NONE)
-		buffIndx = buffIndex_old; // Keep it busy
-	else
-		buffIndx = GetReadable(sysMonitorInst->protocolLogCtrl);
-	sysMonitorInst->protocolLogCtrl.rBusy = buffIndx;
-	memcpy(log, &(sysMonitorInst->protocolLog[buffIndx]), sizeof(PRTCLLOG));
-	sysMonitorInst->protocolLogCtrl.rBusy = buffIndex_old;
-}
-
-/**
- * Get the protocol running log as raw data.
- */
-void SysMonitor_GetProtocolLogRaw(uint8_t *buff)
-{
-	ASSERT(sysMonitorInst != NULL);
-	uint8_t buffIndx, buffIndex_old;
-	buffIndex_old = sysMonitorInst->protocolLogCtrl.rBusy;
-	if (buffIndex_old != BUFF_NONE)
-		buffIndx = buffIndex_old; // Keep it busy
-	else
-		buffIndx = GetReadable(sysMonitorInst->protocolLogCtrl);
-	sysMonitorInst->protocolLogCtrl.rBusy = buffIndx;
-
-	// Encapsulate log
-	PRTCLLOG *logEntry = &(sysMonitorInst->protocolLog[buffIndx]);
-	memcpy(buff, &(logEntry->tmSys), sizeof(logEntry->tmSys));
-	buff += sizeof(logEntry->tmSys);
-	memcpy(buff, &(logEntry->phySt), sizeof(logEntry->phySt));
-	buff += sizeof(logEntry->phySt);
-	memcpy(buff, &(logEntry->tmLocal), sizeof(logEntry->tmLocal));
-	buff += sizeof(logEntry->tmLocal);
-	memcpy(buff, &(logEntry->beamNo), sizeof(logEntry->beamNo));
-	buff += sizeof(logEntry->beamNo);
-	memcpy(buff, &(logEntry->beamWidth), sizeof(logEntry->beamWidth));
-	buff += sizeof(logEntry->beamWidth);
-	memcpy(buff, &(logEntry->stage), sizeof(logEntry->stage));
-	buff += sizeof(logEntry->stage);
-	memcpy(buff, &(logEntry->recvCnt), sizeof(logEntry->recvCnt));
-	buff += sizeof(logEntry->recvCnt);
-	sysMonitorInst->protocolLogCtrl.rBusy = buffIndex_old;
 }
 
 // @Hardware state
@@ -503,6 +428,51 @@ void SysMonitor_GetHardwareStatus(HWSTATE *state)
 	sysMonitorInst->hwStateCtrl.rBusy = buffIndex_old;
 }
 
+/**
+ * Get the latest hardware running status as raw data.
+ */
+void SysMonitor_GetHardwareStatusRaw(uint8_t *buff)
+{
+	ASSERT(sysMonitorInst != NULL);
+	uint8_t buffIndx, buffIndex_old;
+	buffIndex_old = sysMonitorInst->hwStateCtrl.rBusy;
+	if (buffIndex_old != BUFF_NONE)
+		buffIndx = buffIndex_old; // Keep it busy
+	else
+		buffIndx = GetReadable(sysMonitorInst->hwStateCtrl);
+	sysMonitorInst->hwStateCtrl.rBusy = buffIndx;
+
+	// Encapsulate log
+	HWSTATE *logEntry = &(sysMonitorInst->hwState[buffIndx]);
+
+	memcpy(buff, &(logEntry->spPsVolt), sizeof(logEntry->spPsVolt));
+	buff += sizeof(logEntry->spPsVolt);
+	memcpy(buff, &(logEntry->spPsAuxVolt), sizeof(logEntry->spPsAuxVolt));
+	buff += sizeof(logEntry->spPsAuxVolt);
+	memcpy(buff, &(logEntry->spDdrVolt), sizeof(logEntry->spDdrVolt));
+	buff += sizeof(logEntry->spDdrVolt);
+	memcpy(buff, &(logEntry->spPlVolt), sizeof(logEntry->spPlVolt));
+	buff += sizeof(logEntry->spPlVolt);
+	memcpy(buff, &(logEntry->spPlAuxVolt), sizeof(logEntry->spPlAuxVolt));
+	buff += sizeof(logEntry->spPlAuxVolt);
+	memcpy(buff, &(logEntry->spBramVolt), sizeof(logEntry->spBramVolt));
+	buff += sizeof(logEntry->spBramVolt);
+	memcpy(buff, &(logEntry->spTemp), sizeof(logEntry->spTemp));
+	buff += sizeof(logEntry->spTemp);
+	memcpy(buff, &(logEntry->antVolt), sizeof(logEntry->antVolt));
+	buff += sizeof(logEntry->antVolt);
+	memcpy(buff, &(logEntry->antTemp), sizeof(logEntry->antTemp));
+	buff += sizeof(logEntry->antTemp);
+	memcpy(buff, &(logEntry->antPll), sizeof(logEntry->antPll));
+	buff += sizeof(logEntry->antPll);
+	memcpy(buff, &(logEntry->antMgc0), sizeof(logEntry->antMgc0));
+	buff += sizeof(logEntry->antMgc0);
+	memcpy(buff, &(logEntry->antMgc1), sizeof(logEntry->antMgc1));
+	buff += sizeof(logEntry->antMgc1);
+
+	sysMonitorInst->hwStateCtrl.rBusy = buffIndex_old;
+}
+
 // @System log
 /**
  * Get the latest system running log.
@@ -510,9 +480,8 @@ void SysMonitor_GetHardwareStatus(HWSTATE *state)
 void SysMonitor_GetSyslog(SYSLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
-	SysMonitor_GetSendSlotLog(&(log->sendLog));
+	SysMonitor_GetLinklayerLog(&(log->linkLog));
-	SysMonitor_GetRecvSlotLog(&(log->recvLog));
+	SysMonitor_GetPhysicalLayerLog(&(log->phyLog));
-	SysMonitor_GetProtocolLog(&(log->protocolLog));
 	SysMonitor_GetHardwareStatus(&(log->hwSate));
 }
 
@@ -522,9 +491,9 @@ void SysMonitor_GetSyslog(SYSLOG *log)
 void SysMonitor_GetSyslogRaw(uint8_t *buff)
 {
 	ASSERT(sysMonitorInst != NULL);
-	SysMonitor_GetSendSlotLogRaw(buff);
+	SysMonitor_GetLinklayerLogRaw(buff);
 	buff += SLOTLOG_PACK_LEN;
-	SysMonitor_GetRecvSlotLogRaw(buff);
+	SysMonitor_GetPhysicalLayerLogRaw(buff);
 	buff += SLOTLOG_PACK_LEN;
-	SysMonitor_GetProtocolLogRaw(buff);
+	SysMonitor_GetHardwareStatusRaw(buff);
 }

df_datalink_sp/src/system_monitor.h

@@ -20,13 +20,6 @@
 #define TEMPERATURE_MAX 127.0 // Celsius degree
 #define TEMPERATURE_MIN -128.0 // Celsius degree
 
-
-typedef struct
-{
-	// FIXME: To Complete
-	uint8_t dummy;
-} SYSCONFIG;
-
 typedef struct
 {
 	// -- unit: ms, 0~604799999
@@ -75,33 +68,47 @@ typedef struct
 typedef struct
 {
 	// Network log
-	uint32_t tuNo;
+	uint32_t tuNum;
-	uint8_t slotNo;
+	uint8_t slotNum;
-	uint8_t frameType;
+	uint8_t nodeType;
-	// Payload
+	uint8_t cxnStatus;
-	uint8_t payload[PAYLOAD_LEN_MAX];
+	uint8_t linkStage;
-	// Time sync info
+	uint32_t recxnCnt;
-	uint64_t tmStamp;
+	uint8_t beamNo;
-	uint32_t tmDevi;
+	uint16_t beamAz;
-	uint32_t freqDevi;
+	uint16_t beamEl;
-} SLOTLOG;
+	uint16_t advTxCnt;
+	uint16_t advRecvCnt;
+	uint16_t advCorrectCnt;
+	uint32_t cfmTxCnt;
+	uint32_t cfmRecvCnt;
+	uint32_t cfmCorrectCnt;
+	uint32_t svcTxCnt;
+	uint32_t svcRecvCnt;
+	uint32_t svcCorrectCnt;
+	int64_t	timeDev;
+	uint32_t sendId;
+	uint32_t recvId;
+} LINKLOG;
 
 typedef struct
 {
-	// Protocol log
+	uint32_t acqCnt;
-	// -- System time
+	uint32_t fsyncCnt;
-	uint32_t tmSys;
+	uint32_t decodeCnt;
-	// -- Physical layer status
+	uint32_t crcCnt;
-	uint8_t phySt;
+	double doppler;
-	// -- Link layer status
+	uint64_t recvStamp;
-	uint64_t tmLocal;
+	uint64_t acqPeak;
-	uint16_t beamNo;
+	uint64_t acqMean;
-	uint8_t beamWidth;
+	uint8_t acqPhase;
-	// -- Network layer status
+	uint8_t acqFreqCh;
-	uint8_t stage;
+	uint8_t fsyncPeak;
-	uint32_t recvCnt;
+	uint8_t fsyncMean;
-	uint32_t recvCorrect;
+	uint8_t fsyncFreqCh;
-} PRTCLLOG;
+	uint16_t deintlvAmpEst;
+	uint16_t reserve;
+} PHYLOG;
 
 typedef struct
 {
@@ -126,14 +133,11 @@ typedef struct
 
 typedef struct
 {
-	// Send slot log
+	// Link layer log
-	SLOTLOG sendLog;
+	LINKLOG linkLog;
 
-	// Receive slot log
+	// Physical layer log
-	SLOTLOG recvLog;
+	PHYLOG phyLog;
-
-	// Protocol log
-	PRTCLLOG protocolLog;
 
 	// Hardware status
 	HWSTATE hwSate;
@@ -152,18 +156,15 @@ void SysMonitor_UpdateRecvPayloadRaw(const uint8_t *buff, size_t len);
 void SysMonitor_GetSendPayloadRaw(uint8_t *buff, uint32_t *id, size_t len);
 void SysMonitor_GetRecvPayloadRaw(uint8_t *buff, uint32_t *id, size_t len);
 
-void SysMonitor_UpdateSendSlotLog(const SLOTLOG *log);
+void SysMonitor_UpdateLinklayerLog(const LINKLOG *log);
-void SysMonitor_UpdateRecvSlotLog(const SLOTLOG *log);
+void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log);
-void SysMonitor_UpdateProtocolLog(const PRTCLLOG *log);
-void SysMonitor_GetSendSlotLog(SLOTLOG *log);
-void SysMonitor_GetRecvSlotLog(SLOTLOG *log);
-void SysMonitor_GetProtocolLog(PRTCLLOG *log);
-void SysMonitor_GetSendSlotLogRaw(uint8_t *buff);
-void SysMonitor_GetRecvSlotLogRaw(uint8_t *buff);
-void SysMonitor_GetProtocolLogRaw(uint8_t *buff);
-
 void SysMonitor_UpdateHardwareStatus(const HWSTATE *state);
+void SysMonitor_GetLinklayerLog(LINKLOG *log);
+void SysMonitor_GetPhysicalLayerLog(PHYLOG *log);
 void SysMonitor_GetHardwareStatus(HWSTATE *state);
+void SysMonitor_GetLinklayerLogRaw(uint8_t *buff);
+void SysMonitor_GetPhysicalLayerLogRaw(uint8_t *buff);
+void SysMonitor_GetHardwareStatusRaw(uint8_t *buff);
 
 void SysMonitor_GetSyslog(SYSLOG *log);
 void SysMonitor_GetSyslogRaw(uint8_t *buff);