diff --git a/datalink814_ge/src/linklayer/net_mgmt.c b/datalink814_ge/src/linklayer/net_mgmt.c
index 7a6eb13..96ca4f7 100644
--- a/datalink814_ge/src/linklayer/net_mgmt.c
+++ b/datalink814_ge/src/linklayer/net_mgmt.c
@@ -64,17 +64,25 @@ static int32_t MgmtPkt_Packing(L2_INST* instPtr, MGMTPKT_TYPE pktType);
 static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE msgType) {
 	ASSERT(instPtr != NULL);
 	ASSERT(bitarr != NULL);
-	if (bitarr->num_of_bits < MGMT_MSG_LEN || msgType < L2_MSG_TK_INIT
-			|| msgType > L2_MSG_BCU_INIT) {
+	uint64_t dataChunk;
+	L2_RTT_FSM* rttFsmPtr = L2_GetRttFsm(instPtr);
+	if (msgType < L2_MSG_TK_INIT || msgType > L2_MSG_BCU_INIT) {
 		return EPARAM;
 	}
-	uint64_t dataChunk = 0;
-	memset(bitarr->words, 0x99, (size_t) (MGMT_MSG_LEN / 8));
-	switch (msgType) {
-	case L2_MSG_TK_INIT:
+	if(msgType >= L2_MSG_TK_INIT && msgType <= L2_MSG_MADJ_EXTD) {
 		if (bitarr->num_of_bits < MGMT_MSG_LEN) {
 			return EPARAM;
 		}
+	}
+	if(msgType >= L2_MSG_RTT_REQ_INIT && msgType <= L2_MSG_RTT_RSP_CONT) {
+		if (bitarr->num_of_bits < RTT_MSG_LEN) {
+			return EPARAM;
+		}
+	}
+	
+	memset(bitarr->words, 0x99, (size_t) (MGMT_MSG_LEN / 8));
+	switch (msgType) {
+	case L2_MSG_TK_INIT:
 		// Series tag
 		dataChunk = 0;
 		FrameInsertChunk(bitarr, TK_MSG_INI_SER_TAG_OFFSET, TK_MSG_INI_SER_TAG_LEN, dataChunk);
@@ -96,7 +104,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		FrameInsertChunk(bitarr, TK_MSG_INI_OFFSET, TK_MSG_INI_LEN, dataChunk);
 
 		// Next net stage
-		if (instPtr->myInfo.nodeType == HEAD_NODE) {
+		if (L2_GetNodeType(instPtr) == HEAD_NODE) {
 			switch (instPtr->nextState) {
 			case INIT_STATE:
 				dataChunk = NET_INI_STAGE;
@@ -120,10 +128,8 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 			FrameInsertChunk(bitarr, TK_MSG_INI_NET_STATE_OFFSET, TK_MSG_INI_NET_STATE_LEN, dataChunk);
 		}
 		break;
+
 	case L2_MSG_TK_EXTD:
-		if (bitarr->num_of_bits < MGMT_MSG_LEN) {
-			return EPARAM;
-		}
 		// Word tag
 		dataChunk = 1;
 		FrameInsertChunk(bitarr, TK_MSG_EXTEND_WTAG_OFFSET, TK_MSG_EXTEND_WTAG_LEN, dataChunk);
@@ -136,6 +142,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		dataChunk = 0xBBBB;
 		FrameInsertChunk(bitarr, TK_MSG_EXTEND_EAST_SPEED_OFFSET, TK_MSG_EXTEND_EAST_SPEED_LEN, dataChunk);
 		break;
+
 	case L2_MSG_TK_CONT_1:
 		// Word tag
 		dataChunk = 2;
@@ -176,6 +183,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		dataChunk = 0xBBBBBBBB;
 		FrameInsertChunk(bitarr, TK_MSG_CONT_2_LATITUDE_OFFSET, TK_MSG_CONT_2_LATITUDE_LEN, dataChunk);
 		break;
+
 	case L2_MSG_TK_CONT_3:
 
 		// Word tag
@@ -187,8 +195,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		FrameInsertChunk(bitarr, TK_MSG_CONT_3_CONTID_OFFSET, TK_MSG_CONT_3_CONTID_LEN, dataChunk);
 
 		// source node id
-		dataChunk = (instPtr->myInfo.nodeId & 0x1F)
-				| (((uint16_t) (instPtr->myInfo.clustId & 0x1F)) << 5);
+		dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
 		FrameInsertChunk(bitarr, TK_MSG_CONT_3_MEMBER_ADDR_OFFSET, TK_MSG_CONT_3_MEMBER_ADDR_LEN, dataChunk);
 
 		// East speed
@@ -202,7 +209,6 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		// Upper speed
 		dataChunk = 0xDDDD;
 		FrameInsertChunk(bitarr, TK_MSG_CONT_3_UPPER_ACC_OFFSET, TK_MSG_CONT_3_UPPER_ACC_LEN, dataChunk);
-
 		break;
 
 	case L2_MSG_TA_INIT:
@@ -220,15 +226,14 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		FrameInsertChunk(bitarr, TA_MSG_MSG_STAG_OFFSET, TA_MSG_MSG_STAG_LEN, dataChunk);
 
 		// Source node id
-		dataChunk = (instPtr->myInfo.nodeId & 0x1F)
-				| (((uint16_t) (instPtr->myInfo.clustId & 0x1F)) << 5);
+		dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t) (L2_GetClusterId(instPtr) & 0x1F)) << 5);
 		FrameInsertChunk(bitarr, TA_MSG_SRC_ADDR_OFFSET, TA_MSG_SRC_ADDR_LEN, dataChunk);
 
 		// Height
 		dataChunk = 0xEEEEEE;
 		FrameInsertChunk(bitarr, TA_MSG_HEIGHT_OFFSET, TA_MSG_HEIGHT_LEN, dataChunk);
-
 		break;
+
 	case L2_MSG_TA_EXTD:
 
 		// Longitude
@@ -260,12 +265,14 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		// Upper speed
 		dataChunk = 0xDDDD;
 		FrameInsertChunk(bitarr, TA_MSG_CONT_2_UPPER_OFFSET, TA_MSG_CONT_2_UPPER_LEN, dataChunk);
-
 		break;
+
 	case L2_MSG_MADJ_INIT:
 		break;
+
 	case L2_MSG_MADJ_EXTD:
 		break;
+
 	case L2_MSG_RTT_REQ_INIT:
 		// Series tag
 		dataChunk = 0;
@@ -280,20 +287,19 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		FrameInsertChunk(bitarr, RTT_REQ_MSG_TAG_OFFSET, RTT_REQ_MSG_TAG_LEN, dataChunk);
 
 		// message identification.
-		dataChunk = 1;
+		dataChunk = 1; // request
 		FrameInsertChunk(bitarr, RTT_REQ_MSG_STAG_OFFSET, RTT_REQ_MSG_STAG_LEN, dataChunk);
 
 		// message length.
-		dataChunk = 2;		//request
+		dataChunk = 2;
 		FrameInsertChunk(bitarr, RTT_REQ_MSG_OFFSET, RTT_REQ_MSG_LEN, dataChunk);
 
 		// source node address length.
-		dataChunk = (instPtr->myInfo.nodeId & 0x1F)
-				| (((uint16_t) (instPtr->myInfo.clustId & 0x1F)) << 5);
+		dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
 		FrameInsertChunk(bitarr, RTT_REQ_SRC_ADDR_OFFSET, RTT_REQ_SRC_ADDR_LEN, dataChunk);
 
 		// destination node address length.
-		dataChunk = (0x02) | (((uint16_t) (instPtr->myInfo.clustId & 0x1F)) << 5);
+		dataChunk = (0x02) | (((uint16_t) (L2_GetClusterId(instPtr) & 0x1F)) << 5);
 		FrameInsertChunk(bitarr, RTT_REQ_DST_ADDR_OFFSET, RTT_REQ_DST_ADDR_LEN, dataChunk);
 		break;
 
@@ -303,20 +309,20 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		FrameInsertChunk(bitarr, RTT_REQ_EX_WTAG_OFFSET, RTT_REQ_EX_WTAG_LEN, dataChunk);
 
 		// Time tag Low.
-		dataChunk = instPtr->mgmtNetFSM->rttData.rttTime.timeL;
+		dataChunk = rttFsmPtr->timeStamp.frac_part;
 		FrameInsertChunk(bitarr, RTT_REQ_EX_TTAGL_OFFSET, RTT_REQ_EX_TTAGL_LEN, dataChunk);
 
 		// Time tag High.
-		dataChunk = instPtr->mgmtNetFSM->rttData.rttTime.timeH;
+		dataChunk = rttFsmPtr->timeStamp.int_part;
 		FrameInsertChunk(bitarr, RTT_REQ_EX_TTAGH_OFFSET, RTT_REQ_EX_TTAGH_LEN, dataChunk);
 		break;
+
 	case L2_MSG_RTT_REQ_CONT:
 		// Doppler
-		dataChunk = instPtr->mgmtNetFSM->rttData.rttDoppler;
+		dataChunk = rttFsmPtr->doppler;
 		FrameInsertChunk(bitarr, RTT_REQ_CONT_DOP_OFFSET, RTT_REQ_CONT_DOP_LEN, dataChunk);
-
-		////////////////////////////////////////////////////////////////////////////////////////////
 		break;
+
 	case L2_MSG_RTT_RSP_INIT:
 		// Series tag
 		dataChunk = 0;
@@ -332,7 +338,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		RTT_RSP_MSG_TAG_LEN, dataChunk);
 
 		// message identification.
-		dataChunk = 2;		// response
+		dataChunk = 2; // response
 		FrameInsertChunk(bitarr, RTT_RSP_MSG_STAG_OFFSET, RTT_RSP_MSG_STAG_LEN, dataChunk);
 
 		// message length.
@@ -340,83 +346,84 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
 		FrameInsertChunk(bitarr, RTT_RSP_MSG_OFFSET, RTT_RSP_MSG_LEN, dataChunk);
 
 		// source node address length.
-		dataChunk = (instPtr->myInfo.nodeId & 0x1F)
-				| (((uint16_t) (instPtr->myInfo.clustId & 0x1F)) << 5);
+		dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
 		FrameInsertChunk(bitarr, RTT_RSP_SRC_ADDR_OFFSET, RTT_RSP_SRC_ADDR_LEN, dataChunk);
 
 		// destination node address length.
-		dataChunk = (0x01) | (((uint16_t) (instPtr->myInfo.clustId & 0x1F)) << 5);
+		dataChunk = (0x01) | (((uint16_t) (L2_GetClusterId(instPtr) & 0x1F)) << 5);
 		FrameInsertChunk(bitarr, RTT_RSP_DST_ADDR_OFFSET, RTT_RSP_DST_ADDR_LEN, dataChunk);
 		break;
-	case L2_MSG_RTT_RSP_EXTD:
 
+	case L2_MSG_RTT_RSP_EXTD:
 		// Word tag
 		dataChunk = 1;
 		FrameInsertChunk(bitarr, RTT_RSP_EX_WTAG_OFFSET, RTT_RSP_EX_WTAG_LEN, dataChunk);
 
 		// Time tag Low.
-		dataChunk = instPtr->mgmtNetFSM->rttData.rttTime.timeL;
+		dataChunk = rttFsmPtr->timeStamp.frac_part;
 		FrameInsertChunk(bitarr, RTT_RSP_EX_TTAGL_OFFSET, RTT_RSP_EX_TTAGL_LEN, dataChunk);
 
 		// Time tag High.
-		dataChunk = instPtr->mgmtNetFSM->rttData.rttTime.timeH;
+		dataChunk = rttFsmPtr->timeStamp.int_part;
 		FrameInsertChunk(bitarr, RTT_RSP_EX_TTAGH_OFFSET, RTT_RSP_EX_TTAGH_LEN, dataChunk);
 		break;
+
 	case L2_MSG_RTT_RSP_CONT:
 		// Doppler
-		dataChunk = instPtr->mgmtNetFSM->rttData.rttDoppler;
+		dataChunk = rttFsmPtr->doppler;
 		FrameInsertChunk(bitarr, RTT_RSP_CONT_DOP_OFFSET, RTT_RSP_CONT_DOP_LEN, dataChunk);
 		break;
+
 	case L2_MSG_NQT_INIT:
-//		if (priorInfo.myType == MEMBER_NODE && ( L2_GetCurrentFrameNo() == ( myInfo->netScanTime + TIME2QUIT ) )) {
-//			// word tag
-//			dataChunk = 3;
-//			FrameInsertChunk(bitarr, NQT_MSG_WTAG_OFFSET,
-//			NQT_MSG_WTAG_LEN, dataChunk);
-//
-//			// msg tag
-//			dataChunk = 30;
-//			FrameInsertChunk(bitarr, NQT_MSG_MSG_TAG_OFFSET,
-//			NQT_MSG_MSG_TAG_LEN, dataChunk);
-//
-//			// msg sub tag
-//			dataChunk = 1;
-//			FrameInsertChunk(bitarr, NQT_MSG_MSG_STAG_OFFSET,
-//			NQT_MSG_MSG_STAG_LEN, dataChunk);
-//
-//			// msg length
-//			dataChunk = 0;
-//			FrameInsertChunk(bitarr, NQT_MSG_MSG_OFFSET,
-//			NQT_MSG_MSG_LEN, dataChunk);
-//
-//			// Ctrol Word
-//			dataChunk = 1;
-//			FrameInsertChunk(bitarr, NQT_MSG_CTRL_MUTE_OFFSET,
-//			NQT_MSG_CTRL_MUTE_LEN, dataChunk);
-//
-//			// Quit object
-//			dataChunk = (priorInfo.myId & 0x1F)
-//					| (((uint16_t) (priorInfo.clustId & 0x1F)) << 5);
-//			FrameInsertChunk(bitarr, NQT_MSG_OBJ_OFFSET,
-//			NQT_MSG_OBJ_LEN, dataChunk);
-//			L2_NODE_STATE newState = INIT_STATE;
-//			L2_EVENT stateEvent = { 
-//				.event = L2_EV_MAIN_STATE_UPDATE, 
-//				.msg = &newState 
-//			};
-//			AssertL2Event(&stateEvent);
-//			L2_EVENT lostCxnEvent = { 
-//				.event = L2_EV_LOST_CXN, 
-//				.msg = NULL
-//			};
-//			AssertL2Event(&lostCxnEvent);
-//		}
+		// // word tag
+		// dataChunk = 3;
+		// FrameInsertChunk(bitarr, NQT_MSG_WTAG_OFFSET,
+		// NQT_MSG_WTAG_LEN, dataChunk);
+
+		// // msg tag
+		// dataChunk = 30;
+		// FrameInsertChunk(bitarr, NQT_MSG_MSG_TAG_OFFSET,
+		// NQT_MSG_MSG_TAG_LEN, dataChunk);
+
+		// // msg sub tag
+		// dataChunk = 1;
+		// FrameInsertChunk(bitarr, NQT_MSG_MSG_STAG_OFFSET,
+		// NQT_MSG_MSG_STAG_LEN, dataChunk);
+
+		// // msg length
+		// dataChunk = 0;
+		// FrameInsertChunk(bitarr, NQT_MSG_MSG_OFFSET,
+		// NQT_MSG_MSG_LEN, dataChunk);
+
+		// // Ctrol Word
+		// dataChunk = 1;
+		// FrameInsertChunk(bitarr, NQT_MSG_CTRL_MUTE_OFFSET,
+		// NQT_MSG_CTRL_MUTE_LEN, dataChunk);
+
+		// // Quit object
+		// dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
+		// FrameInsertChunk(bitarr, NQT_MSG_OBJ_OFFSET, NQT_MSG_OBJ_LEN, dataChunk);
+		// L2_NODE_STATE newState = INIT_STATE;
+		// L2_EVENT stateEvent = { 
+		// 	.event = L2_EV_MAIN_STATE_UPDATE, 
+		// 	.msg = &newState 
+		// };
+		// AssertL2Event(instPtr, &stateEvent);
+		// L2_EVENT lostCxnEvent = { 
+		// 	.event = L2_EV_LOST_CXN, 
+		// 	.msg = NULL
+		// };
+		// AssertL2Event(instPtr, &lostCxnEvent);
 		break;
+
 	case L2_MSG_CMG_INIT:
 		break;
+
 	case L2_MSG_BCU_INIT:
 		break;
+
 	default:
+		DBG_ERROR("Unsupported message type: %d", msgType);
 		return EPARAM;
 		break;
 	}
@@ -603,7 +610,7 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
 		free(mgmtMsg);
 		return EALLOC;
 	}
-	switch (L2_GetLastRcvFrameType(instPtr)) {
+	switch (L2_GetLastFrameType(instPtr)) {
 	case L2_INTER_MGMT_FRAME:
 	case L2_INTRA_MGMT_FRAME: {
 		for (int i = 0; i < ARRAY_SIZE(intraMgmtFrameMsgs); i++) {
@@ -669,7 +676,7 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
 			case L2_MSG_NQT_INIT:
 				FrameGetChunk(mgmtMsg, NQT_MSG_OBJ_OFFSET, NQT_MSG_OBJ_LEN, &dataChunk);
 				mgmtMsgLog->quitNodeId = (uint8_t) (dataChunk & 0x1F);
-				if (mgmtMsgLog->quitNodeId != instPtr->myInfo.nodeId) {
+				if (mgmtMsgLog->quitNodeId != L2_GetNodeId(instPtr)) {
 					FrameGetChunk(mgmtMsg, NQT_MSG_CTRL_MUTE_OFFSET, NQT_MSG_CTRL_MUTE_LEN, &dataChunk);
 					mgmtMsgLog->quitCtrlWord = (uint8_t)(dataChunk & 0x7F);
 					if (mgmtMsgLog->quitCtrlWord == 0x01) {
@@ -693,7 +700,7 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
 			}
 		}
 		// Member Node update state with received message
-		if(instPtr->myInfo.nodeId != HEAD_NODE && mgmtMsgLog->isValid == true ){
+		if(L2_GetNodeId(instPtr) != HEAD_NODE && mgmtMsgLog->isValid == true ){
 			L2_NODE_STATE newState = NONE_STATE;
 			// FIXME :
 			switch (mgmtMsgLog->nextNetState) {
@@ -723,18 +730,17 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
 			};
 			AssertL2Event(instPtr, &stateUpEvent);
 		}
-		// TODO: Reset of tracking message src
-		RstNodeTTL(instPtr->nodeList, mgmtMsgLog->srcNodeId);
 
-		if(mgmtMsgLog->srcNodeId == instPtr->config.headId){
+		RstNodeTTL(instPtr->nodeList, mgmtMsgLog->srcNodeId);
+		// TODO: Check
+		if(mgmtMsgLog->srcNodeId == L2_GetHeadId(instPtr)){
 			L2_TimeAlign(instPtr, L2_GetCurrentFrameNum(instPtr), L2_GetCurrentSlotNum(instPtr));
 		}
 		break;
 	}
 	case L2_INTER_TSYNC_FRAME:
 	case L2_INTRA_TSYNC_FRAME: {
-		L2_RTT_FSM* rttFsmPtr = L2_GetRttDesc(instPtr);
-		L2_RTT_SATGE rttStage = RTT_GetCurrentStage(rttFsmPtr);
+		L2_RTT_SATGE rttStage = L2_GetRttFsm(instPtr)->rttStatge;
 		if(rttStage == RTT_REQ1 || rttStage == RTT_REQ2){
 			for (int i = 0; i < ARRAY_SIZE(rttReqFrameMsgs); i++) {
 				memcpy(mgmtMsg->words,
@@ -840,15 +846,16 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
 				}
 			}
 		}
-		// TODO: Reset of tracking message src
+
 		RstNodeTTL(instPtr->nodeList, rttMsgRspLog->srcAddr & 0x001F);
-		if((rttMsgRspLog->srcAddr&0x001F) == instPtr->config.headId){
+		// TODO: Check
+		if((rttMsgRspLog->srcAddr&0x001F) == L2_GetHeadId(instPtr)){
 			L2_TimeAlign(instPtr, L2_GetCurrentFrameNum(instPtr), L2_GetCurrentSlotNum(instPtr));
 		}
 		break;
 	}
 	default:
-		DBG_ERROR("Cannot handle frame type [%d] properly.\n", L2_GetLastRcvFrameType(instPtr));
+		DBG_ERROR("Cannot handle frame type [%d] properly.\n", L2_GetLastFrameType(instPtr));
 		Status = EPARAM;
 		goto failed;
 	}
@@ -884,8 +891,6 @@ static bool IsTTLValid(NODE_ENTRY* entry) {
 int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
 	ASSERT(instPtr != NULL);
 	int32_t Status;
-	RTT_DATA *rttData = &(instPtr->mgmtNetFSM->rttData);
-	RTT_RECORD *rttRecord = &(L2_GetRttDesc(instPtr)->rttRecord);
 	DBG_INFO("-------- MgmtNet Routine --------\n");
 
 	if(rtneEntry->slotSeq != 0){
@@ -897,12 +902,12 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
 
 	// Determine next slot TOR state.
 	L2_TOR_TYPE torState = L2_TOR_SUSPEND;
-	if ((rtneEntry->src0 == instPtr->myInfo.nodeId)
-			|| (rtneEntry->src1 == instPtr->myInfo.nodeId)) {
+	if ((rtneEntry->src0 == L2_GetNodeId(instPtr))
+			|| (rtneEntry->src1 == L2_GetNodeId(instPtr))) {
 		torState = L2_TOR_TX;
 	}
-	else if ((rtneEntry->dst0 == instPtr->myInfo.nodeId)
-			|| (rtneEntry->dst1 == instPtr->myInfo.nodeId)) {
+	else if ((rtneEntry->dst0 == L2_GetNodeId(instPtr))
+			|| (rtneEntry->dst1 == L2_GetNodeId(instPtr))) {
 		torState = L2_TOR_RX;
 	}
 	else {
@@ -962,7 +967,7 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
 
 	/*************************************************/
 	// Update link layer state...
-	if (instPtr->myInfo.nodeType == HEAD_NODE) {
+	if (L2_GetNodeType(instPtr) == HEAD_NODE) {
 		L2_NODE_STATE newState = NONE_STATE;
 		L2_EVENT stateEvent = {
 			.event = L2_EV_MAIN_STATE_UPDATE,
@@ -980,7 +985,7 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
 		}
 	}
 	else{ // MEMBER_NODE or BACKUP_HEAD
-		if(IsNodeInList(instPtr->nodeList, instPtr->config.headId) == false){
+		if(IsNodeInList(instPtr->nodeList, L2_GetHeadId(instPtr)) == false){
 			L2_NODE_STATE newState = INIT_STATE;
 			L2_EVENT stateEvent = {
 				.event = L2_EV_MAIN_STATE_UPDATE,
@@ -992,7 +997,7 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
 				.msg = NULL
 			};
 			AssertL2Event(instPtr, &lostCxnEvent);
-			DBG_WARNING("Lost connection with head node [%d].\n", instPtr->config.headId);
+			DBG_WARNING("Lost connection with head node [%d].\n", L2_GetHeadId(instPtr));
 		}
 	}
 	return SUCCESS;
diff --git a/datalink814_ge/src/linklayer/net_service.c b/datalink814_ge/src/linklayer/net_service.c
index fa99736..5fe0f7a 100644
--- a/datalink814_ge/src/linklayer/net_service.c
+++ b/datalink814_ge/src/linklayer/net_service.c
@@ -76,10 +76,10 @@ static int UduHeader_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, uint8_t dst, u
 	dataChunk = dataLen;
 	FrameInsertChunk(bitarr, UDUH_LENGTH_OFFSET, UDUH_LENGTH_LEN, dataChunk);
 	// source node id
-	dataChunk = (instPtr->myInfo.nodeId & 0x1F)|((instPtr->myInfo.clustId & 0x1F) << 5);
+	dataChunk = (L2_GetNodeId(instPtr) & 0x1F)|((L2_GetClusterId(instPtr) & 0x1F) << 5);
 	FrameInsertChunk(bitarr, UDUH_SRC_ADDR_OFFSET, UDUH_SRC_ADDR_LEN, dataChunk);
 	// destination node id
-	dataChunk = (dst & 0x1F)|((instPtr->myInfo.clustId & 0x1F) << 5);
+	dataChunk = (dst & 0x1F)|((L2_GetClusterId(instPtr) & 0x1F) << 5);
 	FrameInsertChunk(bitarr, UDUH_DST_ADDR_OFFSET, UDUH_DST_ADDR_LEN, dataChunk);
 	// UDU Sequence number
 	dataChunk = 0;
@@ -126,10 +126,10 @@ static int PduHeader_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_PDU_HEADER_
 		dataChunk = INTRA_SVC_FRAME_LENGTH_MAX;
 		FrameInsertChunk(bitarr, PDUH0_LENGTH_OFFSET, PDUH0_LENGTH_LEN, dataChunk);
 		// source node id
-		dataChunk = (instPtr->myInfo.nodeId & 0x1F)|((instPtr->myInfo.clustId & 0x1F) << 5);
+		dataChunk = (L2_GetNodeId(instPtr) & 0x1F)|((L2_GetClusterId(instPtr) & 0x1F) << 5);
 		FrameInsertChunk(bitarr, PDUH0_SRC_ADDR_OFFSET, PDUH0_SRC_ADDR_LEN, dataChunk);
 		// destination node id
-		dataChunk = (dst & 0x1F)|((instPtr->myInfo.clustId & 0x1F) << 5);
+		dataChunk = (dst & 0x1F)|((L2_GetClusterId(instPtr) & 0x1F) << 5);
 		FrameInsertChunk(bitarr, PDUH0_DST_ADDR_OFFSET, PDUH0_DST_ADDR_LEN, dataChunk);
 		// Sequence number
 		dataChunk = 0;
@@ -149,10 +149,10 @@ static int PduHeader_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_PDU_HEADER_
 		dataChunk = INTRA_SVC_FRAME_LENGTH_MAX;
 		FrameInsertChunk(bitarr, PDUH1_LENGTH_OFFSET, PDUH1_LENGTH_LEN, dataChunk);
 		// source node id
-		dataChunk = (instPtr->myInfo.nodeId & 0x1F)|((instPtr->myInfo.clustId & 0x1F) << 5);
+		dataChunk = (L2_GetNodeId(instPtr) & 0x1F)|((L2_GetClusterId(instPtr) & 0x1F) << 5);
 		FrameInsertChunk(bitarr, PDUH1_SRC_ADDR_OFFSET, PDUH1_SRC_ADDR_LEN, dataChunk);
 		// destination node id
-		dataChunk = (dst & 0x1F)|((instPtr->myInfo.clustId & 0x1F) << 5);
+		dataChunk = (dst & 0x1F)|((L2_GetClusterId(instPtr) & 0x1F) << 5);
 		FrameInsertChunk(bitarr, PDUH1_DST_ADDR_OFFSET, PDUH1_DST_ADDR_LEN, dataChunk);
 		// Slice tage...
 		// Append CRC
@@ -229,10 +229,10 @@ int32_t ServiceNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntr
 	}
 
 	// Determine TOR State.
-	if(rtneEntry->src0 == instPtr->myInfo.nodeId){
+	if(rtneEntry->src0 == L2_GetNodeId(instPtr)){
 		torState = L2_TOR_TX;
 	}
-	else if(rtneEntry->dst0 == instPtr->myInfo.nodeId){
+	else if(rtneEntry->dst0 == L2_GetNodeId(instPtr)){
 		torState = L2_TOR_RX;
 	}
 	else{
diff --git a/datalink814_ge/src/mpc/mpc_ctrl.c b/datalink814_ge/src/mpc/mpc_ctrl.c
index 20967bd..7992849 100644
--- a/datalink814_ge/src/mpc/mpc_ctrl.c
+++ b/datalink814_ge/src/mpc/mpc_ctrl.c
@@ -431,7 +431,7 @@ int MPC_StateUpload(MPC_INST* instPtr ,  uint8_t* mgmtBuffer , uint32_t mgmtMsgC
 
 	// TODO : Currently DJ is node 1 , only Byte 1 is activate , others is useless
 	// Topo node 1
-	dataChunk = BIT(linkInstPtr->myInfo.nodeId - 1);
+	dataChunk = BIT(L2_GetNodeId(linkInstPtr) - 1);
 	if (GetNodeNum(linkInstPtr->nodeList) > 1 ) {
 		for(int i = 1; i <= linkInstPtr->config.netScale; i++){
 			if (IsNodeInList(linkInstPtr->nodeList, i)) {